1 // This file is Copyright its original authors, visible in version control
4 // This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
5 // or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
6 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
7 // You may not use this file except in accordance with one or both of these
10 //! Wire messages, traits representing wire message handlers, and a few error types live here.
12 //! For a normal node you probably don't need to use anything here, however, if you wish to split a
13 //! node into an internet-facing route/message socket handling daemon and a separate daemon (or
14 //! server entirely) which handles only channel-related messages you may wish to implement
15 //! [`ChannelMessageHandler`] yourself and use it to re-serialize messages and pass them across
18 //! Note that if you go with such an architecture (instead of passing raw socket events to a
19 //! non-internet-facing system) you trust the frontend internet-facing system to not lie about the
20 //! source `node_id` of the message, however this does allow you to significantly reduce bandwidth
21 //! between the systems as routing messages can represent a significant chunk of bandwidth usage
22 //! (especially for non-channel-publicly-announcing nodes). As an alternate design which avoids
23 //! this issue, if you have sufficient bidirectional bandwidth between your systems, you may send
24 //! raw socket events into your non-internet-facing system and then send routing events back to
25 //! track the network on the less-secure system.
27 use bitcoin::blockdata::constants::ChainHash;
28 use bitcoin::secp256k1::PublicKey;
29 use bitcoin::secp256k1::ecdsa::Signature;
30 use bitcoin::{secp256k1, Witness};
31 use bitcoin::blockdata::script::ScriptBuf;
32 use bitcoin::hash_types::Txid;
34 use crate::blinded_path::payment::{BlindedPaymentTlvs, ForwardTlvs, ReceiveTlvs};
35 use crate::ln::{ChannelId, PaymentPreimage, PaymentHash, PaymentSecret};
36 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
37 use crate::ln::onion_utils;
38 use crate::onion_message;
39 use crate::sign::{NodeSigner, Recipient};
41 use crate::prelude::*;
42 #[cfg(feature = "std")]
43 use core::convert::TryFrom;
47 #[cfg(feature = "std")]
48 use core::str::FromStr;
49 #[cfg(feature = "std")]
50 use std::net::SocketAddr;
51 use core::fmt::Display;
52 use crate::io::{self, Cursor, Read};
53 use crate::io_extras::read_to_end;
55 use crate::events::{EventsProvider, MessageSendEventsProvider};
56 use crate::crypto::streams::ChaChaPolyReadAdapter;
57 use crate::util::logger;
58 use crate::util::ser::{LengthReadable, LengthReadableArgs, Readable, ReadableArgs, Writeable, Writer, WithoutLength, FixedLengthReader, HighZeroBytesDroppedBigSize, Hostname, TransactionU16LenLimited, BigSize};
59 use crate::util::base32;
61 use crate::routing::gossip::{NodeAlias, NodeId};
63 /// 21 million * 10^8 * 1000
64 pub(crate) const MAX_VALUE_MSAT: u64 = 21_000_000_0000_0000_000;
67 /// A partial signature that also contains the Musig2 nonce its signer used
68 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
69 pub struct PartialSignatureWithNonce(pub musig2::types::PartialSignature, pub musig2::types::PublicNonce);
71 /// An error in decoding a message or struct.
72 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
73 pub enum DecodeError {
74 /// A version byte specified something we don't know how to handle.
76 /// Includes unknown realm byte in an onion hop data packet.
78 /// Unknown feature mandating we fail to parse message (e.g., TLV with an even, unknown type)
79 UnknownRequiredFeature,
80 /// Value was invalid.
82 /// For example, a byte which was supposed to be a bool was something other than a 0
83 /// or 1, a public key/private key/signature was invalid, text wasn't UTF-8, TLV was
84 /// syntactically incorrect, etc.
86 /// The buffer to be read was too short.
88 /// A length descriptor in the packet didn't describe the later data correctly.
90 /// Error from [`std::io`].
92 /// The message included zlib-compressed values, which we don't support.
93 UnsupportedCompression,
94 /// Value is validly encoded but is dangerous to use.
96 /// This is used for things like [`ChannelManager`] deserialization where we want to ensure
97 /// that we don't use a [`ChannelManager`] which is in out of sync with the [`ChannelMonitor`].
98 /// This indicates that there is a critical implementation flaw in the storage implementation
99 /// and it's unsafe to continue.
101 /// [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
102 /// [`ChannelMonitor`]: crate::chain::channelmonitor::ChannelMonitor
106 /// An [`init`] message to be sent to or received from a peer.
108 /// [`init`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-init-message
109 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
111 /// The relevant features which the sender supports.
112 pub features: InitFeatures,
113 /// Indicates chains the sender is interested in.
115 /// If there are no common chains, the connection will be closed.
116 pub networks: Option<Vec<ChainHash>>,
117 /// The receipient's network address.
119 /// This adds the option to report a remote IP address back to a connecting peer using the init
120 /// message. A node can decide to use that information to discover a potential update to its
121 /// public IPv4 address (NAT) and use that for a [`NodeAnnouncement`] update message containing
123 pub remote_network_address: Option<SocketAddress>,
126 /// An [`error`] message to be sent to or received from a peer.
128 /// [`error`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-error-and-warning-messages
129 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
130 pub struct ErrorMessage {
131 /// The channel ID involved in the error.
133 /// All-0s indicates a general error unrelated to a specific channel, after which all channels
134 /// with the sending peer should be closed.
135 pub channel_id: ChannelId,
136 /// A possibly human-readable error description.
138 /// The string should be sanitized before it is used (e.g., emitted to logs or printed to
139 /// `stdout`). Otherwise, a well crafted error message may trigger a security vulnerability in
140 /// the terminal emulator or the logging subsystem.
144 /// A [`warning`] message to be sent to or received from a peer.
146 /// [`warning`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-error-and-warning-messages
147 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
148 pub struct WarningMessage {
149 /// The channel ID involved in the warning.
151 /// All-0s indicates a warning unrelated to a specific channel.
152 pub channel_id: ChannelId,
153 /// A possibly human-readable warning description.
155 /// The string should be sanitized before it is used (e.g. emitted to logs or printed to
156 /// stdout). Otherwise, a well crafted error message may trigger a security vulnerability in
157 /// the terminal emulator or the logging subsystem.
161 /// A [`ping`] message to be sent to or received from a peer.
163 /// [`ping`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-ping-and-pong-messages
164 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
166 /// The desired response length.
168 /// The ping packet size.
170 /// This field is not sent on the wire. byteslen zeros are sent.
174 /// A [`pong`] message to be sent to or received from a peer.
176 /// [`pong`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-ping-and-pong-messages
177 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
179 /// The pong packet size.
181 /// This field is not sent on the wire. byteslen zeros are sent.
185 /// Contains fields that are both common to [`open_channel`] and `open_channel2` messages.
187 /// [`open_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-open_channel-message
188 // TODO(dual_funding): Add spec link for `open_channel2`.
189 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
190 pub struct CommonOpenChannelFields {
191 /// The genesis hash of the blockchain where the channel is to be opened
192 pub chain_hash: ChainHash,
193 /// A temporary channel ID
194 /// For V2 channels: derived using a zeroed out value for the channel acceptor's revocation basepoint
195 /// For V1 channels: a temporary channel ID, until the funding outpoint is announced
196 pub temporary_channel_id: ChannelId,
197 /// For V1 channels: The channel value
198 /// For V2 channels: Part of the channel value contributed by the channel initiator
199 pub funding_satoshis: u64,
200 /// The threshold below which outputs on transactions broadcast by the channel initiator will be
202 pub dust_limit_satoshis: u64,
203 /// The maximum inbound HTLC value in flight towards channel initiator, in milli-satoshi
204 pub max_htlc_value_in_flight_msat: u64,
205 /// The minimum HTLC size incoming to channel initiator, in milli-satoshi
206 pub htlc_minimum_msat: u64,
207 /// The feerate for the commitment transaction set by the channel initiator until updated by
209 pub commitment_feerate_sat_per_1000_weight: u32,
210 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
211 /// broadcast a commitment transaction
212 pub to_self_delay: u16,
213 /// The maximum number of inbound HTLCs towards channel initiator
214 pub max_accepted_htlcs: u16,
215 /// The channel initiator's key controlling the funding transaction
216 pub funding_pubkey: PublicKey,
217 /// Used to derive a revocation key for transactions broadcast by counterparty
218 pub revocation_basepoint: PublicKey,
219 /// A payment key to channel initiator for transactions broadcast by counterparty
220 pub payment_basepoint: PublicKey,
221 /// Used to derive a payment key to channel initiator for transactions broadcast by channel
223 pub delayed_payment_basepoint: PublicKey,
224 /// Used to derive an HTLC payment key to channel initiator
225 pub htlc_basepoint: PublicKey,
226 /// The first to-be-broadcast-by-channel-initiator transaction's per commitment point
227 pub first_per_commitment_point: PublicKey,
228 /// The channel flags to be used
229 pub channel_flags: u8,
230 /// Optionally, a request to pre-set the to-channel-initiator output's scriptPubkey for when we
231 /// collaboratively close
232 pub shutdown_scriptpubkey: Option<ScriptBuf>,
233 /// The channel type that this channel will represent
235 /// If this is `None`, we derive the channel type from the intersection of our
236 /// feature bits with our counterparty's feature bits from the [`Init`] message.
237 pub channel_type: Option<ChannelTypeFeatures>,
240 /// An [`open_channel`] message to be sent to or received from a peer.
242 /// Used in V1 channel establishment
244 /// [`open_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-open_channel-message
245 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
246 pub struct OpenChannel {
247 /// Common fields of `open_channel(2)`-like messages
248 pub common_fields: CommonOpenChannelFields,
249 /// The amount to push to the counterparty as part of the open, in milli-satoshi
251 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
252 pub channel_reserve_satoshis: u64,
255 /// An open_channel2 message to be sent by or received from the channel initiator.
257 /// Used in V2 channel establishment
259 // TODO(dual_funding): Add spec link for `open_channel2`.
260 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
261 pub struct OpenChannelV2 {
262 /// Common fields of `open_channel(2)`-like messages
263 pub common_fields: CommonOpenChannelFields,
264 /// The feerate for the funding transaction set by the channel initiator
265 pub funding_feerate_sat_per_1000_weight: u32,
266 /// The locktime for the funding transaction
268 /// The second to-be-broadcast-by-channel-initiator transaction's per commitment point
269 pub second_per_commitment_point: PublicKey,
270 /// Optionally, a requirement that only confirmed inputs can be added
271 pub require_confirmed_inputs: Option<()>,
274 /// Contains fields that are both common to [`accept_channel`] and `accept_channel2` messages.
276 /// [`accept_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-accept_channel-message
277 // TODO(dual_funding): Add spec link for `accept_channel2`.
278 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
279 pub struct CommonAcceptChannelFields {
280 /// The same `temporary_channel_id` received from the initiator's `open_channel2` or `open_channel` message.
281 pub temporary_channel_id: ChannelId,
282 /// The threshold below which outputs on transactions broadcast by the channel acceptor will be
284 pub dust_limit_satoshis: u64,
285 /// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
286 pub max_htlc_value_in_flight_msat: u64,
287 /// The minimum HTLC size incoming to channel acceptor, in milli-satoshi
288 pub htlc_minimum_msat: u64,
289 /// Minimum depth of the funding transaction before the channel is considered open
290 pub minimum_depth: u32,
291 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
292 /// broadcast a commitment transaction
293 pub to_self_delay: u16,
294 /// The maximum number of inbound HTLCs towards channel acceptor
295 pub max_accepted_htlcs: u16,
296 /// The channel acceptor's key controlling the funding transaction
297 pub funding_pubkey: PublicKey,
298 /// Used to derive a revocation key for transactions broadcast by counterparty
299 pub revocation_basepoint: PublicKey,
300 /// A payment key to channel acceptor for transactions broadcast by counterparty
301 pub payment_basepoint: PublicKey,
302 /// Used to derive a payment key to channel acceptor for transactions broadcast by channel
304 pub delayed_payment_basepoint: PublicKey,
305 /// Used to derive an HTLC payment key to channel acceptor for transactions broadcast by counterparty
306 pub htlc_basepoint: PublicKey,
307 /// The first to-be-broadcast-by-channel-acceptor transaction's per commitment point
308 pub first_per_commitment_point: PublicKey,
309 /// Optionally, a request to pre-set the to-channel-acceptor output's scriptPubkey for when we
310 /// collaboratively close
311 pub shutdown_scriptpubkey: Option<ScriptBuf>,
312 /// The channel type that this channel will represent. If none is set, we derive the channel
313 /// type from the intersection of our feature bits with our counterparty's feature bits from
314 /// the Init message.
316 /// This is required to match the equivalent field in [`OpenChannel`] or [`OpenChannelV2`]'s
317 /// [`CommonOpenChannelFields::channel_type`].
318 pub channel_type: Option<ChannelTypeFeatures>,
321 /// An [`accept_channel`] message to be sent to or received from a peer.
323 /// Used in V1 channel establishment
325 /// [`accept_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-accept_channel-message
326 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
327 pub struct AcceptChannel {
328 /// Common fields of `accept_channel(2)`-like messages
329 pub common_fields: CommonAcceptChannelFields,
330 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
331 pub channel_reserve_satoshis: u64,
333 /// Next nonce the channel initiator should use to create a funding output signature against
334 pub next_local_nonce: Option<musig2::types::PublicNonce>,
337 /// An accept_channel2 message to be sent by or received from the channel accepter.
339 /// Used in V2 channel establishment
341 // TODO(dual_funding): Add spec link for `accept_channel2`.
342 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
343 pub struct AcceptChannelV2 {
344 /// Common fields of `accept_channel(2)`-like messages
345 pub common_fields: CommonAcceptChannelFields,
346 /// Part of the channel value contributed by the channel acceptor
347 pub funding_satoshis: u64,
348 /// The second to-be-broadcast-by-channel-acceptor transaction's per commitment point
349 pub second_per_commitment_point: PublicKey,
350 /// Optionally, a requirement that only confirmed inputs can be added
351 pub require_confirmed_inputs: Option<()>,
354 /// A [`funding_created`] message to be sent to or received from a peer.
356 /// Used in V1 channel establishment
358 /// [`funding_created`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-funding_created-message
359 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
360 pub struct FundingCreated {
361 /// A temporary channel ID, until the funding is established
362 pub temporary_channel_id: ChannelId,
363 /// The funding transaction ID
364 pub funding_txid: Txid,
365 /// The specific output index funding this channel
366 pub funding_output_index: u16,
367 /// The signature of the channel initiator (funder) on the initial commitment transaction
368 pub signature: Signature,
370 /// The partial signature of the channel initiator (funder)
371 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
373 /// Next nonce the channel acceptor should use to finalize the funding output signature
374 pub next_local_nonce: Option<musig2::types::PublicNonce>
377 /// A [`funding_signed`] message to be sent to or received from a peer.
379 /// Used in V1 channel establishment
381 /// [`funding_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-funding_signed-message
382 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
383 pub struct FundingSigned {
385 pub channel_id: ChannelId,
386 /// The signature of the channel acceptor (fundee) on the initial commitment transaction
387 pub signature: Signature,
389 /// The partial signature of the channel acceptor (fundee)
390 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
393 /// A [`channel_ready`] message to be sent to or received from a peer.
395 /// [`channel_ready`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-channel_ready-message
396 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
397 pub struct ChannelReady {
399 pub channel_id: ChannelId,
400 /// The per-commitment point of the second commitment transaction
401 pub next_per_commitment_point: PublicKey,
402 /// If set, provides a `short_channel_id` alias for this channel.
404 /// The sender will accept payments to be forwarded over this SCID and forward them to this
405 /// messages' recipient.
406 pub short_channel_id_alias: Option<u64>,
409 /// A randomly chosen number that is used to identify inputs within an interactive transaction
411 pub type SerialId = u64;
413 /// An stfu (quiescence) message to be sent by or received from the stfu initiator.
414 // TODO(splicing): Add spec link for `stfu`; still in draft, using from https://github.com/lightning/bolts/pull/863
415 #[derive(Clone, Debug, PartialEq, Eq)]
417 /// The channel ID where quiescence is intended
418 pub channel_id: ChannelId,
419 /// Initiator flag, 1 if initiating, 0 if replying to an stfu.
423 /// A splice message to be sent by or received from the stfu initiator (splice initiator).
424 // TODO(splicing): Add spec link for `splice`; still in draft, using from https://github.com/lightning/bolts/pull/863
425 #[derive(Clone, Debug, PartialEq, Eq)]
427 /// The channel ID where splicing is intended
428 pub channel_id: ChannelId,
429 /// The genesis hash of the blockchain where the channel is intended to be spliced
430 pub chain_hash: ChainHash,
431 /// The intended change in channel capacity: the amount to be added (positive value)
432 /// or removed (negative value) by the sender (splice initiator) by splicing into/from the channel.
433 pub relative_satoshis: i64,
434 /// The feerate for the new funding transaction, set by the splice initiator
435 pub funding_feerate_perkw: u32,
436 /// The locktime for the new funding transaction
438 /// The key of the sender (splice initiator) controlling the new funding transaction
439 pub funding_pubkey: PublicKey,
442 /// A splice_ack message to be received by or sent to the splice initiator.
444 // TODO(splicing): Add spec link for `splice_ack`; still in draft, using from https://github.com/lightning/bolts/pull/863
445 #[derive(Clone, Debug, PartialEq, Eq)]
446 pub struct SpliceAck {
447 /// The channel ID where splicing is intended
448 pub channel_id: ChannelId,
449 /// The genesis hash of the blockchain where the channel is intended to be spliced
450 pub chain_hash: ChainHash,
451 /// The intended change in channel capacity: the amount to be added (positive value)
452 /// or removed (negative value) by the sender (splice acceptor) by splicing into/from the channel.
453 pub relative_satoshis: i64,
454 /// The key of the sender (splice acceptor) controlling the new funding transaction
455 pub funding_pubkey: PublicKey,
458 /// A splice_locked message to be sent to or received from a peer.
460 // TODO(splicing): Add spec link for `splice_locked`; still in draft, using from https://github.com/lightning/bolts/pull/863
461 #[derive(Clone, Debug, PartialEq, Eq)]
462 pub struct SpliceLocked {
464 pub channel_id: ChannelId,
467 /// A tx_add_input message for adding an input during interactive transaction construction
469 // TODO(dual_funding): Add spec link for `tx_add_input`.
470 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
471 pub struct TxAddInput {
473 pub channel_id: ChannelId,
474 /// A randomly chosen unique identifier for this input, which is even for initiators and odd for
476 pub serial_id: SerialId,
477 /// Serialized transaction that contains the output this input spends to verify that it is non
479 pub prevtx: TransactionU16LenLimited,
480 /// The index of the output being spent
482 /// The sequence number of this input
486 /// A tx_add_output message for adding an output during interactive transaction construction.
488 // TODO(dual_funding): Add spec link for `tx_add_output`.
489 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
490 pub struct TxAddOutput {
492 pub channel_id: ChannelId,
493 /// A randomly chosen unique identifier for this output, which is even for initiators and odd for
495 pub serial_id: SerialId,
496 /// The satoshi value of the output
498 /// The scriptPubKey for the output
499 pub script: ScriptBuf,
502 /// A tx_remove_input message for removing an input during interactive transaction construction.
504 // TODO(dual_funding): Add spec link for `tx_remove_input`.
505 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
506 pub struct TxRemoveInput {
508 pub channel_id: ChannelId,
509 /// The serial ID of the input to be removed
510 pub serial_id: SerialId,
513 /// A tx_remove_output message for removing an output during interactive transaction construction.
515 // TODO(dual_funding): Add spec link for `tx_remove_output`.
516 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
517 pub struct TxRemoveOutput {
519 pub channel_id: ChannelId,
520 /// The serial ID of the output to be removed
521 pub serial_id: SerialId,
524 /// A tx_complete message signalling the conclusion of a peer's transaction contributions during
525 /// interactive transaction construction.
527 // TODO(dual_funding): Add spec link for `tx_complete`.
528 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
529 pub struct TxComplete {
531 pub channel_id: ChannelId,
534 /// A tx_signatures message containing the sender's signatures for a transaction constructed with
535 /// interactive transaction construction.
537 // TODO(dual_funding): Add spec link for `tx_signatures`.
538 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
539 pub struct TxSignatures {
541 pub channel_id: ChannelId,
544 /// The list of witnesses
545 pub witnesses: Vec<Witness>,
548 /// A tx_init_rbf message which initiates a replacement of the transaction after it's been
551 // TODO(dual_funding): Add spec link for `tx_init_rbf`.
552 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
553 pub struct TxInitRbf {
555 pub channel_id: ChannelId,
556 /// The locktime of the transaction
558 /// The feerate of the transaction
559 pub feerate_sat_per_1000_weight: u32,
560 /// The number of satoshis the sender will contribute to or, if negative, remove from
561 /// (e.g. splice-out) the funding output of the transaction
562 pub funding_output_contribution: Option<i64>,
565 /// A tx_ack_rbf message which acknowledges replacement of the transaction after it's been
568 // TODO(dual_funding): Add spec link for `tx_ack_rbf`.
569 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
570 pub struct TxAckRbf {
572 pub channel_id: ChannelId,
573 /// The number of satoshis the sender will contribute to or, if negative, remove from
574 /// (e.g. splice-out) the funding output of the transaction
575 pub funding_output_contribution: Option<i64>,
578 /// A tx_abort message which signals the cancellation of an in-progress transaction negotiation.
580 // TODO(dual_funding): Add spec link for `tx_abort`.
581 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
584 pub channel_id: ChannelId,
589 /// A [`shutdown`] message to be sent to or received from a peer.
591 /// [`shutdown`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-initiation-shutdown
592 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
593 pub struct Shutdown {
595 pub channel_id: ChannelId,
596 /// The destination of this peer's funds on closing.
598 /// Must be in one of these forms: P2PKH, P2SH, P2WPKH, P2WSH, P2TR.
599 pub scriptpubkey: ScriptBuf,
602 /// The minimum and maximum fees which the sender is willing to place on the closing transaction.
604 /// This is provided in [`ClosingSigned`] by both sides to indicate the fee range they are willing
606 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
607 pub struct ClosingSignedFeeRange {
608 /// The minimum absolute fee, in satoshis, which the sender is willing to place on the closing
610 pub min_fee_satoshis: u64,
611 /// The maximum absolute fee, in satoshis, which the sender is willing to place on the closing
613 pub max_fee_satoshis: u64,
616 /// A [`closing_signed`] message to be sent to or received from a peer.
618 /// [`closing_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-negotiation-closing_signed
619 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
620 pub struct ClosingSigned {
622 pub channel_id: ChannelId,
623 /// The proposed total fee for the closing transaction
624 pub fee_satoshis: u64,
625 /// A signature on the closing transaction
626 pub signature: Signature,
627 /// The minimum and maximum fees which the sender is willing to accept, provided only by new
629 pub fee_range: Option<ClosingSignedFeeRange>,
632 /// An [`update_add_htlc`] message to be sent to or received from a peer.
634 /// [`update_add_htlc`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#adding-an-htlc-update_add_htlc
635 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
636 pub struct UpdateAddHTLC {
638 pub channel_id: ChannelId,
641 /// The HTLC value in milli-satoshi
642 pub amount_msat: u64,
643 /// The payment hash, the pre-image of which controls HTLC redemption
644 pub payment_hash: PaymentHash,
645 /// The expiry height of the HTLC
646 pub cltv_expiry: u32,
647 /// The extra fee skimmed by the sender of this message. See
648 /// [`ChannelConfig::accept_underpaying_htlcs`].
650 /// [`ChannelConfig::accept_underpaying_htlcs`]: crate::util::config::ChannelConfig::accept_underpaying_htlcs
651 pub skimmed_fee_msat: Option<u64>,
652 /// The onion routing packet with encrypted data for the next hop.
653 pub onion_routing_packet: OnionPacket,
654 /// Provided if we are relaying or receiving a payment within a blinded path, to decrypt the onion
655 /// routing packet and the recipient-provided encrypted payload within.
656 pub blinding_point: Option<PublicKey>,
659 /// An onion message to be sent to or received from a peer.
661 // TODO: update with link to OM when they are merged into the BOLTs
662 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
663 pub struct OnionMessage {
664 /// Used in decrypting the onion packet's payload.
665 pub blinding_point: PublicKey,
666 /// The full onion packet including hop data, pubkey, and hmac
667 pub onion_routing_packet: onion_message::packet::Packet,
670 /// An [`update_fulfill_htlc`] message to be sent to or received from a peer.
672 /// [`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
673 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
674 pub struct UpdateFulfillHTLC {
676 pub channel_id: ChannelId,
679 /// The pre-image of the payment hash, allowing HTLC redemption
680 pub payment_preimage: PaymentPreimage,
683 /// An [`update_fail_htlc`] message to be sent to or received from a peer.
685 /// [`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
686 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
687 pub struct UpdateFailHTLC {
689 pub channel_id: ChannelId,
692 pub(crate) reason: OnionErrorPacket,
695 /// An [`update_fail_malformed_htlc`] message to be sent to or received from a peer.
697 /// [`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
698 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
699 pub struct UpdateFailMalformedHTLC {
701 pub channel_id: ChannelId,
704 pub(crate) sha256_of_onion: [u8; 32],
706 pub failure_code: u16,
709 /// A [`commitment_signed`] message to be sent to or received from a peer.
711 /// [`commitment_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#committing-updates-so-far-commitment_signed
712 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
713 pub struct CommitmentSigned {
715 pub channel_id: ChannelId,
716 /// A signature on the commitment transaction
717 pub signature: Signature,
718 /// Signatures on the HTLC transactions
719 pub htlc_signatures: Vec<Signature>,
721 /// The partial Taproot signature on the commitment transaction
722 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
725 /// A [`revoke_and_ack`] message to be sent to or received from a peer.
727 /// [`revoke_and_ack`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#completing-the-transition-to-the-updated-state-revoke_and_ack
728 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
729 pub struct RevokeAndACK {
731 pub channel_id: ChannelId,
732 /// The secret corresponding to the per-commitment point
733 pub per_commitment_secret: [u8; 32],
734 /// The next sender-broadcast commitment transaction's per-commitment point
735 pub next_per_commitment_point: PublicKey,
737 /// Musig nonce the recipient should use in their next commitment signature message
738 pub next_local_nonce: Option<musig2::types::PublicNonce>
741 /// An [`update_fee`] message to be sent to or received from a peer
743 /// [`update_fee`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#updating-fees-update_fee
744 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
745 pub struct UpdateFee {
747 pub channel_id: ChannelId,
748 /// Fee rate per 1000-weight of the transaction
749 pub feerate_per_kw: u32,
752 /// A [`channel_reestablish`] message to be sent to or received from a peer.
754 /// [`channel_reestablish`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#message-retransmission
755 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
756 pub struct ChannelReestablish {
758 pub channel_id: ChannelId,
759 /// The next commitment number for the sender
760 pub next_local_commitment_number: u64,
761 /// The next commitment number for the recipient
762 pub next_remote_commitment_number: u64,
763 /// Proof that the sender knows the per-commitment secret of a specific commitment transaction
764 /// belonging to the recipient
765 pub your_last_per_commitment_secret: [u8; 32],
766 /// The sender's per-commitment point for their current commitment transaction
767 pub my_current_per_commitment_point: PublicKey,
768 /// The next funding transaction ID
769 pub next_funding_txid: Option<Txid>,
772 /// An [`announcement_signatures`] message to be sent to or received from a peer.
774 /// [`announcement_signatures`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-announcement_signatures-message
775 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
776 pub struct AnnouncementSignatures {
778 pub channel_id: ChannelId,
779 /// The short channel ID
780 pub short_channel_id: u64,
781 /// A signature by the node key
782 pub node_signature: Signature,
783 /// A signature by the funding key
784 pub bitcoin_signature: Signature,
787 /// An address which can be used to connect to a remote peer.
788 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
789 pub enum SocketAddress {
790 /// An IPv4 address and port on which the peer is listening.
792 /// The 4-byte IPv4 address
794 /// The port on which the node is listening
797 /// An IPv6 address and port on which the peer is listening.
799 /// The 16-byte IPv6 address
801 /// The port on which the node is listening
804 /// An old-style Tor onion address/port on which the peer is listening.
806 /// This field is deprecated and the Tor network generally no longer supports V2 Onion
807 /// addresses. Thus, the details are not parsed here.
809 /// A new-style Tor onion address/port on which the peer is listening.
811 /// To create the human-readable "hostname", concatenate the ED25519 pubkey, checksum, and version,
812 /// wrap as base32 and append ".onion".
814 /// The ed25519 long-term public key of the peer
815 ed25519_pubkey: [u8; 32],
816 /// The checksum of the pubkey and version, as included in the onion address
818 /// The version byte, as defined by the Tor Onion v3 spec.
820 /// The port on which the node is listening
823 /// A hostname/port on which the peer is listening.
825 /// The hostname on which the node is listening.
827 /// The port on which the node is listening.
832 /// Gets the ID of this address type. Addresses in [`NodeAnnouncement`] messages should be sorted
834 pub(crate) fn get_id(&self) -> u8 {
836 &SocketAddress::TcpIpV4 {..} => { 1 },
837 &SocketAddress::TcpIpV6 {..} => { 2 },
838 &SocketAddress::OnionV2(_) => { 3 },
839 &SocketAddress::OnionV3 {..} => { 4 },
840 &SocketAddress::Hostname {..} => { 5 },
844 /// Strict byte-length of address descriptor, 1-byte type not recorded
845 fn len(&self) -> u16 {
847 &SocketAddress::TcpIpV4 { .. } => { 6 },
848 &SocketAddress::TcpIpV6 { .. } => { 18 },
849 &SocketAddress::OnionV2(_) => { 12 },
850 &SocketAddress::OnionV3 { .. } => { 37 },
851 // Consists of 1-byte hostname length, hostname bytes, and 2-byte port.
852 &SocketAddress::Hostname { ref hostname, .. } => { u16::from(hostname.len()) + 3 },
856 /// The maximum length of any address descriptor, not including the 1-byte type.
857 /// This maximum length is reached by a hostname address descriptor:
858 /// a hostname with a maximum length of 255, its 1-byte length and a 2-byte port.
859 pub(crate) const MAX_LEN: u16 = 258;
861 pub(crate) fn is_tor(&self) -> bool {
863 &SocketAddress::TcpIpV4 {..} => false,
864 &SocketAddress::TcpIpV6 {..} => false,
865 &SocketAddress::OnionV2(_) => true,
866 &SocketAddress::OnionV3 {..} => true,
867 &SocketAddress::Hostname {..} => false,
872 impl Writeable for SocketAddress {
873 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
875 &SocketAddress::TcpIpV4 { ref addr, ref port } => {
880 &SocketAddress::TcpIpV6 { ref addr, ref port } => {
885 &SocketAddress::OnionV2(bytes) => {
887 bytes.write(writer)?;
889 &SocketAddress::OnionV3 { ref ed25519_pubkey, ref checksum, ref version, ref port } => {
891 ed25519_pubkey.write(writer)?;
892 checksum.write(writer)?;
893 version.write(writer)?;
896 &SocketAddress::Hostname { ref hostname, ref port } => {
898 hostname.write(writer)?;
906 impl Readable for Result<SocketAddress, u8> {
907 fn read<R: Read>(reader: &mut R) -> Result<Result<SocketAddress, u8>, DecodeError> {
908 let byte = <u8 as Readable>::read(reader)?;
911 Ok(Ok(SocketAddress::TcpIpV4 {
912 addr: Readable::read(reader)?,
913 port: Readable::read(reader)?,
917 Ok(Ok(SocketAddress::TcpIpV6 {
918 addr: Readable::read(reader)?,
919 port: Readable::read(reader)?,
922 3 => Ok(Ok(SocketAddress::OnionV2(Readable::read(reader)?))),
924 Ok(Ok(SocketAddress::OnionV3 {
925 ed25519_pubkey: Readable::read(reader)?,
926 checksum: Readable::read(reader)?,
927 version: Readable::read(reader)?,
928 port: Readable::read(reader)?,
932 Ok(Ok(SocketAddress::Hostname {
933 hostname: Readable::read(reader)?,
934 port: Readable::read(reader)?,
937 _ => return Ok(Err(byte)),
942 impl Readable for SocketAddress {
943 fn read<R: Read>(reader: &mut R) -> Result<SocketAddress, DecodeError> {
944 match Readable::read(reader) {
945 Ok(Ok(res)) => Ok(res),
946 Ok(Err(_)) => Err(DecodeError::UnknownVersion),
952 /// [`SocketAddress`] error variants
953 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
954 pub enum SocketAddressParseError {
955 /// Socket address (IPv4/IPv6) parsing error
957 /// Invalid input format
961 /// Invalid onion v3 address
965 impl fmt::Display for SocketAddressParseError {
966 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
968 SocketAddressParseError::SocketAddrParse => write!(f, "Socket address (IPv4/IPv6) parsing error"),
969 SocketAddressParseError::InvalidInput => write!(f, "Invalid input format. \
970 Expected: \"<ipv4>:<port>\", \"[<ipv6>]:<port>\", \"<onion address>.onion:<port>\" or \"<hostname>:<port>\""),
971 SocketAddressParseError::InvalidPort => write!(f, "Invalid port"),
972 SocketAddressParseError::InvalidOnionV3 => write!(f, "Invalid onion v3 address"),
977 #[cfg(feature = "std")]
978 impl From<std::net::SocketAddrV4> for SocketAddress {
979 fn from(addr: std::net::SocketAddrV4) -> Self {
980 SocketAddress::TcpIpV4 { addr: addr.ip().octets(), port: addr.port() }
984 #[cfg(feature = "std")]
985 impl From<std::net::SocketAddrV6> for SocketAddress {
986 fn from(addr: std::net::SocketAddrV6) -> Self {
987 SocketAddress::TcpIpV6 { addr: addr.ip().octets(), port: addr.port() }
991 #[cfg(feature = "std")]
992 impl From<std::net::SocketAddr> for SocketAddress {
993 fn from(addr: std::net::SocketAddr) -> Self {
995 std::net::SocketAddr::V4(addr) => addr.into(),
996 std::net::SocketAddr::V6(addr) => addr.into(),
1001 #[cfg(feature = "std")]
1002 impl std::net::ToSocketAddrs for SocketAddress {
1003 type Iter = std::vec::IntoIter<std::net::SocketAddr>;
1005 fn to_socket_addrs(&self) -> std::io::Result<Self::Iter> {
1007 SocketAddress::TcpIpV4 { addr, port } => {
1008 let ip_addr = std::net::Ipv4Addr::from(*addr);
1009 let socket_addr = SocketAddr::new(ip_addr.into(), *port);
1010 Ok(vec![socket_addr].into_iter())
1012 SocketAddress::TcpIpV6 { addr, port } => {
1013 let ip_addr = std::net::Ipv6Addr::from(*addr);
1014 let socket_addr = SocketAddr::new(ip_addr.into(), *port);
1015 Ok(vec![socket_addr].into_iter())
1017 SocketAddress::Hostname { ref hostname, port } => {
1018 (hostname.as_str(), *port).to_socket_addrs()
1020 SocketAddress::OnionV2(..) => {
1021 Err(std::io::Error::new(std::io::ErrorKind::Other, "Resolution of OnionV2 \
1022 addresses is currently unsupported."))
1024 SocketAddress::OnionV3 { .. } => {
1025 Err(std::io::Error::new(std::io::ErrorKind::Other, "Resolution of OnionV3 \
1026 addresses is currently unsupported."))
1032 /// Parses an OnionV3 host and port into a [`SocketAddress::OnionV3`].
1034 /// The host part must end with ".onion".
1035 pub fn parse_onion_address(host: &str, port: u16) -> Result<SocketAddress, SocketAddressParseError> {
1036 if host.ends_with(".onion") {
1037 let domain = &host[..host.len() - ".onion".len()];
1038 if domain.len() != 56 {
1039 return Err(SocketAddressParseError::InvalidOnionV3);
1041 let onion = base32::Alphabet::RFC4648 { padding: false }.decode(&domain).map_err(|_| SocketAddressParseError::InvalidOnionV3)?;
1042 if onion.len() != 35 {
1043 return Err(SocketAddressParseError::InvalidOnionV3);
1045 let version = onion[0];
1046 let first_checksum_flag = onion[1];
1047 let second_checksum_flag = onion[2];
1048 let mut ed25519_pubkey = [0; 32];
1049 ed25519_pubkey.copy_from_slice(&onion[3..35]);
1050 let checksum = u16::from_be_bytes([first_checksum_flag, second_checksum_flag]);
1051 return Ok(SocketAddress::OnionV3 { ed25519_pubkey, checksum, version, port });
1054 return Err(SocketAddressParseError::InvalidInput);
1058 impl Display for SocketAddress {
1059 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1061 SocketAddress::TcpIpV4{addr, port} => write!(
1062 f, "{}.{}.{}.{}:{}", addr[0], addr[1], addr[2], addr[3], port)?,
1063 SocketAddress::TcpIpV6{addr, port} => write!(
1065 "[{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}]:{}",
1066 addr[0], addr[1], addr[2], addr[3], addr[4], addr[5], addr[6], addr[7], addr[8], addr[9], addr[10], addr[11], addr[12], addr[13], addr[14], addr[15], port
1068 SocketAddress::OnionV2(bytes) => write!(f, "OnionV2({:?})", bytes)?,
1069 SocketAddress::OnionV3 {
1075 let [first_checksum_flag, second_checksum_flag] = checksum.to_be_bytes();
1076 let mut addr = vec![*version, first_checksum_flag, second_checksum_flag];
1077 addr.extend_from_slice(ed25519_pubkey);
1078 let onion = base32::Alphabet::RFC4648 { padding: false }.encode(&addr);
1079 write!(f, "{}.onion:{}", onion, port)?
1081 SocketAddress::Hostname { hostname, port } => write!(f, "{}:{}", hostname, port)?,
1087 #[cfg(feature = "std")]
1088 impl FromStr for SocketAddress {
1089 type Err = SocketAddressParseError;
1091 fn from_str(s: &str) -> Result<Self, Self::Err> {
1092 match std::net::SocketAddr::from_str(s) {
1093 Ok(addr) => Ok(addr.into()),
1095 let trimmed_input = match s.rfind(":") {
1097 None => return Err(SocketAddressParseError::InvalidInput),
1099 let host = &s[..trimmed_input];
1100 let port: u16 = s[trimmed_input + 1..].parse().map_err(|_| SocketAddressParseError::InvalidPort)?;
1101 if host.ends_with(".onion") {
1102 return parse_onion_address(host, port);
1104 if let Ok(hostname) = Hostname::try_from(s[..trimmed_input].to_string()) {
1105 return Ok(SocketAddress::Hostname { hostname, port });
1107 return Err(SocketAddressParseError::SocketAddrParse)
1113 /// Represents the set of gossip messages that require a signature from a node's identity key.
1114 pub enum UnsignedGossipMessage<'a> {
1115 /// An unsigned channel announcement.
1116 ChannelAnnouncement(&'a UnsignedChannelAnnouncement),
1117 /// An unsigned channel update.
1118 ChannelUpdate(&'a UnsignedChannelUpdate),
1119 /// An unsigned node announcement.
1120 NodeAnnouncement(&'a UnsignedNodeAnnouncement)
1123 impl<'a> Writeable for UnsignedGossipMessage<'a> {
1124 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
1126 UnsignedGossipMessage::ChannelAnnouncement(ref msg) => msg.write(writer),
1127 UnsignedGossipMessage::ChannelUpdate(ref msg) => msg.write(writer),
1128 UnsignedGossipMessage::NodeAnnouncement(ref msg) => msg.write(writer),
1133 /// The unsigned part of a [`node_announcement`] message.
1135 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
1136 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1137 pub struct UnsignedNodeAnnouncement {
1138 /// The advertised features
1139 pub features: NodeFeatures,
1140 /// A strictly monotonic announcement counter, with gaps allowed
1142 /// The `node_id` this announcement originated from (don't rebroadcast the `node_announcement` back
1144 pub node_id: NodeId,
1145 /// An RGB color for UI purposes
1147 /// An alias, for UI purposes.
1149 /// This should be sanitized before use. There is no guarantee of uniqueness.
1150 pub alias: NodeAlias,
1151 /// List of addresses on which this node is reachable
1152 pub addresses: Vec<SocketAddress>,
1153 /// Excess address data which was signed as a part of the message which we do not (yet) understand how
1156 /// This is stored to ensure forward-compatibility as new address types are added to the lightning gossip protocol.
1157 pub excess_address_data: Vec<u8>,
1158 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1161 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1162 pub excess_data: Vec<u8>,
1164 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1165 /// A [`node_announcement`] message to be sent to or received from a peer.
1167 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
1168 pub struct NodeAnnouncement {
1169 /// The signature by the node key
1170 pub signature: Signature,
1171 /// The actual content of the announcement
1172 pub contents: UnsignedNodeAnnouncement,
1175 /// The unsigned part of a [`channel_announcement`] message.
1177 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
1178 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1179 pub struct UnsignedChannelAnnouncement {
1180 /// The advertised channel features
1181 pub features: ChannelFeatures,
1182 /// The genesis hash of the blockchain where the channel is to be opened
1183 pub chain_hash: ChainHash,
1184 /// The short channel ID
1185 pub short_channel_id: u64,
1186 /// One of the two `node_id`s which are endpoints of this channel
1187 pub node_id_1: NodeId,
1188 /// The other of the two `node_id`s which are endpoints of this channel
1189 pub node_id_2: NodeId,
1190 /// The funding key for the first node
1191 pub bitcoin_key_1: NodeId,
1192 /// The funding key for the second node
1193 pub bitcoin_key_2: NodeId,
1194 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1197 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1198 pub excess_data: Vec<u8>,
1200 /// A [`channel_announcement`] message to be sent to or received from a peer.
1202 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
1203 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1204 pub struct ChannelAnnouncement {
1205 /// Authentication of the announcement by the first public node
1206 pub node_signature_1: Signature,
1207 /// Authentication of the announcement by the second public node
1208 pub node_signature_2: Signature,
1209 /// Proof of funding UTXO ownership by the first public node
1210 pub bitcoin_signature_1: Signature,
1211 /// Proof of funding UTXO ownership by the second public node
1212 pub bitcoin_signature_2: Signature,
1213 /// The actual announcement
1214 pub contents: UnsignedChannelAnnouncement,
1217 /// The unsigned part of a [`channel_update`] message.
1219 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1220 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1221 pub struct UnsignedChannelUpdate {
1222 /// The genesis hash of the blockchain where the channel is to be opened
1223 pub chain_hash: ChainHash,
1224 /// The short channel ID
1225 pub short_channel_id: u64,
1226 /// A strictly monotonic announcement counter, with gaps allowed, specific to this channel
1230 /// The number of blocks such that if:
1231 /// `incoming_htlc.cltv_expiry < outgoing_htlc.cltv_expiry + cltv_expiry_delta`
1232 /// then we need to fail the HTLC backwards. When forwarding an HTLC, `cltv_expiry_delta` determines
1233 /// the outgoing HTLC's minimum `cltv_expiry` value -- so, if an incoming HTLC comes in with a
1234 /// `cltv_expiry` of 100000, and the node we're forwarding to has a `cltv_expiry_delta` value of 10,
1235 /// then we'll check that the outgoing HTLC's `cltv_expiry` value is at least 100010 before
1236 /// forwarding. Note that the HTLC sender is the one who originally sets this value when
1237 /// constructing the route.
1238 pub cltv_expiry_delta: u16,
1239 /// The minimum HTLC size incoming to sender, in milli-satoshi
1240 pub htlc_minimum_msat: u64,
1241 /// The maximum HTLC value incoming to sender, in milli-satoshi.
1243 /// This used to be optional.
1244 pub htlc_maximum_msat: u64,
1245 /// The base HTLC fee charged by sender, in milli-satoshi
1246 pub fee_base_msat: u32,
1247 /// The amount to fee multiplier, in micro-satoshi
1248 pub fee_proportional_millionths: u32,
1249 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1252 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1253 pub excess_data: Vec<u8>,
1255 /// A [`channel_update`] message to be sent to or received from a peer.
1257 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1258 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1259 pub struct ChannelUpdate {
1260 /// A signature of the channel update
1261 pub signature: Signature,
1262 /// The actual channel update
1263 pub contents: UnsignedChannelUpdate,
1266 /// A [`query_channel_range`] message is used to query a peer for channel
1267 /// UTXOs in a range of blocks. The recipient of a query makes a best
1268 /// effort to reply to the query using one or more [`ReplyChannelRange`]
1271 /// [`query_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1272 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1273 pub struct QueryChannelRange {
1274 /// The genesis hash of the blockchain being queried
1275 pub chain_hash: ChainHash,
1276 /// The height of the first block for the channel UTXOs being queried
1277 pub first_blocknum: u32,
1278 /// The number of blocks to include in the query results
1279 pub number_of_blocks: u32,
1282 /// A [`reply_channel_range`] message is a reply to a [`QueryChannelRange`]
1285 /// Multiple `reply_channel_range` messages can be sent in reply
1286 /// to a single [`QueryChannelRange`] message. The query recipient makes a
1287 /// best effort to respond based on their local network view which may
1288 /// not be a perfect view of the network. The `short_channel_id`s in the
1289 /// reply are encoded. We only support `encoding_type=0` uncompressed
1290 /// serialization and do not support `encoding_type=1` zlib serialization.
1292 /// [`reply_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1293 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1294 pub struct ReplyChannelRange {
1295 /// The genesis hash of the blockchain being queried
1296 pub chain_hash: ChainHash,
1297 /// The height of the first block in the range of the reply
1298 pub first_blocknum: u32,
1299 /// The number of blocks included in the range of the reply
1300 pub number_of_blocks: u32,
1301 /// True when this is the final reply for a query
1302 pub sync_complete: bool,
1303 /// The `short_channel_id`s in the channel range
1304 pub short_channel_ids: Vec<u64>,
1307 /// A [`query_short_channel_ids`] message is used to query a peer for
1308 /// routing gossip messages related to one or more `short_channel_id`s.
1310 /// The query recipient will reply with the latest, if available,
1311 /// [`ChannelAnnouncement`], [`ChannelUpdate`] and [`NodeAnnouncement`] messages
1312 /// it maintains for the requested `short_channel_id`s followed by a
1313 /// [`ReplyShortChannelIdsEnd`] message. The `short_channel_id`s sent in
1314 /// this query are encoded. We only support `encoding_type=0` uncompressed
1315 /// serialization and do not support `encoding_type=1` zlib serialization.
1317 /// [`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
1318 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1319 pub struct QueryShortChannelIds {
1320 /// The genesis hash of the blockchain being queried
1321 pub chain_hash: ChainHash,
1322 /// The short_channel_ids that are being queried
1323 pub short_channel_ids: Vec<u64>,
1326 /// A [`reply_short_channel_ids_end`] message is sent as a reply to a
1327 /// message. The query recipient makes a best
1328 /// effort to respond based on their local network view which may not be
1329 /// a perfect view of the network.
1331 /// [`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
1332 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1333 pub struct ReplyShortChannelIdsEnd {
1334 /// The genesis hash of the blockchain that was queried
1335 pub chain_hash: ChainHash,
1336 /// Indicates if the query recipient maintains up-to-date channel
1337 /// information for the `chain_hash`
1338 pub full_information: bool,
1341 /// A [`gossip_timestamp_filter`] message is used by a node to request
1342 /// gossip relay for messages in the requested time range when the
1343 /// `gossip_queries` feature has been negotiated.
1345 /// [`gossip_timestamp_filter`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-gossip_timestamp_filter-message
1346 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1347 pub struct GossipTimestampFilter {
1348 /// The genesis hash of the blockchain for channel and node information
1349 pub chain_hash: ChainHash,
1350 /// The starting unix timestamp
1351 pub first_timestamp: u32,
1352 /// The range of information in seconds
1353 pub timestamp_range: u32,
1356 /// Encoding type for data compression of collections in gossip queries.
1358 /// We do not support `encoding_type=1` zlib serialization [defined in BOLT
1359 /// #7](https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#query-messages).
1361 Uncompressed = 0x00,
1364 /// Used to put an error message in a [`LightningError`].
1365 #[derive(Clone, Debug, Hash, PartialEq)]
1366 pub enum ErrorAction {
1367 /// The peer took some action which made us think they were useless. Disconnect them.
1369 /// An error message which we should make an effort to send before we disconnect.
1370 msg: Option<ErrorMessage>
1372 /// The peer did something incorrect. Tell them without closing any channels and disconnect them.
1373 DisconnectPeerWithWarning {
1374 /// A warning message which we should make an effort to send before we disconnect.
1375 msg: WarningMessage,
1377 /// The peer did something harmless that we weren't able to process, just log and ignore
1378 // New code should *not* use this. New code must use IgnoreAndLog, below!
1380 /// The peer did something harmless that we weren't able to meaningfully process.
1381 /// If the error is logged, log it at the given level.
1382 IgnoreAndLog(logger::Level),
1383 /// The peer provided us with a gossip message which we'd already seen. In most cases this
1384 /// should be ignored, but it may result in the message being forwarded if it is a duplicate of
1385 /// our own channel announcements.
1386 IgnoreDuplicateGossip,
1387 /// The peer did something incorrect. Tell them.
1389 /// The message to send.
1392 /// The peer did something incorrect. Tell them without closing any channels.
1393 SendWarningMessage {
1394 /// The message to send.
1395 msg: WarningMessage,
1396 /// The peer may have done something harmless that we weren't able to meaningfully process,
1397 /// though we should still tell them about it.
1398 /// If this event is logged, log it at the given level.
1399 log_level: logger::Level,
1403 /// An Err type for failure to process messages.
1404 #[derive(Clone, Debug)]
1405 pub struct LightningError {
1406 /// A human-readable message describing the error
1408 /// The action which should be taken against the offending peer.
1409 pub action: ErrorAction,
1412 /// Struct used to return values from [`RevokeAndACK`] messages, containing a bunch of commitment
1413 /// transaction updates if they were pending.
1414 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1415 pub struct CommitmentUpdate {
1416 /// `update_add_htlc` messages which should be sent
1417 pub update_add_htlcs: Vec<UpdateAddHTLC>,
1418 /// `update_fulfill_htlc` messages which should be sent
1419 pub update_fulfill_htlcs: Vec<UpdateFulfillHTLC>,
1420 /// `update_fail_htlc` messages which should be sent
1421 pub update_fail_htlcs: Vec<UpdateFailHTLC>,
1422 /// `update_fail_malformed_htlc` messages which should be sent
1423 pub update_fail_malformed_htlcs: Vec<UpdateFailMalformedHTLC>,
1424 /// An `update_fee` message which should be sent
1425 pub update_fee: Option<UpdateFee>,
1426 /// A `commitment_signed` message which should be sent
1427 pub commitment_signed: CommitmentSigned,
1430 /// A trait to describe an object which can receive channel messages.
1432 /// Messages MAY be called in parallel when they originate from different `their_node_ids`, however
1433 /// they MUST NOT be called in parallel when the two calls have the same `their_node_id`.
1434 pub trait ChannelMessageHandler : MessageSendEventsProvider {
1436 /// Handle an incoming `open_channel` message from the given peer.
1437 fn handle_open_channel(&self, their_node_id: &PublicKey, msg: &OpenChannel);
1438 /// Handle an incoming `open_channel2` message from the given peer.
1439 fn handle_open_channel_v2(&self, their_node_id: &PublicKey, msg: &OpenChannelV2);
1440 /// Handle an incoming `accept_channel` message from the given peer.
1441 fn handle_accept_channel(&self, their_node_id: &PublicKey, msg: &AcceptChannel);
1442 /// Handle an incoming `accept_channel2` message from the given peer.
1443 fn handle_accept_channel_v2(&self, their_node_id: &PublicKey, msg: &AcceptChannelV2);
1444 /// Handle an incoming `funding_created` message from the given peer.
1445 fn handle_funding_created(&self, their_node_id: &PublicKey, msg: &FundingCreated);
1446 /// Handle an incoming `funding_signed` message from the given peer.
1447 fn handle_funding_signed(&self, their_node_id: &PublicKey, msg: &FundingSigned);
1448 /// Handle an incoming `channel_ready` message from the given peer.
1449 fn handle_channel_ready(&self, their_node_id: &PublicKey, msg: &ChannelReady);
1452 /// Handle an incoming `shutdown` message from the given peer.
1453 fn handle_shutdown(&self, their_node_id: &PublicKey, msg: &Shutdown);
1454 /// Handle an incoming `closing_signed` message from the given peer.
1455 fn handle_closing_signed(&self, their_node_id: &PublicKey, msg: &ClosingSigned);
1458 /// Handle an incoming `stfu` message from the given peer.
1459 fn handle_stfu(&self, their_node_id: &PublicKey, msg: &Stfu);
1462 /// Handle an incoming `splice` message from the given peer.
1463 fn handle_splice(&self, their_node_id: &PublicKey, msg: &Splice);
1464 /// Handle an incoming `splice_ack` message from the given peer.
1465 fn handle_splice_ack(&self, their_node_id: &PublicKey, msg: &SpliceAck);
1466 /// Handle an incoming `splice_locked` message from the given peer.
1467 fn handle_splice_locked(&self, their_node_id: &PublicKey, msg: &SpliceLocked);
1469 // Interactive channel construction
1470 /// Handle an incoming `tx_add_input message` from the given peer.
1471 fn handle_tx_add_input(&self, their_node_id: &PublicKey, msg: &TxAddInput);
1472 /// Handle an incoming `tx_add_output` message from the given peer.
1473 fn handle_tx_add_output(&self, their_node_id: &PublicKey, msg: &TxAddOutput);
1474 /// Handle an incoming `tx_remove_input` message from the given peer.
1475 fn handle_tx_remove_input(&self, their_node_id: &PublicKey, msg: &TxRemoveInput);
1476 /// Handle an incoming `tx_remove_output` message from the given peer.
1477 fn handle_tx_remove_output(&self, their_node_id: &PublicKey, msg: &TxRemoveOutput);
1478 /// Handle an incoming `tx_complete message` from the given peer.
1479 fn handle_tx_complete(&self, their_node_id: &PublicKey, msg: &TxComplete);
1480 /// Handle an incoming `tx_signatures` message from the given peer.
1481 fn handle_tx_signatures(&self, their_node_id: &PublicKey, msg: &TxSignatures);
1482 /// Handle an incoming `tx_init_rbf` message from the given peer.
1483 fn handle_tx_init_rbf(&self, their_node_id: &PublicKey, msg: &TxInitRbf);
1484 /// Handle an incoming `tx_ack_rbf` message from the given peer.
1485 fn handle_tx_ack_rbf(&self, their_node_id: &PublicKey, msg: &TxAckRbf);
1486 /// Handle an incoming `tx_abort message` from the given peer.
1487 fn handle_tx_abort(&self, their_node_id: &PublicKey, msg: &TxAbort);
1490 /// Handle an incoming `update_add_htlc` message from the given peer.
1491 fn handle_update_add_htlc(&self, their_node_id: &PublicKey, msg: &UpdateAddHTLC);
1492 /// Handle an incoming `update_fulfill_htlc` message from the given peer.
1493 fn handle_update_fulfill_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFulfillHTLC);
1494 /// Handle an incoming `update_fail_htlc` message from the given peer.
1495 fn handle_update_fail_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailHTLC);
1496 /// Handle an incoming `update_fail_malformed_htlc` message from the given peer.
1497 fn handle_update_fail_malformed_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailMalformedHTLC);
1498 /// Handle an incoming `commitment_signed` message from the given peer.
1499 fn handle_commitment_signed(&self, their_node_id: &PublicKey, msg: &CommitmentSigned);
1500 /// Handle an incoming `revoke_and_ack` message from the given peer.
1501 fn handle_revoke_and_ack(&self, their_node_id: &PublicKey, msg: &RevokeAndACK);
1503 /// Handle an incoming `update_fee` message from the given peer.
1504 fn handle_update_fee(&self, their_node_id: &PublicKey, msg: &UpdateFee);
1506 // Channel-to-announce:
1507 /// Handle an incoming `announcement_signatures` message from the given peer.
1508 fn handle_announcement_signatures(&self, their_node_id: &PublicKey, msg: &AnnouncementSignatures);
1510 // Connection loss/reestablish:
1511 /// Indicates a connection to the peer failed/an existing connection was lost.
1512 fn peer_disconnected(&self, their_node_id: &PublicKey);
1514 /// Handle a peer reconnecting, possibly generating `channel_reestablish` message(s).
1516 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1517 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1518 /// message handlers may still wish to communicate with this peer.
1519 fn peer_connected(&self, their_node_id: &PublicKey, msg: &Init, inbound: bool) -> Result<(), ()>;
1520 /// Handle an incoming `channel_reestablish` message from the given peer.
1521 fn handle_channel_reestablish(&self, their_node_id: &PublicKey, msg: &ChannelReestablish);
1523 /// Handle an incoming `channel_update` message from the given peer.
1524 fn handle_channel_update(&self, their_node_id: &PublicKey, msg: &ChannelUpdate);
1527 /// Handle an incoming `error` message from the given peer.
1528 fn handle_error(&self, their_node_id: &PublicKey, msg: &ErrorMessage);
1530 // Handler information:
1531 /// Gets the node feature flags which this handler itself supports. All available handlers are
1532 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1533 /// which are broadcasted in our [`NodeAnnouncement`] message.
1534 fn provided_node_features(&self) -> NodeFeatures;
1536 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1537 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1538 /// which are sent in our [`Init`] message.
1540 /// Note that this method is called before [`Self::peer_connected`].
1541 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1543 /// Gets the chain hashes for this `ChannelMessageHandler` indicating which chains it supports.
1545 /// If it's `None`, then no particular network chain hash compatibility will be enforced when
1546 /// connecting to peers.
1547 fn get_chain_hashes(&self) -> Option<Vec<ChainHash>>;
1550 /// A trait to describe an object which can receive routing messages.
1552 /// # Implementor DoS Warnings
1554 /// For messages enabled with the `gossip_queries` feature there are potential DoS vectors when
1555 /// handling inbound queries. Implementors using an on-disk network graph should be aware of
1556 /// repeated disk I/O for queries accessing different parts of the network graph.
1557 pub trait RoutingMessageHandler : MessageSendEventsProvider {
1558 /// Handle an incoming `node_announcement` message, returning `true` if it should be forwarded on,
1559 /// `false` or returning an `Err` otherwise.
1560 fn handle_node_announcement(&self, msg: &NodeAnnouncement) -> Result<bool, LightningError>;
1561 /// Handle a `channel_announcement` message, returning `true` if it should be forwarded on, `false`
1562 /// or returning an `Err` otherwise.
1563 fn handle_channel_announcement(&self, msg: &ChannelAnnouncement) -> Result<bool, LightningError>;
1564 /// Handle an incoming `channel_update` message, returning true if it should be forwarded on,
1565 /// `false` or returning an `Err` otherwise.
1566 fn handle_channel_update(&self, msg: &ChannelUpdate) -> Result<bool, LightningError>;
1567 /// Gets channel announcements and updates required to dump our routing table to a remote node,
1568 /// starting at the `short_channel_id` indicated by `starting_point` and including announcements
1569 /// for a single channel.
1570 fn get_next_channel_announcement(&self, starting_point: u64) -> Option<(ChannelAnnouncement, Option<ChannelUpdate>, Option<ChannelUpdate>)>;
1571 /// Gets a node announcement required to dump our routing table to a remote node, starting at
1572 /// the node *after* the provided pubkey and including up to one announcement immediately
1573 /// higher (as defined by `<PublicKey as Ord>::cmp`) than `starting_point`.
1574 /// If `None` is provided for `starting_point`, we start at the first node.
1575 fn get_next_node_announcement(&self, starting_point: Option<&NodeId>) -> Option<NodeAnnouncement>;
1576 /// Called when a connection is established with a peer. This can be used to
1577 /// perform routing table synchronization using a strategy defined by the
1580 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1581 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1582 /// message handlers may still wish to communicate with this peer.
1583 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1584 /// Handles the reply of a query we initiated to learn about channels
1585 /// for a given range of blocks. We can expect to receive one or more
1586 /// replies to a single query.
1587 fn handle_reply_channel_range(&self, their_node_id: &PublicKey, msg: ReplyChannelRange) -> Result<(), LightningError>;
1588 /// Handles the reply of a query we initiated asking for routing gossip
1589 /// messages for a list of channels. We should receive this message when
1590 /// a node has completed its best effort to send us the pertaining routing
1591 /// gossip messages.
1592 fn handle_reply_short_channel_ids_end(&self, their_node_id: &PublicKey, msg: ReplyShortChannelIdsEnd) -> Result<(), LightningError>;
1593 /// Handles when a peer asks us to send a list of `short_channel_id`s
1594 /// for the requested range of blocks.
1595 fn handle_query_channel_range(&self, their_node_id: &PublicKey, msg: QueryChannelRange) -> Result<(), LightningError>;
1596 /// Handles when a peer asks us to send routing gossip messages for a
1597 /// list of `short_channel_id`s.
1598 fn handle_query_short_channel_ids(&self, their_node_id: &PublicKey, msg: QueryShortChannelIds) -> Result<(), LightningError>;
1600 // Handler queueing status:
1601 /// Indicates that there are a large number of [`ChannelAnnouncement`] (or other) messages
1602 /// pending some async action. While there is no guarantee of the rate of future messages, the
1603 /// caller should seek to reduce the rate of new gossip messages handled, especially
1604 /// [`ChannelAnnouncement`]s.
1605 fn processing_queue_high(&self) -> bool;
1607 // Handler information:
1608 /// Gets the node feature flags which this handler itself supports. All available handlers are
1609 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1610 /// which are broadcasted in our [`NodeAnnouncement`] message.
1611 fn provided_node_features(&self) -> NodeFeatures;
1612 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1613 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1614 /// which are sent in our [`Init`] message.
1616 /// Note that this method is called before [`Self::peer_connected`].
1617 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1620 /// A handler for received [`OnionMessage`]s and for providing generated ones to send.
1621 pub trait OnionMessageHandler: EventsProvider {
1622 /// Handle an incoming `onion_message` message from the given peer.
1623 fn handle_onion_message(&self, peer_node_id: &PublicKey, msg: &OnionMessage);
1625 /// Returns the next pending onion message for the peer with the given node id.
1626 fn next_onion_message_for_peer(&self, peer_node_id: PublicKey) -> Option<OnionMessage>;
1628 /// Called when a connection is established with a peer. Can be used to track which peers
1629 /// advertise onion message support and are online.
1631 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1632 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1633 /// message handlers may still wish to communicate with this peer.
1634 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1636 /// Indicates a connection to the peer failed/an existing connection was lost. Allows handlers to
1637 /// drop and refuse to forward onion messages to this peer.
1638 fn peer_disconnected(&self, their_node_id: &PublicKey);
1640 /// Performs actions that should happen roughly every ten seconds after startup. Allows handlers
1641 /// to drop any buffered onion messages intended for prospective peers.
1642 fn timer_tick_occurred(&self);
1644 // Handler information:
1645 /// Gets the node feature flags which this handler itself supports. All available handlers are
1646 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1647 /// which are broadcasted in our [`NodeAnnouncement`] message.
1648 fn provided_node_features(&self) -> NodeFeatures;
1650 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1651 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1652 /// which are sent in our [`Init`] message.
1654 /// Note that this method is called before [`Self::peer_connected`].
1655 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1659 #[cfg_attr(test, derive(Debug, PartialEq))]
1660 /// Information communicated in the onion to the recipient for multi-part tracking and proof that
1661 /// the payment is associated with an invoice.
1662 pub struct FinalOnionHopData {
1663 /// When sending a multi-part payment, this secret is used to identify a payment across HTLCs.
1664 /// Because it is generated by the recipient and included in the invoice, it also provides
1665 /// proof to the recipient that the payment was sent by someone with the generated invoice.
1666 pub payment_secret: PaymentSecret,
1667 /// The intended total amount that this payment is for.
1669 /// Message serialization may panic if this value is more than 21 million Bitcoin.
1670 pub total_msat: u64,
1673 mod fuzzy_internal_msgs {
1674 use bitcoin::secp256k1::PublicKey;
1675 use crate::blinded_path::payment::{PaymentConstraints, PaymentRelay};
1676 use crate::prelude::*;
1677 use crate::ln::{PaymentPreimage, PaymentSecret};
1678 use crate::ln::features::BlindedHopFeatures;
1679 use super::FinalOnionHopData;
1681 // These types aren't intended to be pub, but are exposed for direct fuzzing (as we deserialize
1682 // them from untrusted input):
1684 pub enum InboundOnionPayload {
1686 short_channel_id: u64,
1687 /// The value, in msat, of the payment after this hop's fee is deducted.
1688 amt_to_forward: u64,
1689 outgoing_cltv_value: u32,
1692 payment_data: Option<FinalOnionHopData>,
1693 payment_metadata: Option<Vec<u8>>,
1694 keysend_preimage: Option<PaymentPreimage>,
1695 custom_tlvs: Vec<(u64, Vec<u8>)>,
1696 sender_intended_htlc_amt_msat: u64,
1697 cltv_expiry_height: u32,
1700 short_channel_id: u64,
1701 payment_relay: PaymentRelay,
1702 payment_constraints: PaymentConstraints,
1703 features: BlindedHopFeatures,
1704 intro_node_blinding_point: Option<PublicKey>,
1707 sender_intended_htlc_amt_msat: u64,
1709 cltv_expiry_height: u32,
1710 payment_secret: PaymentSecret,
1711 payment_constraints: PaymentConstraints,
1712 intro_node_blinding_point: Option<PublicKey>,
1713 keysend_preimage: Option<PaymentPreimage>,
1717 pub(crate) enum OutboundOnionPayload {
1719 short_channel_id: u64,
1720 /// The value, in msat, of the payment after this hop's fee is deducted.
1721 amt_to_forward: u64,
1722 outgoing_cltv_value: u32,
1725 payment_data: Option<FinalOnionHopData>,
1726 payment_metadata: Option<Vec<u8>>,
1727 keysend_preimage: Option<PaymentPreimage>,
1728 custom_tlvs: Vec<(u64, Vec<u8>)>,
1729 sender_intended_htlc_amt_msat: u64,
1730 cltv_expiry_height: u32,
1733 encrypted_tlvs: Vec<u8>,
1734 intro_node_blinding_point: Option<PublicKey>,
1737 sender_intended_htlc_amt_msat: u64,
1739 cltv_expiry_height: u32,
1740 encrypted_tlvs: Vec<u8>,
1741 intro_node_blinding_point: Option<PublicKey>, // Set if the introduction node of the blinded path is the final node
1742 keysend_preimage: Option<PaymentPreimage>,
1746 pub struct DecodedOnionErrorPacket {
1747 pub(crate) hmac: [u8; 32],
1748 pub(crate) failuremsg: Vec<u8>,
1749 pub(crate) pad: Vec<u8>,
1753 pub use self::fuzzy_internal_msgs::*;
1754 #[cfg(not(fuzzing))]
1755 pub(crate) use self::fuzzy_internal_msgs::*;
1757 /// BOLT 4 onion packet including hop data for the next peer.
1758 #[derive(Clone, Hash, PartialEq, Eq)]
1759 pub struct OnionPacket {
1760 /// BOLT 4 version number.
1762 /// In order to ensure we always return an error on onion decode in compliance with [BOLT
1763 /// #4](https://github.com/lightning/bolts/blob/master/04-onion-routing.md), we have to
1764 /// deserialize `OnionPacket`s contained in [`UpdateAddHTLC`] messages even if the ephemeral
1765 /// public key (here) is bogus, so we hold a [`Result`] instead of a [`PublicKey`] as we'd
1767 pub public_key: Result<PublicKey, secp256k1::Error>,
1768 /// 1300 bytes encrypted payload for the next hop.
1769 pub hop_data: [u8; 20*65],
1770 /// HMAC to verify the integrity of hop_data.
1774 impl onion_utils::Packet for OnionPacket {
1775 type Data = onion_utils::FixedSizeOnionPacket;
1776 fn new(pubkey: PublicKey, hop_data: onion_utils::FixedSizeOnionPacket, hmac: [u8; 32]) -> Self {
1779 public_key: Ok(pubkey),
1780 hop_data: hop_data.0,
1786 impl fmt::Debug for OnionPacket {
1787 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1788 f.write_fmt(format_args!("OnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
1792 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1793 pub(crate) struct OnionErrorPacket {
1794 // This really should be a constant size slice, but the spec lets these things be up to 128KB?
1795 // (TODO) We limit it in decode to much lower...
1796 pub(crate) data: Vec<u8>,
1799 impl fmt::Display for DecodeError {
1800 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1802 DecodeError::UnknownVersion => f.write_str("Unknown realm byte in Onion packet"),
1803 DecodeError::UnknownRequiredFeature => f.write_str("Unknown required feature preventing decode"),
1804 DecodeError::InvalidValue => f.write_str("Nonsense bytes didn't map to the type they were interpreted as"),
1805 DecodeError::ShortRead => f.write_str("Packet extended beyond the provided bytes"),
1806 DecodeError::BadLengthDescriptor => f.write_str("A length descriptor in the packet didn't describe the later data correctly"),
1807 DecodeError::Io(ref e) => fmt::Debug::fmt(e, f),
1808 DecodeError::UnsupportedCompression => f.write_str("We don't support receiving messages with zlib-compressed fields"),
1809 DecodeError::DangerousValue => f.write_str("Value would be dangerous to continue execution with"),
1814 impl From<io::Error> for DecodeError {
1815 fn from(e: io::Error) -> Self {
1816 if e.kind() == io::ErrorKind::UnexpectedEof {
1817 DecodeError::ShortRead
1819 DecodeError::Io(e.kind())
1824 impl Writeable for AcceptChannel {
1825 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1826 self.common_fields.temporary_channel_id.write(w)?;
1827 self.common_fields.dust_limit_satoshis.write(w)?;
1828 self.common_fields.max_htlc_value_in_flight_msat.write(w)?;
1829 self.channel_reserve_satoshis.write(w)?;
1830 self.common_fields.htlc_minimum_msat.write(w)?;
1831 self.common_fields.minimum_depth.write(w)?;
1832 self.common_fields.to_self_delay.write(w)?;
1833 self.common_fields.max_accepted_htlcs.write(w)?;
1834 self.common_fields.funding_pubkey.write(w)?;
1835 self.common_fields.revocation_basepoint.write(w)?;
1836 self.common_fields.payment_basepoint.write(w)?;
1837 self.common_fields.delayed_payment_basepoint.write(w)?;
1838 self.common_fields.htlc_basepoint.write(w)?;
1839 self.common_fields.first_per_commitment_point.write(w)?;
1840 #[cfg(not(taproot))]
1841 encode_tlv_stream!(w, {
1842 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
1843 (1, self.common_fields.channel_type, option),
1846 encode_tlv_stream!(w, {
1847 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
1848 (1, self.common_fields.channel_type, option),
1849 (4, self.next_local_nonce, option),
1855 impl Readable for AcceptChannel {
1856 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1857 let temporary_channel_id: ChannelId = Readable::read(r)?;
1858 let dust_limit_satoshis: u64 = Readable::read(r)?;
1859 let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;
1860 let channel_reserve_satoshis: u64 = Readable::read(r)?;
1861 let htlc_minimum_msat: u64 = Readable::read(r)?;
1862 let minimum_depth: u32 = Readable::read(r)?;
1863 let to_self_delay: u16 = Readable::read(r)?;
1864 let max_accepted_htlcs: u16 = Readable::read(r)?;
1865 let funding_pubkey: PublicKey = Readable::read(r)?;
1866 let revocation_basepoint: PublicKey = Readable::read(r)?;
1867 let payment_basepoint: PublicKey = Readable::read(r)?;
1868 let delayed_payment_basepoint: PublicKey = Readable::read(r)?;
1869 let htlc_basepoint: PublicKey = Readable::read(r)?;
1870 let first_per_commitment_point: PublicKey = Readable::read(r)?;
1872 let mut shutdown_scriptpubkey: Option<ScriptBuf> = None;
1873 let mut channel_type: Option<ChannelTypeFeatures> = None;
1874 #[cfg(not(taproot))]
1875 decode_tlv_stream!(r, {
1876 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
1877 (1, channel_type, option),
1880 let mut next_local_nonce: Option<musig2::types::PublicNonce> = None;
1882 decode_tlv_stream!(r, {
1883 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
1884 (1, channel_type, option),
1885 (4, next_local_nonce, option),
1889 common_fields: CommonAcceptChannelFields {
1890 temporary_channel_id,
1891 dust_limit_satoshis,
1892 max_htlc_value_in_flight_msat,
1898 revocation_basepoint,
1900 delayed_payment_basepoint,
1902 first_per_commitment_point,
1903 shutdown_scriptpubkey,
1906 channel_reserve_satoshis,
1913 impl Writeable for AcceptChannelV2 {
1914 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1915 self.common_fields.temporary_channel_id.write(w)?;
1916 self.funding_satoshis.write(w)?;
1917 self.common_fields.dust_limit_satoshis.write(w)?;
1918 self.common_fields.max_htlc_value_in_flight_msat.write(w)?;
1919 self.common_fields.htlc_minimum_msat.write(w)?;
1920 self.common_fields.minimum_depth.write(w)?;
1921 self.common_fields.to_self_delay.write(w)?;
1922 self.common_fields.max_accepted_htlcs.write(w)?;
1923 self.common_fields.funding_pubkey.write(w)?;
1924 self.common_fields.revocation_basepoint.write(w)?;
1925 self.common_fields.payment_basepoint.write(w)?;
1926 self.common_fields.delayed_payment_basepoint.write(w)?;
1927 self.common_fields.htlc_basepoint.write(w)?;
1928 self.common_fields.first_per_commitment_point.write(w)?;
1929 self.second_per_commitment_point.write(w)?;
1931 encode_tlv_stream!(w, {
1932 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
1933 (1, self.common_fields.channel_type, option),
1934 (2, self.require_confirmed_inputs, option),
1940 impl Readable for AcceptChannelV2 {
1941 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1942 let temporary_channel_id: ChannelId = Readable::read(r)?;
1943 let funding_satoshis: u64 = Readable::read(r)?;
1944 let dust_limit_satoshis: u64 = Readable::read(r)?;
1945 let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;
1946 let htlc_minimum_msat: u64 = Readable::read(r)?;
1947 let minimum_depth: u32 = Readable::read(r)?;
1948 let to_self_delay: u16 = Readable::read(r)?;
1949 let max_accepted_htlcs: u16 = Readable::read(r)?;
1950 let funding_pubkey: PublicKey = Readable::read(r)?;
1951 let revocation_basepoint: PublicKey = Readable::read(r)?;
1952 let payment_basepoint: PublicKey = Readable::read(r)?;
1953 let delayed_payment_basepoint: PublicKey = Readable::read(r)?;
1954 let htlc_basepoint: PublicKey = Readable::read(r)?;
1955 let first_per_commitment_point: PublicKey = Readable::read(r)?;
1956 let second_per_commitment_point: PublicKey = Readable::read(r)?;
1958 let mut shutdown_scriptpubkey: Option<ScriptBuf> = None;
1959 let mut channel_type: Option<ChannelTypeFeatures> = None;
1960 let mut require_confirmed_inputs: Option<()> = None;
1961 decode_tlv_stream!(r, {
1962 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
1963 (1, channel_type, option),
1964 (2, require_confirmed_inputs, option),
1967 Ok(AcceptChannelV2 {
1968 common_fields: CommonAcceptChannelFields {
1969 temporary_channel_id,
1970 dust_limit_satoshis,
1971 max_htlc_value_in_flight_msat,
1977 revocation_basepoint,
1979 delayed_payment_basepoint,
1981 first_per_commitment_point,
1982 shutdown_scriptpubkey,
1986 second_per_commitment_point,
1987 require_confirmed_inputs,
1992 impl_writeable_msg!(Stfu, {
1997 impl_writeable_msg!(Splice, {
2001 funding_feerate_perkw,
2006 impl_writeable_msg!(SpliceAck, {
2013 impl_writeable_msg!(SpliceLocked, {
2017 impl_writeable_msg!(TxAddInput, {
2025 impl_writeable_msg!(TxAddOutput, {
2032 impl_writeable_msg!(TxRemoveInput, {
2037 impl_writeable_msg!(TxRemoveOutput, {
2042 impl_writeable_msg!(TxComplete, {
2046 impl_writeable_msg!(TxSignatures, {
2052 impl_writeable_msg!(TxInitRbf, {
2055 feerate_sat_per_1000_weight,
2057 (0, funding_output_contribution, option),
2060 impl_writeable_msg!(TxAckRbf, {
2063 (0, funding_output_contribution, option),
2066 impl_writeable_msg!(TxAbort, {
2071 impl_writeable_msg!(AnnouncementSignatures, {
2078 impl_writeable_msg!(ChannelReestablish, {
2080 next_local_commitment_number,
2081 next_remote_commitment_number,
2082 your_last_per_commitment_secret,
2083 my_current_per_commitment_point,
2085 (0, next_funding_txid, option),
2088 impl_writeable_msg!(ClosingSigned,
2089 { channel_id, fee_satoshis, signature },
2090 { (1, fee_range, option) }
2093 impl_writeable!(ClosingSignedFeeRange, {
2098 #[cfg(not(taproot))]
2099 impl_writeable_msg!(CommitmentSigned, {
2106 impl_writeable_msg!(CommitmentSigned, {
2111 (2, partial_signature_with_nonce, option)
2114 impl_writeable!(DecodedOnionErrorPacket, {
2120 #[cfg(not(taproot))]
2121 impl_writeable_msg!(FundingCreated, {
2122 temporary_channel_id,
2124 funding_output_index,
2128 impl_writeable_msg!(FundingCreated, {
2129 temporary_channel_id,
2131 funding_output_index,
2134 (2, partial_signature_with_nonce, option),
2135 (4, next_local_nonce, option)
2138 #[cfg(not(taproot))]
2139 impl_writeable_msg!(FundingSigned, {
2145 impl_writeable_msg!(FundingSigned, {
2149 (2, partial_signature_with_nonce, option)
2152 impl_writeable_msg!(ChannelReady, {
2154 next_per_commitment_point,
2156 (1, short_channel_id_alias, option),
2159 impl Writeable for Init {
2160 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2161 // global_features gets the bottom 13 bits of our features, and local_features gets all of
2162 // our relevant feature bits. This keeps us compatible with old nodes.
2163 self.features.write_up_to_13(w)?;
2164 self.features.write(w)?;
2165 encode_tlv_stream!(w, {
2166 (1, self.networks.as_ref().map(|n| WithoutLength(n)), option),
2167 (3, self.remote_network_address, option),
2173 impl Readable for Init {
2174 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2175 let global_features: InitFeatures = Readable::read(r)?;
2176 let features: InitFeatures = Readable::read(r)?;
2177 let mut remote_network_address: Option<SocketAddress> = None;
2178 let mut networks: Option<WithoutLength<Vec<ChainHash>>> = None;
2179 decode_tlv_stream!(r, {
2180 (1, networks, option),
2181 (3, remote_network_address, option)
2184 features: features | global_features,
2185 networks: networks.map(|n| n.0),
2186 remote_network_address,
2191 impl Writeable for OpenChannel {
2192 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2193 self.common_fields.chain_hash.write(w)?;
2194 self.common_fields.temporary_channel_id.write(w)?;
2195 self.common_fields.funding_satoshis.write(w)?;
2196 self.push_msat.write(w)?;
2197 self.common_fields.dust_limit_satoshis.write(w)?;
2198 self.common_fields.max_htlc_value_in_flight_msat.write(w)?;
2199 self.channel_reserve_satoshis.write(w)?;
2200 self.common_fields.htlc_minimum_msat.write(w)?;
2201 self.common_fields.commitment_feerate_sat_per_1000_weight.write(w)?;
2202 self.common_fields.to_self_delay.write(w)?;
2203 self.common_fields.max_accepted_htlcs.write(w)?;
2204 self.common_fields.funding_pubkey.write(w)?;
2205 self.common_fields.revocation_basepoint.write(w)?;
2206 self.common_fields.payment_basepoint.write(w)?;
2207 self.common_fields.delayed_payment_basepoint.write(w)?;
2208 self.common_fields.htlc_basepoint.write(w)?;
2209 self.common_fields.first_per_commitment_point.write(w)?;
2210 self.common_fields.channel_flags.write(w)?;
2211 encode_tlv_stream!(w, {
2212 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
2213 (1, self.common_fields.channel_type, option),
2219 impl Readable for OpenChannel {
2220 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2221 let chain_hash: ChainHash = Readable::read(r)?;
2222 let temporary_channel_id: ChannelId = Readable::read(r)?;
2223 let funding_satoshis: u64 = Readable::read(r)?;
2224 let push_msat: u64 = Readable::read(r)?;
2225 let dust_limit_satoshis: u64 = Readable::read(r)?;
2226 let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;
2227 let channel_reserve_satoshis: u64 = Readable::read(r)?;
2228 let htlc_minimum_msat: u64 = Readable::read(r)?;
2229 let commitment_feerate_sat_per_1000_weight: u32 = Readable::read(r)?;
2230 let to_self_delay: u16 = Readable::read(r)?;
2231 let max_accepted_htlcs: u16 = Readable::read(r)?;
2232 let funding_pubkey: PublicKey = Readable::read(r)?;
2233 let revocation_basepoint: PublicKey = Readable::read(r)?;
2234 let payment_basepoint: PublicKey = Readable::read(r)?;
2235 let delayed_payment_basepoint: PublicKey = Readable::read(r)?;
2236 let htlc_basepoint: PublicKey = Readable::read(r)?;
2237 let first_per_commitment_point: PublicKey = Readable::read(r)?;
2238 let channel_flags: u8 = Readable::read(r)?;
2240 let mut shutdown_scriptpubkey: Option<ScriptBuf> = None;
2241 let mut channel_type: Option<ChannelTypeFeatures> = None;
2242 decode_tlv_stream!(r, {
2243 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
2244 (1, channel_type, option),
2247 common_fields: CommonOpenChannelFields {
2249 temporary_channel_id,
2251 dust_limit_satoshis,
2252 max_htlc_value_in_flight_msat,
2254 commitment_feerate_sat_per_1000_weight,
2258 revocation_basepoint,
2260 delayed_payment_basepoint,
2262 first_per_commitment_point,
2264 shutdown_scriptpubkey,
2268 channel_reserve_satoshis,
2273 impl Writeable for OpenChannelV2 {
2274 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2275 self.common_fields.chain_hash.write(w)?;
2276 self.common_fields.temporary_channel_id.write(w)?;
2277 self.funding_feerate_sat_per_1000_weight.write(w)?;
2278 self.common_fields.commitment_feerate_sat_per_1000_weight.write(w)?;
2279 self.common_fields.funding_satoshis.write(w)?;
2280 self.common_fields.dust_limit_satoshis.write(w)?;
2281 self.common_fields.max_htlc_value_in_flight_msat.write(w)?;
2282 self.common_fields.htlc_minimum_msat.write(w)?;
2283 self.common_fields.to_self_delay.write(w)?;
2284 self.common_fields.max_accepted_htlcs.write(w)?;
2285 self.locktime.write(w)?;
2286 self.common_fields.funding_pubkey.write(w)?;
2287 self.common_fields.revocation_basepoint.write(w)?;
2288 self.common_fields.payment_basepoint.write(w)?;
2289 self.common_fields.delayed_payment_basepoint.write(w)?;
2290 self.common_fields.htlc_basepoint.write(w)?;
2291 self.common_fields.first_per_commitment_point.write(w)?;
2292 self.second_per_commitment_point.write(w)?;
2293 self.common_fields.channel_flags.write(w)?;
2294 encode_tlv_stream!(w, {
2295 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
2296 (1, self.common_fields.channel_type, option),
2297 (2, self.require_confirmed_inputs, option),
2303 impl Readable for OpenChannelV2 {
2304 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2305 let chain_hash: ChainHash = Readable::read(r)?;
2306 let temporary_channel_id: ChannelId = Readable::read(r)?;
2307 let funding_feerate_sat_per_1000_weight: u32 = Readable::read(r)?;
2308 let commitment_feerate_sat_per_1000_weight: u32 = Readable::read(r)?;
2309 let funding_satoshis: u64 = Readable::read(r)?;
2310 let dust_limit_satoshis: u64 = Readable::read(r)?;
2311 let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;
2312 let htlc_minimum_msat: u64 = Readable::read(r)?;
2313 let to_self_delay: u16 = Readable::read(r)?;
2314 let max_accepted_htlcs: u16 = Readable::read(r)?;
2315 let locktime: u32 = Readable::read(r)?;
2316 let funding_pubkey: PublicKey = Readable::read(r)?;
2317 let revocation_basepoint: PublicKey = Readable::read(r)?;
2318 let payment_basepoint: PublicKey = Readable::read(r)?;
2319 let delayed_payment_basepoint: PublicKey = Readable::read(r)?;
2320 let htlc_basepoint: PublicKey = Readable::read(r)?;
2321 let first_per_commitment_point: PublicKey = Readable::read(r)?;
2322 let second_per_commitment_point: PublicKey = Readable::read(r)?;
2323 let channel_flags: u8 = Readable::read(r)?;
2325 let mut shutdown_scriptpubkey: Option<ScriptBuf> = None;
2326 let mut channel_type: Option<ChannelTypeFeatures> = None;
2327 let mut require_confirmed_inputs: Option<()> = None;
2328 decode_tlv_stream!(r, {
2329 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
2330 (1, channel_type, option),
2331 (2, require_confirmed_inputs, option),
2334 common_fields: CommonOpenChannelFields {
2336 temporary_channel_id,
2338 dust_limit_satoshis,
2339 max_htlc_value_in_flight_msat,
2341 commitment_feerate_sat_per_1000_weight,
2345 revocation_basepoint,
2347 delayed_payment_basepoint,
2349 first_per_commitment_point,
2351 shutdown_scriptpubkey,
2354 funding_feerate_sat_per_1000_weight,
2356 second_per_commitment_point,
2357 require_confirmed_inputs,
2362 #[cfg(not(taproot))]
2363 impl_writeable_msg!(RevokeAndACK, {
2365 per_commitment_secret,
2366 next_per_commitment_point
2370 impl_writeable_msg!(RevokeAndACK, {
2372 per_commitment_secret,
2373 next_per_commitment_point
2375 (4, next_local_nonce, option)
2378 impl_writeable_msg!(Shutdown, {
2383 impl_writeable_msg!(UpdateFailHTLC, {
2389 impl_writeable_msg!(UpdateFailMalformedHTLC, {
2396 impl_writeable_msg!(UpdateFee, {
2401 impl_writeable_msg!(UpdateFulfillHTLC, {
2407 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2408 // serialization format in a way which assumes we know the total serialized length/message end
2410 impl_writeable!(OnionErrorPacket, {
2414 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2415 // serialization format in a way which assumes we know the total serialized length/message end
2417 impl Writeable for OnionPacket {
2418 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2419 self.version.write(w)?;
2420 match self.public_key {
2421 Ok(pubkey) => pubkey.write(w)?,
2422 Err(_) => [0u8;33].write(w)?,
2424 w.write_all(&self.hop_data)?;
2425 self.hmac.write(w)?;
2430 impl Readable for OnionPacket {
2431 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2433 version: Readable::read(r)?,
2435 let mut buf = [0u8;33];
2436 r.read_exact(&mut buf)?;
2437 PublicKey::from_slice(&buf)
2439 hop_data: Readable::read(r)?,
2440 hmac: Readable::read(r)?,
2445 impl_writeable_msg!(UpdateAddHTLC, {
2451 onion_routing_packet,
2453 (0, blinding_point, option),
2454 (65537, skimmed_fee_msat, option)
2457 impl Readable for OnionMessage {
2458 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2459 let blinding_point: PublicKey = Readable::read(r)?;
2460 let len: u16 = Readable::read(r)?;
2461 let mut packet_reader = FixedLengthReader::new(r, len as u64);
2462 let onion_routing_packet: onion_message::packet::Packet =
2463 <onion_message::packet::Packet as LengthReadable>::read(&mut packet_reader)?;
2466 onion_routing_packet,
2471 impl Writeable for OnionMessage {
2472 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2473 self.blinding_point.write(w)?;
2474 let onion_packet_len = self.onion_routing_packet.serialized_length();
2475 (onion_packet_len as u16).write(w)?;
2476 self.onion_routing_packet.write(w)?;
2481 impl Writeable for FinalOnionHopData {
2482 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2483 self.payment_secret.0.write(w)?;
2484 HighZeroBytesDroppedBigSize(self.total_msat).write(w)
2488 impl Readable for FinalOnionHopData {
2489 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2490 let secret: [u8; 32] = Readable::read(r)?;
2491 let amt: HighZeroBytesDroppedBigSize<u64> = Readable::read(r)?;
2492 Ok(Self { payment_secret: PaymentSecret(secret), total_msat: amt.0 })
2496 impl Writeable for OutboundOnionPayload {
2497 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2499 Self::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } => {
2500 _encode_varint_length_prefixed_tlv!(w, {
2501 (2, HighZeroBytesDroppedBigSize(*amt_to_forward), required),
2502 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2503 (6, short_channel_id, required)
2507 ref payment_data, ref payment_metadata, ref keysend_preimage, sender_intended_htlc_amt_msat,
2508 cltv_expiry_height, ref custom_tlvs,
2510 // We need to update [`ln::outbound_payment::RecipientOnionFields::with_custom_tlvs`]
2511 // to reject any reserved types in the experimental range if new ones are ever
2513 let keysend_tlv = keysend_preimage.map(|preimage| (5482373484, preimage.encode()));
2514 let mut custom_tlvs: Vec<&(u64, Vec<u8>)> = custom_tlvs.iter().chain(keysend_tlv.iter()).collect();
2515 custom_tlvs.sort_unstable_by_key(|(typ, _)| *typ);
2516 _encode_varint_length_prefixed_tlv!(w, {
2517 (2, HighZeroBytesDroppedBigSize(*sender_intended_htlc_amt_msat), required),
2518 (4, HighZeroBytesDroppedBigSize(*cltv_expiry_height), required),
2519 (8, payment_data, option),
2520 (16, payment_metadata.as_ref().map(|m| WithoutLength(m)), option)
2521 }, custom_tlvs.iter());
2523 Self::BlindedForward { encrypted_tlvs, intro_node_blinding_point } => {
2524 _encode_varint_length_prefixed_tlv!(w, {
2525 (10, *encrypted_tlvs, required_vec),
2526 (12, intro_node_blinding_point, option)
2529 Self::BlindedReceive {
2530 sender_intended_htlc_amt_msat, total_msat, cltv_expiry_height, encrypted_tlvs,
2531 intro_node_blinding_point, keysend_preimage,
2533 _encode_varint_length_prefixed_tlv!(w, {
2534 (2, HighZeroBytesDroppedBigSize(*sender_intended_htlc_amt_msat), required),
2535 (4, HighZeroBytesDroppedBigSize(*cltv_expiry_height), required),
2536 (10, *encrypted_tlvs, required_vec),
2537 (12, intro_node_blinding_point, option),
2538 (18, HighZeroBytesDroppedBigSize(*total_msat), required),
2539 (5482373484, keysend_preimage, option)
2547 impl<NS: Deref> ReadableArgs<(Option<PublicKey>, &NS)> for InboundOnionPayload where NS::Target: NodeSigner {
2548 fn read<R: Read>(r: &mut R, args: (Option<PublicKey>, &NS)) -> Result<Self, DecodeError> {
2549 let (update_add_blinding_point, node_signer) = args;
2552 let mut cltv_value = None;
2553 let mut short_id: Option<u64> = None;
2554 let mut payment_data: Option<FinalOnionHopData> = None;
2555 let mut encrypted_tlvs_opt: Option<WithoutLength<Vec<u8>>> = None;
2556 let mut intro_node_blinding_point = None;
2557 let mut payment_metadata: Option<WithoutLength<Vec<u8>>> = None;
2558 let mut total_msat = None;
2559 let mut keysend_preimage: Option<PaymentPreimage> = None;
2560 let mut custom_tlvs = Vec::new();
2562 let tlv_len = BigSize::read(r)?;
2563 let rd = FixedLengthReader::new(r, tlv_len.0);
2564 decode_tlv_stream_with_custom_tlv_decode!(rd, {
2565 (2, amt, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2566 (4, cltv_value, (option, encoding: (u32, HighZeroBytesDroppedBigSize))),
2567 (6, short_id, option),
2568 (8, payment_data, option),
2569 (10, encrypted_tlvs_opt, option),
2570 (12, intro_node_blinding_point, option),
2571 (16, payment_metadata, option),
2572 (18, total_msat, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2573 // See https://github.com/lightning/blips/blob/master/blip-0003.md
2574 (5482373484, keysend_preimage, option)
2575 }, |msg_type: u64, msg_reader: &mut FixedLengthReader<_>| -> Result<bool, DecodeError> {
2576 if msg_type < 1 << 16 { return Ok(false) }
2577 let mut value = Vec::new();
2578 msg_reader.read_to_end(&mut value)?;
2579 custom_tlvs.push((msg_type, value));
2583 if amt.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2584 if intro_node_blinding_point.is_some() && update_add_blinding_point.is_some() {
2585 return Err(DecodeError::InvalidValue)
2588 if let Some(blinding_point) = intro_node_blinding_point.or(update_add_blinding_point) {
2589 if short_id.is_some() || payment_data.is_some() || payment_metadata.is_some() {
2590 return Err(DecodeError::InvalidValue)
2592 let enc_tlvs = encrypted_tlvs_opt.ok_or(DecodeError::InvalidValue)?.0;
2593 let enc_tlvs_ss = node_signer.ecdh(Recipient::Node, &blinding_point, None)
2594 .map_err(|_| DecodeError::InvalidValue)?;
2595 let rho = onion_utils::gen_rho_from_shared_secret(&enc_tlvs_ss.secret_bytes());
2596 let mut s = Cursor::new(&enc_tlvs);
2597 let mut reader = FixedLengthReader::new(&mut s, enc_tlvs.len() as u64);
2598 match ChaChaPolyReadAdapter::read(&mut reader, rho)? {
2599 ChaChaPolyReadAdapter { readable: BlindedPaymentTlvs::Forward(ForwardTlvs {
2600 short_channel_id, payment_relay, payment_constraints, features
2602 if amt.is_some() || cltv_value.is_some() || total_msat.is_some() ||
2603 keysend_preimage.is_some()
2605 return Err(DecodeError::InvalidValue)
2607 Ok(Self::BlindedForward {
2610 payment_constraints,
2612 intro_node_blinding_point,
2615 ChaChaPolyReadAdapter { readable: BlindedPaymentTlvs::Receive(ReceiveTlvs {
2616 payment_secret, payment_constraints
2618 if total_msat.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2619 Ok(Self::BlindedReceive {
2620 sender_intended_htlc_amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2621 total_msat: total_msat.ok_or(DecodeError::InvalidValue)?,
2622 cltv_expiry_height: cltv_value.ok_or(DecodeError::InvalidValue)?,
2624 payment_constraints,
2625 intro_node_blinding_point,
2630 } else if let Some(short_channel_id) = short_id {
2631 if payment_data.is_some() || payment_metadata.is_some() || encrypted_tlvs_opt.is_some() ||
2632 total_msat.is_some()
2633 { return Err(DecodeError::InvalidValue) }
2636 amt_to_forward: amt.ok_or(DecodeError::InvalidValue)?,
2637 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2640 if encrypted_tlvs_opt.is_some() || total_msat.is_some() {
2641 return Err(DecodeError::InvalidValue)
2643 if let Some(data) = &payment_data {
2644 if data.total_msat > MAX_VALUE_MSAT {
2645 return Err(DecodeError::InvalidValue);
2650 payment_metadata: payment_metadata.map(|w| w.0),
2652 sender_intended_htlc_amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2653 cltv_expiry_height: cltv_value.ok_or(DecodeError::InvalidValue)?,
2660 impl Writeable for Ping {
2661 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2662 self.ponglen.write(w)?;
2663 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2668 impl Readable for Ping {
2669 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2671 ponglen: Readable::read(r)?,
2673 let byteslen = Readable::read(r)?;
2674 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2681 impl Writeable for Pong {
2682 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2683 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2688 impl Readable for Pong {
2689 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2692 let byteslen = Readable::read(r)?;
2693 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2700 impl Writeable for UnsignedChannelAnnouncement {
2701 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2702 self.features.write(w)?;
2703 self.chain_hash.write(w)?;
2704 self.short_channel_id.write(w)?;
2705 self.node_id_1.write(w)?;
2706 self.node_id_2.write(w)?;
2707 self.bitcoin_key_1.write(w)?;
2708 self.bitcoin_key_2.write(w)?;
2709 w.write_all(&self.excess_data[..])?;
2714 impl Readable for UnsignedChannelAnnouncement {
2715 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2717 features: Readable::read(r)?,
2718 chain_hash: Readable::read(r)?,
2719 short_channel_id: Readable::read(r)?,
2720 node_id_1: Readable::read(r)?,
2721 node_id_2: Readable::read(r)?,
2722 bitcoin_key_1: Readable::read(r)?,
2723 bitcoin_key_2: Readable::read(r)?,
2724 excess_data: read_to_end(r)?,
2729 impl_writeable!(ChannelAnnouncement, {
2732 bitcoin_signature_1,
2733 bitcoin_signature_2,
2737 impl Writeable for UnsignedChannelUpdate {
2738 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2739 // `message_flags` used to indicate presence of `htlc_maximum_msat`, but was deprecated in the spec.
2740 const MESSAGE_FLAGS: u8 = 1;
2741 self.chain_hash.write(w)?;
2742 self.short_channel_id.write(w)?;
2743 self.timestamp.write(w)?;
2744 let all_flags = self.flags as u16 | ((MESSAGE_FLAGS as u16) << 8);
2745 all_flags.write(w)?;
2746 self.cltv_expiry_delta.write(w)?;
2747 self.htlc_minimum_msat.write(w)?;
2748 self.fee_base_msat.write(w)?;
2749 self.fee_proportional_millionths.write(w)?;
2750 self.htlc_maximum_msat.write(w)?;
2751 w.write_all(&self.excess_data[..])?;
2756 impl Readable for UnsignedChannelUpdate {
2757 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2759 chain_hash: Readable::read(r)?,
2760 short_channel_id: Readable::read(r)?,
2761 timestamp: Readable::read(r)?,
2763 let flags: u16 = Readable::read(r)?;
2764 // Note: we ignore the `message_flags` for now, since it was deprecated by the spec.
2767 cltv_expiry_delta: Readable::read(r)?,
2768 htlc_minimum_msat: Readable::read(r)?,
2769 fee_base_msat: Readable::read(r)?,
2770 fee_proportional_millionths: Readable::read(r)?,
2771 htlc_maximum_msat: Readable::read(r)?,
2772 excess_data: read_to_end(r)?,
2777 impl_writeable!(ChannelUpdate, {
2782 impl Writeable for ErrorMessage {
2783 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2784 self.channel_id.write(w)?;
2785 (self.data.len() as u16).write(w)?;
2786 w.write_all(self.data.as_bytes())?;
2791 impl Readable for ErrorMessage {
2792 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2794 channel_id: Readable::read(r)?,
2796 let sz: usize = <u16 as Readable>::read(r)? as usize;
2797 let mut data = Vec::with_capacity(sz);
2799 r.read_exact(&mut data)?;
2800 match String::from_utf8(data) {
2802 Err(_) => return Err(DecodeError::InvalidValue),
2809 impl Writeable for WarningMessage {
2810 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2811 self.channel_id.write(w)?;
2812 (self.data.len() as u16).write(w)?;
2813 w.write_all(self.data.as_bytes())?;
2818 impl Readable for WarningMessage {
2819 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2821 channel_id: Readable::read(r)?,
2823 let sz: usize = <u16 as Readable>::read(r)? as usize;
2824 let mut data = Vec::with_capacity(sz);
2826 r.read_exact(&mut data)?;
2827 match String::from_utf8(data) {
2829 Err(_) => return Err(DecodeError::InvalidValue),
2836 impl Writeable for UnsignedNodeAnnouncement {
2837 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2838 self.features.write(w)?;
2839 self.timestamp.write(w)?;
2840 self.node_id.write(w)?;
2841 w.write_all(&self.rgb)?;
2842 self.alias.write(w)?;
2844 let mut addr_len = 0;
2845 for addr in self.addresses.iter() {
2846 addr_len += 1 + addr.len();
2848 (addr_len + self.excess_address_data.len() as u16).write(w)?;
2849 for addr in self.addresses.iter() {
2852 w.write_all(&self.excess_address_data[..])?;
2853 w.write_all(&self.excess_data[..])?;
2858 impl Readable for UnsignedNodeAnnouncement {
2859 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2860 let features: NodeFeatures = Readable::read(r)?;
2861 let timestamp: u32 = Readable::read(r)?;
2862 let node_id: NodeId = Readable::read(r)?;
2863 let mut rgb = [0; 3];
2864 r.read_exact(&mut rgb)?;
2865 let alias: NodeAlias = Readable::read(r)?;
2867 let addr_len: u16 = Readable::read(r)?;
2868 let mut addresses: Vec<SocketAddress> = Vec::new();
2869 let mut addr_readpos = 0;
2870 let mut excess = false;
2871 let mut excess_byte = 0;
2873 if addr_len <= addr_readpos { break; }
2874 match Readable::read(r) {
2876 if addr_len < addr_readpos + 1 + addr.len() {
2877 return Err(DecodeError::BadLengthDescriptor);
2879 addr_readpos += (1 + addr.len()) as u16;
2880 addresses.push(addr);
2882 Ok(Err(unknown_descriptor)) => {
2884 excess_byte = unknown_descriptor;
2887 Err(DecodeError::ShortRead) => return Err(DecodeError::BadLengthDescriptor),
2888 Err(e) => return Err(e),
2892 let mut excess_data = vec![];
2893 let excess_address_data = if addr_readpos < addr_len {
2894 let mut excess_address_data = vec![0; (addr_len - addr_readpos) as usize];
2895 r.read_exact(&mut excess_address_data[if excess { 1 } else { 0 }..])?;
2897 excess_address_data[0] = excess_byte;
2902 excess_data.push(excess_byte);
2906 excess_data.extend(read_to_end(r)?.iter());
2907 Ok(UnsignedNodeAnnouncement {
2914 excess_address_data,
2920 impl_writeable!(NodeAnnouncement, {
2925 impl Readable for QueryShortChannelIds {
2926 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2927 let chain_hash: ChainHash = Readable::read(r)?;
2929 let encoding_len: u16 = Readable::read(r)?;
2930 let encoding_type: u8 = Readable::read(r)?;
2932 // Must be encoding_type=0 uncompressed serialization. We do not
2933 // support encoding_type=1 zlib serialization.
2934 if encoding_type != EncodingType::Uncompressed as u8 {
2935 return Err(DecodeError::UnsupportedCompression);
2938 // We expect the encoding_len to always includes the 1-byte
2939 // encoding_type and that short_channel_ids are 8-bytes each
2940 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2941 return Err(DecodeError::InvalidValue);
2944 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2945 // less the 1-byte encoding_type
2946 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2947 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2948 for _ in 0..short_channel_id_count {
2949 short_channel_ids.push(Readable::read(r)?);
2952 Ok(QueryShortChannelIds {
2959 impl Writeable for QueryShortChannelIds {
2960 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2961 // Calculated from 1-byte encoding_type plus 8-bytes per short_channel_id
2962 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2964 self.chain_hash.write(w)?;
2965 encoding_len.write(w)?;
2967 // We only support type=0 uncompressed serialization
2968 (EncodingType::Uncompressed as u8).write(w)?;
2970 for scid in self.short_channel_ids.iter() {
2978 impl_writeable_msg!(ReplyShortChannelIdsEnd, {
2983 impl QueryChannelRange {
2984 /// Calculates the overflow safe ending block height for the query.
2986 /// Overflow returns `0xffffffff`, otherwise returns `first_blocknum + number_of_blocks`.
2987 pub fn end_blocknum(&self) -> u32 {
2988 match self.first_blocknum.checked_add(self.number_of_blocks) {
2989 Some(block) => block,
2990 None => u32::max_value(),
2995 impl_writeable_msg!(QueryChannelRange, {
3001 impl Readable for ReplyChannelRange {
3002 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
3003 let chain_hash: ChainHash = Readable::read(r)?;
3004 let first_blocknum: u32 = Readable::read(r)?;
3005 let number_of_blocks: u32 = Readable::read(r)?;
3006 let sync_complete: bool = Readable::read(r)?;
3008 let encoding_len: u16 = Readable::read(r)?;
3009 let encoding_type: u8 = Readable::read(r)?;
3011 // Must be encoding_type=0 uncompressed serialization. We do not
3012 // support encoding_type=1 zlib serialization.
3013 if encoding_type != EncodingType::Uncompressed as u8 {
3014 return Err(DecodeError::UnsupportedCompression);
3017 // We expect the encoding_len to always includes the 1-byte
3018 // encoding_type and that short_channel_ids are 8-bytes each
3019 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
3020 return Err(DecodeError::InvalidValue);
3023 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
3024 // less the 1-byte encoding_type
3025 let short_channel_id_count: u16 = (encoding_len - 1)/8;
3026 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
3027 for _ in 0..short_channel_id_count {
3028 short_channel_ids.push(Readable::read(r)?);
3031 Ok(ReplyChannelRange {
3041 impl Writeable for ReplyChannelRange {
3042 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
3043 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
3044 self.chain_hash.write(w)?;
3045 self.first_blocknum.write(w)?;
3046 self.number_of_blocks.write(w)?;
3047 self.sync_complete.write(w)?;
3049 encoding_len.write(w)?;
3050 (EncodingType::Uncompressed as u8).write(w)?;
3051 for scid in self.short_channel_ids.iter() {
3059 impl_writeable_msg!(GossipTimestampFilter, {
3067 use std::convert::TryFrom;
3068 use bitcoin::{Transaction, TxIn, ScriptBuf, Sequence, Witness, TxOut};
3069 use hex::DisplayHex;
3070 use crate::ln::{PaymentPreimage, PaymentHash, PaymentSecret};
3071 use crate::ln::ChannelId;
3072 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
3073 use crate::ln::msgs::{self, FinalOnionHopData, OnionErrorPacket, CommonOpenChannelFields, CommonAcceptChannelFields};
3074 use crate::ln::msgs::SocketAddress;
3075 use crate::routing::gossip::{NodeAlias, NodeId};
3076 use crate::util::ser::{Writeable, Readable, ReadableArgs, Hostname, TransactionU16LenLimited};
3077 use crate::util::test_utils;
3079 use bitcoin::hashes::hex::FromHex;
3080 use bitcoin::address::Address;
3081 use bitcoin::network::constants::Network;
3082 use bitcoin::blockdata::constants::ChainHash;
3083 use bitcoin::blockdata::script::Builder;
3084 use bitcoin::blockdata::opcodes;
3085 use bitcoin::hash_types::Txid;
3086 use bitcoin::locktime::absolute::LockTime;
3088 use bitcoin::secp256k1::{PublicKey,SecretKey};
3089 use bitcoin::secp256k1::{Secp256k1, Message};
3091 use crate::io::{self, Cursor};
3092 use crate::prelude::*;
3093 use core::str::FromStr;
3094 use crate::chain::transaction::OutPoint;
3096 #[cfg(feature = "std")]
3097 use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6, ToSocketAddrs};
3098 #[cfg(feature = "std")]
3099 use crate::ln::msgs::SocketAddressParseError;
3102 fn encoding_channel_reestablish() {
3104 let secp_ctx = Secp256k1::new();
3105 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&<Vec<u8>>::from_hex("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
3108 let cr = msgs::ChannelReestablish {
3109 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]),
3110 next_local_commitment_number: 3,
3111 next_remote_commitment_number: 4,
3112 your_last_per_commitment_secret: [9;32],
3113 my_current_per_commitment_point: public_key,
3114 next_funding_txid: None,
3117 let encoded_value = cr.encode();
3121 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
3122 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
3123 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
3124 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
3125 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
3131 fn encoding_channel_reestablish_with_next_funding_txid() {
3133 let secp_ctx = Secp256k1::new();
3134 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&<Vec<u8>>::from_hex("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
3137 let cr = msgs::ChannelReestablish {
3138 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]),
3139 next_local_commitment_number: 3,
3140 next_remote_commitment_number: 4,
3141 your_last_per_commitment_secret: [9;32],
3142 my_current_per_commitment_point: public_key,
3143 next_funding_txid: Some(Txid::from_raw_hash(bitcoin::hashes::Hash::from_slice(&[
3144 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,
3148 let encoded_value = cr.encode();
3152 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
3153 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
3154 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
3155 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
3156 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
3157 0, // Type (next_funding_txid)
3159 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
3164 macro_rules! get_keys_from {
3165 ($slice: expr, $secp_ctx: expr) => {
3167 let privkey = SecretKey::from_slice(&<Vec<u8>>::from_hex($slice).unwrap()[..]).unwrap();
3168 let pubkey = PublicKey::from_secret_key(&$secp_ctx, &privkey);
3174 macro_rules! get_sig_on {
3175 ($privkey: expr, $ctx: expr, $string: expr) => {
3177 let sighash = Message::from_slice(&$string.into_bytes()[..]).unwrap();
3178 $ctx.sign_ecdsa(&sighash, &$privkey)
3184 fn encoding_announcement_signatures() {
3185 let secp_ctx = Secp256k1::new();
3186 let (privkey, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3187 let sig_1 = get_sig_on!(privkey, secp_ctx, String::from("01010101010101010101010101010101"));
3188 let sig_2 = get_sig_on!(privkey, secp_ctx, String::from("02020202020202020202020202020202"));
3189 let announcement_signatures = msgs::AnnouncementSignatures {
3190 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]),
3191 short_channel_id: 2316138423780173,
3192 node_signature: sig_1,
3193 bitcoin_signature: sig_2,
3196 let encoded_value = announcement_signatures.encode();
3197 assert_eq!(encoded_value, <Vec<u8>>::from_hex("040000000000000005000000000000000600000000000000070000000000000000083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073acf9953cef4700860f5967838eba2bae89288ad188ebf8b20bf995c3ea53a26df1876d0a3a0e13172ba286a673140190c02ba9da60a2e43a745188c8a83c7f3ef").unwrap());
3200 fn do_encoding_channel_announcement(unknown_features_bits: bool, excess_data: bool) {
3201 let secp_ctx = Secp256k1::new();
3202 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3203 let (privkey_2, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3204 let (privkey_3, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3205 let (privkey_4, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3206 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3207 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
3208 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
3209 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
3210 let mut features = ChannelFeatures::empty();
3211 if unknown_features_bits {
3212 features = ChannelFeatures::from_le_bytes(vec![0xFF, 0xFF]);
3214 let unsigned_channel_announcement = msgs::UnsignedChannelAnnouncement {
3216 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3217 short_channel_id: 2316138423780173,
3218 node_id_1: NodeId::from_pubkey(&pubkey_1),
3219 node_id_2: NodeId::from_pubkey(&pubkey_2),
3220 bitcoin_key_1: NodeId::from_pubkey(&pubkey_3),
3221 bitcoin_key_2: NodeId::from_pubkey(&pubkey_4),
3222 excess_data: if excess_data { vec![10, 0, 0, 20, 0, 0, 30, 0, 0, 40] } else { Vec::new() },
3224 let channel_announcement = msgs::ChannelAnnouncement {
3225 node_signature_1: sig_1,
3226 node_signature_2: sig_2,
3227 bitcoin_signature_1: sig_3,
3228 bitcoin_signature_2: sig_4,
3229 contents: unsigned_channel_announcement,
3231 let encoded_value = channel_announcement.encode();
3232 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a1735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap();
3233 if unknown_features_bits {
3234 target_value.append(&mut <Vec<u8>>::from_hex("0002ffff").unwrap());
3236 target_value.append(&mut <Vec<u8>>::from_hex("0000").unwrap());
3238 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3239 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
3241 target_value.append(&mut <Vec<u8>>::from_hex("0a00001400001e000028").unwrap());
3243 assert_eq!(encoded_value, target_value);
3247 fn encoding_channel_announcement() {
3248 do_encoding_channel_announcement(true, false);
3249 do_encoding_channel_announcement(false, true);
3250 do_encoding_channel_announcement(false, false);
3251 do_encoding_channel_announcement(true, true);
3254 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) {
3255 let secp_ctx = Secp256k1::new();
3256 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3257 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3258 let features = if unknown_features_bits {
3259 NodeFeatures::from_le_bytes(vec![0xFF, 0xFF])
3261 // Set to some features we may support
3262 NodeFeatures::from_le_bytes(vec![2 | 1 << 5])
3264 let mut addresses = Vec::new();
3266 addresses.push(SocketAddress::TcpIpV4 {
3267 addr: [255, 254, 253, 252],
3272 addresses.push(SocketAddress::TcpIpV6 {
3273 addr: [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240],
3278 addresses.push(msgs::SocketAddress::OnionV2(
3279 [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 38, 7]
3283 addresses.push(msgs::SocketAddress::OnionV3 {
3284 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],
3291 addresses.push(SocketAddress::Hostname {
3292 hostname: Hostname::try_from(String::from("host")).unwrap(),
3296 let mut addr_len = 0;
3297 for addr in &addresses {
3298 addr_len += addr.len() + 1;
3300 let unsigned_node_announcement = msgs::UnsignedNodeAnnouncement {
3302 timestamp: 20190119,
3303 node_id: NodeId::from_pubkey(&pubkey_1),
3305 alias: NodeAlias([16;32]),
3307 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() },
3308 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() },
3310 addr_len += unsigned_node_announcement.excess_address_data.len() as u16;
3311 let node_announcement = msgs::NodeAnnouncement {
3313 contents: unsigned_node_announcement,
3315 let encoded_value = node_announcement.encode();
3316 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3317 if unknown_features_bits {
3318 target_value.append(&mut <Vec<u8>>::from_hex("0002ffff").unwrap());
3320 target_value.append(&mut <Vec<u8>>::from_hex("000122").unwrap());
3322 target_value.append(&mut <Vec<u8>>::from_hex("013413a7031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f2020201010101010101010101010101010101010101010101010101010101010101010").unwrap());
3323 target_value.append(&mut vec![(addr_len >> 8) as u8, addr_len as u8]);
3325 target_value.append(&mut <Vec<u8>>::from_hex("01fffefdfc2607").unwrap());
3328 target_value.append(&mut <Vec<u8>>::from_hex("02fffefdfcfbfaf9f8f7f6f5f4f3f2f1f02607").unwrap());
3331 target_value.append(&mut <Vec<u8>>::from_hex("03fffefdfcfbfaf9f8f7f62607").unwrap());
3334 target_value.append(&mut <Vec<u8>>::from_hex("04fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0efeeedecebeae9e8e7e6e5e4e3e2e1e00020102607").unwrap());
3337 target_value.append(&mut <Vec<u8>>::from_hex("0504686f73742607").unwrap());
3339 if excess_address_data {
3340 target_value.append(&mut <Vec<u8>>::from_hex("216c280b5395a2546e7e4b2663e04f811622f15a4f92e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d269").unwrap());
3343 target_value.append(&mut <Vec<u8>>::from_hex("3b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
3345 assert_eq!(encoded_value, target_value);
3349 fn encoding_node_announcement() {
3350 do_encoding_node_announcement(true, true, true, true, true, true, true, true);
3351 do_encoding_node_announcement(false, false, false, false, false, false, false, false);
3352 do_encoding_node_announcement(false, true, false, false, false, false, false, false);
3353 do_encoding_node_announcement(false, false, true, false, false, false, false, false);
3354 do_encoding_node_announcement(false, false, false, true, false, false, false, false);
3355 do_encoding_node_announcement(false, false, false, false, true, false, false, false);
3356 do_encoding_node_announcement(false, false, false, false, false, true, false, false);
3357 do_encoding_node_announcement(false, false, false, false, false, false, true, false);
3358 do_encoding_node_announcement(false, true, false, true, false, false, true, false);
3359 do_encoding_node_announcement(false, false, true, false, true, false, false, false);
3362 fn do_encoding_channel_update(direction: bool, disable: bool, excess_data: bool) {
3363 let secp_ctx = Secp256k1::new();
3364 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3365 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3366 let unsigned_channel_update = msgs::UnsignedChannelUpdate {
3367 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3368 short_channel_id: 2316138423780173,
3369 timestamp: 20190119,
3370 flags: if direction { 1 } else { 0 } | if disable { 1 << 1 } else { 0 },
3371 cltv_expiry_delta: 144,
3372 htlc_minimum_msat: 1000000,
3373 htlc_maximum_msat: 131355275467161,
3374 fee_base_msat: 10000,
3375 fee_proportional_millionths: 20,
3376 excess_data: if excess_data { vec![0, 0, 0, 0, 59, 154, 202, 0] } else { Vec::new() }
3378 let channel_update = msgs::ChannelUpdate {
3380 contents: unsigned_channel_update
3382 let encoded_value = channel_update.encode();
3383 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3384 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3385 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d013413a7").unwrap());
3386 target_value.append(&mut <Vec<u8>>::from_hex("01").unwrap());
3387 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3389 let flag = target_value.last_mut().unwrap();
3393 let flag = target_value.last_mut().unwrap();
3394 *flag = *flag | 1 << 1;
3396 target_value.append(&mut <Vec<u8>>::from_hex("009000000000000f42400000271000000014").unwrap());
3397 target_value.append(&mut <Vec<u8>>::from_hex("0000777788889999").unwrap());
3399 target_value.append(&mut <Vec<u8>>::from_hex("000000003b9aca00").unwrap());
3401 assert_eq!(encoded_value, target_value);
3405 fn encoding_channel_update() {
3406 do_encoding_channel_update(false, false, false);
3407 do_encoding_channel_update(false, false, true);
3408 do_encoding_channel_update(true, false, false);
3409 do_encoding_channel_update(true, false, true);
3410 do_encoding_channel_update(false, true, false);
3411 do_encoding_channel_update(false, true, true);
3412 do_encoding_channel_update(true, true, false);
3413 do_encoding_channel_update(true, true, true);
3416 fn do_encoding_open_channel(random_bit: bool, shutdown: bool, incl_chan_type: bool) {
3417 let secp_ctx = Secp256k1::new();
3418 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3419 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3420 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3421 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3422 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3423 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3424 let open_channel = msgs::OpenChannel {
3425 common_fields: CommonOpenChannelFields {
3426 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3427 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3428 funding_satoshis: 1311768467284833366,
3429 dust_limit_satoshis: 3608586615801332854,
3430 max_htlc_value_in_flight_msat: 8517154655701053848,
3431 htlc_minimum_msat: 2316138423780173,
3432 commitment_feerate_sat_per_1000_weight: 821716,
3433 to_self_delay: 49340,
3434 max_accepted_htlcs: 49340,
3435 funding_pubkey: pubkey_1,
3436 revocation_basepoint: pubkey_2,
3437 payment_basepoint: pubkey_3,
3438 delayed_payment_basepoint: pubkey_4,
3439 htlc_basepoint: pubkey_5,
3440 first_per_commitment_point: pubkey_6,
3441 channel_flags: if random_bit { 1 << 5 } else { 0 },
3442 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3443 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3445 push_msat: 2536655962884945560,
3446 channel_reserve_satoshis: 8665828695742877976,
3448 let encoded_value = open_channel.encode();
3449 let mut target_value = Vec::new();
3450 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3451 target_value.append(&mut <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202021234567890123456233403289122369832144668701144767633030896203198784335490624111800083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3453 target_value.append(&mut <Vec<u8>>::from_hex("20").unwrap());
3455 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3458 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3461 target_value.append(&mut <Vec<u8>>::from_hex("0100").unwrap());
3463 assert_eq!(encoded_value, target_value);
3467 fn encoding_open_channel() {
3468 do_encoding_open_channel(false, false, false);
3469 do_encoding_open_channel(false, false, true);
3470 do_encoding_open_channel(false, true, false);
3471 do_encoding_open_channel(false, true, true);
3472 do_encoding_open_channel(true, false, false);
3473 do_encoding_open_channel(true, false, true);
3474 do_encoding_open_channel(true, true, false);
3475 do_encoding_open_channel(true, true, true);
3478 fn do_encoding_open_channelv2(random_bit: bool, shutdown: bool, incl_chan_type: bool, require_confirmed_inputs: bool) {
3479 let secp_ctx = Secp256k1::new();
3480 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3481 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3482 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3483 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3484 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3485 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3486 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3487 let open_channelv2 = msgs::OpenChannelV2 {
3488 common_fields: CommonOpenChannelFields {
3489 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3490 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3491 commitment_feerate_sat_per_1000_weight: 821716,
3492 funding_satoshis: 1311768467284833366,
3493 dust_limit_satoshis: 3608586615801332854,
3494 max_htlc_value_in_flight_msat: 8517154655701053848,
3495 htlc_minimum_msat: 2316138423780173,
3496 to_self_delay: 49340,
3497 max_accepted_htlcs: 49340,
3498 funding_pubkey: pubkey_1,
3499 revocation_basepoint: pubkey_2,
3500 payment_basepoint: pubkey_3,
3501 delayed_payment_basepoint: pubkey_4,
3502 htlc_basepoint: pubkey_5,
3503 first_per_commitment_point: pubkey_6,
3504 channel_flags: if random_bit { 1 << 5 } else { 0 },
3505 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3506 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3508 funding_feerate_sat_per_1000_weight: 821716,
3509 locktime: 305419896,
3510 second_per_commitment_point: pubkey_7,
3511 require_confirmed_inputs: if require_confirmed_inputs { Some(()) } else { None },
3513 let encoded_value = open_channelv2.encode();
3514 let mut target_value = Vec::new();
3515 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3516 target_value.append(&mut <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap());
3517 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap());
3518 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap());
3519 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap());
3520 target_value.append(&mut <Vec<u8>>::from_hex("3214466870114476").unwrap());
3521 target_value.append(&mut <Vec<u8>>::from_hex("7633030896203198").unwrap());
3522 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d").unwrap());
3523 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap());
3524 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap());
3525 target_value.append(&mut <Vec<u8>>::from_hex("12345678").unwrap());
3526 target_value.append(&mut <Vec<u8>>::from_hex("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap());
3527 target_value.append(&mut <Vec<u8>>::from_hex("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap());
3528 target_value.append(&mut <Vec<u8>>::from_hex("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap());
3529 target_value.append(&mut <Vec<u8>>::from_hex("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
3530 target_value.append(&mut <Vec<u8>>::from_hex("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap());
3531 target_value.append(&mut <Vec<u8>>::from_hex("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3532 target_value.append(&mut <Vec<u8>>::from_hex("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap());
3535 target_value.append(&mut <Vec<u8>>::from_hex("20").unwrap());
3537 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3540 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3543 target_value.append(&mut <Vec<u8>>::from_hex("0100").unwrap());
3545 if require_confirmed_inputs {
3546 target_value.append(&mut <Vec<u8>>::from_hex("0200").unwrap());
3548 assert_eq!(encoded_value, target_value);
3552 fn encoding_open_channelv2() {
3553 do_encoding_open_channelv2(false, false, false, false);
3554 do_encoding_open_channelv2(false, false, false, true);
3555 do_encoding_open_channelv2(false, false, true, false);
3556 do_encoding_open_channelv2(false, false, true, true);
3557 do_encoding_open_channelv2(false, true, false, false);
3558 do_encoding_open_channelv2(false, true, false, true);
3559 do_encoding_open_channelv2(false, true, true, false);
3560 do_encoding_open_channelv2(false, true, true, true);
3561 do_encoding_open_channelv2(true, false, false, false);
3562 do_encoding_open_channelv2(true, false, false, true);
3563 do_encoding_open_channelv2(true, false, true, false);
3564 do_encoding_open_channelv2(true, false, true, true);
3565 do_encoding_open_channelv2(true, true, false, false);
3566 do_encoding_open_channelv2(true, true, false, true);
3567 do_encoding_open_channelv2(true, true, true, false);
3568 do_encoding_open_channelv2(true, true, true, true);
3571 fn do_encoding_accept_channel(shutdown: bool) {
3572 let secp_ctx = Secp256k1::new();
3573 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3574 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3575 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3576 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3577 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3578 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3579 let accept_channel = msgs::AcceptChannel {
3580 common_fields: CommonAcceptChannelFields {
3581 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3582 dust_limit_satoshis: 1311768467284833366,
3583 max_htlc_value_in_flight_msat: 2536655962884945560,
3584 htlc_minimum_msat: 2316138423780173,
3585 minimum_depth: 821716,
3586 to_self_delay: 49340,
3587 max_accepted_htlcs: 49340,
3588 funding_pubkey: pubkey_1,
3589 revocation_basepoint: pubkey_2,
3590 payment_basepoint: pubkey_3,
3591 delayed_payment_basepoint: pubkey_4,
3592 htlc_basepoint: pubkey_5,
3593 first_per_commitment_point: pubkey_6,
3594 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3597 channel_reserve_satoshis: 3608586615801332854,
3599 next_local_nonce: None,
3601 let encoded_value = accept_channel.encode();
3602 let mut target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020212345678901234562334032891223698321446687011447600083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap();
3604 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3606 assert_eq!(encoded_value, target_value);
3610 fn encoding_accept_channel() {
3611 do_encoding_accept_channel(false);
3612 do_encoding_accept_channel(true);
3615 fn do_encoding_accept_channelv2(shutdown: bool) {
3616 let secp_ctx = Secp256k1::new();
3617 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3618 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3619 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3620 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3621 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3622 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3623 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3624 let accept_channelv2 = msgs::AcceptChannelV2 {
3625 common_fields: CommonAcceptChannelFields {
3626 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3627 dust_limit_satoshis: 1311768467284833366,
3628 max_htlc_value_in_flight_msat: 2536655962884945560,
3629 htlc_minimum_msat: 2316138423780173,
3630 minimum_depth: 821716,
3631 to_self_delay: 49340,
3632 max_accepted_htlcs: 49340,
3633 funding_pubkey: pubkey_1,
3634 revocation_basepoint: pubkey_2,
3635 payment_basepoint: pubkey_3,
3636 delayed_payment_basepoint: pubkey_4,
3637 htlc_basepoint: pubkey_5,
3638 first_per_commitment_point: pubkey_6,
3639 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3642 funding_satoshis: 1311768467284833366,
3643 second_per_commitment_point: pubkey_7,
3644 require_confirmed_inputs: None,
3646 let encoded_value = accept_channelv2.encode();
3647 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // temporary_channel_id
3648 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap()); // funding_satoshis
3649 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap()); // dust_limit_satoshis
3650 target_value.append(&mut <Vec<u8>>::from_hex("2334032891223698").unwrap()); // max_htlc_value_in_flight_msat
3651 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d").unwrap()); // htlc_minimum_msat
3652 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap()); // minimum_depth
3653 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap()); // to_self_delay
3654 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap()); // max_accepted_htlcs
3655 target_value.append(&mut <Vec<u8>>::from_hex("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap()); // funding_pubkey
3656 target_value.append(&mut <Vec<u8>>::from_hex("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap()); // revocation_basepoint
3657 target_value.append(&mut <Vec<u8>>::from_hex("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap()); // payment_basepoint
3658 target_value.append(&mut <Vec<u8>>::from_hex("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap()); // delayed_payment_basepoint
3659 target_value.append(&mut <Vec<u8>>::from_hex("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap()); // htlc_basepoint
3660 target_value.append(&mut <Vec<u8>>::from_hex("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap()); // first_per_commitment_point
3661 target_value.append(&mut <Vec<u8>>::from_hex("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap()); // second_per_commitment_point
3663 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3665 assert_eq!(encoded_value, target_value);
3669 fn encoding_accept_channelv2() {
3670 do_encoding_accept_channelv2(false);
3671 do_encoding_accept_channelv2(true);
3675 fn encoding_funding_created() {
3676 let secp_ctx = Secp256k1::new();
3677 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3678 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3679 let funding_created = msgs::FundingCreated {
3680 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3681 funding_txid: Txid::from_str("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3682 funding_output_index: 255,
3685 partial_signature_with_nonce: None,
3687 next_local_nonce: None,
3689 let encoded_value = funding_created.encode();
3690 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202026e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c200ffd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3691 assert_eq!(encoded_value, target_value);
3695 fn encoding_funding_signed() {
3696 let secp_ctx = Secp256k1::new();
3697 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3698 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3699 let funding_signed = msgs::FundingSigned {
3700 channel_id: ChannelId::from_bytes([2; 32]),
3703 partial_signature_with_nonce: None,
3705 let encoded_value = funding_signed.encode();
3706 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3707 assert_eq!(encoded_value, target_value);
3711 fn encoding_channel_ready() {
3712 let secp_ctx = Secp256k1::new();
3713 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3714 let channel_ready = msgs::ChannelReady {
3715 channel_id: ChannelId::from_bytes([2; 32]),
3716 next_per_commitment_point: pubkey_1,
3717 short_channel_id_alias: None,
3719 let encoded_value = channel_ready.encode();
3720 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3721 assert_eq!(encoded_value, target_value);
3725 fn encoding_splice() {
3726 let secp_ctx = Secp256k1::new();
3727 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3728 let splice = msgs::Splice {
3729 chain_hash: ChainHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
3730 channel_id: ChannelId::from_bytes([2; 32]),
3731 relative_satoshis: 123456,
3732 funding_feerate_perkw: 2000,
3734 funding_pubkey: pubkey_1,
3736 let encoded_value = splice.encode();
3737 assert_eq!(encoded_value.as_hex().to_string(), "02020202020202020202020202020202020202020202020202020202020202026fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000000000000001e240000007d000000000031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f");
3741 fn encoding_stfu() {
3742 let stfu = msgs::Stfu {
3743 channel_id: ChannelId::from_bytes([2; 32]),
3746 let encoded_value = stfu.encode();
3747 assert_eq!(encoded_value.as_hex().to_string(), "020202020202020202020202020202020202020202020202020202020202020201");
3751 fn encoding_splice_ack() {
3752 let secp_ctx = Secp256k1::new();
3753 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3754 let splice = msgs::SpliceAck {
3755 chain_hash: ChainHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
3756 channel_id: ChannelId::from_bytes([2; 32]),
3757 relative_satoshis: 123456,
3758 funding_pubkey: pubkey_1,
3760 let encoded_value = splice.encode();
3761 assert_eq!(encoded_value.as_hex().to_string(), "02020202020202020202020202020202020202020202020202020202020202026fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000000000000001e240031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f");
3765 fn encoding_splice_locked() {
3766 let splice = msgs::SpliceLocked {
3767 channel_id: ChannelId::from_bytes([2; 32]),
3769 let encoded_value = splice.encode();
3770 assert_eq!(encoded_value.as_hex().to_string(), "0202020202020202020202020202020202020202020202020202020202020202");
3774 fn encoding_tx_add_input() {
3775 let tx_add_input = msgs::TxAddInput {
3776 channel_id: ChannelId::from_bytes([2; 32]),
3777 serial_id: 4886718345,
3778 prevtx: TransactionU16LenLimited::new(Transaction {
3780 lock_time: LockTime::ZERO,
3782 previous_output: OutPoint { txid: Txid::from_str("305bab643ee297b8b6b76b320792c8223d55082122cb606bf89382146ced9c77").unwrap(), index: 2 }.into_bitcoin_outpoint(),
3783 script_sig: ScriptBuf::new(),
3784 sequence: Sequence(0xfffffffd),
3785 witness: Witness::from_slice(&vec![
3786 <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3787 <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3792 script_pubkey: Address::from_str("bc1qzlffunw52jav8vwdu5x3jfk6sr8u22rmq3xzw2").unwrap().payload.script_pubkey(),
3796 script_pubkey: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().payload.script_pubkey(),
3800 prevtx_out: 305419896,
3801 sequence: 305419896,
3803 let encoded_value = tx_add_input.encode();
3804 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000000012345678900de02000000000101779ced6c148293f86b60cb222108553d22c89207326bb7b6b897e23e64ab5b300200000000fdffffff0236dbc1000000000016001417d29e4dd454bac3b1cde50d1926da80cfc5287b9cbd03000000000016001436ec78d514df462da95e6a00c24daa8915362d420247304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701210301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944000000001234567812345678").unwrap();
3805 assert_eq!(encoded_value, target_value);
3809 fn encoding_tx_add_output() {
3810 let tx_add_output = msgs::TxAddOutput {
3811 channel_id: ChannelId::from_bytes([2; 32]),
3812 serial_id: 4886718345,
3814 script: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().payload.script_pubkey(),
3816 let encoded_value = tx_add_output.encode();
3817 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000000012345678900000001234567890016001436ec78d514df462da95e6a00c24daa8915362d42").unwrap();
3818 assert_eq!(encoded_value, target_value);
3822 fn encoding_tx_remove_input() {
3823 let tx_remove_input = msgs::TxRemoveInput {
3824 channel_id: ChannelId::from_bytes([2; 32]),
3825 serial_id: 4886718345,
3827 let encoded_value = tx_remove_input.encode();
3828 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3829 assert_eq!(encoded_value, target_value);
3833 fn encoding_tx_remove_output() {
3834 let tx_remove_output = msgs::TxRemoveOutput {
3835 channel_id: ChannelId::from_bytes([2; 32]),
3836 serial_id: 4886718345,
3838 let encoded_value = tx_remove_output.encode();
3839 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3840 assert_eq!(encoded_value, target_value);
3844 fn encoding_tx_complete() {
3845 let tx_complete = msgs::TxComplete {
3846 channel_id: ChannelId::from_bytes([2; 32]),
3848 let encoded_value = tx_complete.encode();
3849 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3850 assert_eq!(encoded_value, target_value);
3854 fn encoding_tx_signatures() {
3855 let tx_signatures = msgs::TxSignatures {
3856 channel_id: ChannelId::from_bytes([2; 32]),
3857 tx_hash: Txid::from_str("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3859 Witness::from_slice(&vec![
3860 <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3861 <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3862 Witness::from_slice(&vec![
3863 <Vec<u8>>::from_hex("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap(),
3864 <Vec<u8>>::from_hex("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap()]),
3867 let encoded_value = tx_signatures.encode();
3868 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3869 target_value.append(&mut <Vec<u8>>::from_hex("6e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c2").unwrap()); // tx_hash (sha256) (big endian byte order)
3870 target_value.append(&mut <Vec<u8>>::from_hex("0002").unwrap()); // num_witnesses (u16)
3872 target_value.append(&mut <Vec<u8>>::from_hex("006b").unwrap()); // len of witness_data
3873 target_value.append(&mut <Vec<u8>>::from_hex("02").unwrap()); // num_witness_elements (VarInt)
3874 target_value.append(&mut <Vec<u8>>::from_hex("47").unwrap()); // len of witness element data (VarInt)
3875 target_value.append(&mut <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap());
3876 target_value.append(&mut <Vec<u8>>::from_hex("21").unwrap()); // len of witness element data (VarInt)
3877 target_value.append(&mut <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap());
3879 target_value.append(&mut <Vec<u8>>::from_hex("006c").unwrap()); // len of witness_data
3880 target_value.append(&mut <Vec<u8>>::from_hex("02").unwrap()); // num_witness_elements (VarInt)
3881 target_value.append(&mut <Vec<u8>>::from_hex("48").unwrap()); // len of witness element data (VarInt)
3882 target_value.append(&mut <Vec<u8>>::from_hex("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap());
3883 target_value.append(&mut <Vec<u8>>::from_hex("21").unwrap()); // len of witness element data (VarInt)
3884 target_value.append(&mut <Vec<u8>>::from_hex("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap());
3885 assert_eq!(encoded_value, target_value);
3888 fn do_encoding_tx_init_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3889 let tx_init_rbf = msgs::TxInitRbf {
3890 channel_id: ChannelId::from_bytes([2; 32]),
3891 locktime: 305419896,
3892 feerate_sat_per_1000_weight: 20190119,
3893 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3895 let encoded_value = tx_init_rbf.encode();
3896 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3897 target_value.append(&mut <Vec<u8>>::from_hex("12345678").unwrap()); // locktime
3898 target_value.append(&mut <Vec<u8>>::from_hex("013413a7").unwrap()); // feerate_sat_per_1000_weight
3899 if let Some((_, target)) = funding_value_with_hex_target {
3900 target_value.push(0x00); // Type
3901 target_value.push(target.len() as u8 / 2); // Length
3902 target_value.append(&mut <Vec<u8>>::from_hex(target).unwrap()); // Value (i64)
3904 assert_eq!(encoded_value, target_value);
3908 fn encoding_tx_init_rbf() {
3909 do_encoding_tx_init_rbf(Some((1311768467284833366, "1234567890123456")));
3910 do_encoding_tx_init_rbf(Some((13117684672, "000000030DDFFBC0")));
3911 do_encoding_tx_init_rbf(None);
3914 fn do_encoding_tx_ack_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3915 let tx_ack_rbf = msgs::TxAckRbf {
3916 channel_id: ChannelId::from_bytes([2; 32]),
3917 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3919 let encoded_value = tx_ack_rbf.encode();
3920 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3921 if let Some((_, target)) = funding_value_with_hex_target {
3922 target_value.push(0x00); // Type
3923 target_value.push(target.len() as u8 / 2); // Length
3924 target_value.append(&mut <Vec<u8>>::from_hex(target).unwrap()); // Value (i64)
3926 assert_eq!(encoded_value, target_value);
3930 fn encoding_tx_ack_rbf() {
3931 do_encoding_tx_ack_rbf(Some((1311768467284833366, "1234567890123456")));
3932 do_encoding_tx_ack_rbf(Some((13117684672, "000000030DDFFBC0")));
3933 do_encoding_tx_ack_rbf(None);
3937 fn encoding_tx_abort() {
3938 let tx_abort = msgs::TxAbort {
3939 channel_id: ChannelId::from_bytes([2; 32]),
3940 data: <Vec<u8>>::from_hex("54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap(),
3942 let encoded_value = tx_abort.encode();
3943 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202002C54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap();
3944 assert_eq!(encoded_value, target_value);
3947 fn do_encoding_shutdown(script_type: u8) {
3948 let secp_ctx = Secp256k1::new();
3949 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3950 let script = Builder::new().push_opcode(opcodes::OP_TRUE).into_script();
3951 let shutdown = msgs::Shutdown {
3952 channel_id: ChannelId::from_bytes([2; 32]),
3954 if script_type == 1 { Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey() }
3955 else if script_type == 2 { Address::p2sh(&script, Network::Testnet).unwrap().script_pubkey() }
3956 else if script_type == 3 { Address::p2wpkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).unwrap().script_pubkey() }
3957 else { Address::p2wsh(&script, Network::Testnet).script_pubkey() },
3959 let encoded_value = shutdown.encode();
3960 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3961 if script_type == 1 {
3962 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3963 } else if script_type == 2 {
3964 target_value.append(&mut <Vec<u8>>::from_hex("0017a914da1745e9b549bd0bfa1a569971c77eba30cd5a4b87").unwrap());
3965 } else if script_type == 3 {
3966 target_value.append(&mut <Vec<u8>>::from_hex("0016001479b000887626b294a914501a4cd226b58b235983").unwrap());
3967 } else if script_type == 4 {
3968 target_value.append(&mut <Vec<u8>>::from_hex("002200204ae81572f06e1b88fd5ced7a1a000945432e83e1551e6f721ee9c00b8cc33260").unwrap());
3970 assert_eq!(encoded_value, target_value);
3974 fn encoding_shutdown() {
3975 do_encoding_shutdown(1);
3976 do_encoding_shutdown(2);
3977 do_encoding_shutdown(3);
3978 do_encoding_shutdown(4);
3982 fn encoding_closing_signed() {
3983 let secp_ctx = Secp256k1::new();
3984 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3985 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3986 let closing_signed = msgs::ClosingSigned {
3987 channel_id: ChannelId::from_bytes([2; 32]),
3988 fee_satoshis: 2316138423780173,
3992 let encoded_value = closing_signed.encode();
3993 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3994 assert_eq!(encoded_value, target_value);
3995 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value)).unwrap(), closing_signed);
3997 let closing_signed_with_range = msgs::ClosingSigned {
3998 channel_id: ChannelId::from_bytes([2; 32]),
3999 fee_satoshis: 2316138423780173,
4001 fee_range: Some(msgs::ClosingSignedFeeRange {
4002 min_fee_satoshis: 0xdeadbeef,
4003 max_fee_satoshis: 0x1badcafe01234567,
4006 let encoded_value_with_range = closing_signed_with_range.encode();
4007 let target_value_with_range = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a011000000000deadbeef1badcafe01234567").unwrap();
4008 assert_eq!(encoded_value_with_range, target_value_with_range);
4009 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value_with_range)).unwrap(),
4010 closing_signed_with_range);
4014 fn encoding_update_add_htlc() {
4015 let secp_ctx = Secp256k1::new();
4016 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4017 let onion_routing_packet = msgs::OnionPacket {
4019 public_key: Ok(pubkey_1),
4020 hop_data: [1; 20*65],
4023 let update_add_htlc = msgs::UpdateAddHTLC {
4024 channel_id: ChannelId::from_bytes([2; 32]),
4025 htlc_id: 2316138423780173,
4026 amount_msat: 3608586615801332854,
4027 payment_hash: PaymentHash([1; 32]),
4028 cltv_expiry: 821716,
4029 onion_routing_packet,
4030 skimmed_fee_msat: None,
4031 blinding_point: None,
4033 let encoded_value = update_add_htlc.encode();
4034 let target_value = <Vec<u8>>::from_hex("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").unwrap();
4035 assert_eq!(encoded_value, target_value);
4039 fn encoding_update_fulfill_htlc() {
4040 let update_fulfill_htlc = msgs::UpdateFulfillHTLC {
4041 channel_id: ChannelId::from_bytes([2; 32]),
4042 htlc_id: 2316138423780173,
4043 payment_preimage: PaymentPreimage([1; 32]),
4045 let encoded_value = update_fulfill_htlc.encode();
4046 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d0101010101010101010101010101010101010101010101010101010101010101").unwrap();
4047 assert_eq!(encoded_value, target_value);
4051 fn encoding_update_fail_htlc() {
4052 let reason = OnionErrorPacket {
4053 data: [1; 32].to_vec(),
4055 let update_fail_htlc = msgs::UpdateFailHTLC {
4056 channel_id: ChannelId::from_bytes([2; 32]),
4057 htlc_id: 2316138423780173,
4060 let encoded_value = update_fail_htlc.encode();
4061 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d00200101010101010101010101010101010101010101010101010101010101010101").unwrap();
4062 assert_eq!(encoded_value, target_value);
4066 fn encoding_update_fail_malformed_htlc() {
4067 let update_fail_malformed_htlc = msgs::UpdateFailMalformedHTLC {
4068 channel_id: ChannelId::from_bytes([2; 32]),
4069 htlc_id: 2316138423780173,
4070 sha256_of_onion: [1; 32],
4073 let encoded_value = update_fail_malformed_htlc.encode();
4074 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d010101010101010101010101010101010101010101010101010101010101010100ff").unwrap();
4075 assert_eq!(encoded_value, target_value);
4078 fn do_encoding_commitment_signed(htlcs: bool) {
4079 let secp_ctx = Secp256k1::new();
4080 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4081 let (privkey_2, _) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
4082 let (privkey_3, _) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
4083 let (privkey_4, _) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
4084 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
4085 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
4086 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
4087 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
4088 let commitment_signed = msgs::CommitmentSigned {
4089 channel_id: ChannelId::from_bytes([2; 32]),
4091 htlc_signatures: if htlcs { vec![sig_2, sig_3, sig_4] } else { Vec::new() },
4093 partial_signature_with_nonce: None,
4095 let encoded_value = commitment_signed.encode();
4096 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
4098 target_value.append(&mut <Vec<u8>>::from_hex("00031735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
4100 target_value.append(&mut <Vec<u8>>::from_hex("0000").unwrap());
4102 assert_eq!(encoded_value, target_value);
4106 fn encoding_commitment_signed() {
4107 do_encoding_commitment_signed(true);
4108 do_encoding_commitment_signed(false);
4112 fn encoding_revoke_and_ack() {
4113 let secp_ctx = Secp256k1::new();
4114 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4115 let raa = msgs::RevokeAndACK {
4116 channel_id: ChannelId::from_bytes([2; 32]),
4117 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],
4118 next_per_commitment_point: pubkey_1,
4120 next_local_nonce: None,
4122 let encoded_value = raa.encode();
4123 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020101010101010101010101010101010101010101010101010101010101010101031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
4124 assert_eq!(encoded_value, target_value);
4128 fn encoding_update_fee() {
4129 let update_fee = msgs::UpdateFee {
4130 channel_id: ChannelId::from_bytes([2; 32]),
4131 feerate_per_kw: 20190119,
4133 let encoded_value = update_fee.encode();
4134 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202013413a7").unwrap();
4135 assert_eq!(encoded_value, target_value);
4139 fn encoding_init() {
4140 let mainnet_hash = ChainHash::using_genesis_block(Network::Bitcoin);
4141 assert_eq!(msgs::Init {
4142 features: InitFeatures::from_le_bytes(vec![0xFF, 0xFF, 0xFF]),
4143 networks: Some(vec![mainnet_hash]),
4144 remote_network_address: None,
4145 }.encode(), <Vec<u8>>::from_hex("00023fff0003ffffff01206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
4146 assert_eq!(msgs::Init {
4147 features: InitFeatures::from_le_bytes(vec![0xFF]),
4149 remote_network_address: None,
4150 }.encode(), <Vec<u8>>::from_hex("0001ff0001ff").unwrap());
4151 assert_eq!(msgs::Init {
4152 features: InitFeatures::from_le_bytes(vec![]),
4153 networks: Some(vec![mainnet_hash]),
4154 remote_network_address: None,
4155 }.encode(), <Vec<u8>>::from_hex("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
4156 assert_eq!(msgs::Init {
4157 features: InitFeatures::from_le_bytes(vec![]),
4158 networks: Some(vec![ChainHash::from(&[1; 32]), ChainHash::from(&[2; 32])]),
4159 remote_network_address: None,
4160 }.encode(), <Vec<u8>>::from_hex("00000000014001010101010101010101010101010101010101010101010101010101010101010202020202020202020202020202020202020202020202020202020202020202").unwrap());
4161 let init_msg = msgs::Init { features: InitFeatures::from_le_bytes(vec![]),
4162 networks: Some(vec![mainnet_hash]),
4163 remote_network_address: Some(SocketAddress::TcpIpV4 {
4164 addr: [127, 0, 0, 1],
4168 let encoded_value = init_msg.encode();
4169 let target_value = <Vec<u8>>::from_hex("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d61900000000000307017f00000103e8").unwrap();
4170 assert_eq!(encoded_value, target_value);
4171 assert_eq!(msgs::Init::read(&mut Cursor::new(&target_value)).unwrap(), init_msg);
4175 fn encoding_error() {
4176 let error = msgs::ErrorMessage {
4177 channel_id: ChannelId::from_bytes([2; 32]),
4178 data: String::from("rust-lightning"),
4180 let encoded_value = error.encode();
4181 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
4182 assert_eq!(encoded_value, target_value);
4186 fn encoding_warning() {
4187 let error = msgs::WarningMessage {
4188 channel_id: ChannelId::from_bytes([2; 32]),
4189 data: String::from("rust-lightning"),
4191 let encoded_value = error.encode();
4192 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
4193 assert_eq!(encoded_value, target_value);
4197 fn encoding_ping() {
4198 let ping = msgs::Ping {
4202 let encoded_value = ping.encode();
4203 let target_value = <Vec<u8>>::from_hex("0040004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
4204 assert_eq!(encoded_value, target_value);
4208 fn encoding_pong() {
4209 let pong = msgs::Pong {
4212 let encoded_value = pong.encode();
4213 let target_value = <Vec<u8>>::from_hex("004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
4214 assert_eq!(encoded_value, target_value);
4218 fn encoding_nonfinal_onion_hop_data() {
4219 let outbound_msg = msgs::OutboundOnionPayload::Forward {
4220 short_channel_id: 0xdeadbeef1bad1dea,
4221 amt_to_forward: 0x0badf00d01020304,
4222 outgoing_cltv_value: 0xffffffff,
4224 let encoded_value = outbound_msg.encode();
4225 let target_value = <Vec<u8>>::from_hex("1a02080badf00d010203040404ffffffff0608deadbeef1bad1dea").unwrap();
4226 assert_eq!(encoded_value, target_value);
4228 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4229 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4230 if let msgs::InboundOnionPayload::Forward {
4231 short_channel_id, amt_to_forward, outgoing_cltv_value
4233 assert_eq!(short_channel_id, 0xdeadbeef1bad1dea);
4234 assert_eq!(amt_to_forward, 0x0badf00d01020304);
4235 assert_eq!(outgoing_cltv_value, 0xffffffff);
4236 } else { panic!(); }
4240 fn encoding_final_onion_hop_data() {
4241 let outbound_msg = msgs::OutboundOnionPayload::Receive {
4243 payment_metadata: None,
4244 keysend_preimage: None,
4245 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4246 cltv_expiry_height: 0xffffffff,
4247 custom_tlvs: vec![],
4249 let encoded_value = outbound_msg.encode();
4250 let target_value = <Vec<u8>>::from_hex("1002080badf00d010203040404ffffffff").unwrap();
4251 assert_eq!(encoded_value, target_value);
4253 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4254 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4255 if let msgs::InboundOnionPayload::Receive {
4256 payment_data: None, sender_intended_htlc_amt_msat, cltv_expiry_height, ..
4258 assert_eq!(sender_intended_htlc_amt_msat, 0x0badf00d01020304);
4259 assert_eq!(cltv_expiry_height, 0xffffffff);
4260 } else { panic!(); }
4264 fn encoding_final_onion_hop_data_with_secret() {
4265 let expected_payment_secret = PaymentSecret([0x42u8; 32]);
4266 let outbound_msg = msgs::OutboundOnionPayload::Receive {
4267 payment_data: Some(FinalOnionHopData {
4268 payment_secret: expected_payment_secret,
4269 total_msat: 0x1badca1f
4271 payment_metadata: None,
4272 keysend_preimage: None,
4273 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4274 cltv_expiry_height: 0xffffffff,
4275 custom_tlvs: vec![],
4277 let encoded_value = outbound_msg.encode();
4278 let target_value = <Vec<u8>>::from_hex("3602080badf00d010203040404ffffffff082442424242424242424242424242424242424242424242424242424242424242421badca1f").unwrap();
4279 assert_eq!(encoded_value, target_value);
4281 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4282 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4283 if let msgs::InboundOnionPayload::Receive {
4284 payment_data: Some(FinalOnionHopData {
4286 total_msat: 0x1badca1f
4288 sender_intended_htlc_amt_msat, cltv_expiry_height,
4289 payment_metadata: None,
4290 keysend_preimage: None,
4293 assert_eq!(payment_secret, expected_payment_secret);
4294 assert_eq!(sender_intended_htlc_amt_msat, 0x0badf00d01020304);
4295 assert_eq!(cltv_expiry_height, 0xffffffff);
4296 assert_eq!(custom_tlvs, vec![]);
4297 } else { panic!(); }
4301 fn encoding_final_onion_hop_data_with_bad_custom_tlvs() {
4302 // If custom TLVs have type number within the range reserved for protocol, treat them as if
4304 let bad_type_range_tlvs = vec![
4305 ((1 << 16) - 4, vec![42]),
4306 ((1 << 16) - 2, vec![42; 32]),
4308 let mut msg = msgs::OutboundOnionPayload::Receive {
4310 payment_metadata: None,
4311 keysend_preimage: None,
4312 custom_tlvs: bad_type_range_tlvs,
4313 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4314 cltv_expiry_height: 0xffffffff,
4316 let encoded_value = msg.encode();
4317 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4318 assert!(msgs::InboundOnionPayload::read(&mut Cursor::new(&encoded_value[..]), (None, &&node_signer)).is_err());
4319 let good_type_range_tlvs = vec![
4320 ((1 << 16) - 3, vec![42]),
4321 ((1 << 16) - 1, vec![42; 32]),
4323 if let msgs::OutboundOnionPayload::Receive { ref mut custom_tlvs, .. } = msg {
4324 *custom_tlvs = good_type_range_tlvs.clone();
4326 let encoded_value = msg.encode();
4327 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&encoded_value[..]), (None, &&node_signer)).unwrap();
4329 msgs::InboundOnionPayload::Receive { custom_tlvs, .. } => assert!(custom_tlvs.is_empty()),
4335 fn encoding_final_onion_hop_data_with_custom_tlvs() {
4336 let expected_custom_tlvs = vec![
4337 (5482373483, vec![0x12, 0x34]),
4338 (5482373487, vec![0x42u8; 8]),
4340 let msg = msgs::OutboundOnionPayload::Receive {
4342 payment_metadata: None,
4343 keysend_preimage: None,
4344 custom_tlvs: expected_custom_tlvs.clone(),
4345 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4346 cltv_expiry_height: 0xffffffff,
4348 let encoded_value = msg.encode();
4349 let target_value = <Vec<u8>>::from_hex("2e02080badf00d010203040404ffffffffff0000000146c6616b021234ff0000000146c6616f084242424242424242").unwrap();
4350 assert_eq!(encoded_value, target_value);
4351 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4352 let inbound_msg: msgs::InboundOnionPayload = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4353 if let msgs::InboundOnionPayload::Receive {
4355 payment_metadata: None,
4356 keysend_preimage: None,
4358 sender_intended_htlc_amt_msat,
4359 cltv_expiry_height: outgoing_cltv_value,
4362 assert_eq!(custom_tlvs, expected_custom_tlvs);
4363 assert_eq!(sender_intended_htlc_amt_msat, 0x0badf00d01020304);
4364 assert_eq!(outgoing_cltv_value, 0xffffffff);
4365 } else { panic!(); }
4369 fn query_channel_range_end_blocknum() {
4370 let tests: Vec<(u32, u32, u32)> = vec![
4371 (10000, 1500, 11500),
4372 (0, 0xffffffff, 0xffffffff),
4373 (1, 0xffffffff, 0xffffffff),
4376 for (first_blocknum, number_of_blocks, expected) in tests.into_iter() {
4377 let sut = msgs::QueryChannelRange {
4378 chain_hash: ChainHash::using_genesis_block(Network::Regtest),
4382 assert_eq!(sut.end_blocknum(), expected);
4387 fn encoding_query_channel_range() {
4388 let mut query_channel_range = msgs::QueryChannelRange {
4389 chain_hash: ChainHash::using_genesis_block(Network::Regtest),
4390 first_blocknum: 100000,
4391 number_of_blocks: 1500,
4393 let encoded_value = query_channel_range.encode();
4394 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000186a0000005dc").unwrap();
4395 assert_eq!(encoded_value, target_value);
4397 query_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4398 assert_eq!(query_channel_range.first_blocknum, 100000);
4399 assert_eq!(query_channel_range.number_of_blocks, 1500);
4403 fn encoding_reply_channel_range() {
4404 do_encoding_reply_channel_range(0);
4405 do_encoding_reply_channel_range(1);
4408 fn do_encoding_reply_channel_range(encoding_type: u8) {
4409 let mut target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000b8a06000005dc01").unwrap();
4410 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4411 let mut reply_channel_range = msgs::ReplyChannelRange {
4412 chain_hash: expected_chain_hash,
4413 first_blocknum: 756230,
4414 number_of_blocks: 1500,
4415 sync_complete: true,
4416 short_channel_ids: vec![0x000000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
4419 if encoding_type == 0 {
4420 target_value.append(&mut <Vec<u8>>::from_hex("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
4421 let encoded_value = reply_channel_range.encode();
4422 assert_eq!(encoded_value, target_value);
4424 reply_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4425 assert_eq!(reply_channel_range.chain_hash, expected_chain_hash);
4426 assert_eq!(reply_channel_range.first_blocknum, 756230);
4427 assert_eq!(reply_channel_range.number_of_blocks, 1500);
4428 assert_eq!(reply_channel_range.sync_complete, true);
4429 assert_eq!(reply_channel_range.short_channel_ids[0], 0x000000000000008e);
4430 assert_eq!(reply_channel_range.short_channel_ids[1], 0x0000000000003c69);
4431 assert_eq!(reply_channel_range.short_channel_ids[2], 0x000000000045a6c4);
4433 target_value.append(&mut <Vec<u8>>::from_hex("001601789c636000833e08659309a65878be010010a9023a").unwrap());
4434 let result: Result<msgs::ReplyChannelRange, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
4435 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
4440 fn encoding_query_short_channel_ids() {
4441 do_encoding_query_short_channel_ids(0);
4442 do_encoding_query_short_channel_ids(1);
4445 fn do_encoding_query_short_channel_ids(encoding_type: u8) {
4446 let mut target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
4447 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4448 let mut query_short_channel_ids = msgs::QueryShortChannelIds {
4449 chain_hash: expected_chain_hash,
4450 short_channel_ids: vec![0x0000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
4453 if encoding_type == 0 {
4454 target_value.append(&mut <Vec<u8>>::from_hex("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
4455 let encoded_value = query_short_channel_ids.encode();
4456 assert_eq!(encoded_value, target_value);
4458 query_short_channel_ids = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4459 assert_eq!(query_short_channel_ids.chain_hash, expected_chain_hash);
4460 assert_eq!(query_short_channel_ids.short_channel_ids[0], 0x000000000000008e);
4461 assert_eq!(query_short_channel_ids.short_channel_ids[1], 0x0000000000003c69);
4462 assert_eq!(query_short_channel_ids.short_channel_ids[2], 0x000000000045a6c4);
4464 target_value.append(&mut <Vec<u8>>::from_hex("001601789c636000833e08659309a65878be010010a9023a").unwrap());
4465 let result: Result<msgs::QueryShortChannelIds, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
4466 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
4471 fn encoding_reply_short_channel_ids_end() {
4472 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4473 let mut reply_short_channel_ids_end = msgs::ReplyShortChannelIdsEnd {
4474 chain_hash: expected_chain_hash,
4475 full_information: true,
4477 let encoded_value = reply_short_channel_ids_end.encode();
4478 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f01").unwrap();
4479 assert_eq!(encoded_value, target_value);
4481 reply_short_channel_ids_end = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4482 assert_eq!(reply_short_channel_ids_end.chain_hash, expected_chain_hash);
4483 assert_eq!(reply_short_channel_ids_end.full_information, true);
4487 fn encoding_gossip_timestamp_filter(){
4488 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4489 let mut gossip_timestamp_filter = msgs::GossipTimestampFilter {
4490 chain_hash: expected_chain_hash,
4491 first_timestamp: 1590000000,
4492 timestamp_range: 0xffff_ffff,
4494 let encoded_value = gossip_timestamp_filter.encode();
4495 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f5ec57980ffffffff").unwrap();
4496 assert_eq!(encoded_value, target_value);
4498 gossip_timestamp_filter = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4499 assert_eq!(gossip_timestamp_filter.chain_hash, expected_chain_hash);
4500 assert_eq!(gossip_timestamp_filter.first_timestamp, 1590000000);
4501 assert_eq!(gossip_timestamp_filter.timestamp_range, 0xffff_ffff);
4505 fn decode_onion_hop_data_len_as_bigsize() {
4506 // Tests that we can decode an onion payload that is >253 bytes.
4507 // Previously, receiving a payload of this size could've caused us to fail to decode a valid
4508 // payload, because we were decoding the length (a BigSize, big-endian) as a VarInt
4511 // Encode a test onion payload with a big custom TLV such that it's >253 bytes, forcing the
4512 // payload length to be encoded over multiple bytes rather than a single u8.
4513 let big_payload = encode_big_payload().unwrap();
4514 let mut rd = Cursor::new(&big_payload[..]);
4516 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4517 <msgs::InboundOnionPayload as ReadableArgs<(Option<PublicKey>, &&test_utils::TestKeysInterface)>>
4518 ::read(&mut rd, (None, &&node_signer)).unwrap();
4520 // see above test, needs to be a separate method for use of the serialization macros.
4521 fn encode_big_payload() -> Result<Vec<u8>, io::Error> {
4522 use crate::util::ser::HighZeroBytesDroppedBigSize;
4523 let payload = msgs::OutboundOnionPayload::Forward {
4524 short_channel_id: 0xdeadbeef1bad1dea,
4525 amt_to_forward: 1000,
4526 outgoing_cltv_value: 0xffffffff,
4528 let mut encoded_payload = Vec::new();
4529 let test_bytes = vec![42u8; 1000];
4530 if let msgs::OutboundOnionPayload::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } = payload {
4531 _encode_varint_length_prefixed_tlv!(&mut encoded_payload, {
4532 (1, test_bytes, required_vec),
4533 (2, HighZeroBytesDroppedBigSize(amt_to_forward), required),
4534 (4, HighZeroBytesDroppedBigSize(outgoing_cltv_value), required),
4535 (6, short_channel_id, required)
4542 #[cfg(feature = "std")]
4543 fn test_socket_address_from_str() {
4544 let tcpip_v4 = SocketAddress::TcpIpV4 {
4545 addr: Ipv4Addr::new(127, 0, 0, 1).octets(),
4548 assert_eq!(tcpip_v4, SocketAddress::from_str("127.0.0.1:1234").unwrap());
4549 assert_eq!(tcpip_v4, SocketAddress::from_str(&tcpip_v4.to_string()).unwrap());
4551 let tcpip_v6 = SocketAddress::TcpIpV6 {
4552 addr: Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1).octets(),
4555 assert_eq!(tcpip_v6, SocketAddress::from_str("[0:0:0:0:0:0:0:1]:1234").unwrap());
4556 assert_eq!(tcpip_v6, SocketAddress::from_str(&tcpip_v6.to_string()).unwrap());
4558 let hostname = SocketAddress::Hostname {
4559 hostname: Hostname::try_from("lightning-node.mydomain.com".to_string()).unwrap(),
4562 assert_eq!(hostname, SocketAddress::from_str("lightning-node.mydomain.com:1234").unwrap());
4563 assert_eq!(hostname, SocketAddress::from_str(&hostname.to_string()).unwrap());
4565 let onion_v2 = SocketAddress::OnionV2 ([40, 4, 64, 185, 202, 19, 162, 75, 90, 200, 38, 7],);
4566 assert_eq!("OnionV2([40, 4, 64, 185, 202, 19, 162, 75, 90, 200, 38, 7])", &onion_v2.to_string());
4567 assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("FACEBOOKCOREWWWI.onion:9735"));
4569 let onion_v3 = SocketAddress::OnionV3 {
4570 ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102, 182, 107, 4, 105, 247, 246, 85,
4571 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31, 33, 71, 3],
4576 assert_eq!(onion_v3, SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion:1234").unwrap());
4577 assert_eq!(onion_v3, SocketAddress::from_str(&onion_v3.to_string()).unwrap());
4579 assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6.onion:1234"));
4580 assert_eq!(Err(SocketAddressParseError::InvalidInput), SocketAddress::from_str("127.0.0.1@1234"));
4581 assert_eq!(Err(SocketAddressParseError::InvalidInput), "".parse::<SocketAddress>());
4582 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:9735:94").is_err());
4583 assert!(SocketAddress::from_str("wrong$%#.com:1234").is_err());
4584 assert_eq!(Err(SocketAddressParseError::InvalidPort), SocketAddress::from_str("example.com:wrong"));
4585 assert!("localhost".parse::<SocketAddress>().is_err());
4586 assert!("localhost:invalid-port".parse::<SocketAddress>().is_err());
4587 assert!( "invalid-onion-v3-hostname.onion:8080".parse::<SocketAddress>().is_err());
4588 assert!("b32.example.onion:invalid-port".parse::<SocketAddress>().is_err());
4589 assert!("invalid-address".parse::<SocketAddress>().is_err());
4590 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:1234").is_err());
4594 #[cfg(feature = "std")]
4595 fn test_socket_address_to_socket_addrs() {
4596 assert_eq!(SocketAddress::TcpIpV4 {addr:[0u8; 4], port: 1337,}.to_socket_addrs().unwrap().next().unwrap(),
4597 SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(0,0,0,0), 1337)));
4598 assert_eq!(SocketAddress::TcpIpV6 {addr:[0u8; 16], port: 1337,}.to_socket_addrs().unwrap().next().unwrap(),
4599 SocketAddr::V6(SocketAddrV6::new(Ipv6Addr::from([0u8; 16]), 1337, 0, 0)));
4600 assert_eq!(SocketAddress::Hostname { hostname: Hostname::try_from("0.0.0.0".to_string()).unwrap(), port: 0 }
4601 .to_socket_addrs().unwrap().next().unwrap(), SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::from([0u8; 4]),0)));
4602 assert!(SocketAddress::OnionV2([0u8; 12]).to_socket_addrs().is_err());
4603 assert!(SocketAddress::OnionV3{ ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102,
4604 182, 107, 4, 105, 247, 246, 85, 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31,
4608 port: 1234 }.to_socket_addrs().is_err());