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 /// An stfu (quiescence) message to be sent by or received from the stfu initiator.
400 // TODO(splicing): Add spec link for `stfu`; still in draft, using from https://github.com/lightning/bolts/pull/863
401 #[derive(Clone, Debug, PartialEq, Eq)]
403 /// The channel ID where quiescence is intended
404 pub channel_id: ChannelId,
405 /// Initiator flag, 1 if initiating, 0 if replying to an stfu.
409 /// A splice message to be sent by or received from the stfu initiator (splice initiator).
410 // TODO(splicing): Add spec link for `splice`; still in draft, using from https://github.com/lightning/bolts/pull/863
411 #[derive(Clone, Debug, PartialEq, Eq)]
413 /// The channel ID where splicing is intended
414 pub channel_id: ChannelId,
415 /// The genesis hash of the blockchain where the channel is intended to be spliced
416 pub chain_hash: ChainHash,
417 /// The intended change in channel capacity: the amount to be added (positive value)
418 /// or removed (negative value) by the sender (splice initiator) by splicing into/from the channel.
419 pub relative_satoshis: i64,
420 /// The feerate for the new funding transaction, set by the splice initiator
421 pub funding_feerate_perkw: u32,
422 /// The locktime for the new funding transaction
424 /// The key of the sender (splice initiator) controlling the new funding transaction
425 pub funding_pubkey: PublicKey,
428 /// A splice_ack message to be received by or sent to the splice initiator.
430 // TODO(splicing): Add spec link for `splice_ack`; still in draft, using from https://github.com/lightning/bolts/pull/863
431 #[derive(Clone, Debug, PartialEq, Eq)]
432 pub struct SpliceAck {
433 /// The channel ID where splicing is intended
434 pub channel_id: ChannelId,
435 /// The genesis hash of the blockchain where the channel is intended to be spliced
436 pub chain_hash: ChainHash,
437 /// The intended change in channel capacity: the amount to be added (positive value)
438 /// or removed (negative value) by the sender (splice acceptor) by splicing into/from the channel.
439 pub relative_satoshis: i64,
440 /// The key of the sender (splice acceptor) controlling the new funding transaction
441 pub funding_pubkey: PublicKey,
444 /// A splice_locked message to be sent to or received from a peer.
446 // TODO(splicing): Add spec link for `splice_locked`; still in draft, using from https://github.com/lightning/bolts/pull/863
447 #[derive(Clone, Debug, PartialEq, Eq)]
448 pub struct SpliceLocked {
450 pub channel_id: ChannelId,
453 /// A tx_add_input message for adding an input during interactive transaction construction
455 // TODO(dual_funding): Add spec link for `tx_add_input`.
456 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
457 pub struct TxAddInput {
459 pub channel_id: ChannelId,
460 /// A randomly chosen unique identifier for this input, which is even for initiators and odd for
463 /// Serialized transaction that contains the output this input spends to verify that it is non
465 pub prevtx: TransactionU16LenLimited,
466 /// The index of the output being spent
468 /// The sequence number of this input
472 /// A tx_add_output message for adding an output during interactive transaction construction.
474 // TODO(dual_funding): Add spec link for `tx_add_output`.
475 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
476 pub struct TxAddOutput {
478 pub channel_id: ChannelId,
479 /// A randomly chosen unique identifier for this output, which is even for initiators and odd for
482 /// The satoshi value of the output
484 /// The scriptPubKey for the output
485 pub script: ScriptBuf,
488 /// A tx_remove_input message for removing an input during interactive transaction construction.
490 // TODO(dual_funding): Add spec link for `tx_remove_input`.
491 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
492 pub struct TxRemoveInput {
494 pub channel_id: ChannelId,
495 /// The serial ID of the input to be removed
499 /// A tx_remove_output message for removing an output during interactive transaction construction.
501 // TODO(dual_funding): Add spec link for `tx_remove_output`.
502 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
503 pub struct TxRemoveOutput {
505 pub channel_id: ChannelId,
506 /// The serial ID of the output to be removed
510 /// A tx_complete message signalling the conclusion of a peer's transaction contributions during
511 /// interactive transaction construction.
513 // TODO(dual_funding): Add spec link for `tx_complete`.
514 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
515 pub struct TxComplete {
517 pub channel_id: ChannelId,
520 /// A tx_signatures message containing the sender's signatures for a transaction constructed with
521 /// interactive transaction construction.
523 // TODO(dual_funding): Add spec link for `tx_signatures`.
524 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
525 pub struct TxSignatures {
527 pub channel_id: ChannelId,
530 /// The list of witnesses
531 pub witnesses: Vec<Witness>,
534 /// A tx_init_rbf message which initiates a replacement of the transaction after it's been
537 // TODO(dual_funding): Add spec link for `tx_init_rbf`.
538 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
539 pub struct TxInitRbf {
541 pub channel_id: ChannelId,
542 /// The locktime of the transaction
544 /// The feerate of the transaction
545 pub feerate_sat_per_1000_weight: u32,
546 /// The number of satoshis the sender will contribute to or, if negative, remove from
547 /// (e.g. splice-out) the funding output of the transaction
548 pub funding_output_contribution: Option<i64>,
551 /// A tx_ack_rbf message which acknowledges replacement of the transaction after it's been
554 // TODO(dual_funding): Add spec link for `tx_ack_rbf`.
555 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
556 pub struct TxAckRbf {
558 pub channel_id: ChannelId,
559 /// The number of satoshis the sender will contribute to or, if negative, remove from
560 /// (e.g. splice-out) the funding output of the transaction
561 pub funding_output_contribution: Option<i64>,
564 /// A tx_abort message which signals the cancellation of an in-progress transaction negotiation.
566 // TODO(dual_funding): Add spec link for `tx_abort`.
567 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
570 pub channel_id: ChannelId,
575 /// A [`shutdown`] message to be sent to or received from a peer.
577 /// [`shutdown`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-initiation-shutdown
578 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
579 pub struct Shutdown {
581 pub channel_id: ChannelId,
582 /// The destination of this peer's funds on closing.
584 /// Must be in one of these forms: P2PKH, P2SH, P2WPKH, P2WSH, P2TR.
585 pub scriptpubkey: ScriptBuf,
588 /// The minimum and maximum fees which the sender is willing to place on the closing transaction.
590 /// This is provided in [`ClosingSigned`] by both sides to indicate the fee range they are willing
592 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
593 pub struct ClosingSignedFeeRange {
594 /// The minimum absolute fee, in satoshis, which the sender is willing to place on the closing
596 pub min_fee_satoshis: u64,
597 /// The maximum absolute fee, in satoshis, which the sender is willing to place on the closing
599 pub max_fee_satoshis: u64,
602 /// A [`closing_signed`] message to be sent to or received from a peer.
604 /// [`closing_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-negotiation-closing_signed
605 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
606 pub struct ClosingSigned {
608 pub channel_id: ChannelId,
609 /// The proposed total fee for the closing transaction
610 pub fee_satoshis: u64,
611 /// A signature on the closing transaction
612 pub signature: Signature,
613 /// The minimum and maximum fees which the sender is willing to accept, provided only by new
615 pub fee_range: Option<ClosingSignedFeeRange>,
618 /// An [`update_add_htlc`] message to be sent to or received from a peer.
620 /// [`update_add_htlc`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#adding-an-htlc-update_add_htlc
621 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
622 pub struct UpdateAddHTLC {
624 pub channel_id: ChannelId,
627 /// The HTLC value in milli-satoshi
628 pub amount_msat: u64,
629 /// The payment hash, the pre-image of which controls HTLC redemption
630 pub payment_hash: PaymentHash,
631 /// The expiry height of the HTLC
632 pub cltv_expiry: u32,
633 /// The extra fee skimmed by the sender of this message. See
634 /// [`ChannelConfig::accept_underpaying_htlcs`].
636 /// [`ChannelConfig::accept_underpaying_htlcs`]: crate::util::config::ChannelConfig::accept_underpaying_htlcs
637 pub skimmed_fee_msat: Option<u64>,
638 /// The onion routing packet with encrypted data for the next hop.
639 pub onion_routing_packet: OnionPacket,
640 /// Provided if we are relaying or receiving a payment within a blinded path, to decrypt the onion
641 /// routing packet and the recipient-provided encrypted payload within.
642 pub blinding_point: Option<PublicKey>,
645 /// An onion message to be sent to or received from a peer.
647 // TODO: update with link to OM when they are merged into the BOLTs
648 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
649 pub struct OnionMessage {
650 /// Used in decrypting the onion packet's payload.
651 pub blinding_point: PublicKey,
652 /// The full onion packet including hop data, pubkey, and hmac
653 pub onion_routing_packet: onion_message::packet::Packet,
656 /// An [`update_fulfill_htlc`] message to be sent to or received from a peer.
658 /// [`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
659 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
660 pub struct UpdateFulfillHTLC {
662 pub channel_id: ChannelId,
665 /// The pre-image of the payment hash, allowing HTLC redemption
666 pub payment_preimage: PaymentPreimage,
669 /// An [`update_fail_htlc`] message to be sent to or received from a peer.
671 /// [`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
672 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
673 pub struct UpdateFailHTLC {
675 pub channel_id: ChannelId,
678 pub(crate) reason: OnionErrorPacket,
681 /// An [`update_fail_malformed_htlc`] message to be sent to or received from a peer.
683 /// [`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
684 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
685 pub struct UpdateFailMalformedHTLC {
687 pub channel_id: ChannelId,
690 pub(crate) sha256_of_onion: [u8; 32],
692 pub failure_code: u16,
695 /// A [`commitment_signed`] message to be sent to or received from a peer.
697 /// [`commitment_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#committing-updates-so-far-commitment_signed
698 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
699 pub struct CommitmentSigned {
701 pub channel_id: ChannelId,
702 /// A signature on the commitment transaction
703 pub signature: Signature,
704 /// Signatures on the HTLC transactions
705 pub htlc_signatures: Vec<Signature>,
707 /// The partial Taproot signature on the commitment transaction
708 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
711 /// A [`revoke_and_ack`] message to be sent to or received from a peer.
713 /// [`revoke_and_ack`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#completing-the-transition-to-the-updated-state-revoke_and_ack
714 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
715 pub struct RevokeAndACK {
717 pub channel_id: ChannelId,
718 /// The secret corresponding to the per-commitment point
719 pub per_commitment_secret: [u8; 32],
720 /// The next sender-broadcast commitment transaction's per-commitment point
721 pub next_per_commitment_point: PublicKey,
723 /// Musig nonce the recipient should use in their next commitment signature message
724 pub next_local_nonce: Option<musig2::types::PublicNonce>
727 /// An [`update_fee`] message to be sent to or received from a peer
729 /// [`update_fee`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#updating-fees-update_fee
730 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
731 pub struct UpdateFee {
733 pub channel_id: ChannelId,
734 /// Fee rate per 1000-weight of the transaction
735 pub feerate_per_kw: u32,
738 /// A [`channel_reestablish`] message to be sent to or received from a peer.
740 /// [`channel_reestablish`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#message-retransmission
741 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
742 pub struct ChannelReestablish {
744 pub channel_id: ChannelId,
745 /// The next commitment number for the sender
746 pub next_local_commitment_number: u64,
747 /// The next commitment number for the recipient
748 pub next_remote_commitment_number: u64,
749 /// Proof that the sender knows the per-commitment secret of a specific commitment transaction
750 /// belonging to the recipient
751 pub your_last_per_commitment_secret: [u8; 32],
752 /// The sender's per-commitment point for their current commitment transaction
753 pub my_current_per_commitment_point: PublicKey,
754 /// The next funding transaction ID
755 pub next_funding_txid: Option<Txid>,
758 /// An [`announcement_signatures`] message to be sent to or received from a peer.
760 /// [`announcement_signatures`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-announcement_signatures-message
761 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
762 pub struct AnnouncementSignatures {
764 pub channel_id: ChannelId,
765 /// The short channel ID
766 pub short_channel_id: u64,
767 /// A signature by the node key
768 pub node_signature: Signature,
769 /// A signature by the funding key
770 pub bitcoin_signature: Signature,
773 /// An address which can be used to connect to a remote peer.
774 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
775 pub enum SocketAddress {
776 /// An IPv4 address and port on which the peer is listening.
778 /// The 4-byte IPv4 address
780 /// The port on which the node is listening
783 /// An IPv6 address and port on which the peer is listening.
785 /// The 16-byte IPv6 address
787 /// The port on which the node is listening
790 /// An old-style Tor onion address/port on which the peer is listening.
792 /// This field is deprecated and the Tor network generally no longer supports V2 Onion
793 /// addresses. Thus, the details are not parsed here.
795 /// A new-style Tor onion address/port on which the peer is listening.
797 /// To create the human-readable "hostname", concatenate the ED25519 pubkey, checksum, and version,
798 /// wrap as base32 and append ".onion".
800 /// The ed25519 long-term public key of the peer
801 ed25519_pubkey: [u8; 32],
802 /// The checksum of the pubkey and version, as included in the onion address
804 /// The version byte, as defined by the Tor Onion v3 spec.
806 /// The port on which the node is listening
809 /// A hostname/port on which the peer is listening.
811 /// The hostname on which the node is listening.
813 /// The port on which the node is listening.
818 /// Gets the ID of this address type. Addresses in [`NodeAnnouncement`] messages should be sorted
820 pub(crate) fn get_id(&self) -> u8 {
822 &SocketAddress::TcpIpV4 {..} => { 1 },
823 &SocketAddress::TcpIpV6 {..} => { 2 },
824 &SocketAddress::OnionV2(_) => { 3 },
825 &SocketAddress::OnionV3 {..} => { 4 },
826 &SocketAddress::Hostname {..} => { 5 },
830 /// Strict byte-length of address descriptor, 1-byte type not recorded
831 fn len(&self) -> u16 {
833 &SocketAddress::TcpIpV4 { .. } => { 6 },
834 &SocketAddress::TcpIpV6 { .. } => { 18 },
835 &SocketAddress::OnionV2(_) => { 12 },
836 &SocketAddress::OnionV3 { .. } => { 37 },
837 // Consists of 1-byte hostname length, hostname bytes, and 2-byte port.
838 &SocketAddress::Hostname { ref hostname, .. } => { u16::from(hostname.len()) + 3 },
842 /// The maximum length of any address descriptor, not including the 1-byte type.
843 /// This maximum length is reached by a hostname address descriptor:
844 /// a hostname with a maximum length of 255, its 1-byte length and a 2-byte port.
845 pub(crate) const MAX_LEN: u16 = 258;
847 pub(crate) fn is_tor(&self) -> bool {
849 &SocketAddress::TcpIpV4 {..} => false,
850 &SocketAddress::TcpIpV6 {..} => false,
851 &SocketAddress::OnionV2(_) => true,
852 &SocketAddress::OnionV3 {..} => true,
853 &SocketAddress::Hostname {..} => false,
858 impl Writeable for SocketAddress {
859 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
861 &SocketAddress::TcpIpV4 { ref addr, ref port } => {
866 &SocketAddress::TcpIpV6 { ref addr, ref port } => {
871 &SocketAddress::OnionV2(bytes) => {
873 bytes.write(writer)?;
875 &SocketAddress::OnionV3 { ref ed25519_pubkey, ref checksum, ref version, ref port } => {
877 ed25519_pubkey.write(writer)?;
878 checksum.write(writer)?;
879 version.write(writer)?;
882 &SocketAddress::Hostname { ref hostname, ref port } => {
884 hostname.write(writer)?;
892 impl Readable for Result<SocketAddress, u8> {
893 fn read<R: Read>(reader: &mut R) -> Result<Result<SocketAddress, u8>, DecodeError> {
894 let byte = <u8 as Readable>::read(reader)?;
897 Ok(Ok(SocketAddress::TcpIpV4 {
898 addr: Readable::read(reader)?,
899 port: Readable::read(reader)?,
903 Ok(Ok(SocketAddress::TcpIpV6 {
904 addr: Readable::read(reader)?,
905 port: Readable::read(reader)?,
908 3 => Ok(Ok(SocketAddress::OnionV2(Readable::read(reader)?))),
910 Ok(Ok(SocketAddress::OnionV3 {
911 ed25519_pubkey: Readable::read(reader)?,
912 checksum: Readable::read(reader)?,
913 version: Readable::read(reader)?,
914 port: Readable::read(reader)?,
918 Ok(Ok(SocketAddress::Hostname {
919 hostname: Readable::read(reader)?,
920 port: Readable::read(reader)?,
923 _ => return Ok(Err(byte)),
928 impl Readable for SocketAddress {
929 fn read<R: Read>(reader: &mut R) -> Result<SocketAddress, DecodeError> {
930 match Readable::read(reader) {
931 Ok(Ok(res)) => Ok(res),
932 Ok(Err(_)) => Err(DecodeError::UnknownVersion),
938 /// [`SocketAddress`] error variants
939 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
940 pub enum SocketAddressParseError {
941 /// Socket address (IPv4/IPv6) parsing error
943 /// Invalid input format
947 /// Invalid onion v3 address
951 impl fmt::Display for SocketAddressParseError {
952 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
954 SocketAddressParseError::SocketAddrParse => write!(f, "Socket address (IPv4/IPv6) parsing error"),
955 SocketAddressParseError::InvalidInput => write!(f, "Invalid input format. \
956 Expected: \"<ipv4>:<port>\", \"[<ipv6>]:<port>\", \"<onion address>.onion:<port>\" or \"<hostname>:<port>\""),
957 SocketAddressParseError::InvalidPort => write!(f, "Invalid port"),
958 SocketAddressParseError::InvalidOnionV3 => write!(f, "Invalid onion v3 address"),
963 #[cfg(feature = "std")]
964 impl From<std::net::SocketAddrV4> for SocketAddress {
965 fn from(addr: std::net::SocketAddrV4) -> Self {
966 SocketAddress::TcpIpV4 { addr: addr.ip().octets(), port: addr.port() }
970 #[cfg(feature = "std")]
971 impl From<std::net::SocketAddrV6> for SocketAddress {
972 fn from(addr: std::net::SocketAddrV6) -> Self {
973 SocketAddress::TcpIpV6 { addr: addr.ip().octets(), port: addr.port() }
977 #[cfg(feature = "std")]
978 impl From<std::net::SocketAddr> for SocketAddress {
979 fn from(addr: std::net::SocketAddr) -> Self {
981 std::net::SocketAddr::V4(addr) => addr.into(),
982 std::net::SocketAddr::V6(addr) => addr.into(),
987 #[cfg(feature = "std")]
988 impl std::net::ToSocketAddrs for SocketAddress {
989 type Iter = std::vec::IntoIter<std::net::SocketAddr>;
991 fn to_socket_addrs(&self) -> std::io::Result<Self::Iter> {
993 SocketAddress::TcpIpV4 { addr, port } => {
994 let ip_addr = std::net::Ipv4Addr::from(*addr);
995 let socket_addr = SocketAddr::new(ip_addr.into(), *port);
996 Ok(vec![socket_addr].into_iter())
998 SocketAddress::TcpIpV6 { addr, port } => {
999 let ip_addr = std::net::Ipv6Addr::from(*addr);
1000 let socket_addr = SocketAddr::new(ip_addr.into(), *port);
1001 Ok(vec![socket_addr].into_iter())
1003 SocketAddress::Hostname { ref hostname, port } => {
1004 (hostname.as_str(), *port).to_socket_addrs()
1006 SocketAddress::OnionV2(..) => {
1007 Err(std::io::Error::new(std::io::ErrorKind::Other, "Resolution of OnionV2 \
1008 addresses is currently unsupported."))
1010 SocketAddress::OnionV3 { .. } => {
1011 Err(std::io::Error::new(std::io::ErrorKind::Other, "Resolution of OnionV3 \
1012 addresses is currently unsupported."))
1018 /// Parses an OnionV3 host and port into a [`SocketAddress::OnionV3`].
1020 /// The host part must end with ".onion".
1021 pub fn parse_onion_address(host: &str, port: u16) -> Result<SocketAddress, SocketAddressParseError> {
1022 if host.ends_with(".onion") {
1023 let domain = &host[..host.len() - ".onion".len()];
1024 if domain.len() != 56 {
1025 return Err(SocketAddressParseError::InvalidOnionV3);
1027 let onion = base32::Alphabet::RFC4648 { padding: false }.decode(&domain).map_err(|_| SocketAddressParseError::InvalidOnionV3)?;
1028 if onion.len() != 35 {
1029 return Err(SocketAddressParseError::InvalidOnionV3);
1031 let version = onion[0];
1032 let first_checksum_flag = onion[1];
1033 let second_checksum_flag = onion[2];
1034 let mut ed25519_pubkey = [0; 32];
1035 ed25519_pubkey.copy_from_slice(&onion[3..35]);
1036 let checksum = u16::from_be_bytes([first_checksum_flag, second_checksum_flag]);
1037 return Ok(SocketAddress::OnionV3 { ed25519_pubkey, checksum, version, port });
1040 return Err(SocketAddressParseError::InvalidInput);
1044 impl Display for SocketAddress {
1045 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1047 SocketAddress::TcpIpV4{addr, port} => write!(
1048 f, "{}.{}.{}.{}:{}", addr[0], addr[1], addr[2], addr[3], port)?,
1049 SocketAddress::TcpIpV6{addr, port} => write!(
1051 "[{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}]:{}",
1052 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
1054 SocketAddress::OnionV2(bytes) => write!(f, "OnionV2({:?})", bytes)?,
1055 SocketAddress::OnionV3 {
1061 let [first_checksum_flag, second_checksum_flag] = checksum.to_be_bytes();
1062 let mut addr = vec![*version, first_checksum_flag, second_checksum_flag];
1063 addr.extend_from_slice(ed25519_pubkey);
1064 let onion = base32::Alphabet::RFC4648 { padding: false }.encode(&addr);
1065 write!(f, "{}.onion:{}", onion, port)?
1067 SocketAddress::Hostname { hostname, port } => write!(f, "{}:{}", hostname, port)?,
1073 #[cfg(feature = "std")]
1074 impl FromStr for SocketAddress {
1075 type Err = SocketAddressParseError;
1077 fn from_str(s: &str) -> Result<Self, Self::Err> {
1078 match std::net::SocketAddr::from_str(s) {
1079 Ok(addr) => Ok(addr.into()),
1081 let trimmed_input = match s.rfind(":") {
1083 None => return Err(SocketAddressParseError::InvalidInput),
1085 let host = &s[..trimmed_input];
1086 let port: u16 = s[trimmed_input + 1..].parse().map_err(|_| SocketAddressParseError::InvalidPort)?;
1087 if host.ends_with(".onion") {
1088 return parse_onion_address(host, port);
1090 if let Ok(hostname) = Hostname::try_from(s[..trimmed_input].to_string()) {
1091 return Ok(SocketAddress::Hostname { hostname, port });
1093 return Err(SocketAddressParseError::SocketAddrParse)
1099 /// Represents the set of gossip messages that require a signature from a node's identity key.
1100 pub enum UnsignedGossipMessage<'a> {
1101 /// An unsigned channel announcement.
1102 ChannelAnnouncement(&'a UnsignedChannelAnnouncement),
1103 /// An unsigned channel update.
1104 ChannelUpdate(&'a UnsignedChannelUpdate),
1105 /// An unsigned node announcement.
1106 NodeAnnouncement(&'a UnsignedNodeAnnouncement)
1109 impl<'a> Writeable for UnsignedGossipMessage<'a> {
1110 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
1112 UnsignedGossipMessage::ChannelAnnouncement(ref msg) => msg.write(writer),
1113 UnsignedGossipMessage::ChannelUpdate(ref msg) => msg.write(writer),
1114 UnsignedGossipMessage::NodeAnnouncement(ref msg) => msg.write(writer),
1119 /// The unsigned part of a [`node_announcement`] message.
1121 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
1122 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1123 pub struct UnsignedNodeAnnouncement {
1124 /// The advertised features
1125 pub features: NodeFeatures,
1126 /// A strictly monotonic announcement counter, with gaps allowed
1128 /// The `node_id` this announcement originated from (don't rebroadcast the `node_announcement` back
1130 pub node_id: NodeId,
1131 /// An RGB color for UI purposes
1133 /// An alias, for UI purposes.
1135 /// This should be sanitized before use. There is no guarantee of uniqueness.
1136 pub alias: NodeAlias,
1137 /// List of addresses on which this node is reachable
1138 pub addresses: Vec<SocketAddress>,
1139 pub(crate) excess_address_data: Vec<u8>,
1140 pub(crate) excess_data: Vec<u8>,
1142 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1143 /// A [`node_announcement`] message to be sent to or received from a peer.
1145 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
1146 pub struct NodeAnnouncement {
1147 /// The signature by the node key
1148 pub signature: Signature,
1149 /// The actual content of the announcement
1150 pub contents: UnsignedNodeAnnouncement,
1153 /// The unsigned part of a [`channel_announcement`] message.
1155 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
1156 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1157 pub struct UnsignedChannelAnnouncement {
1158 /// The advertised channel features
1159 pub features: ChannelFeatures,
1160 /// The genesis hash of the blockchain where the channel is to be opened
1161 pub chain_hash: ChainHash,
1162 /// The short channel ID
1163 pub short_channel_id: u64,
1164 /// One of the two `node_id`s which are endpoints of this channel
1165 pub node_id_1: NodeId,
1166 /// The other of the two `node_id`s which are endpoints of this channel
1167 pub node_id_2: NodeId,
1168 /// The funding key for the first node
1169 pub bitcoin_key_1: NodeId,
1170 /// The funding key for the second node
1171 pub bitcoin_key_2: NodeId,
1172 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1175 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1176 pub excess_data: Vec<u8>,
1178 /// A [`channel_announcement`] message to be sent to or received from a peer.
1180 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
1181 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1182 pub struct ChannelAnnouncement {
1183 /// Authentication of the announcement by the first public node
1184 pub node_signature_1: Signature,
1185 /// Authentication of the announcement by the second public node
1186 pub node_signature_2: Signature,
1187 /// Proof of funding UTXO ownership by the first public node
1188 pub bitcoin_signature_1: Signature,
1189 /// Proof of funding UTXO ownership by the second public node
1190 pub bitcoin_signature_2: Signature,
1191 /// The actual announcement
1192 pub contents: UnsignedChannelAnnouncement,
1195 /// The unsigned part of a [`channel_update`] message.
1197 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1198 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1199 pub struct UnsignedChannelUpdate {
1200 /// The genesis hash of the blockchain where the channel is to be opened
1201 pub chain_hash: ChainHash,
1202 /// The short channel ID
1203 pub short_channel_id: u64,
1204 /// A strictly monotonic announcement counter, with gaps allowed, specific to this channel
1208 /// The number of blocks such that if:
1209 /// `incoming_htlc.cltv_expiry < outgoing_htlc.cltv_expiry + cltv_expiry_delta`
1210 /// then we need to fail the HTLC backwards. When forwarding an HTLC, `cltv_expiry_delta` determines
1211 /// the outgoing HTLC's minimum `cltv_expiry` value -- so, if an incoming HTLC comes in with a
1212 /// `cltv_expiry` of 100000, and the node we're forwarding to has a `cltv_expiry_delta` value of 10,
1213 /// then we'll check that the outgoing HTLC's `cltv_expiry` value is at least 100010 before
1214 /// forwarding. Note that the HTLC sender is the one who originally sets this value when
1215 /// constructing the route.
1216 pub cltv_expiry_delta: u16,
1217 /// The minimum HTLC size incoming to sender, in milli-satoshi
1218 pub htlc_minimum_msat: u64,
1219 /// The maximum HTLC value incoming to sender, in milli-satoshi.
1221 /// This used to be optional.
1222 pub htlc_maximum_msat: u64,
1223 /// The base HTLC fee charged by sender, in milli-satoshi
1224 pub fee_base_msat: u32,
1225 /// The amount to fee multiplier, in micro-satoshi
1226 pub fee_proportional_millionths: u32,
1227 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1230 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1231 pub excess_data: Vec<u8>,
1233 /// A [`channel_update`] message to be sent to or received from a peer.
1235 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1236 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1237 pub struct ChannelUpdate {
1238 /// A signature of the channel update
1239 pub signature: Signature,
1240 /// The actual channel update
1241 pub contents: UnsignedChannelUpdate,
1244 /// A [`query_channel_range`] message is used to query a peer for channel
1245 /// UTXOs in a range of blocks. The recipient of a query makes a best
1246 /// effort to reply to the query using one or more [`ReplyChannelRange`]
1249 /// [`query_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1250 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1251 pub struct QueryChannelRange {
1252 /// The genesis hash of the blockchain being queried
1253 pub chain_hash: ChainHash,
1254 /// The height of the first block for the channel UTXOs being queried
1255 pub first_blocknum: u32,
1256 /// The number of blocks to include in the query results
1257 pub number_of_blocks: u32,
1260 /// A [`reply_channel_range`] message is a reply to a [`QueryChannelRange`]
1263 /// Multiple `reply_channel_range` messages can be sent in reply
1264 /// to a single [`QueryChannelRange`] message. The query recipient makes a
1265 /// best effort to respond based on their local network view which may
1266 /// not be a perfect view of the network. The `short_channel_id`s in the
1267 /// reply are encoded. We only support `encoding_type=0` uncompressed
1268 /// serialization and do not support `encoding_type=1` zlib serialization.
1270 /// [`reply_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1271 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1272 pub struct ReplyChannelRange {
1273 /// The genesis hash of the blockchain being queried
1274 pub chain_hash: ChainHash,
1275 /// The height of the first block in the range of the reply
1276 pub first_blocknum: u32,
1277 /// The number of blocks included in the range of the reply
1278 pub number_of_blocks: u32,
1279 /// True when this is the final reply for a query
1280 pub sync_complete: bool,
1281 /// The `short_channel_id`s in the channel range
1282 pub short_channel_ids: Vec<u64>,
1285 /// A [`query_short_channel_ids`] message is used to query a peer for
1286 /// routing gossip messages related to one or more `short_channel_id`s.
1288 /// The query recipient will reply with the latest, if available,
1289 /// [`ChannelAnnouncement`], [`ChannelUpdate`] and [`NodeAnnouncement`] messages
1290 /// it maintains for the requested `short_channel_id`s followed by a
1291 /// [`ReplyShortChannelIdsEnd`] message. The `short_channel_id`s sent in
1292 /// this query are encoded. We only support `encoding_type=0` uncompressed
1293 /// serialization and do not support `encoding_type=1` zlib serialization.
1295 /// [`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
1296 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1297 pub struct QueryShortChannelIds {
1298 /// The genesis hash of the blockchain being queried
1299 pub chain_hash: ChainHash,
1300 /// The short_channel_ids that are being queried
1301 pub short_channel_ids: Vec<u64>,
1304 /// A [`reply_short_channel_ids_end`] message is sent as a reply to a
1305 /// message. The query recipient makes a best
1306 /// effort to respond based on their local network view which may not be
1307 /// a perfect view of the network.
1309 /// [`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
1310 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1311 pub struct ReplyShortChannelIdsEnd {
1312 /// The genesis hash of the blockchain that was queried
1313 pub chain_hash: ChainHash,
1314 /// Indicates if the query recipient maintains up-to-date channel
1315 /// information for the `chain_hash`
1316 pub full_information: bool,
1319 /// A [`gossip_timestamp_filter`] message is used by a node to request
1320 /// gossip relay for messages in the requested time range when the
1321 /// `gossip_queries` feature has been negotiated.
1323 /// [`gossip_timestamp_filter`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-gossip_timestamp_filter-message
1324 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1325 pub struct GossipTimestampFilter {
1326 /// The genesis hash of the blockchain for channel and node information
1327 pub chain_hash: ChainHash,
1328 /// The starting unix timestamp
1329 pub first_timestamp: u32,
1330 /// The range of information in seconds
1331 pub timestamp_range: u32,
1334 /// Encoding type for data compression of collections in gossip queries.
1336 /// We do not support `encoding_type=1` zlib serialization [defined in BOLT
1337 /// #7](https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#query-messages).
1339 Uncompressed = 0x00,
1342 /// Used to put an error message in a [`LightningError`].
1343 #[derive(Clone, Debug, Hash, PartialEq)]
1344 pub enum ErrorAction {
1345 /// The peer took some action which made us think they were useless. Disconnect them.
1347 /// An error message which we should make an effort to send before we disconnect.
1348 msg: Option<ErrorMessage>
1350 /// The peer did something incorrect. Tell them without closing any channels and disconnect them.
1351 DisconnectPeerWithWarning {
1352 /// A warning message which we should make an effort to send before we disconnect.
1353 msg: WarningMessage,
1355 /// The peer did something harmless that we weren't able to process, just log and ignore
1356 // New code should *not* use this. New code must use IgnoreAndLog, below!
1358 /// The peer did something harmless that we weren't able to meaningfully process.
1359 /// If the error is logged, log it at the given level.
1360 IgnoreAndLog(logger::Level),
1361 /// The peer provided us with a gossip message which we'd already seen. In most cases this
1362 /// should be ignored, but it may result in the message being forwarded if it is a duplicate of
1363 /// our own channel announcements.
1364 IgnoreDuplicateGossip,
1365 /// The peer did something incorrect. Tell them.
1367 /// The message to send.
1370 /// The peer did something incorrect. Tell them without closing any channels.
1371 SendWarningMessage {
1372 /// The message to send.
1373 msg: WarningMessage,
1374 /// The peer may have done something harmless that we weren't able to meaningfully process,
1375 /// though we should still tell them about it.
1376 /// If this event is logged, log it at the given level.
1377 log_level: logger::Level,
1381 /// An Err type for failure to process messages.
1382 #[derive(Clone, Debug)]
1383 pub struct LightningError {
1384 /// A human-readable message describing the error
1386 /// The action which should be taken against the offending peer.
1387 pub action: ErrorAction,
1390 /// Struct used to return values from [`RevokeAndACK`] messages, containing a bunch of commitment
1391 /// transaction updates if they were pending.
1392 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1393 pub struct CommitmentUpdate {
1394 /// `update_add_htlc` messages which should be sent
1395 pub update_add_htlcs: Vec<UpdateAddHTLC>,
1396 /// `update_fulfill_htlc` messages which should be sent
1397 pub update_fulfill_htlcs: Vec<UpdateFulfillHTLC>,
1398 /// `update_fail_htlc` messages which should be sent
1399 pub update_fail_htlcs: Vec<UpdateFailHTLC>,
1400 /// `update_fail_malformed_htlc` messages which should be sent
1401 pub update_fail_malformed_htlcs: Vec<UpdateFailMalformedHTLC>,
1402 /// An `update_fee` message which should be sent
1403 pub update_fee: Option<UpdateFee>,
1404 /// A `commitment_signed` message which should be sent
1405 pub commitment_signed: CommitmentSigned,
1408 /// A trait to describe an object which can receive channel messages.
1410 /// Messages MAY be called in parallel when they originate from different `their_node_ids`, however
1411 /// they MUST NOT be called in parallel when the two calls have the same `their_node_id`.
1412 pub trait ChannelMessageHandler : MessageSendEventsProvider {
1414 /// Handle an incoming `open_channel` message from the given peer.
1415 fn handle_open_channel(&self, their_node_id: &PublicKey, msg: &OpenChannel);
1416 /// Handle an incoming `open_channel2` message from the given peer.
1417 fn handle_open_channel_v2(&self, their_node_id: &PublicKey, msg: &OpenChannelV2);
1418 /// Handle an incoming `accept_channel` message from the given peer.
1419 fn handle_accept_channel(&self, their_node_id: &PublicKey, msg: &AcceptChannel);
1420 /// Handle an incoming `accept_channel2` message from the given peer.
1421 fn handle_accept_channel_v2(&self, their_node_id: &PublicKey, msg: &AcceptChannelV2);
1422 /// Handle an incoming `funding_created` message from the given peer.
1423 fn handle_funding_created(&self, their_node_id: &PublicKey, msg: &FundingCreated);
1424 /// Handle an incoming `funding_signed` message from the given peer.
1425 fn handle_funding_signed(&self, their_node_id: &PublicKey, msg: &FundingSigned);
1426 /// Handle an incoming `channel_ready` message from the given peer.
1427 fn handle_channel_ready(&self, their_node_id: &PublicKey, msg: &ChannelReady);
1430 /// Handle an incoming `shutdown` message from the given peer.
1431 fn handle_shutdown(&self, their_node_id: &PublicKey, msg: &Shutdown);
1432 /// Handle an incoming `closing_signed` message from the given peer.
1433 fn handle_closing_signed(&self, their_node_id: &PublicKey, msg: &ClosingSigned);
1436 /// Handle an incoming `stfu` message from the given peer.
1437 fn handle_stfu(&self, their_node_id: &PublicKey, msg: &Stfu);
1440 /// Handle an incoming `splice` message from the given peer.
1441 fn handle_splice(&self, their_node_id: &PublicKey, msg: &Splice);
1442 /// Handle an incoming `splice_ack` message from the given peer.
1443 fn handle_splice_ack(&self, their_node_id: &PublicKey, msg: &SpliceAck);
1444 /// Handle an incoming `splice_locked` message from the given peer.
1445 fn handle_splice_locked(&self, their_node_id: &PublicKey, msg: &SpliceLocked);
1447 // Interactive channel construction
1448 /// Handle an incoming `tx_add_input message` from the given peer.
1449 fn handle_tx_add_input(&self, their_node_id: &PublicKey, msg: &TxAddInput);
1450 /// Handle an incoming `tx_add_output` message from the given peer.
1451 fn handle_tx_add_output(&self, their_node_id: &PublicKey, msg: &TxAddOutput);
1452 /// Handle an incoming `tx_remove_input` message from the given peer.
1453 fn handle_tx_remove_input(&self, their_node_id: &PublicKey, msg: &TxRemoveInput);
1454 /// Handle an incoming `tx_remove_output` message from the given peer.
1455 fn handle_tx_remove_output(&self, their_node_id: &PublicKey, msg: &TxRemoveOutput);
1456 /// Handle an incoming `tx_complete message` from the given peer.
1457 fn handle_tx_complete(&self, their_node_id: &PublicKey, msg: &TxComplete);
1458 /// Handle an incoming `tx_signatures` message from the given peer.
1459 fn handle_tx_signatures(&self, their_node_id: &PublicKey, msg: &TxSignatures);
1460 /// Handle an incoming `tx_init_rbf` message from the given peer.
1461 fn handle_tx_init_rbf(&self, their_node_id: &PublicKey, msg: &TxInitRbf);
1462 /// Handle an incoming `tx_ack_rbf` message from the given peer.
1463 fn handle_tx_ack_rbf(&self, their_node_id: &PublicKey, msg: &TxAckRbf);
1464 /// Handle an incoming `tx_abort message` from the given peer.
1465 fn handle_tx_abort(&self, their_node_id: &PublicKey, msg: &TxAbort);
1468 /// Handle an incoming `update_add_htlc` message from the given peer.
1469 fn handle_update_add_htlc(&self, their_node_id: &PublicKey, msg: &UpdateAddHTLC);
1470 /// Handle an incoming `update_fulfill_htlc` message from the given peer.
1471 fn handle_update_fulfill_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFulfillHTLC);
1472 /// Handle an incoming `update_fail_htlc` message from the given peer.
1473 fn handle_update_fail_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailHTLC);
1474 /// Handle an incoming `update_fail_malformed_htlc` message from the given peer.
1475 fn handle_update_fail_malformed_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailMalformedHTLC);
1476 /// Handle an incoming `commitment_signed` message from the given peer.
1477 fn handle_commitment_signed(&self, their_node_id: &PublicKey, msg: &CommitmentSigned);
1478 /// Handle an incoming `revoke_and_ack` message from the given peer.
1479 fn handle_revoke_and_ack(&self, their_node_id: &PublicKey, msg: &RevokeAndACK);
1481 /// Handle an incoming `update_fee` message from the given peer.
1482 fn handle_update_fee(&self, their_node_id: &PublicKey, msg: &UpdateFee);
1484 // Channel-to-announce:
1485 /// Handle an incoming `announcement_signatures` message from the given peer.
1486 fn handle_announcement_signatures(&self, their_node_id: &PublicKey, msg: &AnnouncementSignatures);
1488 // Connection loss/reestablish:
1489 /// Indicates a connection to the peer failed/an existing connection was lost.
1490 fn peer_disconnected(&self, their_node_id: &PublicKey);
1492 /// Handle a peer reconnecting, possibly generating `channel_reestablish` message(s).
1494 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1495 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1496 /// message handlers may still wish to communicate with this peer.
1497 fn peer_connected(&self, their_node_id: &PublicKey, msg: &Init, inbound: bool) -> Result<(), ()>;
1498 /// Handle an incoming `channel_reestablish` message from the given peer.
1499 fn handle_channel_reestablish(&self, their_node_id: &PublicKey, msg: &ChannelReestablish);
1501 /// Handle an incoming `channel_update` message from the given peer.
1502 fn handle_channel_update(&self, their_node_id: &PublicKey, msg: &ChannelUpdate);
1505 /// Handle an incoming `error` message from the given peer.
1506 fn handle_error(&self, their_node_id: &PublicKey, msg: &ErrorMessage);
1508 // Handler information:
1509 /// Gets the node feature flags which this handler itself supports. All available handlers are
1510 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1511 /// which are broadcasted in our [`NodeAnnouncement`] message.
1512 fn provided_node_features(&self) -> NodeFeatures;
1514 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1515 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1516 /// which are sent in our [`Init`] message.
1518 /// Note that this method is called before [`Self::peer_connected`].
1519 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1521 /// Gets the chain hashes for this `ChannelMessageHandler` indicating which chains it supports.
1523 /// If it's `None`, then no particular network chain hash compatibility will be enforced when
1524 /// connecting to peers.
1525 fn get_chain_hashes(&self) -> Option<Vec<ChainHash>>;
1528 /// A trait to describe an object which can receive routing messages.
1530 /// # Implementor DoS Warnings
1532 /// For messages enabled with the `gossip_queries` feature there are potential DoS vectors when
1533 /// handling inbound queries. Implementors using an on-disk network graph should be aware of
1534 /// repeated disk I/O for queries accessing different parts of the network graph.
1535 pub trait RoutingMessageHandler : MessageSendEventsProvider {
1536 /// Handle an incoming `node_announcement` message, returning `true` if it should be forwarded on,
1537 /// `false` or returning an `Err` otherwise.
1538 fn handle_node_announcement(&self, msg: &NodeAnnouncement) -> Result<bool, LightningError>;
1539 /// Handle a `channel_announcement` message, returning `true` if it should be forwarded on, `false`
1540 /// or returning an `Err` otherwise.
1541 fn handle_channel_announcement(&self, msg: &ChannelAnnouncement) -> Result<bool, LightningError>;
1542 /// Handle an incoming `channel_update` message, returning true if it should be forwarded on,
1543 /// `false` or returning an `Err` otherwise.
1544 fn handle_channel_update(&self, msg: &ChannelUpdate) -> Result<bool, LightningError>;
1545 /// Gets channel announcements and updates required to dump our routing table to a remote node,
1546 /// starting at the `short_channel_id` indicated by `starting_point` and including announcements
1547 /// for a single channel.
1548 fn get_next_channel_announcement(&self, starting_point: u64) -> Option<(ChannelAnnouncement, Option<ChannelUpdate>, Option<ChannelUpdate>)>;
1549 /// Gets a node announcement required to dump our routing table to a remote node, starting at
1550 /// the node *after* the provided pubkey and including up to one announcement immediately
1551 /// higher (as defined by `<PublicKey as Ord>::cmp`) than `starting_point`.
1552 /// If `None` is provided for `starting_point`, we start at the first node.
1553 fn get_next_node_announcement(&self, starting_point: Option<&NodeId>) -> Option<NodeAnnouncement>;
1554 /// Called when a connection is established with a peer. This can be used to
1555 /// perform routing table synchronization using a strategy defined by the
1558 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1559 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1560 /// message handlers may still wish to communicate with this peer.
1561 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1562 /// Handles the reply of a query we initiated to learn about channels
1563 /// for a given range of blocks. We can expect to receive one or more
1564 /// replies to a single query.
1565 fn handle_reply_channel_range(&self, their_node_id: &PublicKey, msg: ReplyChannelRange) -> Result<(), LightningError>;
1566 /// Handles the reply of a query we initiated asking for routing gossip
1567 /// messages for a list of channels. We should receive this message when
1568 /// a node has completed its best effort to send us the pertaining routing
1569 /// gossip messages.
1570 fn handle_reply_short_channel_ids_end(&self, their_node_id: &PublicKey, msg: ReplyShortChannelIdsEnd) -> Result<(), LightningError>;
1571 /// Handles when a peer asks us to send a list of `short_channel_id`s
1572 /// for the requested range of blocks.
1573 fn handle_query_channel_range(&self, their_node_id: &PublicKey, msg: QueryChannelRange) -> Result<(), LightningError>;
1574 /// Handles when a peer asks us to send routing gossip messages for a
1575 /// list of `short_channel_id`s.
1576 fn handle_query_short_channel_ids(&self, their_node_id: &PublicKey, msg: QueryShortChannelIds) -> Result<(), LightningError>;
1578 // Handler queueing status:
1579 /// Indicates that there are a large number of [`ChannelAnnouncement`] (or other) messages
1580 /// pending some async action. While there is no guarantee of the rate of future messages, the
1581 /// caller should seek to reduce the rate of new gossip messages handled, especially
1582 /// [`ChannelAnnouncement`]s.
1583 fn processing_queue_high(&self) -> bool;
1585 // Handler information:
1586 /// Gets the node feature flags which this handler itself supports. All available handlers are
1587 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1588 /// which are broadcasted in our [`NodeAnnouncement`] message.
1589 fn provided_node_features(&self) -> NodeFeatures;
1590 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1591 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1592 /// which are sent in our [`Init`] message.
1594 /// Note that this method is called before [`Self::peer_connected`].
1595 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1598 /// A handler for received [`OnionMessage`]s and for providing generated ones to send.
1599 pub trait OnionMessageHandler: EventsProvider {
1600 /// Handle an incoming `onion_message` message from the given peer.
1601 fn handle_onion_message(&self, peer_node_id: &PublicKey, msg: &OnionMessage);
1603 /// Returns the next pending onion message for the peer with the given node id.
1604 fn next_onion_message_for_peer(&self, peer_node_id: PublicKey) -> Option<OnionMessage>;
1606 /// Called when a connection is established with a peer. Can be used to track which peers
1607 /// advertise onion message support and are online.
1609 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1610 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1611 /// message handlers may still wish to communicate with this peer.
1612 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1614 /// Indicates a connection to the peer failed/an existing connection was lost. Allows handlers to
1615 /// drop and refuse to forward onion messages to this peer.
1616 fn peer_disconnected(&self, their_node_id: &PublicKey);
1618 /// Performs actions that should happen roughly every ten seconds after startup. Allows handlers
1619 /// to drop any buffered onion messages intended for prospective peers.
1620 fn timer_tick_occurred(&self);
1622 // Handler information:
1623 /// Gets the node feature flags which this handler itself supports. All available handlers are
1624 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1625 /// which are broadcasted in our [`NodeAnnouncement`] message.
1626 fn provided_node_features(&self) -> NodeFeatures;
1628 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1629 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1630 /// which are sent in our [`Init`] message.
1632 /// Note that this method is called before [`Self::peer_connected`].
1633 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1637 #[cfg_attr(test, derive(Debug, PartialEq))]
1638 /// Information communicated in the onion to the recipient for multi-part tracking and proof that
1639 /// the payment is associated with an invoice.
1640 pub struct FinalOnionHopData {
1641 /// When sending a multi-part payment, this secret is used to identify a payment across HTLCs.
1642 /// Because it is generated by the recipient and included in the invoice, it also provides
1643 /// proof to the recipient that the payment was sent by someone with the generated invoice.
1644 pub payment_secret: PaymentSecret,
1645 /// The intended total amount that this payment is for.
1647 /// Message serialization may panic if this value is more than 21 million Bitcoin.
1648 pub total_msat: u64,
1651 mod fuzzy_internal_msgs {
1652 use bitcoin::secp256k1::PublicKey;
1653 use crate::blinded_path::payment::{PaymentConstraints, PaymentRelay};
1654 use crate::prelude::*;
1655 use crate::ln::{PaymentPreimage, PaymentSecret};
1656 use crate::ln::features::BlindedHopFeatures;
1657 use super::{FinalOnionHopData, TrampolineOnionPacket};
1659 // These types aren't intended to be pub, but are exposed for direct fuzzing (as we deserialize
1660 // them from untrusted input):
1662 pub enum InboundOnionPayload {
1664 short_channel_id: u64,
1665 /// The value, in msat, of the payment after this hop's fee is deducted.
1666 amt_to_forward: u64,
1667 outgoing_cltv_value: u32,
1670 payment_data: Option<FinalOnionHopData>,
1671 payment_metadata: Option<Vec<u8>>,
1672 keysend_preimage: Option<PaymentPreimage>,
1673 custom_tlvs: Vec<(u64, Vec<u8>)>,
1674 sender_intended_htlc_amt_msat: u64,
1675 cltv_expiry_height: u32,
1678 short_channel_id: u64,
1679 payment_relay: PaymentRelay,
1680 payment_constraints: PaymentConstraints,
1681 features: BlindedHopFeatures,
1682 intro_node_blinding_point: Option<PublicKey>,
1685 sender_intended_htlc_amt_msat: u64,
1687 cltv_expiry_height: u32,
1688 payment_secret: PaymentSecret,
1689 payment_constraints: PaymentConstraints,
1690 intro_node_blinding_point: Option<PublicKey>,
1694 pub(crate) enum OutboundOnionPayload {
1696 short_channel_id: u64,
1697 /// The value, in msat, of the payment after this hop's fee is deducted.
1698 amt_to_forward: u64,
1699 outgoing_cltv_value: u32,
1702 TrampolineEntrypoint {
1703 amt_to_forward: u64,
1704 outgoing_cltv_value: u32,
1705 multipath_trampoline_data: Option<FinalOnionHopData>,
1706 trampoline_packet: TrampolineOnionPacket,
1709 payment_data: Option<FinalOnionHopData>,
1710 payment_metadata: Option<Vec<u8>>,
1711 keysend_preimage: Option<PaymentPreimage>,
1712 custom_tlvs: Vec<(u64, Vec<u8>)>,
1713 sender_intended_htlc_amt_msat: u64,
1714 cltv_expiry_height: u32,
1717 encrypted_tlvs: Vec<u8>,
1718 intro_node_blinding_point: Option<PublicKey>,
1721 sender_intended_htlc_amt_msat: u64,
1723 cltv_expiry_height: u32,
1724 encrypted_tlvs: Vec<u8>,
1725 intro_node_blinding_point: Option<PublicKey>, // Set if the introduction node of the blinded path is the final node
1729 pub struct DecodedOnionErrorPacket {
1730 pub(crate) hmac: [u8; 32],
1731 pub(crate) failuremsg: Vec<u8>,
1732 pub(crate) pad: Vec<u8>,
1736 pub use self::fuzzy_internal_msgs::*;
1737 #[cfg(not(fuzzing))]
1738 pub(crate) use self::fuzzy_internal_msgs::*;
1740 /// BOLT 4 onion packet including hop data for the next peer.
1741 #[derive(Clone, Hash, PartialEq, Eq)]
1742 pub struct OnionPacket {
1743 /// BOLT 4 version number.
1745 /// In order to ensure we always return an error on onion decode in compliance with [BOLT
1746 /// #4](https://github.com/lightning/bolts/blob/master/04-onion-routing.md), we have to
1747 /// deserialize `OnionPacket`s contained in [`UpdateAddHTLC`] messages even if the ephemeral
1748 /// public key (here) is bogus, so we hold a [`Result`] instead of a [`PublicKey`] as we'd
1750 pub public_key: Result<PublicKey, secp256k1::Error>,
1751 /// 1300 bytes encrypted payload for the next hop.
1752 pub hop_data: [u8; 20*65],
1753 /// HMAC to verify the integrity of hop_data.
1757 impl onion_utils::Packet for OnionPacket {
1758 type Data = onion_utils::FixedSizeOnionPacket;
1759 fn new(pubkey: PublicKey, hop_data: onion_utils::FixedSizeOnionPacket, hmac: [u8; 32]) -> Self {
1762 public_key: Ok(pubkey),
1763 hop_data: hop_data.0,
1769 impl fmt::Debug for OnionPacket {
1770 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1771 f.write_fmt(format_args!("OnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
1775 /// BOLT 4 onion packet including hop data for the next peer.
1776 #[derive(Clone, Hash, PartialEq, Eq)]
1777 pub struct TrampolineOnionPacket {
1778 /// Bolt 04 version number
1780 /// A random sepc256k1 point, used to build the ECDH shared secret to decrypt hop_data
1781 pub public_key: PublicKey,
1782 /// Encrypted payload for the next hop
1784 // Unlike the onion packets used for payments, Trampoline onion packets have to be shorter than
1785 // 1300 bytes. The expected default is 650 bytes.
1786 // TODO: if 650 ends up being the most common size, optimize this to be:
1787 // enum { ThirteenHundred([u8; 650]), VarLen(Vec<u8>) }
1788 pub hop_data: Vec<u8>,
1789 /// HMAC to verify the integrity of hop_data
1793 impl onion_utils::Packet for TrampolineOnionPacket {
1794 type Data = Vec<u8>;
1795 fn new(public_key: PublicKey, hop_data: Vec<u8>, hmac: [u8; 32]) -> Self {
1805 impl Writeable for TrampolineOnionPacket {
1806 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1807 self.version.write(w)?;
1808 self.public_key.write(w)?;
1809 w.write_all(&self.hop_data)?;
1810 self.hmac.write(w)?;
1815 impl Debug for TrampolineOnionPacket {
1816 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1817 f.write_fmt(format_args!("TrampolineOnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
1821 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1822 pub(crate) struct OnionErrorPacket {
1823 // This really should be a constant size slice, but the spec lets these things be up to 128KB?
1824 // (TODO) We limit it in decode to much lower...
1825 pub(crate) data: Vec<u8>,
1828 impl fmt::Display for DecodeError {
1829 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1831 DecodeError::UnknownVersion => f.write_str("Unknown realm byte in Onion packet"),
1832 DecodeError::UnknownRequiredFeature => f.write_str("Unknown required feature preventing decode"),
1833 DecodeError::InvalidValue => f.write_str("Nonsense bytes didn't map to the type they were interpreted as"),
1834 DecodeError::ShortRead => f.write_str("Packet extended beyond the provided bytes"),
1835 DecodeError::BadLengthDescriptor => f.write_str("A length descriptor in the packet didn't describe the later data correctly"),
1836 DecodeError::Io(ref e) => fmt::Debug::fmt(e, f),
1837 DecodeError::UnsupportedCompression => f.write_str("We don't support receiving messages with zlib-compressed fields"),
1842 impl From<io::Error> for DecodeError {
1843 fn from(e: io::Error) -> Self {
1844 if e.kind() == io::ErrorKind::UnexpectedEof {
1845 DecodeError::ShortRead
1847 DecodeError::Io(e.kind())
1852 impl Writeable for AcceptChannel {
1853 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1854 self.common_fields.temporary_channel_id.write(w)?;
1855 self.common_fields.dust_limit_satoshis.write(w)?;
1856 self.common_fields.max_htlc_value_in_flight_msat.write(w)?;
1857 self.channel_reserve_satoshis.write(w)?;
1858 self.common_fields.htlc_minimum_msat.write(w)?;
1859 self.common_fields.minimum_depth.write(w)?;
1860 self.common_fields.to_self_delay.write(w)?;
1861 self.common_fields.max_accepted_htlcs.write(w)?;
1862 self.common_fields.funding_pubkey.write(w)?;
1863 self.common_fields.revocation_basepoint.write(w)?;
1864 self.common_fields.payment_basepoint.write(w)?;
1865 self.common_fields.delayed_payment_basepoint.write(w)?;
1866 self.common_fields.htlc_basepoint.write(w)?;
1867 self.common_fields.first_per_commitment_point.write(w)?;
1868 #[cfg(not(taproot))]
1869 encode_tlv_stream!(w, {
1870 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
1871 (1, self.common_fields.channel_type, option),
1874 encode_tlv_stream!(w, {
1875 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
1876 (1, self.common_fields.channel_type, option),
1877 (4, self.next_local_nonce, option),
1883 impl Readable for AcceptChannel {
1884 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1885 let temporary_channel_id: ChannelId = Readable::read(r)?;
1886 let dust_limit_satoshis: u64 = Readable::read(r)?;
1887 let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;
1888 let channel_reserve_satoshis: u64 = Readable::read(r)?;
1889 let htlc_minimum_msat: u64 = Readable::read(r)?;
1890 let minimum_depth: u32 = Readable::read(r)?;
1891 let to_self_delay: u16 = Readable::read(r)?;
1892 let max_accepted_htlcs: u16 = Readable::read(r)?;
1893 let funding_pubkey: PublicKey = Readable::read(r)?;
1894 let revocation_basepoint: PublicKey = Readable::read(r)?;
1895 let payment_basepoint: PublicKey = Readable::read(r)?;
1896 let delayed_payment_basepoint: PublicKey = Readable::read(r)?;
1897 let htlc_basepoint: PublicKey = Readable::read(r)?;
1898 let first_per_commitment_point: PublicKey = Readable::read(r)?;
1900 let mut shutdown_scriptpubkey: Option<ScriptBuf> = None;
1901 let mut channel_type: Option<ChannelTypeFeatures> = None;
1902 #[cfg(not(taproot))]
1903 decode_tlv_stream!(r, {
1904 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
1905 (1, channel_type, option),
1908 let mut next_local_nonce: Option<musig2::types::PublicNonce> = None;
1910 decode_tlv_stream!(r, {
1911 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
1912 (1, channel_type, option),
1913 (4, next_local_nonce, option),
1917 common_fields: CommonAcceptChannelFields {
1918 temporary_channel_id,
1919 dust_limit_satoshis,
1920 max_htlc_value_in_flight_msat,
1926 revocation_basepoint,
1928 delayed_payment_basepoint,
1930 first_per_commitment_point,
1931 shutdown_scriptpubkey,
1934 channel_reserve_satoshis,
1941 impl Writeable for AcceptChannelV2 {
1942 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1943 self.common_fields.temporary_channel_id.write(w)?;
1944 self.funding_satoshis.write(w)?;
1945 self.common_fields.dust_limit_satoshis.write(w)?;
1946 self.common_fields.max_htlc_value_in_flight_msat.write(w)?;
1947 self.common_fields.htlc_minimum_msat.write(w)?;
1948 self.common_fields.minimum_depth.write(w)?;
1949 self.common_fields.to_self_delay.write(w)?;
1950 self.common_fields.max_accepted_htlcs.write(w)?;
1951 self.common_fields.funding_pubkey.write(w)?;
1952 self.common_fields.revocation_basepoint.write(w)?;
1953 self.common_fields.payment_basepoint.write(w)?;
1954 self.common_fields.delayed_payment_basepoint.write(w)?;
1955 self.common_fields.htlc_basepoint.write(w)?;
1956 self.common_fields.first_per_commitment_point.write(w)?;
1957 self.second_per_commitment_point.write(w)?;
1959 encode_tlv_stream!(w, {
1960 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
1961 (1, self.common_fields.channel_type, option),
1962 (2, self.require_confirmed_inputs, option),
1968 impl Readable for AcceptChannelV2 {
1969 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1970 let temporary_channel_id: ChannelId = Readable::read(r)?;
1971 let funding_satoshis: u64 = Readable::read(r)?;
1972 let dust_limit_satoshis: u64 = Readable::read(r)?;
1973 let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;
1974 let htlc_minimum_msat: u64 = Readable::read(r)?;
1975 let minimum_depth: u32 = Readable::read(r)?;
1976 let to_self_delay: u16 = Readable::read(r)?;
1977 let max_accepted_htlcs: u16 = Readable::read(r)?;
1978 let funding_pubkey: PublicKey = Readable::read(r)?;
1979 let revocation_basepoint: PublicKey = Readable::read(r)?;
1980 let payment_basepoint: PublicKey = Readable::read(r)?;
1981 let delayed_payment_basepoint: PublicKey = Readable::read(r)?;
1982 let htlc_basepoint: PublicKey = Readable::read(r)?;
1983 let first_per_commitment_point: PublicKey = Readable::read(r)?;
1984 let second_per_commitment_point: PublicKey = Readable::read(r)?;
1986 let mut shutdown_scriptpubkey: Option<ScriptBuf> = None;
1987 let mut channel_type: Option<ChannelTypeFeatures> = None;
1988 let mut require_confirmed_inputs: Option<()> = None;
1989 decode_tlv_stream!(r, {
1990 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
1991 (1, channel_type, option),
1992 (2, require_confirmed_inputs, option),
1995 Ok(AcceptChannelV2 {
1996 common_fields: CommonAcceptChannelFields {
1997 temporary_channel_id,
1998 dust_limit_satoshis,
1999 max_htlc_value_in_flight_msat,
2005 revocation_basepoint,
2007 delayed_payment_basepoint,
2009 first_per_commitment_point,
2010 shutdown_scriptpubkey,
2014 second_per_commitment_point,
2015 require_confirmed_inputs,
2020 impl_writeable_msg!(Stfu, {
2025 impl_writeable_msg!(Splice, {
2029 funding_feerate_perkw,
2034 impl_writeable_msg!(SpliceAck, {
2041 impl_writeable_msg!(SpliceLocked, {
2045 impl_writeable_msg!(TxAddInput, {
2053 impl_writeable_msg!(TxAddOutput, {
2060 impl_writeable_msg!(TxRemoveInput, {
2065 impl_writeable_msg!(TxRemoveOutput, {
2070 impl_writeable_msg!(TxComplete, {
2074 impl_writeable_msg!(TxSignatures, {
2080 impl_writeable_msg!(TxInitRbf, {
2083 feerate_sat_per_1000_weight,
2085 (0, funding_output_contribution, option),
2088 impl_writeable_msg!(TxAckRbf, {
2091 (0, funding_output_contribution, option),
2094 impl_writeable_msg!(TxAbort, {
2099 impl_writeable_msg!(AnnouncementSignatures, {
2106 impl_writeable_msg!(ChannelReestablish, {
2108 next_local_commitment_number,
2109 next_remote_commitment_number,
2110 your_last_per_commitment_secret,
2111 my_current_per_commitment_point,
2113 (0, next_funding_txid, option),
2116 impl_writeable_msg!(ClosingSigned,
2117 { channel_id, fee_satoshis, signature },
2118 { (1, fee_range, option) }
2121 impl_writeable!(ClosingSignedFeeRange, {
2126 #[cfg(not(taproot))]
2127 impl_writeable_msg!(CommitmentSigned, {
2134 impl_writeable_msg!(CommitmentSigned, {
2139 (2, partial_signature_with_nonce, option)
2142 impl_writeable!(DecodedOnionErrorPacket, {
2148 #[cfg(not(taproot))]
2149 impl_writeable_msg!(FundingCreated, {
2150 temporary_channel_id,
2152 funding_output_index,
2156 impl_writeable_msg!(FundingCreated, {
2157 temporary_channel_id,
2159 funding_output_index,
2162 (2, partial_signature_with_nonce, option),
2163 (4, next_local_nonce, option)
2166 #[cfg(not(taproot))]
2167 impl_writeable_msg!(FundingSigned, {
2173 impl_writeable_msg!(FundingSigned, {
2177 (2, partial_signature_with_nonce, option)
2180 impl_writeable_msg!(ChannelReady, {
2182 next_per_commitment_point,
2184 (1, short_channel_id_alias, option),
2187 impl Writeable for Init {
2188 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2189 // global_features gets the bottom 13 bits of our features, and local_features gets all of
2190 // our relevant feature bits. This keeps us compatible with old nodes.
2191 self.features.write_up_to_13(w)?;
2192 self.features.write(w)?;
2193 encode_tlv_stream!(w, {
2194 (1, self.networks.as_ref().map(|n| WithoutLength(n)), option),
2195 (3, self.remote_network_address, option),
2201 impl Readable for Init {
2202 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2203 let global_features: InitFeatures = Readable::read(r)?;
2204 let features: InitFeatures = Readable::read(r)?;
2205 let mut remote_network_address: Option<SocketAddress> = None;
2206 let mut networks: Option<WithoutLength<Vec<ChainHash>>> = None;
2207 decode_tlv_stream!(r, {
2208 (1, networks, option),
2209 (3, remote_network_address, option)
2212 features: features | global_features,
2213 networks: networks.map(|n| n.0),
2214 remote_network_address,
2219 impl Writeable for OpenChannel {
2220 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2221 self.common_fields.chain_hash.write(w)?;
2222 self.common_fields.temporary_channel_id.write(w)?;
2223 self.common_fields.funding_satoshis.write(w)?;
2224 self.push_msat.write(w)?;
2225 self.common_fields.dust_limit_satoshis.write(w)?;
2226 self.common_fields.max_htlc_value_in_flight_msat.write(w)?;
2227 self.channel_reserve_satoshis.write(w)?;
2228 self.common_fields.htlc_minimum_msat.write(w)?;
2229 self.common_fields.commitment_feerate_sat_per_1000_weight.write(w)?;
2230 self.common_fields.to_self_delay.write(w)?;
2231 self.common_fields.max_accepted_htlcs.write(w)?;
2232 self.common_fields.funding_pubkey.write(w)?;
2233 self.common_fields.revocation_basepoint.write(w)?;
2234 self.common_fields.payment_basepoint.write(w)?;
2235 self.common_fields.delayed_payment_basepoint.write(w)?;
2236 self.common_fields.htlc_basepoint.write(w)?;
2237 self.common_fields.first_per_commitment_point.write(w)?;
2238 self.common_fields.channel_flags.write(w)?;
2239 encode_tlv_stream!(w, {
2240 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
2241 (1, self.common_fields.channel_type, option),
2247 impl Readable for OpenChannel {
2248 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2249 let chain_hash: ChainHash = Readable::read(r)?;
2250 let temporary_channel_id: ChannelId = Readable::read(r)?;
2251 let funding_satoshis: u64 = Readable::read(r)?;
2252 let push_msat: u64 = Readable::read(r)?;
2253 let dust_limit_satoshis: u64 = Readable::read(r)?;
2254 let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;
2255 let channel_reserve_satoshis: u64 = Readable::read(r)?;
2256 let htlc_minimum_msat: u64 = Readable::read(r)?;
2257 let commitment_feerate_sat_per_1000_weight: u32 = Readable::read(r)?;
2258 let to_self_delay: u16 = Readable::read(r)?;
2259 let max_accepted_htlcs: u16 = Readable::read(r)?;
2260 let funding_pubkey: PublicKey = Readable::read(r)?;
2261 let revocation_basepoint: PublicKey = Readable::read(r)?;
2262 let payment_basepoint: PublicKey = Readable::read(r)?;
2263 let delayed_payment_basepoint: PublicKey = Readable::read(r)?;
2264 let htlc_basepoint: PublicKey = Readable::read(r)?;
2265 let first_per_commitment_point: PublicKey = Readable::read(r)?;
2266 let channel_flags: u8 = Readable::read(r)?;
2268 let mut shutdown_scriptpubkey: Option<ScriptBuf> = None;
2269 let mut channel_type: Option<ChannelTypeFeatures> = None;
2270 decode_tlv_stream!(r, {
2271 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
2272 (1, channel_type, option),
2275 common_fields: CommonOpenChannelFields {
2277 temporary_channel_id,
2279 dust_limit_satoshis,
2280 max_htlc_value_in_flight_msat,
2282 commitment_feerate_sat_per_1000_weight,
2286 revocation_basepoint,
2288 delayed_payment_basepoint,
2290 first_per_commitment_point,
2292 shutdown_scriptpubkey,
2296 channel_reserve_satoshis,
2301 impl Writeable for OpenChannelV2 {
2302 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2303 self.common_fields.chain_hash.write(w)?;
2304 self.common_fields.temporary_channel_id.write(w)?;
2305 self.funding_feerate_sat_per_1000_weight.write(w)?;
2306 self.common_fields.commitment_feerate_sat_per_1000_weight.write(w)?;
2307 self.common_fields.funding_satoshis.write(w)?;
2308 self.common_fields.dust_limit_satoshis.write(w)?;
2309 self.common_fields.max_htlc_value_in_flight_msat.write(w)?;
2310 self.common_fields.htlc_minimum_msat.write(w)?;
2311 self.common_fields.to_self_delay.write(w)?;
2312 self.common_fields.max_accepted_htlcs.write(w)?;
2313 self.locktime.write(w)?;
2314 self.common_fields.funding_pubkey.write(w)?;
2315 self.common_fields.revocation_basepoint.write(w)?;
2316 self.common_fields.payment_basepoint.write(w)?;
2317 self.common_fields.delayed_payment_basepoint.write(w)?;
2318 self.common_fields.htlc_basepoint.write(w)?;
2319 self.common_fields.first_per_commitment_point.write(w)?;
2320 self.second_per_commitment_point.write(w)?;
2321 self.common_fields.channel_flags.write(w)?;
2322 encode_tlv_stream!(w, {
2323 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
2324 (1, self.common_fields.channel_type, option),
2325 (2, self.require_confirmed_inputs, option),
2331 impl Readable for OpenChannelV2 {
2332 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2333 let chain_hash: ChainHash = Readable::read(r)?;
2334 let temporary_channel_id: ChannelId = Readable::read(r)?;
2335 let funding_feerate_sat_per_1000_weight: u32 = Readable::read(r)?;
2336 let commitment_feerate_sat_per_1000_weight: u32 = Readable::read(r)?;
2337 let funding_satoshis: u64 = Readable::read(r)?;
2338 let dust_limit_satoshis: u64 = Readable::read(r)?;
2339 let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;
2340 let htlc_minimum_msat: u64 = Readable::read(r)?;
2341 let to_self_delay: u16 = Readable::read(r)?;
2342 let max_accepted_htlcs: u16 = Readable::read(r)?;
2343 let locktime: u32 = Readable::read(r)?;
2344 let funding_pubkey: PublicKey = Readable::read(r)?;
2345 let revocation_basepoint: PublicKey = Readable::read(r)?;
2346 let payment_basepoint: PublicKey = Readable::read(r)?;
2347 let delayed_payment_basepoint: PublicKey = Readable::read(r)?;
2348 let htlc_basepoint: PublicKey = Readable::read(r)?;
2349 let first_per_commitment_point: PublicKey = Readable::read(r)?;
2350 let second_per_commitment_point: PublicKey = Readable::read(r)?;
2351 let channel_flags: u8 = Readable::read(r)?;
2353 let mut shutdown_scriptpubkey: Option<ScriptBuf> = None;
2354 let mut channel_type: Option<ChannelTypeFeatures> = None;
2355 let mut require_confirmed_inputs: Option<()> = None;
2356 decode_tlv_stream!(r, {
2357 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
2358 (1, channel_type, option),
2359 (2, require_confirmed_inputs, option),
2362 common_fields: CommonOpenChannelFields {
2364 temporary_channel_id,
2366 dust_limit_satoshis,
2367 max_htlc_value_in_flight_msat,
2369 commitment_feerate_sat_per_1000_weight,
2373 revocation_basepoint,
2375 delayed_payment_basepoint,
2377 first_per_commitment_point,
2379 shutdown_scriptpubkey,
2382 funding_feerate_sat_per_1000_weight,
2384 second_per_commitment_point,
2385 require_confirmed_inputs,
2390 #[cfg(not(taproot))]
2391 impl_writeable_msg!(RevokeAndACK, {
2393 per_commitment_secret,
2394 next_per_commitment_point
2398 impl_writeable_msg!(RevokeAndACK, {
2400 per_commitment_secret,
2401 next_per_commitment_point
2403 (4, next_local_nonce, option)
2406 impl_writeable_msg!(Shutdown, {
2411 impl_writeable_msg!(UpdateFailHTLC, {
2417 impl_writeable_msg!(UpdateFailMalformedHTLC, {
2424 impl_writeable_msg!(UpdateFee, {
2429 impl_writeable_msg!(UpdateFulfillHTLC, {
2435 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2436 // serialization format in a way which assumes we know the total serialized length/message end
2438 impl_writeable!(OnionErrorPacket, {
2442 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2443 // serialization format in a way which assumes we know the total serialized length/message end
2445 impl Writeable for OnionPacket {
2446 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2447 self.version.write(w)?;
2448 match self.public_key {
2449 Ok(pubkey) => pubkey.write(w)?,
2450 Err(_) => [0u8;33].write(w)?,
2452 w.write_all(&self.hop_data)?;
2453 self.hmac.write(w)?;
2458 impl Readable for OnionPacket {
2459 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2461 version: Readable::read(r)?,
2463 let mut buf = [0u8;33];
2464 r.read_exact(&mut buf)?;
2465 PublicKey::from_slice(&buf)
2467 hop_data: Readable::read(r)?,
2468 hmac: Readable::read(r)?,
2473 impl_writeable_msg!(UpdateAddHTLC, {
2479 onion_routing_packet,
2481 (0, blinding_point, option),
2482 (65537, skimmed_fee_msat, option)
2485 impl Readable for OnionMessage {
2486 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2487 let blinding_point: PublicKey = Readable::read(r)?;
2488 let len: u16 = Readable::read(r)?;
2489 let mut packet_reader = FixedLengthReader::new(r, len as u64);
2490 let onion_routing_packet: onion_message::packet::Packet =
2491 <onion_message::packet::Packet as LengthReadable>::read(&mut packet_reader)?;
2494 onion_routing_packet,
2499 impl Writeable for OnionMessage {
2500 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2501 self.blinding_point.write(w)?;
2502 let onion_packet_len = self.onion_routing_packet.serialized_length();
2503 (onion_packet_len as u16).write(w)?;
2504 self.onion_routing_packet.write(w)?;
2509 impl Writeable for FinalOnionHopData {
2510 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2511 self.payment_secret.0.write(w)?;
2512 HighZeroBytesDroppedBigSize(self.total_msat).write(w)
2516 impl Readable for FinalOnionHopData {
2517 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2518 let secret: [u8; 32] = Readable::read(r)?;
2519 let amt: HighZeroBytesDroppedBigSize<u64> = Readable::read(r)?;
2520 Ok(Self { payment_secret: PaymentSecret(secret), total_msat: amt.0 })
2524 impl Writeable for OutboundOnionPayload {
2525 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2527 Self::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } => {
2528 _encode_varint_length_prefixed_tlv!(w, {
2529 (2, HighZeroBytesDroppedBigSize(*amt_to_forward), required),
2530 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2531 (6, short_channel_id, required)
2534 Self::TrampolineEntrypoint {
2535 amt_to_forward, outgoing_cltv_value, ref multipath_trampoline_data,
2536 ref trampoline_packet
2538 _encode_varint_length_prefixed_tlv!(w, {
2539 (2, HighZeroBytesDroppedBigSize(*amt_to_forward), required),
2540 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2541 (8, multipath_trampoline_data, option),
2542 (20, trampoline_packet, required)
2546 ref payment_data, ref payment_metadata, ref keysend_preimage, sender_intended_htlc_amt_msat,
2547 cltv_expiry_height, ref custom_tlvs,
2549 // We need to update [`ln::outbound_payment::RecipientOnionFields::with_custom_tlvs`]
2550 // to reject any reserved types in the experimental range if new ones are ever
2552 let keysend_tlv = keysend_preimage.map(|preimage| (5482373484, preimage.encode()));
2553 let mut custom_tlvs: Vec<&(u64, Vec<u8>)> = custom_tlvs.iter().chain(keysend_tlv.iter()).collect();
2554 custom_tlvs.sort_unstable_by_key(|(typ, _)| *typ);
2555 _encode_varint_length_prefixed_tlv!(w, {
2556 (2, HighZeroBytesDroppedBigSize(*sender_intended_htlc_amt_msat), required),
2557 (4, HighZeroBytesDroppedBigSize(*cltv_expiry_height), required),
2558 (8, payment_data, option),
2559 (16, payment_metadata.as_ref().map(|m| WithoutLength(m)), option)
2560 }, custom_tlvs.iter());
2562 Self::BlindedForward { encrypted_tlvs, intro_node_blinding_point } => {
2563 _encode_varint_length_prefixed_tlv!(w, {
2564 (10, *encrypted_tlvs, required_vec),
2565 (12, intro_node_blinding_point, option)
2568 Self::BlindedReceive {
2569 sender_intended_htlc_amt_msat, total_msat, cltv_expiry_height, encrypted_tlvs,
2570 intro_node_blinding_point,
2572 _encode_varint_length_prefixed_tlv!(w, {
2573 (2, HighZeroBytesDroppedBigSize(*sender_intended_htlc_amt_msat), required),
2574 (4, HighZeroBytesDroppedBigSize(*cltv_expiry_height), required),
2575 (10, *encrypted_tlvs, required_vec),
2576 (12, intro_node_blinding_point, option),
2577 (18, HighZeroBytesDroppedBigSize(*total_msat), required)
2585 impl<NS: Deref> ReadableArgs<(Option<PublicKey>, &NS)> for InboundOnionPayload where NS::Target: NodeSigner {
2586 fn read<R: Read>(r: &mut R, args: (Option<PublicKey>, &NS)) -> Result<Self, DecodeError> {
2587 let (update_add_blinding_point, node_signer) = args;
2590 let mut cltv_value = None;
2591 let mut short_id: Option<u64> = None;
2592 let mut payment_data: Option<FinalOnionHopData> = None;
2593 let mut encrypted_tlvs_opt: Option<WithoutLength<Vec<u8>>> = None;
2594 let mut intro_node_blinding_point = None;
2595 let mut payment_metadata: Option<WithoutLength<Vec<u8>>> = None;
2596 let mut total_msat = None;
2597 let mut keysend_preimage: Option<PaymentPreimage> = None;
2598 let mut custom_tlvs = Vec::new();
2600 let tlv_len = BigSize::read(r)?;
2601 let rd = FixedLengthReader::new(r, tlv_len.0);
2602 decode_tlv_stream_with_custom_tlv_decode!(rd, {
2603 (2, amt, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2604 (4, cltv_value, (option, encoding: (u32, HighZeroBytesDroppedBigSize))),
2605 (6, short_id, option),
2606 (8, payment_data, option),
2607 (10, encrypted_tlvs_opt, option),
2608 (12, intro_node_blinding_point, option),
2609 (16, payment_metadata, option),
2610 (18, total_msat, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2611 // See https://github.com/lightning/blips/blob/master/blip-0003.md
2612 (5482373484, keysend_preimage, option)
2613 }, |msg_type: u64, msg_reader: &mut FixedLengthReader<_>| -> Result<bool, DecodeError> {
2614 if msg_type < 1 << 16 { return Ok(false) }
2615 let mut value = Vec::new();
2616 msg_reader.read_to_end(&mut value)?;
2617 custom_tlvs.push((msg_type, value));
2621 if amt.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2622 if intro_node_blinding_point.is_some() && update_add_blinding_point.is_some() {
2623 return Err(DecodeError::InvalidValue)
2626 if let Some(blinding_point) = intro_node_blinding_point.or(update_add_blinding_point) {
2627 if short_id.is_some() || payment_data.is_some() || payment_metadata.is_some() ||
2628 keysend_preimage.is_some()
2630 return Err(DecodeError::InvalidValue)
2632 let enc_tlvs = encrypted_tlvs_opt.ok_or(DecodeError::InvalidValue)?.0;
2633 let enc_tlvs_ss = node_signer.ecdh(Recipient::Node, &blinding_point, None)
2634 .map_err(|_| DecodeError::InvalidValue)?;
2635 let rho = onion_utils::gen_rho_from_shared_secret(&enc_tlvs_ss.secret_bytes());
2636 let mut s = Cursor::new(&enc_tlvs);
2637 let mut reader = FixedLengthReader::new(&mut s, enc_tlvs.len() as u64);
2638 match ChaChaPolyReadAdapter::read(&mut reader, rho)? {
2639 ChaChaPolyReadAdapter { readable: BlindedPaymentTlvs::Forward(ForwardTlvs {
2640 short_channel_id, payment_relay, payment_constraints, features
2642 if amt.is_some() || cltv_value.is_some() || total_msat.is_some() {
2643 return Err(DecodeError::InvalidValue)
2645 Ok(Self::BlindedForward {
2648 payment_constraints,
2650 intro_node_blinding_point,
2653 ChaChaPolyReadAdapter { readable: BlindedPaymentTlvs::Receive(ReceiveTlvs {
2654 payment_secret, payment_constraints
2656 if total_msat.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2657 Ok(Self::BlindedReceive {
2658 sender_intended_htlc_amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2659 total_msat: total_msat.ok_or(DecodeError::InvalidValue)?,
2660 cltv_expiry_height: cltv_value.ok_or(DecodeError::InvalidValue)?,
2662 payment_constraints,
2663 intro_node_blinding_point,
2667 } else if let Some(short_channel_id) = short_id {
2668 if payment_data.is_some() || payment_metadata.is_some() || encrypted_tlvs_opt.is_some() ||
2669 total_msat.is_some()
2670 { return Err(DecodeError::InvalidValue) }
2673 amt_to_forward: amt.ok_or(DecodeError::InvalidValue)?,
2674 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2677 if encrypted_tlvs_opt.is_some() || total_msat.is_some() {
2678 return Err(DecodeError::InvalidValue)
2680 if let Some(data) = &payment_data {
2681 if data.total_msat > MAX_VALUE_MSAT {
2682 return Err(DecodeError::InvalidValue);
2687 payment_metadata: payment_metadata.map(|w| w.0),
2689 sender_intended_htlc_amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2690 cltv_expiry_height: cltv_value.ok_or(DecodeError::InvalidValue)?,
2697 impl Writeable for Ping {
2698 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2699 self.ponglen.write(w)?;
2700 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2705 impl Readable for Ping {
2706 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2708 ponglen: Readable::read(r)?,
2710 let byteslen = Readable::read(r)?;
2711 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2718 impl Writeable for Pong {
2719 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2720 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2725 impl Readable for Pong {
2726 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2729 let byteslen = Readable::read(r)?;
2730 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2737 impl Writeable for UnsignedChannelAnnouncement {
2738 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2739 self.features.write(w)?;
2740 self.chain_hash.write(w)?;
2741 self.short_channel_id.write(w)?;
2742 self.node_id_1.write(w)?;
2743 self.node_id_2.write(w)?;
2744 self.bitcoin_key_1.write(w)?;
2745 self.bitcoin_key_2.write(w)?;
2746 w.write_all(&self.excess_data[..])?;
2751 impl Readable for UnsignedChannelAnnouncement {
2752 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2754 features: Readable::read(r)?,
2755 chain_hash: Readable::read(r)?,
2756 short_channel_id: Readable::read(r)?,
2757 node_id_1: Readable::read(r)?,
2758 node_id_2: Readable::read(r)?,
2759 bitcoin_key_1: Readable::read(r)?,
2760 bitcoin_key_2: Readable::read(r)?,
2761 excess_data: read_to_end(r)?,
2766 impl_writeable!(ChannelAnnouncement, {
2769 bitcoin_signature_1,
2770 bitcoin_signature_2,
2774 impl Writeable for UnsignedChannelUpdate {
2775 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2776 // `message_flags` used to indicate presence of `htlc_maximum_msat`, but was deprecated in the spec.
2777 const MESSAGE_FLAGS: u8 = 1;
2778 self.chain_hash.write(w)?;
2779 self.short_channel_id.write(w)?;
2780 self.timestamp.write(w)?;
2781 let all_flags = self.flags as u16 | ((MESSAGE_FLAGS as u16) << 8);
2782 all_flags.write(w)?;
2783 self.cltv_expiry_delta.write(w)?;
2784 self.htlc_minimum_msat.write(w)?;
2785 self.fee_base_msat.write(w)?;
2786 self.fee_proportional_millionths.write(w)?;
2787 self.htlc_maximum_msat.write(w)?;
2788 w.write_all(&self.excess_data[..])?;
2793 impl Readable for UnsignedChannelUpdate {
2794 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2796 chain_hash: Readable::read(r)?,
2797 short_channel_id: Readable::read(r)?,
2798 timestamp: Readable::read(r)?,
2800 let flags: u16 = Readable::read(r)?;
2801 // Note: we ignore the `message_flags` for now, since it was deprecated by the spec.
2804 cltv_expiry_delta: Readable::read(r)?,
2805 htlc_minimum_msat: Readable::read(r)?,
2806 fee_base_msat: Readable::read(r)?,
2807 fee_proportional_millionths: Readable::read(r)?,
2808 htlc_maximum_msat: Readable::read(r)?,
2809 excess_data: read_to_end(r)?,
2814 impl_writeable!(ChannelUpdate, {
2819 impl Writeable for ErrorMessage {
2820 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2821 self.channel_id.write(w)?;
2822 (self.data.len() as u16).write(w)?;
2823 w.write_all(self.data.as_bytes())?;
2828 impl Readable for ErrorMessage {
2829 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2831 channel_id: Readable::read(r)?,
2833 let sz: usize = <u16 as Readable>::read(r)? as usize;
2834 let mut data = Vec::with_capacity(sz);
2836 r.read_exact(&mut data)?;
2837 match String::from_utf8(data) {
2839 Err(_) => return Err(DecodeError::InvalidValue),
2846 impl Writeable for WarningMessage {
2847 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2848 self.channel_id.write(w)?;
2849 (self.data.len() as u16).write(w)?;
2850 w.write_all(self.data.as_bytes())?;
2855 impl Readable for WarningMessage {
2856 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2858 channel_id: Readable::read(r)?,
2860 let sz: usize = <u16 as Readable>::read(r)? as usize;
2861 let mut data = Vec::with_capacity(sz);
2863 r.read_exact(&mut data)?;
2864 match String::from_utf8(data) {
2866 Err(_) => return Err(DecodeError::InvalidValue),
2873 impl Writeable for UnsignedNodeAnnouncement {
2874 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2875 self.features.write(w)?;
2876 self.timestamp.write(w)?;
2877 self.node_id.write(w)?;
2878 w.write_all(&self.rgb)?;
2879 self.alias.write(w)?;
2881 let mut addr_len = 0;
2882 for addr in self.addresses.iter() {
2883 addr_len += 1 + addr.len();
2885 (addr_len + self.excess_address_data.len() as u16).write(w)?;
2886 for addr in self.addresses.iter() {
2889 w.write_all(&self.excess_address_data[..])?;
2890 w.write_all(&self.excess_data[..])?;
2895 impl Readable for UnsignedNodeAnnouncement {
2896 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2897 let features: NodeFeatures = Readable::read(r)?;
2898 let timestamp: u32 = Readable::read(r)?;
2899 let node_id: NodeId = Readable::read(r)?;
2900 let mut rgb = [0; 3];
2901 r.read_exact(&mut rgb)?;
2902 let alias: NodeAlias = Readable::read(r)?;
2904 let addr_len: u16 = Readable::read(r)?;
2905 let mut addresses: Vec<SocketAddress> = Vec::new();
2906 let mut addr_readpos = 0;
2907 let mut excess = false;
2908 let mut excess_byte = 0;
2910 if addr_len <= addr_readpos { break; }
2911 match Readable::read(r) {
2913 if addr_len < addr_readpos + 1 + addr.len() {
2914 return Err(DecodeError::BadLengthDescriptor);
2916 addr_readpos += (1 + addr.len()) as u16;
2917 addresses.push(addr);
2919 Ok(Err(unknown_descriptor)) => {
2921 excess_byte = unknown_descriptor;
2924 Err(DecodeError::ShortRead) => return Err(DecodeError::BadLengthDescriptor),
2925 Err(e) => return Err(e),
2929 let mut excess_data = vec![];
2930 let excess_address_data = if addr_readpos < addr_len {
2931 let mut excess_address_data = vec![0; (addr_len - addr_readpos) as usize];
2932 r.read_exact(&mut excess_address_data[if excess { 1 } else { 0 }..])?;
2934 excess_address_data[0] = excess_byte;
2939 excess_data.push(excess_byte);
2943 excess_data.extend(read_to_end(r)?.iter());
2944 Ok(UnsignedNodeAnnouncement {
2951 excess_address_data,
2957 impl_writeable!(NodeAnnouncement, {
2962 impl Readable for QueryShortChannelIds {
2963 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2964 let chain_hash: ChainHash = Readable::read(r)?;
2966 let encoding_len: u16 = Readable::read(r)?;
2967 let encoding_type: u8 = Readable::read(r)?;
2969 // Must be encoding_type=0 uncompressed serialization. We do not
2970 // support encoding_type=1 zlib serialization.
2971 if encoding_type != EncodingType::Uncompressed as u8 {
2972 return Err(DecodeError::UnsupportedCompression);
2975 // We expect the encoding_len to always includes the 1-byte
2976 // encoding_type and that short_channel_ids are 8-bytes each
2977 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2978 return Err(DecodeError::InvalidValue);
2981 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2982 // less the 1-byte encoding_type
2983 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2984 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2985 for _ in 0..short_channel_id_count {
2986 short_channel_ids.push(Readable::read(r)?);
2989 Ok(QueryShortChannelIds {
2996 impl Writeable for QueryShortChannelIds {
2997 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2998 // Calculated from 1-byte encoding_type plus 8-bytes per short_channel_id
2999 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
3001 self.chain_hash.write(w)?;
3002 encoding_len.write(w)?;
3004 // We only support type=0 uncompressed serialization
3005 (EncodingType::Uncompressed as u8).write(w)?;
3007 for scid in self.short_channel_ids.iter() {
3015 impl_writeable_msg!(ReplyShortChannelIdsEnd, {
3020 impl QueryChannelRange {
3021 /// Calculates the overflow safe ending block height for the query.
3023 /// Overflow returns `0xffffffff`, otherwise returns `first_blocknum + number_of_blocks`.
3024 pub fn end_blocknum(&self) -> u32 {
3025 match self.first_blocknum.checked_add(self.number_of_blocks) {
3026 Some(block) => block,
3027 None => u32::max_value(),
3032 impl_writeable_msg!(QueryChannelRange, {
3038 impl Readable for ReplyChannelRange {
3039 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
3040 let chain_hash: ChainHash = Readable::read(r)?;
3041 let first_blocknum: u32 = Readable::read(r)?;
3042 let number_of_blocks: u32 = Readable::read(r)?;
3043 let sync_complete: bool = Readable::read(r)?;
3045 let encoding_len: u16 = Readable::read(r)?;
3046 let encoding_type: u8 = Readable::read(r)?;
3048 // Must be encoding_type=0 uncompressed serialization. We do not
3049 // support encoding_type=1 zlib serialization.
3050 if encoding_type != EncodingType::Uncompressed as u8 {
3051 return Err(DecodeError::UnsupportedCompression);
3054 // We expect the encoding_len to always includes the 1-byte
3055 // encoding_type and that short_channel_ids are 8-bytes each
3056 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
3057 return Err(DecodeError::InvalidValue);
3060 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
3061 // less the 1-byte encoding_type
3062 let short_channel_id_count: u16 = (encoding_len - 1)/8;
3063 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
3064 for _ in 0..short_channel_id_count {
3065 short_channel_ids.push(Readable::read(r)?);
3068 Ok(ReplyChannelRange {
3078 impl Writeable for ReplyChannelRange {
3079 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
3080 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
3081 self.chain_hash.write(w)?;
3082 self.first_blocknum.write(w)?;
3083 self.number_of_blocks.write(w)?;
3084 self.sync_complete.write(w)?;
3086 encoding_len.write(w)?;
3087 (EncodingType::Uncompressed as u8).write(w)?;
3088 for scid in self.short_channel_ids.iter() {
3096 impl_writeable_msg!(GossipTimestampFilter, {
3104 use std::convert::TryFrom;
3105 use bitcoin::{Transaction, TxIn, ScriptBuf, Sequence, Witness, TxOut};
3106 use hex::DisplayHex;
3107 use crate::ln::{PaymentPreimage, PaymentHash, PaymentSecret};
3108 use crate::ln::ChannelId;
3109 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
3110 use crate::ln::msgs::{self, FinalOnionHopData, OnionErrorPacket, CommonOpenChannelFields, CommonAcceptChannelFields, TrampolineOnionPacket};
3111 use crate::ln::msgs::SocketAddress;
3112 use crate::routing::gossip::{NodeAlias, NodeId};
3113 use crate::util::ser::{BigSize, Hostname, Readable, ReadableArgs, TransactionU16LenLimited, Writeable};
3114 use crate::util::test_utils;
3116 use bitcoin::hashes::hex::FromHex;
3117 use bitcoin::address::Address;
3118 use bitcoin::network::constants::Network;
3119 use bitcoin::blockdata::constants::ChainHash;
3120 use bitcoin::blockdata::script::Builder;
3121 use bitcoin::blockdata::opcodes;
3122 use bitcoin::hash_types::Txid;
3123 use bitcoin::locktime::absolute::LockTime;
3125 use bitcoin::secp256k1::{PublicKey,SecretKey};
3126 use bitcoin::secp256k1::{Secp256k1, Message};
3128 use crate::io::{self, Cursor};
3129 use crate::prelude::*;
3130 use core::str::FromStr;
3131 use crate::chain::transaction::OutPoint;
3133 #[cfg(feature = "std")]
3134 use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6, ToSocketAddrs};
3135 #[cfg(feature = "std")]
3136 use crate::ln::msgs::SocketAddressParseError;
3139 fn encoding_channel_reestablish() {
3141 let secp_ctx = Secp256k1::new();
3142 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&<Vec<u8>>::from_hex("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
3145 let cr = msgs::ChannelReestablish {
3146 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]),
3147 next_local_commitment_number: 3,
3148 next_remote_commitment_number: 4,
3149 your_last_per_commitment_secret: [9;32],
3150 my_current_per_commitment_point: public_key,
3151 next_funding_txid: None,
3154 let encoded_value = cr.encode();
3158 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
3159 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
3160 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
3161 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
3162 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
3168 fn encoding_channel_reestablish_with_next_funding_txid() {
3170 let secp_ctx = Secp256k1::new();
3171 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&<Vec<u8>>::from_hex("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
3174 let cr = msgs::ChannelReestablish {
3175 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]),
3176 next_local_commitment_number: 3,
3177 next_remote_commitment_number: 4,
3178 your_last_per_commitment_secret: [9;32],
3179 my_current_per_commitment_point: public_key,
3180 next_funding_txid: Some(Txid::from_raw_hash(bitcoin::hashes::Hash::from_slice(&[
3181 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,
3185 let encoded_value = cr.encode();
3189 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
3190 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
3191 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
3192 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
3193 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
3194 0, // Type (next_funding_txid)
3196 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
3201 macro_rules! get_keys_from {
3202 ($slice: expr, $secp_ctx: expr) => {
3204 let privkey = SecretKey::from_slice(&<Vec<u8>>::from_hex($slice).unwrap()[..]).unwrap();
3205 let pubkey = PublicKey::from_secret_key(&$secp_ctx, &privkey);
3211 macro_rules! get_sig_on {
3212 ($privkey: expr, $ctx: expr, $string: expr) => {
3214 let sighash = Message::from_slice(&$string.into_bytes()[..]).unwrap();
3215 $ctx.sign_ecdsa(&sighash, &$privkey)
3221 fn encoding_announcement_signatures() {
3222 let secp_ctx = Secp256k1::new();
3223 let (privkey, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3224 let sig_1 = get_sig_on!(privkey, secp_ctx, String::from("01010101010101010101010101010101"));
3225 let sig_2 = get_sig_on!(privkey, secp_ctx, String::from("02020202020202020202020202020202"));
3226 let announcement_signatures = msgs::AnnouncementSignatures {
3227 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]),
3228 short_channel_id: 2316138423780173,
3229 node_signature: sig_1,
3230 bitcoin_signature: sig_2,
3233 let encoded_value = announcement_signatures.encode();
3234 assert_eq!(encoded_value, <Vec<u8>>::from_hex("040000000000000005000000000000000600000000000000070000000000000000083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073acf9953cef4700860f5967838eba2bae89288ad188ebf8b20bf995c3ea53a26df1876d0a3a0e13172ba286a673140190c02ba9da60a2e43a745188c8a83c7f3ef").unwrap());
3237 fn do_encoding_channel_announcement(unknown_features_bits: bool, excess_data: bool) {
3238 let secp_ctx = Secp256k1::new();
3239 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3240 let (privkey_2, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3241 let (privkey_3, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3242 let (privkey_4, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3243 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3244 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
3245 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
3246 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
3247 let mut features = ChannelFeatures::empty();
3248 if unknown_features_bits {
3249 features = ChannelFeatures::from_le_bytes(vec![0xFF, 0xFF]);
3251 let unsigned_channel_announcement = msgs::UnsignedChannelAnnouncement {
3253 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3254 short_channel_id: 2316138423780173,
3255 node_id_1: NodeId::from_pubkey(&pubkey_1),
3256 node_id_2: NodeId::from_pubkey(&pubkey_2),
3257 bitcoin_key_1: NodeId::from_pubkey(&pubkey_3),
3258 bitcoin_key_2: NodeId::from_pubkey(&pubkey_4),
3259 excess_data: if excess_data { vec![10, 0, 0, 20, 0, 0, 30, 0, 0, 40] } else { Vec::new() },
3261 let channel_announcement = msgs::ChannelAnnouncement {
3262 node_signature_1: sig_1,
3263 node_signature_2: sig_2,
3264 bitcoin_signature_1: sig_3,
3265 bitcoin_signature_2: sig_4,
3266 contents: unsigned_channel_announcement,
3268 let encoded_value = channel_announcement.encode();
3269 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a1735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap();
3270 if unknown_features_bits {
3271 target_value.append(&mut <Vec<u8>>::from_hex("0002ffff").unwrap());
3273 target_value.append(&mut <Vec<u8>>::from_hex("0000").unwrap());
3275 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3276 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
3278 target_value.append(&mut <Vec<u8>>::from_hex("0a00001400001e000028").unwrap());
3280 assert_eq!(encoded_value, target_value);
3284 fn encoding_channel_announcement() {
3285 do_encoding_channel_announcement(true, false);
3286 do_encoding_channel_announcement(false, true);
3287 do_encoding_channel_announcement(false, false);
3288 do_encoding_channel_announcement(true, true);
3291 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) {
3292 let secp_ctx = Secp256k1::new();
3293 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3294 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3295 let features = if unknown_features_bits {
3296 NodeFeatures::from_le_bytes(vec![0xFF, 0xFF])
3298 // Set to some features we may support
3299 NodeFeatures::from_le_bytes(vec![2 | 1 << 5])
3301 let mut addresses = Vec::new();
3303 addresses.push(SocketAddress::TcpIpV4 {
3304 addr: [255, 254, 253, 252],
3309 addresses.push(SocketAddress::TcpIpV6 {
3310 addr: [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240],
3315 addresses.push(msgs::SocketAddress::OnionV2(
3316 [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 38, 7]
3320 addresses.push(msgs::SocketAddress::OnionV3 {
3321 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],
3328 addresses.push(SocketAddress::Hostname {
3329 hostname: Hostname::try_from(String::from("host")).unwrap(),
3333 let mut addr_len = 0;
3334 for addr in &addresses {
3335 addr_len += addr.len() + 1;
3337 let unsigned_node_announcement = msgs::UnsignedNodeAnnouncement {
3339 timestamp: 20190119,
3340 node_id: NodeId::from_pubkey(&pubkey_1),
3342 alias: NodeAlias([16;32]),
3344 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() },
3345 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() },
3347 addr_len += unsigned_node_announcement.excess_address_data.len() as u16;
3348 let node_announcement = msgs::NodeAnnouncement {
3350 contents: unsigned_node_announcement,
3352 let encoded_value = node_announcement.encode();
3353 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3354 if unknown_features_bits {
3355 target_value.append(&mut <Vec<u8>>::from_hex("0002ffff").unwrap());
3357 target_value.append(&mut <Vec<u8>>::from_hex("000122").unwrap());
3359 target_value.append(&mut <Vec<u8>>::from_hex("013413a7031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f2020201010101010101010101010101010101010101010101010101010101010101010").unwrap());
3360 target_value.append(&mut vec![(addr_len >> 8) as u8, addr_len as u8]);
3362 target_value.append(&mut <Vec<u8>>::from_hex("01fffefdfc2607").unwrap());
3365 target_value.append(&mut <Vec<u8>>::from_hex("02fffefdfcfbfaf9f8f7f6f5f4f3f2f1f02607").unwrap());
3368 target_value.append(&mut <Vec<u8>>::from_hex("03fffefdfcfbfaf9f8f7f62607").unwrap());
3371 target_value.append(&mut <Vec<u8>>::from_hex("04fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0efeeedecebeae9e8e7e6e5e4e3e2e1e00020102607").unwrap());
3374 target_value.append(&mut <Vec<u8>>::from_hex("0504686f73742607").unwrap());
3376 if excess_address_data {
3377 target_value.append(&mut <Vec<u8>>::from_hex("216c280b5395a2546e7e4b2663e04f811622f15a4f92e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d269").unwrap());
3380 target_value.append(&mut <Vec<u8>>::from_hex("3b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
3382 assert_eq!(encoded_value, target_value);
3386 fn encoding_node_announcement() {
3387 do_encoding_node_announcement(true, true, true, true, true, true, true, true);
3388 do_encoding_node_announcement(false, false, false, false, false, false, false, false);
3389 do_encoding_node_announcement(false, true, false, false, false, false, false, false);
3390 do_encoding_node_announcement(false, false, true, false, false, false, false, false);
3391 do_encoding_node_announcement(false, false, false, true, false, false, false, false);
3392 do_encoding_node_announcement(false, false, false, false, true, false, false, false);
3393 do_encoding_node_announcement(false, false, false, false, false, true, false, false);
3394 do_encoding_node_announcement(false, false, false, false, false, false, true, false);
3395 do_encoding_node_announcement(false, true, false, true, false, false, true, false);
3396 do_encoding_node_announcement(false, false, true, false, true, false, false, false);
3399 fn do_encoding_channel_update(direction: bool, disable: bool, excess_data: bool) {
3400 let secp_ctx = Secp256k1::new();
3401 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3402 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3403 let unsigned_channel_update = msgs::UnsignedChannelUpdate {
3404 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3405 short_channel_id: 2316138423780173,
3406 timestamp: 20190119,
3407 flags: if direction { 1 } else { 0 } | if disable { 1 << 1 } else { 0 },
3408 cltv_expiry_delta: 144,
3409 htlc_minimum_msat: 1000000,
3410 htlc_maximum_msat: 131355275467161,
3411 fee_base_msat: 10000,
3412 fee_proportional_millionths: 20,
3413 excess_data: if excess_data { vec![0, 0, 0, 0, 59, 154, 202, 0] } else { Vec::new() }
3415 let channel_update = msgs::ChannelUpdate {
3417 contents: unsigned_channel_update
3419 let encoded_value = channel_update.encode();
3420 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3421 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3422 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d013413a7").unwrap());
3423 target_value.append(&mut <Vec<u8>>::from_hex("01").unwrap());
3424 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3426 let flag = target_value.last_mut().unwrap();
3430 let flag = target_value.last_mut().unwrap();
3431 *flag = *flag | 1 << 1;
3433 target_value.append(&mut <Vec<u8>>::from_hex("009000000000000f42400000271000000014").unwrap());
3434 target_value.append(&mut <Vec<u8>>::from_hex("0000777788889999").unwrap());
3436 target_value.append(&mut <Vec<u8>>::from_hex("000000003b9aca00").unwrap());
3438 assert_eq!(encoded_value, target_value);
3442 fn encoding_channel_update() {
3443 do_encoding_channel_update(false, false, false);
3444 do_encoding_channel_update(false, false, true);
3445 do_encoding_channel_update(true, false, false);
3446 do_encoding_channel_update(true, false, true);
3447 do_encoding_channel_update(false, true, false);
3448 do_encoding_channel_update(false, true, true);
3449 do_encoding_channel_update(true, true, false);
3450 do_encoding_channel_update(true, true, true);
3453 fn do_encoding_open_channel(random_bit: bool, shutdown: bool, incl_chan_type: bool) {
3454 let secp_ctx = Secp256k1::new();
3455 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3456 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3457 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3458 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3459 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3460 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3461 let open_channel = msgs::OpenChannel {
3462 common_fields: CommonOpenChannelFields {
3463 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3464 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3465 funding_satoshis: 1311768467284833366,
3466 dust_limit_satoshis: 3608586615801332854,
3467 max_htlc_value_in_flight_msat: 8517154655701053848,
3468 htlc_minimum_msat: 2316138423780173,
3469 commitment_feerate_sat_per_1000_weight: 821716,
3470 to_self_delay: 49340,
3471 max_accepted_htlcs: 49340,
3472 funding_pubkey: pubkey_1,
3473 revocation_basepoint: pubkey_2,
3474 payment_basepoint: pubkey_3,
3475 delayed_payment_basepoint: pubkey_4,
3476 htlc_basepoint: pubkey_5,
3477 first_per_commitment_point: pubkey_6,
3478 channel_flags: if random_bit { 1 << 5 } else { 0 },
3479 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3480 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3482 push_msat: 2536655962884945560,
3483 channel_reserve_satoshis: 8665828695742877976,
3485 let encoded_value = open_channel.encode();
3486 let mut target_value = Vec::new();
3487 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3488 target_value.append(&mut <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202021234567890123456233403289122369832144668701144767633030896203198784335490624111800083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3490 target_value.append(&mut <Vec<u8>>::from_hex("20").unwrap());
3492 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3495 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3498 target_value.append(&mut <Vec<u8>>::from_hex("0100").unwrap());
3500 assert_eq!(encoded_value, target_value);
3504 fn encoding_open_channel() {
3505 do_encoding_open_channel(false, false, false);
3506 do_encoding_open_channel(false, false, true);
3507 do_encoding_open_channel(false, true, false);
3508 do_encoding_open_channel(false, true, true);
3509 do_encoding_open_channel(true, false, false);
3510 do_encoding_open_channel(true, false, true);
3511 do_encoding_open_channel(true, true, false);
3512 do_encoding_open_channel(true, true, true);
3515 fn do_encoding_open_channelv2(random_bit: bool, shutdown: bool, incl_chan_type: bool, require_confirmed_inputs: bool) {
3516 let secp_ctx = Secp256k1::new();
3517 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3518 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3519 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3520 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3521 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3522 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3523 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3524 let open_channelv2 = msgs::OpenChannelV2 {
3525 common_fields: CommonOpenChannelFields {
3526 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3527 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3528 commitment_feerate_sat_per_1000_weight: 821716,
3529 funding_satoshis: 1311768467284833366,
3530 dust_limit_satoshis: 3608586615801332854,
3531 max_htlc_value_in_flight_msat: 8517154655701053848,
3532 htlc_minimum_msat: 2316138423780173,
3533 to_self_delay: 49340,
3534 max_accepted_htlcs: 49340,
3535 funding_pubkey: pubkey_1,
3536 revocation_basepoint: pubkey_2,
3537 payment_basepoint: pubkey_3,
3538 delayed_payment_basepoint: pubkey_4,
3539 htlc_basepoint: pubkey_5,
3540 first_per_commitment_point: pubkey_6,
3541 channel_flags: if random_bit { 1 << 5 } else { 0 },
3542 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3543 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3545 funding_feerate_sat_per_1000_weight: 821716,
3546 locktime: 305419896,
3547 second_per_commitment_point: pubkey_7,
3548 require_confirmed_inputs: if require_confirmed_inputs { Some(()) } else { None },
3550 let encoded_value = open_channelv2.encode();
3551 let mut target_value = Vec::new();
3552 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3553 target_value.append(&mut <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap());
3554 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap());
3555 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap());
3556 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap());
3557 target_value.append(&mut <Vec<u8>>::from_hex("3214466870114476").unwrap());
3558 target_value.append(&mut <Vec<u8>>::from_hex("7633030896203198").unwrap());
3559 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d").unwrap());
3560 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap());
3561 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap());
3562 target_value.append(&mut <Vec<u8>>::from_hex("12345678").unwrap());
3563 target_value.append(&mut <Vec<u8>>::from_hex("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap());
3564 target_value.append(&mut <Vec<u8>>::from_hex("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap());
3565 target_value.append(&mut <Vec<u8>>::from_hex("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap());
3566 target_value.append(&mut <Vec<u8>>::from_hex("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
3567 target_value.append(&mut <Vec<u8>>::from_hex("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap());
3568 target_value.append(&mut <Vec<u8>>::from_hex("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3569 target_value.append(&mut <Vec<u8>>::from_hex("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap());
3572 target_value.append(&mut <Vec<u8>>::from_hex("20").unwrap());
3574 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3577 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3580 target_value.append(&mut <Vec<u8>>::from_hex("0100").unwrap());
3582 if require_confirmed_inputs {
3583 target_value.append(&mut <Vec<u8>>::from_hex("0200").unwrap());
3585 assert_eq!(encoded_value, target_value);
3589 fn encoding_open_channelv2() {
3590 do_encoding_open_channelv2(false, false, false, false);
3591 do_encoding_open_channelv2(false, false, false, true);
3592 do_encoding_open_channelv2(false, false, true, false);
3593 do_encoding_open_channelv2(false, false, true, true);
3594 do_encoding_open_channelv2(false, true, false, false);
3595 do_encoding_open_channelv2(false, true, false, true);
3596 do_encoding_open_channelv2(false, true, true, false);
3597 do_encoding_open_channelv2(false, true, true, true);
3598 do_encoding_open_channelv2(true, false, false, false);
3599 do_encoding_open_channelv2(true, false, false, true);
3600 do_encoding_open_channelv2(true, false, true, false);
3601 do_encoding_open_channelv2(true, false, true, true);
3602 do_encoding_open_channelv2(true, true, false, false);
3603 do_encoding_open_channelv2(true, true, false, true);
3604 do_encoding_open_channelv2(true, true, true, false);
3605 do_encoding_open_channelv2(true, true, true, true);
3608 fn do_encoding_accept_channel(shutdown: bool) {
3609 let secp_ctx = Secp256k1::new();
3610 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3611 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3612 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3613 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3614 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3615 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3616 let accept_channel = msgs::AcceptChannel {
3617 common_fields: CommonAcceptChannelFields {
3618 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3619 dust_limit_satoshis: 1311768467284833366,
3620 max_htlc_value_in_flight_msat: 2536655962884945560,
3621 htlc_minimum_msat: 2316138423780173,
3622 minimum_depth: 821716,
3623 to_self_delay: 49340,
3624 max_accepted_htlcs: 49340,
3625 funding_pubkey: pubkey_1,
3626 revocation_basepoint: pubkey_2,
3627 payment_basepoint: pubkey_3,
3628 delayed_payment_basepoint: pubkey_4,
3629 htlc_basepoint: pubkey_5,
3630 first_per_commitment_point: pubkey_6,
3631 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3634 channel_reserve_satoshis: 3608586615801332854,
3636 next_local_nonce: None,
3638 let encoded_value = accept_channel.encode();
3639 let mut target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020212345678901234562334032891223698321446687011447600083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap();
3641 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3643 assert_eq!(encoded_value, target_value);
3647 fn encoding_accept_channel() {
3648 do_encoding_accept_channel(false);
3649 do_encoding_accept_channel(true);
3652 fn do_encoding_accept_channelv2(shutdown: bool) {
3653 let secp_ctx = Secp256k1::new();
3654 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3655 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3656 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3657 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3658 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3659 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3660 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3661 let accept_channelv2 = msgs::AcceptChannelV2 {
3662 common_fields: CommonAcceptChannelFields {
3663 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3664 dust_limit_satoshis: 1311768467284833366,
3665 max_htlc_value_in_flight_msat: 2536655962884945560,
3666 htlc_minimum_msat: 2316138423780173,
3667 minimum_depth: 821716,
3668 to_self_delay: 49340,
3669 max_accepted_htlcs: 49340,
3670 funding_pubkey: pubkey_1,
3671 revocation_basepoint: pubkey_2,
3672 payment_basepoint: pubkey_3,
3673 delayed_payment_basepoint: pubkey_4,
3674 htlc_basepoint: pubkey_5,
3675 first_per_commitment_point: pubkey_6,
3676 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3679 funding_satoshis: 1311768467284833366,
3680 second_per_commitment_point: pubkey_7,
3681 require_confirmed_inputs: None,
3683 let encoded_value = accept_channelv2.encode();
3684 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // temporary_channel_id
3685 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap()); // funding_satoshis
3686 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap()); // dust_limit_satoshis
3687 target_value.append(&mut <Vec<u8>>::from_hex("2334032891223698").unwrap()); // max_htlc_value_in_flight_msat
3688 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d").unwrap()); // htlc_minimum_msat
3689 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap()); // minimum_depth
3690 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap()); // to_self_delay
3691 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap()); // max_accepted_htlcs
3692 target_value.append(&mut <Vec<u8>>::from_hex("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap()); // funding_pubkey
3693 target_value.append(&mut <Vec<u8>>::from_hex("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap()); // revocation_basepoint
3694 target_value.append(&mut <Vec<u8>>::from_hex("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap()); // payment_basepoint
3695 target_value.append(&mut <Vec<u8>>::from_hex("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap()); // delayed_payment_basepoint
3696 target_value.append(&mut <Vec<u8>>::from_hex("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap()); // htlc_basepoint
3697 target_value.append(&mut <Vec<u8>>::from_hex("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap()); // first_per_commitment_point
3698 target_value.append(&mut <Vec<u8>>::from_hex("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap()); // second_per_commitment_point
3700 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3702 assert_eq!(encoded_value, target_value);
3706 fn encoding_accept_channelv2() {
3707 do_encoding_accept_channelv2(false);
3708 do_encoding_accept_channelv2(true);
3712 fn encoding_funding_created() {
3713 let secp_ctx = Secp256k1::new();
3714 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3715 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3716 let funding_created = msgs::FundingCreated {
3717 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3718 funding_txid: Txid::from_str("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3719 funding_output_index: 255,
3722 partial_signature_with_nonce: None,
3724 next_local_nonce: None,
3726 let encoded_value = funding_created.encode();
3727 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202026e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c200ffd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3728 assert_eq!(encoded_value, target_value);
3732 fn encoding_funding_signed() {
3733 let secp_ctx = Secp256k1::new();
3734 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3735 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3736 let funding_signed = msgs::FundingSigned {
3737 channel_id: ChannelId::from_bytes([2; 32]),
3740 partial_signature_with_nonce: None,
3742 let encoded_value = funding_signed.encode();
3743 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3744 assert_eq!(encoded_value, target_value);
3748 fn encoding_channel_ready() {
3749 let secp_ctx = Secp256k1::new();
3750 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3751 let channel_ready = msgs::ChannelReady {
3752 channel_id: ChannelId::from_bytes([2; 32]),
3753 next_per_commitment_point: pubkey_1,
3754 short_channel_id_alias: None,
3756 let encoded_value = channel_ready.encode();
3757 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3758 assert_eq!(encoded_value, target_value);
3762 fn encoding_splice() {
3763 let secp_ctx = Secp256k1::new();
3764 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3765 let splice = msgs::Splice {
3766 chain_hash: ChainHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
3767 channel_id: ChannelId::from_bytes([2; 32]),
3768 relative_satoshis: 123456,
3769 funding_feerate_perkw: 2000,
3771 funding_pubkey: pubkey_1,
3773 let encoded_value = splice.encode();
3774 assert_eq!(encoded_value.as_hex().to_string(), "02020202020202020202020202020202020202020202020202020202020202026fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000000000000001e240000007d000000000031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f");
3778 fn encoding_stfu() {
3779 let stfu = msgs::Stfu {
3780 channel_id: ChannelId::from_bytes([2; 32]),
3783 let encoded_value = stfu.encode();
3784 assert_eq!(encoded_value.as_hex().to_string(), "020202020202020202020202020202020202020202020202020202020202020201");
3788 fn encoding_splice_ack() {
3789 let secp_ctx = Secp256k1::new();
3790 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3791 let splice = msgs::SpliceAck {
3792 chain_hash: ChainHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
3793 channel_id: ChannelId::from_bytes([2; 32]),
3794 relative_satoshis: 123456,
3795 funding_pubkey: pubkey_1,
3797 let encoded_value = splice.encode();
3798 assert_eq!(encoded_value.as_hex().to_string(), "02020202020202020202020202020202020202020202020202020202020202026fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000000000000001e240031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f");
3802 fn encoding_splice_locked() {
3803 let splice = msgs::SpliceLocked {
3804 channel_id: ChannelId::from_bytes([2; 32]),
3806 let encoded_value = splice.encode();
3807 assert_eq!(encoded_value.as_hex().to_string(), "0202020202020202020202020202020202020202020202020202020202020202");
3811 fn encoding_tx_add_input() {
3812 let tx_add_input = msgs::TxAddInput {
3813 channel_id: ChannelId::from_bytes([2; 32]),
3814 serial_id: 4886718345,
3815 prevtx: TransactionU16LenLimited::new(Transaction {
3817 lock_time: LockTime::ZERO,
3819 previous_output: OutPoint { txid: Txid::from_str("305bab643ee297b8b6b76b320792c8223d55082122cb606bf89382146ced9c77").unwrap(), index: 2 }.into_bitcoin_outpoint(),
3820 script_sig: ScriptBuf::new(),
3821 sequence: Sequence(0xfffffffd),
3822 witness: Witness::from_slice(&vec![
3823 <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3824 <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3829 script_pubkey: Address::from_str("bc1qzlffunw52jav8vwdu5x3jfk6sr8u22rmq3xzw2").unwrap().payload.script_pubkey(),
3833 script_pubkey: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().payload.script_pubkey(),
3837 prevtx_out: 305419896,
3838 sequence: 305419896,
3840 let encoded_value = tx_add_input.encode();
3841 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000000012345678900de02000000000101779ced6c148293f86b60cb222108553d22c89207326bb7b6b897e23e64ab5b300200000000fdffffff0236dbc1000000000016001417d29e4dd454bac3b1cde50d1926da80cfc5287b9cbd03000000000016001436ec78d514df462da95e6a00c24daa8915362d420247304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701210301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944000000001234567812345678").unwrap();
3842 assert_eq!(encoded_value, target_value);
3846 fn encoding_tx_add_output() {
3847 let tx_add_output = msgs::TxAddOutput {
3848 channel_id: ChannelId::from_bytes([2; 32]),
3849 serial_id: 4886718345,
3851 script: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().payload.script_pubkey(),
3853 let encoded_value = tx_add_output.encode();
3854 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000000012345678900000001234567890016001436ec78d514df462da95e6a00c24daa8915362d42").unwrap();
3855 assert_eq!(encoded_value, target_value);
3859 fn encoding_tx_remove_input() {
3860 let tx_remove_input = msgs::TxRemoveInput {
3861 channel_id: ChannelId::from_bytes([2; 32]),
3862 serial_id: 4886718345,
3864 let encoded_value = tx_remove_input.encode();
3865 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3866 assert_eq!(encoded_value, target_value);
3870 fn encoding_tx_remove_output() {
3871 let tx_remove_output = msgs::TxRemoveOutput {
3872 channel_id: ChannelId::from_bytes([2; 32]),
3873 serial_id: 4886718345,
3875 let encoded_value = tx_remove_output.encode();
3876 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3877 assert_eq!(encoded_value, target_value);
3881 fn encoding_tx_complete() {
3882 let tx_complete = msgs::TxComplete {
3883 channel_id: ChannelId::from_bytes([2; 32]),
3885 let encoded_value = tx_complete.encode();
3886 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3887 assert_eq!(encoded_value, target_value);
3891 fn encoding_tx_signatures() {
3892 let tx_signatures = msgs::TxSignatures {
3893 channel_id: ChannelId::from_bytes([2; 32]),
3894 tx_hash: Txid::from_str("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3896 Witness::from_slice(&vec![
3897 <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3898 <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3899 Witness::from_slice(&vec![
3900 <Vec<u8>>::from_hex("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap(),
3901 <Vec<u8>>::from_hex("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap()]),
3904 let encoded_value = tx_signatures.encode();
3905 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3906 target_value.append(&mut <Vec<u8>>::from_hex("6e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c2").unwrap()); // tx_hash (sha256) (big endian byte order)
3907 target_value.append(&mut <Vec<u8>>::from_hex("0002").unwrap()); // num_witnesses (u16)
3909 target_value.append(&mut <Vec<u8>>::from_hex("006b").unwrap()); // len of witness_data
3910 target_value.append(&mut <Vec<u8>>::from_hex("02").unwrap()); // num_witness_elements (VarInt)
3911 target_value.append(&mut <Vec<u8>>::from_hex("47").unwrap()); // len of witness element data (VarInt)
3912 target_value.append(&mut <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap());
3913 target_value.append(&mut <Vec<u8>>::from_hex("21").unwrap()); // len of witness element data (VarInt)
3914 target_value.append(&mut <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap());
3916 target_value.append(&mut <Vec<u8>>::from_hex("006c").unwrap()); // len of witness_data
3917 target_value.append(&mut <Vec<u8>>::from_hex("02").unwrap()); // num_witness_elements (VarInt)
3918 target_value.append(&mut <Vec<u8>>::from_hex("48").unwrap()); // len of witness element data (VarInt)
3919 target_value.append(&mut <Vec<u8>>::from_hex("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap());
3920 target_value.append(&mut <Vec<u8>>::from_hex("21").unwrap()); // len of witness element data (VarInt)
3921 target_value.append(&mut <Vec<u8>>::from_hex("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap());
3922 assert_eq!(encoded_value, target_value);
3925 fn do_encoding_tx_init_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3926 let tx_init_rbf = msgs::TxInitRbf {
3927 channel_id: ChannelId::from_bytes([2; 32]),
3928 locktime: 305419896,
3929 feerate_sat_per_1000_weight: 20190119,
3930 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3932 let encoded_value = tx_init_rbf.encode();
3933 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3934 target_value.append(&mut <Vec<u8>>::from_hex("12345678").unwrap()); // locktime
3935 target_value.append(&mut <Vec<u8>>::from_hex("013413a7").unwrap()); // feerate_sat_per_1000_weight
3936 if let Some((_, target)) = funding_value_with_hex_target {
3937 target_value.push(0x00); // Type
3938 target_value.push(target.len() as u8 / 2); // Length
3939 target_value.append(&mut <Vec<u8>>::from_hex(target).unwrap()); // Value (i64)
3941 assert_eq!(encoded_value, target_value);
3945 fn encoding_tx_init_rbf() {
3946 do_encoding_tx_init_rbf(Some((1311768467284833366, "1234567890123456")));
3947 do_encoding_tx_init_rbf(Some((13117684672, "000000030DDFFBC0")));
3948 do_encoding_tx_init_rbf(None);
3951 fn do_encoding_tx_ack_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3952 let tx_ack_rbf = msgs::TxAckRbf {
3953 channel_id: ChannelId::from_bytes([2; 32]),
3954 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3956 let encoded_value = tx_ack_rbf.encode();
3957 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3958 if let Some((_, target)) = funding_value_with_hex_target {
3959 target_value.push(0x00); // Type
3960 target_value.push(target.len() as u8 / 2); // Length
3961 target_value.append(&mut <Vec<u8>>::from_hex(target).unwrap()); // Value (i64)
3963 assert_eq!(encoded_value, target_value);
3967 fn encoding_tx_ack_rbf() {
3968 do_encoding_tx_ack_rbf(Some((1311768467284833366, "1234567890123456")));
3969 do_encoding_tx_ack_rbf(Some((13117684672, "000000030DDFFBC0")));
3970 do_encoding_tx_ack_rbf(None);
3974 fn encoding_tx_abort() {
3975 let tx_abort = msgs::TxAbort {
3976 channel_id: ChannelId::from_bytes([2; 32]),
3977 data: <Vec<u8>>::from_hex("54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap(),
3979 let encoded_value = tx_abort.encode();
3980 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202002C54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap();
3981 assert_eq!(encoded_value, target_value);
3984 fn do_encoding_shutdown(script_type: u8) {
3985 let secp_ctx = Secp256k1::new();
3986 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3987 let script = Builder::new().push_opcode(opcodes::OP_TRUE).into_script();
3988 let shutdown = msgs::Shutdown {
3989 channel_id: ChannelId::from_bytes([2; 32]),
3991 if script_type == 1 { Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey() }
3992 else if script_type == 2 { Address::p2sh(&script, Network::Testnet).unwrap().script_pubkey() }
3993 else if script_type == 3 { Address::p2wpkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).unwrap().script_pubkey() }
3994 else { Address::p2wsh(&script, Network::Testnet).script_pubkey() },
3996 let encoded_value = shutdown.encode();
3997 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3998 if script_type == 1 {
3999 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
4000 } else if script_type == 2 {
4001 target_value.append(&mut <Vec<u8>>::from_hex("0017a914da1745e9b549bd0bfa1a569971c77eba30cd5a4b87").unwrap());
4002 } else if script_type == 3 {
4003 target_value.append(&mut <Vec<u8>>::from_hex("0016001479b000887626b294a914501a4cd226b58b235983").unwrap());
4004 } else if script_type == 4 {
4005 target_value.append(&mut <Vec<u8>>::from_hex("002200204ae81572f06e1b88fd5ced7a1a000945432e83e1551e6f721ee9c00b8cc33260").unwrap());
4007 assert_eq!(encoded_value, target_value);
4011 fn encoding_shutdown() {
4012 do_encoding_shutdown(1);
4013 do_encoding_shutdown(2);
4014 do_encoding_shutdown(3);
4015 do_encoding_shutdown(4);
4019 fn encoding_closing_signed() {
4020 let secp_ctx = Secp256k1::new();
4021 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4022 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
4023 let closing_signed = msgs::ClosingSigned {
4024 channel_id: ChannelId::from_bytes([2; 32]),
4025 fee_satoshis: 2316138423780173,
4029 let encoded_value = closing_signed.encode();
4030 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
4031 assert_eq!(encoded_value, target_value);
4032 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value)).unwrap(), closing_signed);
4034 let closing_signed_with_range = msgs::ClosingSigned {
4035 channel_id: ChannelId::from_bytes([2; 32]),
4036 fee_satoshis: 2316138423780173,
4038 fee_range: Some(msgs::ClosingSignedFeeRange {
4039 min_fee_satoshis: 0xdeadbeef,
4040 max_fee_satoshis: 0x1badcafe01234567,
4043 let encoded_value_with_range = closing_signed_with_range.encode();
4044 let target_value_with_range = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a011000000000deadbeef1badcafe01234567").unwrap();
4045 assert_eq!(encoded_value_with_range, target_value_with_range);
4046 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value_with_range)).unwrap(),
4047 closing_signed_with_range);
4051 fn encoding_update_add_htlc() {
4052 let secp_ctx = Secp256k1::new();
4053 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4054 let onion_routing_packet = msgs::OnionPacket {
4056 public_key: Ok(pubkey_1),
4057 hop_data: [1; 20*65],
4060 let update_add_htlc = msgs::UpdateAddHTLC {
4061 channel_id: ChannelId::from_bytes([2; 32]),
4062 htlc_id: 2316138423780173,
4063 amount_msat: 3608586615801332854,
4064 payment_hash: PaymentHash([1; 32]),
4065 cltv_expiry: 821716,
4066 onion_routing_packet,
4067 skimmed_fee_msat: None,
4068 blinding_point: None,
4070 let encoded_value = update_add_htlc.encode();
4071 let target_value = <Vec<u8>>::from_hex("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").unwrap();
4072 assert_eq!(encoded_value, target_value);
4076 fn encoding_update_fulfill_htlc() {
4077 let update_fulfill_htlc = msgs::UpdateFulfillHTLC {
4078 channel_id: ChannelId::from_bytes([2; 32]),
4079 htlc_id: 2316138423780173,
4080 payment_preimage: PaymentPreimage([1; 32]),
4082 let encoded_value = update_fulfill_htlc.encode();
4083 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d0101010101010101010101010101010101010101010101010101010101010101").unwrap();
4084 assert_eq!(encoded_value, target_value);
4088 fn encoding_update_fail_htlc() {
4089 let reason = OnionErrorPacket {
4090 data: [1; 32].to_vec(),
4092 let update_fail_htlc = msgs::UpdateFailHTLC {
4093 channel_id: ChannelId::from_bytes([2; 32]),
4094 htlc_id: 2316138423780173,
4097 let encoded_value = update_fail_htlc.encode();
4098 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d00200101010101010101010101010101010101010101010101010101010101010101").unwrap();
4099 assert_eq!(encoded_value, target_value);
4103 fn encoding_update_fail_malformed_htlc() {
4104 let update_fail_malformed_htlc = msgs::UpdateFailMalformedHTLC {
4105 channel_id: ChannelId::from_bytes([2; 32]),
4106 htlc_id: 2316138423780173,
4107 sha256_of_onion: [1; 32],
4110 let encoded_value = update_fail_malformed_htlc.encode();
4111 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d010101010101010101010101010101010101010101010101010101010101010100ff").unwrap();
4112 assert_eq!(encoded_value, target_value);
4115 fn do_encoding_commitment_signed(htlcs: bool) {
4116 let secp_ctx = Secp256k1::new();
4117 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4118 let (privkey_2, _) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
4119 let (privkey_3, _) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
4120 let (privkey_4, _) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
4121 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
4122 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
4123 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
4124 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
4125 let commitment_signed = msgs::CommitmentSigned {
4126 channel_id: ChannelId::from_bytes([2; 32]),
4128 htlc_signatures: if htlcs { vec![sig_2, sig_3, sig_4] } else { Vec::new() },
4130 partial_signature_with_nonce: None,
4132 let encoded_value = commitment_signed.encode();
4133 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
4135 target_value.append(&mut <Vec<u8>>::from_hex("00031735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
4137 target_value.append(&mut <Vec<u8>>::from_hex("0000").unwrap());
4139 assert_eq!(encoded_value, target_value);
4143 fn encoding_commitment_signed() {
4144 do_encoding_commitment_signed(true);
4145 do_encoding_commitment_signed(false);
4149 fn encoding_revoke_and_ack() {
4150 let secp_ctx = Secp256k1::new();
4151 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4152 let raa = msgs::RevokeAndACK {
4153 channel_id: ChannelId::from_bytes([2; 32]),
4154 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],
4155 next_per_commitment_point: pubkey_1,
4157 next_local_nonce: None,
4159 let encoded_value = raa.encode();
4160 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020101010101010101010101010101010101010101010101010101010101010101031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
4161 assert_eq!(encoded_value, target_value);
4165 fn encoding_update_fee() {
4166 let update_fee = msgs::UpdateFee {
4167 channel_id: ChannelId::from_bytes([2; 32]),
4168 feerate_per_kw: 20190119,
4170 let encoded_value = update_fee.encode();
4171 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202013413a7").unwrap();
4172 assert_eq!(encoded_value, target_value);
4176 fn encoding_init() {
4177 let mainnet_hash = ChainHash::using_genesis_block(Network::Bitcoin);
4178 assert_eq!(msgs::Init {
4179 features: InitFeatures::from_le_bytes(vec![0xFF, 0xFF, 0xFF]),
4180 networks: Some(vec![mainnet_hash]),
4181 remote_network_address: None,
4182 }.encode(), <Vec<u8>>::from_hex("00023fff0003ffffff01206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
4183 assert_eq!(msgs::Init {
4184 features: InitFeatures::from_le_bytes(vec![0xFF]),
4186 remote_network_address: None,
4187 }.encode(), <Vec<u8>>::from_hex("0001ff0001ff").unwrap());
4188 assert_eq!(msgs::Init {
4189 features: InitFeatures::from_le_bytes(vec![]),
4190 networks: Some(vec![mainnet_hash]),
4191 remote_network_address: None,
4192 }.encode(), <Vec<u8>>::from_hex("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
4193 assert_eq!(msgs::Init {
4194 features: InitFeatures::from_le_bytes(vec![]),
4195 networks: Some(vec![ChainHash::from(&[1; 32]), ChainHash::from(&[2; 32])]),
4196 remote_network_address: None,
4197 }.encode(), <Vec<u8>>::from_hex("00000000014001010101010101010101010101010101010101010101010101010101010101010202020202020202020202020202020202020202020202020202020202020202").unwrap());
4198 let init_msg = msgs::Init { features: InitFeatures::from_le_bytes(vec![]),
4199 networks: Some(vec![mainnet_hash]),
4200 remote_network_address: Some(SocketAddress::TcpIpV4 {
4201 addr: [127, 0, 0, 1],
4205 let encoded_value = init_msg.encode();
4206 let target_value = <Vec<u8>>::from_hex("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d61900000000000307017f00000103e8").unwrap();
4207 assert_eq!(encoded_value, target_value);
4208 assert_eq!(msgs::Init::read(&mut Cursor::new(&target_value)).unwrap(), init_msg);
4212 fn encoding_error() {
4213 let error = msgs::ErrorMessage {
4214 channel_id: ChannelId::from_bytes([2; 32]),
4215 data: String::from("rust-lightning"),
4217 let encoded_value = error.encode();
4218 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
4219 assert_eq!(encoded_value, target_value);
4223 fn encoding_warning() {
4224 let error = msgs::WarningMessage {
4225 channel_id: ChannelId::from_bytes([2; 32]),
4226 data: String::from("rust-lightning"),
4228 let encoded_value = error.encode();
4229 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
4230 assert_eq!(encoded_value, target_value);
4234 fn encoding_ping() {
4235 let ping = msgs::Ping {
4239 let encoded_value = ping.encode();
4240 let target_value = <Vec<u8>>::from_hex("0040004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
4241 assert_eq!(encoded_value, target_value);
4245 fn encoding_pong() {
4246 let pong = msgs::Pong {
4249 let encoded_value = pong.encode();
4250 let target_value = <Vec<u8>>::from_hex("004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
4251 assert_eq!(encoded_value, target_value);
4255 fn encoding_nonfinal_onion_hop_data() {
4256 let outbound_msg = msgs::OutboundOnionPayload::Forward {
4257 short_channel_id: 0xdeadbeef1bad1dea,
4258 amt_to_forward: 0x0badf00d01020304,
4259 outgoing_cltv_value: 0xffffffff,
4261 let encoded_value = outbound_msg.encode();
4262 let target_value = <Vec<u8>>::from_hex("1a02080badf00d010203040404ffffffff0608deadbeef1bad1dea").unwrap();
4263 assert_eq!(encoded_value, target_value);
4265 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4266 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4267 if let msgs::InboundOnionPayload::Forward {
4268 short_channel_id, amt_to_forward, outgoing_cltv_value
4270 assert_eq!(short_channel_id, 0xdeadbeef1bad1dea);
4271 assert_eq!(amt_to_forward, 0x0badf00d01020304);
4272 assert_eq!(outgoing_cltv_value, 0xffffffff);
4273 } else { panic!(); }
4277 fn encoding_final_onion_hop_data() {
4278 let outbound_msg = msgs::OutboundOnionPayload::Receive {
4280 payment_metadata: None,
4281 keysend_preimage: None,
4282 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4283 cltv_expiry_height: 0xffffffff,
4284 custom_tlvs: vec![],
4286 let encoded_value = outbound_msg.encode();
4287 let target_value = <Vec<u8>>::from_hex("1002080badf00d010203040404ffffffff").unwrap();
4288 assert_eq!(encoded_value, target_value);
4290 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4291 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4292 if let msgs::InboundOnionPayload::Receive {
4293 payment_data: None, sender_intended_htlc_amt_msat, cltv_expiry_height, ..
4295 assert_eq!(sender_intended_htlc_amt_msat, 0x0badf00d01020304);
4296 assert_eq!(cltv_expiry_height, 0xffffffff);
4297 } else { panic!(); }
4301 fn encoding_final_onion_hop_data_with_secret() {
4302 let expected_payment_secret = PaymentSecret([0x42u8; 32]);
4303 let outbound_msg = msgs::OutboundOnionPayload::Receive {
4304 payment_data: Some(FinalOnionHopData {
4305 payment_secret: expected_payment_secret,
4306 total_msat: 0x1badca1f
4308 payment_metadata: None,
4309 keysend_preimage: None,
4310 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4311 cltv_expiry_height: 0xffffffff,
4312 custom_tlvs: vec![],
4314 let encoded_value = outbound_msg.encode();
4315 let target_value = <Vec<u8>>::from_hex("3602080badf00d010203040404ffffffff082442424242424242424242424242424242424242424242424242424242424242421badca1f").unwrap();
4316 assert_eq!(encoded_value, target_value);
4318 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4319 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4320 if let msgs::InboundOnionPayload::Receive {
4321 payment_data: Some(FinalOnionHopData {
4323 total_msat: 0x1badca1f
4325 sender_intended_htlc_amt_msat, cltv_expiry_height,
4326 payment_metadata: None,
4327 keysend_preimage: None,
4330 assert_eq!(payment_secret, expected_payment_secret);
4331 assert_eq!(sender_intended_htlc_amt_msat, 0x0badf00d01020304);
4332 assert_eq!(cltv_expiry_height, 0xffffffff);
4333 assert_eq!(custom_tlvs, vec![]);
4334 } else { panic!(); }
4338 fn encoding_final_onion_hop_data_with_bad_custom_tlvs() {
4339 // If custom TLVs have type number within the range reserved for protocol, treat them as if
4341 let bad_type_range_tlvs = vec![
4342 ((1 << 16) - 4, vec![42]),
4343 ((1 << 16) - 2, vec![42; 32]),
4345 let mut msg = msgs::OutboundOnionPayload::Receive {
4347 payment_metadata: None,
4348 keysend_preimage: None,
4349 custom_tlvs: bad_type_range_tlvs,
4350 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4351 cltv_expiry_height: 0xffffffff,
4353 let encoded_value = msg.encode();
4354 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4355 assert!(msgs::InboundOnionPayload::read(&mut Cursor::new(&encoded_value[..]), (None, &&node_signer)).is_err());
4356 let good_type_range_tlvs = vec![
4357 ((1 << 16) - 3, vec![42]),
4358 ((1 << 16) - 1, vec![42; 32]),
4360 if let msgs::OutboundOnionPayload::Receive { ref mut custom_tlvs, .. } = msg {
4361 *custom_tlvs = good_type_range_tlvs.clone();
4363 let encoded_value = msg.encode();
4364 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&encoded_value[..]), (None, &&node_signer)).unwrap();
4366 msgs::InboundOnionPayload::Receive { custom_tlvs, .. } => assert!(custom_tlvs.is_empty()),
4372 fn encoding_final_onion_hop_data_with_custom_tlvs() {
4373 let expected_custom_tlvs = vec![
4374 (5482373483, vec![0x12, 0x34]),
4375 (5482373487, vec![0x42u8; 8]),
4377 let msg = msgs::OutboundOnionPayload::Receive {
4379 payment_metadata: None,
4380 keysend_preimage: None,
4381 custom_tlvs: expected_custom_tlvs.clone(),
4382 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4383 cltv_expiry_height: 0xffffffff,
4385 let encoded_value = msg.encode();
4386 let target_value = <Vec<u8>>::from_hex("2e02080badf00d010203040404ffffffffff0000000146c6616b021234ff0000000146c6616f084242424242424242").unwrap();
4387 assert_eq!(encoded_value, target_value);
4388 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4389 let inbound_msg: msgs::InboundOnionPayload = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4390 if let msgs::InboundOnionPayload::Receive {
4392 payment_metadata: None,
4393 keysend_preimage: None,
4395 sender_intended_htlc_amt_msat,
4396 cltv_expiry_height: outgoing_cltv_value,
4399 assert_eq!(custom_tlvs, expected_custom_tlvs);
4400 assert_eq!(sender_intended_htlc_amt_msat, 0x0badf00d01020304);
4401 assert_eq!(outgoing_cltv_value, 0xffffffff);
4402 } else { panic!(); }
4406 fn encoding_final_onion_hop_data_with_trampoline_packet() {
4407 let secp_ctx = Secp256k1::new();
4408 let (_private_key, public_key) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4410 let compressed_public_key = public_key.serialize();
4411 assert_eq!(compressed_public_key.len(), 33);
4413 let trampoline_packet = TrampolineOnionPacket {
4416 hop_data: vec![1; 650], // this should be the standard encoded length
4419 let encoded_trampoline_packet = trampoline_packet.encode();
4420 assert_eq!(encoded_trampoline_packet.len(), 716);
4422 let msg = msgs::OutboundOnionPayload::TrampolineEntrypoint {
4423 multipath_trampoline_data: None,
4424 amt_to_forward: 0x0badf00d01020304,
4425 outgoing_cltv_value: 0xffffffff,
4428 let encoded_payload = msg.encode();
4430 let trampoline_type_bytes = &encoded_payload[19..=19];
4431 let mut trampoline_type_cursor = Cursor::new(trampoline_type_bytes);
4432 let trampoline_type_big_size: BigSize = Readable::read(&mut trampoline_type_cursor).unwrap();
4433 assert_eq!(trampoline_type_big_size.0, 20);
4435 let trampoline_length_bytes = &encoded_payload[20..=22];
4436 let mut trampoline_length_cursor = Cursor::new(trampoline_length_bytes);
4437 let trampoline_length_big_size: BigSize = Readable::read(&mut trampoline_length_cursor).unwrap();
4438 assert_eq!(trampoline_length_big_size.0, encoded_trampoline_packet.len() as u64);
4442 fn encoding_final_onion_hop_data_with_eclair_trampoline_packet() {
4443 let public_key = PublicKey::from_slice(&<Vec<u8>>::from_hex("02eec7245d6b7d2ccb30380bfbe2a3648cd7a942653f5aa340edcea1f283686619").unwrap()).unwrap();
4444 let hop_data = <Vec<u8>>::from_hex("cff34152f3a36e52ca94e74927203a560392b9cc7ce3c45809c6be52166c24a595716880f95f178bf5b30ca63141f74db6e92795c6130877cfdac3d4bd3087ee73c65d627ddd709112a848cc99e303f3706509aa43ba7c8a88cba175fccf9a8f5016ef06d3b935dbb15196d7ce16dc1a7157845566901d7b2197e52cab4ce487014b14816e5805f9fcacb4f8f88b8ff176f1b94f6ce6b00bc43221130c17d20ef629db7c5f7eafaa166578c720619561dd14b3277db557ec7dcdb793771aef0f2f667cfdbeae3ac8d331c5994779dffb31e5fc0dbdedc0c592ca6d21c18e47fe3528d6975c19517d7e2ea8c5391cf17d0fe30c80913ed887234ccb48808f7ef9425bcd815c3b586210979e3bb286ef2851bf9ce04e28c40a203df98fd648d2f1936fd2f1def0e77eecb277229b4b682322371c0a1dbfcd723a991993df8cc1f2696b84b055b40a1792a29f710295a18fbd351b0f3ff34cd13941131b8278ba79303c89117120eea691738a9954908195143b039dbeed98f26a92585f3d15cf742c953799d3272e0545e9b744be9d3b4c").unwrap();
4445 let hmac_vector = <Vec<u8>>::from_hex("bb079bfc4b35190eee9f59a1d7b41ba2f773179f322dafb4b1af900c289ebd6c").unwrap();
4446 let mut hmac = [0; 32];
4447 hmac.copy_from_slice(&hmac_vector);
4449 let compressed_public_key = public_key.serialize();
4450 assert_eq!(compressed_public_key.len(), 33);
4452 let trampoline_packet = TrampolineOnionPacket {
4458 let encoded_trampoline_packet = trampoline_packet.encode();
4459 let expected_eclair_trampoline_packet = <Vec<u8>>::from_hex("0002eec7245d6b7d2ccb30380bfbe2a3648cd7a942653f5aa340edcea1f283686619cff34152f3a36e52ca94e74927203a560392b9cc7ce3c45809c6be52166c24a595716880f95f178bf5b30ca63141f74db6e92795c6130877cfdac3d4bd3087ee73c65d627ddd709112a848cc99e303f3706509aa43ba7c8a88cba175fccf9a8f5016ef06d3b935dbb15196d7ce16dc1a7157845566901d7b2197e52cab4ce487014b14816e5805f9fcacb4f8f88b8ff176f1b94f6ce6b00bc43221130c17d20ef629db7c5f7eafaa166578c720619561dd14b3277db557ec7dcdb793771aef0f2f667cfdbeae3ac8d331c5994779dffb31e5fc0dbdedc0c592ca6d21c18e47fe3528d6975c19517d7e2ea8c5391cf17d0fe30c80913ed887234ccb48808f7ef9425bcd815c3b586210979e3bb286ef2851bf9ce04e28c40a203df98fd648d2f1936fd2f1def0e77eecb277229b4b682322371c0a1dbfcd723a991993df8cc1f2696b84b055b40a1792a29f710295a18fbd351b0f3ff34cd13941131b8278ba79303c89117120eea691738a9954908195143b039dbeed98f26a92585f3d15cf742c953799d3272e0545e9b744be9d3b4cbb079bfc4b35190eee9f59a1d7b41ba2f773179f322dafb4b1af900c289ebd6c").unwrap();
4460 assert_eq!(encoded_trampoline_packet, expected_eclair_trampoline_packet);
4464 fn query_channel_range_end_blocknum() {
4465 let tests: Vec<(u32, u32, u32)> = vec![
4466 (10000, 1500, 11500),
4467 (0, 0xffffffff, 0xffffffff),
4468 (1, 0xffffffff, 0xffffffff),
4471 for (first_blocknum, number_of_blocks, expected) in tests.into_iter() {
4472 let sut = msgs::QueryChannelRange {
4473 chain_hash: ChainHash::using_genesis_block(Network::Regtest),
4477 assert_eq!(sut.end_blocknum(), expected);
4482 fn encoding_query_channel_range() {
4483 let mut query_channel_range = msgs::QueryChannelRange {
4484 chain_hash: ChainHash::using_genesis_block(Network::Regtest),
4485 first_blocknum: 100000,
4486 number_of_blocks: 1500,
4488 let encoded_value = query_channel_range.encode();
4489 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000186a0000005dc").unwrap();
4490 assert_eq!(encoded_value, target_value);
4492 query_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4493 assert_eq!(query_channel_range.first_blocknum, 100000);
4494 assert_eq!(query_channel_range.number_of_blocks, 1500);
4498 fn encoding_reply_channel_range() {
4499 do_encoding_reply_channel_range(0);
4500 do_encoding_reply_channel_range(1);
4503 fn do_encoding_reply_channel_range(encoding_type: u8) {
4504 let mut target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000b8a06000005dc01").unwrap();
4505 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4506 let mut reply_channel_range = msgs::ReplyChannelRange {
4507 chain_hash: expected_chain_hash,
4508 first_blocknum: 756230,
4509 number_of_blocks: 1500,
4510 sync_complete: true,
4511 short_channel_ids: vec![0x000000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
4514 if encoding_type == 0 {
4515 target_value.append(&mut <Vec<u8>>::from_hex("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
4516 let encoded_value = reply_channel_range.encode();
4517 assert_eq!(encoded_value, target_value);
4519 reply_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4520 assert_eq!(reply_channel_range.chain_hash, expected_chain_hash);
4521 assert_eq!(reply_channel_range.first_blocknum, 756230);
4522 assert_eq!(reply_channel_range.number_of_blocks, 1500);
4523 assert_eq!(reply_channel_range.sync_complete, true);
4524 assert_eq!(reply_channel_range.short_channel_ids[0], 0x000000000000008e);
4525 assert_eq!(reply_channel_range.short_channel_ids[1], 0x0000000000003c69);
4526 assert_eq!(reply_channel_range.short_channel_ids[2], 0x000000000045a6c4);
4528 target_value.append(&mut <Vec<u8>>::from_hex("001601789c636000833e08659309a65878be010010a9023a").unwrap());
4529 let result: Result<msgs::ReplyChannelRange, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
4530 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
4535 fn encoding_query_short_channel_ids() {
4536 do_encoding_query_short_channel_ids(0);
4537 do_encoding_query_short_channel_ids(1);
4540 fn do_encoding_query_short_channel_ids(encoding_type: u8) {
4541 let mut target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
4542 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4543 let mut query_short_channel_ids = msgs::QueryShortChannelIds {
4544 chain_hash: expected_chain_hash,
4545 short_channel_ids: vec![0x0000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
4548 if encoding_type == 0 {
4549 target_value.append(&mut <Vec<u8>>::from_hex("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
4550 let encoded_value = query_short_channel_ids.encode();
4551 assert_eq!(encoded_value, target_value);
4553 query_short_channel_ids = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4554 assert_eq!(query_short_channel_ids.chain_hash, expected_chain_hash);
4555 assert_eq!(query_short_channel_ids.short_channel_ids[0], 0x000000000000008e);
4556 assert_eq!(query_short_channel_ids.short_channel_ids[1], 0x0000000000003c69);
4557 assert_eq!(query_short_channel_ids.short_channel_ids[2], 0x000000000045a6c4);
4559 target_value.append(&mut <Vec<u8>>::from_hex("001601789c636000833e08659309a65878be010010a9023a").unwrap());
4560 let result: Result<msgs::QueryShortChannelIds, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
4561 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
4566 fn encoding_reply_short_channel_ids_end() {
4567 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4568 let mut reply_short_channel_ids_end = msgs::ReplyShortChannelIdsEnd {
4569 chain_hash: expected_chain_hash,
4570 full_information: true,
4572 let encoded_value = reply_short_channel_ids_end.encode();
4573 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f01").unwrap();
4574 assert_eq!(encoded_value, target_value);
4576 reply_short_channel_ids_end = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4577 assert_eq!(reply_short_channel_ids_end.chain_hash, expected_chain_hash);
4578 assert_eq!(reply_short_channel_ids_end.full_information, true);
4582 fn encoding_gossip_timestamp_filter(){
4583 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4584 let mut gossip_timestamp_filter = msgs::GossipTimestampFilter {
4585 chain_hash: expected_chain_hash,
4586 first_timestamp: 1590000000,
4587 timestamp_range: 0xffff_ffff,
4589 let encoded_value = gossip_timestamp_filter.encode();
4590 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f5ec57980ffffffff").unwrap();
4591 assert_eq!(encoded_value, target_value);
4593 gossip_timestamp_filter = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4594 assert_eq!(gossip_timestamp_filter.chain_hash, expected_chain_hash);
4595 assert_eq!(gossip_timestamp_filter.first_timestamp, 1590000000);
4596 assert_eq!(gossip_timestamp_filter.timestamp_range, 0xffff_ffff);
4600 fn decode_onion_hop_data_len_as_bigsize() {
4601 // Tests that we can decode an onion payload that is >253 bytes.
4602 // Previously, receiving a payload of this size could've caused us to fail to decode a valid
4603 // payload, because we were decoding the length (a BigSize, big-endian) as a VarInt
4606 // Encode a test onion payload with a big custom TLV such that it's >253 bytes, forcing the
4607 // payload length to be encoded over multiple bytes rather than a single u8.
4608 let big_payload = encode_big_payload().unwrap();
4609 let mut rd = Cursor::new(&big_payload[..]);
4611 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4612 <msgs::InboundOnionPayload as ReadableArgs<(Option<PublicKey>, &&test_utils::TestKeysInterface)>>
4613 ::read(&mut rd, (None, &&node_signer)).unwrap();
4615 // see above test, needs to be a separate method for use of the serialization macros.
4616 fn encode_big_payload() -> Result<Vec<u8>, io::Error> {
4617 use crate::util::ser::HighZeroBytesDroppedBigSize;
4618 let payload = msgs::OutboundOnionPayload::Forward {
4619 short_channel_id: 0xdeadbeef1bad1dea,
4620 amt_to_forward: 1000,
4621 outgoing_cltv_value: 0xffffffff,
4623 let mut encoded_payload = Vec::new();
4624 let test_bytes = vec![42u8; 1000];
4625 if let msgs::OutboundOnionPayload::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } = payload {
4626 _encode_varint_length_prefixed_tlv!(&mut encoded_payload, {
4627 (1, test_bytes, required_vec),
4628 (2, HighZeroBytesDroppedBigSize(amt_to_forward), required),
4629 (4, HighZeroBytesDroppedBigSize(outgoing_cltv_value), required),
4630 (6, short_channel_id, required)
4637 #[cfg(feature = "std")]
4638 fn test_socket_address_from_str() {
4639 let tcpip_v4 = SocketAddress::TcpIpV4 {
4640 addr: Ipv4Addr::new(127, 0, 0, 1).octets(),
4643 assert_eq!(tcpip_v4, SocketAddress::from_str("127.0.0.1:1234").unwrap());
4644 assert_eq!(tcpip_v4, SocketAddress::from_str(&tcpip_v4.to_string()).unwrap());
4646 let tcpip_v6 = SocketAddress::TcpIpV6 {
4647 addr: Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1).octets(),
4650 assert_eq!(tcpip_v6, SocketAddress::from_str("[0:0:0:0:0:0:0:1]:1234").unwrap());
4651 assert_eq!(tcpip_v6, SocketAddress::from_str(&tcpip_v6.to_string()).unwrap());
4653 let hostname = SocketAddress::Hostname {
4654 hostname: Hostname::try_from("lightning-node.mydomain.com".to_string()).unwrap(),
4657 assert_eq!(hostname, SocketAddress::from_str("lightning-node.mydomain.com:1234").unwrap());
4658 assert_eq!(hostname, SocketAddress::from_str(&hostname.to_string()).unwrap());
4660 let onion_v2 = SocketAddress::OnionV2 ([40, 4, 64, 185, 202, 19, 162, 75, 90, 200, 38, 7],);
4661 assert_eq!("OnionV2([40, 4, 64, 185, 202, 19, 162, 75, 90, 200, 38, 7])", &onion_v2.to_string());
4662 assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("FACEBOOKCOREWWWI.onion:9735"));
4664 let onion_v3 = SocketAddress::OnionV3 {
4665 ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102, 182, 107, 4, 105, 247, 246, 85,
4666 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31, 33, 71, 3],
4671 assert_eq!(onion_v3, SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion:1234").unwrap());
4672 assert_eq!(onion_v3, SocketAddress::from_str(&onion_v3.to_string()).unwrap());
4674 assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6.onion:1234"));
4675 assert_eq!(Err(SocketAddressParseError::InvalidInput), SocketAddress::from_str("127.0.0.1@1234"));
4676 assert_eq!(Err(SocketAddressParseError::InvalidInput), "".parse::<SocketAddress>());
4677 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:9735:94").is_err());
4678 assert!(SocketAddress::from_str("wrong$%#.com:1234").is_err());
4679 assert_eq!(Err(SocketAddressParseError::InvalidPort), SocketAddress::from_str("example.com:wrong"));
4680 assert!("localhost".parse::<SocketAddress>().is_err());
4681 assert!("localhost:invalid-port".parse::<SocketAddress>().is_err());
4682 assert!( "invalid-onion-v3-hostname.onion:8080".parse::<SocketAddress>().is_err());
4683 assert!("b32.example.onion:invalid-port".parse::<SocketAddress>().is_err());
4684 assert!("invalid-address".parse::<SocketAddress>().is_err());
4685 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:1234").is_err());
4689 #[cfg(feature = "std")]
4690 fn test_socket_address_to_socket_addrs() {
4691 assert_eq!(SocketAddress::TcpIpV4 {addr:[0u8; 4], port: 1337,}.to_socket_addrs().unwrap().next().unwrap(),
4692 SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(0,0,0,0), 1337)));
4693 assert_eq!(SocketAddress::TcpIpV6 {addr:[0u8; 16], port: 1337,}.to_socket_addrs().unwrap().next().unwrap(),
4694 SocketAddr::V6(SocketAddrV6::new(Ipv6Addr::from([0u8; 16]), 1337, 0, 0)));
4695 assert_eq!(SocketAddress::Hostname { hostname: Hostname::try_from("0.0.0.0".to_string()).unwrap(), port: 0 }
4696 .to_socket_addrs().unwrap().next().unwrap(), SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::from([0u8; 4]),0)));
4697 assert!(SocketAddress::OnionV2([0u8; 12]).to_socket_addrs().is_err());
4698 assert!(SocketAddress::OnionV3{ ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102,
4699 182, 107, 4, 105, 247, 246, 85, 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31,
4703 port: 1234 }.to_socket_addrs().is_err());