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, OnionMessageProvider};
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 trait to describe an object that can receive onion messages.
1501 pub trait OnionMessageHandler : OnionMessageProvider {
1502 /// Handle an incoming `onion_message` message from the given peer.
1503 fn handle_onion_message(&self, peer_node_id: &PublicKey, msg: &OnionMessage);
1504 /// Called when a connection is established with a peer. Can be used to track which peers
1505 /// advertise onion message support and are online.
1507 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1508 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1509 /// message handlers may still wish to communicate with this peer.
1510 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1511 /// Indicates a connection to the peer failed/an existing connection was lost. Allows handlers to
1512 /// drop and refuse to forward onion messages to this peer.
1513 fn peer_disconnected(&self, their_node_id: &PublicKey);
1515 // Handler information:
1516 /// Gets the node feature flags which this handler itself supports. All available handlers are
1517 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1518 /// which are broadcasted in our [`NodeAnnouncement`] message.
1519 fn provided_node_features(&self) -> NodeFeatures;
1521 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1522 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1523 /// which are sent in our [`Init`] message.
1525 /// Note that this method is called before [`Self::peer_connected`].
1526 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1529 mod fuzzy_internal_msgs {
1530 use bitcoin::secp256k1::PublicKey;
1531 use crate::blinded_path::payment::PaymentConstraints;
1532 use crate::prelude::*;
1533 use crate::ln::{PaymentPreimage, PaymentSecret};
1535 // These types aren't intended to be pub, but are exposed for direct fuzzing (as we deserialize
1536 // them from untrusted input):
1538 pub struct FinalOnionHopData {
1539 pub payment_secret: PaymentSecret,
1540 /// The total value, in msat, of the payment as received by the ultimate recipient.
1541 /// Message serialization may panic if this value is more than 21 million Bitcoin.
1542 pub total_msat: u64,
1545 pub enum InboundOnionPayload {
1547 short_channel_id: u64,
1548 /// The value, in msat, of the payment after this hop's fee is deducted.
1549 amt_to_forward: u64,
1550 outgoing_cltv_value: u32,
1553 payment_data: Option<FinalOnionHopData>,
1554 payment_metadata: Option<Vec<u8>>,
1555 keysend_preimage: Option<PaymentPreimage>,
1556 custom_tlvs: Vec<(u64, Vec<u8>)>,
1558 outgoing_cltv_value: u32,
1563 outgoing_cltv_value: u32,
1564 payment_secret: PaymentSecret,
1565 payment_constraints: PaymentConstraints,
1566 intro_node_blinding_point: PublicKey,
1570 pub(crate) enum OutboundOnionPayload {
1572 short_channel_id: u64,
1573 /// The value, in msat, of the payment after this hop's fee is deducted.
1574 amt_to_forward: u64,
1575 outgoing_cltv_value: u32,
1578 payment_data: Option<FinalOnionHopData>,
1579 payment_metadata: Option<Vec<u8>>,
1580 keysend_preimage: Option<PaymentPreimage>,
1581 custom_tlvs: Vec<(u64, Vec<u8>)>,
1583 outgoing_cltv_value: u32,
1586 encrypted_tlvs: Vec<u8>,
1587 intro_node_blinding_point: Option<PublicKey>,
1592 outgoing_cltv_value: u32,
1593 encrypted_tlvs: Vec<u8>,
1594 intro_node_blinding_point: Option<PublicKey>, // Set if the introduction node of the blinded path is the final node
1598 pub struct DecodedOnionErrorPacket {
1599 pub(crate) hmac: [u8; 32],
1600 pub(crate) failuremsg: Vec<u8>,
1601 pub(crate) pad: Vec<u8>,
1605 pub use self::fuzzy_internal_msgs::*;
1606 #[cfg(not(fuzzing))]
1607 pub(crate) use self::fuzzy_internal_msgs::*;
1610 pub(crate) struct OnionPacket {
1611 pub(crate) version: u8,
1612 /// In order to ensure we always return an error on onion decode in compliance with [BOLT
1613 /// #4](https://github.com/lightning/bolts/blob/master/04-onion-routing.md), we have to
1614 /// deserialize `OnionPacket`s contained in [`UpdateAddHTLC`] messages even if the ephemeral
1615 /// public key (here) is bogus, so we hold a [`Result`] instead of a [`PublicKey`] as we'd
1617 pub(crate) public_key: Result<PublicKey, secp256k1::Error>,
1618 pub(crate) hop_data: [u8; 20*65],
1619 pub(crate) hmac: [u8; 32],
1622 impl onion_utils::Packet for OnionPacket {
1623 type Data = onion_utils::FixedSizeOnionPacket;
1624 fn new(pubkey: PublicKey, hop_data: onion_utils::FixedSizeOnionPacket, hmac: [u8; 32]) -> Self {
1627 public_key: Ok(pubkey),
1628 hop_data: hop_data.0,
1634 impl Eq for OnionPacket { }
1635 impl PartialEq for OnionPacket {
1636 fn eq(&self, other: &OnionPacket) -> bool {
1637 for (i, j) in self.hop_data.iter().zip(other.hop_data.iter()) {
1638 if i != j { return false; }
1640 self.version == other.version &&
1641 self.public_key == other.public_key &&
1642 self.hmac == other.hmac
1646 impl fmt::Debug for OnionPacket {
1647 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1648 f.write_fmt(format_args!("OnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
1652 #[derive(Clone, Debug, PartialEq, Eq)]
1653 pub(crate) struct OnionErrorPacket {
1654 // This really should be a constant size slice, but the spec lets these things be up to 128KB?
1655 // (TODO) We limit it in decode to much lower...
1656 pub(crate) data: Vec<u8>,
1659 impl fmt::Display for DecodeError {
1660 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1662 DecodeError::UnknownVersion => f.write_str("Unknown realm byte in Onion packet"),
1663 DecodeError::UnknownRequiredFeature => f.write_str("Unknown required feature preventing decode"),
1664 DecodeError::InvalidValue => f.write_str("Nonsense bytes didn't map to the type they were interpreted as"),
1665 DecodeError::ShortRead => f.write_str("Packet extended beyond the provided bytes"),
1666 DecodeError::BadLengthDescriptor => f.write_str("A length descriptor in the packet didn't describe the later data correctly"),
1667 DecodeError::Io(ref e) => fmt::Debug::fmt(e, f),
1668 DecodeError::UnsupportedCompression => f.write_str("We don't support receiving messages with zlib-compressed fields"),
1673 impl From<io::Error> for DecodeError {
1674 fn from(e: io::Error) -> Self {
1675 if e.kind() == io::ErrorKind::UnexpectedEof {
1676 DecodeError::ShortRead
1678 DecodeError::Io(e.kind())
1683 #[cfg(not(taproot))]
1684 impl_writeable_msg!(AcceptChannel, {
1685 temporary_channel_id,
1686 dust_limit_satoshis,
1687 max_htlc_value_in_flight_msat,
1688 channel_reserve_satoshis,
1694 revocation_basepoint,
1696 delayed_payment_basepoint,
1698 first_per_commitment_point,
1700 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1701 (1, channel_type, option),
1705 impl_writeable_msg!(AcceptChannel, {
1706 temporary_channel_id,
1707 dust_limit_satoshis,
1708 max_htlc_value_in_flight_msat,
1709 channel_reserve_satoshis,
1715 revocation_basepoint,
1717 delayed_payment_basepoint,
1719 first_per_commitment_point,
1721 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1722 (1, channel_type, option),
1723 (4, next_local_nonce, option),
1726 impl_writeable_msg!(AcceptChannelV2, {
1727 temporary_channel_id,
1729 dust_limit_satoshis,
1730 max_htlc_value_in_flight_msat,
1736 revocation_basepoint,
1738 delayed_payment_basepoint,
1740 first_per_commitment_point,
1741 second_per_commitment_point,
1743 (0, shutdown_scriptpubkey, option),
1744 (1, channel_type, option),
1745 (2, require_confirmed_inputs, option),
1748 impl_writeable_msg!(TxAddInput, {
1756 impl_writeable_msg!(TxAddOutput, {
1763 impl_writeable_msg!(TxRemoveInput, {
1768 impl_writeable_msg!(TxRemoveOutput, {
1773 impl_writeable_msg!(TxComplete, {
1777 impl_writeable_msg!(TxSignatures, {
1783 impl_writeable_msg!(TxInitRbf, {
1786 feerate_sat_per_1000_weight,
1788 (0, funding_output_contribution, option),
1791 impl_writeable_msg!(TxAckRbf, {
1794 (0, funding_output_contribution, option),
1797 impl_writeable_msg!(TxAbort, {
1802 impl_writeable_msg!(AnnouncementSignatures, {
1809 impl_writeable_msg!(ChannelReestablish, {
1811 next_local_commitment_number,
1812 next_remote_commitment_number,
1813 your_last_per_commitment_secret,
1814 my_current_per_commitment_point,
1816 (0, next_funding_txid, option),
1819 impl_writeable_msg!(ClosingSigned,
1820 { channel_id, fee_satoshis, signature },
1821 { (1, fee_range, option) }
1824 impl_writeable!(ClosingSignedFeeRange, {
1829 #[cfg(not(taproot))]
1830 impl_writeable_msg!(CommitmentSigned, {
1837 impl_writeable_msg!(CommitmentSigned, {
1842 (2, partial_signature_with_nonce, option)
1845 impl_writeable!(DecodedOnionErrorPacket, {
1851 #[cfg(not(taproot))]
1852 impl_writeable_msg!(FundingCreated, {
1853 temporary_channel_id,
1855 funding_output_index,
1859 impl_writeable_msg!(FundingCreated, {
1860 temporary_channel_id,
1862 funding_output_index,
1865 (2, partial_signature_with_nonce, option),
1866 (4, next_local_nonce, option)
1869 #[cfg(not(taproot))]
1870 impl_writeable_msg!(FundingSigned, {
1876 impl_writeable_msg!(FundingSigned, {
1880 (2, partial_signature_with_nonce, option)
1883 impl_writeable_msg!(ChannelReady, {
1885 next_per_commitment_point,
1887 (1, short_channel_id_alias, option),
1890 impl Writeable for Init {
1891 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1892 // global_features gets the bottom 13 bits of our features, and local_features gets all of
1893 // our relevant feature bits. This keeps us compatible with old nodes.
1894 self.features.write_up_to_13(w)?;
1895 self.features.write(w)?;
1896 encode_tlv_stream!(w, {
1897 (1, self.networks.as_ref().map(|n| WithoutLength(n)), option),
1898 (3, self.remote_network_address, option),
1904 impl Readable for Init {
1905 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1906 let global_features: InitFeatures = Readable::read(r)?;
1907 let features: InitFeatures = Readable::read(r)?;
1908 let mut remote_network_address: Option<SocketAddress> = None;
1909 let mut networks: Option<WithoutLength<Vec<ChainHash>>> = None;
1910 decode_tlv_stream!(r, {
1911 (1, networks, option),
1912 (3, remote_network_address, option)
1915 features: features | global_features,
1916 networks: networks.map(|n| n.0),
1917 remote_network_address,
1922 impl_writeable_msg!(OpenChannel, {
1924 temporary_channel_id,
1927 dust_limit_satoshis,
1928 max_htlc_value_in_flight_msat,
1929 channel_reserve_satoshis,
1935 revocation_basepoint,
1937 delayed_payment_basepoint,
1939 first_per_commitment_point,
1942 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1943 (1, channel_type, option),
1946 impl_writeable_msg!(OpenChannelV2, {
1948 temporary_channel_id,
1949 funding_feerate_sat_per_1000_weight,
1950 commitment_feerate_sat_per_1000_weight,
1952 dust_limit_satoshis,
1953 max_htlc_value_in_flight_msat,
1959 revocation_basepoint,
1961 delayed_payment_basepoint,
1963 first_per_commitment_point,
1964 second_per_commitment_point,
1967 (0, shutdown_scriptpubkey, option),
1968 (1, channel_type, option),
1969 (2, require_confirmed_inputs, option),
1972 #[cfg(not(taproot))]
1973 impl_writeable_msg!(RevokeAndACK, {
1975 per_commitment_secret,
1976 next_per_commitment_point
1980 impl_writeable_msg!(RevokeAndACK, {
1982 per_commitment_secret,
1983 next_per_commitment_point
1985 (4, next_local_nonce, option)
1988 impl_writeable_msg!(Shutdown, {
1993 impl_writeable_msg!(UpdateFailHTLC, {
1999 impl_writeable_msg!(UpdateFailMalformedHTLC, {
2006 impl_writeable_msg!(UpdateFee, {
2011 impl_writeable_msg!(UpdateFulfillHTLC, {
2017 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2018 // serialization format in a way which assumes we know the total serialized length/message end
2020 impl_writeable!(OnionErrorPacket, {
2024 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2025 // serialization format in a way which assumes we know the total serialized length/message end
2027 impl Writeable for OnionPacket {
2028 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2029 self.version.write(w)?;
2030 match self.public_key {
2031 Ok(pubkey) => pubkey.write(w)?,
2032 Err(_) => [0u8;33].write(w)?,
2034 w.write_all(&self.hop_data)?;
2035 self.hmac.write(w)?;
2040 impl Readable for OnionPacket {
2041 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2043 version: Readable::read(r)?,
2045 let mut buf = [0u8;33];
2046 r.read_exact(&mut buf)?;
2047 PublicKey::from_slice(&buf)
2049 hop_data: Readable::read(r)?,
2050 hmac: Readable::read(r)?,
2055 impl_writeable_msg!(UpdateAddHTLC, {
2061 onion_routing_packet,
2063 (65537, skimmed_fee_msat, option)
2066 impl Readable for OnionMessage {
2067 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2068 let blinding_point: PublicKey = Readable::read(r)?;
2069 let len: u16 = Readable::read(r)?;
2070 let mut packet_reader = FixedLengthReader::new(r, len as u64);
2071 let onion_routing_packet: onion_message::Packet = <onion_message::Packet as LengthReadable>::read(&mut packet_reader)?;
2074 onion_routing_packet,
2079 impl Writeable for OnionMessage {
2080 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2081 self.blinding_point.write(w)?;
2082 let onion_packet_len = self.onion_routing_packet.serialized_length();
2083 (onion_packet_len as u16).write(w)?;
2084 self.onion_routing_packet.write(w)?;
2089 impl Writeable for FinalOnionHopData {
2090 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2091 self.payment_secret.0.write(w)?;
2092 HighZeroBytesDroppedBigSize(self.total_msat).write(w)
2096 impl Readable for FinalOnionHopData {
2097 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2098 let secret: [u8; 32] = Readable::read(r)?;
2099 let amt: HighZeroBytesDroppedBigSize<u64> = Readable::read(r)?;
2100 Ok(Self { payment_secret: PaymentSecret(secret), total_msat: amt.0 })
2104 impl Writeable for OutboundOnionPayload {
2105 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2107 Self::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } => {
2108 _encode_varint_length_prefixed_tlv!(w, {
2109 (2, HighZeroBytesDroppedBigSize(*amt_to_forward), required),
2110 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2111 (6, short_channel_id, required)
2115 ref payment_data, ref payment_metadata, ref keysend_preimage, amt_msat,
2116 outgoing_cltv_value, ref custom_tlvs,
2118 // We need to update [`ln::outbound_payment::RecipientOnionFields::with_custom_tlvs`]
2119 // to reject any reserved types in the experimental range if new ones are ever
2121 let keysend_tlv = keysend_preimage.map(|preimage| (5482373484, preimage.encode()));
2122 let mut custom_tlvs: Vec<&(u64, Vec<u8>)> = custom_tlvs.iter().chain(keysend_tlv.iter()).collect();
2123 custom_tlvs.sort_unstable_by_key(|(typ, _)| *typ);
2124 _encode_varint_length_prefixed_tlv!(w, {
2125 (2, HighZeroBytesDroppedBigSize(*amt_msat), required),
2126 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2127 (8, payment_data, option),
2128 (16, payment_metadata.as_ref().map(|m| WithoutLength(m)), option)
2129 }, custom_tlvs.iter());
2131 Self::BlindedForward { encrypted_tlvs, intro_node_blinding_point } => {
2132 _encode_varint_length_prefixed_tlv!(w, {
2133 (10, *encrypted_tlvs, required_vec),
2134 (12, intro_node_blinding_point, option)
2137 Self::BlindedReceive {
2138 amt_msat, total_msat, outgoing_cltv_value, encrypted_tlvs,
2139 intro_node_blinding_point,
2141 _encode_varint_length_prefixed_tlv!(w, {
2142 (2, HighZeroBytesDroppedBigSize(*amt_msat), required),
2143 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2144 (10, *encrypted_tlvs, required_vec),
2145 (12, intro_node_blinding_point, option),
2146 (18, HighZeroBytesDroppedBigSize(*total_msat), required)
2154 impl<NS: Deref> ReadableArgs<&NS> for InboundOnionPayload where NS::Target: NodeSigner {
2155 fn read<R: Read>(r: &mut R, node_signer: &NS) -> Result<Self, DecodeError> {
2157 let mut cltv_value = None;
2158 let mut short_id: Option<u64> = None;
2159 let mut payment_data: Option<FinalOnionHopData> = None;
2160 let mut encrypted_tlvs_opt: Option<WithoutLength<Vec<u8>>> = None;
2161 let mut intro_node_blinding_point = None;
2162 let mut payment_metadata: Option<WithoutLength<Vec<u8>>> = None;
2163 let mut total_msat = None;
2164 let mut keysend_preimage: Option<PaymentPreimage> = None;
2165 let mut custom_tlvs = Vec::new();
2167 let tlv_len = BigSize::read(r)?;
2168 let rd = FixedLengthReader::new(r, tlv_len.0);
2169 decode_tlv_stream_with_custom_tlv_decode!(rd, {
2170 (2, amt, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2171 (4, cltv_value, (option, encoding: (u32, HighZeroBytesDroppedBigSize))),
2172 (6, short_id, option),
2173 (8, payment_data, option),
2174 (10, encrypted_tlvs_opt, option),
2175 (12, intro_node_blinding_point, option),
2176 (16, payment_metadata, option),
2177 (18, total_msat, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2178 // See https://github.com/lightning/blips/blob/master/blip-0003.md
2179 (5482373484, keysend_preimage, option)
2180 }, |msg_type: u64, msg_reader: &mut FixedLengthReader<_>| -> Result<bool, DecodeError> {
2181 if msg_type < 1 << 16 { return Ok(false) }
2182 let mut value = Vec::new();
2183 msg_reader.read_to_end(&mut value)?;
2184 custom_tlvs.push((msg_type, value));
2188 if amt.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2190 if let Some(blinding_point) = intro_node_blinding_point {
2191 if short_id.is_some() || payment_data.is_some() || payment_metadata.is_some() {
2192 return Err(DecodeError::InvalidValue)
2194 let enc_tlvs = encrypted_tlvs_opt.ok_or(DecodeError::InvalidValue)?.0;
2195 let enc_tlvs_ss = node_signer.ecdh(Recipient::Node, &blinding_point, None)
2196 .map_err(|_| DecodeError::InvalidValue)?;
2197 let rho = onion_utils::gen_rho_from_shared_secret(&enc_tlvs_ss.secret_bytes());
2198 let mut s = Cursor::new(&enc_tlvs);
2199 let mut reader = FixedLengthReader::new(&mut s, enc_tlvs.len() as u64);
2200 match ChaChaPolyReadAdapter::read(&mut reader, rho)? {
2201 ChaChaPolyReadAdapter { readable: ReceiveTlvs { payment_secret, payment_constraints }} => {
2202 if total_msat.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2203 Ok(Self::BlindedReceive {
2204 amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2205 total_msat: total_msat.ok_or(DecodeError::InvalidValue)?,
2206 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2208 payment_constraints,
2209 intro_node_blinding_point: blinding_point,
2213 } else if let Some(short_channel_id) = short_id {
2214 if payment_data.is_some() || payment_metadata.is_some() || encrypted_tlvs_opt.is_some() ||
2215 total_msat.is_some()
2216 { return Err(DecodeError::InvalidValue) }
2219 amt_to_forward: amt.ok_or(DecodeError::InvalidValue)?,
2220 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2223 if encrypted_tlvs_opt.is_some() || total_msat.is_some() {
2224 return Err(DecodeError::InvalidValue)
2226 if let Some(data) = &payment_data {
2227 if data.total_msat > MAX_VALUE_MSAT {
2228 return Err(DecodeError::InvalidValue);
2233 payment_metadata: payment_metadata.map(|w| w.0),
2235 amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2236 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2243 impl Writeable for Ping {
2244 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2245 self.ponglen.write(w)?;
2246 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2251 impl Readable for Ping {
2252 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2254 ponglen: Readable::read(r)?,
2256 let byteslen = Readable::read(r)?;
2257 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2264 impl Writeable for Pong {
2265 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2266 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2271 impl Readable for Pong {
2272 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2275 let byteslen = Readable::read(r)?;
2276 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2283 impl Writeable for UnsignedChannelAnnouncement {
2284 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2285 self.features.write(w)?;
2286 self.chain_hash.write(w)?;
2287 self.short_channel_id.write(w)?;
2288 self.node_id_1.write(w)?;
2289 self.node_id_2.write(w)?;
2290 self.bitcoin_key_1.write(w)?;
2291 self.bitcoin_key_2.write(w)?;
2292 w.write_all(&self.excess_data[..])?;
2297 impl Readable for UnsignedChannelAnnouncement {
2298 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2300 features: Readable::read(r)?,
2301 chain_hash: Readable::read(r)?,
2302 short_channel_id: Readable::read(r)?,
2303 node_id_1: Readable::read(r)?,
2304 node_id_2: Readable::read(r)?,
2305 bitcoin_key_1: Readable::read(r)?,
2306 bitcoin_key_2: Readable::read(r)?,
2307 excess_data: read_to_end(r)?,
2312 impl_writeable!(ChannelAnnouncement, {
2315 bitcoin_signature_1,
2316 bitcoin_signature_2,
2320 impl Writeable for UnsignedChannelUpdate {
2321 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2322 // `message_flags` used to indicate presence of `htlc_maximum_msat`, but was deprecated in the spec.
2323 const MESSAGE_FLAGS: u8 = 1;
2324 self.chain_hash.write(w)?;
2325 self.short_channel_id.write(w)?;
2326 self.timestamp.write(w)?;
2327 let all_flags = self.flags as u16 | ((MESSAGE_FLAGS as u16) << 8);
2328 all_flags.write(w)?;
2329 self.cltv_expiry_delta.write(w)?;
2330 self.htlc_minimum_msat.write(w)?;
2331 self.fee_base_msat.write(w)?;
2332 self.fee_proportional_millionths.write(w)?;
2333 self.htlc_maximum_msat.write(w)?;
2334 w.write_all(&self.excess_data[..])?;
2339 impl Readable for UnsignedChannelUpdate {
2340 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2342 chain_hash: Readable::read(r)?,
2343 short_channel_id: Readable::read(r)?,
2344 timestamp: Readable::read(r)?,
2346 let flags: u16 = Readable::read(r)?;
2347 // Note: we ignore the `message_flags` for now, since it was deprecated by the spec.
2350 cltv_expiry_delta: Readable::read(r)?,
2351 htlc_minimum_msat: Readable::read(r)?,
2352 fee_base_msat: Readable::read(r)?,
2353 fee_proportional_millionths: Readable::read(r)?,
2354 htlc_maximum_msat: Readable::read(r)?,
2355 excess_data: read_to_end(r)?,
2360 impl_writeable!(ChannelUpdate, {
2365 impl Writeable for ErrorMessage {
2366 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2367 self.channel_id.write(w)?;
2368 (self.data.len() as u16).write(w)?;
2369 w.write_all(self.data.as_bytes())?;
2374 impl Readable for ErrorMessage {
2375 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2377 channel_id: Readable::read(r)?,
2379 let sz: usize = <u16 as Readable>::read(r)? as usize;
2380 let mut data = Vec::with_capacity(sz);
2382 r.read_exact(&mut data)?;
2383 match String::from_utf8(data) {
2385 Err(_) => return Err(DecodeError::InvalidValue),
2392 impl Writeable for WarningMessage {
2393 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2394 self.channel_id.write(w)?;
2395 (self.data.len() as u16).write(w)?;
2396 w.write_all(self.data.as_bytes())?;
2401 impl Readable for WarningMessage {
2402 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2404 channel_id: Readable::read(r)?,
2406 let sz: usize = <u16 as Readable>::read(r)? as usize;
2407 let mut data = Vec::with_capacity(sz);
2409 r.read_exact(&mut data)?;
2410 match String::from_utf8(data) {
2412 Err(_) => return Err(DecodeError::InvalidValue),
2419 impl Writeable for UnsignedNodeAnnouncement {
2420 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2421 self.features.write(w)?;
2422 self.timestamp.write(w)?;
2423 self.node_id.write(w)?;
2424 w.write_all(&self.rgb)?;
2425 self.alias.write(w)?;
2427 let mut addr_len = 0;
2428 for addr in self.addresses.iter() {
2429 addr_len += 1 + addr.len();
2431 (addr_len + self.excess_address_data.len() as u16).write(w)?;
2432 for addr in self.addresses.iter() {
2435 w.write_all(&self.excess_address_data[..])?;
2436 w.write_all(&self.excess_data[..])?;
2441 impl Readable for UnsignedNodeAnnouncement {
2442 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2443 let features: NodeFeatures = Readable::read(r)?;
2444 let timestamp: u32 = Readable::read(r)?;
2445 let node_id: NodeId = Readable::read(r)?;
2446 let mut rgb = [0; 3];
2447 r.read_exact(&mut rgb)?;
2448 let alias: NodeAlias = Readable::read(r)?;
2450 let addr_len: u16 = Readable::read(r)?;
2451 let mut addresses: Vec<SocketAddress> = Vec::new();
2452 let mut addr_readpos = 0;
2453 let mut excess = false;
2454 let mut excess_byte = 0;
2456 if addr_len <= addr_readpos { break; }
2457 match Readable::read(r) {
2459 if addr_len < addr_readpos + 1 + addr.len() {
2460 return Err(DecodeError::BadLengthDescriptor);
2462 addr_readpos += (1 + addr.len()) as u16;
2463 addresses.push(addr);
2465 Ok(Err(unknown_descriptor)) => {
2467 excess_byte = unknown_descriptor;
2470 Err(DecodeError::ShortRead) => return Err(DecodeError::BadLengthDescriptor),
2471 Err(e) => return Err(e),
2475 let mut excess_data = vec![];
2476 let excess_address_data = if addr_readpos < addr_len {
2477 let mut excess_address_data = vec![0; (addr_len - addr_readpos) as usize];
2478 r.read_exact(&mut excess_address_data[if excess { 1 } else { 0 }..])?;
2480 excess_address_data[0] = excess_byte;
2485 excess_data.push(excess_byte);
2489 excess_data.extend(read_to_end(r)?.iter());
2490 Ok(UnsignedNodeAnnouncement {
2497 excess_address_data,
2503 impl_writeable!(NodeAnnouncement, {
2508 impl Readable for QueryShortChannelIds {
2509 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2510 let chain_hash: ChainHash = Readable::read(r)?;
2512 let encoding_len: u16 = Readable::read(r)?;
2513 let encoding_type: u8 = Readable::read(r)?;
2515 // Must be encoding_type=0 uncompressed serialization. We do not
2516 // support encoding_type=1 zlib serialization.
2517 if encoding_type != EncodingType::Uncompressed as u8 {
2518 return Err(DecodeError::UnsupportedCompression);
2521 // We expect the encoding_len to always includes the 1-byte
2522 // encoding_type and that short_channel_ids are 8-bytes each
2523 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2524 return Err(DecodeError::InvalidValue);
2527 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2528 // less the 1-byte encoding_type
2529 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2530 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2531 for _ in 0..short_channel_id_count {
2532 short_channel_ids.push(Readable::read(r)?);
2535 Ok(QueryShortChannelIds {
2542 impl Writeable for QueryShortChannelIds {
2543 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2544 // Calculated from 1-byte encoding_type plus 8-bytes per short_channel_id
2545 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2547 self.chain_hash.write(w)?;
2548 encoding_len.write(w)?;
2550 // We only support type=0 uncompressed serialization
2551 (EncodingType::Uncompressed as u8).write(w)?;
2553 for scid in self.short_channel_ids.iter() {
2561 impl_writeable_msg!(ReplyShortChannelIdsEnd, {
2566 impl QueryChannelRange {
2567 /// Calculates the overflow safe ending block height for the query.
2569 /// Overflow returns `0xffffffff`, otherwise returns `first_blocknum + number_of_blocks`.
2570 pub fn end_blocknum(&self) -> u32 {
2571 match self.first_blocknum.checked_add(self.number_of_blocks) {
2572 Some(block) => block,
2573 None => u32::max_value(),
2578 impl_writeable_msg!(QueryChannelRange, {
2584 impl Readable for ReplyChannelRange {
2585 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2586 let chain_hash: ChainHash = Readable::read(r)?;
2587 let first_blocknum: u32 = Readable::read(r)?;
2588 let number_of_blocks: u32 = Readable::read(r)?;
2589 let sync_complete: bool = Readable::read(r)?;
2591 let encoding_len: u16 = Readable::read(r)?;
2592 let encoding_type: u8 = Readable::read(r)?;
2594 // Must be encoding_type=0 uncompressed serialization. We do not
2595 // support encoding_type=1 zlib serialization.
2596 if encoding_type != EncodingType::Uncompressed as u8 {
2597 return Err(DecodeError::UnsupportedCompression);
2600 // We expect the encoding_len to always includes the 1-byte
2601 // encoding_type and that short_channel_ids are 8-bytes each
2602 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2603 return Err(DecodeError::InvalidValue);
2606 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2607 // less the 1-byte encoding_type
2608 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2609 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2610 for _ in 0..short_channel_id_count {
2611 short_channel_ids.push(Readable::read(r)?);
2614 Ok(ReplyChannelRange {
2624 impl Writeable for ReplyChannelRange {
2625 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2626 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2627 self.chain_hash.write(w)?;
2628 self.first_blocknum.write(w)?;
2629 self.number_of_blocks.write(w)?;
2630 self.sync_complete.write(w)?;
2632 encoding_len.write(w)?;
2633 (EncodingType::Uncompressed as u8).write(w)?;
2634 for scid in self.short_channel_ids.iter() {
2642 impl_writeable_msg!(GossipTimestampFilter, {
2650 use std::convert::TryFrom;
2651 use bitcoin::{Transaction, PackedLockTime, TxIn, Script, Sequence, Witness, TxOut};
2653 use crate::ln::{PaymentPreimage, PaymentHash, PaymentSecret};
2654 use crate::ln::ChannelId;
2655 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
2656 use crate::ln::msgs::{self, FinalOnionHopData, OnionErrorPacket};
2657 use crate::ln::msgs::SocketAddress;
2658 use crate::routing::gossip::{NodeAlias, NodeId};
2659 use crate::util::ser::{Writeable, Readable, ReadableArgs, Hostname, TransactionU16LenLimited};
2660 use crate::util::test_utils;
2662 use bitcoin::hashes::hex::FromHex;
2663 use bitcoin::util::address::Address;
2664 use bitcoin::network::constants::Network;
2665 use bitcoin::blockdata::constants::ChainHash;
2666 use bitcoin::blockdata::script::Builder;
2667 use bitcoin::blockdata::opcodes;
2668 use bitcoin::hash_types::Txid;
2670 use bitcoin::secp256k1::{PublicKey,SecretKey};
2671 use bitcoin::secp256k1::{Secp256k1, Message};
2673 use crate::io::{self, Cursor};
2674 use crate::prelude::*;
2675 use core::str::FromStr;
2676 use crate::chain::transaction::OutPoint;
2678 #[cfg(feature = "std")]
2679 use std::net::{Ipv4Addr, Ipv6Addr};
2680 use crate::ln::msgs::SocketAddressParseError;
2683 fn encoding_channel_reestablish() {
2685 let secp_ctx = Secp256k1::new();
2686 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2689 let cr = msgs::ChannelReestablish {
2690 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]),
2691 next_local_commitment_number: 3,
2692 next_remote_commitment_number: 4,
2693 your_last_per_commitment_secret: [9;32],
2694 my_current_per_commitment_point: public_key,
2695 next_funding_txid: None,
2698 let encoded_value = cr.encode();
2702 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
2703 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2704 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2705 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
2706 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
2712 fn encoding_channel_reestablish_with_next_funding_txid() {
2714 let secp_ctx = Secp256k1::new();
2715 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2718 let cr = msgs::ChannelReestablish {
2719 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]),
2720 next_local_commitment_number: 3,
2721 next_remote_commitment_number: 4,
2722 your_last_per_commitment_secret: [9;32],
2723 my_current_per_commitment_point: public_key,
2724 next_funding_txid: Some(Txid::from_hash(bitcoin::hashes::Hash::from_slice(&[
2725 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,
2729 let encoded_value = cr.encode();
2733 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
2734 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2735 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2736 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
2737 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
2738 0, // Type (next_funding_txid)
2740 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
2745 macro_rules! get_keys_from {
2746 ($slice: expr, $secp_ctx: expr) => {
2748 let privkey = SecretKey::from_slice(&hex::decode($slice).unwrap()[..]).unwrap();
2749 let pubkey = PublicKey::from_secret_key(&$secp_ctx, &privkey);
2755 macro_rules! get_sig_on {
2756 ($privkey: expr, $ctx: expr, $string: expr) => {
2758 let sighash = Message::from_slice(&$string.into_bytes()[..]).unwrap();
2759 $ctx.sign_ecdsa(&sighash, &$privkey)
2765 fn encoding_announcement_signatures() {
2766 let secp_ctx = Secp256k1::new();
2767 let (privkey, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2768 let sig_1 = get_sig_on!(privkey, secp_ctx, String::from("01010101010101010101010101010101"));
2769 let sig_2 = get_sig_on!(privkey, secp_ctx, String::from("02020202020202020202020202020202"));
2770 let announcement_signatures = msgs::AnnouncementSignatures {
2771 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]),
2772 short_channel_id: 2316138423780173,
2773 node_signature: sig_1,
2774 bitcoin_signature: sig_2,
2777 let encoded_value = announcement_signatures.encode();
2778 assert_eq!(encoded_value, hex::decode("040000000000000005000000000000000600000000000000070000000000000000083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073acf9953cef4700860f5967838eba2bae89288ad188ebf8b20bf995c3ea53a26df1876d0a3a0e13172ba286a673140190c02ba9da60a2e43a745188c8a83c7f3ef").unwrap());
2781 fn do_encoding_channel_announcement(unknown_features_bits: bool, excess_data: bool) {
2782 let secp_ctx = Secp256k1::new();
2783 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2784 let (privkey_2, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2785 let (privkey_3, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2786 let (privkey_4, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2787 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2788 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
2789 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
2790 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
2791 let mut features = ChannelFeatures::empty();
2792 if unknown_features_bits {
2793 features = ChannelFeatures::from_le_bytes(vec![0xFF, 0xFF]);
2795 let unsigned_channel_announcement = msgs::UnsignedChannelAnnouncement {
2797 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
2798 short_channel_id: 2316138423780173,
2799 node_id_1: NodeId::from_pubkey(&pubkey_1),
2800 node_id_2: NodeId::from_pubkey(&pubkey_2),
2801 bitcoin_key_1: NodeId::from_pubkey(&pubkey_3),
2802 bitcoin_key_2: NodeId::from_pubkey(&pubkey_4),
2803 excess_data: if excess_data { vec![10, 0, 0, 20, 0, 0, 30, 0, 0, 40] } else { Vec::new() },
2805 let channel_announcement = msgs::ChannelAnnouncement {
2806 node_signature_1: sig_1,
2807 node_signature_2: sig_2,
2808 bitcoin_signature_1: sig_3,
2809 bitcoin_signature_2: sig_4,
2810 contents: unsigned_channel_announcement,
2812 let encoded_value = channel_announcement.encode();
2813 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a1735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap();
2814 if unknown_features_bits {
2815 target_value.append(&mut hex::decode("0002ffff").unwrap());
2817 target_value.append(&mut hex::decode("0000").unwrap());
2819 target_value.append(&mut hex::decode("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
2820 target_value.append(&mut hex::decode("00083a840000034d031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
2822 target_value.append(&mut hex::decode("0a00001400001e000028").unwrap());
2824 assert_eq!(encoded_value, target_value);
2828 fn encoding_channel_announcement() {
2829 do_encoding_channel_announcement(true, false);
2830 do_encoding_channel_announcement(false, true);
2831 do_encoding_channel_announcement(false, false);
2832 do_encoding_channel_announcement(true, true);
2835 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) {
2836 let secp_ctx = Secp256k1::new();
2837 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2838 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2839 let features = if unknown_features_bits {
2840 NodeFeatures::from_le_bytes(vec![0xFF, 0xFF])
2842 // Set to some features we may support
2843 NodeFeatures::from_le_bytes(vec![2 | 1 << 5])
2845 let mut addresses = Vec::new();
2847 addresses.push(SocketAddress::TcpIpV4 {
2848 addr: [255, 254, 253, 252],
2853 addresses.push(SocketAddress::TcpIpV6 {
2854 addr: [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240],
2859 addresses.push(msgs::SocketAddress::OnionV2(
2860 [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 38, 7]
2864 addresses.push(msgs::SocketAddress::OnionV3 {
2865 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],
2872 addresses.push(SocketAddress::Hostname {
2873 hostname: Hostname::try_from(String::from("host")).unwrap(),
2877 let mut addr_len = 0;
2878 for addr in &addresses {
2879 addr_len += addr.len() + 1;
2881 let unsigned_node_announcement = msgs::UnsignedNodeAnnouncement {
2883 timestamp: 20190119,
2884 node_id: NodeId::from_pubkey(&pubkey_1),
2886 alias: NodeAlias([16;32]),
2888 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() },
2889 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() },
2891 addr_len += unsigned_node_announcement.excess_address_data.len() as u16;
2892 let node_announcement = msgs::NodeAnnouncement {
2894 contents: unsigned_node_announcement,
2896 let encoded_value = node_announcement.encode();
2897 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
2898 if unknown_features_bits {
2899 target_value.append(&mut hex::decode("0002ffff").unwrap());
2901 target_value.append(&mut hex::decode("000122").unwrap());
2903 target_value.append(&mut hex::decode("013413a7031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f2020201010101010101010101010101010101010101010101010101010101010101010").unwrap());
2904 target_value.append(&mut vec![(addr_len >> 8) as u8, addr_len as u8]);
2906 target_value.append(&mut hex::decode("01fffefdfc2607").unwrap());
2909 target_value.append(&mut hex::decode("02fffefdfcfbfaf9f8f7f6f5f4f3f2f1f02607").unwrap());
2912 target_value.append(&mut hex::decode("03fffefdfcfbfaf9f8f7f62607").unwrap());
2915 target_value.append(&mut hex::decode("04fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0efeeedecebeae9e8e7e6e5e4e3e2e1e00020102607").unwrap());
2918 target_value.append(&mut hex::decode("0504686f73742607").unwrap());
2920 if excess_address_data {
2921 target_value.append(&mut hex::decode("216c280b5395a2546e7e4b2663e04f811622f15a4f92e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d269").unwrap());
2924 target_value.append(&mut hex::decode("3b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
2926 assert_eq!(encoded_value, target_value);
2930 fn encoding_node_announcement() {
2931 do_encoding_node_announcement(true, true, true, true, true, true, true, true);
2932 do_encoding_node_announcement(false, false, false, false, false, false, false, false);
2933 do_encoding_node_announcement(false, true, false, false, false, false, false, false);
2934 do_encoding_node_announcement(false, false, true, false, false, false, false, false);
2935 do_encoding_node_announcement(false, false, false, true, false, false, false, false);
2936 do_encoding_node_announcement(false, false, false, false, true, false, false, false);
2937 do_encoding_node_announcement(false, false, false, false, false, true, false, false);
2938 do_encoding_node_announcement(false, false, false, false, false, false, true, false);
2939 do_encoding_node_announcement(false, true, false, true, false, false, true, false);
2940 do_encoding_node_announcement(false, false, true, false, true, false, false, false);
2943 fn do_encoding_channel_update(direction: bool, disable: bool, excess_data: bool) {
2944 let secp_ctx = Secp256k1::new();
2945 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2946 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2947 let unsigned_channel_update = msgs::UnsignedChannelUpdate {
2948 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
2949 short_channel_id: 2316138423780173,
2950 timestamp: 20190119,
2951 flags: if direction { 1 } else { 0 } | if disable { 1 << 1 } else { 0 },
2952 cltv_expiry_delta: 144,
2953 htlc_minimum_msat: 1000000,
2954 htlc_maximum_msat: 131355275467161,
2955 fee_base_msat: 10000,
2956 fee_proportional_millionths: 20,
2957 excess_data: if excess_data { vec![0, 0, 0, 0, 59, 154, 202, 0] } else { Vec::new() }
2959 let channel_update = msgs::ChannelUpdate {
2961 contents: unsigned_channel_update
2963 let encoded_value = channel_update.encode();
2964 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
2965 target_value.append(&mut hex::decode("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
2966 target_value.append(&mut hex::decode("00083a840000034d013413a7").unwrap());
2967 target_value.append(&mut hex::decode("01").unwrap());
2968 target_value.append(&mut hex::decode("00").unwrap());
2970 let flag = target_value.last_mut().unwrap();
2974 let flag = target_value.last_mut().unwrap();
2975 *flag = *flag | 1 << 1;
2977 target_value.append(&mut hex::decode("009000000000000f42400000271000000014").unwrap());
2978 target_value.append(&mut hex::decode("0000777788889999").unwrap());
2980 target_value.append(&mut hex::decode("000000003b9aca00").unwrap());
2982 assert_eq!(encoded_value, target_value);
2986 fn encoding_channel_update() {
2987 do_encoding_channel_update(false, false, false);
2988 do_encoding_channel_update(false, false, true);
2989 do_encoding_channel_update(true, false, false);
2990 do_encoding_channel_update(true, false, true);
2991 do_encoding_channel_update(false, true, false);
2992 do_encoding_channel_update(false, true, true);
2993 do_encoding_channel_update(true, true, false);
2994 do_encoding_channel_update(true, true, true);
2997 fn do_encoding_open_channel(random_bit: bool, shutdown: bool, incl_chan_type: bool) {
2998 let secp_ctx = Secp256k1::new();
2999 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3000 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3001 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3002 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3003 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3004 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3005 let open_channel = msgs::OpenChannel {
3006 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3007 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3008 funding_satoshis: 1311768467284833366,
3009 push_msat: 2536655962884945560,
3010 dust_limit_satoshis: 3608586615801332854,
3011 max_htlc_value_in_flight_msat: 8517154655701053848,
3012 channel_reserve_satoshis: 8665828695742877976,
3013 htlc_minimum_msat: 2316138423780173,
3014 feerate_per_kw: 821716,
3015 to_self_delay: 49340,
3016 max_accepted_htlcs: 49340,
3017 funding_pubkey: pubkey_1,
3018 revocation_basepoint: pubkey_2,
3019 payment_point: pubkey_3,
3020 delayed_payment_basepoint: pubkey_4,
3021 htlc_basepoint: pubkey_5,
3022 first_per_commitment_point: pubkey_6,
3023 channel_flags: if random_bit { 1 << 5 } else { 0 },
3024 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3025 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3027 let encoded_value = open_channel.encode();
3028 let mut target_value = Vec::new();
3029 target_value.append(&mut hex::decode("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3030 target_value.append(&mut hex::decode("02020202020202020202020202020202020202020202020202020202020202021234567890123456233403289122369832144668701144767633030896203198784335490624111800083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3032 target_value.append(&mut hex::decode("20").unwrap());
3034 target_value.append(&mut hex::decode("00").unwrap());
3037 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3040 target_value.append(&mut hex::decode("0100").unwrap());
3042 assert_eq!(encoded_value, target_value);
3046 fn encoding_open_channel() {
3047 do_encoding_open_channel(false, false, false);
3048 do_encoding_open_channel(false, false, true);
3049 do_encoding_open_channel(false, true, false);
3050 do_encoding_open_channel(false, true, true);
3051 do_encoding_open_channel(true, false, false);
3052 do_encoding_open_channel(true, false, true);
3053 do_encoding_open_channel(true, true, false);
3054 do_encoding_open_channel(true, true, true);
3057 fn do_encoding_open_channelv2(random_bit: bool, shutdown: bool, incl_chan_type: bool, require_confirmed_inputs: bool) {
3058 let secp_ctx = Secp256k1::new();
3059 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3060 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3061 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3062 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3063 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3064 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3065 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3066 let open_channelv2 = msgs::OpenChannelV2 {
3067 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3068 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3069 funding_feerate_sat_per_1000_weight: 821716,
3070 commitment_feerate_sat_per_1000_weight: 821716,
3071 funding_satoshis: 1311768467284833366,
3072 dust_limit_satoshis: 3608586615801332854,
3073 max_htlc_value_in_flight_msat: 8517154655701053848,
3074 htlc_minimum_msat: 2316138423780173,
3075 to_self_delay: 49340,
3076 max_accepted_htlcs: 49340,
3077 locktime: 305419896,
3078 funding_pubkey: pubkey_1,
3079 revocation_basepoint: pubkey_2,
3080 payment_basepoint: pubkey_3,
3081 delayed_payment_basepoint: pubkey_4,
3082 htlc_basepoint: pubkey_5,
3083 first_per_commitment_point: pubkey_6,
3084 second_per_commitment_point: pubkey_7,
3085 channel_flags: if random_bit { 1 << 5 } else { 0 },
3086 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3087 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3088 require_confirmed_inputs: if require_confirmed_inputs { Some(()) } else { None },
3090 let encoded_value = open_channelv2.encode();
3091 let mut target_value = Vec::new();
3092 target_value.append(&mut hex::decode("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3093 target_value.append(&mut hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap());
3094 target_value.append(&mut hex::decode("000c89d4").unwrap());
3095 target_value.append(&mut hex::decode("000c89d4").unwrap());
3096 target_value.append(&mut hex::decode("1234567890123456").unwrap());
3097 target_value.append(&mut hex::decode("3214466870114476").unwrap());
3098 target_value.append(&mut hex::decode("7633030896203198").unwrap());
3099 target_value.append(&mut hex::decode("00083a840000034d").unwrap());
3100 target_value.append(&mut hex::decode("c0bc").unwrap());
3101 target_value.append(&mut hex::decode("c0bc").unwrap());
3102 target_value.append(&mut hex::decode("12345678").unwrap());
3103 target_value.append(&mut hex::decode("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap());
3104 target_value.append(&mut hex::decode("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap());
3105 target_value.append(&mut hex::decode("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap());
3106 target_value.append(&mut hex::decode("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
3107 target_value.append(&mut hex::decode("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap());
3108 target_value.append(&mut hex::decode("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3109 target_value.append(&mut hex::decode("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap());
3112 target_value.append(&mut hex::decode("20").unwrap());
3114 target_value.append(&mut hex::decode("00").unwrap());
3117 target_value.append(&mut hex::decode("001b").unwrap()); // Type 0 + Length 27
3118 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3121 target_value.append(&mut hex::decode("0100").unwrap());
3123 if require_confirmed_inputs {
3124 target_value.append(&mut hex::decode("0200").unwrap());
3126 assert_eq!(encoded_value, target_value);
3130 fn encoding_open_channelv2() {
3131 do_encoding_open_channelv2(false, false, false, false);
3132 do_encoding_open_channelv2(false, false, false, true);
3133 do_encoding_open_channelv2(false, false, true, false);
3134 do_encoding_open_channelv2(false, false, true, true);
3135 do_encoding_open_channelv2(false, true, false, false);
3136 do_encoding_open_channelv2(false, true, false, true);
3137 do_encoding_open_channelv2(false, true, true, false);
3138 do_encoding_open_channelv2(false, true, true, true);
3139 do_encoding_open_channelv2(true, false, false, false);
3140 do_encoding_open_channelv2(true, false, false, true);
3141 do_encoding_open_channelv2(true, false, true, false);
3142 do_encoding_open_channelv2(true, false, true, true);
3143 do_encoding_open_channelv2(true, true, false, false);
3144 do_encoding_open_channelv2(true, true, false, true);
3145 do_encoding_open_channelv2(true, true, true, false);
3146 do_encoding_open_channelv2(true, true, true, true);
3149 fn do_encoding_accept_channel(shutdown: bool) {
3150 let secp_ctx = Secp256k1::new();
3151 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3152 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3153 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3154 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3155 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3156 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3157 let accept_channel = msgs::AcceptChannel {
3158 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3159 dust_limit_satoshis: 1311768467284833366,
3160 max_htlc_value_in_flight_msat: 2536655962884945560,
3161 channel_reserve_satoshis: 3608586615801332854,
3162 htlc_minimum_msat: 2316138423780173,
3163 minimum_depth: 821716,
3164 to_self_delay: 49340,
3165 max_accepted_htlcs: 49340,
3166 funding_pubkey: pubkey_1,
3167 revocation_basepoint: pubkey_2,
3168 payment_point: pubkey_3,
3169 delayed_payment_basepoint: pubkey_4,
3170 htlc_basepoint: pubkey_5,
3171 first_per_commitment_point: pubkey_6,
3172 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3175 next_local_nonce: None,
3177 let encoded_value = accept_channel.encode();
3178 let mut target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020212345678901234562334032891223698321446687011447600083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap();
3180 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3182 assert_eq!(encoded_value, target_value);
3186 fn encoding_accept_channel() {
3187 do_encoding_accept_channel(false);
3188 do_encoding_accept_channel(true);
3191 fn do_encoding_accept_channelv2(shutdown: bool) {
3192 let secp_ctx = Secp256k1::new();
3193 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3194 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3195 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3196 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3197 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3198 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3199 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3200 let accept_channelv2 = msgs::AcceptChannelV2 {
3201 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3202 funding_satoshis: 1311768467284833366,
3203 dust_limit_satoshis: 1311768467284833366,
3204 max_htlc_value_in_flight_msat: 2536655962884945560,
3205 htlc_minimum_msat: 2316138423780173,
3206 minimum_depth: 821716,
3207 to_self_delay: 49340,
3208 max_accepted_htlcs: 49340,
3209 funding_pubkey: pubkey_1,
3210 revocation_basepoint: pubkey_2,
3211 payment_basepoint: pubkey_3,
3212 delayed_payment_basepoint: pubkey_4,
3213 htlc_basepoint: pubkey_5,
3214 first_per_commitment_point: pubkey_6,
3215 second_per_commitment_point: pubkey_7,
3216 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3218 require_confirmed_inputs: None,
3220 let encoded_value = accept_channelv2.encode();
3221 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // temporary_channel_id
3222 target_value.append(&mut hex::decode("1234567890123456").unwrap()); // funding_satoshis
3223 target_value.append(&mut hex::decode("1234567890123456").unwrap()); // dust_limit_satoshis
3224 target_value.append(&mut hex::decode("2334032891223698").unwrap()); // max_htlc_value_in_flight_msat
3225 target_value.append(&mut hex::decode("00083a840000034d").unwrap()); // htlc_minimum_msat
3226 target_value.append(&mut hex::decode("000c89d4").unwrap()); // minimum_depth
3227 target_value.append(&mut hex::decode("c0bc").unwrap()); // to_self_delay
3228 target_value.append(&mut hex::decode("c0bc").unwrap()); // max_accepted_htlcs
3229 target_value.append(&mut hex::decode("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap()); // funding_pubkey
3230 target_value.append(&mut hex::decode("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap()); // revocation_basepoint
3231 target_value.append(&mut hex::decode("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap()); // payment_basepoint
3232 target_value.append(&mut hex::decode("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap()); // delayed_payment_basepoint
3233 target_value.append(&mut hex::decode("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap()); // htlc_basepoint
3234 target_value.append(&mut hex::decode("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap()); // first_per_commitment_point
3235 target_value.append(&mut hex::decode("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap()); // second_per_commitment_point
3237 target_value.append(&mut hex::decode("001b").unwrap()); // Type 0 + Length 27
3238 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3240 assert_eq!(encoded_value, target_value);
3244 fn encoding_accept_channelv2() {
3245 do_encoding_accept_channelv2(false);
3246 do_encoding_accept_channelv2(true);
3250 fn encoding_funding_created() {
3251 let secp_ctx = Secp256k1::new();
3252 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3253 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3254 let funding_created = msgs::FundingCreated {
3255 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3256 funding_txid: Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3257 funding_output_index: 255,
3260 partial_signature_with_nonce: None,
3262 next_local_nonce: None,
3264 let encoded_value = funding_created.encode();
3265 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202026e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c200ffd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3266 assert_eq!(encoded_value, target_value);
3270 fn encoding_funding_signed() {
3271 let secp_ctx = Secp256k1::new();
3272 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3273 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3274 let funding_signed = msgs::FundingSigned {
3275 channel_id: ChannelId::from_bytes([2; 32]),
3278 partial_signature_with_nonce: None,
3280 let encoded_value = funding_signed.encode();
3281 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3282 assert_eq!(encoded_value, target_value);
3286 fn encoding_channel_ready() {
3287 let secp_ctx = Secp256k1::new();
3288 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3289 let channel_ready = msgs::ChannelReady {
3290 channel_id: ChannelId::from_bytes([2; 32]),
3291 next_per_commitment_point: pubkey_1,
3292 short_channel_id_alias: None,
3294 let encoded_value = channel_ready.encode();
3295 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3296 assert_eq!(encoded_value, target_value);
3300 fn encoding_tx_add_input() {
3301 let tx_add_input = msgs::TxAddInput {
3302 channel_id: ChannelId::from_bytes([2; 32]),
3303 serial_id: 4886718345,
3304 prevtx: TransactionU16LenLimited::new(Transaction {
3306 lock_time: PackedLockTime(0),
3308 previous_output: OutPoint { txid: Txid::from_hex("305bab643ee297b8b6b76b320792c8223d55082122cb606bf89382146ced9c77").unwrap(), index: 2 }.into_bitcoin_outpoint(),
3309 script_sig: Script::new(),
3310 sequence: Sequence(0xfffffffd),
3311 witness: Witness::from_vec(vec![
3312 hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3313 hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3318 script_pubkey: Address::from_str("bc1qzlffunw52jav8vwdu5x3jfk6sr8u22rmq3xzw2").unwrap().script_pubkey(),
3322 script_pubkey: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().script_pubkey(),
3326 prevtx_out: 305419896,
3327 sequence: 305419896,
3329 let encoded_value = tx_add_input.encode();
3330 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000000012345678900de02000000000101779ced6c148293f86b60cb222108553d22c89207326bb7b6b897e23e64ab5b300200000000fdffffff0236dbc1000000000016001417d29e4dd454bac3b1cde50d1926da80cfc5287b9cbd03000000000016001436ec78d514df462da95e6a00c24daa8915362d420247304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701210301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944000000001234567812345678").unwrap();
3331 assert_eq!(encoded_value, target_value);
3335 fn encoding_tx_add_output() {
3336 let tx_add_output = msgs::TxAddOutput {
3337 channel_id: ChannelId::from_bytes([2; 32]),
3338 serial_id: 4886718345,
3340 script: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().script_pubkey(),
3342 let encoded_value = tx_add_output.encode();
3343 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000000012345678900000001234567890016001436ec78d514df462da95e6a00c24daa8915362d42").unwrap();
3344 assert_eq!(encoded_value, target_value);
3348 fn encoding_tx_remove_input() {
3349 let tx_remove_input = msgs::TxRemoveInput {
3350 channel_id: ChannelId::from_bytes([2; 32]),
3351 serial_id: 4886718345,
3353 let encoded_value = tx_remove_input.encode();
3354 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3355 assert_eq!(encoded_value, target_value);
3359 fn encoding_tx_remove_output() {
3360 let tx_remove_output = msgs::TxRemoveOutput {
3361 channel_id: ChannelId::from_bytes([2; 32]),
3362 serial_id: 4886718345,
3364 let encoded_value = tx_remove_output.encode();
3365 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3366 assert_eq!(encoded_value, target_value);
3370 fn encoding_tx_complete() {
3371 let tx_complete = msgs::TxComplete {
3372 channel_id: ChannelId::from_bytes([2; 32]),
3374 let encoded_value = tx_complete.encode();
3375 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3376 assert_eq!(encoded_value, target_value);
3380 fn encoding_tx_signatures() {
3381 let tx_signatures = msgs::TxSignatures {
3382 channel_id: ChannelId::from_bytes([2; 32]),
3383 tx_hash: Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3385 Witness::from_vec(vec![
3386 hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3387 hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3388 Witness::from_vec(vec![
3389 hex::decode("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap(),
3390 hex::decode("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap()]),
3393 let encoded_value = tx_signatures.encode();
3394 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3395 target_value.append(&mut hex::decode("6e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c2").unwrap()); // tx_hash (sha256) (big endian byte order)
3396 target_value.append(&mut hex::decode("0002").unwrap()); // num_witnesses (u16)
3398 target_value.append(&mut hex::decode("006b").unwrap()); // len of witness_data
3399 target_value.append(&mut hex::decode("02").unwrap()); // num_witness_elements (VarInt)
3400 target_value.append(&mut hex::decode("47").unwrap()); // len of witness element data (VarInt)
3401 target_value.append(&mut hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap());
3402 target_value.append(&mut hex::decode("21").unwrap()); // len of witness element data (VarInt)
3403 target_value.append(&mut hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap());
3405 target_value.append(&mut hex::decode("006c").unwrap()); // len of witness_data
3406 target_value.append(&mut hex::decode("02").unwrap()); // num_witness_elements (VarInt)
3407 target_value.append(&mut hex::decode("48").unwrap()); // len of witness element data (VarInt)
3408 target_value.append(&mut hex::decode("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap());
3409 target_value.append(&mut hex::decode("21").unwrap()); // len of witness element data (VarInt)
3410 target_value.append(&mut hex::decode("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap());
3411 assert_eq!(encoded_value, target_value);
3414 fn do_encoding_tx_init_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3415 let tx_init_rbf = msgs::TxInitRbf {
3416 channel_id: ChannelId::from_bytes([2; 32]),
3417 locktime: 305419896,
3418 feerate_sat_per_1000_weight: 20190119,
3419 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3421 let encoded_value = tx_init_rbf.encode();
3422 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3423 target_value.append(&mut hex::decode("12345678").unwrap()); // locktime
3424 target_value.append(&mut hex::decode("013413a7").unwrap()); // feerate_sat_per_1000_weight
3425 if let Some((_, target)) = funding_value_with_hex_target {
3426 target_value.push(0x00); // Type
3427 target_value.push(target.len() as u8 / 2); // Length
3428 target_value.append(&mut hex::decode(target).unwrap()); // Value (i64)
3430 assert_eq!(encoded_value, target_value);
3434 fn encoding_tx_init_rbf() {
3435 do_encoding_tx_init_rbf(Some((1311768467284833366, "1234567890123456")));
3436 do_encoding_tx_init_rbf(Some((13117684672, "000000030DDFFBC0")));
3437 do_encoding_tx_init_rbf(None);
3440 fn do_encoding_tx_ack_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3441 let tx_ack_rbf = msgs::TxAckRbf {
3442 channel_id: ChannelId::from_bytes([2; 32]),
3443 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3445 let encoded_value = tx_ack_rbf.encode();
3446 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3447 if let Some((_, target)) = funding_value_with_hex_target {
3448 target_value.push(0x00); // Type
3449 target_value.push(target.len() as u8 / 2); // Length
3450 target_value.append(&mut hex::decode(target).unwrap()); // Value (i64)
3452 assert_eq!(encoded_value, target_value);
3456 fn encoding_tx_ack_rbf() {
3457 do_encoding_tx_ack_rbf(Some((1311768467284833366, "1234567890123456")));
3458 do_encoding_tx_ack_rbf(Some((13117684672, "000000030DDFFBC0")));
3459 do_encoding_tx_ack_rbf(None);
3463 fn encoding_tx_abort() {
3464 let tx_abort = msgs::TxAbort {
3465 channel_id: ChannelId::from_bytes([2; 32]),
3466 data: hex::decode("54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap(),
3468 let encoded_value = tx_abort.encode();
3469 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202002C54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap();
3470 assert_eq!(encoded_value, target_value);
3473 fn do_encoding_shutdown(script_type: u8) {
3474 let secp_ctx = Secp256k1::new();
3475 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3476 let script = Builder::new().push_opcode(opcodes::OP_TRUE).into_script();
3477 let shutdown = msgs::Shutdown {
3478 channel_id: ChannelId::from_bytes([2; 32]),
3480 if script_type == 1 { Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey() }
3481 else if script_type == 2 { Address::p2sh(&script, Network::Testnet).unwrap().script_pubkey() }
3482 else if script_type == 3 { Address::p2wpkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).unwrap().script_pubkey() }
3483 else { Address::p2wsh(&script, Network::Testnet).script_pubkey() },
3485 let encoded_value = shutdown.encode();
3486 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3487 if script_type == 1 {
3488 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3489 } else if script_type == 2 {
3490 target_value.append(&mut hex::decode("0017a914da1745e9b549bd0bfa1a569971c77eba30cd5a4b87").unwrap());
3491 } else if script_type == 3 {
3492 target_value.append(&mut hex::decode("0016001479b000887626b294a914501a4cd226b58b235983").unwrap());
3493 } else if script_type == 4 {
3494 target_value.append(&mut hex::decode("002200204ae81572f06e1b88fd5ced7a1a000945432e83e1551e6f721ee9c00b8cc33260").unwrap());
3496 assert_eq!(encoded_value, target_value);
3500 fn encoding_shutdown() {
3501 do_encoding_shutdown(1);
3502 do_encoding_shutdown(2);
3503 do_encoding_shutdown(3);
3504 do_encoding_shutdown(4);
3508 fn encoding_closing_signed() {
3509 let secp_ctx = Secp256k1::new();
3510 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3511 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3512 let closing_signed = msgs::ClosingSigned {
3513 channel_id: ChannelId::from_bytes([2; 32]),
3514 fee_satoshis: 2316138423780173,
3518 let encoded_value = closing_signed.encode();
3519 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3520 assert_eq!(encoded_value, target_value);
3521 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value)).unwrap(), closing_signed);
3523 let closing_signed_with_range = msgs::ClosingSigned {
3524 channel_id: ChannelId::from_bytes([2; 32]),
3525 fee_satoshis: 2316138423780173,
3527 fee_range: Some(msgs::ClosingSignedFeeRange {
3528 min_fee_satoshis: 0xdeadbeef,
3529 max_fee_satoshis: 0x1badcafe01234567,
3532 let encoded_value_with_range = closing_signed_with_range.encode();
3533 let target_value_with_range = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a011000000000deadbeef1badcafe01234567").unwrap();
3534 assert_eq!(encoded_value_with_range, target_value_with_range);
3535 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value_with_range)).unwrap(),
3536 closing_signed_with_range);
3540 fn encoding_update_add_htlc() {
3541 let secp_ctx = Secp256k1::new();
3542 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3543 let onion_routing_packet = msgs::OnionPacket {
3545 public_key: Ok(pubkey_1),
3546 hop_data: [1; 20*65],
3549 let update_add_htlc = msgs::UpdateAddHTLC {
3550 channel_id: ChannelId::from_bytes([2; 32]),
3551 htlc_id: 2316138423780173,
3552 amount_msat: 3608586615801332854,
3553 payment_hash: PaymentHash([1; 32]),
3554 cltv_expiry: 821716,
3555 onion_routing_packet,
3556 skimmed_fee_msat: None,
3558 let encoded_value = update_add_htlc.encode();
3559 let target_value = hex::decode("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").unwrap();
3560 assert_eq!(encoded_value, target_value);
3564 fn encoding_update_fulfill_htlc() {
3565 let update_fulfill_htlc = msgs::UpdateFulfillHTLC {
3566 channel_id: ChannelId::from_bytes([2; 32]),
3567 htlc_id: 2316138423780173,
3568 payment_preimage: PaymentPreimage([1; 32]),
3570 let encoded_value = update_fulfill_htlc.encode();
3571 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d0101010101010101010101010101010101010101010101010101010101010101").unwrap();
3572 assert_eq!(encoded_value, target_value);
3576 fn encoding_update_fail_htlc() {
3577 let reason = OnionErrorPacket {
3578 data: [1; 32].to_vec(),
3580 let update_fail_htlc = msgs::UpdateFailHTLC {
3581 channel_id: ChannelId::from_bytes([2; 32]),
3582 htlc_id: 2316138423780173,
3585 let encoded_value = update_fail_htlc.encode();
3586 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d00200101010101010101010101010101010101010101010101010101010101010101").unwrap();
3587 assert_eq!(encoded_value, target_value);
3591 fn encoding_update_fail_malformed_htlc() {
3592 let update_fail_malformed_htlc = msgs::UpdateFailMalformedHTLC {
3593 channel_id: ChannelId::from_bytes([2; 32]),
3594 htlc_id: 2316138423780173,
3595 sha256_of_onion: [1; 32],
3598 let encoded_value = update_fail_malformed_htlc.encode();
3599 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d010101010101010101010101010101010101010101010101010101010101010100ff").unwrap();
3600 assert_eq!(encoded_value, target_value);
3603 fn do_encoding_commitment_signed(htlcs: bool) {
3604 let secp_ctx = Secp256k1::new();
3605 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3606 let (privkey_2, _) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3607 let (privkey_3, _) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3608 let (privkey_4, _) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3609 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3610 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
3611 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
3612 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
3613 let commitment_signed = msgs::CommitmentSigned {
3614 channel_id: ChannelId::from_bytes([2; 32]),
3616 htlc_signatures: if htlcs { vec![sig_2, sig_3, sig_4] } else { Vec::new() },
3618 partial_signature_with_nonce: None,
3620 let encoded_value = commitment_signed.encode();
3621 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3623 target_value.append(&mut hex::decode("00031735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
3625 target_value.append(&mut hex::decode("0000").unwrap());
3627 assert_eq!(encoded_value, target_value);
3631 fn encoding_commitment_signed() {
3632 do_encoding_commitment_signed(true);
3633 do_encoding_commitment_signed(false);
3637 fn encoding_revoke_and_ack() {
3638 let secp_ctx = Secp256k1::new();
3639 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3640 let raa = msgs::RevokeAndACK {
3641 channel_id: ChannelId::from_bytes([2; 32]),
3642 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],
3643 next_per_commitment_point: pubkey_1,
3645 next_local_nonce: None,
3647 let encoded_value = raa.encode();
3648 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020101010101010101010101010101010101010101010101010101010101010101031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3649 assert_eq!(encoded_value, target_value);
3653 fn encoding_update_fee() {
3654 let update_fee = msgs::UpdateFee {
3655 channel_id: ChannelId::from_bytes([2; 32]),
3656 feerate_per_kw: 20190119,
3658 let encoded_value = update_fee.encode();
3659 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202013413a7").unwrap();
3660 assert_eq!(encoded_value, target_value);
3664 fn encoding_init() {
3665 let mainnet_hash = ChainHash::using_genesis_block(Network::Bitcoin);
3666 assert_eq!(msgs::Init {
3667 features: InitFeatures::from_le_bytes(vec![0xFF, 0xFF, 0xFF]),
3668 networks: Some(vec![mainnet_hash]),
3669 remote_network_address: None,
3670 }.encode(), hex::decode("00023fff0003ffffff01206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3671 assert_eq!(msgs::Init {
3672 features: InitFeatures::from_le_bytes(vec![0xFF]),
3674 remote_network_address: None,
3675 }.encode(), hex::decode("0001ff0001ff").unwrap());
3676 assert_eq!(msgs::Init {
3677 features: InitFeatures::from_le_bytes(vec![]),
3678 networks: Some(vec![mainnet_hash]),
3679 remote_network_address: None,
3680 }.encode(), hex::decode("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3681 assert_eq!(msgs::Init {
3682 features: InitFeatures::from_le_bytes(vec![]),
3683 networks: Some(vec![ChainHash::from(&[1; 32][..]), ChainHash::from(&[2; 32][..])]),
3684 remote_network_address: None,
3685 }.encode(), hex::decode("00000000014001010101010101010101010101010101010101010101010101010101010101010202020202020202020202020202020202020202020202020202020202020202").unwrap());
3686 let init_msg = msgs::Init { features: InitFeatures::from_le_bytes(vec![]),
3687 networks: Some(vec![mainnet_hash]),
3688 remote_network_address: Some(SocketAddress::TcpIpV4 {
3689 addr: [127, 0, 0, 1],
3693 let encoded_value = init_msg.encode();
3694 let target_value = hex::decode("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d61900000000000307017f00000103e8").unwrap();
3695 assert_eq!(encoded_value, target_value);
3696 assert_eq!(msgs::Init::read(&mut Cursor::new(&target_value)).unwrap(), init_msg);
3700 fn encoding_error() {
3701 let error = msgs::ErrorMessage {
3702 channel_id: ChannelId::from_bytes([2; 32]),
3703 data: String::from("rust-lightning"),
3705 let encoded_value = error.encode();
3706 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3707 assert_eq!(encoded_value, target_value);
3711 fn encoding_warning() {
3712 let error = msgs::WarningMessage {
3713 channel_id: ChannelId::from_bytes([2; 32]),
3714 data: String::from("rust-lightning"),
3716 let encoded_value = error.encode();
3717 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3718 assert_eq!(encoded_value, target_value);
3722 fn encoding_ping() {
3723 let ping = msgs::Ping {
3727 let encoded_value = ping.encode();
3728 let target_value = hex::decode("0040004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3729 assert_eq!(encoded_value, target_value);
3733 fn encoding_pong() {
3734 let pong = msgs::Pong {
3737 let encoded_value = pong.encode();
3738 let target_value = hex::decode("004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3739 assert_eq!(encoded_value, target_value);
3743 fn encoding_nonfinal_onion_hop_data() {
3744 let outbound_msg = msgs::OutboundOnionPayload::Forward {
3745 short_channel_id: 0xdeadbeef1bad1dea,
3746 amt_to_forward: 0x0badf00d01020304,
3747 outgoing_cltv_value: 0xffffffff,
3749 let encoded_value = outbound_msg.encode();
3750 let target_value = hex::decode("1a02080badf00d010203040404ffffffff0608deadbeef1bad1dea").unwrap();
3751 assert_eq!(encoded_value, target_value);
3753 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3754 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
3755 if let msgs::InboundOnionPayload::Forward {
3756 short_channel_id, amt_to_forward, outgoing_cltv_value
3758 assert_eq!(short_channel_id, 0xdeadbeef1bad1dea);
3759 assert_eq!(amt_to_forward, 0x0badf00d01020304);
3760 assert_eq!(outgoing_cltv_value, 0xffffffff);
3761 } else { panic!(); }
3765 fn encoding_final_onion_hop_data() {
3766 let outbound_msg = msgs::OutboundOnionPayload::Receive {
3768 payment_metadata: None,
3769 keysend_preimage: None,
3770 amt_msat: 0x0badf00d01020304,
3771 outgoing_cltv_value: 0xffffffff,
3772 custom_tlvs: vec![],
3774 let encoded_value = outbound_msg.encode();
3775 let target_value = hex::decode("1002080badf00d010203040404ffffffff").unwrap();
3776 assert_eq!(encoded_value, target_value);
3778 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3779 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
3780 if let msgs::InboundOnionPayload::Receive {
3781 payment_data: None, amt_msat, outgoing_cltv_value, ..
3783 assert_eq!(amt_msat, 0x0badf00d01020304);
3784 assert_eq!(outgoing_cltv_value, 0xffffffff);
3785 } else { panic!(); }
3789 fn encoding_final_onion_hop_data_with_secret() {
3790 let expected_payment_secret = PaymentSecret([0x42u8; 32]);
3791 let outbound_msg = msgs::OutboundOnionPayload::Receive {
3792 payment_data: Some(FinalOnionHopData {
3793 payment_secret: expected_payment_secret,
3794 total_msat: 0x1badca1f
3796 payment_metadata: None,
3797 keysend_preimage: None,
3798 amt_msat: 0x0badf00d01020304,
3799 outgoing_cltv_value: 0xffffffff,
3800 custom_tlvs: vec![],
3802 let encoded_value = outbound_msg.encode();
3803 let target_value = hex::decode("3602080badf00d010203040404ffffffff082442424242424242424242424242424242424242424242424242424242424242421badca1f").unwrap();
3804 assert_eq!(encoded_value, target_value);
3806 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3807 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
3808 if let msgs::InboundOnionPayload::Receive {
3809 payment_data: Some(FinalOnionHopData {
3811 total_msat: 0x1badca1f
3813 amt_msat, outgoing_cltv_value,
3814 payment_metadata: None,
3815 keysend_preimage: None,
3818 assert_eq!(payment_secret, expected_payment_secret);
3819 assert_eq!(amt_msat, 0x0badf00d01020304);
3820 assert_eq!(outgoing_cltv_value, 0xffffffff);
3821 assert_eq!(custom_tlvs, vec![]);
3822 } else { panic!(); }
3826 fn encoding_final_onion_hop_data_with_bad_custom_tlvs() {
3827 // If custom TLVs have type number within the range reserved for protocol, treat them as if
3829 let bad_type_range_tlvs = vec![
3830 ((1 << 16) - 4, vec![42]),
3831 ((1 << 16) - 2, vec![42; 32]),
3833 let mut msg = msgs::OutboundOnionPayload::Receive {
3835 payment_metadata: None,
3836 keysend_preimage: None,
3837 custom_tlvs: bad_type_range_tlvs,
3838 amt_msat: 0x0badf00d01020304,
3839 outgoing_cltv_value: 0xffffffff,
3841 let encoded_value = msg.encode();
3842 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3843 assert!(msgs::InboundOnionPayload::read(&mut Cursor::new(&encoded_value[..]), &&node_signer).is_err());
3844 let good_type_range_tlvs = vec![
3845 ((1 << 16) - 3, vec![42]),
3846 ((1 << 16) - 1, vec![42; 32]),
3848 if let msgs::OutboundOnionPayload::Receive { ref mut custom_tlvs, .. } = msg {
3849 *custom_tlvs = good_type_range_tlvs.clone();
3851 let encoded_value = msg.encode();
3852 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&encoded_value[..]), &&node_signer).unwrap();
3854 msgs::InboundOnionPayload::Receive { custom_tlvs, .. } => assert!(custom_tlvs.is_empty()),
3860 fn encoding_final_onion_hop_data_with_custom_tlvs() {
3861 let expected_custom_tlvs = vec![
3862 (5482373483, vec![0x12, 0x34]),
3863 (5482373487, vec![0x42u8; 8]),
3865 let msg = msgs::OutboundOnionPayload::Receive {
3867 payment_metadata: None,
3868 keysend_preimage: None,
3869 custom_tlvs: expected_custom_tlvs.clone(),
3870 amt_msat: 0x0badf00d01020304,
3871 outgoing_cltv_value: 0xffffffff,
3873 let encoded_value = msg.encode();
3874 let target_value = hex::decode("2e02080badf00d010203040404ffffffffff0000000146c6616b021234ff0000000146c6616f084242424242424242").unwrap();
3875 assert_eq!(encoded_value, target_value);
3876 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3877 let inbound_msg: msgs::InboundOnionPayload = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
3878 if let msgs::InboundOnionPayload::Receive {
3880 payment_metadata: None,
3881 keysend_preimage: None,
3884 outgoing_cltv_value,
3887 assert_eq!(custom_tlvs, expected_custom_tlvs);
3888 assert_eq!(amt_msat, 0x0badf00d01020304);
3889 assert_eq!(outgoing_cltv_value, 0xffffffff);
3890 } else { panic!(); }
3894 fn query_channel_range_end_blocknum() {
3895 let tests: Vec<(u32, u32, u32)> = vec![
3896 (10000, 1500, 11500),
3897 (0, 0xffffffff, 0xffffffff),
3898 (1, 0xffffffff, 0xffffffff),
3901 for (first_blocknum, number_of_blocks, expected) in tests.into_iter() {
3902 let sut = msgs::QueryChannelRange {
3903 chain_hash: ChainHash::using_genesis_block(Network::Regtest),
3907 assert_eq!(sut.end_blocknum(), expected);
3912 fn encoding_query_channel_range() {
3913 let mut query_channel_range = msgs::QueryChannelRange {
3914 chain_hash: ChainHash::using_genesis_block(Network::Regtest),
3915 first_blocknum: 100000,
3916 number_of_blocks: 1500,
3918 let encoded_value = query_channel_range.encode();
3919 let target_value = hex::decode("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000186a0000005dc").unwrap();
3920 assert_eq!(encoded_value, target_value);
3922 query_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3923 assert_eq!(query_channel_range.first_blocknum, 100000);
3924 assert_eq!(query_channel_range.number_of_blocks, 1500);
3928 fn encoding_reply_channel_range() {
3929 do_encoding_reply_channel_range(0);
3930 do_encoding_reply_channel_range(1);
3933 fn do_encoding_reply_channel_range(encoding_type: u8) {
3934 let mut target_value = hex::decode("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000b8a06000005dc01").unwrap();
3935 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
3936 let mut reply_channel_range = msgs::ReplyChannelRange {
3937 chain_hash: expected_chain_hash,
3938 first_blocknum: 756230,
3939 number_of_blocks: 1500,
3940 sync_complete: true,
3941 short_channel_ids: vec![0x000000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
3944 if encoding_type == 0 {
3945 target_value.append(&mut hex::decode("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
3946 let encoded_value = reply_channel_range.encode();
3947 assert_eq!(encoded_value, target_value);
3949 reply_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3950 assert_eq!(reply_channel_range.chain_hash, expected_chain_hash);
3951 assert_eq!(reply_channel_range.first_blocknum, 756230);
3952 assert_eq!(reply_channel_range.number_of_blocks, 1500);
3953 assert_eq!(reply_channel_range.sync_complete, true);
3954 assert_eq!(reply_channel_range.short_channel_ids[0], 0x000000000000008e);
3955 assert_eq!(reply_channel_range.short_channel_ids[1], 0x0000000000003c69);
3956 assert_eq!(reply_channel_range.short_channel_ids[2], 0x000000000045a6c4);
3958 target_value.append(&mut hex::decode("001601789c636000833e08659309a65878be010010a9023a").unwrap());
3959 let result: Result<msgs::ReplyChannelRange, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
3960 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
3965 fn encoding_query_short_channel_ids() {
3966 do_encoding_query_short_channel_ids(0);
3967 do_encoding_query_short_channel_ids(1);
3970 fn do_encoding_query_short_channel_ids(encoding_type: u8) {
3971 let mut target_value = hex::decode("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3972 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
3973 let mut query_short_channel_ids = msgs::QueryShortChannelIds {
3974 chain_hash: expected_chain_hash,
3975 short_channel_ids: vec![0x0000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
3978 if encoding_type == 0 {
3979 target_value.append(&mut hex::decode("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
3980 let encoded_value = query_short_channel_ids.encode();
3981 assert_eq!(encoded_value, target_value);
3983 query_short_channel_ids = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3984 assert_eq!(query_short_channel_ids.chain_hash, expected_chain_hash);
3985 assert_eq!(query_short_channel_ids.short_channel_ids[0], 0x000000000000008e);
3986 assert_eq!(query_short_channel_ids.short_channel_ids[1], 0x0000000000003c69);
3987 assert_eq!(query_short_channel_ids.short_channel_ids[2], 0x000000000045a6c4);
3989 target_value.append(&mut hex::decode("001601789c636000833e08659309a65878be010010a9023a").unwrap());
3990 let result: Result<msgs::QueryShortChannelIds, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
3991 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
3996 fn encoding_reply_short_channel_ids_end() {
3997 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
3998 let mut reply_short_channel_ids_end = msgs::ReplyShortChannelIdsEnd {
3999 chain_hash: expected_chain_hash,
4000 full_information: true,
4002 let encoded_value = reply_short_channel_ids_end.encode();
4003 let target_value = hex::decode("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f01").unwrap();
4004 assert_eq!(encoded_value, target_value);
4006 reply_short_channel_ids_end = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4007 assert_eq!(reply_short_channel_ids_end.chain_hash, expected_chain_hash);
4008 assert_eq!(reply_short_channel_ids_end.full_information, true);
4012 fn encoding_gossip_timestamp_filter(){
4013 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4014 let mut gossip_timestamp_filter = msgs::GossipTimestampFilter {
4015 chain_hash: expected_chain_hash,
4016 first_timestamp: 1590000000,
4017 timestamp_range: 0xffff_ffff,
4019 let encoded_value = gossip_timestamp_filter.encode();
4020 let target_value = hex::decode("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f5ec57980ffffffff").unwrap();
4021 assert_eq!(encoded_value, target_value);
4023 gossip_timestamp_filter = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4024 assert_eq!(gossip_timestamp_filter.chain_hash, expected_chain_hash);
4025 assert_eq!(gossip_timestamp_filter.first_timestamp, 1590000000);
4026 assert_eq!(gossip_timestamp_filter.timestamp_range, 0xffff_ffff);
4030 fn decode_onion_hop_data_len_as_bigsize() {
4031 // Tests that we can decode an onion payload that is >253 bytes.
4032 // Previously, receiving a payload of this size could've caused us to fail to decode a valid
4033 // payload, because we were decoding the length (a BigSize, big-endian) as a VarInt
4036 // Encode a test onion payload with a big custom TLV such that it's >253 bytes, forcing the
4037 // payload length to be encoded over multiple bytes rather than a single u8.
4038 let big_payload = encode_big_payload().unwrap();
4039 let mut rd = Cursor::new(&big_payload[..]);
4041 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4042 <msgs::InboundOnionPayload as ReadableArgs<&&test_utils::TestKeysInterface>>
4043 ::read(&mut rd, &&node_signer).unwrap();
4045 // see above test, needs to be a separate method for use of the serialization macros.
4046 fn encode_big_payload() -> Result<Vec<u8>, io::Error> {
4047 use crate::util::ser::HighZeroBytesDroppedBigSize;
4048 let payload = msgs::OutboundOnionPayload::Forward {
4049 short_channel_id: 0xdeadbeef1bad1dea,
4050 amt_to_forward: 1000,
4051 outgoing_cltv_value: 0xffffffff,
4053 let mut encoded_payload = Vec::new();
4054 let test_bytes = vec![42u8; 1000];
4055 if let msgs::OutboundOnionPayload::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } = payload {
4056 _encode_varint_length_prefixed_tlv!(&mut encoded_payload, {
4057 (1, test_bytes, required_vec),
4058 (2, HighZeroBytesDroppedBigSize(amt_to_forward), required),
4059 (4, HighZeroBytesDroppedBigSize(outgoing_cltv_value), required),
4060 (6, short_channel_id, required)
4067 #[cfg(feature = "std")]
4068 fn test_socket_address_from_str() {
4069 assert_eq!(SocketAddress::TcpIpV4 {
4070 addr: Ipv4Addr::new(127, 0, 0, 1).octets(),
4072 }, SocketAddress::from_str("127.0.0.1:1234").unwrap());
4074 assert_eq!(SocketAddress::TcpIpV6 {
4075 addr: Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1).octets(),
4077 }, SocketAddress::from_str("[0:0:0:0:0:0:0:1]:1234").unwrap());
4079 SocketAddress::Hostname {
4080 hostname: Hostname::try_from("lightning-node.mydomain.com".to_string()).unwrap(),
4082 }, SocketAddress::from_str("lightning-node.mydomain.com:1234").unwrap());
4084 SocketAddress::Hostname {
4085 hostname: Hostname::try_from("example.com".to_string()).unwrap(),
4087 }, SocketAddress::from_str("example.com:1234").unwrap());
4088 assert_eq!(SocketAddress::OnionV3 {
4089 ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102, 182, 107, 4, 105, 247, 246, 85,
4090 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31, 33, 71, 3],
4094 }, SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion:1234").unwrap());
4095 assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6.onion:1234"));
4096 assert_eq!(Err(SocketAddressParseError::InvalidInput), SocketAddress::from_str("127.0.0.1@1234"));
4097 assert_eq!(Err(SocketAddressParseError::InvalidInput), "".parse::<SocketAddress>());
4098 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:9735:94").is_err());
4099 assert!(SocketAddress::from_str("wrong$%#.com:1234").is_err());
4100 assert_eq!(Err(SocketAddressParseError::InvalidPort), SocketAddress::from_str("example.com:wrong"));
4101 assert!("localhost".parse::<SocketAddress>().is_err());
4102 assert!("localhost:invalid-port".parse::<SocketAddress>().is_err());
4103 assert!( "invalid-onion-v3-hostname.onion:8080".parse::<SocketAddress>().is_err());
4104 assert!("b32.example.onion:invalid-port".parse::<SocketAddress>().is_err());
4105 assert!("invalid-address".parse::<SocketAddress>().is_err());
4106 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:1234").is_err());