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, BlockHash};
34 use crate::ln::{ChannelId, PaymentPreimage, PaymentHash, PaymentSecret};
35 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
36 use crate::ln::onion_utils;
37 use crate::onion_message;
38 use crate::sign::NodeSigner;
40 use crate::prelude::*;
41 use core::convert::TryFrom;
45 use core::str::FromStr;
46 use crate::io::{self, Read};
47 use crate::io_extras::read_to_end;
49 use crate::events::{MessageSendEventsProvider, OnionMessageProvider};
50 use crate::util::logger;
51 use crate::util::ser::{LengthReadable, Readable, ReadableArgs, Writeable, Writer, WithoutLength, FixedLengthReader, HighZeroBytesDroppedBigSize, Hostname, TransactionU16LenLimited, BigSize};
52 use crate::util::base32;
54 use crate::routing::gossip::{NodeAlias, NodeId};
56 /// 21 million * 10^8 * 1000
57 pub(crate) const MAX_VALUE_MSAT: u64 = 21_000_000_0000_0000_000;
60 /// A partial signature that also contains the Musig2 nonce its signer used
61 #[derive(Clone, Debug, PartialEq, Eq)]
62 pub struct PartialSignatureWithNonce(pub musig2::types::PartialSignature, pub musig2::types::PublicNonce);
64 /// An error in decoding a message or struct.
65 #[derive(Clone, Debug, PartialEq, Eq)]
66 pub enum DecodeError {
67 /// A version byte specified something we don't know how to handle.
69 /// Includes unknown realm byte in an onion hop data packet.
71 /// Unknown feature mandating we fail to parse message (e.g., TLV with an even, unknown type)
72 UnknownRequiredFeature,
73 /// Value was invalid.
75 /// For example, a byte which was supposed to be a bool was something other than a 0
76 /// or 1, a public key/private key/signature was invalid, text wasn't UTF-8, TLV was
77 /// syntactically incorrect, etc.
79 /// The buffer to be read was too short.
81 /// A length descriptor in the packet didn't describe the later data correctly.
83 /// Error from [`std::io`].
85 /// The message included zlib-compressed values, which we don't support.
86 UnsupportedCompression,
89 /// An [`init`] message to be sent to or received from a peer.
91 /// [`init`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-init-message
92 #[derive(Clone, Debug, PartialEq, Eq)]
94 /// The relevant features which the sender supports.
95 pub features: InitFeatures,
96 /// Indicates chains the sender is interested in.
98 /// If there are no common chains, the connection will be closed.
99 pub networks: Option<Vec<ChainHash>>,
100 /// The receipient's network address.
102 /// This adds the option to report a remote IP address back to a connecting peer using the init
103 /// message. A node can decide to use that information to discover a potential update to its
104 /// public IPv4 address (NAT) and use that for a [`NodeAnnouncement`] update message containing
106 pub remote_network_address: Option<SocketAddress>,
109 /// An [`error`] message to be sent to or received from a peer.
111 /// [`error`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-error-and-warning-messages
112 #[derive(Clone, Debug, PartialEq, Eq)]
113 pub struct ErrorMessage {
114 /// The channel ID involved in the error.
116 /// All-0s indicates a general error unrelated to a specific channel, after which all channels
117 /// with the sending peer should be closed.
118 pub channel_id: ChannelId,
119 /// A possibly human-readable error description.
121 /// The string should be sanitized before it is used (e.g., emitted to logs or printed to
122 /// `stdout`). Otherwise, a well crafted error message may trigger a security vulnerability in
123 /// the terminal emulator or the logging subsystem.
127 /// A [`warning`] message to be sent to or received from a peer.
129 /// [`warning`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-error-and-warning-messages
130 #[derive(Clone, Debug, PartialEq, Eq)]
131 pub struct WarningMessage {
132 /// The channel ID involved in the warning.
134 /// All-0s indicates a warning unrelated to a specific channel.
135 pub channel_id: ChannelId,
136 /// A possibly human-readable warning description.
138 /// The string should be sanitized before it is used (e.g. emitted to logs or printed to
139 /// stdout). Otherwise, a well crafted error message may trigger a security vulnerability in
140 /// the terminal emulator or the logging subsystem.
144 /// A [`ping`] message to be sent to or received from a peer.
146 /// [`ping`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-ping-and-pong-messages
147 #[derive(Clone, Debug, PartialEq, Eq)]
149 /// The desired response length.
151 /// The ping packet size.
153 /// This field is not sent on the wire. byteslen zeros are sent.
157 /// A [`pong`] message to be sent to or received from a peer.
159 /// [`pong`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-ping-and-pong-messages
160 #[derive(Clone, Debug, PartialEq, Eq)]
162 /// The pong packet size.
164 /// This field is not sent on the wire. byteslen zeros are sent.
168 /// An [`open_channel`] message to be sent to or received from a peer.
170 /// Used in V1 channel establishment
172 /// [`open_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-open_channel-message
173 #[derive(Clone, Debug, PartialEq, Eq)]
174 pub struct OpenChannel {
175 /// The genesis hash of the blockchain where the channel is to be opened
176 pub chain_hash: BlockHash,
177 /// A temporary channel ID, until the funding outpoint is announced
178 pub temporary_channel_id: ChannelId,
179 /// The channel value
180 pub funding_satoshis: u64,
181 /// The amount to push to the counterparty as part of the open, in milli-satoshi
183 /// The threshold below which outputs on transactions broadcast by sender will be omitted
184 pub dust_limit_satoshis: u64,
185 /// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
186 pub max_htlc_value_in_flight_msat: u64,
187 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
188 pub channel_reserve_satoshis: u64,
189 /// The minimum HTLC size incoming to sender, in milli-satoshi
190 pub htlc_minimum_msat: u64,
191 /// The feerate per 1000-weight of sender generated transactions, until updated by
193 pub feerate_per_kw: u32,
194 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if
195 /// they broadcast a commitment transaction
196 pub to_self_delay: u16,
197 /// The maximum number of inbound HTLCs towards sender
198 pub max_accepted_htlcs: u16,
199 /// The sender's key controlling the funding transaction
200 pub funding_pubkey: PublicKey,
201 /// Used to derive a revocation key for transactions broadcast by counterparty
202 pub revocation_basepoint: PublicKey,
203 /// A payment key to sender for transactions broadcast by counterparty
204 pub payment_point: PublicKey,
205 /// Used to derive a payment key to sender for transactions broadcast by sender
206 pub delayed_payment_basepoint: PublicKey,
207 /// Used to derive an HTLC payment key to sender
208 pub htlc_basepoint: PublicKey,
209 /// The first to-be-broadcast-by-sender transaction's per commitment point
210 pub first_per_commitment_point: PublicKey,
211 /// The channel flags to be used
212 pub channel_flags: u8,
213 /// A request to pre-set the to-sender output's `scriptPubkey` for when we collaboratively close
214 pub shutdown_scriptpubkey: Option<Script>,
215 /// The channel type that this channel will represent
217 /// If this is `None`, we derive the channel type from the intersection of our
218 /// feature bits with our counterparty's feature bits from the [`Init`] message.
219 pub channel_type: Option<ChannelTypeFeatures>,
222 /// An open_channel2 message to be sent by or received from the channel initiator.
224 /// Used in V2 channel establishment
226 // TODO(dual_funding): Add spec link for `open_channel2`.
227 #[derive(Clone, Debug, PartialEq, Eq)]
228 pub struct OpenChannelV2 {
229 /// The genesis hash of the blockchain where the channel is to be opened
230 pub chain_hash: BlockHash,
231 /// A temporary channel ID derived using a zeroed out value for the channel acceptor's revocation basepoint
232 pub temporary_channel_id: ChannelId,
233 /// The feerate for the funding transaction set by the channel initiator
234 pub funding_feerate_sat_per_1000_weight: u32,
235 /// The feerate for the commitment transaction set by the channel initiator
236 pub commitment_feerate_sat_per_1000_weight: u32,
237 /// Part of the channel value contributed by the channel initiator
238 pub funding_satoshis: u64,
239 /// The threshold below which outputs on transactions broadcast by the channel initiator will be
241 pub dust_limit_satoshis: u64,
242 /// The maximum inbound HTLC value in flight towards channel initiator, in milli-satoshi
243 pub max_htlc_value_in_flight_msat: u64,
244 /// The minimum HTLC size incoming to channel initiator, in milli-satoshi
245 pub htlc_minimum_msat: u64,
246 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
247 /// broadcast a commitment transaction
248 pub to_self_delay: u16,
249 /// The maximum number of inbound HTLCs towards channel initiator
250 pub max_accepted_htlcs: u16,
251 /// The locktime for the funding transaction
253 /// The channel initiator's key controlling the funding transaction
254 pub funding_pubkey: PublicKey,
255 /// Used to derive a revocation key for transactions broadcast by counterparty
256 pub revocation_basepoint: PublicKey,
257 /// A payment key to channel initiator for transactions broadcast by counterparty
258 pub payment_basepoint: PublicKey,
259 /// Used to derive a payment key to channel initiator for transactions broadcast by channel
261 pub delayed_payment_basepoint: PublicKey,
262 /// Used to derive an HTLC payment key to channel initiator
263 pub htlc_basepoint: PublicKey,
264 /// The first to-be-broadcast-by-channel-initiator transaction's per commitment point
265 pub first_per_commitment_point: PublicKey,
266 /// The second to-be-broadcast-by-channel-initiator transaction's per commitment point
267 pub second_per_commitment_point: PublicKey,
269 pub channel_flags: u8,
270 /// Optionally, a request to pre-set the to-channel-initiator output's scriptPubkey for when we
271 /// collaboratively close
272 pub shutdown_scriptpubkey: Option<Script>,
273 /// The channel type that this channel will represent. If none is set, we derive the channel
274 /// type from the intersection of our feature bits with our counterparty's feature bits from
275 /// the Init message.
276 pub channel_type: Option<ChannelTypeFeatures>,
277 /// Optionally, a requirement that only confirmed inputs can be added
278 pub require_confirmed_inputs: Option<()>,
281 /// An [`accept_channel`] message to be sent to or received from a peer.
283 /// Used in V1 channel establishment
285 /// [`accept_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-accept_channel-message
286 #[derive(Clone, Debug, PartialEq, Eq)]
287 pub struct AcceptChannel {
288 /// A temporary channel ID, until the funding outpoint is announced
289 pub temporary_channel_id: ChannelId,
290 /// The threshold below which outputs on transactions broadcast by sender will be omitted
291 pub dust_limit_satoshis: u64,
292 /// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
293 pub max_htlc_value_in_flight_msat: u64,
294 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
295 pub channel_reserve_satoshis: u64,
296 /// The minimum HTLC size incoming to sender, in milli-satoshi
297 pub htlc_minimum_msat: u64,
298 /// Minimum depth of the funding transaction before the channel is considered open
299 pub minimum_depth: u32,
300 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they broadcast a commitment transaction
301 pub to_self_delay: u16,
302 /// The maximum number of inbound HTLCs towards sender
303 pub max_accepted_htlcs: u16,
304 /// The sender's key controlling the funding transaction
305 pub funding_pubkey: PublicKey,
306 /// Used to derive a revocation key for transactions broadcast by counterparty
307 pub revocation_basepoint: PublicKey,
308 /// A payment key to sender for transactions broadcast by counterparty
309 pub payment_point: PublicKey,
310 /// Used to derive a payment key to sender for transactions broadcast by sender
311 pub delayed_payment_basepoint: PublicKey,
312 /// Used to derive an HTLC payment key to sender for transactions broadcast by counterparty
313 pub htlc_basepoint: PublicKey,
314 /// The first to-be-broadcast-by-sender transaction's per commitment point
315 pub first_per_commitment_point: PublicKey,
316 /// A request to pre-set the to-sender output's scriptPubkey for when we collaboratively close
317 pub shutdown_scriptpubkey: Option<Script>,
318 /// The channel type that this channel will represent.
320 /// If this is `None`, we derive the channel type from the intersection of
321 /// our feature bits with our counterparty's feature bits from the [`Init`] message.
322 /// This is required to match the equivalent field in [`OpenChannel::channel_type`].
323 pub channel_type: Option<ChannelTypeFeatures>,
325 /// Next nonce the channel initiator should use to create a funding output signature against
326 pub next_local_nonce: Option<musig2::types::PublicNonce>,
329 /// An accept_channel2 message to be sent by or received from the channel accepter.
331 /// Used in V2 channel establishment
333 // TODO(dual_funding): Add spec link for `accept_channel2`.
334 #[derive(Clone, Debug, PartialEq, Eq)]
335 pub struct AcceptChannelV2 {
336 /// The same `temporary_channel_id` received from the initiator's `open_channel2` message.
337 pub temporary_channel_id: ChannelId,
338 /// Part of the channel value contributed by the channel acceptor
339 pub funding_satoshis: u64,
340 /// The threshold below which outputs on transactions broadcast by the channel acceptor will be
342 pub dust_limit_satoshis: u64,
343 /// The maximum inbound HTLC value in flight towards channel acceptor, in milli-satoshi
344 pub max_htlc_value_in_flight_msat: u64,
345 /// The minimum HTLC size incoming to channel acceptor, in milli-satoshi
346 pub htlc_minimum_msat: u64,
347 /// Minimum depth of the funding transaction before the channel is considered open
348 pub minimum_depth: u32,
349 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
350 /// broadcast a commitment transaction
351 pub to_self_delay: u16,
352 /// The maximum number of inbound HTLCs towards channel acceptor
353 pub max_accepted_htlcs: u16,
354 /// The channel acceptor's key controlling the funding transaction
355 pub funding_pubkey: PublicKey,
356 /// Used to derive a revocation key for transactions broadcast by counterparty
357 pub revocation_basepoint: PublicKey,
358 /// A payment key to channel acceptor for transactions broadcast by counterparty
359 pub payment_basepoint: PublicKey,
360 /// Used to derive a payment key to channel acceptor for transactions broadcast by channel
362 pub delayed_payment_basepoint: PublicKey,
363 /// Used to derive an HTLC payment key to channel acceptor for transactions broadcast by counterparty
364 pub htlc_basepoint: PublicKey,
365 /// The first to-be-broadcast-by-channel-acceptor transaction's per commitment point
366 pub first_per_commitment_point: PublicKey,
367 /// The second to-be-broadcast-by-channel-acceptor transaction's per commitment point
368 pub second_per_commitment_point: PublicKey,
369 /// Optionally, a request to pre-set the to-channel-acceptor output's scriptPubkey for when we
370 /// collaboratively close
371 pub shutdown_scriptpubkey: Option<Script>,
372 /// The channel type that this channel will represent. If none is set, we derive the channel
373 /// type from the intersection of our feature bits with our counterparty's feature bits from
374 /// the Init message.
376 /// This is required to match the equivalent field in [`OpenChannelV2::channel_type`].
377 pub channel_type: Option<ChannelTypeFeatures>,
378 /// Optionally, a requirement that only confirmed inputs can be added
379 pub require_confirmed_inputs: Option<()>,
382 /// A [`funding_created`] message to be sent to or received from a peer.
384 /// Used in V1 channel establishment
386 /// [`funding_created`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-funding_created-message
387 #[derive(Clone, Debug, PartialEq, Eq)]
388 pub struct FundingCreated {
389 /// A temporary channel ID, until the funding is established
390 pub temporary_channel_id: ChannelId,
391 /// The funding transaction ID
392 pub funding_txid: Txid,
393 /// The specific output index funding this channel
394 pub funding_output_index: u16,
395 /// The signature of the channel initiator (funder) on the initial commitment transaction
396 pub signature: Signature,
398 /// The partial signature of the channel initiator (funder)
399 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
401 /// Next nonce the channel acceptor should use to finalize the funding output signature
402 pub next_local_nonce: Option<musig2::types::PublicNonce>
405 /// A [`funding_signed`] message to be sent to or received from a peer.
407 /// Used in V1 channel establishment
409 /// [`funding_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-funding_signed-message
410 #[derive(Clone, Debug, PartialEq, Eq)]
411 pub struct FundingSigned {
413 pub channel_id: ChannelId,
414 /// The signature of the channel acceptor (fundee) on the initial commitment transaction
415 pub signature: Signature,
417 /// The partial signature of the channel acceptor (fundee)
418 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
421 /// A [`channel_ready`] message to be sent to or received from a peer.
423 /// [`channel_ready`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-channel_ready-message
424 #[derive(Clone, Debug, PartialEq, Eq)]
425 pub struct ChannelReady {
427 pub channel_id: ChannelId,
428 /// The per-commitment point of the second commitment transaction
429 pub next_per_commitment_point: PublicKey,
430 /// If set, provides a `short_channel_id` alias for this channel.
432 /// The sender will accept payments to be forwarded over this SCID and forward them to this
433 /// messages' recipient.
434 pub short_channel_id_alias: Option<u64>,
437 /// A tx_add_input message for adding an input during interactive transaction construction
439 // TODO(dual_funding): Add spec link for `tx_add_input`.
440 #[derive(Clone, Debug, PartialEq, Eq)]
441 pub struct TxAddInput {
443 pub channel_id: ChannelId,
444 /// A randomly chosen unique identifier for this input, which is even for initiators and odd for
447 /// Serialized transaction that contains the output this input spends to verify that it is non
449 pub prevtx: TransactionU16LenLimited,
450 /// The index of the output being spent
452 /// The sequence number of this input
456 /// A tx_add_output message for adding an output during interactive transaction construction.
458 // TODO(dual_funding): Add spec link for `tx_add_output`.
459 #[derive(Clone, Debug, PartialEq, Eq)]
460 pub struct TxAddOutput {
462 pub channel_id: ChannelId,
463 /// A randomly chosen unique identifier for this output, which is even for initiators and odd for
466 /// The satoshi value of the output
468 /// The scriptPubKey for the output
472 /// A tx_remove_input message for removing an input during interactive transaction construction.
474 // TODO(dual_funding): Add spec link for `tx_remove_input`.
475 #[derive(Clone, Debug, PartialEq, Eq)]
476 pub struct TxRemoveInput {
478 pub channel_id: ChannelId,
479 /// The serial ID of the input to be removed
483 /// A tx_remove_output message for removing an output during interactive transaction construction.
485 // TODO(dual_funding): Add spec link for `tx_remove_output`.
486 #[derive(Clone, Debug, PartialEq, Eq)]
487 pub struct TxRemoveOutput {
489 pub channel_id: ChannelId,
490 /// The serial ID of the output to be removed
494 /// A tx_complete message signalling the conclusion of a peer's transaction contributions during
495 /// interactive transaction construction.
497 // TODO(dual_funding): Add spec link for `tx_complete`.
498 #[derive(Clone, Debug, PartialEq, Eq)]
499 pub struct TxComplete {
501 pub channel_id: ChannelId,
504 /// A tx_signatures message containing the sender's signatures for a transaction constructed with
505 /// interactive transaction construction.
507 // TODO(dual_funding): Add spec link for `tx_signatures`.
508 #[derive(Clone, Debug, PartialEq, Eq)]
509 pub struct TxSignatures {
511 pub channel_id: ChannelId,
514 /// The list of witnesses
515 pub witnesses: Vec<Witness>,
518 /// A tx_init_rbf message which initiates a replacement of the transaction after it's been
521 // TODO(dual_funding): Add spec link for `tx_init_rbf`.
522 #[derive(Clone, Debug, PartialEq, Eq)]
523 pub struct TxInitRbf {
525 pub channel_id: ChannelId,
526 /// The locktime of the transaction
528 /// The feerate of the transaction
529 pub feerate_sat_per_1000_weight: u32,
530 /// The number of satoshis the sender will contribute to or, if negative, remove from
531 /// (e.g. splice-out) the funding output of the transaction
532 pub funding_output_contribution: Option<i64>,
535 /// A tx_ack_rbf message which acknowledges replacement of the transaction after it's been
538 // TODO(dual_funding): Add spec link for `tx_ack_rbf`.
539 #[derive(Clone, Debug, PartialEq, Eq)]
540 pub struct TxAckRbf {
542 pub channel_id: ChannelId,
543 /// The number of satoshis the sender will contribute to or, if negative, remove from
544 /// (e.g. splice-out) the funding output of the transaction
545 pub funding_output_contribution: Option<i64>,
548 /// A tx_abort message which signals the cancellation of an in-progress transaction negotiation.
550 // TODO(dual_funding): Add spec link for `tx_abort`.
551 #[derive(Clone, Debug, PartialEq, Eq)]
554 pub channel_id: ChannelId,
559 /// A [`shutdown`] message to be sent to or received from a peer.
561 /// [`shutdown`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-initiation-shutdown
562 #[derive(Clone, Debug, PartialEq, Eq)]
563 pub struct Shutdown {
565 pub channel_id: ChannelId,
566 /// The destination of this peer's funds on closing.
568 /// Must be in one of these forms: P2PKH, P2SH, P2WPKH, P2WSH, P2TR.
569 pub scriptpubkey: Script,
572 /// The minimum and maximum fees which the sender is willing to place on the closing transaction.
574 /// This is provided in [`ClosingSigned`] by both sides to indicate the fee range they are willing
576 #[derive(Clone, Debug, PartialEq, Eq)]
577 pub struct ClosingSignedFeeRange {
578 /// The minimum absolute fee, in satoshis, which the sender is willing to place on the closing
580 pub min_fee_satoshis: u64,
581 /// The maximum absolute fee, in satoshis, which the sender is willing to place on the closing
583 pub max_fee_satoshis: u64,
586 /// A [`closing_signed`] message to be sent to or received from a peer.
588 /// [`closing_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-negotiation-closing_signed
589 #[derive(Clone, Debug, PartialEq, Eq)]
590 pub struct ClosingSigned {
592 pub channel_id: ChannelId,
593 /// The proposed total fee for the closing transaction
594 pub fee_satoshis: u64,
595 /// A signature on the closing transaction
596 pub signature: Signature,
597 /// The minimum and maximum fees which the sender is willing to accept, provided only by new
599 pub fee_range: Option<ClosingSignedFeeRange>,
602 /// An [`update_add_htlc`] message to be sent to or received from a peer.
604 /// [`update_add_htlc`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#adding-an-htlc-update_add_htlc
605 #[derive(Clone, Debug, PartialEq, Eq)]
606 pub struct UpdateAddHTLC {
608 pub channel_id: ChannelId,
611 /// The HTLC value in milli-satoshi
612 pub amount_msat: u64,
613 /// The payment hash, the pre-image of which controls HTLC redemption
614 pub payment_hash: PaymentHash,
615 /// The expiry height of the HTLC
616 pub cltv_expiry: u32,
617 /// The extra fee skimmed by the sender of this message. See
618 /// [`ChannelConfig::accept_underpaying_htlcs`].
620 /// [`ChannelConfig::accept_underpaying_htlcs`]: crate::util::config::ChannelConfig::accept_underpaying_htlcs
621 pub skimmed_fee_msat: Option<u64>,
622 pub(crate) onion_routing_packet: OnionPacket,
625 /// An onion message to be sent to or received from a peer.
627 // TODO: update with link to OM when they are merged into the BOLTs
628 #[derive(Clone, Debug, PartialEq, Eq)]
629 pub struct OnionMessage {
630 /// Used in decrypting the onion packet's payload.
631 pub blinding_point: PublicKey,
632 pub(crate) onion_routing_packet: onion_message::Packet,
635 /// An [`update_fulfill_htlc`] message to be sent to or received from a peer.
637 /// [`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
638 #[derive(Clone, Debug, PartialEq, Eq)]
639 pub struct UpdateFulfillHTLC {
641 pub channel_id: ChannelId,
644 /// The pre-image of the payment hash, allowing HTLC redemption
645 pub payment_preimage: PaymentPreimage,
648 /// An [`update_fail_htlc`] message to be sent to or received from a peer.
650 /// [`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
651 #[derive(Clone, Debug, PartialEq, Eq)]
652 pub struct UpdateFailHTLC {
654 pub channel_id: ChannelId,
657 pub(crate) reason: OnionErrorPacket,
660 /// An [`update_fail_malformed_htlc`] message to be sent to or received from a peer.
662 /// [`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
663 #[derive(Clone, Debug, PartialEq, Eq)]
664 pub struct UpdateFailMalformedHTLC {
666 pub channel_id: ChannelId,
669 pub(crate) sha256_of_onion: [u8; 32],
671 pub failure_code: u16,
674 /// A [`commitment_signed`] message to be sent to or received from a peer.
676 /// [`commitment_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#committing-updates-so-far-commitment_signed
677 #[derive(Clone, Debug, PartialEq, Eq)]
678 pub struct CommitmentSigned {
680 pub channel_id: ChannelId,
681 /// A signature on the commitment transaction
682 pub signature: Signature,
683 /// Signatures on the HTLC transactions
684 pub htlc_signatures: Vec<Signature>,
686 /// The partial Taproot signature on the commitment transaction
687 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
690 /// A [`revoke_and_ack`] message to be sent to or received from a peer.
692 /// [`revoke_and_ack`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#completing-the-transition-to-the-updated-state-revoke_and_ack
693 #[derive(Clone, Debug, PartialEq, Eq)]
694 pub struct RevokeAndACK {
696 pub channel_id: ChannelId,
697 /// The secret corresponding to the per-commitment point
698 pub per_commitment_secret: [u8; 32],
699 /// The next sender-broadcast commitment transaction's per-commitment point
700 pub next_per_commitment_point: PublicKey,
702 /// Musig nonce the recipient should use in their next commitment signature message
703 pub next_local_nonce: Option<musig2::types::PublicNonce>
706 /// An [`update_fee`] message to be sent to or received from a peer
708 /// [`update_fee`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#updating-fees-update_fee
709 #[derive(Clone, Debug, PartialEq, Eq)]
710 pub struct UpdateFee {
712 pub channel_id: ChannelId,
713 /// Fee rate per 1000-weight of the transaction
714 pub feerate_per_kw: u32,
717 /// A [`channel_reestablish`] message to be sent to or received from a peer.
719 /// [`channel_reestablish`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#message-retransmission
720 #[derive(Clone, Debug, PartialEq, Eq)]
721 pub struct ChannelReestablish {
723 pub channel_id: ChannelId,
724 /// The next commitment number for the sender
725 pub next_local_commitment_number: u64,
726 /// The next commitment number for the recipient
727 pub next_remote_commitment_number: u64,
728 /// Proof that the sender knows the per-commitment secret of a specific commitment transaction
729 /// belonging to the recipient
730 pub your_last_per_commitment_secret: [u8; 32],
731 /// The sender's per-commitment point for their current commitment transaction
732 pub my_current_per_commitment_point: PublicKey,
733 /// The next funding transaction ID
734 pub next_funding_txid: Option<Txid>,
737 /// An [`announcement_signatures`] message to be sent to or received from a peer.
739 /// [`announcement_signatures`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-announcement_signatures-message
740 #[derive(Clone, Debug, PartialEq, Eq)]
741 pub struct AnnouncementSignatures {
743 pub channel_id: ChannelId,
744 /// The short channel ID
745 pub short_channel_id: u64,
746 /// A signature by the node key
747 pub node_signature: Signature,
748 /// A signature by the funding key
749 pub bitcoin_signature: Signature,
752 /// An address which can be used to connect to a remote peer.
753 #[derive(Clone, Debug, PartialEq, Eq)]
754 pub enum SocketAddress {
755 /// An IPv4 address and port on which the peer is listening.
757 /// The 4-byte IPv4 address
759 /// The port on which the node is listening
762 /// An IPv6 address and port on which the peer is listening.
764 /// The 16-byte IPv6 address
766 /// The port on which the node is listening
769 /// An old-style Tor onion address/port on which the peer is listening.
771 /// This field is deprecated and the Tor network generally no longer supports V2 Onion
772 /// addresses. Thus, the details are not parsed here.
774 /// A new-style Tor onion address/port on which the peer is listening.
776 /// To create the human-readable "hostname", concatenate the ED25519 pubkey, checksum, and version,
777 /// wrap as base32 and append ".onion".
779 /// The ed25519 long-term public key of the peer
780 ed25519_pubkey: [u8; 32],
781 /// The checksum of the pubkey and version, as included in the onion address
783 /// The version byte, as defined by the Tor Onion v3 spec.
785 /// The port on which the node is listening
788 /// A hostname/port on which the peer is listening.
790 /// The hostname on which the node is listening.
792 /// The port on which the node is listening.
797 /// Gets the ID of this address type. Addresses in [`NodeAnnouncement`] messages should be sorted
799 pub(crate) fn get_id(&self) -> u8 {
801 &SocketAddress::TcpIpV4 {..} => { 1 },
802 &SocketAddress::TcpIpV6 {..} => { 2 },
803 &SocketAddress::OnionV2(_) => { 3 },
804 &SocketAddress::OnionV3 {..} => { 4 },
805 &SocketAddress::Hostname {..} => { 5 },
809 /// Strict byte-length of address descriptor, 1-byte type not recorded
810 fn len(&self) -> u16 {
812 &SocketAddress::TcpIpV4 { .. } => { 6 },
813 &SocketAddress::TcpIpV6 { .. } => { 18 },
814 &SocketAddress::OnionV2(_) => { 12 },
815 &SocketAddress::OnionV3 { .. } => { 37 },
816 // Consists of 1-byte hostname length, hostname bytes, and 2-byte port.
817 &SocketAddress::Hostname { ref hostname, .. } => { u16::from(hostname.len()) + 3 },
821 /// The maximum length of any address descriptor, not including the 1-byte type.
822 /// This maximum length is reached by a hostname address descriptor:
823 /// a hostname with a maximum length of 255, its 1-byte length and a 2-byte port.
824 pub(crate) const MAX_LEN: u16 = 258;
827 impl Writeable for SocketAddress {
828 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
830 &SocketAddress::TcpIpV4 { ref addr, ref port } => {
835 &SocketAddress::TcpIpV6 { ref addr, ref port } => {
840 &SocketAddress::OnionV2(bytes) => {
842 bytes.write(writer)?;
844 &SocketAddress::OnionV3 { ref ed25519_pubkey, ref checksum, ref version, ref port } => {
846 ed25519_pubkey.write(writer)?;
847 checksum.write(writer)?;
848 version.write(writer)?;
851 &SocketAddress::Hostname { ref hostname, ref port } => {
853 hostname.write(writer)?;
861 impl Readable for Result<SocketAddress, u8> {
862 fn read<R: Read>(reader: &mut R) -> Result<Result<SocketAddress, u8>, DecodeError> {
863 let byte = <u8 as Readable>::read(reader)?;
866 Ok(Ok(SocketAddress::TcpIpV4 {
867 addr: Readable::read(reader)?,
868 port: Readable::read(reader)?,
872 Ok(Ok(SocketAddress::TcpIpV6 {
873 addr: Readable::read(reader)?,
874 port: Readable::read(reader)?,
877 3 => Ok(Ok(SocketAddress::OnionV2(Readable::read(reader)?))),
879 Ok(Ok(SocketAddress::OnionV3 {
880 ed25519_pubkey: Readable::read(reader)?,
881 checksum: Readable::read(reader)?,
882 version: Readable::read(reader)?,
883 port: Readable::read(reader)?,
887 Ok(Ok(SocketAddress::Hostname {
888 hostname: Readable::read(reader)?,
889 port: Readable::read(reader)?,
892 _ => return Ok(Err(byte)),
897 impl Readable for SocketAddress {
898 fn read<R: Read>(reader: &mut R) -> Result<SocketAddress, DecodeError> {
899 match Readable::read(reader) {
900 Ok(Ok(res)) => Ok(res),
901 Ok(Err(_)) => Err(DecodeError::UnknownVersion),
907 /// [`SocketAddress`] error variants
908 #[derive(Debug, Eq, PartialEq, Clone)]
909 pub enum SocketAddressParseError {
910 /// Socket address (IPv4/IPv6) parsing error
912 /// Invalid input format
916 /// Invalid onion v3 address
920 impl fmt::Display for SocketAddressParseError {
921 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
923 SocketAddressParseError::SocketAddrParse => write!(f, "Socket address (IPv4/IPv6) parsing error"),
924 SocketAddressParseError::InvalidInput => write!(f, "Invalid input format. \
925 Expected: \"<ipv4>:<port>\", \"[<ipv6>]:<port>\", \"<onion address>.onion:<port>\" or \"<hostname>:<port>\""),
926 SocketAddressParseError::InvalidPort => write!(f, "Invalid port"),
927 SocketAddressParseError::InvalidOnionV3 => write!(f, "Invalid onion v3 address"),
932 #[cfg(feature = "std")]
933 impl From<std::net::SocketAddrV4> for SocketAddress {
934 fn from(addr: std::net::SocketAddrV4) -> Self {
935 SocketAddress::TcpIpV4 { addr: addr.ip().octets(), port: addr.port() }
939 #[cfg(feature = "std")]
940 impl From<std::net::SocketAddrV6> for SocketAddress {
941 fn from(addr: std::net::SocketAddrV6) -> Self {
942 SocketAddress::TcpIpV6 { addr: addr.ip().octets(), port: addr.port() }
946 #[cfg(feature = "std")]
947 impl From<std::net::SocketAddr> for SocketAddress {
948 fn from(addr: std::net::SocketAddr) -> Self {
950 std::net::SocketAddr::V4(addr) => addr.into(),
951 std::net::SocketAddr::V6(addr) => addr.into(),
956 fn parse_onion_address(host: &str, port: u16) -> Result<SocketAddress, SocketAddressParseError> {
957 if host.ends_with(".onion") {
958 let domain = &host[..host.len() - ".onion".len()];
959 if domain.len() != 56 {
960 return Err(SocketAddressParseError::InvalidOnionV3);
962 let onion = base32::Alphabet::RFC4648 { padding: false }.decode(&domain).map_err(|_| SocketAddressParseError::InvalidOnionV3)?;
963 if onion.len() != 35 {
964 return Err(SocketAddressParseError::InvalidOnionV3);
966 let version = onion[0];
967 let first_checksum_flag = onion[1];
968 let second_checksum_flag = onion[2];
969 let mut ed25519_pubkey = [0; 32];
970 ed25519_pubkey.copy_from_slice(&onion[3..35]);
971 let checksum = u16::from_be_bytes([first_checksum_flag, second_checksum_flag]);
972 return Ok(SocketAddress::OnionV3 { ed25519_pubkey, checksum, version, port });
975 return Err(SocketAddressParseError::InvalidInput);
979 #[cfg(feature = "std")]
980 impl FromStr for SocketAddress {
981 type Err = SocketAddressParseError;
983 fn from_str(s: &str) -> Result<Self, Self::Err> {
984 match std::net::SocketAddr::from_str(s) {
985 Ok(addr) => Ok(addr.into()),
987 let trimmed_input = match s.rfind(":") {
989 None => return Err(SocketAddressParseError::InvalidInput),
991 let host = &s[..trimmed_input];
992 let port: u16 = s[trimmed_input + 1..].parse().map_err(|_| SocketAddressParseError::InvalidPort)?;
993 if host.ends_with(".onion") {
994 return parse_onion_address(host, port);
996 if let Ok(hostname) = Hostname::try_from(s[..trimmed_input].to_string()) {
997 return Ok(SocketAddress::Hostname { hostname, port });
999 return Err(SocketAddressParseError::SocketAddrParse)
1005 /// Represents the set of gossip messages that require a signature from a node's identity key.
1006 pub enum UnsignedGossipMessage<'a> {
1007 /// An unsigned channel announcement.
1008 ChannelAnnouncement(&'a UnsignedChannelAnnouncement),
1009 /// An unsigned channel update.
1010 ChannelUpdate(&'a UnsignedChannelUpdate),
1011 /// An unsigned node announcement.
1012 NodeAnnouncement(&'a UnsignedNodeAnnouncement)
1015 impl<'a> Writeable for UnsignedGossipMessage<'a> {
1016 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
1018 UnsignedGossipMessage::ChannelAnnouncement(ref msg) => msg.write(writer),
1019 UnsignedGossipMessage::ChannelUpdate(ref msg) => msg.write(writer),
1020 UnsignedGossipMessage::NodeAnnouncement(ref msg) => msg.write(writer),
1025 /// The unsigned part of a [`node_announcement`] message.
1027 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
1028 #[derive(Clone, Debug, PartialEq, Eq)]
1029 pub struct UnsignedNodeAnnouncement {
1030 /// The advertised features
1031 pub features: NodeFeatures,
1032 /// A strictly monotonic announcement counter, with gaps allowed
1034 /// The `node_id` this announcement originated from (don't rebroadcast the `node_announcement` back
1036 pub node_id: NodeId,
1037 /// An RGB color for UI purposes
1039 /// An alias, for UI purposes.
1041 /// This should be sanitized before use. There is no guarantee of uniqueness.
1042 pub alias: NodeAlias,
1043 /// List of addresses on which this node is reachable
1044 pub addresses: Vec<SocketAddress>,
1045 pub(crate) excess_address_data: Vec<u8>,
1046 pub(crate) excess_data: Vec<u8>,
1048 #[derive(Clone, Debug, PartialEq, Eq)]
1049 /// A [`node_announcement`] message to be sent to or received from a peer.
1051 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
1052 pub struct NodeAnnouncement {
1053 /// The signature by the node key
1054 pub signature: Signature,
1055 /// The actual content of the announcement
1056 pub contents: UnsignedNodeAnnouncement,
1059 /// The unsigned part of a [`channel_announcement`] message.
1061 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
1062 #[derive(Clone, Debug, PartialEq, Eq)]
1063 pub struct UnsignedChannelAnnouncement {
1064 /// The advertised channel features
1065 pub features: ChannelFeatures,
1066 /// The genesis hash of the blockchain where the channel is to be opened
1067 pub chain_hash: BlockHash,
1068 /// The short channel ID
1069 pub short_channel_id: u64,
1070 /// One of the two `node_id`s which are endpoints of this channel
1071 pub node_id_1: NodeId,
1072 /// The other of the two `node_id`s which are endpoints of this channel
1073 pub node_id_2: NodeId,
1074 /// The funding key for the first node
1075 pub bitcoin_key_1: NodeId,
1076 /// The funding key for the second node
1077 pub bitcoin_key_2: NodeId,
1078 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1081 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1082 pub excess_data: Vec<u8>,
1084 /// A [`channel_announcement`] message to be sent to or received from a peer.
1086 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
1087 #[derive(Clone, Debug, PartialEq, Eq)]
1088 pub struct ChannelAnnouncement {
1089 /// Authentication of the announcement by the first public node
1090 pub node_signature_1: Signature,
1091 /// Authentication of the announcement by the second public node
1092 pub node_signature_2: Signature,
1093 /// Proof of funding UTXO ownership by the first public node
1094 pub bitcoin_signature_1: Signature,
1095 /// Proof of funding UTXO ownership by the second public node
1096 pub bitcoin_signature_2: Signature,
1097 /// The actual announcement
1098 pub contents: UnsignedChannelAnnouncement,
1101 /// The unsigned part of a [`channel_update`] message.
1103 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1104 #[derive(Clone, Debug, PartialEq, Eq)]
1105 pub struct UnsignedChannelUpdate {
1106 /// The genesis hash of the blockchain where the channel is to be opened
1107 pub chain_hash: BlockHash,
1108 /// The short channel ID
1109 pub short_channel_id: u64,
1110 /// A strictly monotonic announcement counter, with gaps allowed, specific to this channel
1114 /// The number of blocks such that if:
1115 /// `incoming_htlc.cltv_expiry < outgoing_htlc.cltv_expiry + cltv_expiry_delta`
1116 /// then we need to fail the HTLC backwards. When forwarding an HTLC, `cltv_expiry_delta` determines
1117 /// the outgoing HTLC's minimum `cltv_expiry` value -- so, if an incoming HTLC comes in with a
1118 /// `cltv_expiry` of 100000, and the node we're forwarding to has a `cltv_expiry_delta` value of 10,
1119 /// then we'll check that the outgoing HTLC's `cltv_expiry` value is at least 100010 before
1120 /// forwarding. Note that the HTLC sender is the one who originally sets this value when
1121 /// constructing the route.
1122 pub cltv_expiry_delta: u16,
1123 /// The minimum HTLC size incoming to sender, in milli-satoshi
1124 pub htlc_minimum_msat: u64,
1125 /// The maximum HTLC value incoming to sender, in milli-satoshi.
1127 /// This used to be optional.
1128 pub htlc_maximum_msat: u64,
1129 /// The base HTLC fee charged by sender, in milli-satoshi
1130 pub fee_base_msat: u32,
1131 /// The amount to fee multiplier, in micro-satoshi
1132 pub fee_proportional_millionths: u32,
1133 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1136 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1137 pub excess_data: Vec<u8>,
1139 /// A [`channel_update`] message to be sent to or received from a peer.
1141 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1142 #[derive(Clone, Debug, PartialEq, Eq)]
1143 pub struct ChannelUpdate {
1144 /// A signature of the channel update
1145 pub signature: Signature,
1146 /// The actual channel update
1147 pub contents: UnsignedChannelUpdate,
1150 /// A [`query_channel_range`] message is used to query a peer for channel
1151 /// UTXOs in a range of blocks. The recipient of a query makes a best
1152 /// effort to reply to the query using one or more [`ReplyChannelRange`]
1155 /// [`query_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1156 #[derive(Clone, Debug, PartialEq, Eq)]
1157 pub struct QueryChannelRange {
1158 /// The genesis hash of the blockchain being queried
1159 pub chain_hash: BlockHash,
1160 /// The height of the first block for the channel UTXOs being queried
1161 pub first_blocknum: u32,
1162 /// The number of blocks to include in the query results
1163 pub number_of_blocks: u32,
1166 /// A [`reply_channel_range`] message is a reply to a [`QueryChannelRange`]
1169 /// Multiple `reply_channel_range` messages can be sent in reply
1170 /// to a single [`QueryChannelRange`] message. The query recipient makes a
1171 /// best effort to respond based on their local network view which may
1172 /// not be a perfect view of the network. The `short_channel_id`s in the
1173 /// reply are encoded. We only support `encoding_type=0` uncompressed
1174 /// serialization and do not support `encoding_type=1` zlib serialization.
1176 /// [`reply_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1177 #[derive(Clone, Debug, PartialEq, Eq)]
1178 pub struct ReplyChannelRange {
1179 /// The genesis hash of the blockchain being queried
1180 pub chain_hash: BlockHash,
1181 /// The height of the first block in the range of the reply
1182 pub first_blocknum: u32,
1183 /// The number of blocks included in the range of the reply
1184 pub number_of_blocks: u32,
1185 /// True when this is the final reply for a query
1186 pub sync_complete: bool,
1187 /// The `short_channel_id`s in the channel range
1188 pub short_channel_ids: Vec<u64>,
1191 /// A [`query_short_channel_ids`] message is used to query a peer for
1192 /// routing gossip messages related to one or more `short_channel_id`s.
1194 /// The query recipient will reply with the latest, if available,
1195 /// [`ChannelAnnouncement`], [`ChannelUpdate`] and [`NodeAnnouncement`] messages
1196 /// it maintains for the requested `short_channel_id`s followed by a
1197 /// [`ReplyShortChannelIdsEnd`] message. The `short_channel_id`s sent in
1198 /// this query are encoded. We only support `encoding_type=0` uncompressed
1199 /// serialization and do not support `encoding_type=1` zlib serialization.
1201 /// [`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
1202 #[derive(Clone, Debug, PartialEq, Eq)]
1203 pub struct QueryShortChannelIds {
1204 /// The genesis hash of the blockchain being queried
1205 pub chain_hash: BlockHash,
1206 /// The short_channel_ids that are being queried
1207 pub short_channel_ids: Vec<u64>,
1210 /// A [`reply_short_channel_ids_end`] message is sent as a reply to a
1211 /// message. The query recipient makes a best
1212 /// effort to respond based on their local network view which may not be
1213 /// a perfect view of the network.
1215 /// [`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
1216 #[derive(Clone, Debug, PartialEq, Eq)]
1217 pub struct ReplyShortChannelIdsEnd {
1218 /// The genesis hash of the blockchain that was queried
1219 pub chain_hash: BlockHash,
1220 /// Indicates if the query recipient maintains up-to-date channel
1221 /// information for the `chain_hash`
1222 pub full_information: bool,
1225 /// A [`gossip_timestamp_filter`] message is used by a node to request
1226 /// gossip relay for messages in the requested time range when the
1227 /// `gossip_queries` feature has been negotiated.
1229 /// [`gossip_timestamp_filter`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-gossip_timestamp_filter-message
1230 #[derive(Clone, Debug, PartialEq, Eq)]
1231 pub struct GossipTimestampFilter {
1232 /// The genesis hash of the blockchain for channel and node information
1233 pub chain_hash: BlockHash,
1234 /// The starting unix timestamp
1235 pub first_timestamp: u32,
1236 /// The range of information in seconds
1237 pub timestamp_range: u32,
1240 /// Encoding type for data compression of collections in gossip queries.
1242 /// We do not support `encoding_type=1` zlib serialization [defined in BOLT
1243 /// #7](https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#query-messages).
1245 Uncompressed = 0x00,
1248 /// Used to put an error message in a [`LightningError`].
1249 #[derive(Clone, Debug, PartialEq)]
1250 pub enum ErrorAction {
1251 /// The peer took some action which made us think they were useless. Disconnect them.
1253 /// An error message which we should make an effort to send before we disconnect.
1254 msg: Option<ErrorMessage>
1256 /// The peer did something incorrect. Tell them without closing any channels and disconnect them.
1257 DisconnectPeerWithWarning {
1258 /// A warning message which we should make an effort to send before we disconnect.
1259 msg: WarningMessage,
1261 /// The peer did something harmless that we weren't able to process, just log and ignore
1262 // New code should *not* use this. New code must use IgnoreAndLog, below!
1264 /// The peer did something harmless that we weren't able to meaningfully process.
1265 /// If the error is logged, log it at the given level.
1266 IgnoreAndLog(logger::Level),
1267 /// The peer provided us with a gossip message which we'd already seen. In most cases this
1268 /// should be ignored, but it may result in the message being forwarded if it is a duplicate of
1269 /// our own channel announcements.
1270 IgnoreDuplicateGossip,
1271 /// The peer did something incorrect. Tell them.
1273 /// The message to send.
1276 /// The peer did something incorrect. Tell them without closing any channels.
1277 SendWarningMessage {
1278 /// The message to send.
1279 msg: WarningMessage,
1280 /// The peer may have done something harmless that we weren't able to meaningfully process,
1281 /// though we should still tell them about it.
1282 /// If this event is logged, log it at the given level.
1283 log_level: logger::Level,
1287 /// An Err type for failure to process messages.
1288 #[derive(Clone, Debug)]
1289 pub struct LightningError {
1290 /// A human-readable message describing the error
1292 /// The action which should be taken against the offending peer.
1293 pub action: ErrorAction,
1296 /// Struct used to return values from [`RevokeAndACK`] messages, containing a bunch of commitment
1297 /// transaction updates if they were pending.
1298 #[derive(Clone, Debug, PartialEq, Eq)]
1299 pub struct CommitmentUpdate {
1300 /// `update_add_htlc` messages which should be sent
1301 pub update_add_htlcs: Vec<UpdateAddHTLC>,
1302 /// `update_fulfill_htlc` messages which should be sent
1303 pub update_fulfill_htlcs: Vec<UpdateFulfillHTLC>,
1304 /// `update_fail_htlc` messages which should be sent
1305 pub update_fail_htlcs: Vec<UpdateFailHTLC>,
1306 /// `update_fail_malformed_htlc` messages which should be sent
1307 pub update_fail_malformed_htlcs: Vec<UpdateFailMalformedHTLC>,
1308 /// An `update_fee` message which should be sent
1309 pub update_fee: Option<UpdateFee>,
1310 /// A `commitment_signed` message which should be sent
1311 pub commitment_signed: CommitmentSigned,
1314 /// A trait to describe an object which can receive channel messages.
1316 /// Messages MAY be called in parallel when they originate from different `their_node_ids`, however
1317 /// they MUST NOT be called in parallel when the two calls have the same `their_node_id`.
1318 pub trait ChannelMessageHandler : MessageSendEventsProvider {
1320 /// Handle an incoming `open_channel` message from the given peer.
1321 fn handle_open_channel(&self, their_node_id: &PublicKey, msg: &OpenChannel);
1322 /// Handle an incoming `open_channel2` message from the given peer.
1323 fn handle_open_channel_v2(&self, their_node_id: &PublicKey, msg: &OpenChannelV2);
1324 /// Handle an incoming `accept_channel` message from the given peer.
1325 fn handle_accept_channel(&self, their_node_id: &PublicKey, msg: &AcceptChannel);
1326 /// Handle an incoming `accept_channel2` message from the given peer.
1327 fn handle_accept_channel_v2(&self, their_node_id: &PublicKey, msg: &AcceptChannelV2);
1328 /// Handle an incoming `funding_created` message from the given peer.
1329 fn handle_funding_created(&self, their_node_id: &PublicKey, msg: &FundingCreated);
1330 /// Handle an incoming `funding_signed` message from the given peer.
1331 fn handle_funding_signed(&self, their_node_id: &PublicKey, msg: &FundingSigned);
1332 /// Handle an incoming `channel_ready` message from the given peer.
1333 fn handle_channel_ready(&self, their_node_id: &PublicKey, msg: &ChannelReady);
1336 /// Handle an incoming `shutdown` message from the given peer.
1337 fn handle_shutdown(&self, their_node_id: &PublicKey, msg: &Shutdown);
1338 /// Handle an incoming `closing_signed` message from the given peer.
1339 fn handle_closing_signed(&self, their_node_id: &PublicKey, msg: &ClosingSigned);
1341 // Interactive channel construction
1342 /// Handle an incoming `tx_add_input message` from the given peer.
1343 fn handle_tx_add_input(&self, their_node_id: &PublicKey, msg: &TxAddInput);
1344 /// Handle an incoming `tx_add_output` message from the given peer.
1345 fn handle_tx_add_output(&self, their_node_id: &PublicKey, msg: &TxAddOutput);
1346 /// Handle an incoming `tx_remove_input` message from the given peer.
1347 fn handle_tx_remove_input(&self, their_node_id: &PublicKey, msg: &TxRemoveInput);
1348 /// Handle an incoming `tx_remove_output` message from the given peer.
1349 fn handle_tx_remove_output(&self, their_node_id: &PublicKey, msg: &TxRemoveOutput);
1350 /// Handle an incoming `tx_complete message` from the given peer.
1351 fn handle_tx_complete(&self, their_node_id: &PublicKey, msg: &TxComplete);
1352 /// Handle an incoming `tx_signatures` message from the given peer.
1353 fn handle_tx_signatures(&self, their_node_id: &PublicKey, msg: &TxSignatures);
1354 /// Handle an incoming `tx_init_rbf` message from the given peer.
1355 fn handle_tx_init_rbf(&self, their_node_id: &PublicKey, msg: &TxInitRbf);
1356 /// Handle an incoming `tx_ack_rbf` message from the given peer.
1357 fn handle_tx_ack_rbf(&self, their_node_id: &PublicKey, msg: &TxAckRbf);
1358 /// Handle an incoming `tx_abort message` from the given peer.
1359 fn handle_tx_abort(&self, their_node_id: &PublicKey, msg: &TxAbort);
1362 /// Handle an incoming `update_add_htlc` message from the given peer.
1363 fn handle_update_add_htlc(&self, their_node_id: &PublicKey, msg: &UpdateAddHTLC);
1364 /// Handle an incoming `update_fulfill_htlc` message from the given peer.
1365 fn handle_update_fulfill_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFulfillHTLC);
1366 /// Handle an incoming `update_fail_htlc` message from the given peer.
1367 fn handle_update_fail_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailHTLC);
1368 /// Handle an incoming `update_fail_malformed_htlc` message from the given peer.
1369 fn handle_update_fail_malformed_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailMalformedHTLC);
1370 /// Handle an incoming `commitment_signed` message from the given peer.
1371 fn handle_commitment_signed(&self, their_node_id: &PublicKey, msg: &CommitmentSigned);
1372 /// Handle an incoming `revoke_and_ack` message from the given peer.
1373 fn handle_revoke_and_ack(&self, their_node_id: &PublicKey, msg: &RevokeAndACK);
1375 /// Handle an incoming `update_fee` message from the given peer.
1376 fn handle_update_fee(&self, their_node_id: &PublicKey, msg: &UpdateFee);
1378 // Channel-to-announce:
1379 /// Handle an incoming `announcement_signatures` message from the given peer.
1380 fn handle_announcement_signatures(&self, their_node_id: &PublicKey, msg: &AnnouncementSignatures);
1382 // Connection loss/reestablish:
1383 /// Indicates a connection to the peer failed/an existing connection was lost.
1384 fn peer_disconnected(&self, their_node_id: &PublicKey);
1386 /// Handle a peer reconnecting, possibly generating `channel_reestablish` message(s).
1388 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1389 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1390 /// message handlers may still wish to communicate with this peer.
1391 fn peer_connected(&self, their_node_id: &PublicKey, msg: &Init, inbound: bool) -> Result<(), ()>;
1392 /// Handle an incoming `channel_reestablish` message from the given peer.
1393 fn handle_channel_reestablish(&self, their_node_id: &PublicKey, msg: &ChannelReestablish);
1395 /// Handle an incoming `channel_update` message from the given peer.
1396 fn handle_channel_update(&self, their_node_id: &PublicKey, msg: &ChannelUpdate);
1399 /// Handle an incoming `error` message from the given peer.
1400 fn handle_error(&self, their_node_id: &PublicKey, msg: &ErrorMessage);
1402 // Handler information:
1403 /// Gets the node feature flags which this handler itself supports. All available handlers are
1404 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1405 /// which are broadcasted in our [`NodeAnnouncement`] message.
1406 fn provided_node_features(&self) -> NodeFeatures;
1408 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1409 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1410 /// which are sent in our [`Init`] message.
1412 /// Note that this method is called before [`Self::peer_connected`].
1413 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1415 /// Gets the genesis hashes for this `ChannelMessageHandler` indicating which chains it supports.
1417 /// If it's `None`, then no particular network chain hash compatibility will be enforced when
1418 /// connecting to peers.
1419 fn get_genesis_hashes(&self) -> Option<Vec<ChainHash>>;
1422 /// A trait to describe an object which can receive routing messages.
1424 /// # Implementor DoS Warnings
1426 /// For messages enabled with the `gossip_queries` feature there are potential DoS vectors when
1427 /// handling inbound queries. Implementors using an on-disk network graph should be aware of
1428 /// repeated disk I/O for queries accessing different parts of the network graph.
1429 pub trait RoutingMessageHandler : MessageSendEventsProvider {
1430 /// Handle an incoming `node_announcement` message, returning `true` if it should be forwarded on,
1431 /// `false` or returning an `Err` otherwise.
1432 fn handle_node_announcement(&self, msg: &NodeAnnouncement) -> Result<bool, LightningError>;
1433 /// Handle a `channel_announcement` message, returning `true` if it should be forwarded on, `false`
1434 /// or returning an `Err` otherwise.
1435 fn handle_channel_announcement(&self, msg: &ChannelAnnouncement) -> Result<bool, LightningError>;
1436 /// Handle an incoming `channel_update` message, returning true if it should be forwarded on,
1437 /// `false` or returning an `Err` otherwise.
1438 fn handle_channel_update(&self, msg: &ChannelUpdate) -> Result<bool, LightningError>;
1439 /// Gets channel announcements and updates required to dump our routing table to a remote node,
1440 /// starting at the `short_channel_id` indicated by `starting_point` and including announcements
1441 /// for a single channel.
1442 fn get_next_channel_announcement(&self, starting_point: u64) -> Option<(ChannelAnnouncement, Option<ChannelUpdate>, Option<ChannelUpdate>)>;
1443 /// Gets a node announcement required to dump our routing table to a remote node, starting at
1444 /// the node *after* the provided pubkey and including up to one announcement immediately
1445 /// higher (as defined by `<PublicKey as Ord>::cmp`) than `starting_point`.
1446 /// If `None` is provided for `starting_point`, we start at the first node.
1447 fn get_next_node_announcement(&self, starting_point: Option<&NodeId>) -> Option<NodeAnnouncement>;
1448 /// Called when a connection is established with a peer. This can be used to
1449 /// perform routing table synchronization using a strategy defined by the
1452 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1453 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1454 /// message handlers may still wish to communicate with this peer.
1455 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1456 /// Handles the reply of a query we initiated to learn about channels
1457 /// for a given range of blocks. We can expect to receive one or more
1458 /// replies to a single query.
1459 fn handle_reply_channel_range(&self, their_node_id: &PublicKey, msg: ReplyChannelRange) -> Result<(), LightningError>;
1460 /// Handles the reply of a query we initiated asking for routing gossip
1461 /// messages for a list of channels. We should receive this message when
1462 /// a node has completed its best effort to send us the pertaining routing
1463 /// gossip messages.
1464 fn handle_reply_short_channel_ids_end(&self, their_node_id: &PublicKey, msg: ReplyShortChannelIdsEnd) -> Result<(), LightningError>;
1465 /// Handles when a peer asks us to send a list of `short_channel_id`s
1466 /// for the requested range of blocks.
1467 fn handle_query_channel_range(&self, their_node_id: &PublicKey, msg: QueryChannelRange) -> Result<(), LightningError>;
1468 /// Handles when a peer asks us to send routing gossip messages for a
1469 /// list of `short_channel_id`s.
1470 fn handle_query_short_channel_ids(&self, their_node_id: &PublicKey, msg: QueryShortChannelIds) -> Result<(), LightningError>;
1472 // Handler queueing status:
1473 /// Indicates that there are a large number of [`ChannelAnnouncement`] (or other) messages
1474 /// pending some async action. While there is no guarantee of the rate of future messages, the
1475 /// caller should seek to reduce the rate of new gossip messages handled, especially
1476 /// [`ChannelAnnouncement`]s.
1477 fn processing_queue_high(&self) -> bool;
1479 // Handler information:
1480 /// Gets the node feature flags which this handler itself supports. All available handlers are
1481 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1482 /// which are broadcasted in our [`NodeAnnouncement`] message.
1483 fn provided_node_features(&self) -> NodeFeatures;
1484 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1485 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1486 /// which are sent in our [`Init`] message.
1488 /// Note that this method is called before [`Self::peer_connected`].
1489 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1492 /// A trait to describe an object that can receive onion messages.
1493 pub trait OnionMessageHandler : OnionMessageProvider {
1494 /// Handle an incoming `onion_message` message from the given peer.
1495 fn handle_onion_message(&self, peer_node_id: &PublicKey, msg: &OnionMessage);
1496 /// Called when a connection is established with a peer. Can be used to track which peers
1497 /// advertise onion message support and are online.
1499 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1500 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1501 /// message handlers may still wish to communicate with this peer.
1502 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1503 /// Indicates a connection to the peer failed/an existing connection was lost. Allows handlers to
1504 /// drop and refuse to forward onion messages to this peer.
1505 fn peer_disconnected(&self, their_node_id: &PublicKey);
1507 // Handler information:
1508 /// Gets the node feature flags which this handler itself supports. All available handlers are
1509 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1510 /// which are broadcasted in our [`NodeAnnouncement`] message.
1511 fn provided_node_features(&self) -> NodeFeatures;
1513 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1514 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1515 /// which are sent in our [`Init`] message.
1517 /// Note that this method is called before [`Self::peer_connected`].
1518 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1521 mod fuzzy_internal_msgs {
1522 use bitcoin::secp256k1::PublicKey;
1523 use crate::prelude::*;
1524 use crate::ln::{PaymentPreimage, PaymentSecret};
1526 // These types aren't intended to be pub, but are exposed for direct fuzzing (as we deserialize
1527 // them from untrusted input):
1529 pub struct FinalOnionHopData {
1530 pub payment_secret: PaymentSecret,
1531 /// The total value, in msat, of the payment as received by the ultimate recipient.
1532 /// Message serialization may panic if this value is more than 21 million Bitcoin.
1533 pub total_msat: u64,
1536 pub enum InboundOnionPayload {
1538 short_channel_id: u64,
1539 /// The value, in msat, of the payment after this hop's fee is deducted.
1540 amt_to_forward: u64,
1541 outgoing_cltv_value: u32,
1544 payment_data: Option<FinalOnionHopData>,
1545 payment_metadata: Option<Vec<u8>>,
1546 keysend_preimage: Option<PaymentPreimage>,
1547 custom_tlvs: Vec<(u64, Vec<u8>)>,
1549 outgoing_cltv_value: u32,
1553 pub(crate) enum OutboundOnionPayload {
1555 short_channel_id: u64,
1556 /// The value, in msat, of the payment after this hop's fee is deducted.
1557 amt_to_forward: u64,
1558 outgoing_cltv_value: u32,
1561 payment_data: Option<FinalOnionHopData>,
1562 payment_metadata: Option<Vec<u8>>,
1563 keysend_preimage: Option<PaymentPreimage>,
1564 custom_tlvs: Vec<(u64, Vec<u8>)>,
1566 outgoing_cltv_value: u32,
1569 encrypted_tlvs: Vec<u8>,
1570 intro_node_blinding_point: Option<PublicKey>,
1575 outgoing_cltv_value: u32,
1576 encrypted_tlvs: Vec<u8>,
1577 intro_node_blinding_point: Option<PublicKey>, // Set if the introduction node of the blinded path is the final node
1581 pub struct DecodedOnionErrorPacket {
1582 pub(crate) hmac: [u8; 32],
1583 pub(crate) failuremsg: Vec<u8>,
1584 pub(crate) pad: Vec<u8>,
1588 pub use self::fuzzy_internal_msgs::*;
1589 #[cfg(not(fuzzing))]
1590 pub(crate) use self::fuzzy_internal_msgs::*;
1593 pub(crate) struct OnionPacket {
1594 pub(crate) version: u8,
1595 /// In order to ensure we always return an error on onion decode in compliance with [BOLT
1596 /// #4](https://github.com/lightning/bolts/blob/master/04-onion-routing.md), we have to
1597 /// deserialize `OnionPacket`s contained in [`UpdateAddHTLC`] messages even if the ephemeral
1598 /// public key (here) is bogus, so we hold a [`Result`] instead of a [`PublicKey`] as we'd
1600 pub(crate) public_key: Result<PublicKey, secp256k1::Error>,
1601 pub(crate) hop_data: [u8; 20*65],
1602 pub(crate) hmac: [u8; 32],
1605 impl onion_utils::Packet for OnionPacket {
1606 type Data = onion_utils::FixedSizeOnionPacket;
1607 fn new(pubkey: PublicKey, hop_data: onion_utils::FixedSizeOnionPacket, hmac: [u8; 32]) -> Self {
1610 public_key: Ok(pubkey),
1611 hop_data: hop_data.0,
1617 impl Eq for OnionPacket { }
1618 impl PartialEq for OnionPacket {
1619 fn eq(&self, other: &OnionPacket) -> bool {
1620 for (i, j) in self.hop_data.iter().zip(other.hop_data.iter()) {
1621 if i != j { return false; }
1623 self.version == other.version &&
1624 self.public_key == other.public_key &&
1625 self.hmac == other.hmac
1629 impl fmt::Debug for OnionPacket {
1630 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1631 f.write_fmt(format_args!("OnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
1635 #[derive(Clone, Debug, PartialEq, Eq)]
1636 pub(crate) struct OnionErrorPacket {
1637 // This really should be a constant size slice, but the spec lets these things be up to 128KB?
1638 // (TODO) We limit it in decode to much lower...
1639 pub(crate) data: Vec<u8>,
1642 impl fmt::Display for DecodeError {
1643 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1645 DecodeError::UnknownVersion => f.write_str("Unknown realm byte in Onion packet"),
1646 DecodeError::UnknownRequiredFeature => f.write_str("Unknown required feature preventing decode"),
1647 DecodeError::InvalidValue => f.write_str("Nonsense bytes didn't map to the type they were interpreted as"),
1648 DecodeError::ShortRead => f.write_str("Packet extended beyond the provided bytes"),
1649 DecodeError::BadLengthDescriptor => f.write_str("A length descriptor in the packet didn't describe the later data correctly"),
1650 DecodeError::Io(ref e) => fmt::Debug::fmt(e, f),
1651 DecodeError::UnsupportedCompression => f.write_str("We don't support receiving messages with zlib-compressed fields"),
1656 impl From<io::Error> for DecodeError {
1657 fn from(e: io::Error) -> Self {
1658 if e.kind() == io::ErrorKind::UnexpectedEof {
1659 DecodeError::ShortRead
1661 DecodeError::Io(e.kind())
1666 #[cfg(not(taproot))]
1667 impl_writeable_msg!(AcceptChannel, {
1668 temporary_channel_id,
1669 dust_limit_satoshis,
1670 max_htlc_value_in_flight_msat,
1671 channel_reserve_satoshis,
1677 revocation_basepoint,
1679 delayed_payment_basepoint,
1681 first_per_commitment_point,
1683 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1684 (1, channel_type, option),
1688 impl_writeable_msg!(AcceptChannel, {
1689 temporary_channel_id,
1690 dust_limit_satoshis,
1691 max_htlc_value_in_flight_msat,
1692 channel_reserve_satoshis,
1698 revocation_basepoint,
1700 delayed_payment_basepoint,
1702 first_per_commitment_point,
1704 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1705 (1, channel_type, option),
1706 (4, next_local_nonce, option),
1709 impl_writeable_msg!(AcceptChannelV2, {
1710 temporary_channel_id,
1712 dust_limit_satoshis,
1713 max_htlc_value_in_flight_msat,
1719 revocation_basepoint,
1721 delayed_payment_basepoint,
1723 first_per_commitment_point,
1724 second_per_commitment_point,
1726 (0, shutdown_scriptpubkey, option),
1727 (1, channel_type, option),
1728 (2, require_confirmed_inputs, option),
1731 impl_writeable_msg!(TxAddInput, {
1739 impl_writeable_msg!(TxAddOutput, {
1746 impl_writeable_msg!(TxRemoveInput, {
1751 impl_writeable_msg!(TxRemoveOutput, {
1756 impl_writeable_msg!(TxComplete, {
1760 impl_writeable_msg!(TxSignatures, {
1766 impl_writeable_msg!(TxInitRbf, {
1769 feerate_sat_per_1000_weight,
1771 (0, funding_output_contribution, option),
1774 impl_writeable_msg!(TxAckRbf, {
1777 (0, funding_output_contribution, option),
1780 impl_writeable_msg!(TxAbort, {
1785 impl_writeable_msg!(AnnouncementSignatures, {
1792 impl_writeable_msg!(ChannelReestablish, {
1794 next_local_commitment_number,
1795 next_remote_commitment_number,
1796 your_last_per_commitment_secret,
1797 my_current_per_commitment_point,
1799 (0, next_funding_txid, option),
1802 impl_writeable_msg!(ClosingSigned,
1803 { channel_id, fee_satoshis, signature },
1804 { (1, fee_range, option) }
1807 impl_writeable!(ClosingSignedFeeRange, {
1812 #[cfg(not(taproot))]
1813 impl_writeable_msg!(CommitmentSigned, {
1820 impl_writeable_msg!(CommitmentSigned, {
1825 (2, partial_signature_with_nonce, option)
1828 impl_writeable!(DecodedOnionErrorPacket, {
1834 #[cfg(not(taproot))]
1835 impl_writeable_msg!(FundingCreated, {
1836 temporary_channel_id,
1838 funding_output_index,
1842 impl_writeable_msg!(FundingCreated, {
1843 temporary_channel_id,
1845 funding_output_index,
1848 (2, partial_signature_with_nonce, option),
1849 (4, next_local_nonce, option)
1852 #[cfg(not(taproot))]
1853 impl_writeable_msg!(FundingSigned, {
1859 impl_writeable_msg!(FundingSigned, {
1863 (2, partial_signature_with_nonce, option)
1866 impl_writeable_msg!(ChannelReady, {
1868 next_per_commitment_point,
1870 (1, short_channel_id_alias, option),
1873 impl Writeable for Init {
1874 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1875 // global_features gets the bottom 13 bits of our features, and local_features gets all of
1876 // our relevant feature bits. This keeps us compatible with old nodes.
1877 self.features.write_up_to_13(w)?;
1878 self.features.write(w)?;
1879 encode_tlv_stream!(w, {
1880 (1, self.networks.as_ref().map(|n| WithoutLength(n)), option),
1881 (3, self.remote_network_address, option),
1887 impl Readable for Init {
1888 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1889 let global_features: InitFeatures = Readable::read(r)?;
1890 let features: InitFeatures = Readable::read(r)?;
1891 let mut remote_network_address: Option<SocketAddress> = None;
1892 let mut networks: Option<WithoutLength<Vec<ChainHash>>> = None;
1893 decode_tlv_stream!(r, {
1894 (1, networks, option),
1895 (3, remote_network_address, option)
1898 features: features | global_features,
1899 networks: networks.map(|n| n.0),
1900 remote_network_address,
1905 impl_writeable_msg!(OpenChannel, {
1907 temporary_channel_id,
1910 dust_limit_satoshis,
1911 max_htlc_value_in_flight_msat,
1912 channel_reserve_satoshis,
1918 revocation_basepoint,
1920 delayed_payment_basepoint,
1922 first_per_commitment_point,
1925 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1926 (1, channel_type, option),
1929 impl_writeable_msg!(OpenChannelV2, {
1931 temporary_channel_id,
1932 funding_feerate_sat_per_1000_weight,
1933 commitment_feerate_sat_per_1000_weight,
1935 dust_limit_satoshis,
1936 max_htlc_value_in_flight_msat,
1942 revocation_basepoint,
1944 delayed_payment_basepoint,
1946 first_per_commitment_point,
1947 second_per_commitment_point,
1950 (0, shutdown_scriptpubkey, option),
1951 (1, channel_type, option),
1952 (2, require_confirmed_inputs, option),
1955 #[cfg(not(taproot))]
1956 impl_writeable_msg!(RevokeAndACK, {
1958 per_commitment_secret,
1959 next_per_commitment_point
1963 impl_writeable_msg!(RevokeAndACK, {
1965 per_commitment_secret,
1966 next_per_commitment_point
1968 (4, next_local_nonce, option)
1971 impl_writeable_msg!(Shutdown, {
1976 impl_writeable_msg!(UpdateFailHTLC, {
1982 impl_writeable_msg!(UpdateFailMalformedHTLC, {
1989 impl_writeable_msg!(UpdateFee, {
1994 impl_writeable_msg!(UpdateFulfillHTLC, {
2000 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2001 // serialization format in a way which assumes we know the total serialized length/message end
2003 impl_writeable!(OnionErrorPacket, {
2007 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2008 // serialization format in a way which assumes we know the total serialized length/message end
2010 impl Writeable for OnionPacket {
2011 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2012 self.version.write(w)?;
2013 match self.public_key {
2014 Ok(pubkey) => pubkey.write(w)?,
2015 Err(_) => [0u8;33].write(w)?,
2017 w.write_all(&self.hop_data)?;
2018 self.hmac.write(w)?;
2023 impl Readable for OnionPacket {
2024 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2026 version: Readable::read(r)?,
2028 let mut buf = [0u8;33];
2029 r.read_exact(&mut buf)?;
2030 PublicKey::from_slice(&buf)
2032 hop_data: Readable::read(r)?,
2033 hmac: Readable::read(r)?,
2038 impl_writeable_msg!(UpdateAddHTLC, {
2044 onion_routing_packet,
2046 (65537, skimmed_fee_msat, option)
2049 impl Readable for OnionMessage {
2050 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2051 let blinding_point: PublicKey = Readable::read(r)?;
2052 let len: u16 = Readable::read(r)?;
2053 let mut packet_reader = FixedLengthReader::new(r, len as u64);
2054 let onion_routing_packet: onion_message::Packet = <onion_message::Packet as LengthReadable>::read(&mut packet_reader)?;
2057 onion_routing_packet,
2062 impl Writeable for OnionMessage {
2063 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2064 self.blinding_point.write(w)?;
2065 let onion_packet_len = self.onion_routing_packet.serialized_length();
2066 (onion_packet_len as u16).write(w)?;
2067 self.onion_routing_packet.write(w)?;
2072 impl Writeable for FinalOnionHopData {
2073 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2074 self.payment_secret.0.write(w)?;
2075 HighZeroBytesDroppedBigSize(self.total_msat).write(w)
2079 impl Readable for FinalOnionHopData {
2080 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2081 let secret: [u8; 32] = Readable::read(r)?;
2082 let amt: HighZeroBytesDroppedBigSize<u64> = Readable::read(r)?;
2083 Ok(Self { payment_secret: PaymentSecret(secret), total_msat: amt.0 })
2087 impl Writeable for OutboundOnionPayload {
2088 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2090 Self::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } => {
2091 _encode_varint_length_prefixed_tlv!(w, {
2092 (2, HighZeroBytesDroppedBigSize(*amt_to_forward), required),
2093 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2094 (6, short_channel_id, required)
2098 ref payment_data, ref payment_metadata, ref keysend_preimage, amt_msat,
2099 outgoing_cltv_value, ref custom_tlvs,
2101 // We need to update [`ln::outbound_payment::RecipientOnionFields::with_custom_tlvs`]
2102 // to reject any reserved types in the experimental range if new ones are ever
2104 let keysend_tlv = keysend_preimage.map(|preimage| (5482373484, preimage.encode()));
2105 let mut custom_tlvs: Vec<&(u64, Vec<u8>)> = custom_tlvs.iter().chain(keysend_tlv.iter()).collect();
2106 custom_tlvs.sort_unstable_by_key(|(typ, _)| *typ);
2107 _encode_varint_length_prefixed_tlv!(w, {
2108 (2, HighZeroBytesDroppedBigSize(*amt_msat), required),
2109 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2110 (8, payment_data, option),
2111 (16, payment_metadata.as_ref().map(|m| WithoutLength(m)), option)
2112 }, custom_tlvs.iter());
2114 Self::BlindedForward { encrypted_tlvs, intro_node_blinding_point } => {
2115 _encode_varint_length_prefixed_tlv!(w, {
2116 (10, *encrypted_tlvs, required_vec),
2117 (12, intro_node_blinding_point, option)
2120 Self::BlindedReceive {
2121 amt_msat, total_msat, outgoing_cltv_value, encrypted_tlvs,
2122 intro_node_blinding_point,
2124 _encode_varint_length_prefixed_tlv!(w, {
2125 (2, HighZeroBytesDroppedBigSize(*amt_msat), required),
2126 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2127 (10, *encrypted_tlvs, required_vec),
2128 (12, intro_node_blinding_point, option),
2129 (18, HighZeroBytesDroppedBigSize(*total_msat), required)
2137 impl<NS: Deref> ReadableArgs<&NS> for InboundOnionPayload where NS::Target: NodeSigner {
2138 fn read<R: Read>(r: &mut R, node_signer: &NS) -> Result<Self, DecodeError> {
2139 let mut amt = HighZeroBytesDroppedBigSize(0u64);
2140 let mut cltv_value = HighZeroBytesDroppedBigSize(0u32);
2141 let mut short_id: Option<u64> = None;
2142 let mut payment_data: Option<FinalOnionHopData> = None;
2143 let mut payment_metadata: Option<WithoutLength<Vec<u8>>> = None;
2144 let mut keysend_preimage: Option<PaymentPreimage> = None;
2145 let mut custom_tlvs = Vec::new();
2147 let tlv_len = BigSize::read(r)?;
2148 let rd = FixedLengthReader::new(r, tlv_len.0);
2149 decode_tlv_stream_with_custom_tlv_decode!(rd, {
2151 (4, cltv_value, required),
2152 (6, short_id, option),
2153 (8, payment_data, option),
2154 (16, payment_metadata, option),
2155 // See https://github.com/lightning/blips/blob/master/blip-0003.md
2156 (5482373484, keysend_preimage, option)
2157 }, |msg_type: u64, msg_reader: &mut FixedLengthReader<_>| -> Result<bool, DecodeError> {
2158 if msg_type < 1 << 16 { return Ok(false) }
2159 let mut value = Vec::new();
2160 msg_reader.read_to_end(&mut value)?;
2161 custom_tlvs.push((msg_type, value));
2165 if amt.0 > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2166 if let Some(short_channel_id) = short_id {
2167 if payment_data.is_some() { return Err(DecodeError::InvalidValue) }
2168 if payment_metadata.is_some() { return Err(DecodeError::InvalidValue); }
2171 amt_to_forward: amt.0,
2172 outgoing_cltv_value: cltv_value.0,
2175 if let Some(data) = &payment_data {
2176 if data.total_msat > MAX_VALUE_MSAT {
2177 return Err(DecodeError::InvalidValue);
2182 payment_metadata: payment_metadata.map(|w| w.0),
2185 outgoing_cltv_value: cltv_value.0,
2192 impl Writeable for Ping {
2193 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2194 self.ponglen.write(w)?;
2195 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2200 impl Readable for Ping {
2201 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2203 ponglen: Readable::read(r)?,
2205 let byteslen = Readable::read(r)?;
2206 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2213 impl Writeable for Pong {
2214 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2215 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2220 impl Readable for Pong {
2221 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2224 let byteslen = Readable::read(r)?;
2225 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2232 impl Writeable for UnsignedChannelAnnouncement {
2233 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2234 self.features.write(w)?;
2235 self.chain_hash.write(w)?;
2236 self.short_channel_id.write(w)?;
2237 self.node_id_1.write(w)?;
2238 self.node_id_2.write(w)?;
2239 self.bitcoin_key_1.write(w)?;
2240 self.bitcoin_key_2.write(w)?;
2241 w.write_all(&self.excess_data[..])?;
2246 impl Readable for UnsignedChannelAnnouncement {
2247 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2249 features: Readable::read(r)?,
2250 chain_hash: Readable::read(r)?,
2251 short_channel_id: Readable::read(r)?,
2252 node_id_1: Readable::read(r)?,
2253 node_id_2: Readable::read(r)?,
2254 bitcoin_key_1: Readable::read(r)?,
2255 bitcoin_key_2: Readable::read(r)?,
2256 excess_data: read_to_end(r)?,
2261 impl_writeable!(ChannelAnnouncement, {
2264 bitcoin_signature_1,
2265 bitcoin_signature_2,
2269 impl Writeable for UnsignedChannelUpdate {
2270 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2271 // `message_flags` used to indicate presence of `htlc_maximum_msat`, but was deprecated in the spec.
2272 const MESSAGE_FLAGS: u8 = 1;
2273 self.chain_hash.write(w)?;
2274 self.short_channel_id.write(w)?;
2275 self.timestamp.write(w)?;
2276 let all_flags = self.flags as u16 | ((MESSAGE_FLAGS as u16) << 8);
2277 all_flags.write(w)?;
2278 self.cltv_expiry_delta.write(w)?;
2279 self.htlc_minimum_msat.write(w)?;
2280 self.fee_base_msat.write(w)?;
2281 self.fee_proportional_millionths.write(w)?;
2282 self.htlc_maximum_msat.write(w)?;
2283 w.write_all(&self.excess_data[..])?;
2288 impl Readable for UnsignedChannelUpdate {
2289 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2291 chain_hash: Readable::read(r)?,
2292 short_channel_id: Readable::read(r)?,
2293 timestamp: Readable::read(r)?,
2295 let flags: u16 = Readable::read(r)?;
2296 // Note: we ignore the `message_flags` for now, since it was deprecated by the spec.
2299 cltv_expiry_delta: Readable::read(r)?,
2300 htlc_minimum_msat: Readable::read(r)?,
2301 fee_base_msat: Readable::read(r)?,
2302 fee_proportional_millionths: Readable::read(r)?,
2303 htlc_maximum_msat: Readable::read(r)?,
2304 excess_data: read_to_end(r)?,
2309 impl_writeable!(ChannelUpdate, {
2314 impl Writeable for ErrorMessage {
2315 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2316 self.channel_id.write(w)?;
2317 (self.data.len() as u16).write(w)?;
2318 w.write_all(self.data.as_bytes())?;
2323 impl Readable for ErrorMessage {
2324 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2326 channel_id: Readable::read(r)?,
2328 let sz: usize = <u16 as Readable>::read(r)? as usize;
2329 let mut data = Vec::with_capacity(sz);
2331 r.read_exact(&mut data)?;
2332 match String::from_utf8(data) {
2334 Err(_) => return Err(DecodeError::InvalidValue),
2341 impl Writeable for WarningMessage {
2342 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2343 self.channel_id.write(w)?;
2344 (self.data.len() as u16).write(w)?;
2345 w.write_all(self.data.as_bytes())?;
2350 impl Readable for WarningMessage {
2351 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2353 channel_id: Readable::read(r)?,
2355 let sz: usize = <u16 as Readable>::read(r)? as usize;
2356 let mut data = Vec::with_capacity(sz);
2358 r.read_exact(&mut data)?;
2359 match String::from_utf8(data) {
2361 Err(_) => return Err(DecodeError::InvalidValue),
2368 impl Writeable for UnsignedNodeAnnouncement {
2369 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2370 self.features.write(w)?;
2371 self.timestamp.write(w)?;
2372 self.node_id.write(w)?;
2373 w.write_all(&self.rgb)?;
2374 self.alias.write(w)?;
2376 let mut addr_len = 0;
2377 for addr in self.addresses.iter() {
2378 addr_len += 1 + addr.len();
2380 (addr_len + self.excess_address_data.len() as u16).write(w)?;
2381 for addr in self.addresses.iter() {
2384 w.write_all(&self.excess_address_data[..])?;
2385 w.write_all(&self.excess_data[..])?;
2390 impl Readable for UnsignedNodeAnnouncement {
2391 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2392 let features: NodeFeatures = Readable::read(r)?;
2393 let timestamp: u32 = Readable::read(r)?;
2394 let node_id: NodeId = Readable::read(r)?;
2395 let mut rgb = [0; 3];
2396 r.read_exact(&mut rgb)?;
2397 let alias: NodeAlias = Readable::read(r)?;
2399 let addr_len: u16 = Readable::read(r)?;
2400 let mut addresses: Vec<SocketAddress> = Vec::new();
2401 let mut addr_readpos = 0;
2402 let mut excess = false;
2403 let mut excess_byte = 0;
2405 if addr_len <= addr_readpos { break; }
2406 match Readable::read(r) {
2408 if addr_len < addr_readpos + 1 + addr.len() {
2409 return Err(DecodeError::BadLengthDescriptor);
2411 addr_readpos += (1 + addr.len()) as u16;
2412 addresses.push(addr);
2414 Ok(Err(unknown_descriptor)) => {
2416 excess_byte = unknown_descriptor;
2419 Err(DecodeError::ShortRead) => return Err(DecodeError::BadLengthDescriptor),
2420 Err(e) => return Err(e),
2424 let mut excess_data = vec![];
2425 let excess_address_data = if addr_readpos < addr_len {
2426 let mut excess_address_data = vec![0; (addr_len - addr_readpos) as usize];
2427 r.read_exact(&mut excess_address_data[if excess { 1 } else { 0 }..])?;
2429 excess_address_data[0] = excess_byte;
2434 excess_data.push(excess_byte);
2438 excess_data.extend(read_to_end(r)?.iter());
2439 Ok(UnsignedNodeAnnouncement {
2446 excess_address_data,
2452 impl_writeable!(NodeAnnouncement, {
2457 impl Readable for QueryShortChannelIds {
2458 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2459 let chain_hash: BlockHash = Readable::read(r)?;
2461 let encoding_len: u16 = Readable::read(r)?;
2462 let encoding_type: u8 = Readable::read(r)?;
2464 // Must be encoding_type=0 uncompressed serialization. We do not
2465 // support encoding_type=1 zlib serialization.
2466 if encoding_type != EncodingType::Uncompressed as u8 {
2467 return Err(DecodeError::UnsupportedCompression);
2470 // We expect the encoding_len to always includes the 1-byte
2471 // encoding_type and that short_channel_ids are 8-bytes each
2472 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2473 return Err(DecodeError::InvalidValue);
2476 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2477 // less the 1-byte encoding_type
2478 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2479 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2480 for _ in 0..short_channel_id_count {
2481 short_channel_ids.push(Readable::read(r)?);
2484 Ok(QueryShortChannelIds {
2491 impl Writeable for QueryShortChannelIds {
2492 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2493 // Calculated from 1-byte encoding_type plus 8-bytes per short_channel_id
2494 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2496 self.chain_hash.write(w)?;
2497 encoding_len.write(w)?;
2499 // We only support type=0 uncompressed serialization
2500 (EncodingType::Uncompressed as u8).write(w)?;
2502 for scid in self.short_channel_ids.iter() {
2510 impl_writeable_msg!(ReplyShortChannelIdsEnd, {
2515 impl QueryChannelRange {
2516 /// Calculates the overflow safe ending block height for the query.
2518 /// Overflow returns `0xffffffff`, otherwise returns `first_blocknum + number_of_blocks`.
2519 pub fn end_blocknum(&self) -> u32 {
2520 match self.first_blocknum.checked_add(self.number_of_blocks) {
2521 Some(block) => block,
2522 None => u32::max_value(),
2527 impl_writeable_msg!(QueryChannelRange, {
2533 impl Readable for ReplyChannelRange {
2534 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2535 let chain_hash: BlockHash = Readable::read(r)?;
2536 let first_blocknum: u32 = Readable::read(r)?;
2537 let number_of_blocks: u32 = Readable::read(r)?;
2538 let sync_complete: bool = Readable::read(r)?;
2540 let encoding_len: u16 = Readable::read(r)?;
2541 let encoding_type: u8 = Readable::read(r)?;
2543 // Must be encoding_type=0 uncompressed serialization. We do not
2544 // support encoding_type=1 zlib serialization.
2545 if encoding_type != EncodingType::Uncompressed as u8 {
2546 return Err(DecodeError::UnsupportedCompression);
2549 // We expect the encoding_len to always includes the 1-byte
2550 // encoding_type and that short_channel_ids are 8-bytes each
2551 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2552 return Err(DecodeError::InvalidValue);
2555 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2556 // less the 1-byte encoding_type
2557 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2558 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2559 for _ in 0..short_channel_id_count {
2560 short_channel_ids.push(Readable::read(r)?);
2563 Ok(ReplyChannelRange {
2573 impl Writeable for ReplyChannelRange {
2574 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2575 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2576 self.chain_hash.write(w)?;
2577 self.first_blocknum.write(w)?;
2578 self.number_of_blocks.write(w)?;
2579 self.sync_complete.write(w)?;
2581 encoding_len.write(w)?;
2582 (EncodingType::Uncompressed as u8).write(w)?;
2583 for scid in self.short_channel_ids.iter() {
2591 impl_writeable_msg!(GossipTimestampFilter, {
2599 use std::convert::TryFrom;
2600 use bitcoin::blockdata::constants::ChainHash;
2601 use bitcoin::{Transaction, PackedLockTime, TxIn, Script, Sequence, Witness, TxOut};
2603 use crate::ln::{PaymentPreimage, PaymentHash, PaymentSecret};
2604 use crate::ln::ChannelId;
2605 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
2606 use crate::ln::msgs::{self, FinalOnionHopData, OnionErrorPacket};
2607 use crate::ln::msgs::SocketAddress;
2608 use crate::routing::gossip::{NodeAlias, NodeId};
2609 use crate::util::ser::{Writeable, Readable, ReadableArgs, Hostname, TransactionU16LenLimited};
2610 use crate::util::test_utils;
2612 use bitcoin::hashes::hex::FromHex;
2613 use bitcoin::util::address::Address;
2614 use bitcoin::network::constants::Network;
2615 use bitcoin::blockdata::script::Builder;
2616 use bitcoin::blockdata::opcodes;
2617 use bitcoin::hash_types::{Txid, BlockHash};
2619 use bitcoin::secp256k1::{PublicKey,SecretKey};
2620 use bitcoin::secp256k1::{Secp256k1, Message};
2622 use crate::io::{self, Cursor};
2623 use crate::prelude::*;
2624 use core::str::FromStr;
2625 use crate::chain::transaction::OutPoint;
2627 #[cfg(feature = "std")]
2628 use std::net::{Ipv4Addr, Ipv6Addr};
2629 use crate::ln::msgs::SocketAddressParseError;
2632 fn encoding_channel_reestablish() {
2634 let secp_ctx = Secp256k1::new();
2635 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2638 let cr = msgs::ChannelReestablish {
2639 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]),
2640 next_local_commitment_number: 3,
2641 next_remote_commitment_number: 4,
2642 your_last_per_commitment_secret: [9;32],
2643 my_current_per_commitment_point: public_key,
2644 next_funding_txid: None,
2647 let encoded_value = cr.encode();
2651 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
2652 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2653 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2654 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
2655 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
2661 fn encoding_channel_reestablish_with_next_funding_txid() {
2663 let secp_ctx = Secp256k1::new();
2664 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2667 let cr = msgs::ChannelReestablish {
2668 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]),
2669 next_local_commitment_number: 3,
2670 next_remote_commitment_number: 4,
2671 your_last_per_commitment_secret: [9;32],
2672 my_current_per_commitment_point: public_key,
2673 next_funding_txid: Some(Txid::from_hash(bitcoin::hashes::Hash::from_slice(&[
2674 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,
2678 let encoded_value = cr.encode();
2682 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
2683 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2684 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2685 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
2686 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
2687 0, // Type (next_funding_txid)
2689 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
2694 macro_rules! get_keys_from {
2695 ($slice: expr, $secp_ctx: expr) => {
2697 let privkey = SecretKey::from_slice(&hex::decode($slice).unwrap()[..]).unwrap();
2698 let pubkey = PublicKey::from_secret_key(&$secp_ctx, &privkey);
2704 macro_rules! get_sig_on {
2705 ($privkey: expr, $ctx: expr, $string: expr) => {
2707 let sighash = Message::from_slice(&$string.into_bytes()[..]).unwrap();
2708 $ctx.sign_ecdsa(&sighash, &$privkey)
2714 fn encoding_announcement_signatures() {
2715 let secp_ctx = Secp256k1::new();
2716 let (privkey, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2717 let sig_1 = get_sig_on!(privkey, secp_ctx, String::from("01010101010101010101010101010101"));
2718 let sig_2 = get_sig_on!(privkey, secp_ctx, String::from("02020202020202020202020202020202"));
2719 let announcement_signatures = msgs::AnnouncementSignatures {
2720 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]),
2721 short_channel_id: 2316138423780173,
2722 node_signature: sig_1,
2723 bitcoin_signature: sig_2,
2726 let encoded_value = announcement_signatures.encode();
2727 assert_eq!(encoded_value, hex::decode("040000000000000005000000000000000600000000000000070000000000000000083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073acf9953cef4700860f5967838eba2bae89288ad188ebf8b20bf995c3ea53a26df1876d0a3a0e13172ba286a673140190c02ba9da60a2e43a745188c8a83c7f3ef").unwrap());
2730 fn do_encoding_channel_announcement(unknown_features_bits: bool, excess_data: bool) {
2731 let secp_ctx = Secp256k1::new();
2732 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2733 let (privkey_2, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2734 let (privkey_3, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2735 let (privkey_4, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2736 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2737 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
2738 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
2739 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
2740 let mut features = ChannelFeatures::empty();
2741 if unknown_features_bits {
2742 features = ChannelFeatures::from_le_bytes(vec![0xFF, 0xFF]);
2744 let unsigned_channel_announcement = msgs::UnsignedChannelAnnouncement {
2746 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2747 short_channel_id: 2316138423780173,
2748 node_id_1: NodeId::from_pubkey(&pubkey_1),
2749 node_id_2: NodeId::from_pubkey(&pubkey_2),
2750 bitcoin_key_1: NodeId::from_pubkey(&pubkey_3),
2751 bitcoin_key_2: NodeId::from_pubkey(&pubkey_4),
2752 excess_data: if excess_data { vec![10, 0, 0, 20, 0, 0, 30, 0, 0, 40] } else { Vec::new() },
2754 let channel_announcement = msgs::ChannelAnnouncement {
2755 node_signature_1: sig_1,
2756 node_signature_2: sig_2,
2757 bitcoin_signature_1: sig_3,
2758 bitcoin_signature_2: sig_4,
2759 contents: unsigned_channel_announcement,
2761 let encoded_value = channel_announcement.encode();
2762 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a1735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap();
2763 if unknown_features_bits {
2764 target_value.append(&mut hex::decode("0002ffff").unwrap());
2766 target_value.append(&mut hex::decode("0000").unwrap());
2768 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2769 target_value.append(&mut hex::decode("00083a840000034d031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
2771 target_value.append(&mut hex::decode("0a00001400001e000028").unwrap());
2773 assert_eq!(encoded_value, target_value);
2777 fn encoding_channel_announcement() {
2778 do_encoding_channel_announcement(true, false);
2779 do_encoding_channel_announcement(false, true);
2780 do_encoding_channel_announcement(false, false);
2781 do_encoding_channel_announcement(true, true);
2784 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) {
2785 let secp_ctx = Secp256k1::new();
2786 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2787 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2788 let features = if unknown_features_bits {
2789 NodeFeatures::from_le_bytes(vec![0xFF, 0xFF])
2791 // Set to some features we may support
2792 NodeFeatures::from_le_bytes(vec![2 | 1 << 5])
2794 let mut addresses = Vec::new();
2796 addresses.push(SocketAddress::TcpIpV4 {
2797 addr: [255, 254, 253, 252],
2802 addresses.push(SocketAddress::TcpIpV6 {
2803 addr: [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240],
2808 addresses.push(msgs::SocketAddress::OnionV2(
2809 [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 38, 7]
2813 addresses.push(msgs::SocketAddress::OnionV3 {
2814 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],
2821 addresses.push(SocketAddress::Hostname {
2822 hostname: Hostname::try_from(String::from("host")).unwrap(),
2826 let mut addr_len = 0;
2827 for addr in &addresses {
2828 addr_len += addr.len() + 1;
2830 let unsigned_node_announcement = msgs::UnsignedNodeAnnouncement {
2832 timestamp: 20190119,
2833 node_id: NodeId::from_pubkey(&pubkey_1),
2835 alias: NodeAlias([16;32]),
2837 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() },
2838 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() },
2840 addr_len += unsigned_node_announcement.excess_address_data.len() as u16;
2841 let node_announcement = msgs::NodeAnnouncement {
2843 contents: unsigned_node_announcement,
2845 let encoded_value = node_announcement.encode();
2846 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
2847 if unknown_features_bits {
2848 target_value.append(&mut hex::decode("0002ffff").unwrap());
2850 target_value.append(&mut hex::decode("000122").unwrap());
2852 target_value.append(&mut hex::decode("013413a7031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f2020201010101010101010101010101010101010101010101010101010101010101010").unwrap());
2853 target_value.append(&mut vec![(addr_len >> 8) as u8, addr_len as u8]);
2855 target_value.append(&mut hex::decode("01fffefdfc2607").unwrap());
2858 target_value.append(&mut hex::decode("02fffefdfcfbfaf9f8f7f6f5f4f3f2f1f02607").unwrap());
2861 target_value.append(&mut hex::decode("03fffefdfcfbfaf9f8f7f62607").unwrap());
2864 target_value.append(&mut hex::decode("04fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0efeeedecebeae9e8e7e6e5e4e3e2e1e00020102607").unwrap());
2867 target_value.append(&mut hex::decode("0504686f73742607").unwrap());
2869 if excess_address_data {
2870 target_value.append(&mut hex::decode("216c280b5395a2546e7e4b2663e04f811622f15a4f92e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d269").unwrap());
2873 target_value.append(&mut hex::decode("3b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
2875 assert_eq!(encoded_value, target_value);
2879 fn encoding_node_announcement() {
2880 do_encoding_node_announcement(true, true, true, true, true, true, true, true);
2881 do_encoding_node_announcement(false, false, false, false, false, false, false, false);
2882 do_encoding_node_announcement(false, true, false, false, false, false, false, false);
2883 do_encoding_node_announcement(false, false, true, false, false, false, false, false);
2884 do_encoding_node_announcement(false, false, false, true, false, false, false, false);
2885 do_encoding_node_announcement(false, false, false, false, true, false, false, false);
2886 do_encoding_node_announcement(false, false, false, false, false, true, false, false);
2887 do_encoding_node_announcement(false, false, false, false, false, false, true, false);
2888 do_encoding_node_announcement(false, true, false, true, false, false, true, false);
2889 do_encoding_node_announcement(false, false, true, false, true, false, false, false);
2892 fn do_encoding_channel_update(direction: bool, disable: bool, excess_data: bool) {
2893 let secp_ctx = Secp256k1::new();
2894 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2895 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2896 let unsigned_channel_update = msgs::UnsignedChannelUpdate {
2897 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2898 short_channel_id: 2316138423780173,
2899 timestamp: 20190119,
2900 flags: if direction { 1 } else { 0 } | if disable { 1 << 1 } else { 0 },
2901 cltv_expiry_delta: 144,
2902 htlc_minimum_msat: 1000000,
2903 htlc_maximum_msat: 131355275467161,
2904 fee_base_msat: 10000,
2905 fee_proportional_millionths: 20,
2906 excess_data: if excess_data { vec![0, 0, 0, 0, 59, 154, 202, 0] } else { Vec::new() }
2908 let channel_update = msgs::ChannelUpdate {
2910 contents: unsigned_channel_update
2912 let encoded_value = channel_update.encode();
2913 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
2914 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2915 target_value.append(&mut hex::decode("00083a840000034d013413a7").unwrap());
2916 target_value.append(&mut hex::decode("01").unwrap());
2917 target_value.append(&mut hex::decode("00").unwrap());
2919 let flag = target_value.last_mut().unwrap();
2923 let flag = target_value.last_mut().unwrap();
2924 *flag = *flag | 1 << 1;
2926 target_value.append(&mut hex::decode("009000000000000f42400000271000000014").unwrap());
2927 target_value.append(&mut hex::decode("0000777788889999").unwrap());
2929 target_value.append(&mut hex::decode("000000003b9aca00").unwrap());
2931 assert_eq!(encoded_value, target_value);
2935 fn encoding_channel_update() {
2936 do_encoding_channel_update(false, false, false);
2937 do_encoding_channel_update(false, false, true);
2938 do_encoding_channel_update(true, false, false);
2939 do_encoding_channel_update(true, false, true);
2940 do_encoding_channel_update(false, true, false);
2941 do_encoding_channel_update(false, true, true);
2942 do_encoding_channel_update(true, true, false);
2943 do_encoding_channel_update(true, true, true);
2946 fn do_encoding_open_channel(random_bit: bool, shutdown: bool, incl_chan_type: bool) {
2947 let secp_ctx = Secp256k1::new();
2948 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2949 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2950 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2951 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2952 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
2953 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
2954 let open_channel = msgs::OpenChannel {
2955 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2956 temporary_channel_id: ChannelId::from_bytes([2; 32]),
2957 funding_satoshis: 1311768467284833366,
2958 push_msat: 2536655962884945560,
2959 dust_limit_satoshis: 3608586615801332854,
2960 max_htlc_value_in_flight_msat: 8517154655701053848,
2961 channel_reserve_satoshis: 8665828695742877976,
2962 htlc_minimum_msat: 2316138423780173,
2963 feerate_per_kw: 821716,
2964 to_self_delay: 49340,
2965 max_accepted_htlcs: 49340,
2966 funding_pubkey: pubkey_1,
2967 revocation_basepoint: pubkey_2,
2968 payment_point: pubkey_3,
2969 delayed_payment_basepoint: pubkey_4,
2970 htlc_basepoint: pubkey_5,
2971 first_per_commitment_point: pubkey_6,
2972 channel_flags: if random_bit { 1 << 5 } else { 0 },
2973 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
2974 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
2976 let encoded_value = open_channel.encode();
2977 let mut target_value = Vec::new();
2978 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2979 target_value.append(&mut hex::decode("02020202020202020202020202020202020202020202020202020202020202021234567890123456233403289122369832144668701144767633030896203198784335490624111800083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
2981 target_value.append(&mut hex::decode("20").unwrap());
2983 target_value.append(&mut hex::decode("00").unwrap());
2986 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
2989 target_value.append(&mut hex::decode("0100").unwrap());
2991 assert_eq!(encoded_value, target_value);
2995 fn encoding_open_channel() {
2996 do_encoding_open_channel(false, false, false);
2997 do_encoding_open_channel(false, false, true);
2998 do_encoding_open_channel(false, true, false);
2999 do_encoding_open_channel(false, true, true);
3000 do_encoding_open_channel(true, false, false);
3001 do_encoding_open_channel(true, false, true);
3002 do_encoding_open_channel(true, true, false);
3003 do_encoding_open_channel(true, true, true);
3006 fn do_encoding_open_channelv2(random_bit: bool, shutdown: bool, incl_chan_type: bool, require_confirmed_inputs: bool) {
3007 let secp_ctx = Secp256k1::new();
3008 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3009 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3010 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3011 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3012 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3013 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3014 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3015 let open_channelv2 = msgs::OpenChannelV2 {
3016 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
3017 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3018 funding_feerate_sat_per_1000_weight: 821716,
3019 commitment_feerate_sat_per_1000_weight: 821716,
3020 funding_satoshis: 1311768467284833366,
3021 dust_limit_satoshis: 3608586615801332854,
3022 max_htlc_value_in_flight_msat: 8517154655701053848,
3023 htlc_minimum_msat: 2316138423780173,
3024 to_self_delay: 49340,
3025 max_accepted_htlcs: 49340,
3026 locktime: 305419896,
3027 funding_pubkey: pubkey_1,
3028 revocation_basepoint: pubkey_2,
3029 payment_basepoint: pubkey_3,
3030 delayed_payment_basepoint: pubkey_4,
3031 htlc_basepoint: pubkey_5,
3032 first_per_commitment_point: pubkey_6,
3033 second_per_commitment_point: pubkey_7,
3034 channel_flags: if random_bit { 1 << 5 } else { 0 },
3035 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3036 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3037 require_confirmed_inputs: if require_confirmed_inputs { Some(()) } else { None },
3039 let encoded_value = open_channelv2.encode();
3040 let mut target_value = Vec::new();
3041 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
3042 target_value.append(&mut hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap());
3043 target_value.append(&mut hex::decode("000c89d4").unwrap());
3044 target_value.append(&mut hex::decode("000c89d4").unwrap());
3045 target_value.append(&mut hex::decode("1234567890123456").unwrap());
3046 target_value.append(&mut hex::decode("3214466870114476").unwrap());
3047 target_value.append(&mut hex::decode("7633030896203198").unwrap());
3048 target_value.append(&mut hex::decode("00083a840000034d").unwrap());
3049 target_value.append(&mut hex::decode("c0bc").unwrap());
3050 target_value.append(&mut hex::decode("c0bc").unwrap());
3051 target_value.append(&mut hex::decode("12345678").unwrap());
3052 target_value.append(&mut hex::decode("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap());
3053 target_value.append(&mut hex::decode("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap());
3054 target_value.append(&mut hex::decode("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap());
3055 target_value.append(&mut hex::decode("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
3056 target_value.append(&mut hex::decode("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap());
3057 target_value.append(&mut hex::decode("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3058 target_value.append(&mut hex::decode("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap());
3061 target_value.append(&mut hex::decode("20").unwrap());
3063 target_value.append(&mut hex::decode("00").unwrap());
3066 target_value.append(&mut hex::decode("001b").unwrap()); // Type 0 + Length 27
3067 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3070 target_value.append(&mut hex::decode("0100").unwrap());
3072 if require_confirmed_inputs {
3073 target_value.append(&mut hex::decode("0200").unwrap());
3075 assert_eq!(encoded_value, target_value);
3079 fn encoding_open_channelv2() {
3080 do_encoding_open_channelv2(false, false, false, false);
3081 do_encoding_open_channelv2(false, false, false, true);
3082 do_encoding_open_channelv2(false, false, true, false);
3083 do_encoding_open_channelv2(false, false, true, true);
3084 do_encoding_open_channelv2(false, true, false, false);
3085 do_encoding_open_channelv2(false, true, false, true);
3086 do_encoding_open_channelv2(false, true, true, false);
3087 do_encoding_open_channelv2(false, true, true, true);
3088 do_encoding_open_channelv2(true, false, false, false);
3089 do_encoding_open_channelv2(true, false, false, true);
3090 do_encoding_open_channelv2(true, false, true, false);
3091 do_encoding_open_channelv2(true, false, true, true);
3092 do_encoding_open_channelv2(true, true, false, false);
3093 do_encoding_open_channelv2(true, true, false, true);
3094 do_encoding_open_channelv2(true, true, true, false);
3095 do_encoding_open_channelv2(true, true, true, true);
3098 fn do_encoding_accept_channel(shutdown: bool) {
3099 let secp_ctx = Secp256k1::new();
3100 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3101 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3102 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3103 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3104 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3105 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3106 let accept_channel = msgs::AcceptChannel {
3107 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3108 dust_limit_satoshis: 1311768467284833366,
3109 max_htlc_value_in_flight_msat: 2536655962884945560,
3110 channel_reserve_satoshis: 3608586615801332854,
3111 htlc_minimum_msat: 2316138423780173,
3112 minimum_depth: 821716,
3113 to_self_delay: 49340,
3114 max_accepted_htlcs: 49340,
3115 funding_pubkey: pubkey_1,
3116 revocation_basepoint: pubkey_2,
3117 payment_point: pubkey_3,
3118 delayed_payment_basepoint: pubkey_4,
3119 htlc_basepoint: pubkey_5,
3120 first_per_commitment_point: pubkey_6,
3121 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3124 next_local_nonce: None,
3126 let encoded_value = accept_channel.encode();
3127 let mut target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020212345678901234562334032891223698321446687011447600083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap();
3129 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3131 assert_eq!(encoded_value, target_value);
3135 fn encoding_accept_channel() {
3136 do_encoding_accept_channel(false);
3137 do_encoding_accept_channel(true);
3140 fn do_encoding_accept_channelv2(shutdown: bool) {
3141 let secp_ctx = Secp256k1::new();
3142 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3143 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3144 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3145 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3146 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3147 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3148 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3149 let accept_channelv2 = msgs::AcceptChannelV2 {
3150 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3151 funding_satoshis: 1311768467284833366,
3152 dust_limit_satoshis: 1311768467284833366,
3153 max_htlc_value_in_flight_msat: 2536655962884945560,
3154 htlc_minimum_msat: 2316138423780173,
3155 minimum_depth: 821716,
3156 to_self_delay: 49340,
3157 max_accepted_htlcs: 49340,
3158 funding_pubkey: pubkey_1,
3159 revocation_basepoint: pubkey_2,
3160 payment_basepoint: pubkey_3,
3161 delayed_payment_basepoint: pubkey_4,
3162 htlc_basepoint: pubkey_5,
3163 first_per_commitment_point: pubkey_6,
3164 second_per_commitment_point: pubkey_7,
3165 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3167 require_confirmed_inputs: None,
3169 let encoded_value = accept_channelv2.encode();
3170 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // temporary_channel_id
3171 target_value.append(&mut hex::decode("1234567890123456").unwrap()); // funding_satoshis
3172 target_value.append(&mut hex::decode("1234567890123456").unwrap()); // dust_limit_satoshis
3173 target_value.append(&mut hex::decode("2334032891223698").unwrap()); // max_htlc_value_in_flight_msat
3174 target_value.append(&mut hex::decode("00083a840000034d").unwrap()); // htlc_minimum_msat
3175 target_value.append(&mut hex::decode("000c89d4").unwrap()); // minimum_depth
3176 target_value.append(&mut hex::decode("c0bc").unwrap()); // to_self_delay
3177 target_value.append(&mut hex::decode("c0bc").unwrap()); // max_accepted_htlcs
3178 target_value.append(&mut hex::decode("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap()); // funding_pubkey
3179 target_value.append(&mut hex::decode("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap()); // revocation_basepoint
3180 target_value.append(&mut hex::decode("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap()); // payment_basepoint
3181 target_value.append(&mut hex::decode("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap()); // delayed_payment_basepoint
3182 target_value.append(&mut hex::decode("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap()); // htlc_basepoint
3183 target_value.append(&mut hex::decode("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap()); // first_per_commitment_point
3184 target_value.append(&mut hex::decode("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap()); // second_per_commitment_point
3186 target_value.append(&mut hex::decode("001b").unwrap()); // Type 0 + Length 27
3187 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3189 assert_eq!(encoded_value, target_value);
3193 fn encoding_accept_channelv2() {
3194 do_encoding_accept_channelv2(false);
3195 do_encoding_accept_channelv2(true);
3199 fn encoding_funding_created() {
3200 let secp_ctx = Secp256k1::new();
3201 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3202 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3203 let funding_created = msgs::FundingCreated {
3204 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3205 funding_txid: Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3206 funding_output_index: 255,
3209 partial_signature_with_nonce: None,
3211 next_local_nonce: None,
3213 let encoded_value = funding_created.encode();
3214 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202026e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c200ffd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3215 assert_eq!(encoded_value, target_value);
3219 fn encoding_funding_signed() {
3220 let secp_ctx = Secp256k1::new();
3221 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3222 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3223 let funding_signed = msgs::FundingSigned {
3224 channel_id: ChannelId::from_bytes([2; 32]),
3227 partial_signature_with_nonce: None,
3229 let encoded_value = funding_signed.encode();
3230 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3231 assert_eq!(encoded_value, target_value);
3235 fn encoding_channel_ready() {
3236 let secp_ctx = Secp256k1::new();
3237 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3238 let channel_ready = msgs::ChannelReady {
3239 channel_id: ChannelId::from_bytes([2; 32]),
3240 next_per_commitment_point: pubkey_1,
3241 short_channel_id_alias: None,
3243 let encoded_value = channel_ready.encode();
3244 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3245 assert_eq!(encoded_value, target_value);
3249 fn encoding_tx_add_input() {
3250 let tx_add_input = msgs::TxAddInput {
3251 channel_id: ChannelId::from_bytes([2; 32]),
3252 serial_id: 4886718345,
3253 prevtx: TransactionU16LenLimited::new(Transaction {
3255 lock_time: PackedLockTime(0),
3257 previous_output: OutPoint { txid: Txid::from_hex("305bab643ee297b8b6b76b320792c8223d55082122cb606bf89382146ced9c77").unwrap(), index: 2 }.into_bitcoin_outpoint(),
3258 script_sig: Script::new(),
3259 sequence: Sequence(0xfffffffd),
3260 witness: Witness::from_vec(vec![
3261 hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3262 hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3267 script_pubkey: Address::from_str("bc1qzlffunw52jav8vwdu5x3jfk6sr8u22rmq3xzw2").unwrap().script_pubkey(),
3271 script_pubkey: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().script_pubkey(),
3275 prevtx_out: 305419896,
3276 sequence: 305419896,
3278 let encoded_value = tx_add_input.encode();
3279 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000000012345678900de02000000000101779ced6c148293f86b60cb222108553d22c89207326bb7b6b897e23e64ab5b300200000000fdffffff0236dbc1000000000016001417d29e4dd454bac3b1cde50d1926da80cfc5287b9cbd03000000000016001436ec78d514df462da95e6a00c24daa8915362d420247304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701210301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944000000001234567812345678").unwrap();
3280 assert_eq!(encoded_value, target_value);
3284 fn encoding_tx_add_output() {
3285 let tx_add_output = msgs::TxAddOutput {
3286 channel_id: ChannelId::from_bytes([2; 32]),
3287 serial_id: 4886718345,
3289 script: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().script_pubkey(),
3291 let encoded_value = tx_add_output.encode();
3292 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000000012345678900000001234567890016001436ec78d514df462da95e6a00c24daa8915362d42").unwrap();
3293 assert_eq!(encoded_value, target_value);
3297 fn encoding_tx_remove_input() {
3298 let tx_remove_input = msgs::TxRemoveInput {
3299 channel_id: ChannelId::from_bytes([2; 32]),
3300 serial_id: 4886718345,
3302 let encoded_value = tx_remove_input.encode();
3303 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3304 assert_eq!(encoded_value, target_value);
3308 fn encoding_tx_remove_output() {
3309 let tx_remove_output = msgs::TxRemoveOutput {
3310 channel_id: ChannelId::from_bytes([2; 32]),
3311 serial_id: 4886718345,
3313 let encoded_value = tx_remove_output.encode();
3314 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3315 assert_eq!(encoded_value, target_value);
3319 fn encoding_tx_complete() {
3320 let tx_complete = msgs::TxComplete {
3321 channel_id: ChannelId::from_bytes([2; 32]),
3323 let encoded_value = tx_complete.encode();
3324 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3325 assert_eq!(encoded_value, target_value);
3329 fn encoding_tx_signatures() {
3330 let tx_signatures = msgs::TxSignatures {
3331 channel_id: ChannelId::from_bytes([2; 32]),
3332 tx_hash: Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3334 Witness::from_vec(vec![
3335 hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3336 hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3337 Witness::from_vec(vec![
3338 hex::decode("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap(),
3339 hex::decode("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap()]),
3342 let encoded_value = tx_signatures.encode();
3343 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3344 target_value.append(&mut hex::decode("6e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c2").unwrap()); // tx_hash (sha256) (big endian byte order)
3345 target_value.append(&mut hex::decode("0002").unwrap()); // num_witnesses (u16)
3347 target_value.append(&mut hex::decode("006b").unwrap()); // len of witness_data
3348 target_value.append(&mut hex::decode("02").unwrap()); // num_witness_elements (VarInt)
3349 target_value.append(&mut hex::decode("47").unwrap()); // len of witness element data (VarInt)
3350 target_value.append(&mut hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap());
3351 target_value.append(&mut hex::decode("21").unwrap()); // len of witness element data (VarInt)
3352 target_value.append(&mut hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap());
3354 target_value.append(&mut hex::decode("006c").unwrap()); // len of witness_data
3355 target_value.append(&mut hex::decode("02").unwrap()); // num_witness_elements (VarInt)
3356 target_value.append(&mut hex::decode("48").unwrap()); // len of witness element data (VarInt)
3357 target_value.append(&mut hex::decode("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap());
3358 target_value.append(&mut hex::decode("21").unwrap()); // len of witness element data (VarInt)
3359 target_value.append(&mut hex::decode("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap());
3360 assert_eq!(encoded_value, target_value);
3363 fn do_encoding_tx_init_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3364 let tx_init_rbf = msgs::TxInitRbf {
3365 channel_id: ChannelId::from_bytes([2; 32]),
3366 locktime: 305419896,
3367 feerate_sat_per_1000_weight: 20190119,
3368 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3370 let encoded_value = tx_init_rbf.encode();
3371 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3372 target_value.append(&mut hex::decode("12345678").unwrap()); // locktime
3373 target_value.append(&mut hex::decode("013413a7").unwrap()); // feerate_sat_per_1000_weight
3374 if let Some((_, target)) = funding_value_with_hex_target {
3375 target_value.push(0x00); // Type
3376 target_value.push(target.len() as u8 / 2); // Length
3377 target_value.append(&mut hex::decode(target).unwrap()); // Value (i64)
3379 assert_eq!(encoded_value, target_value);
3383 fn encoding_tx_init_rbf() {
3384 do_encoding_tx_init_rbf(Some((1311768467284833366, "1234567890123456")));
3385 do_encoding_tx_init_rbf(Some((13117684672, "000000030DDFFBC0")));
3386 do_encoding_tx_init_rbf(None);
3389 fn do_encoding_tx_ack_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3390 let tx_ack_rbf = msgs::TxAckRbf {
3391 channel_id: ChannelId::from_bytes([2; 32]),
3392 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3394 let encoded_value = tx_ack_rbf.encode();
3395 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3396 if let Some((_, target)) = funding_value_with_hex_target {
3397 target_value.push(0x00); // Type
3398 target_value.push(target.len() as u8 / 2); // Length
3399 target_value.append(&mut hex::decode(target).unwrap()); // Value (i64)
3401 assert_eq!(encoded_value, target_value);
3405 fn encoding_tx_ack_rbf() {
3406 do_encoding_tx_ack_rbf(Some((1311768467284833366, "1234567890123456")));
3407 do_encoding_tx_ack_rbf(Some((13117684672, "000000030DDFFBC0")));
3408 do_encoding_tx_ack_rbf(None);
3412 fn encoding_tx_abort() {
3413 let tx_abort = msgs::TxAbort {
3414 channel_id: ChannelId::from_bytes([2; 32]),
3415 data: hex::decode("54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap(),
3417 let encoded_value = tx_abort.encode();
3418 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202002C54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap();
3419 assert_eq!(encoded_value, target_value);
3422 fn do_encoding_shutdown(script_type: u8) {
3423 let secp_ctx = Secp256k1::new();
3424 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3425 let script = Builder::new().push_opcode(opcodes::OP_TRUE).into_script();
3426 let shutdown = msgs::Shutdown {
3427 channel_id: ChannelId::from_bytes([2; 32]),
3429 if script_type == 1 { Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey() }
3430 else if script_type == 2 { Address::p2sh(&script, Network::Testnet).unwrap().script_pubkey() }
3431 else if script_type == 3 { Address::p2wpkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).unwrap().script_pubkey() }
3432 else { Address::p2wsh(&script, Network::Testnet).script_pubkey() },
3434 let encoded_value = shutdown.encode();
3435 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3436 if script_type == 1 {
3437 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3438 } else if script_type == 2 {
3439 target_value.append(&mut hex::decode("0017a914da1745e9b549bd0bfa1a569971c77eba30cd5a4b87").unwrap());
3440 } else if script_type == 3 {
3441 target_value.append(&mut hex::decode("0016001479b000887626b294a914501a4cd226b58b235983").unwrap());
3442 } else if script_type == 4 {
3443 target_value.append(&mut hex::decode("002200204ae81572f06e1b88fd5ced7a1a000945432e83e1551e6f721ee9c00b8cc33260").unwrap());
3445 assert_eq!(encoded_value, target_value);
3449 fn encoding_shutdown() {
3450 do_encoding_shutdown(1);
3451 do_encoding_shutdown(2);
3452 do_encoding_shutdown(3);
3453 do_encoding_shutdown(4);
3457 fn encoding_closing_signed() {
3458 let secp_ctx = Secp256k1::new();
3459 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3460 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3461 let closing_signed = msgs::ClosingSigned {
3462 channel_id: ChannelId::from_bytes([2; 32]),
3463 fee_satoshis: 2316138423780173,
3467 let encoded_value = closing_signed.encode();
3468 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3469 assert_eq!(encoded_value, target_value);
3470 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value)).unwrap(), closing_signed);
3472 let closing_signed_with_range = msgs::ClosingSigned {
3473 channel_id: ChannelId::from_bytes([2; 32]),
3474 fee_satoshis: 2316138423780173,
3476 fee_range: Some(msgs::ClosingSignedFeeRange {
3477 min_fee_satoshis: 0xdeadbeef,
3478 max_fee_satoshis: 0x1badcafe01234567,
3481 let encoded_value_with_range = closing_signed_with_range.encode();
3482 let target_value_with_range = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a011000000000deadbeef1badcafe01234567").unwrap();
3483 assert_eq!(encoded_value_with_range, target_value_with_range);
3484 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value_with_range)).unwrap(),
3485 closing_signed_with_range);
3489 fn encoding_update_add_htlc() {
3490 let secp_ctx = Secp256k1::new();
3491 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3492 let onion_routing_packet = msgs::OnionPacket {
3494 public_key: Ok(pubkey_1),
3495 hop_data: [1; 20*65],
3498 let update_add_htlc = msgs::UpdateAddHTLC {
3499 channel_id: ChannelId::from_bytes([2; 32]),
3500 htlc_id: 2316138423780173,
3501 amount_msat: 3608586615801332854,
3502 payment_hash: PaymentHash([1; 32]),
3503 cltv_expiry: 821716,
3504 onion_routing_packet,
3505 skimmed_fee_msat: None,
3507 let encoded_value = update_add_htlc.encode();
3508 let target_value = hex::decode("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").unwrap();
3509 assert_eq!(encoded_value, target_value);
3513 fn encoding_update_fulfill_htlc() {
3514 let update_fulfill_htlc = msgs::UpdateFulfillHTLC {
3515 channel_id: ChannelId::from_bytes([2; 32]),
3516 htlc_id: 2316138423780173,
3517 payment_preimage: PaymentPreimage([1; 32]),
3519 let encoded_value = update_fulfill_htlc.encode();
3520 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d0101010101010101010101010101010101010101010101010101010101010101").unwrap();
3521 assert_eq!(encoded_value, target_value);
3525 fn encoding_update_fail_htlc() {
3526 let reason = OnionErrorPacket {
3527 data: [1; 32].to_vec(),
3529 let update_fail_htlc = msgs::UpdateFailHTLC {
3530 channel_id: ChannelId::from_bytes([2; 32]),
3531 htlc_id: 2316138423780173,
3534 let encoded_value = update_fail_htlc.encode();
3535 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d00200101010101010101010101010101010101010101010101010101010101010101").unwrap();
3536 assert_eq!(encoded_value, target_value);
3540 fn encoding_update_fail_malformed_htlc() {
3541 let update_fail_malformed_htlc = msgs::UpdateFailMalformedHTLC {
3542 channel_id: ChannelId::from_bytes([2; 32]),
3543 htlc_id: 2316138423780173,
3544 sha256_of_onion: [1; 32],
3547 let encoded_value = update_fail_malformed_htlc.encode();
3548 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d010101010101010101010101010101010101010101010101010101010101010100ff").unwrap();
3549 assert_eq!(encoded_value, target_value);
3552 fn do_encoding_commitment_signed(htlcs: bool) {
3553 let secp_ctx = Secp256k1::new();
3554 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3555 let (privkey_2, _) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3556 let (privkey_3, _) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3557 let (privkey_4, _) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3558 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3559 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
3560 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
3561 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
3562 let commitment_signed = msgs::CommitmentSigned {
3563 channel_id: ChannelId::from_bytes([2; 32]),
3565 htlc_signatures: if htlcs { vec![sig_2, sig_3, sig_4] } else { Vec::new() },
3567 partial_signature_with_nonce: None,
3569 let encoded_value = commitment_signed.encode();
3570 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3572 target_value.append(&mut hex::decode("00031735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
3574 target_value.append(&mut hex::decode("0000").unwrap());
3576 assert_eq!(encoded_value, target_value);
3580 fn encoding_commitment_signed() {
3581 do_encoding_commitment_signed(true);
3582 do_encoding_commitment_signed(false);
3586 fn encoding_revoke_and_ack() {
3587 let secp_ctx = Secp256k1::new();
3588 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3589 let raa = msgs::RevokeAndACK {
3590 channel_id: ChannelId::from_bytes([2; 32]),
3591 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],
3592 next_per_commitment_point: pubkey_1,
3594 next_local_nonce: None,
3596 let encoded_value = raa.encode();
3597 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020101010101010101010101010101010101010101010101010101010101010101031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3598 assert_eq!(encoded_value, target_value);
3602 fn encoding_update_fee() {
3603 let update_fee = msgs::UpdateFee {
3604 channel_id: ChannelId::from_bytes([2; 32]),
3605 feerate_per_kw: 20190119,
3607 let encoded_value = update_fee.encode();
3608 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202013413a7").unwrap();
3609 assert_eq!(encoded_value, target_value);
3613 fn encoding_init() {
3614 let mainnet_hash = ChainHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap();
3615 assert_eq!(msgs::Init {
3616 features: InitFeatures::from_le_bytes(vec![0xFF, 0xFF, 0xFF]),
3617 networks: Some(vec![mainnet_hash]),
3618 remote_network_address: None,
3619 }.encode(), hex::decode("00023fff0003ffffff01206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3620 assert_eq!(msgs::Init {
3621 features: InitFeatures::from_le_bytes(vec![0xFF]),
3623 remote_network_address: None,
3624 }.encode(), hex::decode("0001ff0001ff").unwrap());
3625 assert_eq!(msgs::Init {
3626 features: InitFeatures::from_le_bytes(vec![]),
3627 networks: Some(vec![mainnet_hash]),
3628 remote_network_address: None,
3629 }.encode(), hex::decode("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3630 assert_eq!(msgs::Init {
3631 features: InitFeatures::from_le_bytes(vec![]),
3632 networks: Some(vec![ChainHash::from(&[1; 32][..]), ChainHash::from(&[2; 32][..])]),
3633 remote_network_address: None,
3634 }.encode(), hex::decode("00000000014001010101010101010101010101010101010101010101010101010101010101010202020202020202020202020202020202020202020202020202020202020202").unwrap());
3635 let init_msg = msgs::Init { features: InitFeatures::from_le_bytes(vec![]),
3636 networks: Some(vec![mainnet_hash]),
3637 remote_network_address: Some(SocketAddress::TcpIpV4 {
3638 addr: [127, 0, 0, 1],
3642 let encoded_value = init_msg.encode();
3643 let target_value = hex::decode("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d61900000000000307017f00000103e8").unwrap();
3644 assert_eq!(encoded_value, target_value);
3645 assert_eq!(msgs::Init::read(&mut Cursor::new(&target_value)).unwrap(), init_msg);
3649 fn encoding_error() {
3650 let error = msgs::ErrorMessage {
3651 channel_id: ChannelId::from_bytes([2; 32]),
3652 data: String::from("rust-lightning"),
3654 let encoded_value = error.encode();
3655 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3656 assert_eq!(encoded_value, target_value);
3660 fn encoding_warning() {
3661 let error = msgs::WarningMessage {
3662 channel_id: ChannelId::from_bytes([2; 32]),
3663 data: String::from("rust-lightning"),
3665 let encoded_value = error.encode();
3666 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3667 assert_eq!(encoded_value, target_value);
3671 fn encoding_ping() {
3672 let ping = msgs::Ping {
3676 let encoded_value = ping.encode();
3677 let target_value = hex::decode("0040004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3678 assert_eq!(encoded_value, target_value);
3682 fn encoding_pong() {
3683 let pong = msgs::Pong {
3686 let encoded_value = pong.encode();
3687 let target_value = hex::decode("004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3688 assert_eq!(encoded_value, target_value);
3692 fn encoding_nonfinal_onion_hop_data() {
3693 let outbound_msg = msgs::OutboundOnionPayload::Forward {
3694 short_channel_id: 0xdeadbeef1bad1dea,
3695 amt_to_forward: 0x0badf00d01020304,
3696 outgoing_cltv_value: 0xffffffff,
3698 let encoded_value = outbound_msg.encode();
3699 let target_value = hex::decode("1a02080badf00d010203040404ffffffff0608deadbeef1bad1dea").unwrap();
3700 assert_eq!(encoded_value, target_value);
3702 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3703 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
3704 if let msgs::InboundOnionPayload::Forward {
3705 short_channel_id, amt_to_forward, outgoing_cltv_value
3707 assert_eq!(short_channel_id, 0xdeadbeef1bad1dea);
3708 assert_eq!(amt_to_forward, 0x0badf00d01020304);
3709 assert_eq!(outgoing_cltv_value, 0xffffffff);
3710 } else { panic!(); }
3714 fn encoding_final_onion_hop_data() {
3715 let outbound_msg = msgs::OutboundOnionPayload::Receive {
3717 payment_metadata: None,
3718 keysend_preimage: None,
3719 amt_msat: 0x0badf00d01020304,
3720 outgoing_cltv_value: 0xffffffff,
3721 custom_tlvs: vec![],
3723 let encoded_value = outbound_msg.encode();
3724 let target_value = hex::decode("1002080badf00d010203040404ffffffff").unwrap();
3725 assert_eq!(encoded_value, target_value);
3727 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3728 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
3729 if let msgs::InboundOnionPayload::Receive {
3730 payment_data: None, amt_msat, outgoing_cltv_value, ..
3732 assert_eq!(amt_msat, 0x0badf00d01020304);
3733 assert_eq!(outgoing_cltv_value, 0xffffffff);
3734 } else { panic!(); }
3738 fn encoding_final_onion_hop_data_with_secret() {
3739 let expected_payment_secret = PaymentSecret([0x42u8; 32]);
3740 let outbound_msg = msgs::OutboundOnionPayload::Receive {
3741 payment_data: Some(FinalOnionHopData {
3742 payment_secret: expected_payment_secret,
3743 total_msat: 0x1badca1f
3745 payment_metadata: None,
3746 keysend_preimage: None,
3747 amt_msat: 0x0badf00d01020304,
3748 outgoing_cltv_value: 0xffffffff,
3749 custom_tlvs: vec![],
3751 let encoded_value = outbound_msg.encode();
3752 let target_value = hex::decode("3602080badf00d010203040404ffffffff082442424242424242424242424242424242424242424242424242424242424242421badca1f").unwrap();
3753 assert_eq!(encoded_value, target_value);
3755 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3756 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
3757 if let msgs::InboundOnionPayload::Receive {
3758 payment_data: Some(FinalOnionHopData {
3760 total_msat: 0x1badca1f
3762 amt_msat, outgoing_cltv_value,
3763 payment_metadata: None,
3764 keysend_preimage: None,
3767 assert_eq!(payment_secret, expected_payment_secret);
3768 assert_eq!(amt_msat, 0x0badf00d01020304);
3769 assert_eq!(outgoing_cltv_value, 0xffffffff);
3770 assert_eq!(custom_tlvs, vec![]);
3771 } else { panic!(); }
3775 fn encoding_final_onion_hop_data_with_bad_custom_tlvs() {
3776 // If custom TLVs have type number within the range reserved for protocol, treat them as if
3778 let bad_type_range_tlvs = vec![
3779 ((1 << 16) - 4, vec![42]),
3780 ((1 << 16) - 2, vec![42; 32]),
3782 let mut msg = msgs::OutboundOnionPayload::Receive {
3784 payment_metadata: None,
3785 keysend_preimage: None,
3786 custom_tlvs: bad_type_range_tlvs,
3787 amt_msat: 0x0badf00d01020304,
3788 outgoing_cltv_value: 0xffffffff,
3790 let encoded_value = msg.encode();
3791 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3792 assert!(msgs::InboundOnionPayload::read(&mut Cursor::new(&encoded_value[..]), &&node_signer).is_err());
3793 let good_type_range_tlvs = vec![
3794 ((1 << 16) - 3, vec![42]),
3795 ((1 << 16) - 1, vec![42; 32]),
3797 if let msgs::OutboundOnionPayload::Receive { ref mut custom_tlvs, .. } = msg {
3798 *custom_tlvs = good_type_range_tlvs.clone();
3800 let encoded_value = msg.encode();
3801 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&encoded_value[..]), &&node_signer).unwrap();
3803 msgs::InboundOnionPayload::Receive { custom_tlvs, .. } => assert!(custom_tlvs.is_empty()),
3809 fn encoding_final_onion_hop_data_with_custom_tlvs() {
3810 let expected_custom_tlvs = vec![
3811 (5482373483, vec![0x12, 0x34]),
3812 (5482373487, vec![0x42u8; 8]),
3814 let msg = msgs::OutboundOnionPayload::Receive {
3816 payment_metadata: None,
3817 keysend_preimage: None,
3818 custom_tlvs: expected_custom_tlvs.clone(),
3819 amt_msat: 0x0badf00d01020304,
3820 outgoing_cltv_value: 0xffffffff,
3822 let encoded_value = msg.encode();
3823 let target_value = hex::decode("2e02080badf00d010203040404ffffffffff0000000146c6616b021234ff0000000146c6616f084242424242424242").unwrap();
3824 assert_eq!(encoded_value, target_value);
3825 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3826 let inbound_msg: msgs::InboundOnionPayload = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
3827 if let msgs::InboundOnionPayload::Receive {
3829 payment_metadata: None,
3830 keysend_preimage: None,
3833 outgoing_cltv_value,
3836 assert_eq!(custom_tlvs, expected_custom_tlvs);
3837 assert_eq!(amt_msat, 0x0badf00d01020304);
3838 assert_eq!(outgoing_cltv_value, 0xffffffff);
3839 } else { panic!(); }
3843 fn query_channel_range_end_blocknum() {
3844 let tests: Vec<(u32, u32, u32)> = vec![
3845 (10000, 1500, 11500),
3846 (0, 0xffffffff, 0xffffffff),
3847 (1, 0xffffffff, 0xffffffff),
3850 for (first_blocknum, number_of_blocks, expected) in tests.into_iter() {
3851 let sut = msgs::QueryChannelRange {
3852 chain_hash: BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap(),
3856 assert_eq!(sut.end_blocknum(), expected);
3861 fn encoding_query_channel_range() {
3862 let mut query_channel_range = msgs::QueryChannelRange {
3863 chain_hash: BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap(),
3864 first_blocknum: 100000,
3865 number_of_blocks: 1500,
3867 let encoded_value = query_channel_range.encode();
3868 let target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206000186a0000005dc").unwrap();
3869 assert_eq!(encoded_value, target_value);
3871 query_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3872 assert_eq!(query_channel_range.first_blocknum, 100000);
3873 assert_eq!(query_channel_range.number_of_blocks, 1500);
3877 fn encoding_reply_channel_range() {
3878 do_encoding_reply_channel_range(0);
3879 do_encoding_reply_channel_range(1);
3882 fn do_encoding_reply_channel_range(encoding_type: u8) {
3883 let mut target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206000b8a06000005dc01").unwrap();
3884 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3885 let mut reply_channel_range = msgs::ReplyChannelRange {
3886 chain_hash: expected_chain_hash,
3887 first_blocknum: 756230,
3888 number_of_blocks: 1500,
3889 sync_complete: true,
3890 short_channel_ids: vec![0x000000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
3893 if encoding_type == 0 {
3894 target_value.append(&mut hex::decode("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
3895 let encoded_value = reply_channel_range.encode();
3896 assert_eq!(encoded_value, target_value);
3898 reply_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3899 assert_eq!(reply_channel_range.chain_hash, expected_chain_hash);
3900 assert_eq!(reply_channel_range.first_blocknum, 756230);
3901 assert_eq!(reply_channel_range.number_of_blocks, 1500);
3902 assert_eq!(reply_channel_range.sync_complete, true);
3903 assert_eq!(reply_channel_range.short_channel_ids[0], 0x000000000000008e);
3904 assert_eq!(reply_channel_range.short_channel_ids[1], 0x0000000000003c69);
3905 assert_eq!(reply_channel_range.short_channel_ids[2], 0x000000000045a6c4);
3907 target_value.append(&mut hex::decode("001601789c636000833e08659309a65878be010010a9023a").unwrap());
3908 let result: Result<msgs::ReplyChannelRange, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
3909 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
3914 fn encoding_query_short_channel_ids() {
3915 do_encoding_query_short_channel_ids(0);
3916 do_encoding_query_short_channel_ids(1);
3919 fn do_encoding_query_short_channel_ids(encoding_type: u8) {
3920 let mut target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206").unwrap();
3921 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3922 let mut query_short_channel_ids = msgs::QueryShortChannelIds {
3923 chain_hash: expected_chain_hash,
3924 short_channel_ids: vec![0x0000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
3927 if encoding_type == 0 {
3928 target_value.append(&mut hex::decode("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
3929 let encoded_value = query_short_channel_ids.encode();
3930 assert_eq!(encoded_value, target_value);
3932 query_short_channel_ids = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3933 assert_eq!(query_short_channel_ids.chain_hash, expected_chain_hash);
3934 assert_eq!(query_short_channel_ids.short_channel_ids[0], 0x000000000000008e);
3935 assert_eq!(query_short_channel_ids.short_channel_ids[1], 0x0000000000003c69);
3936 assert_eq!(query_short_channel_ids.short_channel_ids[2], 0x000000000045a6c4);
3938 target_value.append(&mut hex::decode("001601789c636000833e08659309a65878be010010a9023a").unwrap());
3939 let result: Result<msgs::QueryShortChannelIds, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
3940 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
3945 fn encoding_reply_short_channel_ids_end() {
3946 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3947 let mut reply_short_channel_ids_end = msgs::ReplyShortChannelIdsEnd {
3948 chain_hash: expected_chain_hash,
3949 full_information: true,
3951 let encoded_value = reply_short_channel_ids_end.encode();
3952 let target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e220601").unwrap();
3953 assert_eq!(encoded_value, target_value);
3955 reply_short_channel_ids_end = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3956 assert_eq!(reply_short_channel_ids_end.chain_hash, expected_chain_hash);
3957 assert_eq!(reply_short_channel_ids_end.full_information, true);
3961 fn encoding_gossip_timestamp_filter(){
3962 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3963 let mut gossip_timestamp_filter = msgs::GossipTimestampFilter {
3964 chain_hash: expected_chain_hash,
3965 first_timestamp: 1590000000,
3966 timestamp_range: 0xffff_ffff,
3968 let encoded_value = gossip_timestamp_filter.encode();
3969 let target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e22065ec57980ffffffff").unwrap();
3970 assert_eq!(encoded_value, target_value);
3972 gossip_timestamp_filter = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3973 assert_eq!(gossip_timestamp_filter.chain_hash, expected_chain_hash);
3974 assert_eq!(gossip_timestamp_filter.first_timestamp, 1590000000);
3975 assert_eq!(gossip_timestamp_filter.timestamp_range, 0xffff_ffff);
3979 fn decode_onion_hop_data_len_as_bigsize() {
3980 // Tests that we can decode an onion payload that is >253 bytes.
3981 // Previously, receiving a payload of this size could've caused us to fail to decode a valid
3982 // payload, because we were decoding the length (a BigSize, big-endian) as a VarInt
3985 // Encode a test onion payload with a big custom TLV such that it's >253 bytes, forcing the
3986 // payload length to be encoded over multiple bytes rather than a single u8.
3987 let big_payload = encode_big_payload().unwrap();
3988 let mut rd = Cursor::new(&big_payload[..]);
3990 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3991 <msgs::InboundOnionPayload as ReadableArgs<&&test_utils::TestKeysInterface>>
3992 ::read(&mut rd, &&node_signer).unwrap();
3994 // see above test, needs to be a separate method for use of the serialization macros.
3995 fn encode_big_payload() -> Result<Vec<u8>, io::Error> {
3996 use crate::util::ser::HighZeroBytesDroppedBigSize;
3997 let payload = msgs::OutboundOnionPayload::Forward {
3998 short_channel_id: 0xdeadbeef1bad1dea,
3999 amt_to_forward: 1000,
4000 outgoing_cltv_value: 0xffffffff,
4002 let mut encoded_payload = Vec::new();
4003 let test_bytes = vec![42u8; 1000];
4004 if let msgs::OutboundOnionPayload::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } = payload {
4005 _encode_varint_length_prefixed_tlv!(&mut encoded_payload, {
4006 (1, test_bytes, required_vec),
4007 (2, HighZeroBytesDroppedBigSize(amt_to_forward), required),
4008 (4, HighZeroBytesDroppedBigSize(outgoing_cltv_value), required),
4009 (6, short_channel_id, required)
4016 #[cfg(feature = "std")]
4017 fn test_socket_address_from_str() {
4018 assert_eq!(SocketAddress::TcpIpV4 {
4019 addr: Ipv4Addr::new(127, 0, 0, 1).octets(),
4021 }, SocketAddress::from_str("127.0.0.1:1234").unwrap());
4023 assert_eq!(SocketAddress::TcpIpV6 {
4024 addr: Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1).octets(),
4026 }, SocketAddress::from_str("[0:0:0:0:0:0:0:1]:1234").unwrap());
4028 SocketAddress::Hostname {
4029 hostname: Hostname::try_from("lightning-node.mydomain.com".to_string()).unwrap(),
4031 }, SocketAddress::from_str("lightning-node.mydomain.com:1234").unwrap());
4033 SocketAddress::Hostname {
4034 hostname: Hostname::try_from("example.com".to_string()).unwrap(),
4036 }, SocketAddress::from_str("example.com:1234").unwrap());
4037 assert_eq!(SocketAddress::OnionV3 {
4038 ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102, 182, 107, 4, 105, 247, 246, 85,
4039 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31, 33, 71, 3],
4043 }, SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion:1234").unwrap());
4044 assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6.onion:1234"));
4045 assert_eq!(Err(SocketAddressParseError::InvalidInput), SocketAddress::from_str("127.0.0.1@1234"));
4046 assert_eq!(Err(SocketAddressParseError::InvalidInput), "".parse::<SocketAddress>());
4047 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:9735:94").is_err());
4048 assert!(SocketAddress::from_str("wrong$%#.com:1234").is_err());
4049 assert_eq!(Err(SocketAddressParseError::InvalidPort), SocketAddress::from_str("example.com:wrong"));
4050 assert!("localhost".parse::<SocketAddress>().is_err());
4051 assert!("localhost:invalid-port".parse::<SocketAddress>().is_err());
4052 assert!( "invalid-onion-v3-hostname.onion:8080".parse::<SocketAddress>().is_err());
4053 assert!("b32.example.onion:invalid-port".parse::<SocketAddress>().is_err());
4054 assert!("invalid-address".parse::<SocketAddress>().is_err());
4055 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:1234").is_err());