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::Script;
32 use bitcoin::hash_types::Txid;
34 use crate::blinded_path::payment::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::MessageSendEventsProvider;
56 use crate::util::chacha20poly1305rfc::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, 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, 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, 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, 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, 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, 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, PartialEq, Eq)]
169 /// The pong packet size.
171 /// This field is not sent on the wire. byteslen zeros are sent.
175 /// An [`open_channel`] message to be sent to or received from a peer.
177 /// Used in V1 channel establishment
179 /// [`open_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-open_channel-message
180 #[derive(Clone, Debug, PartialEq, Eq)]
181 pub struct OpenChannel {
182 /// The genesis hash of the blockchain where the channel is to be opened
183 pub chain_hash: ChainHash,
184 /// A temporary channel ID, until the funding outpoint is announced
185 pub temporary_channel_id: ChannelId,
186 /// The channel value
187 pub funding_satoshis: u64,
188 /// The amount to push to the counterparty as part of the open, in milli-satoshi
190 /// The threshold below which outputs on transactions broadcast by sender will be omitted
191 pub dust_limit_satoshis: u64,
192 /// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
193 pub max_htlc_value_in_flight_msat: u64,
194 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
195 pub channel_reserve_satoshis: u64,
196 /// The minimum HTLC size incoming to sender, in milli-satoshi
197 pub htlc_minimum_msat: u64,
198 /// The feerate per 1000-weight of sender generated transactions, until updated by
200 pub feerate_per_kw: u32,
201 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if
202 /// they broadcast a commitment transaction
203 pub to_self_delay: u16,
204 /// The maximum number of inbound HTLCs towards sender
205 pub max_accepted_htlcs: u16,
206 /// The sender's key controlling the funding transaction
207 pub funding_pubkey: PublicKey,
208 /// Used to derive a revocation key for transactions broadcast by counterparty
209 pub revocation_basepoint: PublicKey,
210 /// A payment key to sender for transactions broadcast by counterparty
211 pub payment_point: PublicKey,
212 /// Used to derive a payment key to sender for transactions broadcast by sender
213 pub delayed_payment_basepoint: PublicKey,
214 /// Used to derive an HTLC payment key to sender
215 pub htlc_basepoint: PublicKey,
216 /// The first to-be-broadcast-by-sender 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 /// A request to pre-set the to-sender output's `scriptPubkey` for when we collaboratively close
221 pub shutdown_scriptpubkey: Option<Script>,
222 /// The channel type that this channel will represent
224 /// If this is `None`, we derive the channel type from the intersection of our
225 /// feature bits with our counterparty's feature bits from the [`Init`] message.
226 pub channel_type: Option<ChannelTypeFeatures>,
229 /// An open_channel2 message to be sent by or received from the channel initiator.
231 /// Used in V2 channel establishment
233 // TODO(dual_funding): Add spec link for `open_channel2`.
234 #[derive(Clone, Debug, PartialEq, Eq)]
235 pub struct OpenChannelV2 {
236 /// The genesis hash of the blockchain where the channel is to be opened
237 pub chain_hash: ChainHash,
238 /// A temporary channel ID derived using a zeroed out value for the channel acceptor's revocation basepoint
239 pub temporary_channel_id: ChannelId,
240 /// The feerate for the funding transaction set by the channel initiator
241 pub funding_feerate_sat_per_1000_weight: u32,
242 /// The feerate for the commitment transaction set by the channel initiator
243 pub commitment_feerate_sat_per_1000_weight: u32,
244 /// Part of the channel value contributed by the channel initiator
245 pub funding_satoshis: u64,
246 /// The threshold below which outputs on transactions broadcast by the channel initiator will be
248 pub dust_limit_satoshis: u64,
249 /// The maximum inbound HTLC value in flight towards channel initiator, in milli-satoshi
250 pub max_htlc_value_in_flight_msat: u64,
251 /// The minimum HTLC size incoming to channel initiator, in milli-satoshi
252 pub htlc_minimum_msat: u64,
253 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
254 /// broadcast a commitment transaction
255 pub to_self_delay: u16,
256 /// The maximum number of inbound HTLCs towards channel initiator
257 pub max_accepted_htlcs: u16,
258 /// The locktime for the funding transaction
260 /// The channel initiator's key controlling the funding transaction
261 pub funding_pubkey: PublicKey,
262 /// Used to derive a revocation key for transactions broadcast by counterparty
263 pub revocation_basepoint: PublicKey,
264 /// A payment key to channel initiator for transactions broadcast by counterparty
265 pub payment_basepoint: PublicKey,
266 /// Used to derive a payment key to channel initiator for transactions broadcast by channel
268 pub delayed_payment_basepoint: PublicKey,
269 /// Used to derive an HTLC payment key to channel initiator
270 pub htlc_basepoint: PublicKey,
271 /// The first to-be-broadcast-by-channel-initiator transaction's per commitment point
272 pub first_per_commitment_point: PublicKey,
273 /// The second to-be-broadcast-by-channel-initiator transaction's per commitment point
274 pub second_per_commitment_point: PublicKey,
276 pub channel_flags: u8,
277 /// Optionally, a request to pre-set the to-channel-initiator output's scriptPubkey for when we
278 /// collaboratively close
279 pub shutdown_scriptpubkey: Option<Script>,
280 /// The channel type that this channel will represent. If none is set, we derive the channel
281 /// type from the intersection of our feature bits with our counterparty's feature bits from
282 /// the Init message.
283 pub channel_type: Option<ChannelTypeFeatures>,
284 /// Optionally, a requirement that only confirmed inputs can be added
285 pub require_confirmed_inputs: Option<()>,
288 /// An [`accept_channel`] message to be sent to or received from a peer.
290 /// Used in V1 channel establishment
292 /// [`accept_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-accept_channel-message
293 #[derive(Clone, Debug, PartialEq, Eq)]
294 pub struct AcceptChannel {
295 /// A temporary channel ID, until the funding outpoint is announced
296 pub temporary_channel_id: ChannelId,
297 /// The threshold below which outputs on transactions broadcast by sender will be omitted
298 pub dust_limit_satoshis: u64,
299 /// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
300 pub max_htlc_value_in_flight_msat: u64,
301 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
302 pub channel_reserve_satoshis: u64,
303 /// The minimum HTLC size incoming to sender, in milli-satoshi
304 pub htlc_minimum_msat: u64,
305 /// Minimum depth of the funding transaction before the channel is considered open
306 pub minimum_depth: u32,
307 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they broadcast a commitment transaction
308 pub to_self_delay: u16,
309 /// The maximum number of inbound HTLCs towards sender
310 pub max_accepted_htlcs: u16,
311 /// The sender's key controlling the funding transaction
312 pub funding_pubkey: PublicKey,
313 /// Used to derive a revocation key for transactions broadcast by counterparty
314 pub revocation_basepoint: PublicKey,
315 /// A payment key to sender for transactions broadcast by counterparty
316 pub payment_point: PublicKey,
317 /// Used to derive a payment key to sender for transactions broadcast by sender
318 pub delayed_payment_basepoint: PublicKey,
319 /// Used to derive an HTLC payment key to sender for transactions broadcast by counterparty
320 pub htlc_basepoint: PublicKey,
321 /// The first to-be-broadcast-by-sender transaction's per commitment point
322 pub first_per_commitment_point: PublicKey,
323 /// A request to pre-set the to-sender output's scriptPubkey for when we collaboratively close
324 pub shutdown_scriptpubkey: Option<Script>,
325 /// The channel type that this channel will represent.
327 /// If this is `None`, we derive the channel type from the intersection of
328 /// our feature bits with our counterparty's feature bits from the [`Init`] message.
329 /// This is required to match the equivalent field in [`OpenChannel::channel_type`].
330 pub channel_type: Option<ChannelTypeFeatures>,
332 /// Next nonce the channel initiator should use to create a funding output signature against
333 pub next_local_nonce: Option<musig2::types::PublicNonce>,
336 /// An accept_channel2 message to be sent by or received from the channel accepter.
338 /// Used in V2 channel establishment
340 // TODO(dual_funding): Add spec link for `accept_channel2`.
341 #[derive(Clone, Debug, PartialEq, Eq)]
342 pub struct AcceptChannelV2 {
343 /// The same `temporary_channel_id` received from the initiator's `open_channel2` message.
344 pub temporary_channel_id: ChannelId,
345 /// Part of the channel value contributed by the channel acceptor
346 pub funding_satoshis: u64,
347 /// The threshold below which outputs on transactions broadcast by the channel acceptor will be
349 pub dust_limit_satoshis: u64,
350 /// The maximum inbound HTLC value in flight towards channel acceptor, in milli-satoshi
351 pub max_htlc_value_in_flight_msat: u64,
352 /// The minimum HTLC size incoming to channel acceptor, in milli-satoshi
353 pub htlc_minimum_msat: u64,
354 /// Minimum depth of the funding transaction before the channel is considered open
355 pub minimum_depth: u32,
356 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
357 /// broadcast a commitment transaction
358 pub to_self_delay: u16,
359 /// The maximum number of inbound HTLCs towards channel acceptor
360 pub max_accepted_htlcs: u16,
361 /// The channel acceptor's key controlling the funding transaction
362 pub funding_pubkey: PublicKey,
363 /// Used to derive a revocation key for transactions broadcast by counterparty
364 pub revocation_basepoint: PublicKey,
365 /// A payment key to channel acceptor for transactions broadcast by counterparty
366 pub payment_basepoint: PublicKey,
367 /// Used to derive a payment key to channel acceptor for transactions broadcast by channel
369 pub delayed_payment_basepoint: PublicKey,
370 /// Used to derive an HTLC payment key to channel acceptor for transactions broadcast by counterparty
371 pub htlc_basepoint: PublicKey,
372 /// The first to-be-broadcast-by-channel-acceptor transaction's per commitment point
373 pub first_per_commitment_point: PublicKey,
374 /// The second to-be-broadcast-by-channel-acceptor transaction's per commitment point
375 pub second_per_commitment_point: PublicKey,
376 /// Optionally, a request to pre-set the to-channel-acceptor output's scriptPubkey for when we
377 /// collaboratively close
378 pub shutdown_scriptpubkey: Option<Script>,
379 /// The channel type that this channel will represent. If none is set, we derive the channel
380 /// type from the intersection of our feature bits with our counterparty's feature bits from
381 /// the Init message.
383 /// This is required to match the equivalent field in [`OpenChannelV2::channel_type`].
384 pub channel_type: Option<ChannelTypeFeatures>,
385 /// Optionally, a requirement that only confirmed inputs can be added
386 pub require_confirmed_inputs: Option<()>,
389 /// A [`funding_created`] message to be sent to or received from a peer.
391 /// Used in V1 channel establishment
393 /// [`funding_created`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-funding_created-message
394 #[derive(Clone, Debug, PartialEq, Eq)]
395 pub struct FundingCreated {
396 /// A temporary channel ID, until the funding is established
397 pub temporary_channel_id: ChannelId,
398 /// The funding transaction ID
399 pub funding_txid: Txid,
400 /// The specific output index funding this channel
401 pub funding_output_index: u16,
402 /// The signature of the channel initiator (funder) on the initial commitment transaction
403 pub signature: Signature,
405 /// The partial signature of the channel initiator (funder)
406 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
408 /// Next nonce the channel acceptor should use to finalize the funding output signature
409 pub next_local_nonce: Option<musig2::types::PublicNonce>
412 /// A [`funding_signed`] message to be sent to or received from a peer.
414 /// Used in V1 channel establishment
416 /// [`funding_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-funding_signed-message
417 #[derive(Clone, Debug, PartialEq, Eq)]
418 pub struct FundingSigned {
420 pub channel_id: ChannelId,
421 /// The signature of the channel acceptor (fundee) on the initial commitment transaction
422 pub signature: Signature,
424 /// The partial signature of the channel acceptor (fundee)
425 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
428 /// A [`channel_ready`] message to be sent to or received from a peer.
430 /// [`channel_ready`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-channel_ready-message
431 #[derive(Clone, Debug, PartialEq, Eq)]
432 pub struct ChannelReady {
434 pub channel_id: ChannelId,
435 /// The per-commitment point of the second commitment transaction
436 pub next_per_commitment_point: PublicKey,
437 /// If set, provides a `short_channel_id` alias for this channel.
439 /// The sender will accept payments to be forwarded over this SCID and forward them to this
440 /// messages' recipient.
441 pub short_channel_id_alias: Option<u64>,
444 /// An stfu (quiescence) message to be sent by or received from the stfu initiator.
445 // TODO(splicing): Add spec link for `stfu`; still in draft, using from https://github.com/lightning/bolts/pull/863
446 #[derive(Clone, Debug, PartialEq, Eq)]
448 /// The channel ID where quiescence is intended
449 pub channel_id: ChannelId,
450 /// Initiator flag, 1 if initiating, 0 if replying to an stfu.
454 /// A splice message to be sent by or received from the stfu initiator (splice initiator).
455 // TODO(splicing): Add spec link for `splice`; still in draft, using from https://github.com/lightning/bolts/pull/863
456 #[derive(Clone, Debug, PartialEq, Eq)]
458 /// The channel ID where splicing is intended
459 pub channel_id: ChannelId,
460 /// The genesis hash of the blockchain where the channel is intended to be spliced
461 pub chain_hash: ChainHash,
462 /// The intended change in channel capacity: the amount to be added (positive value)
463 /// or removed (negative value) by the sender (splice initiator) by splicing into/from the channel.
464 pub relative_satoshis: i64,
465 /// The feerate for the new funding transaction, set by the splice initiator
466 pub funding_feerate_perkw: u32,
467 /// The locktime for the new funding transaction
469 /// The key of the sender (splice initiator) controlling the new funding transaction
470 pub funding_pubkey: PublicKey,
473 /// A splice_ack message to be received by or sent to the splice initiator.
475 // TODO(splicing): Add spec link for `splice_ack`; still in draft, using from https://github.com/lightning/bolts/pull/863
476 #[derive(Clone, Debug, PartialEq, Eq)]
477 pub struct SpliceAck {
478 /// The channel ID where splicing is intended
479 pub channel_id: ChannelId,
480 /// The genesis hash of the blockchain where the channel is intended to be spliced
481 pub chain_hash: ChainHash,
482 /// The intended change in channel capacity: the amount to be added (positive value)
483 /// or removed (negative value) by the sender (splice acceptor) by splicing into/from the channel.
484 pub relative_satoshis: i64,
485 /// The key of the sender (splice acceptor) controlling the new funding transaction
486 pub funding_pubkey: PublicKey,
489 /// A splice_locked message to be sent to or received from a peer.
491 // TODO(splicing): Add spec link for `splice_locked`; still in draft, using from https://github.com/lightning/bolts/pull/863
492 #[derive(Clone, Debug, PartialEq, Eq)]
493 pub struct SpliceLocked {
495 pub channel_id: ChannelId,
498 /// A tx_add_input message for adding an input during interactive transaction construction
500 // TODO(dual_funding): Add spec link for `tx_add_input`.
501 #[derive(Clone, Debug, PartialEq, Eq)]
502 pub struct TxAddInput {
504 pub channel_id: ChannelId,
505 /// A randomly chosen unique identifier for this input, which is even for initiators and odd for
508 /// Serialized transaction that contains the output this input spends to verify that it is non
510 pub prevtx: TransactionU16LenLimited,
511 /// The index of the output being spent
513 /// The sequence number of this input
517 /// A tx_add_output message for adding an output during interactive transaction construction.
519 // TODO(dual_funding): Add spec link for `tx_add_output`.
520 #[derive(Clone, Debug, PartialEq, Eq)]
521 pub struct TxAddOutput {
523 pub channel_id: ChannelId,
524 /// A randomly chosen unique identifier for this output, which is even for initiators and odd for
527 /// The satoshi value of the output
529 /// The scriptPubKey for the output
533 /// A tx_remove_input message for removing an input during interactive transaction construction.
535 // TODO(dual_funding): Add spec link for `tx_remove_input`.
536 #[derive(Clone, Debug, PartialEq, Eq)]
537 pub struct TxRemoveInput {
539 pub channel_id: ChannelId,
540 /// The serial ID of the input to be removed
544 /// A tx_remove_output message for removing an output during interactive transaction construction.
546 // TODO(dual_funding): Add spec link for `tx_remove_output`.
547 #[derive(Clone, Debug, PartialEq, Eq)]
548 pub struct TxRemoveOutput {
550 pub channel_id: ChannelId,
551 /// The serial ID of the output to be removed
555 /// A tx_complete message signalling the conclusion of a peer's transaction contributions during
556 /// interactive transaction construction.
558 // TODO(dual_funding): Add spec link for `tx_complete`.
559 #[derive(Clone, Debug, PartialEq, Eq)]
560 pub struct TxComplete {
562 pub channel_id: ChannelId,
565 /// A tx_signatures message containing the sender's signatures for a transaction constructed with
566 /// interactive transaction construction.
568 // TODO(dual_funding): Add spec link for `tx_signatures`.
569 #[derive(Clone, Debug, PartialEq, Eq)]
570 pub struct TxSignatures {
572 pub channel_id: ChannelId,
575 /// The list of witnesses
576 pub witnesses: Vec<Witness>,
579 /// A tx_init_rbf message which initiates a replacement of the transaction after it's been
582 // TODO(dual_funding): Add spec link for `tx_init_rbf`.
583 #[derive(Clone, Debug, PartialEq, Eq)]
584 pub struct TxInitRbf {
586 pub channel_id: ChannelId,
587 /// The locktime of the transaction
589 /// The feerate of the transaction
590 pub feerate_sat_per_1000_weight: u32,
591 /// The number of satoshis the sender will contribute to or, if negative, remove from
592 /// (e.g. splice-out) the funding output of the transaction
593 pub funding_output_contribution: Option<i64>,
596 /// A tx_ack_rbf message which acknowledges replacement of the transaction after it's been
599 // TODO(dual_funding): Add spec link for `tx_ack_rbf`.
600 #[derive(Clone, Debug, PartialEq, Eq)]
601 pub struct TxAckRbf {
603 pub channel_id: ChannelId,
604 /// The number of satoshis the sender will contribute to or, if negative, remove from
605 /// (e.g. splice-out) the funding output of the transaction
606 pub funding_output_contribution: Option<i64>,
609 /// A tx_abort message which signals the cancellation of an in-progress transaction negotiation.
611 // TODO(dual_funding): Add spec link for `tx_abort`.
612 #[derive(Clone, Debug, PartialEq, Eq)]
615 pub channel_id: ChannelId,
620 /// A [`shutdown`] message to be sent to or received from a peer.
622 /// [`shutdown`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-initiation-shutdown
623 #[derive(Clone, Debug, PartialEq, Eq)]
624 pub struct Shutdown {
626 pub channel_id: ChannelId,
627 /// The destination of this peer's funds on closing.
629 /// Must be in one of these forms: P2PKH, P2SH, P2WPKH, P2WSH, P2TR.
630 pub scriptpubkey: Script,
633 /// The minimum and maximum fees which the sender is willing to place on the closing transaction.
635 /// This is provided in [`ClosingSigned`] by both sides to indicate the fee range they are willing
637 #[derive(Clone, Debug, PartialEq, Eq)]
638 pub struct ClosingSignedFeeRange {
639 /// The minimum absolute fee, in satoshis, which the sender is willing to place on the closing
641 pub min_fee_satoshis: u64,
642 /// The maximum absolute fee, in satoshis, which the sender is willing to place on the closing
644 pub max_fee_satoshis: u64,
647 /// A [`closing_signed`] message to be sent to or received from a peer.
649 /// [`closing_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-negotiation-closing_signed
650 #[derive(Clone, Debug, PartialEq, Eq)]
651 pub struct ClosingSigned {
653 pub channel_id: ChannelId,
654 /// The proposed total fee for the closing transaction
655 pub fee_satoshis: u64,
656 /// A signature on the closing transaction
657 pub signature: Signature,
658 /// The minimum and maximum fees which the sender is willing to accept, provided only by new
660 pub fee_range: Option<ClosingSignedFeeRange>,
663 /// An [`update_add_htlc`] message to be sent to or received from a peer.
665 /// [`update_add_htlc`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#adding-an-htlc-update_add_htlc
666 #[derive(Clone, Debug, PartialEq, Eq)]
667 pub struct UpdateAddHTLC {
669 pub channel_id: ChannelId,
672 /// The HTLC value in milli-satoshi
673 pub amount_msat: u64,
674 /// The payment hash, the pre-image of which controls HTLC redemption
675 pub payment_hash: PaymentHash,
676 /// The expiry height of the HTLC
677 pub cltv_expiry: u32,
678 /// The extra fee skimmed by the sender of this message. See
679 /// [`ChannelConfig::accept_underpaying_htlcs`].
681 /// [`ChannelConfig::accept_underpaying_htlcs`]: crate::util::config::ChannelConfig::accept_underpaying_htlcs
682 pub skimmed_fee_msat: Option<u64>,
683 pub(crate) onion_routing_packet: OnionPacket,
686 /// An onion message to be sent to or received from a peer.
688 // TODO: update with link to OM when they are merged into the BOLTs
689 #[derive(Clone, Debug, PartialEq, Eq)]
690 pub struct OnionMessage {
691 /// Used in decrypting the onion packet's payload.
692 pub blinding_point: PublicKey,
693 /// The full onion packet including hop data, pubkey, and hmac
694 pub onion_routing_packet: onion_message::Packet,
697 /// An [`update_fulfill_htlc`] message to be sent to or received from a peer.
699 /// [`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
700 #[derive(Clone, Debug, PartialEq, Eq)]
701 pub struct UpdateFulfillHTLC {
703 pub channel_id: ChannelId,
706 /// The pre-image of the payment hash, allowing HTLC redemption
707 pub payment_preimage: PaymentPreimage,
710 /// An [`update_fail_htlc`] message to be sent to or received from a peer.
712 /// [`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
713 #[derive(Clone, Debug, PartialEq, Eq)]
714 pub struct UpdateFailHTLC {
716 pub channel_id: ChannelId,
719 pub(crate) reason: OnionErrorPacket,
722 /// An [`update_fail_malformed_htlc`] message to be sent to or received from a peer.
724 /// [`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
725 #[derive(Clone, Debug, PartialEq, Eq)]
726 pub struct UpdateFailMalformedHTLC {
728 pub channel_id: ChannelId,
731 pub(crate) sha256_of_onion: [u8; 32],
733 pub failure_code: u16,
736 /// A [`commitment_signed`] message to be sent to or received from a peer.
738 /// [`commitment_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#committing-updates-so-far-commitment_signed
739 #[derive(Clone, Debug, PartialEq, Eq)]
740 pub struct CommitmentSigned {
742 pub channel_id: ChannelId,
743 /// A signature on the commitment transaction
744 pub signature: Signature,
745 /// Signatures on the HTLC transactions
746 pub htlc_signatures: Vec<Signature>,
748 /// The partial Taproot signature on the commitment transaction
749 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
752 /// A [`revoke_and_ack`] message to be sent to or received from a peer.
754 /// [`revoke_and_ack`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#completing-the-transition-to-the-updated-state-revoke_and_ack
755 #[derive(Clone, Debug, PartialEq, Eq)]
756 pub struct RevokeAndACK {
758 pub channel_id: ChannelId,
759 /// The secret corresponding to the per-commitment point
760 pub per_commitment_secret: [u8; 32],
761 /// The next sender-broadcast commitment transaction's per-commitment point
762 pub next_per_commitment_point: PublicKey,
764 /// Musig nonce the recipient should use in their next commitment signature message
765 pub next_local_nonce: Option<musig2::types::PublicNonce>
768 /// An [`update_fee`] message to be sent to or received from a peer
770 /// [`update_fee`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#updating-fees-update_fee
771 #[derive(Clone, Debug, PartialEq, Eq)]
772 pub struct UpdateFee {
774 pub channel_id: ChannelId,
775 /// Fee rate per 1000-weight of the transaction
776 pub feerate_per_kw: u32,
779 /// A [`channel_reestablish`] message to be sent to or received from a peer.
781 /// [`channel_reestablish`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#message-retransmission
782 #[derive(Clone, Debug, PartialEq, Eq)]
783 pub struct ChannelReestablish {
785 pub channel_id: ChannelId,
786 /// The next commitment number for the sender
787 pub next_local_commitment_number: u64,
788 /// The next commitment number for the recipient
789 pub next_remote_commitment_number: u64,
790 /// Proof that the sender knows the per-commitment secret of a specific commitment transaction
791 /// belonging to the recipient
792 pub your_last_per_commitment_secret: [u8; 32],
793 /// The sender's per-commitment point for their current commitment transaction
794 pub my_current_per_commitment_point: PublicKey,
795 /// The next funding transaction ID
796 pub next_funding_txid: Option<Txid>,
799 /// An [`announcement_signatures`] message to be sent to or received from a peer.
801 /// [`announcement_signatures`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-announcement_signatures-message
802 #[derive(Clone, Debug, PartialEq, Eq)]
803 pub struct AnnouncementSignatures {
805 pub channel_id: ChannelId,
806 /// The short channel ID
807 pub short_channel_id: u64,
808 /// A signature by the node key
809 pub node_signature: Signature,
810 /// A signature by the funding key
811 pub bitcoin_signature: Signature,
814 /// An address which can be used to connect to a remote peer.
815 #[derive(Clone, Debug, PartialEq, Eq)]
816 pub enum SocketAddress {
817 /// An IPv4 address and port on which the peer is listening.
819 /// The 4-byte IPv4 address
821 /// The port on which the node is listening
824 /// An IPv6 address and port on which the peer is listening.
826 /// The 16-byte IPv6 address
828 /// The port on which the node is listening
831 /// An old-style Tor onion address/port on which the peer is listening.
833 /// This field is deprecated and the Tor network generally no longer supports V2 Onion
834 /// addresses. Thus, the details are not parsed here.
836 /// A new-style Tor onion address/port on which the peer is listening.
838 /// To create the human-readable "hostname", concatenate the ED25519 pubkey, checksum, and version,
839 /// wrap as base32 and append ".onion".
841 /// The ed25519 long-term public key of the peer
842 ed25519_pubkey: [u8; 32],
843 /// The checksum of the pubkey and version, as included in the onion address
845 /// The version byte, as defined by the Tor Onion v3 spec.
847 /// The port on which the node is listening
850 /// A hostname/port on which the peer is listening.
852 /// The hostname on which the node is listening.
854 /// The port on which the node is listening.
859 /// Gets the ID of this address type. Addresses in [`NodeAnnouncement`] messages should be sorted
861 pub(crate) fn get_id(&self) -> u8 {
863 &SocketAddress::TcpIpV4 {..} => { 1 },
864 &SocketAddress::TcpIpV6 {..} => { 2 },
865 &SocketAddress::OnionV2(_) => { 3 },
866 &SocketAddress::OnionV3 {..} => { 4 },
867 &SocketAddress::Hostname {..} => { 5 },
871 /// Strict byte-length of address descriptor, 1-byte type not recorded
872 fn len(&self) -> u16 {
874 &SocketAddress::TcpIpV4 { .. } => { 6 },
875 &SocketAddress::TcpIpV6 { .. } => { 18 },
876 &SocketAddress::OnionV2(_) => { 12 },
877 &SocketAddress::OnionV3 { .. } => { 37 },
878 // Consists of 1-byte hostname length, hostname bytes, and 2-byte port.
879 &SocketAddress::Hostname { ref hostname, .. } => { u16::from(hostname.len()) + 3 },
883 /// The maximum length of any address descriptor, not including the 1-byte type.
884 /// This maximum length is reached by a hostname address descriptor:
885 /// a hostname with a maximum length of 255, its 1-byte length and a 2-byte port.
886 pub(crate) const MAX_LEN: u16 = 258;
889 impl Writeable for SocketAddress {
890 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
892 &SocketAddress::TcpIpV4 { ref addr, ref port } => {
897 &SocketAddress::TcpIpV6 { ref addr, ref port } => {
902 &SocketAddress::OnionV2(bytes) => {
904 bytes.write(writer)?;
906 &SocketAddress::OnionV3 { ref ed25519_pubkey, ref checksum, ref version, ref port } => {
908 ed25519_pubkey.write(writer)?;
909 checksum.write(writer)?;
910 version.write(writer)?;
913 &SocketAddress::Hostname { ref hostname, ref port } => {
915 hostname.write(writer)?;
923 impl Readable for Result<SocketAddress, u8> {
924 fn read<R: Read>(reader: &mut R) -> Result<Result<SocketAddress, u8>, DecodeError> {
925 let byte = <u8 as Readable>::read(reader)?;
928 Ok(Ok(SocketAddress::TcpIpV4 {
929 addr: Readable::read(reader)?,
930 port: Readable::read(reader)?,
934 Ok(Ok(SocketAddress::TcpIpV6 {
935 addr: Readable::read(reader)?,
936 port: Readable::read(reader)?,
939 3 => Ok(Ok(SocketAddress::OnionV2(Readable::read(reader)?))),
941 Ok(Ok(SocketAddress::OnionV3 {
942 ed25519_pubkey: Readable::read(reader)?,
943 checksum: Readable::read(reader)?,
944 version: Readable::read(reader)?,
945 port: Readable::read(reader)?,
949 Ok(Ok(SocketAddress::Hostname {
950 hostname: Readable::read(reader)?,
951 port: Readable::read(reader)?,
954 _ => return Ok(Err(byte)),
959 impl Readable for SocketAddress {
960 fn read<R: Read>(reader: &mut R) -> Result<SocketAddress, DecodeError> {
961 match Readable::read(reader) {
962 Ok(Ok(res)) => Ok(res),
963 Ok(Err(_)) => Err(DecodeError::UnknownVersion),
969 /// [`SocketAddress`] error variants
970 #[derive(Debug, Eq, PartialEq, Clone)]
971 pub enum SocketAddressParseError {
972 /// Socket address (IPv4/IPv6) parsing error
974 /// Invalid input format
978 /// Invalid onion v3 address
982 impl fmt::Display for SocketAddressParseError {
983 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
985 SocketAddressParseError::SocketAddrParse => write!(f, "Socket address (IPv4/IPv6) parsing error"),
986 SocketAddressParseError::InvalidInput => write!(f, "Invalid input format. \
987 Expected: \"<ipv4>:<port>\", \"[<ipv6>]:<port>\", \"<onion address>.onion:<port>\" or \"<hostname>:<port>\""),
988 SocketAddressParseError::InvalidPort => write!(f, "Invalid port"),
989 SocketAddressParseError::InvalidOnionV3 => write!(f, "Invalid onion v3 address"),
994 #[cfg(feature = "std")]
995 impl From<std::net::SocketAddrV4> for SocketAddress {
996 fn from(addr: std::net::SocketAddrV4) -> Self {
997 SocketAddress::TcpIpV4 { addr: addr.ip().octets(), port: addr.port() }
1001 #[cfg(feature = "std")]
1002 impl From<std::net::SocketAddrV6> for SocketAddress {
1003 fn from(addr: std::net::SocketAddrV6) -> Self {
1004 SocketAddress::TcpIpV6 { addr: addr.ip().octets(), port: addr.port() }
1008 #[cfg(feature = "std")]
1009 impl From<std::net::SocketAddr> for SocketAddress {
1010 fn from(addr: std::net::SocketAddr) -> Self {
1012 std::net::SocketAddr::V4(addr) => addr.into(),
1013 std::net::SocketAddr::V6(addr) => addr.into(),
1018 #[cfg(feature = "std")]
1019 impl std::net::ToSocketAddrs for SocketAddress {
1020 type Iter = std::vec::IntoIter<std::net::SocketAddr>;
1022 fn to_socket_addrs(&self) -> std::io::Result<Self::Iter> {
1024 SocketAddress::TcpIpV4 { addr, port } => {
1025 let ip_addr = std::net::Ipv4Addr::from(*addr);
1026 let socket_addr = SocketAddr::new(ip_addr.into(), *port);
1027 Ok(vec![socket_addr].into_iter())
1029 SocketAddress::TcpIpV6 { addr, port } => {
1030 let ip_addr = std::net::Ipv6Addr::from(*addr);
1031 let socket_addr = SocketAddr::new(ip_addr.into(), *port);
1032 Ok(vec![socket_addr].into_iter())
1034 SocketAddress::Hostname { ref hostname, port } => {
1035 (hostname.as_str(), *port).to_socket_addrs()
1037 SocketAddress::OnionV2(..) => {
1038 Err(std::io::Error::new(std::io::ErrorKind::Other, "Resolution of OnionV2 \
1039 addresses is currently unsupported."))
1041 SocketAddress::OnionV3 { .. } => {
1042 Err(std::io::Error::new(std::io::ErrorKind::Other, "Resolution of OnionV3 \
1043 addresses is currently unsupported."))
1049 /// Parses an OnionV3 host and port into a [`SocketAddress::OnionV3`].
1051 /// The host part must end with ".onion".
1052 pub fn parse_onion_address(host: &str, port: u16) -> Result<SocketAddress, SocketAddressParseError> {
1053 if host.ends_with(".onion") {
1054 let domain = &host[..host.len() - ".onion".len()];
1055 if domain.len() != 56 {
1056 return Err(SocketAddressParseError::InvalidOnionV3);
1058 let onion = base32::Alphabet::RFC4648 { padding: false }.decode(&domain).map_err(|_| SocketAddressParseError::InvalidOnionV3)?;
1059 if onion.len() != 35 {
1060 return Err(SocketAddressParseError::InvalidOnionV3);
1062 let version = onion[0];
1063 let first_checksum_flag = onion[1];
1064 let second_checksum_flag = onion[2];
1065 let mut ed25519_pubkey = [0; 32];
1066 ed25519_pubkey.copy_from_slice(&onion[3..35]);
1067 let checksum = u16::from_be_bytes([first_checksum_flag, second_checksum_flag]);
1068 return Ok(SocketAddress::OnionV3 { ed25519_pubkey, checksum, version, port });
1071 return Err(SocketAddressParseError::InvalidInput);
1075 impl Display for SocketAddress {
1076 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1078 SocketAddress::TcpIpV4{addr, port} => write!(
1079 f, "{}.{}.{}.{}:{}", addr[0], addr[1], addr[2], addr[3], port)?,
1080 SocketAddress::TcpIpV6{addr, port} => write!(
1082 "[{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}]:{}",
1083 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
1085 SocketAddress::OnionV2(bytes) => write!(f, "OnionV2({:?})", bytes)?,
1086 SocketAddress::OnionV3 {
1092 let [first_checksum_flag, second_checksum_flag] = checksum.to_be_bytes();
1093 let mut addr = vec![*version, first_checksum_flag, second_checksum_flag];
1094 addr.extend_from_slice(ed25519_pubkey);
1095 let onion = base32::Alphabet::RFC4648 { padding: false }.encode(&addr);
1096 write!(f, "{}.onion:{}", onion, port)?
1098 SocketAddress::Hostname { hostname, port } => write!(f, "{}:{}", hostname, port)?,
1104 #[cfg(feature = "std")]
1105 impl FromStr for SocketAddress {
1106 type Err = SocketAddressParseError;
1108 fn from_str(s: &str) -> Result<Self, Self::Err> {
1109 match std::net::SocketAddr::from_str(s) {
1110 Ok(addr) => Ok(addr.into()),
1112 let trimmed_input = match s.rfind(":") {
1114 None => return Err(SocketAddressParseError::InvalidInput),
1116 let host = &s[..trimmed_input];
1117 let port: u16 = s[trimmed_input + 1..].parse().map_err(|_| SocketAddressParseError::InvalidPort)?;
1118 if host.ends_with(".onion") {
1119 return parse_onion_address(host, port);
1121 if let Ok(hostname) = Hostname::try_from(s[..trimmed_input].to_string()) {
1122 return Ok(SocketAddress::Hostname { hostname, port });
1124 return Err(SocketAddressParseError::SocketAddrParse)
1130 /// Represents the set of gossip messages that require a signature from a node's identity key.
1131 pub enum UnsignedGossipMessage<'a> {
1132 /// An unsigned channel announcement.
1133 ChannelAnnouncement(&'a UnsignedChannelAnnouncement),
1134 /// An unsigned channel update.
1135 ChannelUpdate(&'a UnsignedChannelUpdate),
1136 /// An unsigned node announcement.
1137 NodeAnnouncement(&'a UnsignedNodeAnnouncement)
1140 impl<'a> Writeable for UnsignedGossipMessage<'a> {
1141 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
1143 UnsignedGossipMessage::ChannelAnnouncement(ref msg) => msg.write(writer),
1144 UnsignedGossipMessage::ChannelUpdate(ref msg) => msg.write(writer),
1145 UnsignedGossipMessage::NodeAnnouncement(ref msg) => msg.write(writer),
1150 /// The unsigned part of a [`node_announcement`] message.
1152 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
1153 #[derive(Clone, Debug, PartialEq, Eq)]
1154 pub struct UnsignedNodeAnnouncement {
1155 /// The advertised features
1156 pub features: NodeFeatures,
1157 /// A strictly monotonic announcement counter, with gaps allowed
1159 /// The `node_id` this announcement originated from (don't rebroadcast the `node_announcement` back
1161 pub node_id: NodeId,
1162 /// An RGB color for UI purposes
1164 /// An alias, for UI purposes.
1166 /// This should be sanitized before use. There is no guarantee of uniqueness.
1167 pub alias: NodeAlias,
1168 /// List of addresses on which this node is reachable
1169 pub addresses: Vec<SocketAddress>,
1170 pub(crate) excess_address_data: Vec<u8>,
1171 pub(crate) excess_data: Vec<u8>,
1173 #[derive(Clone, Debug, PartialEq, Eq)]
1174 /// A [`node_announcement`] message to be sent to or received from a peer.
1176 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
1177 pub struct NodeAnnouncement {
1178 /// The signature by the node key
1179 pub signature: Signature,
1180 /// The actual content of the announcement
1181 pub contents: UnsignedNodeAnnouncement,
1184 /// The unsigned part of a [`channel_announcement`] message.
1186 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
1187 #[derive(Clone, Debug, PartialEq, Eq)]
1188 pub struct UnsignedChannelAnnouncement {
1189 /// The advertised channel features
1190 pub features: ChannelFeatures,
1191 /// The genesis hash of the blockchain where the channel is to be opened
1192 pub chain_hash: ChainHash,
1193 /// The short channel ID
1194 pub short_channel_id: u64,
1195 /// One of the two `node_id`s which are endpoints of this channel
1196 pub node_id_1: NodeId,
1197 /// The other of the two `node_id`s which are endpoints of this channel
1198 pub node_id_2: NodeId,
1199 /// The funding key for the first node
1200 pub bitcoin_key_1: NodeId,
1201 /// The funding key for the second node
1202 pub bitcoin_key_2: NodeId,
1203 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1206 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1207 pub excess_data: Vec<u8>,
1209 /// A [`channel_announcement`] message to be sent to or received from a peer.
1211 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
1212 #[derive(Clone, Debug, PartialEq, Eq)]
1213 pub struct ChannelAnnouncement {
1214 /// Authentication of the announcement by the first public node
1215 pub node_signature_1: Signature,
1216 /// Authentication of the announcement by the second public node
1217 pub node_signature_2: Signature,
1218 /// Proof of funding UTXO ownership by the first public node
1219 pub bitcoin_signature_1: Signature,
1220 /// Proof of funding UTXO ownership by the second public node
1221 pub bitcoin_signature_2: Signature,
1222 /// The actual announcement
1223 pub contents: UnsignedChannelAnnouncement,
1226 /// The unsigned part of a [`channel_update`] message.
1228 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1229 #[derive(Clone, Debug, PartialEq, Eq)]
1230 pub struct UnsignedChannelUpdate {
1231 /// The genesis hash of the blockchain where the channel is to be opened
1232 pub chain_hash: ChainHash,
1233 /// The short channel ID
1234 pub short_channel_id: u64,
1235 /// A strictly monotonic announcement counter, with gaps allowed, specific to this channel
1239 /// The number of blocks such that if:
1240 /// `incoming_htlc.cltv_expiry < outgoing_htlc.cltv_expiry + cltv_expiry_delta`
1241 /// then we need to fail the HTLC backwards. When forwarding an HTLC, `cltv_expiry_delta` determines
1242 /// the outgoing HTLC's minimum `cltv_expiry` value -- so, if an incoming HTLC comes in with a
1243 /// `cltv_expiry` of 100000, and the node we're forwarding to has a `cltv_expiry_delta` value of 10,
1244 /// then we'll check that the outgoing HTLC's `cltv_expiry` value is at least 100010 before
1245 /// forwarding. Note that the HTLC sender is the one who originally sets this value when
1246 /// constructing the route.
1247 pub cltv_expiry_delta: u16,
1248 /// The minimum HTLC size incoming to sender, in milli-satoshi
1249 pub htlc_minimum_msat: u64,
1250 /// The maximum HTLC value incoming to sender, in milli-satoshi.
1252 /// This used to be optional.
1253 pub htlc_maximum_msat: u64,
1254 /// The base HTLC fee charged by sender, in milli-satoshi
1255 pub fee_base_msat: u32,
1256 /// The amount to fee multiplier, in micro-satoshi
1257 pub fee_proportional_millionths: u32,
1258 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1261 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1262 pub excess_data: Vec<u8>,
1264 /// A [`channel_update`] message to be sent to or received from a peer.
1266 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1267 #[derive(Clone, Debug, PartialEq, Eq)]
1268 pub struct ChannelUpdate {
1269 /// A signature of the channel update
1270 pub signature: Signature,
1271 /// The actual channel update
1272 pub contents: UnsignedChannelUpdate,
1275 /// A [`query_channel_range`] message is used to query a peer for channel
1276 /// UTXOs in a range of blocks. The recipient of a query makes a best
1277 /// effort to reply to the query using one or more [`ReplyChannelRange`]
1280 /// [`query_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1281 #[derive(Clone, Debug, PartialEq, Eq)]
1282 pub struct QueryChannelRange {
1283 /// The genesis hash of the blockchain being queried
1284 pub chain_hash: ChainHash,
1285 /// The height of the first block for the channel UTXOs being queried
1286 pub first_blocknum: u32,
1287 /// The number of blocks to include in the query results
1288 pub number_of_blocks: u32,
1291 /// A [`reply_channel_range`] message is a reply to a [`QueryChannelRange`]
1294 /// Multiple `reply_channel_range` messages can be sent in reply
1295 /// to a single [`QueryChannelRange`] message. The query recipient makes a
1296 /// best effort to respond based on their local network view which may
1297 /// not be a perfect view of the network. The `short_channel_id`s in the
1298 /// reply are encoded. We only support `encoding_type=0` uncompressed
1299 /// serialization and do not support `encoding_type=1` zlib serialization.
1301 /// [`reply_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1302 #[derive(Clone, Debug, PartialEq, Eq)]
1303 pub struct ReplyChannelRange {
1304 /// The genesis hash of the blockchain being queried
1305 pub chain_hash: ChainHash,
1306 /// The height of the first block in the range of the reply
1307 pub first_blocknum: u32,
1308 /// The number of blocks included in the range of the reply
1309 pub number_of_blocks: u32,
1310 /// True when this is the final reply for a query
1311 pub sync_complete: bool,
1312 /// The `short_channel_id`s in the channel range
1313 pub short_channel_ids: Vec<u64>,
1316 /// A [`query_short_channel_ids`] message is used to query a peer for
1317 /// routing gossip messages related to one or more `short_channel_id`s.
1319 /// The query recipient will reply with the latest, if available,
1320 /// [`ChannelAnnouncement`], [`ChannelUpdate`] and [`NodeAnnouncement`] messages
1321 /// it maintains for the requested `short_channel_id`s followed by a
1322 /// [`ReplyShortChannelIdsEnd`] message. The `short_channel_id`s sent in
1323 /// this query are encoded. We only support `encoding_type=0` uncompressed
1324 /// serialization and do not support `encoding_type=1` zlib serialization.
1326 /// [`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
1327 #[derive(Clone, Debug, PartialEq, Eq)]
1328 pub struct QueryShortChannelIds {
1329 /// The genesis hash of the blockchain being queried
1330 pub chain_hash: ChainHash,
1331 /// The short_channel_ids that are being queried
1332 pub short_channel_ids: Vec<u64>,
1335 /// A [`reply_short_channel_ids_end`] message is sent as a reply to a
1336 /// message. The query recipient makes a best
1337 /// effort to respond based on their local network view which may not be
1338 /// a perfect view of the network.
1340 /// [`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
1341 #[derive(Clone, Debug, PartialEq, Eq)]
1342 pub struct ReplyShortChannelIdsEnd {
1343 /// The genesis hash of the blockchain that was queried
1344 pub chain_hash: ChainHash,
1345 /// Indicates if the query recipient maintains up-to-date channel
1346 /// information for the `chain_hash`
1347 pub full_information: bool,
1350 /// A [`gossip_timestamp_filter`] message is used by a node to request
1351 /// gossip relay for messages in the requested time range when the
1352 /// `gossip_queries` feature has been negotiated.
1354 /// [`gossip_timestamp_filter`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-gossip_timestamp_filter-message
1355 #[derive(Clone, Debug, PartialEq, Eq)]
1356 pub struct GossipTimestampFilter {
1357 /// The genesis hash of the blockchain for channel and node information
1358 pub chain_hash: ChainHash,
1359 /// The starting unix timestamp
1360 pub first_timestamp: u32,
1361 /// The range of information in seconds
1362 pub timestamp_range: u32,
1365 /// Encoding type for data compression of collections in gossip queries.
1367 /// We do not support `encoding_type=1` zlib serialization [defined in BOLT
1368 /// #7](https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#query-messages).
1370 Uncompressed = 0x00,
1373 /// Used to put an error message in a [`LightningError`].
1374 #[derive(Clone, Debug, PartialEq)]
1375 pub enum ErrorAction {
1376 /// The peer took some action which made us think they were useless. Disconnect them.
1378 /// An error message which we should make an effort to send before we disconnect.
1379 msg: Option<ErrorMessage>
1381 /// The peer did something incorrect. Tell them without closing any channels and disconnect them.
1382 DisconnectPeerWithWarning {
1383 /// A warning message which we should make an effort to send before we disconnect.
1384 msg: WarningMessage,
1386 /// The peer did something harmless that we weren't able to process, just log and ignore
1387 // New code should *not* use this. New code must use IgnoreAndLog, below!
1389 /// The peer did something harmless that we weren't able to meaningfully process.
1390 /// If the error is logged, log it at the given level.
1391 IgnoreAndLog(logger::Level),
1392 /// The peer provided us with a gossip message which we'd already seen. In most cases this
1393 /// should be ignored, but it may result in the message being forwarded if it is a duplicate of
1394 /// our own channel announcements.
1395 IgnoreDuplicateGossip,
1396 /// The peer did something incorrect. Tell them.
1398 /// The message to send.
1401 /// The peer did something incorrect. Tell them without closing any channels.
1402 SendWarningMessage {
1403 /// The message to send.
1404 msg: WarningMessage,
1405 /// The peer may have done something harmless that we weren't able to meaningfully process,
1406 /// though we should still tell them about it.
1407 /// If this event is logged, log it at the given level.
1408 log_level: logger::Level,
1412 /// An Err type for failure to process messages.
1413 #[derive(Clone, Debug)]
1414 pub struct LightningError {
1415 /// A human-readable message describing the error
1417 /// The action which should be taken against the offending peer.
1418 pub action: ErrorAction,
1421 /// Struct used to return values from [`RevokeAndACK`] messages, containing a bunch of commitment
1422 /// transaction updates if they were pending.
1423 #[derive(Clone, Debug, PartialEq, Eq)]
1424 pub struct CommitmentUpdate {
1425 /// `update_add_htlc` messages which should be sent
1426 pub update_add_htlcs: Vec<UpdateAddHTLC>,
1427 /// `update_fulfill_htlc` messages which should be sent
1428 pub update_fulfill_htlcs: Vec<UpdateFulfillHTLC>,
1429 /// `update_fail_htlc` messages which should be sent
1430 pub update_fail_htlcs: Vec<UpdateFailHTLC>,
1431 /// `update_fail_malformed_htlc` messages which should be sent
1432 pub update_fail_malformed_htlcs: Vec<UpdateFailMalformedHTLC>,
1433 /// An `update_fee` message which should be sent
1434 pub update_fee: Option<UpdateFee>,
1435 /// A `commitment_signed` message which should be sent
1436 pub commitment_signed: CommitmentSigned,
1439 /// A trait to describe an object which can receive channel messages.
1441 /// Messages MAY be called in parallel when they originate from different `their_node_ids`, however
1442 /// they MUST NOT be called in parallel when the two calls have the same `their_node_id`.
1443 pub trait ChannelMessageHandler : MessageSendEventsProvider {
1445 /// Handle an incoming `open_channel` message from the given peer.
1446 fn handle_open_channel(&self, their_node_id: &PublicKey, msg: &OpenChannel);
1447 /// Handle an incoming `open_channel2` message from the given peer.
1448 fn handle_open_channel_v2(&self, their_node_id: &PublicKey, msg: &OpenChannelV2);
1449 /// Handle an incoming `accept_channel` message from the given peer.
1450 fn handle_accept_channel(&self, their_node_id: &PublicKey, msg: &AcceptChannel);
1451 /// Handle an incoming `accept_channel2` message from the given peer.
1452 fn handle_accept_channel_v2(&self, their_node_id: &PublicKey, msg: &AcceptChannelV2);
1453 /// Handle an incoming `funding_created` message from the given peer.
1454 fn handle_funding_created(&self, their_node_id: &PublicKey, msg: &FundingCreated);
1455 /// Handle an incoming `funding_signed` message from the given peer.
1456 fn handle_funding_signed(&self, their_node_id: &PublicKey, msg: &FundingSigned);
1457 /// Handle an incoming `channel_ready` message from the given peer.
1458 fn handle_channel_ready(&self, their_node_id: &PublicKey, msg: &ChannelReady);
1461 /// Handle an incoming `shutdown` message from the given peer.
1462 fn handle_shutdown(&self, their_node_id: &PublicKey, msg: &Shutdown);
1463 /// Handle an incoming `closing_signed` message from the given peer.
1464 fn handle_closing_signed(&self, their_node_id: &PublicKey, msg: &ClosingSigned);
1467 /// Handle an incoming `stfu` message from the given peer.
1468 fn handle_stfu(&self, their_node_id: &PublicKey, msg: &Stfu);
1471 /// Handle an incoming `splice` message from the given peer.
1472 fn handle_splice(&self, their_node_id: &PublicKey, msg: &Splice);
1473 /// Handle an incoming `splice_ack` message from the given peer.
1474 fn handle_splice_ack(&self, their_node_id: &PublicKey, msg: &SpliceAck);
1475 /// Handle an incoming `splice_locked` message from the given peer.
1476 fn handle_splice_locked(&self, their_node_id: &PublicKey, msg: &SpliceLocked);
1478 // Interactive channel construction
1479 /// Handle an incoming `tx_add_input message` from the given peer.
1480 fn handle_tx_add_input(&self, their_node_id: &PublicKey, msg: &TxAddInput);
1481 /// Handle an incoming `tx_add_output` message from the given peer.
1482 fn handle_tx_add_output(&self, their_node_id: &PublicKey, msg: &TxAddOutput);
1483 /// Handle an incoming `tx_remove_input` message from the given peer.
1484 fn handle_tx_remove_input(&self, their_node_id: &PublicKey, msg: &TxRemoveInput);
1485 /// Handle an incoming `tx_remove_output` message from the given peer.
1486 fn handle_tx_remove_output(&self, their_node_id: &PublicKey, msg: &TxRemoveOutput);
1487 /// Handle an incoming `tx_complete message` from the given peer.
1488 fn handle_tx_complete(&self, their_node_id: &PublicKey, msg: &TxComplete);
1489 /// Handle an incoming `tx_signatures` message from the given peer.
1490 fn handle_tx_signatures(&self, their_node_id: &PublicKey, msg: &TxSignatures);
1491 /// Handle an incoming `tx_init_rbf` message from the given peer.
1492 fn handle_tx_init_rbf(&self, their_node_id: &PublicKey, msg: &TxInitRbf);
1493 /// Handle an incoming `tx_ack_rbf` message from the given peer.
1494 fn handle_tx_ack_rbf(&self, their_node_id: &PublicKey, msg: &TxAckRbf);
1495 /// Handle an incoming `tx_abort message` from the given peer.
1496 fn handle_tx_abort(&self, their_node_id: &PublicKey, msg: &TxAbort);
1499 /// Handle an incoming `update_add_htlc` message from the given peer.
1500 fn handle_update_add_htlc(&self, their_node_id: &PublicKey, msg: &UpdateAddHTLC);
1501 /// Handle an incoming `update_fulfill_htlc` message from the given peer.
1502 fn handle_update_fulfill_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFulfillHTLC);
1503 /// Handle an incoming `update_fail_htlc` message from the given peer.
1504 fn handle_update_fail_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailHTLC);
1505 /// Handle an incoming `update_fail_malformed_htlc` message from the given peer.
1506 fn handle_update_fail_malformed_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailMalformedHTLC);
1507 /// Handle an incoming `commitment_signed` message from the given peer.
1508 fn handle_commitment_signed(&self, their_node_id: &PublicKey, msg: &CommitmentSigned);
1509 /// Handle an incoming `revoke_and_ack` message from the given peer.
1510 fn handle_revoke_and_ack(&self, their_node_id: &PublicKey, msg: &RevokeAndACK);
1512 /// Handle an incoming `update_fee` message from the given peer.
1513 fn handle_update_fee(&self, their_node_id: &PublicKey, msg: &UpdateFee);
1515 // Channel-to-announce:
1516 /// Handle an incoming `announcement_signatures` message from the given peer.
1517 fn handle_announcement_signatures(&self, their_node_id: &PublicKey, msg: &AnnouncementSignatures);
1519 // Connection loss/reestablish:
1520 /// Indicates a connection to the peer failed/an existing connection was lost.
1521 fn peer_disconnected(&self, their_node_id: &PublicKey);
1523 /// Handle a peer reconnecting, possibly generating `channel_reestablish` message(s).
1525 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1526 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1527 /// message handlers may still wish to communicate with this peer.
1528 fn peer_connected(&self, their_node_id: &PublicKey, msg: &Init, inbound: bool) -> Result<(), ()>;
1529 /// Handle an incoming `channel_reestablish` message from the given peer.
1530 fn handle_channel_reestablish(&self, their_node_id: &PublicKey, msg: &ChannelReestablish);
1532 /// Handle an incoming `channel_update` message from the given peer.
1533 fn handle_channel_update(&self, their_node_id: &PublicKey, msg: &ChannelUpdate);
1536 /// Handle an incoming `error` message from the given peer.
1537 fn handle_error(&self, their_node_id: &PublicKey, msg: &ErrorMessage);
1539 // Handler information:
1540 /// Gets the node feature flags which this handler itself supports. All available handlers are
1541 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1542 /// which are broadcasted in our [`NodeAnnouncement`] message.
1543 fn provided_node_features(&self) -> NodeFeatures;
1545 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1546 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1547 /// which are sent in our [`Init`] message.
1549 /// Note that this method is called before [`Self::peer_connected`].
1550 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1552 /// Gets the chain hashes for this `ChannelMessageHandler` indicating which chains it supports.
1554 /// If it's `None`, then no particular network chain hash compatibility will be enforced when
1555 /// connecting to peers.
1556 fn get_chain_hashes(&self) -> Option<Vec<ChainHash>>;
1559 /// A trait to describe an object which can receive routing messages.
1561 /// # Implementor DoS Warnings
1563 /// For messages enabled with the `gossip_queries` feature there are potential DoS vectors when
1564 /// handling inbound queries. Implementors using an on-disk network graph should be aware of
1565 /// repeated disk I/O for queries accessing different parts of the network graph.
1566 pub trait RoutingMessageHandler : MessageSendEventsProvider {
1567 /// Handle an incoming `node_announcement` message, returning `true` if it should be forwarded on,
1568 /// `false` or returning an `Err` otherwise.
1569 fn handle_node_announcement(&self, msg: &NodeAnnouncement) -> Result<bool, LightningError>;
1570 /// Handle a `channel_announcement` message, returning `true` if it should be forwarded on, `false`
1571 /// or returning an `Err` otherwise.
1572 fn handle_channel_announcement(&self, msg: &ChannelAnnouncement) -> Result<bool, LightningError>;
1573 /// Handle an incoming `channel_update` message, returning true if it should be forwarded on,
1574 /// `false` or returning an `Err` otherwise.
1575 fn handle_channel_update(&self, msg: &ChannelUpdate) -> Result<bool, LightningError>;
1576 /// Gets channel announcements and updates required to dump our routing table to a remote node,
1577 /// starting at the `short_channel_id` indicated by `starting_point` and including announcements
1578 /// for a single channel.
1579 fn get_next_channel_announcement(&self, starting_point: u64) -> Option<(ChannelAnnouncement, Option<ChannelUpdate>, Option<ChannelUpdate>)>;
1580 /// Gets a node announcement required to dump our routing table to a remote node, starting at
1581 /// the node *after* the provided pubkey and including up to one announcement immediately
1582 /// higher (as defined by `<PublicKey as Ord>::cmp`) than `starting_point`.
1583 /// If `None` is provided for `starting_point`, we start at the first node.
1584 fn get_next_node_announcement(&self, starting_point: Option<&NodeId>) -> Option<NodeAnnouncement>;
1585 /// Called when a connection is established with a peer. This can be used to
1586 /// perform routing table synchronization using a strategy defined by the
1589 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1590 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1591 /// message handlers may still wish to communicate with this peer.
1592 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1593 /// Handles the reply of a query we initiated to learn about channels
1594 /// for a given range of blocks. We can expect to receive one or more
1595 /// replies to a single query.
1596 fn handle_reply_channel_range(&self, their_node_id: &PublicKey, msg: ReplyChannelRange) -> Result<(), LightningError>;
1597 /// Handles the reply of a query we initiated asking for routing gossip
1598 /// messages for a list of channels. We should receive this message when
1599 /// a node has completed its best effort to send us the pertaining routing
1600 /// gossip messages.
1601 fn handle_reply_short_channel_ids_end(&self, their_node_id: &PublicKey, msg: ReplyShortChannelIdsEnd) -> Result<(), LightningError>;
1602 /// Handles when a peer asks us to send a list of `short_channel_id`s
1603 /// for the requested range of blocks.
1604 fn handle_query_channel_range(&self, their_node_id: &PublicKey, msg: QueryChannelRange) -> Result<(), LightningError>;
1605 /// Handles when a peer asks us to send routing gossip messages for a
1606 /// list of `short_channel_id`s.
1607 fn handle_query_short_channel_ids(&self, their_node_id: &PublicKey, msg: QueryShortChannelIds) -> Result<(), LightningError>;
1609 // Handler queueing status:
1610 /// Indicates that there are a large number of [`ChannelAnnouncement`] (or other) messages
1611 /// pending some async action. While there is no guarantee of the rate of future messages, the
1612 /// caller should seek to reduce the rate of new gossip messages handled, especially
1613 /// [`ChannelAnnouncement`]s.
1614 fn processing_queue_high(&self) -> bool;
1616 // Handler information:
1617 /// Gets the node feature flags which this handler itself supports. All available handlers are
1618 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1619 /// which are broadcasted in our [`NodeAnnouncement`] message.
1620 fn provided_node_features(&self) -> NodeFeatures;
1621 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1622 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1623 /// which are sent in our [`Init`] message.
1625 /// Note that this method is called before [`Self::peer_connected`].
1626 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1629 /// A handler for received [`OnionMessage`]s and for providing generated ones to send.
1630 pub trait OnionMessageHandler {
1631 /// Handle an incoming `onion_message` message from the given peer.
1632 fn handle_onion_message(&self, peer_node_id: &PublicKey, msg: &OnionMessage);
1634 /// Returns the next pending onion message for the peer with the given node id.
1635 fn next_onion_message_for_peer(&self, peer_node_id: PublicKey) -> Option<OnionMessage>;
1637 /// Called when a connection is established with a peer. Can be used to track which peers
1638 /// advertise onion message support and are online.
1640 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1641 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1642 /// message handlers may still wish to communicate with this peer.
1643 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1645 /// Indicates a connection to the peer failed/an existing connection was lost. Allows handlers to
1646 /// drop and refuse to forward onion messages to this peer.
1647 fn peer_disconnected(&self, their_node_id: &PublicKey);
1649 // Handler information:
1650 /// Gets the node feature flags which this handler itself supports. All available handlers are
1651 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1652 /// which are broadcasted in our [`NodeAnnouncement`] message.
1653 fn provided_node_features(&self) -> NodeFeatures;
1655 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1656 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1657 /// which are sent in our [`Init`] message.
1659 /// Note that this method is called before [`Self::peer_connected`].
1660 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1663 mod fuzzy_internal_msgs {
1664 use bitcoin::secp256k1::PublicKey;
1665 use crate::blinded_path::payment::PaymentConstraints;
1666 use crate::prelude::*;
1667 use crate::ln::{PaymentPreimage, PaymentSecret};
1669 // These types aren't intended to be pub, but are exposed for direct fuzzing (as we deserialize
1670 // them from untrusted input):
1672 pub struct FinalOnionHopData {
1673 pub payment_secret: PaymentSecret,
1674 /// The total value, in msat, of the payment as received by the ultimate recipient.
1675 /// Message serialization may panic if this value is more than 21 million Bitcoin.
1676 pub total_msat: u64,
1679 pub enum InboundOnionPayload {
1681 short_channel_id: u64,
1682 /// The value, in msat, of the payment after this hop's fee is deducted.
1683 amt_to_forward: u64,
1684 outgoing_cltv_value: u32,
1687 payment_data: Option<FinalOnionHopData>,
1688 payment_metadata: Option<Vec<u8>>,
1689 keysend_preimage: Option<PaymentPreimage>,
1690 custom_tlvs: Vec<(u64, Vec<u8>)>,
1692 outgoing_cltv_value: u32,
1697 outgoing_cltv_value: u32,
1698 payment_secret: PaymentSecret,
1699 payment_constraints: PaymentConstraints,
1700 intro_node_blinding_point: PublicKey,
1704 pub(crate) enum OutboundOnionPayload {
1706 short_channel_id: u64,
1707 /// The value, in msat, of the payment after this hop's fee is deducted.
1708 amt_to_forward: u64,
1709 outgoing_cltv_value: u32,
1712 payment_data: Option<FinalOnionHopData>,
1713 payment_metadata: Option<Vec<u8>>,
1714 keysend_preimage: Option<PaymentPreimage>,
1715 custom_tlvs: Vec<(u64, Vec<u8>)>,
1717 outgoing_cltv_value: u32,
1720 encrypted_tlvs: Vec<u8>,
1721 intro_node_blinding_point: Option<PublicKey>,
1726 outgoing_cltv_value: u32,
1727 encrypted_tlvs: Vec<u8>,
1728 intro_node_blinding_point: Option<PublicKey>, // Set if the introduction node of the blinded path is the final node
1732 pub struct DecodedOnionErrorPacket {
1733 pub(crate) hmac: [u8; 32],
1734 pub(crate) failuremsg: Vec<u8>,
1735 pub(crate) pad: Vec<u8>,
1739 pub use self::fuzzy_internal_msgs::*;
1740 #[cfg(not(fuzzing))]
1741 pub(crate) use self::fuzzy_internal_msgs::*;
1743 /// BOLT 4 onion packet including hop data for the next peer.
1745 pub struct OnionPacket {
1746 /// BOLT 4 version number.
1748 /// In order to ensure we always return an error on onion decode in compliance with [BOLT
1749 /// #4](https://github.com/lightning/bolts/blob/master/04-onion-routing.md), we have to
1750 /// deserialize `OnionPacket`s contained in [`UpdateAddHTLC`] messages even if the ephemeral
1751 /// public key (here) is bogus, so we hold a [`Result`] instead of a [`PublicKey`] as we'd
1753 pub public_key: Result<PublicKey, secp256k1::Error>,
1754 /// 1300 bytes encrypted payload for the next hop.
1755 pub hop_data: [u8; 20*65],
1756 /// HMAC to verify the integrity of hop_data.
1760 impl onion_utils::Packet for OnionPacket {
1761 type Data = onion_utils::FixedSizeOnionPacket;
1762 fn new(pubkey: PublicKey, hop_data: onion_utils::FixedSizeOnionPacket, hmac: [u8; 32]) -> Self {
1765 public_key: Ok(pubkey),
1766 hop_data: hop_data.0,
1772 impl Eq for OnionPacket { }
1773 impl PartialEq for OnionPacket {
1774 fn eq(&self, other: &OnionPacket) -> bool {
1775 for (i, j) in self.hop_data.iter().zip(other.hop_data.iter()) {
1776 if i != j { return false; }
1778 self.version == other.version &&
1779 self.public_key == other.public_key &&
1780 self.hmac == other.hmac
1784 impl fmt::Debug for OnionPacket {
1785 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1786 f.write_fmt(format_args!("OnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
1790 #[derive(Clone, Debug, PartialEq, Eq)]
1791 pub(crate) struct OnionErrorPacket {
1792 // This really should be a constant size slice, but the spec lets these things be up to 128KB?
1793 // (TODO) We limit it in decode to much lower...
1794 pub(crate) data: Vec<u8>,
1797 impl fmt::Display for DecodeError {
1798 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1800 DecodeError::UnknownVersion => f.write_str("Unknown realm byte in Onion packet"),
1801 DecodeError::UnknownRequiredFeature => f.write_str("Unknown required feature preventing decode"),
1802 DecodeError::InvalidValue => f.write_str("Nonsense bytes didn't map to the type they were interpreted as"),
1803 DecodeError::ShortRead => f.write_str("Packet extended beyond the provided bytes"),
1804 DecodeError::BadLengthDescriptor => f.write_str("A length descriptor in the packet didn't describe the later data correctly"),
1805 DecodeError::Io(ref e) => fmt::Debug::fmt(e, f),
1806 DecodeError::UnsupportedCompression => f.write_str("We don't support receiving messages with zlib-compressed fields"),
1811 impl From<io::Error> for DecodeError {
1812 fn from(e: io::Error) -> Self {
1813 if e.kind() == io::ErrorKind::UnexpectedEof {
1814 DecodeError::ShortRead
1816 DecodeError::Io(e.kind())
1821 #[cfg(not(taproot))]
1822 impl_writeable_msg!(AcceptChannel, {
1823 temporary_channel_id,
1824 dust_limit_satoshis,
1825 max_htlc_value_in_flight_msat,
1826 channel_reserve_satoshis,
1832 revocation_basepoint,
1834 delayed_payment_basepoint,
1836 first_per_commitment_point,
1838 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1839 (1, channel_type, option),
1843 impl_writeable_msg!(AcceptChannel, {
1844 temporary_channel_id,
1845 dust_limit_satoshis,
1846 max_htlc_value_in_flight_msat,
1847 channel_reserve_satoshis,
1853 revocation_basepoint,
1855 delayed_payment_basepoint,
1857 first_per_commitment_point,
1859 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1860 (1, channel_type, option),
1861 (4, next_local_nonce, option),
1864 impl_writeable_msg!(AcceptChannelV2, {
1865 temporary_channel_id,
1867 dust_limit_satoshis,
1868 max_htlc_value_in_flight_msat,
1874 revocation_basepoint,
1876 delayed_payment_basepoint,
1878 first_per_commitment_point,
1879 second_per_commitment_point,
1881 (0, shutdown_scriptpubkey, option),
1882 (1, channel_type, option),
1883 (2, require_confirmed_inputs, option),
1886 impl_writeable_msg!(Stfu, {
1891 impl_writeable_msg!(Splice, {
1895 funding_feerate_perkw,
1900 impl_writeable_msg!(SpliceAck, {
1907 impl_writeable_msg!(SpliceLocked, {
1911 impl_writeable_msg!(TxAddInput, {
1919 impl_writeable_msg!(TxAddOutput, {
1926 impl_writeable_msg!(TxRemoveInput, {
1931 impl_writeable_msg!(TxRemoveOutput, {
1936 impl_writeable_msg!(TxComplete, {
1940 impl_writeable_msg!(TxSignatures, {
1946 impl_writeable_msg!(TxInitRbf, {
1949 feerate_sat_per_1000_weight,
1951 (0, funding_output_contribution, option),
1954 impl_writeable_msg!(TxAckRbf, {
1957 (0, funding_output_contribution, option),
1960 impl_writeable_msg!(TxAbort, {
1965 impl_writeable_msg!(AnnouncementSignatures, {
1972 impl_writeable_msg!(ChannelReestablish, {
1974 next_local_commitment_number,
1975 next_remote_commitment_number,
1976 your_last_per_commitment_secret,
1977 my_current_per_commitment_point,
1979 (0, next_funding_txid, option),
1982 impl_writeable_msg!(ClosingSigned,
1983 { channel_id, fee_satoshis, signature },
1984 { (1, fee_range, option) }
1987 impl_writeable!(ClosingSignedFeeRange, {
1992 #[cfg(not(taproot))]
1993 impl_writeable_msg!(CommitmentSigned, {
2000 impl_writeable_msg!(CommitmentSigned, {
2005 (2, partial_signature_with_nonce, option)
2008 impl_writeable!(DecodedOnionErrorPacket, {
2014 #[cfg(not(taproot))]
2015 impl_writeable_msg!(FundingCreated, {
2016 temporary_channel_id,
2018 funding_output_index,
2022 impl_writeable_msg!(FundingCreated, {
2023 temporary_channel_id,
2025 funding_output_index,
2028 (2, partial_signature_with_nonce, option),
2029 (4, next_local_nonce, option)
2032 #[cfg(not(taproot))]
2033 impl_writeable_msg!(FundingSigned, {
2039 impl_writeable_msg!(FundingSigned, {
2043 (2, partial_signature_with_nonce, option)
2046 impl_writeable_msg!(ChannelReady, {
2048 next_per_commitment_point,
2050 (1, short_channel_id_alias, option),
2053 impl Writeable for Init {
2054 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2055 // global_features gets the bottom 13 bits of our features, and local_features gets all of
2056 // our relevant feature bits. This keeps us compatible with old nodes.
2057 self.features.write_up_to_13(w)?;
2058 self.features.write(w)?;
2059 encode_tlv_stream!(w, {
2060 (1, self.networks.as_ref().map(|n| WithoutLength(n)), option),
2061 (3, self.remote_network_address, option),
2067 impl Readable for Init {
2068 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2069 let global_features: InitFeatures = Readable::read(r)?;
2070 let features: InitFeatures = Readable::read(r)?;
2071 let mut remote_network_address: Option<SocketAddress> = None;
2072 let mut networks: Option<WithoutLength<Vec<ChainHash>>> = None;
2073 decode_tlv_stream!(r, {
2074 (1, networks, option),
2075 (3, remote_network_address, option)
2078 features: features | global_features,
2079 networks: networks.map(|n| n.0),
2080 remote_network_address,
2085 impl_writeable_msg!(OpenChannel, {
2087 temporary_channel_id,
2090 dust_limit_satoshis,
2091 max_htlc_value_in_flight_msat,
2092 channel_reserve_satoshis,
2098 revocation_basepoint,
2100 delayed_payment_basepoint,
2102 first_per_commitment_point,
2105 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
2106 (1, channel_type, option),
2109 impl_writeable_msg!(OpenChannelV2, {
2111 temporary_channel_id,
2112 funding_feerate_sat_per_1000_weight,
2113 commitment_feerate_sat_per_1000_weight,
2115 dust_limit_satoshis,
2116 max_htlc_value_in_flight_msat,
2122 revocation_basepoint,
2124 delayed_payment_basepoint,
2126 first_per_commitment_point,
2127 second_per_commitment_point,
2130 (0, shutdown_scriptpubkey, option),
2131 (1, channel_type, option),
2132 (2, require_confirmed_inputs, option),
2135 #[cfg(not(taproot))]
2136 impl_writeable_msg!(RevokeAndACK, {
2138 per_commitment_secret,
2139 next_per_commitment_point
2143 impl_writeable_msg!(RevokeAndACK, {
2145 per_commitment_secret,
2146 next_per_commitment_point
2148 (4, next_local_nonce, option)
2151 impl_writeable_msg!(Shutdown, {
2156 impl_writeable_msg!(UpdateFailHTLC, {
2162 impl_writeable_msg!(UpdateFailMalformedHTLC, {
2169 impl_writeable_msg!(UpdateFee, {
2174 impl_writeable_msg!(UpdateFulfillHTLC, {
2180 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2181 // serialization format in a way which assumes we know the total serialized length/message end
2183 impl_writeable!(OnionErrorPacket, {
2187 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2188 // serialization format in a way which assumes we know the total serialized length/message end
2190 impl Writeable for OnionPacket {
2191 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2192 self.version.write(w)?;
2193 match self.public_key {
2194 Ok(pubkey) => pubkey.write(w)?,
2195 Err(_) => [0u8;33].write(w)?,
2197 w.write_all(&self.hop_data)?;
2198 self.hmac.write(w)?;
2203 impl Readable for OnionPacket {
2204 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2206 version: Readable::read(r)?,
2208 let mut buf = [0u8;33];
2209 r.read_exact(&mut buf)?;
2210 PublicKey::from_slice(&buf)
2212 hop_data: Readable::read(r)?,
2213 hmac: Readable::read(r)?,
2218 impl_writeable_msg!(UpdateAddHTLC, {
2224 onion_routing_packet,
2226 (65537, skimmed_fee_msat, option)
2229 impl Readable for OnionMessage {
2230 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2231 let blinding_point: PublicKey = Readable::read(r)?;
2232 let len: u16 = Readable::read(r)?;
2233 let mut packet_reader = FixedLengthReader::new(r, len as u64);
2234 let onion_routing_packet: onion_message::Packet = <onion_message::Packet as LengthReadable>::read(&mut packet_reader)?;
2237 onion_routing_packet,
2242 impl Writeable for OnionMessage {
2243 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2244 self.blinding_point.write(w)?;
2245 let onion_packet_len = self.onion_routing_packet.serialized_length();
2246 (onion_packet_len as u16).write(w)?;
2247 self.onion_routing_packet.write(w)?;
2252 impl Writeable for FinalOnionHopData {
2253 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2254 self.payment_secret.0.write(w)?;
2255 HighZeroBytesDroppedBigSize(self.total_msat).write(w)
2259 impl Readable for FinalOnionHopData {
2260 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2261 let secret: [u8; 32] = Readable::read(r)?;
2262 let amt: HighZeroBytesDroppedBigSize<u64> = Readable::read(r)?;
2263 Ok(Self { payment_secret: PaymentSecret(secret), total_msat: amt.0 })
2267 impl Writeable for OutboundOnionPayload {
2268 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2270 Self::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } => {
2271 _encode_varint_length_prefixed_tlv!(w, {
2272 (2, HighZeroBytesDroppedBigSize(*amt_to_forward), required),
2273 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2274 (6, short_channel_id, required)
2278 ref payment_data, ref payment_metadata, ref keysend_preimage, amt_msat,
2279 outgoing_cltv_value, ref custom_tlvs,
2281 // We need to update [`ln::outbound_payment::RecipientOnionFields::with_custom_tlvs`]
2282 // to reject any reserved types in the experimental range if new ones are ever
2284 let keysend_tlv = keysend_preimage.map(|preimage| (5482373484, preimage.encode()));
2285 let mut custom_tlvs: Vec<&(u64, Vec<u8>)> = custom_tlvs.iter().chain(keysend_tlv.iter()).collect();
2286 custom_tlvs.sort_unstable_by_key(|(typ, _)| *typ);
2287 _encode_varint_length_prefixed_tlv!(w, {
2288 (2, HighZeroBytesDroppedBigSize(*amt_msat), required),
2289 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2290 (8, payment_data, option),
2291 (16, payment_metadata.as_ref().map(|m| WithoutLength(m)), option)
2292 }, custom_tlvs.iter());
2294 Self::BlindedForward { encrypted_tlvs, intro_node_blinding_point } => {
2295 _encode_varint_length_prefixed_tlv!(w, {
2296 (10, *encrypted_tlvs, required_vec),
2297 (12, intro_node_blinding_point, option)
2300 Self::BlindedReceive {
2301 amt_msat, total_msat, outgoing_cltv_value, encrypted_tlvs,
2302 intro_node_blinding_point,
2304 _encode_varint_length_prefixed_tlv!(w, {
2305 (2, HighZeroBytesDroppedBigSize(*amt_msat), required),
2306 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2307 (10, *encrypted_tlvs, required_vec),
2308 (12, intro_node_blinding_point, option),
2309 (18, HighZeroBytesDroppedBigSize(*total_msat), required)
2317 impl<NS: Deref> ReadableArgs<&NS> for InboundOnionPayload where NS::Target: NodeSigner {
2318 fn read<R: Read>(r: &mut R, node_signer: &NS) -> Result<Self, DecodeError> {
2320 let mut cltv_value = None;
2321 let mut short_id: Option<u64> = None;
2322 let mut payment_data: Option<FinalOnionHopData> = None;
2323 let mut encrypted_tlvs_opt: Option<WithoutLength<Vec<u8>>> = None;
2324 let mut intro_node_blinding_point = None;
2325 let mut payment_metadata: Option<WithoutLength<Vec<u8>>> = None;
2326 let mut total_msat = None;
2327 let mut keysend_preimage: Option<PaymentPreimage> = None;
2328 let mut custom_tlvs = Vec::new();
2330 let tlv_len = BigSize::read(r)?;
2331 let rd = FixedLengthReader::new(r, tlv_len.0);
2332 decode_tlv_stream_with_custom_tlv_decode!(rd, {
2333 (2, amt, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2334 (4, cltv_value, (option, encoding: (u32, HighZeroBytesDroppedBigSize))),
2335 (6, short_id, option),
2336 (8, payment_data, option),
2337 (10, encrypted_tlvs_opt, option),
2338 (12, intro_node_blinding_point, option),
2339 (16, payment_metadata, option),
2340 (18, total_msat, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2341 // See https://github.com/lightning/blips/blob/master/blip-0003.md
2342 (5482373484, keysend_preimage, option)
2343 }, |msg_type: u64, msg_reader: &mut FixedLengthReader<_>| -> Result<bool, DecodeError> {
2344 if msg_type < 1 << 16 { return Ok(false) }
2345 let mut value = Vec::new();
2346 msg_reader.read_to_end(&mut value)?;
2347 custom_tlvs.push((msg_type, value));
2351 if amt.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2353 if let Some(blinding_point) = intro_node_blinding_point {
2354 if short_id.is_some() || payment_data.is_some() || payment_metadata.is_some() {
2355 return Err(DecodeError::InvalidValue)
2357 let enc_tlvs = encrypted_tlvs_opt.ok_or(DecodeError::InvalidValue)?.0;
2358 let enc_tlvs_ss = node_signer.ecdh(Recipient::Node, &blinding_point, None)
2359 .map_err(|_| DecodeError::InvalidValue)?;
2360 let rho = onion_utils::gen_rho_from_shared_secret(&enc_tlvs_ss.secret_bytes());
2361 let mut s = Cursor::new(&enc_tlvs);
2362 let mut reader = FixedLengthReader::new(&mut s, enc_tlvs.len() as u64);
2363 match ChaChaPolyReadAdapter::read(&mut reader, rho)? {
2364 ChaChaPolyReadAdapter { readable: ReceiveTlvs { payment_secret, payment_constraints }} => {
2365 if total_msat.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2366 Ok(Self::BlindedReceive {
2367 amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2368 total_msat: total_msat.ok_or(DecodeError::InvalidValue)?,
2369 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2371 payment_constraints,
2372 intro_node_blinding_point: blinding_point,
2376 } else if let Some(short_channel_id) = short_id {
2377 if payment_data.is_some() || payment_metadata.is_some() || encrypted_tlvs_opt.is_some() ||
2378 total_msat.is_some()
2379 { return Err(DecodeError::InvalidValue) }
2382 amt_to_forward: amt.ok_or(DecodeError::InvalidValue)?,
2383 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2386 if encrypted_tlvs_opt.is_some() || total_msat.is_some() {
2387 return Err(DecodeError::InvalidValue)
2389 if let Some(data) = &payment_data {
2390 if data.total_msat > MAX_VALUE_MSAT {
2391 return Err(DecodeError::InvalidValue);
2396 payment_metadata: payment_metadata.map(|w| w.0),
2398 amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2399 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2406 impl Writeable for Ping {
2407 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2408 self.ponglen.write(w)?;
2409 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2414 impl Readable for Ping {
2415 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2417 ponglen: Readable::read(r)?,
2419 let byteslen = Readable::read(r)?;
2420 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2427 impl Writeable for Pong {
2428 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2429 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2434 impl Readable for Pong {
2435 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2438 let byteslen = Readable::read(r)?;
2439 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2446 impl Writeable for UnsignedChannelAnnouncement {
2447 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2448 self.features.write(w)?;
2449 self.chain_hash.write(w)?;
2450 self.short_channel_id.write(w)?;
2451 self.node_id_1.write(w)?;
2452 self.node_id_2.write(w)?;
2453 self.bitcoin_key_1.write(w)?;
2454 self.bitcoin_key_2.write(w)?;
2455 w.write_all(&self.excess_data[..])?;
2460 impl Readable for UnsignedChannelAnnouncement {
2461 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2463 features: Readable::read(r)?,
2464 chain_hash: Readable::read(r)?,
2465 short_channel_id: Readable::read(r)?,
2466 node_id_1: Readable::read(r)?,
2467 node_id_2: Readable::read(r)?,
2468 bitcoin_key_1: Readable::read(r)?,
2469 bitcoin_key_2: Readable::read(r)?,
2470 excess_data: read_to_end(r)?,
2475 impl_writeable!(ChannelAnnouncement, {
2478 bitcoin_signature_1,
2479 bitcoin_signature_2,
2483 impl Writeable for UnsignedChannelUpdate {
2484 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2485 // `message_flags` used to indicate presence of `htlc_maximum_msat`, but was deprecated in the spec.
2486 const MESSAGE_FLAGS: u8 = 1;
2487 self.chain_hash.write(w)?;
2488 self.short_channel_id.write(w)?;
2489 self.timestamp.write(w)?;
2490 let all_flags = self.flags as u16 | ((MESSAGE_FLAGS as u16) << 8);
2491 all_flags.write(w)?;
2492 self.cltv_expiry_delta.write(w)?;
2493 self.htlc_minimum_msat.write(w)?;
2494 self.fee_base_msat.write(w)?;
2495 self.fee_proportional_millionths.write(w)?;
2496 self.htlc_maximum_msat.write(w)?;
2497 w.write_all(&self.excess_data[..])?;
2502 impl Readable for UnsignedChannelUpdate {
2503 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2505 chain_hash: Readable::read(r)?,
2506 short_channel_id: Readable::read(r)?,
2507 timestamp: Readable::read(r)?,
2509 let flags: u16 = Readable::read(r)?;
2510 // Note: we ignore the `message_flags` for now, since it was deprecated by the spec.
2513 cltv_expiry_delta: Readable::read(r)?,
2514 htlc_minimum_msat: Readable::read(r)?,
2515 fee_base_msat: Readable::read(r)?,
2516 fee_proportional_millionths: Readable::read(r)?,
2517 htlc_maximum_msat: Readable::read(r)?,
2518 excess_data: read_to_end(r)?,
2523 impl_writeable!(ChannelUpdate, {
2528 impl Writeable for ErrorMessage {
2529 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2530 self.channel_id.write(w)?;
2531 (self.data.len() as u16).write(w)?;
2532 w.write_all(self.data.as_bytes())?;
2537 impl Readable for ErrorMessage {
2538 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2540 channel_id: Readable::read(r)?,
2542 let sz: usize = <u16 as Readable>::read(r)? as usize;
2543 let mut data = Vec::with_capacity(sz);
2545 r.read_exact(&mut data)?;
2546 match String::from_utf8(data) {
2548 Err(_) => return Err(DecodeError::InvalidValue),
2555 impl Writeable for WarningMessage {
2556 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2557 self.channel_id.write(w)?;
2558 (self.data.len() as u16).write(w)?;
2559 w.write_all(self.data.as_bytes())?;
2564 impl Readable for WarningMessage {
2565 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2567 channel_id: Readable::read(r)?,
2569 let sz: usize = <u16 as Readable>::read(r)? as usize;
2570 let mut data = Vec::with_capacity(sz);
2572 r.read_exact(&mut data)?;
2573 match String::from_utf8(data) {
2575 Err(_) => return Err(DecodeError::InvalidValue),
2582 impl Writeable for UnsignedNodeAnnouncement {
2583 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2584 self.features.write(w)?;
2585 self.timestamp.write(w)?;
2586 self.node_id.write(w)?;
2587 w.write_all(&self.rgb)?;
2588 self.alias.write(w)?;
2590 let mut addr_len = 0;
2591 for addr in self.addresses.iter() {
2592 addr_len += 1 + addr.len();
2594 (addr_len + self.excess_address_data.len() as u16).write(w)?;
2595 for addr in self.addresses.iter() {
2598 w.write_all(&self.excess_address_data[..])?;
2599 w.write_all(&self.excess_data[..])?;
2604 impl Readable for UnsignedNodeAnnouncement {
2605 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2606 let features: NodeFeatures = Readable::read(r)?;
2607 let timestamp: u32 = Readable::read(r)?;
2608 let node_id: NodeId = Readable::read(r)?;
2609 let mut rgb = [0; 3];
2610 r.read_exact(&mut rgb)?;
2611 let alias: NodeAlias = Readable::read(r)?;
2613 let addr_len: u16 = Readable::read(r)?;
2614 let mut addresses: Vec<SocketAddress> = Vec::new();
2615 let mut addr_readpos = 0;
2616 let mut excess = false;
2617 let mut excess_byte = 0;
2619 if addr_len <= addr_readpos { break; }
2620 match Readable::read(r) {
2622 if addr_len < addr_readpos + 1 + addr.len() {
2623 return Err(DecodeError::BadLengthDescriptor);
2625 addr_readpos += (1 + addr.len()) as u16;
2626 addresses.push(addr);
2628 Ok(Err(unknown_descriptor)) => {
2630 excess_byte = unknown_descriptor;
2633 Err(DecodeError::ShortRead) => return Err(DecodeError::BadLengthDescriptor),
2634 Err(e) => return Err(e),
2638 let mut excess_data = vec![];
2639 let excess_address_data = if addr_readpos < addr_len {
2640 let mut excess_address_data = vec![0; (addr_len - addr_readpos) as usize];
2641 r.read_exact(&mut excess_address_data[if excess { 1 } else { 0 }..])?;
2643 excess_address_data[0] = excess_byte;
2648 excess_data.push(excess_byte);
2652 excess_data.extend(read_to_end(r)?.iter());
2653 Ok(UnsignedNodeAnnouncement {
2660 excess_address_data,
2666 impl_writeable!(NodeAnnouncement, {
2671 impl Readable for QueryShortChannelIds {
2672 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2673 let chain_hash: ChainHash = Readable::read(r)?;
2675 let encoding_len: u16 = Readable::read(r)?;
2676 let encoding_type: u8 = Readable::read(r)?;
2678 // Must be encoding_type=0 uncompressed serialization. We do not
2679 // support encoding_type=1 zlib serialization.
2680 if encoding_type != EncodingType::Uncompressed as u8 {
2681 return Err(DecodeError::UnsupportedCompression);
2684 // We expect the encoding_len to always includes the 1-byte
2685 // encoding_type and that short_channel_ids are 8-bytes each
2686 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2687 return Err(DecodeError::InvalidValue);
2690 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2691 // less the 1-byte encoding_type
2692 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2693 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2694 for _ in 0..short_channel_id_count {
2695 short_channel_ids.push(Readable::read(r)?);
2698 Ok(QueryShortChannelIds {
2705 impl Writeable for QueryShortChannelIds {
2706 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2707 // Calculated from 1-byte encoding_type plus 8-bytes per short_channel_id
2708 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2710 self.chain_hash.write(w)?;
2711 encoding_len.write(w)?;
2713 // We only support type=0 uncompressed serialization
2714 (EncodingType::Uncompressed as u8).write(w)?;
2716 for scid in self.short_channel_ids.iter() {
2724 impl_writeable_msg!(ReplyShortChannelIdsEnd, {
2729 impl QueryChannelRange {
2730 /// Calculates the overflow safe ending block height for the query.
2732 /// Overflow returns `0xffffffff`, otherwise returns `first_blocknum + number_of_blocks`.
2733 pub fn end_blocknum(&self) -> u32 {
2734 match self.first_blocknum.checked_add(self.number_of_blocks) {
2735 Some(block) => block,
2736 None => u32::max_value(),
2741 impl_writeable_msg!(QueryChannelRange, {
2747 impl Readable for ReplyChannelRange {
2748 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2749 let chain_hash: ChainHash = Readable::read(r)?;
2750 let first_blocknum: u32 = Readable::read(r)?;
2751 let number_of_blocks: u32 = Readable::read(r)?;
2752 let sync_complete: bool = Readable::read(r)?;
2754 let encoding_len: u16 = Readable::read(r)?;
2755 let encoding_type: u8 = Readable::read(r)?;
2757 // Must be encoding_type=0 uncompressed serialization. We do not
2758 // support encoding_type=1 zlib serialization.
2759 if encoding_type != EncodingType::Uncompressed as u8 {
2760 return Err(DecodeError::UnsupportedCompression);
2763 // We expect the encoding_len to always includes the 1-byte
2764 // encoding_type and that short_channel_ids are 8-bytes each
2765 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2766 return Err(DecodeError::InvalidValue);
2769 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2770 // less the 1-byte encoding_type
2771 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2772 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2773 for _ in 0..short_channel_id_count {
2774 short_channel_ids.push(Readable::read(r)?);
2777 Ok(ReplyChannelRange {
2787 impl Writeable for ReplyChannelRange {
2788 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2789 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2790 self.chain_hash.write(w)?;
2791 self.first_blocknum.write(w)?;
2792 self.number_of_blocks.write(w)?;
2793 self.sync_complete.write(w)?;
2795 encoding_len.write(w)?;
2796 (EncodingType::Uncompressed as u8).write(w)?;
2797 for scid in self.short_channel_ids.iter() {
2805 impl_writeable_msg!(GossipTimestampFilter, {
2813 use std::convert::TryFrom;
2814 use bitcoin::{Transaction, PackedLockTime, TxIn, Script, Sequence, Witness, TxOut};
2816 use crate::ln::{PaymentPreimage, PaymentHash, PaymentSecret};
2817 use crate::ln::ChannelId;
2818 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
2819 use crate::ln::msgs::{self, FinalOnionHopData, OnionErrorPacket};
2820 use crate::ln::msgs::SocketAddress;
2821 use crate::routing::gossip::{NodeAlias, NodeId};
2822 use crate::util::ser::{Writeable, Readable, ReadableArgs, Hostname, TransactionU16LenLimited};
2823 use crate::util::test_utils;
2825 use bitcoin::hashes::hex::FromHex;
2826 use bitcoin::util::address::Address;
2827 use bitcoin::network::constants::Network;
2828 use bitcoin::blockdata::constants::ChainHash;
2829 use bitcoin::blockdata::script::Builder;
2830 use bitcoin::blockdata::opcodes;
2831 use bitcoin::hash_types::Txid;
2833 use bitcoin::secp256k1::{PublicKey,SecretKey};
2834 use bitcoin::secp256k1::{Secp256k1, Message};
2836 use crate::io::{self, Cursor};
2837 use crate::prelude::*;
2838 use core::str::FromStr;
2839 use crate::chain::transaction::OutPoint;
2841 #[cfg(feature = "std")]
2842 use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6, ToSocketAddrs};
2843 #[cfg(feature = "std")]
2844 use crate::ln::msgs::SocketAddressParseError;
2847 fn encoding_channel_reestablish() {
2849 let secp_ctx = Secp256k1::new();
2850 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2853 let cr = msgs::ChannelReestablish {
2854 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]),
2855 next_local_commitment_number: 3,
2856 next_remote_commitment_number: 4,
2857 your_last_per_commitment_secret: [9;32],
2858 my_current_per_commitment_point: public_key,
2859 next_funding_txid: None,
2862 let encoded_value = cr.encode();
2866 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
2867 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2868 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2869 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
2870 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
2876 fn encoding_channel_reestablish_with_next_funding_txid() {
2878 let secp_ctx = Secp256k1::new();
2879 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2882 let cr = msgs::ChannelReestablish {
2883 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]),
2884 next_local_commitment_number: 3,
2885 next_remote_commitment_number: 4,
2886 your_last_per_commitment_secret: [9;32],
2887 my_current_per_commitment_point: public_key,
2888 next_funding_txid: Some(Txid::from_hash(bitcoin::hashes::Hash::from_slice(&[
2889 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,
2893 let encoded_value = cr.encode();
2897 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
2898 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2899 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2900 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
2901 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
2902 0, // Type (next_funding_txid)
2904 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
2909 macro_rules! get_keys_from {
2910 ($slice: expr, $secp_ctx: expr) => {
2912 let privkey = SecretKey::from_slice(&hex::decode($slice).unwrap()[..]).unwrap();
2913 let pubkey = PublicKey::from_secret_key(&$secp_ctx, &privkey);
2919 macro_rules! get_sig_on {
2920 ($privkey: expr, $ctx: expr, $string: expr) => {
2922 let sighash = Message::from_slice(&$string.into_bytes()[..]).unwrap();
2923 $ctx.sign_ecdsa(&sighash, &$privkey)
2929 fn encoding_announcement_signatures() {
2930 let secp_ctx = Secp256k1::new();
2931 let (privkey, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2932 let sig_1 = get_sig_on!(privkey, secp_ctx, String::from("01010101010101010101010101010101"));
2933 let sig_2 = get_sig_on!(privkey, secp_ctx, String::from("02020202020202020202020202020202"));
2934 let announcement_signatures = msgs::AnnouncementSignatures {
2935 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]),
2936 short_channel_id: 2316138423780173,
2937 node_signature: sig_1,
2938 bitcoin_signature: sig_2,
2941 let encoded_value = announcement_signatures.encode();
2942 assert_eq!(encoded_value, hex::decode("040000000000000005000000000000000600000000000000070000000000000000083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073acf9953cef4700860f5967838eba2bae89288ad188ebf8b20bf995c3ea53a26df1876d0a3a0e13172ba286a673140190c02ba9da60a2e43a745188c8a83c7f3ef").unwrap());
2945 fn do_encoding_channel_announcement(unknown_features_bits: bool, excess_data: bool) {
2946 let secp_ctx = Secp256k1::new();
2947 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2948 let (privkey_2, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2949 let (privkey_3, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2950 let (privkey_4, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2951 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2952 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
2953 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
2954 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
2955 let mut features = ChannelFeatures::empty();
2956 if unknown_features_bits {
2957 features = ChannelFeatures::from_le_bytes(vec![0xFF, 0xFF]);
2959 let unsigned_channel_announcement = msgs::UnsignedChannelAnnouncement {
2961 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
2962 short_channel_id: 2316138423780173,
2963 node_id_1: NodeId::from_pubkey(&pubkey_1),
2964 node_id_2: NodeId::from_pubkey(&pubkey_2),
2965 bitcoin_key_1: NodeId::from_pubkey(&pubkey_3),
2966 bitcoin_key_2: NodeId::from_pubkey(&pubkey_4),
2967 excess_data: if excess_data { vec![10, 0, 0, 20, 0, 0, 30, 0, 0, 40] } else { Vec::new() },
2969 let channel_announcement = msgs::ChannelAnnouncement {
2970 node_signature_1: sig_1,
2971 node_signature_2: sig_2,
2972 bitcoin_signature_1: sig_3,
2973 bitcoin_signature_2: sig_4,
2974 contents: unsigned_channel_announcement,
2976 let encoded_value = channel_announcement.encode();
2977 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a1735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap();
2978 if unknown_features_bits {
2979 target_value.append(&mut hex::decode("0002ffff").unwrap());
2981 target_value.append(&mut hex::decode("0000").unwrap());
2983 target_value.append(&mut hex::decode("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
2984 target_value.append(&mut hex::decode("00083a840000034d031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
2986 target_value.append(&mut hex::decode("0a00001400001e000028").unwrap());
2988 assert_eq!(encoded_value, target_value);
2992 fn encoding_channel_announcement() {
2993 do_encoding_channel_announcement(true, false);
2994 do_encoding_channel_announcement(false, true);
2995 do_encoding_channel_announcement(false, false);
2996 do_encoding_channel_announcement(true, true);
2999 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) {
3000 let secp_ctx = Secp256k1::new();
3001 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3002 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3003 let features = if unknown_features_bits {
3004 NodeFeatures::from_le_bytes(vec![0xFF, 0xFF])
3006 // Set to some features we may support
3007 NodeFeatures::from_le_bytes(vec![2 | 1 << 5])
3009 let mut addresses = Vec::new();
3011 addresses.push(SocketAddress::TcpIpV4 {
3012 addr: [255, 254, 253, 252],
3017 addresses.push(SocketAddress::TcpIpV6 {
3018 addr: [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240],
3023 addresses.push(msgs::SocketAddress::OnionV2(
3024 [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 38, 7]
3028 addresses.push(msgs::SocketAddress::OnionV3 {
3029 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],
3036 addresses.push(SocketAddress::Hostname {
3037 hostname: Hostname::try_from(String::from("host")).unwrap(),
3041 let mut addr_len = 0;
3042 for addr in &addresses {
3043 addr_len += addr.len() + 1;
3045 let unsigned_node_announcement = msgs::UnsignedNodeAnnouncement {
3047 timestamp: 20190119,
3048 node_id: NodeId::from_pubkey(&pubkey_1),
3050 alias: NodeAlias([16;32]),
3052 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() },
3053 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() },
3055 addr_len += unsigned_node_announcement.excess_address_data.len() as u16;
3056 let node_announcement = msgs::NodeAnnouncement {
3058 contents: unsigned_node_announcement,
3060 let encoded_value = node_announcement.encode();
3061 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3062 if unknown_features_bits {
3063 target_value.append(&mut hex::decode("0002ffff").unwrap());
3065 target_value.append(&mut hex::decode("000122").unwrap());
3067 target_value.append(&mut hex::decode("013413a7031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f2020201010101010101010101010101010101010101010101010101010101010101010").unwrap());
3068 target_value.append(&mut vec![(addr_len >> 8) as u8, addr_len as u8]);
3070 target_value.append(&mut hex::decode("01fffefdfc2607").unwrap());
3073 target_value.append(&mut hex::decode("02fffefdfcfbfaf9f8f7f6f5f4f3f2f1f02607").unwrap());
3076 target_value.append(&mut hex::decode("03fffefdfcfbfaf9f8f7f62607").unwrap());
3079 target_value.append(&mut hex::decode("04fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0efeeedecebeae9e8e7e6e5e4e3e2e1e00020102607").unwrap());
3082 target_value.append(&mut hex::decode("0504686f73742607").unwrap());
3084 if excess_address_data {
3085 target_value.append(&mut hex::decode("216c280b5395a2546e7e4b2663e04f811622f15a4f92e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d269").unwrap());
3088 target_value.append(&mut hex::decode("3b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
3090 assert_eq!(encoded_value, target_value);
3094 fn encoding_node_announcement() {
3095 do_encoding_node_announcement(true, true, true, true, true, true, true, true);
3096 do_encoding_node_announcement(false, false, false, false, false, false, false, false);
3097 do_encoding_node_announcement(false, true, false, false, false, false, false, false);
3098 do_encoding_node_announcement(false, false, true, false, false, false, false, false);
3099 do_encoding_node_announcement(false, false, false, true, false, false, false, false);
3100 do_encoding_node_announcement(false, false, false, false, true, false, false, false);
3101 do_encoding_node_announcement(false, false, false, false, false, true, false, false);
3102 do_encoding_node_announcement(false, false, false, false, false, false, true, false);
3103 do_encoding_node_announcement(false, true, false, true, false, false, true, false);
3104 do_encoding_node_announcement(false, false, true, false, true, false, false, false);
3107 fn do_encoding_channel_update(direction: bool, disable: bool, excess_data: bool) {
3108 let secp_ctx = Secp256k1::new();
3109 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3110 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3111 let unsigned_channel_update = msgs::UnsignedChannelUpdate {
3112 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3113 short_channel_id: 2316138423780173,
3114 timestamp: 20190119,
3115 flags: if direction { 1 } else { 0 } | if disable { 1 << 1 } else { 0 },
3116 cltv_expiry_delta: 144,
3117 htlc_minimum_msat: 1000000,
3118 htlc_maximum_msat: 131355275467161,
3119 fee_base_msat: 10000,
3120 fee_proportional_millionths: 20,
3121 excess_data: if excess_data { vec![0, 0, 0, 0, 59, 154, 202, 0] } else { Vec::new() }
3123 let channel_update = msgs::ChannelUpdate {
3125 contents: unsigned_channel_update
3127 let encoded_value = channel_update.encode();
3128 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3129 target_value.append(&mut hex::decode("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3130 target_value.append(&mut hex::decode("00083a840000034d013413a7").unwrap());
3131 target_value.append(&mut hex::decode("01").unwrap());
3132 target_value.append(&mut hex::decode("00").unwrap());
3134 let flag = target_value.last_mut().unwrap();
3138 let flag = target_value.last_mut().unwrap();
3139 *flag = *flag | 1 << 1;
3141 target_value.append(&mut hex::decode("009000000000000f42400000271000000014").unwrap());
3142 target_value.append(&mut hex::decode("0000777788889999").unwrap());
3144 target_value.append(&mut hex::decode("000000003b9aca00").unwrap());
3146 assert_eq!(encoded_value, target_value);
3150 fn encoding_channel_update() {
3151 do_encoding_channel_update(false, false, false);
3152 do_encoding_channel_update(false, false, true);
3153 do_encoding_channel_update(true, false, false);
3154 do_encoding_channel_update(true, false, true);
3155 do_encoding_channel_update(false, true, false);
3156 do_encoding_channel_update(false, true, true);
3157 do_encoding_channel_update(true, true, false);
3158 do_encoding_channel_update(true, true, true);
3161 fn do_encoding_open_channel(random_bit: bool, shutdown: bool, incl_chan_type: bool) {
3162 let secp_ctx = Secp256k1::new();
3163 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3164 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3165 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3166 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3167 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3168 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3169 let open_channel = msgs::OpenChannel {
3170 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3171 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3172 funding_satoshis: 1311768467284833366,
3173 push_msat: 2536655962884945560,
3174 dust_limit_satoshis: 3608586615801332854,
3175 max_htlc_value_in_flight_msat: 8517154655701053848,
3176 channel_reserve_satoshis: 8665828695742877976,
3177 htlc_minimum_msat: 2316138423780173,
3178 feerate_per_kw: 821716,
3179 to_self_delay: 49340,
3180 max_accepted_htlcs: 49340,
3181 funding_pubkey: pubkey_1,
3182 revocation_basepoint: pubkey_2,
3183 payment_point: pubkey_3,
3184 delayed_payment_basepoint: pubkey_4,
3185 htlc_basepoint: pubkey_5,
3186 first_per_commitment_point: pubkey_6,
3187 channel_flags: if random_bit { 1 << 5 } else { 0 },
3188 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3189 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3191 let encoded_value = open_channel.encode();
3192 let mut target_value = Vec::new();
3193 target_value.append(&mut hex::decode("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3194 target_value.append(&mut hex::decode("02020202020202020202020202020202020202020202020202020202020202021234567890123456233403289122369832144668701144767633030896203198784335490624111800083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3196 target_value.append(&mut hex::decode("20").unwrap());
3198 target_value.append(&mut hex::decode("00").unwrap());
3201 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3204 target_value.append(&mut hex::decode("0100").unwrap());
3206 assert_eq!(encoded_value, target_value);
3210 fn encoding_open_channel() {
3211 do_encoding_open_channel(false, false, false);
3212 do_encoding_open_channel(false, false, true);
3213 do_encoding_open_channel(false, true, false);
3214 do_encoding_open_channel(false, true, true);
3215 do_encoding_open_channel(true, false, false);
3216 do_encoding_open_channel(true, false, true);
3217 do_encoding_open_channel(true, true, false);
3218 do_encoding_open_channel(true, true, true);
3221 fn do_encoding_open_channelv2(random_bit: bool, shutdown: bool, incl_chan_type: bool, require_confirmed_inputs: bool) {
3222 let secp_ctx = Secp256k1::new();
3223 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3224 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3225 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3226 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3227 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3228 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3229 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3230 let open_channelv2 = msgs::OpenChannelV2 {
3231 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3232 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3233 funding_feerate_sat_per_1000_weight: 821716,
3234 commitment_feerate_sat_per_1000_weight: 821716,
3235 funding_satoshis: 1311768467284833366,
3236 dust_limit_satoshis: 3608586615801332854,
3237 max_htlc_value_in_flight_msat: 8517154655701053848,
3238 htlc_minimum_msat: 2316138423780173,
3239 to_self_delay: 49340,
3240 max_accepted_htlcs: 49340,
3241 locktime: 305419896,
3242 funding_pubkey: pubkey_1,
3243 revocation_basepoint: pubkey_2,
3244 payment_basepoint: pubkey_3,
3245 delayed_payment_basepoint: pubkey_4,
3246 htlc_basepoint: pubkey_5,
3247 first_per_commitment_point: pubkey_6,
3248 second_per_commitment_point: pubkey_7,
3249 channel_flags: if random_bit { 1 << 5 } else { 0 },
3250 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3251 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3252 require_confirmed_inputs: if require_confirmed_inputs { Some(()) } else { None },
3254 let encoded_value = open_channelv2.encode();
3255 let mut target_value = Vec::new();
3256 target_value.append(&mut hex::decode("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3257 target_value.append(&mut hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap());
3258 target_value.append(&mut hex::decode("000c89d4").unwrap());
3259 target_value.append(&mut hex::decode("000c89d4").unwrap());
3260 target_value.append(&mut hex::decode("1234567890123456").unwrap());
3261 target_value.append(&mut hex::decode("3214466870114476").unwrap());
3262 target_value.append(&mut hex::decode("7633030896203198").unwrap());
3263 target_value.append(&mut hex::decode("00083a840000034d").unwrap());
3264 target_value.append(&mut hex::decode("c0bc").unwrap());
3265 target_value.append(&mut hex::decode("c0bc").unwrap());
3266 target_value.append(&mut hex::decode("12345678").unwrap());
3267 target_value.append(&mut hex::decode("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap());
3268 target_value.append(&mut hex::decode("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap());
3269 target_value.append(&mut hex::decode("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap());
3270 target_value.append(&mut hex::decode("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
3271 target_value.append(&mut hex::decode("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap());
3272 target_value.append(&mut hex::decode("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3273 target_value.append(&mut hex::decode("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap());
3276 target_value.append(&mut hex::decode("20").unwrap());
3278 target_value.append(&mut hex::decode("00").unwrap());
3281 target_value.append(&mut hex::decode("001b").unwrap()); // Type 0 + Length 27
3282 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3285 target_value.append(&mut hex::decode("0100").unwrap());
3287 if require_confirmed_inputs {
3288 target_value.append(&mut hex::decode("0200").unwrap());
3290 assert_eq!(encoded_value, target_value);
3294 fn encoding_open_channelv2() {
3295 do_encoding_open_channelv2(false, false, false, false);
3296 do_encoding_open_channelv2(false, false, false, true);
3297 do_encoding_open_channelv2(false, false, true, false);
3298 do_encoding_open_channelv2(false, false, true, true);
3299 do_encoding_open_channelv2(false, true, false, false);
3300 do_encoding_open_channelv2(false, true, false, true);
3301 do_encoding_open_channelv2(false, true, true, false);
3302 do_encoding_open_channelv2(false, true, true, true);
3303 do_encoding_open_channelv2(true, false, false, false);
3304 do_encoding_open_channelv2(true, false, false, true);
3305 do_encoding_open_channelv2(true, false, true, false);
3306 do_encoding_open_channelv2(true, false, true, true);
3307 do_encoding_open_channelv2(true, true, false, false);
3308 do_encoding_open_channelv2(true, true, false, true);
3309 do_encoding_open_channelv2(true, true, true, false);
3310 do_encoding_open_channelv2(true, true, true, true);
3313 fn do_encoding_accept_channel(shutdown: bool) {
3314 let secp_ctx = Secp256k1::new();
3315 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3316 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3317 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3318 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3319 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3320 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3321 let accept_channel = msgs::AcceptChannel {
3322 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3323 dust_limit_satoshis: 1311768467284833366,
3324 max_htlc_value_in_flight_msat: 2536655962884945560,
3325 channel_reserve_satoshis: 3608586615801332854,
3326 htlc_minimum_msat: 2316138423780173,
3327 minimum_depth: 821716,
3328 to_self_delay: 49340,
3329 max_accepted_htlcs: 49340,
3330 funding_pubkey: pubkey_1,
3331 revocation_basepoint: pubkey_2,
3332 payment_point: pubkey_3,
3333 delayed_payment_basepoint: pubkey_4,
3334 htlc_basepoint: pubkey_5,
3335 first_per_commitment_point: pubkey_6,
3336 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3339 next_local_nonce: None,
3341 let encoded_value = accept_channel.encode();
3342 let mut target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020212345678901234562334032891223698321446687011447600083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap();
3344 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3346 assert_eq!(encoded_value, target_value);
3350 fn encoding_accept_channel() {
3351 do_encoding_accept_channel(false);
3352 do_encoding_accept_channel(true);
3355 fn do_encoding_accept_channelv2(shutdown: bool) {
3356 let secp_ctx = Secp256k1::new();
3357 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3358 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3359 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3360 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3361 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3362 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3363 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3364 let accept_channelv2 = msgs::AcceptChannelV2 {
3365 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3366 funding_satoshis: 1311768467284833366,
3367 dust_limit_satoshis: 1311768467284833366,
3368 max_htlc_value_in_flight_msat: 2536655962884945560,
3369 htlc_minimum_msat: 2316138423780173,
3370 minimum_depth: 821716,
3371 to_self_delay: 49340,
3372 max_accepted_htlcs: 49340,
3373 funding_pubkey: pubkey_1,
3374 revocation_basepoint: pubkey_2,
3375 payment_basepoint: pubkey_3,
3376 delayed_payment_basepoint: pubkey_4,
3377 htlc_basepoint: pubkey_5,
3378 first_per_commitment_point: pubkey_6,
3379 second_per_commitment_point: pubkey_7,
3380 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3382 require_confirmed_inputs: None,
3384 let encoded_value = accept_channelv2.encode();
3385 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // temporary_channel_id
3386 target_value.append(&mut hex::decode("1234567890123456").unwrap()); // funding_satoshis
3387 target_value.append(&mut hex::decode("1234567890123456").unwrap()); // dust_limit_satoshis
3388 target_value.append(&mut hex::decode("2334032891223698").unwrap()); // max_htlc_value_in_flight_msat
3389 target_value.append(&mut hex::decode("00083a840000034d").unwrap()); // htlc_minimum_msat
3390 target_value.append(&mut hex::decode("000c89d4").unwrap()); // minimum_depth
3391 target_value.append(&mut hex::decode("c0bc").unwrap()); // to_self_delay
3392 target_value.append(&mut hex::decode("c0bc").unwrap()); // max_accepted_htlcs
3393 target_value.append(&mut hex::decode("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap()); // funding_pubkey
3394 target_value.append(&mut hex::decode("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap()); // revocation_basepoint
3395 target_value.append(&mut hex::decode("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap()); // payment_basepoint
3396 target_value.append(&mut hex::decode("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap()); // delayed_payment_basepoint
3397 target_value.append(&mut hex::decode("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap()); // htlc_basepoint
3398 target_value.append(&mut hex::decode("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap()); // first_per_commitment_point
3399 target_value.append(&mut hex::decode("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap()); // second_per_commitment_point
3401 target_value.append(&mut hex::decode("001b").unwrap()); // Type 0 + Length 27
3402 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3404 assert_eq!(encoded_value, target_value);
3408 fn encoding_accept_channelv2() {
3409 do_encoding_accept_channelv2(false);
3410 do_encoding_accept_channelv2(true);
3414 fn encoding_funding_created() {
3415 let secp_ctx = Secp256k1::new();
3416 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3417 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3418 let funding_created = msgs::FundingCreated {
3419 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3420 funding_txid: Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3421 funding_output_index: 255,
3424 partial_signature_with_nonce: None,
3426 next_local_nonce: None,
3428 let encoded_value = funding_created.encode();
3429 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202026e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c200ffd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3430 assert_eq!(encoded_value, target_value);
3434 fn encoding_funding_signed() {
3435 let secp_ctx = Secp256k1::new();
3436 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3437 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3438 let funding_signed = msgs::FundingSigned {
3439 channel_id: ChannelId::from_bytes([2; 32]),
3442 partial_signature_with_nonce: None,
3444 let encoded_value = funding_signed.encode();
3445 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3446 assert_eq!(encoded_value, target_value);
3450 fn encoding_channel_ready() {
3451 let secp_ctx = Secp256k1::new();
3452 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3453 let channel_ready = msgs::ChannelReady {
3454 channel_id: ChannelId::from_bytes([2; 32]),
3455 next_per_commitment_point: pubkey_1,
3456 short_channel_id_alias: None,
3458 let encoded_value = channel_ready.encode();
3459 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3460 assert_eq!(encoded_value, target_value);
3464 fn encoding_splice() {
3465 let secp_ctx = Secp256k1::new();
3466 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3467 let splice = msgs::Splice {
3468 chain_hash: ChainHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
3469 channel_id: ChannelId::from_bytes([2; 32]),
3470 relative_satoshis: 123456,
3471 funding_feerate_perkw: 2000,
3473 funding_pubkey: pubkey_1,
3475 let encoded_value = splice.encode();
3476 assert_eq!(hex::encode(encoded_value), "02020202020202020202020202020202020202020202020202020202020202026fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000000000000001e240000007d000000000031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f");
3480 fn encoding_stfu() {
3481 let stfu = msgs::Stfu {
3482 channel_id: ChannelId::from_bytes([2; 32]),
3485 let encoded_value = stfu.encode();
3486 assert_eq!(hex::encode(encoded_value), "020202020202020202020202020202020202020202020202020202020202020201");
3490 fn encoding_splice_ack() {
3491 let secp_ctx = Secp256k1::new();
3492 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3493 let splice = msgs::SpliceAck {
3494 chain_hash: ChainHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
3495 channel_id: ChannelId::from_bytes([2; 32]),
3496 relative_satoshis: 123456,
3497 funding_pubkey: pubkey_1,
3499 let encoded_value = splice.encode();
3500 assert_eq!(hex::encode(encoded_value), "02020202020202020202020202020202020202020202020202020202020202026fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000000000000001e240031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f");
3504 fn encoding_splice_locked() {
3505 let splice = msgs::SpliceLocked {
3506 channel_id: ChannelId::from_bytes([2; 32]),
3508 let encoded_value = splice.encode();
3509 assert_eq!(hex::encode(encoded_value), "0202020202020202020202020202020202020202020202020202020202020202");
3513 fn encoding_tx_add_input() {
3514 let tx_add_input = msgs::TxAddInput {
3515 channel_id: ChannelId::from_bytes([2; 32]),
3516 serial_id: 4886718345,
3517 prevtx: TransactionU16LenLimited::new(Transaction {
3519 lock_time: PackedLockTime(0),
3521 previous_output: OutPoint { txid: Txid::from_hex("305bab643ee297b8b6b76b320792c8223d55082122cb606bf89382146ced9c77").unwrap(), index: 2 }.into_bitcoin_outpoint(),
3522 script_sig: Script::new(),
3523 sequence: Sequence(0xfffffffd),
3524 witness: Witness::from_vec(vec![
3525 hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3526 hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3531 script_pubkey: Address::from_str("bc1qzlffunw52jav8vwdu5x3jfk6sr8u22rmq3xzw2").unwrap().script_pubkey(),
3535 script_pubkey: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().script_pubkey(),
3539 prevtx_out: 305419896,
3540 sequence: 305419896,
3542 let encoded_value = tx_add_input.encode();
3543 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000000012345678900de02000000000101779ced6c148293f86b60cb222108553d22c89207326bb7b6b897e23e64ab5b300200000000fdffffff0236dbc1000000000016001417d29e4dd454bac3b1cde50d1926da80cfc5287b9cbd03000000000016001436ec78d514df462da95e6a00c24daa8915362d420247304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701210301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944000000001234567812345678").unwrap();
3544 assert_eq!(encoded_value, target_value);
3548 fn encoding_tx_add_output() {
3549 let tx_add_output = msgs::TxAddOutput {
3550 channel_id: ChannelId::from_bytes([2; 32]),
3551 serial_id: 4886718345,
3553 script: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().script_pubkey(),
3555 let encoded_value = tx_add_output.encode();
3556 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000000012345678900000001234567890016001436ec78d514df462da95e6a00c24daa8915362d42").unwrap();
3557 assert_eq!(encoded_value, target_value);
3561 fn encoding_tx_remove_input() {
3562 let tx_remove_input = msgs::TxRemoveInput {
3563 channel_id: ChannelId::from_bytes([2; 32]),
3564 serial_id: 4886718345,
3566 let encoded_value = tx_remove_input.encode();
3567 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3568 assert_eq!(encoded_value, target_value);
3572 fn encoding_tx_remove_output() {
3573 let tx_remove_output = msgs::TxRemoveOutput {
3574 channel_id: ChannelId::from_bytes([2; 32]),
3575 serial_id: 4886718345,
3577 let encoded_value = tx_remove_output.encode();
3578 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3579 assert_eq!(encoded_value, target_value);
3583 fn encoding_tx_complete() {
3584 let tx_complete = msgs::TxComplete {
3585 channel_id: ChannelId::from_bytes([2; 32]),
3587 let encoded_value = tx_complete.encode();
3588 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3589 assert_eq!(encoded_value, target_value);
3593 fn encoding_tx_signatures() {
3594 let tx_signatures = msgs::TxSignatures {
3595 channel_id: ChannelId::from_bytes([2; 32]),
3596 tx_hash: Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3598 Witness::from_vec(vec![
3599 hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3600 hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3601 Witness::from_vec(vec![
3602 hex::decode("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap(),
3603 hex::decode("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap()]),
3606 let encoded_value = tx_signatures.encode();
3607 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3608 target_value.append(&mut hex::decode("6e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c2").unwrap()); // tx_hash (sha256) (big endian byte order)
3609 target_value.append(&mut hex::decode("0002").unwrap()); // num_witnesses (u16)
3611 target_value.append(&mut hex::decode("006b").unwrap()); // len of witness_data
3612 target_value.append(&mut hex::decode("02").unwrap()); // num_witness_elements (VarInt)
3613 target_value.append(&mut hex::decode("47").unwrap()); // len of witness element data (VarInt)
3614 target_value.append(&mut hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap());
3615 target_value.append(&mut hex::decode("21").unwrap()); // len of witness element data (VarInt)
3616 target_value.append(&mut hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap());
3618 target_value.append(&mut hex::decode("006c").unwrap()); // len of witness_data
3619 target_value.append(&mut hex::decode("02").unwrap()); // num_witness_elements (VarInt)
3620 target_value.append(&mut hex::decode("48").unwrap()); // len of witness element data (VarInt)
3621 target_value.append(&mut hex::decode("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap());
3622 target_value.append(&mut hex::decode("21").unwrap()); // len of witness element data (VarInt)
3623 target_value.append(&mut hex::decode("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap());
3624 assert_eq!(encoded_value, target_value);
3627 fn do_encoding_tx_init_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3628 let tx_init_rbf = msgs::TxInitRbf {
3629 channel_id: ChannelId::from_bytes([2; 32]),
3630 locktime: 305419896,
3631 feerate_sat_per_1000_weight: 20190119,
3632 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3634 let encoded_value = tx_init_rbf.encode();
3635 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3636 target_value.append(&mut hex::decode("12345678").unwrap()); // locktime
3637 target_value.append(&mut hex::decode("013413a7").unwrap()); // feerate_sat_per_1000_weight
3638 if let Some((_, target)) = funding_value_with_hex_target {
3639 target_value.push(0x00); // Type
3640 target_value.push(target.len() as u8 / 2); // Length
3641 target_value.append(&mut hex::decode(target).unwrap()); // Value (i64)
3643 assert_eq!(encoded_value, target_value);
3647 fn encoding_tx_init_rbf() {
3648 do_encoding_tx_init_rbf(Some((1311768467284833366, "1234567890123456")));
3649 do_encoding_tx_init_rbf(Some((13117684672, "000000030DDFFBC0")));
3650 do_encoding_tx_init_rbf(None);
3653 fn do_encoding_tx_ack_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3654 let tx_ack_rbf = msgs::TxAckRbf {
3655 channel_id: ChannelId::from_bytes([2; 32]),
3656 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3658 let encoded_value = tx_ack_rbf.encode();
3659 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3660 if let Some((_, target)) = funding_value_with_hex_target {
3661 target_value.push(0x00); // Type
3662 target_value.push(target.len() as u8 / 2); // Length
3663 target_value.append(&mut hex::decode(target).unwrap()); // Value (i64)
3665 assert_eq!(encoded_value, target_value);
3669 fn encoding_tx_ack_rbf() {
3670 do_encoding_tx_ack_rbf(Some((1311768467284833366, "1234567890123456")));
3671 do_encoding_tx_ack_rbf(Some((13117684672, "000000030DDFFBC0")));
3672 do_encoding_tx_ack_rbf(None);
3676 fn encoding_tx_abort() {
3677 let tx_abort = msgs::TxAbort {
3678 channel_id: ChannelId::from_bytes([2; 32]),
3679 data: hex::decode("54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap(),
3681 let encoded_value = tx_abort.encode();
3682 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202002C54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap();
3683 assert_eq!(encoded_value, target_value);
3686 fn do_encoding_shutdown(script_type: u8) {
3687 let secp_ctx = Secp256k1::new();
3688 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3689 let script = Builder::new().push_opcode(opcodes::OP_TRUE).into_script();
3690 let shutdown = msgs::Shutdown {
3691 channel_id: ChannelId::from_bytes([2; 32]),
3693 if script_type == 1 { Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey() }
3694 else if script_type == 2 { Address::p2sh(&script, Network::Testnet).unwrap().script_pubkey() }
3695 else if script_type == 3 { Address::p2wpkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).unwrap().script_pubkey() }
3696 else { Address::p2wsh(&script, Network::Testnet).script_pubkey() },
3698 let encoded_value = shutdown.encode();
3699 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3700 if script_type == 1 {
3701 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3702 } else if script_type == 2 {
3703 target_value.append(&mut hex::decode("0017a914da1745e9b549bd0bfa1a569971c77eba30cd5a4b87").unwrap());
3704 } else if script_type == 3 {
3705 target_value.append(&mut hex::decode("0016001479b000887626b294a914501a4cd226b58b235983").unwrap());
3706 } else if script_type == 4 {
3707 target_value.append(&mut hex::decode("002200204ae81572f06e1b88fd5ced7a1a000945432e83e1551e6f721ee9c00b8cc33260").unwrap());
3709 assert_eq!(encoded_value, target_value);
3713 fn encoding_shutdown() {
3714 do_encoding_shutdown(1);
3715 do_encoding_shutdown(2);
3716 do_encoding_shutdown(3);
3717 do_encoding_shutdown(4);
3721 fn encoding_closing_signed() {
3722 let secp_ctx = Secp256k1::new();
3723 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3724 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3725 let closing_signed = msgs::ClosingSigned {
3726 channel_id: ChannelId::from_bytes([2; 32]),
3727 fee_satoshis: 2316138423780173,
3731 let encoded_value = closing_signed.encode();
3732 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3733 assert_eq!(encoded_value, target_value);
3734 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value)).unwrap(), closing_signed);
3736 let closing_signed_with_range = msgs::ClosingSigned {
3737 channel_id: ChannelId::from_bytes([2; 32]),
3738 fee_satoshis: 2316138423780173,
3740 fee_range: Some(msgs::ClosingSignedFeeRange {
3741 min_fee_satoshis: 0xdeadbeef,
3742 max_fee_satoshis: 0x1badcafe01234567,
3745 let encoded_value_with_range = closing_signed_with_range.encode();
3746 let target_value_with_range = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a011000000000deadbeef1badcafe01234567").unwrap();
3747 assert_eq!(encoded_value_with_range, target_value_with_range);
3748 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value_with_range)).unwrap(),
3749 closing_signed_with_range);
3753 fn encoding_update_add_htlc() {
3754 let secp_ctx = Secp256k1::new();
3755 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3756 let onion_routing_packet = msgs::OnionPacket {
3758 public_key: Ok(pubkey_1),
3759 hop_data: [1; 20*65],
3762 let update_add_htlc = msgs::UpdateAddHTLC {
3763 channel_id: ChannelId::from_bytes([2; 32]),
3764 htlc_id: 2316138423780173,
3765 amount_msat: 3608586615801332854,
3766 payment_hash: PaymentHash([1; 32]),
3767 cltv_expiry: 821716,
3768 onion_routing_packet,
3769 skimmed_fee_msat: None,
3771 let encoded_value = update_add_htlc.encode();
3772 let target_value = hex::decode("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").unwrap();
3773 assert_eq!(encoded_value, target_value);
3777 fn encoding_update_fulfill_htlc() {
3778 let update_fulfill_htlc = msgs::UpdateFulfillHTLC {
3779 channel_id: ChannelId::from_bytes([2; 32]),
3780 htlc_id: 2316138423780173,
3781 payment_preimage: PaymentPreimage([1; 32]),
3783 let encoded_value = update_fulfill_htlc.encode();
3784 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d0101010101010101010101010101010101010101010101010101010101010101").unwrap();
3785 assert_eq!(encoded_value, target_value);
3789 fn encoding_update_fail_htlc() {
3790 let reason = OnionErrorPacket {
3791 data: [1; 32].to_vec(),
3793 let update_fail_htlc = msgs::UpdateFailHTLC {
3794 channel_id: ChannelId::from_bytes([2; 32]),
3795 htlc_id: 2316138423780173,
3798 let encoded_value = update_fail_htlc.encode();
3799 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d00200101010101010101010101010101010101010101010101010101010101010101").unwrap();
3800 assert_eq!(encoded_value, target_value);
3804 fn encoding_update_fail_malformed_htlc() {
3805 let update_fail_malformed_htlc = msgs::UpdateFailMalformedHTLC {
3806 channel_id: ChannelId::from_bytes([2; 32]),
3807 htlc_id: 2316138423780173,
3808 sha256_of_onion: [1; 32],
3811 let encoded_value = update_fail_malformed_htlc.encode();
3812 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d010101010101010101010101010101010101010101010101010101010101010100ff").unwrap();
3813 assert_eq!(encoded_value, target_value);
3816 fn do_encoding_commitment_signed(htlcs: bool) {
3817 let secp_ctx = Secp256k1::new();
3818 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3819 let (privkey_2, _) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3820 let (privkey_3, _) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3821 let (privkey_4, _) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3822 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3823 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
3824 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
3825 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
3826 let commitment_signed = msgs::CommitmentSigned {
3827 channel_id: ChannelId::from_bytes([2; 32]),
3829 htlc_signatures: if htlcs { vec![sig_2, sig_3, sig_4] } else { Vec::new() },
3831 partial_signature_with_nonce: None,
3833 let encoded_value = commitment_signed.encode();
3834 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3836 target_value.append(&mut hex::decode("00031735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
3838 target_value.append(&mut hex::decode("0000").unwrap());
3840 assert_eq!(encoded_value, target_value);
3844 fn encoding_commitment_signed() {
3845 do_encoding_commitment_signed(true);
3846 do_encoding_commitment_signed(false);
3850 fn encoding_revoke_and_ack() {
3851 let secp_ctx = Secp256k1::new();
3852 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3853 let raa = msgs::RevokeAndACK {
3854 channel_id: ChannelId::from_bytes([2; 32]),
3855 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],
3856 next_per_commitment_point: pubkey_1,
3858 next_local_nonce: None,
3860 let encoded_value = raa.encode();
3861 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020101010101010101010101010101010101010101010101010101010101010101031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3862 assert_eq!(encoded_value, target_value);
3866 fn encoding_update_fee() {
3867 let update_fee = msgs::UpdateFee {
3868 channel_id: ChannelId::from_bytes([2; 32]),
3869 feerate_per_kw: 20190119,
3871 let encoded_value = update_fee.encode();
3872 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202013413a7").unwrap();
3873 assert_eq!(encoded_value, target_value);
3877 fn encoding_init() {
3878 let mainnet_hash = ChainHash::using_genesis_block(Network::Bitcoin);
3879 assert_eq!(msgs::Init {
3880 features: InitFeatures::from_le_bytes(vec![0xFF, 0xFF, 0xFF]),
3881 networks: Some(vec![mainnet_hash]),
3882 remote_network_address: None,
3883 }.encode(), hex::decode("00023fff0003ffffff01206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3884 assert_eq!(msgs::Init {
3885 features: InitFeatures::from_le_bytes(vec![0xFF]),
3887 remote_network_address: None,
3888 }.encode(), hex::decode("0001ff0001ff").unwrap());
3889 assert_eq!(msgs::Init {
3890 features: InitFeatures::from_le_bytes(vec![]),
3891 networks: Some(vec![mainnet_hash]),
3892 remote_network_address: None,
3893 }.encode(), hex::decode("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3894 assert_eq!(msgs::Init {
3895 features: InitFeatures::from_le_bytes(vec![]),
3896 networks: Some(vec![ChainHash::from(&[1; 32][..]), ChainHash::from(&[2; 32][..])]),
3897 remote_network_address: None,
3898 }.encode(), hex::decode("00000000014001010101010101010101010101010101010101010101010101010101010101010202020202020202020202020202020202020202020202020202020202020202").unwrap());
3899 let init_msg = msgs::Init { features: InitFeatures::from_le_bytes(vec![]),
3900 networks: Some(vec![mainnet_hash]),
3901 remote_network_address: Some(SocketAddress::TcpIpV4 {
3902 addr: [127, 0, 0, 1],
3906 let encoded_value = init_msg.encode();
3907 let target_value = hex::decode("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d61900000000000307017f00000103e8").unwrap();
3908 assert_eq!(encoded_value, target_value);
3909 assert_eq!(msgs::Init::read(&mut Cursor::new(&target_value)).unwrap(), init_msg);
3913 fn encoding_error() {
3914 let error = msgs::ErrorMessage {
3915 channel_id: ChannelId::from_bytes([2; 32]),
3916 data: String::from("rust-lightning"),
3918 let encoded_value = error.encode();
3919 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3920 assert_eq!(encoded_value, target_value);
3924 fn encoding_warning() {
3925 let error = msgs::WarningMessage {
3926 channel_id: ChannelId::from_bytes([2; 32]),
3927 data: String::from("rust-lightning"),
3929 let encoded_value = error.encode();
3930 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3931 assert_eq!(encoded_value, target_value);
3935 fn encoding_ping() {
3936 let ping = msgs::Ping {
3940 let encoded_value = ping.encode();
3941 let target_value = hex::decode("0040004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3942 assert_eq!(encoded_value, target_value);
3946 fn encoding_pong() {
3947 let pong = msgs::Pong {
3950 let encoded_value = pong.encode();
3951 let target_value = hex::decode("004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3952 assert_eq!(encoded_value, target_value);
3956 fn encoding_nonfinal_onion_hop_data() {
3957 let outbound_msg = msgs::OutboundOnionPayload::Forward {
3958 short_channel_id: 0xdeadbeef1bad1dea,
3959 amt_to_forward: 0x0badf00d01020304,
3960 outgoing_cltv_value: 0xffffffff,
3962 let encoded_value = outbound_msg.encode();
3963 let target_value = hex::decode("1a02080badf00d010203040404ffffffff0608deadbeef1bad1dea").unwrap();
3964 assert_eq!(encoded_value, target_value);
3966 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3967 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
3968 if let msgs::InboundOnionPayload::Forward {
3969 short_channel_id, amt_to_forward, outgoing_cltv_value
3971 assert_eq!(short_channel_id, 0xdeadbeef1bad1dea);
3972 assert_eq!(amt_to_forward, 0x0badf00d01020304);
3973 assert_eq!(outgoing_cltv_value, 0xffffffff);
3974 } else { panic!(); }
3978 fn encoding_final_onion_hop_data() {
3979 let outbound_msg = msgs::OutboundOnionPayload::Receive {
3981 payment_metadata: None,
3982 keysend_preimage: None,
3983 amt_msat: 0x0badf00d01020304,
3984 outgoing_cltv_value: 0xffffffff,
3985 custom_tlvs: vec![],
3987 let encoded_value = outbound_msg.encode();
3988 let target_value = hex::decode("1002080badf00d010203040404ffffffff").unwrap();
3989 assert_eq!(encoded_value, target_value);
3991 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3992 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
3993 if let msgs::InboundOnionPayload::Receive {
3994 payment_data: None, amt_msat, outgoing_cltv_value, ..
3996 assert_eq!(amt_msat, 0x0badf00d01020304);
3997 assert_eq!(outgoing_cltv_value, 0xffffffff);
3998 } else { panic!(); }
4002 fn encoding_final_onion_hop_data_with_secret() {
4003 let expected_payment_secret = PaymentSecret([0x42u8; 32]);
4004 let outbound_msg = msgs::OutboundOnionPayload::Receive {
4005 payment_data: Some(FinalOnionHopData {
4006 payment_secret: expected_payment_secret,
4007 total_msat: 0x1badca1f
4009 payment_metadata: None,
4010 keysend_preimage: None,
4011 amt_msat: 0x0badf00d01020304,
4012 outgoing_cltv_value: 0xffffffff,
4013 custom_tlvs: vec![],
4015 let encoded_value = outbound_msg.encode();
4016 let target_value = hex::decode("3602080badf00d010203040404ffffffff082442424242424242424242424242424242424242424242424242424242424242421badca1f").unwrap();
4017 assert_eq!(encoded_value, target_value);
4019 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4020 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
4021 if let msgs::InboundOnionPayload::Receive {
4022 payment_data: Some(FinalOnionHopData {
4024 total_msat: 0x1badca1f
4026 amt_msat, outgoing_cltv_value,
4027 payment_metadata: None,
4028 keysend_preimage: None,
4031 assert_eq!(payment_secret, expected_payment_secret);
4032 assert_eq!(amt_msat, 0x0badf00d01020304);
4033 assert_eq!(outgoing_cltv_value, 0xffffffff);
4034 assert_eq!(custom_tlvs, vec![]);
4035 } else { panic!(); }
4039 fn encoding_final_onion_hop_data_with_bad_custom_tlvs() {
4040 // If custom TLVs have type number within the range reserved for protocol, treat them as if
4042 let bad_type_range_tlvs = vec![
4043 ((1 << 16) - 4, vec![42]),
4044 ((1 << 16) - 2, vec![42; 32]),
4046 let mut msg = msgs::OutboundOnionPayload::Receive {
4048 payment_metadata: None,
4049 keysend_preimage: None,
4050 custom_tlvs: bad_type_range_tlvs,
4051 amt_msat: 0x0badf00d01020304,
4052 outgoing_cltv_value: 0xffffffff,
4054 let encoded_value = msg.encode();
4055 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4056 assert!(msgs::InboundOnionPayload::read(&mut Cursor::new(&encoded_value[..]), &&node_signer).is_err());
4057 let good_type_range_tlvs = vec![
4058 ((1 << 16) - 3, vec![42]),
4059 ((1 << 16) - 1, vec![42; 32]),
4061 if let msgs::OutboundOnionPayload::Receive { ref mut custom_tlvs, .. } = msg {
4062 *custom_tlvs = good_type_range_tlvs.clone();
4064 let encoded_value = msg.encode();
4065 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&encoded_value[..]), &&node_signer).unwrap();
4067 msgs::InboundOnionPayload::Receive { custom_tlvs, .. } => assert!(custom_tlvs.is_empty()),
4073 fn encoding_final_onion_hop_data_with_custom_tlvs() {
4074 let expected_custom_tlvs = vec![
4075 (5482373483, vec![0x12, 0x34]),
4076 (5482373487, vec![0x42u8; 8]),
4078 let msg = msgs::OutboundOnionPayload::Receive {
4080 payment_metadata: None,
4081 keysend_preimage: None,
4082 custom_tlvs: expected_custom_tlvs.clone(),
4083 amt_msat: 0x0badf00d01020304,
4084 outgoing_cltv_value: 0xffffffff,
4086 let encoded_value = msg.encode();
4087 let target_value = hex::decode("2e02080badf00d010203040404ffffffffff0000000146c6616b021234ff0000000146c6616f084242424242424242").unwrap();
4088 assert_eq!(encoded_value, target_value);
4089 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4090 let inbound_msg: msgs::InboundOnionPayload = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
4091 if let msgs::InboundOnionPayload::Receive {
4093 payment_metadata: None,
4094 keysend_preimage: None,
4097 outgoing_cltv_value,
4100 assert_eq!(custom_tlvs, expected_custom_tlvs);
4101 assert_eq!(amt_msat, 0x0badf00d01020304);
4102 assert_eq!(outgoing_cltv_value, 0xffffffff);
4103 } else { panic!(); }
4107 fn query_channel_range_end_blocknum() {
4108 let tests: Vec<(u32, u32, u32)> = vec![
4109 (10000, 1500, 11500),
4110 (0, 0xffffffff, 0xffffffff),
4111 (1, 0xffffffff, 0xffffffff),
4114 for (first_blocknum, number_of_blocks, expected) in tests.into_iter() {
4115 let sut = msgs::QueryChannelRange {
4116 chain_hash: ChainHash::using_genesis_block(Network::Regtest),
4120 assert_eq!(sut.end_blocknum(), expected);
4125 fn encoding_query_channel_range() {
4126 let mut query_channel_range = msgs::QueryChannelRange {
4127 chain_hash: ChainHash::using_genesis_block(Network::Regtest),
4128 first_blocknum: 100000,
4129 number_of_blocks: 1500,
4131 let encoded_value = query_channel_range.encode();
4132 let target_value = hex::decode("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000186a0000005dc").unwrap();
4133 assert_eq!(encoded_value, target_value);
4135 query_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4136 assert_eq!(query_channel_range.first_blocknum, 100000);
4137 assert_eq!(query_channel_range.number_of_blocks, 1500);
4141 fn encoding_reply_channel_range() {
4142 do_encoding_reply_channel_range(0);
4143 do_encoding_reply_channel_range(1);
4146 fn do_encoding_reply_channel_range(encoding_type: u8) {
4147 let mut target_value = hex::decode("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000b8a06000005dc01").unwrap();
4148 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4149 let mut reply_channel_range = msgs::ReplyChannelRange {
4150 chain_hash: expected_chain_hash,
4151 first_blocknum: 756230,
4152 number_of_blocks: 1500,
4153 sync_complete: true,
4154 short_channel_ids: vec![0x000000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
4157 if encoding_type == 0 {
4158 target_value.append(&mut hex::decode("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
4159 let encoded_value = reply_channel_range.encode();
4160 assert_eq!(encoded_value, target_value);
4162 reply_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4163 assert_eq!(reply_channel_range.chain_hash, expected_chain_hash);
4164 assert_eq!(reply_channel_range.first_blocknum, 756230);
4165 assert_eq!(reply_channel_range.number_of_blocks, 1500);
4166 assert_eq!(reply_channel_range.sync_complete, true);
4167 assert_eq!(reply_channel_range.short_channel_ids[0], 0x000000000000008e);
4168 assert_eq!(reply_channel_range.short_channel_ids[1], 0x0000000000003c69);
4169 assert_eq!(reply_channel_range.short_channel_ids[2], 0x000000000045a6c4);
4171 target_value.append(&mut hex::decode("001601789c636000833e08659309a65878be010010a9023a").unwrap());
4172 let result: Result<msgs::ReplyChannelRange, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
4173 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
4178 fn encoding_query_short_channel_ids() {
4179 do_encoding_query_short_channel_ids(0);
4180 do_encoding_query_short_channel_ids(1);
4183 fn do_encoding_query_short_channel_ids(encoding_type: u8) {
4184 let mut target_value = hex::decode("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
4185 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4186 let mut query_short_channel_ids = msgs::QueryShortChannelIds {
4187 chain_hash: expected_chain_hash,
4188 short_channel_ids: vec![0x0000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
4191 if encoding_type == 0 {
4192 target_value.append(&mut hex::decode("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
4193 let encoded_value = query_short_channel_ids.encode();
4194 assert_eq!(encoded_value, target_value);
4196 query_short_channel_ids = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4197 assert_eq!(query_short_channel_ids.chain_hash, expected_chain_hash);
4198 assert_eq!(query_short_channel_ids.short_channel_ids[0], 0x000000000000008e);
4199 assert_eq!(query_short_channel_ids.short_channel_ids[1], 0x0000000000003c69);
4200 assert_eq!(query_short_channel_ids.short_channel_ids[2], 0x000000000045a6c4);
4202 target_value.append(&mut hex::decode("001601789c636000833e08659309a65878be010010a9023a").unwrap());
4203 let result: Result<msgs::QueryShortChannelIds, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
4204 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
4209 fn encoding_reply_short_channel_ids_end() {
4210 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4211 let mut reply_short_channel_ids_end = msgs::ReplyShortChannelIdsEnd {
4212 chain_hash: expected_chain_hash,
4213 full_information: true,
4215 let encoded_value = reply_short_channel_ids_end.encode();
4216 let target_value = hex::decode("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f01").unwrap();
4217 assert_eq!(encoded_value, target_value);
4219 reply_short_channel_ids_end = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4220 assert_eq!(reply_short_channel_ids_end.chain_hash, expected_chain_hash);
4221 assert_eq!(reply_short_channel_ids_end.full_information, true);
4225 fn encoding_gossip_timestamp_filter(){
4226 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4227 let mut gossip_timestamp_filter = msgs::GossipTimestampFilter {
4228 chain_hash: expected_chain_hash,
4229 first_timestamp: 1590000000,
4230 timestamp_range: 0xffff_ffff,
4232 let encoded_value = gossip_timestamp_filter.encode();
4233 let target_value = hex::decode("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f5ec57980ffffffff").unwrap();
4234 assert_eq!(encoded_value, target_value);
4236 gossip_timestamp_filter = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4237 assert_eq!(gossip_timestamp_filter.chain_hash, expected_chain_hash);
4238 assert_eq!(gossip_timestamp_filter.first_timestamp, 1590000000);
4239 assert_eq!(gossip_timestamp_filter.timestamp_range, 0xffff_ffff);
4243 fn decode_onion_hop_data_len_as_bigsize() {
4244 // Tests that we can decode an onion payload that is >253 bytes.
4245 // Previously, receiving a payload of this size could've caused us to fail to decode a valid
4246 // payload, because we were decoding the length (a BigSize, big-endian) as a VarInt
4249 // Encode a test onion payload with a big custom TLV such that it's >253 bytes, forcing the
4250 // payload length to be encoded over multiple bytes rather than a single u8.
4251 let big_payload = encode_big_payload().unwrap();
4252 let mut rd = Cursor::new(&big_payload[..]);
4254 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4255 <msgs::InboundOnionPayload as ReadableArgs<&&test_utils::TestKeysInterface>>
4256 ::read(&mut rd, &&node_signer).unwrap();
4258 // see above test, needs to be a separate method for use of the serialization macros.
4259 fn encode_big_payload() -> Result<Vec<u8>, io::Error> {
4260 use crate::util::ser::HighZeroBytesDroppedBigSize;
4261 let payload = msgs::OutboundOnionPayload::Forward {
4262 short_channel_id: 0xdeadbeef1bad1dea,
4263 amt_to_forward: 1000,
4264 outgoing_cltv_value: 0xffffffff,
4266 let mut encoded_payload = Vec::new();
4267 let test_bytes = vec![42u8; 1000];
4268 if let msgs::OutboundOnionPayload::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } = payload {
4269 _encode_varint_length_prefixed_tlv!(&mut encoded_payload, {
4270 (1, test_bytes, required_vec),
4271 (2, HighZeroBytesDroppedBigSize(amt_to_forward), required),
4272 (4, HighZeroBytesDroppedBigSize(outgoing_cltv_value), required),
4273 (6, short_channel_id, required)
4280 #[cfg(feature = "std")]
4281 fn test_socket_address_from_str() {
4282 let tcpip_v4 = SocketAddress::TcpIpV4 {
4283 addr: Ipv4Addr::new(127, 0, 0, 1).octets(),
4286 assert_eq!(tcpip_v4, SocketAddress::from_str("127.0.0.1:1234").unwrap());
4287 assert_eq!(tcpip_v4, SocketAddress::from_str(&tcpip_v4.to_string()).unwrap());
4289 let tcpip_v6 = SocketAddress::TcpIpV6 {
4290 addr: Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1).octets(),
4293 assert_eq!(tcpip_v6, SocketAddress::from_str("[0:0:0:0:0:0:0:1]:1234").unwrap());
4294 assert_eq!(tcpip_v6, SocketAddress::from_str(&tcpip_v6.to_string()).unwrap());
4296 let hostname = SocketAddress::Hostname {
4297 hostname: Hostname::try_from("lightning-node.mydomain.com".to_string()).unwrap(),
4300 assert_eq!(hostname, SocketAddress::from_str("lightning-node.mydomain.com:1234").unwrap());
4301 assert_eq!(hostname, SocketAddress::from_str(&hostname.to_string()).unwrap());
4303 let onion_v2 = SocketAddress::OnionV2 ([40, 4, 64, 185, 202, 19, 162, 75, 90, 200, 38, 7],);
4304 assert_eq!("OnionV2([40, 4, 64, 185, 202, 19, 162, 75, 90, 200, 38, 7])", &onion_v2.to_string());
4305 assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("FACEBOOKCOREWWWI.onion:9735"));
4307 let onion_v3 = SocketAddress::OnionV3 {
4308 ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102, 182, 107, 4, 105, 247, 246, 85,
4309 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31, 33, 71, 3],
4314 assert_eq!(onion_v3, SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion:1234").unwrap());
4315 assert_eq!(onion_v3, SocketAddress::from_str(&onion_v3.to_string()).unwrap());
4317 assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6.onion:1234"));
4318 assert_eq!(Err(SocketAddressParseError::InvalidInput), SocketAddress::from_str("127.0.0.1@1234"));
4319 assert_eq!(Err(SocketAddressParseError::InvalidInput), "".parse::<SocketAddress>());
4320 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:9735:94").is_err());
4321 assert!(SocketAddress::from_str("wrong$%#.com:1234").is_err());
4322 assert_eq!(Err(SocketAddressParseError::InvalidPort), SocketAddress::from_str("example.com:wrong"));
4323 assert!("localhost".parse::<SocketAddress>().is_err());
4324 assert!("localhost:invalid-port".parse::<SocketAddress>().is_err());
4325 assert!( "invalid-onion-v3-hostname.onion:8080".parse::<SocketAddress>().is_err());
4326 assert!("b32.example.onion:invalid-port".parse::<SocketAddress>().is_err());
4327 assert!("invalid-address".parse::<SocketAddress>().is_err());
4328 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:1234").is_err());
4332 #[cfg(feature = "std")]
4333 fn test_socket_address_to_socket_addrs() {
4334 assert_eq!(SocketAddress::TcpIpV4 {addr:[0u8; 4], port: 1337,}.to_socket_addrs().unwrap().next().unwrap(),
4335 SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(0,0,0,0), 1337)));
4336 assert_eq!(SocketAddress::TcpIpV6 {addr:[0u8; 16], port: 1337,}.to_socket_addrs().unwrap().next().unwrap(),
4337 SocketAddr::V6(SocketAddrV6::new(Ipv6Addr::from([0u8; 16]), 1337, 0, 0)));
4338 assert_eq!(SocketAddress::Hostname { hostname: Hostname::try_from("0.0.0.0".to_string()).unwrap(), port: 0 }
4339 .to_socket_addrs().unwrap().next().unwrap(), SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::from([0u8; 4]),0)));
4340 assert!(SocketAddress::OnionV2([0u8; 12]).to_socket_addrs().is_err());
4341 assert!(SocketAddress::OnionV3{ ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102,
4342 182, 107, 4, 105, 247, 246, 85, 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31,
4346 port: 1234 }.to_socket_addrs().is_err());