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 #[allow(unused_imports)]
42 use crate::prelude::*;
44 #[cfg(feature = "std")]
45 use core::convert::TryFrom;
49 #[cfg(feature = "std")]
50 use core::str::FromStr;
51 #[cfg(feature = "std")]
52 use std::net::SocketAddr;
53 use core::fmt::Display;
54 use crate::io::{self, Cursor, Read};
55 use crate::io_extras::read_to_end;
57 use crate::events::{EventsProvider, MessageSendEventsProvider};
58 use crate::crypto::streams::ChaChaPolyReadAdapter;
59 use crate::util::logger;
60 use crate::util::ser::{LengthReadable, LengthReadableArgs, Readable, ReadableArgs, Writeable, Writer, WithoutLength, FixedLengthReader, HighZeroBytesDroppedBigSize, Hostname, TransactionU16LenLimited, BigSize};
61 use crate::util::base32;
63 use crate::routing::gossip::{NodeAlias, NodeId};
65 /// 21 million * 10^8 * 1000
66 pub(crate) const MAX_VALUE_MSAT: u64 = 21_000_000_0000_0000_000;
69 /// A partial signature that also contains the Musig2 nonce its signer used
70 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
71 pub struct PartialSignatureWithNonce(pub musig2::types::PartialSignature, pub musig2::types::PublicNonce);
73 /// An error in decoding a message or struct.
74 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
75 pub enum DecodeError {
76 /// A version byte specified something we don't know how to handle.
78 /// Includes unknown realm byte in an onion hop data packet.
80 /// Unknown feature mandating we fail to parse message (e.g., TLV with an even, unknown type)
81 UnknownRequiredFeature,
82 /// Value was invalid.
84 /// For example, a byte which was supposed to be a bool was something other than a 0
85 /// or 1, a public key/private key/signature was invalid, text wasn't UTF-8, TLV was
86 /// syntactically incorrect, etc.
88 /// The buffer to be read was too short.
90 /// A length descriptor in the packet didn't describe the later data correctly.
92 /// Error from [`std::io`].
94 /// The message included zlib-compressed values, which we don't support.
95 UnsupportedCompression,
96 /// Value is validly encoded but is dangerous to use.
98 /// This is used for things like [`ChannelManager`] deserialization where we want to ensure
99 /// that we don't use a [`ChannelManager`] which is in out of sync with the [`ChannelMonitor`].
100 /// This indicates that there is a critical implementation flaw in the storage implementation
101 /// and it's unsafe to continue.
103 /// [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
104 /// [`ChannelMonitor`]: crate::chain::channelmonitor::ChannelMonitor
108 /// An [`init`] message to be sent to or received from a peer.
110 /// [`init`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-init-message
111 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
113 /// The relevant features which the sender supports.
114 pub features: InitFeatures,
115 /// Indicates chains the sender is interested in.
117 /// If there are no common chains, the connection will be closed.
118 pub networks: Option<Vec<ChainHash>>,
119 /// The receipient's network address.
121 /// This adds the option to report a remote IP address back to a connecting peer using the init
122 /// message. A node can decide to use that information to discover a potential update to its
123 /// public IPv4 address (NAT) and use that for a [`NodeAnnouncement`] update message containing
125 pub remote_network_address: Option<SocketAddress>,
128 /// An [`error`] message to be sent to or received from a peer.
130 /// [`error`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-error-and-warning-messages
131 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
132 pub struct ErrorMessage {
133 /// The channel ID involved in the error.
135 /// All-0s indicates a general error unrelated to a specific channel, after which all channels
136 /// with the sending peer should be closed.
137 pub channel_id: ChannelId,
138 /// A possibly human-readable error description.
140 /// The string should be sanitized before it is used (e.g., emitted to logs or printed to
141 /// `stdout`). Otherwise, a well crafted error message may trigger a security vulnerability in
142 /// the terminal emulator or the logging subsystem.
146 /// A [`warning`] message to be sent to or received from a peer.
148 /// [`warning`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-error-and-warning-messages
149 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
150 pub struct WarningMessage {
151 /// The channel ID involved in the warning.
153 /// All-0s indicates a warning unrelated to a specific channel.
154 pub channel_id: ChannelId,
155 /// A possibly human-readable warning description.
157 /// The string should be sanitized before it is used (e.g. emitted to logs or printed to
158 /// stdout). Otherwise, a well crafted error message may trigger a security vulnerability in
159 /// the terminal emulator or the logging subsystem.
163 /// A [`ping`] message to be sent to or received from a peer.
165 /// [`ping`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-ping-and-pong-messages
166 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
168 /// The desired response length.
170 /// The ping packet size.
172 /// This field is not sent on the wire. byteslen zeros are sent.
176 /// A [`pong`] message to be sent to or received from a peer.
178 /// [`pong`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-ping-and-pong-messages
179 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
181 /// The pong packet size.
183 /// This field is not sent on the wire. byteslen zeros are sent.
187 /// Contains fields that are both common to [`open_channel`] and `open_channel2` messages.
189 /// [`open_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-open_channel-message
190 // TODO(dual_funding): Add spec link for `open_channel2`.
191 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
192 pub struct CommonOpenChannelFields {
193 /// The genesis hash of the blockchain where the channel is to be opened
194 pub chain_hash: ChainHash,
195 /// A temporary channel ID
196 /// For V2 channels: derived using a zeroed out value for the channel acceptor's revocation basepoint
197 /// For V1 channels: a temporary channel ID, until the funding outpoint is announced
198 pub temporary_channel_id: ChannelId,
199 /// For V1 channels: The channel value
200 /// For V2 channels: Part of the channel value contributed by the channel initiator
201 pub funding_satoshis: u64,
202 /// The threshold below which outputs on transactions broadcast by the channel initiator will be
204 pub dust_limit_satoshis: u64,
205 /// The maximum inbound HTLC value in flight towards channel initiator, in milli-satoshi
206 pub max_htlc_value_in_flight_msat: u64,
207 /// The minimum HTLC size incoming to channel initiator, in milli-satoshi
208 pub htlc_minimum_msat: u64,
209 /// The feerate for the commitment transaction set by the channel initiator until updated by
211 pub commitment_feerate_sat_per_1000_weight: u32,
212 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
213 /// broadcast a commitment transaction
214 pub to_self_delay: u16,
215 /// The maximum number of inbound HTLCs towards channel initiator
216 pub max_accepted_htlcs: u16,
217 /// The channel initiator's key controlling the funding transaction
218 pub funding_pubkey: PublicKey,
219 /// Used to derive a revocation key for transactions broadcast by counterparty
220 pub revocation_basepoint: PublicKey,
221 /// A payment key to channel initiator for transactions broadcast by counterparty
222 pub payment_basepoint: PublicKey,
223 /// Used to derive a payment key to channel initiator for transactions broadcast by channel
225 pub delayed_payment_basepoint: PublicKey,
226 /// Used to derive an HTLC payment key to channel initiator
227 pub htlc_basepoint: PublicKey,
228 /// The first to-be-broadcast-by-channel-initiator transaction's per commitment point
229 pub first_per_commitment_point: PublicKey,
230 /// The channel flags to be used
231 pub channel_flags: u8,
232 /// Optionally, a request to pre-set the to-channel-initiator output's scriptPubkey for when we
233 /// collaboratively close
234 pub shutdown_scriptpubkey: Option<ScriptBuf>,
235 /// The channel type that this channel will represent
237 /// If this is `None`, we derive the channel type from the intersection of our
238 /// feature bits with our counterparty's feature bits from the [`Init`] message.
239 pub channel_type: Option<ChannelTypeFeatures>,
242 /// An [`open_channel`] message to be sent to or received from a peer.
244 /// Used in V1 channel establishment
246 /// [`open_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-open_channel-message
247 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
248 pub struct OpenChannel {
249 /// Common fields of `open_channel(2)`-like messages
250 pub common_fields: CommonOpenChannelFields,
251 /// The amount to push to the counterparty as part of the open, in milli-satoshi
253 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
254 pub channel_reserve_satoshis: u64,
257 /// An open_channel2 message to be sent by or received from the channel initiator.
259 /// Used in V2 channel establishment
261 // TODO(dual_funding): Add spec link for `open_channel2`.
262 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
263 pub struct OpenChannelV2 {
264 /// Common fields of `open_channel(2)`-like messages
265 pub common_fields: CommonOpenChannelFields,
266 /// The feerate for the funding transaction set by the channel initiator
267 pub funding_feerate_sat_per_1000_weight: u32,
268 /// The locktime for the funding transaction
270 /// The second to-be-broadcast-by-channel-initiator transaction's per commitment point
271 pub second_per_commitment_point: PublicKey,
272 /// Optionally, a requirement that only confirmed inputs can be added
273 pub require_confirmed_inputs: Option<()>,
276 /// Contains fields that are both common to [`accept_channel`] and `accept_channel2` messages.
278 /// [`accept_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-accept_channel-message
279 // TODO(dual_funding): Add spec link for `accept_channel2`.
280 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
281 pub struct CommonAcceptChannelFields {
282 /// The same `temporary_channel_id` received from the initiator's `open_channel2` or `open_channel` message.
283 pub temporary_channel_id: ChannelId,
284 /// The threshold below which outputs on transactions broadcast by the channel acceptor will be
286 pub dust_limit_satoshis: u64,
287 /// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
288 pub max_htlc_value_in_flight_msat: u64,
289 /// The minimum HTLC size incoming to channel acceptor, in milli-satoshi
290 pub htlc_minimum_msat: u64,
291 /// Minimum depth of the funding transaction before the channel is considered open
292 pub minimum_depth: u32,
293 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
294 /// broadcast a commitment transaction
295 pub to_self_delay: u16,
296 /// The maximum number of inbound HTLCs towards channel acceptor
297 pub max_accepted_htlcs: u16,
298 /// The channel acceptor's key controlling the funding transaction
299 pub funding_pubkey: PublicKey,
300 /// Used to derive a revocation key for transactions broadcast by counterparty
301 pub revocation_basepoint: PublicKey,
302 /// A payment key to channel acceptor for transactions broadcast by counterparty
303 pub payment_basepoint: PublicKey,
304 /// Used to derive a payment key to channel acceptor for transactions broadcast by channel
306 pub delayed_payment_basepoint: PublicKey,
307 /// Used to derive an HTLC payment key to channel acceptor for transactions broadcast by counterparty
308 pub htlc_basepoint: PublicKey,
309 /// The first to-be-broadcast-by-channel-acceptor transaction's per commitment point
310 pub first_per_commitment_point: PublicKey,
311 /// Optionally, a request to pre-set the to-channel-acceptor output's scriptPubkey for when we
312 /// collaboratively close
313 pub shutdown_scriptpubkey: Option<ScriptBuf>,
314 /// The channel type that this channel will represent. If none is set, we derive the channel
315 /// type from the intersection of our feature bits with our counterparty's feature bits from
316 /// the Init message.
318 /// This is required to match the equivalent field in [`OpenChannel`] or [`OpenChannelV2`]'s
319 /// [`CommonOpenChannelFields::channel_type`].
320 pub channel_type: Option<ChannelTypeFeatures>,
323 /// An [`accept_channel`] message to be sent to or received from a peer.
325 /// Used in V1 channel establishment
327 /// [`accept_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-accept_channel-message
328 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
329 pub struct AcceptChannel {
330 /// Common fields of `accept_channel(2)`-like messages
331 pub common_fields: CommonAcceptChannelFields,
332 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
333 pub channel_reserve_satoshis: u64,
335 /// Next nonce the channel initiator should use to create a funding output signature against
336 pub next_local_nonce: Option<musig2::types::PublicNonce>,
339 /// An accept_channel2 message to be sent by or received from the channel accepter.
341 /// Used in V2 channel establishment
343 // TODO(dual_funding): Add spec link for `accept_channel2`.
344 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
345 pub struct AcceptChannelV2 {
346 /// Common fields of `accept_channel(2)`-like messages
347 pub common_fields: CommonAcceptChannelFields,
348 /// Part of the channel value contributed by the channel acceptor
349 pub funding_satoshis: u64,
350 /// The second to-be-broadcast-by-channel-acceptor transaction's per commitment point
351 pub second_per_commitment_point: PublicKey,
352 /// Optionally, a requirement that only confirmed inputs can be added
353 pub require_confirmed_inputs: Option<()>,
356 /// A [`funding_created`] message to be sent to or received from a peer.
358 /// Used in V1 channel establishment
360 /// [`funding_created`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-funding_created-message
361 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
362 pub struct FundingCreated {
363 /// A temporary channel ID, until the funding is established
364 pub temporary_channel_id: ChannelId,
365 /// The funding transaction ID
366 pub funding_txid: Txid,
367 /// The specific output index funding this channel
368 pub funding_output_index: u16,
369 /// The signature of the channel initiator (funder) on the initial commitment transaction
370 pub signature: Signature,
372 /// The partial signature of the channel initiator (funder)
373 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
375 /// Next nonce the channel acceptor should use to finalize the funding output signature
376 pub next_local_nonce: Option<musig2::types::PublicNonce>
379 /// A [`funding_signed`] message to be sent to or received from a peer.
381 /// Used in V1 channel establishment
383 /// [`funding_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-funding_signed-message
384 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
385 pub struct FundingSigned {
387 pub channel_id: ChannelId,
388 /// The signature of the channel acceptor (fundee) on the initial commitment transaction
389 pub signature: Signature,
391 /// The partial signature of the channel acceptor (fundee)
392 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
395 /// A [`channel_ready`] message to be sent to or received from a peer.
397 /// [`channel_ready`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-channel_ready-message
398 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
399 pub struct ChannelReady {
401 pub channel_id: ChannelId,
402 /// The per-commitment point of the second commitment transaction
403 pub next_per_commitment_point: PublicKey,
404 /// If set, provides a `short_channel_id` alias for this channel.
406 /// The sender will accept payments to be forwarded over this SCID and forward them to this
407 /// messages' recipient.
408 pub short_channel_id_alias: Option<u64>,
411 /// A randomly chosen number that is used to identify inputs within an interactive transaction
413 pub type SerialId = u64;
415 /// An stfu (quiescence) message to be sent by or received from the stfu initiator.
416 // TODO(splicing): Add spec link for `stfu`; still in draft, using from https://github.com/lightning/bolts/pull/863
417 #[derive(Clone, Debug, PartialEq, Eq)]
419 /// The channel ID where quiescence is intended
420 pub channel_id: ChannelId,
421 /// Initiator flag, 1 if initiating, 0 if replying to an stfu.
425 /// A splice message to be sent by or received from the stfu initiator (splice initiator).
426 // TODO(splicing): Add spec link for `splice`; still in draft, using from https://github.com/lightning/bolts/pull/863
427 #[derive(Clone, Debug, PartialEq, Eq)]
429 /// The channel ID where splicing is intended
430 pub channel_id: ChannelId,
431 /// The genesis hash of the blockchain where the channel is intended to be spliced
432 pub chain_hash: ChainHash,
433 /// The intended change in channel capacity: the amount to be added (positive value)
434 /// or removed (negative value) by the sender (splice initiator) by splicing into/from the channel.
435 pub relative_satoshis: i64,
436 /// The feerate for the new funding transaction, set by the splice initiator
437 pub funding_feerate_perkw: u32,
438 /// The locktime for the new funding transaction
440 /// The key of the sender (splice initiator) controlling the new funding transaction
441 pub funding_pubkey: PublicKey,
444 /// A splice_ack message to be received by or sent to the splice initiator.
446 // TODO(splicing): Add spec link for `splice_ack`; still in draft, using from https://github.com/lightning/bolts/pull/863
447 #[derive(Clone, Debug, PartialEq, Eq)]
448 pub struct SpliceAck {
449 /// The channel ID where splicing is intended
450 pub channel_id: ChannelId,
451 /// The genesis hash of the blockchain where the channel is intended to be spliced
452 pub chain_hash: ChainHash,
453 /// The intended change in channel capacity: the amount to be added (positive value)
454 /// or removed (negative value) by the sender (splice acceptor) by splicing into/from the channel.
455 pub relative_satoshis: i64,
456 /// The key of the sender (splice acceptor) controlling the new funding transaction
457 pub funding_pubkey: PublicKey,
460 /// A splice_locked message to be sent to or received from a peer.
462 // TODO(splicing): Add spec link for `splice_locked`; still in draft, using from https://github.com/lightning/bolts/pull/863
463 #[derive(Clone, Debug, PartialEq, Eq)]
464 pub struct SpliceLocked {
466 pub channel_id: ChannelId,
469 /// A tx_add_input message for adding an input during interactive transaction construction
471 // TODO(dual_funding): Add spec link for `tx_add_input`.
472 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
473 pub struct TxAddInput {
475 pub channel_id: ChannelId,
476 /// A randomly chosen unique identifier for this input, which is even for initiators and odd for
478 pub serial_id: SerialId,
479 /// Serialized transaction that contains the output this input spends to verify that it is non
481 pub prevtx: TransactionU16LenLimited,
482 /// The index of the output being spent
484 /// The sequence number of this input
488 /// A tx_add_output message for adding an output during interactive transaction construction.
490 // TODO(dual_funding): Add spec link for `tx_add_output`.
491 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
492 pub struct TxAddOutput {
494 pub channel_id: ChannelId,
495 /// A randomly chosen unique identifier for this output, which is even for initiators and odd for
497 pub serial_id: SerialId,
498 /// The satoshi value of the output
500 /// The scriptPubKey for the output
501 pub script: ScriptBuf,
504 /// A tx_remove_input message for removing an input during interactive transaction construction.
506 // TODO(dual_funding): Add spec link for `tx_remove_input`.
507 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
508 pub struct TxRemoveInput {
510 pub channel_id: ChannelId,
511 /// The serial ID of the input to be removed
512 pub serial_id: SerialId,
515 /// A tx_remove_output message for removing an output during interactive transaction construction.
517 // TODO(dual_funding): Add spec link for `tx_remove_output`.
518 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
519 pub struct TxRemoveOutput {
521 pub channel_id: ChannelId,
522 /// The serial ID of the output to be removed
523 pub serial_id: SerialId,
526 /// A tx_complete message signalling the conclusion of a peer's transaction contributions during
527 /// interactive transaction construction.
529 // TODO(dual_funding): Add spec link for `tx_complete`.
530 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
531 pub struct TxComplete {
533 pub channel_id: ChannelId,
536 /// A tx_signatures message containing the sender's signatures for a transaction constructed with
537 /// interactive transaction construction.
539 // TODO(dual_funding): Add spec link for `tx_signatures`.
540 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
541 pub struct TxSignatures {
543 pub channel_id: ChannelId,
546 /// The list of witnesses
547 pub witnesses: Vec<Witness>,
550 /// A tx_init_rbf message which initiates a replacement of the transaction after it's been
553 // TODO(dual_funding): Add spec link for `tx_init_rbf`.
554 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
555 pub struct TxInitRbf {
557 pub channel_id: ChannelId,
558 /// The locktime of the transaction
560 /// The feerate of the transaction
561 pub feerate_sat_per_1000_weight: u32,
562 /// The number of satoshis the sender will contribute to or, if negative, remove from
563 /// (e.g. splice-out) the funding output of the transaction
564 pub funding_output_contribution: Option<i64>,
567 /// A tx_ack_rbf message which acknowledges replacement of the transaction after it's been
570 // TODO(dual_funding): Add spec link for `tx_ack_rbf`.
571 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
572 pub struct TxAckRbf {
574 pub channel_id: ChannelId,
575 /// The number of satoshis the sender will contribute to or, if negative, remove from
576 /// (e.g. splice-out) the funding output of the transaction
577 pub funding_output_contribution: Option<i64>,
580 /// A tx_abort message which signals the cancellation of an in-progress transaction negotiation.
582 // TODO(dual_funding): Add spec link for `tx_abort`.
583 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
586 pub channel_id: ChannelId,
591 /// A [`shutdown`] message to be sent to or received from a peer.
593 /// [`shutdown`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-initiation-shutdown
594 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
595 pub struct Shutdown {
597 pub channel_id: ChannelId,
598 /// The destination of this peer's funds on closing.
600 /// Must be in one of these forms: P2PKH, P2SH, P2WPKH, P2WSH, P2TR.
601 pub scriptpubkey: ScriptBuf,
604 /// The minimum and maximum fees which the sender is willing to place on the closing transaction.
606 /// This is provided in [`ClosingSigned`] by both sides to indicate the fee range they are willing
608 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
609 pub struct ClosingSignedFeeRange {
610 /// The minimum absolute fee, in satoshis, which the sender is willing to place on the closing
612 pub min_fee_satoshis: u64,
613 /// The maximum absolute fee, in satoshis, which the sender is willing to place on the closing
615 pub max_fee_satoshis: u64,
618 /// A [`closing_signed`] message to be sent to or received from a peer.
620 /// [`closing_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-negotiation-closing_signed
621 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
622 pub struct ClosingSigned {
624 pub channel_id: ChannelId,
625 /// The proposed total fee for the closing transaction
626 pub fee_satoshis: u64,
627 /// A signature on the closing transaction
628 pub signature: Signature,
629 /// The minimum and maximum fees which the sender is willing to accept, provided only by new
631 pub fee_range: Option<ClosingSignedFeeRange>,
634 /// An [`update_add_htlc`] message to be sent to or received from a peer.
636 /// [`update_add_htlc`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#adding-an-htlc-update_add_htlc
637 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
638 pub struct UpdateAddHTLC {
640 pub channel_id: ChannelId,
643 /// The HTLC value in milli-satoshi
644 pub amount_msat: u64,
645 /// The payment hash, the pre-image of which controls HTLC redemption
646 pub payment_hash: PaymentHash,
647 /// The expiry height of the HTLC
648 pub cltv_expiry: u32,
649 /// The extra fee skimmed by the sender of this message. See
650 /// [`ChannelConfig::accept_underpaying_htlcs`].
652 /// [`ChannelConfig::accept_underpaying_htlcs`]: crate::util::config::ChannelConfig::accept_underpaying_htlcs
653 pub skimmed_fee_msat: Option<u64>,
654 /// The onion routing packet with encrypted data for the next hop.
655 pub onion_routing_packet: OnionPacket,
656 /// Provided if we are relaying or receiving a payment within a blinded path, to decrypt the onion
657 /// routing packet and the recipient-provided encrypted payload within.
658 pub blinding_point: Option<PublicKey>,
661 /// An onion message to be sent to or received from a peer.
663 // TODO: update with link to OM when they are merged into the BOLTs
664 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
665 pub struct OnionMessage {
666 /// Used in decrypting the onion packet's payload.
667 pub blinding_point: PublicKey,
668 /// The full onion packet including hop data, pubkey, and hmac
669 pub onion_routing_packet: onion_message::packet::Packet,
672 /// An [`update_fulfill_htlc`] message to be sent to or received from a peer.
674 /// [`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
675 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
676 pub struct UpdateFulfillHTLC {
678 pub channel_id: ChannelId,
681 /// The pre-image of the payment hash, allowing HTLC redemption
682 pub payment_preimage: PaymentPreimage,
685 /// An [`update_fail_htlc`] message to be sent to or received from a peer.
687 /// [`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
688 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
689 pub struct UpdateFailHTLC {
691 pub channel_id: ChannelId,
694 pub(crate) reason: OnionErrorPacket,
697 /// An [`update_fail_malformed_htlc`] message to be sent to or received from a peer.
699 /// [`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
700 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
701 pub struct UpdateFailMalformedHTLC {
703 pub channel_id: ChannelId,
706 pub(crate) sha256_of_onion: [u8; 32],
708 pub failure_code: u16,
711 /// A [`commitment_signed`] message to be sent to or received from a peer.
713 /// [`commitment_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#committing-updates-so-far-commitment_signed
714 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
715 pub struct CommitmentSigned {
717 pub channel_id: ChannelId,
718 /// A signature on the commitment transaction
719 pub signature: Signature,
720 /// Signatures on the HTLC transactions
721 pub htlc_signatures: Vec<Signature>,
723 /// The partial Taproot signature on the commitment transaction
724 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
727 /// A [`revoke_and_ack`] message to be sent to or received from a peer.
729 /// [`revoke_and_ack`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#completing-the-transition-to-the-updated-state-revoke_and_ack
730 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
731 pub struct RevokeAndACK {
733 pub channel_id: ChannelId,
734 /// The secret corresponding to the per-commitment point
735 pub per_commitment_secret: [u8; 32],
736 /// The next sender-broadcast commitment transaction's per-commitment point
737 pub next_per_commitment_point: PublicKey,
739 /// Musig nonce the recipient should use in their next commitment signature message
740 pub next_local_nonce: Option<musig2::types::PublicNonce>
743 /// An [`update_fee`] message to be sent to or received from a peer
745 /// [`update_fee`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#updating-fees-update_fee
746 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
747 pub struct UpdateFee {
749 pub channel_id: ChannelId,
750 /// Fee rate per 1000-weight of the transaction
751 pub feerate_per_kw: u32,
754 /// A [`channel_reestablish`] message to be sent to or received from a peer.
756 /// [`channel_reestablish`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#message-retransmission
757 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
758 pub struct ChannelReestablish {
760 pub channel_id: ChannelId,
761 /// The next commitment number for the sender
762 pub next_local_commitment_number: u64,
763 /// The next commitment number for the recipient
764 pub next_remote_commitment_number: u64,
765 /// Proof that the sender knows the per-commitment secret of a specific commitment transaction
766 /// belonging to the recipient
767 pub your_last_per_commitment_secret: [u8; 32],
768 /// The sender's per-commitment point for their current commitment transaction
769 pub my_current_per_commitment_point: PublicKey,
770 /// The next funding transaction ID
771 pub next_funding_txid: Option<Txid>,
774 /// An [`announcement_signatures`] message to be sent to or received from a peer.
776 /// [`announcement_signatures`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-announcement_signatures-message
777 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
778 pub struct AnnouncementSignatures {
780 pub channel_id: ChannelId,
781 /// The short channel ID
782 pub short_channel_id: u64,
783 /// A signature by the node key
784 pub node_signature: Signature,
785 /// A signature by the funding key
786 pub bitcoin_signature: Signature,
789 /// An address which can be used to connect to a remote peer.
790 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
791 pub enum SocketAddress {
792 /// An IPv4 address and port on which the peer is listening.
794 /// The 4-byte IPv4 address
796 /// The port on which the node is listening
799 /// An IPv6 address and port on which the peer is listening.
801 /// The 16-byte IPv6 address
803 /// The port on which the node is listening
806 /// An old-style Tor onion address/port on which the peer is listening.
808 /// This field is deprecated and the Tor network generally no longer supports V2 Onion
809 /// addresses. Thus, the details are not parsed here.
811 /// A new-style Tor onion address/port on which the peer is listening.
813 /// To create the human-readable "hostname", concatenate the ED25519 pubkey, checksum, and version,
814 /// wrap as base32 and append ".onion".
816 /// The ed25519 long-term public key of the peer
817 ed25519_pubkey: [u8; 32],
818 /// The checksum of the pubkey and version, as included in the onion address
820 /// The version byte, as defined by the Tor Onion v3 spec.
822 /// The port on which the node is listening
825 /// A hostname/port on which the peer is listening.
827 /// The hostname on which the node is listening.
829 /// The port on which the node is listening.
834 /// Gets the ID of this address type. Addresses in [`NodeAnnouncement`] messages should be sorted
836 pub(crate) fn get_id(&self) -> u8 {
838 &SocketAddress::TcpIpV4 {..} => { 1 },
839 &SocketAddress::TcpIpV6 {..} => { 2 },
840 &SocketAddress::OnionV2(_) => { 3 },
841 &SocketAddress::OnionV3 {..} => { 4 },
842 &SocketAddress::Hostname {..} => { 5 },
846 /// Strict byte-length of address descriptor, 1-byte type not recorded
847 fn len(&self) -> u16 {
849 &SocketAddress::TcpIpV4 { .. } => { 6 },
850 &SocketAddress::TcpIpV6 { .. } => { 18 },
851 &SocketAddress::OnionV2(_) => { 12 },
852 &SocketAddress::OnionV3 { .. } => { 37 },
853 // Consists of 1-byte hostname length, hostname bytes, and 2-byte port.
854 &SocketAddress::Hostname { ref hostname, .. } => { u16::from(hostname.len()) + 3 },
858 /// The maximum length of any address descriptor, not including the 1-byte type.
859 /// This maximum length is reached by a hostname address descriptor:
860 /// a hostname with a maximum length of 255, its 1-byte length and a 2-byte port.
861 pub(crate) const MAX_LEN: u16 = 258;
863 pub(crate) fn is_tor(&self) -> bool {
865 &SocketAddress::TcpIpV4 {..} => false,
866 &SocketAddress::TcpIpV6 {..} => false,
867 &SocketAddress::OnionV2(_) => true,
868 &SocketAddress::OnionV3 {..} => true,
869 &SocketAddress::Hostname {..} => false,
874 impl Writeable for SocketAddress {
875 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
877 &SocketAddress::TcpIpV4 { ref addr, ref port } => {
882 &SocketAddress::TcpIpV6 { ref addr, ref port } => {
887 &SocketAddress::OnionV2(bytes) => {
889 bytes.write(writer)?;
891 &SocketAddress::OnionV3 { ref ed25519_pubkey, ref checksum, ref version, ref port } => {
893 ed25519_pubkey.write(writer)?;
894 checksum.write(writer)?;
895 version.write(writer)?;
898 &SocketAddress::Hostname { ref hostname, ref port } => {
900 hostname.write(writer)?;
908 impl Readable for Result<SocketAddress, u8> {
909 fn read<R: Read>(reader: &mut R) -> Result<Result<SocketAddress, u8>, DecodeError> {
910 let byte = <u8 as Readable>::read(reader)?;
913 Ok(Ok(SocketAddress::TcpIpV4 {
914 addr: Readable::read(reader)?,
915 port: Readable::read(reader)?,
919 Ok(Ok(SocketAddress::TcpIpV6 {
920 addr: Readable::read(reader)?,
921 port: Readable::read(reader)?,
924 3 => Ok(Ok(SocketAddress::OnionV2(Readable::read(reader)?))),
926 Ok(Ok(SocketAddress::OnionV3 {
927 ed25519_pubkey: Readable::read(reader)?,
928 checksum: Readable::read(reader)?,
929 version: Readable::read(reader)?,
930 port: Readable::read(reader)?,
934 Ok(Ok(SocketAddress::Hostname {
935 hostname: Readable::read(reader)?,
936 port: Readable::read(reader)?,
939 _ => return Ok(Err(byte)),
944 impl Readable for SocketAddress {
945 fn read<R: Read>(reader: &mut R) -> Result<SocketAddress, DecodeError> {
946 match Readable::read(reader) {
947 Ok(Ok(res)) => Ok(res),
948 Ok(Err(_)) => Err(DecodeError::UnknownVersion),
954 /// [`SocketAddress`] error variants
955 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
956 pub enum SocketAddressParseError {
957 /// Socket address (IPv4/IPv6) parsing error
959 /// Invalid input format
963 /// Invalid onion v3 address
967 impl fmt::Display for SocketAddressParseError {
968 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
970 SocketAddressParseError::SocketAddrParse => write!(f, "Socket address (IPv4/IPv6) parsing error"),
971 SocketAddressParseError::InvalidInput => write!(f, "Invalid input format. \
972 Expected: \"<ipv4>:<port>\", \"[<ipv6>]:<port>\", \"<onion address>.onion:<port>\" or \"<hostname>:<port>\""),
973 SocketAddressParseError::InvalidPort => write!(f, "Invalid port"),
974 SocketAddressParseError::InvalidOnionV3 => write!(f, "Invalid onion v3 address"),
979 #[cfg(feature = "std")]
980 impl From<std::net::SocketAddrV4> for SocketAddress {
981 fn from(addr: std::net::SocketAddrV4) -> Self {
982 SocketAddress::TcpIpV4 { addr: addr.ip().octets(), port: addr.port() }
986 #[cfg(feature = "std")]
987 impl From<std::net::SocketAddrV6> for SocketAddress {
988 fn from(addr: std::net::SocketAddrV6) -> Self {
989 SocketAddress::TcpIpV6 { addr: addr.ip().octets(), port: addr.port() }
993 #[cfg(feature = "std")]
994 impl From<std::net::SocketAddr> for SocketAddress {
995 fn from(addr: std::net::SocketAddr) -> Self {
997 std::net::SocketAddr::V4(addr) => addr.into(),
998 std::net::SocketAddr::V6(addr) => addr.into(),
1003 #[cfg(feature = "std")]
1004 impl std::net::ToSocketAddrs for SocketAddress {
1005 type Iter = std::vec::IntoIter<std::net::SocketAddr>;
1007 fn to_socket_addrs(&self) -> std::io::Result<Self::Iter> {
1009 SocketAddress::TcpIpV4 { addr, port } => {
1010 let ip_addr = std::net::Ipv4Addr::from(*addr);
1011 let socket_addr = SocketAddr::new(ip_addr.into(), *port);
1012 Ok(vec![socket_addr].into_iter())
1014 SocketAddress::TcpIpV6 { addr, port } => {
1015 let ip_addr = std::net::Ipv6Addr::from(*addr);
1016 let socket_addr = SocketAddr::new(ip_addr.into(), *port);
1017 Ok(vec![socket_addr].into_iter())
1019 SocketAddress::Hostname { ref hostname, port } => {
1020 (hostname.as_str(), *port).to_socket_addrs()
1022 SocketAddress::OnionV2(..) => {
1023 Err(std::io::Error::new(std::io::ErrorKind::Other, "Resolution of OnionV2 \
1024 addresses is currently unsupported."))
1026 SocketAddress::OnionV3 { .. } => {
1027 Err(std::io::Error::new(std::io::ErrorKind::Other, "Resolution of OnionV3 \
1028 addresses is currently unsupported."))
1034 /// Parses an OnionV3 host and port into a [`SocketAddress::OnionV3`].
1036 /// The host part must end with ".onion".
1037 pub fn parse_onion_address(host: &str, port: u16) -> Result<SocketAddress, SocketAddressParseError> {
1038 if host.ends_with(".onion") {
1039 let domain = &host[..host.len() - ".onion".len()];
1040 if domain.len() != 56 {
1041 return Err(SocketAddressParseError::InvalidOnionV3);
1043 let onion = base32::Alphabet::RFC4648 { padding: false }.decode(&domain).map_err(|_| SocketAddressParseError::InvalidOnionV3)?;
1044 if onion.len() != 35 {
1045 return Err(SocketAddressParseError::InvalidOnionV3);
1047 let version = onion[0];
1048 let first_checksum_flag = onion[1];
1049 let second_checksum_flag = onion[2];
1050 let mut ed25519_pubkey = [0; 32];
1051 ed25519_pubkey.copy_from_slice(&onion[3..35]);
1052 let checksum = u16::from_be_bytes([first_checksum_flag, second_checksum_flag]);
1053 return Ok(SocketAddress::OnionV3 { ed25519_pubkey, checksum, version, port });
1056 return Err(SocketAddressParseError::InvalidInput);
1060 impl Display for SocketAddress {
1061 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1063 SocketAddress::TcpIpV4{addr, port} => write!(
1064 f, "{}.{}.{}.{}:{}", addr[0], addr[1], addr[2], addr[3], port)?,
1065 SocketAddress::TcpIpV6{addr, port} => write!(
1067 "[{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}]:{}",
1068 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
1070 SocketAddress::OnionV2(bytes) => write!(f, "OnionV2({:?})", bytes)?,
1071 SocketAddress::OnionV3 {
1077 let [first_checksum_flag, second_checksum_flag] = checksum.to_be_bytes();
1078 let mut addr = vec![*version, first_checksum_flag, second_checksum_flag];
1079 addr.extend_from_slice(ed25519_pubkey);
1080 let onion = base32::Alphabet::RFC4648 { padding: false }.encode(&addr);
1081 write!(f, "{}.onion:{}", onion, port)?
1083 SocketAddress::Hostname { hostname, port } => write!(f, "{}:{}", hostname, port)?,
1089 #[cfg(feature = "std")]
1090 impl FromStr for SocketAddress {
1091 type Err = SocketAddressParseError;
1093 fn from_str(s: &str) -> Result<Self, Self::Err> {
1094 match std::net::SocketAddr::from_str(s) {
1095 Ok(addr) => Ok(addr.into()),
1097 let trimmed_input = match s.rfind(":") {
1099 None => return Err(SocketAddressParseError::InvalidInput),
1101 let host = &s[..trimmed_input];
1102 let port: u16 = s[trimmed_input + 1..].parse().map_err(|_| SocketAddressParseError::InvalidPort)?;
1103 if host.ends_with(".onion") {
1104 return parse_onion_address(host, port);
1106 if let Ok(hostname) = Hostname::try_from(s[..trimmed_input].to_string()) {
1107 return Ok(SocketAddress::Hostname { hostname, port });
1109 return Err(SocketAddressParseError::SocketAddrParse)
1115 /// Represents the set of gossip messages that require a signature from a node's identity key.
1116 pub enum UnsignedGossipMessage<'a> {
1117 /// An unsigned channel announcement.
1118 ChannelAnnouncement(&'a UnsignedChannelAnnouncement),
1119 /// An unsigned channel update.
1120 ChannelUpdate(&'a UnsignedChannelUpdate),
1121 /// An unsigned node announcement.
1122 NodeAnnouncement(&'a UnsignedNodeAnnouncement)
1125 impl<'a> Writeable for UnsignedGossipMessage<'a> {
1126 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
1128 UnsignedGossipMessage::ChannelAnnouncement(ref msg) => msg.write(writer),
1129 UnsignedGossipMessage::ChannelUpdate(ref msg) => msg.write(writer),
1130 UnsignedGossipMessage::NodeAnnouncement(ref msg) => msg.write(writer),
1135 /// The unsigned part of a [`node_announcement`] message.
1137 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
1138 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1139 pub struct UnsignedNodeAnnouncement {
1140 /// The advertised features
1141 pub features: NodeFeatures,
1142 /// A strictly monotonic announcement counter, with gaps allowed
1144 /// The `node_id` this announcement originated from (don't rebroadcast the `node_announcement` back
1146 pub node_id: NodeId,
1147 /// An RGB color for UI purposes
1149 /// An alias, for UI purposes.
1151 /// This should be sanitized before use. There is no guarantee of uniqueness.
1152 pub alias: NodeAlias,
1153 /// List of addresses on which this node is reachable
1154 pub addresses: Vec<SocketAddress>,
1155 /// Excess address data which was signed as a part of the message which we do not (yet) understand how
1158 /// This is stored to ensure forward-compatibility as new address types are added to the lightning gossip protocol.
1159 pub excess_address_data: Vec<u8>,
1160 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1163 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1164 pub excess_data: Vec<u8>,
1166 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1167 /// A [`node_announcement`] message to be sent to or received from a peer.
1169 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
1170 pub struct NodeAnnouncement {
1171 /// The signature by the node key
1172 pub signature: Signature,
1173 /// The actual content of the announcement
1174 pub contents: UnsignedNodeAnnouncement,
1177 /// The unsigned part of a [`channel_announcement`] message.
1179 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
1180 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1181 pub struct UnsignedChannelAnnouncement {
1182 /// The advertised channel features
1183 pub features: ChannelFeatures,
1184 /// The genesis hash of the blockchain where the channel is to be opened
1185 pub chain_hash: ChainHash,
1186 /// The short channel ID
1187 pub short_channel_id: u64,
1188 /// One of the two `node_id`s which are endpoints of this channel
1189 pub node_id_1: NodeId,
1190 /// The other of the two `node_id`s which are endpoints of this channel
1191 pub node_id_2: NodeId,
1192 /// The funding key for the first node
1193 pub bitcoin_key_1: NodeId,
1194 /// The funding key for the second node
1195 pub bitcoin_key_2: NodeId,
1196 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1199 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1200 pub excess_data: Vec<u8>,
1202 /// A [`channel_announcement`] message to be sent to or received from a peer.
1204 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
1205 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1206 pub struct ChannelAnnouncement {
1207 /// Authentication of the announcement by the first public node
1208 pub node_signature_1: Signature,
1209 /// Authentication of the announcement by the second public node
1210 pub node_signature_2: Signature,
1211 /// Proof of funding UTXO ownership by the first public node
1212 pub bitcoin_signature_1: Signature,
1213 /// Proof of funding UTXO ownership by the second public node
1214 pub bitcoin_signature_2: Signature,
1215 /// The actual announcement
1216 pub contents: UnsignedChannelAnnouncement,
1219 /// The unsigned part of a [`channel_update`] message.
1221 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1222 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1223 pub struct UnsignedChannelUpdate {
1224 /// The genesis hash of the blockchain where the channel is to be opened
1225 pub chain_hash: ChainHash,
1226 /// The short channel ID
1227 pub short_channel_id: u64,
1228 /// A strictly monotonic announcement counter, with gaps allowed, specific to this channel
1232 /// The number of blocks such that if:
1233 /// `incoming_htlc.cltv_expiry < outgoing_htlc.cltv_expiry + cltv_expiry_delta`
1234 /// then we need to fail the HTLC backwards. When forwarding an HTLC, `cltv_expiry_delta` determines
1235 /// the outgoing HTLC's minimum `cltv_expiry` value -- so, if an incoming HTLC comes in with a
1236 /// `cltv_expiry` of 100000, and the node we're forwarding to has a `cltv_expiry_delta` value of 10,
1237 /// then we'll check that the outgoing HTLC's `cltv_expiry` value is at least 100010 before
1238 /// forwarding. Note that the HTLC sender is the one who originally sets this value when
1239 /// constructing the route.
1240 pub cltv_expiry_delta: u16,
1241 /// The minimum HTLC size incoming to sender, in milli-satoshi
1242 pub htlc_minimum_msat: u64,
1243 /// The maximum HTLC value incoming to sender, in milli-satoshi.
1245 /// This used to be optional.
1246 pub htlc_maximum_msat: u64,
1247 /// The base HTLC fee charged by sender, in milli-satoshi
1248 pub fee_base_msat: u32,
1249 /// The amount to fee multiplier, in micro-satoshi
1250 pub fee_proportional_millionths: u32,
1251 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1254 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1255 pub excess_data: Vec<u8>,
1257 /// A [`channel_update`] message to be sent to or received from a peer.
1259 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1260 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1261 pub struct ChannelUpdate {
1262 /// A signature of the channel update
1263 pub signature: Signature,
1264 /// The actual channel update
1265 pub contents: UnsignedChannelUpdate,
1268 /// A [`query_channel_range`] message is used to query a peer for channel
1269 /// UTXOs in a range of blocks. The recipient of a query makes a best
1270 /// effort to reply to the query using one or more [`ReplyChannelRange`]
1273 /// [`query_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1274 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1275 pub struct QueryChannelRange {
1276 /// The genesis hash of the blockchain being queried
1277 pub chain_hash: ChainHash,
1278 /// The height of the first block for the channel UTXOs being queried
1279 pub first_blocknum: u32,
1280 /// The number of blocks to include in the query results
1281 pub number_of_blocks: u32,
1284 /// A [`reply_channel_range`] message is a reply to a [`QueryChannelRange`]
1287 /// Multiple `reply_channel_range` messages can be sent in reply
1288 /// to a single [`QueryChannelRange`] message. The query recipient makes a
1289 /// best effort to respond based on their local network view which may
1290 /// not be a perfect view of the network. The `short_channel_id`s in the
1291 /// reply are encoded. We only support `encoding_type=0` uncompressed
1292 /// serialization and do not support `encoding_type=1` zlib serialization.
1294 /// [`reply_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1295 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1296 pub struct ReplyChannelRange {
1297 /// The genesis hash of the blockchain being queried
1298 pub chain_hash: ChainHash,
1299 /// The height of the first block in the range of the reply
1300 pub first_blocknum: u32,
1301 /// The number of blocks included in the range of the reply
1302 pub number_of_blocks: u32,
1303 /// True when this is the final reply for a query
1304 pub sync_complete: bool,
1305 /// The `short_channel_id`s in the channel range
1306 pub short_channel_ids: Vec<u64>,
1309 /// A [`query_short_channel_ids`] message is used to query a peer for
1310 /// routing gossip messages related to one or more `short_channel_id`s.
1312 /// The query recipient will reply with the latest, if available,
1313 /// [`ChannelAnnouncement`], [`ChannelUpdate`] and [`NodeAnnouncement`] messages
1314 /// it maintains for the requested `short_channel_id`s followed by a
1315 /// [`ReplyShortChannelIdsEnd`] message. The `short_channel_id`s sent in
1316 /// this query are encoded. We only support `encoding_type=0` uncompressed
1317 /// serialization and do not support `encoding_type=1` zlib serialization.
1319 /// [`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
1320 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1321 pub struct QueryShortChannelIds {
1322 /// The genesis hash of the blockchain being queried
1323 pub chain_hash: ChainHash,
1324 /// The short_channel_ids that are being queried
1325 pub short_channel_ids: Vec<u64>,
1328 /// A [`reply_short_channel_ids_end`] message is sent as a reply to a
1329 /// message. The query recipient makes a best
1330 /// effort to respond based on their local network view which may not be
1331 /// a perfect view of the network.
1333 /// [`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
1334 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1335 pub struct ReplyShortChannelIdsEnd {
1336 /// The genesis hash of the blockchain that was queried
1337 pub chain_hash: ChainHash,
1338 /// Indicates if the query recipient maintains up-to-date channel
1339 /// information for the `chain_hash`
1340 pub full_information: bool,
1343 /// A [`gossip_timestamp_filter`] message is used by a node to request
1344 /// gossip relay for messages in the requested time range when the
1345 /// `gossip_queries` feature has been negotiated.
1347 /// [`gossip_timestamp_filter`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-gossip_timestamp_filter-message
1348 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1349 pub struct GossipTimestampFilter {
1350 /// The genesis hash of the blockchain for channel and node information
1351 pub chain_hash: ChainHash,
1352 /// The starting unix timestamp
1353 pub first_timestamp: u32,
1354 /// The range of information in seconds
1355 pub timestamp_range: u32,
1358 /// Encoding type for data compression of collections in gossip queries.
1360 /// We do not support `encoding_type=1` zlib serialization [defined in BOLT
1361 /// #7](https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#query-messages).
1363 Uncompressed = 0x00,
1366 /// Used to put an error message in a [`LightningError`].
1367 #[derive(Clone, Debug, Hash, PartialEq)]
1368 pub enum ErrorAction {
1369 /// The peer took some action which made us think they were useless. Disconnect them.
1371 /// An error message which we should make an effort to send before we disconnect.
1372 msg: Option<ErrorMessage>
1374 /// The peer did something incorrect. Tell them without closing any channels and disconnect them.
1375 DisconnectPeerWithWarning {
1376 /// A warning message which we should make an effort to send before we disconnect.
1377 msg: WarningMessage,
1379 /// The peer did something harmless that we weren't able to process, just log and ignore
1380 // New code should *not* use this. New code must use IgnoreAndLog, below!
1382 /// The peer did something harmless that we weren't able to meaningfully process.
1383 /// If the error is logged, log it at the given level.
1384 IgnoreAndLog(logger::Level),
1385 /// The peer provided us with a gossip message which we'd already seen. In most cases this
1386 /// should be ignored, but it may result in the message being forwarded if it is a duplicate of
1387 /// our own channel announcements.
1388 IgnoreDuplicateGossip,
1389 /// The peer did something incorrect. Tell them.
1391 /// The message to send.
1394 /// The peer did something incorrect. Tell them without closing any channels.
1395 SendWarningMessage {
1396 /// The message to send.
1397 msg: WarningMessage,
1398 /// The peer may have done something harmless that we weren't able to meaningfully process,
1399 /// though we should still tell them about it.
1400 /// If this event is logged, log it at the given level.
1401 log_level: logger::Level,
1405 /// An Err type for failure to process messages.
1406 #[derive(Clone, Debug)]
1407 pub struct LightningError {
1408 /// A human-readable message describing the error
1410 /// The action which should be taken against the offending peer.
1411 pub action: ErrorAction,
1414 /// Struct used to return values from [`RevokeAndACK`] messages, containing a bunch of commitment
1415 /// transaction updates if they were pending.
1416 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1417 pub struct CommitmentUpdate {
1418 /// `update_add_htlc` messages which should be sent
1419 pub update_add_htlcs: Vec<UpdateAddHTLC>,
1420 /// `update_fulfill_htlc` messages which should be sent
1421 pub update_fulfill_htlcs: Vec<UpdateFulfillHTLC>,
1422 /// `update_fail_htlc` messages which should be sent
1423 pub update_fail_htlcs: Vec<UpdateFailHTLC>,
1424 /// `update_fail_malformed_htlc` messages which should be sent
1425 pub update_fail_malformed_htlcs: Vec<UpdateFailMalformedHTLC>,
1426 /// An `update_fee` message which should be sent
1427 pub update_fee: Option<UpdateFee>,
1428 /// A `commitment_signed` message which should be sent
1429 pub commitment_signed: CommitmentSigned,
1432 /// A trait to describe an object which can receive channel messages.
1434 /// Messages MAY be called in parallel when they originate from different `their_node_ids`, however
1435 /// they MUST NOT be called in parallel when the two calls have the same `their_node_id`.
1436 pub trait ChannelMessageHandler : MessageSendEventsProvider {
1438 /// Handle an incoming `open_channel` message from the given peer.
1439 fn handle_open_channel(&self, their_node_id: &PublicKey, msg: &OpenChannel);
1440 /// Handle an incoming `open_channel2` message from the given peer.
1441 fn handle_open_channel_v2(&self, their_node_id: &PublicKey, msg: &OpenChannelV2);
1442 /// Handle an incoming `accept_channel` message from the given peer.
1443 fn handle_accept_channel(&self, their_node_id: &PublicKey, msg: &AcceptChannel);
1444 /// Handle an incoming `accept_channel2` message from the given peer.
1445 fn handle_accept_channel_v2(&self, their_node_id: &PublicKey, msg: &AcceptChannelV2);
1446 /// Handle an incoming `funding_created` message from the given peer.
1447 fn handle_funding_created(&self, their_node_id: &PublicKey, msg: &FundingCreated);
1448 /// Handle an incoming `funding_signed` message from the given peer.
1449 fn handle_funding_signed(&self, their_node_id: &PublicKey, msg: &FundingSigned);
1450 /// Handle an incoming `channel_ready` message from the given peer.
1451 fn handle_channel_ready(&self, their_node_id: &PublicKey, msg: &ChannelReady);
1454 /// Handle an incoming `shutdown` message from the given peer.
1455 fn handle_shutdown(&self, their_node_id: &PublicKey, msg: &Shutdown);
1456 /// Handle an incoming `closing_signed` message from the given peer.
1457 fn handle_closing_signed(&self, their_node_id: &PublicKey, msg: &ClosingSigned);
1460 /// Handle an incoming `stfu` message from the given peer.
1461 fn handle_stfu(&self, their_node_id: &PublicKey, msg: &Stfu);
1464 /// Handle an incoming `splice` message from the given peer.
1465 fn handle_splice(&self, their_node_id: &PublicKey, msg: &Splice);
1466 /// Handle an incoming `splice_ack` message from the given peer.
1467 fn handle_splice_ack(&self, their_node_id: &PublicKey, msg: &SpliceAck);
1468 /// Handle an incoming `splice_locked` message from the given peer.
1469 fn handle_splice_locked(&self, their_node_id: &PublicKey, msg: &SpliceLocked);
1471 // Interactive channel construction
1472 /// Handle an incoming `tx_add_input message` from the given peer.
1473 fn handle_tx_add_input(&self, their_node_id: &PublicKey, msg: &TxAddInput);
1474 /// Handle an incoming `tx_add_output` message from the given peer.
1475 fn handle_tx_add_output(&self, their_node_id: &PublicKey, msg: &TxAddOutput);
1476 /// Handle an incoming `tx_remove_input` message from the given peer.
1477 fn handle_tx_remove_input(&self, their_node_id: &PublicKey, msg: &TxRemoveInput);
1478 /// Handle an incoming `tx_remove_output` message from the given peer.
1479 fn handle_tx_remove_output(&self, their_node_id: &PublicKey, msg: &TxRemoveOutput);
1480 /// Handle an incoming `tx_complete message` from the given peer.
1481 fn handle_tx_complete(&self, their_node_id: &PublicKey, msg: &TxComplete);
1482 /// Handle an incoming `tx_signatures` message from the given peer.
1483 fn handle_tx_signatures(&self, their_node_id: &PublicKey, msg: &TxSignatures);
1484 /// Handle an incoming `tx_init_rbf` message from the given peer.
1485 fn handle_tx_init_rbf(&self, their_node_id: &PublicKey, msg: &TxInitRbf);
1486 /// Handle an incoming `tx_ack_rbf` message from the given peer.
1487 fn handle_tx_ack_rbf(&self, their_node_id: &PublicKey, msg: &TxAckRbf);
1488 /// Handle an incoming `tx_abort message` from the given peer.
1489 fn handle_tx_abort(&self, their_node_id: &PublicKey, msg: &TxAbort);
1492 /// Handle an incoming `update_add_htlc` message from the given peer.
1493 fn handle_update_add_htlc(&self, their_node_id: &PublicKey, msg: &UpdateAddHTLC);
1494 /// Handle an incoming `update_fulfill_htlc` message from the given peer.
1495 fn handle_update_fulfill_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFulfillHTLC);
1496 /// Handle an incoming `update_fail_htlc` message from the given peer.
1497 fn handle_update_fail_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailHTLC);
1498 /// Handle an incoming `update_fail_malformed_htlc` message from the given peer.
1499 fn handle_update_fail_malformed_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailMalformedHTLC);
1500 /// Handle an incoming `commitment_signed` message from the given peer.
1501 fn handle_commitment_signed(&self, their_node_id: &PublicKey, msg: &CommitmentSigned);
1502 /// Handle an incoming `revoke_and_ack` message from the given peer.
1503 fn handle_revoke_and_ack(&self, their_node_id: &PublicKey, msg: &RevokeAndACK);
1505 /// Handle an incoming `update_fee` message from the given peer.
1506 fn handle_update_fee(&self, their_node_id: &PublicKey, msg: &UpdateFee);
1508 // Channel-to-announce:
1509 /// Handle an incoming `announcement_signatures` message from the given peer.
1510 fn handle_announcement_signatures(&self, their_node_id: &PublicKey, msg: &AnnouncementSignatures);
1512 // Connection loss/reestablish:
1513 /// Indicates a connection to the peer failed/an existing connection was lost.
1514 fn peer_disconnected(&self, their_node_id: &PublicKey);
1516 /// Handle a peer reconnecting, possibly generating `channel_reestablish` message(s).
1518 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1519 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1520 /// message handlers may still wish to communicate with this peer.
1521 fn peer_connected(&self, their_node_id: &PublicKey, msg: &Init, inbound: bool) -> Result<(), ()>;
1522 /// Handle an incoming `channel_reestablish` message from the given peer.
1523 fn handle_channel_reestablish(&self, their_node_id: &PublicKey, msg: &ChannelReestablish);
1525 /// Handle an incoming `channel_update` message from the given peer.
1526 fn handle_channel_update(&self, their_node_id: &PublicKey, msg: &ChannelUpdate);
1529 /// Handle an incoming `error` message from the given peer.
1530 fn handle_error(&self, their_node_id: &PublicKey, msg: &ErrorMessage);
1532 // Handler information:
1533 /// Gets the node feature flags which this handler itself supports. All available handlers are
1534 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1535 /// which are broadcasted in our [`NodeAnnouncement`] message.
1536 fn provided_node_features(&self) -> NodeFeatures;
1538 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1539 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1540 /// which are sent in our [`Init`] message.
1542 /// Note that this method is called before [`Self::peer_connected`].
1543 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1545 /// Gets the chain hashes for this `ChannelMessageHandler` indicating which chains it supports.
1547 /// If it's `None`, then no particular network chain hash compatibility will be enforced when
1548 /// connecting to peers.
1549 fn get_chain_hashes(&self) -> Option<Vec<ChainHash>>;
1552 /// A trait to describe an object which can receive routing messages.
1554 /// # Implementor DoS Warnings
1556 /// For messages enabled with the `gossip_queries` feature there are potential DoS vectors when
1557 /// handling inbound queries. Implementors using an on-disk network graph should be aware of
1558 /// repeated disk I/O for queries accessing different parts of the network graph.
1559 pub trait RoutingMessageHandler : MessageSendEventsProvider {
1560 /// Handle an incoming `node_announcement` message, returning `true` if it should be forwarded on,
1561 /// `false` or returning an `Err` otherwise.
1562 fn handle_node_announcement(&self, msg: &NodeAnnouncement) -> Result<bool, LightningError>;
1563 /// Handle a `channel_announcement` message, returning `true` if it should be forwarded on, `false`
1564 /// or returning an `Err` otherwise.
1565 fn handle_channel_announcement(&self, msg: &ChannelAnnouncement) -> Result<bool, LightningError>;
1566 /// Handle an incoming `channel_update` message, returning true if it should be forwarded on,
1567 /// `false` or returning an `Err` otherwise.
1568 fn handle_channel_update(&self, msg: &ChannelUpdate) -> Result<bool, LightningError>;
1569 /// Gets channel announcements and updates required to dump our routing table to a remote node,
1570 /// starting at the `short_channel_id` indicated by `starting_point` and including announcements
1571 /// for a single channel.
1572 fn get_next_channel_announcement(&self, starting_point: u64) -> Option<(ChannelAnnouncement, Option<ChannelUpdate>, Option<ChannelUpdate>)>;
1573 /// Gets a node announcement required to dump our routing table to a remote node, starting at
1574 /// the node *after* the provided pubkey and including up to one announcement immediately
1575 /// higher (as defined by `<PublicKey as Ord>::cmp`) than `starting_point`.
1576 /// If `None` is provided for `starting_point`, we start at the first node.
1577 fn get_next_node_announcement(&self, starting_point: Option<&NodeId>) -> Option<NodeAnnouncement>;
1578 /// Called when a connection is established with a peer. This can be used to
1579 /// perform routing table synchronization using a strategy defined by the
1582 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1583 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1584 /// message handlers may still wish to communicate with this peer.
1585 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1586 /// Handles the reply of a query we initiated to learn about channels
1587 /// for a given range of blocks. We can expect to receive one or more
1588 /// replies to a single query.
1589 fn handle_reply_channel_range(&self, their_node_id: &PublicKey, msg: ReplyChannelRange) -> Result<(), LightningError>;
1590 /// Handles the reply of a query we initiated asking for routing gossip
1591 /// messages for a list of channels. We should receive this message when
1592 /// a node has completed its best effort to send us the pertaining routing
1593 /// gossip messages.
1594 fn handle_reply_short_channel_ids_end(&self, their_node_id: &PublicKey, msg: ReplyShortChannelIdsEnd) -> Result<(), LightningError>;
1595 /// Handles when a peer asks us to send a list of `short_channel_id`s
1596 /// for the requested range of blocks.
1597 fn handle_query_channel_range(&self, their_node_id: &PublicKey, msg: QueryChannelRange) -> Result<(), LightningError>;
1598 /// Handles when a peer asks us to send routing gossip messages for a
1599 /// list of `short_channel_id`s.
1600 fn handle_query_short_channel_ids(&self, their_node_id: &PublicKey, msg: QueryShortChannelIds) -> Result<(), LightningError>;
1602 // Handler queueing status:
1603 /// Indicates that there are a large number of [`ChannelAnnouncement`] (or other) messages
1604 /// pending some async action. While there is no guarantee of the rate of future messages, the
1605 /// caller should seek to reduce the rate of new gossip messages handled, especially
1606 /// [`ChannelAnnouncement`]s.
1607 fn processing_queue_high(&self) -> bool;
1609 // Handler information:
1610 /// Gets the node feature flags which this handler itself supports. All available handlers are
1611 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1612 /// which are broadcasted in our [`NodeAnnouncement`] message.
1613 fn provided_node_features(&self) -> NodeFeatures;
1614 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1615 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1616 /// which are sent in our [`Init`] message.
1618 /// Note that this method is called before [`Self::peer_connected`].
1619 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1622 /// A handler for received [`OnionMessage`]s and for providing generated ones to send.
1623 pub trait OnionMessageHandler: EventsProvider {
1624 /// Handle an incoming `onion_message` message from the given peer.
1625 fn handle_onion_message(&self, peer_node_id: &PublicKey, msg: &OnionMessage);
1627 /// Returns the next pending onion message for the peer with the given node id.
1628 fn next_onion_message_for_peer(&self, peer_node_id: PublicKey) -> Option<OnionMessage>;
1630 /// Called when a connection is established with a peer. Can be used to track which peers
1631 /// advertise onion message support and are online.
1633 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1634 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1635 /// message handlers may still wish to communicate with this peer.
1636 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1638 /// Indicates a connection to the peer failed/an existing connection was lost. Allows handlers to
1639 /// drop and refuse to forward onion messages to this peer.
1640 fn peer_disconnected(&self, their_node_id: &PublicKey);
1642 /// Performs actions that should happen roughly every ten seconds after startup. Allows handlers
1643 /// to drop any buffered onion messages intended for prospective peers.
1644 fn timer_tick_occurred(&self);
1646 // Handler information:
1647 /// Gets the node feature flags which this handler itself supports. All available handlers are
1648 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1649 /// which are broadcasted in our [`NodeAnnouncement`] message.
1650 fn provided_node_features(&self) -> NodeFeatures;
1652 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1653 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1654 /// which are sent in our [`Init`] message.
1656 /// Note that this method is called before [`Self::peer_connected`].
1657 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1661 #[cfg_attr(test, derive(Debug, PartialEq))]
1662 /// Information communicated in the onion to the recipient for multi-part tracking and proof that
1663 /// the payment is associated with an invoice.
1664 pub struct FinalOnionHopData {
1665 /// When sending a multi-part payment, this secret is used to identify a payment across HTLCs.
1666 /// Because it is generated by the recipient and included in the invoice, it also provides
1667 /// proof to the recipient that the payment was sent by someone with the generated invoice.
1668 pub payment_secret: PaymentSecret,
1669 /// The intended total amount that this payment is for.
1671 /// Message serialization may panic if this value is more than 21 million Bitcoin.
1672 pub total_msat: u64,
1675 mod fuzzy_internal_msgs {
1676 use bitcoin::secp256k1::PublicKey;
1677 use crate::blinded_path::payment::{PaymentConstraints, PaymentRelay};
1678 use crate::ln::{PaymentPreimage, PaymentSecret};
1679 use crate::ln::features::BlindedHopFeatures;
1680 use super::{FinalOnionHopData, TrampolineOnionPacket};
1682 #[allow(unused_imports)]
1683 use crate::prelude::*;
1685 // These types aren't intended to be pub, but are exposed for direct fuzzing (as we deserialize
1686 // them from untrusted input):
1688 pub enum InboundOnionPayload {
1690 short_channel_id: u64,
1691 /// The value, in msat, of the payment after this hop's fee is deducted.
1692 amt_to_forward: u64,
1693 outgoing_cltv_value: u32,
1696 payment_data: Option<FinalOnionHopData>,
1697 payment_metadata: Option<Vec<u8>>,
1698 keysend_preimage: Option<PaymentPreimage>,
1699 custom_tlvs: Vec<(u64, Vec<u8>)>,
1700 sender_intended_htlc_amt_msat: u64,
1701 cltv_expiry_height: u32,
1704 short_channel_id: u64,
1705 payment_relay: PaymentRelay,
1706 payment_constraints: PaymentConstraints,
1707 features: BlindedHopFeatures,
1708 intro_node_blinding_point: Option<PublicKey>,
1711 sender_intended_htlc_amt_msat: u64,
1713 cltv_expiry_height: u32,
1714 payment_secret: PaymentSecret,
1715 payment_constraints: PaymentConstraints,
1716 intro_node_blinding_point: Option<PublicKey>,
1717 keysend_preimage: Option<PaymentPreimage>,
1718 custom_tlvs: Vec<(u64, Vec<u8>)>,
1722 pub(crate) enum OutboundOnionPayload {
1724 short_channel_id: u64,
1725 /// The value, in msat, of the payment after this hop's fee is deducted.
1726 amt_to_forward: u64,
1727 outgoing_cltv_value: u32,
1730 TrampolineEntrypoint {
1731 amt_to_forward: u64,
1732 outgoing_cltv_value: u32,
1733 multipath_trampoline_data: Option<FinalOnionHopData>,
1734 trampoline_packet: TrampolineOnionPacket,
1737 payment_data: Option<FinalOnionHopData>,
1738 payment_metadata: Option<Vec<u8>>,
1739 keysend_preimage: Option<PaymentPreimage>,
1740 custom_tlvs: Vec<(u64, Vec<u8>)>,
1741 sender_intended_htlc_amt_msat: u64,
1742 cltv_expiry_height: u32,
1745 encrypted_tlvs: Vec<u8>,
1746 intro_node_blinding_point: Option<PublicKey>,
1749 sender_intended_htlc_amt_msat: u64,
1751 cltv_expiry_height: u32,
1752 encrypted_tlvs: Vec<u8>,
1753 intro_node_blinding_point: Option<PublicKey>, // Set if the introduction node of the blinded path is the final node
1754 keysend_preimage: Option<PaymentPreimage>,
1755 custom_tlvs: Vec<(u64, Vec<u8>)>,
1759 pub(crate) enum OutboundTrampolinePayload {
1762 /// The value, in msat, of the payment after this hop's fee is deducted.
1763 amt_to_forward: u64,
1764 outgoing_cltv_value: u32,
1765 /// The node id to which the trampoline node must find a route
1766 outgoing_node_id: PublicKey,
1770 pub struct DecodedOnionErrorPacket {
1771 pub(crate) hmac: [u8; 32],
1772 pub(crate) failuremsg: Vec<u8>,
1773 pub(crate) pad: Vec<u8>,
1777 pub use self::fuzzy_internal_msgs::*;
1778 #[cfg(not(fuzzing))]
1779 pub(crate) use self::fuzzy_internal_msgs::*;
1781 /// BOLT 4 onion packet including hop data for the next peer.
1782 #[derive(Clone, Hash, PartialEq, Eq)]
1783 pub struct OnionPacket {
1784 /// BOLT 4 version number.
1786 /// In order to ensure we always return an error on onion decode in compliance with [BOLT
1787 /// #4](https://github.com/lightning/bolts/blob/master/04-onion-routing.md), we have to
1788 /// deserialize `OnionPacket`s contained in [`UpdateAddHTLC`] messages even if the ephemeral
1789 /// public key (here) is bogus, so we hold a [`Result`] instead of a [`PublicKey`] as we'd
1791 pub public_key: Result<PublicKey, secp256k1::Error>,
1792 /// 1300 bytes encrypted payload for the next hop.
1793 pub hop_data: [u8; 20*65],
1794 /// HMAC to verify the integrity of hop_data.
1798 impl onion_utils::Packet for OnionPacket {
1799 type Data = onion_utils::FixedSizeOnionPacket;
1800 fn new(pubkey: PublicKey, hop_data: onion_utils::FixedSizeOnionPacket, hmac: [u8; 32]) -> Self {
1803 public_key: Ok(pubkey),
1804 hop_data: hop_data.0,
1810 impl fmt::Debug for OnionPacket {
1811 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1812 f.write_fmt(format_args!("OnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
1816 /// BOLT 4 onion packet including hop data for the next peer.
1817 #[derive(Clone, Hash, PartialEq, Eq)]
1818 pub struct TrampolineOnionPacket {
1819 /// Bolt 04 version number
1821 /// A random sepc256k1 point, used to build the ECDH shared secret to decrypt hop_data
1822 pub public_key: PublicKey,
1823 /// Encrypted payload for the next hop
1825 // Unlike the onion packets used for payments, Trampoline onion packets have to be shorter than
1826 // 1300 bytes. The expected default is 650 bytes.
1827 // TODO: if 650 ends up being the most common size, optimize this to be:
1828 // enum { SixFifty([u8; 650]), VarLen(Vec<u8>) }
1829 pub hop_data: Vec<u8>,
1830 /// HMAC to verify the integrity of hop_data
1834 impl onion_utils::Packet for TrampolineOnionPacket {
1835 type Data = Vec<u8>;
1836 fn new(public_key: PublicKey, hop_data: Vec<u8>, hmac: [u8; 32]) -> Self {
1846 impl Writeable for TrampolineOnionPacket {
1847 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1848 self.version.write(w)?;
1849 self.public_key.write(w)?;
1850 w.write_all(&self.hop_data)?;
1851 self.hmac.write(w)?;
1856 impl Debug for TrampolineOnionPacket {
1857 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1858 f.write_fmt(format_args!("TrampolineOnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
1862 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1863 pub(crate) struct OnionErrorPacket {
1864 // This really should be a constant size slice, but the spec lets these things be up to 128KB?
1865 // (TODO) We limit it in decode to much lower...
1866 pub(crate) data: Vec<u8>,
1869 impl fmt::Display for DecodeError {
1870 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1872 DecodeError::UnknownVersion => f.write_str("Unknown realm byte in Onion packet"),
1873 DecodeError::UnknownRequiredFeature => f.write_str("Unknown required feature preventing decode"),
1874 DecodeError::InvalidValue => f.write_str("Nonsense bytes didn't map to the type they were interpreted as"),
1875 DecodeError::ShortRead => f.write_str("Packet extended beyond the provided bytes"),
1876 DecodeError::BadLengthDescriptor => f.write_str("A length descriptor in the packet didn't describe the later data correctly"),
1877 DecodeError::Io(ref e) => fmt::Debug::fmt(e, f),
1878 DecodeError::UnsupportedCompression => f.write_str("We don't support receiving messages with zlib-compressed fields"),
1879 DecodeError::DangerousValue => f.write_str("Value would be dangerous to continue execution with"),
1884 impl From<io::Error> for DecodeError {
1885 fn from(e: io::Error) -> Self {
1886 if e.kind() == io::ErrorKind::UnexpectedEof {
1887 DecodeError::ShortRead
1889 DecodeError::Io(e.kind())
1894 impl Writeable for AcceptChannel {
1895 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1896 self.common_fields.temporary_channel_id.write(w)?;
1897 self.common_fields.dust_limit_satoshis.write(w)?;
1898 self.common_fields.max_htlc_value_in_flight_msat.write(w)?;
1899 self.channel_reserve_satoshis.write(w)?;
1900 self.common_fields.htlc_minimum_msat.write(w)?;
1901 self.common_fields.minimum_depth.write(w)?;
1902 self.common_fields.to_self_delay.write(w)?;
1903 self.common_fields.max_accepted_htlcs.write(w)?;
1904 self.common_fields.funding_pubkey.write(w)?;
1905 self.common_fields.revocation_basepoint.write(w)?;
1906 self.common_fields.payment_basepoint.write(w)?;
1907 self.common_fields.delayed_payment_basepoint.write(w)?;
1908 self.common_fields.htlc_basepoint.write(w)?;
1909 self.common_fields.first_per_commitment_point.write(w)?;
1910 #[cfg(not(taproot))]
1911 encode_tlv_stream!(w, {
1912 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
1913 (1, self.common_fields.channel_type, option),
1916 encode_tlv_stream!(w, {
1917 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
1918 (1, self.common_fields.channel_type, option),
1919 (4, self.next_local_nonce, option),
1925 impl Readable for AcceptChannel {
1926 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1927 let temporary_channel_id: ChannelId = Readable::read(r)?;
1928 let dust_limit_satoshis: u64 = Readable::read(r)?;
1929 let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;
1930 let channel_reserve_satoshis: u64 = Readable::read(r)?;
1931 let htlc_minimum_msat: u64 = Readable::read(r)?;
1932 let minimum_depth: u32 = Readable::read(r)?;
1933 let to_self_delay: u16 = Readable::read(r)?;
1934 let max_accepted_htlcs: u16 = Readable::read(r)?;
1935 let funding_pubkey: PublicKey = Readable::read(r)?;
1936 let revocation_basepoint: PublicKey = Readable::read(r)?;
1937 let payment_basepoint: PublicKey = Readable::read(r)?;
1938 let delayed_payment_basepoint: PublicKey = Readable::read(r)?;
1939 let htlc_basepoint: PublicKey = Readable::read(r)?;
1940 let first_per_commitment_point: PublicKey = Readable::read(r)?;
1942 let mut shutdown_scriptpubkey: Option<ScriptBuf> = None;
1943 let mut channel_type: Option<ChannelTypeFeatures> = None;
1944 #[cfg(not(taproot))]
1945 decode_tlv_stream!(r, {
1946 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
1947 (1, channel_type, option),
1950 let mut next_local_nonce: Option<musig2::types::PublicNonce> = None;
1952 decode_tlv_stream!(r, {
1953 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
1954 (1, channel_type, option),
1955 (4, next_local_nonce, option),
1959 common_fields: CommonAcceptChannelFields {
1960 temporary_channel_id,
1961 dust_limit_satoshis,
1962 max_htlc_value_in_flight_msat,
1968 revocation_basepoint,
1970 delayed_payment_basepoint,
1972 first_per_commitment_point,
1973 shutdown_scriptpubkey,
1976 channel_reserve_satoshis,
1983 impl Writeable for AcceptChannelV2 {
1984 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1985 self.common_fields.temporary_channel_id.write(w)?;
1986 self.funding_satoshis.write(w)?;
1987 self.common_fields.dust_limit_satoshis.write(w)?;
1988 self.common_fields.max_htlc_value_in_flight_msat.write(w)?;
1989 self.common_fields.htlc_minimum_msat.write(w)?;
1990 self.common_fields.minimum_depth.write(w)?;
1991 self.common_fields.to_self_delay.write(w)?;
1992 self.common_fields.max_accepted_htlcs.write(w)?;
1993 self.common_fields.funding_pubkey.write(w)?;
1994 self.common_fields.revocation_basepoint.write(w)?;
1995 self.common_fields.payment_basepoint.write(w)?;
1996 self.common_fields.delayed_payment_basepoint.write(w)?;
1997 self.common_fields.htlc_basepoint.write(w)?;
1998 self.common_fields.first_per_commitment_point.write(w)?;
1999 self.second_per_commitment_point.write(w)?;
2001 encode_tlv_stream!(w, {
2002 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
2003 (1, self.common_fields.channel_type, option),
2004 (2, self.require_confirmed_inputs, option),
2010 impl Readable for AcceptChannelV2 {
2011 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2012 let temporary_channel_id: ChannelId = Readable::read(r)?;
2013 let funding_satoshis: u64 = Readable::read(r)?;
2014 let dust_limit_satoshis: u64 = Readable::read(r)?;
2015 let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;
2016 let htlc_minimum_msat: u64 = Readable::read(r)?;
2017 let minimum_depth: u32 = Readable::read(r)?;
2018 let to_self_delay: u16 = Readable::read(r)?;
2019 let max_accepted_htlcs: u16 = Readable::read(r)?;
2020 let funding_pubkey: PublicKey = Readable::read(r)?;
2021 let revocation_basepoint: PublicKey = Readable::read(r)?;
2022 let payment_basepoint: PublicKey = Readable::read(r)?;
2023 let delayed_payment_basepoint: PublicKey = Readable::read(r)?;
2024 let htlc_basepoint: PublicKey = Readable::read(r)?;
2025 let first_per_commitment_point: PublicKey = Readable::read(r)?;
2026 let second_per_commitment_point: PublicKey = Readable::read(r)?;
2028 let mut shutdown_scriptpubkey: Option<ScriptBuf> = None;
2029 let mut channel_type: Option<ChannelTypeFeatures> = None;
2030 let mut require_confirmed_inputs: Option<()> = None;
2031 decode_tlv_stream!(r, {
2032 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
2033 (1, channel_type, option),
2034 (2, require_confirmed_inputs, option),
2037 Ok(AcceptChannelV2 {
2038 common_fields: CommonAcceptChannelFields {
2039 temporary_channel_id,
2040 dust_limit_satoshis,
2041 max_htlc_value_in_flight_msat,
2047 revocation_basepoint,
2049 delayed_payment_basepoint,
2051 first_per_commitment_point,
2052 shutdown_scriptpubkey,
2056 second_per_commitment_point,
2057 require_confirmed_inputs,
2062 impl_writeable_msg!(Stfu, {
2067 impl_writeable_msg!(Splice, {
2071 funding_feerate_perkw,
2076 impl_writeable_msg!(SpliceAck, {
2083 impl_writeable_msg!(SpliceLocked, {
2087 impl_writeable_msg!(TxAddInput, {
2095 impl_writeable_msg!(TxAddOutput, {
2102 impl_writeable_msg!(TxRemoveInput, {
2107 impl_writeable_msg!(TxRemoveOutput, {
2112 impl_writeable_msg!(TxComplete, {
2116 impl_writeable_msg!(TxSignatures, {
2122 impl_writeable_msg!(TxInitRbf, {
2125 feerate_sat_per_1000_weight,
2127 (0, funding_output_contribution, option),
2130 impl_writeable_msg!(TxAckRbf, {
2133 (0, funding_output_contribution, option),
2136 impl_writeable_msg!(TxAbort, {
2141 impl_writeable_msg!(AnnouncementSignatures, {
2148 impl_writeable_msg!(ChannelReestablish, {
2150 next_local_commitment_number,
2151 next_remote_commitment_number,
2152 your_last_per_commitment_secret,
2153 my_current_per_commitment_point,
2155 (0, next_funding_txid, option),
2158 impl_writeable_msg!(ClosingSigned,
2159 { channel_id, fee_satoshis, signature },
2160 { (1, fee_range, option) }
2163 impl_writeable!(ClosingSignedFeeRange, {
2168 #[cfg(not(taproot))]
2169 impl_writeable_msg!(CommitmentSigned, {
2176 impl_writeable_msg!(CommitmentSigned, {
2181 (2, partial_signature_with_nonce, option)
2184 impl_writeable!(DecodedOnionErrorPacket, {
2190 #[cfg(not(taproot))]
2191 impl_writeable_msg!(FundingCreated, {
2192 temporary_channel_id,
2194 funding_output_index,
2198 impl_writeable_msg!(FundingCreated, {
2199 temporary_channel_id,
2201 funding_output_index,
2204 (2, partial_signature_with_nonce, option),
2205 (4, next_local_nonce, option)
2208 #[cfg(not(taproot))]
2209 impl_writeable_msg!(FundingSigned, {
2215 impl_writeable_msg!(FundingSigned, {
2219 (2, partial_signature_with_nonce, option)
2222 impl_writeable_msg!(ChannelReady, {
2224 next_per_commitment_point,
2226 (1, short_channel_id_alias, option),
2229 impl Writeable for Init {
2230 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2231 // global_features gets the bottom 13 bits of our features, and local_features gets all of
2232 // our relevant feature bits. This keeps us compatible with old nodes.
2233 self.features.write_up_to_13(w)?;
2234 self.features.write(w)?;
2235 encode_tlv_stream!(w, {
2236 (1, self.networks.as_ref().map(|n| WithoutLength(n)), option),
2237 (3, self.remote_network_address, option),
2243 impl Readable for Init {
2244 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2245 let global_features: InitFeatures = Readable::read(r)?;
2246 let features: InitFeatures = Readable::read(r)?;
2247 let mut remote_network_address: Option<SocketAddress> = None;
2248 let mut networks: Option<WithoutLength<Vec<ChainHash>>> = None;
2249 decode_tlv_stream!(r, {
2250 (1, networks, option),
2251 (3, remote_network_address, option)
2254 features: features | global_features,
2255 networks: networks.map(|n| n.0),
2256 remote_network_address,
2261 impl Writeable for OpenChannel {
2262 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2263 self.common_fields.chain_hash.write(w)?;
2264 self.common_fields.temporary_channel_id.write(w)?;
2265 self.common_fields.funding_satoshis.write(w)?;
2266 self.push_msat.write(w)?;
2267 self.common_fields.dust_limit_satoshis.write(w)?;
2268 self.common_fields.max_htlc_value_in_flight_msat.write(w)?;
2269 self.channel_reserve_satoshis.write(w)?;
2270 self.common_fields.htlc_minimum_msat.write(w)?;
2271 self.common_fields.commitment_feerate_sat_per_1000_weight.write(w)?;
2272 self.common_fields.to_self_delay.write(w)?;
2273 self.common_fields.max_accepted_htlcs.write(w)?;
2274 self.common_fields.funding_pubkey.write(w)?;
2275 self.common_fields.revocation_basepoint.write(w)?;
2276 self.common_fields.payment_basepoint.write(w)?;
2277 self.common_fields.delayed_payment_basepoint.write(w)?;
2278 self.common_fields.htlc_basepoint.write(w)?;
2279 self.common_fields.first_per_commitment_point.write(w)?;
2280 self.common_fields.channel_flags.write(w)?;
2281 encode_tlv_stream!(w, {
2282 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
2283 (1, self.common_fields.channel_type, option),
2289 impl Readable for OpenChannel {
2290 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2291 let chain_hash: ChainHash = Readable::read(r)?;
2292 let temporary_channel_id: ChannelId = Readable::read(r)?;
2293 let funding_satoshis: u64 = Readable::read(r)?;
2294 let push_msat: u64 = Readable::read(r)?;
2295 let dust_limit_satoshis: u64 = Readable::read(r)?;
2296 let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;
2297 let channel_reserve_satoshis: u64 = Readable::read(r)?;
2298 let htlc_minimum_msat: u64 = Readable::read(r)?;
2299 let commitment_feerate_sat_per_1000_weight: u32 = Readable::read(r)?;
2300 let to_self_delay: u16 = Readable::read(r)?;
2301 let max_accepted_htlcs: u16 = Readable::read(r)?;
2302 let funding_pubkey: PublicKey = Readable::read(r)?;
2303 let revocation_basepoint: PublicKey = Readable::read(r)?;
2304 let payment_basepoint: PublicKey = Readable::read(r)?;
2305 let delayed_payment_basepoint: PublicKey = Readable::read(r)?;
2306 let htlc_basepoint: PublicKey = Readable::read(r)?;
2307 let first_per_commitment_point: PublicKey = Readable::read(r)?;
2308 let channel_flags: u8 = Readable::read(r)?;
2310 let mut shutdown_scriptpubkey: Option<ScriptBuf> = None;
2311 let mut channel_type: Option<ChannelTypeFeatures> = None;
2312 decode_tlv_stream!(r, {
2313 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
2314 (1, channel_type, option),
2317 common_fields: CommonOpenChannelFields {
2319 temporary_channel_id,
2321 dust_limit_satoshis,
2322 max_htlc_value_in_flight_msat,
2324 commitment_feerate_sat_per_1000_weight,
2328 revocation_basepoint,
2330 delayed_payment_basepoint,
2332 first_per_commitment_point,
2334 shutdown_scriptpubkey,
2338 channel_reserve_satoshis,
2343 impl Writeable for OpenChannelV2 {
2344 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2345 self.common_fields.chain_hash.write(w)?;
2346 self.common_fields.temporary_channel_id.write(w)?;
2347 self.funding_feerate_sat_per_1000_weight.write(w)?;
2348 self.common_fields.commitment_feerate_sat_per_1000_weight.write(w)?;
2349 self.common_fields.funding_satoshis.write(w)?;
2350 self.common_fields.dust_limit_satoshis.write(w)?;
2351 self.common_fields.max_htlc_value_in_flight_msat.write(w)?;
2352 self.common_fields.htlc_minimum_msat.write(w)?;
2353 self.common_fields.to_self_delay.write(w)?;
2354 self.common_fields.max_accepted_htlcs.write(w)?;
2355 self.locktime.write(w)?;
2356 self.common_fields.funding_pubkey.write(w)?;
2357 self.common_fields.revocation_basepoint.write(w)?;
2358 self.common_fields.payment_basepoint.write(w)?;
2359 self.common_fields.delayed_payment_basepoint.write(w)?;
2360 self.common_fields.htlc_basepoint.write(w)?;
2361 self.common_fields.first_per_commitment_point.write(w)?;
2362 self.second_per_commitment_point.write(w)?;
2363 self.common_fields.channel_flags.write(w)?;
2364 encode_tlv_stream!(w, {
2365 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
2366 (1, self.common_fields.channel_type, option),
2367 (2, self.require_confirmed_inputs, option),
2373 impl Readable for OpenChannelV2 {
2374 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2375 let chain_hash: ChainHash = Readable::read(r)?;
2376 let temporary_channel_id: ChannelId = Readable::read(r)?;
2377 let funding_feerate_sat_per_1000_weight: u32 = Readable::read(r)?;
2378 let commitment_feerate_sat_per_1000_weight: u32 = Readable::read(r)?;
2379 let funding_satoshis: u64 = Readable::read(r)?;
2380 let dust_limit_satoshis: u64 = Readable::read(r)?;
2381 let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;
2382 let htlc_minimum_msat: u64 = Readable::read(r)?;
2383 let to_self_delay: u16 = Readable::read(r)?;
2384 let max_accepted_htlcs: u16 = Readable::read(r)?;
2385 let locktime: u32 = Readable::read(r)?;
2386 let funding_pubkey: PublicKey = Readable::read(r)?;
2387 let revocation_basepoint: PublicKey = Readable::read(r)?;
2388 let payment_basepoint: PublicKey = Readable::read(r)?;
2389 let delayed_payment_basepoint: PublicKey = Readable::read(r)?;
2390 let htlc_basepoint: PublicKey = Readable::read(r)?;
2391 let first_per_commitment_point: PublicKey = Readable::read(r)?;
2392 let second_per_commitment_point: PublicKey = Readable::read(r)?;
2393 let channel_flags: u8 = Readable::read(r)?;
2395 let mut shutdown_scriptpubkey: Option<ScriptBuf> = None;
2396 let mut channel_type: Option<ChannelTypeFeatures> = None;
2397 let mut require_confirmed_inputs: Option<()> = None;
2398 decode_tlv_stream!(r, {
2399 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
2400 (1, channel_type, option),
2401 (2, require_confirmed_inputs, option),
2404 common_fields: CommonOpenChannelFields {
2406 temporary_channel_id,
2408 dust_limit_satoshis,
2409 max_htlc_value_in_flight_msat,
2411 commitment_feerate_sat_per_1000_weight,
2415 revocation_basepoint,
2417 delayed_payment_basepoint,
2419 first_per_commitment_point,
2421 shutdown_scriptpubkey,
2424 funding_feerate_sat_per_1000_weight,
2426 second_per_commitment_point,
2427 require_confirmed_inputs,
2432 #[cfg(not(taproot))]
2433 impl_writeable_msg!(RevokeAndACK, {
2435 per_commitment_secret,
2436 next_per_commitment_point
2440 impl_writeable_msg!(RevokeAndACK, {
2442 per_commitment_secret,
2443 next_per_commitment_point
2445 (4, next_local_nonce, option)
2448 impl_writeable_msg!(Shutdown, {
2453 impl_writeable_msg!(UpdateFailHTLC, {
2459 impl_writeable_msg!(UpdateFailMalformedHTLC, {
2466 impl_writeable_msg!(UpdateFee, {
2471 impl_writeable_msg!(UpdateFulfillHTLC, {
2477 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2478 // serialization format in a way which assumes we know the total serialized length/message end
2480 impl_writeable!(OnionErrorPacket, {
2484 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2485 // serialization format in a way which assumes we know the total serialized length/message end
2487 impl Writeable for OnionPacket {
2488 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2489 self.version.write(w)?;
2490 match self.public_key {
2491 Ok(pubkey) => pubkey.write(w)?,
2492 Err(_) => [0u8;33].write(w)?,
2494 w.write_all(&self.hop_data)?;
2495 self.hmac.write(w)?;
2500 impl Readable for OnionPacket {
2501 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2503 version: Readable::read(r)?,
2505 let mut buf = [0u8;33];
2506 r.read_exact(&mut buf)?;
2507 PublicKey::from_slice(&buf)
2509 hop_data: Readable::read(r)?,
2510 hmac: Readable::read(r)?,
2515 impl_writeable_msg!(UpdateAddHTLC, {
2521 onion_routing_packet,
2523 (0, blinding_point, option),
2524 (65537, skimmed_fee_msat, option)
2527 impl Readable for OnionMessage {
2528 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2529 let blinding_point: PublicKey = Readable::read(r)?;
2530 let len: u16 = Readable::read(r)?;
2531 let mut packet_reader = FixedLengthReader::new(r, len as u64);
2532 let onion_routing_packet: onion_message::packet::Packet =
2533 <onion_message::packet::Packet as LengthReadable>::read(&mut packet_reader)?;
2536 onion_routing_packet,
2541 impl Writeable for OnionMessage {
2542 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2543 self.blinding_point.write(w)?;
2544 let onion_packet_len = self.onion_routing_packet.serialized_length();
2545 (onion_packet_len as u16).write(w)?;
2546 self.onion_routing_packet.write(w)?;
2551 impl Writeable for FinalOnionHopData {
2552 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2553 self.payment_secret.0.write(w)?;
2554 HighZeroBytesDroppedBigSize(self.total_msat).write(w)
2558 impl Readable for FinalOnionHopData {
2559 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2560 let secret: [u8; 32] = Readable::read(r)?;
2561 let amt: HighZeroBytesDroppedBigSize<u64> = Readable::read(r)?;
2562 Ok(Self { payment_secret: PaymentSecret(secret), total_msat: amt.0 })
2566 impl Writeable for OutboundOnionPayload {
2567 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2569 Self::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } => {
2570 _encode_varint_length_prefixed_tlv!(w, {
2571 (2, HighZeroBytesDroppedBigSize(*amt_to_forward), required),
2572 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2573 (6, short_channel_id, required)
2576 Self::TrampolineEntrypoint {
2577 amt_to_forward, outgoing_cltv_value, ref multipath_trampoline_data,
2578 ref trampoline_packet
2580 _encode_varint_length_prefixed_tlv!(w, {
2581 (2, HighZeroBytesDroppedBigSize(*amt_to_forward), required),
2582 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2583 (8, multipath_trampoline_data, option),
2584 (20, trampoline_packet, required)
2588 ref payment_data, ref payment_metadata, ref keysend_preimage, sender_intended_htlc_amt_msat,
2589 cltv_expiry_height, ref custom_tlvs,
2591 // We need to update [`ln::outbound_payment::RecipientOnionFields::with_custom_tlvs`]
2592 // to reject any reserved types in the experimental range if new ones are ever
2594 let keysend_tlv = keysend_preimage.map(|preimage| (5482373484, preimage.encode()));
2595 let mut custom_tlvs: Vec<&(u64, Vec<u8>)> = custom_tlvs.iter().chain(keysend_tlv.iter()).collect();
2596 custom_tlvs.sort_unstable_by_key(|(typ, _)| *typ);
2597 _encode_varint_length_prefixed_tlv!(w, {
2598 (2, HighZeroBytesDroppedBigSize(*sender_intended_htlc_amt_msat), required),
2599 (4, HighZeroBytesDroppedBigSize(*cltv_expiry_height), required),
2600 (8, payment_data, option),
2601 (16, payment_metadata.as_ref().map(|m| WithoutLength(m)), option)
2602 }, custom_tlvs.iter());
2604 Self::BlindedForward { encrypted_tlvs, intro_node_blinding_point } => {
2605 _encode_varint_length_prefixed_tlv!(w, {
2606 (10, *encrypted_tlvs, required_vec),
2607 (12, intro_node_blinding_point, option)
2610 Self::BlindedReceive {
2611 sender_intended_htlc_amt_msat, total_msat, cltv_expiry_height, encrypted_tlvs,
2612 intro_node_blinding_point, keysend_preimage, ref custom_tlvs,
2614 // We need to update [`ln::outbound_payment::RecipientOnionFields::with_custom_tlvs`]
2615 // to reject any reserved types in the experimental range if new ones are ever
2617 let keysend_tlv = keysend_preimage.map(|preimage| (5482373484, preimage.encode()));
2618 let mut custom_tlvs: Vec<&(u64, Vec<u8>)> = custom_tlvs.iter().chain(keysend_tlv.iter()).collect();
2619 custom_tlvs.sort_unstable_by_key(|(typ, _)| *typ);
2620 _encode_varint_length_prefixed_tlv!(w, {
2621 (2, HighZeroBytesDroppedBigSize(*sender_intended_htlc_amt_msat), required),
2622 (4, HighZeroBytesDroppedBigSize(*cltv_expiry_height), required),
2623 (10, *encrypted_tlvs, required_vec),
2624 (12, intro_node_blinding_point, option),
2625 (18, HighZeroBytesDroppedBigSize(*total_msat), required)
2626 }, custom_tlvs.iter());
2633 impl Writeable for OutboundTrampolinePayload {
2634 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2636 Self::Forward { amt_to_forward, outgoing_cltv_value, outgoing_node_id } => {
2637 _encode_varint_length_prefixed_tlv!(w, {
2638 (2, HighZeroBytesDroppedBigSize(*amt_to_forward), required),
2639 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2640 (14, outgoing_node_id, required)
2649 impl<NS: Deref> ReadableArgs<(Option<PublicKey>, &NS)> for InboundOnionPayload where NS::Target: NodeSigner {
2650 fn read<R: Read>(r: &mut R, args: (Option<PublicKey>, &NS)) -> Result<Self, DecodeError> {
2651 let (update_add_blinding_point, node_signer) = args;
2654 let mut cltv_value = None;
2655 let mut short_id: Option<u64> = None;
2656 let mut payment_data: Option<FinalOnionHopData> = None;
2657 let mut encrypted_tlvs_opt: Option<WithoutLength<Vec<u8>>> = None;
2658 let mut intro_node_blinding_point = None;
2659 let mut payment_metadata: Option<WithoutLength<Vec<u8>>> = None;
2660 let mut total_msat = None;
2661 let mut keysend_preimage: Option<PaymentPreimage> = None;
2662 let mut custom_tlvs = Vec::new();
2664 let tlv_len = BigSize::read(r)?;
2665 let rd = FixedLengthReader::new(r, tlv_len.0);
2666 decode_tlv_stream_with_custom_tlv_decode!(rd, {
2667 (2, amt, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2668 (4, cltv_value, (option, encoding: (u32, HighZeroBytesDroppedBigSize))),
2669 (6, short_id, option),
2670 (8, payment_data, option),
2671 (10, encrypted_tlvs_opt, option),
2672 (12, intro_node_blinding_point, option),
2673 (16, payment_metadata, option),
2674 (18, total_msat, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2675 // See https://github.com/lightning/blips/blob/master/blip-0003.md
2676 (5482373484, keysend_preimage, option)
2677 }, |msg_type: u64, msg_reader: &mut FixedLengthReader<_>| -> Result<bool, DecodeError> {
2678 if msg_type < 1 << 16 { return Ok(false) }
2679 let mut value = Vec::new();
2680 msg_reader.read_to_end(&mut value)?;
2681 custom_tlvs.push((msg_type, value));
2685 if amt.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2686 if intro_node_blinding_point.is_some() && update_add_blinding_point.is_some() {
2687 return Err(DecodeError::InvalidValue)
2690 if let Some(blinding_point) = intro_node_blinding_point.or(update_add_blinding_point) {
2691 if short_id.is_some() || payment_data.is_some() || payment_metadata.is_some() {
2692 return Err(DecodeError::InvalidValue)
2694 let enc_tlvs = encrypted_tlvs_opt.ok_or(DecodeError::InvalidValue)?.0;
2695 let enc_tlvs_ss = node_signer.ecdh(Recipient::Node, &blinding_point, None)
2696 .map_err(|_| DecodeError::InvalidValue)?;
2697 let rho = onion_utils::gen_rho_from_shared_secret(&enc_tlvs_ss.secret_bytes());
2698 let mut s = Cursor::new(&enc_tlvs);
2699 let mut reader = FixedLengthReader::new(&mut s, enc_tlvs.len() as u64);
2700 match ChaChaPolyReadAdapter::read(&mut reader, rho)? {
2701 ChaChaPolyReadAdapter { readable: BlindedPaymentTlvs::Forward(ForwardTlvs {
2702 short_channel_id, payment_relay, payment_constraints, features
2704 if amt.is_some() || cltv_value.is_some() || total_msat.is_some() ||
2705 keysend_preimage.is_some()
2707 return Err(DecodeError::InvalidValue)
2709 Ok(Self::BlindedForward {
2712 payment_constraints,
2714 intro_node_blinding_point,
2717 ChaChaPolyReadAdapter { readable: BlindedPaymentTlvs::Receive(ReceiveTlvs {
2718 payment_secret, payment_constraints
2720 if total_msat.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2721 Ok(Self::BlindedReceive {
2722 sender_intended_htlc_amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2723 total_msat: total_msat.ok_or(DecodeError::InvalidValue)?,
2724 cltv_expiry_height: cltv_value.ok_or(DecodeError::InvalidValue)?,
2726 payment_constraints,
2727 intro_node_blinding_point,
2733 } else if let Some(short_channel_id) = short_id {
2734 if payment_data.is_some() || payment_metadata.is_some() || encrypted_tlvs_opt.is_some() ||
2735 total_msat.is_some()
2736 { return Err(DecodeError::InvalidValue) }
2739 amt_to_forward: amt.ok_or(DecodeError::InvalidValue)?,
2740 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2743 if encrypted_tlvs_opt.is_some() || total_msat.is_some() {
2744 return Err(DecodeError::InvalidValue)
2746 if let Some(data) = &payment_data {
2747 if data.total_msat > MAX_VALUE_MSAT {
2748 return Err(DecodeError::InvalidValue);
2753 payment_metadata: payment_metadata.map(|w| w.0),
2755 sender_intended_htlc_amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2756 cltv_expiry_height: cltv_value.ok_or(DecodeError::InvalidValue)?,
2763 impl Writeable for Ping {
2764 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2765 self.ponglen.write(w)?;
2766 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2771 impl Readable for Ping {
2772 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2774 ponglen: Readable::read(r)?,
2776 let byteslen = Readable::read(r)?;
2777 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2784 impl Writeable for Pong {
2785 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2786 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2791 impl Readable for Pong {
2792 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2795 let byteslen = Readable::read(r)?;
2796 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2803 impl Writeable for UnsignedChannelAnnouncement {
2804 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2805 self.features.write(w)?;
2806 self.chain_hash.write(w)?;
2807 self.short_channel_id.write(w)?;
2808 self.node_id_1.write(w)?;
2809 self.node_id_2.write(w)?;
2810 self.bitcoin_key_1.write(w)?;
2811 self.bitcoin_key_2.write(w)?;
2812 w.write_all(&self.excess_data[..])?;
2817 impl Readable for UnsignedChannelAnnouncement {
2818 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2820 features: Readable::read(r)?,
2821 chain_hash: Readable::read(r)?,
2822 short_channel_id: Readable::read(r)?,
2823 node_id_1: Readable::read(r)?,
2824 node_id_2: Readable::read(r)?,
2825 bitcoin_key_1: Readable::read(r)?,
2826 bitcoin_key_2: Readable::read(r)?,
2827 excess_data: read_to_end(r)?,
2832 impl_writeable!(ChannelAnnouncement, {
2835 bitcoin_signature_1,
2836 bitcoin_signature_2,
2840 impl Writeable for UnsignedChannelUpdate {
2841 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2842 // `message_flags` used to indicate presence of `htlc_maximum_msat`, but was deprecated in the spec.
2843 const MESSAGE_FLAGS: u8 = 1;
2844 self.chain_hash.write(w)?;
2845 self.short_channel_id.write(w)?;
2846 self.timestamp.write(w)?;
2847 let all_flags = self.flags as u16 | ((MESSAGE_FLAGS as u16) << 8);
2848 all_flags.write(w)?;
2849 self.cltv_expiry_delta.write(w)?;
2850 self.htlc_minimum_msat.write(w)?;
2851 self.fee_base_msat.write(w)?;
2852 self.fee_proportional_millionths.write(w)?;
2853 self.htlc_maximum_msat.write(w)?;
2854 w.write_all(&self.excess_data[..])?;
2859 impl Readable for UnsignedChannelUpdate {
2860 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2862 chain_hash: Readable::read(r)?,
2863 short_channel_id: Readable::read(r)?,
2864 timestamp: Readable::read(r)?,
2866 let flags: u16 = Readable::read(r)?;
2867 // Note: we ignore the `message_flags` for now, since it was deprecated by the spec.
2870 cltv_expiry_delta: Readable::read(r)?,
2871 htlc_minimum_msat: Readable::read(r)?,
2872 fee_base_msat: Readable::read(r)?,
2873 fee_proportional_millionths: Readable::read(r)?,
2874 htlc_maximum_msat: Readable::read(r)?,
2875 excess_data: read_to_end(r)?,
2880 impl_writeable!(ChannelUpdate, {
2885 impl Writeable for ErrorMessage {
2886 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2887 self.channel_id.write(w)?;
2888 (self.data.len() as u16).write(w)?;
2889 w.write_all(self.data.as_bytes())?;
2894 impl Readable for ErrorMessage {
2895 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2897 channel_id: Readable::read(r)?,
2899 let sz: usize = <u16 as Readable>::read(r)? as usize;
2900 let mut data = Vec::with_capacity(sz);
2902 r.read_exact(&mut data)?;
2903 match String::from_utf8(data) {
2905 Err(_) => return Err(DecodeError::InvalidValue),
2912 impl Writeable for WarningMessage {
2913 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2914 self.channel_id.write(w)?;
2915 (self.data.len() as u16).write(w)?;
2916 w.write_all(self.data.as_bytes())?;
2921 impl Readable for WarningMessage {
2922 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2924 channel_id: Readable::read(r)?,
2926 let sz: usize = <u16 as Readable>::read(r)? as usize;
2927 let mut data = Vec::with_capacity(sz);
2929 r.read_exact(&mut data)?;
2930 match String::from_utf8(data) {
2932 Err(_) => return Err(DecodeError::InvalidValue),
2939 impl Writeable for UnsignedNodeAnnouncement {
2940 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2941 self.features.write(w)?;
2942 self.timestamp.write(w)?;
2943 self.node_id.write(w)?;
2944 w.write_all(&self.rgb)?;
2945 self.alias.write(w)?;
2947 let mut addr_len = 0;
2948 for addr in self.addresses.iter() {
2949 addr_len += 1 + addr.len();
2951 (addr_len + self.excess_address_data.len() as u16).write(w)?;
2952 for addr in self.addresses.iter() {
2955 w.write_all(&self.excess_address_data[..])?;
2956 w.write_all(&self.excess_data[..])?;
2961 impl Readable for UnsignedNodeAnnouncement {
2962 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2963 let features: NodeFeatures = Readable::read(r)?;
2964 let timestamp: u32 = Readable::read(r)?;
2965 let node_id: NodeId = Readable::read(r)?;
2966 let mut rgb = [0; 3];
2967 r.read_exact(&mut rgb)?;
2968 let alias: NodeAlias = Readable::read(r)?;
2970 let addr_len: u16 = Readable::read(r)?;
2971 let mut addresses: Vec<SocketAddress> = Vec::new();
2972 let mut addr_readpos = 0;
2973 let mut excess = false;
2974 let mut excess_byte = 0;
2976 if addr_len <= addr_readpos { break; }
2977 match Readable::read(r) {
2979 if addr_len < addr_readpos + 1 + addr.len() {
2980 return Err(DecodeError::BadLengthDescriptor);
2982 addr_readpos += (1 + addr.len()) as u16;
2983 addresses.push(addr);
2985 Ok(Err(unknown_descriptor)) => {
2987 excess_byte = unknown_descriptor;
2990 Err(DecodeError::ShortRead) => return Err(DecodeError::BadLengthDescriptor),
2991 Err(e) => return Err(e),
2995 let mut excess_data = vec![];
2996 let excess_address_data = if addr_readpos < addr_len {
2997 let mut excess_address_data = vec![0; (addr_len - addr_readpos) as usize];
2998 r.read_exact(&mut excess_address_data[if excess { 1 } else { 0 }..])?;
3000 excess_address_data[0] = excess_byte;
3005 excess_data.push(excess_byte);
3009 excess_data.extend(read_to_end(r)?.iter());
3010 Ok(UnsignedNodeAnnouncement {
3017 excess_address_data,
3023 impl_writeable!(NodeAnnouncement, {
3028 impl Readable for QueryShortChannelIds {
3029 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
3030 let chain_hash: ChainHash = Readable::read(r)?;
3032 let encoding_len: u16 = Readable::read(r)?;
3033 let encoding_type: u8 = Readable::read(r)?;
3035 // Must be encoding_type=0 uncompressed serialization. We do not
3036 // support encoding_type=1 zlib serialization.
3037 if encoding_type != EncodingType::Uncompressed as u8 {
3038 return Err(DecodeError::UnsupportedCompression);
3041 // We expect the encoding_len to always includes the 1-byte
3042 // encoding_type and that short_channel_ids are 8-bytes each
3043 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
3044 return Err(DecodeError::InvalidValue);
3047 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
3048 // less the 1-byte encoding_type
3049 let short_channel_id_count: u16 = (encoding_len - 1)/8;
3050 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
3051 for _ in 0..short_channel_id_count {
3052 short_channel_ids.push(Readable::read(r)?);
3055 Ok(QueryShortChannelIds {
3062 impl Writeable for QueryShortChannelIds {
3063 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
3064 // Calculated from 1-byte encoding_type plus 8-bytes per short_channel_id
3065 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
3067 self.chain_hash.write(w)?;
3068 encoding_len.write(w)?;
3070 // We only support type=0 uncompressed serialization
3071 (EncodingType::Uncompressed as u8).write(w)?;
3073 for scid in self.short_channel_ids.iter() {
3081 impl_writeable_msg!(ReplyShortChannelIdsEnd, {
3086 impl QueryChannelRange {
3087 /// Calculates the overflow safe ending block height for the query.
3089 /// Overflow returns `0xffffffff`, otherwise returns `first_blocknum + number_of_blocks`.
3090 pub fn end_blocknum(&self) -> u32 {
3091 match self.first_blocknum.checked_add(self.number_of_blocks) {
3092 Some(block) => block,
3093 None => u32::max_value(),
3098 impl_writeable_msg!(QueryChannelRange, {
3104 impl Readable for ReplyChannelRange {
3105 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
3106 let chain_hash: ChainHash = Readable::read(r)?;
3107 let first_blocknum: u32 = Readable::read(r)?;
3108 let number_of_blocks: u32 = Readable::read(r)?;
3109 let sync_complete: bool = Readable::read(r)?;
3111 let encoding_len: u16 = Readable::read(r)?;
3112 let encoding_type: u8 = Readable::read(r)?;
3114 // Must be encoding_type=0 uncompressed serialization. We do not
3115 // support encoding_type=1 zlib serialization.
3116 if encoding_type != EncodingType::Uncompressed as u8 {
3117 return Err(DecodeError::UnsupportedCompression);
3120 // We expect the encoding_len to always includes the 1-byte
3121 // encoding_type and that short_channel_ids are 8-bytes each
3122 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
3123 return Err(DecodeError::InvalidValue);
3126 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
3127 // less the 1-byte encoding_type
3128 let short_channel_id_count: u16 = (encoding_len - 1)/8;
3129 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
3130 for _ in 0..short_channel_id_count {
3131 short_channel_ids.push(Readable::read(r)?);
3134 Ok(ReplyChannelRange {
3144 impl Writeable for ReplyChannelRange {
3145 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
3146 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
3147 self.chain_hash.write(w)?;
3148 self.first_blocknum.write(w)?;
3149 self.number_of_blocks.write(w)?;
3150 self.sync_complete.write(w)?;
3152 encoding_len.write(w)?;
3153 (EncodingType::Uncompressed as u8).write(w)?;
3154 for scid in self.short_channel_ids.iter() {
3162 impl_writeable_msg!(GossipTimestampFilter, {
3170 use std::convert::TryFrom;
3171 use bitcoin::{Transaction, TxIn, ScriptBuf, Sequence, Witness, TxOut};
3172 use hex::DisplayHex;
3173 use crate::ln::{PaymentPreimage, PaymentHash, PaymentSecret};
3174 use crate::ln::ChannelId;
3175 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
3176 use crate::ln::msgs::{self, FinalOnionHopData, OnionErrorPacket, CommonOpenChannelFields, CommonAcceptChannelFields, TrampolineOnionPacket};
3177 use crate::ln::msgs::SocketAddress;
3178 use crate::routing::gossip::{NodeAlias, NodeId};
3179 use crate::util::ser::{BigSize, Hostname, Readable, ReadableArgs, TransactionU16LenLimited, Writeable};
3180 use crate::util::test_utils;
3182 use bitcoin::hashes::hex::FromHex;
3183 use bitcoin::address::Address;
3184 use bitcoin::network::constants::Network;
3185 use bitcoin::blockdata::constants::ChainHash;
3186 use bitcoin::blockdata::script::Builder;
3187 use bitcoin::blockdata::opcodes;
3188 use bitcoin::hash_types::Txid;
3189 use bitcoin::locktime::absolute::LockTime;
3191 use bitcoin::secp256k1::{PublicKey,SecretKey};
3192 use bitcoin::secp256k1::{Secp256k1, Message};
3194 use crate::io::{self, Cursor};
3195 use crate::prelude::*;
3196 use core::str::FromStr;
3197 use crate::chain::transaction::OutPoint;
3199 #[cfg(feature = "std")]
3200 use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6, ToSocketAddrs};
3201 #[cfg(feature = "std")]
3202 use crate::ln::msgs::SocketAddressParseError;
3205 fn encoding_channel_reestablish() {
3207 let secp_ctx = Secp256k1::new();
3208 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&<Vec<u8>>::from_hex("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
3211 let cr = msgs::ChannelReestablish {
3212 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]),
3213 next_local_commitment_number: 3,
3214 next_remote_commitment_number: 4,
3215 your_last_per_commitment_secret: [9;32],
3216 my_current_per_commitment_point: public_key,
3217 next_funding_txid: None,
3220 let encoded_value = cr.encode();
3224 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
3225 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
3226 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
3227 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
3228 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
3234 fn encoding_channel_reestablish_with_next_funding_txid() {
3236 let secp_ctx = Secp256k1::new();
3237 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&<Vec<u8>>::from_hex("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
3240 let cr = msgs::ChannelReestablish {
3241 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]),
3242 next_local_commitment_number: 3,
3243 next_remote_commitment_number: 4,
3244 your_last_per_commitment_secret: [9;32],
3245 my_current_per_commitment_point: public_key,
3246 next_funding_txid: Some(Txid::from_raw_hash(bitcoin::hashes::Hash::from_slice(&[
3247 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,
3251 let encoded_value = cr.encode();
3255 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
3256 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
3257 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
3258 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
3259 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
3260 0, // Type (next_funding_txid)
3262 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
3267 macro_rules! get_keys_from {
3268 ($slice: expr, $secp_ctx: expr) => {
3270 let privkey = SecretKey::from_slice(&<Vec<u8>>::from_hex($slice).unwrap()[..]).unwrap();
3271 let pubkey = PublicKey::from_secret_key(&$secp_ctx, &privkey);
3277 macro_rules! get_sig_on {
3278 ($privkey: expr, $ctx: expr, $string: expr) => {
3280 let sighash = Message::from_slice(&$string.into_bytes()[..]).unwrap();
3281 $ctx.sign_ecdsa(&sighash, &$privkey)
3287 fn encoding_announcement_signatures() {
3288 let secp_ctx = Secp256k1::new();
3289 let (privkey, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3290 let sig_1 = get_sig_on!(privkey, secp_ctx, String::from("01010101010101010101010101010101"));
3291 let sig_2 = get_sig_on!(privkey, secp_ctx, String::from("02020202020202020202020202020202"));
3292 let announcement_signatures = msgs::AnnouncementSignatures {
3293 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]),
3294 short_channel_id: 2316138423780173,
3295 node_signature: sig_1,
3296 bitcoin_signature: sig_2,
3299 let encoded_value = announcement_signatures.encode();
3300 assert_eq!(encoded_value, <Vec<u8>>::from_hex("040000000000000005000000000000000600000000000000070000000000000000083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073acf9953cef4700860f5967838eba2bae89288ad188ebf8b20bf995c3ea53a26df1876d0a3a0e13172ba286a673140190c02ba9da60a2e43a745188c8a83c7f3ef").unwrap());
3303 fn do_encoding_channel_announcement(unknown_features_bits: bool, excess_data: bool) {
3304 let secp_ctx = Secp256k1::new();
3305 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3306 let (privkey_2, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3307 let (privkey_3, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3308 let (privkey_4, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3309 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3310 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
3311 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
3312 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
3313 let mut features = ChannelFeatures::empty();
3314 if unknown_features_bits {
3315 features = ChannelFeatures::from_le_bytes(vec![0xFF, 0xFF]);
3317 let unsigned_channel_announcement = msgs::UnsignedChannelAnnouncement {
3319 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3320 short_channel_id: 2316138423780173,
3321 node_id_1: NodeId::from_pubkey(&pubkey_1),
3322 node_id_2: NodeId::from_pubkey(&pubkey_2),
3323 bitcoin_key_1: NodeId::from_pubkey(&pubkey_3),
3324 bitcoin_key_2: NodeId::from_pubkey(&pubkey_4),
3325 excess_data: if excess_data { vec![10, 0, 0, 20, 0, 0, 30, 0, 0, 40] } else { Vec::new() },
3327 let channel_announcement = msgs::ChannelAnnouncement {
3328 node_signature_1: sig_1,
3329 node_signature_2: sig_2,
3330 bitcoin_signature_1: sig_3,
3331 bitcoin_signature_2: sig_4,
3332 contents: unsigned_channel_announcement,
3334 let encoded_value = channel_announcement.encode();
3335 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a1735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap();
3336 if unknown_features_bits {
3337 target_value.append(&mut <Vec<u8>>::from_hex("0002ffff").unwrap());
3339 target_value.append(&mut <Vec<u8>>::from_hex("0000").unwrap());
3341 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3342 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
3344 target_value.append(&mut <Vec<u8>>::from_hex("0a00001400001e000028").unwrap());
3346 assert_eq!(encoded_value, target_value);
3350 fn encoding_channel_announcement() {
3351 do_encoding_channel_announcement(true, false);
3352 do_encoding_channel_announcement(false, true);
3353 do_encoding_channel_announcement(false, false);
3354 do_encoding_channel_announcement(true, true);
3357 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) {
3358 let secp_ctx = Secp256k1::new();
3359 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3360 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3361 let features = if unknown_features_bits {
3362 NodeFeatures::from_le_bytes(vec![0xFF, 0xFF])
3364 // Set to some features we may support
3365 NodeFeatures::from_le_bytes(vec![2 | 1 << 5])
3367 let mut addresses = Vec::new();
3369 addresses.push(SocketAddress::TcpIpV4 {
3370 addr: [255, 254, 253, 252],
3375 addresses.push(SocketAddress::TcpIpV6 {
3376 addr: [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240],
3381 addresses.push(msgs::SocketAddress::OnionV2(
3382 [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 38, 7]
3386 addresses.push(msgs::SocketAddress::OnionV3 {
3387 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],
3394 addresses.push(SocketAddress::Hostname {
3395 hostname: Hostname::try_from(String::from("host")).unwrap(),
3399 let mut addr_len = 0;
3400 for addr in &addresses {
3401 addr_len += addr.len() + 1;
3403 let unsigned_node_announcement = msgs::UnsignedNodeAnnouncement {
3405 timestamp: 20190119,
3406 node_id: NodeId::from_pubkey(&pubkey_1),
3408 alias: NodeAlias([16;32]),
3410 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() },
3411 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() },
3413 addr_len += unsigned_node_announcement.excess_address_data.len() as u16;
3414 let node_announcement = msgs::NodeAnnouncement {
3416 contents: unsigned_node_announcement,
3418 let encoded_value = node_announcement.encode();
3419 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3420 if unknown_features_bits {
3421 target_value.append(&mut <Vec<u8>>::from_hex("0002ffff").unwrap());
3423 target_value.append(&mut <Vec<u8>>::from_hex("000122").unwrap());
3425 target_value.append(&mut <Vec<u8>>::from_hex("013413a7031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f2020201010101010101010101010101010101010101010101010101010101010101010").unwrap());
3426 target_value.append(&mut vec![(addr_len >> 8) as u8, addr_len as u8]);
3428 target_value.append(&mut <Vec<u8>>::from_hex("01fffefdfc2607").unwrap());
3431 target_value.append(&mut <Vec<u8>>::from_hex("02fffefdfcfbfaf9f8f7f6f5f4f3f2f1f02607").unwrap());
3434 target_value.append(&mut <Vec<u8>>::from_hex("03fffefdfcfbfaf9f8f7f62607").unwrap());
3437 target_value.append(&mut <Vec<u8>>::from_hex("04fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0efeeedecebeae9e8e7e6e5e4e3e2e1e00020102607").unwrap());
3440 target_value.append(&mut <Vec<u8>>::from_hex("0504686f73742607").unwrap());
3442 if excess_address_data {
3443 target_value.append(&mut <Vec<u8>>::from_hex("216c280b5395a2546e7e4b2663e04f811622f15a4f92e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d269").unwrap());
3446 target_value.append(&mut <Vec<u8>>::from_hex("3b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
3448 assert_eq!(encoded_value, target_value);
3452 fn encoding_node_announcement() {
3453 do_encoding_node_announcement(true, true, true, true, true, true, true, true);
3454 do_encoding_node_announcement(false, false, false, false, false, false, false, false);
3455 do_encoding_node_announcement(false, true, false, false, false, false, false, false);
3456 do_encoding_node_announcement(false, false, true, false, false, false, false, false);
3457 do_encoding_node_announcement(false, false, false, true, false, false, false, false);
3458 do_encoding_node_announcement(false, false, false, false, true, false, false, false);
3459 do_encoding_node_announcement(false, false, false, false, false, true, false, false);
3460 do_encoding_node_announcement(false, false, false, false, false, false, true, false);
3461 do_encoding_node_announcement(false, true, false, true, false, false, true, false);
3462 do_encoding_node_announcement(false, false, true, false, true, false, false, false);
3465 fn do_encoding_channel_update(direction: bool, disable: bool, excess_data: bool) {
3466 let secp_ctx = Secp256k1::new();
3467 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3468 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3469 let unsigned_channel_update = msgs::UnsignedChannelUpdate {
3470 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3471 short_channel_id: 2316138423780173,
3472 timestamp: 20190119,
3473 flags: if direction { 1 } else { 0 } | if disable { 1 << 1 } else { 0 },
3474 cltv_expiry_delta: 144,
3475 htlc_minimum_msat: 1000000,
3476 htlc_maximum_msat: 131355275467161,
3477 fee_base_msat: 10000,
3478 fee_proportional_millionths: 20,
3479 excess_data: if excess_data { vec![0, 0, 0, 0, 59, 154, 202, 0] } else { Vec::new() }
3481 let channel_update = msgs::ChannelUpdate {
3483 contents: unsigned_channel_update
3485 let encoded_value = channel_update.encode();
3486 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3487 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3488 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d013413a7").unwrap());
3489 target_value.append(&mut <Vec<u8>>::from_hex("01").unwrap());
3490 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3492 let flag = target_value.last_mut().unwrap();
3496 let flag = target_value.last_mut().unwrap();
3497 *flag = *flag | 1 << 1;
3499 target_value.append(&mut <Vec<u8>>::from_hex("009000000000000f42400000271000000014").unwrap());
3500 target_value.append(&mut <Vec<u8>>::from_hex("0000777788889999").unwrap());
3502 target_value.append(&mut <Vec<u8>>::from_hex("000000003b9aca00").unwrap());
3504 assert_eq!(encoded_value, target_value);
3508 fn encoding_channel_update() {
3509 do_encoding_channel_update(false, false, false);
3510 do_encoding_channel_update(false, false, true);
3511 do_encoding_channel_update(true, false, false);
3512 do_encoding_channel_update(true, false, true);
3513 do_encoding_channel_update(false, true, false);
3514 do_encoding_channel_update(false, true, true);
3515 do_encoding_channel_update(true, true, false);
3516 do_encoding_channel_update(true, true, true);
3519 fn do_encoding_open_channel(random_bit: bool, shutdown: bool, incl_chan_type: bool) {
3520 let secp_ctx = Secp256k1::new();
3521 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3522 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3523 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3524 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3525 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3526 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3527 let open_channel = msgs::OpenChannel {
3528 common_fields: CommonOpenChannelFields {
3529 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3530 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3531 funding_satoshis: 1311768467284833366,
3532 dust_limit_satoshis: 3608586615801332854,
3533 max_htlc_value_in_flight_msat: 8517154655701053848,
3534 htlc_minimum_msat: 2316138423780173,
3535 commitment_feerate_sat_per_1000_weight: 821716,
3536 to_self_delay: 49340,
3537 max_accepted_htlcs: 49340,
3538 funding_pubkey: pubkey_1,
3539 revocation_basepoint: pubkey_2,
3540 payment_basepoint: pubkey_3,
3541 delayed_payment_basepoint: pubkey_4,
3542 htlc_basepoint: pubkey_5,
3543 first_per_commitment_point: pubkey_6,
3544 channel_flags: if random_bit { 1 << 5 } else { 0 },
3545 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3546 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3548 push_msat: 2536655962884945560,
3549 channel_reserve_satoshis: 8665828695742877976,
3551 let encoded_value = open_channel.encode();
3552 let mut target_value = Vec::new();
3553 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3554 target_value.append(&mut <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202021234567890123456233403289122369832144668701144767633030896203198784335490624111800083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3556 target_value.append(&mut <Vec<u8>>::from_hex("20").unwrap());
3558 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3561 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3564 target_value.append(&mut <Vec<u8>>::from_hex("0100").unwrap());
3566 assert_eq!(encoded_value, target_value);
3570 fn encoding_open_channel() {
3571 do_encoding_open_channel(false, false, false);
3572 do_encoding_open_channel(false, false, true);
3573 do_encoding_open_channel(false, true, false);
3574 do_encoding_open_channel(false, true, true);
3575 do_encoding_open_channel(true, false, false);
3576 do_encoding_open_channel(true, false, true);
3577 do_encoding_open_channel(true, true, false);
3578 do_encoding_open_channel(true, true, true);
3581 fn do_encoding_open_channelv2(random_bit: bool, shutdown: bool, incl_chan_type: bool, require_confirmed_inputs: bool) {
3582 let secp_ctx = Secp256k1::new();
3583 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3584 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3585 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3586 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3587 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3588 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3589 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3590 let open_channelv2 = msgs::OpenChannelV2 {
3591 common_fields: CommonOpenChannelFields {
3592 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3593 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3594 commitment_feerate_sat_per_1000_weight: 821716,
3595 funding_satoshis: 1311768467284833366,
3596 dust_limit_satoshis: 3608586615801332854,
3597 max_htlc_value_in_flight_msat: 8517154655701053848,
3598 htlc_minimum_msat: 2316138423780173,
3599 to_self_delay: 49340,
3600 max_accepted_htlcs: 49340,
3601 funding_pubkey: pubkey_1,
3602 revocation_basepoint: pubkey_2,
3603 payment_basepoint: pubkey_3,
3604 delayed_payment_basepoint: pubkey_4,
3605 htlc_basepoint: pubkey_5,
3606 first_per_commitment_point: pubkey_6,
3607 channel_flags: if random_bit { 1 << 5 } else { 0 },
3608 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3609 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3611 funding_feerate_sat_per_1000_weight: 821716,
3612 locktime: 305419896,
3613 second_per_commitment_point: pubkey_7,
3614 require_confirmed_inputs: if require_confirmed_inputs { Some(()) } else { None },
3616 let encoded_value = open_channelv2.encode();
3617 let mut target_value = Vec::new();
3618 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3619 target_value.append(&mut <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap());
3620 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap());
3621 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap());
3622 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap());
3623 target_value.append(&mut <Vec<u8>>::from_hex("3214466870114476").unwrap());
3624 target_value.append(&mut <Vec<u8>>::from_hex("7633030896203198").unwrap());
3625 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d").unwrap());
3626 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap());
3627 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap());
3628 target_value.append(&mut <Vec<u8>>::from_hex("12345678").unwrap());
3629 target_value.append(&mut <Vec<u8>>::from_hex("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap());
3630 target_value.append(&mut <Vec<u8>>::from_hex("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap());
3631 target_value.append(&mut <Vec<u8>>::from_hex("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap());
3632 target_value.append(&mut <Vec<u8>>::from_hex("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
3633 target_value.append(&mut <Vec<u8>>::from_hex("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap());
3634 target_value.append(&mut <Vec<u8>>::from_hex("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3635 target_value.append(&mut <Vec<u8>>::from_hex("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap());
3638 target_value.append(&mut <Vec<u8>>::from_hex("20").unwrap());
3640 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3643 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3646 target_value.append(&mut <Vec<u8>>::from_hex("0100").unwrap());
3648 if require_confirmed_inputs {
3649 target_value.append(&mut <Vec<u8>>::from_hex("0200").unwrap());
3651 assert_eq!(encoded_value, target_value);
3655 fn encoding_open_channelv2() {
3656 do_encoding_open_channelv2(false, false, false, false);
3657 do_encoding_open_channelv2(false, false, false, true);
3658 do_encoding_open_channelv2(false, false, true, false);
3659 do_encoding_open_channelv2(false, false, true, true);
3660 do_encoding_open_channelv2(false, true, false, false);
3661 do_encoding_open_channelv2(false, true, false, true);
3662 do_encoding_open_channelv2(false, true, true, false);
3663 do_encoding_open_channelv2(false, true, true, true);
3664 do_encoding_open_channelv2(true, false, false, false);
3665 do_encoding_open_channelv2(true, false, false, true);
3666 do_encoding_open_channelv2(true, false, true, false);
3667 do_encoding_open_channelv2(true, false, true, true);
3668 do_encoding_open_channelv2(true, true, false, false);
3669 do_encoding_open_channelv2(true, true, false, true);
3670 do_encoding_open_channelv2(true, true, true, false);
3671 do_encoding_open_channelv2(true, true, true, true);
3674 fn do_encoding_accept_channel(shutdown: bool) {
3675 let secp_ctx = Secp256k1::new();
3676 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3677 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3678 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3679 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3680 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3681 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3682 let accept_channel = msgs::AcceptChannel {
3683 common_fields: CommonAcceptChannelFields {
3684 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3685 dust_limit_satoshis: 1311768467284833366,
3686 max_htlc_value_in_flight_msat: 2536655962884945560,
3687 htlc_minimum_msat: 2316138423780173,
3688 minimum_depth: 821716,
3689 to_self_delay: 49340,
3690 max_accepted_htlcs: 49340,
3691 funding_pubkey: pubkey_1,
3692 revocation_basepoint: pubkey_2,
3693 payment_basepoint: pubkey_3,
3694 delayed_payment_basepoint: pubkey_4,
3695 htlc_basepoint: pubkey_5,
3696 first_per_commitment_point: pubkey_6,
3697 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3700 channel_reserve_satoshis: 3608586615801332854,
3702 next_local_nonce: None,
3704 let encoded_value = accept_channel.encode();
3705 let mut target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020212345678901234562334032891223698321446687011447600083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap();
3707 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3709 assert_eq!(encoded_value, target_value);
3713 fn encoding_accept_channel() {
3714 do_encoding_accept_channel(false);
3715 do_encoding_accept_channel(true);
3718 fn do_encoding_accept_channelv2(shutdown: bool) {
3719 let secp_ctx = Secp256k1::new();
3720 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3721 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3722 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3723 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3724 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3725 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3726 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3727 let accept_channelv2 = msgs::AcceptChannelV2 {
3728 common_fields: CommonAcceptChannelFields {
3729 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3730 dust_limit_satoshis: 1311768467284833366,
3731 max_htlc_value_in_flight_msat: 2536655962884945560,
3732 htlc_minimum_msat: 2316138423780173,
3733 minimum_depth: 821716,
3734 to_self_delay: 49340,
3735 max_accepted_htlcs: 49340,
3736 funding_pubkey: pubkey_1,
3737 revocation_basepoint: pubkey_2,
3738 payment_basepoint: pubkey_3,
3739 delayed_payment_basepoint: pubkey_4,
3740 htlc_basepoint: pubkey_5,
3741 first_per_commitment_point: pubkey_6,
3742 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3745 funding_satoshis: 1311768467284833366,
3746 second_per_commitment_point: pubkey_7,
3747 require_confirmed_inputs: None,
3749 let encoded_value = accept_channelv2.encode();
3750 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // temporary_channel_id
3751 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap()); // funding_satoshis
3752 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap()); // dust_limit_satoshis
3753 target_value.append(&mut <Vec<u8>>::from_hex("2334032891223698").unwrap()); // max_htlc_value_in_flight_msat
3754 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d").unwrap()); // htlc_minimum_msat
3755 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap()); // minimum_depth
3756 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap()); // to_self_delay
3757 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap()); // max_accepted_htlcs
3758 target_value.append(&mut <Vec<u8>>::from_hex("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap()); // funding_pubkey
3759 target_value.append(&mut <Vec<u8>>::from_hex("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap()); // revocation_basepoint
3760 target_value.append(&mut <Vec<u8>>::from_hex("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap()); // payment_basepoint
3761 target_value.append(&mut <Vec<u8>>::from_hex("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap()); // delayed_payment_basepoint
3762 target_value.append(&mut <Vec<u8>>::from_hex("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap()); // htlc_basepoint
3763 target_value.append(&mut <Vec<u8>>::from_hex("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap()); // first_per_commitment_point
3764 target_value.append(&mut <Vec<u8>>::from_hex("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap()); // second_per_commitment_point
3766 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3768 assert_eq!(encoded_value, target_value);
3772 fn encoding_accept_channelv2() {
3773 do_encoding_accept_channelv2(false);
3774 do_encoding_accept_channelv2(true);
3778 fn encoding_funding_created() {
3779 let secp_ctx = Secp256k1::new();
3780 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3781 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3782 let funding_created = msgs::FundingCreated {
3783 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3784 funding_txid: Txid::from_str("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3785 funding_output_index: 255,
3788 partial_signature_with_nonce: None,
3790 next_local_nonce: None,
3792 let encoded_value = funding_created.encode();
3793 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202026e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c200ffd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3794 assert_eq!(encoded_value, target_value);
3798 fn encoding_funding_signed() {
3799 let secp_ctx = Secp256k1::new();
3800 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3801 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3802 let funding_signed = msgs::FundingSigned {
3803 channel_id: ChannelId::from_bytes([2; 32]),
3806 partial_signature_with_nonce: None,
3808 let encoded_value = funding_signed.encode();
3809 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3810 assert_eq!(encoded_value, target_value);
3814 fn encoding_channel_ready() {
3815 let secp_ctx = Secp256k1::new();
3816 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3817 let channel_ready = msgs::ChannelReady {
3818 channel_id: ChannelId::from_bytes([2; 32]),
3819 next_per_commitment_point: pubkey_1,
3820 short_channel_id_alias: None,
3822 let encoded_value = channel_ready.encode();
3823 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3824 assert_eq!(encoded_value, target_value);
3828 fn encoding_splice() {
3829 let secp_ctx = Secp256k1::new();
3830 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3831 let splice = msgs::Splice {
3832 chain_hash: ChainHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
3833 channel_id: ChannelId::from_bytes([2; 32]),
3834 relative_satoshis: 123456,
3835 funding_feerate_perkw: 2000,
3837 funding_pubkey: pubkey_1,
3839 let encoded_value = splice.encode();
3840 assert_eq!(encoded_value.as_hex().to_string(), "02020202020202020202020202020202020202020202020202020202020202026fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000000000000001e240000007d000000000031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f");
3844 fn encoding_stfu() {
3845 let stfu = msgs::Stfu {
3846 channel_id: ChannelId::from_bytes([2; 32]),
3849 let encoded_value = stfu.encode();
3850 assert_eq!(encoded_value.as_hex().to_string(), "020202020202020202020202020202020202020202020202020202020202020201");
3854 fn encoding_splice_ack() {
3855 let secp_ctx = Secp256k1::new();
3856 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3857 let splice = msgs::SpliceAck {
3858 chain_hash: ChainHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
3859 channel_id: ChannelId::from_bytes([2; 32]),
3860 relative_satoshis: 123456,
3861 funding_pubkey: pubkey_1,
3863 let encoded_value = splice.encode();
3864 assert_eq!(encoded_value.as_hex().to_string(), "02020202020202020202020202020202020202020202020202020202020202026fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000000000000001e240031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f");
3868 fn encoding_splice_locked() {
3869 let splice = msgs::SpliceLocked {
3870 channel_id: ChannelId::from_bytes([2; 32]),
3872 let encoded_value = splice.encode();
3873 assert_eq!(encoded_value.as_hex().to_string(), "0202020202020202020202020202020202020202020202020202020202020202");
3877 fn encoding_tx_add_input() {
3878 let tx_add_input = msgs::TxAddInput {
3879 channel_id: ChannelId::from_bytes([2; 32]),
3880 serial_id: 4886718345,
3881 prevtx: TransactionU16LenLimited::new(Transaction {
3883 lock_time: LockTime::ZERO,
3885 previous_output: OutPoint { txid: Txid::from_str("305bab643ee297b8b6b76b320792c8223d55082122cb606bf89382146ced9c77").unwrap(), index: 2 }.into_bitcoin_outpoint(),
3886 script_sig: ScriptBuf::new(),
3887 sequence: Sequence(0xfffffffd),
3888 witness: Witness::from_slice(&vec![
3889 <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3890 <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3895 script_pubkey: Address::from_str("bc1qzlffunw52jav8vwdu5x3jfk6sr8u22rmq3xzw2").unwrap().payload.script_pubkey(),
3899 script_pubkey: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().payload.script_pubkey(),
3903 prevtx_out: 305419896,
3904 sequence: 305419896,
3906 let encoded_value = tx_add_input.encode();
3907 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000000012345678900de02000000000101779ced6c148293f86b60cb222108553d22c89207326bb7b6b897e23e64ab5b300200000000fdffffff0236dbc1000000000016001417d29e4dd454bac3b1cde50d1926da80cfc5287b9cbd03000000000016001436ec78d514df462da95e6a00c24daa8915362d420247304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701210301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944000000001234567812345678").unwrap();
3908 assert_eq!(encoded_value, target_value);
3912 fn encoding_tx_add_output() {
3913 let tx_add_output = msgs::TxAddOutput {
3914 channel_id: ChannelId::from_bytes([2; 32]),
3915 serial_id: 4886718345,
3917 script: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().payload.script_pubkey(),
3919 let encoded_value = tx_add_output.encode();
3920 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000000012345678900000001234567890016001436ec78d514df462da95e6a00c24daa8915362d42").unwrap();
3921 assert_eq!(encoded_value, target_value);
3925 fn encoding_tx_remove_input() {
3926 let tx_remove_input = msgs::TxRemoveInput {
3927 channel_id: ChannelId::from_bytes([2; 32]),
3928 serial_id: 4886718345,
3930 let encoded_value = tx_remove_input.encode();
3931 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3932 assert_eq!(encoded_value, target_value);
3936 fn encoding_tx_remove_output() {
3937 let tx_remove_output = msgs::TxRemoveOutput {
3938 channel_id: ChannelId::from_bytes([2; 32]),
3939 serial_id: 4886718345,
3941 let encoded_value = tx_remove_output.encode();
3942 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3943 assert_eq!(encoded_value, target_value);
3947 fn encoding_tx_complete() {
3948 let tx_complete = msgs::TxComplete {
3949 channel_id: ChannelId::from_bytes([2; 32]),
3951 let encoded_value = tx_complete.encode();
3952 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3953 assert_eq!(encoded_value, target_value);
3957 fn encoding_tx_signatures() {
3958 let tx_signatures = msgs::TxSignatures {
3959 channel_id: ChannelId::from_bytes([2; 32]),
3960 tx_hash: Txid::from_str("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3962 Witness::from_slice(&vec![
3963 <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3964 <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3965 Witness::from_slice(&vec![
3966 <Vec<u8>>::from_hex("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap(),
3967 <Vec<u8>>::from_hex("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap()]),
3970 let encoded_value = tx_signatures.encode();
3971 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3972 target_value.append(&mut <Vec<u8>>::from_hex("6e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c2").unwrap()); // tx_hash (sha256) (big endian byte order)
3973 target_value.append(&mut <Vec<u8>>::from_hex("0002").unwrap()); // num_witnesses (u16)
3975 target_value.append(&mut <Vec<u8>>::from_hex("006b").unwrap()); // len of witness_data
3976 target_value.append(&mut <Vec<u8>>::from_hex("02").unwrap()); // num_witness_elements (VarInt)
3977 target_value.append(&mut <Vec<u8>>::from_hex("47").unwrap()); // len of witness element data (VarInt)
3978 target_value.append(&mut <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap());
3979 target_value.append(&mut <Vec<u8>>::from_hex("21").unwrap()); // len of witness element data (VarInt)
3980 target_value.append(&mut <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap());
3982 target_value.append(&mut <Vec<u8>>::from_hex("006c").unwrap()); // len of witness_data
3983 target_value.append(&mut <Vec<u8>>::from_hex("02").unwrap()); // num_witness_elements (VarInt)
3984 target_value.append(&mut <Vec<u8>>::from_hex("48").unwrap()); // len of witness element data (VarInt)
3985 target_value.append(&mut <Vec<u8>>::from_hex("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap());
3986 target_value.append(&mut <Vec<u8>>::from_hex("21").unwrap()); // len of witness element data (VarInt)
3987 target_value.append(&mut <Vec<u8>>::from_hex("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap());
3988 assert_eq!(encoded_value, target_value);
3991 fn do_encoding_tx_init_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3992 let tx_init_rbf = msgs::TxInitRbf {
3993 channel_id: ChannelId::from_bytes([2; 32]),
3994 locktime: 305419896,
3995 feerate_sat_per_1000_weight: 20190119,
3996 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3998 let encoded_value = tx_init_rbf.encode();
3999 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
4000 target_value.append(&mut <Vec<u8>>::from_hex("12345678").unwrap()); // locktime
4001 target_value.append(&mut <Vec<u8>>::from_hex("013413a7").unwrap()); // feerate_sat_per_1000_weight
4002 if let Some((_, target)) = funding_value_with_hex_target {
4003 target_value.push(0x00); // Type
4004 target_value.push(target.len() as u8 / 2); // Length
4005 target_value.append(&mut <Vec<u8>>::from_hex(target).unwrap()); // Value (i64)
4007 assert_eq!(encoded_value, target_value);
4011 fn encoding_tx_init_rbf() {
4012 do_encoding_tx_init_rbf(Some((1311768467284833366, "1234567890123456")));
4013 do_encoding_tx_init_rbf(Some((13117684672, "000000030DDFFBC0")));
4014 do_encoding_tx_init_rbf(None);
4017 fn do_encoding_tx_ack_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
4018 let tx_ack_rbf = msgs::TxAckRbf {
4019 channel_id: ChannelId::from_bytes([2; 32]),
4020 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
4022 let encoded_value = tx_ack_rbf.encode();
4023 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
4024 if let Some((_, target)) = funding_value_with_hex_target {
4025 target_value.push(0x00); // Type
4026 target_value.push(target.len() as u8 / 2); // Length
4027 target_value.append(&mut <Vec<u8>>::from_hex(target).unwrap()); // Value (i64)
4029 assert_eq!(encoded_value, target_value);
4033 fn encoding_tx_ack_rbf() {
4034 do_encoding_tx_ack_rbf(Some((1311768467284833366, "1234567890123456")));
4035 do_encoding_tx_ack_rbf(Some((13117684672, "000000030DDFFBC0")));
4036 do_encoding_tx_ack_rbf(None);
4040 fn encoding_tx_abort() {
4041 let tx_abort = msgs::TxAbort {
4042 channel_id: ChannelId::from_bytes([2; 32]),
4043 data: <Vec<u8>>::from_hex("54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap(),
4045 let encoded_value = tx_abort.encode();
4046 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202002C54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap();
4047 assert_eq!(encoded_value, target_value);
4050 fn do_encoding_shutdown(script_type: u8) {
4051 let secp_ctx = Secp256k1::new();
4052 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4053 let script = Builder::new().push_opcode(opcodes::OP_TRUE).into_script();
4054 let shutdown = msgs::Shutdown {
4055 channel_id: ChannelId::from_bytes([2; 32]),
4057 if script_type == 1 { Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey() }
4058 else if script_type == 2 { Address::p2sh(&script, Network::Testnet).unwrap().script_pubkey() }
4059 else if script_type == 3 { Address::p2wpkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).unwrap().script_pubkey() }
4060 else { Address::p2wsh(&script, Network::Testnet).script_pubkey() },
4062 let encoded_value = shutdown.encode();
4063 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
4064 if script_type == 1 {
4065 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
4066 } else if script_type == 2 {
4067 target_value.append(&mut <Vec<u8>>::from_hex("0017a914da1745e9b549bd0bfa1a569971c77eba30cd5a4b87").unwrap());
4068 } else if script_type == 3 {
4069 target_value.append(&mut <Vec<u8>>::from_hex("0016001479b000887626b294a914501a4cd226b58b235983").unwrap());
4070 } else if script_type == 4 {
4071 target_value.append(&mut <Vec<u8>>::from_hex("002200204ae81572f06e1b88fd5ced7a1a000945432e83e1551e6f721ee9c00b8cc33260").unwrap());
4073 assert_eq!(encoded_value, target_value);
4077 fn encoding_shutdown() {
4078 do_encoding_shutdown(1);
4079 do_encoding_shutdown(2);
4080 do_encoding_shutdown(3);
4081 do_encoding_shutdown(4);
4085 fn encoding_closing_signed() {
4086 let secp_ctx = Secp256k1::new();
4087 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4088 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
4089 let closing_signed = msgs::ClosingSigned {
4090 channel_id: ChannelId::from_bytes([2; 32]),
4091 fee_satoshis: 2316138423780173,
4095 let encoded_value = closing_signed.encode();
4096 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
4097 assert_eq!(encoded_value, target_value);
4098 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value)).unwrap(), closing_signed);
4100 let closing_signed_with_range = msgs::ClosingSigned {
4101 channel_id: ChannelId::from_bytes([2; 32]),
4102 fee_satoshis: 2316138423780173,
4104 fee_range: Some(msgs::ClosingSignedFeeRange {
4105 min_fee_satoshis: 0xdeadbeef,
4106 max_fee_satoshis: 0x1badcafe01234567,
4109 let encoded_value_with_range = closing_signed_with_range.encode();
4110 let target_value_with_range = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a011000000000deadbeef1badcafe01234567").unwrap();
4111 assert_eq!(encoded_value_with_range, target_value_with_range);
4112 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value_with_range)).unwrap(),
4113 closing_signed_with_range);
4117 fn encoding_update_add_htlc() {
4118 let secp_ctx = Secp256k1::new();
4119 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4120 let onion_routing_packet = msgs::OnionPacket {
4122 public_key: Ok(pubkey_1),
4123 hop_data: [1; 20*65],
4126 let update_add_htlc = msgs::UpdateAddHTLC {
4127 channel_id: ChannelId::from_bytes([2; 32]),
4128 htlc_id: 2316138423780173,
4129 amount_msat: 3608586615801332854,
4130 payment_hash: PaymentHash([1; 32]),
4131 cltv_expiry: 821716,
4132 onion_routing_packet,
4133 skimmed_fee_msat: None,
4134 blinding_point: None,
4136 let encoded_value = update_add_htlc.encode();
4137 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d32144668701144760101010101010101010101010101010101010101010101010101010101010101000c89d4ff031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010202020202020202020202020202020202020202020202020202020202020202").unwrap();
4138 assert_eq!(encoded_value, target_value);
4142 fn encoding_update_fulfill_htlc() {
4143 let update_fulfill_htlc = msgs::UpdateFulfillHTLC {
4144 channel_id: ChannelId::from_bytes([2; 32]),
4145 htlc_id: 2316138423780173,
4146 payment_preimage: PaymentPreimage([1; 32]),
4148 let encoded_value = update_fulfill_htlc.encode();
4149 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d0101010101010101010101010101010101010101010101010101010101010101").unwrap();
4150 assert_eq!(encoded_value, target_value);
4154 fn encoding_update_fail_htlc() {
4155 let reason = OnionErrorPacket {
4156 data: [1; 32].to_vec(),
4158 let update_fail_htlc = msgs::UpdateFailHTLC {
4159 channel_id: ChannelId::from_bytes([2; 32]),
4160 htlc_id: 2316138423780173,
4163 let encoded_value = update_fail_htlc.encode();
4164 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d00200101010101010101010101010101010101010101010101010101010101010101").unwrap();
4165 assert_eq!(encoded_value, target_value);
4169 fn encoding_update_fail_malformed_htlc() {
4170 let update_fail_malformed_htlc = msgs::UpdateFailMalformedHTLC {
4171 channel_id: ChannelId::from_bytes([2; 32]),
4172 htlc_id: 2316138423780173,
4173 sha256_of_onion: [1; 32],
4176 let encoded_value = update_fail_malformed_htlc.encode();
4177 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d010101010101010101010101010101010101010101010101010101010101010100ff").unwrap();
4178 assert_eq!(encoded_value, target_value);
4181 fn do_encoding_commitment_signed(htlcs: bool) {
4182 let secp_ctx = Secp256k1::new();
4183 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4184 let (privkey_2, _) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
4185 let (privkey_3, _) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
4186 let (privkey_4, _) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
4187 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
4188 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
4189 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
4190 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
4191 let commitment_signed = msgs::CommitmentSigned {
4192 channel_id: ChannelId::from_bytes([2; 32]),
4194 htlc_signatures: if htlcs { vec![sig_2, sig_3, sig_4] } else { Vec::new() },
4196 partial_signature_with_nonce: None,
4198 let encoded_value = commitment_signed.encode();
4199 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
4201 target_value.append(&mut <Vec<u8>>::from_hex("00031735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
4203 target_value.append(&mut <Vec<u8>>::from_hex("0000").unwrap());
4205 assert_eq!(encoded_value, target_value);
4209 fn encoding_commitment_signed() {
4210 do_encoding_commitment_signed(true);
4211 do_encoding_commitment_signed(false);
4215 fn encoding_revoke_and_ack() {
4216 let secp_ctx = Secp256k1::new();
4217 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4218 let raa = msgs::RevokeAndACK {
4219 channel_id: ChannelId::from_bytes([2; 32]),
4220 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],
4221 next_per_commitment_point: pubkey_1,
4223 next_local_nonce: None,
4225 let encoded_value = raa.encode();
4226 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020101010101010101010101010101010101010101010101010101010101010101031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
4227 assert_eq!(encoded_value, target_value);
4231 fn encoding_update_fee() {
4232 let update_fee = msgs::UpdateFee {
4233 channel_id: ChannelId::from_bytes([2; 32]),
4234 feerate_per_kw: 20190119,
4236 let encoded_value = update_fee.encode();
4237 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202013413a7").unwrap();
4238 assert_eq!(encoded_value, target_value);
4242 fn encoding_init() {
4243 let mainnet_hash = ChainHash::using_genesis_block(Network::Bitcoin);
4244 assert_eq!(msgs::Init {
4245 features: InitFeatures::from_le_bytes(vec![0xFF, 0xFF, 0xFF]),
4246 networks: Some(vec![mainnet_hash]),
4247 remote_network_address: None,
4248 }.encode(), <Vec<u8>>::from_hex("00023fff0003ffffff01206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
4249 assert_eq!(msgs::Init {
4250 features: InitFeatures::from_le_bytes(vec![0xFF]),
4252 remote_network_address: None,
4253 }.encode(), <Vec<u8>>::from_hex("0001ff0001ff").unwrap());
4254 assert_eq!(msgs::Init {
4255 features: InitFeatures::from_le_bytes(vec![]),
4256 networks: Some(vec![mainnet_hash]),
4257 remote_network_address: None,
4258 }.encode(), <Vec<u8>>::from_hex("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
4259 assert_eq!(msgs::Init {
4260 features: InitFeatures::from_le_bytes(vec![]),
4261 networks: Some(vec![ChainHash::from(&[1; 32]), ChainHash::from(&[2; 32])]),
4262 remote_network_address: None,
4263 }.encode(), <Vec<u8>>::from_hex("00000000014001010101010101010101010101010101010101010101010101010101010101010202020202020202020202020202020202020202020202020202020202020202").unwrap());
4264 let init_msg = msgs::Init { features: InitFeatures::from_le_bytes(vec![]),
4265 networks: Some(vec![mainnet_hash]),
4266 remote_network_address: Some(SocketAddress::TcpIpV4 {
4267 addr: [127, 0, 0, 1],
4271 let encoded_value = init_msg.encode();
4272 let target_value = <Vec<u8>>::from_hex("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d61900000000000307017f00000103e8").unwrap();
4273 assert_eq!(encoded_value, target_value);
4274 assert_eq!(msgs::Init::read(&mut Cursor::new(&target_value)).unwrap(), init_msg);
4278 fn encoding_error() {
4279 let error = msgs::ErrorMessage {
4280 channel_id: ChannelId::from_bytes([2; 32]),
4281 data: String::from("rust-lightning"),
4283 let encoded_value = error.encode();
4284 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
4285 assert_eq!(encoded_value, target_value);
4289 fn encoding_warning() {
4290 let error = msgs::WarningMessage {
4291 channel_id: ChannelId::from_bytes([2; 32]),
4292 data: String::from("rust-lightning"),
4294 let encoded_value = error.encode();
4295 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
4296 assert_eq!(encoded_value, target_value);
4300 fn encoding_ping() {
4301 let ping = msgs::Ping {
4305 let encoded_value = ping.encode();
4306 let target_value = <Vec<u8>>::from_hex("0040004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
4307 assert_eq!(encoded_value, target_value);
4311 fn encoding_pong() {
4312 let pong = msgs::Pong {
4315 let encoded_value = pong.encode();
4316 let target_value = <Vec<u8>>::from_hex("004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
4317 assert_eq!(encoded_value, target_value);
4321 fn encoding_nonfinal_onion_hop_data() {
4322 let outbound_msg = msgs::OutboundOnionPayload::Forward {
4323 short_channel_id: 0xdeadbeef1bad1dea,
4324 amt_to_forward: 0x0badf00d01020304,
4325 outgoing_cltv_value: 0xffffffff,
4327 let encoded_value = outbound_msg.encode();
4328 let target_value = <Vec<u8>>::from_hex("1a02080badf00d010203040404ffffffff0608deadbeef1bad1dea").unwrap();
4329 assert_eq!(encoded_value, target_value);
4331 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4332 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4333 if let msgs::InboundOnionPayload::Forward {
4334 short_channel_id, amt_to_forward, outgoing_cltv_value
4336 assert_eq!(short_channel_id, 0xdeadbeef1bad1dea);
4337 assert_eq!(amt_to_forward, 0x0badf00d01020304);
4338 assert_eq!(outgoing_cltv_value, 0xffffffff);
4339 } else { panic!(); }
4343 fn encoding_final_onion_hop_data() {
4344 let outbound_msg = msgs::OutboundOnionPayload::Receive {
4346 payment_metadata: None,
4347 keysend_preimage: None,
4348 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4349 cltv_expiry_height: 0xffffffff,
4350 custom_tlvs: vec![],
4352 let encoded_value = outbound_msg.encode();
4353 let target_value = <Vec<u8>>::from_hex("1002080badf00d010203040404ffffffff").unwrap();
4354 assert_eq!(encoded_value, target_value);
4356 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4357 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4358 if let msgs::InboundOnionPayload::Receive {
4359 payment_data: None, sender_intended_htlc_amt_msat, cltv_expiry_height, ..
4361 assert_eq!(sender_intended_htlc_amt_msat, 0x0badf00d01020304);
4362 assert_eq!(cltv_expiry_height, 0xffffffff);
4363 } else { panic!(); }
4367 fn encoding_final_onion_hop_data_with_secret() {
4368 let expected_payment_secret = PaymentSecret([0x42u8; 32]);
4369 let outbound_msg = msgs::OutboundOnionPayload::Receive {
4370 payment_data: Some(FinalOnionHopData {
4371 payment_secret: expected_payment_secret,
4372 total_msat: 0x1badca1f
4374 payment_metadata: None,
4375 keysend_preimage: None,
4376 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4377 cltv_expiry_height: 0xffffffff,
4378 custom_tlvs: vec![],
4380 let encoded_value = outbound_msg.encode();
4381 let target_value = <Vec<u8>>::from_hex("3602080badf00d010203040404ffffffff082442424242424242424242424242424242424242424242424242424242424242421badca1f").unwrap();
4382 assert_eq!(encoded_value, target_value);
4384 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4385 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4386 if let msgs::InboundOnionPayload::Receive {
4387 payment_data: Some(FinalOnionHopData {
4389 total_msat: 0x1badca1f
4391 sender_intended_htlc_amt_msat, cltv_expiry_height,
4392 payment_metadata: None,
4393 keysend_preimage: None,
4396 assert_eq!(payment_secret, expected_payment_secret);
4397 assert_eq!(sender_intended_htlc_amt_msat, 0x0badf00d01020304);
4398 assert_eq!(cltv_expiry_height, 0xffffffff);
4399 assert_eq!(custom_tlvs, vec![]);
4400 } else { panic!(); }
4404 fn encoding_final_onion_hop_data_with_bad_custom_tlvs() {
4405 // If custom TLVs have type number within the range reserved for protocol, treat them as if
4407 let bad_type_range_tlvs = vec![
4408 ((1 << 16) - 4, vec![42]),
4409 ((1 << 16) - 2, vec![42; 32]),
4411 let mut msg = msgs::OutboundOnionPayload::Receive {
4413 payment_metadata: None,
4414 keysend_preimage: None,
4415 custom_tlvs: bad_type_range_tlvs,
4416 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4417 cltv_expiry_height: 0xffffffff,
4419 let encoded_value = msg.encode();
4420 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4421 assert!(msgs::InboundOnionPayload::read(&mut Cursor::new(&encoded_value[..]), (None, &&node_signer)).is_err());
4422 let good_type_range_tlvs = vec![
4423 ((1 << 16) - 3, vec![42]),
4424 ((1 << 16) - 1, vec![42; 32]),
4426 if let msgs::OutboundOnionPayload::Receive { ref mut custom_tlvs, .. } = msg {
4427 *custom_tlvs = good_type_range_tlvs.clone();
4429 let encoded_value = msg.encode();
4430 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&encoded_value[..]), (None, &&node_signer)).unwrap();
4432 msgs::InboundOnionPayload::Receive { custom_tlvs, .. } => assert!(custom_tlvs.is_empty()),
4438 fn encoding_final_onion_hop_data_with_custom_tlvs() {
4439 let expected_custom_tlvs = vec![
4440 (5482373483, vec![0x12, 0x34]),
4441 (5482373487, vec![0x42u8; 8]),
4443 let msg = msgs::OutboundOnionPayload::Receive {
4445 payment_metadata: None,
4446 keysend_preimage: None,
4447 custom_tlvs: expected_custom_tlvs.clone(),
4448 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4449 cltv_expiry_height: 0xffffffff,
4451 let encoded_value = msg.encode();
4452 let target_value = <Vec<u8>>::from_hex("2e02080badf00d010203040404ffffffffff0000000146c6616b021234ff0000000146c6616f084242424242424242").unwrap();
4453 assert_eq!(encoded_value, target_value);
4454 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4455 let inbound_msg: msgs::InboundOnionPayload = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4456 if let msgs::InboundOnionPayload::Receive {
4458 payment_metadata: None,
4459 keysend_preimage: None,
4461 sender_intended_htlc_amt_msat,
4462 cltv_expiry_height: outgoing_cltv_value,
4465 assert_eq!(custom_tlvs, expected_custom_tlvs);
4466 assert_eq!(sender_intended_htlc_amt_msat, 0x0badf00d01020304);
4467 assert_eq!(outgoing_cltv_value, 0xffffffff);
4468 } else { panic!(); }
4472 fn encoding_final_onion_hop_data_with_trampoline_packet() {
4473 let secp_ctx = Secp256k1::new();
4474 let (_private_key, public_key) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4476 let compressed_public_key = public_key.serialize();
4477 assert_eq!(compressed_public_key.len(), 33);
4479 let trampoline_packet = TrampolineOnionPacket {
4482 hop_data: vec![1; 650], // this should be the standard encoded length
4485 let encoded_trampoline_packet = trampoline_packet.encode();
4486 assert_eq!(encoded_trampoline_packet.len(), 716);
4488 let msg = msgs::OutboundOnionPayload::TrampolineEntrypoint {
4489 multipath_trampoline_data: None,
4490 amt_to_forward: 0x0badf00d01020304,
4491 outgoing_cltv_value: 0xffffffff,
4494 let encoded_payload = msg.encode();
4496 let trampoline_type_bytes = &encoded_payload[19..=19];
4497 let mut trampoline_type_cursor = Cursor::new(trampoline_type_bytes);
4498 let trampoline_type_big_size: BigSize = Readable::read(&mut trampoline_type_cursor).unwrap();
4499 assert_eq!(trampoline_type_big_size.0, 20);
4501 let trampoline_length_bytes = &encoded_payload[20..=22];
4502 let mut trampoline_length_cursor = Cursor::new(trampoline_length_bytes);
4503 let trampoline_length_big_size: BigSize = Readable::read(&mut trampoline_length_cursor).unwrap();
4504 assert_eq!(trampoline_length_big_size.0, encoded_trampoline_packet.len() as u64);
4508 fn encoding_final_onion_hop_data_with_eclair_trampoline_packet() {
4509 let public_key = PublicKey::from_slice(&<Vec<u8>>::from_hex("02eec7245d6b7d2ccb30380bfbe2a3648cd7a942653f5aa340edcea1f283686619").unwrap()).unwrap();
4510 let hop_data = <Vec<u8>>::from_hex("cff34152f3a36e52ca94e74927203a560392b9cc7ce3c45809c6be52166c24a595716880f95f178bf5b30ca63141f74db6e92795c6130877cfdac3d4bd3087ee73c65d627ddd709112a848cc99e303f3706509aa43ba7c8a88cba175fccf9a8f5016ef06d3b935dbb15196d7ce16dc1a7157845566901d7b2197e52cab4ce487014b14816e5805f9fcacb4f8f88b8ff176f1b94f6ce6b00bc43221130c17d20ef629db7c5f7eafaa166578c720619561dd14b3277db557ec7dcdb793771aef0f2f667cfdbeae3ac8d331c5994779dffb31e5fc0dbdedc0c592ca6d21c18e47fe3528d6975c19517d7e2ea8c5391cf17d0fe30c80913ed887234ccb48808f7ef9425bcd815c3b586210979e3bb286ef2851bf9ce04e28c40a203df98fd648d2f1936fd2f1def0e77eecb277229b4b682322371c0a1dbfcd723a991993df8cc1f2696b84b055b40a1792a29f710295a18fbd351b0f3ff34cd13941131b8278ba79303c89117120eea691738a9954908195143b039dbeed98f26a92585f3d15cf742c953799d3272e0545e9b744be9d3b4c").unwrap();
4511 let hmac_vector = <Vec<u8>>::from_hex("bb079bfc4b35190eee9f59a1d7b41ba2f773179f322dafb4b1af900c289ebd6c").unwrap();
4512 let mut hmac = [0; 32];
4513 hmac.copy_from_slice(&hmac_vector);
4515 let compressed_public_key = public_key.serialize();
4516 assert_eq!(compressed_public_key.len(), 33);
4518 let trampoline_packet = TrampolineOnionPacket {
4524 let encoded_trampoline_packet = trampoline_packet.encode();
4525 let expected_eclair_trampoline_packet = <Vec<u8>>::from_hex("0002eec7245d6b7d2ccb30380bfbe2a3648cd7a942653f5aa340edcea1f283686619cff34152f3a36e52ca94e74927203a560392b9cc7ce3c45809c6be52166c24a595716880f95f178bf5b30ca63141f74db6e92795c6130877cfdac3d4bd3087ee73c65d627ddd709112a848cc99e303f3706509aa43ba7c8a88cba175fccf9a8f5016ef06d3b935dbb15196d7ce16dc1a7157845566901d7b2197e52cab4ce487014b14816e5805f9fcacb4f8f88b8ff176f1b94f6ce6b00bc43221130c17d20ef629db7c5f7eafaa166578c720619561dd14b3277db557ec7dcdb793771aef0f2f667cfdbeae3ac8d331c5994779dffb31e5fc0dbdedc0c592ca6d21c18e47fe3528d6975c19517d7e2ea8c5391cf17d0fe30c80913ed887234ccb48808f7ef9425bcd815c3b586210979e3bb286ef2851bf9ce04e28c40a203df98fd648d2f1936fd2f1def0e77eecb277229b4b682322371c0a1dbfcd723a991993df8cc1f2696b84b055b40a1792a29f710295a18fbd351b0f3ff34cd13941131b8278ba79303c89117120eea691738a9954908195143b039dbeed98f26a92585f3d15cf742c953799d3272e0545e9b744be9d3b4cbb079bfc4b35190eee9f59a1d7b41ba2f773179f322dafb4b1af900c289ebd6c").unwrap();
4526 assert_eq!(encoded_trampoline_packet, expected_eclair_trampoline_packet);
4530 fn query_channel_range_end_blocknum() {
4531 let tests: Vec<(u32, u32, u32)> = vec![
4532 (10000, 1500, 11500),
4533 (0, 0xffffffff, 0xffffffff),
4534 (1, 0xffffffff, 0xffffffff),
4537 for (first_blocknum, number_of_blocks, expected) in tests.into_iter() {
4538 let sut = msgs::QueryChannelRange {
4539 chain_hash: ChainHash::using_genesis_block(Network::Regtest),
4543 assert_eq!(sut.end_blocknum(), expected);
4548 fn encoding_query_channel_range() {
4549 let mut query_channel_range = msgs::QueryChannelRange {
4550 chain_hash: ChainHash::using_genesis_block(Network::Regtest),
4551 first_blocknum: 100000,
4552 number_of_blocks: 1500,
4554 let encoded_value = query_channel_range.encode();
4555 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000186a0000005dc").unwrap();
4556 assert_eq!(encoded_value, target_value);
4558 query_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4559 assert_eq!(query_channel_range.first_blocknum, 100000);
4560 assert_eq!(query_channel_range.number_of_blocks, 1500);
4564 fn encoding_reply_channel_range() {
4565 do_encoding_reply_channel_range(0);
4566 do_encoding_reply_channel_range(1);
4569 fn do_encoding_reply_channel_range(encoding_type: u8) {
4570 let mut target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000b8a06000005dc01").unwrap();
4571 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4572 let mut reply_channel_range = msgs::ReplyChannelRange {
4573 chain_hash: expected_chain_hash,
4574 first_blocknum: 756230,
4575 number_of_blocks: 1500,
4576 sync_complete: true,
4577 short_channel_ids: vec![0x000000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
4580 if encoding_type == 0 {
4581 target_value.append(&mut <Vec<u8>>::from_hex("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
4582 let encoded_value = reply_channel_range.encode();
4583 assert_eq!(encoded_value, target_value);
4585 reply_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4586 assert_eq!(reply_channel_range.chain_hash, expected_chain_hash);
4587 assert_eq!(reply_channel_range.first_blocknum, 756230);
4588 assert_eq!(reply_channel_range.number_of_blocks, 1500);
4589 assert_eq!(reply_channel_range.sync_complete, true);
4590 assert_eq!(reply_channel_range.short_channel_ids[0], 0x000000000000008e);
4591 assert_eq!(reply_channel_range.short_channel_ids[1], 0x0000000000003c69);
4592 assert_eq!(reply_channel_range.short_channel_ids[2], 0x000000000045a6c4);
4594 target_value.append(&mut <Vec<u8>>::from_hex("001601789c636000833e08659309a65878be010010a9023a").unwrap());
4595 let result: Result<msgs::ReplyChannelRange, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
4596 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
4601 fn encoding_query_short_channel_ids() {
4602 do_encoding_query_short_channel_ids(0);
4603 do_encoding_query_short_channel_ids(1);
4606 fn do_encoding_query_short_channel_ids(encoding_type: u8) {
4607 let mut target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
4608 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4609 let mut query_short_channel_ids = msgs::QueryShortChannelIds {
4610 chain_hash: expected_chain_hash,
4611 short_channel_ids: vec![0x0000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
4614 if encoding_type == 0 {
4615 target_value.append(&mut <Vec<u8>>::from_hex("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
4616 let encoded_value = query_short_channel_ids.encode();
4617 assert_eq!(encoded_value, target_value);
4619 query_short_channel_ids = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4620 assert_eq!(query_short_channel_ids.chain_hash, expected_chain_hash);
4621 assert_eq!(query_short_channel_ids.short_channel_ids[0], 0x000000000000008e);
4622 assert_eq!(query_short_channel_ids.short_channel_ids[1], 0x0000000000003c69);
4623 assert_eq!(query_short_channel_ids.short_channel_ids[2], 0x000000000045a6c4);
4625 target_value.append(&mut <Vec<u8>>::from_hex("001601789c636000833e08659309a65878be010010a9023a").unwrap());
4626 let result: Result<msgs::QueryShortChannelIds, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
4627 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
4632 fn encoding_reply_short_channel_ids_end() {
4633 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4634 let mut reply_short_channel_ids_end = msgs::ReplyShortChannelIdsEnd {
4635 chain_hash: expected_chain_hash,
4636 full_information: true,
4638 let encoded_value = reply_short_channel_ids_end.encode();
4639 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f01").unwrap();
4640 assert_eq!(encoded_value, target_value);
4642 reply_short_channel_ids_end = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4643 assert_eq!(reply_short_channel_ids_end.chain_hash, expected_chain_hash);
4644 assert_eq!(reply_short_channel_ids_end.full_information, true);
4648 fn encoding_gossip_timestamp_filter(){
4649 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4650 let mut gossip_timestamp_filter = msgs::GossipTimestampFilter {
4651 chain_hash: expected_chain_hash,
4652 first_timestamp: 1590000000,
4653 timestamp_range: 0xffff_ffff,
4655 let encoded_value = gossip_timestamp_filter.encode();
4656 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f5ec57980ffffffff").unwrap();
4657 assert_eq!(encoded_value, target_value);
4659 gossip_timestamp_filter = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4660 assert_eq!(gossip_timestamp_filter.chain_hash, expected_chain_hash);
4661 assert_eq!(gossip_timestamp_filter.first_timestamp, 1590000000);
4662 assert_eq!(gossip_timestamp_filter.timestamp_range, 0xffff_ffff);
4666 fn decode_onion_hop_data_len_as_bigsize() {
4667 // Tests that we can decode an onion payload that is >253 bytes.
4668 // Previously, receiving a payload of this size could've caused us to fail to decode a valid
4669 // payload, because we were decoding the length (a BigSize, big-endian) as a VarInt
4672 // Encode a test onion payload with a big custom TLV such that it's >253 bytes, forcing the
4673 // payload length to be encoded over multiple bytes rather than a single u8.
4674 let big_payload = encode_big_payload().unwrap();
4675 let mut rd = Cursor::new(&big_payload[..]);
4677 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4678 <msgs::InboundOnionPayload as ReadableArgs<(Option<PublicKey>, &&test_utils::TestKeysInterface)>>
4679 ::read(&mut rd, (None, &&node_signer)).unwrap();
4681 // see above test, needs to be a separate method for use of the serialization macros.
4682 fn encode_big_payload() -> Result<Vec<u8>, io::Error> {
4683 use crate::util::ser::HighZeroBytesDroppedBigSize;
4684 let payload = msgs::OutboundOnionPayload::Forward {
4685 short_channel_id: 0xdeadbeef1bad1dea,
4686 amt_to_forward: 1000,
4687 outgoing_cltv_value: 0xffffffff,
4689 let mut encoded_payload = Vec::new();
4690 let test_bytes = vec![42u8; 1000];
4691 if let msgs::OutboundOnionPayload::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } = payload {
4692 _encode_varint_length_prefixed_tlv!(&mut encoded_payload, {
4693 (1, test_bytes, required_vec),
4694 (2, HighZeroBytesDroppedBigSize(amt_to_forward), required),
4695 (4, HighZeroBytesDroppedBigSize(outgoing_cltv_value), required),
4696 (6, short_channel_id, required)
4703 #[cfg(feature = "std")]
4704 fn test_socket_address_from_str() {
4705 let tcpip_v4 = SocketAddress::TcpIpV4 {
4706 addr: Ipv4Addr::new(127, 0, 0, 1).octets(),
4709 assert_eq!(tcpip_v4, SocketAddress::from_str("127.0.0.1:1234").unwrap());
4710 assert_eq!(tcpip_v4, SocketAddress::from_str(&tcpip_v4.to_string()).unwrap());
4712 let tcpip_v6 = SocketAddress::TcpIpV6 {
4713 addr: Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1).octets(),
4716 assert_eq!(tcpip_v6, SocketAddress::from_str("[0:0:0:0:0:0:0:1]:1234").unwrap());
4717 assert_eq!(tcpip_v6, SocketAddress::from_str(&tcpip_v6.to_string()).unwrap());
4719 let hostname = SocketAddress::Hostname {
4720 hostname: Hostname::try_from("lightning-node.mydomain.com".to_string()).unwrap(),
4723 assert_eq!(hostname, SocketAddress::from_str("lightning-node.mydomain.com:1234").unwrap());
4724 assert_eq!(hostname, SocketAddress::from_str(&hostname.to_string()).unwrap());
4726 let onion_v2 = SocketAddress::OnionV2 ([40, 4, 64, 185, 202, 19, 162, 75, 90, 200, 38, 7],);
4727 assert_eq!("OnionV2([40, 4, 64, 185, 202, 19, 162, 75, 90, 200, 38, 7])", &onion_v2.to_string());
4728 assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("FACEBOOKCOREWWWI.onion:9735"));
4730 let onion_v3 = SocketAddress::OnionV3 {
4731 ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102, 182, 107, 4, 105, 247, 246, 85,
4732 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31, 33, 71, 3],
4737 assert_eq!(onion_v3, SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion:1234").unwrap());
4738 assert_eq!(onion_v3, SocketAddress::from_str(&onion_v3.to_string()).unwrap());
4740 assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6.onion:1234"));
4741 assert_eq!(Err(SocketAddressParseError::InvalidInput), SocketAddress::from_str("127.0.0.1@1234"));
4742 assert_eq!(Err(SocketAddressParseError::InvalidInput), "".parse::<SocketAddress>());
4743 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:9735:94").is_err());
4744 assert!(SocketAddress::from_str("wrong$%#.com:1234").is_err());
4745 assert_eq!(Err(SocketAddressParseError::InvalidPort), SocketAddress::from_str("example.com:wrong"));
4746 assert!("localhost".parse::<SocketAddress>().is_err());
4747 assert!("localhost:invalid-port".parse::<SocketAddress>().is_err());
4748 assert!( "invalid-onion-v3-hostname.onion:8080".parse::<SocketAddress>().is_err());
4749 assert!("b32.example.onion:invalid-port".parse::<SocketAddress>().is_err());
4750 assert!("invalid-address".parse::<SocketAddress>().is_err());
4751 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:1234").is_err());
4755 #[cfg(feature = "std")]
4756 fn test_socket_address_to_socket_addrs() {
4757 assert_eq!(SocketAddress::TcpIpV4 {addr:[0u8; 4], port: 1337,}.to_socket_addrs().unwrap().next().unwrap(),
4758 SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(0,0,0,0), 1337)));
4759 assert_eq!(SocketAddress::TcpIpV6 {addr:[0u8; 16], port: 1337,}.to_socket_addrs().unwrap().next().unwrap(),
4760 SocketAddr::V6(SocketAddrV6::new(Ipv6Addr::from([0u8; 16]), 1337, 0, 0)));
4761 assert_eq!(SocketAddress::Hostname { hostname: Hostname::try_from("0.0.0.0".to_string()).unwrap(), port: 0 }
4762 .to_socket_addrs().unwrap().next().unwrap(), SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::from([0u8; 4]),0)));
4763 assert!(SocketAddress::OnionV2([0u8; 12]).to_socket_addrs().is_err());
4764 assert!(SocketAddress::OnionV3{ ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102,
4765 182, 107, 4, 105, 247, 246, 85, 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31,
4769 port: 1234 }.to_socket_addrs().is_err());