1 // This file is Copyright its original authors, visible in version control
4 // This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
5 // or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
6 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
7 // You may not use this file except in accordance with one or both of these
10 //! Wire messages, traits representing wire message handlers, and a few error types live here.
12 //! For a normal node you probably don't need to use anything here, however, if you wish to split a
13 //! node into an internet-facing route/message socket handling daemon and a separate daemon (or
14 //! server entirely) which handles only channel-related messages you may wish to implement
15 //! [`ChannelMessageHandler`] yourself and use it to re-serialize messages and pass them across
18 //! Note that if you go with such an architecture (instead of passing raw socket events to a
19 //! non-internet-facing system) you trust the frontend internet-facing system to not lie about the
20 //! source `node_id` of the message, however this does allow you to significantly reduce bandwidth
21 //! between the systems as routing messages can represent a significant chunk of bandwidth usage
22 //! (especially for non-channel-publicly-announcing nodes). As an alternate design which avoids
23 //! this issue, if you have sufficient bidirectional bandwidth between your systems, you may send
24 //! raw socket events into your non-internet-facing system and then send routing events back to
25 //! track the network on the less-secure system.
27 use bitcoin::blockdata::constants::ChainHash;
28 use bitcoin::secp256k1::PublicKey;
29 use bitcoin::secp256k1::ecdsa::Signature;
30 use bitcoin::{secp256k1, Witness};
31 use bitcoin::blockdata::script::Script;
32 use bitcoin::hash_types::Txid;
34 use crate::blinded_path::payment::ReceiveTlvs;
35 use crate::ln::{ChannelId, PaymentPreimage, PaymentHash, PaymentSecret};
36 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
37 use crate::ln::onion_utils;
38 use crate::onion_message;
39 use crate::sign::{NodeSigner, Recipient};
41 use crate::prelude::*;
42 #[cfg(feature = "std")]
43 use core::convert::TryFrom;
47 #[cfg(feature = "std")]
48 use core::str::FromStr;
49 use crate::io::{self, Cursor, Read};
50 use crate::io_extras::read_to_end;
52 use crate::events::MessageSendEventsProvider;
53 use crate::util::chacha20poly1305rfc::ChaChaPolyReadAdapter;
54 use crate::util::logger;
55 use crate::util::ser::{LengthReadable, LengthReadableArgs, Readable, ReadableArgs, Writeable, Writer, WithoutLength, FixedLengthReader, HighZeroBytesDroppedBigSize, Hostname, TransactionU16LenLimited, BigSize};
56 use crate::util::base32;
58 use crate::routing::gossip::{NodeAlias, NodeId};
60 /// 21 million * 10^8 * 1000
61 pub(crate) const MAX_VALUE_MSAT: u64 = 21_000_000_0000_0000_000;
64 /// A partial signature that also contains the Musig2 nonce its signer used
65 #[derive(Clone, Debug, PartialEq, Eq)]
66 pub struct PartialSignatureWithNonce(pub musig2::types::PartialSignature, pub musig2::types::PublicNonce);
68 /// An error in decoding a message or struct.
69 #[derive(Clone, Debug, PartialEq, Eq)]
70 pub enum DecodeError {
71 /// A version byte specified something we don't know how to handle.
73 /// Includes unknown realm byte in an onion hop data packet.
75 /// Unknown feature mandating we fail to parse message (e.g., TLV with an even, unknown type)
76 UnknownRequiredFeature,
77 /// Value was invalid.
79 /// For example, a byte which was supposed to be a bool was something other than a 0
80 /// or 1, a public key/private key/signature was invalid, text wasn't UTF-8, TLV was
81 /// syntactically incorrect, etc.
83 /// The buffer to be read was too short.
85 /// A length descriptor in the packet didn't describe the later data correctly.
87 /// Error from [`std::io`].
89 /// The message included zlib-compressed values, which we don't support.
90 UnsupportedCompression,
93 /// An [`init`] message to be sent to or received from a peer.
95 /// [`init`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-init-message
96 #[derive(Clone, Debug, PartialEq, Eq)]
98 /// The relevant features which the sender supports.
99 pub features: InitFeatures,
100 /// Indicates chains the sender is interested in.
102 /// If there are no common chains, the connection will be closed.
103 pub networks: Option<Vec<ChainHash>>,
104 /// The receipient's network address.
106 /// This adds the option to report a remote IP address back to a connecting peer using the init
107 /// message. A node can decide to use that information to discover a potential update to its
108 /// public IPv4 address (NAT) and use that for a [`NodeAnnouncement`] update message containing
110 pub remote_network_address: Option<SocketAddress>,
113 /// An [`error`] message to be sent to or received from a peer.
115 /// [`error`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-error-and-warning-messages
116 #[derive(Clone, Debug, PartialEq, Eq)]
117 pub struct ErrorMessage {
118 /// The channel ID involved in the error.
120 /// All-0s indicates a general error unrelated to a specific channel, after which all channels
121 /// with the sending peer should be closed.
122 pub channel_id: ChannelId,
123 /// A possibly human-readable error description.
125 /// The string should be sanitized before it is used (e.g., emitted to logs or printed to
126 /// `stdout`). Otherwise, a well crafted error message may trigger a security vulnerability in
127 /// the terminal emulator or the logging subsystem.
131 /// A [`warning`] message to be sent to or received from a peer.
133 /// [`warning`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-error-and-warning-messages
134 #[derive(Clone, Debug, PartialEq, Eq)]
135 pub struct WarningMessage {
136 /// The channel ID involved in the warning.
138 /// All-0s indicates a warning unrelated to a specific channel.
139 pub channel_id: ChannelId,
140 /// A possibly human-readable warning description.
142 /// The string should be sanitized before it is used (e.g. emitted to logs or printed to
143 /// stdout). Otherwise, a well crafted error message may trigger a security vulnerability in
144 /// the terminal emulator or the logging subsystem.
148 /// A [`ping`] message to be sent to or received from a peer.
150 /// [`ping`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-ping-and-pong-messages
151 #[derive(Clone, Debug, PartialEq, Eq)]
153 /// The desired response length.
155 /// The ping packet size.
157 /// This field is not sent on the wire. byteslen zeros are sent.
161 /// A [`pong`] message to be sent to or received from a peer.
163 /// [`pong`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-ping-and-pong-messages
164 #[derive(Clone, Debug, PartialEq, Eq)]
166 /// The pong packet size.
168 /// This field is not sent on the wire. byteslen zeros are sent.
172 /// An [`open_channel`] message to be sent to or received from a peer.
174 /// Used in V1 channel establishment
176 /// [`open_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-open_channel-message
177 #[derive(Clone, Debug, PartialEq, Eq)]
178 pub struct OpenChannel {
179 /// The genesis hash of the blockchain where the channel is to be opened
180 pub chain_hash: ChainHash,
181 /// A temporary channel ID, until the funding outpoint is announced
182 pub temporary_channel_id: ChannelId,
183 /// The channel value
184 pub funding_satoshis: u64,
185 /// The amount to push to the counterparty as part of the open, in milli-satoshi
187 /// The threshold below which outputs on transactions broadcast by sender will be omitted
188 pub dust_limit_satoshis: u64,
189 /// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
190 pub max_htlc_value_in_flight_msat: u64,
191 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
192 pub channel_reserve_satoshis: u64,
193 /// The minimum HTLC size incoming to sender, in milli-satoshi
194 pub htlc_minimum_msat: u64,
195 /// The feerate per 1000-weight of sender generated transactions, until updated by
197 pub feerate_per_kw: u32,
198 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if
199 /// they broadcast a commitment transaction
200 pub to_self_delay: u16,
201 /// The maximum number of inbound HTLCs towards sender
202 pub max_accepted_htlcs: u16,
203 /// The sender's key controlling the funding transaction
204 pub funding_pubkey: PublicKey,
205 /// Used to derive a revocation key for transactions broadcast by counterparty
206 pub revocation_basepoint: PublicKey,
207 /// A payment key to sender for transactions broadcast by counterparty
208 pub payment_point: PublicKey,
209 /// Used to derive a payment key to sender for transactions broadcast by sender
210 pub delayed_payment_basepoint: PublicKey,
211 /// Used to derive an HTLC payment key to sender
212 pub htlc_basepoint: PublicKey,
213 /// The first to-be-broadcast-by-sender transaction's per commitment point
214 pub first_per_commitment_point: PublicKey,
215 /// The channel flags to be used
216 pub channel_flags: u8,
217 /// A request to pre-set the to-sender output's `scriptPubkey` for when we collaboratively close
218 pub shutdown_scriptpubkey: Option<Script>,
219 /// The channel type that this channel will represent
221 /// If this is `None`, we derive the channel type from the intersection of our
222 /// feature bits with our counterparty's feature bits from the [`Init`] message.
223 pub channel_type: Option<ChannelTypeFeatures>,
226 /// An open_channel2 message to be sent by or received from the channel initiator.
228 /// Used in V2 channel establishment
230 // TODO(dual_funding): Add spec link for `open_channel2`.
231 #[derive(Clone, Debug, PartialEq, Eq)]
232 pub struct OpenChannelV2 {
233 /// The genesis hash of the blockchain where the channel is to be opened
234 pub chain_hash: ChainHash,
235 /// A temporary channel ID derived using a zeroed out value for the channel acceptor's revocation basepoint
236 pub temporary_channel_id: ChannelId,
237 /// The feerate for the funding transaction set by the channel initiator
238 pub funding_feerate_sat_per_1000_weight: u32,
239 /// The feerate for the commitment transaction set by the channel initiator
240 pub commitment_feerate_sat_per_1000_weight: u32,
241 /// Part of the channel value contributed by the channel initiator
242 pub funding_satoshis: u64,
243 /// The threshold below which outputs on transactions broadcast by the channel initiator will be
245 pub dust_limit_satoshis: u64,
246 /// The maximum inbound HTLC value in flight towards channel initiator, in milli-satoshi
247 pub max_htlc_value_in_flight_msat: u64,
248 /// The minimum HTLC size incoming to channel initiator, in milli-satoshi
249 pub htlc_minimum_msat: u64,
250 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
251 /// broadcast a commitment transaction
252 pub to_self_delay: u16,
253 /// The maximum number of inbound HTLCs towards channel initiator
254 pub max_accepted_htlcs: u16,
255 /// The locktime for the funding transaction
257 /// The channel initiator's key controlling the funding transaction
258 pub funding_pubkey: PublicKey,
259 /// Used to derive a revocation key for transactions broadcast by counterparty
260 pub revocation_basepoint: PublicKey,
261 /// A payment key to channel initiator for transactions broadcast by counterparty
262 pub payment_basepoint: PublicKey,
263 /// Used to derive a payment key to channel initiator for transactions broadcast by channel
265 pub delayed_payment_basepoint: PublicKey,
266 /// Used to derive an HTLC payment key to channel initiator
267 pub htlc_basepoint: PublicKey,
268 /// The first to-be-broadcast-by-channel-initiator transaction's per commitment point
269 pub first_per_commitment_point: PublicKey,
270 /// The second to-be-broadcast-by-channel-initiator transaction's per commitment point
271 pub second_per_commitment_point: PublicKey,
273 pub channel_flags: u8,
274 /// Optionally, a request to pre-set the to-channel-initiator output's scriptPubkey for when we
275 /// collaboratively close
276 pub shutdown_scriptpubkey: Option<Script>,
277 /// The channel type that this channel will represent. If none is set, we derive the channel
278 /// type from the intersection of our feature bits with our counterparty's feature bits from
279 /// the Init message.
280 pub channel_type: Option<ChannelTypeFeatures>,
281 /// Optionally, a requirement that only confirmed inputs can be added
282 pub require_confirmed_inputs: Option<()>,
285 /// An [`accept_channel`] message to be sent to or received from a peer.
287 /// Used in V1 channel establishment
289 /// [`accept_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-accept_channel-message
290 #[derive(Clone, Debug, PartialEq, Eq)]
291 pub struct AcceptChannel {
292 /// A temporary channel ID, until the funding outpoint is announced
293 pub temporary_channel_id: ChannelId,
294 /// The threshold below which outputs on transactions broadcast by sender will be omitted
295 pub dust_limit_satoshis: u64,
296 /// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
297 pub max_htlc_value_in_flight_msat: u64,
298 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
299 pub channel_reserve_satoshis: u64,
300 /// The minimum HTLC size incoming to sender, in milli-satoshi
301 pub htlc_minimum_msat: u64,
302 /// Minimum depth of the funding transaction before the channel is considered open
303 pub minimum_depth: u32,
304 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they broadcast a commitment transaction
305 pub to_self_delay: u16,
306 /// The maximum number of inbound HTLCs towards sender
307 pub max_accepted_htlcs: u16,
308 /// The sender's key controlling the funding transaction
309 pub funding_pubkey: PublicKey,
310 /// Used to derive a revocation key for transactions broadcast by counterparty
311 pub revocation_basepoint: PublicKey,
312 /// A payment key to sender for transactions broadcast by counterparty
313 pub payment_point: PublicKey,
314 /// Used to derive a payment key to sender for transactions broadcast by sender
315 pub delayed_payment_basepoint: PublicKey,
316 /// Used to derive an HTLC payment key to sender for transactions broadcast by counterparty
317 pub htlc_basepoint: PublicKey,
318 /// The first to-be-broadcast-by-sender transaction's per commitment point
319 pub first_per_commitment_point: PublicKey,
320 /// A request to pre-set the to-sender output's scriptPubkey for when we collaboratively close
321 pub shutdown_scriptpubkey: Option<Script>,
322 /// The channel type that this channel will represent.
324 /// If this is `None`, we derive the channel type from the intersection of
325 /// our feature bits with our counterparty's feature bits from the [`Init`] message.
326 /// This is required to match the equivalent field in [`OpenChannel::channel_type`].
327 pub channel_type: Option<ChannelTypeFeatures>,
329 /// Next nonce the channel initiator should use to create a funding output signature against
330 pub next_local_nonce: Option<musig2::types::PublicNonce>,
333 /// An accept_channel2 message to be sent by or received from the channel accepter.
335 /// Used in V2 channel establishment
337 // TODO(dual_funding): Add spec link for `accept_channel2`.
338 #[derive(Clone, Debug, PartialEq, Eq)]
339 pub struct AcceptChannelV2 {
340 /// The same `temporary_channel_id` received from the initiator's `open_channel2` message.
341 pub temporary_channel_id: ChannelId,
342 /// Part of the channel value contributed by the channel acceptor
343 pub funding_satoshis: u64,
344 /// The threshold below which outputs on transactions broadcast by the channel acceptor will be
346 pub dust_limit_satoshis: u64,
347 /// The maximum inbound HTLC value in flight towards channel acceptor, in milli-satoshi
348 pub max_htlc_value_in_flight_msat: u64,
349 /// The minimum HTLC size incoming to channel acceptor, in milli-satoshi
350 pub htlc_minimum_msat: u64,
351 /// Minimum depth of the funding transaction before the channel is considered open
352 pub minimum_depth: u32,
353 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
354 /// broadcast a commitment transaction
355 pub to_self_delay: u16,
356 /// The maximum number of inbound HTLCs towards channel acceptor
357 pub max_accepted_htlcs: u16,
358 /// The channel acceptor's key controlling the funding transaction
359 pub funding_pubkey: PublicKey,
360 /// Used to derive a revocation key for transactions broadcast by counterparty
361 pub revocation_basepoint: PublicKey,
362 /// A payment key to channel acceptor for transactions broadcast by counterparty
363 pub payment_basepoint: PublicKey,
364 /// Used to derive a payment key to channel acceptor for transactions broadcast by channel
366 pub delayed_payment_basepoint: PublicKey,
367 /// Used to derive an HTLC payment key to channel acceptor for transactions broadcast by counterparty
368 pub htlc_basepoint: PublicKey,
369 /// The first to-be-broadcast-by-channel-acceptor transaction's per commitment point
370 pub first_per_commitment_point: PublicKey,
371 /// The second to-be-broadcast-by-channel-acceptor transaction's per commitment point
372 pub second_per_commitment_point: PublicKey,
373 /// Optionally, a request to pre-set the to-channel-acceptor output's scriptPubkey for when we
374 /// collaboratively close
375 pub shutdown_scriptpubkey: Option<Script>,
376 /// The channel type that this channel will represent. If none is set, we derive the channel
377 /// type from the intersection of our feature bits with our counterparty's feature bits from
378 /// the Init message.
380 /// This is required to match the equivalent field in [`OpenChannelV2::channel_type`].
381 pub channel_type: Option<ChannelTypeFeatures>,
382 /// Optionally, a requirement that only confirmed inputs can be added
383 pub require_confirmed_inputs: Option<()>,
386 /// A [`funding_created`] message to be sent to or received from a peer.
388 /// Used in V1 channel establishment
390 /// [`funding_created`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-funding_created-message
391 #[derive(Clone, Debug, PartialEq, Eq)]
392 pub struct FundingCreated {
393 /// A temporary channel ID, until the funding is established
394 pub temporary_channel_id: ChannelId,
395 /// The funding transaction ID
396 pub funding_txid: Txid,
397 /// The specific output index funding this channel
398 pub funding_output_index: u16,
399 /// The signature of the channel initiator (funder) on the initial commitment transaction
400 pub signature: Signature,
402 /// The partial signature of the channel initiator (funder)
403 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
405 /// Next nonce the channel acceptor should use to finalize the funding output signature
406 pub next_local_nonce: Option<musig2::types::PublicNonce>
409 /// A [`funding_signed`] message to be sent to or received from a peer.
411 /// Used in V1 channel establishment
413 /// [`funding_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-funding_signed-message
414 #[derive(Clone, Debug, PartialEq, Eq)]
415 pub struct FundingSigned {
417 pub channel_id: ChannelId,
418 /// The signature of the channel acceptor (fundee) on the initial commitment transaction
419 pub signature: Signature,
421 /// The partial signature of the channel acceptor (fundee)
422 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
425 /// A [`channel_ready`] message to be sent to or received from a peer.
427 /// [`channel_ready`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-channel_ready-message
428 #[derive(Clone, Debug, PartialEq, Eq)]
429 pub struct ChannelReady {
431 pub channel_id: ChannelId,
432 /// The per-commitment point of the second commitment transaction
433 pub next_per_commitment_point: PublicKey,
434 /// If set, provides a `short_channel_id` alias for this channel.
436 /// The sender will accept payments to be forwarded over this SCID and forward them to this
437 /// messages' recipient.
438 pub short_channel_id_alias: Option<u64>,
441 /// A tx_add_input message for adding an input during interactive transaction construction
443 // TODO(dual_funding): Add spec link for `tx_add_input`.
444 #[derive(Clone, Debug, PartialEq, Eq)]
445 pub struct TxAddInput {
447 pub channel_id: ChannelId,
448 /// A randomly chosen unique identifier for this input, which is even for initiators and odd for
451 /// Serialized transaction that contains the output this input spends to verify that it is non
453 pub prevtx: TransactionU16LenLimited,
454 /// The index of the output being spent
456 /// The sequence number of this input
460 /// A tx_add_output message for adding an output during interactive transaction construction.
462 // TODO(dual_funding): Add spec link for `tx_add_output`.
463 #[derive(Clone, Debug, PartialEq, Eq)]
464 pub struct TxAddOutput {
466 pub channel_id: ChannelId,
467 /// A randomly chosen unique identifier for this output, which is even for initiators and odd for
470 /// The satoshi value of the output
472 /// The scriptPubKey for the output
476 /// A tx_remove_input message for removing an input during interactive transaction construction.
478 // TODO(dual_funding): Add spec link for `tx_remove_input`.
479 #[derive(Clone, Debug, PartialEq, Eq)]
480 pub struct TxRemoveInput {
482 pub channel_id: ChannelId,
483 /// The serial ID of the input to be removed
487 /// A tx_remove_output message for removing an output during interactive transaction construction.
489 // TODO(dual_funding): Add spec link for `tx_remove_output`.
490 #[derive(Clone, Debug, PartialEq, Eq)]
491 pub struct TxRemoveOutput {
493 pub channel_id: ChannelId,
494 /// The serial ID of the output to be removed
498 /// A tx_complete message signalling the conclusion of a peer's transaction contributions during
499 /// interactive transaction construction.
501 // TODO(dual_funding): Add spec link for `tx_complete`.
502 #[derive(Clone, Debug, PartialEq, Eq)]
503 pub struct TxComplete {
505 pub channel_id: ChannelId,
508 /// A tx_signatures message containing the sender's signatures for a transaction constructed with
509 /// interactive transaction construction.
511 // TODO(dual_funding): Add spec link for `tx_signatures`.
512 #[derive(Clone, Debug, PartialEq, Eq)]
513 pub struct TxSignatures {
515 pub channel_id: ChannelId,
518 /// The list of witnesses
519 pub witnesses: Vec<Witness>,
522 /// A tx_init_rbf message which initiates a replacement of the transaction after it's been
525 // TODO(dual_funding): Add spec link for `tx_init_rbf`.
526 #[derive(Clone, Debug, PartialEq, Eq)]
527 pub struct TxInitRbf {
529 pub channel_id: ChannelId,
530 /// The locktime of the transaction
532 /// The feerate of the transaction
533 pub feerate_sat_per_1000_weight: u32,
534 /// The number of satoshis the sender will contribute to or, if negative, remove from
535 /// (e.g. splice-out) the funding output of the transaction
536 pub funding_output_contribution: Option<i64>,
539 /// A tx_ack_rbf message which acknowledges replacement of the transaction after it's been
542 // TODO(dual_funding): Add spec link for `tx_ack_rbf`.
543 #[derive(Clone, Debug, PartialEq, Eq)]
544 pub struct TxAckRbf {
546 pub channel_id: ChannelId,
547 /// The number of satoshis the sender will contribute to or, if negative, remove from
548 /// (e.g. splice-out) the funding output of the transaction
549 pub funding_output_contribution: Option<i64>,
552 /// A tx_abort message which signals the cancellation of an in-progress transaction negotiation.
554 // TODO(dual_funding): Add spec link for `tx_abort`.
555 #[derive(Clone, Debug, PartialEq, Eq)]
558 pub channel_id: ChannelId,
563 /// A [`shutdown`] message to be sent to or received from a peer.
565 /// [`shutdown`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-initiation-shutdown
566 #[derive(Clone, Debug, PartialEq, Eq)]
567 pub struct Shutdown {
569 pub channel_id: ChannelId,
570 /// The destination of this peer's funds on closing.
572 /// Must be in one of these forms: P2PKH, P2SH, P2WPKH, P2WSH, P2TR.
573 pub scriptpubkey: Script,
576 /// The minimum and maximum fees which the sender is willing to place on the closing transaction.
578 /// This is provided in [`ClosingSigned`] by both sides to indicate the fee range they are willing
580 #[derive(Clone, Debug, PartialEq, Eq)]
581 pub struct ClosingSignedFeeRange {
582 /// The minimum absolute fee, in satoshis, which the sender is willing to place on the closing
584 pub min_fee_satoshis: u64,
585 /// The maximum absolute fee, in satoshis, which the sender is willing to place on the closing
587 pub max_fee_satoshis: u64,
590 /// A [`closing_signed`] message to be sent to or received from a peer.
592 /// [`closing_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-negotiation-closing_signed
593 #[derive(Clone, Debug, PartialEq, Eq)]
594 pub struct ClosingSigned {
596 pub channel_id: ChannelId,
597 /// The proposed total fee for the closing transaction
598 pub fee_satoshis: u64,
599 /// A signature on the closing transaction
600 pub signature: Signature,
601 /// The minimum and maximum fees which the sender is willing to accept, provided only by new
603 pub fee_range: Option<ClosingSignedFeeRange>,
606 /// An [`update_add_htlc`] message to be sent to or received from a peer.
608 /// [`update_add_htlc`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#adding-an-htlc-update_add_htlc
609 #[derive(Clone, Debug, PartialEq, Eq)]
610 pub struct UpdateAddHTLC {
612 pub channel_id: ChannelId,
615 /// The HTLC value in milli-satoshi
616 pub amount_msat: u64,
617 /// The payment hash, the pre-image of which controls HTLC redemption
618 pub payment_hash: PaymentHash,
619 /// The expiry height of the HTLC
620 pub cltv_expiry: u32,
621 /// The extra fee skimmed by the sender of this message. See
622 /// [`ChannelConfig::accept_underpaying_htlcs`].
624 /// [`ChannelConfig::accept_underpaying_htlcs`]: crate::util::config::ChannelConfig::accept_underpaying_htlcs
625 pub skimmed_fee_msat: Option<u64>,
626 pub(crate) onion_routing_packet: OnionPacket,
629 /// An onion message to be sent to or received from a peer.
631 // TODO: update with link to OM when they are merged into the BOLTs
632 #[derive(Clone, Debug, PartialEq, Eq)]
633 pub struct OnionMessage {
634 /// Used in decrypting the onion packet's payload.
635 pub blinding_point: PublicKey,
636 /// The full onion packet including hop data, pubkey, and hmac
637 pub onion_routing_packet: onion_message::Packet,
640 /// An [`update_fulfill_htlc`] message to be sent to or received from a peer.
642 /// [`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
643 #[derive(Clone, Debug, PartialEq, Eq)]
644 pub struct UpdateFulfillHTLC {
646 pub channel_id: ChannelId,
649 /// The pre-image of the payment hash, allowing HTLC redemption
650 pub payment_preimage: PaymentPreimage,
653 /// An [`update_fail_htlc`] message to be sent to or received from a peer.
655 /// [`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
656 #[derive(Clone, Debug, PartialEq, Eq)]
657 pub struct UpdateFailHTLC {
659 pub channel_id: ChannelId,
662 pub(crate) reason: OnionErrorPacket,
665 /// An [`update_fail_malformed_htlc`] message to be sent to or received from a peer.
667 /// [`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
668 #[derive(Clone, Debug, PartialEq, Eq)]
669 pub struct UpdateFailMalformedHTLC {
671 pub channel_id: ChannelId,
674 pub(crate) sha256_of_onion: [u8; 32],
676 pub failure_code: u16,
679 /// A [`commitment_signed`] message to be sent to or received from a peer.
681 /// [`commitment_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#committing-updates-so-far-commitment_signed
682 #[derive(Clone, Debug, PartialEq, Eq)]
683 pub struct CommitmentSigned {
685 pub channel_id: ChannelId,
686 /// A signature on the commitment transaction
687 pub signature: Signature,
688 /// Signatures on the HTLC transactions
689 pub htlc_signatures: Vec<Signature>,
691 /// The partial Taproot signature on the commitment transaction
692 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
695 /// A [`revoke_and_ack`] message to be sent to or received from a peer.
697 /// [`revoke_and_ack`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#completing-the-transition-to-the-updated-state-revoke_and_ack
698 #[derive(Clone, Debug, PartialEq, Eq)]
699 pub struct RevokeAndACK {
701 pub channel_id: ChannelId,
702 /// The secret corresponding to the per-commitment point
703 pub per_commitment_secret: [u8; 32],
704 /// The next sender-broadcast commitment transaction's per-commitment point
705 pub next_per_commitment_point: PublicKey,
707 /// Musig nonce the recipient should use in their next commitment signature message
708 pub next_local_nonce: Option<musig2::types::PublicNonce>
711 /// An [`update_fee`] message to be sent to or received from a peer
713 /// [`update_fee`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#updating-fees-update_fee
714 #[derive(Clone, Debug, PartialEq, Eq)]
715 pub struct UpdateFee {
717 pub channel_id: ChannelId,
718 /// Fee rate per 1000-weight of the transaction
719 pub feerate_per_kw: u32,
722 /// A [`channel_reestablish`] message to be sent to or received from a peer.
724 /// [`channel_reestablish`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#message-retransmission
725 #[derive(Clone, Debug, PartialEq, Eq)]
726 pub struct ChannelReestablish {
728 pub channel_id: ChannelId,
729 /// The next commitment number for the sender
730 pub next_local_commitment_number: u64,
731 /// The next commitment number for the recipient
732 pub next_remote_commitment_number: u64,
733 /// Proof that the sender knows the per-commitment secret of a specific commitment transaction
734 /// belonging to the recipient
735 pub your_last_per_commitment_secret: [u8; 32],
736 /// The sender's per-commitment point for their current commitment transaction
737 pub my_current_per_commitment_point: PublicKey,
738 /// The next funding transaction ID
739 pub next_funding_txid: Option<Txid>,
742 /// An [`announcement_signatures`] message to be sent to or received from a peer.
744 /// [`announcement_signatures`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-announcement_signatures-message
745 #[derive(Clone, Debug, PartialEq, Eq)]
746 pub struct AnnouncementSignatures {
748 pub channel_id: ChannelId,
749 /// The short channel ID
750 pub short_channel_id: u64,
751 /// A signature by the node key
752 pub node_signature: Signature,
753 /// A signature by the funding key
754 pub bitcoin_signature: Signature,
757 /// An address which can be used to connect to a remote peer.
758 #[derive(Clone, Debug, PartialEq, Eq)]
759 pub enum SocketAddress {
760 /// An IPv4 address and port on which the peer is listening.
762 /// The 4-byte IPv4 address
764 /// The port on which the node is listening
767 /// An IPv6 address and port on which the peer is listening.
769 /// The 16-byte IPv6 address
771 /// The port on which the node is listening
774 /// An old-style Tor onion address/port on which the peer is listening.
776 /// This field is deprecated and the Tor network generally no longer supports V2 Onion
777 /// addresses. Thus, the details are not parsed here.
779 /// A new-style Tor onion address/port on which the peer is listening.
781 /// To create the human-readable "hostname", concatenate the ED25519 pubkey, checksum, and version,
782 /// wrap as base32 and append ".onion".
784 /// The ed25519 long-term public key of the peer
785 ed25519_pubkey: [u8; 32],
786 /// The checksum of the pubkey and version, as included in the onion address
788 /// The version byte, as defined by the Tor Onion v3 spec.
790 /// The port on which the node is listening
793 /// A hostname/port on which the peer is listening.
795 /// The hostname on which the node is listening.
797 /// The port on which the node is listening.
802 /// Gets the ID of this address type. Addresses in [`NodeAnnouncement`] messages should be sorted
804 pub(crate) fn get_id(&self) -> u8 {
806 &SocketAddress::TcpIpV4 {..} => { 1 },
807 &SocketAddress::TcpIpV6 {..} => { 2 },
808 &SocketAddress::OnionV2(_) => { 3 },
809 &SocketAddress::OnionV3 {..} => { 4 },
810 &SocketAddress::Hostname {..} => { 5 },
814 /// Strict byte-length of address descriptor, 1-byte type not recorded
815 fn len(&self) -> u16 {
817 &SocketAddress::TcpIpV4 { .. } => { 6 },
818 &SocketAddress::TcpIpV6 { .. } => { 18 },
819 &SocketAddress::OnionV2(_) => { 12 },
820 &SocketAddress::OnionV3 { .. } => { 37 },
821 // Consists of 1-byte hostname length, hostname bytes, and 2-byte port.
822 &SocketAddress::Hostname { ref hostname, .. } => { u16::from(hostname.len()) + 3 },
826 /// The maximum length of any address descriptor, not including the 1-byte type.
827 /// This maximum length is reached by a hostname address descriptor:
828 /// a hostname with a maximum length of 255, its 1-byte length and a 2-byte port.
829 pub(crate) const MAX_LEN: u16 = 258;
832 impl Writeable for SocketAddress {
833 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
835 &SocketAddress::TcpIpV4 { ref addr, ref port } => {
840 &SocketAddress::TcpIpV6 { ref addr, ref port } => {
845 &SocketAddress::OnionV2(bytes) => {
847 bytes.write(writer)?;
849 &SocketAddress::OnionV3 { ref ed25519_pubkey, ref checksum, ref version, ref port } => {
851 ed25519_pubkey.write(writer)?;
852 checksum.write(writer)?;
853 version.write(writer)?;
856 &SocketAddress::Hostname { ref hostname, ref port } => {
858 hostname.write(writer)?;
866 impl Readable for Result<SocketAddress, u8> {
867 fn read<R: Read>(reader: &mut R) -> Result<Result<SocketAddress, u8>, DecodeError> {
868 let byte = <u8 as Readable>::read(reader)?;
871 Ok(Ok(SocketAddress::TcpIpV4 {
872 addr: Readable::read(reader)?,
873 port: Readable::read(reader)?,
877 Ok(Ok(SocketAddress::TcpIpV6 {
878 addr: Readable::read(reader)?,
879 port: Readable::read(reader)?,
882 3 => Ok(Ok(SocketAddress::OnionV2(Readable::read(reader)?))),
884 Ok(Ok(SocketAddress::OnionV3 {
885 ed25519_pubkey: Readable::read(reader)?,
886 checksum: Readable::read(reader)?,
887 version: Readable::read(reader)?,
888 port: Readable::read(reader)?,
892 Ok(Ok(SocketAddress::Hostname {
893 hostname: Readable::read(reader)?,
894 port: Readable::read(reader)?,
897 _ => return Ok(Err(byte)),
902 impl Readable for SocketAddress {
903 fn read<R: Read>(reader: &mut R) -> Result<SocketAddress, DecodeError> {
904 match Readable::read(reader) {
905 Ok(Ok(res)) => Ok(res),
906 Ok(Err(_)) => Err(DecodeError::UnknownVersion),
912 /// [`SocketAddress`] error variants
913 #[derive(Debug, Eq, PartialEq, Clone)]
914 pub enum SocketAddressParseError {
915 /// Socket address (IPv4/IPv6) parsing error
917 /// Invalid input format
921 /// Invalid onion v3 address
925 impl fmt::Display for SocketAddressParseError {
926 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
928 SocketAddressParseError::SocketAddrParse => write!(f, "Socket address (IPv4/IPv6) parsing error"),
929 SocketAddressParseError::InvalidInput => write!(f, "Invalid input format. \
930 Expected: \"<ipv4>:<port>\", \"[<ipv6>]:<port>\", \"<onion address>.onion:<port>\" or \"<hostname>:<port>\""),
931 SocketAddressParseError::InvalidPort => write!(f, "Invalid port"),
932 SocketAddressParseError::InvalidOnionV3 => write!(f, "Invalid onion v3 address"),
937 #[cfg(feature = "std")]
938 impl From<std::net::SocketAddrV4> for SocketAddress {
939 fn from(addr: std::net::SocketAddrV4) -> Self {
940 SocketAddress::TcpIpV4 { addr: addr.ip().octets(), port: addr.port() }
944 #[cfg(feature = "std")]
945 impl From<std::net::SocketAddrV6> for SocketAddress {
946 fn from(addr: std::net::SocketAddrV6) -> Self {
947 SocketAddress::TcpIpV6 { addr: addr.ip().octets(), port: addr.port() }
951 #[cfg(feature = "std")]
952 impl From<std::net::SocketAddr> for SocketAddress {
953 fn from(addr: std::net::SocketAddr) -> Self {
955 std::net::SocketAddr::V4(addr) => addr.into(),
956 std::net::SocketAddr::V6(addr) => addr.into(),
961 /// Parses an OnionV3 host and port into a [`SocketAddress::OnionV3`].
963 /// The host part must end with ".onion".
964 pub fn parse_onion_address(host: &str, port: u16) -> Result<SocketAddress, SocketAddressParseError> {
965 if host.ends_with(".onion") {
966 let domain = &host[..host.len() - ".onion".len()];
967 if domain.len() != 56 {
968 return Err(SocketAddressParseError::InvalidOnionV3);
970 let onion = base32::Alphabet::RFC4648 { padding: false }.decode(&domain).map_err(|_| SocketAddressParseError::InvalidOnionV3)?;
971 if onion.len() != 35 {
972 return Err(SocketAddressParseError::InvalidOnionV3);
974 let version = onion[0];
975 let first_checksum_flag = onion[1];
976 let second_checksum_flag = onion[2];
977 let mut ed25519_pubkey = [0; 32];
978 ed25519_pubkey.copy_from_slice(&onion[3..35]);
979 let checksum = u16::from_be_bytes([first_checksum_flag, second_checksum_flag]);
980 return Ok(SocketAddress::OnionV3 { ed25519_pubkey, checksum, version, port });
983 return Err(SocketAddressParseError::InvalidInput);
987 #[cfg(feature = "std")]
988 impl FromStr for SocketAddress {
989 type Err = SocketAddressParseError;
991 fn from_str(s: &str) -> Result<Self, Self::Err> {
992 match std::net::SocketAddr::from_str(s) {
993 Ok(addr) => Ok(addr.into()),
995 let trimmed_input = match s.rfind(":") {
997 None => return Err(SocketAddressParseError::InvalidInput),
999 let host = &s[..trimmed_input];
1000 let port: u16 = s[trimmed_input + 1..].parse().map_err(|_| SocketAddressParseError::InvalidPort)?;
1001 if host.ends_with(".onion") {
1002 return parse_onion_address(host, port);
1004 if let Ok(hostname) = Hostname::try_from(s[..trimmed_input].to_string()) {
1005 return Ok(SocketAddress::Hostname { hostname, port });
1007 return Err(SocketAddressParseError::SocketAddrParse)
1013 /// Represents the set of gossip messages that require a signature from a node's identity key.
1014 pub enum UnsignedGossipMessage<'a> {
1015 /// An unsigned channel announcement.
1016 ChannelAnnouncement(&'a UnsignedChannelAnnouncement),
1017 /// An unsigned channel update.
1018 ChannelUpdate(&'a UnsignedChannelUpdate),
1019 /// An unsigned node announcement.
1020 NodeAnnouncement(&'a UnsignedNodeAnnouncement)
1023 impl<'a> Writeable for UnsignedGossipMessage<'a> {
1024 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
1026 UnsignedGossipMessage::ChannelAnnouncement(ref msg) => msg.write(writer),
1027 UnsignedGossipMessage::ChannelUpdate(ref msg) => msg.write(writer),
1028 UnsignedGossipMessage::NodeAnnouncement(ref msg) => msg.write(writer),
1033 /// The unsigned part of a [`node_announcement`] message.
1035 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
1036 #[derive(Clone, Debug, PartialEq, Eq)]
1037 pub struct UnsignedNodeAnnouncement {
1038 /// The advertised features
1039 pub features: NodeFeatures,
1040 /// A strictly monotonic announcement counter, with gaps allowed
1042 /// The `node_id` this announcement originated from (don't rebroadcast the `node_announcement` back
1044 pub node_id: NodeId,
1045 /// An RGB color for UI purposes
1047 /// An alias, for UI purposes.
1049 /// This should be sanitized before use. There is no guarantee of uniqueness.
1050 pub alias: NodeAlias,
1051 /// List of addresses on which this node is reachable
1052 pub addresses: Vec<SocketAddress>,
1053 pub(crate) excess_address_data: Vec<u8>,
1054 pub(crate) excess_data: Vec<u8>,
1056 #[derive(Clone, Debug, PartialEq, Eq)]
1057 /// A [`node_announcement`] message to be sent to or received from a peer.
1059 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
1060 pub struct NodeAnnouncement {
1061 /// The signature by the node key
1062 pub signature: Signature,
1063 /// The actual content of the announcement
1064 pub contents: UnsignedNodeAnnouncement,
1067 /// The unsigned part of a [`channel_announcement`] message.
1069 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
1070 #[derive(Clone, Debug, PartialEq, Eq)]
1071 pub struct UnsignedChannelAnnouncement {
1072 /// The advertised channel features
1073 pub features: ChannelFeatures,
1074 /// The genesis hash of the blockchain where the channel is to be opened
1075 pub chain_hash: ChainHash,
1076 /// The short channel ID
1077 pub short_channel_id: u64,
1078 /// One of the two `node_id`s which are endpoints of this channel
1079 pub node_id_1: NodeId,
1080 /// The other of the two `node_id`s which are endpoints of this channel
1081 pub node_id_2: NodeId,
1082 /// The funding key for the first node
1083 pub bitcoin_key_1: NodeId,
1084 /// The funding key for the second node
1085 pub bitcoin_key_2: NodeId,
1086 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1089 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1090 pub excess_data: Vec<u8>,
1092 /// A [`channel_announcement`] message to be sent to or received from a peer.
1094 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
1095 #[derive(Clone, Debug, PartialEq, Eq)]
1096 pub struct ChannelAnnouncement {
1097 /// Authentication of the announcement by the first public node
1098 pub node_signature_1: Signature,
1099 /// Authentication of the announcement by the second public node
1100 pub node_signature_2: Signature,
1101 /// Proof of funding UTXO ownership by the first public node
1102 pub bitcoin_signature_1: Signature,
1103 /// Proof of funding UTXO ownership by the second public node
1104 pub bitcoin_signature_2: Signature,
1105 /// The actual announcement
1106 pub contents: UnsignedChannelAnnouncement,
1109 /// The unsigned part of a [`channel_update`] message.
1111 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1112 #[derive(Clone, Debug, PartialEq, Eq)]
1113 pub struct UnsignedChannelUpdate {
1114 /// The genesis hash of the blockchain where the channel is to be opened
1115 pub chain_hash: ChainHash,
1116 /// The short channel ID
1117 pub short_channel_id: u64,
1118 /// A strictly monotonic announcement counter, with gaps allowed, specific to this channel
1122 /// The number of blocks such that if:
1123 /// `incoming_htlc.cltv_expiry < outgoing_htlc.cltv_expiry + cltv_expiry_delta`
1124 /// then we need to fail the HTLC backwards. When forwarding an HTLC, `cltv_expiry_delta` determines
1125 /// the outgoing HTLC's minimum `cltv_expiry` value -- so, if an incoming HTLC comes in with a
1126 /// `cltv_expiry` of 100000, and the node we're forwarding to has a `cltv_expiry_delta` value of 10,
1127 /// then we'll check that the outgoing HTLC's `cltv_expiry` value is at least 100010 before
1128 /// forwarding. Note that the HTLC sender is the one who originally sets this value when
1129 /// constructing the route.
1130 pub cltv_expiry_delta: u16,
1131 /// The minimum HTLC size incoming to sender, in milli-satoshi
1132 pub htlc_minimum_msat: u64,
1133 /// The maximum HTLC value incoming to sender, in milli-satoshi.
1135 /// This used to be optional.
1136 pub htlc_maximum_msat: u64,
1137 /// The base HTLC fee charged by sender, in milli-satoshi
1138 pub fee_base_msat: u32,
1139 /// The amount to fee multiplier, in micro-satoshi
1140 pub fee_proportional_millionths: u32,
1141 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1144 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1145 pub excess_data: Vec<u8>,
1147 /// A [`channel_update`] message to be sent to or received from a peer.
1149 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1150 #[derive(Clone, Debug, PartialEq, Eq)]
1151 pub struct ChannelUpdate {
1152 /// A signature of the channel update
1153 pub signature: Signature,
1154 /// The actual channel update
1155 pub contents: UnsignedChannelUpdate,
1158 /// A [`query_channel_range`] message is used to query a peer for channel
1159 /// UTXOs in a range of blocks. The recipient of a query makes a best
1160 /// effort to reply to the query using one or more [`ReplyChannelRange`]
1163 /// [`query_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1164 #[derive(Clone, Debug, PartialEq, Eq)]
1165 pub struct QueryChannelRange {
1166 /// The genesis hash of the blockchain being queried
1167 pub chain_hash: ChainHash,
1168 /// The height of the first block for the channel UTXOs being queried
1169 pub first_blocknum: u32,
1170 /// The number of blocks to include in the query results
1171 pub number_of_blocks: u32,
1174 /// A [`reply_channel_range`] message is a reply to a [`QueryChannelRange`]
1177 /// Multiple `reply_channel_range` messages can be sent in reply
1178 /// to a single [`QueryChannelRange`] message. The query recipient makes a
1179 /// best effort to respond based on their local network view which may
1180 /// not be a perfect view of the network. The `short_channel_id`s in the
1181 /// reply are encoded. We only support `encoding_type=0` uncompressed
1182 /// serialization and do not support `encoding_type=1` zlib serialization.
1184 /// [`reply_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1185 #[derive(Clone, Debug, PartialEq, Eq)]
1186 pub struct ReplyChannelRange {
1187 /// The genesis hash of the blockchain being queried
1188 pub chain_hash: ChainHash,
1189 /// The height of the first block in the range of the reply
1190 pub first_blocknum: u32,
1191 /// The number of blocks included in the range of the reply
1192 pub number_of_blocks: u32,
1193 /// True when this is the final reply for a query
1194 pub sync_complete: bool,
1195 /// The `short_channel_id`s in the channel range
1196 pub short_channel_ids: Vec<u64>,
1199 /// A [`query_short_channel_ids`] message is used to query a peer for
1200 /// routing gossip messages related to one or more `short_channel_id`s.
1202 /// The query recipient will reply with the latest, if available,
1203 /// [`ChannelAnnouncement`], [`ChannelUpdate`] and [`NodeAnnouncement`] messages
1204 /// it maintains for the requested `short_channel_id`s followed by a
1205 /// [`ReplyShortChannelIdsEnd`] message. The `short_channel_id`s sent in
1206 /// this query are encoded. We only support `encoding_type=0` uncompressed
1207 /// serialization and do not support `encoding_type=1` zlib serialization.
1209 /// [`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
1210 #[derive(Clone, Debug, PartialEq, Eq)]
1211 pub struct QueryShortChannelIds {
1212 /// The genesis hash of the blockchain being queried
1213 pub chain_hash: ChainHash,
1214 /// The short_channel_ids that are being queried
1215 pub short_channel_ids: Vec<u64>,
1218 /// A [`reply_short_channel_ids_end`] message is sent as a reply to a
1219 /// message. The query recipient makes a best
1220 /// effort to respond based on their local network view which may not be
1221 /// a perfect view of the network.
1223 /// [`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
1224 #[derive(Clone, Debug, PartialEq, Eq)]
1225 pub struct ReplyShortChannelIdsEnd {
1226 /// The genesis hash of the blockchain that was queried
1227 pub chain_hash: ChainHash,
1228 /// Indicates if the query recipient maintains up-to-date channel
1229 /// information for the `chain_hash`
1230 pub full_information: bool,
1233 /// A [`gossip_timestamp_filter`] message is used by a node to request
1234 /// gossip relay for messages in the requested time range when the
1235 /// `gossip_queries` feature has been negotiated.
1237 /// [`gossip_timestamp_filter`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-gossip_timestamp_filter-message
1238 #[derive(Clone, Debug, PartialEq, Eq)]
1239 pub struct GossipTimestampFilter {
1240 /// The genesis hash of the blockchain for channel and node information
1241 pub chain_hash: ChainHash,
1242 /// The starting unix timestamp
1243 pub first_timestamp: u32,
1244 /// The range of information in seconds
1245 pub timestamp_range: u32,
1248 /// Encoding type for data compression of collections in gossip queries.
1250 /// We do not support `encoding_type=1` zlib serialization [defined in BOLT
1251 /// #7](https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#query-messages).
1253 Uncompressed = 0x00,
1256 /// Used to put an error message in a [`LightningError`].
1257 #[derive(Clone, Debug, PartialEq)]
1258 pub enum ErrorAction {
1259 /// The peer took some action which made us think they were useless. Disconnect them.
1261 /// An error message which we should make an effort to send before we disconnect.
1262 msg: Option<ErrorMessage>
1264 /// The peer did something incorrect. Tell them without closing any channels and disconnect them.
1265 DisconnectPeerWithWarning {
1266 /// A warning message which we should make an effort to send before we disconnect.
1267 msg: WarningMessage,
1269 /// The peer did something harmless that we weren't able to process, just log and ignore
1270 // New code should *not* use this. New code must use IgnoreAndLog, below!
1272 /// The peer did something harmless that we weren't able to meaningfully process.
1273 /// If the error is logged, log it at the given level.
1274 IgnoreAndLog(logger::Level),
1275 /// The peer provided us with a gossip message which we'd already seen. In most cases this
1276 /// should be ignored, but it may result in the message being forwarded if it is a duplicate of
1277 /// our own channel announcements.
1278 IgnoreDuplicateGossip,
1279 /// The peer did something incorrect. Tell them.
1281 /// The message to send.
1284 /// The peer did something incorrect. Tell them without closing any channels.
1285 SendWarningMessage {
1286 /// The message to send.
1287 msg: WarningMessage,
1288 /// The peer may have done something harmless that we weren't able to meaningfully process,
1289 /// though we should still tell them about it.
1290 /// If this event is logged, log it at the given level.
1291 log_level: logger::Level,
1295 /// An Err type for failure to process messages.
1296 #[derive(Clone, Debug)]
1297 pub struct LightningError {
1298 /// A human-readable message describing the error
1300 /// The action which should be taken against the offending peer.
1301 pub action: ErrorAction,
1304 /// Struct used to return values from [`RevokeAndACK`] messages, containing a bunch of commitment
1305 /// transaction updates if they were pending.
1306 #[derive(Clone, Debug, PartialEq, Eq)]
1307 pub struct CommitmentUpdate {
1308 /// `update_add_htlc` messages which should be sent
1309 pub update_add_htlcs: Vec<UpdateAddHTLC>,
1310 /// `update_fulfill_htlc` messages which should be sent
1311 pub update_fulfill_htlcs: Vec<UpdateFulfillHTLC>,
1312 /// `update_fail_htlc` messages which should be sent
1313 pub update_fail_htlcs: Vec<UpdateFailHTLC>,
1314 /// `update_fail_malformed_htlc` messages which should be sent
1315 pub update_fail_malformed_htlcs: Vec<UpdateFailMalformedHTLC>,
1316 /// An `update_fee` message which should be sent
1317 pub update_fee: Option<UpdateFee>,
1318 /// A `commitment_signed` message which should be sent
1319 pub commitment_signed: CommitmentSigned,
1322 /// A trait to describe an object which can receive channel messages.
1324 /// Messages MAY be called in parallel when they originate from different `their_node_ids`, however
1325 /// they MUST NOT be called in parallel when the two calls have the same `their_node_id`.
1326 pub trait ChannelMessageHandler : MessageSendEventsProvider {
1328 /// Handle an incoming `open_channel` message from the given peer.
1329 fn handle_open_channel(&self, their_node_id: &PublicKey, msg: &OpenChannel);
1330 /// Handle an incoming `open_channel2` message from the given peer.
1331 fn handle_open_channel_v2(&self, their_node_id: &PublicKey, msg: &OpenChannelV2);
1332 /// Handle an incoming `accept_channel` message from the given peer.
1333 fn handle_accept_channel(&self, their_node_id: &PublicKey, msg: &AcceptChannel);
1334 /// Handle an incoming `accept_channel2` message from the given peer.
1335 fn handle_accept_channel_v2(&self, their_node_id: &PublicKey, msg: &AcceptChannelV2);
1336 /// Handle an incoming `funding_created` message from the given peer.
1337 fn handle_funding_created(&self, their_node_id: &PublicKey, msg: &FundingCreated);
1338 /// Handle an incoming `funding_signed` message from the given peer.
1339 fn handle_funding_signed(&self, their_node_id: &PublicKey, msg: &FundingSigned);
1340 /// Handle an incoming `channel_ready` message from the given peer.
1341 fn handle_channel_ready(&self, their_node_id: &PublicKey, msg: &ChannelReady);
1344 /// Handle an incoming `shutdown` message from the given peer.
1345 fn handle_shutdown(&self, their_node_id: &PublicKey, msg: &Shutdown);
1346 /// Handle an incoming `closing_signed` message from the given peer.
1347 fn handle_closing_signed(&self, their_node_id: &PublicKey, msg: &ClosingSigned);
1349 // Interactive channel construction
1350 /// Handle an incoming `tx_add_input message` from the given peer.
1351 fn handle_tx_add_input(&self, their_node_id: &PublicKey, msg: &TxAddInput);
1352 /// Handle an incoming `tx_add_output` message from the given peer.
1353 fn handle_tx_add_output(&self, their_node_id: &PublicKey, msg: &TxAddOutput);
1354 /// Handle an incoming `tx_remove_input` message from the given peer.
1355 fn handle_tx_remove_input(&self, their_node_id: &PublicKey, msg: &TxRemoveInput);
1356 /// Handle an incoming `tx_remove_output` message from the given peer.
1357 fn handle_tx_remove_output(&self, their_node_id: &PublicKey, msg: &TxRemoveOutput);
1358 /// Handle an incoming `tx_complete message` from the given peer.
1359 fn handle_tx_complete(&self, their_node_id: &PublicKey, msg: &TxComplete);
1360 /// Handle an incoming `tx_signatures` message from the given peer.
1361 fn handle_tx_signatures(&self, their_node_id: &PublicKey, msg: &TxSignatures);
1362 /// Handle an incoming `tx_init_rbf` message from the given peer.
1363 fn handle_tx_init_rbf(&self, their_node_id: &PublicKey, msg: &TxInitRbf);
1364 /// Handle an incoming `tx_ack_rbf` message from the given peer.
1365 fn handle_tx_ack_rbf(&self, their_node_id: &PublicKey, msg: &TxAckRbf);
1366 /// Handle an incoming `tx_abort message` from the given peer.
1367 fn handle_tx_abort(&self, their_node_id: &PublicKey, msg: &TxAbort);
1370 /// Handle an incoming `update_add_htlc` message from the given peer.
1371 fn handle_update_add_htlc(&self, their_node_id: &PublicKey, msg: &UpdateAddHTLC);
1372 /// Handle an incoming `update_fulfill_htlc` message from the given peer.
1373 fn handle_update_fulfill_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFulfillHTLC);
1374 /// Handle an incoming `update_fail_htlc` message from the given peer.
1375 fn handle_update_fail_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailHTLC);
1376 /// Handle an incoming `update_fail_malformed_htlc` message from the given peer.
1377 fn handle_update_fail_malformed_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailMalformedHTLC);
1378 /// Handle an incoming `commitment_signed` message from the given peer.
1379 fn handle_commitment_signed(&self, their_node_id: &PublicKey, msg: &CommitmentSigned);
1380 /// Handle an incoming `revoke_and_ack` message from the given peer.
1381 fn handle_revoke_and_ack(&self, their_node_id: &PublicKey, msg: &RevokeAndACK);
1383 /// Handle an incoming `update_fee` message from the given peer.
1384 fn handle_update_fee(&self, their_node_id: &PublicKey, msg: &UpdateFee);
1386 // Channel-to-announce:
1387 /// Handle an incoming `announcement_signatures` message from the given peer.
1388 fn handle_announcement_signatures(&self, their_node_id: &PublicKey, msg: &AnnouncementSignatures);
1390 // Connection loss/reestablish:
1391 /// Indicates a connection to the peer failed/an existing connection was lost.
1392 fn peer_disconnected(&self, their_node_id: &PublicKey);
1394 /// Handle a peer reconnecting, possibly generating `channel_reestablish` message(s).
1396 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1397 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1398 /// message handlers may still wish to communicate with this peer.
1399 fn peer_connected(&self, their_node_id: &PublicKey, msg: &Init, inbound: bool) -> Result<(), ()>;
1400 /// Handle an incoming `channel_reestablish` message from the given peer.
1401 fn handle_channel_reestablish(&self, their_node_id: &PublicKey, msg: &ChannelReestablish);
1403 /// Handle an incoming `channel_update` message from the given peer.
1404 fn handle_channel_update(&self, their_node_id: &PublicKey, msg: &ChannelUpdate);
1407 /// Handle an incoming `error` message from the given peer.
1408 fn handle_error(&self, their_node_id: &PublicKey, msg: &ErrorMessage);
1410 // Handler information:
1411 /// Gets the node feature flags which this handler itself supports. All available handlers are
1412 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1413 /// which are broadcasted in our [`NodeAnnouncement`] message.
1414 fn provided_node_features(&self) -> NodeFeatures;
1416 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1417 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1418 /// which are sent in our [`Init`] message.
1420 /// Note that this method is called before [`Self::peer_connected`].
1421 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1423 /// Gets the chain hashes for this `ChannelMessageHandler` indicating which chains it supports.
1425 /// If it's `None`, then no particular network chain hash compatibility will be enforced when
1426 /// connecting to peers.
1427 fn get_chain_hashes(&self) -> Option<Vec<ChainHash>>;
1430 /// A trait to describe an object which can receive routing messages.
1432 /// # Implementor DoS Warnings
1434 /// For messages enabled with the `gossip_queries` feature there are potential DoS vectors when
1435 /// handling inbound queries. Implementors using an on-disk network graph should be aware of
1436 /// repeated disk I/O for queries accessing different parts of the network graph.
1437 pub trait RoutingMessageHandler : MessageSendEventsProvider {
1438 /// Handle an incoming `node_announcement` message, returning `true` if it should be forwarded on,
1439 /// `false` or returning an `Err` otherwise.
1440 fn handle_node_announcement(&self, msg: &NodeAnnouncement) -> Result<bool, LightningError>;
1441 /// Handle a `channel_announcement` message, returning `true` if it should be forwarded on, `false`
1442 /// or returning an `Err` otherwise.
1443 fn handle_channel_announcement(&self, msg: &ChannelAnnouncement) -> Result<bool, LightningError>;
1444 /// Handle an incoming `channel_update` message, returning true if it should be forwarded on,
1445 /// `false` or returning an `Err` otherwise.
1446 fn handle_channel_update(&self, msg: &ChannelUpdate) -> Result<bool, LightningError>;
1447 /// Gets channel announcements and updates required to dump our routing table to a remote node,
1448 /// starting at the `short_channel_id` indicated by `starting_point` and including announcements
1449 /// for a single channel.
1450 fn get_next_channel_announcement(&self, starting_point: u64) -> Option<(ChannelAnnouncement, Option<ChannelUpdate>, Option<ChannelUpdate>)>;
1451 /// Gets a node announcement required to dump our routing table to a remote node, starting at
1452 /// the node *after* the provided pubkey and including up to one announcement immediately
1453 /// higher (as defined by `<PublicKey as Ord>::cmp`) than `starting_point`.
1454 /// If `None` is provided for `starting_point`, we start at the first node.
1455 fn get_next_node_announcement(&self, starting_point: Option<&NodeId>) -> Option<NodeAnnouncement>;
1456 /// Called when a connection is established with a peer. This can be used to
1457 /// perform routing table synchronization using a strategy defined by the
1460 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1461 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1462 /// message handlers may still wish to communicate with this peer.
1463 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1464 /// Handles the reply of a query we initiated to learn about channels
1465 /// for a given range of blocks. We can expect to receive one or more
1466 /// replies to a single query.
1467 fn handle_reply_channel_range(&self, their_node_id: &PublicKey, msg: ReplyChannelRange) -> Result<(), LightningError>;
1468 /// Handles the reply of a query we initiated asking for routing gossip
1469 /// messages for a list of channels. We should receive this message when
1470 /// a node has completed its best effort to send us the pertaining routing
1471 /// gossip messages.
1472 fn handle_reply_short_channel_ids_end(&self, their_node_id: &PublicKey, msg: ReplyShortChannelIdsEnd) -> Result<(), LightningError>;
1473 /// Handles when a peer asks us to send a list of `short_channel_id`s
1474 /// for the requested range of blocks.
1475 fn handle_query_channel_range(&self, their_node_id: &PublicKey, msg: QueryChannelRange) -> Result<(), LightningError>;
1476 /// Handles when a peer asks us to send routing gossip messages for a
1477 /// list of `short_channel_id`s.
1478 fn handle_query_short_channel_ids(&self, their_node_id: &PublicKey, msg: QueryShortChannelIds) -> Result<(), LightningError>;
1480 // Handler queueing status:
1481 /// Indicates that there are a large number of [`ChannelAnnouncement`] (or other) messages
1482 /// pending some async action. While there is no guarantee of the rate of future messages, the
1483 /// caller should seek to reduce the rate of new gossip messages handled, especially
1484 /// [`ChannelAnnouncement`]s.
1485 fn processing_queue_high(&self) -> bool;
1487 // Handler information:
1488 /// Gets the node feature flags which this handler itself supports. All available handlers are
1489 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1490 /// which are broadcasted in our [`NodeAnnouncement`] message.
1491 fn provided_node_features(&self) -> NodeFeatures;
1492 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1493 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1494 /// which are sent in our [`Init`] message.
1496 /// Note that this method is called before [`Self::peer_connected`].
1497 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1500 /// A handler for received [`OnionMessage`]s and for providing generated ones to send.
1501 pub trait OnionMessageHandler {
1502 /// Handle an incoming `onion_message` message from the given peer.
1503 fn handle_onion_message(&self, peer_node_id: &PublicKey, msg: &OnionMessage);
1505 /// Returns the next pending onion message for the peer with the given node id.
1506 fn next_onion_message_for_peer(&self, peer_node_id: PublicKey) -> Option<OnionMessage>;
1508 /// Called when a connection is established with a peer. Can be used to track which peers
1509 /// advertise onion message support and are online.
1511 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1512 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1513 /// message handlers may still wish to communicate with this peer.
1514 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1516 /// Indicates a connection to the peer failed/an existing connection was lost. Allows handlers to
1517 /// drop and refuse to forward onion messages to this peer.
1518 fn peer_disconnected(&self, their_node_id: &PublicKey);
1520 // Handler information:
1521 /// Gets the node feature flags which this handler itself supports. All available handlers are
1522 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1523 /// which are broadcasted in our [`NodeAnnouncement`] message.
1524 fn provided_node_features(&self) -> NodeFeatures;
1526 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1527 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1528 /// which are sent in our [`Init`] message.
1530 /// Note that this method is called before [`Self::peer_connected`].
1531 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1534 mod fuzzy_internal_msgs {
1535 use bitcoin::secp256k1::PublicKey;
1536 use crate::blinded_path::payment::PaymentConstraints;
1537 use crate::prelude::*;
1538 use crate::ln::{PaymentPreimage, PaymentSecret};
1540 // These types aren't intended to be pub, but are exposed for direct fuzzing (as we deserialize
1541 // them from untrusted input):
1543 pub struct FinalOnionHopData {
1544 pub payment_secret: PaymentSecret,
1545 /// The total value, in msat, of the payment as received by the ultimate recipient.
1546 /// Message serialization may panic if this value is more than 21 million Bitcoin.
1547 pub total_msat: u64,
1550 pub enum InboundOnionPayload {
1552 short_channel_id: u64,
1553 /// The value, in msat, of the payment after this hop's fee is deducted.
1554 amt_to_forward: u64,
1555 outgoing_cltv_value: u32,
1558 payment_data: Option<FinalOnionHopData>,
1559 payment_metadata: Option<Vec<u8>>,
1560 keysend_preimage: Option<PaymentPreimage>,
1561 custom_tlvs: Vec<(u64, Vec<u8>)>,
1563 outgoing_cltv_value: u32,
1568 outgoing_cltv_value: u32,
1569 payment_secret: PaymentSecret,
1570 payment_constraints: PaymentConstraints,
1571 intro_node_blinding_point: PublicKey,
1575 pub(crate) enum OutboundOnionPayload {
1577 short_channel_id: u64,
1578 /// The value, in msat, of the payment after this hop's fee is deducted.
1579 amt_to_forward: u64,
1580 outgoing_cltv_value: u32,
1583 payment_data: Option<FinalOnionHopData>,
1584 payment_metadata: Option<Vec<u8>>,
1585 keysend_preimage: Option<PaymentPreimage>,
1586 custom_tlvs: Vec<(u64, Vec<u8>)>,
1588 outgoing_cltv_value: u32,
1591 encrypted_tlvs: Vec<u8>,
1592 intro_node_blinding_point: Option<PublicKey>,
1597 outgoing_cltv_value: u32,
1598 encrypted_tlvs: Vec<u8>,
1599 intro_node_blinding_point: Option<PublicKey>, // Set if the introduction node of the blinded path is the final node
1603 pub struct DecodedOnionErrorPacket {
1604 pub(crate) hmac: [u8; 32],
1605 pub(crate) failuremsg: Vec<u8>,
1606 pub(crate) pad: Vec<u8>,
1610 pub use self::fuzzy_internal_msgs::*;
1611 #[cfg(not(fuzzing))]
1612 pub(crate) use self::fuzzy_internal_msgs::*;
1615 pub(crate) struct OnionPacket {
1616 pub(crate) version: u8,
1617 /// In order to ensure we always return an error on onion decode in compliance with [BOLT
1618 /// #4](https://github.com/lightning/bolts/blob/master/04-onion-routing.md), we have to
1619 /// deserialize `OnionPacket`s contained in [`UpdateAddHTLC`] messages even if the ephemeral
1620 /// public key (here) is bogus, so we hold a [`Result`] instead of a [`PublicKey`] as we'd
1622 pub(crate) public_key: Result<PublicKey, secp256k1::Error>,
1623 pub(crate) hop_data: [u8; 20*65],
1624 pub(crate) hmac: [u8; 32],
1627 impl onion_utils::Packet for OnionPacket {
1628 type Data = onion_utils::FixedSizeOnionPacket;
1629 fn new(pubkey: PublicKey, hop_data: onion_utils::FixedSizeOnionPacket, hmac: [u8; 32]) -> Self {
1632 public_key: Ok(pubkey),
1633 hop_data: hop_data.0,
1639 impl Eq for OnionPacket { }
1640 impl PartialEq for OnionPacket {
1641 fn eq(&self, other: &OnionPacket) -> bool {
1642 for (i, j) in self.hop_data.iter().zip(other.hop_data.iter()) {
1643 if i != j { return false; }
1645 self.version == other.version &&
1646 self.public_key == other.public_key &&
1647 self.hmac == other.hmac
1651 impl fmt::Debug for OnionPacket {
1652 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1653 f.write_fmt(format_args!("OnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
1657 #[derive(Clone, Debug, PartialEq, Eq)]
1658 pub(crate) struct OnionErrorPacket {
1659 // This really should be a constant size slice, but the spec lets these things be up to 128KB?
1660 // (TODO) We limit it in decode to much lower...
1661 pub(crate) data: Vec<u8>,
1664 impl fmt::Display for DecodeError {
1665 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1667 DecodeError::UnknownVersion => f.write_str("Unknown realm byte in Onion packet"),
1668 DecodeError::UnknownRequiredFeature => f.write_str("Unknown required feature preventing decode"),
1669 DecodeError::InvalidValue => f.write_str("Nonsense bytes didn't map to the type they were interpreted as"),
1670 DecodeError::ShortRead => f.write_str("Packet extended beyond the provided bytes"),
1671 DecodeError::BadLengthDescriptor => f.write_str("A length descriptor in the packet didn't describe the later data correctly"),
1672 DecodeError::Io(ref e) => fmt::Debug::fmt(e, f),
1673 DecodeError::UnsupportedCompression => f.write_str("We don't support receiving messages with zlib-compressed fields"),
1678 impl From<io::Error> for DecodeError {
1679 fn from(e: io::Error) -> Self {
1680 if e.kind() == io::ErrorKind::UnexpectedEof {
1681 DecodeError::ShortRead
1683 DecodeError::Io(e.kind())
1688 #[cfg(not(taproot))]
1689 impl_writeable_msg!(AcceptChannel, {
1690 temporary_channel_id,
1691 dust_limit_satoshis,
1692 max_htlc_value_in_flight_msat,
1693 channel_reserve_satoshis,
1699 revocation_basepoint,
1701 delayed_payment_basepoint,
1703 first_per_commitment_point,
1705 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1706 (1, channel_type, option),
1710 impl_writeable_msg!(AcceptChannel, {
1711 temporary_channel_id,
1712 dust_limit_satoshis,
1713 max_htlc_value_in_flight_msat,
1714 channel_reserve_satoshis,
1720 revocation_basepoint,
1722 delayed_payment_basepoint,
1724 first_per_commitment_point,
1726 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1727 (1, channel_type, option),
1728 (4, next_local_nonce, option),
1731 impl_writeable_msg!(AcceptChannelV2, {
1732 temporary_channel_id,
1734 dust_limit_satoshis,
1735 max_htlc_value_in_flight_msat,
1741 revocation_basepoint,
1743 delayed_payment_basepoint,
1745 first_per_commitment_point,
1746 second_per_commitment_point,
1748 (0, shutdown_scriptpubkey, option),
1749 (1, channel_type, option),
1750 (2, require_confirmed_inputs, option),
1753 impl_writeable_msg!(TxAddInput, {
1761 impl_writeable_msg!(TxAddOutput, {
1768 impl_writeable_msg!(TxRemoveInput, {
1773 impl_writeable_msg!(TxRemoveOutput, {
1778 impl_writeable_msg!(TxComplete, {
1782 impl_writeable_msg!(TxSignatures, {
1788 impl_writeable_msg!(TxInitRbf, {
1791 feerate_sat_per_1000_weight,
1793 (0, funding_output_contribution, option),
1796 impl_writeable_msg!(TxAckRbf, {
1799 (0, funding_output_contribution, option),
1802 impl_writeable_msg!(TxAbort, {
1807 impl_writeable_msg!(AnnouncementSignatures, {
1814 impl_writeable_msg!(ChannelReestablish, {
1816 next_local_commitment_number,
1817 next_remote_commitment_number,
1818 your_last_per_commitment_secret,
1819 my_current_per_commitment_point,
1821 (0, next_funding_txid, option),
1824 impl_writeable_msg!(ClosingSigned,
1825 { channel_id, fee_satoshis, signature },
1826 { (1, fee_range, option) }
1829 impl_writeable!(ClosingSignedFeeRange, {
1834 #[cfg(not(taproot))]
1835 impl_writeable_msg!(CommitmentSigned, {
1842 impl_writeable_msg!(CommitmentSigned, {
1847 (2, partial_signature_with_nonce, option)
1850 impl_writeable!(DecodedOnionErrorPacket, {
1856 #[cfg(not(taproot))]
1857 impl_writeable_msg!(FundingCreated, {
1858 temporary_channel_id,
1860 funding_output_index,
1864 impl_writeable_msg!(FundingCreated, {
1865 temporary_channel_id,
1867 funding_output_index,
1870 (2, partial_signature_with_nonce, option),
1871 (4, next_local_nonce, option)
1874 #[cfg(not(taproot))]
1875 impl_writeable_msg!(FundingSigned, {
1881 impl_writeable_msg!(FundingSigned, {
1885 (2, partial_signature_with_nonce, option)
1888 impl_writeable_msg!(ChannelReady, {
1890 next_per_commitment_point,
1892 (1, short_channel_id_alias, option),
1895 impl Writeable for Init {
1896 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1897 // global_features gets the bottom 13 bits of our features, and local_features gets all of
1898 // our relevant feature bits. This keeps us compatible with old nodes.
1899 self.features.write_up_to_13(w)?;
1900 self.features.write(w)?;
1901 encode_tlv_stream!(w, {
1902 (1, self.networks.as_ref().map(|n| WithoutLength(n)), option),
1903 (3, self.remote_network_address, option),
1909 impl Readable for Init {
1910 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1911 let global_features: InitFeatures = Readable::read(r)?;
1912 let features: InitFeatures = Readable::read(r)?;
1913 let mut remote_network_address: Option<SocketAddress> = None;
1914 let mut networks: Option<WithoutLength<Vec<ChainHash>>> = None;
1915 decode_tlv_stream!(r, {
1916 (1, networks, option),
1917 (3, remote_network_address, option)
1920 features: features | global_features,
1921 networks: networks.map(|n| n.0),
1922 remote_network_address,
1927 impl_writeable_msg!(OpenChannel, {
1929 temporary_channel_id,
1932 dust_limit_satoshis,
1933 max_htlc_value_in_flight_msat,
1934 channel_reserve_satoshis,
1940 revocation_basepoint,
1942 delayed_payment_basepoint,
1944 first_per_commitment_point,
1947 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1948 (1, channel_type, option),
1951 impl_writeable_msg!(OpenChannelV2, {
1953 temporary_channel_id,
1954 funding_feerate_sat_per_1000_weight,
1955 commitment_feerate_sat_per_1000_weight,
1957 dust_limit_satoshis,
1958 max_htlc_value_in_flight_msat,
1964 revocation_basepoint,
1966 delayed_payment_basepoint,
1968 first_per_commitment_point,
1969 second_per_commitment_point,
1972 (0, shutdown_scriptpubkey, option),
1973 (1, channel_type, option),
1974 (2, require_confirmed_inputs, option),
1977 #[cfg(not(taproot))]
1978 impl_writeable_msg!(RevokeAndACK, {
1980 per_commitment_secret,
1981 next_per_commitment_point
1985 impl_writeable_msg!(RevokeAndACK, {
1987 per_commitment_secret,
1988 next_per_commitment_point
1990 (4, next_local_nonce, option)
1993 impl_writeable_msg!(Shutdown, {
1998 impl_writeable_msg!(UpdateFailHTLC, {
2004 impl_writeable_msg!(UpdateFailMalformedHTLC, {
2011 impl_writeable_msg!(UpdateFee, {
2016 impl_writeable_msg!(UpdateFulfillHTLC, {
2022 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2023 // serialization format in a way which assumes we know the total serialized length/message end
2025 impl_writeable!(OnionErrorPacket, {
2029 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2030 // serialization format in a way which assumes we know the total serialized length/message end
2032 impl Writeable for OnionPacket {
2033 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2034 self.version.write(w)?;
2035 match self.public_key {
2036 Ok(pubkey) => pubkey.write(w)?,
2037 Err(_) => [0u8;33].write(w)?,
2039 w.write_all(&self.hop_data)?;
2040 self.hmac.write(w)?;
2045 impl Readable for OnionPacket {
2046 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2048 version: Readable::read(r)?,
2050 let mut buf = [0u8;33];
2051 r.read_exact(&mut buf)?;
2052 PublicKey::from_slice(&buf)
2054 hop_data: Readable::read(r)?,
2055 hmac: Readable::read(r)?,
2060 impl_writeable_msg!(UpdateAddHTLC, {
2066 onion_routing_packet,
2068 (65537, skimmed_fee_msat, option)
2071 impl Readable for OnionMessage {
2072 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2073 let blinding_point: PublicKey = Readable::read(r)?;
2074 let len: u16 = Readable::read(r)?;
2075 let mut packet_reader = FixedLengthReader::new(r, len as u64);
2076 let onion_routing_packet: onion_message::Packet = <onion_message::Packet as LengthReadable>::read(&mut packet_reader)?;
2079 onion_routing_packet,
2084 impl Writeable for OnionMessage {
2085 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2086 self.blinding_point.write(w)?;
2087 let onion_packet_len = self.onion_routing_packet.serialized_length();
2088 (onion_packet_len as u16).write(w)?;
2089 self.onion_routing_packet.write(w)?;
2094 impl Writeable for FinalOnionHopData {
2095 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2096 self.payment_secret.0.write(w)?;
2097 HighZeroBytesDroppedBigSize(self.total_msat).write(w)
2101 impl Readable for FinalOnionHopData {
2102 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2103 let secret: [u8; 32] = Readable::read(r)?;
2104 let amt: HighZeroBytesDroppedBigSize<u64> = Readable::read(r)?;
2105 Ok(Self { payment_secret: PaymentSecret(secret), total_msat: amt.0 })
2109 impl Writeable for OutboundOnionPayload {
2110 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2112 Self::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } => {
2113 _encode_varint_length_prefixed_tlv!(w, {
2114 (2, HighZeroBytesDroppedBigSize(*amt_to_forward), required),
2115 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2116 (6, short_channel_id, required)
2120 ref payment_data, ref payment_metadata, ref keysend_preimage, amt_msat,
2121 outgoing_cltv_value, ref custom_tlvs,
2123 // We need to update [`ln::outbound_payment::RecipientOnionFields::with_custom_tlvs`]
2124 // to reject any reserved types in the experimental range if new ones are ever
2126 let keysend_tlv = keysend_preimage.map(|preimage| (5482373484, preimage.encode()));
2127 let mut custom_tlvs: Vec<&(u64, Vec<u8>)> = custom_tlvs.iter().chain(keysend_tlv.iter()).collect();
2128 custom_tlvs.sort_unstable_by_key(|(typ, _)| *typ);
2129 _encode_varint_length_prefixed_tlv!(w, {
2130 (2, HighZeroBytesDroppedBigSize(*amt_msat), required),
2131 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2132 (8, payment_data, option),
2133 (16, payment_metadata.as_ref().map(|m| WithoutLength(m)), option)
2134 }, custom_tlvs.iter());
2136 Self::BlindedForward { encrypted_tlvs, intro_node_blinding_point } => {
2137 _encode_varint_length_prefixed_tlv!(w, {
2138 (10, *encrypted_tlvs, required_vec),
2139 (12, intro_node_blinding_point, option)
2142 Self::BlindedReceive {
2143 amt_msat, total_msat, outgoing_cltv_value, encrypted_tlvs,
2144 intro_node_blinding_point,
2146 _encode_varint_length_prefixed_tlv!(w, {
2147 (2, HighZeroBytesDroppedBigSize(*amt_msat), required),
2148 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2149 (10, *encrypted_tlvs, required_vec),
2150 (12, intro_node_blinding_point, option),
2151 (18, HighZeroBytesDroppedBigSize(*total_msat), required)
2159 impl<NS: Deref> ReadableArgs<&NS> for InboundOnionPayload where NS::Target: NodeSigner {
2160 fn read<R: Read>(r: &mut R, node_signer: &NS) -> Result<Self, DecodeError> {
2162 let mut cltv_value = None;
2163 let mut short_id: Option<u64> = None;
2164 let mut payment_data: Option<FinalOnionHopData> = None;
2165 let mut encrypted_tlvs_opt: Option<WithoutLength<Vec<u8>>> = None;
2166 let mut intro_node_blinding_point = None;
2167 let mut payment_metadata: Option<WithoutLength<Vec<u8>>> = None;
2168 let mut total_msat = None;
2169 let mut keysend_preimage: Option<PaymentPreimage> = None;
2170 let mut custom_tlvs = Vec::new();
2172 let tlv_len = BigSize::read(r)?;
2173 let rd = FixedLengthReader::new(r, tlv_len.0);
2174 decode_tlv_stream_with_custom_tlv_decode!(rd, {
2175 (2, amt, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2176 (4, cltv_value, (option, encoding: (u32, HighZeroBytesDroppedBigSize))),
2177 (6, short_id, option),
2178 (8, payment_data, option),
2179 (10, encrypted_tlvs_opt, option),
2180 (12, intro_node_blinding_point, option),
2181 (16, payment_metadata, option),
2182 (18, total_msat, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2183 // See https://github.com/lightning/blips/blob/master/blip-0003.md
2184 (5482373484, keysend_preimage, option)
2185 }, |msg_type: u64, msg_reader: &mut FixedLengthReader<_>| -> Result<bool, DecodeError> {
2186 if msg_type < 1 << 16 { return Ok(false) }
2187 let mut value = Vec::new();
2188 msg_reader.read_to_end(&mut value)?;
2189 custom_tlvs.push((msg_type, value));
2193 if amt.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2195 if let Some(blinding_point) = intro_node_blinding_point {
2196 if short_id.is_some() || payment_data.is_some() || payment_metadata.is_some() {
2197 return Err(DecodeError::InvalidValue)
2199 let enc_tlvs = encrypted_tlvs_opt.ok_or(DecodeError::InvalidValue)?.0;
2200 let enc_tlvs_ss = node_signer.ecdh(Recipient::Node, &blinding_point, None)
2201 .map_err(|_| DecodeError::InvalidValue)?;
2202 let rho = onion_utils::gen_rho_from_shared_secret(&enc_tlvs_ss.secret_bytes());
2203 let mut s = Cursor::new(&enc_tlvs);
2204 let mut reader = FixedLengthReader::new(&mut s, enc_tlvs.len() as u64);
2205 match ChaChaPolyReadAdapter::read(&mut reader, rho)? {
2206 ChaChaPolyReadAdapter { readable: ReceiveTlvs { payment_secret, payment_constraints }} => {
2207 if total_msat.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2208 Ok(Self::BlindedReceive {
2209 amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2210 total_msat: total_msat.ok_or(DecodeError::InvalidValue)?,
2211 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2213 payment_constraints,
2214 intro_node_blinding_point: blinding_point,
2218 } else if let Some(short_channel_id) = short_id {
2219 if payment_data.is_some() || payment_metadata.is_some() || encrypted_tlvs_opt.is_some() ||
2220 total_msat.is_some()
2221 { return Err(DecodeError::InvalidValue) }
2224 amt_to_forward: amt.ok_or(DecodeError::InvalidValue)?,
2225 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2228 if encrypted_tlvs_opt.is_some() || total_msat.is_some() {
2229 return Err(DecodeError::InvalidValue)
2231 if let Some(data) = &payment_data {
2232 if data.total_msat > MAX_VALUE_MSAT {
2233 return Err(DecodeError::InvalidValue);
2238 payment_metadata: payment_metadata.map(|w| w.0),
2240 amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2241 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2248 impl Writeable for Ping {
2249 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2250 self.ponglen.write(w)?;
2251 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2256 impl Readable for Ping {
2257 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2259 ponglen: Readable::read(r)?,
2261 let byteslen = Readable::read(r)?;
2262 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2269 impl Writeable for Pong {
2270 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2271 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2276 impl Readable for Pong {
2277 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2280 let byteslen = Readable::read(r)?;
2281 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2288 impl Writeable for UnsignedChannelAnnouncement {
2289 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2290 self.features.write(w)?;
2291 self.chain_hash.write(w)?;
2292 self.short_channel_id.write(w)?;
2293 self.node_id_1.write(w)?;
2294 self.node_id_2.write(w)?;
2295 self.bitcoin_key_1.write(w)?;
2296 self.bitcoin_key_2.write(w)?;
2297 w.write_all(&self.excess_data[..])?;
2302 impl Readable for UnsignedChannelAnnouncement {
2303 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2305 features: Readable::read(r)?,
2306 chain_hash: Readable::read(r)?,
2307 short_channel_id: Readable::read(r)?,
2308 node_id_1: Readable::read(r)?,
2309 node_id_2: Readable::read(r)?,
2310 bitcoin_key_1: Readable::read(r)?,
2311 bitcoin_key_2: Readable::read(r)?,
2312 excess_data: read_to_end(r)?,
2317 impl_writeable!(ChannelAnnouncement, {
2320 bitcoin_signature_1,
2321 bitcoin_signature_2,
2325 impl Writeable for UnsignedChannelUpdate {
2326 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2327 // `message_flags` used to indicate presence of `htlc_maximum_msat`, but was deprecated in the spec.
2328 const MESSAGE_FLAGS: u8 = 1;
2329 self.chain_hash.write(w)?;
2330 self.short_channel_id.write(w)?;
2331 self.timestamp.write(w)?;
2332 let all_flags = self.flags as u16 | ((MESSAGE_FLAGS as u16) << 8);
2333 all_flags.write(w)?;
2334 self.cltv_expiry_delta.write(w)?;
2335 self.htlc_minimum_msat.write(w)?;
2336 self.fee_base_msat.write(w)?;
2337 self.fee_proportional_millionths.write(w)?;
2338 self.htlc_maximum_msat.write(w)?;
2339 w.write_all(&self.excess_data[..])?;
2344 impl Readable for UnsignedChannelUpdate {
2345 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2347 chain_hash: Readable::read(r)?,
2348 short_channel_id: Readable::read(r)?,
2349 timestamp: Readable::read(r)?,
2351 let flags: u16 = Readable::read(r)?;
2352 // Note: we ignore the `message_flags` for now, since it was deprecated by the spec.
2355 cltv_expiry_delta: Readable::read(r)?,
2356 htlc_minimum_msat: Readable::read(r)?,
2357 fee_base_msat: Readable::read(r)?,
2358 fee_proportional_millionths: Readable::read(r)?,
2359 htlc_maximum_msat: Readable::read(r)?,
2360 excess_data: read_to_end(r)?,
2365 impl_writeable!(ChannelUpdate, {
2370 impl Writeable for ErrorMessage {
2371 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2372 self.channel_id.write(w)?;
2373 (self.data.len() as u16).write(w)?;
2374 w.write_all(self.data.as_bytes())?;
2379 impl Readable for ErrorMessage {
2380 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2382 channel_id: Readable::read(r)?,
2384 let sz: usize = <u16 as Readable>::read(r)? as usize;
2385 let mut data = Vec::with_capacity(sz);
2387 r.read_exact(&mut data)?;
2388 match String::from_utf8(data) {
2390 Err(_) => return Err(DecodeError::InvalidValue),
2397 impl Writeable for WarningMessage {
2398 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2399 self.channel_id.write(w)?;
2400 (self.data.len() as u16).write(w)?;
2401 w.write_all(self.data.as_bytes())?;
2406 impl Readable for WarningMessage {
2407 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2409 channel_id: Readable::read(r)?,
2411 let sz: usize = <u16 as Readable>::read(r)? as usize;
2412 let mut data = Vec::with_capacity(sz);
2414 r.read_exact(&mut data)?;
2415 match String::from_utf8(data) {
2417 Err(_) => return Err(DecodeError::InvalidValue),
2424 impl Writeable for UnsignedNodeAnnouncement {
2425 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2426 self.features.write(w)?;
2427 self.timestamp.write(w)?;
2428 self.node_id.write(w)?;
2429 w.write_all(&self.rgb)?;
2430 self.alias.write(w)?;
2432 let mut addr_len = 0;
2433 for addr in self.addresses.iter() {
2434 addr_len += 1 + addr.len();
2436 (addr_len + self.excess_address_data.len() as u16).write(w)?;
2437 for addr in self.addresses.iter() {
2440 w.write_all(&self.excess_address_data[..])?;
2441 w.write_all(&self.excess_data[..])?;
2446 impl Readable for UnsignedNodeAnnouncement {
2447 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2448 let features: NodeFeatures = Readable::read(r)?;
2449 let timestamp: u32 = Readable::read(r)?;
2450 let node_id: NodeId = Readable::read(r)?;
2451 let mut rgb = [0; 3];
2452 r.read_exact(&mut rgb)?;
2453 let alias: NodeAlias = Readable::read(r)?;
2455 let addr_len: u16 = Readable::read(r)?;
2456 let mut addresses: Vec<SocketAddress> = Vec::new();
2457 let mut addr_readpos = 0;
2458 let mut excess = false;
2459 let mut excess_byte = 0;
2461 if addr_len <= addr_readpos { break; }
2462 match Readable::read(r) {
2464 if addr_len < addr_readpos + 1 + addr.len() {
2465 return Err(DecodeError::BadLengthDescriptor);
2467 addr_readpos += (1 + addr.len()) as u16;
2468 addresses.push(addr);
2470 Ok(Err(unknown_descriptor)) => {
2472 excess_byte = unknown_descriptor;
2475 Err(DecodeError::ShortRead) => return Err(DecodeError::BadLengthDescriptor),
2476 Err(e) => return Err(e),
2480 let mut excess_data = vec![];
2481 let excess_address_data = if addr_readpos < addr_len {
2482 let mut excess_address_data = vec![0; (addr_len - addr_readpos) as usize];
2483 r.read_exact(&mut excess_address_data[if excess { 1 } else { 0 }..])?;
2485 excess_address_data[0] = excess_byte;
2490 excess_data.push(excess_byte);
2494 excess_data.extend(read_to_end(r)?.iter());
2495 Ok(UnsignedNodeAnnouncement {
2502 excess_address_data,
2508 impl_writeable!(NodeAnnouncement, {
2513 impl Readable for QueryShortChannelIds {
2514 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2515 let chain_hash: ChainHash = Readable::read(r)?;
2517 let encoding_len: u16 = Readable::read(r)?;
2518 let encoding_type: u8 = Readable::read(r)?;
2520 // Must be encoding_type=0 uncompressed serialization. We do not
2521 // support encoding_type=1 zlib serialization.
2522 if encoding_type != EncodingType::Uncompressed as u8 {
2523 return Err(DecodeError::UnsupportedCompression);
2526 // We expect the encoding_len to always includes the 1-byte
2527 // encoding_type and that short_channel_ids are 8-bytes each
2528 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2529 return Err(DecodeError::InvalidValue);
2532 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2533 // less the 1-byte encoding_type
2534 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2535 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2536 for _ in 0..short_channel_id_count {
2537 short_channel_ids.push(Readable::read(r)?);
2540 Ok(QueryShortChannelIds {
2547 impl Writeable for QueryShortChannelIds {
2548 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2549 // Calculated from 1-byte encoding_type plus 8-bytes per short_channel_id
2550 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2552 self.chain_hash.write(w)?;
2553 encoding_len.write(w)?;
2555 // We only support type=0 uncompressed serialization
2556 (EncodingType::Uncompressed as u8).write(w)?;
2558 for scid in self.short_channel_ids.iter() {
2566 impl_writeable_msg!(ReplyShortChannelIdsEnd, {
2571 impl QueryChannelRange {
2572 /// Calculates the overflow safe ending block height for the query.
2574 /// Overflow returns `0xffffffff`, otherwise returns `first_blocknum + number_of_blocks`.
2575 pub fn end_blocknum(&self) -> u32 {
2576 match self.first_blocknum.checked_add(self.number_of_blocks) {
2577 Some(block) => block,
2578 None => u32::max_value(),
2583 impl_writeable_msg!(QueryChannelRange, {
2589 impl Readable for ReplyChannelRange {
2590 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2591 let chain_hash: ChainHash = Readable::read(r)?;
2592 let first_blocknum: u32 = Readable::read(r)?;
2593 let number_of_blocks: u32 = Readable::read(r)?;
2594 let sync_complete: bool = Readable::read(r)?;
2596 let encoding_len: u16 = Readable::read(r)?;
2597 let encoding_type: u8 = Readable::read(r)?;
2599 // Must be encoding_type=0 uncompressed serialization. We do not
2600 // support encoding_type=1 zlib serialization.
2601 if encoding_type != EncodingType::Uncompressed as u8 {
2602 return Err(DecodeError::UnsupportedCompression);
2605 // We expect the encoding_len to always includes the 1-byte
2606 // encoding_type and that short_channel_ids are 8-bytes each
2607 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2608 return Err(DecodeError::InvalidValue);
2611 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2612 // less the 1-byte encoding_type
2613 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2614 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2615 for _ in 0..short_channel_id_count {
2616 short_channel_ids.push(Readable::read(r)?);
2619 Ok(ReplyChannelRange {
2629 impl Writeable for ReplyChannelRange {
2630 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2631 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2632 self.chain_hash.write(w)?;
2633 self.first_blocknum.write(w)?;
2634 self.number_of_blocks.write(w)?;
2635 self.sync_complete.write(w)?;
2637 encoding_len.write(w)?;
2638 (EncodingType::Uncompressed as u8).write(w)?;
2639 for scid in self.short_channel_ids.iter() {
2647 impl_writeable_msg!(GossipTimestampFilter, {
2655 use std::convert::TryFrom;
2656 use bitcoin::{Transaction, PackedLockTime, TxIn, Script, Sequence, Witness, TxOut};
2658 use crate::ln::{PaymentPreimage, PaymentHash, PaymentSecret};
2659 use crate::ln::ChannelId;
2660 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
2661 use crate::ln::msgs::{self, FinalOnionHopData, OnionErrorPacket};
2662 use crate::ln::msgs::SocketAddress;
2663 use crate::routing::gossip::{NodeAlias, NodeId};
2664 use crate::util::ser::{Writeable, Readable, ReadableArgs, Hostname, TransactionU16LenLimited};
2665 use crate::util::test_utils;
2667 use bitcoin::hashes::hex::FromHex;
2668 use bitcoin::util::address::Address;
2669 use bitcoin::network::constants::Network;
2670 use bitcoin::blockdata::constants::ChainHash;
2671 use bitcoin::blockdata::script::Builder;
2672 use bitcoin::blockdata::opcodes;
2673 use bitcoin::hash_types::Txid;
2675 use bitcoin::secp256k1::{PublicKey,SecretKey};
2676 use bitcoin::secp256k1::{Secp256k1, Message};
2678 use crate::io::{self, Cursor};
2679 use crate::prelude::*;
2680 use core::str::FromStr;
2681 use crate::chain::transaction::OutPoint;
2683 #[cfg(feature = "std")]
2684 use std::net::{Ipv4Addr, Ipv6Addr};
2685 use crate::ln::msgs::SocketAddressParseError;
2688 fn encoding_channel_reestablish() {
2690 let secp_ctx = Secp256k1::new();
2691 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2694 let cr = msgs::ChannelReestablish {
2695 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]),
2696 next_local_commitment_number: 3,
2697 next_remote_commitment_number: 4,
2698 your_last_per_commitment_secret: [9;32],
2699 my_current_per_commitment_point: public_key,
2700 next_funding_txid: None,
2703 let encoded_value = cr.encode();
2707 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
2708 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2709 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2710 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
2711 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
2717 fn encoding_channel_reestablish_with_next_funding_txid() {
2719 let secp_ctx = Secp256k1::new();
2720 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2723 let cr = msgs::ChannelReestablish {
2724 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]),
2725 next_local_commitment_number: 3,
2726 next_remote_commitment_number: 4,
2727 your_last_per_commitment_secret: [9;32],
2728 my_current_per_commitment_point: public_key,
2729 next_funding_txid: Some(Txid::from_hash(bitcoin::hashes::Hash::from_slice(&[
2730 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,
2734 let encoded_value = cr.encode();
2738 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
2739 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2740 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2741 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
2742 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
2743 0, // Type (next_funding_txid)
2745 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
2750 macro_rules! get_keys_from {
2751 ($slice: expr, $secp_ctx: expr) => {
2753 let privkey = SecretKey::from_slice(&hex::decode($slice).unwrap()[..]).unwrap();
2754 let pubkey = PublicKey::from_secret_key(&$secp_ctx, &privkey);
2760 macro_rules! get_sig_on {
2761 ($privkey: expr, $ctx: expr, $string: expr) => {
2763 let sighash = Message::from_slice(&$string.into_bytes()[..]).unwrap();
2764 $ctx.sign_ecdsa(&sighash, &$privkey)
2770 fn encoding_announcement_signatures() {
2771 let secp_ctx = Secp256k1::new();
2772 let (privkey, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2773 let sig_1 = get_sig_on!(privkey, secp_ctx, String::from("01010101010101010101010101010101"));
2774 let sig_2 = get_sig_on!(privkey, secp_ctx, String::from("02020202020202020202020202020202"));
2775 let announcement_signatures = msgs::AnnouncementSignatures {
2776 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]),
2777 short_channel_id: 2316138423780173,
2778 node_signature: sig_1,
2779 bitcoin_signature: sig_2,
2782 let encoded_value = announcement_signatures.encode();
2783 assert_eq!(encoded_value, hex::decode("040000000000000005000000000000000600000000000000070000000000000000083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073acf9953cef4700860f5967838eba2bae89288ad188ebf8b20bf995c3ea53a26df1876d0a3a0e13172ba286a673140190c02ba9da60a2e43a745188c8a83c7f3ef").unwrap());
2786 fn do_encoding_channel_announcement(unknown_features_bits: bool, excess_data: bool) {
2787 let secp_ctx = Secp256k1::new();
2788 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2789 let (privkey_2, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2790 let (privkey_3, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2791 let (privkey_4, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2792 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2793 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
2794 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
2795 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
2796 let mut features = ChannelFeatures::empty();
2797 if unknown_features_bits {
2798 features = ChannelFeatures::from_le_bytes(vec![0xFF, 0xFF]);
2800 let unsigned_channel_announcement = msgs::UnsignedChannelAnnouncement {
2802 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
2803 short_channel_id: 2316138423780173,
2804 node_id_1: NodeId::from_pubkey(&pubkey_1),
2805 node_id_2: NodeId::from_pubkey(&pubkey_2),
2806 bitcoin_key_1: NodeId::from_pubkey(&pubkey_3),
2807 bitcoin_key_2: NodeId::from_pubkey(&pubkey_4),
2808 excess_data: if excess_data { vec![10, 0, 0, 20, 0, 0, 30, 0, 0, 40] } else { Vec::new() },
2810 let channel_announcement = msgs::ChannelAnnouncement {
2811 node_signature_1: sig_1,
2812 node_signature_2: sig_2,
2813 bitcoin_signature_1: sig_3,
2814 bitcoin_signature_2: sig_4,
2815 contents: unsigned_channel_announcement,
2817 let encoded_value = channel_announcement.encode();
2818 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a1735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap();
2819 if unknown_features_bits {
2820 target_value.append(&mut hex::decode("0002ffff").unwrap());
2822 target_value.append(&mut hex::decode("0000").unwrap());
2824 target_value.append(&mut hex::decode("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
2825 target_value.append(&mut hex::decode("00083a840000034d031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
2827 target_value.append(&mut hex::decode("0a00001400001e000028").unwrap());
2829 assert_eq!(encoded_value, target_value);
2833 fn encoding_channel_announcement() {
2834 do_encoding_channel_announcement(true, false);
2835 do_encoding_channel_announcement(false, true);
2836 do_encoding_channel_announcement(false, false);
2837 do_encoding_channel_announcement(true, true);
2840 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) {
2841 let secp_ctx = Secp256k1::new();
2842 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2843 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2844 let features = if unknown_features_bits {
2845 NodeFeatures::from_le_bytes(vec![0xFF, 0xFF])
2847 // Set to some features we may support
2848 NodeFeatures::from_le_bytes(vec![2 | 1 << 5])
2850 let mut addresses = Vec::new();
2852 addresses.push(SocketAddress::TcpIpV4 {
2853 addr: [255, 254, 253, 252],
2858 addresses.push(SocketAddress::TcpIpV6 {
2859 addr: [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240],
2864 addresses.push(msgs::SocketAddress::OnionV2(
2865 [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 38, 7]
2869 addresses.push(msgs::SocketAddress::OnionV3 {
2870 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],
2877 addresses.push(SocketAddress::Hostname {
2878 hostname: Hostname::try_from(String::from("host")).unwrap(),
2882 let mut addr_len = 0;
2883 for addr in &addresses {
2884 addr_len += addr.len() + 1;
2886 let unsigned_node_announcement = msgs::UnsignedNodeAnnouncement {
2888 timestamp: 20190119,
2889 node_id: NodeId::from_pubkey(&pubkey_1),
2891 alias: NodeAlias([16;32]),
2893 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() },
2894 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() },
2896 addr_len += unsigned_node_announcement.excess_address_data.len() as u16;
2897 let node_announcement = msgs::NodeAnnouncement {
2899 contents: unsigned_node_announcement,
2901 let encoded_value = node_announcement.encode();
2902 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
2903 if unknown_features_bits {
2904 target_value.append(&mut hex::decode("0002ffff").unwrap());
2906 target_value.append(&mut hex::decode("000122").unwrap());
2908 target_value.append(&mut hex::decode("013413a7031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f2020201010101010101010101010101010101010101010101010101010101010101010").unwrap());
2909 target_value.append(&mut vec![(addr_len >> 8) as u8, addr_len as u8]);
2911 target_value.append(&mut hex::decode("01fffefdfc2607").unwrap());
2914 target_value.append(&mut hex::decode("02fffefdfcfbfaf9f8f7f6f5f4f3f2f1f02607").unwrap());
2917 target_value.append(&mut hex::decode("03fffefdfcfbfaf9f8f7f62607").unwrap());
2920 target_value.append(&mut hex::decode("04fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0efeeedecebeae9e8e7e6e5e4e3e2e1e00020102607").unwrap());
2923 target_value.append(&mut hex::decode("0504686f73742607").unwrap());
2925 if excess_address_data {
2926 target_value.append(&mut hex::decode("216c280b5395a2546e7e4b2663e04f811622f15a4f92e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d269").unwrap());
2929 target_value.append(&mut hex::decode("3b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
2931 assert_eq!(encoded_value, target_value);
2935 fn encoding_node_announcement() {
2936 do_encoding_node_announcement(true, true, true, true, true, true, true, true);
2937 do_encoding_node_announcement(false, false, false, false, false, false, false, false);
2938 do_encoding_node_announcement(false, true, false, false, false, false, false, false);
2939 do_encoding_node_announcement(false, false, true, false, false, false, false, false);
2940 do_encoding_node_announcement(false, false, false, true, false, false, false, false);
2941 do_encoding_node_announcement(false, false, false, false, true, false, false, false);
2942 do_encoding_node_announcement(false, false, false, false, false, true, false, false);
2943 do_encoding_node_announcement(false, false, false, false, false, false, true, false);
2944 do_encoding_node_announcement(false, true, false, true, false, false, true, false);
2945 do_encoding_node_announcement(false, false, true, false, true, false, false, false);
2948 fn do_encoding_channel_update(direction: bool, disable: bool, excess_data: bool) {
2949 let secp_ctx = Secp256k1::new();
2950 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2951 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2952 let unsigned_channel_update = msgs::UnsignedChannelUpdate {
2953 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
2954 short_channel_id: 2316138423780173,
2955 timestamp: 20190119,
2956 flags: if direction { 1 } else { 0 } | if disable { 1 << 1 } else { 0 },
2957 cltv_expiry_delta: 144,
2958 htlc_minimum_msat: 1000000,
2959 htlc_maximum_msat: 131355275467161,
2960 fee_base_msat: 10000,
2961 fee_proportional_millionths: 20,
2962 excess_data: if excess_data { vec![0, 0, 0, 0, 59, 154, 202, 0] } else { Vec::new() }
2964 let channel_update = msgs::ChannelUpdate {
2966 contents: unsigned_channel_update
2968 let encoded_value = channel_update.encode();
2969 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
2970 target_value.append(&mut hex::decode("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
2971 target_value.append(&mut hex::decode("00083a840000034d013413a7").unwrap());
2972 target_value.append(&mut hex::decode("01").unwrap());
2973 target_value.append(&mut hex::decode("00").unwrap());
2975 let flag = target_value.last_mut().unwrap();
2979 let flag = target_value.last_mut().unwrap();
2980 *flag = *flag | 1 << 1;
2982 target_value.append(&mut hex::decode("009000000000000f42400000271000000014").unwrap());
2983 target_value.append(&mut hex::decode("0000777788889999").unwrap());
2985 target_value.append(&mut hex::decode("000000003b9aca00").unwrap());
2987 assert_eq!(encoded_value, target_value);
2991 fn encoding_channel_update() {
2992 do_encoding_channel_update(false, false, false);
2993 do_encoding_channel_update(false, false, true);
2994 do_encoding_channel_update(true, false, false);
2995 do_encoding_channel_update(true, false, true);
2996 do_encoding_channel_update(false, true, false);
2997 do_encoding_channel_update(false, true, true);
2998 do_encoding_channel_update(true, true, false);
2999 do_encoding_channel_update(true, true, true);
3002 fn do_encoding_open_channel(random_bit: bool, shutdown: bool, incl_chan_type: bool) {
3003 let secp_ctx = Secp256k1::new();
3004 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3005 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3006 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3007 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3008 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3009 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3010 let open_channel = msgs::OpenChannel {
3011 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3012 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3013 funding_satoshis: 1311768467284833366,
3014 push_msat: 2536655962884945560,
3015 dust_limit_satoshis: 3608586615801332854,
3016 max_htlc_value_in_flight_msat: 8517154655701053848,
3017 channel_reserve_satoshis: 8665828695742877976,
3018 htlc_minimum_msat: 2316138423780173,
3019 feerate_per_kw: 821716,
3020 to_self_delay: 49340,
3021 max_accepted_htlcs: 49340,
3022 funding_pubkey: pubkey_1,
3023 revocation_basepoint: pubkey_2,
3024 payment_point: pubkey_3,
3025 delayed_payment_basepoint: pubkey_4,
3026 htlc_basepoint: pubkey_5,
3027 first_per_commitment_point: pubkey_6,
3028 channel_flags: if random_bit { 1 << 5 } else { 0 },
3029 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3030 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3032 let encoded_value = open_channel.encode();
3033 let mut target_value = Vec::new();
3034 target_value.append(&mut hex::decode("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3035 target_value.append(&mut hex::decode("02020202020202020202020202020202020202020202020202020202020202021234567890123456233403289122369832144668701144767633030896203198784335490624111800083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3037 target_value.append(&mut hex::decode("20").unwrap());
3039 target_value.append(&mut hex::decode("00").unwrap());
3042 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3045 target_value.append(&mut hex::decode("0100").unwrap());
3047 assert_eq!(encoded_value, target_value);
3051 fn encoding_open_channel() {
3052 do_encoding_open_channel(false, false, false);
3053 do_encoding_open_channel(false, false, true);
3054 do_encoding_open_channel(false, true, false);
3055 do_encoding_open_channel(false, true, true);
3056 do_encoding_open_channel(true, false, false);
3057 do_encoding_open_channel(true, false, true);
3058 do_encoding_open_channel(true, true, false);
3059 do_encoding_open_channel(true, true, true);
3062 fn do_encoding_open_channelv2(random_bit: bool, shutdown: bool, incl_chan_type: bool, require_confirmed_inputs: bool) {
3063 let secp_ctx = Secp256k1::new();
3064 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3065 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3066 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3067 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3068 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3069 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3070 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3071 let open_channelv2 = msgs::OpenChannelV2 {
3072 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3073 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3074 funding_feerate_sat_per_1000_weight: 821716,
3075 commitment_feerate_sat_per_1000_weight: 821716,
3076 funding_satoshis: 1311768467284833366,
3077 dust_limit_satoshis: 3608586615801332854,
3078 max_htlc_value_in_flight_msat: 8517154655701053848,
3079 htlc_minimum_msat: 2316138423780173,
3080 to_self_delay: 49340,
3081 max_accepted_htlcs: 49340,
3082 locktime: 305419896,
3083 funding_pubkey: pubkey_1,
3084 revocation_basepoint: pubkey_2,
3085 payment_basepoint: pubkey_3,
3086 delayed_payment_basepoint: pubkey_4,
3087 htlc_basepoint: pubkey_5,
3088 first_per_commitment_point: pubkey_6,
3089 second_per_commitment_point: pubkey_7,
3090 channel_flags: if random_bit { 1 << 5 } else { 0 },
3091 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3092 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3093 require_confirmed_inputs: if require_confirmed_inputs { Some(()) } else { None },
3095 let encoded_value = open_channelv2.encode();
3096 let mut target_value = Vec::new();
3097 target_value.append(&mut hex::decode("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3098 target_value.append(&mut hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap());
3099 target_value.append(&mut hex::decode("000c89d4").unwrap());
3100 target_value.append(&mut hex::decode("000c89d4").unwrap());
3101 target_value.append(&mut hex::decode("1234567890123456").unwrap());
3102 target_value.append(&mut hex::decode("3214466870114476").unwrap());
3103 target_value.append(&mut hex::decode("7633030896203198").unwrap());
3104 target_value.append(&mut hex::decode("00083a840000034d").unwrap());
3105 target_value.append(&mut hex::decode("c0bc").unwrap());
3106 target_value.append(&mut hex::decode("c0bc").unwrap());
3107 target_value.append(&mut hex::decode("12345678").unwrap());
3108 target_value.append(&mut hex::decode("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap());
3109 target_value.append(&mut hex::decode("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap());
3110 target_value.append(&mut hex::decode("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap());
3111 target_value.append(&mut hex::decode("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
3112 target_value.append(&mut hex::decode("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap());
3113 target_value.append(&mut hex::decode("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3114 target_value.append(&mut hex::decode("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap());
3117 target_value.append(&mut hex::decode("20").unwrap());
3119 target_value.append(&mut hex::decode("00").unwrap());
3122 target_value.append(&mut hex::decode("001b").unwrap()); // Type 0 + Length 27
3123 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3126 target_value.append(&mut hex::decode("0100").unwrap());
3128 if require_confirmed_inputs {
3129 target_value.append(&mut hex::decode("0200").unwrap());
3131 assert_eq!(encoded_value, target_value);
3135 fn encoding_open_channelv2() {
3136 do_encoding_open_channelv2(false, false, false, false);
3137 do_encoding_open_channelv2(false, false, false, true);
3138 do_encoding_open_channelv2(false, false, true, false);
3139 do_encoding_open_channelv2(false, false, true, true);
3140 do_encoding_open_channelv2(false, true, false, false);
3141 do_encoding_open_channelv2(false, true, false, true);
3142 do_encoding_open_channelv2(false, true, true, false);
3143 do_encoding_open_channelv2(false, true, true, true);
3144 do_encoding_open_channelv2(true, false, false, false);
3145 do_encoding_open_channelv2(true, false, false, true);
3146 do_encoding_open_channelv2(true, false, true, false);
3147 do_encoding_open_channelv2(true, false, true, true);
3148 do_encoding_open_channelv2(true, true, false, false);
3149 do_encoding_open_channelv2(true, true, false, true);
3150 do_encoding_open_channelv2(true, true, true, false);
3151 do_encoding_open_channelv2(true, true, true, true);
3154 fn do_encoding_accept_channel(shutdown: bool) {
3155 let secp_ctx = Secp256k1::new();
3156 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3157 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3158 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3159 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3160 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3161 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3162 let accept_channel = msgs::AcceptChannel {
3163 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3164 dust_limit_satoshis: 1311768467284833366,
3165 max_htlc_value_in_flight_msat: 2536655962884945560,
3166 channel_reserve_satoshis: 3608586615801332854,
3167 htlc_minimum_msat: 2316138423780173,
3168 minimum_depth: 821716,
3169 to_self_delay: 49340,
3170 max_accepted_htlcs: 49340,
3171 funding_pubkey: pubkey_1,
3172 revocation_basepoint: pubkey_2,
3173 payment_point: pubkey_3,
3174 delayed_payment_basepoint: pubkey_4,
3175 htlc_basepoint: pubkey_5,
3176 first_per_commitment_point: pubkey_6,
3177 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3180 next_local_nonce: None,
3182 let encoded_value = accept_channel.encode();
3183 let mut target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020212345678901234562334032891223698321446687011447600083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap();
3185 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3187 assert_eq!(encoded_value, target_value);
3191 fn encoding_accept_channel() {
3192 do_encoding_accept_channel(false);
3193 do_encoding_accept_channel(true);
3196 fn do_encoding_accept_channelv2(shutdown: bool) {
3197 let secp_ctx = Secp256k1::new();
3198 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3199 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3200 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3201 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3202 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3203 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3204 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3205 let accept_channelv2 = msgs::AcceptChannelV2 {
3206 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3207 funding_satoshis: 1311768467284833366,
3208 dust_limit_satoshis: 1311768467284833366,
3209 max_htlc_value_in_flight_msat: 2536655962884945560,
3210 htlc_minimum_msat: 2316138423780173,
3211 minimum_depth: 821716,
3212 to_self_delay: 49340,
3213 max_accepted_htlcs: 49340,
3214 funding_pubkey: pubkey_1,
3215 revocation_basepoint: pubkey_2,
3216 payment_basepoint: pubkey_3,
3217 delayed_payment_basepoint: pubkey_4,
3218 htlc_basepoint: pubkey_5,
3219 first_per_commitment_point: pubkey_6,
3220 second_per_commitment_point: pubkey_7,
3221 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3223 require_confirmed_inputs: None,
3225 let encoded_value = accept_channelv2.encode();
3226 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // temporary_channel_id
3227 target_value.append(&mut hex::decode("1234567890123456").unwrap()); // funding_satoshis
3228 target_value.append(&mut hex::decode("1234567890123456").unwrap()); // dust_limit_satoshis
3229 target_value.append(&mut hex::decode("2334032891223698").unwrap()); // max_htlc_value_in_flight_msat
3230 target_value.append(&mut hex::decode("00083a840000034d").unwrap()); // htlc_minimum_msat
3231 target_value.append(&mut hex::decode("000c89d4").unwrap()); // minimum_depth
3232 target_value.append(&mut hex::decode("c0bc").unwrap()); // to_self_delay
3233 target_value.append(&mut hex::decode("c0bc").unwrap()); // max_accepted_htlcs
3234 target_value.append(&mut hex::decode("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap()); // funding_pubkey
3235 target_value.append(&mut hex::decode("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap()); // revocation_basepoint
3236 target_value.append(&mut hex::decode("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap()); // payment_basepoint
3237 target_value.append(&mut hex::decode("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap()); // delayed_payment_basepoint
3238 target_value.append(&mut hex::decode("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap()); // htlc_basepoint
3239 target_value.append(&mut hex::decode("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap()); // first_per_commitment_point
3240 target_value.append(&mut hex::decode("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap()); // second_per_commitment_point
3242 target_value.append(&mut hex::decode("001b").unwrap()); // Type 0 + Length 27
3243 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3245 assert_eq!(encoded_value, target_value);
3249 fn encoding_accept_channelv2() {
3250 do_encoding_accept_channelv2(false);
3251 do_encoding_accept_channelv2(true);
3255 fn encoding_funding_created() {
3256 let secp_ctx = Secp256k1::new();
3257 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3258 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3259 let funding_created = msgs::FundingCreated {
3260 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3261 funding_txid: Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3262 funding_output_index: 255,
3265 partial_signature_with_nonce: None,
3267 next_local_nonce: None,
3269 let encoded_value = funding_created.encode();
3270 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202026e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c200ffd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3271 assert_eq!(encoded_value, target_value);
3275 fn encoding_funding_signed() {
3276 let secp_ctx = Secp256k1::new();
3277 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3278 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3279 let funding_signed = msgs::FundingSigned {
3280 channel_id: ChannelId::from_bytes([2; 32]),
3283 partial_signature_with_nonce: None,
3285 let encoded_value = funding_signed.encode();
3286 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3287 assert_eq!(encoded_value, target_value);
3291 fn encoding_channel_ready() {
3292 let secp_ctx = Secp256k1::new();
3293 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3294 let channel_ready = msgs::ChannelReady {
3295 channel_id: ChannelId::from_bytes([2; 32]),
3296 next_per_commitment_point: pubkey_1,
3297 short_channel_id_alias: None,
3299 let encoded_value = channel_ready.encode();
3300 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3301 assert_eq!(encoded_value, target_value);
3305 fn encoding_tx_add_input() {
3306 let tx_add_input = msgs::TxAddInput {
3307 channel_id: ChannelId::from_bytes([2; 32]),
3308 serial_id: 4886718345,
3309 prevtx: TransactionU16LenLimited::new(Transaction {
3311 lock_time: PackedLockTime(0),
3313 previous_output: OutPoint { txid: Txid::from_hex("305bab643ee297b8b6b76b320792c8223d55082122cb606bf89382146ced9c77").unwrap(), index: 2 }.into_bitcoin_outpoint(),
3314 script_sig: Script::new(),
3315 sequence: Sequence(0xfffffffd),
3316 witness: Witness::from_vec(vec![
3317 hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3318 hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3323 script_pubkey: Address::from_str("bc1qzlffunw52jav8vwdu5x3jfk6sr8u22rmq3xzw2").unwrap().script_pubkey(),
3327 script_pubkey: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().script_pubkey(),
3331 prevtx_out: 305419896,
3332 sequence: 305419896,
3334 let encoded_value = tx_add_input.encode();
3335 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000000012345678900de02000000000101779ced6c148293f86b60cb222108553d22c89207326bb7b6b897e23e64ab5b300200000000fdffffff0236dbc1000000000016001417d29e4dd454bac3b1cde50d1926da80cfc5287b9cbd03000000000016001436ec78d514df462da95e6a00c24daa8915362d420247304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701210301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944000000001234567812345678").unwrap();
3336 assert_eq!(encoded_value, target_value);
3340 fn encoding_tx_add_output() {
3341 let tx_add_output = msgs::TxAddOutput {
3342 channel_id: ChannelId::from_bytes([2; 32]),
3343 serial_id: 4886718345,
3345 script: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().script_pubkey(),
3347 let encoded_value = tx_add_output.encode();
3348 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000000012345678900000001234567890016001436ec78d514df462da95e6a00c24daa8915362d42").unwrap();
3349 assert_eq!(encoded_value, target_value);
3353 fn encoding_tx_remove_input() {
3354 let tx_remove_input = msgs::TxRemoveInput {
3355 channel_id: ChannelId::from_bytes([2; 32]),
3356 serial_id: 4886718345,
3358 let encoded_value = tx_remove_input.encode();
3359 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3360 assert_eq!(encoded_value, target_value);
3364 fn encoding_tx_remove_output() {
3365 let tx_remove_output = msgs::TxRemoveOutput {
3366 channel_id: ChannelId::from_bytes([2; 32]),
3367 serial_id: 4886718345,
3369 let encoded_value = tx_remove_output.encode();
3370 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3371 assert_eq!(encoded_value, target_value);
3375 fn encoding_tx_complete() {
3376 let tx_complete = msgs::TxComplete {
3377 channel_id: ChannelId::from_bytes([2; 32]),
3379 let encoded_value = tx_complete.encode();
3380 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3381 assert_eq!(encoded_value, target_value);
3385 fn encoding_tx_signatures() {
3386 let tx_signatures = msgs::TxSignatures {
3387 channel_id: ChannelId::from_bytes([2; 32]),
3388 tx_hash: Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3390 Witness::from_vec(vec![
3391 hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3392 hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3393 Witness::from_vec(vec![
3394 hex::decode("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap(),
3395 hex::decode("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap()]),
3398 let encoded_value = tx_signatures.encode();
3399 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3400 target_value.append(&mut hex::decode("6e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c2").unwrap()); // tx_hash (sha256) (big endian byte order)
3401 target_value.append(&mut hex::decode("0002").unwrap()); // num_witnesses (u16)
3403 target_value.append(&mut hex::decode("006b").unwrap()); // len of witness_data
3404 target_value.append(&mut hex::decode("02").unwrap()); // num_witness_elements (VarInt)
3405 target_value.append(&mut hex::decode("47").unwrap()); // len of witness element data (VarInt)
3406 target_value.append(&mut hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap());
3407 target_value.append(&mut hex::decode("21").unwrap()); // len of witness element data (VarInt)
3408 target_value.append(&mut hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap());
3410 target_value.append(&mut hex::decode("006c").unwrap()); // len of witness_data
3411 target_value.append(&mut hex::decode("02").unwrap()); // num_witness_elements (VarInt)
3412 target_value.append(&mut hex::decode("48").unwrap()); // len of witness element data (VarInt)
3413 target_value.append(&mut hex::decode("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap());
3414 target_value.append(&mut hex::decode("21").unwrap()); // len of witness element data (VarInt)
3415 target_value.append(&mut hex::decode("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap());
3416 assert_eq!(encoded_value, target_value);
3419 fn do_encoding_tx_init_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3420 let tx_init_rbf = msgs::TxInitRbf {
3421 channel_id: ChannelId::from_bytes([2; 32]),
3422 locktime: 305419896,
3423 feerate_sat_per_1000_weight: 20190119,
3424 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3426 let encoded_value = tx_init_rbf.encode();
3427 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3428 target_value.append(&mut hex::decode("12345678").unwrap()); // locktime
3429 target_value.append(&mut hex::decode("013413a7").unwrap()); // feerate_sat_per_1000_weight
3430 if let Some((_, target)) = funding_value_with_hex_target {
3431 target_value.push(0x00); // Type
3432 target_value.push(target.len() as u8 / 2); // Length
3433 target_value.append(&mut hex::decode(target).unwrap()); // Value (i64)
3435 assert_eq!(encoded_value, target_value);
3439 fn encoding_tx_init_rbf() {
3440 do_encoding_tx_init_rbf(Some((1311768467284833366, "1234567890123456")));
3441 do_encoding_tx_init_rbf(Some((13117684672, "000000030DDFFBC0")));
3442 do_encoding_tx_init_rbf(None);
3445 fn do_encoding_tx_ack_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3446 let tx_ack_rbf = msgs::TxAckRbf {
3447 channel_id: ChannelId::from_bytes([2; 32]),
3448 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3450 let encoded_value = tx_ack_rbf.encode();
3451 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3452 if let Some((_, target)) = funding_value_with_hex_target {
3453 target_value.push(0x00); // Type
3454 target_value.push(target.len() as u8 / 2); // Length
3455 target_value.append(&mut hex::decode(target).unwrap()); // Value (i64)
3457 assert_eq!(encoded_value, target_value);
3461 fn encoding_tx_ack_rbf() {
3462 do_encoding_tx_ack_rbf(Some((1311768467284833366, "1234567890123456")));
3463 do_encoding_tx_ack_rbf(Some((13117684672, "000000030DDFFBC0")));
3464 do_encoding_tx_ack_rbf(None);
3468 fn encoding_tx_abort() {
3469 let tx_abort = msgs::TxAbort {
3470 channel_id: ChannelId::from_bytes([2; 32]),
3471 data: hex::decode("54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap(),
3473 let encoded_value = tx_abort.encode();
3474 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202002C54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap();
3475 assert_eq!(encoded_value, target_value);
3478 fn do_encoding_shutdown(script_type: u8) {
3479 let secp_ctx = Secp256k1::new();
3480 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3481 let script = Builder::new().push_opcode(opcodes::OP_TRUE).into_script();
3482 let shutdown = msgs::Shutdown {
3483 channel_id: ChannelId::from_bytes([2; 32]),
3485 if script_type == 1 { Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey() }
3486 else if script_type == 2 { Address::p2sh(&script, Network::Testnet).unwrap().script_pubkey() }
3487 else if script_type == 3 { Address::p2wpkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).unwrap().script_pubkey() }
3488 else { Address::p2wsh(&script, Network::Testnet).script_pubkey() },
3490 let encoded_value = shutdown.encode();
3491 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3492 if script_type == 1 {
3493 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3494 } else if script_type == 2 {
3495 target_value.append(&mut hex::decode("0017a914da1745e9b549bd0bfa1a569971c77eba30cd5a4b87").unwrap());
3496 } else if script_type == 3 {
3497 target_value.append(&mut hex::decode("0016001479b000887626b294a914501a4cd226b58b235983").unwrap());
3498 } else if script_type == 4 {
3499 target_value.append(&mut hex::decode("002200204ae81572f06e1b88fd5ced7a1a000945432e83e1551e6f721ee9c00b8cc33260").unwrap());
3501 assert_eq!(encoded_value, target_value);
3505 fn encoding_shutdown() {
3506 do_encoding_shutdown(1);
3507 do_encoding_shutdown(2);
3508 do_encoding_shutdown(3);
3509 do_encoding_shutdown(4);
3513 fn encoding_closing_signed() {
3514 let secp_ctx = Secp256k1::new();
3515 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3516 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3517 let closing_signed = msgs::ClosingSigned {
3518 channel_id: ChannelId::from_bytes([2; 32]),
3519 fee_satoshis: 2316138423780173,
3523 let encoded_value = closing_signed.encode();
3524 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3525 assert_eq!(encoded_value, target_value);
3526 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value)).unwrap(), closing_signed);
3528 let closing_signed_with_range = msgs::ClosingSigned {
3529 channel_id: ChannelId::from_bytes([2; 32]),
3530 fee_satoshis: 2316138423780173,
3532 fee_range: Some(msgs::ClosingSignedFeeRange {
3533 min_fee_satoshis: 0xdeadbeef,
3534 max_fee_satoshis: 0x1badcafe01234567,
3537 let encoded_value_with_range = closing_signed_with_range.encode();
3538 let target_value_with_range = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a011000000000deadbeef1badcafe01234567").unwrap();
3539 assert_eq!(encoded_value_with_range, target_value_with_range);
3540 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value_with_range)).unwrap(),
3541 closing_signed_with_range);
3545 fn encoding_update_add_htlc() {
3546 let secp_ctx = Secp256k1::new();
3547 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3548 let onion_routing_packet = msgs::OnionPacket {
3550 public_key: Ok(pubkey_1),
3551 hop_data: [1; 20*65],
3554 let update_add_htlc = msgs::UpdateAddHTLC {
3555 channel_id: ChannelId::from_bytes([2; 32]),
3556 htlc_id: 2316138423780173,
3557 amount_msat: 3608586615801332854,
3558 payment_hash: PaymentHash([1; 32]),
3559 cltv_expiry: 821716,
3560 onion_routing_packet,
3561 skimmed_fee_msat: None,
3563 let encoded_value = update_add_htlc.encode();
3564 let target_value = hex::decode("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").unwrap();
3565 assert_eq!(encoded_value, target_value);
3569 fn encoding_update_fulfill_htlc() {
3570 let update_fulfill_htlc = msgs::UpdateFulfillHTLC {
3571 channel_id: ChannelId::from_bytes([2; 32]),
3572 htlc_id: 2316138423780173,
3573 payment_preimage: PaymentPreimage([1; 32]),
3575 let encoded_value = update_fulfill_htlc.encode();
3576 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d0101010101010101010101010101010101010101010101010101010101010101").unwrap();
3577 assert_eq!(encoded_value, target_value);
3581 fn encoding_update_fail_htlc() {
3582 let reason = OnionErrorPacket {
3583 data: [1; 32].to_vec(),
3585 let update_fail_htlc = msgs::UpdateFailHTLC {
3586 channel_id: ChannelId::from_bytes([2; 32]),
3587 htlc_id: 2316138423780173,
3590 let encoded_value = update_fail_htlc.encode();
3591 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d00200101010101010101010101010101010101010101010101010101010101010101").unwrap();
3592 assert_eq!(encoded_value, target_value);
3596 fn encoding_update_fail_malformed_htlc() {
3597 let update_fail_malformed_htlc = msgs::UpdateFailMalformedHTLC {
3598 channel_id: ChannelId::from_bytes([2; 32]),
3599 htlc_id: 2316138423780173,
3600 sha256_of_onion: [1; 32],
3603 let encoded_value = update_fail_malformed_htlc.encode();
3604 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d010101010101010101010101010101010101010101010101010101010101010100ff").unwrap();
3605 assert_eq!(encoded_value, target_value);
3608 fn do_encoding_commitment_signed(htlcs: bool) {
3609 let secp_ctx = Secp256k1::new();
3610 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3611 let (privkey_2, _) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3612 let (privkey_3, _) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3613 let (privkey_4, _) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3614 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3615 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
3616 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
3617 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
3618 let commitment_signed = msgs::CommitmentSigned {
3619 channel_id: ChannelId::from_bytes([2; 32]),
3621 htlc_signatures: if htlcs { vec![sig_2, sig_3, sig_4] } else { Vec::new() },
3623 partial_signature_with_nonce: None,
3625 let encoded_value = commitment_signed.encode();
3626 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3628 target_value.append(&mut hex::decode("00031735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
3630 target_value.append(&mut hex::decode("0000").unwrap());
3632 assert_eq!(encoded_value, target_value);
3636 fn encoding_commitment_signed() {
3637 do_encoding_commitment_signed(true);
3638 do_encoding_commitment_signed(false);
3642 fn encoding_revoke_and_ack() {
3643 let secp_ctx = Secp256k1::new();
3644 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3645 let raa = msgs::RevokeAndACK {
3646 channel_id: ChannelId::from_bytes([2; 32]),
3647 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],
3648 next_per_commitment_point: pubkey_1,
3650 next_local_nonce: None,
3652 let encoded_value = raa.encode();
3653 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020101010101010101010101010101010101010101010101010101010101010101031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3654 assert_eq!(encoded_value, target_value);
3658 fn encoding_update_fee() {
3659 let update_fee = msgs::UpdateFee {
3660 channel_id: ChannelId::from_bytes([2; 32]),
3661 feerate_per_kw: 20190119,
3663 let encoded_value = update_fee.encode();
3664 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202013413a7").unwrap();
3665 assert_eq!(encoded_value, target_value);
3669 fn encoding_init() {
3670 let mainnet_hash = ChainHash::using_genesis_block(Network::Bitcoin);
3671 assert_eq!(msgs::Init {
3672 features: InitFeatures::from_le_bytes(vec![0xFF, 0xFF, 0xFF]),
3673 networks: Some(vec![mainnet_hash]),
3674 remote_network_address: None,
3675 }.encode(), hex::decode("00023fff0003ffffff01206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3676 assert_eq!(msgs::Init {
3677 features: InitFeatures::from_le_bytes(vec![0xFF]),
3679 remote_network_address: None,
3680 }.encode(), hex::decode("0001ff0001ff").unwrap());
3681 assert_eq!(msgs::Init {
3682 features: InitFeatures::from_le_bytes(vec![]),
3683 networks: Some(vec![mainnet_hash]),
3684 remote_network_address: None,
3685 }.encode(), hex::decode("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3686 assert_eq!(msgs::Init {
3687 features: InitFeatures::from_le_bytes(vec![]),
3688 networks: Some(vec![ChainHash::from(&[1; 32][..]), ChainHash::from(&[2; 32][..])]),
3689 remote_network_address: None,
3690 }.encode(), hex::decode("00000000014001010101010101010101010101010101010101010101010101010101010101010202020202020202020202020202020202020202020202020202020202020202").unwrap());
3691 let init_msg = msgs::Init { features: InitFeatures::from_le_bytes(vec![]),
3692 networks: Some(vec![mainnet_hash]),
3693 remote_network_address: Some(SocketAddress::TcpIpV4 {
3694 addr: [127, 0, 0, 1],
3698 let encoded_value = init_msg.encode();
3699 let target_value = hex::decode("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d61900000000000307017f00000103e8").unwrap();
3700 assert_eq!(encoded_value, target_value);
3701 assert_eq!(msgs::Init::read(&mut Cursor::new(&target_value)).unwrap(), init_msg);
3705 fn encoding_error() {
3706 let error = msgs::ErrorMessage {
3707 channel_id: ChannelId::from_bytes([2; 32]),
3708 data: String::from("rust-lightning"),
3710 let encoded_value = error.encode();
3711 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3712 assert_eq!(encoded_value, target_value);
3716 fn encoding_warning() {
3717 let error = msgs::WarningMessage {
3718 channel_id: ChannelId::from_bytes([2; 32]),
3719 data: String::from("rust-lightning"),
3721 let encoded_value = error.encode();
3722 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3723 assert_eq!(encoded_value, target_value);
3727 fn encoding_ping() {
3728 let ping = msgs::Ping {
3732 let encoded_value = ping.encode();
3733 let target_value = hex::decode("0040004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3734 assert_eq!(encoded_value, target_value);
3738 fn encoding_pong() {
3739 let pong = msgs::Pong {
3742 let encoded_value = pong.encode();
3743 let target_value = hex::decode("004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3744 assert_eq!(encoded_value, target_value);
3748 fn encoding_nonfinal_onion_hop_data() {
3749 let outbound_msg = msgs::OutboundOnionPayload::Forward {
3750 short_channel_id: 0xdeadbeef1bad1dea,
3751 amt_to_forward: 0x0badf00d01020304,
3752 outgoing_cltv_value: 0xffffffff,
3754 let encoded_value = outbound_msg.encode();
3755 let target_value = hex::decode("1a02080badf00d010203040404ffffffff0608deadbeef1bad1dea").unwrap();
3756 assert_eq!(encoded_value, target_value);
3758 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3759 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
3760 if let msgs::InboundOnionPayload::Forward {
3761 short_channel_id, amt_to_forward, outgoing_cltv_value
3763 assert_eq!(short_channel_id, 0xdeadbeef1bad1dea);
3764 assert_eq!(amt_to_forward, 0x0badf00d01020304);
3765 assert_eq!(outgoing_cltv_value, 0xffffffff);
3766 } else { panic!(); }
3770 fn encoding_final_onion_hop_data() {
3771 let outbound_msg = msgs::OutboundOnionPayload::Receive {
3773 payment_metadata: None,
3774 keysend_preimage: None,
3775 amt_msat: 0x0badf00d01020304,
3776 outgoing_cltv_value: 0xffffffff,
3777 custom_tlvs: vec![],
3779 let encoded_value = outbound_msg.encode();
3780 let target_value = hex::decode("1002080badf00d010203040404ffffffff").unwrap();
3781 assert_eq!(encoded_value, target_value);
3783 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3784 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
3785 if let msgs::InboundOnionPayload::Receive {
3786 payment_data: None, amt_msat, outgoing_cltv_value, ..
3788 assert_eq!(amt_msat, 0x0badf00d01020304);
3789 assert_eq!(outgoing_cltv_value, 0xffffffff);
3790 } else { panic!(); }
3794 fn encoding_final_onion_hop_data_with_secret() {
3795 let expected_payment_secret = PaymentSecret([0x42u8; 32]);
3796 let outbound_msg = msgs::OutboundOnionPayload::Receive {
3797 payment_data: Some(FinalOnionHopData {
3798 payment_secret: expected_payment_secret,
3799 total_msat: 0x1badca1f
3801 payment_metadata: None,
3802 keysend_preimage: None,
3803 amt_msat: 0x0badf00d01020304,
3804 outgoing_cltv_value: 0xffffffff,
3805 custom_tlvs: vec![],
3807 let encoded_value = outbound_msg.encode();
3808 let target_value = hex::decode("3602080badf00d010203040404ffffffff082442424242424242424242424242424242424242424242424242424242424242421badca1f").unwrap();
3809 assert_eq!(encoded_value, target_value);
3811 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3812 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
3813 if let msgs::InboundOnionPayload::Receive {
3814 payment_data: Some(FinalOnionHopData {
3816 total_msat: 0x1badca1f
3818 amt_msat, outgoing_cltv_value,
3819 payment_metadata: None,
3820 keysend_preimage: None,
3823 assert_eq!(payment_secret, expected_payment_secret);
3824 assert_eq!(amt_msat, 0x0badf00d01020304);
3825 assert_eq!(outgoing_cltv_value, 0xffffffff);
3826 assert_eq!(custom_tlvs, vec![]);
3827 } else { panic!(); }
3831 fn encoding_final_onion_hop_data_with_bad_custom_tlvs() {
3832 // If custom TLVs have type number within the range reserved for protocol, treat them as if
3834 let bad_type_range_tlvs = vec![
3835 ((1 << 16) - 4, vec![42]),
3836 ((1 << 16) - 2, vec![42; 32]),
3838 let mut msg = msgs::OutboundOnionPayload::Receive {
3840 payment_metadata: None,
3841 keysend_preimage: None,
3842 custom_tlvs: bad_type_range_tlvs,
3843 amt_msat: 0x0badf00d01020304,
3844 outgoing_cltv_value: 0xffffffff,
3846 let encoded_value = msg.encode();
3847 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3848 assert!(msgs::InboundOnionPayload::read(&mut Cursor::new(&encoded_value[..]), &&node_signer).is_err());
3849 let good_type_range_tlvs = vec![
3850 ((1 << 16) - 3, vec![42]),
3851 ((1 << 16) - 1, vec![42; 32]),
3853 if let msgs::OutboundOnionPayload::Receive { ref mut custom_tlvs, .. } = msg {
3854 *custom_tlvs = good_type_range_tlvs.clone();
3856 let encoded_value = msg.encode();
3857 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&encoded_value[..]), &&node_signer).unwrap();
3859 msgs::InboundOnionPayload::Receive { custom_tlvs, .. } => assert!(custom_tlvs.is_empty()),
3865 fn encoding_final_onion_hop_data_with_custom_tlvs() {
3866 let expected_custom_tlvs = vec![
3867 (5482373483, vec![0x12, 0x34]),
3868 (5482373487, vec![0x42u8; 8]),
3870 let msg = msgs::OutboundOnionPayload::Receive {
3872 payment_metadata: None,
3873 keysend_preimage: None,
3874 custom_tlvs: expected_custom_tlvs.clone(),
3875 amt_msat: 0x0badf00d01020304,
3876 outgoing_cltv_value: 0xffffffff,
3878 let encoded_value = msg.encode();
3879 let target_value = hex::decode("2e02080badf00d010203040404ffffffffff0000000146c6616b021234ff0000000146c6616f084242424242424242").unwrap();
3880 assert_eq!(encoded_value, target_value);
3881 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3882 let inbound_msg: msgs::InboundOnionPayload = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
3883 if let msgs::InboundOnionPayload::Receive {
3885 payment_metadata: None,
3886 keysend_preimage: None,
3889 outgoing_cltv_value,
3892 assert_eq!(custom_tlvs, expected_custom_tlvs);
3893 assert_eq!(amt_msat, 0x0badf00d01020304);
3894 assert_eq!(outgoing_cltv_value, 0xffffffff);
3895 } else { panic!(); }
3899 fn query_channel_range_end_blocknum() {
3900 let tests: Vec<(u32, u32, u32)> = vec![
3901 (10000, 1500, 11500),
3902 (0, 0xffffffff, 0xffffffff),
3903 (1, 0xffffffff, 0xffffffff),
3906 for (first_blocknum, number_of_blocks, expected) in tests.into_iter() {
3907 let sut = msgs::QueryChannelRange {
3908 chain_hash: ChainHash::using_genesis_block(Network::Regtest),
3912 assert_eq!(sut.end_blocknum(), expected);
3917 fn encoding_query_channel_range() {
3918 let mut query_channel_range = msgs::QueryChannelRange {
3919 chain_hash: ChainHash::using_genesis_block(Network::Regtest),
3920 first_blocknum: 100000,
3921 number_of_blocks: 1500,
3923 let encoded_value = query_channel_range.encode();
3924 let target_value = hex::decode("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000186a0000005dc").unwrap();
3925 assert_eq!(encoded_value, target_value);
3927 query_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3928 assert_eq!(query_channel_range.first_blocknum, 100000);
3929 assert_eq!(query_channel_range.number_of_blocks, 1500);
3933 fn encoding_reply_channel_range() {
3934 do_encoding_reply_channel_range(0);
3935 do_encoding_reply_channel_range(1);
3938 fn do_encoding_reply_channel_range(encoding_type: u8) {
3939 let mut target_value = hex::decode("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000b8a06000005dc01").unwrap();
3940 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
3941 let mut reply_channel_range = msgs::ReplyChannelRange {
3942 chain_hash: expected_chain_hash,
3943 first_blocknum: 756230,
3944 number_of_blocks: 1500,
3945 sync_complete: true,
3946 short_channel_ids: vec![0x000000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
3949 if encoding_type == 0 {
3950 target_value.append(&mut hex::decode("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
3951 let encoded_value = reply_channel_range.encode();
3952 assert_eq!(encoded_value, target_value);
3954 reply_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3955 assert_eq!(reply_channel_range.chain_hash, expected_chain_hash);
3956 assert_eq!(reply_channel_range.first_blocknum, 756230);
3957 assert_eq!(reply_channel_range.number_of_blocks, 1500);
3958 assert_eq!(reply_channel_range.sync_complete, true);
3959 assert_eq!(reply_channel_range.short_channel_ids[0], 0x000000000000008e);
3960 assert_eq!(reply_channel_range.short_channel_ids[1], 0x0000000000003c69);
3961 assert_eq!(reply_channel_range.short_channel_ids[2], 0x000000000045a6c4);
3963 target_value.append(&mut hex::decode("001601789c636000833e08659309a65878be010010a9023a").unwrap());
3964 let result: Result<msgs::ReplyChannelRange, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
3965 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
3970 fn encoding_query_short_channel_ids() {
3971 do_encoding_query_short_channel_ids(0);
3972 do_encoding_query_short_channel_ids(1);
3975 fn do_encoding_query_short_channel_ids(encoding_type: u8) {
3976 let mut target_value = hex::decode("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3977 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
3978 let mut query_short_channel_ids = msgs::QueryShortChannelIds {
3979 chain_hash: expected_chain_hash,
3980 short_channel_ids: vec![0x0000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
3983 if encoding_type == 0 {
3984 target_value.append(&mut hex::decode("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
3985 let encoded_value = query_short_channel_ids.encode();
3986 assert_eq!(encoded_value, target_value);
3988 query_short_channel_ids = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3989 assert_eq!(query_short_channel_ids.chain_hash, expected_chain_hash);
3990 assert_eq!(query_short_channel_ids.short_channel_ids[0], 0x000000000000008e);
3991 assert_eq!(query_short_channel_ids.short_channel_ids[1], 0x0000000000003c69);
3992 assert_eq!(query_short_channel_ids.short_channel_ids[2], 0x000000000045a6c4);
3994 target_value.append(&mut hex::decode("001601789c636000833e08659309a65878be010010a9023a").unwrap());
3995 let result: Result<msgs::QueryShortChannelIds, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
3996 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
4001 fn encoding_reply_short_channel_ids_end() {
4002 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4003 let mut reply_short_channel_ids_end = msgs::ReplyShortChannelIdsEnd {
4004 chain_hash: expected_chain_hash,
4005 full_information: true,
4007 let encoded_value = reply_short_channel_ids_end.encode();
4008 let target_value = hex::decode("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f01").unwrap();
4009 assert_eq!(encoded_value, target_value);
4011 reply_short_channel_ids_end = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4012 assert_eq!(reply_short_channel_ids_end.chain_hash, expected_chain_hash);
4013 assert_eq!(reply_short_channel_ids_end.full_information, true);
4017 fn encoding_gossip_timestamp_filter(){
4018 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4019 let mut gossip_timestamp_filter = msgs::GossipTimestampFilter {
4020 chain_hash: expected_chain_hash,
4021 first_timestamp: 1590000000,
4022 timestamp_range: 0xffff_ffff,
4024 let encoded_value = gossip_timestamp_filter.encode();
4025 let target_value = hex::decode("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f5ec57980ffffffff").unwrap();
4026 assert_eq!(encoded_value, target_value);
4028 gossip_timestamp_filter = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4029 assert_eq!(gossip_timestamp_filter.chain_hash, expected_chain_hash);
4030 assert_eq!(gossip_timestamp_filter.first_timestamp, 1590000000);
4031 assert_eq!(gossip_timestamp_filter.timestamp_range, 0xffff_ffff);
4035 fn decode_onion_hop_data_len_as_bigsize() {
4036 // Tests that we can decode an onion payload that is >253 bytes.
4037 // Previously, receiving a payload of this size could've caused us to fail to decode a valid
4038 // payload, because we were decoding the length (a BigSize, big-endian) as a VarInt
4041 // Encode a test onion payload with a big custom TLV such that it's >253 bytes, forcing the
4042 // payload length to be encoded over multiple bytes rather than a single u8.
4043 let big_payload = encode_big_payload().unwrap();
4044 let mut rd = Cursor::new(&big_payload[..]);
4046 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4047 <msgs::InboundOnionPayload as ReadableArgs<&&test_utils::TestKeysInterface>>
4048 ::read(&mut rd, &&node_signer).unwrap();
4050 // see above test, needs to be a separate method for use of the serialization macros.
4051 fn encode_big_payload() -> Result<Vec<u8>, io::Error> {
4052 use crate::util::ser::HighZeroBytesDroppedBigSize;
4053 let payload = msgs::OutboundOnionPayload::Forward {
4054 short_channel_id: 0xdeadbeef1bad1dea,
4055 amt_to_forward: 1000,
4056 outgoing_cltv_value: 0xffffffff,
4058 let mut encoded_payload = Vec::new();
4059 let test_bytes = vec![42u8; 1000];
4060 if let msgs::OutboundOnionPayload::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } = payload {
4061 _encode_varint_length_prefixed_tlv!(&mut encoded_payload, {
4062 (1, test_bytes, required_vec),
4063 (2, HighZeroBytesDroppedBigSize(amt_to_forward), required),
4064 (4, HighZeroBytesDroppedBigSize(outgoing_cltv_value), required),
4065 (6, short_channel_id, required)
4072 #[cfg(feature = "std")]
4073 fn test_socket_address_from_str() {
4074 assert_eq!(SocketAddress::TcpIpV4 {
4075 addr: Ipv4Addr::new(127, 0, 0, 1).octets(),
4077 }, SocketAddress::from_str("127.0.0.1:1234").unwrap());
4079 assert_eq!(SocketAddress::TcpIpV6 {
4080 addr: Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1).octets(),
4082 }, SocketAddress::from_str("[0:0:0:0:0:0:0:1]:1234").unwrap());
4084 SocketAddress::Hostname {
4085 hostname: Hostname::try_from("lightning-node.mydomain.com".to_string()).unwrap(),
4087 }, SocketAddress::from_str("lightning-node.mydomain.com:1234").unwrap());
4089 SocketAddress::Hostname {
4090 hostname: Hostname::try_from("example.com".to_string()).unwrap(),
4092 }, SocketAddress::from_str("example.com:1234").unwrap());
4093 assert_eq!(SocketAddress::OnionV3 {
4094 ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102, 182, 107, 4, 105, 247, 246, 85,
4095 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31, 33, 71, 3],
4099 }, SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion:1234").unwrap());
4100 assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6.onion:1234"));
4101 assert_eq!(Err(SocketAddressParseError::InvalidInput), SocketAddress::from_str("127.0.0.1@1234"));
4102 assert_eq!(Err(SocketAddressParseError::InvalidInput), "".parse::<SocketAddress>());
4103 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:9735:94").is_err());
4104 assert!(SocketAddress::from_str("wrong$%#.com:1234").is_err());
4105 assert_eq!(Err(SocketAddressParseError::InvalidPort), SocketAddress::from_str("example.com:wrong"));
4106 assert!("localhost".parse::<SocketAddress>().is_err());
4107 assert!("localhost:invalid-port".parse::<SocketAddress>().is_err());
4108 assert!( "invalid-onion-v3-hostname.onion:8080".parse::<SocketAddress>().is_err());
4109 assert!("b32.example.onion:invalid-port".parse::<SocketAddress>().is_err());
4110 assert!("invalid-address".parse::<SocketAddress>().is_err());
4111 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:1234").is_err());