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>,
1743 pub(crate) enum OutboundTrampolinePayload {
1746 /// The value, in msat, of the payment after this hop's fee is deducted.
1747 amt_to_forward: u64,
1748 outgoing_cltv_value: u32,
1749 /// The node id to which the trampoline node must find a route
1750 outgoing_node_id: PublicKey,
1754 pub struct DecodedOnionErrorPacket {
1755 pub(crate) hmac: [u8; 32],
1756 pub(crate) failuremsg: Vec<u8>,
1757 pub(crate) pad: Vec<u8>,
1761 pub use self::fuzzy_internal_msgs::*;
1762 #[cfg(not(fuzzing))]
1763 pub(crate) use self::fuzzy_internal_msgs::*;
1765 /// BOLT 4 onion packet including hop data for the next peer.
1766 #[derive(Clone, Hash, PartialEq, Eq)]
1767 pub struct OnionPacket {
1768 /// BOLT 4 version number.
1770 /// In order to ensure we always return an error on onion decode in compliance with [BOLT
1771 /// #4](https://github.com/lightning/bolts/blob/master/04-onion-routing.md), we have to
1772 /// deserialize `OnionPacket`s contained in [`UpdateAddHTLC`] messages even if the ephemeral
1773 /// public key (here) is bogus, so we hold a [`Result`] instead of a [`PublicKey`] as we'd
1775 pub public_key: Result<PublicKey, secp256k1::Error>,
1776 /// 1300 bytes encrypted payload for the next hop.
1777 pub hop_data: [u8; 20*65],
1778 /// HMAC to verify the integrity of hop_data.
1782 impl onion_utils::Packet for OnionPacket {
1783 type Data = onion_utils::FixedSizeOnionPacket;
1784 fn new(pubkey: PublicKey, hop_data: onion_utils::FixedSizeOnionPacket, hmac: [u8; 32]) -> Self {
1787 public_key: Ok(pubkey),
1788 hop_data: hop_data.0,
1794 impl fmt::Debug for OnionPacket {
1795 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1796 f.write_fmt(format_args!("OnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
1800 /// BOLT 4 onion packet including hop data for the next peer.
1801 #[derive(Clone, Hash, PartialEq, Eq)]
1802 pub struct TrampolineOnionPacket {
1803 /// Bolt 04 version number
1805 /// A random sepc256k1 point, used to build the ECDH shared secret to decrypt hop_data
1806 pub public_key: PublicKey,
1807 /// Encrypted payload for the next hop
1809 // Unlike the onion packets used for payments, Trampoline onion packets have to be shorter than
1810 // 1300 bytes. The expected default is 650 bytes.
1811 // TODO: if 650 ends up being the most common size, optimize this to be:
1812 // enum { SixFifty([u8; 650]), VarLen(Vec<u8>) }
1813 pub hop_data: Vec<u8>,
1814 /// HMAC to verify the integrity of hop_data
1818 impl onion_utils::Packet for TrampolineOnionPacket {
1819 type Data = Vec<u8>;
1820 fn new(public_key: PublicKey, hop_data: Vec<u8>, hmac: [u8; 32]) -> Self {
1830 impl Writeable for TrampolineOnionPacket {
1831 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1832 self.version.write(w)?;
1833 self.public_key.write(w)?;
1834 w.write_all(&self.hop_data)?;
1835 self.hmac.write(w)?;
1840 impl Debug for TrampolineOnionPacket {
1841 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1842 f.write_fmt(format_args!("TrampolineOnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
1846 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1847 pub(crate) struct OnionErrorPacket {
1848 // This really should be a constant size slice, but the spec lets these things be up to 128KB?
1849 // (TODO) We limit it in decode to much lower...
1850 pub(crate) data: Vec<u8>,
1853 impl fmt::Display for DecodeError {
1854 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1856 DecodeError::UnknownVersion => f.write_str("Unknown realm byte in Onion packet"),
1857 DecodeError::UnknownRequiredFeature => f.write_str("Unknown required feature preventing decode"),
1858 DecodeError::InvalidValue => f.write_str("Nonsense bytes didn't map to the type they were interpreted as"),
1859 DecodeError::ShortRead => f.write_str("Packet extended beyond the provided bytes"),
1860 DecodeError::BadLengthDescriptor => f.write_str("A length descriptor in the packet didn't describe the later data correctly"),
1861 DecodeError::Io(ref e) => fmt::Debug::fmt(e, f),
1862 DecodeError::UnsupportedCompression => f.write_str("We don't support receiving messages with zlib-compressed fields"),
1867 impl From<io::Error> for DecodeError {
1868 fn from(e: io::Error) -> Self {
1869 if e.kind() == io::ErrorKind::UnexpectedEof {
1870 DecodeError::ShortRead
1872 DecodeError::Io(e.kind())
1877 impl Writeable for AcceptChannel {
1878 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1879 self.common_fields.temporary_channel_id.write(w)?;
1880 self.common_fields.dust_limit_satoshis.write(w)?;
1881 self.common_fields.max_htlc_value_in_flight_msat.write(w)?;
1882 self.channel_reserve_satoshis.write(w)?;
1883 self.common_fields.htlc_minimum_msat.write(w)?;
1884 self.common_fields.minimum_depth.write(w)?;
1885 self.common_fields.to_self_delay.write(w)?;
1886 self.common_fields.max_accepted_htlcs.write(w)?;
1887 self.common_fields.funding_pubkey.write(w)?;
1888 self.common_fields.revocation_basepoint.write(w)?;
1889 self.common_fields.payment_basepoint.write(w)?;
1890 self.common_fields.delayed_payment_basepoint.write(w)?;
1891 self.common_fields.htlc_basepoint.write(w)?;
1892 self.common_fields.first_per_commitment_point.write(w)?;
1893 #[cfg(not(taproot))]
1894 encode_tlv_stream!(w, {
1895 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
1896 (1, self.common_fields.channel_type, option),
1899 encode_tlv_stream!(w, {
1900 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
1901 (1, self.common_fields.channel_type, option),
1902 (4, self.next_local_nonce, option),
1908 impl Readable for AcceptChannel {
1909 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1910 let temporary_channel_id: ChannelId = Readable::read(r)?;
1911 let dust_limit_satoshis: u64 = Readable::read(r)?;
1912 let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;
1913 let channel_reserve_satoshis: u64 = Readable::read(r)?;
1914 let htlc_minimum_msat: u64 = Readable::read(r)?;
1915 let minimum_depth: u32 = Readable::read(r)?;
1916 let to_self_delay: u16 = Readable::read(r)?;
1917 let max_accepted_htlcs: u16 = Readable::read(r)?;
1918 let funding_pubkey: PublicKey = Readable::read(r)?;
1919 let revocation_basepoint: PublicKey = Readable::read(r)?;
1920 let payment_basepoint: PublicKey = Readable::read(r)?;
1921 let delayed_payment_basepoint: PublicKey = Readable::read(r)?;
1922 let htlc_basepoint: PublicKey = Readable::read(r)?;
1923 let first_per_commitment_point: PublicKey = Readable::read(r)?;
1925 let mut shutdown_scriptpubkey: Option<ScriptBuf> = None;
1926 let mut channel_type: Option<ChannelTypeFeatures> = None;
1927 #[cfg(not(taproot))]
1928 decode_tlv_stream!(r, {
1929 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
1930 (1, channel_type, option),
1933 let mut next_local_nonce: Option<musig2::types::PublicNonce> = None;
1935 decode_tlv_stream!(r, {
1936 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
1937 (1, channel_type, option),
1938 (4, next_local_nonce, option),
1942 common_fields: CommonAcceptChannelFields {
1943 temporary_channel_id,
1944 dust_limit_satoshis,
1945 max_htlc_value_in_flight_msat,
1951 revocation_basepoint,
1953 delayed_payment_basepoint,
1955 first_per_commitment_point,
1956 shutdown_scriptpubkey,
1959 channel_reserve_satoshis,
1966 impl Writeable for AcceptChannelV2 {
1967 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1968 self.common_fields.temporary_channel_id.write(w)?;
1969 self.funding_satoshis.write(w)?;
1970 self.common_fields.dust_limit_satoshis.write(w)?;
1971 self.common_fields.max_htlc_value_in_flight_msat.write(w)?;
1972 self.common_fields.htlc_minimum_msat.write(w)?;
1973 self.common_fields.minimum_depth.write(w)?;
1974 self.common_fields.to_self_delay.write(w)?;
1975 self.common_fields.max_accepted_htlcs.write(w)?;
1976 self.common_fields.funding_pubkey.write(w)?;
1977 self.common_fields.revocation_basepoint.write(w)?;
1978 self.common_fields.payment_basepoint.write(w)?;
1979 self.common_fields.delayed_payment_basepoint.write(w)?;
1980 self.common_fields.htlc_basepoint.write(w)?;
1981 self.common_fields.first_per_commitment_point.write(w)?;
1982 self.second_per_commitment_point.write(w)?;
1984 encode_tlv_stream!(w, {
1985 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
1986 (1, self.common_fields.channel_type, option),
1987 (2, self.require_confirmed_inputs, option),
1993 impl Readable for AcceptChannelV2 {
1994 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1995 let temporary_channel_id: ChannelId = Readable::read(r)?;
1996 let funding_satoshis: u64 = Readable::read(r)?;
1997 let dust_limit_satoshis: u64 = Readable::read(r)?;
1998 let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;
1999 let htlc_minimum_msat: u64 = Readable::read(r)?;
2000 let minimum_depth: u32 = Readable::read(r)?;
2001 let to_self_delay: u16 = Readable::read(r)?;
2002 let max_accepted_htlcs: u16 = Readable::read(r)?;
2003 let funding_pubkey: PublicKey = Readable::read(r)?;
2004 let revocation_basepoint: PublicKey = Readable::read(r)?;
2005 let payment_basepoint: PublicKey = Readable::read(r)?;
2006 let delayed_payment_basepoint: PublicKey = Readable::read(r)?;
2007 let htlc_basepoint: PublicKey = Readable::read(r)?;
2008 let first_per_commitment_point: PublicKey = Readable::read(r)?;
2009 let second_per_commitment_point: PublicKey = Readable::read(r)?;
2011 let mut shutdown_scriptpubkey: Option<ScriptBuf> = None;
2012 let mut channel_type: Option<ChannelTypeFeatures> = None;
2013 let mut require_confirmed_inputs: Option<()> = None;
2014 decode_tlv_stream!(r, {
2015 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
2016 (1, channel_type, option),
2017 (2, require_confirmed_inputs, option),
2020 Ok(AcceptChannelV2 {
2021 common_fields: CommonAcceptChannelFields {
2022 temporary_channel_id,
2023 dust_limit_satoshis,
2024 max_htlc_value_in_flight_msat,
2030 revocation_basepoint,
2032 delayed_payment_basepoint,
2034 first_per_commitment_point,
2035 shutdown_scriptpubkey,
2039 second_per_commitment_point,
2040 require_confirmed_inputs,
2045 impl_writeable_msg!(Stfu, {
2050 impl_writeable_msg!(Splice, {
2054 funding_feerate_perkw,
2059 impl_writeable_msg!(SpliceAck, {
2066 impl_writeable_msg!(SpliceLocked, {
2070 impl_writeable_msg!(TxAddInput, {
2078 impl_writeable_msg!(TxAddOutput, {
2085 impl_writeable_msg!(TxRemoveInput, {
2090 impl_writeable_msg!(TxRemoveOutput, {
2095 impl_writeable_msg!(TxComplete, {
2099 impl_writeable_msg!(TxSignatures, {
2105 impl_writeable_msg!(TxInitRbf, {
2108 feerate_sat_per_1000_weight,
2110 (0, funding_output_contribution, option),
2113 impl_writeable_msg!(TxAckRbf, {
2116 (0, funding_output_contribution, option),
2119 impl_writeable_msg!(TxAbort, {
2124 impl_writeable_msg!(AnnouncementSignatures, {
2131 impl_writeable_msg!(ChannelReestablish, {
2133 next_local_commitment_number,
2134 next_remote_commitment_number,
2135 your_last_per_commitment_secret,
2136 my_current_per_commitment_point,
2138 (0, next_funding_txid, option),
2141 impl_writeable_msg!(ClosingSigned,
2142 { channel_id, fee_satoshis, signature },
2143 { (1, fee_range, option) }
2146 impl_writeable!(ClosingSignedFeeRange, {
2151 #[cfg(not(taproot))]
2152 impl_writeable_msg!(CommitmentSigned, {
2159 impl_writeable_msg!(CommitmentSigned, {
2164 (2, partial_signature_with_nonce, option)
2167 impl_writeable!(DecodedOnionErrorPacket, {
2173 #[cfg(not(taproot))]
2174 impl_writeable_msg!(FundingCreated, {
2175 temporary_channel_id,
2177 funding_output_index,
2181 impl_writeable_msg!(FundingCreated, {
2182 temporary_channel_id,
2184 funding_output_index,
2187 (2, partial_signature_with_nonce, option),
2188 (4, next_local_nonce, option)
2191 #[cfg(not(taproot))]
2192 impl_writeable_msg!(FundingSigned, {
2198 impl_writeable_msg!(FundingSigned, {
2202 (2, partial_signature_with_nonce, option)
2205 impl_writeable_msg!(ChannelReady, {
2207 next_per_commitment_point,
2209 (1, short_channel_id_alias, option),
2212 impl Writeable for Init {
2213 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2214 // global_features gets the bottom 13 bits of our features, and local_features gets all of
2215 // our relevant feature bits. This keeps us compatible with old nodes.
2216 self.features.write_up_to_13(w)?;
2217 self.features.write(w)?;
2218 encode_tlv_stream!(w, {
2219 (1, self.networks.as_ref().map(|n| WithoutLength(n)), option),
2220 (3, self.remote_network_address, option),
2226 impl Readable for Init {
2227 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2228 let global_features: InitFeatures = Readable::read(r)?;
2229 let features: InitFeatures = Readable::read(r)?;
2230 let mut remote_network_address: Option<SocketAddress> = None;
2231 let mut networks: Option<WithoutLength<Vec<ChainHash>>> = None;
2232 decode_tlv_stream!(r, {
2233 (1, networks, option),
2234 (3, remote_network_address, option)
2237 features: features | global_features,
2238 networks: networks.map(|n| n.0),
2239 remote_network_address,
2244 impl Writeable for OpenChannel {
2245 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2246 self.common_fields.chain_hash.write(w)?;
2247 self.common_fields.temporary_channel_id.write(w)?;
2248 self.common_fields.funding_satoshis.write(w)?;
2249 self.push_msat.write(w)?;
2250 self.common_fields.dust_limit_satoshis.write(w)?;
2251 self.common_fields.max_htlc_value_in_flight_msat.write(w)?;
2252 self.channel_reserve_satoshis.write(w)?;
2253 self.common_fields.htlc_minimum_msat.write(w)?;
2254 self.common_fields.commitment_feerate_sat_per_1000_weight.write(w)?;
2255 self.common_fields.to_self_delay.write(w)?;
2256 self.common_fields.max_accepted_htlcs.write(w)?;
2257 self.common_fields.funding_pubkey.write(w)?;
2258 self.common_fields.revocation_basepoint.write(w)?;
2259 self.common_fields.payment_basepoint.write(w)?;
2260 self.common_fields.delayed_payment_basepoint.write(w)?;
2261 self.common_fields.htlc_basepoint.write(w)?;
2262 self.common_fields.first_per_commitment_point.write(w)?;
2263 self.common_fields.channel_flags.write(w)?;
2264 encode_tlv_stream!(w, {
2265 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
2266 (1, self.common_fields.channel_type, option),
2272 impl Readable for OpenChannel {
2273 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2274 let chain_hash: ChainHash = Readable::read(r)?;
2275 let temporary_channel_id: ChannelId = Readable::read(r)?;
2276 let funding_satoshis: u64 = Readable::read(r)?;
2277 let push_msat: u64 = Readable::read(r)?;
2278 let dust_limit_satoshis: u64 = Readable::read(r)?;
2279 let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;
2280 let channel_reserve_satoshis: u64 = Readable::read(r)?;
2281 let htlc_minimum_msat: u64 = Readable::read(r)?;
2282 let commitment_feerate_sat_per_1000_weight: u32 = Readable::read(r)?;
2283 let to_self_delay: u16 = Readable::read(r)?;
2284 let max_accepted_htlcs: u16 = Readable::read(r)?;
2285 let funding_pubkey: PublicKey = Readable::read(r)?;
2286 let revocation_basepoint: PublicKey = Readable::read(r)?;
2287 let payment_basepoint: PublicKey = Readable::read(r)?;
2288 let delayed_payment_basepoint: PublicKey = Readable::read(r)?;
2289 let htlc_basepoint: PublicKey = Readable::read(r)?;
2290 let first_per_commitment_point: PublicKey = Readable::read(r)?;
2291 let channel_flags: u8 = Readable::read(r)?;
2293 let mut shutdown_scriptpubkey: Option<ScriptBuf> = None;
2294 let mut channel_type: Option<ChannelTypeFeatures> = None;
2295 decode_tlv_stream!(r, {
2296 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
2297 (1, channel_type, option),
2300 common_fields: CommonOpenChannelFields {
2302 temporary_channel_id,
2304 dust_limit_satoshis,
2305 max_htlc_value_in_flight_msat,
2307 commitment_feerate_sat_per_1000_weight,
2311 revocation_basepoint,
2313 delayed_payment_basepoint,
2315 first_per_commitment_point,
2317 shutdown_scriptpubkey,
2321 channel_reserve_satoshis,
2326 impl Writeable for OpenChannelV2 {
2327 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2328 self.common_fields.chain_hash.write(w)?;
2329 self.common_fields.temporary_channel_id.write(w)?;
2330 self.funding_feerate_sat_per_1000_weight.write(w)?;
2331 self.common_fields.commitment_feerate_sat_per_1000_weight.write(w)?;
2332 self.common_fields.funding_satoshis.write(w)?;
2333 self.common_fields.dust_limit_satoshis.write(w)?;
2334 self.common_fields.max_htlc_value_in_flight_msat.write(w)?;
2335 self.common_fields.htlc_minimum_msat.write(w)?;
2336 self.common_fields.to_self_delay.write(w)?;
2337 self.common_fields.max_accepted_htlcs.write(w)?;
2338 self.locktime.write(w)?;
2339 self.common_fields.funding_pubkey.write(w)?;
2340 self.common_fields.revocation_basepoint.write(w)?;
2341 self.common_fields.payment_basepoint.write(w)?;
2342 self.common_fields.delayed_payment_basepoint.write(w)?;
2343 self.common_fields.htlc_basepoint.write(w)?;
2344 self.common_fields.first_per_commitment_point.write(w)?;
2345 self.second_per_commitment_point.write(w)?;
2346 self.common_fields.channel_flags.write(w)?;
2347 encode_tlv_stream!(w, {
2348 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
2349 (1, self.common_fields.channel_type, option),
2350 (2, self.require_confirmed_inputs, option),
2356 impl Readable for OpenChannelV2 {
2357 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2358 let chain_hash: ChainHash = Readable::read(r)?;
2359 let temporary_channel_id: ChannelId = Readable::read(r)?;
2360 let funding_feerate_sat_per_1000_weight: u32 = Readable::read(r)?;
2361 let commitment_feerate_sat_per_1000_weight: u32 = Readable::read(r)?;
2362 let funding_satoshis: u64 = Readable::read(r)?;
2363 let dust_limit_satoshis: u64 = Readable::read(r)?;
2364 let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;
2365 let htlc_minimum_msat: u64 = Readable::read(r)?;
2366 let to_self_delay: u16 = Readable::read(r)?;
2367 let max_accepted_htlcs: u16 = Readable::read(r)?;
2368 let locktime: u32 = Readable::read(r)?;
2369 let funding_pubkey: PublicKey = Readable::read(r)?;
2370 let revocation_basepoint: PublicKey = Readable::read(r)?;
2371 let payment_basepoint: PublicKey = Readable::read(r)?;
2372 let delayed_payment_basepoint: PublicKey = Readable::read(r)?;
2373 let htlc_basepoint: PublicKey = Readable::read(r)?;
2374 let first_per_commitment_point: PublicKey = Readable::read(r)?;
2375 let second_per_commitment_point: PublicKey = Readable::read(r)?;
2376 let channel_flags: u8 = Readable::read(r)?;
2378 let mut shutdown_scriptpubkey: Option<ScriptBuf> = None;
2379 let mut channel_type: Option<ChannelTypeFeatures> = None;
2380 let mut require_confirmed_inputs: Option<()> = None;
2381 decode_tlv_stream!(r, {
2382 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
2383 (1, channel_type, option),
2384 (2, require_confirmed_inputs, option),
2387 common_fields: CommonOpenChannelFields {
2389 temporary_channel_id,
2391 dust_limit_satoshis,
2392 max_htlc_value_in_flight_msat,
2394 commitment_feerate_sat_per_1000_weight,
2398 revocation_basepoint,
2400 delayed_payment_basepoint,
2402 first_per_commitment_point,
2404 shutdown_scriptpubkey,
2407 funding_feerate_sat_per_1000_weight,
2409 second_per_commitment_point,
2410 require_confirmed_inputs,
2415 #[cfg(not(taproot))]
2416 impl_writeable_msg!(RevokeAndACK, {
2418 per_commitment_secret,
2419 next_per_commitment_point
2423 impl_writeable_msg!(RevokeAndACK, {
2425 per_commitment_secret,
2426 next_per_commitment_point
2428 (4, next_local_nonce, option)
2431 impl_writeable_msg!(Shutdown, {
2436 impl_writeable_msg!(UpdateFailHTLC, {
2442 impl_writeable_msg!(UpdateFailMalformedHTLC, {
2449 impl_writeable_msg!(UpdateFee, {
2454 impl_writeable_msg!(UpdateFulfillHTLC, {
2460 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2461 // serialization format in a way which assumes we know the total serialized length/message end
2463 impl_writeable!(OnionErrorPacket, {
2467 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2468 // serialization format in a way which assumes we know the total serialized length/message end
2470 impl Writeable for OnionPacket {
2471 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2472 self.version.write(w)?;
2473 match self.public_key {
2474 Ok(pubkey) => pubkey.write(w)?,
2475 Err(_) => [0u8;33].write(w)?,
2477 w.write_all(&self.hop_data)?;
2478 self.hmac.write(w)?;
2483 impl Readable for OnionPacket {
2484 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2486 version: Readable::read(r)?,
2488 let mut buf = [0u8;33];
2489 r.read_exact(&mut buf)?;
2490 PublicKey::from_slice(&buf)
2492 hop_data: Readable::read(r)?,
2493 hmac: Readable::read(r)?,
2498 impl_writeable_msg!(UpdateAddHTLC, {
2504 onion_routing_packet,
2506 (0, blinding_point, option),
2507 (65537, skimmed_fee_msat, option)
2510 impl Readable for OnionMessage {
2511 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2512 let blinding_point: PublicKey = Readable::read(r)?;
2513 let len: u16 = Readable::read(r)?;
2514 let mut packet_reader = FixedLengthReader::new(r, len as u64);
2515 let onion_routing_packet: onion_message::packet::Packet =
2516 <onion_message::packet::Packet as LengthReadable>::read(&mut packet_reader)?;
2519 onion_routing_packet,
2524 impl Writeable for OnionMessage {
2525 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2526 self.blinding_point.write(w)?;
2527 let onion_packet_len = self.onion_routing_packet.serialized_length();
2528 (onion_packet_len as u16).write(w)?;
2529 self.onion_routing_packet.write(w)?;
2534 impl Writeable for FinalOnionHopData {
2535 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2536 self.payment_secret.0.write(w)?;
2537 HighZeroBytesDroppedBigSize(self.total_msat).write(w)
2541 impl Readable for FinalOnionHopData {
2542 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2543 let secret: [u8; 32] = Readable::read(r)?;
2544 let amt: HighZeroBytesDroppedBigSize<u64> = Readable::read(r)?;
2545 Ok(Self { payment_secret: PaymentSecret(secret), total_msat: amt.0 })
2549 impl Writeable for OutboundOnionPayload {
2550 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2552 Self::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } => {
2553 _encode_varint_length_prefixed_tlv!(w, {
2554 (2, HighZeroBytesDroppedBigSize(*amt_to_forward), required),
2555 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2556 (6, short_channel_id, required)
2559 Self::TrampolineEntrypoint {
2560 amt_to_forward, outgoing_cltv_value, ref multipath_trampoline_data,
2561 ref trampoline_packet
2563 _encode_varint_length_prefixed_tlv!(w, {
2564 (2, HighZeroBytesDroppedBigSize(*amt_to_forward), required),
2565 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2566 (8, multipath_trampoline_data, option),
2567 (20, trampoline_packet, required)
2571 ref payment_data, ref payment_metadata, ref keysend_preimage, sender_intended_htlc_amt_msat,
2572 cltv_expiry_height, ref custom_tlvs,
2574 // We need to update [`ln::outbound_payment::RecipientOnionFields::with_custom_tlvs`]
2575 // to reject any reserved types in the experimental range if new ones are ever
2577 let keysend_tlv = keysend_preimage.map(|preimage| (5482373484, preimage.encode()));
2578 let mut custom_tlvs: Vec<&(u64, Vec<u8>)> = custom_tlvs.iter().chain(keysend_tlv.iter()).collect();
2579 custom_tlvs.sort_unstable_by_key(|(typ, _)| *typ);
2580 _encode_varint_length_prefixed_tlv!(w, {
2581 (2, HighZeroBytesDroppedBigSize(*sender_intended_htlc_amt_msat), required),
2582 (4, HighZeroBytesDroppedBigSize(*cltv_expiry_height), required),
2583 (8, payment_data, option),
2584 (16, payment_metadata.as_ref().map(|m| WithoutLength(m)), option)
2585 }, custom_tlvs.iter());
2587 Self::BlindedForward { encrypted_tlvs, intro_node_blinding_point } => {
2588 _encode_varint_length_prefixed_tlv!(w, {
2589 (10, *encrypted_tlvs, required_vec),
2590 (12, intro_node_blinding_point, option)
2593 Self::BlindedReceive {
2594 sender_intended_htlc_amt_msat, total_msat, cltv_expiry_height, encrypted_tlvs,
2595 intro_node_blinding_point, keysend_preimage,
2597 _encode_varint_length_prefixed_tlv!(w, {
2598 (2, HighZeroBytesDroppedBigSize(*sender_intended_htlc_amt_msat), required),
2599 (4, HighZeroBytesDroppedBigSize(*cltv_expiry_height), required),
2600 (10, *encrypted_tlvs, required_vec),
2601 (12, intro_node_blinding_point, option),
2602 (18, HighZeroBytesDroppedBigSize(*total_msat), required),
2603 (5482373484, keysend_preimage, option)
2611 impl Writeable for OutboundTrampolinePayload {
2612 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2614 Self::Forward { amt_to_forward, outgoing_cltv_value, outgoing_node_id } => {
2615 _encode_varint_length_prefixed_tlv!(w, {
2616 (2, HighZeroBytesDroppedBigSize(*amt_to_forward), required),
2617 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2618 (14, outgoing_node_id, required)
2627 impl<NS: Deref> ReadableArgs<(Option<PublicKey>, &NS)> for InboundOnionPayload where NS::Target: NodeSigner {
2628 fn read<R: Read>(r: &mut R, args: (Option<PublicKey>, &NS)) -> Result<Self, DecodeError> {
2629 let (update_add_blinding_point, node_signer) = args;
2632 let mut cltv_value = None;
2633 let mut short_id: Option<u64> = None;
2634 let mut payment_data: Option<FinalOnionHopData> = None;
2635 let mut encrypted_tlvs_opt: Option<WithoutLength<Vec<u8>>> = None;
2636 let mut intro_node_blinding_point = None;
2637 let mut payment_metadata: Option<WithoutLength<Vec<u8>>> = None;
2638 let mut total_msat = None;
2639 let mut keysend_preimage: Option<PaymentPreimage> = None;
2640 let mut custom_tlvs = Vec::new();
2642 let tlv_len = BigSize::read(r)?;
2643 let rd = FixedLengthReader::new(r, tlv_len.0);
2644 decode_tlv_stream_with_custom_tlv_decode!(rd, {
2645 (2, amt, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2646 (4, cltv_value, (option, encoding: (u32, HighZeroBytesDroppedBigSize))),
2647 (6, short_id, option),
2648 (8, payment_data, option),
2649 (10, encrypted_tlvs_opt, option),
2650 (12, intro_node_blinding_point, option),
2651 (16, payment_metadata, option),
2652 (18, total_msat, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2653 // See https://github.com/lightning/blips/blob/master/blip-0003.md
2654 (5482373484, keysend_preimage, option)
2655 }, |msg_type: u64, msg_reader: &mut FixedLengthReader<_>| -> Result<bool, DecodeError> {
2656 if msg_type < 1 << 16 { return Ok(false) }
2657 let mut value = Vec::new();
2658 msg_reader.read_to_end(&mut value)?;
2659 custom_tlvs.push((msg_type, value));
2663 if amt.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2664 if intro_node_blinding_point.is_some() && update_add_blinding_point.is_some() {
2665 return Err(DecodeError::InvalidValue)
2668 if let Some(blinding_point) = intro_node_blinding_point.or(update_add_blinding_point) {
2669 if short_id.is_some() || payment_data.is_some() || payment_metadata.is_some() {
2670 return Err(DecodeError::InvalidValue)
2672 let enc_tlvs = encrypted_tlvs_opt.ok_or(DecodeError::InvalidValue)?.0;
2673 let enc_tlvs_ss = node_signer.ecdh(Recipient::Node, &blinding_point, None)
2674 .map_err(|_| DecodeError::InvalidValue)?;
2675 let rho = onion_utils::gen_rho_from_shared_secret(&enc_tlvs_ss.secret_bytes());
2676 let mut s = Cursor::new(&enc_tlvs);
2677 let mut reader = FixedLengthReader::new(&mut s, enc_tlvs.len() as u64);
2678 match ChaChaPolyReadAdapter::read(&mut reader, rho)? {
2679 ChaChaPolyReadAdapter { readable: BlindedPaymentTlvs::Forward(ForwardTlvs {
2680 short_channel_id, payment_relay, payment_constraints, features
2682 if amt.is_some() || cltv_value.is_some() || total_msat.is_some() ||
2683 keysend_preimage.is_some()
2685 return Err(DecodeError::InvalidValue)
2687 Ok(Self::BlindedForward {
2690 payment_constraints,
2692 intro_node_blinding_point,
2695 ChaChaPolyReadAdapter { readable: BlindedPaymentTlvs::Receive(ReceiveTlvs {
2696 payment_secret, payment_constraints
2698 if total_msat.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2699 Ok(Self::BlindedReceive {
2700 sender_intended_htlc_amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2701 total_msat: total_msat.ok_or(DecodeError::InvalidValue)?,
2702 cltv_expiry_height: cltv_value.ok_or(DecodeError::InvalidValue)?,
2704 payment_constraints,
2705 intro_node_blinding_point,
2710 } else if let Some(short_channel_id) = short_id {
2711 if payment_data.is_some() || payment_metadata.is_some() || encrypted_tlvs_opt.is_some() ||
2712 total_msat.is_some()
2713 { return Err(DecodeError::InvalidValue) }
2716 amt_to_forward: amt.ok_or(DecodeError::InvalidValue)?,
2717 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2720 if encrypted_tlvs_opt.is_some() || total_msat.is_some() {
2721 return Err(DecodeError::InvalidValue)
2723 if let Some(data) = &payment_data {
2724 if data.total_msat > MAX_VALUE_MSAT {
2725 return Err(DecodeError::InvalidValue);
2730 payment_metadata: payment_metadata.map(|w| w.0),
2732 sender_intended_htlc_amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2733 cltv_expiry_height: cltv_value.ok_or(DecodeError::InvalidValue)?,
2740 impl Writeable for Ping {
2741 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2742 self.ponglen.write(w)?;
2743 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2748 impl Readable for Ping {
2749 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2751 ponglen: Readable::read(r)?,
2753 let byteslen = Readable::read(r)?;
2754 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2761 impl Writeable for Pong {
2762 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2763 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2768 impl Readable for Pong {
2769 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2772 let byteslen = Readable::read(r)?;
2773 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2780 impl Writeable for UnsignedChannelAnnouncement {
2781 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2782 self.features.write(w)?;
2783 self.chain_hash.write(w)?;
2784 self.short_channel_id.write(w)?;
2785 self.node_id_1.write(w)?;
2786 self.node_id_2.write(w)?;
2787 self.bitcoin_key_1.write(w)?;
2788 self.bitcoin_key_2.write(w)?;
2789 w.write_all(&self.excess_data[..])?;
2794 impl Readable for UnsignedChannelAnnouncement {
2795 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2797 features: Readable::read(r)?,
2798 chain_hash: Readable::read(r)?,
2799 short_channel_id: Readable::read(r)?,
2800 node_id_1: Readable::read(r)?,
2801 node_id_2: Readable::read(r)?,
2802 bitcoin_key_1: Readable::read(r)?,
2803 bitcoin_key_2: Readable::read(r)?,
2804 excess_data: read_to_end(r)?,
2809 impl_writeable!(ChannelAnnouncement, {
2812 bitcoin_signature_1,
2813 bitcoin_signature_2,
2817 impl Writeable for UnsignedChannelUpdate {
2818 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2819 // `message_flags` used to indicate presence of `htlc_maximum_msat`, but was deprecated in the spec.
2820 const MESSAGE_FLAGS: u8 = 1;
2821 self.chain_hash.write(w)?;
2822 self.short_channel_id.write(w)?;
2823 self.timestamp.write(w)?;
2824 let all_flags = self.flags as u16 | ((MESSAGE_FLAGS as u16) << 8);
2825 all_flags.write(w)?;
2826 self.cltv_expiry_delta.write(w)?;
2827 self.htlc_minimum_msat.write(w)?;
2828 self.fee_base_msat.write(w)?;
2829 self.fee_proportional_millionths.write(w)?;
2830 self.htlc_maximum_msat.write(w)?;
2831 w.write_all(&self.excess_data[..])?;
2836 impl Readable for UnsignedChannelUpdate {
2837 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2839 chain_hash: Readable::read(r)?,
2840 short_channel_id: Readable::read(r)?,
2841 timestamp: Readable::read(r)?,
2843 let flags: u16 = Readable::read(r)?;
2844 // Note: we ignore the `message_flags` for now, since it was deprecated by the spec.
2847 cltv_expiry_delta: Readable::read(r)?,
2848 htlc_minimum_msat: Readable::read(r)?,
2849 fee_base_msat: Readable::read(r)?,
2850 fee_proportional_millionths: Readable::read(r)?,
2851 htlc_maximum_msat: Readable::read(r)?,
2852 excess_data: read_to_end(r)?,
2857 impl_writeable!(ChannelUpdate, {
2862 impl Writeable for ErrorMessage {
2863 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2864 self.channel_id.write(w)?;
2865 (self.data.len() as u16).write(w)?;
2866 w.write_all(self.data.as_bytes())?;
2871 impl Readable for ErrorMessage {
2872 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2874 channel_id: Readable::read(r)?,
2876 let sz: usize = <u16 as Readable>::read(r)? as usize;
2877 let mut data = Vec::with_capacity(sz);
2879 r.read_exact(&mut data)?;
2880 match String::from_utf8(data) {
2882 Err(_) => return Err(DecodeError::InvalidValue),
2889 impl Writeable for WarningMessage {
2890 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2891 self.channel_id.write(w)?;
2892 (self.data.len() as u16).write(w)?;
2893 w.write_all(self.data.as_bytes())?;
2898 impl Readable for WarningMessage {
2899 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2901 channel_id: Readable::read(r)?,
2903 let sz: usize = <u16 as Readable>::read(r)? as usize;
2904 let mut data = Vec::with_capacity(sz);
2906 r.read_exact(&mut data)?;
2907 match String::from_utf8(data) {
2909 Err(_) => return Err(DecodeError::InvalidValue),
2916 impl Writeable for UnsignedNodeAnnouncement {
2917 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2918 self.features.write(w)?;
2919 self.timestamp.write(w)?;
2920 self.node_id.write(w)?;
2921 w.write_all(&self.rgb)?;
2922 self.alias.write(w)?;
2924 let mut addr_len = 0;
2925 for addr in self.addresses.iter() {
2926 addr_len += 1 + addr.len();
2928 (addr_len + self.excess_address_data.len() as u16).write(w)?;
2929 for addr in self.addresses.iter() {
2932 w.write_all(&self.excess_address_data[..])?;
2933 w.write_all(&self.excess_data[..])?;
2938 impl Readable for UnsignedNodeAnnouncement {
2939 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2940 let features: NodeFeatures = Readable::read(r)?;
2941 let timestamp: u32 = Readable::read(r)?;
2942 let node_id: NodeId = Readable::read(r)?;
2943 let mut rgb = [0; 3];
2944 r.read_exact(&mut rgb)?;
2945 let alias: NodeAlias = Readable::read(r)?;
2947 let addr_len: u16 = Readable::read(r)?;
2948 let mut addresses: Vec<SocketAddress> = Vec::new();
2949 let mut addr_readpos = 0;
2950 let mut excess = false;
2951 let mut excess_byte = 0;
2953 if addr_len <= addr_readpos { break; }
2954 match Readable::read(r) {
2956 if addr_len < addr_readpos + 1 + addr.len() {
2957 return Err(DecodeError::BadLengthDescriptor);
2959 addr_readpos += (1 + addr.len()) as u16;
2960 addresses.push(addr);
2962 Ok(Err(unknown_descriptor)) => {
2964 excess_byte = unknown_descriptor;
2967 Err(DecodeError::ShortRead) => return Err(DecodeError::BadLengthDescriptor),
2968 Err(e) => return Err(e),
2972 let mut excess_data = vec![];
2973 let excess_address_data = if addr_readpos < addr_len {
2974 let mut excess_address_data = vec![0; (addr_len - addr_readpos) as usize];
2975 r.read_exact(&mut excess_address_data[if excess { 1 } else { 0 }..])?;
2977 excess_address_data[0] = excess_byte;
2982 excess_data.push(excess_byte);
2986 excess_data.extend(read_to_end(r)?.iter());
2987 Ok(UnsignedNodeAnnouncement {
2994 excess_address_data,
3000 impl_writeable!(NodeAnnouncement, {
3005 impl Readable for QueryShortChannelIds {
3006 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
3007 let chain_hash: ChainHash = Readable::read(r)?;
3009 let encoding_len: u16 = Readable::read(r)?;
3010 let encoding_type: u8 = Readable::read(r)?;
3012 // Must be encoding_type=0 uncompressed serialization. We do not
3013 // support encoding_type=1 zlib serialization.
3014 if encoding_type != EncodingType::Uncompressed as u8 {
3015 return Err(DecodeError::UnsupportedCompression);
3018 // We expect the encoding_len to always includes the 1-byte
3019 // encoding_type and that short_channel_ids are 8-bytes each
3020 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
3021 return Err(DecodeError::InvalidValue);
3024 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
3025 // less the 1-byte encoding_type
3026 let short_channel_id_count: u16 = (encoding_len - 1)/8;
3027 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
3028 for _ in 0..short_channel_id_count {
3029 short_channel_ids.push(Readable::read(r)?);
3032 Ok(QueryShortChannelIds {
3039 impl Writeable for QueryShortChannelIds {
3040 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
3041 // Calculated from 1-byte encoding_type plus 8-bytes per short_channel_id
3042 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
3044 self.chain_hash.write(w)?;
3045 encoding_len.write(w)?;
3047 // We only support type=0 uncompressed serialization
3048 (EncodingType::Uncompressed as u8).write(w)?;
3050 for scid in self.short_channel_ids.iter() {
3058 impl_writeable_msg!(ReplyShortChannelIdsEnd, {
3063 impl QueryChannelRange {
3064 /// Calculates the overflow safe ending block height for the query.
3066 /// Overflow returns `0xffffffff`, otherwise returns `first_blocknum + number_of_blocks`.
3067 pub fn end_blocknum(&self) -> u32 {
3068 match self.first_blocknum.checked_add(self.number_of_blocks) {
3069 Some(block) => block,
3070 None => u32::max_value(),
3075 impl_writeable_msg!(QueryChannelRange, {
3081 impl Readable for ReplyChannelRange {
3082 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
3083 let chain_hash: ChainHash = Readable::read(r)?;
3084 let first_blocknum: u32 = Readable::read(r)?;
3085 let number_of_blocks: u32 = Readable::read(r)?;
3086 let sync_complete: bool = Readable::read(r)?;
3088 let encoding_len: u16 = Readable::read(r)?;
3089 let encoding_type: u8 = Readable::read(r)?;
3091 // Must be encoding_type=0 uncompressed serialization. We do not
3092 // support encoding_type=1 zlib serialization.
3093 if encoding_type != EncodingType::Uncompressed as u8 {
3094 return Err(DecodeError::UnsupportedCompression);
3097 // We expect the encoding_len to always includes the 1-byte
3098 // encoding_type and that short_channel_ids are 8-bytes each
3099 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
3100 return Err(DecodeError::InvalidValue);
3103 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
3104 // less the 1-byte encoding_type
3105 let short_channel_id_count: u16 = (encoding_len - 1)/8;
3106 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
3107 for _ in 0..short_channel_id_count {
3108 short_channel_ids.push(Readable::read(r)?);
3111 Ok(ReplyChannelRange {
3121 impl Writeable for ReplyChannelRange {
3122 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
3123 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
3124 self.chain_hash.write(w)?;
3125 self.first_blocknum.write(w)?;
3126 self.number_of_blocks.write(w)?;
3127 self.sync_complete.write(w)?;
3129 encoding_len.write(w)?;
3130 (EncodingType::Uncompressed as u8).write(w)?;
3131 for scid in self.short_channel_ids.iter() {
3139 impl_writeable_msg!(GossipTimestampFilter, {
3147 use std::convert::TryFrom;
3148 use bitcoin::{Transaction, TxIn, ScriptBuf, Sequence, Witness, TxOut};
3149 use hex::DisplayHex;
3150 use crate::ln::{PaymentPreimage, PaymentHash, PaymentSecret};
3151 use crate::ln::ChannelId;
3152 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
3153 use crate::ln::msgs::{self, FinalOnionHopData, OnionErrorPacket, CommonOpenChannelFields, CommonAcceptChannelFields, TrampolineOnionPacket};
3154 use crate::ln::msgs::SocketAddress;
3155 use crate::routing::gossip::{NodeAlias, NodeId};
3156 use crate::util::ser::{BigSize, Hostname, Readable, ReadableArgs, TransactionU16LenLimited, Writeable};
3157 use crate::util::test_utils;
3159 use bitcoin::hashes::hex::FromHex;
3160 use bitcoin::address::Address;
3161 use bitcoin::network::constants::Network;
3162 use bitcoin::blockdata::constants::ChainHash;
3163 use bitcoin::blockdata::script::Builder;
3164 use bitcoin::blockdata::opcodes;
3165 use bitcoin::hash_types::Txid;
3166 use bitcoin::locktime::absolute::LockTime;
3168 use bitcoin::secp256k1::{PublicKey,SecretKey};
3169 use bitcoin::secp256k1::{Secp256k1, Message};
3171 use crate::io::{self, Cursor};
3172 use crate::prelude::*;
3173 use core::str::FromStr;
3174 use crate::chain::transaction::OutPoint;
3176 #[cfg(feature = "std")]
3177 use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6, ToSocketAddrs};
3178 #[cfg(feature = "std")]
3179 use crate::ln::msgs::SocketAddressParseError;
3182 fn encoding_channel_reestablish() {
3184 let secp_ctx = Secp256k1::new();
3185 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&<Vec<u8>>::from_hex("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
3188 let cr = msgs::ChannelReestablish {
3189 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]),
3190 next_local_commitment_number: 3,
3191 next_remote_commitment_number: 4,
3192 your_last_per_commitment_secret: [9;32],
3193 my_current_per_commitment_point: public_key,
3194 next_funding_txid: None,
3197 let encoded_value = cr.encode();
3201 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
3202 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
3203 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
3204 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
3205 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
3211 fn encoding_channel_reestablish_with_next_funding_txid() {
3213 let secp_ctx = Secp256k1::new();
3214 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&<Vec<u8>>::from_hex("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
3217 let cr = msgs::ChannelReestablish {
3218 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]),
3219 next_local_commitment_number: 3,
3220 next_remote_commitment_number: 4,
3221 your_last_per_commitment_secret: [9;32],
3222 my_current_per_commitment_point: public_key,
3223 next_funding_txid: Some(Txid::from_raw_hash(bitcoin::hashes::Hash::from_slice(&[
3224 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,
3228 let encoded_value = cr.encode();
3232 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
3233 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
3234 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
3235 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
3236 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
3237 0, // Type (next_funding_txid)
3239 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
3244 macro_rules! get_keys_from {
3245 ($slice: expr, $secp_ctx: expr) => {
3247 let privkey = SecretKey::from_slice(&<Vec<u8>>::from_hex($slice).unwrap()[..]).unwrap();
3248 let pubkey = PublicKey::from_secret_key(&$secp_ctx, &privkey);
3254 macro_rules! get_sig_on {
3255 ($privkey: expr, $ctx: expr, $string: expr) => {
3257 let sighash = Message::from_slice(&$string.into_bytes()[..]).unwrap();
3258 $ctx.sign_ecdsa(&sighash, &$privkey)
3264 fn encoding_announcement_signatures() {
3265 let secp_ctx = Secp256k1::new();
3266 let (privkey, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3267 let sig_1 = get_sig_on!(privkey, secp_ctx, String::from("01010101010101010101010101010101"));
3268 let sig_2 = get_sig_on!(privkey, secp_ctx, String::from("02020202020202020202020202020202"));
3269 let announcement_signatures = msgs::AnnouncementSignatures {
3270 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]),
3271 short_channel_id: 2316138423780173,
3272 node_signature: sig_1,
3273 bitcoin_signature: sig_2,
3276 let encoded_value = announcement_signatures.encode();
3277 assert_eq!(encoded_value, <Vec<u8>>::from_hex("040000000000000005000000000000000600000000000000070000000000000000083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073acf9953cef4700860f5967838eba2bae89288ad188ebf8b20bf995c3ea53a26df1876d0a3a0e13172ba286a673140190c02ba9da60a2e43a745188c8a83c7f3ef").unwrap());
3280 fn do_encoding_channel_announcement(unknown_features_bits: bool, excess_data: bool) {
3281 let secp_ctx = Secp256k1::new();
3282 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3283 let (privkey_2, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3284 let (privkey_3, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3285 let (privkey_4, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3286 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3287 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
3288 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
3289 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
3290 let mut features = ChannelFeatures::empty();
3291 if unknown_features_bits {
3292 features = ChannelFeatures::from_le_bytes(vec![0xFF, 0xFF]);
3294 let unsigned_channel_announcement = msgs::UnsignedChannelAnnouncement {
3296 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3297 short_channel_id: 2316138423780173,
3298 node_id_1: NodeId::from_pubkey(&pubkey_1),
3299 node_id_2: NodeId::from_pubkey(&pubkey_2),
3300 bitcoin_key_1: NodeId::from_pubkey(&pubkey_3),
3301 bitcoin_key_2: NodeId::from_pubkey(&pubkey_4),
3302 excess_data: if excess_data { vec![10, 0, 0, 20, 0, 0, 30, 0, 0, 40] } else { Vec::new() },
3304 let channel_announcement = msgs::ChannelAnnouncement {
3305 node_signature_1: sig_1,
3306 node_signature_2: sig_2,
3307 bitcoin_signature_1: sig_3,
3308 bitcoin_signature_2: sig_4,
3309 contents: unsigned_channel_announcement,
3311 let encoded_value = channel_announcement.encode();
3312 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a1735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap();
3313 if unknown_features_bits {
3314 target_value.append(&mut <Vec<u8>>::from_hex("0002ffff").unwrap());
3316 target_value.append(&mut <Vec<u8>>::from_hex("0000").unwrap());
3318 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3319 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
3321 target_value.append(&mut <Vec<u8>>::from_hex("0a00001400001e000028").unwrap());
3323 assert_eq!(encoded_value, target_value);
3327 fn encoding_channel_announcement() {
3328 do_encoding_channel_announcement(true, false);
3329 do_encoding_channel_announcement(false, true);
3330 do_encoding_channel_announcement(false, false);
3331 do_encoding_channel_announcement(true, true);
3334 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) {
3335 let secp_ctx = Secp256k1::new();
3336 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3337 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3338 let features = if unknown_features_bits {
3339 NodeFeatures::from_le_bytes(vec![0xFF, 0xFF])
3341 // Set to some features we may support
3342 NodeFeatures::from_le_bytes(vec![2 | 1 << 5])
3344 let mut addresses = Vec::new();
3346 addresses.push(SocketAddress::TcpIpV4 {
3347 addr: [255, 254, 253, 252],
3352 addresses.push(SocketAddress::TcpIpV6 {
3353 addr: [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240],
3358 addresses.push(msgs::SocketAddress::OnionV2(
3359 [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 38, 7]
3363 addresses.push(msgs::SocketAddress::OnionV3 {
3364 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],
3371 addresses.push(SocketAddress::Hostname {
3372 hostname: Hostname::try_from(String::from("host")).unwrap(),
3376 let mut addr_len = 0;
3377 for addr in &addresses {
3378 addr_len += addr.len() + 1;
3380 let unsigned_node_announcement = msgs::UnsignedNodeAnnouncement {
3382 timestamp: 20190119,
3383 node_id: NodeId::from_pubkey(&pubkey_1),
3385 alias: NodeAlias([16;32]),
3387 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() },
3388 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() },
3390 addr_len += unsigned_node_announcement.excess_address_data.len() as u16;
3391 let node_announcement = msgs::NodeAnnouncement {
3393 contents: unsigned_node_announcement,
3395 let encoded_value = node_announcement.encode();
3396 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3397 if unknown_features_bits {
3398 target_value.append(&mut <Vec<u8>>::from_hex("0002ffff").unwrap());
3400 target_value.append(&mut <Vec<u8>>::from_hex("000122").unwrap());
3402 target_value.append(&mut <Vec<u8>>::from_hex("013413a7031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f2020201010101010101010101010101010101010101010101010101010101010101010").unwrap());
3403 target_value.append(&mut vec![(addr_len >> 8) as u8, addr_len as u8]);
3405 target_value.append(&mut <Vec<u8>>::from_hex("01fffefdfc2607").unwrap());
3408 target_value.append(&mut <Vec<u8>>::from_hex("02fffefdfcfbfaf9f8f7f6f5f4f3f2f1f02607").unwrap());
3411 target_value.append(&mut <Vec<u8>>::from_hex("03fffefdfcfbfaf9f8f7f62607").unwrap());
3414 target_value.append(&mut <Vec<u8>>::from_hex("04fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0efeeedecebeae9e8e7e6e5e4e3e2e1e00020102607").unwrap());
3417 target_value.append(&mut <Vec<u8>>::from_hex("0504686f73742607").unwrap());
3419 if excess_address_data {
3420 target_value.append(&mut <Vec<u8>>::from_hex("216c280b5395a2546e7e4b2663e04f811622f15a4f92e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d269").unwrap());
3423 target_value.append(&mut <Vec<u8>>::from_hex("3b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
3425 assert_eq!(encoded_value, target_value);
3429 fn encoding_node_announcement() {
3430 do_encoding_node_announcement(true, true, true, true, true, true, true, true);
3431 do_encoding_node_announcement(false, false, false, false, false, false, false, false);
3432 do_encoding_node_announcement(false, true, false, false, false, false, false, false);
3433 do_encoding_node_announcement(false, false, true, false, false, false, false, false);
3434 do_encoding_node_announcement(false, false, false, true, false, false, false, false);
3435 do_encoding_node_announcement(false, false, false, false, true, false, false, false);
3436 do_encoding_node_announcement(false, false, false, false, false, true, false, false);
3437 do_encoding_node_announcement(false, false, false, false, false, false, true, false);
3438 do_encoding_node_announcement(false, true, false, true, false, false, true, false);
3439 do_encoding_node_announcement(false, false, true, false, true, false, false, false);
3442 fn do_encoding_channel_update(direction: bool, disable: bool, excess_data: bool) {
3443 let secp_ctx = Secp256k1::new();
3444 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3445 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3446 let unsigned_channel_update = msgs::UnsignedChannelUpdate {
3447 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3448 short_channel_id: 2316138423780173,
3449 timestamp: 20190119,
3450 flags: if direction { 1 } else { 0 } | if disable { 1 << 1 } else { 0 },
3451 cltv_expiry_delta: 144,
3452 htlc_minimum_msat: 1000000,
3453 htlc_maximum_msat: 131355275467161,
3454 fee_base_msat: 10000,
3455 fee_proportional_millionths: 20,
3456 excess_data: if excess_data { vec![0, 0, 0, 0, 59, 154, 202, 0] } else { Vec::new() }
3458 let channel_update = msgs::ChannelUpdate {
3460 contents: unsigned_channel_update
3462 let encoded_value = channel_update.encode();
3463 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3464 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3465 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d013413a7").unwrap());
3466 target_value.append(&mut <Vec<u8>>::from_hex("01").unwrap());
3467 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3469 let flag = target_value.last_mut().unwrap();
3473 let flag = target_value.last_mut().unwrap();
3474 *flag = *flag | 1 << 1;
3476 target_value.append(&mut <Vec<u8>>::from_hex("009000000000000f42400000271000000014").unwrap());
3477 target_value.append(&mut <Vec<u8>>::from_hex("0000777788889999").unwrap());
3479 target_value.append(&mut <Vec<u8>>::from_hex("000000003b9aca00").unwrap());
3481 assert_eq!(encoded_value, target_value);
3485 fn encoding_channel_update() {
3486 do_encoding_channel_update(false, false, false);
3487 do_encoding_channel_update(false, false, true);
3488 do_encoding_channel_update(true, false, false);
3489 do_encoding_channel_update(true, false, true);
3490 do_encoding_channel_update(false, true, false);
3491 do_encoding_channel_update(false, true, true);
3492 do_encoding_channel_update(true, true, false);
3493 do_encoding_channel_update(true, true, true);
3496 fn do_encoding_open_channel(random_bit: bool, shutdown: bool, incl_chan_type: bool) {
3497 let secp_ctx = Secp256k1::new();
3498 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3499 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3500 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3501 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3502 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3503 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3504 let open_channel = msgs::OpenChannel {
3505 common_fields: CommonOpenChannelFields {
3506 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3507 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3508 funding_satoshis: 1311768467284833366,
3509 dust_limit_satoshis: 3608586615801332854,
3510 max_htlc_value_in_flight_msat: 8517154655701053848,
3511 htlc_minimum_msat: 2316138423780173,
3512 commitment_feerate_sat_per_1000_weight: 821716,
3513 to_self_delay: 49340,
3514 max_accepted_htlcs: 49340,
3515 funding_pubkey: pubkey_1,
3516 revocation_basepoint: pubkey_2,
3517 payment_basepoint: pubkey_3,
3518 delayed_payment_basepoint: pubkey_4,
3519 htlc_basepoint: pubkey_5,
3520 first_per_commitment_point: pubkey_6,
3521 channel_flags: if random_bit { 1 << 5 } else { 0 },
3522 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3523 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3525 push_msat: 2536655962884945560,
3526 channel_reserve_satoshis: 8665828695742877976,
3528 let encoded_value = open_channel.encode();
3529 let mut target_value = Vec::new();
3530 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3531 target_value.append(&mut <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202021234567890123456233403289122369832144668701144767633030896203198784335490624111800083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3533 target_value.append(&mut <Vec<u8>>::from_hex("20").unwrap());
3535 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3538 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3541 target_value.append(&mut <Vec<u8>>::from_hex("0100").unwrap());
3543 assert_eq!(encoded_value, target_value);
3547 fn encoding_open_channel() {
3548 do_encoding_open_channel(false, false, false);
3549 do_encoding_open_channel(false, false, true);
3550 do_encoding_open_channel(false, true, false);
3551 do_encoding_open_channel(false, true, true);
3552 do_encoding_open_channel(true, false, false);
3553 do_encoding_open_channel(true, false, true);
3554 do_encoding_open_channel(true, true, false);
3555 do_encoding_open_channel(true, true, true);
3558 fn do_encoding_open_channelv2(random_bit: bool, shutdown: bool, incl_chan_type: bool, require_confirmed_inputs: bool) {
3559 let secp_ctx = Secp256k1::new();
3560 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3561 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3562 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3563 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3564 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3565 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3566 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3567 let open_channelv2 = msgs::OpenChannelV2 {
3568 common_fields: CommonOpenChannelFields {
3569 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3570 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3571 commitment_feerate_sat_per_1000_weight: 821716,
3572 funding_satoshis: 1311768467284833366,
3573 dust_limit_satoshis: 3608586615801332854,
3574 max_htlc_value_in_flight_msat: 8517154655701053848,
3575 htlc_minimum_msat: 2316138423780173,
3576 to_self_delay: 49340,
3577 max_accepted_htlcs: 49340,
3578 funding_pubkey: pubkey_1,
3579 revocation_basepoint: pubkey_2,
3580 payment_basepoint: pubkey_3,
3581 delayed_payment_basepoint: pubkey_4,
3582 htlc_basepoint: pubkey_5,
3583 first_per_commitment_point: pubkey_6,
3584 channel_flags: if random_bit { 1 << 5 } else { 0 },
3585 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3586 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3588 funding_feerate_sat_per_1000_weight: 821716,
3589 locktime: 305419896,
3590 second_per_commitment_point: pubkey_7,
3591 require_confirmed_inputs: if require_confirmed_inputs { Some(()) } else { None },
3593 let encoded_value = open_channelv2.encode();
3594 let mut target_value = Vec::new();
3595 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3596 target_value.append(&mut <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap());
3597 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap());
3598 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap());
3599 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap());
3600 target_value.append(&mut <Vec<u8>>::from_hex("3214466870114476").unwrap());
3601 target_value.append(&mut <Vec<u8>>::from_hex("7633030896203198").unwrap());
3602 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d").unwrap());
3603 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap());
3604 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap());
3605 target_value.append(&mut <Vec<u8>>::from_hex("12345678").unwrap());
3606 target_value.append(&mut <Vec<u8>>::from_hex("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap());
3607 target_value.append(&mut <Vec<u8>>::from_hex("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap());
3608 target_value.append(&mut <Vec<u8>>::from_hex("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap());
3609 target_value.append(&mut <Vec<u8>>::from_hex("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
3610 target_value.append(&mut <Vec<u8>>::from_hex("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap());
3611 target_value.append(&mut <Vec<u8>>::from_hex("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3612 target_value.append(&mut <Vec<u8>>::from_hex("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap());
3615 target_value.append(&mut <Vec<u8>>::from_hex("20").unwrap());
3617 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3620 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3623 target_value.append(&mut <Vec<u8>>::from_hex("0100").unwrap());
3625 if require_confirmed_inputs {
3626 target_value.append(&mut <Vec<u8>>::from_hex("0200").unwrap());
3628 assert_eq!(encoded_value, target_value);
3632 fn encoding_open_channelv2() {
3633 do_encoding_open_channelv2(false, false, false, false);
3634 do_encoding_open_channelv2(false, false, false, true);
3635 do_encoding_open_channelv2(false, false, true, false);
3636 do_encoding_open_channelv2(false, false, true, true);
3637 do_encoding_open_channelv2(false, true, false, false);
3638 do_encoding_open_channelv2(false, true, false, true);
3639 do_encoding_open_channelv2(false, true, true, false);
3640 do_encoding_open_channelv2(false, true, true, true);
3641 do_encoding_open_channelv2(true, false, false, false);
3642 do_encoding_open_channelv2(true, false, false, true);
3643 do_encoding_open_channelv2(true, false, true, false);
3644 do_encoding_open_channelv2(true, false, true, true);
3645 do_encoding_open_channelv2(true, true, false, false);
3646 do_encoding_open_channelv2(true, true, false, true);
3647 do_encoding_open_channelv2(true, true, true, false);
3648 do_encoding_open_channelv2(true, true, true, true);
3651 fn do_encoding_accept_channel(shutdown: bool) {
3652 let secp_ctx = Secp256k1::new();
3653 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3654 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3655 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3656 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3657 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3658 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3659 let accept_channel = msgs::AcceptChannel {
3660 common_fields: CommonAcceptChannelFields {
3661 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3662 dust_limit_satoshis: 1311768467284833366,
3663 max_htlc_value_in_flight_msat: 2536655962884945560,
3664 htlc_minimum_msat: 2316138423780173,
3665 minimum_depth: 821716,
3666 to_self_delay: 49340,
3667 max_accepted_htlcs: 49340,
3668 funding_pubkey: pubkey_1,
3669 revocation_basepoint: pubkey_2,
3670 payment_basepoint: pubkey_3,
3671 delayed_payment_basepoint: pubkey_4,
3672 htlc_basepoint: pubkey_5,
3673 first_per_commitment_point: pubkey_6,
3674 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3677 channel_reserve_satoshis: 3608586615801332854,
3679 next_local_nonce: None,
3681 let encoded_value = accept_channel.encode();
3682 let mut target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020212345678901234562334032891223698321446687011447600083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap();
3684 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3686 assert_eq!(encoded_value, target_value);
3690 fn encoding_accept_channel() {
3691 do_encoding_accept_channel(false);
3692 do_encoding_accept_channel(true);
3695 fn do_encoding_accept_channelv2(shutdown: bool) {
3696 let secp_ctx = Secp256k1::new();
3697 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3698 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3699 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3700 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3701 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3702 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3703 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3704 let accept_channelv2 = msgs::AcceptChannelV2 {
3705 common_fields: CommonAcceptChannelFields {
3706 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3707 dust_limit_satoshis: 1311768467284833366,
3708 max_htlc_value_in_flight_msat: 2536655962884945560,
3709 htlc_minimum_msat: 2316138423780173,
3710 minimum_depth: 821716,
3711 to_self_delay: 49340,
3712 max_accepted_htlcs: 49340,
3713 funding_pubkey: pubkey_1,
3714 revocation_basepoint: pubkey_2,
3715 payment_basepoint: pubkey_3,
3716 delayed_payment_basepoint: pubkey_4,
3717 htlc_basepoint: pubkey_5,
3718 first_per_commitment_point: pubkey_6,
3719 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3722 funding_satoshis: 1311768467284833366,
3723 second_per_commitment_point: pubkey_7,
3724 require_confirmed_inputs: None,
3726 let encoded_value = accept_channelv2.encode();
3727 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // temporary_channel_id
3728 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap()); // funding_satoshis
3729 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap()); // dust_limit_satoshis
3730 target_value.append(&mut <Vec<u8>>::from_hex("2334032891223698").unwrap()); // max_htlc_value_in_flight_msat
3731 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d").unwrap()); // htlc_minimum_msat
3732 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap()); // minimum_depth
3733 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap()); // to_self_delay
3734 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap()); // max_accepted_htlcs
3735 target_value.append(&mut <Vec<u8>>::from_hex("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap()); // funding_pubkey
3736 target_value.append(&mut <Vec<u8>>::from_hex("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap()); // revocation_basepoint
3737 target_value.append(&mut <Vec<u8>>::from_hex("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap()); // payment_basepoint
3738 target_value.append(&mut <Vec<u8>>::from_hex("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap()); // delayed_payment_basepoint
3739 target_value.append(&mut <Vec<u8>>::from_hex("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap()); // htlc_basepoint
3740 target_value.append(&mut <Vec<u8>>::from_hex("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap()); // first_per_commitment_point
3741 target_value.append(&mut <Vec<u8>>::from_hex("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap()); // second_per_commitment_point
3743 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3745 assert_eq!(encoded_value, target_value);
3749 fn encoding_accept_channelv2() {
3750 do_encoding_accept_channelv2(false);
3751 do_encoding_accept_channelv2(true);
3755 fn encoding_funding_created() {
3756 let secp_ctx = Secp256k1::new();
3757 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3758 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3759 let funding_created = msgs::FundingCreated {
3760 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3761 funding_txid: Txid::from_str("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3762 funding_output_index: 255,
3765 partial_signature_with_nonce: None,
3767 next_local_nonce: None,
3769 let encoded_value = funding_created.encode();
3770 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202026e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c200ffd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3771 assert_eq!(encoded_value, target_value);
3775 fn encoding_funding_signed() {
3776 let secp_ctx = Secp256k1::new();
3777 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3778 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3779 let funding_signed = msgs::FundingSigned {
3780 channel_id: ChannelId::from_bytes([2; 32]),
3783 partial_signature_with_nonce: None,
3785 let encoded_value = funding_signed.encode();
3786 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3787 assert_eq!(encoded_value, target_value);
3791 fn encoding_channel_ready() {
3792 let secp_ctx = Secp256k1::new();
3793 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3794 let channel_ready = msgs::ChannelReady {
3795 channel_id: ChannelId::from_bytes([2; 32]),
3796 next_per_commitment_point: pubkey_1,
3797 short_channel_id_alias: None,
3799 let encoded_value = channel_ready.encode();
3800 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3801 assert_eq!(encoded_value, target_value);
3805 fn encoding_splice() {
3806 let secp_ctx = Secp256k1::new();
3807 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3808 let splice = msgs::Splice {
3809 chain_hash: ChainHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
3810 channel_id: ChannelId::from_bytes([2; 32]),
3811 relative_satoshis: 123456,
3812 funding_feerate_perkw: 2000,
3814 funding_pubkey: pubkey_1,
3816 let encoded_value = splice.encode();
3817 assert_eq!(encoded_value.as_hex().to_string(), "02020202020202020202020202020202020202020202020202020202020202026fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000000000000001e240000007d000000000031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f");
3821 fn encoding_stfu() {
3822 let stfu = msgs::Stfu {
3823 channel_id: ChannelId::from_bytes([2; 32]),
3826 let encoded_value = stfu.encode();
3827 assert_eq!(encoded_value.as_hex().to_string(), "020202020202020202020202020202020202020202020202020202020202020201");
3831 fn encoding_splice_ack() {
3832 let secp_ctx = Secp256k1::new();
3833 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3834 let splice = msgs::SpliceAck {
3835 chain_hash: ChainHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
3836 channel_id: ChannelId::from_bytes([2; 32]),
3837 relative_satoshis: 123456,
3838 funding_pubkey: pubkey_1,
3840 let encoded_value = splice.encode();
3841 assert_eq!(encoded_value.as_hex().to_string(), "02020202020202020202020202020202020202020202020202020202020202026fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000000000000001e240031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f");
3845 fn encoding_splice_locked() {
3846 let splice = msgs::SpliceLocked {
3847 channel_id: ChannelId::from_bytes([2; 32]),
3849 let encoded_value = splice.encode();
3850 assert_eq!(encoded_value.as_hex().to_string(), "0202020202020202020202020202020202020202020202020202020202020202");
3854 fn encoding_tx_add_input() {
3855 let tx_add_input = msgs::TxAddInput {
3856 channel_id: ChannelId::from_bytes([2; 32]),
3857 serial_id: 4886718345,
3858 prevtx: TransactionU16LenLimited::new(Transaction {
3860 lock_time: LockTime::ZERO,
3862 previous_output: OutPoint { txid: Txid::from_str("305bab643ee297b8b6b76b320792c8223d55082122cb606bf89382146ced9c77").unwrap(), index: 2 }.into_bitcoin_outpoint(),
3863 script_sig: ScriptBuf::new(),
3864 sequence: Sequence(0xfffffffd),
3865 witness: Witness::from_slice(&vec![
3866 <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3867 <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3872 script_pubkey: Address::from_str("bc1qzlffunw52jav8vwdu5x3jfk6sr8u22rmq3xzw2").unwrap().payload.script_pubkey(),
3876 script_pubkey: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().payload.script_pubkey(),
3880 prevtx_out: 305419896,
3881 sequence: 305419896,
3883 let encoded_value = tx_add_input.encode();
3884 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000000012345678900de02000000000101779ced6c148293f86b60cb222108553d22c89207326bb7b6b897e23e64ab5b300200000000fdffffff0236dbc1000000000016001417d29e4dd454bac3b1cde50d1926da80cfc5287b9cbd03000000000016001436ec78d514df462da95e6a00c24daa8915362d420247304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701210301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944000000001234567812345678").unwrap();
3885 assert_eq!(encoded_value, target_value);
3889 fn encoding_tx_add_output() {
3890 let tx_add_output = msgs::TxAddOutput {
3891 channel_id: ChannelId::from_bytes([2; 32]),
3892 serial_id: 4886718345,
3894 script: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().payload.script_pubkey(),
3896 let encoded_value = tx_add_output.encode();
3897 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000000012345678900000001234567890016001436ec78d514df462da95e6a00c24daa8915362d42").unwrap();
3898 assert_eq!(encoded_value, target_value);
3902 fn encoding_tx_remove_input() {
3903 let tx_remove_input = msgs::TxRemoveInput {
3904 channel_id: ChannelId::from_bytes([2; 32]),
3905 serial_id: 4886718345,
3907 let encoded_value = tx_remove_input.encode();
3908 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3909 assert_eq!(encoded_value, target_value);
3913 fn encoding_tx_remove_output() {
3914 let tx_remove_output = msgs::TxRemoveOutput {
3915 channel_id: ChannelId::from_bytes([2; 32]),
3916 serial_id: 4886718345,
3918 let encoded_value = tx_remove_output.encode();
3919 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3920 assert_eq!(encoded_value, target_value);
3924 fn encoding_tx_complete() {
3925 let tx_complete = msgs::TxComplete {
3926 channel_id: ChannelId::from_bytes([2; 32]),
3928 let encoded_value = tx_complete.encode();
3929 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3930 assert_eq!(encoded_value, target_value);
3934 fn encoding_tx_signatures() {
3935 let tx_signatures = msgs::TxSignatures {
3936 channel_id: ChannelId::from_bytes([2; 32]),
3937 tx_hash: Txid::from_str("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3939 Witness::from_slice(&vec![
3940 <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3941 <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3942 Witness::from_slice(&vec![
3943 <Vec<u8>>::from_hex("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap(),
3944 <Vec<u8>>::from_hex("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap()]),
3947 let encoded_value = tx_signatures.encode();
3948 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3949 target_value.append(&mut <Vec<u8>>::from_hex("6e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c2").unwrap()); // tx_hash (sha256) (big endian byte order)
3950 target_value.append(&mut <Vec<u8>>::from_hex("0002").unwrap()); // num_witnesses (u16)
3952 target_value.append(&mut <Vec<u8>>::from_hex("006b").unwrap()); // len of witness_data
3953 target_value.append(&mut <Vec<u8>>::from_hex("02").unwrap()); // num_witness_elements (VarInt)
3954 target_value.append(&mut <Vec<u8>>::from_hex("47").unwrap()); // len of witness element data (VarInt)
3955 target_value.append(&mut <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap());
3956 target_value.append(&mut <Vec<u8>>::from_hex("21").unwrap()); // len of witness element data (VarInt)
3957 target_value.append(&mut <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap());
3959 target_value.append(&mut <Vec<u8>>::from_hex("006c").unwrap()); // len of witness_data
3960 target_value.append(&mut <Vec<u8>>::from_hex("02").unwrap()); // num_witness_elements (VarInt)
3961 target_value.append(&mut <Vec<u8>>::from_hex("48").unwrap()); // len of witness element data (VarInt)
3962 target_value.append(&mut <Vec<u8>>::from_hex("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap());
3963 target_value.append(&mut <Vec<u8>>::from_hex("21").unwrap()); // len of witness element data (VarInt)
3964 target_value.append(&mut <Vec<u8>>::from_hex("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap());
3965 assert_eq!(encoded_value, target_value);
3968 fn do_encoding_tx_init_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3969 let tx_init_rbf = msgs::TxInitRbf {
3970 channel_id: ChannelId::from_bytes([2; 32]),
3971 locktime: 305419896,
3972 feerate_sat_per_1000_weight: 20190119,
3973 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3975 let encoded_value = tx_init_rbf.encode();
3976 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3977 target_value.append(&mut <Vec<u8>>::from_hex("12345678").unwrap()); // locktime
3978 target_value.append(&mut <Vec<u8>>::from_hex("013413a7").unwrap()); // feerate_sat_per_1000_weight
3979 if let Some((_, target)) = funding_value_with_hex_target {
3980 target_value.push(0x00); // Type
3981 target_value.push(target.len() as u8 / 2); // Length
3982 target_value.append(&mut <Vec<u8>>::from_hex(target).unwrap()); // Value (i64)
3984 assert_eq!(encoded_value, target_value);
3988 fn encoding_tx_init_rbf() {
3989 do_encoding_tx_init_rbf(Some((1311768467284833366, "1234567890123456")));
3990 do_encoding_tx_init_rbf(Some((13117684672, "000000030DDFFBC0")));
3991 do_encoding_tx_init_rbf(None);
3994 fn do_encoding_tx_ack_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3995 let tx_ack_rbf = msgs::TxAckRbf {
3996 channel_id: ChannelId::from_bytes([2; 32]),
3997 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3999 let encoded_value = tx_ack_rbf.encode();
4000 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
4001 if let Some((_, target)) = funding_value_with_hex_target {
4002 target_value.push(0x00); // Type
4003 target_value.push(target.len() as u8 / 2); // Length
4004 target_value.append(&mut <Vec<u8>>::from_hex(target).unwrap()); // Value (i64)
4006 assert_eq!(encoded_value, target_value);
4010 fn encoding_tx_ack_rbf() {
4011 do_encoding_tx_ack_rbf(Some((1311768467284833366, "1234567890123456")));
4012 do_encoding_tx_ack_rbf(Some((13117684672, "000000030DDFFBC0")));
4013 do_encoding_tx_ack_rbf(None);
4017 fn encoding_tx_abort() {
4018 let tx_abort = msgs::TxAbort {
4019 channel_id: ChannelId::from_bytes([2; 32]),
4020 data: <Vec<u8>>::from_hex("54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap(),
4022 let encoded_value = tx_abort.encode();
4023 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202002C54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap();
4024 assert_eq!(encoded_value, target_value);
4027 fn do_encoding_shutdown(script_type: u8) {
4028 let secp_ctx = Secp256k1::new();
4029 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4030 let script = Builder::new().push_opcode(opcodes::OP_TRUE).into_script();
4031 let shutdown = msgs::Shutdown {
4032 channel_id: ChannelId::from_bytes([2; 32]),
4034 if script_type == 1 { Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey() }
4035 else if script_type == 2 { Address::p2sh(&script, Network::Testnet).unwrap().script_pubkey() }
4036 else if script_type == 3 { Address::p2wpkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).unwrap().script_pubkey() }
4037 else { Address::p2wsh(&script, Network::Testnet).script_pubkey() },
4039 let encoded_value = shutdown.encode();
4040 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
4041 if script_type == 1 {
4042 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
4043 } else if script_type == 2 {
4044 target_value.append(&mut <Vec<u8>>::from_hex("0017a914da1745e9b549bd0bfa1a569971c77eba30cd5a4b87").unwrap());
4045 } else if script_type == 3 {
4046 target_value.append(&mut <Vec<u8>>::from_hex("0016001479b000887626b294a914501a4cd226b58b235983").unwrap());
4047 } else if script_type == 4 {
4048 target_value.append(&mut <Vec<u8>>::from_hex("002200204ae81572f06e1b88fd5ced7a1a000945432e83e1551e6f721ee9c00b8cc33260").unwrap());
4050 assert_eq!(encoded_value, target_value);
4054 fn encoding_shutdown() {
4055 do_encoding_shutdown(1);
4056 do_encoding_shutdown(2);
4057 do_encoding_shutdown(3);
4058 do_encoding_shutdown(4);
4062 fn encoding_closing_signed() {
4063 let secp_ctx = Secp256k1::new();
4064 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4065 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
4066 let closing_signed = msgs::ClosingSigned {
4067 channel_id: ChannelId::from_bytes([2; 32]),
4068 fee_satoshis: 2316138423780173,
4072 let encoded_value = closing_signed.encode();
4073 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
4074 assert_eq!(encoded_value, target_value);
4075 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value)).unwrap(), closing_signed);
4077 let closing_signed_with_range = msgs::ClosingSigned {
4078 channel_id: ChannelId::from_bytes([2; 32]),
4079 fee_satoshis: 2316138423780173,
4081 fee_range: Some(msgs::ClosingSignedFeeRange {
4082 min_fee_satoshis: 0xdeadbeef,
4083 max_fee_satoshis: 0x1badcafe01234567,
4086 let encoded_value_with_range = closing_signed_with_range.encode();
4087 let target_value_with_range = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a011000000000deadbeef1badcafe01234567").unwrap();
4088 assert_eq!(encoded_value_with_range, target_value_with_range);
4089 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value_with_range)).unwrap(),
4090 closing_signed_with_range);
4094 fn encoding_update_add_htlc() {
4095 let secp_ctx = Secp256k1::new();
4096 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4097 let onion_routing_packet = msgs::OnionPacket {
4099 public_key: Ok(pubkey_1),
4100 hop_data: [1; 20*65],
4103 let update_add_htlc = msgs::UpdateAddHTLC {
4104 channel_id: ChannelId::from_bytes([2; 32]),
4105 htlc_id: 2316138423780173,
4106 amount_msat: 3608586615801332854,
4107 payment_hash: PaymentHash([1; 32]),
4108 cltv_expiry: 821716,
4109 onion_routing_packet,
4110 skimmed_fee_msat: None,
4111 blinding_point: None,
4113 let encoded_value = update_add_htlc.encode();
4114 let target_value = <Vec<u8>>::from_hex("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").unwrap();
4115 assert_eq!(encoded_value, target_value);
4119 fn encoding_update_fulfill_htlc() {
4120 let update_fulfill_htlc = msgs::UpdateFulfillHTLC {
4121 channel_id: ChannelId::from_bytes([2; 32]),
4122 htlc_id: 2316138423780173,
4123 payment_preimage: PaymentPreimage([1; 32]),
4125 let encoded_value = update_fulfill_htlc.encode();
4126 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d0101010101010101010101010101010101010101010101010101010101010101").unwrap();
4127 assert_eq!(encoded_value, target_value);
4131 fn encoding_update_fail_htlc() {
4132 let reason = OnionErrorPacket {
4133 data: [1; 32].to_vec(),
4135 let update_fail_htlc = msgs::UpdateFailHTLC {
4136 channel_id: ChannelId::from_bytes([2; 32]),
4137 htlc_id: 2316138423780173,
4140 let encoded_value = update_fail_htlc.encode();
4141 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d00200101010101010101010101010101010101010101010101010101010101010101").unwrap();
4142 assert_eq!(encoded_value, target_value);
4146 fn encoding_update_fail_malformed_htlc() {
4147 let update_fail_malformed_htlc = msgs::UpdateFailMalformedHTLC {
4148 channel_id: ChannelId::from_bytes([2; 32]),
4149 htlc_id: 2316138423780173,
4150 sha256_of_onion: [1; 32],
4153 let encoded_value = update_fail_malformed_htlc.encode();
4154 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d010101010101010101010101010101010101010101010101010101010101010100ff").unwrap();
4155 assert_eq!(encoded_value, target_value);
4158 fn do_encoding_commitment_signed(htlcs: bool) {
4159 let secp_ctx = Secp256k1::new();
4160 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4161 let (privkey_2, _) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
4162 let (privkey_3, _) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
4163 let (privkey_4, _) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
4164 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
4165 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
4166 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
4167 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
4168 let commitment_signed = msgs::CommitmentSigned {
4169 channel_id: ChannelId::from_bytes([2; 32]),
4171 htlc_signatures: if htlcs { vec![sig_2, sig_3, sig_4] } else { Vec::new() },
4173 partial_signature_with_nonce: None,
4175 let encoded_value = commitment_signed.encode();
4176 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
4178 target_value.append(&mut <Vec<u8>>::from_hex("00031735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
4180 target_value.append(&mut <Vec<u8>>::from_hex("0000").unwrap());
4182 assert_eq!(encoded_value, target_value);
4186 fn encoding_commitment_signed() {
4187 do_encoding_commitment_signed(true);
4188 do_encoding_commitment_signed(false);
4192 fn encoding_revoke_and_ack() {
4193 let secp_ctx = Secp256k1::new();
4194 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4195 let raa = msgs::RevokeAndACK {
4196 channel_id: ChannelId::from_bytes([2; 32]),
4197 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],
4198 next_per_commitment_point: pubkey_1,
4200 next_local_nonce: None,
4202 let encoded_value = raa.encode();
4203 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020101010101010101010101010101010101010101010101010101010101010101031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
4204 assert_eq!(encoded_value, target_value);
4208 fn encoding_update_fee() {
4209 let update_fee = msgs::UpdateFee {
4210 channel_id: ChannelId::from_bytes([2; 32]),
4211 feerate_per_kw: 20190119,
4213 let encoded_value = update_fee.encode();
4214 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202013413a7").unwrap();
4215 assert_eq!(encoded_value, target_value);
4219 fn encoding_init() {
4220 let mainnet_hash = ChainHash::using_genesis_block(Network::Bitcoin);
4221 assert_eq!(msgs::Init {
4222 features: InitFeatures::from_le_bytes(vec![0xFF, 0xFF, 0xFF]),
4223 networks: Some(vec![mainnet_hash]),
4224 remote_network_address: None,
4225 }.encode(), <Vec<u8>>::from_hex("00023fff0003ffffff01206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
4226 assert_eq!(msgs::Init {
4227 features: InitFeatures::from_le_bytes(vec![0xFF]),
4229 remote_network_address: None,
4230 }.encode(), <Vec<u8>>::from_hex("0001ff0001ff").unwrap());
4231 assert_eq!(msgs::Init {
4232 features: InitFeatures::from_le_bytes(vec![]),
4233 networks: Some(vec![mainnet_hash]),
4234 remote_network_address: None,
4235 }.encode(), <Vec<u8>>::from_hex("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
4236 assert_eq!(msgs::Init {
4237 features: InitFeatures::from_le_bytes(vec![]),
4238 networks: Some(vec![ChainHash::from(&[1; 32]), ChainHash::from(&[2; 32])]),
4239 remote_network_address: None,
4240 }.encode(), <Vec<u8>>::from_hex("00000000014001010101010101010101010101010101010101010101010101010101010101010202020202020202020202020202020202020202020202020202020202020202").unwrap());
4241 let init_msg = msgs::Init { features: InitFeatures::from_le_bytes(vec![]),
4242 networks: Some(vec![mainnet_hash]),
4243 remote_network_address: Some(SocketAddress::TcpIpV4 {
4244 addr: [127, 0, 0, 1],
4248 let encoded_value = init_msg.encode();
4249 let target_value = <Vec<u8>>::from_hex("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d61900000000000307017f00000103e8").unwrap();
4250 assert_eq!(encoded_value, target_value);
4251 assert_eq!(msgs::Init::read(&mut Cursor::new(&target_value)).unwrap(), init_msg);
4255 fn encoding_error() {
4256 let error = msgs::ErrorMessage {
4257 channel_id: ChannelId::from_bytes([2; 32]),
4258 data: String::from("rust-lightning"),
4260 let encoded_value = error.encode();
4261 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
4262 assert_eq!(encoded_value, target_value);
4266 fn encoding_warning() {
4267 let error = msgs::WarningMessage {
4268 channel_id: ChannelId::from_bytes([2; 32]),
4269 data: String::from("rust-lightning"),
4271 let encoded_value = error.encode();
4272 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
4273 assert_eq!(encoded_value, target_value);
4277 fn encoding_ping() {
4278 let ping = msgs::Ping {
4282 let encoded_value = ping.encode();
4283 let target_value = <Vec<u8>>::from_hex("0040004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
4284 assert_eq!(encoded_value, target_value);
4288 fn encoding_pong() {
4289 let pong = msgs::Pong {
4292 let encoded_value = pong.encode();
4293 let target_value = <Vec<u8>>::from_hex("004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
4294 assert_eq!(encoded_value, target_value);
4298 fn encoding_nonfinal_onion_hop_data() {
4299 let outbound_msg = msgs::OutboundOnionPayload::Forward {
4300 short_channel_id: 0xdeadbeef1bad1dea,
4301 amt_to_forward: 0x0badf00d01020304,
4302 outgoing_cltv_value: 0xffffffff,
4304 let encoded_value = outbound_msg.encode();
4305 let target_value = <Vec<u8>>::from_hex("1a02080badf00d010203040404ffffffff0608deadbeef1bad1dea").unwrap();
4306 assert_eq!(encoded_value, target_value);
4308 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4309 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4310 if let msgs::InboundOnionPayload::Forward {
4311 short_channel_id, amt_to_forward, outgoing_cltv_value
4313 assert_eq!(short_channel_id, 0xdeadbeef1bad1dea);
4314 assert_eq!(amt_to_forward, 0x0badf00d01020304);
4315 assert_eq!(outgoing_cltv_value, 0xffffffff);
4316 } else { panic!(); }
4320 fn encoding_final_onion_hop_data() {
4321 let outbound_msg = msgs::OutboundOnionPayload::Receive {
4323 payment_metadata: None,
4324 keysend_preimage: None,
4325 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4326 cltv_expiry_height: 0xffffffff,
4327 custom_tlvs: vec![],
4329 let encoded_value = outbound_msg.encode();
4330 let target_value = <Vec<u8>>::from_hex("1002080badf00d010203040404ffffffff").unwrap();
4331 assert_eq!(encoded_value, target_value);
4333 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4334 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4335 if let msgs::InboundOnionPayload::Receive {
4336 payment_data: None, sender_intended_htlc_amt_msat, cltv_expiry_height, ..
4338 assert_eq!(sender_intended_htlc_amt_msat, 0x0badf00d01020304);
4339 assert_eq!(cltv_expiry_height, 0xffffffff);
4340 } else { panic!(); }
4344 fn encoding_final_onion_hop_data_with_secret() {
4345 let expected_payment_secret = PaymentSecret([0x42u8; 32]);
4346 let outbound_msg = msgs::OutboundOnionPayload::Receive {
4347 payment_data: Some(FinalOnionHopData {
4348 payment_secret: expected_payment_secret,
4349 total_msat: 0x1badca1f
4351 payment_metadata: None,
4352 keysend_preimage: None,
4353 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4354 cltv_expiry_height: 0xffffffff,
4355 custom_tlvs: vec![],
4357 let encoded_value = outbound_msg.encode();
4358 let target_value = <Vec<u8>>::from_hex("3602080badf00d010203040404ffffffff082442424242424242424242424242424242424242424242424242424242424242421badca1f").unwrap();
4359 assert_eq!(encoded_value, target_value);
4361 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4362 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4363 if let msgs::InboundOnionPayload::Receive {
4364 payment_data: Some(FinalOnionHopData {
4366 total_msat: 0x1badca1f
4368 sender_intended_htlc_amt_msat, cltv_expiry_height,
4369 payment_metadata: None,
4370 keysend_preimage: None,
4373 assert_eq!(payment_secret, expected_payment_secret);
4374 assert_eq!(sender_intended_htlc_amt_msat, 0x0badf00d01020304);
4375 assert_eq!(cltv_expiry_height, 0xffffffff);
4376 assert_eq!(custom_tlvs, vec![]);
4377 } else { panic!(); }
4381 fn encoding_final_onion_hop_data_with_bad_custom_tlvs() {
4382 // If custom TLVs have type number within the range reserved for protocol, treat them as if
4384 let bad_type_range_tlvs = vec![
4385 ((1 << 16) - 4, vec![42]),
4386 ((1 << 16) - 2, vec![42; 32]),
4388 let mut msg = msgs::OutboundOnionPayload::Receive {
4390 payment_metadata: None,
4391 keysend_preimage: None,
4392 custom_tlvs: bad_type_range_tlvs,
4393 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4394 cltv_expiry_height: 0xffffffff,
4396 let encoded_value = msg.encode();
4397 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4398 assert!(msgs::InboundOnionPayload::read(&mut Cursor::new(&encoded_value[..]), (None, &&node_signer)).is_err());
4399 let good_type_range_tlvs = vec![
4400 ((1 << 16) - 3, vec![42]),
4401 ((1 << 16) - 1, vec![42; 32]),
4403 if let msgs::OutboundOnionPayload::Receive { ref mut custom_tlvs, .. } = msg {
4404 *custom_tlvs = good_type_range_tlvs.clone();
4406 let encoded_value = msg.encode();
4407 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&encoded_value[..]), (None, &&node_signer)).unwrap();
4409 msgs::InboundOnionPayload::Receive { custom_tlvs, .. } => assert!(custom_tlvs.is_empty()),
4415 fn encoding_final_onion_hop_data_with_custom_tlvs() {
4416 let expected_custom_tlvs = vec![
4417 (5482373483, vec![0x12, 0x34]),
4418 (5482373487, vec![0x42u8; 8]),
4420 let msg = msgs::OutboundOnionPayload::Receive {
4422 payment_metadata: None,
4423 keysend_preimage: None,
4424 custom_tlvs: expected_custom_tlvs.clone(),
4425 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4426 cltv_expiry_height: 0xffffffff,
4428 let encoded_value = msg.encode();
4429 let target_value = <Vec<u8>>::from_hex("2e02080badf00d010203040404ffffffffff0000000146c6616b021234ff0000000146c6616f084242424242424242").unwrap();
4430 assert_eq!(encoded_value, target_value);
4431 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4432 let inbound_msg: msgs::InboundOnionPayload = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4433 if let msgs::InboundOnionPayload::Receive {
4435 payment_metadata: None,
4436 keysend_preimage: None,
4438 sender_intended_htlc_amt_msat,
4439 cltv_expiry_height: outgoing_cltv_value,
4442 assert_eq!(custom_tlvs, expected_custom_tlvs);
4443 assert_eq!(sender_intended_htlc_amt_msat, 0x0badf00d01020304);
4444 assert_eq!(outgoing_cltv_value, 0xffffffff);
4445 } else { panic!(); }
4449 fn encoding_final_onion_hop_data_with_trampoline_packet() {
4450 let secp_ctx = Secp256k1::new();
4451 let (_private_key, public_key) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4453 let compressed_public_key = public_key.serialize();
4454 assert_eq!(compressed_public_key.len(), 33);
4456 let trampoline_packet = TrampolineOnionPacket {
4459 hop_data: vec![1; 650], // this should be the standard encoded length
4462 let encoded_trampoline_packet = trampoline_packet.encode();
4463 assert_eq!(encoded_trampoline_packet.len(), 716);
4465 let msg = msgs::OutboundOnionPayload::TrampolineEntrypoint {
4466 multipath_trampoline_data: None,
4467 amt_to_forward: 0x0badf00d01020304,
4468 outgoing_cltv_value: 0xffffffff,
4471 let encoded_payload = msg.encode();
4473 let trampoline_type_bytes = &encoded_payload[19..=19];
4474 let mut trampoline_type_cursor = Cursor::new(trampoline_type_bytes);
4475 let trampoline_type_big_size: BigSize = Readable::read(&mut trampoline_type_cursor).unwrap();
4476 assert_eq!(trampoline_type_big_size.0, 20);
4478 let trampoline_length_bytes = &encoded_payload[20..=22];
4479 let mut trampoline_length_cursor = Cursor::new(trampoline_length_bytes);
4480 let trampoline_length_big_size: BigSize = Readable::read(&mut trampoline_length_cursor).unwrap();
4481 assert_eq!(trampoline_length_big_size.0, encoded_trampoline_packet.len() as u64);
4485 fn encoding_final_onion_hop_data_with_eclair_trampoline_packet() {
4486 let public_key = PublicKey::from_slice(&<Vec<u8>>::from_hex("02eec7245d6b7d2ccb30380bfbe2a3648cd7a942653f5aa340edcea1f283686619").unwrap()).unwrap();
4487 let hop_data = <Vec<u8>>::from_hex("cff34152f3a36e52ca94e74927203a560392b9cc7ce3c45809c6be52166c24a595716880f95f178bf5b30ca63141f74db6e92795c6130877cfdac3d4bd3087ee73c65d627ddd709112a848cc99e303f3706509aa43ba7c8a88cba175fccf9a8f5016ef06d3b935dbb15196d7ce16dc1a7157845566901d7b2197e52cab4ce487014b14816e5805f9fcacb4f8f88b8ff176f1b94f6ce6b00bc43221130c17d20ef629db7c5f7eafaa166578c720619561dd14b3277db557ec7dcdb793771aef0f2f667cfdbeae3ac8d331c5994779dffb31e5fc0dbdedc0c592ca6d21c18e47fe3528d6975c19517d7e2ea8c5391cf17d0fe30c80913ed887234ccb48808f7ef9425bcd815c3b586210979e3bb286ef2851bf9ce04e28c40a203df98fd648d2f1936fd2f1def0e77eecb277229b4b682322371c0a1dbfcd723a991993df8cc1f2696b84b055b40a1792a29f710295a18fbd351b0f3ff34cd13941131b8278ba79303c89117120eea691738a9954908195143b039dbeed98f26a92585f3d15cf742c953799d3272e0545e9b744be9d3b4c").unwrap();
4488 let hmac_vector = <Vec<u8>>::from_hex("bb079bfc4b35190eee9f59a1d7b41ba2f773179f322dafb4b1af900c289ebd6c").unwrap();
4489 let mut hmac = [0; 32];
4490 hmac.copy_from_slice(&hmac_vector);
4492 let compressed_public_key = public_key.serialize();
4493 assert_eq!(compressed_public_key.len(), 33);
4495 let trampoline_packet = TrampolineOnionPacket {
4501 let encoded_trampoline_packet = trampoline_packet.encode();
4502 let expected_eclair_trampoline_packet = <Vec<u8>>::from_hex("0002eec7245d6b7d2ccb30380bfbe2a3648cd7a942653f5aa340edcea1f283686619cff34152f3a36e52ca94e74927203a560392b9cc7ce3c45809c6be52166c24a595716880f95f178bf5b30ca63141f74db6e92795c6130877cfdac3d4bd3087ee73c65d627ddd709112a848cc99e303f3706509aa43ba7c8a88cba175fccf9a8f5016ef06d3b935dbb15196d7ce16dc1a7157845566901d7b2197e52cab4ce487014b14816e5805f9fcacb4f8f88b8ff176f1b94f6ce6b00bc43221130c17d20ef629db7c5f7eafaa166578c720619561dd14b3277db557ec7dcdb793771aef0f2f667cfdbeae3ac8d331c5994779dffb31e5fc0dbdedc0c592ca6d21c18e47fe3528d6975c19517d7e2ea8c5391cf17d0fe30c80913ed887234ccb48808f7ef9425bcd815c3b586210979e3bb286ef2851bf9ce04e28c40a203df98fd648d2f1936fd2f1def0e77eecb277229b4b682322371c0a1dbfcd723a991993df8cc1f2696b84b055b40a1792a29f710295a18fbd351b0f3ff34cd13941131b8278ba79303c89117120eea691738a9954908195143b039dbeed98f26a92585f3d15cf742c953799d3272e0545e9b744be9d3b4cbb079bfc4b35190eee9f59a1d7b41ba2f773179f322dafb4b1af900c289ebd6c").unwrap();
4503 assert_eq!(encoded_trampoline_packet, expected_eclair_trampoline_packet);
4507 fn query_channel_range_end_blocknum() {
4508 let tests: Vec<(u32, u32, u32)> = vec![
4509 (10000, 1500, 11500),
4510 (0, 0xffffffff, 0xffffffff),
4511 (1, 0xffffffff, 0xffffffff),
4514 for (first_blocknum, number_of_blocks, expected) in tests.into_iter() {
4515 let sut = msgs::QueryChannelRange {
4516 chain_hash: ChainHash::using_genesis_block(Network::Regtest),
4520 assert_eq!(sut.end_blocknum(), expected);
4525 fn encoding_query_channel_range() {
4526 let mut query_channel_range = msgs::QueryChannelRange {
4527 chain_hash: ChainHash::using_genesis_block(Network::Regtest),
4528 first_blocknum: 100000,
4529 number_of_blocks: 1500,
4531 let encoded_value = query_channel_range.encode();
4532 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000186a0000005dc").unwrap();
4533 assert_eq!(encoded_value, target_value);
4535 query_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4536 assert_eq!(query_channel_range.first_blocknum, 100000);
4537 assert_eq!(query_channel_range.number_of_blocks, 1500);
4541 fn encoding_reply_channel_range() {
4542 do_encoding_reply_channel_range(0);
4543 do_encoding_reply_channel_range(1);
4546 fn do_encoding_reply_channel_range(encoding_type: u8) {
4547 let mut target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000b8a06000005dc01").unwrap();
4548 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4549 let mut reply_channel_range = msgs::ReplyChannelRange {
4550 chain_hash: expected_chain_hash,
4551 first_blocknum: 756230,
4552 number_of_blocks: 1500,
4553 sync_complete: true,
4554 short_channel_ids: vec![0x000000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
4557 if encoding_type == 0 {
4558 target_value.append(&mut <Vec<u8>>::from_hex("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
4559 let encoded_value = reply_channel_range.encode();
4560 assert_eq!(encoded_value, target_value);
4562 reply_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4563 assert_eq!(reply_channel_range.chain_hash, expected_chain_hash);
4564 assert_eq!(reply_channel_range.first_blocknum, 756230);
4565 assert_eq!(reply_channel_range.number_of_blocks, 1500);
4566 assert_eq!(reply_channel_range.sync_complete, true);
4567 assert_eq!(reply_channel_range.short_channel_ids[0], 0x000000000000008e);
4568 assert_eq!(reply_channel_range.short_channel_ids[1], 0x0000000000003c69);
4569 assert_eq!(reply_channel_range.short_channel_ids[2], 0x000000000045a6c4);
4571 target_value.append(&mut <Vec<u8>>::from_hex("001601789c636000833e08659309a65878be010010a9023a").unwrap());
4572 let result: Result<msgs::ReplyChannelRange, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
4573 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
4578 fn encoding_query_short_channel_ids() {
4579 do_encoding_query_short_channel_ids(0);
4580 do_encoding_query_short_channel_ids(1);
4583 fn do_encoding_query_short_channel_ids(encoding_type: u8) {
4584 let mut target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
4585 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4586 let mut query_short_channel_ids = msgs::QueryShortChannelIds {
4587 chain_hash: expected_chain_hash,
4588 short_channel_ids: vec![0x0000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
4591 if encoding_type == 0 {
4592 target_value.append(&mut <Vec<u8>>::from_hex("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
4593 let encoded_value = query_short_channel_ids.encode();
4594 assert_eq!(encoded_value, target_value);
4596 query_short_channel_ids = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4597 assert_eq!(query_short_channel_ids.chain_hash, expected_chain_hash);
4598 assert_eq!(query_short_channel_ids.short_channel_ids[0], 0x000000000000008e);
4599 assert_eq!(query_short_channel_ids.short_channel_ids[1], 0x0000000000003c69);
4600 assert_eq!(query_short_channel_ids.short_channel_ids[2], 0x000000000045a6c4);
4602 target_value.append(&mut <Vec<u8>>::from_hex("001601789c636000833e08659309a65878be010010a9023a").unwrap());
4603 let result: Result<msgs::QueryShortChannelIds, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
4604 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
4609 fn encoding_reply_short_channel_ids_end() {
4610 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4611 let mut reply_short_channel_ids_end = msgs::ReplyShortChannelIdsEnd {
4612 chain_hash: expected_chain_hash,
4613 full_information: true,
4615 let encoded_value = reply_short_channel_ids_end.encode();
4616 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f01").unwrap();
4617 assert_eq!(encoded_value, target_value);
4619 reply_short_channel_ids_end = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4620 assert_eq!(reply_short_channel_ids_end.chain_hash, expected_chain_hash);
4621 assert_eq!(reply_short_channel_ids_end.full_information, true);
4625 fn encoding_gossip_timestamp_filter(){
4626 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4627 let mut gossip_timestamp_filter = msgs::GossipTimestampFilter {
4628 chain_hash: expected_chain_hash,
4629 first_timestamp: 1590000000,
4630 timestamp_range: 0xffff_ffff,
4632 let encoded_value = gossip_timestamp_filter.encode();
4633 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f5ec57980ffffffff").unwrap();
4634 assert_eq!(encoded_value, target_value);
4636 gossip_timestamp_filter = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4637 assert_eq!(gossip_timestamp_filter.chain_hash, expected_chain_hash);
4638 assert_eq!(gossip_timestamp_filter.first_timestamp, 1590000000);
4639 assert_eq!(gossip_timestamp_filter.timestamp_range, 0xffff_ffff);
4643 fn decode_onion_hop_data_len_as_bigsize() {
4644 // Tests that we can decode an onion payload that is >253 bytes.
4645 // Previously, receiving a payload of this size could've caused us to fail to decode a valid
4646 // payload, because we were decoding the length (a BigSize, big-endian) as a VarInt
4649 // Encode a test onion payload with a big custom TLV such that it's >253 bytes, forcing the
4650 // payload length to be encoded over multiple bytes rather than a single u8.
4651 let big_payload = encode_big_payload().unwrap();
4652 let mut rd = Cursor::new(&big_payload[..]);
4654 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4655 <msgs::InboundOnionPayload as ReadableArgs<(Option<PublicKey>, &&test_utils::TestKeysInterface)>>
4656 ::read(&mut rd, (None, &&node_signer)).unwrap();
4658 // see above test, needs to be a separate method for use of the serialization macros.
4659 fn encode_big_payload() -> Result<Vec<u8>, io::Error> {
4660 use crate::util::ser::HighZeroBytesDroppedBigSize;
4661 let payload = msgs::OutboundOnionPayload::Forward {
4662 short_channel_id: 0xdeadbeef1bad1dea,
4663 amt_to_forward: 1000,
4664 outgoing_cltv_value: 0xffffffff,
4666 let mut encoded_payload = Vec::new();
4667 let test_bytes = vec![42u8; 1000];
4668 if let msgs::OutboundOnionPayload::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } = payload {
4669 _encode_varint_length_prefixed_tlv!(&mut encoded_payload, {
4670 (1, test_bytes, required_vec),
4671 (2, HighZeroBytesDroppedBigSize(amt_to_forward), required),
4672 (4, HighZeroBytesDroppedBigSize(outgoing_cltv_value), required),
4673 (6, short_channel_id, required)
4680 #[cfg(feature = "std")]
4681 fn test_socket_address_from_str() {
4682 let tcpip_v4 = SocketAddress::TcpIpV4 {
4683 addr: Ipv4Addr::new(127, 0, 0, 1).octets(),
4686 assert_eq!(tcpip_v4, SocketAddress::from_str("127.0.0.1:1234").unwrap());
4687 assert_eq!(tcpip_v4, SocketAddress::from_str(&tcpip_v4.to_string()).unwrap());
4689 let tcpip_v6 = SocketAddress::TcpIpV6 {
4690 addr: Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1).octets(),
4693 assert_eq!(tcpip_v6, SocketAddress::from_str("[0:0:0:0:0:0:0:1]:1234").unwrap());
4694 assert_eq!(tcpip_v6, SocketAddress::from_str(&tcpip_v6.to_string()).unwrap());
4696 let hostname = SocketAddress::Hostname {
4697 hostname: Hostname::try_from("lightning-node.mydomain.com".to_string()).unwrap(),
4700 assert_eq!(hostname, SocketAddress::from_str("lightning-node.mydomain.com:1234").unwrap());
4701 assert_eq!(hostname, SocketAddress::from_str(&hostname.to_string()).unwrap());
4703 let onion_v2 = SocketAddress::OnionV2 ([40, 4, 64, 185, 202, 19, 162, 75, 90, 200, 38, 7],);
4704 assert_eq!("OnionV2([40, 4, 64, 185, 202, 19, 162, 75, 90, 200, 38, 7])", &onion_v2.to_string());
4705 assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("FACEBOOKCOREWWWI.onion:9735"));
4707 let onion_v3 = SocketAddress::OnionV3 {
4708 ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102, 182, 107, 4, 105, 247, 246, 85,
4709 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31, 33, 71, 3],
4714 assert_eq!(onion_v3, SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion:1234").unwrap());
4715 assert_eq!(onion_v3, SocketAddress::from_str(&onion_v3.to_string()).unwrap());
4717 assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6.onion:1234"));
4718 assert_eq!(Err(SocketAddressParseError::InvalidInput), SocketAddress::from_str("127.0.0.1@1234"));
4719 assert_eq!(Err(SocketAddressParseError::InvalidInput), "".parse::<SocketAddress>());
4720 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:9735:94").is_err());
4721 assert!(SocketAddress::from_str("wrong$%#.com:1234").is_err());
4722 assert_eq!(Err(SocketAddressParseError::InvalidPort), SocketAddress::from_str("example.com:wrong"));
4723 assert!("localhost".parse::<SocketAddress>().is_err());
4724 assert!("localhost:invalid-port".parse::<SocketAddress>().is_err());
4725 assert!( "invalid-onion-v3-hostname.onion:8080".parse::<SocketAddress>().is_err());
4726 assert!("b32.example.onion:invalid-port".parse::<SocketAddress>().is_err());
4727 assert!("invalid-address".parse::<SocketAddress>().is_err());
4728 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:1234").is_err());
4732 #[cfg(feature = "std")]
4733 fn test_socket_address_to_socket_addrs() {
4734 assert_eq!(SocketAddress::TcpIpV4 {addr:[0u8; 4], port: 1337,}.to_socket_addrs().unwrap().next().unwrap(),
4735 SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(0,0,0,0), 1337)));
4736 assert_eq!(SocketAddress::TcpIpV6 {addr:[0u8; 16], port: 1337,}.to_socket_addrs().unwrap().next().unwrap(),
4737 SocketAddr::V6(SocketAddrV6::new(Ipv6Addr::from([0u8; 16]), 1337, 0, 0)));
4738 assert_eq!(SocketAddress::Hostname { hostname: Hostname::try_from("0.0.0.0".to_string()).unwrap(), port: 0 }
4739 .to_socket_addrs().unwrap().next().unwrap(), SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::from([0u8; 4]),0)));
4740 assert!(SocketAddress::OnionV2([0u8; 12]).to_socket_addrs().is_err());
4741 assert!(SocketAddress::OnionV3{ ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102,
4742 182, 107, 4, 105, 247, 246, 85, 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31,
4746 port: 1234 }.to_socket_addrs().is_err());