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,
96 /// An [`init`] message to be sent to or received from a peer.
98 /// [`init`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-init-message
99 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
101 /// The relevant features which the sender supports.
102 pub features: InitFeatures,
103 /// Indicates chains the sender is interested in.
105 /// If there are no common chains, the connection will be closed.
106 pub networks: Option<Vec<ChainHash>>,
107 /// The receipient's network address.
109 /// This adds the option to report a remote IP address back to a connecting peer using the init
110 /// message. A node can decide to use that information to discover a potential update to its
111 /// public IPv4 address (NAT) and use that for a [`NodeAnnouncement`] update message containing
113 pub remote_network_address: Option<SocketAddress>,
116 /// An [`error`] message to be sent to or received from a peer.
118 /// [`error`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-error-and-warning-messages
119 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
120 pub struct ErrorMessage {
121 /// The channel ID involved in the error.
123 /// All-0s indicates a general error unrelated to a specific channel, after which all channels
124 /// with the sending peer should be closed.
125 pub channel_id: ChannelId,
126 /// A possibly human-readable error description.
128 /// The string should be sanitized before it is used (e.g., emitted to logs or printed to
129 /// `stdout`). Otherwise, a well crafted error message may trigger a security vulnerability in
130 /// the terminal emulator or the logging subsystem.
134 /// A [`warning`] message to be sent to or received from a peer.
136 /// [`warning`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-error-and-warning-messages
137 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
138 pub struct WarningMessage {
139 /// The channel ID involved in the warning.
141 /// All-0s indicates a warning unrelated to a specific channel.
142 pub channel_id: ChannelId,
143 /// A possibly human-readable warning description.
145 /// The string should be sanitized before it is used (e.g. emitted to logs or printed to
146 /// stdout). Otherwise, a well crafted error message may trigger a security vulnerability in
147 /// the terminal emulator or the logging subsystem.
151 /// A [`ping`] message to be sent to or received from a peer.
153 /// [`ping`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-ping-and-pong-messages
154 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
156 /// The desired response length.
158 /// The ping packet size.
160 /// This field is not sent on the wire. byteslen zeros are sent.
164 /// A [`pong`] message to be sent to or received from a peer.
166 /// [`pong`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-ping-and-pong-messages
167 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
169 /// The pong packet size.
171 /// This field is not sent on the wire. byteslen zeros are sent.
175 /// Contains fields that are both common to [`open_channel`] and `open_channel2` messages.
177 /// [`open_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-open_channel-message
178 // TODO(dual_funding): Add spec link for `open_channel2`.
179 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
180 pub struct CommonOpenChannelFields {
181 /// The genesis hash of the blockchain where the channel is to be opened
182 pub chain_hash: ChainHash,
183 /// A temporary channel ID
184 /// For V2 channels: derived using a zeroed out value for the channel acceptor's revocation basepoint
185 /// For V1 channels: a temporary channel ID, until the funding outpoint is announced
186 pub temporary_channel_id: ChannelId,
187 /// For V1 channels: The channel value
188 /// For V2 channels: Part of the channel value contributed by the channel initiator
189 pub funding_satoshis: u64,
190 /// The threshold below which outputs on transactions broadcast by the channel initiator will be
192 pub dust_limit_satoshis: u64,
193 /// The maximum inbound HTLC value in flight towards channel initiator, in milli-satoshi
194 pub max_htlc_value_in_flight_msat: u64,
195 /// The minimum HTLC size incoming to channel initiator, in milli-satoshi
196 pub htlc_minimum_msat: u64,
197 /// The feerate for the commitment transaction set by the channel initiator until updated by
199 pub commitment_feerate_sat_per_1000_weight: u32,
200 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
201 /// broadcast a commitment transaction
202 pub to_self_delay: u16,
203 /// The maximum number of inbound HTLCs towards channel initiator
204 pub max_accepted_htlcs: u16,
205 /// The channel initiator's key controlling the funding transaction
206 pub funding_pubkey: PublicKey,
207 /// Used to derive a revocation key for transactions broadcast by counterparty
208 pub revocation_basepoint: PublicKey,
209 /// A payment key to channel initiator for transactions broadcast by counterparty
210 pub payment_basepoint: PublicKey,
211 /// Used to derive a payment key to channel initiator for transactions broadcast by channel
213 pub delayed_payment_basepoint: PublicKey,
214 /// Used to derive an HTLC payment key to channel initiator
215 pub htlc_basepoint: PublicKey,
216 /// The first to-be-broadcast-by-channel-initiator transaction's per commitment point
217 pub first_per_commitment_point: PublicKey,
218 /// The channel flags to be used
219 pub channel_flags: u8,
220 /// Optionally, a request to pre-set the to-channel-initiator output's scriptPubkey for when we
221 /// collaboratively close
222 pub shutdown_scriptpubkey: Option<ScriptBuf>,
223 /// The channel type that this channel will represent
225 /// If this is `None`, we derive the channel type from the intersection of our
226 /// feature bits with our counterparty's feature bits from the [`Init`] message.
227 pub channel_type: Option<ChannelTypeFeatures>,
230 /// An [`open_channel`] message to be sent to or received from a peer.
232 /// Used in V1 channel establishment
234 /// [`open_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-open_channel-message
235 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
236 pub struct OpenChannel {
237 /// Common fields of `open_channel(2)`-like messages
238 pub common_fields: CommonOpenChannelFields,
239 /// The amount to push to the counterparty as part of the open, in milli-satoshi
241 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
242 pub channel_reserve_satoshis: u64,
245 /// An open_channel2 message to be sent by or received from the channel initiator.
247 /// Used in V2 channel establishment
249 // TODO(dual_funding): Add spec link for `open_channel2`.
250 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
251 pub struct OpenChannelV2 {
252 /// Common fields of `open_channel(2)`-like messages
253 pub common_fields: CommonOpenChannelFields,
254 /// The feerate for the funding transaction set by the channel initiator
255 pub funding_feerate_sat_per_1000_weight: u32,
256 /// The locktime for the funding transaction
258 /// The second to-be-broadcast-by-channel-initiator transaction's per commitment point
259 pub second_per_commitment_point: PublicKey,
260 /// Optionally, a requirement that only confirmed inputs can be added
261 pub require_confirmed_inputs: Option<()>,
264 /// Contains fields that are both common to [`accept_channel`] and `accept_channel2` messages.
266 /// [`accept_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-accept_channel-message
267 // TODO(dual_funding): Add spec link for `accept_channel2`.
268 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
269 pub struct CommonAcceptChannelFields {
270 /// The same `temporary_channel_id` received from the initiator's `open_channel2` or `open_channel` message.
271 pub temporary_channel_id: ChannelId,
272 /// The threshold below which outputs on transactions broadcast by the channel acceptor will be
274 pub dust_limit_satoshis: u64,
275 /// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
276 pub max_htlc_value_in_flight_msat: u64,
277 /// The minimum HTLC size incoming to channel acceptor, in milli-satoshi
278 pub htlc_minimum_msat: u64,
279 /// Minimum depth of the funding transaction before the channel is considered open
280 pub minimum_depth: u32,
281 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
282 /// broadcast a commitment transaction
283 pub to_self_delay: u16,
284 /// The maximum number of inbound HTLCs towards channel acceptor
285 pub max_accepted_htlcs: u16,
286 /// The channel acceptor's key controlling the funding transaction
287 pub funding_pubkey: PublicKey,
288 /// Used to derive a revocation key for transactions broadcast by counterparty
289 pub revocation_basepoint: PublicKey,
290 /// A payment key to channel acceptor for transactions broadcast by counterparty
291 pub payment_basepoint: PublicKey,
292 /// Used to derive a payment key to channel acceptor for transactions broadcast by channel
294 pub delayed_payment_basepoint: PublicKey,
295 /// Used to derive an HTLC payment key to channel acceptor for transactions broadcast by counterparty
296 pub htlc_basepoint: PublicKey,
297 /// The first to-be-broadcast-by-channel-acceptor transaction's per commitment point
298 pub first_per_commitment_point: PublicKey,
299 /// Optionally, a request to pre-set the to-channel-acceptor output's scriptPubkey for when we
300 /// collaboratively close
301 pub shutdown_scriptpubkey: Option<ScriptBuf>,
302 /// The channel type that this channel will represent. If none is set, we derive the channel
303 /// type from the intersection of our feature bits with our counterparty's feature bits from
304 /// the Init message.
306 /// This is required to match the equivalent field in [`OpenChannel`] or [`OpenChannelV2`]'s
307 /// [`CommonOpenChannelFields::channel_type`].
308 pub channel_type: Option<ChannelTypeFeatures>,
311 /// An [`accept_channel`] message to be sent to or received from a peer.
313 /// Used in V1 channel establishment
315 /// [`accept_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-accept_channel-message
316 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
317 pub struct AcceptChannel {
318 /// Common fields of `accept_channel(2)`-like messages
319 pub common_fields: CommonAcceptChannelFields,
320 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
321 pub channel_reserve_satoshis: u64,
323 /// Next nonce the channel initiator should use to create a funding output signature against
324 pub next_local_nonce: Option<musig2::types::PublicNonce>,
327 /// An accept_channel2 message to be sent by or received from the channel accepter.
329 /// Used in V2 channel establishment
331 // TODO(dual_funding): Add spec link for `accept_channel2`.
332 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
333 pub struct AcceptChannelV2 {
334 /// Common fields of `accept_channel(2)`-like messages
335 pub common_fields: CommonAcceptChannelFields,
336 /// Part of the channel value contributed by the channel acceptor
337 pub funding_satoshis: u64,
338 /// The second to-be-broadcast-by-channel-acceptor transaction's per commitment point
339 pub second_per_commitment_point: PublicKey,
340 /// Optionally, a requirement that only confirmed inputs can be added
341 pub require_confirmed_inputs: Option<()>,
344 /// A [`funding_created`] message to be sent to or received from a peer.
346 /// Used in V1 channel establishment
348 /// [`funding_created`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-funding_created-message
349 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
350 pub struct FundingCreated {
351 /// A temporary channel ID, until the funding is established
352 pub temporary_channel_id: ChannelId,
353 /// The funding transaction ID
354 pub funding_txid: Txid,
355 /// The specific output index funding this channel
356 pub funding_output_index: u16,
357 /// The signature of the channel initiator (funder) on the initial commitment transaction
358 pub signature: Signature,
360 /// The partial signature of the channel initiator (funder)
361 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
363 /// Next nonce the channel acceptor should use to finalize the funding output signature
364 pub next_local_nonce: Option<musig2::types::PublicNonce>
367 /// A [`funding_signed`] message to be sent to or received from a peer.
369 /// Used in V1 channel establishment
371 /// [`funding_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-funding_signed-message
372 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
373 pub struct FundingSigned {
375 pub channel_id: ChannelId,
376 /// The signature of the channel acceptor (fundee) on the initial commitment transaction
377 pub signature: Signature,
379 /// The partial signature of the channel acceptor (fundee)
380 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
383 /// A [`channel_ready`] message to be sent to or received from a peer.
385 /// [`channel_ready`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-channel_ready-message
386 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
387 pub struct ChannelReady {
389 pub channel_id: ChannelId,
390 /// The per-commitment point of the second commitment transaction
391 pub next_per_commitment_point: PublicKey,
392 /// If set, provides a `short_channel_id` alias for this channel.
394 /// The sender will accept payments to be forwarded over this SCID and forward them to this
395 /// messages' recipient.
396 pub short_channel_id_alias: Option<u64>,
399 /// An stfu (quiescence) message to be sent by or received from the stfu initiator.
400 // TODO(splicing): Add spec link for `stfu`; still in draft, using from https://github.com/lightning/bolts/pull/863
401 #[derive(Clone, Debug, PartialEq, Eq)]
403 /// The channel ID where quiescence is intended
404 pub channel_id: ChannelId,
405 /// Initiator flag, 1 if initiating, 0 if replying to an stfu.
409 /// A splice message to be sent by or received from the stfu initiator (splice initiator).
410 // TODO(splicing): Add spec link for `splice`; still in draft, using from https://github.com/lightning/bolts/pull/863
411 #[derive(Clone, Debug, PartialEq, Eq)]
413 /// The channel ID where splicing is intended
414 pub channel_id: ChannelId,
415 /// The genesis hash of the blockchain where the channel is intended to be spliced
416 pub chain_hash: ChainHash,
417 /// The intended change in channel capacity: the amount to be added (positive value)
418 /// or removed (negative value) by the sender (splice initiator) by splicing into/from the channel.
419 pub relative_satoshis: i64,
420 /// The feerate for the new funding transaction, set by the splice initiator
421 pub funding_feerate_perkw: u32,
422 /// The locktime for the new funding transaction
424 /// The key of the sender (splice initiator) controlling the new funding transaction
425 pub funding_pubkey: PublicKey,
428 /// A splice_ack message to be received by or sent to the splice initiator.
430 // TODO(splicing): Add spec link for `splice_ack`; still in draft, using from https://github.com/lightning/bolts/pull/863
431 #[derive(Clone, Debug, PartialEq, Eq)]
432 pub struct SpliceAck {
433 /// The channel ID where splicing is intended
434 pub channel_id: ChannelId,
435 /// The genesis hash of the blockchain where the channel is intended to be spliced
436 pub chain_hash: ChainHash,
437 /// The intended change in channel capacity: the amount to be added (positive value)
438 /// or removed (negative value) by the sender (splice acceptor) by splicing into/from the channel.
439 pub relative_satoshis: i64,
440 /// The key of the sender (splice acceptor) controlling the new funding transaction
441 pub funding_pubkey: PublicKey,
444 /// A splice_locked message to be sent to or received from a peer.
446 // TODO(splicing): Add spec link for `splice_locked`; still in draft, using from https://github.com/lightning/bolts/pull/863
447 #[derive(Clone, Debug, PartialEq, Eq)]
448 pub struct SpliceLocked {
450 pub channel_id: ChannelId,
453 /// A tx_add_input message for adding an input during interactive transaction construction
455 // TODO(dual_funding): Add spec link for `tx_add_input`.
456 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
457 pub struct TxAddInput {
459 pub channel_id: ChannelId,
460 /// A randomly chosen unique identifier for this input, which is even for initiators and odd for
463 /// Serialized transaction that contains the output this input spends to verify that it is non
465 pub prevtx: TransactionU16LenLimited,
466 /// The index of the output being spent
468 /// The sequence number of this input
472 /// A tx_add_output message for adding an output during interactive transaction construction.
474 // TODO(dual_funding): Add spec link for `tx_add_output`.
475 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
476 pub struct TxAddOutput {
478 pub channel_id: ChannelId,
479 /// A randomly chosen unique identifier for this output, which is even for initiators and odd for
482 /// The satoshi value of the output
484 /// The scriptPubKey for the output
485 pub script: ScriptBuf,
488 /// A tx_remove_input message for removing an input during interactive transaction construction.
490 // TODO(dual_funding): Add spec link for `tx_remove_input`.
491 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
492 pub struct TxRemoveInput {
494 pub channel_id: ChannelId,
495 /// The serial ID of the input to be removed
499 /// A tx_remove_output message for removing an output during interactive transaction construction.
501 // TODO(dual_funding): Add spec link for `tx_remove_output`.
502 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
503 pub struct TxRemoveOutput {
505 pub channel_id: ChannelId,
506 /// The serial ID of the output to be removed
510 /// A tx_complete message signalling the conclusion of a peer's transaction contributions during
511 /// interactive transaction construction.
513 // TODO(dual_funding): Add spec link for `tx_complete`.
514 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
515 pub struct TxComplete {
517 pub channel_id: ChannelId,
520 /// A tx_signatures message containing the sender's signatures for a transaction constructed with
521 /// interactive transaction construction.
523 // TODO(dual_funding): Add spec link for `tx_signatures`.
524 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
525 pub struct TxSignatures {
527 pub channel_id: ChannelId,
530 /// The list of witnesses
531 pub witnesses: Vec<Witness>,
534 /// A tx_init_rbf message which initiates a replacement of the transaction after it's been
537 // TODO(dual_funding): Add spec link for `tx_init_rbf`.
538 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
539 pub struct TxInitRbf {
541 pub channel_id: ChannelId,
542 /// The locktime of the transaction
544 /// The feerate of the transaction
545 pub feerate_sat_per_1000_weight: u32,
546 /// The number of satoshis the sender will contribute to or, if negative, remove from
547 /// (e.g. splice-out) the funding output of the transaction
548 pub funding_output_contribution: Option<i64>,
551 /// A tx_ack_rbf message which acknowledges replacement of the transaction after it's been
554 // TODO(dual_funding): Add spec link for `tx_ack_rbf`.
555 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
556 pub struct TxAckRbf {
558 pub channel_id: ChannelId,
559 /// The number of satoshis the sender will contribute to or, if negative, remove from
560 /// (e.g. splice-out) the funding output of the transaction
561 pub funding_output_contribution: Option<i64>,
564 /// A tx_abort message which signals the cancellation of an in-progress transaction negotiation.
566 // TODO(dual_funding): Add spec link for `tx_abort`.
567 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
570 pub channel_id: ChannelId,
575 /// A [`shutdown`] message to be sent to or received from a peer.
577 /// [`shutdown`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-initiation-shutdown
578 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
579 pub struct Shutdown {
581 pub channel_id: ChannelId,
582 /// The destination of this peer's funds on closing.
584 /// Must be in one of these forms: P2PKH, P2SH, P2WPKH, P2WSH, P2TR.
585 pub scriptpubkey: ScriptBuf,
588 /// The minimum and maximum fees which the sender is willing to place on the closing transaction.
590 /// This is provided in [`ClosingSigned`] by both sides to indicate the fee range they are willing
592 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
593 pub struct ClosingSignedFeeRange {
594 /// The minimum absolute fee, in satoshis, which the sender is willing to place on the closing
596 pub min_fee_satoshis: u64,
597 /// The maximum absolute fee, in satoshis, which the sender is willing to place on the closing
599 pub max_fee_satoshis: u64,
602 /// A [`closing_signed`] message to be sent to or received from a peer.
604 /// [`closing_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-negotiation-closing_signed
605 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
606 pub struct ClosingSigned {
608 pub channel_id: ChannelId,
609 /// The proposed total fee for the closing transaction
610 pub fee_satoshis: u64,
611 /// A signature on the closing transaction
612 pub signature: Signature,
613 /// The minimum and maximum fees which the sender is willing to accept, provided only by new
615 pub fee_range: Option<ClosingSignedFeeRange>,
618 /// An [`update_add_htlc`] message to be sent to or received from a peer.
620 /// [`update_add_htlc`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#adding-an-htlc-update_add_htlc
621 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
622 pub struct UpdateAddHTLC {
624 pub channel_id: ChannelId,
627 /// The HTLC value in milli-satoshi
628 pub amount_msat: u64,
629 /// The payment hash, the pre-image of which controls HTLC redemption
630 pub payment_hash: PaymentHash,
631 /// The expiry height of the HTLC
632 pub cltv_expiry: u32,
633 /// The extra fee skimmed by the sender of this message. See
634 /// [`ChannelConfig::accept_underpaying_htlcs`].
636 /// [`ChannelConfig::accept_underpaying_htlcs`]: crate::util::config::ChannelConfig::accept_underpaying_htlcs
637 pub skimmed_fee_msat: Option<u64>,
638 /// The onion routing packet with encrypted data for the next hop.
639 pub onion_routing_packet: OnionPacket,
640 /// Provided if we are relaying or receiving a payment within a blinded path, to decrypt the onion
641 /// routing packet and the recipient-provided encrypted payload within.
642 pub blinding_point: Option<PublicKey>,
645 /// An onion message to be sent to or received from a peer.
647 // TODO: update with link to OM when they are merged into the BOLTs
648 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
649 pub struct OnionMessage {
650 /// Used in decrypting the onion packet's payload.
651 pub blinding_point: PublicKey,
652 /// The full onion packet including hop data, pubkey, and hmac
653 pub onion_routing_packet: onion_message::packet::Packet,
656 /// An [`update_fulfill_htlc`] message to be sent to or received from a peer.
658 /// [`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
659 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
660 pub struct UpdateFulfillHTLC {
662 pub channel_id: ChannelId,
665 /// The pre-image of the payment hash, allowing HTLC redemption
666 pub payment_preimage: PaymentPreimage,
669 /// An [`update_fail_htlc`] message to be sent to or received from a peer.
671 /// [`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
672 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
673 pub struct UpdateFailHTLC {
675 pub channel_id: ChannelId,
678 pub(crate) reason: OnionErrorPacket,
681 /// An [`update_fail_malformed_htlc`] message to be sent to or received from a peer.
683 /// [`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
684 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
685 pub struct UpdateFailMalformedHTLC {
687 pub channel_id: ChannelId,
690 pub(crate) sha256_of_onion: [u8; 32],
692 pub failure_code: u16,
695 /// A [`commitment_signed`] message to be sent to or received from a peer.
697 /// [`commitment_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#committing-updates-so-far-commitment_signed
698 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
699 pub struct CommitmentSigned {
701 pub channel_id: ChannelId,
702 /// A signature on the commitment transaction
703 pub signature: Signature,
704 /// Signatures on the HTLC transactions
705 pub htlc_signatures: Vec<Signature>,
707 /// The partial Taproot signature on the commitment transaction
708 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
711 /// A [`revoke_and_ack`] message to be sent to or received from a peer.
713 /// [`revoke_and_ack`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#completing-the-transition-to-the-updated-state-revoke_and_ack
714 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
715 pub struct RevokeAndACK {
717 pub channel_id: ChannelId,
718 /// The secret corresponding to the per-commitment point
719 pub per_commitment_secret: [u8; 32],
720 /// The next sender-broadcast commitment transaction's per-commitment point
721 pub next_per_commitment_point: PublicKey,
723 /// Musig nonce the recipient should use in their next commitment signature message
724 pub next_local_nonce: Option<musig2::types::PublicNonce>
727 /// An [`update_fee`] message to be sent to or received from a peer
729 /// [`update_fee`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#updating-fees-update_fee
730 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
731 pub struct UpdateFee {
733 pub channel_id: ChannelId,
734 /// Fee rate per 1000-weight of the transaction
735 pub feerate_per_kw: u32,
738 /// A [`channel_reestablish`] message to be sent to or received from a peer.
740 /// [`channel_reestablish`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#message-retransmission
741 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
742 pub struct ChannelReestablish {
744 pub channel_id: ChannelId,
745 /// The next commitment number for the sender
746 pub next_local_commitment_number: u64,
747 /// The next commitment number for the recipient
748 pub next_remote_commitment_number: u64,
749 /// Proof that the sender knows the per-commitment secret of a specific commitment transaction
750 /// belonging to the recipient
751 pub your_last_per_commitment_secret: [u8; 32],
752 /// The sender's per-commitment point for their current commitment transaction
753 pub my_current_per_commitment_point: PublicKey,
754 /// The next funding transaction ID
755 pub next_funding_txid: Option<Txid>,
758 /// An [`announcement_signatures`] message to be sent to or received from a peer.
760 /// [`announcement_signatures`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-announcement_signatures-message
761 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
762 pub struct AnnouncementSignatures {
764 pub channel_id: ChannelId,
765 /// The short channel ID
766 pub short_channel_id: u64,
767 /// A signature by the node key
768 pub node_signature: Signature,
769 /// A signature by the funding key
770 pub bitcoin_signature: Signature,
773 /// An address which can be used to connect to a remote peer.
774 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
775 pub enum SocketAddress {
776 /// An IPv4 address and port on which the peer is listening.
778 /// The 4-byte IPv4 address
780 /// The port on which the node is listening
783 /// An IPv6 address and port on which the peer is listening.
785 /// The 16-byte IPv6 address
787 /// The port on which the node is listening
790 /// An old-style Tor onion address/port on which the peer is listening.
792 /// This field is deprecated and the Tor network generally no longer supports V2 Onion
793 /// addresses. Thus, the details are not parsed here.
795 /// A new-style Tor onion address/port on which the peer is listening.
797 /// To create the human-readable "hostname", concatenate the ED25519 pubkey, checksum, and version,
798 /// wrap as base32 and append ".onion".
800 /// The ed25519 long-term public key of the peer
801 ed25519_pubkey: [u8; 32],
802 /// The checksum of the pubkey and version, as included in the onion address
804 /// The version byte, as defined by the Tor Onion v3 spec.
806 /// The port on which the node is listening
809 /// A hostname/port on which the peer is listening.
811 /// The hostname on which the node is listening.
813 /// The port on which the node is listening.
818 /// Gets the ID of this address type. Addresses in [`NodeAnnouncement`] messages should be sorted
820 pub(crate) fn get_id(&self) -> u8 {
822 &SocketAddress::TcpIpV4 {..} => { 1 },
823 &SocketAddress::TcpIpV6 {..} => { 2 },
824 &SocketAddress::OnionV2(_) => { 3 },
825 &SocketAddress::OnionV3 {..} => { 4 },
826 &SocketAddress::Hostname {..} => { 5 },
830 /// Strict byte-length of address descriptor, 1-byte type not recorded
831 fn len(&self) -> u16 {
833 &SocketAddress::TcpIpV4 { .. } => { 6 },
834 &SocketAddress::TcpIpV6 { .. } => { 18 },
835 &SocketAddress::OnionV2(_) => { 12 },
836 &SocketAddress::OnionV3 { .. } => { 37 },
837 // Consists of 1-byte hostname length, hostname bytes, and 2-byte port.
838 &SocketAddress::Hostname { ref hostname, .. } => { u16::from(hostname.len()) + 3 },
842 /// The maximum length of any address descriptor, not including the 1-byte type.
843 /// This maximum length is reached by a hostname address descriptor:
844 /// a hostname with a maximum length of 255, its 1-byte length and a 2-byte port.
845 pub(crate) const MAX_LEN: u16 = 258;
847 pub(crate) fn is_tor(&self) -> bool {
849 &SocketAddress::TcpIpV4 {..} => false,
850 &SocketAddress::TcpIpV6 {..} => false,
851 &SocketAddress::OnionV2(_) => true,
852 &SocketAddress::OnionV3 {..} => true,
853 &SocketAddress::Hostname {..} => false,
858 impl Writeable for SocketAddress {
859 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
861 &SocketAddress::TcpIpV4 { ref addr, ref port } => {
866 &SocketAddress::TcpIpV6 { ref addr, ref port } => {
871 &SocketAddress::OnionV2(bytes) => {
873 bytes.write(writer)?;
875 &SocketAddress::OnionV3 { ref ed25519_pubkey, ref checksum, ref version, ref port } => {
877 ed25519_pubkey.write(writer)?;
878 checksum.write(writer)?;
879 version.write(writer)?;
882 &SocketAddress::Hostname { ref hostname, ref port } => {
884 hostname.write(writer)?;
892 impl Readable for Result<SocketAddress, u8> {
893 fn read<R: Read>(reader: &mut R) -> Result<Result<SocketAddress, u8>, DecodeError> {
894 let byte = <u8 as Readable>::read(reader)?;
897 Ok(Ok(SocketAddress::TcpIpV4 {
898 addr: Readable::read(reader)?,
899 port: Readable::read(reader)?,
903 Ok(Ok(SocketAddress::TcpIpV6 {
904 addr: Readable::read(reader)?,
905 port: Readable::read(reader)?,
908 3 => Ok(Ok(SocketAddress::OnionV2(Readable::read(reader)?))),
910 Ok(Ok(SocketAddress::OnionV3 {
911 ed25519_pubkey: Readable::read(reader)?,
912 checksum: Readable::read(reader)?,
913 version: Readable::read(reader)?,
914 port: Readable::read(reader)?,
918 Ok(Ok(SocketAddress::Hostname {
919 hostname: Readable::read(reader)?,
920 port: Readable::read(reader)?,
923 _ => return Ok(Err(byte)),
928 impl Readable for SocketAddress {
929 fn read<R: Read>(reader: &mut R) -> Result<SocketAddress, DecodeError> {
930 match Readable::read(reader) {
931 Ok(Ok(res)) => Ok(res),
932 Ok(Err(_)) => Err(DecodeError::UnknownVersion),
938 /// [`SocketAddress`] error variants
939 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
940 pub enum SocketAddressParseError {
941 /// Socket address (IPv4/IPv6) parsing error
943 /// Invalid input format
947 /// Invalid onion v3 address
951 impl fmt::Display for SocketAddressParseError {
952 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
954 SocketAddressParseError::SocketAddrParse => write!(f, "Socket address (IPv4/IPv6) parsing error"),
955 SocketAddressParseError::InvalidInput => write!(f, "Invalid input format. \
956 Expected: \"<ipv4>:<port>\", \"[<ipv6>]:<port>\", \"<onion address>.onion:<port>\" or \"<hostname>:<port>\""),
957 SocketAddressParseError::InvalidPort => write!(f, "Invalid port"),
958 SocketAddressParseError::InvalidOnionV3 => write!(f, "Invalid onion v3 address"),
963 #[cfg(feature = "std")]
964 impl From<std::net::SocketAddrV4> for SocketAddress {
965 fn from(addr: std::net::SocketAddrV4) -> Self {
966 SocketAddress::TcpIpV4 { addr: addr.ip().octets(), port: addr.port() }
970 #[cfg(feature = "std")]
971 impl From<std::net::SocketAddrV6> for SocketAddress {
972 fn from(addr: std::net::SocketAddrV6) -> Self {
973 SocketAddress::TcpIpV6 { addr: addr.ip().octets(), port: addr.port() }
977 #[cfg(feature = "std")]
978 impl From<std::net::SocketAddr> for SocketAddress {
979 fn from(addr: std::net::SocketAddr) -> Self {
981 std::net::SocketAddr::V4(addr) => addr.into(),
982 std::net::SocketAddr::V6(addr) => addr.into(),
987 #[cfg(feature = "std")]
988 impl std::net::ToSocketAddrs for SocketAddress {
989 type Iter = std::vec::IntoIter<std::net::SocketAddr>;
991 fn to_socket_addrs(&self) -> std::io::Result<Self::Iter> {
993 SocketAddress::TcpIpV4 { addr, port } => {
994 let ip_addr = std::net::Ipv4Addr::from(*addr);
995 let socket_addr = SocketAddr::new(ip_addr.into(), *port);
996 Ok(vec![socket_addr].into_iter())
998 SocketAddress::TcpIpV6 { addr, port } => {
999 let ip_addr = std::net::Ipv6Addr::from(*addr);
1000 let socket_addr = SocketAddr::new(ip_addr.into(), *port);
1001 Ok(vec![socket_addr].into_iter())
1003 SocketAddress::Hostname { ref hostname, port } => {
1004 (hostname.as_str(), *port).to_socket_addrs()
1006 SocketAddress::OnionV2(..) => {
1007 Err(std::io::Error::new(std::io::ErrorKind::Other, "Resolution of OnionV2 \
1008 addresses is currently unsupported."))
1010 SocketAddress::OnionV3 { .. } => {
1011 Err(std::io::Error::new(std::io::ErrorKind::Other, "Resolution of OnionV3 \
1012 addresses is currently unsupported."))
1018 /// Parses an OnionV3 host and port into a [`SocketAddress::OnionV3`].
1020 /// The host part must end with ".onion".
1021 pub fn parse_onion_address(host: &str, port: u16) -> Result<SocketAddress, SocketAddressParseError> {
1022 if host.ends_with(".onion") {
1023 let domain = &host[..host.len() - ".onion".len()];
1024 if domain.len() != 56 {
1025 return Err(SocketAddressParseError::InvalidOnionV3);
1027 let onion = base32::Alphabet::RFC4648 { padding: false }.decode(&domain).map_err(|_| SocketAddressParseError::InvalidOnionV3)?;
1028 if onion.len() != 35 {
1029 return Err(SocketAddressParseError::InvalidOnionV3);
1031 let version = onion[0];
1032 let first_checksum_flag = onion[1];
1033 let second_checksum_flag = onion[2];
1034 let mut ed25519_pubkey = [0; 32];
1035 ed25519_pubkey.copy_from_slice(&onion[3..35]);
1036 let checksum = u16::from_be_bytes([first_checksum_flag, second_checksum_flag]);
1037 return Ok(SocketAddress::OnionV3 { ed25519_pubkey, checksum, version, port });
1040 return Err(SocketAddressParseError::InvalidInput);
1044 impl Display for SocketAddress {
1045 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1047 SocketAddress::TcpIpV4{addr, port} => write!(
1048 f, "{}.{}.{}.{}:{}", addr[0], addr[1], addr[2], addr[3], port)?,
1049 SocketAddress::TcpIpV6{addr, port} => write!(
1051 "[{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}]:{}",
1052 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
1054 SocketAddress::OnionV2(bytes) => write!(f, "OnionV2({:?})", bytes)?,
1055 SocketAddress::OnionV3 {
1061 let [first_checksum_flag, second_checksum_flag] = checksum.to_be_bytes();
1062 let mut addr = vec![*version, first_checksum_flag, second_checksum_flag];
1063 addr.extend_from_slice(ed25519_pubkey);
1064 let onion = base32::Alphabet::RFC4648 { padding: false }.encode(&addr);
1065 write!(f, "{}.onion:{}", onion, port)?
1067 SocketAddress::Hostname { hostname, port } => write!(f, "{}:{}", hostname, port)?,
1073 #[cfg(feature = "std")]
1074 impl FromStr for SocketAddress {
1075 type Err = SocketAddressParseError;
1077 fn from_str(s: &str) -> Result<Self, Self::Err> {
1078 match std::net::SocketAddr::from_str(s) {
1079 Ok(addr) => Ok(addr.into()),
1081 let trimmed_input = match s.rfind(":") {
1083 None => return Err(SocketAddressParseError::InvalidInput),
1085 let host = &s[..trimmed_input];
1086 let port: u16 = s[trimmed_input + 1..].parse().map_err(|_| SocketAddressParseError::InvalidPort)?;
1087 if host.ends_with(".onion") {
1088 return parse_onion_address(host, port);
1090 if let Ok(hostname) = Hostname::try_from(s[..trimmed_input].to_string()) {
1091 return Ok(SocketAddress::Hostname { hostname, port });
1093 return Err(SocketAddressParseError::SocketAddrParse)
1099 /// Represents the set of gossip messages that require a signature from a node's identity key.
1100 pub enum UnsignedGossipMessage<'a> {
1101 /// An unsigned channel announcement.
1102 ChannelAnnouncement(&'a UnsignedChannelAnnouncement),
1103 /// An unsigned channel update.
1104 ChannelUpdate(&'a UnsignedChannelUpdate),
1105 /// An unsigned node announcement.
1106 NodeAnnouncement(&'a UnsignedNodeAnnouncement)
1109 impl<'a> Writeable for UnsignedGossipMessage<'a> {
1110 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
1112 UnsignedGossipMessage::ChannelAnnouncement(ref msg) => msg.write(writer),
1113 UnsignedGossipMessage::ChannelUpdate(ref msg) => msg.write(writer),
1114 UnsignedGossipMessage::NodeAnnouncement(ref msg) => msg.write(writer),
1119 /// The unsigned part of a [`node_announcement`] message.
1121 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
1122 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1123 pub struct UnsignedNodeAnnouncement {
1124 /// The advertised features
1125 pub features: NodeFeatures,
1126 /// A strictly monotonic announcement counter, with gaps allowed
1128 /// The `node_id` this announcement originated from (don't rebroadcast the `node_announcement` back
1130 pub node_id: NodeId,
1131 /// An RGB color for UI purposes
1133 /// An alias, for UI purposes.
1135 /// This should be sanitized before use. There is no guarantee of uniqueness.
1136 pub alias: NodeAlias,
1137 /// List of addresses on which this node is reachable
1138 pub addresses: Vec<SocketAddress>,
1139 pub(crate) excess_address_data: Vec<u8>,
1140 pub(crate) excess_data: Vec<u8>,
1142 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1143 /// A [`node_announcement`] message to be sent to or received from a peer.
1145 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
1146 pub struct NodeAnnouncement {
1147 /// The signature by the node key
1148 pub signature: Signature,
1149 /// The actual content of the announcement
1150 pub contents: UnsignedNodeAnnouncement,
1153 /// The unsigned part of a [`channel_announcement`] message.
1155 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
1156 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1157 pub struct UnsignedChannelAnnouncement {
1158 /// The advertised channel features
1159 pub features: ChannelFeatures,
1160 /// The genesis hash of the blockchain where the channel is to be opened
1161 pub chain_hash: ChainHash,
1162 /// The short channel ID
1163 pub short_channel_id: u64,
1164 /// One of the two `node_id`s which are endpoints of this channel
1165 pub node_id_1: NodeId,
1166 /// The other of the two `node_id`s which are endpoints of this channel
1167 pub node_id_2: NodeId,
1168 /// The funding key for the first node
1169 pub bitcoin_key_1: NodeId,
1170 /// The funding key for the second node
1171 pub bitcoin_key_2: NodeId,
1172 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1175 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1176 pub excess_data: Vec<u8>,
1178 /// A [`channel_announcement`] message to be sent to or received from a peer.
1180 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
1181 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1182 pub struct ChannelAnnouncement {
1183 /// Authentication of the announcement by the first public node
1184 pub node_signature_1: Signature,
1185 /// Authentication of the announcement by the second public node
1186 pub node_signature_2: Signature,
1187 /// Proof of funding UTXO ownership by the first public node
1188 pub bitcoin_signature_1: Signature,
1189 /// Proof of funding UTXO ownership by the second public node
1190 pub bitcoin_signature_2: Signature,
1191 /// The actual announcement
1192 pub contents: UnsignedChannelAnnouncement,
1195 /// The unsigned part of a [`channel_update`] message.
1197 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1198 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1199 pub struct UnsignedChannelUpdate {
1200 /// The genesis hash of the blockchain where the channel is to be opened
1201 pub chain_hash: ChainHash,
1202 /// The short channel ID
1203 pub short_channel_id: u64,
1204 /// A strictly monotonic announcement counter, with gaps allowed, specific to this channel
1208 /// The number of blocks such that if:
1209 /// `incoming_htlc.cltv_expiry < outgoing_htlc.cltv_expiry + cltv_expiry_delta`
1210 /// then we need to fail the HTLC backwards. When forwarding an HTLC, `cltv_expiry_delta` determines
1211 /// the outgoing HTLC's minimum `cltv_expiry` value -- so, if an incoming HTLC comes in with a
1212 /// `cltv_expiry` of 100000, and the node we're forwarding to has a `cltv_expiry_delta` value of 10,
1213 /// then we'll check that the outgoing HTLC's `cltv_expiry` value is at least 100010 before
1214 /// forwarding. Note that the HTLC sender is the one who originally sets this value when
1215 /// constructing the route.
1216 pub cltv_expiry_delta: u16,
1217 /// The minimum HTLC size incoming to sender, in milli-satoshi
1218 pub htlc_minimum_msat: u64,
1219 /// The maximum HTLC value incoming to sender, in milli-satoshi.
1221 /// This used to be optional.
1222 pub htlc_maximum_msat: u64,
1223 /// The base HTLC fee charged by sender, in milli-satoshi
1224 pub fee_base_msat: u32,
1225 /// The amount to fee multiplier, in micro-satoshi
1226 pub fee_proportional_millionths: u32,
1227 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1230 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1231 pub excess_data: Vec<u8>,
1233 /// A [`channel_update`] message to be sent to or received from a peer.
1235 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1236 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1237 pub struct ChannelUpdate {
1238 /// A signature of the channel update
1239 pub signature: Signature,
1240 /// The actual channel update
1241 pub contents: UnsignedChannelUpdate,
1244 /// A [`query_channel_range`] message is used to query a peer for channel
1245 /// UTXOs in a range of blocks. The recipient of a query makes a best
1246 /// effort to reply to the query using one or more [`ReplyChannelRange`]
1249 /// [`query_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1250 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1251 pub struct QueryChannelRange {
1252 /// The genesis hash of the blockchain being queried
1253 pub chain_hash: ChainHash,
1254 /// The height of the first block for the channel UTXOs being queried
1255 pub first_blocknum: u32,
1256 /// The number of blocks to include in the query results
1257 pub number_of_blocks: u32,
1260 /// A [`reply_channel_range`] message is a reply to a [`QueryChannelRange`]
1263 /// Multiple `reply_channel_range` messages can be sent in reply
1264 /// to a single [`QueryChannelRange`] message. The query recipient makes a
1265 /// best effort to respond based on their local network view which may
1266 /// not be a perfect view of the network. The `short_channel_id`s in the
1267 /// reply are encoded. We only support `encoding_type=0` uncompressed
1268 /// serialization and do not support `encoding_type=1` zlib serialization.
1270 /// [`reply_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1271 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1272 pub struct ReplyChannelRange {
1273 /// The genesis hash of the blockchain being queried
1274 pub chain_hash: ChainHash,
1275 /// The height of the first block in the range of the reply
1276 pub first_blocknum: u32,
1277 /// The number of blocks included in the range of the reply
1278 pub number_of_blocks: u32,
1279 /// True when this is the final reply for a query
1280 pub sync_complete: bool,
1281 /// The `short_channel_id`s in the channel range
1282 pub short_channel_ids: Vec<u64>,
1285 /// A [`query_short_channel_ids`] message is used to query a peer for
1286 /// routing gossip messages related to one or more `short_channel_id`s.
1288 /// The query recipient will reply with the latest, if available,
1289 /// [`ChannelAnnouncement`], [`ChannelUpdate`] and [`NodeAnnouncement`] messages
1290 /// it maintains for the requested `short_channel_id`s followed by a
1291 /// [`ReplyShortChannelIdsEnd`] message. The `short_channel_id`s sent in
1292 /// this query are encoded. We only support `encoding_type=0` uncompressed
1293 /// serialization and do not support `encoding_type=1` zlib serialization.
1295 /// [`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
1296 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1297 pub struct QueryShortChannelIds {
1298 /// The genesis hash of the blockchain being queried
1299 pub chain_hash: ChainHash,
1300 /// The short_channel_ids that are being queried
1301 pub short_channel_ids: Vec<u64>,
1304 /// A [`reply_short_channel_ids_end`] message is sent as a reply to a
1305 /// message. The query recipient makes a best
1306 /// effort to respond based on their local network view which may not be
1307 /// a perfect view of the network.
1309 /// [`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
1310 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1311 pub struct ReplyShortChannelIdsEnd {
1312 /// The genesis hash of the blockchain that was queried
1313 pub chain_hash: ChainHash,
1314 /// Indicates if the query recipient maintains up-to-date channel
1315 /// information for the `chain_hash`
1316 pub full_information: bool,
1319 /// A [`gossip_timestamp_filter`] message is used by a node to request
1320 /// gossip relay for messages in the requested time range when the
1321 /// `gossip_queries` feature has been negotiated.
1323 /// [`gossip_timestamp_filter`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-gossip_timestamp_filter-message
1324 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1325 pub struct GossipTimestampFilter {
1326 /// The genesis hash of the blockchain for channel and node information
1327 pub chain_hash: ChainHash,
1328 /// The starting unix timestamp
1329 pub first_timestamp: u32,
1330 /// The range of information in seconds
1331 pub timestamp_range: u32,
1334 /// Encoding type for data compression of collections in gossip queries.
1336 /// We do not support `encoding_type=1` zlib serialization [defined in BOLT
1337 /// #7](https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#query-messages).
1339 Uncompressed = 0x00,
1342 /// Used to put an error message in a [`LightningError`].
1343 #[derive(Clone, Debug, Hash, PartialEq)]
1344 pub enum ErrorAction {
1345 /// The peer took some action which made us think they were useless. Disconnect them.
1347 /// An error message which we should make an effort to send before we disconnect.
1348 msg: Option<ErrorMessage>
1350 /// The peer did something incorrect. Tell them without closing any channels and disconnect them.
1351 DisconnectPeerWithWarning {
1352 /// A warning message which we should make an effort to send before we disconnect.
1353 msg: WarningMessage,
1355 /// The peer did something harmless that we weren't able to process, just log and ignore
1356 // New code should *not* use this. New code must use IgnoreAndLog, below!
1358 /// The peer did something harmless that we weren't able to meaningfully process.
1359 /// If the error is logged, log it at the given level.
1360 IgnoreAndLog(logger::Level),
1361 /// The peer provided us with a gossip message which we'd already seen. In most cases this
1362 /// should be ignored, but it may result in the message being forwarded if it is a duplicate of
1363 /// our own channel announcements.
1364 IgnoreDuplicateGossip,
1365 /// The peer did something incorrect. Tell them.
1367 /// The message to send.
1370 /// The peer did something incorrect. Tell them without closing any channels.
1371 SendWarningMessage {
1372 /// The message to send.
1373 msg: WarningMessage,
1374 /// The peer may have done something harmless that we weren't able to meaningfully process,
1375 /// though we should still tell them about it.
1376 /// If this event is logged, log it at the given level.
1377 log_level: logger::Level,
1381 /// An Err type for failure to process messages.
1382 #[derive(Clone, Debug)]
1383 pub struct LightningError {
1384 /// A human-readable message describing the error
1386 /// The action which should be taken against the offending peer.
1387 pub action: ErrorAction,
1390 /// Struct used to return values from [`RevokeAndACK`] messages, containing a bunch of commitment
1391 /// transaction updates if they were pending.
1392 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1393 pub struct CommitmentUpdate {
1394 /// `update_add_htlc` messages which should be sent
1395 pub update_add_htlcs: Vec<UpdateAddHTLC>,
1396 /// `update_fulfill_htlc` messages which should be sent
1397 pub update_fulfill_htlcs: Vec<UpdateFulfillHTLC>,
1398 /// `update_fail_htlc` messages which should be sent
1399 pub update_fail_htlcs: Vec<UpdateFailHTLC>,
1400 /// `update_fail_malformed_htlc` messages which should be sent
1401 pub update_fail_malformed_htlcs: Vec<UpdateFailMalformedHTLC>,
1402 /// An `update_fee` message which should be sent
1403 pub update_fee: Option<UpdateFee>,
1404 /// A `commitment_signed` message which should be sent
1405 pub commitment_signed: CommitmentSigned,
1408 /// A trait to describe an object which can receive channel messages.
1410 /// Messages MAY be called in parallel when they originate from different `their_node_ids`, however
1411 /// they MUST NOT be called in parallel when the two calls have the same `their_node_id`.
1412 pub trait ChannelMessageHandler : MessageSendEventsProvider {
1414 /// Handle an incoming `open_channel` message from the given peer.
1415 fn handle_open_channel(&self, their_node_id: &PublicKey, msg: &OpenChannel);
1416 /// Handle an incoming `open_channel2` message from the given peer.
1417 fn handle_open_channel_v2(&self, their_node_id: &PublicKey, msg: &OpenChannelV2);
1418 /// Handle an incoming `accept_channel` message from the given peer.
1419 fn handle_accept_channel(&self, their_node_id: &PublicKey, msg: &AcceptChannel);
1420 /// Handle an incoming `accept_channel2` message from the given peer.
1421 fn handle_accept_channel_v2(&self, their_node_id: &PublicKey, msg: &AcceptChannelV2);
1422 /// Handle an incoming `funding_created` message from the given peer.
1423 fn handle_funding_created(&self, their_node_id: &PublicKey, msg: &FundingCreated);
1424 /// Handle an incoming `funding_signed` message from the given peer.
1425 fn handle_funding_signed(&self, their_node_id: &PublicKey, msg: &FundingSigned);
1426 /// Handle an incoming `channel_ready` message from the given peer.
1427 fn handle_channel_ready(&self, their_node_id: &PublicKey, msg: &ChannelReady);
1430 /// Handle an incoming `shutdown` message from the given peer.
1431 fn handle_shutdown(&self, their_node_id: &PublicKey, msg: &Shutdown);
1432 /// Handle an incoming `closing_signed` message from the given peer.
1433 fn handle_closing_signed(&self, their_node_id: &PublicKey, msg: &ClosingSigned);
1436 /// Handle an incoming `stfu` message from the given peer.
1437 fn handle_stfu(&self, their_node_id: &PublicKey, msg: &Stfu);
1440 /// Handle an incoming `splice` message from the given peer.
1441 fn handle_splice(&self, their_node_id: &PublicKey, msg: &Splice);
1442 /// Handle an incoming `splice_ack` message from the given peer.
1443 fn handle_splice_ack(&self, their_node_id: &PublicKey, msg: &SpliceAck);
1444 /// Handle an incoming `splice_locked` message from the given peer.
1445 fn handle_splice_locked(&self, their_node_id: &PublicKey, msg: &SpliceLocked);
1447 // Interactive channel construction
1448 /// Handle an incoming `tx_add_input message` from the given peer.
1449 fn handle_tx_add_input(&self, their_node_id: &PublicKey, msg: &TxAddInput);
1450 /// Handle an incoming `tx_add_output` message from the given peer.
1451 fn handle_tx_add_output(&self, their_node_id: &PublicKey, msg: &TxAddOutput);
1452 /// Handle an incoming `tx_remove_input` message from the given peer.
1453 fn handle_tx_remove_input(&self, their_node_id: &PublicKey, msg: &TxRemoveInput);
1454 /// Handle an incoming `tx_remove_output` message from the given peer.
1455 fn handle_tx_remove_output(&self, their_node_id: &PublicKey, msg: &TxRemoveOutput);
1456 /// Handle an incoming `tx_complete message` from the given peer.
1457 fn handle_tx_complete(&self, their_node_id: &PublicKey, msg: &TxComplete);
1458 /// Handle an incoming `tx_signatures` message from the given peer.
1459 fn handle_tx_signatures(&self, their_node_id: &PublicKey, msg: &TxSignatures);
1460 /// Handle an incoming `tx_init_rbf` message from the given peer.
1461 fn handle_tx_init_rbf(&self, their_node_id: &PublicKey, msg: &TxInitRbf);
1462 /// Handle an incoming `tx_ack_rbf` message from the given peer.
1463 fn handle_tx_ack_rbf(&self, their_node_id: &PublicKey, msg: &TxAckRbf);
1464 /// Handle an incoming `tx_abort message` from the given peer.
1465 fn handle_tx_abort(&self, their_node_id: &PublicKey, msg: &TxAbort);
1468 /// Handle an incoming `update_add_htlc` message from the given peer.
1469 fn handle_update_add_htlc(&self, their_node_id: &PublicKey, msg: &UpdateAddHTLC);
1470 /// Handle an incoming `update_fulfill_htlc` message from the given peer.
1471 fn handle_update_fulfill_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFulfillHTLC);
1472 /// Handle an incoming `update_fail_htlc` message from the given peer.
1473 fn handle_update_fail_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailHTLC);
1474 /// Handle an incoming `update_fail_malformed_htlc` message from the given peer.
1475 fn handle_update_fail_malformed_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailMalformedHTLC);
1476 /// Handle an incoming `commitment_signed` message from the given peer.
1477 fn handle_commitment_signed(&self, their_node_id: &PublicKey, msg: &CommitmentSigned);
1478 /// Handle an incoming `revoke_and_ack` message from the given peer.
1479 fn handle_revoke_and_ack(&self, their_node_id: &PublicKey, msg: &RevokeAndACK);
1481 /// Handle an incoming `update_fee` message from the given peer.
1482 fn handle_update_fee(&self, their_node_id: &PublicKey, msg: &UpdateFee);
1484 // Channel-to-announce:
1485 /// Handle an incoming `announcement_signatures` message from the given peer.
1486 fn handle_announcement_signatures(&self, their_node_id: &PublicKey, msg: &AnnouncementSignatures);
1488 // Connection loss/reestablish:
1489 /// Indicates a connection to the peer failed/an existing connection was lost.
1490 fn peer_disconnected(&self, their_node_id: &PublicKey);
1492 /// Handle a peer reconnecting, possibly generating `channel_reestablish` message(s).
1494 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1495 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1496 /// message handlers may still wish to communicate with this peer.
1497 fn peer_connected(&self, their_node_id: &PublicKey, msg: &Init, inbound: bool) -> Result<(), ()>;
1498 /// Handle an incoming `channel_reestablish` message from the given peer.
1499 fn handle_channel_reestablish(&self, their_node_id: &PublicKey, msg: &ChannelReestablish);
1501 /// Handle an incoming `channel_update` message from the given peer.
1502 fn handle_channel_update(&self, their_node_id: &PublicKey, msg: &ChannelUpdate);
1505 /// Handle an incoming `error` message from the given peer.
1506 fn handle_error(&self, their_node_id: &PublicKey, msg: &ErrorMessage);
1508 // Handler information:
1509 /// Gets the node feature flags which this handler itself supports. All available handlers are
1510 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1511 /// which are broadcasted in our [`NodeAnnouncement`] message.
1512 fn provided_node_features(&self) -> NodeFeatures;
1514 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1515 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1516 /// which are sent in our [`Init`] message.
1518 /// Note that this method is called before [`Self::peer_connected`].
1519 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1521 /// Gets the chain hashes for this `ChannelMessageHandler` indicating which chains it supports.
1523 /// If it's `None`, then no particular network chain hash compatibility will be enforced when
1524 /// connecting to peers.
1525 fn get_chain_hashes(&self) -> Option<Vec<ChainHash>>;
1528 /// A trait to describe an object which can receive routing messages.
1530 /// # Implementor DoS Warnings
1532 /// For messages enabled with the `gossip_queries` feature there are potential DoS vectors when
1533 /// handling inbound queries. Implementors using an on-disk network graph should be aware of
1534 /// repeated disk I/O for queries accessing different parts of the network graph.
1535 pub trait RoutingMessageHandler : MessageSendEventsProvider {
1536 /// Handle an incoming `node_announcement` message, returning `true` if it should be forwarded on,
1537 /// `false` or returning an `Err` otherwise.
1538 fn handle_node_announcement(&self, msg: &NodeAnnouncement) -> Result<bool, LightningError>;
1539 /// Handle a `channel_announcement` message, returning `true` if it should be forwarded on, `false`
1540 /// or returning an `Err` otherwise.
1541 fn handle_channel_announcement(&self, msg: &ChannelAnnouncement) -> Result<bool, LightningError>;
1542 /// Handle an incoming `channel_update` message, returning true if it should be forwarded on,
1543 /// `false` or returning an `Err` otherwise.
1544 fn handle_channel_update(&self, msg: &ChannelUpdate) -> Result<bool, LightningError>;
1545 /// Gets channel announcements and updates required to dump our routing table to a remote node,
1546 /// starting at the `short_channel_id` indicated by `starting_point` and including announcements
1547 /// for a single channel.
1548 fn get_next_channel_announcement(&self, starting_point: u64) -> Option<(ChannelAnnouncement, Option<ChannelUpdate>, Option<ChannelUpdate>)>;
1549 /// Gets a node announcement required to dump our routing table to a remote node, starting at
1550 /// the node *after* the provided pubkey and including up to one announcement immediately
1551 /// higher (as defined by `<PublicKey as Ord>::cmp`) than `starting_point`.
1552 /// If `None` is provided for `starting_point`, we start at the first node.
1553 fn get_next_node_announcement(&self, starting_point: Option<&NodeId>) -> Option<NodeAnnouncement>;
1554 /// Called when a connection is established with a peer. This can be used to
1555 /// perform routing table synchronization using a strategy defined by the
1558 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1559 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1560 /// message handlers may still wish to communicate with this peer.
1561 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1562 /// Handles the reply of a query we initiated to learn about channels
1563 /// for a given range of blocks. We can expect to receive one or more
1564 /// replies to a single query.
1565 fn handle_reply_channel_range(&self, their_node_id: &PublicKey, msg: ReplyChannelRange) -> Result<(), LightningError>;
1566 /// Handles the reply of a query we initiated asking for routing gossip
1567 /// messages for a list of channels. We should receive this message when
1568 /// a node has completed its best effort to send us the pertaining routing
1569 /// gossip messages.
1570 fn handle_reply_short_channel_ids_end(&self, their_node_id: &PublicKey, msg: ReplyShortChannelIdsEnd) -> Result<(), LightningError>;
1571 /// Handles when a peer asks us to send a list of `short_channel_id`s
1572 /// for the requested range of blocks.
1573 fn handle_query_channel_range(&self, their_node_id: &PublicKey, msg: QueryChannelRange) -> Result<(), LightningError>;
1574 /// Handles when a peer asks us to send routing gossip messages for a
1575 /// list of `short_channel_id`s.
1576 fn handle_query_short_channel_ids(&self, their_node_id: &PublicKey, msg: QueryShortChannelIds) -> Result<(), LightningError>;
1578 // Handler queueing status:
1579 /// Indicates that there are a large number of [`ChannelAnnouncement`] (or other) messages
1580 /// pending some async action. While there is no guarantee of the rate of future messages, the
1581 /// caller should seek to reduce the rate of new gossip messages handled, especially
1582 /// [`ChannelAnnouncement`]s.
1583 fn processing_queue_high(&self) -> bool;
1585 // Handler information:
1586 /// Gets the node feature flags which this handler itself supports. All available handlers are
1587 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1588 /// which are broadcasted in our [`NodeAnnouncement`] message.
1589 fn provided_node_features(&self) -> NodeFeatures;
1590 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1591 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1592 /// which are sent in our [`Init`] message.
1594 /// Note that this method is called before [`Self::peer_connected`].
1595 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1598 /// A handler for received [`OnionMessage`]s and for providing generated ones to send.
1599 pub trait OnionMessageHandler: EventsProvider {
1600 /// Handle an incoming `onion_message` message from the given peer.
1601 fn handle_onion_message(&self, peer_node_id: &PublicKey, msg: &OnionMessage);
1603 /// Returns the next pending onion message for the peer with the given node id.
1604 fn next_onion_message_for_peer(&self, peer_node_id: PublicKey) -> Option<OnionMessage>;
1606 /// Called when a connection is established with a peer. Can be used to track which peers
1607 /// advertise onion message support and are online.
1609 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1610 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1611 /// message handlers may still wish to communicate with this peer.
1612 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1614 /// Indicates a connection to the peer failed/an existing connection was lost. Allows handlers to
1615 /// drop and refuse to forward onion messages to this peer.
1616 fn peer_disconnected(&self, their_node_id: &PublicKey);
1618 /// Performs actions that should happen roughly every ten seconds after startup. Allows handlers
1619 /// to drop any buffered onion messages intended for prospective peers.
1620 fn timer_tick_occurred(&self);
1622 // Handler information:
1623 /// Gets the node feature flags which this handler itself supports. All available handlers are
1624 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1625 /// which are broadcasted in our [`NodeAnnouncement`] message.
1626 fn provided_node_features(&self) -> NodeFeatures;
1628 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1629 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1630 /// which are sent in our [`Init`] message.
1632 /// Note that this method is called before [`Self::peer_connected`].
1633 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1637 #[cfg_attr(test, derive(Debug, PartialEq))]
1638 /// Information communicated in the onion to the recipient for multi-part tracking and proof that
1639 /// the payment is associated with an invoice.
1640 pub struct FinalOnionHopData {
1641 /// When sending a multi-part payment, this secret is used to identify a payment across HTLCs.
1642 /// Because it is generated by the recipient and included in the invoice, it also provides
1643 /// proof to the recipient that the payment was sent by someone with the generated invoice.
1644 pub payment_secret: PaymentSecret,
1645 /// The intended total amount that this payment is for.
1647 /// Message serialization may panic if this value is more than 21 million Bitcoin.
1648 pub total_msat: u64,
1651 mod fuzzy_internal_msgs {
1652 use bitcoin::secp256k1::PublicKey;
1653 use crate::blinded_path::payment::{PaymentConstraints, PaymentRelay};
1654 use crate::prelude::*;
1655 use crate::ln::{PaymentPreimage, PaymentSecret};
1656 use crate::ln::features::BlindedHopFeatures;
1657 use super::FinalOnionHopData;
1659 // These types aren't intended to be pub, but are exposed for direct fuzzing (as we deserialize
1660 // them from untrusted input):
1662 pub enum InboundOnionPayload {
1664 short_channel_id: u64,
1665 /// The value, in msat, of the payment after this hop's fee is deducted.
1666 amt_to_forward: u64,
1667 outgoing_cltv_value: u32,
1670 payment_data: Option<FinalOnionHopData>,
1671 payment_metadata: Option<Vec<u8>>,
1672 keysend_preimage: Option<PaymentPreimage>,
1673 custom_tlvs: Vec<(u64, Vec<u8>)>,
1674 sender_intended_htlc_amt_msat: u64,
1675 cltv_expiry_height: u32,
1678 short_channel_id: u64,
1679 payment_relay: PaymentRelay,
1680 payment_constraints: PaymentConstraints,
1681 features: BlindedHopFeatures,
1682 intro_node_blinding_point: Option<PublicKey>,
1685 sender_intended_htlc_amt_msat: u64,
1687 cltv_expiry_height: u32,
1688 payment_secret: PaymentSecret,
1689 payment_constraints: PaymentConstraints,
1690 intro_node_blinding_point: Option<PublicKey>,
1694 pub(crate) enum OutboundOnionPayload {
1696 short_channel_id: u64,
1697 /// The value, in msat, of the payment after this hop's fee is deducted.
1698 amt_to_forward: u64,
1699 outgoing_cltv_value: u32,
1702 payment_data: Option<FinalOnionHopData>,
1703 payment_metadata: Option<Vec<u8>>,
1704 keysend_preimage: Option<PaymentPreimage>,
1705 custom_tlvs: Vec<(u64, Vec<u8>)>,
1706 sender_intended_htlc_amt_msat: u64,
1707 cltv_expiry_height: u32,
1710 encrypted_tlvs: Vec<u8>,
1711 intro_node_blinding_point: Option<PublicKey>,
1714 sender_intended_htlc_amt_msat: u64,
1716 cltv_expiry_height: u32,
1717 encrypted_tlvs: Vec<u8>,
1718 intro_node_blinding_point: Option<PublicKey>, // Set if the introduction node of the blinded path is the final node
1722 pub struct DecodedOnionErrorPacket {
1723 pub(crate) hmac: [u8; 32],
1724 pub(crate) failuremsg: Vec<u8>,
1725 pub(crate) pad: Vec<u8>,
1729 pub use self::fuzzy_internal_msgs::*;
1730 #[cfg(not(fuzzing))]
1731 pub(crate) use self::fuzzy_internal_msgs::*;
1733 /// BOLT 4 onion packet including hop data for the next peer.
1734 #[derive(Clone, Hash, PartialEq, Eq)]
1735 pub struct OnionPacket {
1736 /// BOLT 4 version number.
1738 /// In order to ensure we always return an error on onion decode in compliance with [BOLT
1739 /// #4](https://github.com/lightning/bolts/blob/master/04-onion-routing.md), we have to
1740 /// deserialize `OnionPacket`s contained in [`UpdateAddHTLC`] messages even if the ephemeral
1741 /// public key (here) is bogus, so we hold a [`Result`] instead of a [`PublicKey`] as we'd
1743 pub public_key: Result<PublicKey, secp256k1::Error>,
1744 /// 1300 bytes encrypted payload for the next hop.
1745 pub hop_data: [u8; 20*65],
1746 /// HMAC to verify the integrity of hop_data.
1750 impl onion_utils::Packet for OnionPacket {
1751 type Data = onion_utils::FixedSizeOnionPacket;
1752 fn new(pubkey: PublicKey, hop_data: onion_utils::FixedSizeOnionPacket, hmac: [u8; 32]) -> Self {
1755 public_key: Ok(pubkey),
1756 hop_data: hop_data.0,
1762 impl fmt::Debug for OnionPacket {
1763 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1764 f.write_fmt(format_args!("OnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
1768 /// BOLT 4 onion packet including hop data for the next peer.
1769 #[derive(Clone, Hash, PartialEq, Eq)]
1770 pub struct TrampolineOnionPacket {
1771 /// Bolt 04 version number
1773 /// A random sepc256k1 point, used to build the ECDH shared secret to decrypt hop_data
1774 pub public_key: PublicKey,
1775 /// Encrypted payload for the next hop
1777 // Unlike the onion packets used for payments, Trampoline onion packets have to be shorter than
1778 // 1300 bytes. The expected default is 650 bytes.
1779 // TODO: if 650 ends up being the most common size, optimize this to be:
1780 // enum { ThirteenHundred([u8; 650]), VarLen(Vec<u8>) }
1781 pub hop_data: Vec<u8>,
1782 /// HMAC to verify the integrity of hop_data
1786 impl onion_utils::Packet for TrampolineOnionPacket {
1787 type Data = Vec<u8>;
1788 fn new(public_key: PublicKey, hop_data: Vec<u8>, hmac: [u8; 32]) -> Self {
1798 impl Writeable for TrampolineOnionPacket {
1799 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1800 self.version.write(w)?;
1801 self.public_key.write(w)?;
1802 w.write_all(&self.hop_data)?;
1803 self.hmac.write(w)?;
1808 impl Debug for TrampolineOnionPacket {
1809 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1810 f.write_fmt(format_args!("TrampolineOnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
1814 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1815 pub(crate) struct OnionErrorPacket {
1816 // This really should be a constant size slice, but the spec lets these things be up to 128KB?
1817 // (TODO) We limit it in decode to much lower...
1818 pub(crate) data: Vec<u8>,
1821 impl fmt::Display for DecodeError {
1822 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1824 DecodeError::UnknownVersion => f.write_str("Unknown realm byte in Onion packet"),
1825 DecodeError::UnknownRequiredFeature => f.write_str("Unknown required feature preventing decode"),
1826 DecodeError::InvalidValue => f.write_str("Nonsense bytes didn't map to the type they were interpreted as"),
1827 DecodeError::ShortRead => f.write_str("Packet extended beyond the provided bytes"),
1828 DecodeError::BadLengthDescriptor => f.write_str("A length descriptor in the packet didn't describe the later data correctly"),
1829 DecodeError::Io(ref e) => fmt::Debug::fmt(e, f),
1830 DecodeError::UnsupportedCompression => f.write_str("We don't support receiving messages with zlib-compressed fields"),
1835 impl From<io::Error> for DecodeError {
1836 fn from(e: io::Error) -> Self {
1837 if e.kind() == io::ErrorKind::UnexpectedEof {
1838 DecodeError::ShortRead
1840 DecodeError::Io(e.kind())
1845 impl Writeable for AcceptChannel {
1846 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1847 self.common_fields.temporary_channel_id.write(w)?;
1848 self.common_fields.dust_limit_satoshis.write(w)?;
1849 self.common_fields.max_htlc_value_in_flight_msat.write(w)?;
1850 self.channel_reserve_satoshis.write(w)?;
1851 self.common_fields.htlc_minimum_msat.write(w)?;
1852 self.common_fields.minimum_depth.write(w)?;
1853 self.common_fields.to_self_delay.write(w)?;
1854 self.common_fields.max_accepted_htlcs.write(w)?;
1855 self.common_fields.funding_pubkey.write(w)?;
1856 self.common_fields.revocation_basepoint.write(w)?;
1857 self.common_fields.payment_basepoint.write(w)?;
1858 self.common_fields.delayed_payment_basepoint.write(w)?;
1859 self.common_fields.htlc_basepoint.write(w)?;
1860 self.common_fields.first_per_commitment_point.write(w)?;
1861 #[cfg(not(taproot))]
1862 encode_tlv_stream!(w, {
1863 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
1864 (1, self.common_fields.channel_type, option),
1867 encode_tlv_stream!(w, {
1868 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
1869 (1, self.common_fields.channel_type, option),
1870 (4, self.next_local_nonce, option),
1876 impl Readable for AcceptChannel {
1877 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1878 let temporary_channel_id: ChannelId = Readable::read(r)?;
1879 let dust_limit_satoshis: u64 = Readable::read(r)?;
1880 let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;
1881 let channel_reserve_satoshis: u64 = Readable::read(r)?;
1882 let htlc_minimum_msat: u64 = Readable::read(r)?;
1883 let minimum_depth: u32 = Readable::read(r)?;
1884 let to_self_delay: u16 = Readable::read(r)?;
1885 let max_accepted_htlcs: u16 = Readable::read(r)?;
1886 let funding_pubkey: PublicKey = Readable::read(r)?;
1887 let revocation_basepoint: PublicKey = Readable::read(r)?;
1888 let payment_basepoint: PublicKey = Readable::read(r)?;
1889 let delayed_payment_basepoint: PublicKey = Readable::read(r)?;
1890 let htlc_basepoint: PublicKey = Readable::read(r)?;
1891 let first_per_commitment_point: PublicKey = Readable::read(r)?;
1893 let mut shutdown_scriptpubkey: Option<ScriptBuf> = None;
1894 let mut channel_type: Option<ChannelTypeFeatures> = None;
1895 #[cfg(not(taproot))]
1896 decode_tlv_stream!(r, {
1897 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
1898 (1, channel_type, option),
1901 let mut next_local_nonce: Option<musig2::types::PublicNonce> = None;
1903 decode_tlv_stream!(r, {
1904 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
1905 (1, channel_type, option),
1906 (4, next_local_nonce, option),
1910 common_fields: CommonAcceptChannelFields {
1911 temporary_channel_id,
1912 dust_limit_satoshis,
1913 max_htlc_value_in_flight_msat,
1919 revocation_basepoint,
1921 delayed_payment_basepoint,
1923 first_per_commitment_point,
1924 shutdown_scriptpubkey,
1927 channel_reserve_satoshis,
1934 impl Writeable for AcceptChannelV2 {
1935 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1936 self.common_fields.temporary_channel_id.write(w)?;
1937 self.funding_satoshis.write(w)?;
1938 self.common_fields.dust_limit_satoshis.write(w)?;
1939 self.common_fields.max_htlc_value_in_flight_msat.write(w)?;
1940 self.common_fields.htlc_minimum_msat.write(w)?;
1941 self.common_fields.minimum_depth.write(w)?;
1942 self.common_fields.to_self_delay.write(w)?;
1943 self.common_fields.max_accepted_htlcs.write(w)?;
1944 self.common_fields.funding_pubkey.write(w)?;
1945 self.common_fields.revocation_basepoint.write(w)?;
1946 self.common_fields.payment_basepoint.write(w)?;
1947 self.common_fields.delayed_payment_basepoint.write(w)?;
1948 self.common_fields.htlc_basepoint.write(w)?;
1949 self.common_fields.first_per_commitment_point.write(w)?;
1950 self.second_per_commitment_point.write(w)?;
1952 encode_tlv_stream!(w, {
1953 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
1954 (1, self.common_fields.channel_type, option),
1955 (2, self.require_confirmed_inputs, option),
1961 impl Readable for AcceptChannelV2 {
1962 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1963 let temporary_channel_id: ChannelId = Readable::read(r)?;
1964 let funding_satoshis: u64 = Readable::read(r)?;
1965 let dust_limit_satoshis: u64 = Readable::read(r)?;
1966 let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;
1967 let htlc_minimum_msat: u64 = Readable::read(r)?;
1968 let minimum_depth: u32 = Readable::read(r)?;
1969 let to_self_delay: u16 = Readable::read(r)?;
1970 let max_accepted_htlcs: u16 = Readable::read(r)?;
1971 let funding_pubkey: PublicKey = Readable::read(r)?;
1972 let revocation_basepoint: PublicKey = Readable::read(r)?;
1973 let payment_basepoint: PublicKey = Readable::read(r)?;
1974 let delayed_payment_basepoint: PublicKey = Readable::read(r)?;
1975 let htlc_basepoint: PublicKey = Readable::read(r)?;
1976 let first_per_commitment_point: PublicKey = Readable::read(r)?;
1977 let second_per_commitment_point: PublicKey = Readable::read(r)?;
1979 let mut shutdown_scriptpubkey: Option<ScriptBuf> = None;
1980 let mut channel_type: Option<ChannelTypeFeatures> = None;
1981 let mut require_confirmed_inputs: Option<()> = None;
1982 decode_tlv_stream!(r, {
1983 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
1984 (1, channel_type, option),
1985 (2, require_confirmed_inputs, option),
1988 Ok(AcceptChannelV2 {
1989 common_fields: CommonAcceptChannelFields {
1990 temporary_channel_id,
1991 dust_limit_satoshis,
1992 max_htlc_value_in_flight_msat,
1998 revocation_basepoint,
2000 delayed_payment_basepoint,
2002 first_per_commitment_point,
2003 shutdown_scriptpubkey,
2007 second_per_commitment_point,
2008 require_confirmed_inputs,
2013 impl_writeable_msg!(Stfu, {
2018 impl_writeable_msg!(Splice, {
2022 funding_feerate_perkw,
2027 impl_writeable_msg!(SpliceAck, {
2034 impl_writeable_msg!(SpliceLocked, {
2038 impl_writeable_msg!(TxAddInput, {
2046 impl_writeable_msg!(TxAddOutput, {
2053 impl_writeable_msg!(TxRemoveInput, {
2058 impl_writeable_msg!(TxRemoveOutput, {
2063 impl_writeable_msg!(TxComplete, {
2067 impl_writeable_msg!(TxSignatures, {
2073 impl_writeable_msg!(TxInitRbf, {
2076 feerate_sat_per_1000_weight,
2078 (0, funding_output_contribution, option),
2081 impl_writeable_msg!(TxAckRbf, {
2084 (0, funding_output_contribution, option),
2087 impl_writeable_msg!(TxAbort, {
2092 impl_writeable_msg!(AnnouncementSignatures, {
2099 impl_writeable_msg!(ChannelReestablish, {
2101 next_local_commitment_number,
2102 next_remote_commitment_number,
2103 your_last_per_commitment_secret,
2104 my_current_per_commitment_point,
2106 (0, next_funding_txid, option),
2109 impl_writeable_msg!(ClosingSigned,
2110 { channel_id, fee_satoshis, signature },
2111 { (1, fee_range, option) }
2114 impl_writeable!(ClosingSignedFeeRange, {
2119 #[cfg(not(taproot))]
2120 impl_writeable_msg!(CommitmentSigned, {
2127 impl_writeable_msg!(CommitmentSigned, {
2132 (2, partial_signature_with_nonce, option)
2135 impl_writeable!(DecodedOnionErrorPacket, {
2141 #[cfg(not(taproot))]
2142 impl_writeable_msg!(FundingCreated, {
2143 temporary_channel_id,
2145 funding_output_index,
2149 impl_writeable_msg!(FundingCreated, {
2150 temporary_channel_id,
2152 funding_output_index,
2155 (2, partial_signature_with_nonce, option),
2156 (4, next_local_nonce, option)
2159 #[cfg(not(taproot))]
2160 impl_writeable_msg!(FundingSigned, {
2166 impl_writeable_msg!(FundingSigned, {
2170 (2, partial_signature_with_nonce, option)
2173 impl_writeable_msg!(ChannelReady, {
2175 next_per_commitment_point,
2177 (1, short_channel_id_alias, option),
2180 impl Writeable for Init {
2181 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2182 // global_features gets the bottom 13 bits of our features, and local_features gets all of
2183 // our relevant feature bits. This keeps us compatible with old nodes.
2184 self.features.write_up_to_13(w)?;
2185 self.features.write(w)?;
2186 encode_tlv_stream!(w, {
2187 (1, self.networks.as_ref().map(|n| WithoutLength(n)), option),
2188 (3, self.remote_network_address, option),
2194 impl Readable for Init {
2195 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2196 let global_features: InitFeatures = Readable::read(r)?;
2197 let features: InitFeatures = Readable::read(r)?;
2198 let mut remote_network_address: Option<SocketAddress> = None;
2199 let mut networks: Option<WithoutLength<Vec<ChainHash>>> = None;
2200 decode_tlv_stream!(r, {
2201 (1, networks, option),
2202 (3, remote_network_address, option)
2205 features: features | global_features,
2206 networks: networks.map(|n| n.0),
2207 remote_network_address,
2212 impl Writeable for OpenChannel {
2213 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2214 self.common_fields.chain_hash.write(w)?;
2215 self.common_fields.temporary_channel_id.write(w)?;
2216 self.common_fields.funding_satoshis.write(w)?;
2217 self.push_msat.write(w)?;
2218 self.common_fields.dust_limit_satoshis.write(w)?;
2219 self.common_fields.max_htlc_value_in_flight_msat.write(w)?;
2220 self.channel_reserve_satoshis.write(w)?;
2221 self.common_fields.htlc_minimum_msat.write(w)?;
2222 self.common_fields.commitment_feerate_sat_per_1000_weight.write(w)?;
2223 self.common_fields.to_self_delay.write(w)?;
2224 self.common_fields.max_accepted_htlcs.write(w)?;
2225 self.common_fields.funding_pubkey.write(w)?;
2226 self.common_fields.revocation_basepoint.write(w)?;
2227 self.common_fields.payment_basepoint.write(w)?;
2228 self.common_fields.delayed_payment_basepoint.write(w)?;
2229 self.common_fields.htlc_basepoint.write(w)?;
2230 self.common_fields.first_per_commitment_point.write(w)?;
2231 self.common_fields.channel_flags.write(w)?;
2232 encode_tlv_stream!(w, {
2233 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
2234 (1, self.common_fields.channel_type, option),
2240 impl Readable for OpenChannel {
2241 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2242 let chain_hash: ChainHash = Readable::read(r)?;
2243 let temporary_channel_id: ChannelId = Readable::read(r)?;
2244 let funding_satoshis: u64 = Readable::read(r)?;
2245 let push_msat: u64 = Readable::read(r)?;
2246 let dust_limit_satoshis: u64 = Readable::read(r)?;
2247 let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;
2248 let channel_reserve_satoshis: u64 = Readable::read(r)?;
2249 let htlc_minimum_msat: u64 = Readable::read(r)?;
2250 let commitment_feerate_sat_per_1000_weight: u32 = Readable::read(r)?;
2251 let to_self_delay: u16 = Readable::read(r)?;
2252 let max_accepted_htlcs: u16 = Readable::read(r)?;
2253 let funding_pubkey: PublicKey = Readable::read(r)?;
2254 let revocation_basepoint: PublicKey = Readable::read(r)?;
2255 let payment_basepoint: PublicKey = Readable::read(r)?;
2256 let delayed_payment_basepoint: PublicKey = Readable::read(r)?;
2257 let htlc_basepoint: PublicKey = Readable::read(r)?;
2258 let first_per_commitment_point: PublicKey = Readable::read(r)?;
2259 let channel_flags: u8 = Readable::read(r)?;
2261 let mut shutdown_scriptpubkey: Option<ScriptBuf> = None;
2262 let mut channel_type: Option<ChannelTypeFeatures> = None;
2263 decode_tlv_stream!(r, {
2264 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
2265 (1, channel_type, option),
2268 common_fields: CommonOpenChannelFields {
2270 temporary_channel_id,
2272 dust_limit_satoshis,
2273 max_htlc_value_in_flight_msat,
2275 commitment_feerate_sat_per_1000_weight,
2279 revocation_basepoint,
2281 delayed_payment_basepoint,
2283 first_per_commitment_point,
2285 shutdown_scriptpubkey,
2289 channel_reserve_satoshis,
2294 impl Writeable for OpenChannelV2 {
2295 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2296 self.common_fields.chain_hash.write(w)?;
2297 self.common_fields.temporary_channel_id.write(w)?;
2298 self.funding_feerate_sat_per_1000_weight.write(w)?;
2299 self.common_fields.commitment_feerate_sat_per_1000_weight.write(w)?;
2300 self.common_fields.funding_satoshis.write(w)?;
2301 self.common_fields.dust_limit_satoshis.write(w)?;
2302 self.common_fields.max_htlc_value_in_flight_msat.write(w)?;
2303 self.common_fields.htlc_minimum_msat.write(w)?;
2304 self.common_fields.to_self_delay.write(w)?;
2305 self.common_fields.max_accepted_htlcs.write(w)?;
2306 self.locktime.write(w)?;
2307 self.common_fields.funding_pubkey.write(w)?;
2308 self.common_fields.revocation_basepoint.write(w)?;
2309 self.common_fields.payment_basepoint.write(w)?;
2310 self.common_fields.delayed_payment_basepoint.write(w)?;
2311 self.common_fields.htlc_basepoint.write(w)?;
2312 self.common_fields.first_per_commitment_point.write(w)?;
2313 self.second_per_commitment_point.write(w)?;
2314 self.common_fields.channel_flags.write(w)?;
2315 encode_tlv_stream!(w, {
2316 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
2317 (1, self.common_fields.channel_type, option),
2318 (2, self.require_confirmed_inputs, option),
2324 impl Readable for OpenChannelV2 {
2325 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2326 let chain_hash: ChainHash = Readable::read(r)?;
2327 let temporary_channel_id: ChannelId = Readable::read(r)?;
2328 let funding_feerate_sat_per_1000_weight: u32 = Readable::read(r)?;
2329 let commitment_feerate_sat_per_1000_weight: u32 = Readable::read(r)?;
2330 let funding_satoshis: u64 = Readable::read(r)?;
2331 let dust_limit_satoshis: u64 = Readable::read(r)?;
2332 let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;
2333 let htlc_minimum_msat: u64 = Readable::read(r)?;
2334 let to_self_delay: u16 = Readable::read(r)?;
2335 let max_accepted_htlcs: u16 = Readable::read(r)?;
2336 let locktime: u32 = Readable::read(r)?;
2337 let funding_pubkey: PublicKey = Readable::read(r)?;
2338 let revocation_basepoint: PublicKey = Readable::read(r)?;
2339 let payment_basepoint: PublicKey = Readable::read(r)?;
2340 let delayed_payment_basepoint: PublicKey = Readable::read(r)?;
2341 let htlc_basepoint: PublicKey = Readable::read(r)?;
2342 let first_per_commitment_point: PublicKey = Readable::read(r)?;
2343 let second_per_commitment_point: PublicKey = Readable::read(r)?;
2344 let channel_flags: u8 = Readable::read(r)?;
2346 let mut shutdown_scriptpubkey: Option<ScriptBuf> = None;
2347 let mut channel_type: Option<ChannelTypeFeatures> = None;
2348 let mut require_confirmed_inputs: Option<()> = None;
2349 decode_tlv_stream!(r, {
2350 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
2351 (1, channel_type, option),
2352 (2, require_confirmed_inputs, option),
2355 common_fields: CommonOpenChannelFields {
2357 temporary_channel_id,
2359 dust_limit_satoshis,
2360 max_htlc_value_in_flight_msat,
2362 commitment_feerate_sat_per_1000_weight,
2366 revocation_basepoint,
2368 delayed_payment_basepoint,
2370 first_per_commitment_point,
2372 shutdown_scriptpubkey,
2375 funding_feerate_sat_per_1000_weight,
2377 second_per_commitment_point,
2378 require_confirmed_inputs,
2383 #[cfg(not(taproot))]
2384 impl_writeable_msg!(RevokeAndACK, {
2386 per_commitment_secret,
2387 next_per_commitment_point
2391 impl_writeable_msg!(RevokeAndACK, {
2393 per_commitment_secret,
2394 next_per_commitment_point
2396 (4, next_local_nonce, option)
2399 impl_writeable_msg!(Shutdown, {
2404 impl_writeable_msg!(UpdateFailHTLC, {
2410 impl_writeable_msg!(UpdateFailMalformedHTLC, {
2417 impl_writeable_msg!(UpdateFee, {
2422 impl_writeable_msg!(UpdateFulfillHTLC, {
2428 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2429 // serialization format in a way which assumes we know the total serialized length/message end
2431 impl_writeable!(OnionErrorPacket, {
2435 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2436 // serialization format in a way which assumes we know the total serialized length/message end
2438 impl Writeable for OnionPacket {
2439 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2440 self.version.write(w)?;
2441 match self.public_key {
2442 Ok(pubkey) => pubkey.write(w)?,
2443 Err(_) => [0u8;33].write(w)?,
2445 w.write_all(&self.hop_data)?;
2446 self.hmac.write(w)?;
2451 impl Readable for OnionPacket {
2452 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2454 version: Readable::read(r)?,
2456 let mut buf = [0u8;33];
2457 r.read_exact(&mut buf)?;
2458 PublicKey::from_slice(&buf)
2460 hop_data: Readable::read(r)?,
2461 hmac: Readable::read(r)?,
2466 impl_writeable_msg!(UpdateAddHTLC, {
2472 onion_routing_packet,
2474 (0, blinding_point, option),
2475 (65537, skimmed_fee_msat, option)
2478 impl Readable for OnionMessage {
2479 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2480 let blinding_point: PublicKey = Readable::read(r)?;
2481 let len: u16 = Readable::read(r)?;
2482 let mut packet_reader = FixedLengthReader::new(r, len as u64);
2483 let onion_routing_packet: onion_message::packet::Packet =
2484 <onion_message::packet::Packet as LengthReadable>::read(&mut packet_reader)?;
2487 onion_routing_packet,
2492 impl Writeable for OnionMessage {
2493 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2494 self.blinding_point.write(w)?;
2495 let onion_packet_len = self.onion_routing_packet.serialized_length();
2496 (onion_packet_len as u16).write(w)?;
2497 self.onion_routing_packet.write(w)?;
2502 impl Writeable for FinalOnionHopData {
2503 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2504 self.payment_secret.0.write(w)?;
2505 HighZeroBytesDroppedBigSize(self.total_msat).write(w)
2509 impl Readable for FinalOnionHopData {
2510 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2511 let secret: [u8; 32] = Readable::read(r)?;
2512 let amt: HighZeroBytesDroppedBigSize<u64> = Readable::read(r)?;
2513 Ok(Self { payment_secret: PaymentSecret(secret), total_msat: amt.0 })
2517 impl Writeable for OutboundOnionPayload {
2518 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2520 Self::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } => {
2521 _encode_varint_length_prefixed_tlv!(w, {
2522 (2, HighZeroBytesDroppedBigSize(*amt_to_forward), required),
2523 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2524 (6, short_channel_id, required)
2528 ref payment_data, ref payment_metadata, ref keysend_preimage, sender_intended_htlc_amt_msat,
2529 cltv_expiry_height, ref custom_tlvs,
2531 // We need to update [`ln::outbound_payment::RecipientOnionFields::with_custom_tlvs`]
2532 // to reject any reserved types in the experimental range if new ones are ever
2534 let keysend_tlv = keysend_preimage.map(|preimage| (5482373484, preimage.encode()));
2535 let mut custom_tlvs: Vec<&(u64, Vec<u8>)> = custom_tlvs.iter().chain(keysend_tlv.iter()).collect();
2536 custom_tlvs.sort_unstable_by_key(|(typ, _)| *typ);
2537 _encode_varint_length_prefixed_tlv!(w, {
2538 (2, HighZeroBytesDroppedBigSize(*sender_intended_htlc_amt_msat), required),
2539 (4, HighZeroBytesDroppedBigSize(*cltv_expiry_height), required),
2540 (8, payment_data, option),
2541 (16, payment_metadata.as_ref().map(|m| WithoutLength(m)), option)
2542 }, custom_tlvs.iter());
2544 Self::BlindedForward { encrypted_tlvs, intro_node_blinding_point } => {
2545 _encode_varint_length_prefixed_tlv!(w, {
2546 (10, *encrypted_tlvs, required_vec),
2547 (12, intro_node_blinding_point, option)
2550 Self::BlindedReceive {
2551 sender_intended_htlc_amt_msat, total_msat, cltv_expiry_height, encrypted_tlvs,
2552 intro_node_blinding_point,
2554 _encode_varint_length_prefixed_tlv!(w, {
2555 (2, HighZeroBytesDroppedBigSize(*sender_intended_htlc_amt_msat), required),
2556 (4, HighZeroBytesDroppedBigSize(*cltv_expiry_height), required),
2557 (10, *encrypted_tlvs, required_vec),
2558 (12, intro_node_blinding_point, option),
2559 (18, HighZeroBytesDroppedBigSize(*total_msat), required)
2567 impl<NS: Deref> ReadableArgs<(Option<PublicKey>, &NS)> for InboundOnionPayload where NS::Target: NodeSigner {
2568 fn read<R: Read>(r: &mut R, args: (Option<PublicKey>, &NS)) -> Result<Self, DecodeError> {
2569 let (update_add_blinding_point, node_signer) = args;
2572 let mut cltv_value = None;
2573 let mut short_id: Option<u64> = None;
2574 let mut payment_data: Option<FinalOnionHopData> = None;
2575 let mut encrypted_tlvs_opt: Option<WithoutLength<Vec<u8>>> = None;
2576 let mut intro_node_blinding_point = None;
2577 let mut payment_metadata: Option<WithoutLength<Vec<u8>>> = None;
2578 let mut total_msat = None;
2579 let mut keysend_preimage: Option<PaymentPreimage> = None;
2580 let mut custom_tlvs = Vec::new();
2582 let tlv_len = BigSize::read(r)?;
2583 let rd = FixedLengthReader::new(r, tlv_len.0);
2584 decode_tlv_stream_with_custom_tlv_decode!(rd, {
2585 (2, amt, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2586 (4, cltv_value, (option, encoding: (u32, HighZeroBytesDroppedBigSize))),
2587 (6, short_id, option),
2588 (8, payment_data, option),
2589 (10, encrypted_tlvs_opt, option),
2590 (12, intro_node_blinding_point, option),
2591 (16, payment_metadata, option),
2592 (18, total_msat, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2593 // See https://github.com/lightning/blips/blob/master/blip-0003.md
2594 (5482373484, keysend_preimage, option)
2595 }, |msg_type: u64, msg_reader: &mut FixedLengthReader<_>| -> Result<bool, DecodeError> {
2596 if msg_type < 1 << 16 { return Ok(false) }
2597 let mut value = Vec::new();
2598 msg_reader.read_to_end(&mut value)?;
2599 custom_tlvs.push((msg_type, value));
2603 if amt.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2604 if intro_node_blinding_point.is_some() && update_add_blinding_point.is_some() {
2605 return Err(DecodeError::InvalidValue)
2608 if let Some(blinding_point) = intro_node_blinding_point.or(update_add_blinding_point) {
2609 if short_id.is_some() || payment_data.is_some() || payment_metadata.is_some() ||
2610 keysend_preimage.is_some()
2612 return Err(DecodeError::InvalidValue)
2614 let enc_tlvs = encrypted_tlvs_opt.ok_or(DecodeError::InvalidValue)?.0;
2615 let enc_tlvs_ss = node_signer.ecdh(Recipient::Node, &blinding_point, None)
2616 .map_err(|_| DecodeError::InvalidValue)?;
2617 let rho = onion_utils::gen_rho_from_shared_secret(&enc_tlvs_ss.secret_bytes());
2618 let mut s = Cursor::new(&enc_tlvs);
2619 let mut reader = FixedLengthReader::new(&mut s, enc_tlvs.len() as u64);
2620 match ChaChaPolyReadAdapter::read(&mut reader, rho)? {
2621 ChaChaPolyReadAdapter { readable: BlindedPaymentTlvs::Forward(ForwardTlvs {
2622 short_channel_id, payment_relay, payment_constraints, features
2624 if amt.is_some() || cltv_value.is_some() || total_msat.is_some() {
2625 return Err(DecodeError::InvalidValue)
2627 Ok(Self::BlindedForward {
2630 payment_constraints,
2632 intro_node_blinding_point,
2635 ChaChaPolyReadAdapter { readable: BlindedPaymentTlvs::Receive(ReceiveTlvs {
2636 payment_secret, payment_constraints
2638 if total_msat.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2639 Ok(Self::BlindedReceive {
2640 sender_intended_htlc_amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2641 total_msat: total_msat.ok_or(DecodeError::InvalidValue)?,
2642 cltv_expiry_height: cltv_value.ok_or(DecodeError::InvalidValue)?,
2644 payment_constraints,
2645 intro_node_blinding_point,
2649 } else if let Some(short_channel_id) = short_id {
2650 if payment_data.is_some() || payment_metadata.is_some() || encrypted_tlvs_opt.is_some() ||
2651 total_msat.is_some()
2652 { return Err(DecodeError::InvalidValue) }
2655 amt_to_forward: amt.ok_or(DecodeError::InvalidValue)?,
2656 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2659 if encrypted_tlvs_opt.is_some() || total_msat.is_some() {
2660 return Err(DecodeError::InvalidValue)
2662 if let Some(data) = &payment_data {
2663 if data.total_msat > MAX_VALUE_MSAT {
2664 return Err(DecodeError::InvalidValue);
2669 payment_metadata: payment_metadata.map(|w| w.0),
2671 sender_intended_htlc_amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2672 cltv_expiry_height: cltv_value.ok_or(DecodeError::InvalidValue)?,
2679 impl Writeable for Ping {
2680 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2681 self.ponglen.write(w)?;
2682 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2687 impl Readable for Ping {
2688 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2690 ponglen: Readable::read(r)?,
2692 let byteslen = Readable::read(r)?;
2693 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2700 impl Writeable for Pong {
2701 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2702 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2707 impl Readable for Pong {
2708 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2711 let byteslen = Readable::read(r)?;
2712 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2719 impl Writeable for UnsignedChannelAnnouncement {
2720 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2721 self.features.write(w)?;
2722 self.chain_hash.write(w)?;
2723 self.short_channel_id.write(w)?;
2724 self.node_id_1.write(w)?;
2725 self.node_id_2.write(w)?;
2726 self.bitcoin_key_1.write(w)?;
2727 self.bitcoin_key_2.write(w)?;
2728 w.write_all(&self.excess_data[..])?;
2733 impl Readable for UnsignedChannelAnnouncement {
2734 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2736 features: Readable::read(r)?,
2737 chain_hash: Readable::read(r)?,
2738 short_channel_id: Readable::read(r)?,
2739 node_id_1: Readable::read(r)?,
2740 node_id_2: Readable::read(r)?,
2741 bitcoin_key_1: Readable::read(r)?,
2742 bitcoin_key_2: Readable::read(r)?,
2743 excess_data: read_to_end(r)?,
2748 impl_writeable!(ChannelAnnouncement, {
2751 bitcoin_signature_1,
2752 bitcoin_signature_2,
2756 impl Writeable for UnsignedChannelUpdate {
2757 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2758 // `message_flags` used to indicate presence of `htlc_maximum_msat`, but was deprecated in the spec.
2759 const MESSAGE_FLAGS: u8 = 1;
2760 self.chain_hash.write(w)?;
2761 self.short_channel_id.write(w)?;
2762 self.timestamp.write(w)?;
2763 let all_flags = self.flags as u16 | ((MESSAGE_FLAGS as u16) << 8);
2764 all_flags.write(w)?;
2765 self.cltv_expiry_delta.write(w)?;
2766 self.htlc_minimum_msat.write(w)?;
2767 self.fee_base_msat.write(w)?;
2768 self.fee_proportional_millionths.write(w)?;
2769 self.htlc_maximum_msat.write(w)?;
2770 w.write_all(&self.excess_data[..])?;
2775 impl Readable for UnsignedChannelUpdate {
2776 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2778 chain_hash: Readable::read(r)?,
2779 short_channel_id: Readable::read(r)?,
2780 timestamp: Readable::read(r)?,
2782 let flags: u16 = Readable::read(r)?;
2783 // Note: we ignore the `message_flags` for now, since it was deprecated by the spec.
2786 cltv_expiry_delta: Readable::read(r)?,
2787 htlc_minimum_msat: Readable::read(r)?,
2788 fee_base_msat: Readable::read(r)?,
2789 fee_proportional_millionths: Readable::read(r)?,
2790 htlc_maximum_msat: Readable::read(r)?,
2791 excess_data: read_to_end(r)?,
2796 impl_writeable!(ChannelUpdate, {
2801 impl Writeable for ErrorMessage {
2802 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2803 self.channel_id.write(w)?;
2804 (self.data.len() as u16).write(w)?;
2805 w.write_all(self.data.as_bytes())?;
2810 impl Readable for ErrorMessage {
2811 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2813 channel_id: Readable::read(r)?,
2815 let sz: usize = <u16 as Readable>::read(r)? as usize;
2816 let mut data = Vec::with_capacity(sz);
2818 r.read_exact(&mut data)?;
2819 match String::from_utf8(data) {
2821 Err(_) => return Err(DecodeError::InvalidValue),
2828 impl Writeable for WarningMessage {
2829 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2830 self.channel_id.write(w)?;
2831 (self.data.len() as u16).write(w)?;
2832 w.write_all(self.data.as_bytes())?;
2837 impl Readable for WarningMessage {
2838 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2840 channel_id: Readable::read(r)?,
2842 let sz: usize = <u16 as Readable>::read(r)? as usize;
2843 let mut data = Vec::with_capacity(sz);
2845 r.read_exact(&mut data)?;
2846 match String::from_utf8(data) {
2848 Err(_) => return Err(DecodeError::InvalidValue),
2855 impl Writeable for UnsignedNodeAnnouncement {
2856 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2857 self.features.write(w)?;
2858 self.timestamp.write(w)?;
2859 self.node_id.write(w)?;
2860 w.write_all(&self.rgb)?;
2861 self.alias.write(w)?;
2863 let mut addr_len = 0;
2864 for addr in self.addresses.iter() {
2865 addr_len += 1 + addr.len();
2867 (addr_len + self.excess_address_data.len() as u16).write(w)?;
2868 for addr in self.addresses.iter() {
2871 w.write_all(&self.excess_address_data[..])?;
2872 w.write_all(&self.excess_data[..])?;
2877 impl Readable for UnsignedNodeAnnouncement {
2878 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2879 let features: NodeFeatures = Readable::read(r)?;
2880 let timestamp: u32 = Readable::read(r)?;
2881 let node_id: NodeId = Readable::read(r)?;
2882 let mut rgb = [0; 3];
2883 r.read_exact(&mut rgb)?;
2884 let alias: NodeAlias = Readable::read(r)?;
2886 let addr_len: u16 = Readable::read(r)?;
2887 let mut addresses: Vec<SocketAddress> = Vec::new();
2888 let mut addr_readpos = 0;
2889 let mut excess = false;
2890 let mut excess_byte = 0;
2892 if addr_len <= addr_readpos { break; }
2893 match Readable::read(r) {
2895 if addr_len < addr_readpos + 1 + addr.len() {
2896 return Err(DecodeError::BadLengthDescriptor);
2898 addr_readpos += (1 + addr.len()) as u16;
2899 addresses.push(addr);
2901 Ok(Err(unknown_descriptor)) => {
2903 excess_byte = unknown_descriptor;
2906 Err(DecodeError::ShortRead) => return Err(DecodeError::BadLengthDescriptor),
2907 Err(e) => return Err(e),
2911 let mut excess_data = vec![];
2912 let excess_address_data = if addr_readpos < addr_len {
2913 let mut excess_address_data = vec![0; (addr_len - addr_readpos) as usize];
2914 r.read_exact(&mut excess_address_data[if excess { 1 } else { 0 }..])?;
2916 excess_address_data[0] = excess_byte;
2921 excess_data.push(excess_byte);
2925 excess_data.extend(read_to_end(r)?.iter());
2926 Ok(UnsignedNodeAnnouncement {
2933 excess_address_data,
2939 impl_writeable!(NodeAnnouncement, {
2944 impl Readable for QueryShortChannelIds {
2945 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2946 let chain_hash: ChainHash = Readable::read(r)?;
2948 let encoding_len: u16 = Readable::read(r)?;
2949 let encoding_type: u8 = Readable::read(r)?;
2951 // Must be encoding_type=0 uncompressed serialization. We do not
2952 // support encoding_type=1 zlib serialization.
2953 if encoding_type != EncodingType::Uncompressed as u8 {
2954 return Err(DecodeError::UnsupportedCompression);
2957 // We expect the encoding_len to always includes the 1-byte
2958 // encoding_type and that short_channel_ids are 8-bytes each
2959 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2960 return Err(DecodeError::InvalidValue);
2963 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2964 // less the 1-byte encoding_type
2965 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2966 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2967 for _ in 0..short_channel_id_count {
2968 short_channel_ids.push(Readable::read(r)?);
2971 Ok(QueryShortChannelIds {
2978 impl Writeable for QueryShortChannelIds {
2979 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2980 // Calculated from 1-byte encoding_type plus 8-bytes per short_channel_id
2981 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2983 self.chain_hash.write(w)?;
2984 encoding_len.write(w)?;
2986 // We only support type=0 uncompressed serialization
2987 (EncodingType::Uncompressed as u8).write(w)?;
2989 for scid in self.short_channel_ids.iter() {
2997 impl_writeable_msg!(ReplyShortChannelIdsEnd, {
3002 impl QueryChannelRange {
3003 /// Calculates the overflow safe ending block height for the query.
3005 /// Overflow returns `0xffffffff`, otherwise returns `first_blocknum + number_of_blocks`.
3006 pub fn end_blocknum(&self) -> u32 {
3007 match self.first_blocknum.checked_add(self.number_of_blocks) {
3008 Some(block) => block,
3009 None => u32::max_value(),
3014 impl_writeable_msg!(QueryChannelRange, {
3020 impl Readable for ReplyChannelRange {
3021 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
3022 let chain_hash: ChainHash = Readable::read(r)?;
3023 let first_blocknum: u32 = Readable::read(r)?;
3024 let number_of_blocks: u32 = Readable::read(r)?;
3025 let sync_complete: bool = Readable::read(r)?;
3027 let encoding_len: u16 = Readable::read(r)?;
3028 let encoding_type: u8 = Readable::read(r)?;
3030 // Must be encoding_type=0 uncompressed serialization. We do not
3031 // support encoding_type=1 zlib serialization.
3032 if encoding_type != EncodingType::Uncompressed as u8 {
3033 return Err(DecodeError::UnsupportedCompression);
3036 // We expect the encoding_len to always includes the 1-byte
3037 // encoding_type and that short_channel_ids are 8-bytes each
3038 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
3039 return Err(DecodeError::InvalidValue);
3042 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
3043 // less the 1-byte encoding_type
3044 let short_channel_id_count: u16 = (encoding_len - 1)/8;
3045 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
3046 for _ in 0..short_channel_id_count {
3047 short_channel_ids.push(Readable::read(r)?);
3050 Ok(ReplyChannelRange {
3060 impl Writeable for ReplyChannelRange {
3061 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
3062 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
3063 self.chain_hash.write(w)?;
3064 self.first_blocknum.write(w)?;
3065 self.number_of_blocks.write(w)?;
3066 self.sync_complete.write(w)?;
3068 encoding_len.write(w)?;
3069 (EncodingType::Uncompressed as u8).write(w)?;
3070 for scid in self.short_channel_ids.iter() {
3078 impl_writeable_msg!(GossipTimestampFilter, {
3086 use std::convert::TryFrom;
3087 use bitcoin::{Transaction, TxIn, ScriptBuf, Sequence, Witness, TxOut};
3088 use hex::DisplayHex;
3089 use crate::ln::{PaymentPreimage, PaymentHash, PaymentSecret};
3090 use crate::ln::ChannelId;
3091 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
3092 use crate::ln::msgs::{self, FinalOnionHopData, OnionErrorPacket, CommonOpenChannelFields, CommonAcceptChannelFields};
3093 use crate::ln::msgs::SocketAddress;
3094 use crate::routing::gossip::{NodeAlias, NodeId};
3095 use crate::util::ser::{Writeable, Readable, ReadableArgs, Hostname, TransactionU16LenLimited};
3096 use crate::util::test_utils;
3098 use bitcoin::hashes::hex::FromHex;
3099 use bitcoin::address::Address;
3100 use bitcoin::network::constants::Network;
3101 use bitcoin::blockdata::constants::ChainHash;
3102 use bitcoin::blockdata::script::Builder;
3103 use bitcoin::blockdata::opcodes;
3104 use bitcoin::hash_types::Txid;
3105 use bitcoin::locktime::absolute::LockTime;
3107 use bitcoin::secp256k1::{PublicKey,SecretKey};
3108 use bitcoin::secp256k1::{Secp256k1, Message};
3110 use crate::io::{self, Cursor};
3111 use crate::prelude::*;
3112 use core::str::FromStr;
3113 use crate::chain::transaction::OutPoint;
3115 #[cfg(feature = "std")]
3116 use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6, ToSocketAddrs};
3117 #[cfg(feature = "std")]
3118 use crate::ln::msgs::SocketAddressParseError;
3121 fn encoding_channel_reestablish() {
3123 let secp_ctx = Secp256k1::new();
3124 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&<Vec<u8>>::from_hex("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
3127 let cr = msgs::ChannelReestablish {
3128 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]),
3129 next_local_commitment_number: 3,
3130 next_remote_commitment_number: 4,
3131 your_last_per_commitment_secret: [9;32],
3132 my_current_per_commitment_point: public_key,
3133 next_funding_txid: None,
3136 let encoded_value = cr.encode();
3140 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
3141 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
3142 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
3143 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
3144 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
3150 fn encoding_channel_reestablish_with_next_funding_txid() {
3152 let secp_ctx = Secp256k1::new();
3153 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&<Vec<u8>>::from_hex("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
3156 let cr = msgs::ChannelReestablish {
3157 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]),
3158 next_local_commitment_number: 3,
3159 next_remote_commitment_number: 4,
3160 your_last_per_commitment_secret: [9;32],
3161 my_current_per_commitment_point: public_key,
3162 next_funding_txid: Some(Txid::from_raw_hash(bitcoin::hashes::Hash::from_slice(&[
3163 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,
3167 let encoded_value = cr.encode();
3171 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
3172 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
3173 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
3174 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
3175 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
3176 0, // Type (next_funding_txid)
3178 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
3183 macro_rules! get_keys_from {
3184 ($slice: expr, $secp_ctx: expr) => {
3186 let privkey = SecretKey::from_slice(&<Vec<u8>>::from_hex($slice).unwrap()[..]).unwrap();
3187 let pubkey = PublicKey::from_secret_key(&$secp_ctx, &privkey);
3193 macro_rules! get_sig_on {
3194 ($privkey: expr, $ctx: expr, $string: expr) => {
3196 let sighash = Message::from_slice(&$string.into_bytes()[..]).unwrap();
3197 $ctx.sign_ecdsa(&sighash, &$privkey)
3203 fn encoding_announcement_signatures() {
3204 let secp_ctx = Secp256k1::new();
3205 let (privkey, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3206 let sig_1 = get_sig_on!(privkey, secp_ctx, String::from("01010101010101010101010101010101"));
3207 let sig_2 = get_sig_on!(privkey, secp_ctx, String::from("02020202020202020202020202020202"));
3208 let announcement_signatures = msgs::AnnouncementSignatures {
3209 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]),
3210 short_channel_id: 2316138423780173,
3211 node_signature: sig_1,
3212 bitcoin_signature: sig_2,
3215 let encoded_value = announcement_signatures.encode();
3216 assert_eq!(encoded_value, <Vec<u8>>::from_hex("040000000000000005000000000000000600000000000000070000000000000000083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073acf9953cef4700860f5967838eba2bae89288ad188ebf8b20bf995c3ea53a26df1876d0a3a0e13172ba286a673140190c02ba9da60a2e43a745188c8a83c7f3ef").unwrap());
3219 fn do_encoding_channel_announcement(unknown_features_bits: bool, excess_data: bool) {
3220 let secp_ctx = Secp256k1::new();
3221 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3222 let (privkey_2, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3223 let (privkey_3, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3224 let (privkey_4, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3225 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3226 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
3227 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
3228 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
3229 let mut features = ChannelFeatures::empty();
3230 if unknown_features_bits {
3231 features = ChannelFeatures::from_le_bytes(vec![0xFF, 0xFF]);
3233 let unsigned_channel_announcement = msgs::UnsignedChannelAnnouncement {
3235 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3236 short_channel_id: 2316138423780173,
3237 node_id_1: NodeId::from_pubkey(&pubkey_1),
3238 node_id_2: NodeId::from_pubkey(&pubkey_2),
3239 bitcoin_key_1: NodeId::from_pubkey(&pubkey_3),
3240 bitcoin_key_2: NodeId::from_pubkey(&pubkey_4),
3241 excess_data: if excess_data { vec![10, 0, 0, 20, 0, 0, 30, 0, 0, 40] } else { Vec::new() },
3243 let channel_announcement = msgs::ChannelAnnouncement {
3244 node_signature_1: sig_1,
3245 node_signature_2: sig_2,
3246 bitcoin_signature_1: sig_3,
3247 bitcoin_signature_2: sig_4,
3248 contents: unsigned_channel_announcement,
3250 let encoded_value = channel_announcement.encode();
3251 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a1735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap();
3252 if unknown_features_bits {
3253 target_value.append(&mut <Vec<u8>>::from_hex("0002ffff").unwrap());
3255 target_value.append(&mut <Vec<u8>>::from_hex("0000").unwrap());
3257 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3258 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
3260 target_value.append(&mut <Vec<u8>>::from_hex("0a00001400001e000028").unwrap());
3262 assert_eq!(encoded_value, target_value);
3266 fn encoding_channel_announcement() {
3267 do_encoding_channel_announcement(true, false);
3268 do_encoding_channel_announcement(false, true);
3269 do_encoding_channel_announcement(false, false);
3270 do_encoding_channel_announcement(true, true);
3273 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) {
3274 let secp_ctx = Secp256k1::new();
3275 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3276 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3277 let features = if unknown_features_bits {
3278 NodeFeatures::from_le_bytes(vec![0xFF, 0xFF])
3280 // Set to some features we may support
3281 NodeFeatures::from_le_bytes(vec![2 | 1 << 5])
3283 let mut addresses = Vec::new();
3285 addresses.push(SocketAddress::TcpIpV4 {
3286 addr: [255, 254, 253, 252],
3291 addresses.push(SocketAddress::TcpIpV6 {
3292 addr: [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240],
3297 addresses.push(msgs::SocketAddress::OnionV2(
3298 [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 38, 7]
3302 addresses.push(msgs::SocketAddress::OnionV3 {
3303 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],
3310 addresses.push(SocketAddress::Hostname {
3311 hostname: Hostname::try_from(String::from("host")).unwrap(),
3315 let mut addr_len = 0;
3316 for addr in &addresses {
3317 addr_len += addr.len() + 1;
3319 let unsigned_node_announcement = msgs::UnsignedNodeAnnouncement {
3321 timestamp: 20190119,
3322 node_id: NodeId::from_pubkey(&pubkey_1),
3324 alias: NodeAlias([16;32]),
3326 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() },
3327 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() },
3329 addr_len += unsigned_node_announcement.excess_address_data.len() as u16;
3330 let node_announcement = msgs::NodeAnnouncement {
3332 contents: unsigned_node_announcement,
3334 let encoded_value = node_announcement.encode();
3335 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3336 if unknown_features_bits {
3337 target_value.append(&mut <Vec<u8>>::from_hex("0002ffff").unwrap());
3339 target_value.append(&mut <Vec<u8>>::from_hex("000122").unwrap());
3341 target_value.append(&mut <Vec<u8>>::from_hex("013413a7031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f2020201010101010101010101010101010101010101010101010101010101010101010").unwrap());
3342 target_value.append(&mut vec![(addr_len >> 8) as u8, addr_len as u8]);
3344 target_value.append(&mut <Vec<u8>>::from_hex("01fffefdfc2607").unwrap());
3347 target_value.append(&mut <Vec<u8>>::from_hex("02fffefdfcfbfaf9f8f7f6f5f4f3f2f1f02607").unwrap());
3350 target_value.append(&mut <Vec<u8>>::from_hex("03fffefdfcfbfaf9f8f7f62607").unwrap());
3353 target_value.append(&mut <Vec<u8>>::from_hex("04fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0efeeedecebeae9e8e7e6e5e4e3e2e1e00020102607").unwrap());
3356 target_value.append(&mut <Vec<u8>>::from_hex("0504686f73742607").unwrap());
3358 if excess_address_data {
3359 target_value.append(&mut <Vec<u8>>::from_hex("216c280b5395a2546e7e4b2663e04f811622f15a4f92e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d269").unwrap());
3362 target_value.append(&mut <Vec<u8>>::from_hex("3b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
3364 assert_eq!(encoded_value, target_value);
3368 fn encoding_node_announcement() {
3369 do_encoding_node_announcement(true, true, true, true, true, true, true, true);
3370 do_encoding_node_announcement(false, false, false, false, false, false, false, false);
3371 do_encoding_node_announcement(false, true, false, false, false, false, false, false);
3372 do_encoding_node_announcement(false, false, true, false, false, false, false, false);
3373 do_encoding_node_announcement(false, false, false, true, false, false, false, false);
3374 do_encoding_node_announcement(false, false, false, false, true, false, false, false);
3375 do_encoding_node_announcement(false, false, false, false, false, true, false, false);
3376 do_encoding_node_announcement(false, false, false, false, false, false, true, false);
3377 do_encoding_node_announcement(false, true, false, true, false, false, true, false);
3378 do_encoding_node_announcement(false, false, true, false, true, false, false, false);
3381 fn do_encoding_channel_update(direction: bool, disable: bool, excess_data: bool) {
3382 let secp_ctx = Secp256k1::new();
3383 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3384 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3385 let unsigned_channel_update = msgs::UnsignedChannelUpdate {
3386 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3387 short_channel_id: 2316138423780173,
3388 timestamp: 20190119,
3389 flags: if direction { 1 } else { 0 } | if disable { 1 << 1 } else { 0 },
3390 cltv_expiry_delta: 144,
3391 htlc_minimum_msat: 1000000,
3392 htlc_maximum_msat: 131355275467161,
3393 fee_base_msat: 10000,
3394 fee_proportional_millionths: 20,
3395 excess_data: if excess_data { vec![0, 0, 0, 0, 59, 154, 202, 0] } else { Vec::new() }
3397 let channel_update = msgs::ChannelUpdate {
3399 contents: unsigned_channel_update
3401 let encoded_value = channel_update.encode();
3402 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3403 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3404 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d013413a7").unwrap());
3405 target_value.append(&mut <Vec<u8>>::from_hex("01").unwrap());
3406 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3408 let flag = target_value.last_mut().unwrap();
3412 let flag = target_value.last_mut().unwrap();
3413 *flag = *flag | 1 << 1;
3415 target_value.append(&mut <Vec<u8>>::from_hex("009000000000000f42400000271000000014").unwrap());
3416 target_value.append(&mut <Vec<u8>>::from_hex("0000777788889999").unwrap());
3418 target_value.append(&mut <Vec<u8>>::from_hex("000000003b9aca00").unwrap());
3420 assert_eq!(encoded_value, target_value);
3424 fn encoding_channel_update() {
3425 do_encoding_channel_update(false, false, false);
3426 do_encoding_channel_update(false, false, true);
3427 do_encoding_channel_update(true, false, false);
3428 do_encoding_channel_update(true, false, true);
3429 do_encoding_channel_update(false, true, false);
3430 do_encoding_channel_update(false, true, true);
3431 do_encoding_channel_update(true, true, false);
3432 do_encoding_channel_update(true, true, true);
3435 fn do_encoding_open_channel(random_bit: bool, shutdown: bool, incl_chan_type: bool) {
3436 let secp_ctx = Secp256k1::new();
3437 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3438 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3439 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3440 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3441 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3442 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3443 let open_channel = msgs::OpenChannel {
3444 common_fields: CommonOpenChannelFields {
3445 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3446 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3447 funding_satoshis: 1311768467284833366,
3448 dust_limit_satoshis: 3608586615801332854,
3449 max_htlc_value_in_flight_msat: 8517154655701053848,
3450 htlc_minimum_msat: 2316138423780173,
3451 commitment_feerate_sat_per_1000_weight: 821716,
3452 to_self_delay: 49340,
3453 max_accepted_htlcs: 49340,
3454 funding_pubkey: pubkey_1,
3455 revocation_basepoint: pubkey_2,
3456 payment_basepoint: pubkey_3,
3457 delayed_payment_basepoint: pubkey_4,
3458 htlc_basepoint: pubkey_5,
3459 first_per_commitment_point: pubkey_6,
3460 channel_flags: if random_bit { 1 << 5 } else { 0 },
3461 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3462 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3464 push_msat: 2536655962884945560,
3465 channel_reserve_satoshis: 8665828695742877976,
3467 let encoded_value = open_channel.encode();
3468 let mut target_value = Vec::new();
3469 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3470 target_value.append(&mut <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202021234567890123456233403289122369832144668701144767633030896203198784335490624111800083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3472 target_value.append(&mut <Vec<u8>>::from_hex("20").unwrap());
3474 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3477 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3480 target_value.append(&mut <Vec<u8>>::from_hex("0100").unwrap());
3482 assert_eq!(encoded_value, target_value);
3486 fn encoding_open_channel() {
3487 do_encoding_open_channel(false, false, false);
3488 do_encoding_open_channel(false, false, true);
3489 do_encoding_open_channel(false, true, false);
3490 do_encoding_open_channel(false, true, true);
3491 do_encoding_open_channel(true, false, false);
3492 do_encoding_open_channel(true, false, true);
3493 do_encoding_open_channel(true, true, false);
3494 do_encoding_open_channel(true, true, true);
3497 fn do_encoding_open_channelv2(random_bit: bool, shutdown: bool, incl_chan_type: bool, require_confirmed_inputs: bool) {
3498 let secp_ctx = Secp256k1::new();
3499 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3500 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3501 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3502 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3503 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3504 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3505 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3506 let open_channelv2 = msgs::OpenChannelV2 {
3507 common_fields: CommonOpenChannelFields {
3508 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3509 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3510 commitment_feerate_sat_per_1000_weight: 821716,
3511 funding_satoshis: 1311768467284833366,
3512 dust_limit_satoshis: 3608586615801332854,
3513 max_htlc_value_in_flight_msat: 8517154655701053848,
3514 htlc_minimum_msat: 2316138423780173,
3515 to_self_delay: 49340,
3516 max_accepted_htlcs: 49340,
3517 funding_pubkey: pubkey_1,
3518 revocation_basepoint: pubkey_2,
3519 payment_basepoint: pubkey_3,
3520 delayed_payment_basepoint: pubkey_4,
3521 htlc_basepoint: pubkey_5,
3522 first_per_commitment_point: pubkey_6,
3523 channel_flags: if random_bit { 1 << 5 } else { 0 },
3524 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3525 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3527 funding_feerate_sat_per_1000_weight: 821716,
3528 locktime: 305419896,
3529 second_per_commitment_point: pubkey_7,
3530 require_confirmed_inputs: if require_confirmed_inputs { Some(()) } else { None },
3532 let encoded_value = open_channelv2.encode();
3533 let mut target_value = Vec::new();
3534 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3535 target_value.append(&mut <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap());
3536 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap());
3537 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap());
3538 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap());
3539 target_value.append(&mut <Vec<u8>>::from_hex("3214466870114476").unwrap());
3540 target_value.append(&mut <Vec<u8>>::from_hex("7633030896203198").unwrap());
3541 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d").unwrap());
3542 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap());
3543 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap());
3544 target_value.append(&mut <Vec<u8>>::from_hex("12345678").unwrap());
3545 target_value.append(&mut <Vec<u8>>::from_hex("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap());
3546 target_value.append(&mut <Vec<u8>>::from_hex("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap());
3547 target_value.append(&mut <Vec<u8>>::from_hex("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap());
3548 target_value.append(&mut <Vec<u8>>::from_hex("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
3549 target_value.append(&mut <Vec<u8>>::from_hex("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap());
3550 target_value.append(&mut <Vec<u8>>::from_hex("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3551 target_value.append(&mut <Vec<u8>>::from_hex("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap());
3554 target_value.append(&mut <Vec<u8>>::from_hex("20").unwrap());
3556 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3559 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3562 target_value.append(&mut <Vec<u8>>::from_hex("0100").unwrap());
3564 if require_confirmed_inputs {
3565 target_value.append(&mut <Vec<u8>>::from_hex("0200").unwrap());
3567 assert_eq!(encoded_value, target_value);
3571 fn encoding_open_channelv2() {
3572 do_encoding_open_channelv2(false, false, false, false);
3573 do_encoding_open_channelv2(false, false, false, true);
3574 do_encoding_open_channelv2(false, false, true, false);
3575 do_encoding_open_channelv2(false, false, true, true);
3576 do_encoding_open_channelv2(false, true, false, false);
3577 do_encoding_open_channelv2(false, true, false, true);
3578 do_encoding_open_channelv2(false, true, true, false);
3579 do_encoding_open_channelv2(false, true, true, true);
3580 do_encoding_open_channelv2(true, false, false, false);
3581 do_encoding_open_channelv2(true, false, false, true);
3582 do_encoding_open_channelv2(true, false, true, false);
3583 do_encoding_open_channelv2(true, false, true, true);
3584 do_encoding_open_channelv2(true, true, false, false);
3585 do_encoding_open_channelv2(true, true, false, true);
3586 do_encoding_open_channelv2(true, true, true, false);
3587 do_encoding_open_channelv2(true, true, true, true);
3590 fn do_encoding_accept_channel(shutdown: bool) {
3591 let secp_ctx = Secp256k1::new();
3592 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3593 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3594 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3595 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3596 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3597 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3598 let accept_channel = msgs::AcceptChannel {
3599 common_fields: CommonAcceptChannelFields {
3600 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3601 dust_limit_satoshis: 1311768467284833366,
3602 max_htlc_value_in_flight_msat: 2536655962884945560,
3603 htlc_minimum_msat: 2316138423780173,
3604 minimum_depth: 821716,
3605 to_self_delay: 49340,
3606 max_accepted_htlcs: 49340,
3607 funding_pubkey: pubkey_1,
3608 revocation_basepoint: pubkey_2,
3609 payment_basepoint: pubkey_3,
3610 delayed_payment_basepoint: pubkey_4,
3611 htlc_basepoint: pubkey_5,
3612 first_per_commitment_point: pubkey_6,
3613 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3616 channel_reserve_satoshis: 3608586615801332854,
3618 next_local_nonce: None,
3620 let encoded_value = accept_channel.encode();
3621 let mut target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020212345678901234562334032891223698321446687011447600083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap();
3623 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3625 assert_eq!(encoded_value, target_value);
3629 fn encoding_accept_channel() {
3630 do_encoding_accept_channel(false);
3631 do_encoding_accept_channel(true);
3634 fn do_encoding_accept_channelv2(shutdown: bool) {
3635 let secp_ctx = Secp256k1::new();
3636 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3637 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3638 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3639 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3640 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3641 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3642 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3643 let accept_channelv2 = msgs::AcceptChannelV2 {
3644 common_fields: CommonAcceptChannelFields {
3645 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3646 dust_limit_satoshis: 1311768467284833366,
3647 max_htlc_value_in_flight_msat: 2536655962884945560,
3648 htlc_minimum_msat: 2316138423780173,
3649 minimum_depth: 821716,
3650 to_self_delay: 49340,
3651 max_accepted_htlcs: 49340,
3652 funding_pubkey: pubkey_1,
3653 revocation_basepoint: pubkey_2,
3654 payment_basepoint: pubkey_3,
3655 delayed_payment_basepoint: pubkey_4,
3656 htlc_basepoint: pubkey_5,
3657 first_per_commitment_point: pubkey_6,
3658 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3661 funding_satoshis: 1311768467284833366,
3662 second_per_commitment_point: pubkey_7,
3663 require_confirmed_inputs: None,
3665 let encoded_value = accept_channelv2.encode();
3666 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // temporary_channel_id
3667 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap()); // funding_satoshis
3668 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap()); // dust_limit_satoshis
3669 target_value.append(&mut <Vec<u8>>::from_hex("2334032891223698").unwrap()); // max_htlc_value_in_flight_msat
3670 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d").unwrap()); // htlc_minimum_msat
3671 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap()); // minimum_depth
3672 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap()); // to_self_delay
3673 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap()); // max_accepted_htlcs
3674 target_value.append(&mut <Vec<u8>>::from_hex("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap()); // funding_pubkey
3675 target_value.append(&mut <Vec<u8>>::from_hex("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap()); // revocation_basepoint
3676 target_value.append(&mut <Vec<u8>>::from_hex("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap()); // payment_basepoint
3677 target_value.append(&mut <Vec<u8>>::from_hex("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap()); // delayed_payment_basepoint
3678 target_value.append(&mut <Vec<u8>>::from_hex("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap()); // htlc_basepoint
3679 target_value.append(&mut <Vec<u8>>::from_hex("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap()); // first_per_commitment_point
3680 target_value.append(&mut <Vec<u8>>::from_hex("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap()); // second_per_commitment_point
3682 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3684 assert_eq!(encoded_value, target_value);
3688 fn encoding_accept_channelv2() {
3689 do_encoding_accept_channelv2(false);
3690 do_encoding_accept_channelv2(true);
3694 fn encoding_funding_created() {
3695 let secp_ctx = Secp256k1::new();
3696 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3697 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3698 let funding_created = msgs::FundingCreated {
3699 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3700 funding_txid: Txid::from_str("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3701 funding_output_index: 255,
3704 partial_signature_with_nonce: None,
3706 next_local_nonce: None,
3708 let encoded_value = funding_created.encode();
3709 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202026e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c200ffd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3710 assert_eq!(encoded_value, target_value);
3714 fn encoding_funding_signed() {
3715 let secp_ctx = Secp256k1::new();
3716 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3717 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3718 let funding_signed = msgs::FundingSigned {
3719 channel_id: ChannelId::from_bytes([2; 32]),
3722 partial_signature_with_nonce: None,
3724 let encoded_value = funding_signed.encode();
3725 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3726 assert_eq!(encoded_value, target_value);
3730 fn encoding_channel_ready() {
3731 let secp_ctx = Secp256k1::new();
3732 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3733 let channel_ready = msgs::ChannelReady {
3734 channel_id: ChannelId::from_bytes([2; 32]),
3735 next_per_commitment_point: pubkey_1,
3736 short_channel_id_alias: None,
3738 let encoded_value = channel_ready.encode();
3739 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3740 assert_eq!(encoded_value, target_value);
3744 fn encoding_splice() {
3745 let secp_ctx = Secp256k1::new();
3746 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3747 let splice = msgs::Splice {
3748 chain_hash: ChainHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
3749 channel_id: ChannelId::from_bytes([2; 32]),
3750 relative_satoshis: 123456,
3751 funding_feerate_perkw: 2000,
3753 funding_pubkey: pubkey_1,
3755 let encoded_value = splice.encode();
3756 assert_eq!(encoded_value.as_hex().to_string(), "02020202020202020202020202020202020202020202020202020202020202026fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000000000000001e240000007d000000000031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f");
3760 fn encoding_stfu() {
3761 let stfu = msgs::Stfu {
3762 channel_id: ChannelId::from_bytes([2; 32]),
3765 let encoded_value = stfu.encode();
3766 assert_eq!(encoded_value.as_hex().to_string(), "020202020202020202020202020202020202020202020202020202020202020201");
3770 fn encoding_splice_ack() {
3771 let secp_ctx = Secp256k1::new();
3772 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3773 let splice = msgs::SpliceAck {
3774 chain_hash: ChainHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
3775 channel_id: ChannelId::from_bytes([2; 32]),
3776 relative_satoshis: 123456,
3777 funding_pubkey: pubkey_1,
3779 let encoded_value = splice.encode();
3780 assert_eq!(encoded_value.as_hex().to_string(), "02020202020202020202020202020202020202020202020202020202020202026fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000000000000001e240031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f");
3784 fn encoding_splice_locked() {
3785 let splice = msgs::SpliceLocked {
3786 channel_id: ChannelId::from_bytes([2; 32]),
3788 let encoded_value = splice.encode();
3789 assert_eq!(encoded_value.as_hex().to_string(), "0202020202020202020202020202020202020202020202020202020202020202");
3793 fn encoding_tx_add_input() {
3794 let tx_add_input = msgs::TxAddInput {
3795 channel_id: ChannelId::from_bytes([2; 32]),
3796 serial_id: 4886718345,
3797 prevtx: TransactionU16LenLimited::new(Transaction {
3799 lock_time: LockTime::ZERO,
3801 previous_output: OutPoint { txid: Txid::from_str("305bab643ee297b8b6b76b320792c8223d55082122cb606bf89382146ced9c77").unwrap(), index: 2 }.into_bitcoin_outpoint(),
3802 script_sig: ScriptBuf::new(),
3803 sequence: Sequence(0xfffffffd),
3804 witness: Witness::from_slice(&vec![
3805 <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3806 <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3811 script_pubkey: Address::from_str("bc1qzlffunw52jav8vwdu5x3jfk6sr8u22rmq3xzw2").unwrap().payload.script_pubkey(),
3815 script_pubkey: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().payload.script_pubkey(),
3819 prevtx_out: 305419896,
3820 sequence: 305419896,
3822 let encoded_value = tx_add_input.encode();
3823 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000000012345678900de02000000000101779ced6c148293f86b60cb222108553d22c89207326bb7b6b897e23e64ab5b300200000000fdffffff0236dbc1000000000016001417d29e4dd454bac3b1cde50d1926da80cfc5287b9cbd03000000000016001436ec78d514df462da95e6a00c24daa8915362d420247304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701210301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944000000001234567812345678").unwrap();
3824 assert_eq!(encoded_value, target_value);
3828 fn encoding_tx_add_output() {
3829 let tx_add_output = msgs::TxAddOutput {
3830 channel_id: ChannelId::from_bytes([2; 32]),
3831 serial_id: 4886718345,
3833 script: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().payload.script_pubkey(),
3835 let encoded_value = tx_add_output.encode();
3836 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000000012345678900000001234567890016001436ec78d514df462da95e6a00c24daa8915362d42").unwrap();
3837 assert_eq!(encoded_value, target_value);
3841 fn encoding_tx_remove_input() {
3842 let tx_remove_input = msgs::TxRemoveInput {
3843 channel_id: ChannelId::from_bytes([2; 32]),
3844 serial_id: 4886718345,
3846 let encoded_value = tx_remove_input.encode();
3847 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3848 assert_eq!(encoded_value, target_value);
3852 fn encoding_tx_remove_output() {
3853 let tx_remove_output = msgs::TxRemoveOutput {
3854 channel_id: ChannelId::from_bytes([2; 32]),
3855 serial_id: 4886718345,
3857 let encoded_value = tx_remove_output.encode();
3858 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3859 assert_eq!(encoded_value, target_value);
3863 fn encoding_tx_complete() {
3864 let tx_complete = msgs::TxComplete {
3865 channel_id: ChannelId::from_bytes([2; 32]),
3867 let encoded_value = tx_complete.encode();
3868 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3869 assert_eq!(encoded_value, target_value);
3873 fn encoding_tx_signatures() {
3874 let tx_signatures = msgs::TxSignatures {
3875 channel_id: ChannelId::from_bytes([2; 32]),
3876 tx_hash: Txid::from_str("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3878 Witness::from_slice(&vec![
3879 <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3880 <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3881 Witness::from_slice(&vec![
3882 <Vec<u8>>::from_hex("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap(),
3883 <Vec<u8>>::from_hex("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap()]),
3886 let encoded_value = tx_signatures.encode();
3887 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3888 target_value.append(&mut <Vec<u8>>::from_hex("6e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c2").unwrap()); // tx_hash (sha256) (big endian byte order)
3889 target_value.append(&mut <Vec<u8>>::from_hex("0002").unwrap()); // num_witnesses (u16)
3891 target_value.append(&mut <Vec<u8>>::from_hex("006b").unwrap()); // len of witness_data
3892 target_value.append(&mut <Vec<u8>>::from_hex("02").unwrap()); // num_witness_elements (VarInt)
3893 target_value.append(&mut <Vec<u8>>::from_hex("47").unwrap()); // len of witness element data (VarInt)
3894 target_value.append(&mut <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap());
3895 target_value.append(&mut <Vec<u8>>::from_hex("21").unwrap()); // len of witness element data (VarInt)
3896 target_value.append(&mut <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap());
3898 target_value.append(&mut <Vec<u8>>::from_hex("006c").unwrap()); // len of witness_data
3899 target_value.append(&mut <Vec<u8>>::from_hex("02").unwrap()); // num_witness_elements (VarInt)
3900 target_value.append(&mut <Vec<u8>>::from_hex("48").unwrap()); // len of witness element data (VarInt)
3901 target_value.append(&mut <Vec<u8>>::from_hex("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap());
3902 target_value.append(&mut <Vec<u8>>::from_hex("21").unwrap()); // len of witness element data (VarInt)
3903 target_value.append(&mut <Vec<u8>>::from_hex("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap());
3904 assert_eq!(encoded_value, target_value);
3907 fn do_encoding_tx_init_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3908 let tx_init_rbf = msgs::TxInitRbf {
3909 channel_id: ChannelId::from_bytes([2; 32]),
3910 locktime: 305419896,
3911 feerate_sat_per_1000_weight: 20190119,
3912 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3914 let encoded_value = tx_init_rbf.encode();
3915 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3916 target_value.append(&mut <Vec<u8>>::from_hex("12345678").unwrap()); // locktime
3917 target_value.append(&mut <Vec<u8>>::from_hex("013413a7").unwrap()); // feerate_sat_per_1000_weight
3918 if let Some((_, target)) = funding_value_with_hex_target {
3919 target_value.push(0x00); // Type
3920 target_value.push(target.len() as u8 / 2); // Length
3921 target_value.append(&mut <Vec<u8>>::from_hex(target).unwrap()); // Value (i64)
3923 assert_eq!(encoded_value, target_value);
3927 fn encoding_tx_init_rbf() {
3928 do_encoding_tx_init_rbf(Some((1311768467284833366, "1234567890123456")));
3929 do_encoding_tx_init_rbf(Some((13117684672, "000000030DDFFBC0")));
3930 do_encoding_tx_init_rbf(None);
3933 fn do_encoding_tx_ack_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3934 let tx_ack_rbf = msgs::TxAckRbf {
3935 channel_id: ChannelId::from_bytes([2; 32]),
3936 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3938 let encoded_value = tx_ack_rbf.encode();
3939 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3940 if let Some((_, target)) = funding_value_with_hex_target {
3941 target_value.push(0x00); // Type
3942 target_value.push(target.len() as u8 / 2); // Length
3943 target_value.append(&mut <Vec<u8>>::from_hex(target).unwrap()); // Value (i64)
3945 assert_eq!(encoded_value, target_value);
3949 fn encoding_tx_ack_rbf() {
3950 do_encoding_tx_ack_rbf(Some((1311768467284833366, "1234567890123456")));
3951 do_encoding_tx_ack_rbf(Some((13117684672, "000000030DDFFBC0")));
3952 do_encoding_tx_ack_rbf(None);
3956 fn encoding_tx_abort() {
3957 let tx_abort = msgs::TxAbort {
3958 channel_id: ChannelId::from_bytes([2; 32]),
3959 data: <Vec<u8>>::from_hex("54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap(),
3961 let encoded_value = tx_abort.encode();
3962 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202002C54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap();
3963 assert_eq!(encoded_value, target_value);
3966 fn do_encoding_shutdown(script_type: u8) {
3967 let secp_ctx = Secp256k1::new();
3968 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3969 let script = Builder::new().push_opcode(opcodes::OP_TRUE).into_script();
3970 let shutdown = msgs::Shutdown {
3971 channel_id: ChannelId::from_bytes([2; 32]),
3973 if script_type == 1 { Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey() }
3974 else if script_type == 2 { Address::p2sh(&script, Network::Testnet).unwrap().script_pubkey() }
3975 else if script_type == 3 { Address::p2wpkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).unwrap().script_pubkey() }
3976 else { Address::p2wsh(&script, Network::Testnet).script_pubkey() },
3978 let encoded_value = shutdown.encode();
3979 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3980 if script_type == 1 {
3981 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3982 } else if script_type == 2 {
3983 target_value.append(&mut <Vec<u8>>::from_hex("0017a914da1745e9b549bd0bfa1a569971c77eba30cd5a4b87").unwrap());
3984 } else if script_type == 3 {
3985 target_value.append(&mut <Vec<u8>>::from_hex("0016001479b000887626b294a914501a4cd226b58b235983").unwrap());
3986 } else if script_type == 4 {
3987 target_value.append(&mut <Vec<u8>>::from_hex("002200204ae81572f06e1b88fd5ced7a1a000945432e83e1551e6f721ee9c00b8cc33260").unwrap());
3989 assert_eq!(encoded_value, target_value);
3993 fn encoding_shutdown() {
3994 do_encoding_shutdown(1);
3995 do_encoding_shutdown(2);
3996 do_encoding_shutdown(3);
3997 do_encoding_shutdown(4);
4001 fn encoding_closing_signed() {
4002 let secp_ctx = Secp256k1::new();
4003 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4004 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
4005 let closing_signed = msgs::ClosingSigned {
4006 channel_id: ChannelId::from_bytes([2; 32]),
4007 fee_satoshis: 2316138423780173,
4011 let encoded_value = closing_signed.encode();
4012 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
4013 assert_eq!(encoded_value, target_value);
4014 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value)).unwrap(), closing_signed);
4016 let closing_signed_with_range = msgs::ClosingSigned {
4017 channel_id: ChannelId::from_bytes([2; 32]),
4018 fee_satoshis: 2316138423780173,
4020 fee_range: Some(msgs::ClosingSignedFeeRange {
4021 min_fee_satoshis: 0xdeadbeef,
4022 max_fee_satoshis: 0x1badcafe01234567,
4025 let encoded_value_with_range = closing_signed_with_range.encode();
4026 let target_value_with_range = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a011000000000deadbeef1badcafe01234567").unwrap();
4027 assert_eq!(encoded_value_with_range, target_value_with_range);
4028 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value_with_range)).unwrap(),
4029 closing_signed_with_range);
4033 fn encoding_update_add_htlc() {
4034 let secp_ctx = Secp256k1::new();
4035 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4036 let onion_routing_packet = msgs::OnionPacket {
4038 public_key: Ok(pubkey_1),
4039 hop_data: [1; 20*65],
4042 let update_add_htlc = msgs::UpdateAddHTLC {
4043 channel_id: ChannelId::from_bytes([2; 32]),
4044 htlc_id: 2316138423780173,
4045 amount_msat: 3608586615801332854,
4046 payment_hash: PaymentHash([1; 32]),
4047 cltv_expiry: 821716,
4048 onion_routing_packet,
4049 skimmed_fee_msat: None,
4050 blinding_point: None,
4052 let encoded_value = update_add_htlc.encode();
4053 let target_value = <Vec<u8>>::from_hex("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").unwrap();
4054 assert_eq!(encoded_value, target_value);
4058 fn encoding_update_fulfill_htlc() {
4059 let update_fulfill_htlc = msgs::UpdateFulfillHTLC {
4060 channel_id: ChannelId::from_bytes([2; 32]),
4061 htlc_id: 2316138423780173,
4062 payment_preimage: PaymentPreimage([1; 32]),
4064 let encoded_value = update_fulfill_htlc.encode();
4065 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d0101010101010101010101010101010101010101010101010101010101010101").unwrap();
4066 assert_eq!(encoded_value, target_value);
4070 fn encoding_update_fail_htlc() {
4071 let reason = OnionErrorPacket {
4072 data: [1; 32].to_vec(),
4074 let update_fail_htlc = msgs::UpdateFailHTLC {
4075 channel_id: ChannelId::from_bytes([2; 32]),
4076 htlc_id: 2316138423780173,
4079 let encoded_value = update_fail_htlc.encode();
4080 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d00200101010101010101010101010101010101010101010101010101010101010101").unwrap();
4081 assert_eq!(encoded_value, target_value);
4085 fn encoding_update_fail_malformed_htlc() {
4086 let update_fail_malformed_htlc = msgs::UpdateFailMalformedHTLC {
4087 channel_id: ChannelId::from_bytes([2; 32]),
4088 htlc_id: 2316138423780173,
4089 sha256_of_onion: [1; 32],
4092 let encoded_value = update_fail_malformed_htlc.encode();
4093 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d010101010101010101010101010101010101010101010101010101010101010100ff").unwrap();
4094 assert_eq!(encoded_value, target_value);
4097 fn do_encoding_commitment_signed(htlcs: bool) {
4098 let secp_ctx = Secp256k1::new();
4099 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4100 let (privkey_2, _) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
4101 let (privkey_3, _) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
4102 let (privkey_4, _) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
4103 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
4104 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
4105 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
4106 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
4107 let commitment_signed = msgs::CommitmentSigned {
4108 channel_id: ChannelId::from_bytes([2; 32]),
4110 htlc_signatures: if htlcs { vec![sig_2, sig_3, sig_4] } else { Vec::new() },
4112 partial_signature_with_nonce: None,
4114 let encoded_value = commitment_signed.encode();
4115 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
4117 target_value.append(&mut <Vec<u8>>::from_hex("00031735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
4119 target_value.append(&mut <Vec<u8>>::from_hex("0000").unwrap());
4121 assert_eq!(encoded_value, target_value);
4125 fn encoding_commitment_signed() {
4126 do_encoding_commitment_signed(true);
4127 do_encoding_commitment_signed(false);
4131 fn encoding_revoke_and_ack() {
4132 let secp_ctx = Secp256k1::new();
4133 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4134 let raa = msgs::RevokeAndACK {
4135 channel_id: ChannelId::from_bytes([2; 32]),
4136 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],
4137 next_per_commitment_point: pubkey_1,
4139 next_local_nonce: None,
4141 let encoded_value = raa.encode();
4142 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020101010101010101010101010101010101010101010101010101010101010101031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
4143 assert_eq!(encoded_value, target_value);
4147 fn encoding_update_fee() {
4148 let update_fee = msgs::UpdateFee {
4149 channel_id: ChannelId::from_bytes([2; 32]),
4150 feerate_per_kw: 20190119,
4152 let encoded_value = update_fee.encode();
4153 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202013413a7").unwrap();
4154 assert_eq!(encoded_value, target_value);
4158 fn encoding_init() {
4159 let mainnet_hash = ChainHash::using_genesis_block(Network::Bitcoin);
4160 assert_eq!(msgs::Init {
4161 features: InitFeatures::from_le_bytes(vec![0xFF, 0xFF, 0xFF]),
4162 networks: Some(vec![mainnet_hash]),
4163 remote_network_address: None,
4164 }.encode(), <Vec<u8>>::from_hex("00023fff0003ffffff01206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
4165 assert_eq!(msgs::Init {
4166 features: InitFeatures::from_le_bytes(vec![0xFF]),
4168 remote_network_address: None,
4169 }.encode(), <Vec<u8>>::from_hex("0001ff0001ff").unwrap());
4170 assert_eq!(msgs::Init {
4171 features: InitFeatures::from_le_bytes(vec![]),
4172 networks: Some(vec![mainnet_hash]),
4173 remote_network_address: None,
4174 }.encode(), <Vec<u8>>::from_hex("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
4175 assert_eq!(msgs::Init {
4176 features: InitFeatures::from_le_bytes(vec![]),
4177 networks: Some(vec![ChainHash::from(&[1; 32]), ChainHash::from(&[2; 32])]),
4178 remote_network_address: None,
4179 }.encode(), <Vec<u8>>::from_hex("00000000014001010101010101010101010101010101010101010101010101010101010101010202020202020202020202020202020202020202020202020202020202020202").unwrap());
4180 let init_msg = msgs::Init { features: InitFeatures::from_le_bytes(vec![]),
4181 networks: Some(vec![mainnet_hash]),
4182 remote_network_address: Some(SocketAddress::TcpIpV4 {
4183 addr: [127, 0, 0, 1],
4187 let encoded_value = init_msg.encode();
4188 let target_value = <Vec<u8>>::from_hex("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d61900000000000307017f00000103e8").unwrap();
4189 assert_eq!(encoded_value, target_value);
4190 assert_eq!(msgs::Init::read(&mut Cursor::new(&target_value)).unwrap(), init_msg);
4194 fn encoding_error() {
4195 let error = msgs::ErrorMessage {
4196 channel_id: ChannelId::from_bytes([2; 32]),
4197 data: String::from("rust-lightning"),
4199 let encoded_value = error.encode();
4200 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
4201 assert_eq!(encoded_value, target_value);
4205 fn encoding_warning() {
4206 let error = msgs::WarningMessage {
4207 channel_id: ChannelId::from_bytes([2; 32]),
4208 data: String::from("rust-lightning"),
4210 let encoded_value = error.encode();
4211 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
4212 assert_eq!(encoded_value, target_value);
4216 fn encoding_ping() {
4217 let ping = msgs::Ping {
4221 let encoded_value = ping.encode();
4222 let target_value = <Vec<u8>>::from_hex("0040004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
4223 assert_eq!(encoded_value, target_value);
4227 fn encoding_pong() {
4228 let pong = msgs::Pong {
4231 let encoded_value = pong.encode();
4232 let target_value = <Vec<u8>>::from_hex("004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
4233 assert_eq!(encoded_value, target_value);
4237 fn encoding_nonfinal_onion_hop_data() {
4238 let outbound_msg = msgs::OutboundOnionPayload::Forward {
4239 short_channel_id: 0xdeadbeef1bad1dea,
4240 amt_to_forward: 0x0badf00d01020304,
4241 outgoing_cltv_value: 0xffffffff,
4243 let encoded_value = outbound_msg.encode();
4244 let target_value = <Vec<u8>>::from_hex("1a02080badf00d010203040404ffffffff0608deadbeef1bad1dea").unwrap();
4245 assert_eq!(encoded_value, target_value);
4247 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4248 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4249 if let msgs::InboundOnionPayload::Forward {
4250 short_channel_id, amt_to_forward, outgoing_cltv_value
4252 assert_eq!(short_channel_id, 0xdeadbeef1bad1dea);
4253 assert_eq!(amt_to_forward, 0x0badf00d01020304);
4254 assert_eq!(outgoing_cltv_value, 0xffffffff);
4255 } else { panic!(); }
4259 fn encoding_final_onion_hop_data() {
4260 let outbound_msg = msgs::OutboundOnionPayload::Receive {
4262 payment_metadata: None,
4263 keysend_preimage: None,
4264 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4265 cltv_expiry_height: 0xffffffff,
4266 custom_tlvs: vec![],
4268 let encoded_value = outbound_msg.encode();
4269 let target_value = <Vec<u8>>::from_hex("1002080badf00d010203040404ffffffff").unwrap();
4270 assert_eq!(encoded_value, target_value);
4272 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4273 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4274 if let msgs::InboundOnionPayload::Receive {
4275 payment_data: None, sender_intended_htlc_amt_msat, cltv_expiry_height, ..
4277 assert_eq!(sender_intended_htlc_amt_msat, 0x0badf00d01020304);
4278 assert_eq!(cltv_expiry_height, 0xffffffff);
4279 } else { panic!(); }
4283 fn encoding_final_onion_hop_data_with_secret() {
4284 let expected_payment_secret = PaymentSecret([0x42u8; 32]);
4285 let outbound_msg = msgs::OutboundOnionPayload::Receive {
4286 payment_data: Some(FinalOnionHopData {
4287 payment_secret: expected_payment_secret,
4288 total_msat: 0x1badca1f
4290 payment_metadata: None,
4291 keysend_preimage: None,
4292 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4293 cltv_expiry_height: 0xffffffff,
4294 custom_tlvs: vec![],
4296 let encoded_value = outbound_msg.encode();
4297 let target_value = <Vec<u8>>::from_hex("3602080badf00d010203040404ffffffff082442424242424242424242424242424242424242424242424242424242424242421badca1f").unwrap();
4298 assert_eq!(encoded_value, target_value);
4300 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4301 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4302 if let msgs::InboundOnionPayload::Receive {
4303 payment_data: Some(FinalOnionHopData {
4305 total_msat: 0x1badca1f
4307 sender_intended_htlc_amt_msat, cltv_expiry_height,
4308 payment_metadata: None,
4309 keysend_preimage: None,
4312 assert_eq!(payment_secret, expected_payment_secret);
4313 assert_eq!(sender_intended_htlc_amt_msat, 0x0badf00d01020304);
4314 assert_eq!(cltv_expiry_height, 0xffffffff);
4315 assert_eq!(custom_tlvs, vec![]);
4316 } else { panic!(); }
4320 fn encoding_final_onion_hop_data_with_bad_custom_tlvs() {
4321 // If custom TLVs have type number within the range reserved for protocol, treat them as if
4323 let bad_type_range_tlvs = vec![
4324 ((1 << 16) - 4, vec![42]),
4325 ((1 << 16) - 2, vec![42; 32]),
4327 let mut msg = msgs::OutboundOnionPayload::Receive {
4329 payment_metadata: None,
4330 keysend_preimage: None,
4331 custom_tlvs: bad_type_range_tlvs,
4332 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4333 cltv_expiry_height: 0xffffffff,
4335 let encoded_value = msg.encode();
4336 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4337 assert!(msgs::InboundOnionPayload::read(&mut Cursor::new(&encoded_value[..]), (None, &&node_signer)).is_err());
4338 let good_type_range_tlvs = vec![
4339 ((1 << 16) - 3, vec![42]),
4340 ((1 << 16) - 1, vec![42; 32]),
4342 if let msgs::OutboundOnionPayload::Receive { ref mut custom_tlvs, .. } = msg {
4343 *custom_tlvs = good_type_range_tlvs.clone();
4345 let encoded_value = msg.encode();
4346 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&encoded_value[..]), (None, &&node_signer)).unwrap();
4348 msgs::InboundOnionPayload::Receive { custom_tlvs, .. } => assert!(custom_tlvs.is_empty()),
4354 fn encoding_final_onion_hop_data_with_custom_tlvs() {
4355 let expected_custom_tlvs = vec![
4356 (5482373483, vec![0x12, 0x34]),
4357 (5482373487, vec![0x42u8; 8]),
4359 let msg = msgs::OutboundOnionPayload::Receive {
4361 payment_metadata: None,
4362 keysend_preimage: None,
4363 custom_tlvs: expected_custom_tlvs.clone(),
4364 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4365 cltv_expiry_height: 0xffffffff,
4367 let encoded_value = msg.encode();
4368 let target_value = <Vec<u8>>::from_hex("2e02080badf00d010203040404ffffffffff0000000146c6616b021234ff0000000146c6616f084242424242424242").unwrap();
4369 assert_eq!(encoded_value, target_value);
4370 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4371 let inbound_msg: msgs::InboundOnionPayload = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4372 if let msgs::InboundOnionPayload::Receive {
4374 payment_metadata: None,
4375 keysend_preimage: None,
4377 sender_intended_htlc_amt_msat,
4378 cltv_expiry_height: outgoing_cltv_value,
4381 assert_eq!(custom_tlvs, expected_custom_tlvs);
4382 assert_eq!(sender_intended_htlc_amt_msat, 0x0badf00d01020304);
4383 assert_eq!(outgoing_cltv_value, 0xffffffff);
4384 } else { panic!(); }
4388 fn query_channel_range_end_blocknum() {
4389 let tests: Vec<(u32, u32, u32)> = vec![
4390 (10000, 1500, 11500),
4391 (0, 0xffffffff, 0xffffffff),
4392 (1, 0xffffffff, 0xffffffff),
4395 for (first_blocknum, number_of_blocks, expected) in tests.into_iter() {
4396 let sut = msgs::QueryChannelRange {
4397 chain_hash: ChainHash::using_genesis_block(Network::Regtest),
4401 assert_eq!(sut.end_blocknum(), expected);
4406 fn encoding_query_channel_range() {
4407 let mut query_channel_range = msgs::QueryChannelRange {
4408 chain_hash: ChainHash::using_genesis_block(Network::Regtest),
4409 first_blocknum: 100000,
4410 number_of_blocks: 1500,
4412 let encoded_value = query_channel_range.encode();
4413 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000186a0000005dc").unwrap();
4414 assert_eq!(encoded_value, target_value);
4416 query_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4417 assert_eq!(query_channel_range.first_blocknum, 100000);
4418 assert_eq!(query_channel_range.number_of_blocks, 1500);
4422 fn encoding_reply_channel_range() {
4423 do_encoding_reply_channel_range(0);
4424 do_encoding_reply_channel_range(1);
4427 fn do_encoding_reply_channel_range(encoding_type: u8) {
4428 let mut target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000b8a06000005dc01").unwrap();
4429 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4430 let mut reply_channel_range = msgs::ReplyChannelRange {
4431 chain_hash: expected_chain_hash,
4432 first_blocknum: 756230,
4433 number_of_blocks: 1500,
4434 sync_complete: true,
4435 short_channel_ids: vec![0x000000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
4438 if encoding_type == 0 {
4439 target_value.append(&mut <Vec<u8>>::from_hex("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
4440 let encoded_value = reply_channel_range.encode();
4441 assert_eq!(encoded_value, target_value);
4443 reply_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4444 assert_eq!(reply_channel_range.chain_hash, expected_chain_hash);
4445 assert_eq!(reply_channel_range.first_blocknum, 756230);
4446 assert_eq!(reply_channel_range.number_of_blocks, 1500);
4447 assert_eq!(reply_channel_range.sync_complete, true);
4448 assert_eq!(reply_channel_range.short_channel_ids[0], 0x000000000000008e);
4449 assert_eq!(reply_channel_range.short_channel_ids[1], 0x0000000000003c69);
4450 assert_eq!(reply_channel_range.short_channel_ids[2], 0x000000000045a6c4);
4452 target_value.append(&mut <Vec<u8>>::from_hex("001601789c636000833e08659309a65878be010010a9023a").unwrap());
4453 let result: Result<msgs::ReplyChannelRange, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
4454 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
4459 fn encoding_query_short_channel_ids() {
4460 do_encoding_query_short_channel_ids(0);
4461 do_encoding_query_short_channel_ids(1);
4464 fn do_encoding_query_short_channel_ids(encoding_type: u8) {
4465 let mut target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
4466 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4467 let mut query_short_channel_ids = msgs::QueryShortChannelIds {
4468 chain_hash: expected_chain_hash,
4469 short_channel_ids: vec![0x0000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
4472 if encoding_type == 0 {
4473 target_value.append(&mut <Vec<u8>>::from_hex("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
4474 let encoded_value = query_short_channel_ids.encode();
4475 assert_eq!(encoded_value, target_value);
4477 query_short_channel_ids = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4478 assert_eq!(query_short_channel_ids.chain_hash, expected_chain_hash);
4479 assert_eq!(query_short_channel_ids.short_channel_ids[0], 0x000000000000008e);
4480 assert_eq!(query_short_channel_ids.short_channel_ids[1], 0x0000000000003c69);
4481 assert_eq!(query_short_channel_ids.short_channel_ids[2], 0x000000000045a6c4);
4483 target_value.append(&mut <Vec<u8>>::from_hex("001601789c636000833e08659309a65878be010010a9023a").unwrap());
4484 let result: Result<msgs::QueryShortChannelIds, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
4485 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
4490 fn encoding_reply_short_channel_ids_end() {
4491 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4492 let mut reply_short_channel_ids_end = msgs::ReplyShortChannelIdsEnd {
4493 chain_hash: expected_chain_hash,
4494 full_information: true,
4496 let encoded_value = reply_short_channel_ids_end.encode();
4497 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f01").unwrap();
4498 assert_eq!(encoded_value, target_value);
4500 reply_short_channel_ids_end = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4501 assert_eq!(reply_short_channel_ids_end.chain_hash, expected_chain_hash);
4502 assert_eq!(reply_short_channel_ids_end.full_information, true);
4506 fn encoding_gossip_timestamp_filter(){
4507 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4508 let mut gossip_timestamp_filter = msgs::GossipTimestampFilter {
4509 chain_hash: expected_chain_hash,
4510 first_timestamp: 1590000000,
4511 timestamp_range: 0xffff_ffff,
4513 let encoded_value = gossip_timestamp_filter.encode();
4514 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f5ec57980ffffffff").unwrap();
4515 assert_eq!(encoded_value, target_value);
4517 gossip_timestamp_filter = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4518 assert_eq!(gossip_timestamp_filter.chain_hash, expected_chain_hash);
4519 assert_eq!(gossip_timestamp_filter.first_timestamp, 1590000000);
4520 assert_eq!(gossip_timestamp_filter.timestamp_range, 0xffff_ffff);
4524 fn decode_onion_hop_data_len_as_bigsize() {
4525 // Tests that we can decode an onion payload that is >253 bytes.
4526 // Previously, receiving a payload of this size could've caused us to fail to decode a valid
4527 // payload, because we were decoding the length (a BigSize, big-endian) as a VarInt
4530 // Encode a test onion payload with a big custom TLV such that it's >253 bytes, forcing the
4531 // payload length to be encoded over multiple bytes rather than a single u8.
4532 let big_payload = encode_big_payload().unwrap();
4533 let mut rd = Cursor::new(&big_payload[..]);
4535 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4536 <msgs::InboundOnionPayload as ReadableArgs<(Option<PublicKey>, &&test_utils::TestKeysInterface)>>
4537 ::read(&mut rd, (None, &&node_signer)).unwrap();
4539 // see above test, needs to be a separate method for use of the serialization macros.
4540 fn encode_big_payload() -> Result<Vec<u8>, io::Error> {
4541 use crate::util::ser::HighZeroBytesDroppedBigSize;
4542 let payload = msgs::OutboundOnionPayload::Forward {
4543 short_channel_id: 0xdeadbeef1bad1dea,
4544 amt_to_forward: 1000,
4545 outgoing_cltv_value: 0xffffffff,
4547 let mut encoded_payload = Vec::new();
4548 let test_bytes = vec![42u8; 1000];
4549 if let msgs::OutboundOnionPayload::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } = payload {
4550 _encode_varint_length_prefixed_tlv!(&mut encoded_payload, {
4551 (1, test_bytes, required_vec),
4552 (2, HighZeroBytesDroppedBigSize(amt_to_forward), required),
4553 (4, HighZeroBytesDroppedBigSize(outgoing_cltv_value), required),
4554 (6, short_channel_id, required)
4561 #[cfg(feature = "std")]
4562 fn test_socket_address_from_str() {
4563 let tcpip_v4 = SocketAddress::TcpIpV4 {
4564 addr: Ipv4Addr::new(127, 0, 0, 1).octets(),
4567 assert_eq!(tcpip_v4, SocketAddress::from_str("127.0.0.1:1234").unwrap());
4568 assert_eq!(tcpip_v4, SocketAddress::from_str(&tcpip_v4.to_string()).unwrap());
4570 let tcpip_v6 = SocketAddress::TcpIpV6 {
4571 addr: Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1).octets(),
4574 assert_eq!(tcpip_v6, SocketAddress::from_str("[0:0:0:0:0:0:0:1]:1234").unwrap());
4575 assert_eq!(tcpip_v6, SocketAddress::from_str(&tcpip_v6.to_string()).unwrap());
4577 let hostname = SocketAddress::Hostname {
4578 hostname: Hostname::try_from("lightning-node.mydomain.com".to_string()).unwrap(),
4581 assert_eq!(hostname, SocketAddress::from_str("lightning-node.mydomain.com:1234").unwrap());
4582 assert_eq!(hostname, SocketAddress::from_str(&hostname.to_string()).unwrap());
4584 let onion_v2 = SocketAddress::OnionV2 ([40, 4, 64, 185, 202, 19, 162, 75, 90, 200, 38, 7],);
4585 assert_eq!("OnionV2([40, 4, 64, 185, 202, 19, 162, 75, 90, 200, 38, 7])", &onion_v2.to_string());
4586 assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("FACEBOOKCOREWWWI.onion:9735"));
4588 let onion_v3 = SocketAddress::OnionV3 {
4589 ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102, 182, 107, 4, 105, 247, 246, 85,
4590 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31, 33, 71, 3],
4595 assert_eq!(onion_v3, SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion:1234").unwrap());
4596 assert_eq!(onion_v3, SocketAddress::from_str(&onion_v3.to_string()).unwrap());
4598 assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6.onion:1234"));
4599 assert_eq!(Err(SocketAddressParseError::InvalidInput), SocketAddress::from_str("127.0.0.1@1234"));
4600 assert_eq!(Err(SocketAddressParseError::InvalidInput), "".parse::<SocketAddress>());
4601 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:9735:94").is_err());
4602 assert!(SocketAddress::from_str("wrong$%#.com:1234").is_err());
4603 assert_eq!(Err(SocketAddressParseError::InvalidPort), SocketAddress::from_str("example.com:wrong"));
4604 assert!("localhost".parse::<SocketAddress>().is_err());
4605 assert!("localhost:invalid-port".parse::<SocketAddress>().is_err());
4606 assert!( "invalid-onion-v3-hostname.onion:8080".parse::<SocketAddress>().is_err());
4607 assert!("b32.example.onion:invalid-port".parse::<SocketAddress>().is_err());
4608 assert!("invalid-address".parse::<SocketAddress>().is_err());
4609 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:1234").is_err());
4613 #[cfg(feature = "std")]
4614 fn test_socket_address_to_socket_addrs() {
4615 assert_eq!(SocketAddress::TcpIpV4 {addr:[0u8; 4], port: 1337,}.to_socket_addrs().unwrap().next().unwrap(),
4616 SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(0,0,0,0), 1337)));
4617 assert_eq!(SocketAddress::TcpIpV6 {addr:[0u8; 16], port: 1337,}.to_socket_addrs().unwrap().next().unwrap(),
4618 SocketAddr::V6(SocketAddrV6::new(Ipv6Addr::from([0u8; 16]), 1337, 0, 0)));
4619 assert_eq!(SocketAddress::Hostname { hostname: Hostname::try_from("0.0.0.0".to_string()).unwrap(), port: 0 }
4620 .to_socket_addrs().unwrap().next().unwrap(), SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::from([0u8; 4]),0)));
4621 assert!(SocketAddress::OnionV2([0u8; 12]).to_socket_addrs().is_err());
4622 assert!(SocketAddress::OnionV3{ ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102,
4623 182, 107, 4, 105, 247, 246, 85, 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31,
4627 port: 1234 }.to_socket_addrs().is_err());