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::types::{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::*;
47 #[cfg(feature = "std")]
48 use core::str::FromStr;
49 #[cfg(feature = "std")]
50 use std::net::SocketAddr;
51 use core::fmt::Display;
52 use crate::io::{self, Cursor, Read};
53 use crate::io_extras::read_to_end;
55 use crate::events::MessageSendEventsProvider;
56 use crate::crypto::streams::ChaChaPolyReadAdapter;
57 use crate::util::logger;
58 use crate::util::ser::{BigSize, FixedLengthReader, HighZeroBytesDroppedBigSize, Hostname, LengthRead, LengthReadable, LengthReadableArgs, Readable, ReadableArgs, TransactionU16LenLimited, WithoutLength, Writeable, Writer};
59 use crate::util::base32;
61 use crate::routing::gossip::{NodeAlias, NodeId};
63 /// 21 million * 10^8 * 1000
64 pub(crate) const MAX_VALUE_MSAT: u64 = 21_000_000_0000_0000_000;
67 /// A partial signature that also contains the Musig2 nonce its signer used
68 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
69 pub struct PartialSignatureWithNonce(pub musig2::types::PartialSignature, pub musig2::types::PublicNonce);
71 /// An error in decoding a message or struct.
72 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
73 pub enum DecodeError {
74 /// A version byte specified something we don't know how to handle.
76 /// Includes unknown realm byte in an onion hop data packet.
78 /// Unknown feature mandating we fail to parse message (e.g., TLV with an even, unknown type)
79 UnknownRequiredFeature,
80 /// Value was invalid.
82 /// For example, a byte which was supposed to be a bool was something other than a 0
83 /// or 1, a public key/private key/signature was invalid, text wasn't UTF-8, TLV was
84 /// syntactically incorrect, etc.
86 /// The buffer to be read was too short.
88 /// A length descriptor in the packet didn't describe the later data correctly.
90 /// Error from [`std::io`].
92 /// The message included zlib-compressed values, which we don't support.
93 UnsupportedCompression,
94 /// Value is validly encoded but is dangerous to use.
96 /// This is used for things like [`ChannelManager`] deserialization where we want to ensure
97 /// that we don't use a [`ChannelManager`] which is in out of sync with the [`ChannelMonitor`].
98 /// This indicates that there is a critical implementation flaw in the storage implementation
99 /// and it's unsafe to continue.
101 /// [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
102 /// [`ChannelMonitor`]: crate::chain::channelmonitor::ChannelMonitor
106 /// An [`init`] message to be sent to or received from a peer.
108 /// [`init`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-init-message
109 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
111 /// The relevant features which the sender supports.
112 pub features: InitFeatures,
113 /// Indicates chains the sender is interested in.
115 /// If there are no common chains, the connection will be closed.
116 pub networks: Option<Vec<ChainHash>>,
117 /// The receipient's network address.
119 /// This adds the option to report a remote IP address back to a connecting peer using the init
120 /// message. A node can decide to use that information to discover a potential update to its
121 /// public IPv4 address (NAT) and use that for a [`NodeAnnouncement`] update message containing
123 pub remote_network_address: Option<SocketAddress>,
126 /// An [`error`] message to be sent to or received from a peer.
128 /// [`error`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-error-and-warning-messages
129 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
130 pub struct ErrorMessage {
131 /// The channel ID involved in the error.
133 /// All-0s indicates a general error unrelated to a specific channel, after which all channels
134 /// with the sending peer should be closed.
135 pub channel_id: ChannelId,
136 /// A possibly human-readable error description.
138 /// The string should be sanitized before it is used (e.g., emitted to logs or printed to
139 /// `stdout`). Otherwise, a well crafted error message may trigger a security vulnerability in
140 /// the terminal emulator or the logging subsystem.
144 /// A [`warning`] message to be sent to or received from a peer.
146 /// [`warning`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-error-and-warning-messages
147 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
148 pub struct WarningMessage {
149 /// The channel ID involved in the warning.
151 /// All-0s indicates a warning unrelated to a specific channel.
152 pub channel_id: ChannelId,
153 /// A possibly human-readable warning description.
155 /// The string should be sanitized before it is used (e.g. emitted to logs or printed to
156 /// stdout). Otherwise, a well crafted error message may trigger a security vulnerability in
157 /// the terminal emulator or the logging subsystem.
161 /// A [`ping`] message to be sent to or received from a peer.
163 /// [`ping`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-ping-and-pong-messages
164 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
166 /// The desired response length.
168 /// The ping packet size.
170 /// This field is not sent on the wire. byteslen zeros are sent.
174 /// A [`pong`] message to be sent to or received from a peer.
176 /// [`pong`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-ping-and-pong-messages
177 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
179 /// The pong packet size.
181 /// This field is not sent on the wire. byteslen zeros are sent.
185 /// Contains fields that are both common to [`open_channel`] and `open_channel2` messages.
187 /// [`open_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-open_channel-message
188 // TODO(dual_funding): Add spec link for `open_channel2`.
189 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
190 pub struct CommonOpenChannelFields {
191 /// The genesis hash of the blockchain where the channel is to be opened
192 pub chain_hash: ChainHash,
193 /// A temporary channel ID
194 /// For V2 channels: derived using a zeroed out value for the channel acceptor's revocation basepoint
195 /// For V1 channels: a temporary channel ID, until the funding outpoint is announced
196 pub temporary_channel_id: ChannelId,
197 /// For V1 channels: The channel value
198 /// For V2 channels: Part of the channel value contributed by the channel initiator
199 pub funding_satoshis: u64,
200 /// The threshold below which outputs on transactions broadcast by the channel initiator will be
202 pub dust_limit_satoshis: u64,
203 /// The maximum inbound HTLC value in flight towards channel initiator, in milli-satoshi
204 pub max_htlc_value_in_flight_msat: u64,
205 /// The minimum HTLC size incoming to channel initiator, in milli-satoshi
206 pub htlc_minimum_msat: u64,
207 /// The feerate for the commitment transaction set by the channel initiator until updated by
209 pub commitment_feerate_sat_per_1000_weight: u32,
210 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
211 /// broadcast a commitment transaction
212 pub to_self_delay: u16,
213 /// The maximum number of inbound HTLCs towards channel initiator
214 pub max_accepted_htlcs: u16,
215 /// The channel initiator's key controlling the funding transaction
216 pub funding_pubkey: PublicKey,
217 /// Used to derive a revocation key for transactions broadcast by counterparty
218 pub revocation_basepoint: PublicKey,
219 /// A payment key to channel initiator for transactions broadcast by counterparty
220 pub payment_basepoint: PublicKey,
221 /// Used to derive a payment key to channel initiator for transactions broadcast by channel
223 pub delayed_payment_basepoint: PublicKey,
224 /// Used to derive an HTLC payment key to channel initiator
225 pub htlc_basepoint: PublicKey,
226 /// The first to-be-broadcast-by-channel-initiator transaction's per commitment point
227 pub first_per_commitment_point: PublicKey,
228 /// The channel flags to be used
229 pub channel_flags: u8,
230 /// Optionally, a request to pre-set the to-channel-initiator output's scriptPubkey for when we
231 /// collaboratively close
232 pub shutdown_scriptpubkey: Option<ScriptBuf>,
233 /// The channel type that this channel will represent
235 /// If this is `None`, we derive the channel type from the intersection of our
236 /// feature bits with our counterparty's feature bits from the [`Init`] message.
237 pub channel_type: Option<ChannelTypeFeatures>,
240 /// An [`open_channel`] message to be sent to or received from a peer.
242 /// Used in V1 channel establishment
244 /// [`open_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-open_channel-message
245 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
246 pub struct OpenChannel {
247 /// Common fields of `open_channel(2)`-like messages
248 pub common_fields: CommonOpenChannelFields,
249 /// The amount to push to the counterparty as part of the open, in milli-satoshi
251 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
252 pub channel_reserve_satoshis: u64,
255 /// An open_channel2 message to be sent by or received from the channel initiator.
257 /// Used in V2 channel establishment
259 // TODO(dual_funding): Add spec link for `open_channel2`.
260 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
261 pub struct OpenChannelV2 {
262 /// Common fields of `open_channel(2)`-like messages
263 pub common_fields: CommonOpenChannelFields,
264 /// The feerate for the funding transaction set by the channel initiator
265 pub funding_feerate_sat_per_1000_weight: u32,
266 /// The locktime for the funding transaction
268 /// The second to-be-broadcast-by-channel-initiator transaction's per commitment point
269 pub second_per_commitment_point: PublicKey,
270 /// Optionally, a requirement that only confirmed inputs can be added
271 pub require_confirmed_inputs: Option<()>,
274 /// Contains fields that are both common to [`accept_channel`] and `accept_channel2` messages.
276 /// [`accept_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-accept_channel-message
277 // TODO(dual_funding): Add spec link for `accept_channel2`.
278 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
279 pub struct CommonAcceptChannelFields {
280 /// The same `temporary_channel_id` received from the initiator's `open_channel2` or `open_channel` message.
281 pub temporary_channel_id: ChannelId,
282 /// The threshold below which outputs on transactions broadcast by the channel acceptor will be
284 pub dust_limit_satoshis: u64,
285 /// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
286 pub max_htlc_value_in_flight_msat: u64,
287 /// The minimum HTLC size incoming to channel acceptor, in milli-satoshi
288 pub htlc_minimum_msat: u64,
289 /// Minimum depth of the funding transaction before the channel is considered open
290 pub minimum_depth: u32,
291 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
292 /// broadcast a commitment transaction
293 pub to_self_delay: u16,
294 /// The maximum number of inbound HTLCs towards channel acceptor
295 pub max_accepted_htlcs: u16,
296 /// The channel acceptor's key controlling the funding transaction
297 pub funding_pubkey: PublicKey,
298 /// Used to derive a revocation key for transactions broadcast by counterparty
299 pub revocation_basepoint: PublicKey,
300 /// A payment key to channel acceptor for transactions broadcast by counterparty
301 pub payment_basepoint: PublicKey,
302 /// Used to derive a payment key to channel acceptor for transactions broadcast by channel
304 pub delayed_payment_basepoint: PublicKey,
305 /// Used to derive an HTLC payment key to channel acceptor for transactions broadcast by counterparty
306 pub htlc_basepoint: PublicKey,
307 /// The first to-be-broadcast-by-channel-acceptor transaction's per commitment point
308 pub first_per_commitment_point: PublicKey,
309 /// Optionally, a request to pre-set the to-channel-acceptor output's scriptPubkey for when we
310 /// collaboratively close
311 pub shutdown_scriptpubkey: Option<ScriptBuf>,
312 /// The channel type that this channel will represent. If none is set, we derive the channel
313 /// type from the intersection of our feature bits with our counterparty's feature bits from
314 /// the Init message.
316 /// This is required to match the equivalent field in [`OpenChannel`] or [`OpenChannelV2`]'s
317 /// [`CommonOpenChannelFields::channel_type`].
318 pub channel_type: Option<ChannelTypeFeatures>,
321 /// An [`accept_channel`] message to be sent to or received from a peer.
323 /// Used in V1 channel establishment
325 /// [`accept_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-accept_channel-message
326 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
327 pub struct AcceptChannel {
328 /// Common fields of `accept_channel(2)`-like messages
329 pub common_fields: CommonAcceptChannelFields,
330 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
331 pub channel_reserve_satoshis: u64,
333 /// Next nonce the channel initiator should use to create a funding output signature against
334 pub next_local_nonce: Option<musig2::types::PublicNonce>,
337 /// An accept_channel2 message to be sent by or received from the channel accepter.
339 /// Used in V2 channel establishment
341 // TODO(dual_funding): Add spec link for `accept_channel2`.
342 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
343 pub struct AcceptChannelV2 {
344 /// Common fields of `accept_channel(2)`-like messages
345 pub common_fields: CommonAcceptChannelFields,
346 /// Part of the channel value contributed by the channel acceptor
347 pub funding_satoshis: u64,
348 /// The second to-be-broadcast-by-channel-acceptor transaction's per commitment point
349 pub second_per_commitment_point: PublicKey,
350 /// Optionally, a requirement that only confirmed inputs can be added
351 pub require_confirmed_inputs: Option<()>,
354 /// A [`funding_created`] message to be sent to or received from a peer.
356 /// Used in V1 channel establishment
358 /// [`funding_created`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-funding_created-message
359 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
360 pub struct FundingCreated {
361 /// A temporary channel ID, until the funding is established
362 pub temporary_channel_id: ChannelId,
363 /// The funding transaction ID
364 pub funding_txid: Txid,
365 /// The specific output index funding this channel
366 pub funding_output_index: u16,
367 /// The signature of the channel initiator (funder) on the initial commitment transaction
368 pub signature: Signature,
370 /// The partial signature of the channel initiator (funder)
371 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
373 /// Next nonce the channel acceptor should use to finalize the funding output signature
374 pub next_local_nonce: Option<musig2::types::PublicNonce>
377 /// A [`funding_signed`] message to be sent to or received from a peer.
379 /// Used in V1 channel establishment
381 /// [`funding_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-funding_signed-message
382 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
383 pub struct FundingSigned {
385 pub channel_id: ChannelId,
386 /// The signature of the channel acceptor (fundee) on the initial commitment transaction
387 pub signature: Signature,
389 /// The partial signature of the channel acceptor (fundee)
390 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
393 /// A [`channel_ready`] message to be sent to or received from a peer.
395 /// [`channel_ready`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-channel_ready-message
396 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
397 pub struct ChannelReady {
399 pub channel_id: ChannelId,
400 /// The per-commitment point of the second commitment transaction
401 pub next_per_commitment_point: PublicKey,
402 /// If set, provides a `short_channel_id` alias for this channel.
404 /// The sender will accept payments to be forwarded over this SCID and forward them to this
405 /// messages' recipient.
406 pub short_channel_id_alias: Option<u64>,
409 /// A randomly chosen number that is used to identify inputs within an interactive transaction
411 pub type SerialId = u64;
413 /// An stfu (quiescence) message to be sent by or received from the stfu initiator.
414 // TODO(splicing): Add spec link for `stfu`; still in draft, using from https://github.com/lightning/bolts/pull/863
415 #[derive(Clone, Debug, PartialEq, Eq)]
417 /// The channel ID where quiescence is intended
418 pub channel_id: ChannelId,
419 /// Initiator flag, 1 if initiating, 0 if replying to an stfu.
423 /// A splice message to be sent by or received from the stfu initiator (splice initiator).
424 // TODO(splicing): Add spec link for `splice`; still in draft, using from https://github.com/lightning/bolts/pull/863
425 #[derive(Clone, Debug, PartialEq, Eq)]
427 /// The channel ID where splicing is intended
428 pub channel_id: ChannelId,
429 /// The genesis hash of the blockchain where the channel is intended to be spliced
430 pub chain_hash: ChainHash,
431 /// The intended change in channel capacity: the amount to be added (positive value)
432 /// or removed (negative value) by the sender (splice initiator) by splicing into/from the channel.
433 pub relative_satoshis: i64,
434 /// The feerate for the new funding transaction, set by the splice initiator
435 pub funding_feerate_perkw: u32,
436 /// The locktime for the new funding transaction
438 /// The key of the sender (splice initiator) controlling the new funding transaction
439 pub funding_pubkey: PublicKey,
442 /// A splice_ack message to be received by or sent to the splice initiator.
444 // TODO(splicing): Add spec link for `splice_ack`; still in draft, using from https://github.com/lightning/bolts/pull/863
445 #[derive(Clone, Debug, PartialEq, Eq)]
446 pub struct SpliceAck {
447 /// The channel ID where splicing is intended
448 pub channel_id: ChannelId,
449 /// The genesis hash of the blockchain where the channel is intended to be spliced
450 pub chain_hash: ChainHash,
451 /// The intended change in channel capacity: the amount to be added (positive value)
452 /// or removed (negative value) by the sender (splice acceptor) by splicing into/from the channel.
453 pub relative_satoshis: i64,
454 /// The key of the sender (splice acceptor) controlling the new funding transaction
455 pub funding_pubkey: PublicKey,
458 /// A splice_locked message to be sent to or received from a peer.
460 // TODO(splicing): Add spec link for `splice_locked`; still in draft, using from https://github.com/lightning/bolts/pull/863
461 #[derive(Clone, Debug, PartialEq, Eq)]
462 pub struct SpliceLocked {
464 pub channel_id: ChannelId,
467 /// A tx_add_input message for adding an input during interactive transaction construction
469 // TODO(dual_funding): Add spec link for `tx_add_input`.
470 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
471 pub struct TxAddInput {
473 pub channel_id: ChannelId,
474 /// A randomly chosen unique identifier for this input, which is even for initiators and odd for
476 pub serial_id: SerialId,
477 /// Serialized transaction that contains the output this input spends to verify that it is non
479 pub prevtx: TransactionU16LenLimited,
480 /// The index of the output being spent
482 /// The sequence number of this input
486 /// A tx_add_output message for adding an output during interactive transaction construction.
488 // TODO(dual_funding): Add spec link for `tx_add_output`.
489 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
490 pub struct TxAddOutput {
492 pub channel_id: ChannelId,
493 /// A randomly chosen unique identifier for this output, which is even for initiators and odd for
495 pub serial_id: SerialId,
496 /// The satoshi value of the output
498 /// The scriptPubKey for the output
499 pub script: ScriptBuf,
502 /// A tx_remove_input message for removing an input during interactive transaction construction.
504 // TODO(dual_funding): Add spec link for `tx_remove_input`.
505 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
506 pub struct TxRemoveInput {
508 pub channel_id: ChannelId,
509 /// The serial ID of the input to be removed
510 pub serial_id: SerialId,
513 /// A tx_remove_output message for removing an output during interactive transaction construction.
515 // TODO(dual_funding): Add spec link for `tx_remove_output`.
516 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
517 pub struct TxRemoveOutput {
519 pub channel_id: ChannelId,
520 /// The serial ID of the output to be removed
521 pub serial_id: SerialId,
524 /// A tx_complete message signalling the conclusion of a peer's transaction contributions during
525 /// interactive transaction construction.
527 // TODO(dual_funding): Add spec link for `tx_complete`.
528 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
529 pub struct TxComplete {
531 pub channel_id: ChannelId,
534 /// A tx_signatures message containing the sender's signatures for a transaction constructed with
535 /// interactive transaction construction.
537 // TODO(dual_funding): Add spec link for `tx_signatures`.
538 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
539 pub struct TxSignatures {
541 pub channel_id: ChannelId,
544 /// The list of witnesses
545 pub witnesses: Vec<Witness>,
546 /// Optional signature for the shared input -- the previous funding outpoint -- signed by both peers
547 pub funding_outpoint_sig: Option<Signature>,
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.
1466 fn handle_splice(&self, their_node_id: &PublicKey, msg: &Splice);
1467 /// Handle an incoming `splice_ack` message from the given peer.
1469 fn handle_splice_ack(&self, their_node_id: &PublicKey, msg: &SpliceAck);
1470 /// Handle an incoming `splice_locked` message from the given peer.
1472 fn handle_splice_locked(&self, their_node_id: &PublicKey, msg: &SpliceLocked);
1474 // Interactive channel construction
1475 /// Handle an incoming `tx_add_input message` from the given peer.
1476 fn handle_tx_add_input(&self, their_node_id: &PublicKey, msg: &TxAddInput);
1477 /// Handle an incoming `tx_add_output` message from the given peer.
1478 fn handle_tx_add_output(&self, their_node_id: &PublicKey, msg: &TxAddOutput);
1479 /// Handle an incoming `tx_remove_input` message from the given peer.
1480 fn handle_tx_remove_input(&self, their_node_id: &PublicKey, msg: &TxRemoveInput);
1481 /// Handle an incoming `tx_remove_output` message from the given peer.
1482 fn handle_tx_remove_output(&self, their_node_id: &PublicKey, msg: &TxRemoveOutput);
1483 /// Handle an incoming `tx_complete message` from the given peer.
1484 fn handle_tx_complete(&self, their_node_id: &PublicKey, msg: &TxComplete);
1485 /// Handle an incoming `tx_signatures` message from the given peer.
1486 fn handle_tx_signatures(&self, their_node_id: &PublicKey, msg: &TxSignatures);
1487 /// Handle an incoming `tx_init_rbf` message from the given peer.
1488 fn handle_tx_init_rbf(&self, their_node_id: &PublicKey, msg: &TxInitRbf);
1489 /// Handle an incoming `tx_ack_rbf` message from the given peer.
1490 fn handle_tx_ack_rbf(&self, their_node_id: &PublicKey, msg: &TxAckRbf);
1491 /// Handle an incoming `tx_abort message` from the given peer.
1492 fn handle_tx_abort(&self, their_node_id: &PublicKey, msg: &TxAbort);
1495 /// Handle an incoming `update_add_htlc` message from the given peer.
1496 fn handle_update_add_htlc(&self, their_node_id: &PublicKey, msg: &UpdateAddHTLC);
1497 /// Handle an incoming `update_fulfill_htlc` message from the given peer.
1498 fn handle_update_fulfill_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFulfillHTLC);
1499 /// Handle an incoming `update_fail_htlc` message from the given peer.
1500 fn handle_update_fail_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailHTLC);
1501 /// Handle an incoming `update_fail_malformed_htlc` message from the given peer.
1502 fn handle_update_fail_malformed_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailMalformedHTLC);
1503 /// Handle an incoming `commitment_signed` message from the given peer.
1504 fn handle_commitment_signed(&self, their_node_id: &PublicKey, msg: &CommitmentSigned);
1505 /// Handle an incoming `revoke_and_ack` message from the given peer.
1506 fn handle_revoke_and_ack(&self, their_node_id: &PublicKey, msg: &RevokeAndACK);
1508 /// Handle an incoming `update_fee` message from the given peer.
1509 fn handle_update_fee(&self, their_node_id: &PublicKey, msg: &UpdateFee);
1511 // Channel-to-announce:
1512 /// Handle an incoming `announcement_signatures` message from the given peer.
1513 fn handle_announcement_signatures(&self, their_node_id: &PublicKey, msg: &AnnouncementSignatures);
1515 // Connection loss/reestablish:
1516 /// Indicates a connection to the peer failed/an existing connection was lost.
1517 fn peer_disconnected(&self, their_node_id: &PublicKey);
1519 /// Handle a peer reconnecting, possibly generating `channel_reestablish` message(s).
1521 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1522 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1523 /// message handlers may still wish to communicate with this peer.
1524 fn peer_connected(&self, their_node_id: &PublicKey, msg: &Init, inbound: bool) -> Result<(), ()>;
1525 /// Handle an incoming `channel_reestablish` message from the given peer.
1526 fn handle_channel_reestablish(&self, their_node_id: &PublicKey, msg: &ChannelReestablish);
1528 /// Handle an incoming `channel_update` message from the given peer.
1529 fn handle_channel_update(&self, their_node_id: &PublicKey, msg: &ChannelUpdate);
1532 /// Handle an incoming `error` message from the given peer.
1533 fn handle_error(&self, their_node_id: &PublicKey, msg: &ErrorMessage);
1535 // Handler information:
1536 /// Gets the node feature flags which this handler itself supports. All available handlers are
1537 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1538 /// which are broadcasted in our [`NodeAnnouncement`] message.
1539 fn provided_node_features(&self) -> NodeFeatures;
1541 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1542 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1543 /// which are sent in our [`Init`] message.
1545 /// Note that this method is called before [`Self::peer_connected`].
1546 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1548 /// Gets the chain hashes for this `ChannelMessageHandler` indicating which chains it supports.
1550 /// If it's `None`, then no particular network chain hash compatibility will be enforced when
1551 /// connecting to peers.
1552 fn get_chain_hashes(&self) -> Option<Vec<ChainHash>>;
1555 /// A trait to describe an object which can receive routing messages.
1557 /// # Implementor DoS Warnings
1559 /// For messages enabled with the `gossip_queries` feature there are potential DoS vectors when
1560 /// handling inbound queries. Implementors using an on-disk network graph should be aware of
1561 /// repeated disk I/O for queries accessing different parts of the network graph.
1562 pub trait RoutingMessageHandler : MessageSendEventsProvider {
1563 /// Handle an incoming `node_announcement` message, returning `true` if it should be forwarded on,
1564 /// `false` or returning an `Err` otherwise.
1565 fn handle_node_announcement(&self, msg: &NodeAnnouncement) -> Result<bool, LightningError>;
1566 /// Handle a `channel_announcement` message, returning `true` if it should be forwarded on, `false`
1567 /// or returning an `Err` otherwise.
1568 fn handle_channel_announcement(&self, msg: &ChannelAnnouncement) -> Result<bool, LightningError>;
1569 /// Handle an incoming `channel_update` message, returning true if it should be forwarded on,
1570 /// `false` or returning an `Err` otherwise.
1571 fn handle_channel_update(&self, msg: &ChannelUpdate) -> Result<bool, LightningError>;
1572 /// Gets channel announcements and updates required to dump our routing table to a remote node,
1573 /// starting at the `short_channel_id` indicated by `starting_point` and including announcements
1574 /// for a single channel.
1575 fn get_next_channel_announcement(&self, starting_point: u64) -> Option<(ChannelAnnouncement, Option<ChannelUpdate>, Option<ChannelUpdate>)>;
1576 /// Gets a node announcement required to dump our routing table to a remote node, starting at
1577 /// the node *after* the provided pubkey and including up to one announcement immediately
1578 /// higher (as defined by `<PublicKey as Ord>::cmp`) than `starting_point`.
1579 /// If `None` is provided for `starting_point`, we start at the first node.
1580 fn get_next_node_announcement(&self, starting_point: Option<&NodeId>) -> Option<NodeAnnouncement>;
1581 /// Called when a connection is established with a peer. This can be used to
1582 /// perform routing table synchronization using a strategy defined by the
1585 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1586 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1587 /// message handlers may still wish to communicate with this peer.
1588 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1589 /// Handles the reply of a query we initiated to learn about channels
1590 /// for a given range of blocks. We can expect to receive one or more
1591 /// replies to a single query.
1592 fn handle_reply_channel_range(&self, their_node_id: &PublicKey, msg: ReplyChannelRange) -> Result<(), LightningError>;
1593 /// Handles the reply of a query we initiated asking for routing gossip
1594 /// messages for a list of channels. We should receive this message when
1595 /// a node has completed its best effort to send us the pertaining routing
1596 /// gossip messages.
1597 fn handle_reply_short_channel_ids_end(&self, their_node_id: &PublicKey, msg: ReplyShortChannelIdsEnd) -> Result<(), LightningError>;
1598 /// Handles when a peer asks us to send a list of `short_channel_id`s
1599 /// for the requested range of blocks.
1600 fn handle_query_channel_range(&self, their_node_id: &PublicKey, msg: QueryChannelRange) -> Result<(), LightningError>;
1601 /// Handles when a peer asks us to send routing gossip messages for a
1602 /// list of `short_channel_id`s.
1603 fn handle_query_short_channel_ids(&self, their_node_id: &PublicKey, msg: QueryShortChannelIds) -> Result<(), LightningError>;
1605 // Handler queueing status:
1606 /// Indicates that there are a large number of [`ChannelAnnouncement`] (or other) messages
1607 /// pending some async action. While there is no guarantee of the rate of future messages, the
1608 /// caller should seek to reduce the rate of new gossip messages handled, especially
1609 /// [`ChannelAnnouncement`]s.
1610 fn processing_queue_high(&self) -> bool;
1612 // Handler information:
1613 /// Gets the node feature flags which this handler itself supports. All available handlers are
1614 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1615 /// which are broadcasted in our [`NodeAnnouncement`] message.
1616 fn provided_node_features(&self) -> NodeFeatures;
1617 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1618 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1619 /// which are sent in our [`Init`] message.
1621 /// Note that this method is called before [`Self::peer_connected`].
1622 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1625 /// A handler for received [`OnionMessage`]s and for providing generated ones to send.
1626 pub trait OnionMessageHandler {
1627 /// Handle an incoming `onion_message` message from the given peer.
1628 fn handle_onion_message(&self, peer_node_id: &PublicKey, msg: &OnionMessage);
1630 /// Returns the next pending onion message for the peer with the given node id.
1631 fn next_onion_message_for_peer(&self, peer_node_id: PublicKey) -> Option<OnionMessage>;
1633 /// Called when a connection is established with a peer. Can be used to track which peers
1634 /// advertise onion message support and are online.
1636 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1637 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1638 /// message handlers may still wish to communicate with this peer.
1639 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1641 /// Indicates a connection to the peer failed/an existing connection was lost. Allows handlers to
1642 /// drop and refuse to forward onion messages to this peer.
1643 fn peer_disconnected(&self, their_node_id: &PublicKey);
1645 /// Performs actions that should happen roughly every ten seconds after startup. Allows handlers
1646 /// to drop any buffered onion messages intended for prospective peers.
1647 fn timer_tick_occurred(&self);
1649 // Handler information:
1650 /// Gets the node feature flags which this handler itself supports. All available handlers are
1651 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1652 /// which are broadcasted in our [`NodeAnnouncement`] message.
1653 fn provided_node_features(&self) -> NodeFeatures;
1655 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1656 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1657 /// which are sent in our [`Init`] message.
1659 /// Note that this method is called before [`Self::peer_connected`].
1660 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1664 #[cfg_attr(test, derive(Debug, PartialEq))]
1665 /// Information communicated in the onion to the recipient for multi-part tracking and proof that
1666 /// the payment is associated with an invoice.
1667 pub struct FinalOnionHopData {
1668 /// When sending a multi-part payment, this secret is used to identify a payment across HTLCs.
1669 /// Because it is generated by the recipient and included in the invoice, it also provides
1670 /// proof to the recipient that the payment was sent by someone with the generated invoice.
1671 pub payment_secret: PaymentSecret,
1672 /// The intended total amount that this payment is for.
1674 /// Message serialization may panic if this value is more than 21 million Bitcoin.
1675 pub total_msat: u64,
1678 mod fuzzy_internal_msgs {
1679 use bitcoin::secp256k1::PublicKey;
1680 use crate::blinded_path::payment::{PaymentConstraints, PaymentContext, PaymentRelay};
1681 use crate::ln::types::{PaymentPreimage, PaymentSecret};
1682 use crate::ln::features::BlindedHopFeatures;
1683 use super::{FinalOnionHopData, TrampolineOnionPacket};
1685 #[allow(unused_imports)]
1686 use crate::prelude::*;
1688 // These types aren't intended to be pub, but are exposed for direct fuzzing (as we deserialize
1689 // them from untrusted input):
1691 pub enum InboundOnionPayload {
1693 short_channel_id: u64,
1694 /// The value, in msat, of the payment after this hop's fee is deducted.
1695 amt_to_forward: u64,
1696 outgoing_cltv_value: u32,
1699 payment_data: Option<FinalOnionHopData>,
1700 payment_metadata: Option<Vec<u8>>,
1701 keysend_preimage: Option<PaymentPreimage>,
1702 custom_tlvs: Vec<(u64, Vec<u8>)>,
1703 sender_intended_htlc_amt_msat: u64,
1704 cltv_expiry_height: u32,
1707 short_channel_id: u64,
1708 payment_relay: PaymentRelay,
1709 payment_constraints: PaymentConstraints,
1710 features: BlindedHopFeatures,
1711 intro_node_blinding_point: Option<PublicKey>,
1714 sender_intended_htlc_amt_msat: u64,
1716 cltv_expiry_height: u32,
1717 payment_secret: PaymentSecret,
1718 payment_constraints: PaymentConstraints,
1719 payment_context: PaymentContext,
1720 intro_node_blinding_point: Option<PublicKey>,
1721 keysend_preimage: Option<PaymentPreimage>,
1722 custom_tlvs: Vec<(u64, Vec<u8>)>,
1726 pub(crate) enum OutboundOnionPayload<'a> {
1728 short_channel_id: u64,
1729 /// The value, in msat, of the payment after this hop's fee is deducted.
1730 amt_to_forward: u64,
1731 outgoing_cltv_value: u32,
1734 TrampolineEntrypoint {
1735 amt_to_forward: u64,
1736 outgoing_cltv_value: u32,
1737 multipath_trampoline_data: Option<FinalOnionHopData>,
1738 trampoline_packet: TrampolineOnionPacket,
1741 payment_data: Option<FinalOnionHopData>,
1742 payment_metadata: Option<&'a Vec<u8>>,
1743 keysend_preimage: Option<PaymentPreimage>,
1744 custom_tlvs: &'a Vec<(u64, Vec<u8>)>,
1745 sender_intended_htlc_amt_msat: u64,
1746 cltv_expiry_height: u32,
1749 encrypted_tlvs: &'a Vec<u8>,
1750 intro_node_blinding_point: Option<PublicKey>,
1753 sender_intended_htlc_amt_msat: u64,
1755 cltv_expiry_height: u32,
1756 encrypted_tlvs: &'a Vec<u8>,
1757 intro_node_blinding_point: Option<PublicKey>, // Set if the introduction node of the blinded path is the final node
1758 keysend_preimage: Option<PaymentPreimage>,
1759 custom_tlvs: &'a Vec<(u64, Vec<u8>)>,
1763 pub(crate) enum OutboundTrampolinePayload {
1766 /// The value, in msat, of the payment after this hop's fee is deducted.
1767 amt_to_forward: u64,
1768 outgoing_cltv_value: u32,
1769 /// The node id to which the trampoline node must find a route
1770 outgoing_node_id: PublicKey,
1774 pub struct DecodedOnionErrorPacket {
1775 pub(crate) hmac: [u8; 32],
1776 pub(crate) failuremsg: Vec<u8>,
1777 pub(crate) pad: Vec<u8>,
1781 pub use self::fuzzy_internal_msgs::*;
1782 #[cfg(not(fuzzing))]
1783 pub(crate) use self::fuzzy_internal_msgs::*;
1785 /// BOLT 4 onion packet including hop data for the next peer.
1786 #[derive(Clone, Hash, PartialEq, Eq)]
1787 pub struct OnionPacket {
1788 /// BOLT 4 version number.
1790 /// In order to ensure we always return an error on onion decode in compliance with [BOLT
1791 /// #4](https://github.com/lightning/bolts/blob/master/04-onion-routing.md), we have to
1792 /// deserialize `OnionPacket`s contained in [`UpdateAddHTLC`] messages even if the ephemeral
1793 /// public key (here) is bogus, so we hold a [`Result`] instead of a [`PublicKey`] as we'd
1795 pub public_key: Result<PublicKey, secp256k1::Error>,
1796 /// 1300 bytes encrypted payload for the next hop.
1797 pub hop_data: [u8; 20*65],
1798 /// HMAC to verify the integrity of hop_data.
1802 impl onion_utils::Packet for OnionPacket {
1803 type Data = onion_utils::FixedSizeOnionPacket;
1804 fn new(pubkey: PublicKey, hop_data: onion_utils::FixedSizeOnionPacket, hmac: [u8; 32]) -> Self {
1807 public_key: Ok(pubkey),
1808 hop_data: hop_data.0,
1814 impl fmt::Debug for OnionPacket {
1815 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1816 f.write_fmt(format_args!("OnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
1820 /// BOLT 4 onion packet including hop data for the next peer.
1821 #[derive(Clone, Hash, PartialEq, Eq)]
1822 pub struct TrampolineOnionPacket {
1823 /// Bolt 04 version number
1825 /// A random sepc256k1 point, used to build the ECDH shared secret to decrypt hop_data
1826 pub public_key: PublicKey,
1827 /// Encrypted payload for the next hop
1829 // Unlike the onion packets used for payments, Trampoline onion packets have to be shorter than
1830 // 1300 bytes. The expected default is 650 bytes.
1831 // TODO: if 650 ends up being the most common size, optimize this to be:
1832 // enum { SixFifty([u8; 650]), VarLen(Vec<u8>) }
1833 pub hop_data: Vec<u8>,
1834 /// HMAC to verify the integrity of hop_data
1838 impl onion_utils::Packet for TrampolineOnionPacket {
1839 type Data = Vec<u8>;
1840 fn new(public_key: PublicKey, hop_data: Vec<u8>, hmac: [u8; 32]) -> Self {
1850 impl Writeable for TrampolineOnionPacket {
1851 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1852 self.version.write(w)?;
1853 self.public_key.write(w)?;
1854 w.write_all(&self.hop_data)?;
1855 self.hmac.write(w)?;
1860 impl LengthReadable for TrampolineOnionPacket {
1861 fn read<R: LengthRead>(r: &mut R) -> Result<Self, DecodeError> {
1862 let version = Readable::read(r)?;
1863 let public_key = Readable::read(r)?;
1865 let hop_data_len = r.total_bytes().saturating_sub(66); // 1 (version) + 33 (pubkey) + 32 (HMAC) = 66
1866 let mut rd = FixedLengthReader::new(r, hop_data_len);
1867 let hop_data = WithoutLength::<Vec<u8>>::read(&mut rd)?.0;
1869 let hmac = Readable::read(r)?;
1871 Ok(TrampolineOnionPacket {
1880 impl Debug for TrampolineOnionPacket {
1881 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1882 f.write_fmt(format_args!("TrampolineOnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
1886 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1887 pub(crate) struct OnionErrorPacket {
1888 // This really should be a constant size slice, but the spec lets these things be up to 128KB?
1889 // (TODO) We limit it in decode to much lower...
1890 pub(crate) data: Vec<u8>,
1893 impl fmt::Display for DecodeError {
1894 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1896 DecodeError::UnknownVersion => f.write_str("Unknown realm byte in Onion packet"),
1897 DecodeError::UnknownRequiredFeature => f.write_str("Unknown required feature preventing decode"),
1898 DecodeError::InvalidValue => f.write_str("Nonsense bytes didn't map to the type they were interpreted as"),
1899 DecodeError::ShortRead => f.write_str("Packet extended beyond the provided bytes"),
1900 DecodeError::BadLengthDescriptor => f.write_str("A length descriptor in the packet didn't describe the later data correctly"),
1901 DecodeError::Io(ref e) => fmt::Debug::fmt(e, f),
1902 DecodeError::UnsupportedCompression => f.write_str("We don't support receiving messages with zlib-compressed fields"),
1903 DecodeError::DangerousValue => f.write_str("Value would be dangerous to continue execution with"),
1908 impl From<io::Error> for DecodeError {
1909 fn from(e: io::Error) -> Self {
1910 if e.kind() == io::ErrorKind::UnexpectedEof {
1911 DecodeError::ShortRead
1913 DecodeError::Io(e.kind())
1918 impl Writeable for AcceptChannel {
1919 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1920 self.common_fields.temporary_channel_id.write(w)?;
1921 self.common_fields.dust_limit_satoshis.write(w)?;
1922 self.common_fields.max_htlc_value_in_flight_msat.write(w)?;
1923 self.channel_reserve_satoshis.write(w)?;
1924 self.common_fields.htlc_minimum_msat.write(w)?;
1925 self.common_fields.minimum_depth.write(w)?;
1926 self.common_fields.to_self_delay.write(w)?;
1927 self.common_fields.max_accepted_htlcs.write(w)?;
1928 self.common_fields.funding_pubkey.write(w)?;
1929 self.common_fields.revocation_basepoint.write(w)?;
1930 self.common_fields.payment_basepoint.write(w)?;
1931 self.common_fields.delayed_payment_basepoint.write(w)?;
1932 self.common_fields.htlc_basepoint.write(w)?;
1933 self.common_fields.first_per_commitment_point.write(w)?;
1934 #[cfg(not(taproot))]
1935 encode_tlv_stream!(w, {
1936 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
1937 (1, self.common_fields.channel_type, option),
1940 encode_tlv_stream!(w, {
1941 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
1942 (1, self.common_fields.channel_type, option),
1943 (4, self.next_local_nonce, option),
1949 impl Readable for AcceptChannel {
1950 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1951 let temporary_channel_id: ChannelId = Readable::read(r)?;
1952 let dust_limit_satoshis: u64 = Readable::read(r)?;
1953 let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;
1954 let channel_reserve_satoshis: u64 = Readable::read(r)?;
1955 let htlc_minimum_msat: u64 = Readable::read(r)?;
1956 let minimum_depth: u32 = Readable::read(r)?;
1957 let to_self_delay: u16 = Readable::read(r)?;
1958 let max_accepted_htlcs: u16 = Readable::read(r)?;
1959 let funding_pubkey: PublicKey = Readable::read(r)?;
1960 let revocation_basepoint: PublicKey = Readable::read(r)?;
1961 let payment_basepoint: PublicKey = Readable::read(r)?;
1962 let delayed_payment_basepoint: PublicKey = Readable::read(r)?;
1963 let htlc_basepoint: PublicKey = Readable::read(r)?;
1964 let first_per_commitment_point: PublicKey = Readable::read(r)?;
1966 let mut shutdown_scriptpubkey: Option<ScriptBuf> = None;
1967 let mut channel_type: Option<ChannelTypeFeatures> = None;
1968 #[cfg(not(taproot))]
1969 decode_tlv_stream!(r, {
1970 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
1971 (1, channel_type, option),
1974 let mut next_local_nonce: Option<musig2::types::PublicNonce> = None;
1976 decode_tlv_stream!(r, {
1977 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
1978 (1, channel_type, option),
1979 (4, next_local_nonce, option),
1983 common_fields: CommonAcceptChannelFields {
1984 temporary_channel_id,
1985 dust_limit_satoshis,
1986 max_htlc_value_in_flight_msat,
1992 revocation_basepoint,
1994 delayed_payment_basepoint,
1996 first_per_commitment_point,
1997 shutdown_scriptpubkey,
2000 channel_reserve_satoshis,
2007 impl Writeable for AcceptChannelV2 {
2008 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2009 self.common_fields.temporary_channel_id.write(w)?;
2010 self.funding_satoshis.write(w)?;
2011 self.common_fields.dust_limit_satoshis.write(w)?;
2012 self.common_fields.max_htlc_value_in_flight_msat.write(w)?;
2013 self.common_fields.htlc_minimum_msat.write(w)?;
2014 self.common_fields.minimum_depth.write(w)?;
2015 self.common_fields.to_self_delay.write(w)?;
2016 self.common_fields.max_accepted_htlcs.write(w)?;
2017 self.common_fields.funding_pubkey.write(w)?;
2018 self.common_fields.revocation_basepoint.write(w)?;
2019 self.common_fields.payment_basepoint.write(w)?;
2020 self.common_fields.delayed_payment_basepoint.write(w)?;
2021 self.common_fields.htlc_basepoint.write(w)?;
2022 self.common_fields.first_per_commitment_point.write(w)?;
2023 self.second_per_commitment_point.write(w)?;
2025 encode_tlv_stream!(w, {
2026 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
2027 (1, self.common_fields.channel_type, option),
2028 (2, self.require_confirmed_inputs, option),
2034 impl Readable for AcceptChannelV2 {
2035 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2036 let temporary_channel_id: ChannelId = Readable::read(r)?;
2037 let funding_satoshis: u64 = Readable::read(r)?;
2038 let dust_limit_satoshis: u64 = Readable::read(r)?;
2039 let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;
2040 let htlc_minimum_msat: u64 = Readable::read(r)?;
2041 let minimum_depth: u32 = Readable::read(r)?;
2042 let to_self_delay: u16 = Readable::read(r)?;
2043 let max_accepted_htlcs: u16 = Readable::read(r)?;
2044 let funding_pubkey: PublicKey = Readable::read(r)?;
2045 let revocation_basepoint: PublicKey = Readable::read(r)?;
2046 let payment_basepoint: PublicKey = Readable::read(r)?;
2047 let delayed_payment_basepoint: PublicKey = Readable::read(r)?;
2048 let htlc_basepoint: PublicKey = Readable::read(r)?;
2049 let first_per_commitment_point: PublicKey = Readable::read(r)?;
2050 let second_per_commitment_point: PublicKey = Readable::read(r)?;
2052 let mut shutdown_scriptpubkey: Option<ScriptBuf> = None;
2053 let mut channel_type: Option<ChannelTypeFeatures> = None;
2054 let mut require_confirmed_inputs: Option<()> = None;
2055 decode_tlv_stream!(r, {
2056 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
2057 (1, channel_type, option),
2058 (2, require_confirmed_inputs, option),
2061 Ok(AcceptChannelV2 {
2062 common_fields: CommonAcceptChannelFields {
2063 temporary_channel_id,
2064 dust_limit_satoshis,
2065 max_htlc_value_in_flight_msat,
2071 revocation_basepoint,
2073 delayed_payment_basepoint,
2075 first_per_commitment_point,
2076 shutdown_scriptpubkey,
2080 second_per_commitment_point,
2081 require_confirmed_inputs,
2086 impl_writeable_msg!(Stfu, {
2091 impl_writeable_msg!(Splice, {
2095 funding_feerate_perkw,
2100 impl_writeable_msg!(SpliceAck, {
2107 impl_writeable_msg!(SpliceLocked, {
2111 impl_writeable_msg!(TxAddInput, {
2119 impl_writeable_msg!(TxAddOutput, {
2126 impl_writeable_msg!(TxRemoveInput, {
2131 impl_writeable_msg!(TxRemoveOutput, {
2136 impl_writeable_msg!(TxComplete, {
2140 impl_writeable_msg!(TxSignatures, {
2145 (0, funding_outpoint_sig, option),
2148 impl_writeable_msg!(TxInitRbf, {
2151 feerate_sat_per_1000_weight,
2153 (0, funding_output_contribution, option),
2156 impl_writeable_msg!(TxAckRbf, {
2159 (0, funding_output_contribution, option),
2162 impl_writeable_msg!(TxAbort, {
2167 impl_writeable_msg!(AnnouncementSignatures, {
2174 impl_writeable_msg!(ChannelReestablish, {
2176 next_local_commitment_number,
2177 next_remote_commitment_number,
2178 your_last_per_commitment_secret,
2179 my_current_per_commitment_point,
2181 (0, next_funding_txid, option),
2184 impl_writeable_msg!(ClosingSigned,
2185 { channel_id, fee_satoshis, signature },
2186 { (1, fee_range, option) }
2189 impl_writeable!(ClosingSignedFeeRange, {
2194 #[cfg(not(taproot))]
2195 impl_writeable_msg!(CommitmentSigned, {
2202 impl_writeable_msg!(CommitmentSigned, {
2207 (2, partial_signature_with_nonce, option)
2210 impl_writeable!(DecodedOnionErrorPacket, {
2216 #[cfg(not(taproot))]
2217 impl_writeable_msg!(FundingCreated, {
2218 temporary_channel_id,
2220 funding_output_index,
2224 impl_writeable_msg!(FundingCreated, {
2225 temporary_channel_id,
2227 funding_output_index,
2230 (2, partial_signature_with_nonce, option),
2231 (4, next_local_nonce, option)
2234 #[cfg(not(taproot))]
2235 impl_writeable_msg!(FundingSigned, {
2241 impl_writeable_msg!(FundingSigned, {
2245 (2, partial_signature_with_nonce, option)
2248 impl_writeable_msg!(ChannelReady, {
2250 next_per_commitment_point,
2252 (1, short_channel_id_alias, option),
2255 impl Writeable for Init {
2256 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2257 // global_features gets the bottom 13 bits of our features, and local_features gets all of
2258 // our relevant feature bits. This keeps us compatible with old nodes.
2259 self.features.write_up_to_13(w)?;
2260 self.features.write(w)?;
2261 encode_tlv_stream!(w, {
2262 (1, self.networks.as_ref().map(|n| WithoutLength(n)), option),
2263 (3, self.remote_network_address, option),
2269 impl Readable for Init {
2270 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2271 let global_features: InitFeatures = Readable::read(r)?;
2272 let features: InitFeatures = Readable::read(r)?;
2273 let mut remote_network_address: Option<SocketAddress> = None;
2274 let mut networks: Option<WithoutLength<Vec<ChainHash>>> = None;
2275 decode_tlv_stream!(r, {
2276 (1, networks, option),
2277 (3, remote_network_address, option)
2280 features: features | global_features,
2281 networks: networks.map(|n| n.0),
2282 remote_network_address,
2287 impl Writeable for OpenChannel {
2288 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2289 self.common_fields.chain_hash.write(w)?;
2290 self.common_fields.temporary_channel_id.write(w)?;
2291 self.common_fields.funding_satoshis.write(w)?;
2292 self.push_msat.write(w)?;
2293 self.common_fields.dust_limit_satoshis.write(w)?;
2294 self.common_fields.max_htlc_value_in_flight_msat.write(w)?;
2295 self.channel_reserve_satoshis.write(w)?;
2296 self.common_fields.htlc_minimum_msat.write(w)?;
2297 self.common_fields.commitment_feerate_sat_per_1000_weight.write(w)?;
2298 self.common_fields.to_self_delay.write(w)?;
2299 self.common_fields.max_accepted_htlcs.write(w)?;
2300 self.common_fields.funding_pubkey.write(w)?;
2301 self.common_fields.revocation_basepoint.write(w)?;
2302 self.common_fields.payment_basepoint.write(w)?;
2303 self.common_fields.delayed_payment_basepoint.write(w)?;
2304 self.common_fields.htlc_basepoint.write(w)?;
2305 self.common_fields.first_per_commitment_point.write(w)?;
2306 self.common_fields.channel_flags.write(w)?;
2307 encode_tlv_stream!(w, {
2308 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
2309 (1, self.common_fields.channel_type, option),
2315 impl Readable for OpenChannel {
2316 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2317 let chain_hash: ChainHash = Readable::read(r)?;
2318 let temporary_channel_id: ChannelId = Readable::read(r)?;
2319 let funding_satoshis: u64 = Readable::read(r)?;
2320 let push_msat: u64 = Readable::read(r)?;
2321 let dust_limit_satoshis: u64 = Readable::read(r)?;
2322 let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;
2323 let channel_reserve_satoshis: u64 = Readable::read(r)?;
2324 let htlc_minimum_msat: u64 = Readable::read(r)?;
2325 let commitment_feerate_sat_per_1000_weight: u32 = Readable::read(r)?;
2326 let to_self_delay: u16 = Readable::read(r)?;
2327 let max_accepted_htlcs: u16 = Readable::read(r)?;
2328 let funding_pubkey: PublicKey = Readable::read(r)?;
2329 let revocation_basepoint: PublicKey = Readable::read(r)?;
2330 let payment_basepoint: PublicKey = Readable::read(r)?;
2331 let delayed_payment_basepoint: PublicKey = Readable::read(r)?;
2332 let htlc_basepoint: PublicKey = Readable::read(r)?;
2333 let first_per_commitment_point: PublicKey = Readable::read(r)?;
2334 let channel_flags: u8 = Readable::read(r)?;
2336 let mut shutdown_scriptpubkey: Option<ScriptBuf> = None;
2337 let mut channel_type: Option<ChannelTypeFeatures> = None;
2338 decode_tlv_stream!(r, {
2339 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
2340 (1, channel_type, option),
2343 common_fields: CommonOpenChannelFields {
2345 temporary_channel_id,
2347 dust_limit_satoshis,
2348 max_htlc_value_in_flight_msat,
2350 commitment_feerate_sat_per_1000_weight,
2354 revocation_basepoint,
2356 delayed_payment_basepoint,
2358 first_per_commitment_point,
2360 shutdown_scriptpubkey,
2364 channel_reserve_satoshis,
2369 impl Writeable for OpenChannelV2 {
2370 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2371 self.common_fields.chain_hash.write(w)?;
2372 self.common_fields.temporary_channel_id.write(w)?;
2373 self.funding_feerate_sat_per_1000_weight.write(w)?;
2374 self.common_fields.commitment_feerate_sat_per_1000_weight.write(w)?;
2375 self.common_fields.funding_satoshis.write(w)?;
2376 self.common_fields.dust_limit_satoshis.write(w)?;
2377 self.common_fields.max_htlc_value_in_flight_msat.write(w)?;
2378 self.common_fields.htlc_minimum_msat.write(w)?;
2379 self.common_fields.to_self_delay.write(w)?;
2380 self.common_fields.max_accepted_htlcs.write(w)?;
2381 self.locktime.write(w)?;
2382 self.common_fields.funding_pubkey.write(w)?;
2383 self.common_fields.revocation_basepoint.write(w)?;
2384 self.common_fields.payment_basepoint.write(w)?;
2385 self.common_fields.delayed_payment_basepoint.write(w)?;
2386 self.common_fields.htlc_basepoint.write(w)?;
2387 self.common_fields.first_per_commitment_point.write(w)?;
2388 self.second_per_commitment_point.write(w)?;
2389 self.common_fields.channel_flags.write(w)?;
2390 encode_tlv_stream!(w, {
2391 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
2392 (1, self.common_fields.channel_type, option),
2393 (2, self.require_confirmed_inputs, option),
2399 impl Readable for OpenChannelV2 {
2400 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2401 let chain_hash: ChainHash = Readable::read(r)?;
2402 let temporary_channel_id: ChannelId = Readable::read(r)?;
2403 let funding_feerate_sat_per_1000_weight: u32 = Readable::read(r)?;
2404 let commitment_feerate_sat_per_1000_weight: u32 = Readable::read(r)?;
2405 let funding_satoshis: u64 = Readable::read(r)?;
2406 let dust_limit_satoshis: u64 = Readable::read(r)?;
2407 let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;
2408 let htlc_minimum_msat: u64 = Readable::read(r)?;
2409 let to_self_delay: u16 = Readable::read(r)?;
2410 let max_accepted_htlcs: u16 = Readable::read(r)?;
2411 let locktime: u32 = Readable::read(r)?;
2412 let funding_pubkey: PublicKey = Readable::read(r)?;
2413 let revocation_basepoint: PublicKey = Readable::read(r)?;
2414 let payment_basepoint: PublicKey = Readable::read(r)?;
2415 let delayed_payment_basepoint: PublicKey = Readable::read(r)?;
2416 let htlc_basepoint: PublicKey = Readable::read(r)?;
2417 let first_per_commitment_point: PublicKey = Readable::read(r)?;
2418 let second_per_commitment_point: PublicKey = Readable::read(r)?;
2419 let channel_flags: u8 = Readable::read(r)?;
2421 let mut shutdown_scriptpubkey: Option<ScriptBuf> = None;
2422 let mut channel_type: Option<ChannelTypeFeatures> = None;
2423 let mut require_confirmed_inputs: Option<()> = None;
2424 decode_tlv_stream!(r, {
2425 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
2426 (1, channel_type, option),
2427 (2, require_confirmed_inputs, option),
2430 common_fields: CommonOpenChannelFields {
2432 temporary_channel_id,
2434 dust_limit_satoshis,
2435 max_htlc_value_in_flight_msat,
2437 commitment_feerate_sat_per_1000_weight,
2441 revocation_basepoint,
2443 delayed_payment_basepoint,
2445 first_per_commitment_point,
2447 shutdown_scriptpubkey,
2450 funding_feerate_sat_per_1000_weight,
2452 second_per_commitment_point,
2453 require_confirmed_inputs,
2458 #[cfg(not(taproot))]
2459 impl_writeable_msg!(RevokeAndACK, {
2461 per_commitment_secret,
2462 next_per_commitment_point
2466 impl_writeable_msg!(RevokeAndACK, {
2468 per_commitment_secret,
2469 next_per_commitment_point
2471 (4, next_local_nonce, option)
2474 impl_writeable_msg!(Shutdown, {
2479 impl_writeable_msg!(UpdateFailHTLC, {
2485 impl_writeable_msg!(UpdateFailMalformedHTLC, {
2492 impl_writeable_msg!(UpdateFee, {
2497 impl_writeable_msg!(UpdateFulfillHTLC, {
2503 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2504 // serialization format in a way which assumes we know the total serialized length/message end
2506 impl_writeable!(OnionErrorPacket, {
2510 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2511 // serialization format in a way which assumes we know the total serialized length/message end
2513 impl Writeable for OnionPacket {
2514 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2515 self.version.write(w)?;
2516 match self.public_key {
2517 Ok(pubkey) => pubkey.write(w)?,
2518 Err(_) => [0u8;33].write(w)?,
2520 w.write_all(&self.hop_data)?;
2521 self.hmac.write(w)?;
2526 impl Readable for OnionPacket {
2527 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2529 version: Readable::read(r)?,
2531 let mut buf = [0u8;33];
2532 r.read_exact(&mut buf)?;
2533 PublicKey::from_slice(&buf)
2535 hop_data: Readable::read(r)?,
2536 hmac: Readable::read(r)?,
2541 impl_writeable_msg!(UpdateAddHTLC, {
2547 onion_routing_packet,
2549 (0, blinding_point, option),
2550 (65537, skimmed_fee_msat, option)
2553 impl Readable for OnionMessage {
2554 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2555 let blinding_point: PublicKey = Readable::read(r)?;
2556 let len: u16 = Readable::read(r)?;
2557 let mut packet_reader = FixedLengthReader::new(r, len as u64);
2558 let onion_routing_packet: onion_message::packet::Packet =
2559 <onion_message::packet::Packet as LengthReadable>::read(&mut packet_reader)?;
2562 onion_routing_packet,
2567 impl Writeable for OnionMessage {
2568 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2569 self.blinding_point.write(w)?;
2570 let onion_packet_len = self.onion_routing_packet.serialized_length();
2571 (onion_packet_len as u16).write(w)?;
2572 self.onion_routing_packet.write(w)?;
2577 impl Writeable for FinalOnionHopData {
2578 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2579 self.payment_secret.0.write(w)?;
2580 HighZeroBytesDroppedBigSize(self.total_msat).write(w)
2584 impl Readable for FinalOnionHopData {
2585 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2586 let secret: [u8; 32] = Readable::read(r)?;
2587 let amt: HighZeroBytesDroppedBigSize<u64> = Readable::read(r)?;
2588 Ok(Self { payment_secret: PaymentSecret(secret), total_msat: amt.0 })
2592 impl<'a> Writeable for OutboundOnionPayload<'a> {
2593 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2595 Self::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } => {
2596 _encode_varint_length_prefixed_tlv!(w, {
2597 (2, HighZeroBytesDroppedBigSize(*amt_to_forward), required),
2598 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2599 (6, short_channel_id, required)
2602 Self::TrampolineEntrypoint {
2603 amt_to_forward, outgoing_cltv_value, ref multipath_trampoline_data,
2604 ref trampoline_packet
2606 _encode_varint_length_prefixed_tlv!(w, {
2607 (2, HighZeroBytesDroppedBigSize(*amt_to_forward), required),
2608 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2609 (8, multipath_trampoline_data, option),
2610 (20, trampoline_packet, required)
2614 ref payment_data, ref payment_metadata, ref keysend_preimage, sender_intended_htlc_amt_msat,
2615 cltv_expiry_height, ref custom_tlvs,
2617 // We need to update [`ln::outbound_payment::RecipientOnionFields::with_custom_tlvs`]
2618 // to reject any reserved types in the experimental range if new ones are ever
2620 let keysend_tlv = keysend_preimage.map(|preimage| (5482373484, preimage.encode()));
2621 let mut custom_tlvs: Vec<&(u64, Vec<u8>)> = custom_tlvs.iter().chain(keysend_tlv.iter()).collect();
2622 custom_tlvs.sort_unstable_by_key(|(typ, _)| *typ);
2623 _encode_varint_length_prefixed_tlv!(w, {
2624 (2, HighZeroBytesDroppedBigSize(*sender_intended_htlc_amt_msat), required),
2625 (4, HighZeroBytesDroppedBigSize(*cltv_expiry_height), required),
2626 (8, payment_data, option),
2627 (16, payment_metadata.map(|m| WithoutLength(m)), option)
2628 }, custom_tlvs.iter());
2630 Self::BlindedForward { encrypted_tlvs, intro_node_blinding_point } => {
2631 _encode_varint_length_prefixed_tlv!(w, {
2632 (10, **encrypted_tlvs, required_vec),
2633 (12, intro_node_blinding_point, option)
2636 Self::BlindedReceive {
2637 sender_intended_htlc_amt_msat, total_msat, cltv_expiry_height, encrypted_tlvs,
2638 intro_node_blinding_point, keysend_preimage, ref custom_tlvs,
2640 // We need to update [`ln::outbound_payment::RecipientOnionFields::with_custom_tlvs`]
2641 // to reject any reserved types in the experimental range if new ones are ever
2643 let keysend_tlv = keysend_preimage.map(|preimage| (5482373484, preimage.encode()));
2644 let mut custom_tlvs: Vec<&(u64, Vec<u8>)> = custom_tlvs.iter().chain(keysend_tlv.iter()).collect();
2645 custom_tlvs.sort_unstable_by_key(|(typ, _)| *typ);
2646 _encode_varint_length_prefixed_tlv!(w, {
2647 (2, HighZeroBytesDroppedBigSize(*sender_intended_htlc_amt_msat), required),
2648 (4, HighZeroBytesDroppedBigSize(*cltv_expiry_height), required),
2649 (10, **encrypted_tlvs, required_vec),
2650 (12, intro_node_blinding_point, option),
2651 (18, HighZeroBytesDroppedBigSize(*total_msat), required)
2652 }, custom_tlvs.iter());
2659 impl Writeable for OutboundTrampolinePayload {
2660 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2662 Self::Forward { amt_to_forward, outgoing_cltv_value, outgoing_node_id } => {
2663 _encode_varint_length_prefixed_tlv!(w, {
2664 (2, HighZeroBytesDroppedBigSize(*amt_to_forward), required),
2665 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2666 (14, outgoing_node_id, required)
2675 impl<NS: Deref> ReadableArgs<(Option<PublicKey>, &NS)> for InboundOnionPayload where NS::Target: NodeSigner {
2676 fn read<R: Read>(r: &mut R, args: (Option<PublicKey>, &NS)) -> Result<Self, DecodeError> {
2677 let (update_add_blinding_point, node_signer) = args;
2680 let mut cltv_value = None;
2681 let mut short_id: Option<u64> = None;
2682 let mut payment_data: Option<FinalOnionHopData> = None;
2683 let mut encrypted_tlvs_opt: Option<WithoutLength<Vec<u8>>> = None;
2684 let mut intro_node_blinding_point = None;
2685 let mut payment_metadata: Option<WithoutLength<Vec<u8>>> = None;
2686 let mut total_msat = None;
2687 let mut keysend_preimage: Option<PaymentPreimage> = None;
2688 let mut custom_tlvs = Vec::new();
2690 let tlv_len = BigSize::read(r)?;
2691 let rd = FixedLengthReader::new(r, tlv_len.0);
2692 decode_tlv_stream_with_custom_tlv_decode!(rd, {
2693 (2, amt, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2694 (4, cltv_value, (option, encoding: (u32, HighZeroBytesDroppedBigSize))),
2695 (6, short_id, option),
2696 (8, payment_data, option),
2697 (10, encrypted_tlvs_opt, option),
2698 (12, intro_node_blinding_point, option),
2699 (16, payment_metadata, option),
2700 (18, total_msat, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2701 // See https://github.com/lightning/blips/blob/master/blip-0003.md
2702 (5482373484, keysend_preimage, option)
2703 }, |msg_type: u64, msg_reader: &mut FixedLengthReader<_>| -> Result<bool, DecodeError> {
2704 if msg_type < 1 << 16 { return Ok(false) }
2705 let mut value = Vec::new();
2706 msg_reader.read_to_end(&mut value)?;
2707 custom_tlvs.push((msg_type, value));
2711 if amt.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2712 if intro_node_blinding_point.is_some() && update_add_blinding_point.is_some() {
2713 return Err(DecodeError::InvalidValue)
2716 if let Some(blinding_point) = intro_node_blinding_point.or(update_add_blinding_point) {
2717 if short_id.is_some() || payment_data.is_some() || payment_metadata.is_some() {
2718 return Err(DecodeError::InvalidValue)
2720 let enc_tlvs = encrypted_tlvs_opt.ok_or(DecodeError::InvalidValue)?.0;
2721 let enc_tlvs_ss = node_signer.ecdh(Recipient::Node, &blinding_point, None)
2722 .map_err(|_| DecodeError::InvalidValue)?;
2723 let rho = onion_utils::gen_rho_from_shared_secret(&enc_tlvs_ss.secret_bytes());
2724 let mut s = Cursor::new(&enc_tlvs);
2725 let mut reader = FixedLengthReader::new(&mut s, enc_tlvs.len() as u64);
2726 match ChaChaPolyReadAdapter::read(&mut reader, rho)? {
2727 ChaChaPolyReadAdapter { readable: BlindedPaymentTlvs::Forward(ForwardTlvs {
2728 short_channel_id, payment_relay, payment_constraints, features
2730 if amt.is_some() || cltv_value.is_some() || total_msat.is_some() ||
2731 keysend_preimage.is_some()
2733 return Err(DecodeError::InvalidValue)
2735 Ok(Self::BlindedForward {
2738 payment_constraints,
2740 intro_node_blinding_point,
2743 ChaChaPolyReadAdapter { readable: BlindedPaymentTlvs::Receive(ReceiveTlvs {
2744 payment_secret, payment_constraints, payment_context
2746 if total_msat.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2747 Ok(Self::BlindedReceive {
2748 sender_intended_htlc_amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2749 total_msat: total_msat.ok_or(DecodeError::InvalidValue)?,
2750 cltv_expiry_height: cltv_value.ok_or(DecodeError::InvalidValue)?,
2752 payment_constraints,
2754 intro_node_blinding_point,
2760 } else if let Some(short_channel_id) = short_id {
2761 if payment_data.is_some() || payment_metadata.is_some() || encrypted_tlvs_opt.is_some() ||
2762 total_msat.is_some()
2763 { return Err(DecodeError::InvalidValue) }
2766 amt_to_forward: amt.ok_or(DecodeError::InvalidValue)?,
2767 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2770 if encrypted_tlvs_opt.is_some() || total_msat.is_some() {
2771 return Err(DecodeError::InvalidValue)
2773 if let Some(data) = &payment_data {
2774 if data.total_msat > MAX_VALUE_MSAT {
2775 return Err(DecodeError::InvalidValue);
2780 payment_metadata: payment_metadata.map(|w| w.0),
2782 sender_intended_htlc_amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2783 cltv_expiry_height: cltv_value.ok_or(DecodeError::InvalidValue)?,
2790 impl Writeable for Ping {
2791 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2792 self.ponglen.write(w)?;
2793 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2798 impl Readable for Ping {
2799 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2801 ponglen: Readable::read(r)?,
2803 let byteslen = Readable::read(r)?;
2804 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2811 impl Writeable for Pong {
2812 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2813 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2818 impl Readable for Pong {
2819 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2822 let byteslen = Readable::read(r)?;
2823 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2830 impl Writeable for UnsignedChannelAnnouncement {
2831 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2832 self.features.write(w)?;
2833 self.chain_hash.write(w)?;
2834 self.short_channel_id.write(w)?;
2835 self.node_id_1.write(w)?;
2836 self.node_id_2.write(w)?;
2837 self.bitcoin_key_1.write(w)?;
2838 self.bitcoin_key_2.write(w)?;
2839 w.write_all(&self.excess_data[..])?;
2844 impl Readable for UnsignedChannelAnnouncement {
2845 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2847 features: Readable::read(r)?,
2848 chain_hash: Readable::read(r)?,
2849 short_channel_id: Readable::read(r)?,
2850 node_id_1: Readable::read(r)?,
2851 node_id_2: Readable::read(r)?,
2852 bitcoin_key_1: Readable::read(r)?,
2853 bitcoin_key_2: Readable::read(r)?,
2854 excess_data: read_to_end(r)?,
2859 impl_writeable!(ChannelAnnouncement, {
2862 bitcoin_signature_1,
2863 bitcoin_signature_2,
2867 impl Writeable for UnsignedChannelUpdate {
2868 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2869 // `message_flags` used to indicate presence of `htlc_maximum_msat`, but was deprecated in the spec.
2870 const MESSAGE_FLAGS: u8 = 1;
2871 self.chain_hash.write(w)?;
2872 self.short_channel_id.write(w)?;
2873 self.timestamp.write(w)?;
2874 let all_flags = self.flags as u16 | ((MESSAGE_FLAGS as u16) << 8);
2875 all_flags.write(w)?;
2876 self.cltv_expiry_delta.write(w)?;
2877 self.htlc_minimum_msat.write(w)?;
2878 self.fee_base_msat.write(w)?;
2879 self.fee_proportional_millionths.write(w)?;
2880 self.htlc_maximum_msat.write(w)?;
2881 w.write_all(&self.excess_data[..])?;
2886 impl Readable for UnsignedChannelUpdate {
2887 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2889 chain_hash: Readable::read(r)?,
2890 short_channel_id: Readable::read(r)?,
2891 timestamp: Readable::read(r)?,
2893 let flags: u16 = Readable::read(r)?;
2894 // Note: we ignore the `message_flags` for now, since it was deprecated by the spec.
2897 cltv_expiry_delta: Readable::read(r)?,
2898 htlc_minimum_msat: Readable::read(r)?,
2899 fee_base_msat: Readable::read(r)?,
2900 fee_proportional_millionths: Readable::read(r)?,
2901 htlc_maximum_msat: Readable::read(r)?,
2902 excess_data: read_to_end(r)?,
2907 impl_writeable!(ChannelUpdate, {
2912 impl Writeable for ErrorMessage {
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 ErrorMessage {
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 WarningMessage {
2940 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2941 self.channel_id.write(w)?;
2942 (self.data.len() as u16).write(w)?;
2943 w.write_all(self.data.as_bytes())?;
2948 impl Readable for WarningMessage {
2949 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2951 channel_id: Readable::read(r)?,
2953 let sz: usize = <u16 as Readable>::read(r)? as usize;
2954 let mut data = Vec::with_capacity(sz);
2956 r.read_exact(&mut data)?;
2957 match String::from_utf8(data) {
2959 Err(_) => return Err(DecodeError::InvalidValue),
2966 impl Writeable for UnsignedNodeAnnouncement {
2967 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2968 self.features.write(w)?;
2969 self.timestamp.write(w)?;
2970 self.node_id.write(w)?;
2971 w.write_all(&self.rgb)?;
2972 self.alias.write(w)?;
2974 let mut addr_len = 0;
2975 for addr in self.addresses.iter() {
2976 addr_len += 1 + addr.len();
2978 (addr_len + self.excess_address_data.len() as u16).write(w)?;
2979 for addr in self.addresses.iter() {
2982 w.write_all(&self.excess_address_data[..])?;
2983 w.write_all(&self.excess_data[..])?;
2988 impl Readable for UnsignedNodeAnnouncement {
2989 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2990 let features: NodeFeatures = Readable::read(r)?;
2991 let timestamp: u32 = Readable::read(r)?;
2992 let node_id: NodeId = Readable::read(r)?;
2993 let mut rgb = [0; 3];
2994 r.read_exact(&mut rgb)?;
2995 let alias: NodeAlias = Readable::read(r)?;
2997 let addr_len: u16 = Readable::read(r)?;
2998 let mut addresses: Vec<SocketAddress> = Vec::new();
2999 let mut addr_readpos = 0;
3000 let mut excess = false;
3001 let mut excess_byte = 0;
3003 if addr_len <= addr_readpos { break; }
3004 match Readable::read(r) {
3006 if addr_len < addr_readpos + 1 + addr.len() {
3007 return Err(DecodeError::BadLengthDescriptor);
3009 addr_readpos += (1 + addr.len()) as u16;
3010 addresses.push(addr);
3012 Ok(Err(unknown_descriptor)) => {
3014 excess_byte = unknown_descriptor;
3017 Err(DecodeError::ShortRead) => return Err(DecodeError::BadLengthDescriptor),
3018 Err(e) => return Err(e),
3022 let mut excess_data = vec![];
3023 let excess_address_data = if addr_readpos < addr_len {
3024 let mut excess_address_data = vec![0; (addr_len - addr_readpos) as usize];
3025 r.read_exact(&mut excess_address_data[if excess { 1 } else { 0 }..])?;
3027 excess_address_data[0] = excess_byte;
3032 excess_data.push(excess_byte);
3036 excess_data.extend(read_to_end(r)?.iter());
3037 Ok(UnsignedNodeAnnouncement {
3044 excess_address_data,
3050 impl_writeable!(NodeAnnouncement, {
3055 impl Readable for QueryShortChannelIds {
3056 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
3057 let chain_hash: ChainHash = Readable::read(r)?;
3059 let encoding_len: u16 = Readable::read(r)?;
3060 let encoding_type: u8 = Readable::read(r)?;
3062 // Must be encoding_type=0 uncompressed serialization. We do not
3063 // support encoding_type=1 zlib serialization.
3064 if encoding_type != EncodingType::Uncompressed as u8 {
3065 return Err(DecodeError::UnsupportedCompression);
3068 // We expect the encoding_len to always includes the 1-byte
3069 // encoding_type and that short_channel_ids are 8-bytes each
3070 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
3071 return Err(DecodeError::InvalidValue);
3074 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
3075 // less the 1-byte encoding_type
3076 let short_channel_id_count: u16 = (encoding_len - 1)/8;
3077 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
3078 for _ in 0..short_channel_id_count {
3079 short_channel_ids.push(Readable::read(r)?);
3082 Ok(QueryShortChannelIds {
3089 impl Writeable for QueryShortChannelIds {
3090 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
3091 // Calculated from 1-byte encoding_type plus 8-bytes per short_channel_id
3092 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
3094 self.chain_hash.write(w)?;
3095 encoding_len.write(w)?;
3097 // We only support type=0 uncompressed serialization
3098 (EncodingType::Uncompressed as u8).write(w)?;
3100 for scid in self.short_channel_ids.iter() {
3108 impl_writeable_msg!(ReplyShortChannelIdsEnd, {
3113 impl QueryChannelRange {
3114 /// Calculates the overflow safe ending block height for the query.
3116 /// Overflow returns `0xffffffff`, otherwise returns `first_blocknum + number_of_blocks`.
3117 pub fn end_blocknum(&self) -> u32 {
3118 match self.first_blocknum.checked_add(self.number_of_blocks) {
3119 Some(block) => block,
3120 None => u32::max_value(),
3125 impl_writeable_msg!(QueryChannelRange, {
3131 impl Readable for ReplyChannelRange {
3132 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
3133 let chain_hash: ChainHash = Readable::read(r)?;
3134 let first_blocknum: u32 = Readable::read(r)?;
3135 let number_of_blocks: u32 = Readable::read(r)?;
3136 let sync_complete: bool = Readable::read(r)?;
3138 let encoding_len: u16 = Readable::read(r)?;
3139 let encoding_type: u8 = Readable::read(r)?;
3141 // Must be encoding_type=0 uncompressed serialization. We do not
3142 // support encoding_type=1 zlib serialization.
3143 if encoding_type != EncodingType::Uncompressed as u8 {
3144 return Err(DecodeError::UnsupportedCompression);
3147 // We expect the encoding_len to always includes the 1-byte
3148 // encoding_type and that short_channel_ids are 8-bytes each
3149 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
3150 return Err(DecodeError::InvalidValue);
3153 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
3154 // less the 1-byte encoding_type
3155 let short_channel_id_count: u16 = (encoding_len - 1)/8;
3156 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
3157 for _ in 0..short_channel_id_count {
3158 short_channel_ids.push(Readable::read(r)?);
3161 Ok(ReplyChannelRange {
3171 impl Writeable for ReplyChannelRange {
3172 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
3173 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
3174 self.chain_hash.write(w)?;
3175 self.first_blocknum.write(w)?;
3176 self.number_of_blocks.write(w)?;
3177 self.sync_complete.write(w)?;
3179 encoding_len.write(w)?;
3180 (EncodingType::Uncompressed as u8).write(w)?;
3181 for scid in self.short_channel_ids.iter() {
3189 impl_writeable_msg!(GossipTimestampFilter, {
3197 use bitcoin::{Amount, Transaction, TxIn, ScriptBuf, Sequence, Witness, TxOut};
3198 use hex::DisplayHex;
3199 use crate::ln::types::{ChannelId, PaymentPreimage, PaymentHash, PaymentSecret};
3200 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
3201 use crate::ln::msgs::{self, FinalOnionHopData, OnionErrorPacket, CommonOpenChannelFields, CommonAcceptChannelFields, TrampolineOnionPacket};
3202 use crate::ln::msgs::SocketAddress;
3203 use crate::routing::gossip::{NodeAlias, NodeId};
3204 use crate::util::ser::{BigSize, FixedLengthReader, Hostname, LengthReadable, Readable, ReadableArgs, TransactionU16LenLimited, Writeable};
3205 use crate::util::test_utils;
3207 use bitcoin::hashes::hex::FromHex;
3208 use bitcoin::address::Address;
3209 use bitcoin::network::Network;
3210 use bitcoin::blockdata::constants::ChainHash;
3211 use bitcoin::blockdata::script::Builder;
3212 use bitcoin::blockdata::opcodes;
3213 use bitcoin::hash_types::Txid;
3214 use bitcoin::locktime::absolute::LockTime;
3215 use bitcoin::transaction::Version;
3217 use bitcoin::secp256k1::{PublicKey,SecretKey};
3218 use bitcoin::secp256k1::{Secp256k1, Message};
3220 use crate::io::{self, Cursor};
3221 use crate::prelude::*;
3222 use core::str::FromStr;
3223 use crate::chain::transaction::OutPoint;
3225 #[cfg(feature = "std")]
3226 use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6, ToSocketAddrs};
3227 #[cfg(feature = "std")]
3228 use crate::ln::msgs::SocketAddressParseError;
3231 fn encoding_channel_reestablish() {
3233 let secp_ctx = Secp256k1::new();
3234 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&<Vec<u8>>::from_hex("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
3237 let cr = msgs::ChannelReestablish {
3238 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]),
3239 next_local_commitment_number: 3,
3240 next_remote_commitment_number: 4,
3241 your_last_per_commitment_secret: [9;32],
3242 my_current_per_commitment_point: public_key,
3243 next_funding_txid: None,
3246 let encoded_value = cr.encode();
3250 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
3251 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
3252 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
3253 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
3254 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 fn encoding_channel_reestablish_with_next_funding_txid() {
3262 let secp_ctx = Secp256k1::new();
3263 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&<Vec<u8>>::from_hex("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
3266 let cr = msgs::ChannelReestablish {
3267 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]),
3268 next_local_commitment_number: 3,
3269 next_remote_commitment_number: 4,
3270 your_last_per_commitment_secret: [9;32],
3271 my_current_per_commitment_point: public_key,
3272 next_funding_txid: Some(Txid::from_raw_hash(bitcoin::hashes::Hash::from_slice(&[
3273 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,
3277 let encoded_value = cr.encode();
3281 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
3282 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
3283 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
3284 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
3285 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
3286 0, // Type (next_funding_txid)
3288 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
3293 macro_rules! get_keys_from {
3294 ($slice: expr, $secp_ctx: expr) => {
3296 let privkey = SecretKey::from_slice(&<Vec<u8>>::from_hex($slice).unwrap()[..]).unwrap();
3297 let pubkey = PublicKey::from_secret_key(&$secp_ctx, &privkey);
3303 macro_rules! get_sig_on {
3304 ($privkey: expr, $ctx: expr, $string: expr) => {
3306 let sighash = Message::from_digest_slice(&$string.into_bytes()[..]).unwrap();
3307 $ctx.sign_ecdsa(&sighash, &$privkey)
3313 fn encoding_announcement_signatures() {
3314 let secp_ctx = Secp256k1::new();
3315 let (privkey, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3316 let sig_1 = get_sig_on!(privkey, secp_ctx, String::from("01010101010101010101010101010101"));
3317 let sig_2 = get_sig_on!(privkey, secp_ctx, String::from("02020202020202020202020202020202"));
3318 let announcement_signatures = msgs::AnnouncementSignatures {
3319 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]),
3320 short_channel_id: 2316138423780173,
3321 node_signature: sig_1,
3322 bitcoin_signature: sig_2,
3325 let encoded_value = announcement_signatures.encode();
3326 assert_eq!(encoded_value, <Vec<u8>>::from_hex("040000000000000005000000000000000600000000000000070000000000000000083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073acf9953cef4700860f5967838eba2bae89288ad188ebf8b20bf995c3ea53a26df1876d0a3a0e13172ba286a673140190c02ba9da60a2e43a745188c8a83c7f3ef").unwrap());
3329 fn do_encoding_channel_announcement(unknown_features_bits: bool, excess_data: bool) {
3330 let secp_ctx = Secp256k1::new();
3331 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3332 let (privkey_2, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3333 let (privkey_3, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3334 let (privkey_4, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3335 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3336 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
3337 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
3338 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
3339 let mut features = ChannelFeatures::empty();
3340 if unknown_features_bits {
3341 features = ChannelFeatures::from_le_bytes(vec![0xFF, 0xFF]);
3343 let unsigned_channel_announcement = msgs::UnsignedChannelAnnouncement {
3345 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3346 short_channel_id: 2316138423780173,
3347 node_id_1: NodeId::from_pubkey(&pubkey_1),
3348 node_id_2: NodeId::from_pubkey(&pubkey_2),
3349 bitcoin_key_1: NodeId::from_pubkey(&pubkey_3),
3350 bitcoin_key_2: NodeId::from_pubkey(&pubkey_4),
3351 excess_data: if excess_data { vec![10, 0, 0, 20, 0, 0, 30, 0, 0, 40] } else { Vec::new() },
3353 let channel_announcement = msgs::ChannelAnnouncement {
3354 node_signature_1: sig_1,
3355 node_signature_2: sig_2,
3356 bitcoin_signature_1: sig_3,
3357 bitcoin_signature_2: sig_4,
3358 contents: unsigned_channel_announcement,
3360 let encoded_value = channel_announcement.encode();
3361 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a1735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap();
3362 if unknown_features_bits {
3363 target_value.append(&mut <Vec<u8>>::from_hex("0002ffff").unwrap());
3365 target_value.append(&mut <Vec<u8>>::from_hex("0000").unwrap());
3367 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3368 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
3370 target_value.append(&mut <Vec<u8>>::from_hex("0a00001400001e000028").unwrap());
3372 assert_eq!(encoded_value, target_value);
3376 fn encoding_channel_announcement() {
3377 do_encoding_channel_announcement(true, false);
3378 do_encoding_channel_announcement(false, true);
3379 do_encoding_channel_announcement(false, false);
3380 do_encoding_channel_announcement(true, true);
3383 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) {
3384 let secp_ctx = Secp256k1::new();
3385 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3386 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3387 let features = if unknown_features_bits {
3388 NodeFeatures::from_le_bytes(vec![0xFF, 0xFF])
3390 // Set to some features we may support
3391 NodeFeatures::from_le_bytes(vec![2 | 1 << 5])
3393 let mut addresses = Vec::new();
3395 addresses.push(SocketAddress::TcpIpV4 {
3396 addr: [255, 254, 253, 252],
3401 addresses.push(SocketAddress::TcpIpV6 {
3402 addr: [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240],
3407 addresses.push(msgs::SocketAddress::OnionV2(
3408 [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 38, 7]
3412 addresses.push(msgs::SocketAddress::OnionV3 {
3413 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],
3420 addresses.push(SocketAddress::Hostname {
3421 hostname: Hostname::try_from(String::from("host")).unwrap(),
3425 let mut addr_len = 0;
3426 for addr in &addresses {
3427 addr_len += addr.len() + 1;
3429 let unsigned_node_announcement = msgs::UnsignedNodeAnnouncement {
3431 timestamp: 20190119,
3432 node_id: NodeId::from_pubkey(&pubkey_1),
3434 alias: NodeAlias([16;32]),
3436 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() },
3437 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() },
3439 addr_len += unsigned_node_announcement.excess_address_data.len() as u16;
3440 let node_announcement = msgs::NodeAnnouncement {
3442 contents: unsigned_node_announcement,
3444 let encoded_value = node_announcement.encode();
3445 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3446 if unknown_features_bits {
3447 target_value.append(&mut <Vec<u8>>::from_hex("0002ffff").unwrap());
3449 target_value.append(&mut <Vec<u8>>::from_hex("000122").unwrap());
3451 target_value.append(&mut <Vec<u8>>::from_hex("013413a7031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f2020201010101010101010101010101010101010101010101010101010101010101010").unwrap());
3452 target_value.append(&mut vec![(addr_len >> 8) as u8, addr_len as u8]);
3454 target_value.append(&mut <Vec<u8>>::from_hex("01fffefdfc2607").unwrap());
3457 target_value.append(&mut <Vec<u8>>::from_hex("02fffefdfcfbfaf9f8f7f6f5f4f3f2f1f02607").unwrap());
3460 target_value.append(&mut <Vec<u8>>::from_hex("03fffefdfcfbfaf9f8f7f62607").unwrap());
3463 target_value.append(&mut <Vec<u8>>::from_hex("04fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0efeeedecebeae9e8e7e6e5e4e3e2e1e00020102607").unwrap());
3466 target_value.append(&mut <Vec<u8>>::from_hex("0504686f73742607").unwrap());
3468 if excess_address_data {
3469 target_value.append(&mut <Vec<u8>>::from_hex("216c280b5395a2546e7e4b2663e04f811622f15a4f92e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d269").unwrap());
3472 target_value.append(&mut <Vec<u8>>::from_hex("3b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
3474 assert_eq!(encoded_value, target_value);
3478 fn encoding_node_announcement() {
3479 do_encoding_node_announcement(true, true, true, true, true, true, true, true);
3480 do_encoding_node_announcement(false, false, false, false, false, false, false, false);
3481 do_encoding_node_announcement(false, true, false, false, false, false, false, false);
3482 do_encoding_node_announcement(false, false, true, false, false, false, false, false);
3483 do_encoding_node_announcement(false, false, false, true, false, false, false, false);
3484 do_encoding_node_announcement(false, false, false, false, true, false, false, false);
3485 do_encoding_node_announcement(false, false, false, false, false, true, false, false);
3486 do_encoding_node_announcement(false, false, false, false, false, false, true, false);
3487 do_encoding_node_announcement(false, true, false, true, false, false, true, false);
3488 do_encoding_node_announcement(false, false, true, false, true, false, false, false);
3491 fn do_encoding_channel_update(direction: bool, disable: bool, excess_data: bool) {
3492 let secp_ctx = Secp256k1::new();
3493 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3494 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3495 let unsigned_channel_update = msgs::UnsignedChannelUpdate {
3496 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3497 short_channel_id: 2316138423780173,
3498 timestamp: 20190119,
3499 flags: if direction { 1 } else { 0 } | if disable { 1 << 1 } else { 0 },
3500 cltv_expiry_delta: 144,
3501 htlc_minimum_msat: 1000000,
3502 htlc_maximum_msat: 131355275467161,
3503 fee_base_msat: 10000,
3504 fee_proportional_millionths: 20,
3505 excess_data: if excess_data { vec![0, 0, 0, 0, 59, 154, 202, 0] } else { Vec::new() }
3507 let channel_update = msgs::ChannelUpdate {
3509 contents: unsigned_channel_update
3511 let encoded_value = channel_update.encode();
3512 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3513 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3514 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d013413a7").unwrap());
3515 target_value.append(&mut <Vec<u8>>::from_hex("01").unwrap());
3516 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3518 let flag = target_value.last_mut().unwrap();
3522 let flag = target_value.last_mut().unwrap();
3523 *flag = *flag | 1 << 1;
3525 target_value.append(&mut <Vec<u8>>::from_hex("009000000000000f42400000271000000014").unwrap());
3526 target_value.append(&mut <Vec<u8>>::from_hex("0000777788889999").unwrap());
3528 target_value.append(&mut <Vec<u8>>::from_hex("000000003b9aca00").unwrap());
3530 assert_eq!(encoded_value, target_value);
3534 fn encoding_channel_update() {
3535 do_encoding_channel_update(false, false, false);
3536 do_encoding_channel_update(false, false, true);
3537 do_encoding_channel_update(true, false, false);
3538 do_encoding_channel_update(true, false, true);
3539 do_encoding_channel_update(false, true, false);
3540 do_encoding_channel_update(false, true, true);
3541 do_encoding_channel_update(true, true, false);
3542 do_encoding_channel_update(true, true, true);
3545 fn do_encoding_open_channel(random_bit: bool, shutdown: bool, incl_chan_type: bool) {
3546 let secp_ctx = Secp256k1::new();
3547 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3548 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3549 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3550 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3551 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3552 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3553 let open_channel = msgs::OpenChannel {
3554 common_fields: CommonOpenChannelFields {
3555 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3556 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3557 funding_satoshis: 1311768467284833366,
3558 dust_limit_satoshis: 3608586615801332854,
3559 max_htlc_value_in_flight_msat: 8517154655701053848,
3560 htlc_minimum_msat: 2316138423780173,
3561 commitment_feerate_sat_per_1000_weight: 821716,
3562 to_self_delay: 49340,
3563 max_accepted_htlcs: 49340,
3564 funding_pubkey: pubkey_1,
3565 revocation_basepoint: pubkey_2,
3566 payment_basepoint: pubkey_3,
3567 delayed_payment_basepoint: pubkey_4,
3568 htlc_basepoint: pubkey_5,
3569 first_per_commitment_point: pubkey_6,
3570 channel_flags: if random_bit { 1 << 5 } else { 0 },
3571 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3572 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3574 push_msat: 2536655962884945560,
3575 channel_reserve_satoshis: 8665828695742877976,
3577 let encoded_value = open_channel.encode();
3578 let mut target_value = Vec::new();
3579 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3580 target_value.append(&mut <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202021234567890123456233403289122369832144668701144767633030896203198784335490624111800083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3582 target_value.append(&mut <Vec<u8>>::from_hex("20").unwrap());
3584 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3587 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3590 target_value.append(&mut <Vec<u8>>::from_hex("0100").unwrap());
3592 assert_eq!(encoded_value, target_value);
3596 fn encoding_open_channel() {
3597 do_encoding_open_channel(false, false, false);
3598 do_encoding_open_channel(false, false, true);
3599 do_encoding_open_channel(false, true, false);
3600 do_encoding_open_channel(false, true, true);
3601 do_encoding_open_channel(true, false, false);
3602 do_encoding_open_channel(true, false, true);
3603 do_encoding_open_channel(true, true, false);
3604 do_encoding_open_channel(true, true, true);
3607 fn do_encoding_open_channelv2(random_bit: bool, shutdown: bool, incl_chan_type: bool, require_confirmed_inputs: bool) {
3608 let secp_ctx = Secp256k1::new();
3609 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3610 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3611 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3612 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3613 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3614 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3615 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3616 let open_channelv2 = msgs::OpenChannelV2 {
3617 common_fields: CommonOpenChannelFields {
3618 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3619 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3620 commitment_feerate_sat_per_1000_weight: 821716,
3621 funding_satoshis: 1311768467284833366,
3622 dust_limit_satoshis: 3608586615801332854,
3623 max_htlc_value_in_flight_msat: 8517154655701053848,
3624 htlc_minimum_msat: 2316138423780173,
3625 to_self_delay: 49340,
3626 max_accepted_htlcs: 49340,
3627 funding_pubkey: pubkey_1,
3628 revocation_basepoint: pubkey_2,
3629 payment_basepoint: pubkey_3,
3630 delayed_payment_basepoint: pubkey_4,
3631 htlc_basepoint: pubkey_5,
3632 first_per_commitment_point: pubkey_6,
3633 channel_flags: if random_bit { 1 << 5 } else { 0 },
3634 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3635 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3637 funding_feerate_sat_per_1000_weight: 821716,
3638 locktime: 305419896,
3639 second_per_commitment_point: pubkey_7,
3640 require_confirmed_inputs: if require_confirmed_inputs { Some(()) } else { None },
3642 let encoded_value = open_channelv2.encode();
3643 let mut target_value = Vec::new();
3644 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3645 target_value.append(&mut <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap());
3646 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap());
3647 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap());
3648 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap());
3649 target_value.append(&mut <Vec<u8>>::from_hex("3214466870114476").unwrap());
3650 target_value.append(&mut <Vec<u8>>::from_hex("7633030896203198").unwrap());
3651 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d").unwrap());
3652 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap());
3653 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap());
3654 target_value.append(&mut <Vec<u8>>::from_hex("12345678").unwrap());
3655 target_value.append(&mut <Vec<u8>>::from_hex("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap());
3656 target_value.append(&mut <Vec<u8>>::from_hex("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap());
3657 target_value.append(&mut <Vec<u8>>::from_hex("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap());
3658 target_value.append(&mut <Vec<u8>>::from_hex("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
3659 target_value.append(&mut <Vec<u8>>::from_hex("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap());
3660 target_value.append(&mut <Vec<u8>>::from_hex("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3661 target_value.append(&mut <Vec<u8>>::from_hex("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap());
3664 target_value.append(&mut <Vec<u8>>::from_hex("20").unwrap());
3666 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3669 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3672 target_value.append(&mut <Vec<u8>>::from_hex("0100").unwrap());
3674 if require_confirmed_inputs {
3675 target_value.append(&mut <Vec<u8>>::from_hex("0200").unwrap());
3677 assert_eq!(encoded_value, target_value);
3681 fn encoding_open_channelv2() {
3682 do_encoding_open_channelv2(false, false, false, false);
3683 do_encoding_open_channelv2(false, false, false, true);
3684 do_encoding_open_channelv2(false, false, true, false);
3685 do_encoding_open_channelv2(false, false, true, true);
3686 do_encoding_open_channelv2(false, true, false, false);
3687 do_encoding_open_channelv2(false, true, false, true);
3688 do_encoding_open_channelv2(false, true, true, false);
3689 do_encoding_open_channelv2(false, true, true, true);
3690 do_encoding_open_channelv2(true, false, false, false);
3691 do_encoding_open_channelv2(true, false, false, true);
3692 do_encoding_open_channelv2(true, false, true, false);
3693 do_encoding_open_channelv2(true, false, true, true);
3694 do_encoding_open_channelv2(true, true, false, false);
3695 do_encoding_open_channelv2(true, true, false, true);
3696 do_encoding_open_channelv2(true, true, true, false);
3697 do_encoding_open_channelv2(true, true, true, true);
3700 fn do_encoding_accept_channel(shutdown: bool) {
3701 let secp_ctx = Secp256k1::new();
3702 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3703 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3704 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3705 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3706 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3707 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3708 let accept_channel = msgs::AcceptChannel {
3709 common_fields: CommonAcceptChannelFields {
3710 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3711 dust_limit_satoshis: 1311768467284833366,
3712 max_htlc_value_in_flight_msat: 2536655962884945560,
3713 htlc_minimum_msat: 2316138423780173,
3714 minimum_depth: 821716,
3715 to_self_delay: 49340,
3716 max_accepted_htlcs: 49340,
3717 funding_pubkey: pubkey_1,
3718 revocation_basepoint: pubkey_2,
3719 payment_basepoint: pubkey_3,
3720 delayed_payment_basepoint: pubkey_4,
3721 htlc_basepoint: pubkey_5,
3722 first_per_commitment_point: pubkey_6,
3723 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3726 channel_reserve_satoshis: 3608586615801332854,
3728 next_local_nonce: None,
3730 let encoded_value = accept_channel.encode();
3731 let mut target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020212345678901234562334032891223698321446687011447600083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap();
3733 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3735 assert_eq!(encoded_value, target_value);
3739 fn encoding_accept_channel() {
3740 do_encoding_accept_channel(false);
3741 do_encoding_accept_channel(true);
3744 fn do_encoding_accept_channelv2(shutdown: bool) {
3745 let secp_ctx = Secp256k1::new();
3746 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3747 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3748 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3749 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3750 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3751 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3752 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3753 let accept_channelv2 = msgs::AcceptChannelV2 {
3754 common_fields: CommonAcceptChannelFields {
3755 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3756 dust_limit_satoshis: 1311768467284833366,
3757 max_htlc_value_in_flight_msat: 2536655962884945560,
3758 htlc_minimum_msat: 2316138423780173,
3759 minimum_depth: 821716,
3760 to_self_delay: 49340,
3761 max_accepted_htlcs: 49340,
3762 funding_pubkey: pubkey_1,
3763 revocation_basepoint: pubkey_2,
3764 payment_basepoint: pubkey_3,
3765 delayed_payment_basepoint: pubkey_4,
3766 htlc_basepoint: pubkey_5,
3767 first_per_commitment_point: pubkey_6,
3768 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3771 funding_satoshis: 1311768467284833366,
3772 second_per_commitment_point: pubkey_7,
3773 require_confirmed_inputs: None,
3775 let encoded_value = accept_channelv2.encode();
3776 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // temporary_channel_id
3777 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap()); // funding_satoshis
3778 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap()); // dust_limit_satoshis
3779 target_value.append(&mut <Vec<u8>>::from_hex("2334032891223698").unwrap()); // max_htlc_value_in_flight_msat
3780 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d").unwrap()); // htlc_minimum_msat
3781 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap()); // minimum_depth
3782 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap()); // to_self_delay
3783 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap()); // max_accepted_htlcs
3784 target_value.append(&mut <Vec<u8>>::from_hex("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap()); // funding_pubkey
3785 target_value.append(&mut <Vec<u8>>::from_hex("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap()); // revocation_basepoint
3786 target_value.append(&mut <Vec<u8>>::from_hex("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap()); // payment_basepoint
3787 target_value.append(&mut <Vec<u8>>::from_hex("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap()); // delayed_payment_basepoint
3788 target_value.append(&mut <Vec<u8>>::from_hex("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap()); // htlc_basepoint
3789 target_value.append(&mut <Vec<u8>>::from_hex("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap()); // first_per_commitment_point
3790 target_value.append(&mut <Vec<u8>>::from_hex("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap()); // second_per_commitment_point
3792 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3794 assert_eq!(encoded_value, target_value);
3798 fn encoding_accept_channelv2() {
3799 do_encoding_accept_channelv2(false);
3800 do_encoding_accept_channelv2(true);
3804 fn encoding_funding_created() {
3805 let secp_ctx = Secp256k1::new();
3806 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3807 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3808 let funding_created = msgs::FundingCreated {
3809 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3810 funding_txid: Txid::from_str("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3811 funding_output_index: 255,
3814 partial_signature_with_nonce: None,
3816 next_local_nonce: None,
3818 let encoded_value = funding_created.encode();
3819 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202026e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c200ffd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3820 assert_eq!(encoded_value, target_value);
3824 fn encoding_funding_signed() {
3825 let secp_ctx = Secp256k1::new();
3826 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3827 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3828 let funding_signed = msgs::FundingSigned {
3829 channel_id: ChannelId::from_bytes([2; 32]),
3832 partial_signature_with_nonce: None,
3834 let encoded_value = funding_signed.encode();
3835 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3836 assert_eq!(encoded_value, target_value);
3840 fn encoding_channel_ready() {
3841 let secp_ctx = Secp256k1::new();
3842 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3843 let channel_ready = msgs::ChannelReady {
3844 channel_id: ChannelId::from_bytes([2; 32]),
3845 next_per_commitment_point: pubkey_1,
3846 short_channel_id_alias: None,
3848 let encoded_value = channel_ready.encode();
3849 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3850 assert_eq!(encoded_value, target_value);
3854 fn encoding_splice() {
3855 let secp_ctx = Secp256k1::new();
3856 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3857 let splice = msgs::Splice {
3858 chain_hash: ChainHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
3859 channel_id: ChannelId::from_bytes([2; 32]),
3860 relative_satoshis: 123456,
3861 funding_feerate_perkw: 2000,
3863 funding_pubkey: pubkey_1,
3865 let encoded_value = splice.encode();
3866 assert_eq!(encoded_value.as_hex().to_string(), "02020202020202020202020202020202020202020202020202020202020202026fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000000000000001e240000007d000000000031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f");
3870 fn encoding_stfu() {
3871 let stfu = msgs::Stfu {
3872 channel_id: ChannelId::from_bytes([2; 32]),
3875 let encoded_value = stfu.encode();
3876 assert_eq!(encoded_value.as_hex().to_string(), "020202020202020202020202020202020202020202020202020202020202020201");
3880 fn encoding_splice_ack() {
3881 let secp_ctx = Secp256k1::new();
3882 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3883 let splice = msgs::SpliceAck {
3884 chain_hash: ChainHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
3885 channel_id: ChannelId::from_bytes([2; 32]),
3886 relative_satoshis: 123456,
3887 funding_pubkey: pubkey_1,
3889 let encoded_value = splice.encode();
3890 assert_eq!(encoded_value.as_hex().to_string(), "02020202020202020202020202020202020202020202020202020202020202026fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000000000000001e240031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f");
3894 fn encoding_splice_locked() {
3895 let splice = msgs::SpliceLocked {
3896 channel_id: ChannelId::from_bytes([2; 32]),
3898 let encoded_value = splice.encode();
3899 assert_eq!(encoded_value.as_hex().to_string(), "0202020202020202020202020202020202020202020202020202020202020202");
3903 fn encoding_tx_add_input() {
3904 let tx_add_input = msgs::TxAddInput {
3905 channel_id: ChannelId::from_bytes([2; 32]),
3906 serial_id: 4886718345,
3907 prevtx: TransactionU16LenLimited::new(Transaction {
3908 version: Version::TWO,
3909 lock_time: LockTime::ZERO,
3911 previous_output: OutPoint { txid: Txid::from_str("305bab643ee297b8b6b76b320792c8223d55082122cb606bf89382146ced9c77").unwrap(), index: 2 }.into_bitcoin_outpoint(),
3912 script_sig: ScriptBuf::new(),
3913 sequence: Sequence(0xfffffffd),
3914 witness: Witness::from_slice(&vec![
3915 <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3916 <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3920 value: Amount::from_sat(12704566),
3921 script_pubkey: Address::from_str("bc1qzlffunw52jav8vwdu5x3jfk6sr8u22rmq3xzw2").unwrap().payload().script_pubkey(),
3924 value: Amount::from_sat(245148),
3925 script_pubkey: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().payload().script_pubkey(),
3929 prevtx_out: 305419896,
3930 sequence: 305419896,
3932 let encoded_value = tx_add_input.encode();
3933 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000000012345678900de02000000000101779ced6c148293f86b60cb222108553d22c89207326bb7b6b897e23e64ab5b300200000000fdffffff0236dbc1000000000016001417d29e4dd454bac3b1cde50d1926da80cfc5287b9cbd03000000000016001436ec78d514df462da95e6a00c24daa8915362d420247304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701210301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944000000001234567812345678").unwrap();
3934 assert_eq!(encoded_value, target_value);
3938 fn encoding_tx_add_output() {
3939 let tx_add_output = msgs::TxAddOutput {
3940 channel_id: ChannelId::from_bytes([2; 32]),
3941 serial_id: 4886718345,
3943 script: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().payload().script_pubkey(),
3945 let encoded_value = tx_add_output.encode();
3946 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000000012345678900000001234567890016001436ec78d514df462da95e6a00c24daa8915362d42").unwrap();
3947 assert_eq!(encoded_value, target_value);
3951 fn encoding_tx_remove_input() {
3952 let tx_remove_input = msgs::TxRemoveInput {
3953 channel_id: ChannelId::from_bytes([2; 32]),
3954 serial_id: 4886718345,
3956 let encoded_value = tx_remove_input.encode();
3957 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3958 assert_eq!(encoded_value, target_value);
3962 fn encoding_tx_remove_output() {
3963 let tx_remove_output = msgs::TxRemoveOutput {
3964 channel_id: ChannelId::from_bytes([2; 32]),
3965 serial_id: 4886718345,
3967 let encoded_value = tx_remove_output.encode();
3968 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3969 assert_eq!(encoded_value, target_value);
3973 fn encoding_tx_complete() {
3974 let tx_complete = msgs::TxComplete {
3975 channel_id: ChannelId::from_bytes([2; 32]),
3977 let encoded_value = tx_complete.encode();
3978 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3979 assert_eq!(encoded_value, target_value);
3983 fn encoding_tx_signatures() {
3984 let secp_ctx = Secp256k1::new();
3985 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3986 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3988 let tx_signatures = msgs::TxSignatures {
3989 channel_id: ChannelId::from_bytes([2; 32]),
3990 tx_hash: Txid::from_str("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3992 Witness::from_slice(&vec![
3993 <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3994 <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3995 Witness::from_slice(&vec![
3996 <Vec<u8>>::from_hex("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap(),
3997 <Vec<u8>>::from_hex("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap()]),
3999 funding_outpoint_sig: Some(sig_1),
4001 let encoded_value = tx_signatures.encode();
4002 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
4003 target_value.append(&mut <Vec<u8>>::from_hex("6e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c2").unwrap()); // tx_hash (sha256) (big endian byte order)
4004 target_value.append(&mut <Vec<u8>>::from_hex("0002").unwrap()); // num_witnesses (u16)
4006 target_value.append(&mut <Vec<u8>>::from_hex("006b").unwrap()); // len of witness_data
4007 target_value.append(&mut <Vec<u8>>::from_hex("02").unwrap()); // num_witness_elements (VarInt)
4008 target_value.append(&mut <Vec<u8>>::from_hex("47").unwrap()); // len of witness element data (VarInt)
4009 target_value.append(&mut <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap());
4010 target_value.append(&mut <Vec<u8>>::from_hex("21").unwrap()); // len of witness element data (VarInt)
4011 target_value.append(&mut <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap());
4013 target_value.append(&mut <Vec<u8>>::from_hex("006c").unwrap()); // len of witness_data
4014 target_value.append(&mut <Vec<u8>>::from_hex("02").unwrap()); // num_witness_elements (VarInt)
4015 target_value.append(&mut <Vec<u8>>::from_hex("48").unwrap()); // len of witness element data (VarInt)
4016 target_value.append(&mut <Vec<u8>>::from_hex("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap());
4017 target_value.append(&mut <Vec<u8>>::from_hex("21").unwrap()); // len of witness element data (VarInt)
4018 target_value.append(&mut <Vec<u8>>::from_hex("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap());
4019 target_value.append(&mut <Vec<u8>>::from_hex("0040").unwrap()); // type and len (64)
4020 target_value.append(&mut <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap());
4021 assert_eq!(encoded_value, target_value);
4024 fn do_encoding_tx_init_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
4025 let tx_init_rbf = msgs::TxInitRbf {
4026 channel_id: ChannelId::from_bytes([2; 32]),
4027 locktime: 305419896,
4028 feerate_sat_per_1000_weight: 20190119,
4029 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
4031 let encoded_value = tx_init_rbf.encode();
4032 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
4033 target_value.append(&mut <Vec<u8>>::from_hex("12345678").unwrap()); // locktime
4034 target_value.append(&mut <Vec<u8>>::from_hex("013413a7").unwrap()); // feerate_sat_per_1000_weight
4035 if let Some((_, target)) = funding_value_with_hex_target {
4036 target_value.push(0x00); // Type
4037 target_value.push(target.len() as u8 / 2); // Length
4038 target_value.append(&mut <Vec<u8>>::from_hex(target).unwrap()); // Value (i64)
4040 assert_eq!(encoded_value, target_value);
4044 fn encoding_tx_init_rbf() {
4045 do_encoding_tx_init_rbf(Some((1311768467284833366, "1234567890123456")));
4046 do_encoding_tx_init_rbf(Some((13117684672, "000000030DDFFBC0")));
4047 do_encoding_tx_init_rbf(None);
4050 fn do_encoding_tx_ack_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
4051 let tx_ack_rbf = msgs::TxAckRbf {
4052 channel_id: ChannelId::from_bytes([2; 32]),
4053 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
4055 let encoded_value = tx_ack_rbf.encode();
4056 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
4057 if let Some((_, target)) = funding_value_with_hex_target {
4058 target_value.push(0x00); // Type
4059 target_value.push(target.len() as u8 / 2); // Length
4060 target_value.append(&mut <Vec<u8>>::from_hex(target).unwrap()); // Value (i64)
4062 assert_eq!(encoded_value, target_value);
4066 fn encoding_tx_ack_rbf() {
4067 do_encoding_tx_ack_rbf(Some((1311768467284833366, "1234567890123456")));
4068 do_encoding_tx_ack_rbf(Some((13117684672, "000000030DDFFBC0")));
4069 do_encoding_tx_ack_rbf(None);
4073 fn encoding_tx_abort() {
4074 let tx_abort = msgs::TxAbort {
4075 channel_id: ChannelId::from_bytes([2; 32]),
4076 data: <Vec<u8>>::from_hex("54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap(),
4078 let encoded_value = tx_abort.encode();
4079 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202002C54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap();
4080 assert_eq!(encoded_value, target_value);
4083 fn do_encoding_shutdown(script_type: u8) {
4084 let secp_ctx = Secp256k1::new();
4085 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4086 let script = Builder::new().push_opcode(opcodes::OP_TRUE).into_script();
4087 let shutdown = msgs::Shutdown {
4088 channel_id: ChannelId::from_bytes([2; 32]),
4090 if script_type == 1 { Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey() }
4091 else if script_type == 2 { Address::p2sh(&script, Network::Testnet).unwrap().script_pubkey() }
4092 else if script_type == 3 { Address::p2wpkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).unwrap().script_pubkey() }
4093 else { Address::p2wsh(&script, Network::Testnet).script_pubkey() },
4095 let encoded_value = shutdown.encode();
4096 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
4097 if script_type == 1 {
4098 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
4099 } else if script_type == 2 {
4100 target_value.append(&mut <Vec<u8>>::from_hex("0017a914da1745e9b549bd0bfa1a569971c77eba30cd5a4b87").unwrap());
4101 } else if script_type == 3 {
4102 target_value.append(&mut <Vec<u8>>::from_hex("0016001479b000887626b294a914501a4cd226b58b235983").unwrap());
4103 } else if script_type == 4 {
4104 target_value.append(&mut <Vec<u8>>::from_hex("002200204ae81572f06e1b88fd5ced7a1a000945432e83e1551e6f721ee9c00b8cc33260").unwrap());
4106 assert_eq!(encoded_value, target_value);
4110 fn encoding_shutdown() {
4111 do_encoding_shutdown(1);
4112 do_encoding_shutdown(2);
4113 do_encoding_shutdown(3);
4114 do_encoding_shutdown(4);
4118 fn encoding_closing_signed() {
4119 let secp_ctx = Secp256k1::new();
4120 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4121 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
4122 let closing_signed = msgs::ClosingSigned {
4123 channel_id: ChannelId::from_bytes([2; 32]),
4124 fee_satoshis: 2316138423780173,
4128 let encoded_value = closing_signed.encode();
4129 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
4130 assert_eq!(encoded_value, target_value);
4131 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value)).unwrap(), closing_signed);
4133 let closing_signed_with_range = msgs::ClosingSigned {
4134 channel_id: ChannelId::from_bytes([2; 32]),
4135 fee_satoshis: 2316138423780173,
4137 fee_range: Some(msgs::ClosingSignedFeeRange {
4138 min_fee_satoshis: 0xdeadbeef,
4139 max_fee_satoshis: 0x1badcafe01234567,
4142 let encoded_value_with_range = closing_signed_with_range.encode();
4143 let target_value_with_range = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a011000000000deadbeef1badcafe01234567").unwrap();
4144 assert_eq!(encoded_value_with_range, target_value_with_range);
4145 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value_with_range)).unwrap(),
4146 closing_signed_with_range);
4150 fn encoding_update_add_htlc() {
4151 let secp_ctx = Secp256k1::new();
4152 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4153 let onion_routing_packet = msgs::OnionPacket {
4155 public_key: Ok(pubkey_1),
4156 hop_data: [1; 20*65],
4159 let update_add_htlc = msgs::UpdateAddHTLC {
4160 channel_id: ChannelId::from_bytes([2; 32]),
4161 htlc_id: 2316138423780173,
4162 amount_msat: 3608586615801332854,
4163 payment_hash: PaymentHash([1; 32]),
4164 cltv_expiry: 821716,
4165 onion_routing_packet,
4166 skimmed_fee_msat: None,
4167 blinding_point: None,
4169 let encoded_value = update_add_htlc.encode();
4170 let target_value = <Vec<u8>>::from_hex("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").unwrap();
4171 assert_eq!(encoded_value, target_value);
4175 fn encoding_update_fulfill_htlc() {
4176 let update_fulfill_htlc = msgs::UpdateFulfillHTLC {
4177 channel_id: ChannelId::from_bytes([2; 32]),
4178 htlc_id: 2316138423780173,
4179 payment_preimage: PaymentPreimage([1; 32]),
4181 let encoded_value = update_fulfill_htlc.encode();
4182 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d0101010101010101010101010101010101010101010101010101010101010101").unwrap();
4183 assert_eq!(encoded_value, target_value);
4187 fn encoding_update_fail_htlc() {
4188 let reason = OnionErrorPacket {
4189 data: [1; 32].to_vec(),
4191 let update_fail_htlc = msgs::UpdateFailHTLC {
4192 channel_id: ChannelId::from_bytes([2; 32]),
4193 htlc_id: 2316138423780173,
4196 let encoded_value = update_fail_htlc.encode();
4197 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d00200101010101010101010101010101010101010101010101010101010101010101").unwrap();
4198 assert_eq!(encoded_value, target_value);
4202 fn encoding_update_fail_malformed_htlc() {
4203 let update_fail_malformed_htlc = msgs::UpdateFailMalformedHTLC {
4204 channel_id: ChannelId::from_bytes([2; 32]),
4205 htlc_id: 2316138423780173,
4206 sha256_of_onion: [1; 32],
4209 let encoded_value = update_fail_malformed_htlc.encode();
4210 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d010101010101010101010101010101010101010101010101010101010101010100ff").unwrap();
4211 assert_eq!(encoded_value, target_value);
4214 fn do_encoding_commitment_signed(htlcs: bool) {
4215 let secp_ctx = Secp256k1::new();
4216 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4217 let (privkey_2, _) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
4218 let (privkey_3, _) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
4219 let (privkey_4, _) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
4220 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
4221 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
4222 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
4223 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
4224 let commitment_signed = msgs::CommitmentSigned {
4225 channel_id: ChannelId::from_bytes([2; 32]),
4227 htlc_signatures: if htlcs { vec![sig_2, sig_3, sig_4] } else { Vec::new() },
4229 partial_signature_with_nonce: None,
4231 let encoded_value = commitment_signed.encode();
4232 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
4234 target_value.append(&mut <Vec<u8>>::from_hex("00031735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
4236 target_value.append(&mut <Vec<u8>>::from_hex("0000").unwrap());
4238 assert_eq!(encoded_value, target_value);
4242 fn encoding_commitment_signed() {
4243 do_encoding_commitment_signed(true);
4244 do_encoding_commitment_signed(false);
4248 fn encoding_revoke_and_ack() {
4249 let secp_ctx = Secp256k1::new();
4250 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4251 let raa = msgs::RevokeAndACK {
4252 channel_id: ChannelId::from_bytes([2; 32]),
4253 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],
4254 next_per_commitment_point: pubkey_1,
4256 next_local_nonce: None,
4258 let encoded_value = raa.encode();
4259 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020101010101010101010101010101010101010101010101010101010101010101031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
4260 assert_eq!(encoded_value, target_value);
4264 fn encoding_update_fee() {
4265 let update_fee = msgs::UpdateFee {
4266 channel_id: ChannelId::from_bytes([2; 32]),
4267 feerate_per_kw: 20190119,
4269 let encoded_value = update_fee.encode();
4270 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202013413a7").unwrap();
4271 assert_eq!(encoded_value, target_value);
4275 fn encoding_init() {
4276 let mainnet_hash = ChainHash::using_genesis_block(Network::Bitcoin);
4277 assert_eq!(msgs::Init {
4278 features: InitFeatures::from_le_bytes(vec![0xFF, 0xFF, 0xFF]),
4279 networks: Some(vec![mainnet_hash]),
4280 remote_network_address: None,
4281 }.encode(), <Vec<u8>>::from_hex("00023fff0003ffffff01206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
4282 assert_eq!(msgs::Init {
4283 features: InitFeatures::from_le_bytes(vec![0xFF]),
4285 remote_network_address: None,
4286 }.encode(), <Vec<u8>>::from_hex("0001ff0001ff").unwrap());
4287 assert_eq!(msgs::Init {
4288 features: InitFeatures::from_le_bytes(vec![]),
4289 networks: Some(vec![mainnet_hash]),
4290 remote_network_address: None,
4291 }.encode(), <Vec<u8>>::from_hex("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
4292 assert_eq!(msgs::Init {
4293 features: InitFeatures::from_le_bytes(vec![]),
4294 networks: Some(vec![ChainHash::from(&[1; 32]), ChainHash::from(&[2; 32])]),
4295 remote_network_address: None,
4296 }.encode(), <Vec<u8>>::from_hex("00000000014001010101010101010101010101010101010101010101010101010101010101010202020202020202020202020202020202020202020202020202020202020202").unwrap());
4297 let init_msg = msgs::Init { features: InitFeatures::from_le_bytes(vec![]),
4298 networks: Some(vec![mainnet_hash]),
4299 remote_network_address: Some(SocketAddress::TcpIpV4 {
4300 addr: [127, 0, 0, 1],
4304 let encoded_value = init_msg.encode();
4305 let target_value = <Vec<u8>>::from_hex("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d61900000000000307017f00000103e8").unwrap();
4306 assert_eq!(encoded_value, target_value);
4307 assert_eq!(msgs::Init::read(&mut Cursor::new(&target_value)).unwrap(), init_msg);
4311 fn encoding_error() {
4312 let error = msgs::ErrorMessage {
4313 channel_id: ChannelId::from_bytes([2; 32]),
4314 data: String::from("rust-lightning"),
4316 let encoded_value = error.encode();
4317 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
4318 assert_eq!(encoded_value, target_value);
4322 fn encoding_warning() {
4323 let error = msgs::WarningMessage {
4324 channel_id: ChannelId::from_bytes([2; 32]),
4325 data: String::from("rust-lightning"),
4327 let encoded_value = error.encode();
4328 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
4329 assert_eq!(encoded_value, target_value);
4333 fn encoding_ping() {
4334 let ping = msgs::Ping {
4338 let encoded_value = ping.encode();
4339 let target_value = <Vec<u8>>::from_hex("0040004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
4340 assert_eq!(encoded_value, target_value);
4344 fn encoding_pong() {
4345 let pong = msgs::Pong {
4348 let encoded_value = pong.encode();
4349 let target_value = <Vec<u8>>::from_hex("004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
4350 assert_eq!(encoded_value, target_value);
4354 fn encoding_nonfinal_onion_hop_data() {
4355 let outbound_msg = msgs::OutboundOnionPayload::Forward {
4356 short_channel_id: 0xdeadbeef1bad1dea,
4357 amt_to_forward: 0x0badf00d01020304,
4358 outgoing_cltv_value: 0xffffffff,
4360 let encoded_value = outbound_msg.encode();
4361 let target_value = <Vec<u8>>::from_hex("1a02080badf00d010203040404ffffffff0608deadbeef1bad1dea").unwrap();
4362 assert_eq!(encoded_value, target_value);
4364 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4365 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4366 if let msgs::InboundOnionPayload::Forward {
4367 short_channel_id, amt_to_forward, outgoing_cltv_value
4369 assert_eq!(short_channel_id, 0xdeadbeef1bad1dea);
4370 assert_eq!(amt_to_forward, 0x0badf00d01020304);
4371 assert_eq!(outgoing_cltv_value, 0xffffffff);
4372 } else { panic!(); }
4376 fn encoding_final_onion_hop_data() {
4377 let outbound_msg = msgs::OutboundOnionPayload::Receive {
4379 payment_metadata: None,
4380 keysend_preimage: None,
4381 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4382 cltv_expiry_height: 0xffffffff,
4383 custom_tlvs: &vec![],
4385 let encoded_value = outbound_msg.encode();
4386 let target_value = <Vec<u8>>::from_hex("1002080badf00d010203040404ffffffff").unwrap();
4387 assert_eq!(encoded_value, target_value);
4389 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4390 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4391 if let msgs::InboundOnionPayload::Receive {
4392 payment_data: None, sender_intended_htlc_amt_msat, cltv_expiry_height, ..
4394 assert_eq!(sender_intended_htlc_amt_msat, 0x0badf00d01020304);
4395 assert_eq!(cltv_expiry_height, 0xffffffff);
4396 } else { panic!(); }
4400 fn encoding_final_onion_hop_data_with_secret() {
4401 let expected_payment_secret = PaymentSecret([0x42u8; 32]);
4402 let outbound_msg = msgs::OutboundOnionPayload::Receive {
4403 payment_data: Some(FinalOnionHopData {
4404 payment_secret: expected_payment_secret,
4405 total_msat: 0x1badca1f
4407 payment_metadata: None,
4408 keysend_preimage: None,
4409 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4410 cltv_expiry_height: 0xffffffff,
4411 custom_tlvs: &vec![],
4413 let encoded_value = outbound_msg.encode();
4414 let target_value = <Vec<u8>>::from_hex("3602080badf00d010203040404ffffffff082442424242424242424242424242424242424242424242424242424242424242421badca1f").unwrap();
4415 assert_eq!(encoded_value, target_value);
4417 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4418 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4419 if let msgs::InboundOnionPayload::Receive {
4420 payment_data: Some(FinalOnionHopData {
4422 total_msat: 0x1badca1f
4424 sender_intended_htlc_amt_msat, cltv_expiry_height,
4425 payment_metadata: None,
4426 keysend_preimage: None,
4429 assert_eq!(payment_secret, expected_payment_secret);
4430 assert_eq!(sender_intended_htlc_amt_msat, 0x0badf00d01020304);
4431 assert_eq!(cltv_expiry_height, 0xffffffff);
4432 assert_eq!(custom_tlvs, vec![]);
4433 } else { panic!(); }
4437 fn encoding_final_onion_hop_data_with_bad_custom_tlvs() {
4438 // If custom TLVs have type number within the range reserved for protocol, treat them as if
4440 let bad_type_range_tlvs = vec![
4441 ((1 << 16) - 4, vec![42]),
4442 ((1 << 16) - 2, vec![42; 32]),
4444 let mut msg = msgs::OutboundOnionPayload::Receive {
4446 payment_metadata: None,
4447 keysend_preimage: None,
4448 custom_tlvs: &bad_type_range_tlvs,
4449 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4450 cltv_expiry_height: 0xffffffff,
4452 let encoded_value = msg.encode();
4453 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4454 assert!(msgs::InboundOnionPayload::read(&mut Cursor::new(&encoded_value[..]), (None, &&node_signer)).is_err());
4455 let good_type_range_tlvs = vec![
4456 ((1 << 16) - 3, vec![42]),
4457 ((1 << 16) - 1, vec![42; 32]),
4459 if let msgs::OutboundOnionPayload::Receive { ref mut custom_tlvs, .. } = msg {
4460 *custom_tlvs = &good_type_range_tlvs;
4462 let encoded_value = msg.encode();
4463 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&encoded_value[..]), (None, &&node_signer)).unwrap();
4465 msgs::InboundOnionPayload::Receive { custom_tlvs, .. } => assert!(custom_tlvs.is_empty()),
4471 fn encoding_final_onion_hop_data_with_custom_tlvs() {
4472 let expected_custom_tlvs = vec![
4473 (5482373483, vec![0x12, 0x34]),
4474 (5482373487, vec![0x42u8; 8]),
4476 let msg = msgs::OutboundOnionPayload::Receive {
4478 payment_metadata: None,
4479 keysend_preimage: None,
4480 custom_tlvs: &expected_custom_tlvs,
4481 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4482 cltv_expiry_height: 0xffffffff,
4484 let encoded_value = msg.encode();
4485 let target_value = <Vec<u8>>::from_hex("2e02080badf00d010203040404ffffffffff0000000146c6616b021234ff0000000146c6616f084242424242424242").unwrap();
4486 assert_eq!(encoded_value, target_value);
4487 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4488 let inbound_msg: msgs::InboundOnionPayload = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4489 if let msgs::InboundOnionPayload::Receive {
4491 payment_metadata: None,
4492 keysend_preimage: None,
4494 sender_intended_htlc_amt_msat,
4495 cltv_expiry_height: outgoing_cltv_value,
4498 assert_eq!(custom_tlvs, expected_custom_tlvs);
4499 assert_eq!(sender_intended_htlc_amt_msat, 0x0badf00d01020304);
4500 assert_eq!(outgoing_cltv_value, 0xffffffff);
4501 } else { panic!(); }
4505 fn encoding_final_onion_hop_data_with_trampoline_packet() {
4506 let secp_ctx = Secp256k1::new();
4507 let (_private_key, public_key) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4509 let compressed_public_key = public_key.serialize();
4510 assert_eq!(compressed_public_key.len(), 33);
4512 let trampoline_packet = TrampolineOnionPacket {
4515 hop_data: vec![1; 650], // this should be the standard encoded length
4518 let encoded_trampoline_packet = trampoline_packet.encode();
4519 assert_eq!(encoded_trampoline_packet.len(), 716);
4521 { // verify that a codec round trip works
4522 let mut reader = Cursor::new(&encoded_trampoline_packet);
4523 let mut trampoline_packet_reader = FixedLengthReader::new(&mut reader, encoded_trampoline_packet.len() as u64);
4524 let decoded_trampoline_packet: TrampolineOnionPacket = <TrampolineOnionPacket as LengthReadable>::read(&mut trampoline_packet_reader).unwrap();
4525 assert_eq!(decoded_trampoline_packet.encode(), encoded_trampoline_packet);
4528 let msg = msgs::OutboundOnionPayload::TrampolineEntrypoint {
4529 multipath_trampoline_data: None,
4530 amt_to_forward: 0x0badf00d01020304,
4531 outgoing_cltv_value: 0xffffffff,
4534 let encoded_payload = msg.encode();
4536 let trampoline_type_bytes = &encoded_payload[19..=19];
4537 let mut trampoline_type_cursor = Cursor::new(trampoline_type_bytes);
4538 let trampoline_type_big_size: BigSize = Readable::read(&mut trampoline_type_cursor).unwrap();
4539 assert_eq!(trampoline_type_big_size.0, 20);
4541 let trampoline_length_bytes = &encoded_payload[20..=22];
4542 let mut trampoline_length_cursor = Cursor::new(trampoline_length_bytes);
4543 let trampoline_length_big_size: BigSize = Readable::read(&mut trampoline_length_cursor).unwrap();
4544 assert_eq!(trampoline_length_big_size.0, encoded_trampoline_packet.len() as u64);
4548 fn encoding_final_onion_hop_data_with_eclair_trampoline_packet() {
4549 let public_key = PublicKey::from_slice(&<Vec<u8>>::from_hex("02eec7245d6b7d2ccb30380bfbe2a3648cd7a942653f5aa340edcea1f283686619").unwrap()).unwrap();
4550 let hop_data = <Vec<u8>>::from_hex("cff34152f3a36e52ca94e74927203a560392b9cc7ce3c45809c6be52166c24a595716880f95f178bf5b30ca63141f74db6e92795c6130877cfdac3d4bd3087ee73c65d627ddd709112a848cc99e303f3706509aa43ba7c8a88cba175fccf9a8f5016ef06d3b935dbb15196d7ce16dc1a7157845566901d7b2197e52cab4ce487014b14816e5805f9fcacb4f8f88b8ff176f1b94f6ce6b00bc43221130c17d20ef629db7c5f7eafaa166578c720619561dd14b3277db557ec7dcdb793771aef0f2f667cfdbeae3ac8d331c5994779dffb31e5fc0dbdedc0c592ca6d21c18e47fe3528d6975c19517d7e2ea8c5391cf17d0fe30c80913ed887234ccb48808f7ef9425bcd815c3b586210979e3bb286ef2851bf9ce04e28c40a203df98fd648d2f1936fd2f1def0e77eecb277229b4b682322371c0a1dbfcd723a991993df8cc1f2696b84b055b40a1792a29f710295a18fbd351b0f3ff34cd13941131b8278ba79303c89117120eea691738a9954908195143b039dbeed98f26a92585f3d15cf742c953799d3272e0545e9b744be9d3b4c").unwrap();
4551 let hmac_vector = <Vec<u8>>::from_hex("bb079bfc4b35190eee9f59a1d7b41ba2f773179f322dafb4b1af900c289ebd6c").unwrap();
4552 let mut hmac = [0; 32];
4553 hmac.copy_from_slice(&hmac_vector);
4555 let compressed_public_key = public_key.serialize();
4556 assert_eq!(compressed_public_key.len(), 33);
4558 let trampoline_packet = TrampolineOnionPacket {
4564 let encoded_trampoline_packet = trampoline_packet.encode();
4565 let expected_eclair_trampoline_packet = <Vec<u8>>::from_hex("0002eec7245d6b7d2ccb30380bfbe2a3648cd7a942653f5aa340edcea1f283686619cff34152f3a36e52ca94e74927203a560392b9cc7ce3c45809c6be52166c24a595716880f95f178bf5b30ca63141f74db6e92795c6130877cfdac3d4bd3087ee73c65d627ddd709112a848cc99e303f3706509aa43ba7c8a88cba175fccf9a8f5016ef06d3b935dbb15196d7ce16dc1a7157845566901d7b2197e52cab4ce487014b14816e5805f9fcacb4f8f88b8ff176f1b94f6ce6b00bc43221130c17d20ef629db7c5f7eafaa166578c720619561dd14b3277db557ec7dcdb793771aef0f2f667cfdbeae3ac8d331c5994779dffb31e5fc0dbdedc0c592ca6d21c18e47fe3528d6975c19517d7e2ea8c5391cf17d0fe30c80913ed887234ccb48808f7ef9425bcd815c3b586210979e3bb286ef2851bf9ce04e28c40a203df98fd648d2f1936fd2f1def0e77eecb277229b4b682322371c0a1dbfcd723a991993df8cc1f2696b84b055b40a1792a29f710295a18fbd351b0f3ff34cd13941131b8278ba79303c89117120eea691738a9954908195143b039dbeed98f26a92585f3d15cf742c953799d3272e0545e9b744be9d3b4cbb079bfc4b35190eee9f59a1d7b41ba2f773179f322dafb4b1af900c289ebd6c").unwrap();
4566 assert_eq!(encoded_trampoline_packet, expected_eclair_trampoline_packet);
4570 fn query_channel_range_end_blocknum() {
4571 let tests: Vec<(u32, u32, u32)> = vec![
4572 (10000, 1500, 11500),
4573 (0, 0xffffffff, 0xffffffff),
4574 (1, 0xffffffff, 0xffffffff),
4577 for (first_blocknum, number_of_blocks, expected) in tests.into_iter() {
4578 let sut = msgs::QueryChannelRange {
4579 chain_hash: ChainHash::using_genesis_block(Network::Regtest),
4583 assert_eq!(sut.end_blocknum(), expected);
4588 fn encoding_query_channel_range() {
4589 let mut query_channel_range = msgs::QueryChannelRange {
4590 chain_hash: ChainHash::using_genesis_block(Network::Regtest),
4591 first_blocknum: 100000,
4592 number_of_blocks: 1500,
4594 let encoded_value = query_channel_range.encode();
4595 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000186a0000005dc").unwrap();
4596 assert_eq!(encoded_value, target_value);
4598 query_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4599 assert_eq!(query_channel_range.first_blocknum, 100000);
4600 assert_eq!(query_channel_range.number_of_blocks, 1500);
4604 fn encoding_reply_channel_range() {
4605 do_encoding_reply_channel_range(0);
4606 do_encoding_reply_channel_range(1);
4609 fn do_encoding_reply_channel_range(encoding_type: u8) {
4610 let mut target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000b8a06000005dc01").unwrap();
4611 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4612 let mut reply_channel_range = msgs::ReplyChannelRange {
4613 chain_hash: expected_chain_hash,
4614 first_blocknum: 756230,
4615 number_of_blocks: 1500,
4616 sync_complete: true,
4617 short_channel_ids: vec![0x000000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
4620 if encoding_type == 0 {
4621 target_value.append(&mut <Vec<u8>>::from_hex("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
4622 let encoded_value = reply_channel_range.encode();
4623 assert_eq!(encoded_value, target_value);
4625 reply_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4626 assert_eq!(reply_channel_range.chain_hash, expected_chain_hash);
4627 assert_eq!(reply_channel_range.first_blocknum, 756230);
4628 assert_eq!(reply_channel_range.number_of_blocks, 1500);
4629 assert_eq!(reply_channel_range.sync_complete, true);
4630 assert_eq!(reply_channel_range.short_channel_ids[0], 0x000000000000008e);
4631 assert_eq!(reply_channel_range.short_channel_ids[1], 0x0000000000003c69);
4632 assert_eq!(reply_channel_range.short_channel_ids[2], 0x000000000045a6c4);
4634 target_value.append(&mut <Vec<u8>>::from_hex("001601789c636000833e08659309a65878be010010a9023a").unwrap());
4635 let result: Result<msgs::ReplyChannelRange, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
4636 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
4641 fn encoding_query_short_channel_ids() {
4642 do_encoding_query_short_channel_ids(0);
4643 do_encoding_query_short_channel_ids(1);
4646 fn do_encoding_query_short_channel_ids(encoding_type: u8) {
4647 let mut target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
4648 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4649 let mut query_short_channel_ids = msgs::QueryShortChannelIds {
4650 chain_hash: expected_chain_hash,
4651 short_channel_ids: vec![0x0000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
4654 if encoding_type == 0 {
4655 target_value.append(&mut <Vec<u8>>::from_hex("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
4656 let encoded_value = query_short_channel_ids.encode();
4657 assert_eq!(encoded_value, target_value);
4659 query_short_channel_ids = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4660 assert_eq!(query_short_channel_ids.chain_hash, expected_chain_hash);
4661 assert_eq!(query_short_channel_ids.short_channel_ids[0], 0x000000000000008e);
4662 assert_eq!(query_short_channel_ids.short_channel_ids[1], 0x0000000000003c69);
4663 assert_eq!(query_short_channel_ids.short_channel_ids[2], 0x000000000045a6c4);
4665 target_value.append(&mut <Vec<u8>>::from_hex("001601789c636000833e08659309a65878be010010a9023a").unwrap());
4666 let result: Result<msgs::QueryShortChannelIds, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
4667 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
4672 fn encoding_reply_short_channel_ids_end() {
4673 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4674 let mut reply_short_channel_ids_end = msgs::ReplyShortChannelIdsEnd {
4675 chain_hash: expected_chain_hash,
4676 full_information: true,
4678 let encoded_value = reply_short_channel_ids_end.encode();
4679 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f01").unwrap();
4680 assert_eq!(encoded_value, target_value);
4682 reply_short_channel_ids_end = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4683 assert_eq!(reply_short_channel_ids_end.chain_hash, expected_chain_hash);
4684 assert_eq!(reply_short_channel_ids_end.full_information, true);
4688 fn encoding_gossip_timestamp_filter(){
4689 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4690 let mut gossip_timestamp_filter = msgs::GossipTimestampFilter {
4691 chain_hash: expected_chain_hash,
4692 first_timestamp: 1590000000,
4693 timestamp_range: 0xffff_ffff,
4695 let encoded_value = gossip_timestamp_filter.encode();
4696 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f5ec57980ffffffff").unwrap();
4697 assert_eq!(encoded_value, target_value);
4699 gossip_timestamp_filter = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4700 assert_eq!(gossip_timestamp_filter.chain_hash, expected_chain_hash);
4701 assert_eq!(gossip_timestamp_filter.first_timestamp, 1590000000);
4702 assert_eq!(gossip_timestamp_filter.timestamp_range, 0xffff_ffff);
4706 fn decode_onion_hop_data_len_as_bigsize() {
4707 // Tests that we can decode an onion payload that is >253 bytes.
4708 // Previously, receiving a payload of this size could've caused us to fail to decode a valid
4709 // payload, because we were decoding the length (a BigSize, big-endian) as a VarInt
4712 // Encode a test onion payload with a big custom TLV such that it's >253 bytes, forcing the
4713 // payload length to be encoded over multiple bytes rather than a single u8.
4714 let big_payload = encode_big_payload().unwrap();
4715 let mut rd = Cursor::new(&big_payload[..]);
4717 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4718 <msgs::InboundOnionPayload as ReadableArgs<(Option<PublicKey>, &&test_utils::TestKeysInterface)>>
4719 ::read(&mut rd, (None, &&node_signer)).unwrap();
4721 // see above test, needs to be a separate method for use of the serialization macros.
4722 fn encode_big_payload() -> Result<Vec<u8>, io::Error> {
4723 use crate::util::ser::HighZeroBytesDroppedBigSize;
4724 let payload = msgs::OutboundOnionPayload::Forward {
4725 short_channel_id: 0xdeadbeef1bad1dea,
4726 amt_to_forward: 1000,
4727 outgoing_cltv_value: 0xffffffff,
4729 let mut encoded_payload = Vec::new();
4730 let test_bytes = vec![42u8; 1000];
4731 if let msgs::OutboundOnionPayload::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } = payload {
4732 _encode_varint_length_prefixed_tlv!(&mut encoded_payload, {
4733 (1, test_bytes, required_vec),
4734 (2, HighZeroBytesDroppedBigSize(amt_to_forward), required),
4735 (4, HighZeroBytesDroppedBigSize(outgoing_cltv_value), required),
4736 (6, short_channel_id, required)
4743 #[cfg(feature = "std")]
4744 fn test_socket_address_from_str() {
4745 let tcpip_v4 = SocketAddress::TcpIpV4 {
4746 addr: Ipv4Addr::new(127, 0, 0, 1).octets(),
4749 assert_eq!(tcpip_v4, SocketAddress::from_str("127.0.0.1:1234").unwrap());
4750 assert_eq!(tcpip_v4, SocketAddress::from_str(&tcpip_v4.to_string()).unwrap());
4752 let tcpip_v6 = SocketAddress::TcpIpV6 {
4753 addr: Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1).octets(),
4756 assert_eq!(tcpip_v6, SocketAddress::from_str("[0:0:0:0:0:0:0:1]:1234").unwrap());
4757 assert_eq!(tcpip_v6, SocketAddress::from_str(&tcpip_v6.to_string()).unwrap());
4759 let hostname = SocketAddress::Hostname {
4760 hostname: Hostname::try_from("lightning-node.mydomain.com".to_string()).unwrap(),
4763 assert_eq!(hostname, SocketAddress::from_str("lightning-node.mydomain.com:1234").unwrap());
4764 assert_eq!(hostname, SocketAddress::from_str(&hostname.to_string()).unwrap());
4766 let onion_v2 = SocketAddress::OnionV2 ([40, 4, 64, 185, 202, 19, 162, 75, 90, 200, 38, 7],);
4767 assert_eq!("OnionV2([40, 4, 64, 185, 202, 19, 162, 75, 90, 200, 38, 7])", &onion_v2.to_string());
4768 assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("FACEBOOKCOREWWWI.onion:9735"));
4770 let onion_v3 = SocketAddress::OnionV3 {
4771 ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102, 182, 107, 4, 105, 247, 246, 85,
4772 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31, 33, 71, 3],
4777 assert_eq!(onion_v3, SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion:1234").unwrap());
4778 assert_eq!(onion_v3, SocketAddress::from_str(&onion_v3.to_string()).unwrap());
4780 assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6.onion:1234"));
4781 assert_eq!(Err(SocketAddressParseError::InvalidInput), SocketAddress::from_str("127.0.0.1@1234"));
4782 assert_eq!(Err(SocketAddressParseError::InvalidInput), "".parse::<SocketAddress>());
4783 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:9735:94").is_err());
4784 assert!(SocketAddress::from_str("wrong$%#.com:1234").is_err());
4785 assert_eq!(Err(SocketAddressParseError::InvalidPort), SocketAddress::from_str("example.com:wrong"));
4786 assert!("localhost".parse::<SocketAddress>().is_err());
4787 assert!("localhost:invalid-port".parse::<SocketAddress>().is_err());
4788 assert!( "invalid-onion-v3-hostname.onion:8080".parse::<SocketAddress>().is_err());
4789 assert!("b32.example.onion:invalid-port".parse::<SocketAddress>().is_err());
4790 assert!("invalid-address".parse::<SocketAddress>().is_err());
4791 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:1234").is_err());
4795 #[cfg(feature = "std")]
4796 fn test_socket_address_to_socket_addrs() {
4797 assert_eq!(SocketAddress::TcpIpV4 {addr:[0u8; 4], port: 1337,}.to_socket_addrs().unwrap().next().unwrap(),
4798 SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(0,0,0,0), 1337)));
4799 assert_eq!(SocketAddress::TcpIpV6 {addr:[0u8; 16], port: 1337,}.to_socket_addrs().unwrap().next().unwrap(),
4800 SocketAddr::V6(SocketAddrV6::new(Ipv6Addr::from([0u8; 16]), 1337, 0, 0)));
4801 assert_eq!(SocketAddress::Hostname { hostname: Hostname::try_from("0.0.0.0".to_string()).unwrap(), port: 0 }
4802 .to_socket_addrs().unwrap().next().unwrap(), SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::from([0u8; 4]),0)));
4803 assert!(SocketAddress::OnionV2([0u8; 12]).to_socket_addrs().is_err());
4804 assert!(SocketAddress::OnionV3{ ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102,
4805 182, 107, 4, 105, 247, 246, 85, 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31,
4809 port: 1234 }.to_socket_addrs().is_err());