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>,
1691 keysend_preimage: Option<PaymentPreimage>,
1695 pub(crate) enum OutboundOnionPayload {
1697 short_channel_id: u64,
1698 /// The value, in msat, of the payment after this hop's fee is deducted.
1699 amt_to_forward: u64,
1700 outgoing_cltv_value: u32,
1703 payment_data: Option<FinalOnionHopData>,
1704 payment_metadata: Option<Vec<u8>>,
1705 keysend_preimage: Option<PaymentPreimage>,
1706 custom_tlvs: Vec<(u64, Vec<u8>)>,
1707 sender_intended_htlc_amt_msat: u64,
1708 cltv_expiry_height: u32,
1711 encrypted_tlvs: Vec<u8>,
1712 intro_node_blinding_point: Option<PublicKey>,
1715 sender_intended_htlc_amt_msat: u64,
1717 cltv_expiry_height: u32,
1718 encrypted_tlvs: Vec<u8>,
1719 intro_node_blinding_point: Option<PublicKey>, // Set if the introduction node of the blinded path is the final node
1720 keysend_preimage: Option<PaymentPreimage>,
1724 pub struct DecodedOnionErrorPacket {
1725 pub(crate) hmac: [u8; 32],
1726 pub(crate) failuremsg: Vec<u8>,
1727 pub(crate) pad: Vec<u8>,
1731 pub use self::fuzzy_internal_msgs::*;
1732 #[cfg(not(fuzzing))]
1733 pub(crate) use self::fuzzy_internal_msgs::*;
1735 /// BOLT 4 onion packet including hop data for the next peer.
1736 #[derive(Clone, Hash, PartialEq, Eq)]
1737 pub struct OnionPacket {
1738 /// BOLT 4 version number.
1740 /// In order to ensure we always return an error on onion decode in compliance with [BOLT
1741 /// #4](https://github.com/lightning/bolts/blob/master/04-onion-routing.md), we have to
1742 /// deserialize `OnionPacket`s contained in [`UpdateAddHTLC`] messages even if the ephemeral
1743 /// public key (here) is bogus, so we hold a [`Result`] instead of a [`PublicKey`] as we'd
1745 pub public_key: Result<PublicKey, secp256k1::Error>,
1746 /// 1300 bytes encrypted payload for the next hop.
1747 pub hop_data: [u8; 20*65],
1748 /// HMAC to verify the integrity of hop_data.
1752 impl onion_utils::Packet for OnionPacket {
1753 type Data = onion_utils::FixedSizeOnionPacket;
1754 fn new(pubkey: PublicKey, hop_data: onion_utils::FixedSizeOnionPacket, hmac: [u8; 32]) -> Self {
1757 public_key: Ok(pubkey),
1758 hop_data: hop_data.0,
1764 impl fmt::Debug for OnionPacket {
1765 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1766 f.write_fmt(format_args!("OnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
1770 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1771 pub(crate) struct OnionErrorPacket {
1772 // This really should be a constant size slice, but the spec lets these things be up to 128KB?
1773 // (TODO) We limit it in decode to much lower...
1774 pub(crate) data: Vec<u8>,
1777 impl fmt::Display for DecodeError {
1778 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1780 DecodeError::UnknownVersion => f.write_str("Unknown realm byte in Onion packet"),
1781 DecodeError::UnknownRequiredFeature => f.write_str("Unknown required feature preventing decode"),
1782 DecodeError::InvalidValue => f.write_str("Nonsense bytes didn't map to the type they were interpreted as"),
1783 DecodeError::ShortRead => f.write_str("Packet extended beyond the provided bytes"),
1784 DecodeError::BadLengthDescriptor => f.write_str("A length descriptor in the packet didn't describe the later data correctly"),
1785 DecodeError::Io(ref e) => fmt::Debug::fmt(e, f),
1786 DecodeError::UnsupportedCompression => f.write_str("We don't support receiving messages with zlib-compressed fields"),
1791 impl From<io::Error> for DecodeError {
1792 fn from(e: io::Error) -> Self {
1793 if e.kind() == io::ErrorKind::UnexpectedEof {
1794 DecodeError::ShortRead
1796 DecodeError::Io(e.kind())
1801 impl Writeable for AcceptChannel {
1802 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1803 self.common_fields.temporary_channel_id.write(w)?;
1804 self.common_fields.dust_limit_satoshis.write(w)?;
1805 self.common_fields.max_htlc_value_in_flight_msat.write(w)?;
1806 self.channel_reserve_satoshis.write(w)?;
1807 self.common_fields.htlc_minimum_msat.write(w)?;
1808 self.common_fields.minimum_depth.write(w)?;
1809 self.common_fields.to_self_delay.write(w)?;
1810 self.common_fields.max_accepted_htlcs.write(w)?;
1811 self.common_fields.funding_pubkey.write(w)?;
1812 self.common_fields.revocation_basepoint.write(w)?;
1813 self.common_fields.payment_basepoint.write(w)?;
1814 self.common_fields.delayed_payment_basepoint.write(w)?;
1815 self.common_fields.htlc_basepoint.write(w)?;
1816 self.common_fields.first_per_commitment_point.write(w)?;
1817 #[cfg(not(taproot))]
1818 encode_tlv_stream!(w, {
1819 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
1820 (1, self.common_fields.channel_type, option),
1823 encode_tlv_stream!(w, {
1824 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
1825 (1, self.common_fields.channel_type, option),
1826 (4, self.next_local_nonce, option),
1832 impl Readable for AcceptChannel {
1833 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1834 let temporary_channel_id: ChannelId = Readable::read(r)?;
1835 let dust_limit_satoshis: u64 = Readable::read(r)?;
1836 let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;
1837 let channel_reserve_satoshis: u64 = Readable::read(r)?;
1838 let htlc_minimum_msat: u64 = Readable::read(r)?;
1839 let minimum_depth: u32 = Readable::read(r)?;
1840 let to_self_delay: u16 = Readable::read(r)?;
1841 let max_accepted_htlcs: u16 = Readable::read(r)?;
1842 let funding_pubkey: PublicKey = Readable::read(r)?;
1843 let revocation_basepoint: PublicKey = Readable::read(r)?;
1844 let payment_basepoint: PublicKey = Readable::read(r)?;
1845 let delayed_payment_basepoint: PublicKey = Readable::read(r)?;
1846 let htlc_basepoint: PublicKey = Readable::read(r)?;
1847 let first_per_commitment_point: PublicKey = Readable::read(r)?;
1849 let mut shutdown_scriptpubkey: Option<ScriptBuf> = None;
1850 let mut channel_type: Option<ChannelTypeFeatures> = None;
1851 #[cfg(not(taproot))]
1852 decode_tlv_stream!(r, {
1853 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
1854 (1, channel_type, option),
1857 let mut next_local_nonce: Option<musig2::types::PublicNonce> = None;
1859 decode_tlv_stream!(r, {
1860 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
1861 (1, channel_type, option),
1862 (4, next_local_nonce, option),
1866 common_fields: CommonAcceptChannelFields {
1867 temporary_channel_id,
1868 dust_limit_satoshis,
1869 max_htlc_value_in_flight_msat,
1875 revocation_basepoint,
1877 delayed_payment_basepoint,
1879 first_per_commitment_point,
1880 shutdown_scriptpubkey,
1883 channel_reserve_satoshis,
1890 impl Writeable for AcceptChannelV2 {
1891 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1892 self.common_fields.temporary_channel_id.write(w)?;
1893 self.funding_satoshis.write(w)?;
1894 self.common_fields.dust_limit_satoshis.write(w)?;
1895 self.common_fields.max_htlc_value_in_flight_msat.write(w)?;
1896 self.common_fields.htlc_minimum_msat.write(w)?;
1897 self.common_fields.minimum_depth.write(w)?;
1898 self.common_fields.to_self_delay.write(w)?;
1899 self.common_fields.max_accepted_htlcs.write(w)?;
1900 self.common_fields.funding_pubkey.write(w)?;
1901 self.common_fields.revocation_basepoint.write(w)?;
1902 self.common_fields.payment_basepoint.write(w)?;
1903 self.common_fields.delayed_payment_basepoint.write(w)?;
1904 self.common_fields.htlc_basepoint.write(w)?;
1905 self.common_fields.first_per_commitment_point.write(w)?;
1906 self.second_per_commitment_point.write(w)?;
1908 encode_tlv_stream!(w, {
1909 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
1910 (1, self.common_fields.channel_type, option),
1911 (2, self.require_confirmed_inputs, option),
1917 impl Readable for AcceptChannelV2 {
1918 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1919 let temporary_channel_id: ChannelId = Readable::read(r)?;
1920 let funding_satoshis: u64 = Readable::read(r)?;
1921 let dust_limit_satoshis: u64 = Readable::read(r)?;
1922 let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;
1923 let htlc_minimum_msat: u64 = Readable::read(r)?;
1924 let minimum_depth: u32 = Readable::read(r)?;
1925 let to_self_delay: u16 = Readable::read(r)?;
1926 let max_accepted_htlcs: u16 = Readable::read(r)?;
1927 let funding_pubkey: PublicKey = Readable::read(r)?;
1928 let revocation_basepoint: PublicKey = Readable::read(r)?;
1929 let payment_basepoint: PublicKey = Readable::read(r)?;
1930 let delayed_payment_basepoint: PublicKey = Readable::read(r)?;
1931 let htlc_basepoint: PublicKey = Readable::read(r)?;
1932 let first_per_commitment_point: PublicKey = Readable::read(r)?;
1933 let second_per_commitment_point: PublicKey = Readable::read(r)?;
1935 let mut shutdown_scriptpubkey: Option<ScriptBuf> = None;
1936 let mut channel_type: Option<ChannelTypeFeatures> = None;
1937 let mut require_confirmed_inputs: Option<()> = None;
1938 decode_tlv_stream!(r, {
1939 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
1940 (1, channel_type, option),
1941 (2, require_confirmed_inputs, option),
1944 Ok(AcceptChannelV2 {
1945 common_fields: CommonAcceptChannelFields {
1946 temporary_channel_id,
1947 dust_limit_satoshis,
1948 max_htlc_value_in_flight_msat,
1954 revocation_basepoint,
1956 delayed_payment_basepoint,
1958 first_per_commitment_point,
1959 shutdown_scriptpubkey,
1963 second_per_commitment_point,
1964 require_confirmed_inputs,
1969 impl_writeable_msg!(Stfu, {
1974 impl_writeable_msg!(Splice, {
1978 funding_feerate_perkw,
1983 impl_writeable_msg!(SpliceAck, {
1990 impl_writeable_msg!(SpliceLocked, {
1994 impl_writeable_msg!(TxAddInput, {
2002 impl_writeable_msg!(TxAddOutput, {
2009 impl_writeable_msg!(TxRemoveInput, {
2014 impl_writeable_msg!(TxRemoveOutput, {
2019 impl_writeable_msg!(TxComplete, {
2023 impl_writeable_msg!(TxSignatures, {
2029 impl_writeable_msg!(TxInitRbf, {
2032 feerate_sat_per_1000_weight,
2034 (0, funding_output_contribution, option),
2037 impl_writeable_msg!(TxAckRbf, {
2040 (0, funding_output_contribution, option),
2043 impl_writeable_msg!(TxAbort, {
2048 impl_writeable_msg!(AnnouncementSignatures, {
2055 impl_writeable_msg!(ChannelReestablish, {
2057 next_local_commitment_number,
2058 next_remote_commitment_number,
2059 your_last_per_commitment_secret,
2060 my_current_per_commitment_point,
2062 (0, next_funding_txid, option),
2065 impl_writeable_msg!(ClosingSigned,
2066 { channel_id, fee_satoshis, signature },
2067 { (1, fee_range, option) }
2070 impl_writeable!(ClosingSignedFeeRange, {
2075 #[cfg(not(taproot))]
2076 impl_writeable_msg!(CommitmentSigned, {
2083 impl_writeable_msg!(CommitmentSigned, {
2088 (2, partial_signature_with_nonce, option)
2091 impl_writeable!(DecodedOnionErrorPacket, {
2097 #[cfg(not(taproot))]
2098 impl_writeable_msg!(FundingCreated, {
2099 temporary_channel_id,
2101 funding_output_index,
2105 impl_writeable_msg!(FundingCreated, {
2106 temporary_channel_id,
2108 funding_output_index,
2111 (2, partial_signature_with_nonce, option),
2112 (4, next_local_nonce, option)
2115 #[cfg(not(taproot))]
2116 impl_writeable_msg!(FundingSigned, {
2122 impl_writeable_msg!(FundingSigned, {
2126 (2, partial_signature_with_nonce, option)
2129 impl_writeable_msg!(ChannelReady, {
2131 next_per_commitment_point,
2133 (1, short_channel_id_alias, option),
2136 impl Writeable for Init {
2137 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2138 // global_features gets the bottom 13 bits of our features, and local_features gets all of
2139 // our relevant feature bits. This keeps us compatible with old nodes.
2140 self.features.write_up_to_13(w)?;
2141 self.features.write(w)?;
2142 encode_tlv_stream!(w, {
2143 (1, self.networks.as_ref().map(|n| WithoutLength(n)), option),
2144 (3, self.remote_network_address, option),
2150 impl Readable for Init {
2151 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2152 let global_features: InitFeatures = Readable::read(r)?;
2153 let features: InitFeatures = Readable::read(r)?;
2154 let mut remote_network_address: Option<SocketAddress> = None;
2155 let mut networks: Option<WithoutLength<Vec<ChainHash>>> = None;
2156 decode_tlv_stream!(r, {
2157 (1, networks, option),
2158 (3, remote_network_address, option)
2161 features: features | global_features,
2162 networks: networks.map(|n| n.0),
2163 remote_network_address,
2168 impl Writeable for OpenChannel {
2169 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2170 self.common_fields.chain_hash.write(w)?;
2171 self.common_fields.temporary_channel_id.write(w)?;
2172 self.common_fields.funding_satoshis.write(w)?;
2173 self.push_msat.write(w)?;
2174 self.common_fields.dust_limit_satoshis.write(w)?;
2175 self.common_fields.max_htlc_value_in_flight_msat.write(w)?;
2176 self.channel_reserve_satoshis.write(w)?;
2177 self.common_fields.htlc_minimum_msat.write(w)?;
2178 self.common_fields.commitment_feerate_sat_per_1000_weight.write(w)?;
2179 self.common_fields.to_self_delay.write(w)?;
2180 self.common_fields.max_accepted_htlcs.write(w)?;
2181 self.common_fields.funding_pubkey.write(w)?;
2182 self.common_fields.revocation_basepoint.write(w)?;
2183 self.common_fields.payment_basepoint.write(w)?;
2184 self.common_fields.delayed_payment_basepoint.write(w)?;
2185 self.common_fields.htlc_basepoint.write(w)?;
2186 self.common_fields.first_per_commitment_point.write(w)?;
2187 self.common_fields.channel_flags.write(w)?;
2188 encode_tlv_stream!(w, {
2189 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
2190 (1, self.common_fields.channel_type, option),
2196 impl Readable for OpenChannel {
2197 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2198 let chain_hash: ChainHash = Readable::read(r)?;
2199 let temporary_channel_id: ChannelId = Readable::read(r)?;
2200 let funding_satoshis: u64 = Readable::read(r)?;
2201 let push_msat: u64 = Readable::read(r)?;
2202 let dust_limit_satoshis: u64 = Readable::read(r)?;
2203 let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;
2204 let channel_reserve_satoshis: u64 = Readable::read(r)?;
2205 let htlc_minimum_msat: u64 = Readable::read(r)?;
2206 let commitment_feerate_sat_per_1000_weight: u32 = Readable::read(r)?;
2207 let to_self_delay: u16 = Readable::read(r)?;
2208 let max_accepted_htlcs: u16 = Readable::read(r)?;
2209 let funding_pubkey: PublicKey = Readable::read(r)?;
2210 let revocation_basepoint: PublicKey = Readable::read(r)?;
2211 let payment_basepoint: PublicKey = Readable::read(r)?;
2212 let delayed_payment_basepoint: PublicKey = Readable::read(r)?;
2213 let htlc_basepoint: PublicKey = Readable::read(r)?;
2214 let first_per_commitment_point: PublicKey = Readable::read(r)?;
2215 let channel_flags: u8 = Readable::read(r)?;
2217 let mut shutdown_scriptpubkey: Option<ScriptBuf> = None;
2218 let mut channel_type: Option<ChannelTypeFeatures> = None;
2219 decode_tlv_stream!(r, {
2220 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
2221 (1, channel_type, option),
2224 common_fields: CommonOpenChannelFields {
2226 temporary_channel_id,
2228 dust_limit_satoshis,
2229 max_htlc_value_in_flight_msat,
2231 commitment_feerate_sat_per_1000_weight,
2235 revocation_basepoint,
2237 delayed_payment_basepoint,
2239 first_per_commitment_point,
2241 shutdown_scriptpubkey,
2245 channel_reserve_satoshis,
2250 impl Writeable for OpenChannelV2 {
2251 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2252 self.common_fields.chain_hash.write(w)?;
2253 self.common_fields.temporary_channel_id.write(w)?;
2254 self.funding_feerate_sat_per_1000_weight.write(w)?;
2255 self.common_fields.commitment_feerate_sat_per_1000_weight.write(w)?;
2256 self.common_fields.funding_satoshis.write(w)?;
2257 self.common_fields.dust_limit_satoshis.write(w)?;
2258 self.common_fields.max_htlc_value_in_flight_msat.write(w)?;
2259 self.common_fields.htlc_minimum_msat.write(w)?;
2260 self.common_fields.to_self_delay.write(w)?;
2261 self.common_fields.max_accepted_htlcs.write(w)?;
2262 self.locktime.write(w)?;
2263 self.common_fields.funding_pubkey.write(w)?;
2264 self.common_fields.revocation_basepoint.write(w)?;
2265 self.common_fields.payment_basepoint.write(w)?;
2266 self.common_fields.delayed_payment_basepoint.write(w)?;
2267 self.common_fields.htlc_basepoint.write(w)?;
2268 self.common_fields.first_per_commitment_point.write(w)?;
2269 self.second_per_commitment_point.write(w)?;
2270 self.common_fields.channel_flags.write(w)?;
2271 encode_tlv_stream!(w, {
2272 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
2273 (1, self.common_fields.channel_type, option),
2274 (2, self.require_confirmed_inputs, option),
2280 impl Readable for OpenChannelV2 {
2281 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2282 let chain_hash: ChainHash = Readable::read(r)?;
2283 let temporary_channel_id: ChannelId = Readable::read(r)?;
2284 let funding_feerate_sat_per_1000_weight: u32 = Readable::read(r)?;
2285 let commitment_feerate_sat_per_1000_weight: u32 = Readable::read(r)?;
2286 let funding_satoshis: u64 = Readable::read(r)?;
2287 let dust_limit_satoshis: u64 = Readable::read(r)?;
2288 let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;
2289 let htlc_minimum_msat: u64 = Readable::read(r)?;
2290 let to_self_delay: u16 = Readable::read(r)?;
2291 let max_accepted_htlcs: u16 = Readable::read(r)?;
2292 let locktime: u32 = Readable::read(r)?;
2293 let funding_pubkey: PublicKey = Readable::read(r)?;
2294 let revocation_basepoint: PublicKey = Readable::read(r)?;
2295 let payment_basepoint: PublicKey = Readable::read(r)?;
2296 let delayed_payment_basepoint: PublicKey = Readable::read(r)?;
2297 let htlc_basepoint: PublicKey = Readable::read(r)?;
2298 let first_per_commitment_point: PublicKey = Readable::read(r)?;
2299 let second_per_commitment_point: PublicKey = Readable::read(r)?;
2300 let channel_flags: u8 = Readable::read(r)?;
2302 let mut shutdown_scriptpubkey: Option<ScriptBuf> = None;
2303 let mut channel_type: Option<ChannelTypeFeatures> = None;
2304 let mut require_confirmed_inputs: Option<()> = None;
2305 decode_tlv_stream!(r, {
2306 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
2307 (1, channel_type, option),
2308 (2, require_confirmed_inputs, option),
2311 common_fields: CommonOpenChannelFields {
2313 temporary_channel_id,
2315 dust_limit_satoshis,
2316 max_htlc_value_in_flight_msat,
2318 commitment_feerate_sat_per_1000_weight,
2322 revocation_basepoint,
2324 delayed_payment_basepoint,
2326 first_per_commitment_point,
2328 shutdown_scriptpubkey,
2331 funding_feerate_sat_per_1000_weight,
2333 second_per_commitment_point,
2334 require_confirmed_inputs,
2339 #[cfg(not(taproot))]
2340 impl_writeable_msg!(RevokeAndACK, {
2342 per_commitment_secret,
2343 next_per_commitment_point
2347 impl_writeable_msg!(RevokeAndACK, {
2349 per_commitment_secret,
2350 next_per_commitment_point
2352 (4, next_local_nonce, option)
2355 impl_writeable_msg!(Shutdown, {
2360 impl_writeable_msg!(UpdateFailHTLC, {
2366 impl_writeable_msg!(UpdateFailMalformedHTLC, {
2373 impl_writeable_msg!(UpdateFee, {
2378 impl_writeable_msg!(UpdateFulfillHTLC, {
2384 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2385 // serialization format in a way which assumes we know the total serialized length/message end
2387 impl_writeable!(OnionErrorPacket, {
2391 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2392 // serialization format in a way which assumes we know the total serialized length/message end
2394 impl Writeable for OnionPacket {
2395 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2396 self.version.write(w)?;
2397 match self.public_key {
2398 Ok(pubkey) => pubkey.write(w)?,
2399 Err(_) => [0u8;33].write(w)?,
2401 w.write_all(&self.hop_data)?;
2402 self.hmac.write(w)?;
2407 impl Readable for OnionPacket {
2408 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2410 version: Readable::read(r)?,
2412 let mut buf = [0u8;33];
2413 r.read_exact(&mut buf)?;
2414 PublicKey::from_slice(&buf)
2416 hop_data: Readable::read(r)?,
2417 hmac: Readable::read(r)?,
2422 impl_writeable_msg!(UpdateAddHTLC, {
2428 onion_routing_packet,
2430 (0, blinding_point, option),
2431 (65537, skimmed_fee_msat, option)
2434 impl Readable for OnionMessage {
2435 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2436 let blinding_point: PublicKey = Readable::read(r)?;
2437 let len: u16 = Readable::read(r)?;
2438 let mut packet_reader = FixedLengthReader::new(r, len as u64);
2439 let onion_routing_packet: onion_message::packet::Packet =
2440 <onion_message::packet::Packet as LengthReadable>::read(&mut packet_reader)?;
2443 onion_routing_packet,
2448 impl Writeable for OnionMessage {
2449 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2450 self.blinding_point.write(w)?;
2451 let onion_packet_len = self.onion_routing_packet.serialized_length();
2452 (onion_packet_len as u16).write(w)?;
2453 self.onion_routing_packet.write(w)?;
2458 impl Writeable for FinalOnionHopData {
2459 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2460 self.payment_secret.0.write(w)?;
2461 HighZeroBytesDroppedBigSize(self.total_msat).write(w)
2465 impl Readable for FinalOnionHopData {
2466 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2467 let secret: [u8; 32] = Readable::read(r)?;
2468 let amt: HighZeroBytesDroppedBigSize<u64> = Readable::read(r)?;
2469 Ok(Self { payment_secret: PaymentSecret(secret), total_msat: amt.0 })
2473 impl Writeable for OutboundOnionPayload {
2474 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2476 Self::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } => {
2477 _encode_varint_length_prefixed_tlv!(w, {
2478 (2, HighZeroBytesDroppedBigSize(*amt_to_forward), required),
2479 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2480 (6, short_channel_id, required)
2484 ref payment_data, ref payment_metadata, ref keysend_preimage, sender_intended_htlc_amt_msat,
2485 cltv_expiry_height, ref custom_tlvs,
2487 // We need to update [`ln::outbound_payment::RecipientOnionFields::with_custom_tlvs`]
2488 // to reject any reserved types in the experimental range if new ones are ever
2490 let keysend_tlv = keysend_preimage.map(|preimage| (5482373484, preimage.encode()));
2491 let mut custom_tlvs: Vec<&(u64, Vec<u8>)> = custom_tlvs.iter().chain(keysend_tlv.iter()).collect();
2492 custom_tlvs.sort_unstable_by_key(|(typ, _)| *typ);
2493 _encode_varint_length_prefixed_tlv!(w, {
2494 (2, HighZeroBytesDroppedBigSize(*sender_intended_htlc_amt_msat), required),
2495 (4, HighZeroBytesDroppedBigSize(*cltv_expiry_height), required),
2496 (8, payment_data, option),
2497 (16, payment_metadata.as_ref().map(|m| WithoutLength(m)), option)
2498 }, custom_tlvs.iter());
2500 Self::BlindedForward { encrypted_tlvs, intro_node_blinding_point } => {
2501 _encode_varint_length_prefixed_tlv!(w, {
2502 (10, *encrypted_tlvs, required_vec),
2503 (12, intro_node_blinding_point, option)
2506 Self::BlindedReceive {
2507 sender_intended_htlc_amt_msat, total_msat, cltv_expiry_height, encrypted_tlvs,
2508 intro_node_blinding_point, keysend_preimage,
2510 _encode_varint_length_prefixed_tlv!(w, {
2511 (2, HighZeroBytesDroppedBigSize(*sender_intended_htlc_amt_msat), required),
2512 (4, HighZeroBytesDroppedBigSize(*cltv_expiry_height), required),
2513 (10, *encrypted_tlvs, required_vec),
2514 (12, intro_node_blinding_point, option),
2515 (18, HighZeroBytesDroppedBigSize(*total_msat), required),
2516 (5482373484, keysend_preimage, option)
2524 impl<NS: Deref> ReadableArgs<(Option<PublicKey>, &NS)> for InboundOnionPayload where NS::Target: NodeSigner {
2525 fn read<R: Read>(r: &mut R, args: (Option<PublicKey>, &NS)) -> Result<Self, DecodeError> {
2526 let (update_add_blinding_point, node_signer) = args;
2529 let mut cltv_value = None;
2530 let mut short_id: Option<u64> = None;
2531 let mut payment_data: Option<FinalOnionHopData> = None;
2532 let mut encrypted_tlvs_opt: Option<WithoutLength<Vec<u8>>> = None;
2533 let mut intro_node_blinding_point = None;
2534 let mut payment_metadata: Option<WithoutLength<Vec<u8>>> = None;
2535 let mut total_msat = None;
2536 let mut keysend_preimage: Option<PaymentPreimage> = None;
2537 let mut custom_tlvs = Vec::new();
2539 let tlv_len = BigSize::read(r)?;
2540 let rd = FixedLengthReader::new(r, tlv_len.0);
2541 decode_tlv_stream_with_custom_tlv_decode!(rd, {
2542 (2, amt, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2543 (4, cltv_value, (option, encoding: (u32, HighZeroBytesDroppedBigSize))),
2544 (6, short_id, option),
2545 (8, payment_data, option),
2546 (10, encrypted_tlvs_opt, option),
2547 (12, intro_node_blinding_point, option),
2548 (16, payment_metadata, option),
2549 (18, total_msat, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2550 // See https://github.com/lightning/blips/blob/master/blip-0003.md
2551 (5482373484, keysend_preimage, option)
2552 }, |msg_type: u64, msg_reader: &mut FixedLengthReader<_>| -> Result<bool, DecodeError> {
2553 if msg_type < 1 << 16 { return Ok(false) }
2554 let mut value = Vec::new();
2555 msg_reader.read_to_end(&mut value)?;
2556 custom_tlvs.push((msg_type, value));
2560 if amt.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2561 if intro_node_blinding_point.is_some() && update_add_blinding_point.is_some() {
2562 return Err(DecodeError::InvalidValue)
2565 if let Some(blinding_point) = intro_node_blinding_point.or(update_add_blinding_point) {
2566 if short_id.is_some() || payment_data.is_some() || payment_metadata.is_some() {
2567 return Err(DecodeError::InvalidValue)
2569 let enc_tlvs = encrypted_tlvs_opt.ok_or(DecodeError::InvalidValue)?.0;
2570 let enc_tlvs_ss = node_signer.ecdh(Recipient::Node, &blinding_point, None)
2571 .map_err(|_| DecodeError::InvalidValue)?;
2572 let rho = onion_utils::gen_rho_from_shared_secret(&enc_tlvs_ss.secret_bytes());
2573 let mut s = Cursor::new(&enc_tlvs);
2574 let mut reader = FixedLengthReader::new(&mut s, enc_tlvs.len() as u64);
2575 match ChaChaPolyReadAdapter::read(&mut reader, rho)? {
2576 ChaChaPolyReadAdapter { readable: BlindedPaymentTlvs::Forward(ForwardTlvs {
2577 short_channel_id, payment_relay, payment_constraints, features
2579 if amt.is_some() || cltv_value.is_some() || total_msat.is_some() ||
2580 keysend_preimage.is_some()
2582 return Err(DecodeError::InvalidValue)
2584 Ok(Self::BlindedForward {
2587 payment_constraints,
2589 intro_node_blinding_point,
2592 ChaChaPolyReadAdapter { readable: BlindedPaymentTlvs::Receive(ReceiveTlvs {
2593 payment_secret, payment_constraints
2595 if total_msat.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2596 Ok(Self::BlindedReceive {
2597 sender_intended_htlc_amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2598 total_msat: total_msat.ok_or(DecodeError::InvalidValue)?,
2599 cltv_expiry_height: cltv_value.ok_or(DecodeError::InvalidValue)?,
2601 payment_constraints,
2602 intro_node_blinding_point,
2607 } else if let Some(short_channel_id) = short_id {
2608 if payment_data.is_some() || payment_metadata.is_some() || encrypted_tlvs_opt.is_some() ||
2609 total_msat.is_some()
2610 { return Err(DecodeError::InvalidValue) }
2613 amt_to_forward: amt.ok_or(DecodeError::InvalidValue)?,
2614 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2617 if encrypted_tlvs_opt.is_some() || total_msat.is_some() {
2618 return Err(DecodeError::InvalidValue)
2620 if let Some(data) = &payment_data {
2621 if data.total_msat > MAX_VALUE_MSAT {
2622 return Err(DecodeError::InvalidValue);
2627 payment_metadata: payment_metadata.map(|w| w.0),
2629 sender_intended_htlc_amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2630 cltv_expiry_height: cltv_value.ok_or(DecodeError::InvalidValue)?,
2637 impl Writeable for Ping {
2638 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2639 self.ponglen.write(w)?;
2640 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2645 impl Readable for Ping {
2646 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2648 ponglen: Readable::read(r)?,
2650 let byteslen = Readable::read(r)?;
2651 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2658 impl Writeable for Pong {
2659 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2660 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2665 impl Readable for Pong {
2666 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2669 let byteslen = Readable::read(r)?;
2670 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2677 impl Writeable for UnsignedChannelAnnouncement {
2678 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2679 self.features.write(w)?;
2680 self.chain_hash.write(w)?;
2681 self.short_channel_id.write(w)?;
2682 self.node_id_1.write(w)?;
2683 self.node_id_2.write(w)?;
2684 self.bitcoin_key_1.write(w)?;
2685 self.bitcoin_key_2.write(w)?;
2686 w.write_all(&self.excess_data[..])?;
2691 impl Readable for UnsignedChannelAnnouncement {
2692 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2694 features: Readable::read(r)?,
2695 chain_hash: Readable::read(r)?,
2696 short_channel_id: Readable::read(r)?,
2697 node_id_1: Readable::read(r)?,
2698 node_id_2: Readable::read(r)?,
2699 bitcoin_key_1: Readable::read(r)?,
2700 bitcoin_key_2: Readable::read(r)?,
2701 excess_data: read_to_end(r)?,
2706 impl_writeable!(ChannelAnnouncement, {
2709 bitcoin_signature_1,
2710 bitcoin_signature_2,
2714 impl Writeable for UnsignedChannelUpdate {
2715 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2716 // `message_flags` used to indicate presence of `htlc_maximum_msat`, but was deprecated in the spec.
2717 const MESSAGE_FLAGS: u8 = 1;
2718 self.chain_hash.write(w)?;
2719 self.short_channel_id.write(w)?;
2720 self.timestamp.write(w)?;
2721 let all_flags = self.flags as u16 | ((MESSAGE_FLAGS as u16) << 8);
2722 all_flags.write(w)?;
2723 self.cltv_expiry_delta.write(w)?;
2724 self.htlc_minimum_msat.write(w)?;
2725 self.fee_base_msat.write(w)?;
2726 self.fee_proportional_millionths.write(w)?;
2727 self.htlc_maximum_msat.write(w)?;
2728 w.write_all(&self.excess_data[..])?;
2733 impl Readable for UnsignedChannelUpdate {
2734 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2736 chain_hash: Readable::read(r)?,
2737 short_channel_id: Readable::read(r)?,
2738 timestamp: Readable::read(r)?,
2740 let flags: u16 = Readable::read(r)?;
2741 // Note: we ignore the `message_flags` for now, since it was deprecated by the spec.
2744 cltv_expiry_delta: Readable::read(r)?,
2745 htlc_minimum_msat: Readable::read(r)?,
2746 fee_base_msat: Readable::read(r)?,
2747 fee_proportional_millionths: Readable::read(r)?,
2748 htlc_maximum_msat: Readable::read(r)?,
2749 excess_data: read_to_end(r)?,
2754 impl_writeable!(ChannelUpdate, {
2759 impl Writeable for ErrorMessage {
2760 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2761 self.channel_id.write(w)?;
2762 (self.data.len() as u16).write(w)?;
2763 w.write_all(self.data.as_bytes())?;
2768 impl Readable for ErrorMessage {
2769 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2771 channel_id: Readable::read(r)?,
2773 let sz: usize = <u16 as Readable>::read(r)? as usize;
2774 let mut data = Vec::with_capacity(sz);
2776 r.read_exact(&mut data)?;
2777 match String::from_utf8(data) {
2779 Err(_) => return Err(DecodeError::InvalidValue),
2786 impl Writeable for WarningMessage {
2787 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2788 self.channel_id.write(w)?;
2789 (self.data.len() as u16).write(w)?;
2790 w.write_all(self.data.as_bytes())?;
2795 impl Readable for WarningMessage {
2796 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2798 channel_id: Readable::read(r)?,
2800 let sz: usize = <u16 as Readable>::read(r)? as usize;
2801 let mut data = Vec::with_capacity(sz);
2803 r.read_exact(&mut data)?;
2804 match String::from_utf8(data) {
2806 Err(_) => return Err(DecodeError::InvalidValue),
2813 impl Writeable for UnsignedNodeAnnouncement {
2814 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2815 self.features.write(w)?;
2816 self.timestamp.write(w)?;
2817 self.node_id.write(w)?;
2818 w.write_all(&self.rgb)?;
2819 self.alias.write(w)?;
2821 let mut addr_len = 0;
2822 for addr in self.addresses.iter() {
2823 addr_len += 1 + addr.len();
2825 (addr_len + self.excess_address_data.len() as u16).write(w)?;
2826 for addr in self.addresses.iter() {
2829 w.write_all(&self.excess_address_data[..])?;
2830 w.write_all(&self.excess_data[..])?;
2835 impl Readable for UnsignedNodeAnnouncement {
2836 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2837 let features: NodeFeatures = Readable::read(r)?;
2838 let timestamp: u32 = Readable::read(r)?;
2839 let node_id: NodeId = Readable::read(r)?;
2840 let mut rgb = [0; 3];
2841 r.read_exact(&mut rgb)?;
2842 let alias: NodeAlias = Readable::read(r)?;
2844 let addr_len: u16 = Readable::read(r)?;
2845 let mut addresses: Vec<SocketAddress> = Vec::new();
2846 let mut addr_readpos = 0;
2847 let mut excess = false;
2848 let mut excess_byte = 0;
2850 if addr_len <= addr_readpos { break; }
2851 match Readable::read(r) {
2853 if addr_len < addr_readpos + 1 + addr.len() {
2854 return Err(DecodeError::BadLengthDescriptor);
2856 addr_readpos += (1 + addr.len()) as u16;
2857 addresses.push(addr);
2859 Ok(Err(unknown_descriptor)) => {
2861 excess_byte = unknown_descriptor;
2864 Err(DecodeError::ShortRead) => return Err(DecodeError::BadLengthDescriptor),
2865 Err(e) => return Err(e),
2869 let mut excess_data = vec![];
2870 let excess_address_data = if addr_readpos < addr_len {
2871 let mut excess_address_data = vec![0; (addr_len - addr_readpos) as usize];
2872 r.read_exact(&mut excess_address_data[if excess { 1 } else { 0 }..])?;
2874 excess_address_data[0] = excess_byte;
2879 excess_data.push(excess_byte);
2883 excess_data.extend(read_to_end(r)?.iter());
2884 Ok(UnsignedNodeAnnouncement {
2891 excess_address_data,
2897 impl_writeable!(NodeAnnouncement, {
2902 impl Readable for QueryShortChannelIds {
2903 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2904 let chain_hash: ChainHash = Readable::read(r)?;
2906 let encoding_len: u16 = Readable::read(r)?;
2907 let encoding_type: u8 = Readable::read(r)?;
2909 // Must be encoding_type=0 uncompressed serialization. We do not
2910 // support encoding_type=1 zlib serialization.
2911 if encoding_type != EncodingType::Uncompressed as u8 {
2912 return Err(DecodeError::UnsupportedCompression);
2915 // We expect the encoding_len to always includes the 1-byte
2916 // encoding_type and that short_channel_ids are 8-bytes each
2917 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2918 return Err(DecodeError::InvalidValue);
2921 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2922 // less the 1-byte encoding_type
2923 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2924 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2925 for _ in 0..short_channel_id_count {
2926 short_channel_ids.push(Readable::read(r)?);
2929 Ok(QueryShortChannelIds {
2936 impl Writeable for QueryShortChannelIds {
2937 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2938 // Calculated from 1-byte encoding_type plus 8-bytes per short_channel_id
2939 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2941 self.chain_hash.write(w)?;
2942 encoding_len.write(w)?;
2944 // We only support type=0 uncompressed serialization
2945 (EncodingType::Uncompressed as u8).write(w)?;
2947 for scid in self.short_channel_ids.iter() {
2955 impl_writeable_msg!(ReplyShortChannelIdsEnd, {
2960 impl QueryChannelRange {
2961 /// Calculates the overflow safe ending block height for the query.
2963 /// Overflow returns `0xffffffff`, otherwise returns `first_blocknum + number_of_blocks`.
2964 pub fn end_blocknum(&self) -> u32 {
2965 match self.first_blocknum.checked_add(self.number_of_blocks) {
2966 Some(block) => block,
2967 None => u32::max_value(),
2972 impl_writeable_msg!(QueryChannelRange, {
2978 impl Readable for ReplyChannelRange {
2979 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2980 let chain_hash: ChainHash = Readable::read(r)?;
2981 let first_blocknum: u32 = Readable::read(r)?;
2982 let number_of_blocks: u32 = Readable::read(r)?;
2983 let sync_complete: bool = Readable::read(r)?;
2985 let encoding_len: u16 = Readable::read(r)?;
2986 let encoding_type: u8 = Readable::read(r)?;
2988 // Must be encoding_type=0 uncompressed serialization. We do not
2989 // support encoding_type=1 zlib serialization.
2990 if encoding_type != EncodingType::Uncompressed as u8 {
2991 return Err(DecodeError::UnsupportedCompression);
2994 // We expect the encoding_len to always includes the 1-byte
2995 // encoding_type and that short_channel_ids are 8-bytes each
2996 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2997 return Err(DecodeError::InvalidValue);
3000 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
3001 // less the 1-byte encoding_type
3002 let short_channel_id_count: u16 = (encoding_len - 1)/8;
3003 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
3004 for _ in 0..short_channel_id_count {
3005 short_channel_ids.push(Readable::read(r)?);
3008 Ok(ReplyChannelRange {
3018 impl Writeable for ReplyChannelRange {
3019 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
3020 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
3021 self.chain_hash.write(w)?;
3022 self.first_blocknum.write(w)?;
3023 self.number_of_blocks.write(w)?;
3024 self.sync_complete.write(w)?;
3026 encoding_len.write(w)?;
3027 (EncodingType::Uncompressed as u8).write(w)?;
3028 for scid in self.short_channel_ids.iter() {
3036 impl_writeable_msg!(GossipTimestampFilter, {
3044 use std::convert::TryFrom;
3045 use bitcoin::{Transaction, TxIn, ScriptBuf, Sequence, Witness, TxOut};
3046 use hex::DisplayHex;
3047 use crate::ln::{PaymentPreimage, PaymentHash, PaymentSecret};
3048 use crate::ln::ChannelId;
3049 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
3050 use crate::ln::msgs::{self, FinalOnionHopData, OnionErrorPacket, CommonOpenChannelFields, CommonAcceptChannelFields};
3051 use crate::ln::msgs::SocketAddress;
3052 use crate::routing::gossip::{NodeAlias, NodeId};
3053 use crate::util::ser::{Writeable, Readable, ReadableArgs, Hostname, TransactionU16LenLimited};
3054 use crate::util::test_utils;
3056 use bitcoin::hashes::hex::FromHex;
3057 use bitcoin::address::Address;
3058 use bitcoin::network::constants::Network;
3059 use bitcoin::blockdata::constants::ChainHash;
3060 use bitcoin::blockdata::script::Builder;
3061 use bitcoin::blockdata::opcodes;
3062 use bitcoin::hash_types::Txid;
3063 use bitcoin::locktime::absolute::LockTime;
3065 use bitcoin::secp256k1::{PublicKey,SecretKey};
3066 use bitcoin::secp256k1::{Secp256k1, Message};
3068 use crate::io::{self, Cursor};
3069 use crate::prelude::*;
3070 use core::str::FromStr;
3071 use crate::chain::transaction::OutPoint;
3073 #[cfg(feature = "std")]
3074 use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6, ToSocketAddrs};
3075 #[cfg(feature = "std")]
3076 use crate::ln::msgs::SocketAddressParseError;
3079 fn encoding_channel_reestablish() {
3081 let secp_ctx = Secp256k1::new();
3082 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&<Vec<u8>>::from_hex("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
3085 let cr = msgs::ChannelReestablish {
3086 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]),
3087 next_local_commitment_number: 3,
3088 next_remote_commitment_number: 4,
3089 your_last_per_commitment_secret: [9;32],
3090 my_current_per_commitment_point: public_key,
3091 next_funding_txid: None,
3094 let encoded_value = cr.encode();
3098 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
3099 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
3100 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
3101 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
3102 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
3108 fn encoding_channel_reestablish_with_next_funding_txid() {
3110 let secp_ctx = Secp256k1::new();
3111 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&<Vec<u8>>::from_hex("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
3114 let cr = msgs::ChannelReestablish {
3115 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]),
3116 next_local_commitment_number: 3,
3117 next_remote_commitment_number: 4,
3118 your_last_per_commitment_secret: [9;32],
3119 my_current_per_commitment_point: public_key,
3120 next_funding_txid: Some(Txid::from_raw_hash(bitcoin::hashes::Hash::from_slice(&[
3121 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,
3125 let encoded_value = cr.encode();
3129 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
3130 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
3131 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
3132 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
3133 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
3134 0, // Type (next_funding_txid)
3136 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
3141 macro_rules! get_keys_from {
3142 ($slice: expr, $secp_ctx: expr) => {
3144 let privkey = SecretKey::from_slice(&<Vec<u8>>::from_hex($slice).unwrap()[..]).unwrap();
3145 let pubkey = PublicKey::from_secret_key(&$secp_ctx, &privkey);
3151 macro_rules! get_sig_on {
3152 ($privkey: expr, $ctx: expr, $string: expr) => {
3154 let sighash = Message::from_slice(&$string.into_bytes()[..]).unwrap();
3155 $ctx.sign_ecdsa(&sighash, &$privkey)
3161 fn encoding_announcement_signatures() {
3162 let secp_ctx = Secp256k1::new();
3163 let (privkey, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3164 let sig_1 = get_sig_on!(privkey, secp_ctx, String::from("01010101010101010101010101010101"));
3165 let sig_2 = get_sig_on!(privkey, secp_ctx, String::from("02020202020202020202020202020202"));
3166 let announcement_signatures = msgs::AnnouncementSignatures {
3167 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]),
3168 short_channel_id: 2316138423780173,
3169 node_signature: sig_1,
3170 bitcoin_signature: sig_2,
3173 let encoded_value = announcement_signatures.encode();
3174 assert_eq!(encoded_value, <Vec<u8>>::from_hex("040000000000000005000000000000000600000000000000070000000000000000083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073acf9953cef4700860f5967838eba2bae89288ad188ebf8b20bf995c3ea53a26df1876d0a3a0e13172ba286a673140190c02ba9da60a2e43a745188c8a83c7f3ef").unwrap());
3177 fn do_encoding_channel_announcement(unknown_features_bits: bool, excess_data: bool) {
3178 let secp_ctx = Secp256k1::new();
3179 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3180 let (privkey_2, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3181 let (privkey_3, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3182 let (privkey_4, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3183 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3184 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
3185 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
3186 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
3187 let mut features = ChannelFeatures::empty();
3188 if unknown_features_bits {
3189 features = ChannelFeatures::from_le_bytes(vec![0xFF, 0xFF]);
3191 let unsigned_channel_announcement = msgs::UnsignedChannelAnnouncement {
3193 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3194 short_channel_id: 2316138423780173,
3195 node_id_1: NodeId::from_pubkey(&pubkey_1),
3196 node_id_2: NodeId::from_pubkey(&pubkey_2),
3197 bitcoin_key_1: NodeId::from_pubkey(&pubkey_3),
3198 bitcoin_key_2: NodeId::from_pubkey(&pubkey_4),
3199 excess_data: if excess_data { vec![10, 0, 0, 20, 0, 0, 30, 0, 0, 40] } else { Vec::new() },
3201 let channel_announcement = msgs::ChannelAnnouncement {
3202 node_signature_1: sig_1,
3203 node_signature_2: sig_2,
3204 bitcoin_signature_1: sig_3,
3205 bitcoin_signature_2: sig_4,
3206 contents: unsigned_channel_announcement,
3208 let encoded_value = channel_announcement.encode();
3209 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a1735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap();
3210 if unknown_features_bits {
3211 target_value.append(&mut <Vec<u8>>::from_hex("0002ffff").unwrap());
3213 target_value.append(&mut <Vec<u8>>::from_hex("0000").unwrap());
3215 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3216 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
3218 target_value.append(&mut <Vec<u8>>::from_hex("0a00001400001e000028").unwrap());
3220 assert_eq!(encoded_value, target_value);
3224 fn encoding_channel_announcement() {
3225 do_encoding_channel_announcement(true, false);
3226 do_encoding_channel_announcement(false, true);
3227 do_encoding_channel_announcement(false, false);
3228 do_encoding_channel_announcement(true, true);
3231 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) {
3232 let secp_ctx = Secp256k1::new();
3233 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3234 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3235 let features = if unknown_features_bits {
3236 NodeFeatures::from_le_bytes(vec![0xFF, 0xFF])
3238 // Set to some features we may support
3239 NodeFeatures::from_le_bytes(vec![2 | 1 << 5])
3241 let mut addresses = Vec::new();
3243 addresses.push(SocketAddress::TcpIpV4 {
3244 addr: [255, 254, 253, 252],
3249 addresses.push(SocketAddress::TcpIpV6 {
3250 addr: [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240],
3255 addresses.push(msgs::SocketAddress::OnionV2(
3256 [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 38, 7]
3260 addresses.push(msgs::SocketAddress::OnionV3 {
3261 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],
3268 addresses.push(SocketAddress::Hostname {
3269 hostname: Hostname::try_from(String::from("host")).unwrap(),
3273 let mut addr_len = 0;
3274 for addr in &addresses {
3275 addr_len += addr.len() + 1;
3277 let unsigned_node_announcement = msgs::UnsignedNodeAnnouncement {
3279 timestamp: 20190119,
3280 node_id: NodeId::from_pubkey(&pubkey_1),
3282 alias: NodeAlias([16;32]),
3284 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() },
3285 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() },
3287 addr_len += unsigned_node_announcement.excess_address_data.len() as u16;
3288 let node_announcement = msgs::NodeAnnouncement {
3290 contents: unsigned_node_announcement,
3292 let encoded_value = node_announcement.encode();
3293 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3294 if unknown_features_bits {
3295 target_value.append(&mut <Vec<u8>>::from_hex("0002ffff").unwrap());
3297 target_value.append(&mut <Vec<u8>>::from_hex("000122").unwrap());
3299 target_value.append(&mut <Vec<u8>>::from_hex("013413a7031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f2020201010101010101010101010101010101010101010101010101010101010101010").unwrap());
3300 target_value.append(&mut vec![(addr_len >> 8) as u8, addr_len as u8]);
3302 target_value.append(&mut <Vec<u8>>::from_hex("01fffefdfc2607").unwrap());
3305 target_value.append(&mut <Vec<u8>>::from_hex("02fffefdfcfbfaf9f8f7f6f5f4f3f2f1f02607").unwrap());
3308 target_value.append(&mut <Vec<u8>>::from_hex("03fffefdfcfbfaf9f8f7f62607").unwrap());
3311 target_value.append(&mut <Vec<u8>>::from_hex("04fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0efeeedecebeae9e8e7e6e5e4e3e2e1e00020102607").unwrap());
3314 target_value.append(&mut <Vec<u8>>::from_hex("0504686f73742607").unwrap());
3316 if excess_address_data {
3317 target_value.append(&mut <Vec<u8>>::from_hex("216c280b5395a2546e7e4b2663e04f811622f15a4f92e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d269").unwrap());
3320 target_value.append(&mut <Vec<u8>>::from_hex("3b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
3322 assert_eq!(encoded_value, target_value);
3326 fn encoding_node_announcement() {
3327 do_encoding_node_announcement(true, true, true, true, true, true, true, true);
3328 do_encoding_node_announcement(false, false, false, false, false, false, false, false);
3329 do_encoding_node_announcement(false, true, false, false, false, false, false, false);
3330 do_encoding_node_announcement(false, false, true, false, false, false, false, false);
3331 do_encoding_node_announcement(false, false, false, true, false, false, false, false);
3332 do_encoding_node_announcement(false, false, false, false, true, false, false, false);
3333 do_encoding_node_announcement(false, false, false, false, false, true, false, false);
3334 do_encoding_node_announcement(false, false, false, false, false, false, true, false);
3335 do_encoding_node_announcement(false, true, false, true, false, false, true, false);
3336 do_encoding_node_announcement(false, false, true, false, true, false, false, false);
3339 fn do_encoding_channel_update(direction: bool, disable: bool, excess_data: bool) {
3340 let secp_ctx = Secp256k1::new();
3341 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3342 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3343 let unsigned_channel_update = msgs::UnsignedChannelUpdate {
3344 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3345 short_channel_id: 2316138423780173,
3346 timestamp: 20190119,
3347 flags: if direction { 1 } else { 0 } | if disable { 1 << 1 } else { 0 },
3348 cltv_expiry_delta: 144,
3349 htlc_minimum_msat: 1000000,
3350 htlc_maximum_msat: 131355275467161,
3351 fee_base_msat: 10000,
3352 fee_proportional_millionths: 20,
3353 excess_data: if excess_data { vec![0, 0, 0, 0, 59, 154, 202, 0] } else { Vec::new() }
3355 let channel_update = msgs::ChannelUpdate {
3357 contents: unsigned_channel_update
3359 let encoded_value = channel_update.encode();
3360 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3361 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3362 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d013413a7").unwrap());
3363 target_value.append(&mut <Vec<u8>>::from_hex("01").unwrap());
3364 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3366 let flag = target_value.last_mut().unwrap();
3370 let flag = target_value.last_mut().unwrap();
3371 *flag = *flag | 1 << 1;
3373 target_value.append(&mut <Vec<u8>>::from_hex("009000000000000f42400000271000000014").unwrap());
3374 target_value.append(&mut <Vec<u8>>::from_hex("0000777788889999").unwrap());
3376 target_value.append(&mut <Vec<u8>>::from_hex("000000003b9aca00").unwrap());
3378 assert_eq!(encoded_value, target_value);
3382 fn encoding_channel_update() {
3383 do_encoding_channel_update(false, false, false);
3384 do_encoding_channel_update(false, false, true);
3385 do_encoding_channel_update(true, false, false);
3386 do_encoding_channel_update(true, false, true);
3387 do_encoding_channel_update(false, true, false);
3388 do_encoding_channel_update(false, true, true);
3389 do_encoding_channel_update(true, true, false);
3390 do_encoding_channel_update(true, true, true);
3393 fn do_encoding_open_channel(random_bit: bool, shutdown: bool, incl_chan_type: bool) {
3394 let secp_ctx = Secp256k1::new();
3395 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3396 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3397 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3398 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3399 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3400 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3401 let open_channel = msgs::OpenChannel {
3402 common_fields: CommonOpenChannelFields {
3403 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3404 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3405 funding_satoshis: 1311768467284833366,
3406 dust_limit_satoshis: 3608586615801332854,
3407 max_htlc_value_in_flight_msat: 8517154655701053848,
3408 htlc_minimum_msat: 2316138423780173,
3409 commitment_feerate_sat_per_1000_weight: 821716,
3410 to_self_delay: 49340,
3411 max_accepted_htlcs: 49340,
3412 funding_pubkey: pubkey_1,
3413 revocation_basepoint: pubkey_2,
3414 payment_basepoint: pubkey_3,
3415 delayed_payment_basepoint: pubkey_4,
3416 htlc_basepoint: pubkey_5,
3417 first_per_commitment_point: pubkey_6,
3418 channel_flags: if random_bit { 1 << 5 } else { 0 },
3419 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3420 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3422 push_msat: 2536655962884945560,
3423 channel_reserve_satoshis: 8665828695742877976,
3425 let encoded_value = open_channel.encode();
3426 let mut target_value = Vec::new();
3427 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3428 target_value.append(&mut <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202021234567890123456233403289122369832144668701144767633030896203198784335490624111800083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3430 target_value.append(&mut <Vec<u8>>::from_hex("20").unwrap());
3432 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3435 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3438 target_value.append(&mut <Vec<u8>>::from_hex("0100").unwrap());
3440 assert_eq!(encoded_value, target_value);
3444 fn encoding_open_channel() {
3445 do_encoding_open_channel(false, false, false);
3446 do_encoding_open_channel(false, false, true);
3447 do_encoding_open_channel(false, true, false);
3448 do_encoding_open_channel(false, true, true);
3449 do_encoding_open_channel(true, false, false);
3450 do_encoding_open_channel(true, false, true);
3451 do_encoding_open_channel(true, true, false);
3452 do_encoding_open_channel(true, true, true);
3455 fn do_encoding_open_channelv2(random_bit: bool, shutdown: bool, incl_chan_type: bool, require_confirmed_inputs: bool) {
3456 let secp_ctx = Secp256k1::new();
3457 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3458 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3459 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3460 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3461 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3462 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3463 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3464 let open_channelv2 = msgs::OpenChannelV2 {
3465 common_fields: CommonOpenChannelFields {
3466 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3467 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3468 commitment_feerate_sat_per_1000_weight: 821716,
3469 funding_satoshis: 1311768467284833366,
3470 dust_limit_satoshis: 3608586615801332854,
3471 max_htlc_value_in_flight_msat: 8517154655701053848,
3472 htlc_minimum_msat: 2316138423780173,
3473 to_self_delay: 49340,
3474 max_accepted_htlcs: 49340,
3475 funding_pubkey: pubkey_1,
3476 revocation_basepoint: pubkey_2,
3477 payment_basepoint: pubkey_3,
3478 delayed_payment_basepoint: pubkey_4,
3479 htlc_basepoint: pubkey_5,
3480 first_per_commitment_point: pubkey_6,
3481 channel_flags: if random_bit { 1 << 5 } else { 0 },
3482 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3483 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3485 funding_feerate_sat_per_1000_weight: 821716,
3486 locktime: 305419896,
3487 second_per_commitment_point: pubkey_7,
3488 require_confirmed_inputs: if require_confirmed_inputs { Some(()) } else { None },
3490 let encoded_value = open_channelv2.encode();
3491 let mut target_value = Vec::new();
3492 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3493 target_value.append(&mut <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap());
3494 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap());
3495 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap());
3496 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap());
3497 target_value.append(&mut <Vec<u8>>::from_hex("3214466870114476").unwrap());
3498 target_value.append(&mut <Vec<u8>>::from_hex("7633030896203198").unwrap());
3499 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d").unwrap());
3500 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap());
3501 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap());
3502 target_value.append(&mut <Vec<u8>>::from_hex("12345678").unwrap());
3503 target_value.append(&mut <Vec<u8>>::from_hex("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap());
3504 target_value.append(&mut <Vec<u8>>::from_hex("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap());
3505 target_value.append(&mut <Vec<u8>>::from_hex("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap());
3506 target_value.append(&mut <Vec<u8>>::from_hex("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
3507 target_value.append(&mut <Vec<u8>>::from_hex("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap());
3508 target_value.append(&mut <Vec<u8>>::from_hex("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3509 target_value.append(&mut <Vec<u8>>::from_hex("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap());
3512 target_value.append(&mut <Vec<u8>>::from_hex("20").unwrap());
3514 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3517 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3520 target_value.append(&mut <Vec<u8>>::from_hex("0100").unwrap());
3522 if require_confirmed_inputs {
3523 target_value.append(&mut <Vec<u8>>::from_hex("0200").unwrap());
3525 assert_eq!(encoded_value, target_value);
3529 fn encoding_open_channelv2() {
3530 do_encoding_open_channelv2(false, false, false, false);
3531 do_encoding_open_channelv2(false, false, false, true);
3532 do_encoding_open_channelv2(false, false, true, false);
3533 do_encoding_open_channelv2(false, false, true, true);
3534 do_encoding_open_channelv2(false, true, false, false);
3535 do_encoding_open_channelv2(false, true, false, true);
3536 do_encoding_open_channelv2(false, true, true, false);
3537 do_encoding_open_channelv2(false, true, true, true);
3538 do_encoding_open_channelv2(true, false, false, false);
3539 do_encoding_open_channelv2(true, false, false, true);
3540 do_encoding_open_channelv2(true, false, true, false);
3541 do_encoding_open_channelv2(true, false, true, true);
3542 do_encoding_open_channelv2(true, true, false, false);
3543 do_encoding_open_channelv2(true, true, false, true);
3544 do_encoding_open_channelv2(true, true, true, false);
3545 do_encoding_open_channelv2(true, true, true, true);
3548 fn do_encoding_accept_channel(shutdown: bool) {
3549 let secp_ctx = Secp256k1::new();
3550 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3551 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3552 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3553 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3554 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3555 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3556 let accept_channel = msgs::AcceptChannel {
3557 common_fields: CommonAcceptChannelFields {
3558 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3559 dust_limit_satoshis: 1311768467284833366,
3560 max_htlc_value_in_flight_msat: 2536655962884945560,
3561 htlc_minimum_msat: 2316138423780173,
3562 minimum_depth: 821716,
3563 to_self_delay: 49340,
3564 max_accepted_htlcs: 49340,
3565 funding_pubkey: pubkey_1,
3566 revocation_basepoint: pubkey_2,
3567 payment_basepoint: pubkey_3,
3568 delayed_payment_basepoint: pubkey_4,
3569 htlc_basepoint: pubkey_5,
3570 first_per_commitment_point: pubkey_6,
3571 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3574 channel_reserve_satoshis: 3608586615801332854,
3576 next_local_nonce: None,
3578 let encoded_value = accept_channel.encode();
3579 let mut target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020212345678901234562334032891223698321446687011447600083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap();
3581 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3583 assert_eq!(encoded_value, target_value);
3587 fn encoding_accept_channel() {
3588 do_encoding_accept_channel(false);
3589 do_encoding_accept_channel(true);
3592 fn do_encoding_accept_channelv2(shutdown: bool) {
3593 let secp_ctx = Secp256k1::new();
3594 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3595 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3596 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3597 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3598 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3599 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3600 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3601 let accept_channelv2 = msgs::AcceptChannelV2 {
3602 common_fields: CommonAcceptChannelFields {
3603 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3604 dust_limit_satoshis: 1311768467284833366,
3605 max_htlc_value_in_flight_msat: 2536655962884945560,
3606 htlc_minimum_msat: 2316138423780173,
3607 minimum_depth: 821716,
3608 to_self_delay: 49340,
3609 max_accepted_htlcs: 49340,
3610 funding_pubkey: pubkey_1,
3611 revocation_basepoint: pubkey_2,
3612 payment_basepoint: pubkey_3,
3613 delayed_payment_basepoint: pubkey_4,
3614 htlc_basepoint: pubkey_5,
3615 first_per_commitment_point: pubkey_6,
3616 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3619 funding_satoshis: 1311768467284833366,
3620 second_per_commitment_point: pubkey_7,
3621 require_confirmed_inputs: None,
3623 let encoded_value = accept_channelv2.encode();
3624 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // temporary_channel_id
3625 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap()); // funding_satoshis
3626 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap()); // dust_limit_satoshis
3627 target_value.append(&mut <Vec<u8>>::from_hex("2334032891223698").unwrap()); // max_htlc_value_in_flight_msat
3628 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d").unwrap()); // htlc_minimum_msat
3629 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap()); // minimum_depth
3630 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap()); // to_self_delay
3631 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap()); // max_accepted_htlcs
3632 target_value.append(&mut <Vec<u8>>::from_hex("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap()); // funding_pubkey
3633 target_value.append(&mut <Vec<u8>>::from_hex("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap()); // revocation_basepoint
3634 target_value.append(&mut <Vec<u8>>::from_hex("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap()); // payment_basepoint
3635 target_value.append(&mut <Vec<u8>>::from_hex("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap()); // delayed_payment_basepoint
3636 target_value.append(&mut <Vec<u8>>::from_hex("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap()); // htlc_basepoint
3637 target_value.append(&mut <Vec<u8>>::from_hex("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap()); // first_per_commitment_point
3638 target_value.append(&mut <Vec<u8>>::from_hex("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap()); // second_per_commitment_point
3640 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3642 assert_eq!(encoded_value, target_value);
3646 fn encoding_accept_channelv2() {
3647 do_encoding_accept_channelv2(false);
3648 do_encoding_accept_channelv2(true);
3652 fn encoding_funding_created() {
3653 let secp_ctx = Secp256k1::new();
3654 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3655 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3656 let funding_created = msgs::FundingCreated {
3657 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3658 funding_txid: Txid::from_str("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3659 funding_output_index: 255,
3662 partial_signature_with_nonce: None,
3664 next_local_nonce: None,
3666 let encoded_value = funding_created.encode();
3667 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202026e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c200ffd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3668 assert_eq!(encoded_value, target_value);
3672 fn encoding_funding_signed() {
3673 let secp_ctx = Secp256k1::new();
3674 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3675 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3676 let funding_signed = msgs::FundingSigned {
3677 channel_id: ChannelId::from_bytes([2; 32]),
3680 partial_signature_with_nonce: None,
3682 let encoded_value = funding_signed.encode();
3683 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3684 assert_eq!(encoded_value, target_value);
3688 fn encoding_channel_ready() {
3689 let secp_ctx = Secp256k1::new();
3690 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3691 let channel_ready = msgs::ChannelReady {
3692 channel_id: ChannelId::from_bytes([2; 32]),
3693 next_per_commitment_point: pubkey_1,
3694 short_channel_id_alias: None,
3696 let encoded_value = channel_ready.encode();
3697 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3698 assert_eq!(encoded_value, target_value);
3702 fn encoding_splice() {
3703 let secp_ctx = Secp256k1::new();
3704 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3705 let splice = msgs::Splice {
3706 chain_hash: ChainHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
3707 channel_id: ChannelId::from_bytes([2; 32]),
3708 relative_satoshis: 123456,
3709 funding_feerate_perkw: 2000,
3711 funding_pubkey: pubkey_1,
3713 let encoded_value = splice.encode();
3714 assert_eq!(encoded_value.as_hex().to_string(), "02020202020202020202020202020202020202020202020202020202020202026fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000000000000001e240000007d000000000031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f");
3718 fn encoding_stfu() {
3719 let stfu = msgs::Stfu {
3720 channel_id: ChannelId::from_bytes([2; 32]),
3723 let encoded_value = stfu.encode();
3724 assert_eq!(encoded_value.as_hex().to_string(), "020202020202020202020202020202020202020202020202020202020202020201");
3728 fn encoding_splice_ack() {
3729 let secp_ctx = Secp256k1::new();
3730 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3731 let splice = msgs::SpliceAck {
3732 chain_hash: ChainHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
3733 channel_id: ChannelId::from_bytes([2; 32]),
3734 relative_satoshis: 123456,
3735 funding_pubkey: pubkey_1,
3737 let encoded_value = splice.encode();
3738 assert_eq!(encoded_value.as_hex().to_string(), "02020202020202020202020202020202020202020202020202020202020202026fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000000000000001e240031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f");
3742 fn encoding_splice_locked() {
3743 let splice = msgs::SpliceLocked {
3744 channel_id: ChannelId::from_bytes([2; 32]),
3746 let encoded_value = splice.encode();
3747 assert_eq!(encoded_value.as_hex().to_string(), "0202020202020202020202020202020202020202020202020202020202020202");
3751 fn encoding_tx_add_input() {
3752 let tx_add_input = msgs::TxAddInput {
3753 channel_id: ChannelId::from_bytes([2; 32]),
3754 serial_id: 4886718345,
3755 prevtx: TransactionU16LenLimited::new(Transaction {
3757 lock_time: LockTime::ZERO,
3759 previous_output: OutPoint { txid: Txid::from_str("305bab643ee297b8b6b76b320792c8223d55082122cb606bf89382146ced9c77").unwrap(), index: 2 }.into_bitcoin_outpoint(),
3760 script_sig: ScriptBuf::new(),
3761 sequence: Sequence(0xfffffffd),
3762 witness: Witness::from_slice(&vec![
3763 <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3764 <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3769 script_pubkey: Address::from_str("bc1qzlffunw52jav8vwdu5x3jfk6sr8u22rmq3xzw2").unwrap().payload.script_pubkey(),
3773 script_pubkey: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().payload.script_pubkey(),
3777 prevtx_out: 305419896,
3778 sequence: 305419896,
3780 let encoded_value = tx_add_input.encode();
3781 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000000012345678900de02000000000101779ced6c148293f86b60cb222108553d22c89207326bb7b6b897e23e64ab5b300200000000fdffffff0236dbc1000000000016001417d29e4dd454bac3b1cde50d1926da80cfc5287b9cbd03000000000016001436ec78d514df462da95e6a00c24daa8915362d420247304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701210301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944000000001234567812345678").unwrap();
3782 assert_eq!(encoded_value, target_value);
3786 fn encoding_tx_add_output() {
3787 let tx_add_output = msgs::TxAddOutput {
3788 channel_id: ChannelId::from_bytes([2; 32]),
3789 serial_id: 4886718345,
3791 script: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().payload.script_pubkey(),
3793 let encoded_value = tx_add_output.encode();
3794 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000000012345678900000001234567890016001436ec78d514df462da95e6a00c24daa8915362d42").unwrap();
3795 assert_eq!(encoded_value, target_value);
3799 fn encoding_tx_remove_input() {
3800 let tx_remove_input = msgs::TxRemoveInput {
3801 channel_id: ChannelId::from_bytes([2; 32]),
3802 serial_id: 4886718345,
3804 let encoded_value = tx_remove_input.encode();
3805 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3806 assert_eq!(encoded_value, target_value);
3810 fn encoding_tx_remove_output() {
3811 let tx_remove_output = msgs::TxRemoveOutput {
3812 channel_id: ChannelId::from_bytes([2; 32]),
3813 serial_id: 4886718345,
3815 let encoded_value = tx_remove_output.encode();
3816 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3817 assert_eq!(encoded_value, target_value);
3821 fn encoding_tx_complete() {
3822 let tx_complete = msgs::TxComplete {
3823 channel_id: ChannelId::from_bytes([2; 32]),
3825 let encoded_value = tx_complete.encode();
3826 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3827 assert_eq!(encoded_value, target_value);
3831 fn encoding_tx_signatures() {
3832 let tx_signatures = msgs::TxSignatures {
3833 channel_id: ChannelId::from_bytes([2; 32]),
3834 tx_hash: Txid::from_str("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3836 Witness::from_slice(&vec![
3837 <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3838 <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3839 Witness::from_slice(&vec![
3840 <Vec<u8>>::from_hex("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap(),
3841 <Vec<u8>>::from_hex("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap()]),
3844 let encoded_value = tx_signatures.encode();
3845 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3846 target_value.append(&mut <Vec<u8>>::from_hex("6e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c2").unwrap()); // tx_hash (sha256) (big endian byte order)
3847 target_value.append(&mut <Vec<u8>>::from_hex("0002").unwrap()); // num_witnesses (u16)
3849 target_value.append(&mut <Vec<u8>>::from_hex("006b").unwrap()); // len of witness_data
3850 target_value.append(&mut <Vec<u8>>::from_hex("02").unwrap()); // num_witness_elements (VarInt)
3851 target_value.append(&mut <Vec<u8>>::from_hex("47").unwrap()); // len of witness element data (VarInt)
3852 target_value.append(&mut <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap());
3853 target_value.append(&mut <Vec<u8>>::from_hex("21").unwrap()); // len of witness element data (VarInt)
3854 target_value.append(&mut <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap());
3856 target_value.append(&mut <Vec<u8>>::from_hex("006c").unwrap()); // len of witness_data
3857 target_value.append(&mut <Vec<u8>>::from_hex("02").unwrap()); // num_witness_elements (VarInt)
3858 target_value.append(&mut <Vec<u8>>::from_hex("48").unwrap()); // len of witness element data (VarInt)
3859 target_value.append(&mut <Vec<u8>>::from_hex("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap());
3860 target_value.append(&mut <Vec<u8>>::from_hex("21").unwrap()); // len of witness element data (VarInt)
3861 target_value.append(&mut <Vec<u8>>::from_hex("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap());
3862 assert_eq!(encoded_value, target_value);
3865 fn do_encoding_tx_init_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3866 let tx_init_rbf = msgs::TxInitRbf {
3867 channel_id: ChannelId::from_bytes([2; 32]),
3868 locktime: 305419896,
3869 feerate_sat_per_1000_weight: 20190119,
3870 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3872 let encoded_value = tx_init_rbf.encode();
3873 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3874 target_value.append(&mut <Vec<u8>>::from_hex("12345678").unwrap()); // locktime
3875 target_value.append(&mut <Vec<u8>>::from_hex("013413a7").unwrap()); // feerate_sat_per_1000_weight
3876 if let Some((_, target)) = funding_value_with_hex_target {
3877 target_value.push(0x00); // Type
3878 target_value.push(target.len() as u8 / 2); // Length
3879 target_value.append(&mut <Vec<u8>>::from_hex(target).unwrap()); // Value (i64)
3881 assert_eq!(encoded_value, target_value);
3885 fn encoding_tx_init_rbf() {
3886 do_encoding_tx_init_rbf(Some((1311768467284833366, "1234567890123456")));
3887 do_encoding_tx_init_rbf(Some((13117684672, "000000030DDFFBC0")));
3888 do_encoding_tx_init_rbf(None);
3891 fn do_encoding_tx_ack_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3892 let tx_ack_rbf = msgs::TxAckRbf {
3893 channel_id: ChannelId::from_bytes([2; 32]),
3894 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3896 let encoded_value = tx_ack_rbf.encode();
3897 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3898 if let Some((_, target)) = funding_value_with_hex_target {
3899 target_value.push(0x00); // Type
3900 target_value.push(target.len() as u8 / 2); // Length
3901 target_value.append(&mut <Vec<u8>>::from_hex(target).unwrap()); // Value (i64)
3903 assert_eq!(encoded_value, target_value);
3907 fn encoding_tx_ack_rbf() {
3908 do_encoding_tx_ack_rbf(Some((1311768467284833366, "1234567890123456")));
3909 do_encoding_tx_ack_rbf(Some((13117684672, "000000030DDFFBC0")));
3910 do_encoding_tx_ack_rbf(None);
3914 fn encoding_tx_abort() {
3915 let tx_abort = msgs::TxAbort {
3916 channel_id: ChannelId::from_bytes([2; 32]),
3917 data: <Vec<u8>>::from_hex("54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap(),
3919 let encoded_value = tx_abort.encode();
3920 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202002C54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap();
3921 assert_eq!(encoded_value, target_value);
3924 fn do_encoding_shutdown(script_type: u8) {
3925 let secp_ctx = Secp256k1::new();
3926 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3927 let script = Builder::new().push_opcode(opcodes::OP_TRUE).into_script();
3928 let shutdown = msgs::Shutdown {
3929 channel_id: ChannelId::from_bytes([2; 32]),
3931 if script_type == 1 { Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey() }
3932 else if script_type == 2 { Address::p2sh(&script, Network::Testnet).unwrap().script_pubkey() }
3933 else if script_type == 3 { Address::p2wpkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).unwrap().script_pubkey() }
3934 else { Address::p2wsh(&script, Network::Testnet).script_pubkey() },
3936 let encoded_value = shutdown.encode();
3937 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3938 if script_type == 1 {
3939 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3940 } else if script_type == 2 {
3941 target_value.append(&mut <Vec<u8>>::from_hex("0017a914da1745e9b549bd0bfa1a569971c77eba30cd5a4b87").unwrap());
3942 } else if script_type == 3 {
3943 target_value.append(&mut <Vec<u8>>::from_hex("0016001479b000887626b294a914501a4cd226b58b235983").unwrap());
3944 } else if script_type == 4 {
3945 target_value.append(&mut <Vec<u8>>::from_hex("002200204ae81572f06e1b88fd5ced7a1a000945432e83e1551e6f721ee9c00b8cc33260").unwrap());
3947 assert_eq!(encoded_value, target_value);
3951 fn encoding_shutdown() {
3952 do_encoding_shutdown(1);
3953 do_encoding_shutdown(2);
3954 do_encoding_shutdown(3);
3955 do_encoding_shutdown(4);
3959 fn encoding_closing_signed() {
3960 let secp_ctx = Secp256k1::new();
3961 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3962 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3963 let closing_signed = msgs::ClosingSigned {
3964 channel_id: ChannelId::from_bytes([2; 32]),
3965 fee_satoshis: 2316138423780173,
3969 let encoded_value = closing_signed.encode();
3970 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3971 assert_eq!(encoded_value, target_value);
3972 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value)).unwrap(), closing_signed);
3974 let closing_signed_with_range = msgs::ClosingSigned {
3975 channel_id: ChannelId::from_bytes([2; 32]),
3976 fee_satoshis: 2316138423780173,
3978 fee_range: Some(msgs::ClosingSignedFeeRange {
3979 min_fee_satoshis: 0xdeadbeef,
3980 max_fee_satoshis: 0x1badcafe01234567,
3983 let encoded_value_with_range = closing_signed_with_range.encode();
3984 let target_value_with_range = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a011000000000deadbeef1badcafe01234567").unwrap();
3985 assert_eq!(encoded_value_with_range, target_value_with_range);
3986 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value_with_range)).unwrap(),
3987 closing_signed_with_range);
3991 fn encoding_update_add_htlc() {
3992 let secp_ctx = Secp256k1::new();
3993 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3994 let onion_routing_packet = msgs::OnionPacket {
3996 public_key: Ok(pubkey_1),
3997 hop_data: [1; 20*65],
4000 let update_add_htlc = msgs::UpdateAddHTLC {
4001 channel_id: ChannelId::from_bytes([2; 32]),
4002 htlc_id: 2316138423780173,
4003 amount_msat: 3608586615801332854,
4004 payment_hash: PaymentHash([1; 32]),
4005 cltv_expiry: 821716,
4006 onion_routing_packet,
4007 skimmed_fee_msat: None,
4008 blinding_point: None,
4010 let encoded_value = update_add_htlc.encode();
4011 let target_value = <Vec<u8>>::from_hex("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").unwrap();
4012 assert_eq!(encoded_value, target_value);
4016 fn encoding_update_fulfill_htlc() {
4017 let update_fulfill_htlc = msgs::UpdateFulfillHTLC {
4018 channel_id: ChannelId::from_bytes([2; 32]),
4019 htlc_id: 2316138423780173,
4020 payment_preimage: PaymentPreimage([1; 32]),
4022 let encoded_value = update_fulfill_htlc.encode();
4023 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d0101010101010101010101010101010101010101010101010101010101010101").unwrap();
4024 assert_eq!(encoded_value, target_value);
4028 fn encoding_update_fail_htlc() {
4029 let reason = OnionErrorPacket {
4030 data: [1; 32].to_vec(),
4032 let update_fail_htlc = msgs::UpdateFailHTLC {
4033 channel_id: ChannelId::from_bytes([2; 32]),
4034 htlc_id: 2316138423780173,
4037 let encoded_value = update_fail_htlc.encode();
4038 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d00200101010101010101010101010101010101010101010101010101010101010101").unwrap();
4039 assert_eq!(encoded_value, target_value);
4043 fn encoding_update_fail_malformed_htlc() {
4044 let update_fail_malformed_htlc = msgs::UpdateFailMalformedHTLC {
4045 channel_id: ChannelId::from_bytes([2; 32]),
4046 htlc_id: 2316138423780173,
4047 sha256_of_onion: [1; 32],
4050 let encoded_value = update_fail_malformed_htlc.encode();
4051 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d010101010101010101010101010101010101010101010101010101010101010100ff").unwrap();
4052 assert_eq!(encoded_value, target_value);
4055 fn do_encoding_commitment_signed(htlcs: bool) {
4056 let secp_ctx = Secp256k1::new();
4057 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4058 let (privkey_2, _) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
4059 let (privkey_3, _) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
4060 let (privkey_4, _) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
4061 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
4062 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
4063 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
4064 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
4065 let commitment_signed = msgs::CommitmentSigned {
4066 channel_id: ChannelId::from_bytes([2; 32]),
4068 htlc_signatures: if htlcs { vec![sig_2, sig_3, sig_4] } else { Vec::new() },
4070 partial_signature_with_nonce: None,
4072 let encoded_value = commitment_signed.encode();
4073 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
4075 target_value.append(&mut <Vec<u8>>::from_hex("00031735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
4077 target_value.append(&mut <Vec<u8>>::from_hex("0000").unwrap());
4079 assert_eq!(encoded_value, target_value);
4083 fn encoding_commitment_signed() {
4084 do_encoding_commitment_signed(true);
4085 do_encoding_commitment_signed(false);
4089 fn encoding_revoke_and_ack() {
4090 let secp_ctx = Secp256k1::new();
4091 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4092 let raa = msgs::RevokeAndACK {
4093 channel_id: ChannelId::from_bytes([2; 32]),
4094 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],
4095 next_per_commitment_point: pubkey_1,
4097 next_local_nonce: None,
4099 let encoded_value = raa.encode();
4100 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020101010101010101010101010101010101010101010101010101010101010101031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
4101 assert_eq!(encoded_value, target_value);
4105 fn encoding_update_fee() {
4106 let update_fee = msgs::UpdateFee {
4107 channel_id: ChannelId::from_bytes([2; 32]),
4108 feerate_per_kw: 20190119,
4110 let encoded_value = update_fee.encode();
4111 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202013413a7").unwrap();
4112 assert_eq!(encoded_value, target_value);
4116 fn encoding_init() {
4117 let mainnet_hash = ChainHash::using_genesis_block(Network::Bitcoin);
4118 assert_eq!(msgs::Init {
4119 features: InitFeatures::from_le_bytes(vec![0xFF, 0xFF, 0xFF]),
4120 networks: Some(vec![mainnet_hash]),
4121 remote_network_address: None,
4122 }.encode(), <Vec<u8>>::from_hex("00023fff0003ffffff01206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
4123 assert_eq!(msgs::Init {
4124 features: InitFeatures::from_le_bytes(vec![0xFF]),
4126 remote_network_address: None,
4127 }.encode(), <Vec<u8>>::from_hex("0001ff0001ff").unwrap());
4128 assert_eq!(msgs::Init {
4129 features: InitFeatures::from_le_bytes(vec![]),
4130 networks: Some(vec![mainnet_hash]),
4131 remote_network_address: None,
4132 }.encode(), <Vec<u8>>::from_hex("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
4133 assert_eq!(msgs::Init {
4134 features: InitFeatures::from_le_bytes(vec![]),
4135 networks: Some(vec![ChainHash::from(&[1; 32]), ChainHash::from(&[2; 32])]),
4136 remote_network_address: None,
4137 }.encode(), <Vec<u8>>::from_hex("00000000014001010101010101010101010101010101010101010101010101010101010101010202020202020202020202020202020202020202020202020202020202020202").unwrap());
4138 let init_msg = msgs::Init { features: InitFeatures::from_le_bytes(vec![]),
4139 networks: Some(vec![mainnet_hash]),
4140 remote_network_address: Some(SocketAddress::TcpIpV4 {
4141 addr: [127, 0, 0, 1],
4145 let encoded_value = init_msg.encode();
4146 let target_value = <Vec<u8>>::from_hex("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d61900000000000307017f00000103e8").unwrap();
4147 assert_eq!(encoded_value, target_value);
4148 assert_eq!(msgs::Init::read(&mut Cursor::new(&target_value)).unwrap(), init_msg);
4152 fn encoding_error() {
4153 let error = msgs::ErrorMessage {
4154 channel_id: ChannelId::from_bytes([2; 32]),
4155 data: String::from("rust-lightning"),
4157 let encoded_value = error.encode();
4158 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
4159 assert_eq!(encoded_value, target_value);
4163 fn encoding_warning() {
4164 let error = msgs::WarningMessage {
4165 channel_id: ChannelId::from_bytes([2; 32]),
4166 data: String::from("rust-lightning"),
4168 let encoded_value = error.encode();
4169 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
4170 assert_eq!(encoded_value, target_value);
4174 fn encoding_ping() {
4175 let ping = msgs::Ping {
4179 let encoded_value = ping.encode();
4180 let target_value = <Vec<u8>>::from_hex("0040004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
4181 assert_eq!(encoded_value, target_value);
4185 fn encoding_pong() {
4186 let pong = msgs::Pong {
4189 let encoded_value = pong.encode();
4190 let target_value = <Vec<u8>>::from_hex("004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
4191 assert_eq!(encoded_value, target_value);
4195 fn encoding_nonfinal_onion_hop_data() {
4196 let outbound_msg = msgs::OutboundOnionPayload::Forward {
4197 short_channel_id: 0xdeadbeef1bad1dea,
4198 amt_to_forward: 0x0badf00d01020304,
4199 outgoing_cltv_value: 0xffffffff,
4201 let encoded_value = outbound_msg.encode();
4202 let target_value = <Vec<u8>>::from_hex("1a02080badf00d010203040404ffffffff0608deadbeef1bad1dea").unwrap();
4203 assert_eq!(encoded_value, target_value);
4205 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4206 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4207 if let msgs::InboundOnionPayload::Forward {
4208 short_channel_id, amt_to_forward, outgoing_cltv_value
4210 assert_eq!(short_channel_id, 0xdeadbeef1bad1dea);
4211 assert_eq!(amt_to_forward, 0x0badf00d01020304);
4212 assert_eq!(outgoing_cltv_value, 0xffffffff);
4213 } else { panic!(); }
4217 fn encoding_final_onion_hop_data() {
4218 let outbound_msg = msgs::OutboundOnionPayload::Receive {
4220 payment_metadata: None,
4221 keysend_preimage: None,
4222 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4223 cltv_expiry_height: 0xffffffff,
4224 custom_tlvs: vec![],
4226 let encoded_value = outbound_msg.encode();
4227 let target_value = <Vec<u8>>::from_hex("1002080badf00d010203040404ffffffff").unwrap();
4228 assert_eq!(encoded_value, target_value);
4230 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4231 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4232 if let msgs::InboundOnionPayload::Receive {
4233 payment_data: None, sender_intended_htlc_amt_msat, cltv_expiry_height, ..
4235 assert_eq!(sender_intended_htlc_amt_msat, 0x0badf00d01020304);
4236 assert_eq!(cltv_expiry_height, 0xffffffff);
4237 } else { panic!(); }
4241 fn encoding_final_onion_hop_data_with_secret() {
4242 let expected_payment_secret = PaymentSecret([0x42u8; 32]);
4243 let outbound_msg = msgs::OutboundOnionPayload::Receive {
4244 payment_data: Some(FinalOnionHopData {
4245 payment_secret: expected_payment_secret,
4246 total_msat: 0x1badca1f
4248 payment_metadata: None,
4249 keysend_preimage: None,
4250 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4251 cltv_expiry_height: 0xffffffff,
4252 custom_tlvs: vec![],
4254 let encoded_value = outbound_msg.encode();
4255 let target_value = <Vec<u8>>::from_hex("3602080badf00d010203040404ffffffff082442424242424242424242424242424242424242424242424242424242424242421badca1f").unwrap();
4256 assert_eq!(encoded_value, target_value);
4258 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4259 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4260 if let msgs::InboundOnionPayload::Receive {
4261 payment_data: Some(FinalOnionHopData {
4263 total_msat: 0x1badca1f
4265 sender_intended_htlc_amt_msat, cltv_expiry_height,
4266 payment_metadata: None,
4267 keysend_preimage: None,
4270 assert_eq!(payment_secret, expected_payment_secret);
4271 assert_eq!(sender_intended_htlc_amt_msat, 0x0badf00d01020304);
4272 assert_eq!(cltv_expiry_height, 0xffffffff);
4273 assert_eq!(custom_tlvs, vec![]);
4274 } else { panic!(); }
4278 fn encoding_final_onion_hop_data_with_bad_custom_tlvs() {
4279 // If custom TLVs have type number within the range reserved for protocol, treat them as if
4281 let bad_type_range_tlvs = vec![
4282 ((1 << 16) - 4, vec![42]),
4283 ((1 << 16) - 2, vec![42; 32]),
4285 let mut msg = msgs::OutboundOnionPayload::Receive {
4287 payment_metadata: None,
4288 keysend_preimage: None,
4289 custom_tlvs: bad_type_range_tlvs,
4290 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4291 cltv_expiry_height: 0xffffffff,
4293 let encoded_value = msg.encode();
4294 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4295 assert!(msgs::InboundOnionPayload::read(&mut Cursor::new(&encoded_value[..]), (None, &&node_signer)).is_err());
4296 let good_type_range_tlvs = vec![
4297 ((1 << 16) - 3, vec![42]),
4298 ((1 << 16) - 1, vec![42; 32]),
4300 if let msgs::OutboundOnionPayload::Receive { ref mut custom_tlvs, .. } = msg {
4301 *custom_tlvs = good_type_range_tlvs.clone();
4303 let encoded_value = msg.encode();
4304 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&encoded_value[..]), (None, &&node_signer)).unwrap();
4306 msgs::InboundOnionPayload::Receive { custom_tlvs, .. } => assert!(custom_tlvs.is_empty()),
4312 fn encoding_final_onion_hop_data_with_custom_tlvs() {
4313 let expected_custom_tlvs = vec![
4314 (5482373483, vec![0x12, 0x34]),
4315 (5482373487, vec![0x42u8; 8]),
4317 let msg = msgs::OutboundOnionPayload::Receive {
4319 payment_metadata: None,
4320 keysend_preimage: None,
4321 custom_tlvs: expected_custom_tlvs.clone(),
4322 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4323 cltv_expiry_height: 0xffffffff,
4325 let encoded_value = msg.encode();
4326 let target_value = <Vec<u8>>::from_hex("2e02080badf00d010203040404ffffffffff0000000146c6616b021234ff0000000146c6616f084242424242424242").unwrap();
4327 assert_eq!(encoded_value, target_value);
4328 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4329 let inbound_msg: msgs::InboundOnionPayload = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4330 if let msgs::InboundOnionPayload::Receive {
4332 payment_metadata: None,
4333 keysend_preimage: None,
4335 sender_intended_htlc_amt_msat,
4336 cltv_expiry_height: outgoing_cltv_value,
4339 assert_eq!(custom_tlvs, expected_custom_tlvs);
4340 assert_eq!(sender_intended_htlc_amt_msat, 0x0badf00d01020304);
4341 assert_eq!(outgoing_cltv_value, 0xffffffff);
4342 } else { panic!(); }
4346 fn query_channel_range_end_blocknum() {
4347 let tests: Vec<(u32, u32, u32)> = vec![
4348 (10000, 1500, 11500),
4349 (0, 0xffffffff, 0xffffffff),
4350 (1, 0xffffffff, 0xffffffff),
4353 for (first_blocknum, number_of_blocks, expected) in tests.into_iter() {
4354 let sut = msgs::QueryChannelRange {
4355 chain_hash: ChainHash::using_genesis_block(Network::Regtest),
4359 assert_eq!(sut.end_blocknum(), expected);
4364 fn encoding_query_channel_range() {
4365 let mut query_channel_range = msgs::QueryChannelRange {
4366 chain_hash: ChainHash::using_genesis_block(Network::Regtest),
4367 first_blocknum: 100000,
4368 number_of_blocks: 1500,
4370 let encoded_value = query_channel_range.encode();
4371 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000186a0000005dc").unwrap();
4372 assert_eq!(encoded_value, target_value);
4374 query_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4375 assert_eq!(query_channel_range.first_blocknum, 100000);
4376 assert_eq!(query_channel_range.number_of_blocks, 1500);
4380 fn encoding_reply_channel_range() {
4381 do_encoding_reply_channel_range(0);
4382 do_encoding_reply_channel_range(1);
4385 fn do_encoding_reply_channel_range(encoding_type: u8) {
4386 let mut target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000b8a06000005dc01").unwrap();
4387 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4388 let mut reply_channel_range = msgs::ReplyChannelRange {
4389 chain_hash: expected_chain_hash,
4390 first_blocknum: 756230,
4391 number_of_blocks: 1500,
4392 sync_complete: true,
4393 short_channel_ids: vec![0x000000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
4396 if encoding_type == 0 {
4397 target_value.append(&mut <Vec<u8>>::from_hex("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
4398 let encoded_value = reply_channel_range.encode();
4399 assert_eq!(encoded_value, target_value);
4401 reply_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4402 assert_eq!(reply_channel_range.chain_hash, expected_chain_hash);
4403 assert_eq!(reply_channel_range.first_blocknum, 756230);
4404 assert_eq!(reply_channel_range.number_of_blocks, 1500);
4405 assert_eq!(reply_channel_range.sync_complete, true);
4406 assert_eq!(reply_channel_range.short_channel_ids[0], 0x000000000000008e);
4407 assert_eq!(reply_channel_range.short_channel_ids[1], 0x0000000000003c69);
4408 assert_eq!(reply_channel_range.short_channel_ids[2], 0x000000000045a6c4);
4410 target_value.append(&mut <Vec<u8>>::from_hex("001601789c636000833e08659309a65878be010010a9023a").unwrap());
4411 let result: Result<msgs::ReplyChannelRange, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
4412 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
4417 fn encoding_query_short_channel_ids() {
4418 do_encoding_query_short_channel_ids(0);
4419 do_encoding_query_short_channel_ids(1);
4422 fn do_encoding_query_short_channel_ids(encoding_type: u8) {
4423 let mut target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
4424 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4425 let mut query_short_channel_ids = msgs::QueryShortChannelIds {
4426 chain_hash: expected_chain_hash,
4427 short_channel_ids: vec![0x0000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
4430 if encoding_type == 0 {
4431 target_value.append(&mut <Vec<u8>>::from_hex("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
4432 let encoded_value = query_short_channel_ids.encode();
4433 assert_eq!(encoded_value, target_value);
4435 query_short_channel_ids = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4436 assert_eq!(query_short_channel_ids.chain_hash, expected_chain_hash);
4437 assert_eq!(query_short_channel_ids.short_channel_ids[0], 0x000000000000008e);
4438 assert_eq!(query_short_channel_ids.short_channel_ids[1], 0x0000000000003c69);
4439 assert_eq!(query_short_channel_ids.short_channel_ids[2], 0x000000000045a6c4);
4441 target_value.append(&mut <Vec<u8>>::from_hex("001601789c636000833e08659309a65878be010010a9023a").unwrap());
4442 let result: Result<msgs::QueryShortChannelIds, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
4443 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
4448 fn encoding_reply_short_channel_ids_end() {
4449 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4450 let mut reply_short_channel_ids_end = msgs::ReplyShortChannelIdsEnd {
4451 chain_hash: expected_chain_hash,
4452 full_information: true,
4454 let encoded_value = reply_short_channel_ids_end.encode();
4455 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f01").unwrap();
4456 assert_eq!(encoded_value, target_value);
4458 reply_short_channel_ids_end = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4459 assert_eq!(reply_short_channel_ids_end.chain_hash, expected_chain_hash);
4460 assert_eq!(reply_short_channel_ids_end.full_information, true);
4464 fn encoding_gossip_timestamp_filter(){
4465 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4466 let mut gossip_timestamp_filter = msgs::GossipTimestampFilter {
4467 chain_hash: expected_chain_hash,
4468 first_timestamp: 1590000000,
4469 timestamp_range: 0xffff_ffff,
4471 let encoded_value = gossip_timestamp_filter.encode();
4472 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f5ec57980ffffffff").unwrap();
4473 assert_eq!(encoded_value, target_value);
4475 gossip_timestamp_filter = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4476 assert_eq!(gossip_timestamp_filter.chain_hash, expected_chain_hash);
4477 assert_eq!(gossip_timestamp_filter.first_timestamp, 1590000000);
4478 assert_eq!(gossip_timestamp_filter.timestamp_range, 0xffff_ffff);
4482 fn decode_onion_hop_data_len_as_bigsize() {
4483 // Tests that we can decode an onion payload that is >253 bytes.
4484 // Previously, receiving a payload of this size could've caused us to fail to decode a valid
4485 // payload, because we were decoding the length (a BigSize, big-endian) as a VarInt
4488 // Encode a test onion payload with a big custom TLV such that it's >253 bytes, forcing the
4489 // payload length to be encoded over multiple bytes rather than a single u8.
4490 let big_payload = encode_big_payload().unwrap();
4491 let mut rd = Cursor::new(&big_payload[..]);
4493 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4494 <msgs::InboundOnionPayload as ReadableArgs<(Option<PublicKey>, &&test_utils::TestKeysInterface)>>
4495 ::read(&mut rd, (None, &&node_signer)).unwrap();
4497 // see above test, needs to be a separate method for use of the serialization macros.
4498 fn encode_big_payload() -> Result<Vec<u8>, io::Error> {
4499 use crate::util::ser::HighZeroBytesDroppedBigSize;
4500 let payload = msgs::OutboundOnionPayload::Forward {
4501 short_channel_id: 0xdeadbeef1bad1dea,
4502 amt_to_forward: 1000,
4503 outgoing_cltv_value: 0xffffffff,
4505 let mut encoded_payload = Vec::new();
4506 let test_bytes = vec![42u8; 1000];
4507 if let msgs::OutboundOnionPayload::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } = payload {
4508 _encode_varint_length_prefixed_tlv!(&mut encoded_payload, {
4509 (1, test_bytes, required_vec),
4510 (2, HighZeroBytesDroppedBigSize(amt_to_forward), required),
4511 (4, HighZeroBytesDroppedBigSize(outgoing_cltv_value), required),
4512 (6, short_channel_id, required)
4519 #[cfg(feature = "std")]
4520 fn test_socket_address_from_str() {
4521 let tcpip_v4 = SocketAddress::TcpIpV4 {
4522 addr: Ipv4Addr::new(127, 0, 0, 1).octets(),
4525 assert_eq!(tcpip_v4, SocketAddress::from_str("127.0.0.1:1234").unwrap());
4526 assert_eq!(tcpip_v4, SocketAddress::from_str(&tcpip_v4.to_string()).unwrap());
4528 let tcpip_v6 = SocketAddress::TcpIpV6 {
4529 addr: Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1).octets(),
4532 assert_eq!(tcpip_v6, SocketAddress::from_str("[0:0:0:0:0:0:0:1]:1234").unwrap());
4533 assert_eq!(tcpip_v6, SocketAddress::from_str(&tcpip_v6.to_string()).unwrap());
4535 let hostname = SocketAddress::Hostname {
4536 hostname: Hostname::try_from("lightning-node.mydomain.com".to_string()).unwrap(),
4539 assert_eq!(hostname, SocketAddress::from_str("lightning-node.mydomain.com:1234").unwrap());
4540 assert_eq!(hostname, SocketAddress::from_str(&hostname.to_string()).unwrap());
4542 let onion_v2 = SocketAddress::OnionV2 ([40, 4, 64, 185, 202, 19, 162, 75, 90, 200, 38, 7],);
4543 assert_eq!("OnionV2([40, 4, 64, 185, 202, 19, 162, 75, 90, 200, 38, 7])", &onion_v2.to_string());
4544 assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("FACEBOOKCOREWWWI.onion:9735"));
4546 let onion_v3 = SocketAddress::OnionV3 {
4547 ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102, 182, 107, 4, 105, 247, 246, 85,
4548 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31, 33, 71, 3],
4553 assert_eq!(onion_v3, SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion:1234").unwrap());
4554 assert_eq!(onion_v3, SocketAddress::from_str(&onion_v3.to_string()).unwrap());
4556 assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6.onion:1234"));
4557 assert_eq!(Err(SocketAddressParseError::InvalidInput), SocketAddress::from_str("127.0.0.1@1234"));
4558 assert_eq!(Err(SocketAddressParseError::InvalidInput), "".parse::<SocketAddress>());
4559 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:9735:94").is_err());
4560 assert!(SocketAddress::from_str("wrong$%#.com:1234").is_err());
4561 assert_eq!(Err(SocketAddressParseError::InvalidPort), SocketAddress::from_str("example.com:wrong"));
4562 assert!("localhost".parse::<SocketAddress>().is_err());
4563 assert!("localhost:invalid-port".parse::<SocketAddress>().is_err());
4564 assert!( "invalid-onion-v3-hostname.onion:8080".parse::<SocketAddress>().is_err());
4565 assert!("b32.example.onion:invalid-port".parse::<SocketAddress>().is_err());
4566 assert!("invalid-address".parse::<SocketAddress>().is_err());
4567 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:1234").is_err());
4571 #[cfg(feature = "std")]
4572 fn test_socket_address_to_socket_addrs() {
4573 assert_eq!(SocketAddress::TcpIpV4 {addr:[0u8; 4], port: 1337,}.to_socket_addrs().unwrap().next().unwrap(),
4574 SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(0,0,0,0), 1337)));
4575 assert_eq!(SocketAddress::TcpIpV6 {addr:[0u8; 16], port: 1337,}.to_socket_addrs().unwrap().next().unwrap(),
4576 SocketAddr::V6(SocketAddrV6::new(Ipv6Addr::from([0u8; 16]), 1337, 0, 0)));
4577 assert_eq!(SocketAddress::Hostname { hostname: Hostname::try_from("0.0.0.0".to_string()).unwrap(), port: 0 }
4578 .to_socket_addrs().unwrap().next().unwrap(), SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::from([0u8; 4]),0)));
4579 assert!(SocketAddress::OnionV2([0u8; 12]).to_socket_addrs().is_err());
4580 assert!(SocketAddress::OnionV3{ ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102,
4581 182, 107, 4, 105, 247, 246, 85, 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31,
4585 port: 1234 }.to_socket_addrs().is_err());