1 // This file is Copyright its original authors, visible in version control
4 // This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
5 // or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
6 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
7 // You may not use this file except in accordance with one or both of these
10 //! Wire messages, traits representing wire message handlers, and a few error types live here.
12 //! For a normal node you probably don't need to use anything here, however, if you wish to split a
13 //! node into an internet-facing route/message socket handling daemon and a separate daemon (or
14 //! server entirely) which handles only channel-related messages you may wish to implement
15 //! [`ChannelMessageHandler`] yourself and use it to re-serialize messages and pass them across
18 //! Note that if you go with such an architecture (instead of passing raw socket events to a
19 //! non-internet-facing system) you trust the frontend internet-facing system to not lie about the
20 //! source `node_id` of the message, however this does allow you to significantly reduce bandwidth
21 //! between the systems as routing messages can represent a significant chunk of bandwidth usage
22 //! (especially for non-channel-publicly-announcing nodes). As an alternate design which avoids
23 //! this issue, if you have sufficient bidirectional bandwidth between your systems, you may send
24 //! raw socket events into your non-internet-facing system and then send routing events back to
25 //! track the network on the less-secure system.
27 use bitcoin::blockdata::constants::ChainHash;
28 use bitcoin::secp256k1::PublicKey;
29 use bitcoin::secp256k1::ecdsa::Signature;
30 use bitcoin::{secp256k1, Witness};
31 use bitcoin::blockdata::script::ScriptBuf;
32 use bitcoin::hash_types::Txid;
34 use crate::blinded_path::payment::{BlindedPaymentTlvs, ForwardTlvs, ReceiveTlvs};
35 use crate::ln::{ChannelId, PaymentPreimage, PaymentHash, PaymentSecret};
36 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
37 use crate::ln::onion_utils;
38 use crate::onion_message;
39 use crate::sign::{NodeSigner, Recipient};
41 #[allow(unused_imports)]
42 use crate::prelude::*;
47 #[cfg(feature = "std")]
48 use core::str::FromStr;
49 #[cfg(feature = "std")]
50 use std::net::SocketAddr;
51 use core::fmt::Display;
52 use crate::io::{self, Cursor, Read};
53 use crate::io_extras::read_to_end;
55 use crate::events::{EventsProvider, MessageSendEventsProvider};
56 use crate::crypto::streams::ChaChaPolyReadAdapter;
57 use crate::util::logger;
58 use crate::util::ser::{LengthReadable, LengthReadableArgs, Readable, ReadableArgs, Writeable, Writer, WithoutLength, FixedLengthReader, HighZeroBytesDroppedBigSize, Hostname, TransactionU16LenLimited, BigSize};
59 use crate::util::base32;
61 use crate::routing::gossip::{NodeAlias, NodeId};
63 /// 21 million * 10^8 * 1000
64 pub(crate) const MAX_VALUE_MSAT: u64 = 21_000_000_0000_0000_000;
67 /// A partial signature that also contains the Musig2 nonce its signer used
68 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
69 pub struct PartialSignatureWithNonce(pub musig2::types::PartialSignature, pub musig2::types::PublicNonce);
71 /// An error in decoding a message or struct.
72 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
73 pub enum DecodeError {
74 /// A version byte specified something we don't know how to handle.
76 /// Includes unknown realm byte in an onion hop data packet.
78 /// Unknown feature mandating we fail to parse message (e.g., TLV with an even, unknown type)
79 UnknownRequiredFeature,
80 /// Value was invalid.
82 /// For example, a byte which was supposed to be a bool was something other than a 0
83 /// or 1, a public key/private key/signature was invalid, text wasn't UTF-8, TLV was
84 /// syntactically incorrect, etc.
86 /// The buffer to be read was too short.
88 /// A length descriptor in the packet didn't describe the later data correctly.
90 /// Error from [`std::io`].
92 /// The message included zlib-compressed values, which we don't support.
93 UnsupportedCompression,
94 /// Value is validly encoded but is dangerous to use.
96 /// This is used for things like [`ChannelManager`] deserialization where we want to ensure
97 /// that we don't use a [`ChannelManager`] which is in out of sync with the [`ChannelMonitor`].
98 /// This indicates that there is a critical implementation flaw in the storage implementation
99 /// and it's unsafe to continue.
101 /// [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
102 /// [`ChannelMonitor`]: crate::chain::channelmonitor::ChannelMonitor
106 /// An [`init`] message to be sent to or received from a peer.
108 /// [`init`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-init-message
109 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
111 /// The relevant features which the sender supports.
112 pub features: InitFeatures,
113 /// Indicates chains the sender is interested in.
115 /// If there are no common chains, the connection will be closed.
116 pub networks: Option<Vec<ChainHash>>,
117 /// The receipient's network address.
119 /// This adds the option to report a remote IP address back to a connecting peer using the init
120 /// message. A node can decide to use that information to discover a potential update to its
121 /// public IPv4 address (NAT) and use that for a [`NodeAnnouncement`] update message containing
123 pub remote_network_address: Option<SocketAddress>,
126 /// An [`error`] message to be sent to or received from a peer.
128 /// [`error`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-error-and-warning-messages
129 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
130 pub struct ErrorMessage {
131 /// The channel ID involved in the error.
133 /// All-0s indicates a general error unrelated to a specific channel, after which all channels
134 /// with the sending peer should be closed.
135 pub channel_id: ChannelId,
136 /// A possibly human-readable error description.
138 /// The string should be sanitized before it is used (e.g., emitted to logs or printed to
139 /// `stdout`). Otherwise, a well crafted error message may trigger a security vulnerability in
140 /// the terminal emulator or the logging subsystem.
144 /// A [`warning`] message to be sent to or received from a peer.
146 /// [`warning`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-error-and-warning-messages
147 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
148 pub struct WarningMessage {
149 /// The channel ID involved in the warning.
151 /// All-0s indicates a warning unrelated to a specific channel.
152 pub channel_id: ChannelId,
153 /// A possibly human-readable warning description.
155 /// The string should be sanitized before it is used (e.g. emitted to logs or printed to
156 /// stdout). Otherwise, a well crafted error message may trigger a security vulnerability in
157 /// the terminal emulator or the logging subsystem.
161 /// A [`ping`] message to be sent to or received from a peer.
163 /// [`ping`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-ping-and-pong-messages
164 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
166 /// The desired response length.
168 /// The ping packet size.
170 /// This field is not sent on the wire. byteslen zeros are sent.
174 /// A [`pong`] message to be sent to or received from a peer.
176 /// [`pong`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-ping-and-pong-messages
177 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
179 /// The pong packet size.
181 /// This field is not sent on the wire. byteslen zeros are sent.
185 /// Contains fields that are both common to [`open_channel`] and `open_channel2` messages.
187 /// [`open_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-open_channel-message
188 // TODO(dual_funding): Add spec link for `open_channel2`.
189 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
190 pub struct CommonOpenChannelFields {
191 /// The genesis hash of the blockchain where the channel is to be opened
192 pub chain_hash: ChainHash,
193 /// A temporary channel ID
194 /// For V2 channels: derived using a zeroed out value for the channel acceptor's revocation basepoint
195 /// For V1 channels: a temporary channel ID, until the funding outpoint is announced
196 pub temporary_channel_id: ChannelId,
197 /// For V1 channels: The channel value
198 /// For V2 channels: Part of the channel value contributed by the channel initiator
199 pub funding_satoshis: u64,
200 /// The threshold below which outputs on transactions broadcast by the channel initiator will be
202 pub dust_limit_satoshis: u64,
203 /// The maximum inbound HTLC value in flight towards channel initiator, in milli-satoshi
204 pub max_htlc_value_in_flight_msat: u64,
205 /// The minimum HTLC size incoming to channel initiator, in milli-satoshi
206 pub htlc_minimum_msat: u64,
207 /// The feerate for the commitment transaction set by the channel initiator until updated by
209 pub commitment_feerate_sat_per_1000_weight: u32,
210 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
211 /// broadcast a commitment transaction
212 pub to_self_delay: u16,
213 /// The maximum number of inbound HTLCs towards channel initiator
214 pub max_accepted_htlcs: u16,
215 /// The channel initiator's key controlling the funding transaction
216 pub funding_pubkey: PublicKey,
217 /// Used to derive a revocation key for transactions broadcast by counterparty
218 pub revocation_basepoint: PublicKey,
219 /// A payment key to channel initiator for transactions broadcast by counterparty
220 pub payment_basepoint: PublicKey,
221 /// Used to derive a payment key to channel initiator for transactions broadcast by channel
223 pub delayed_payment_basepoint: PublicKey,
224 /// Used to derive an HTLC payment key to channel initiator
225 pub htlc_basepoint: PublicKey,
226 /// The first to-be-broadcast-by-channel-initiator transaction's per commitment point
227 pub first_per_commitment_point: PublicKey,
228 /// The channel flags to be used
229 pub channel_flags: u8,
230 /// Optionally, a request to pre-set the to-channel-initiator output's scriptPubkey for when we
231 /// collaboratively close
232 pub shutdown_scriptpubkey: Option<ScriptBuf>,
233 /// The channel type that this channel will represent
235 /// If this is `None`, we derive the channel type from the intersection of our
236 /// feature bits with our counterparty's feature bits from the [`Init`] message.
237 pub channel_type: Option<ChannelTypeFeatures>,
240 /// An [`open_channel`] message to be sent to or received from a peer.
242 /// Used in V1 channel establishment
244 /// [`open_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-open_channel-message
245 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
246 pub struct OpenChannel {
247 /// Common fields of `open_channel(2)`-like messages
248 pub common_fields: CommonOpenChannelFields,
249 /// The amount to push to the counterparty as part of the open, in milli-satoshi
251 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
252 pub channel_reserve_satoshis: u64,
255 /// An open_channel2 message to be sent by or received from the channel initiator.
257 /// Used in V2 channel establishment
259 // TODO(dual_funding): Add spec link for `open_channel2`.
260 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
261 pub struct OpenChannelV2 {
262 /// Common fields of `open_channel(2)`-like messages
263 pub common_fields: CommonOpenChannelFields,
264 /// The feerate for the funding transaction set by the channel initiator
265 pub funding_feerate_sat_per_1000_weight: u32,
266 /// The locktime for the funding transaction
268 /// The second to-be-broadcast-by-channel-initiator transaction's per commitment point
269 pub second_per_commitment_point: PublicKey,
270 /// Optionally, a requirement that only confirmed inputs can be added
271 pub require_confirmed_inputs: Option<()>,
274 /// Contains fields that are both common to [`accept_channel`] and `accept_channel2` messages.
276 /// [`accept_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-accept_channel-message
277 // TODO(dual_funding): Add spec link for `accept_channel2`.
278 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
279 pub struct CommonAcceptChannelFields {
280 /// The same `temporary_channel_id` received from the initiator's `open_channel2` or `open_channel` message.
281 pub temporary_channel_id: ChannelId,
282 /// The threshold below which outputs on transactions broadcast by the channel acceptor will be
284 pub dust_limit_satoshis: u64,
285 /// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
286 pub max_htlc_value_in_flight_msat: u64,
287 /// The minimum HTLC size incoming to channel acceptor, in milli-satoshi
288 pub htlc_minimum_msat: u64,
289 /// Minimum depth of the funding transaction before the channel is considered open
290 pub minimum_depth: u32,
291 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
292 /// broadcast a commitment transaction
293 pub to_self_delay: u16,
294 /// The maximum number of inbound HTLCs towards channel acceptor
295 pub max_accepted_htlcs: u16,
296 /// The channel acceptor's key controlling the funding transaction
297 pub funding_pubkey: PublicKey,
298 /// Used to derive a revocation key for transactions broadcast by counterparty
299 pub revocation_basepoint: PublicKey,
300 /// A payment key to channel acceptor for transactions broadcast by counterparty
301 pub payment_basepoint: PublicKey,
302 /// Used to derive a payment key to channel acceptor for transactions broadcast by channel
304 pub delayed_payment_basepoint: PublicKey,
305 /// Used to derive an HTLC payment key to channel acceptor for transactions broadcast by counterparty
306 pub htlc_basepoint: PublicKey,
307 /// The first to-be-broadcast-by-channel-acceptor transaction's per commitment point
308 pub first_per_commitment_point: PublicKey,
309 /// Optionally, a request to pre-set the to-channel-acceptor output's scriptPubkey for when we
310 /// collaboratively close
311 pub shutdown_scriptpubkey: Option<ScriptBuf>,
312 /// The channel type that this channel will represent. If none is set, we derive the channel
313 /// type from the intersection of our feature bits with our counterparty's feature bits from
314 /// the Init message.
316 /// This is required to match the equivalent field in [`OpenChannel`] or [`OpenChannelV2`]'s
317 /// [`CommonOpenChannelFields::channel_type`].
318 pub channel_type: Option<ChannelTypeFeatures>,
321 /// An [`accept_channel`] message to be sent to or received from a peer.
323 /// Used in V1 channel establishment
325 /// [`accept_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-accept_channel-message
326 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
327 pub struct AcceptChannel {
328 /// Common fields of `accept_channel(2)`-like messages
329 pub common_fields: CommonAcceptChannelFields,
330 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
331 pub channel_reserve_satoshis: u64,
333 /// Next nonce the channel initiator should use to create a funding output signature against
334 pub next_local_nonce: Option<musig2::types::PublicNonce>,
337 /// An accept_channel2 message to be sent by or received from the channel accepter.
339 /// Used in V2 channel establishment
341 // TODO(dual_funding): Add spec link for `accept_channel2`.
342 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
343 pub struct AcceptChannelV2 {
344 /// Common fields of `accept_channel(2)`-like messages
345 pub common_fields: CommonAcceptChannelFields,
346 /// Part of the channel value contributed by the channel acceptor
347 pub funding_satoshis: u64,
348 /// The second to-be-broadcast-by-channel-acceptor transaction's per commitment point
349 pub second_per_commitment_point: PublicKey,
350 /// Optionally, a requirement that only confirmed inputs can be added
351 pub require_confirmed_inputs: Option<()>,
354 /// A [`funding_created`] message to be sent to or received from a peer.
356 /// Used in V1 channel establishment
358 /// [`funding_created`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-funding_created-message
359 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
360 pub struct FundingCreated {
361 /// A temporary channel ID, until the funding is established
362 pub temporary_channel_id: ChannelId,
363 /// The funding transaction ID
364 pub funding_txid: Txid,
365 /// The specific output index funding this channel
366 pub funding_output_index: u16,
367 /// The signature of the channel initiator (funder) on the initial commitment transaction
368 pub signature: Signature,
370 /// The partial signature of the channel initiator (funder)
371 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
373 /// Next nonce the channel acceptor should use to finalize the funding output signature
374 pub next_local_nonce: Option<musig2::types::PublicNonce>
377 /// A [`funding_signed`] message to be sent to or received from a peer.
379 /// Used in V1 channel establishment
381 /// [`funding_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-funding_signed-message
382 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
383 pub struct FundingSigned {
385 pub channel_id: ChannelId,
386 /// The signature of the channel acceptor (fundee) on the initial commitment transaction
387 pub signature: Signature,
389 /// The partial signature of the channel acceptor (fundee)
390 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
393 /// A [`channel_ready`] message to be sent to or received from a peer.
395 /// [`channel_ready`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-channel_ready-message
396 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
397 pub struct ChannelReady {
399 pub channel_id: ChannelId,
400 /// The per-commitment point of the second commitment transaction
401 pub next_per_commitment_point: PublicKey,
402 /// If set, provides a `short_channel_id` alias for this channel.
404 /// The sender will accept payments to be forwarded over this SCID and forward them to this
405 /// messages' recipient.
406 pub short_channel_id_alias: Option<u64>,
409 /// A randomly chosen number that is used to identify inputs within an interactive transaction
411 pub type SerialId = u64;
413 /// An stfu (quiescence) message to be sent by or received from the stfu initiator.
414 // TODO(splicing): Add spec link for `stfu`; still in draft, using from https://github.com/lightning/bolts/pull/863
415 #[derive(Clone, Debug, PartialEq, Eq)]
417 /// The channel ID where quiescence is intended
418 pub channel_id: ChannelId,
419 /// Initiator flag, 1 if initiating, 0 if replying to an stfu.
423 /// A splice message to be sent by or received from the stfu initiator (splice initiator).
424 // TODO(splicing): Add spec link for `splice`; still in draft, using from https://github.com/lightning/bolts/pull/863
425 #[derive(Clone, Debug, PartialEq, Eq)]
427 /// The channel ID where splicing is intended
428 pub channel_id: ChannelId,
429 /// The genesis hash of the blockchain where the channel is intended to be spliced
430 pub chain_hash: ChainHash,
431 /// The intended change in channel capacity: the amount to be added (positive value)
432 /// or removed (negative value) by the sender (splice initiator) by splicing into/from the channel.
433 pub relative_satoshis: i64,
434 /// The feerate for the new funding transaction, set by the splice initiator
435 pub funding_feerate_perkw: u32,
436 /// The locktime for the new funding transaction
438 /// The key of the sender (splice initiator) controlling the new funding transaction
439 pub funding_pubkey: PublicKey,
442 /// A splice_ack message to be received by or sent to the splice initiator.
444 // TODO(splicing): Add spec link for `splice_ack`; still in draft, using from https://github.com/lightning/bolts/pull/863
445 #[derive(Clone, Debug, PartialEq, Eq)]
446 pub struct SpliceAck {
447 /// The channel ID where splicing is intended
448 pub channel_id: ChannelId,
449 /// The genesis hash of the blockchain where the channel is intended to be spliced
450 pub chain_hash: ChainHash,
451 /// The intended change in channel capacity: the amount to be added (positive value)
452 /// or removed (negative value) by the sender (splice acceptor) by splicing into/from the channel.
453 pub relative_satoshis: i64,
454 /// The key of the sender (splice acceptor) controlling the new funding transaction
455 pub funding_pubkey: PublicKey,
458 /// A splice_locked message to be sent to or received from a peer.
460 // TODO(splicing): Add spec link for `splice_locked`; still in draft, using from https://github.com/lightning/bolts/pull/863
461 #[derive(Clone, Debug, PartialEq, Eq)]
462 pub struct SpliceLocked {
464 pub channel_id: ChannelId,
467 /// A tx_add_input message for adding an input during interactive transaction construction
469 // TODO(dual_funding): Add spec link for `tx_add_input`.
470 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
471 pub struct TxAddInput {
473 pub channel_id: ChannelId,
474 /// A randomly chosen unique identifier for this input, which is even for initiators and odd for
476 pub serial_id: SerialId,
477 /// Serialized transaction that contains the output this input spends to verify that it is non
479 pub prevtx: TransactionU16LenLimited,
480 /// The index of the output being spent
482 /// The sequence number of this input
486 /// A tx_add_output message for adding an output during interactive transaction construction.
488 // TODO(dual_funding): Add spec link for `tx_add_output`.
489 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
490 pub struct TxAddOutput {
492 pub channel_id: ChannelId,
493 /// A randomly chosen unique identifier for this output, which is even for initiators and odd for
495 pub serial_id: SerialId,
496 /// The satoshi value of the output
498 /// The scriptPubKey for the output
499 pub script: ScriptBuf,
502 /// A tx_remove_input message for removing an input during interactive transaction construction.
504 // TODO(dual_funding): Add spec link for `tx_remove_input`.
505 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
506 pub struct TxRemoveInput {
508 pub channel_id: ChannelId,
509 /// The serial ID of the input to be removed
510 pub serial_id: SerialId,
513 /// A tx_remove_output message for removing an output during interactive transaction construction.
515 // TODO(dual_funding): Add spec link for `tx_remove_output`.
516 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
517 pub struct TxRemoveOutput {
519 pub channel_id: ChannelId,
520 /// The serial ID of the output to be removed
521 pub serial_id: SerialId,
524 /// A tx_complete message signalling the conclusion of a peer's transaction contributions during
525 /// interactive transaction construction.
527 // TODO(dual_funding): Add spec link for `tx_complete`.
528 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
529 pub struct TxComplete {
531 pub channel_id: ChannelId,
534 /// A tx_signatures message containing the sender's signatures for a transaction constructed with
535 /// interactive transaction construction.
537 // TODO(dual_funding): Add spec link for `tx_signatures`.
538 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
539 pub struct TxSignatures {
541 pub channel_id: ChannelId,
544 /// The list of witnesses
545 pub witnesses: Vec<Witness>,
548 /// A tx_init_rbf message which initiates a replacement of the transaction after it's been
551 // TODO(dual_funding): Add spec link for `tx_init_rbf`.
552 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
553 pub struct TxInitRbf {
555 pub channel_id: ChannelId,
556 /// The locktime of the transaction
558 /// The feerate of the transaction
559 pub feerate_sat_per_1000_weight: u32,
560 /// The number of satoshis the sender will contribute to or, if negative, remove from
561 /// (e.g. splice-out) the funding output of the transaction
562 pub funding_output_contribution: Option<i64>,
565 /// A tx_ack_rbf message which acknowledges replacement of the transaction after it's been
568 // TODO(dual_funding): Add spec link for `tx_ack_rbf`.
569 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
570 pub struct TxAckRbf {
572 pub channel_id: ChannelId,
573 /// The number of satoshis the sender will contribute to or, if negative, remove from
574 /// (e.g. splice-out) the funding output of the transaction
575 pub funding_output_contribution: Option<i64>,
578 /// A tx_abort message which signals the cancellation of an in-progress transaction negotiation.
580 // TODO(dual_funding): Add spec link for `tx_abort`.
581 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
584 pub channel_id: ChannelId,
589 /// A [`shutdown`] message to be sent to or received from a peer.
591 /// [`shutdown`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-initiation-shutdown
592 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
593 pub struct Shutdown {
595 pub channel_id: ChannelId,
596 /// The destination of this peer's funds on closing.
598 /// Must be in one of these forms: P2PKH, P2SH, P2WPKH, P2WSH, P2TR.
599 pub scriptpubkey: ScriptBuf,
602 /// The minimum and maximum fees which the sender is willing to place on the closing transaction.
604 /// This is provided in [`ClosingSigned`] by both sides to indicate the fee range they are willing
606 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
607 pub struct ClosingSignedFeeRange {
608 /// The minimum absolute fee, in satoshis, which the sender is willing to place on the closing
610 pub min_fee_satoshis: u64,
611 /// The maximum absolute fee, in satoshis, which the sender is willing to place on the closing
613 pub max_fee_satoshis: u64,
616 /// A [`closing_signed`] message to be sent to or received from a peer.
618 /// [`closing_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-negotiation-closing_signed
619 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
620 pub struct ClosingSigned {
622 pub channel_id: ChannelId,
623 /// The proposed total fee for the closing transaction
624 pub fee_satoshis: u64,
625 /// A signature on the closing transaction
626 pub signature: Signature,
627 /// The minimum and maximum fees which the sender is willing to accept, provided only by new
629 pub fee_range: Option<ClosingSignedFeeRange>,
632 /// An [`update_add_htlc`] message to be sent to or received from a peer.
634 /// [`update_add_htlc`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#adding-an-htlc-update_add_htlc
635 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
636 pub struct UpdateAddHTLC {
638 pub channel_id: ChannelId,
641 /// The HTLC value in milli-satoshi
642 pub amount_msat: u64,
643 /// The payment hash, the pre-image of which controls HTLC redemption
644 pub payment_hash: PaymentHash,
645 /// The expiry height of the HTLC
646 pub cltv_expiry: u32,
647 /// The extra fee skimmed by the sender of this message. See
648 /// [`ChannelConfig::accept_underpaying_htlcs`].
650 /// [`ChannelConfig::accept_underpaying_htlcs`]: crate::util::config::ChannelConfig::accept_underpaying_htlcs
651 pub skimmed_fee_msat: Option<u64>,
652 /// The onion routing packet with encrypted data for the next hop.
653 pub onion_routing_packet: OnionPacket,
654 /// Provided if we are relaying or receiving a payment within a blinded path, to decrypt the onion
655 /// routing packet and the recipient-provided encrypted payload within.
656 pub blinding_point: Option<PublicKey>,
659 /// An onion message to be sent to or received from a peer.
661 // TODO: update with link to OM when they are merged into the BOLTs
662 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
663 pub struct OnionMessage {
664 /// Used in decrypting the onion packet's payload.
665 pub blinding_point: PublicKey,
666 /// The full onion packet including hop data, pubkey, and hmac
667 pub onion_routing_packet: onion_message::packet::Packet,
670 /// An [`update_fulfill_htlc`] message to be sent to or received from a peer.
672 /// [`update_fulfill_htlc`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#removing-an-htlc-update_fulfill_htlc-update_fail_htlc-and-update_fail_malformed_htlc
673 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
674 pub struct UpdateFulfillHTLC {
676 pub channel_id: ChannelId,
679 /// The pre-image of the payment hash, allowing HTLC redemption
680 pub payment_preimage: PaymentPreimage,
683 /// An [`update_fail_htlc`] message to be sent to or received from a peer.
685 /// [`update_fail_htlc`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#removing-an-htlc-update_fulfill_htlc-update_fail_htlc-and-update_fail_malformed_htlc
686 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
687 pub struct UpdateFailHTLC {
689 pub channel_id: ChannelId,
692 pub(crate) reason: OnionErrorPacket,
695 /// An [`update_fail_malformed_htlc`] message to be sent to or received from a peer.
697 /// [`update_fail_malformed_htlc`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#removing-an-htlc-update_fulfill_htlc-update_fail_htlc-and-update_fail_malformed_htlc
698 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
699 pub struct UpdateFailMalformedHTLC {
701 pub channel_id: ChannelId,
704 pub(crate) sha256_of_onion: [u8; 32],
706 pub failure_code: u16,
709 /// A [`commitment_signed`] message to be sent to or received from a peer.
711 /// [`commitment_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#committing-updates-so-far-commitment_signed
712 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
713 pub struct CommitmentSigned {
715 pub channel_id: ChannelId,
716 /// A signature on the commitment transaction
717 pub signature: Signature,
718 /// Signatures on the HTLC transactions
719 pub htlc_signatures: Vec<Signature>,
721 /// The partial Taproot signature on the commitment transaction
722 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
725 /// A [`revoke_and_ack`] message to be sent to or received from a peer.
727 /// [`revoke_and_ack`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#completing-the-transition-to-the-updated-state-revoke_and_ack
728 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
729 pub struct RevokeAndACK {
731 pub channel_id: ChannelId,
732 /// The secret corresponding to the per-commitment point
733 pub per_commitment_secret: [u8; 32],
734 /// The next sender-broadcast commitment transaction's per-commitment point
735 pub next_per_commitment_point: PublicKey,
737 /// Musig nonce the recipient should use in their next commitment signature message
738 pub next_local_nonce: Option<musig2::types::PublicNonce>
741 /// An [`update_fee`] message to be sent to or received from a peer
743 /// [`update_fee`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#updating-fees-update_fee
744 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
745 pub struct UpdateFee {
747 pub channel_id: ChannelId,
748 /// Fee rate per 1000-weight of the transaction
749 pub feerate_per_kw: u32,
752 /// A [`channel_reestablish`] message to be sent to or received from a peer.
754 /// [`channel_reestablish`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#message-retransmission
755 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
756 pub struct ChannelReestablish {
758 pub channel_id: ChannelId,
759 /// The next commitment number for the sender
760 pub next_local_commitment_number: u64,
761 /// The next commitment number for the recipient
762 pub next_remote_commitment_number: u64,
763 /// Proof that the sender knows the per-commitment secret of a specific commitment transaction
764 /// belonging to the recipient
765 pub your_last_per_commitment_secret: [u8; 32],
766 /// The sender's per-commitment point for their current commitment transaction
767 pub my_current_per_commitment_point: PublicKey,
768 /// The next funding transaction ID
769 pub next_funding_txid: Option<Txid>,
772 /// An [`announcement_signatures`] message to be sent to or received from a peer.
774 /// [`announcement_signatures`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-announcement_signatures-message
775 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
776 pub struct AnnouncementSignatures {
778 pub channel_id: ChannelId,
779 /// The short channel ID
780 pub short_channel_id: u64,
781 /// A signature by the node key
782 pub node_signature: Signature,
783 /// A signature by the funding key
784 pub bitcoin_signature: Signature,
787 /// An address which can be used to connect to a remote peer.
788 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
789 pub enum SocketAddress {
790 /// An IPv4 address and port on which the peer is listening.
792 /// The 4-byte IPv4 address
794 /// The port on which the node is listening
797 /// An IPv6 address and port on which the peer is listening.
799 /// The 16-byte IPv6 address
801 /// The port on which the node is listening
804 /// An old-style Tor onion address/port on which the peer is listening.
806 /// This field is deprecated and the Tor network generally no longer supports V2 Onion
807 /// addresses. Thus, the details are not parsed here.
809 /// A new-style Tor onion address/port on which the peer is listening.
811 /// To create the human-readable "hostname", concatenate the ED25519 pubkey, checksum, and version,
812 /// wrap as base32 and append ".onion".
814 /// The ed25519 long-term public key of the peer
815 ed25519_pubkey: [u8; 32],
816 /// The checksum of the pubkey and version, as included in the onion address
818 /// The version byte, as defined by the Tor Onion v3 spec.
820 /// The port on which the node is listening
823 /// A hostname/port on which the peer is listening.
825 /// The hostname on which the node is listening.
827 /// The port on which the node is listening.
832 /// Gets the ID of this address type. Addresses in [`NodeAnnouncement`] messages should be sorted
834 pub(crate) fn get_id(&self) -> u8 {
836 &SocketAddress::TcpIpV4 {..} => { 1 },
837 &SocketAddress::TcpIpV6 {..} => { 2 },
838 &SocketAddress::OnionV2(_) => { 3 },
839 &SocketAddress::OnionV3 {..} => { 4 },
840 &SocketAddress::Hostname {..} => { 5 },
844 /// Strict byte-length of address descriptor, 1-byte type not recorded
845 fn len(&self) -> u16 {
847 &SocketAddress::TcpIpV4 { .. } => { 6 },
848 &SocketAddress::TcpIpV6 { .. } => { 18 },
849 &SocketAddress::OnionV2(_) => { 12 },
850 &SocketAddress::OnionV3 { .. } => { 37 },
851 // Consists of 1-byte hostname length, hostname bytes, and 2-byte port.
852 &SocketAddress::Hostname { ref hostname, .. } => { u16::from(hostname.len()) + 3 },
856 /// The maximum length of any address descriptor, not including the 1-byte type.
857 /// This maximum length is reached by a hostname address descriptor:
858 /// a hostname with a maximum length of 255, its 1-byte length and a 2-byte port.
859 pub(crate) const MAX_LEN: u16 = 258;
861 pub(crate) fn is_tor(&self) -> bool {
863 &SocketAddress::TcpIpV4 {..} => false,
864 &SocketAddress::TcpIpV6 {..} => false,
865 &SocketAddress::OnionV2(_) => true,
866 &SocketAddress::OnionV3 {..} => true,
867 &SocketAddress::Hostname {..} => false,
872 impl Writeable for SocketAddress {
873 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
875 &SocketAddress::TcpIpV4 { ref addr, ref port } => {
880 &SocketAddress::TcpIpV6 { ref addr, ref port } => {
885 &SocketAddress::OnionV2(bytes) => {
887 bytes.write(writer)?;
889 &SocketAddress::OnionV3 { ref ed25519_pubkey, ref checksum, ref version, ref port } => {
891 ed25519_pubkey.write(writer)?;
892 checksum.write(writer)?;
893 version.write(writer)?;
896 &SocketAddress::Hostname { ref hostname, ref port } => {
898 hostname.write(writer)?;
906 impl Readable for Result<SocketAddress, u8> {
907 fn read<R: Read>(reader: &mut R) -> Result<Result<SocketAddress, u8>, DecodeError> {
908 let byte = <u8 as Readable>::read(reader)?;
911 Ok(Ok(SocketAddress::TcpIpV4 {
912 addr: Readable::read(reader)?,
913 port: Readable::read(reader)?,
917 Ok(Ok(SocketAddress::TcpIpV6 {
918 addr: Readable::read(reader)?,
919 port: Readable::read(reader)?,
922 3 => Ok(Ok(SocketAddress::OnionV2(Readable::read(reader)?))),
924 Ok(Ok(SocketAddress::OnionV3 {
925 ed25519_pubkey: Readable::read(reader)?,
926 checksum: Readable::read(reader)?,
927 version: Readable::read(reader)?,
928 port: Readable::read(reader)?,
932 Ok(Ok(SocketAddress::Hostname {
933 hostname: Readable::read(reader)?,
934 port: Readable::read(reader)?,
937 _ => return Ok(Err(byte)),
942 impl Readable for SocketAddress {
943 fn read<R: Read>(reader: &mut R) -> Result<SocketAddress, DecodeError> {
944 match Readable::read(reader) {
945 Ok(Ok(res)) => Ok(res),
946 Ok(Err(_)) => Err(DecodeError::UnknownVersion),
952 /// [`SocketAddress`] error variants
953 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
954 pub enum SocketAddressParseError {
955 /// Socket address (IPv4/IPv6) parsing error
957 /// Invalid input format
961 /// Invalid onion v3 address
965 impl fmt::Display for SocketAddressParseError {
966 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
968 SocketAddressParseError::SocketAddrParse => write!(f, "Socket address (IPv4/IPv6) parsing error"),
969 SocketAddressParseError::InvalidInput => write!(f, "Invalid input format. \
970 Expected: \"<ipv4>:<port>\", \"[<ipv6>]:<port>\", \"<onion address>.onion:<port>\" or \"<hostname>:<port>\""),
971 SocketAddressParseError::InvalidPort => write!(f, "Invalid port"),
972 SocketAddressParseError::InvalidOnionV3 => write!(f, "Invalid onion v3 address"),
977 #[cfg(feature = "std")]
978 impl From<std::net::SocketAddrV4> for SocketAddress {
979 fn from(addr: std::net::SocketAddrV4) -> Self {
980 SocketAddress::TcpIpV4 { addr: addr.ip().octets(), port: addr.port() }
984 #[cfg(feature = "std")]
985 impl From<std::net::SocketAddrV6> for SocketAddress {
986 fn from(addr: std::net::SocketAddrV6) -> Self {
987 SocketAddress::TcpIpV6 { addr: addr.ip().octets(), port: addr.port() }
991 #[cfg(feature = "std")]
992 impl From<std::net::SocketAddr> for SocketAddress {
993 fn from(addr: std::net::SocketAddr) -> Self {
995 std::net::SocketAddr::V4(addr) => addr.into(),
996 std::net::SocketAddr::V6(addr) => addr.into(),
1001 #[cfg(feature = "std")]
1002 impl std::net::ToSocketAddrs for SocketAddress {
1003 type Iter = std::vec::IntoIter<std::net::SocketAddr>;
1005 fn to_socket_addrs(&self) -> std::io::Result<Self::Iter> {
1007 SocketAddress::TcpIpV4 { addr, port } => {
1008 let ip_addr = std::net::Ipv4Addr::from(*addr);
1009 let socket_addr = SocketAddr::new(ip_addr.into(), *port);
1010 Ok(vec![socket_addr].into_iter())
1012 SocketAddress::TcpIpV6 { addr, port } => {
1013 let ip_addr = std::net::Ipv6Addr::from(*addr);
1014 let socket_addr = SocketAddr::new(ip_addr.into(), *port);
1015 Ok(vec![socket_addr].into_iter())
1017 SocketAddress::Hostname { ref hostname, port } => {
1018 (hostname.as_str(), *port).to_socket_addrs()
1020 SocketAddress::OnionV2(..) => {
1021 Err(std::io::Error::new(std::io::ErrorKind::Other, "Resolution of OnionV2 \
1022 addresses is currently unsupported."))
1024 SocketAddress::OnionV3 { .. } => {
1025 Err(std::io::Error::new(std::io::ErrorKind::Other, "Resolution of OnionV3 \
1026 addresses is currently unsupported."))
1032 /// Parses an OnionV3 host and port into a [`SocketAddress::OnionV3`].
1034 /// The host part must end with ".onion".
1035 pub fn parse_onion_address(host: &str, port: u16) -> Result<SocketAddress, SocketAddressParseError> {
1036 if host.ends_with(".onion") {
1037 let domain = &host[..host.len() - ".onion".len()];
1038 if domain.len() != 56 {
1039 return Err(SocketAddressParseError::InvalidOnionV3);
1041 let onion = base32::Alphabet::RFC4648 { padding: false }.decode(&domain).map_err(|_| SocketAddressParseError::InvalidOnionV3)?;
1042 if onion.len() != 35 {
1043 return Err(SocketAddressParseError::InvalidOnionV3);
1045 let version = onion[0];
1046 let first_checksum_flag = onion[1];
1047 let second_checksum_flag = onion[2];
1048 let mut ed25519_pubkey = [0; 32];
1049 ed25519_pubkey.copy_from_slice(&onion[3..35]);
1050 let checksum = u16::from_be_bytes([first_checksum_flag, second_checksum_flag]);
1051 return Ok(SocketAddress::OnionV3 { ed25519_pubkey, checksum, version, port });
1054 return Err(SocketAddressParseError::InvalidInput);
1058 impl Display for SocketAddress {
1059 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1061 SocketAddress::TcpIpV4{addr, port} => write!(
1062 f, "{}.{}.{}.{}:{}", addr[0], addr[1], addr[2], addr[3], port)?,
1063 SocketAddress::TcpIpV6{addr, port} => write!(
1065 "[{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}]:{}",
1066 addr[0], addr[1], addr[2], addr[3], addr[4], addr[5], addr[6], addr[7], addr[8], addr[9], addr[10], addr[11], addr[12], addr[13], addr[14], addr[15], port
1068 SocketAddress::OnionV2(bytes) => write!(f, "OnionV2({:?})", bytes)?,
1069 SocketAddress::OnionV3 {
1075 let [first_checksum_flag, second_checksum_flag] = checksum.to_be_bytes();
1076 let mut addr = vec![*version, first_checksum_flag, second_checksum_flag];
1077 addr.extend_from_slice(ed25519_pubkey);
1078 let onion = base32::Alphabet::RFC4648 { padding: false }.encode(&addr);
1079 write!(f, "{}.onion:{}", onion, port)?
1081 SocketAddress::Hostname { hostname, port } => write!(f, "{}:{}", hostname, port)?,
1087 #[cfg(feature = "std")]
1088 impl FromStr for SocketAddress {
1089 type Err = SocketAddressParseError;
1091 fn from_str(s: &str) -> Result<Self, Self::Err> {
1092 match std::net::SocketAddr::from_str(s) {
1093 Ok(addr) => Ok(addr.into()),
1095 let trimmed_input = match s.rfind(":") {
1097 None => return Err(SocketAddressParseError::InvalidInput),
1099 let host = &s[..trimmed_input];
1100 let port: u16 = s[trimmed_input + 1..].parse().map_err(|_| SocketAddressParseError::InvalidPort)?;
1101 if host.ends_with(".onion") {
1102 return parse_onion_address(host, port);
1104 if let Ok(hostname) = Hostname::try_from(s[..trimmed_input].to_string()) {
1105 return Ok(SocketAddress::Hostname { hostname, port });
1107 return Err(SocketAddressParseError::SocketAddrParse)
1113 /// Represents the set of gossip messages that require a signature from a node's identity key.
1114 pub enum UnsignedGossipMessage<'a> {
1115 /// An unsigned channel announcement.
1116 ChannelAnnouncement(&'a UnsignedChannelAnnouncement),
1117 /// An unsigned channel update.
1118 ChannelUpdate(&'a UnsignedChannelUpdate),
1119 /// An unsigned node announcement.
1120 NodeAnnouncement(&'a UnsignedNodeAnnouncement)
1123 impl<'a> Writeable for UnsignedGossipMessage<'a> {
1124 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
1126 UnsignedGossipMessage::ChannelAnnouncement(ref msg) => msg.write(writer),
1127 UnsignedGossipMessage::ChannelUpdate(ref msg) => msg.write(writer),
1128 UnsignedGossipMessage::NodeAnnouncement(ref msg) => msg.write(writer),
1133 /// The unsigned part of a [`node_announcement`] message.
1135 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
1136 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1137 pub struct UnsignedNodeAnnouncement {
1138 /// The advertised features
1139 pub features: NodeFeatures,
1140 /// A strictly monotonic announcement counter, with gaps allowed
1142 /// The `node_id` this announcement originated from (don't rebroadcast the `node_announcement` back
1144 pub node_id: NodeId,
1145 /// An RGB color for UI purposes
1147 /// An alias, for UI purposes.
1149 /// This should be sanitized before use. There is no guarantee of uniqueness.
1150 pub alias: NodeAlias,
1151 /// List of addresses on which this node is reachable
1152 pub addresses: Vec<SocketAddress>,
1153 /// Excess address data which was signed as a part of the message which we do not (yet) understand how
1156 /// This is stored to ensure forward-compatibility as new address types are added to the lightning gossip protocol.
1157 pub excess_address_data: Vec<u8>,
1158 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1161 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1162 pub excess_data: Vec<u8>,
1164 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1165 /// A [`node_announcement`] message to be sent to or received from a peer.
1167 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
1168 pub struct NodeAnnouncement {
1169 /// The signature by the node key
1170 pub signature: Signature,
1171 /// The actual content of the announcement
1172 pub contents: UnsignedNodeAnnouncement,
1175 /// The unsigned part of a [`channel_announcement`] message.
1177 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
1178 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1179 pub struct UnsignedChannelAnnouncement {
1180 /// The advertised channel features
1181 pub features: ChannelFeatures,
1182 /// The genesis hash of the blockchain where the channel is to be opened
1183 pub chain_hash: ChainHash,
1184 /// The short channel ID
1185 pub short_channel_id: u64,
1186 /// One of the two `node_id`s which are endpoints of this channel
1187 pub node_id_1: NodeId,
1188 /// The other of the two `node_id`s which are endpoints of this channel
1189 pub node_id_2: NodeId,
1190 /// The funding key for the first node
1191 pub bitcoin_key_1: NodeId,
1192 /// The funding key for the second node
1193 pub bitcoin_key_2: NodeId,
1194 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1197 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1198 pub excess_data: Vec<u8>,
1200 /// A [`channel_announcement`] message to be sent to or received from a peer.
1202 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
1203 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1204 pub struct ChannelAnnouncement {
1205 /// Authentication of the announcement by the first public node
1206 pub node_signature_1: Signature,
1207 /// Authentication of the announcement by the second public node
1208 pub node_signature_2: Signature,
1209 /// Proof of funding UTXO ownership by the first public node
1210 pub bitcoin_signature_1: Signature,
1211 /// Proof of funding UTXO ownership by the second public node
1212 pub bitcoin_signature_2: Signature,
1213 /// The actual announcement
1214 pub contents: UnsignedChannelAnnouncement,
1217 /// The unsigned part of a [`channel_update`] message.
1219 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1220 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1221 pub struct UnsignedChannelUpdate {
1222 /// The genesis hash of the blockchain where the channel is to be opened
1223 pub chain_hash: ChainHash,
1224 /// The short channel ID
1225 pub short_channel_id: u64,
1226 /// A strictly monotonic announcement counter, with gaps allowed, specific to this channel
1230 /// The number of blocks such that if:
1231 /// `incoming_htlc.cltv_expiry < outgoing_htlc.cltv_expiry + cltv_expiry_delta`
1232 /// then we need to fail the HTLC backwards. When forwarding an HTLC, `cltv_expiry_delta` determines
1233 /// the outgoing HTLC's minimum `cltv_expiry` value -- so, if an incoming HTLC comes in with a
1234 /// `cltv_expiry` of 100000, and the node we're forwarding to has a `cltv_expiry_delta` value of 10,
1235 /// then we'll check that the outgoing HTLC's `cltv_expiry` value is at least 100010 before
1236 /// forwarding. Note that the HTLC sender is the one who originally sets this value when
1237 /// constructing the route.
1238 pub cltv_expiry_delta: u16,
1239 /// The minimum HTLC size incoming to sender, in milli-satoshi
1240 pub htlc_minimum_msat: u64,
1241 /// The maximum HTLC value incoming to sender, in milli-satoshi.
1243 /// This used to be optional.
1244 pub htlc_maximum_msat: u64,
1245 /// The base HTLC fee charged by sender, in milli-satoshi
1246 pub fee_base_msat: u32,
1247 /// The amount to fee multiplier, in micro-satoshi
1248 pub fee_proportional_millionths: u32,
1249 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1252 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1253 pub excess_data: Vec<u8>,
1255 /// A [`channel_update`] message to be sent to or received from a peer.
1257 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1258 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1259 pub struct ChannelUpdate {
1260 /// A signature of the channel update
1261 pub signature: Signature,
1262 /// The actual channel update
1263 pub contents: UnsignedChannelUpdate,
1266 /// A [`query_channel_range`] message is used to query a peer for channel
1267 /// UTXOs in a range of blocks. The recipient of a query makes a best
1268 /// effort to reply to the query using one or more [`ReplyChannelRange`]
1271 /// [`query_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1272 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1273 pub struct QueryChannelRange {
1274 /// The genesis hash of the blockchain being queried
1275 pub chain_hash: ChainHash,
1276 /// The height of the first block for the channel UTXOs being queried
1277 pub first_blocknum: u32,
1278 /// The number of blocks to include in the query results
1279 pub number_of_blocks: u32,
1282 /// A [`reply_channel_range`] message is a reply to a [`QueryChannelRange`]
1285 /// Multiple `reply_channel_range` messages can be sent in reply
1286 /// to a single [`QueryChannelRange`] message. The query recipient makes a
1287 /// best effort to respond based on their local network view which may
1288 /// not be a perfect view of the network. The `short_channel_id`s in the
1289 /// reply are encoded. We only support `encoding_type=0` uncompressed
1290 /// serialization and do not support `encoding_type=1` zlib serialization.
1292 /// [`reply_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1293 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1294 pub struct ReplyChannelRange {
1295 /// The genesis hash of the blockchain being queried
1296 pub chain_hash: ChainHash,
1297 /// The height of the first block in the range of the reply
1298 pub first_blocknum: u32,
1299 /// The number of blocks included in the range of the reply
1300 pub number_of_blocks: u32,
1301 /// True when this is the final reply for a query
1302 pub sync_complete: bool,
1303 /// The `short_channel_id`s in the channel range
1304 pub short_channel_ids: Vec<u64>,
1307 /// A [`query_short_channel_ids`] message is used to query a peer for
1308 /// routing gossip messages related to one or more `short_channel_id`s.
1310 /// The query recipient will reply with the latest, if available,
1311 /// [`ChannelAnnouncement`], [`ChannelUpdate`] and [`NodeAnnouncement`] messages
1312 /// it maintains for the requested `short_channel_id`s followed by a
1313 /// [`ReplyShortChannelIdsEnd`] message. The `short_channel_id`s sent in
1314 /// this query are encoded. We only support `encoding_type=0` uncompressed
1315 /// serialization and do not support `encoding_type=1` zlib serialization.
1317 /// [`query_short_channel_ids`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_short_channel_idsreply_short_channel_ids_end-messages
1318 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1319 pub struct QueryShortChannelIds {
1320 /// The genesis hash of the blockchain being queried
1321 pub chain_hash: ChainHash,
1322 /// The short_channel_ids that are being queried
1323 pub short_channel_ids: Vec<u64>,
1326 /// A [`reply_short_channel_ids_end`] message is sent as a reply to a
1327 /// message. The query recipient makes a best
1328 /// effort to respond based on their local network view which may not be
1329 /// a perfect view of the network.
1331 /// [`reply_short_channel_ids_end`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_short_channel_idsreply_short_channel_ids_end-messages
1332 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1333 pub struct ReplyShortChannelIdsEnd {
1334 /// The genesis hash of the blockchain that was queried
1335 pub chain_hash: ChainHash,
1336 /// Indicates if the query recipient maintains up-to-date channel
1337 /// information for the `chain_hash`
1338 pub full_information: bool,
1341 /// A [`gossip_timestamp_filter`] message is used by a node to request
1342 /// gossip relay for messages in the requested time range when the
1343 /// `gossip_queries` feature has been negotiated.
1345 /// [`gossip_timestamp_filter`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-gossip_timestamp_filter-message
1346 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1347 pub struct GossipTimestampFilter {
1348 /// The genesis hash of the blockchain for channel and node information
1349 pub chain_hash: ChainHash,
1350 /// The starting unix timestamp
1351 pub first_timestamp: u32,
1352 /// The range of information in seconds
1353 pub timestamp_range: u32,
1356 /// Encoding type for data compression of collections in gossip queries.
1358 /// We do not support `encoding_type=1` zlib serialization [defined in BOLT
1359 /// #7](https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#query-messages).
1361 Uncompressed = 0x00,
1364 /// Used to put an error message in a [`LightningError`].
1365 #[derive(Clone, Debug, Hash, PartialEq)]
1366 pub enum ErrorAction {
1367 /// The peer took some action which made us think they were useless. Disconnect them.
1369 /// An error message which we should make an effort to send before we disconnect.
1370 msg: Option<ErrorMessage>
1372 /// The peer did something incorrect. Tell them without closing any channels and disconnect them.
1373 DisconnectPeerWithWarning {
1374 /// A warning message which we should make an effort to send before we disconnect.
1375 msg: WarningMessage,
1377 /// The peer did something harmless that we weren't able to process, just log and ignore
1378 // New code should *not* use this. New code must use IgnoreAndLog, below!
1380 /// The peer did something harmless that we weren't able to meaningfully process.
1381 /// If the error is logged, log it at the given level.
1382 IgnoreAndLog(logger::Level),
1383 /// The peer provided us with a gossip message which we'd already seen. In most cases this
1384 /// should be ignored, but it may result in the message being forwarded if it is a duplicate of
1385 /// our own channel announcements.
1386 IgnoreDuplicateGossip,
1387 /// The peer did something incorrect. Tell them.
1389 /// The message to send.
1392 /// The peer did something incorrect. Tell them without closing any channels.
1393 SendWarningMessage {
1394 /// The message to send.
1395 msg: WarningMessage,
1396 /// The peer may have done something harmless that we weren't able to meaningfully process,
1397 /// though we should still tell them about it.
1398 /// If this event is logged, log it at the given level.
1399 log_level: logger::Level,
1403 /// An Err type for failure to process messages.
1404 #[derive(Clone, Debug)]
1405 pub struct LightningError {
1406 /// A human-readable message describing the error
1408 /// The action which should be taken against the offending peer.
1409 pub action: ErrorAction,
1412 /// Struct used to return values from [`RevokeAndACK`] messages, containing a bunch of commitment
1413 /// transaction updates if they were pending.
1414 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1415 pub struct CommitmentUpdate {
1416 /// `update_add_htlc` messages which should be sent
1417 pub update_add_htlcs: Vec<UpdateAddHTLC>,
1418 /// `update_fulfill_htlc` messages which should be sent
1419 pub update_fulfill_htlcs: Vec<UpdateFulfillHTLC>,
1420 /// `update_fail_htlc` messages which should be sent
1421 pub update_fail_htlcs: Vec<UpdateFailHTLC>,
1422 /// `update_fail_malformed_htlc` messages which should be sent
1423 pub update_fail_malformed_htlcs: Vec<UpdateFailMalformedHTLC>,
1424 /// An `update_fee` message which should be sent
1425 pub update_fee: Option<UpdateFee>,
1426 /// A `commitment_signed` message which should be sent
1427 pub commitment_signed: CommitmentSigned,
1430 /// A trait to describe an object which can receive channel messages.
1432 /// Messages MAY be called in parallel when they originate from different `their_node_ids`, however
1433 /// they MUST NOT be called in parallel when the two calls have the same `their_node_id`.
1434 pub trait ChannelMessageHandler : MessageSendEventsProvider {
1436 /// Handle an incoming `open_channel` message from the given peer.
1437 fn handle_open_channel(&self, their_node_id: &PublicKey, msg: &OpenChannel);
1438 /// Handle an incoming `open_channel2` message from the given peer.
1439 fn handle_open_channel_v2(&self, their_node_id: &PublicKey, msg: &OpenChannelV2);
1440 /// Handle an incoming `accept_channel` message from the given peer.
1441 fn handle_accept_channel(&self, their_node_id: &PublicKey, msg: &AcceptChannel);
1442 /// Handle an incoming `accept_channel2` message from the given peer.
1443 fn handle_accept_channel_v2(&self, their_node_id: &PublicKey, msg: &AcceptChannelV2);
1444 /// Handle an incoming `funding_created` message from the given peer.
1445 fn handle_funding_created(&self, their_node_id: &PublicKey, msg: &FundingCreated);
1446 /// Handle an incoming `funding_signed` message from the given peer.
1447 fn handle_funding_signed(&self, their_node_id: &PublicKey, msg: &FundingSigned);
1448 /// Handle an incoming `channel_ready` message from the given peer.
1449 fn handle_channel_ready(&self, their_node_id: &PublicKey, msg: &ChannelReady);
1452 /// Handle an incoming `shutdown` message from the given peer.
1453 fn handle_shutdown(&self, their_node_id: &PublicKey, msg: &Shutdown);
1454 /// Handle an incoming `closing_signed` message from the given peer.
1455 fn handle_closing_signed(&self, their_node_id: &PublicKey, msg: &ClosingSigned);
1458 /// Handle an incoming `stfu` message from the given peer.
1459 fn handle_stfu(&self, their_node_id: &PublicKey, msg: &Stfu);
1462 /// Handle an incoming `splice` message from the given peer.
1463 fn handle_splice(&self, their_node_id: &PublicKey, msg: &Splice);
1464 /// Handle an incoming `splice_ack` message from the given peer.
1465 fn handle_splice_ack(&self, their_node_id: &PublicKey, msg: &SpliceAck);
1466 /// Handle an incoming `splice_locked` message from the given peer.
1467 fn handle_splice_locked(&self, their_node_id: &PublicKey, msg: &SpliceLocked);
1469 // Interactive channel construction
1470 /// Handle an incoming `tx_add_input message` from the given peer.
1471 fn handle_tx_add_input(&self, their_node_id: &PublicKey, msg: &TxAddInput);
1472 /// Handle an incoming `tx_add_output` message from the given peer.
1473 fn handle_tx_add_output(&self, their_node_id: &PublicKey, msg: &TxAddOutput);
1474 /// Handle an incoming `tx_remove_input` message from the given peer.
1475 fn handle_tx_remove_input(&self, their_node_id: &PublicKey, msg: &TxRemoveInput);
1476 /// Handle an incoming `tx_remove_output` message from the given peer.
1477 fn handle_tx_remove_output(&self, their_node_id: &PublicKey, msg: &TxRemoveOutput);
1478 /// Handle an incoming `tx_complete message` from the given peer.
1479 fn handle_tx_complete(&self, their_node_id: &PublicKey, msg: &TxComplete);
1480 /// Handle an incoming `tx_signatures` message from the given peer.
1481 fn handle_tx_signatures(&self, their_node_id: &PublicKey, msg: &TxSignatures);
1482 /// Handle an incoming `tx_init_rbf` message from the given peer.
1483 fn handle_tx_init_rbf(&self, their_node_id: &PublicKey, msg: &TxInitRbf);
1484 /// Handle an incoming `tx_ack_rbf` message from the given peer.
1485 fn handle_tx_ack_rbf(&self, their_node_id: &PublicKey, msg: &TxAckRbf);
1486 /// Handle an incoming `tx_abort message` from the given peer.
1487 fn handle_tx_abort(&self, their_node_id: &PublicKey, msg: &TxAbort);
1490 /// Handle an incoming `update_add_htlc` message from the given peer.
1491 fn handle_update_add_htlc(&self, their_node_id: &PublicKey, msg: &UpdateAddHTLC);
1492 /// Handle an incoming `update_fulfill_htlc` message from the given peer.
1493 fn handle_update_fulfill_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFulfillHTLC);
1494 /// Handle an incoming `update_fail_htlc` message from the given peer.
1495 fn handle_update_fail_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailHTLC);
1496 /// Handle an incoming `update_fail_malformed_htlc` message from the given peer.
1497 fn handle_update_fail_malformed_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailMalformedHTLC);
1498 /// Handle an incoming `commitment_signed` message from the given peer.
1499 fn handle_commitment_signed(&self, their_node_id: &PublicKey, msg: &CommitmentSigned);
1500 /// Handle an incoming `revoke_and_ack` message from the given peer.
1501 fn handle_revoke_and_ack(&self, their_node_id: &PublicKey, msg: &RevokeAndACK);
1503 /// Handle an incoming `update_fee` message from the given peer.
1504 fn handle_update_fee(&self, their_node_id: &PublicKey, msg: &UpdateFee);
1506 // Channel-to-announce:
1507 /// Handle an incoming `announcement_signatures` message from the given peer.
1508 fn handle_announcement_signatures(&self, their_node_id: &PublicKey, msg: &AnnouncementSignatures);
1510 // Connection loss/reestablish:
1511 /// Indicates a connection to the peer failed/an existing connection was lost.
1512 fn peer_disconnected(&self, their_node_id: &PublicKey);
1514 /// Handle a peer reconnecting, possibly generating `channel_reestablish` message(s).
1516 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1517 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1518 /// message handlers may still wish to communicate with this peer.
1519 fn peer_connected(&self, their_node_id: &PublicKey, msg: &Init, inbound: bool) -> Result<(), ()>;
1520 /// Handle an incoming `channel_reestablish` message from the given peer.
1521 fn handle_channel_reestablish(&self, their_node_id: &PublicKey, msg: &ChannelReestablish);
1523 /// Handle an incoming `channel_update` message from the given peer.
1524 fn handle_channel_update(&self, their_node_id: &PublicKey, msg: &ChannelUpdate);
1527 /// Handle an incoming `error` message from the given peer.
1528 fn handle_error(&self, their_node_id: &PublicKey, msg: &ErrorMessage);
1530 // Handler information:
1531 /// Gets the node feature flags which this handler itself supports. All available handlers are
1532 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1533 /// which are broadcasted in our [`NodeAnnouncement`] message.
1534 fn provided_node_features(&self) -> NodeFeatures;
1536 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1537 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1538 /// which are sent in our [`Init`] message.
1540 /// Note that this method is called before [`Self::peer_connected`].
1541 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1543 /// Gets the chain hashes for this `ChannelMessageHandler` indicating which chains it supports.
1545 /// If it's `None`, then no particular network chain hash compatibility will be enforced when
1546 /// connecting to peers.
1547 fn get_chain_hashes(&self) -> Option<Vec<ChainHash>>;
1550 /// A trait to describe an object which can receive routing messages.
1552 /// # Implementor DoS Warnings
1554 /// For messages enabled with the `gossip_queries` feature there are potential DoS vectors when
1555 /// handling inbound queries. Implementors using an on-disk network graph should be aware of
1556 /// repeated disk I/O for queries accessing different parts of the network graph.
1557 pub trait RoutingMessageHandler : MessageSendEventsProvider {
1558 /// Handle an incoming `node_announcement` message, returning `true` if it should be forwarded on,
1559 /// `false` or returning an `Err` otherwise.
1560 fn handle_node_announcement(&self, msg: &NodeAnnouncement) -> Result<bool, LightningError>;
1561 /// Handle a `channel_announcement` message, returning `true` if it should be forwarded on, `false`
1562 /// or returning an `Err` otherwise.
1563 fn handle_channel_announcement(&self, msg: &ChannelAnnouncement) -> Result<bool, LightningError>;
1564 /// Handle an incoming `channel_update` message, returning true if it should be forwarded on,
1565 /// `false` or returning an `Err` otherwise.
1566 fn handle_channel_update(&self, msg: &ChannelUpdate) -> Result<bool, LightningError>;
1567 /// Gets channel announcements and updates required to dump our routing table to a remote node,
1568 /// starting at the `short_channel_id` indicated by `starting_point` and including announcements
1569 /// for a single channel.
1570 fn get_next_channel_announcement(&self, starting_point: u64) -> Option<(ChannelAnnouncement, Option<ChannelUpdate>, Option<ChannelUpdate>)>;
1571 /// Gets a node announcement required to dump our routing table to a remote node, starting at
1572 /// the node *after* the provided pubkey and including up to one announcement immediately
1573 /// higher (as defined by `<PublicKey as Ord>::cmp`) than `starting_point`.
1574 /// If `None` is provided for `starting_point`, we start at the first node.
1575 fn get_next_node_announcement(&self, starting_point: Option<&NodeId>) -> Option<NodeAnnouncement>;
1576 /// Called when a connection is established with a peer. This can be used to
1577 /// perform routing table synchronization using a strategy defined by the
1580 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1581 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1582 /// message handlers may still wish to communicate with this peer.
1583 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1584 /// Handles the reply of a query we initiated to learn about channels
1585 /// for a given range of blocks. We can expect to receive one or more
1586 /// replies to a single query.
1587 fn handle_reply_channel_range(&self, their_node_id: &PublicKey, msg: ReplyChannelRange) -> Result<(), LightningError>;
1588 /// Handles the reply of a query we initiated asking for routing gossip
1589 /// messages for a list of channels. We should receive this message when
1590 /// a node has completed its best effort to send us the pertaining routing
1591 /// gossip messages.
1592 fn handle_reply_short_channel_ids_end(&self, their_node_id: &PublicKey, msg: ReplyShortChannelIdsEnd) -> Result<(), LightningError>;
1593 /// Handles when a peer asks us to send a list of `short_channel_id`s
1594 /// for the requested range of blocks.
1595 fn handle_query_channel_range(&self, their_node_id: &PublicKey, msg: QueryChannelRange) -> Result<(), LightningError>;
1596 /// Handles when a peer asks us to send routing gossip messages for a
1597 /// list of `short_channel_id`s.
1598 fn handle_query_short_channel_ids(&self, their_node_id: &PublicKey, msg: QueryShortChannelIds) -> Result<(), LightningError>;
1600 // Handler queueing status:
1601 /// Indicates that there are a large number of [`ChannelAnnouncement`] (or other) messages
1602 /// pending some async action. While there is no guarantee of the rate of future messages, the
1603 /// caller should seek to reduce the rate of new gossip messages handled, especially
1604 /// [`ChannelAnnouncement`]s.
1605 fn processing_queue_high(&self) -> bool;
1607 // Handler information:
1608 /// Gets the node feature flags which this handler itself supports. All available handlers are
1609 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1610 /// which are broadcasted in our [`NodeAnnouncement`] message.
1611 fn provided_node_features(&self) -> NodeFeatures;
1612 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1613 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1614 /// which are sent in our [`Init`] message.
1616 /// Note that this method is called before [`Self::peer_connected`].
1617 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1620 /// A handler for received [`OnionMessage`]s and for providing generated ones to send.
1621 pub trait OnionMessageHandler: EventsProvider {
1622 /// Handle an incoming `onion_message` message from the given peer.
1623 fn handle_onion_message(&self, peer_node_id: &PublicKey, msg: &OnionMessage);
1625 /// Returns the next pending onion message for the peer with the given node id.
1626 fn next_onion_message_for_peer(&self, peer_node_id: PublicKey) -> Option<OnionMessage>;
1628 /// Called when a connection is established with a peer. Can be used to track which peers
1629 /// advertise onion message support and are online.
1631 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1632 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1633 /// message handlers may still wish to communicate with this peer.
1634 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1636 /// Indicates a connection to the peer failed/an existing connection was lost. Allows handlers to
1637 /// drop and refuse to forward onion messages to this peer.
1638 fn peer_disconnected(&self, their_node_id: &PublicKey);
1640 /// Performs actions that should happen roughly every ten seconds after startup. Allows handlers
1641 /// to drop any buffered onion messages intended for prospective peers.
1642 fn timer_tick_occurred(&self);
1644 // Handler information:
1645 /// Gets the node feature flags which this handler itself supports. All available handlers are
1646 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1647 /// which are broadcasted in our [`NodeAnnouncement`] message.
1648 fn provided_node_features(&self) -> NodeFeatures;
1650 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1651 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1652 /// which are sent in our [`Init`] message.
1654 /// Note that this method is called before [`Self::peer_connected`].
1655 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1659 #[cfg_attr(test, derive(Debug, PartialEq))]
1660 /// Information communicated in the onion to the recipient for multi-part tracking and proof that
1661 /// the payment is associated with an invoice.
1662 pub struct FinalOnionHopData {
1663 /// When sending a multi-part payment, this secret is used to identify a payment across HTLCs.
1664 /// Because it is generated by the recipient and included in the invoice, it also provides
1665 /// proof to the recipient that the payment was sent by someone with the generated invoice.
1666 pub payment_secret: PaymentSecret,
1667 /// The intended total amount that this payment is for.
1669 /// Message serialization may panic if this value is more than 21 million Bitcoin.
1670 pub total_msat: u64,
1673 mod fuzzy_internal_msgs {
1674 use bitcoin::secp256k1::PublicKey;
1675 use crate::blinded_path::payment::{PaymentConstraints, PaymentContext, PaymentRelay};
1676 use crate::ln::{PaymentPreimage, PaymentSecret};
1677 use crate::ln::features::BlindedHopFeatures;
1678 use super::{FinalOnionHopData, TrampolineOnionPacket};
1680 #[allow(unused_imports)]
1681 use crate::prelude::*;
1683 // These types aren't intended to be pub, but are exposed for direct fuzzing (as we deserialize
1684 // them from untrusted input):
1686 pub enum InboundOnionPayload {
1688 short_channel_id: u64,
1689 /// The value, in msat, of the payment after this hop's fee is deducted.
1690 amt_to_forward: u64,
1691 outgoing_cltv_value: u32,
1694 payment_data: Option<FinalOnionHopData>,
1695 payment_metadata: Option<Vec<u8>>,
1696 keysend_preimage: Option<PaymentPreimage>,
1697 custom_tlvs: Vec<(u64, Vec<u8>)>,
1698 sender_intended_htlc_amt_msat: u64,
1699 cltv_expiry_height: u32,
1702 short_channel_id: u64,
1703 payment_relay: PaymentRelay,
1704 payment_constraints: PaymentConstraints,
1705 features: BlindedHopFeatures,
1706 intro_node_blinding_point: Option<PublicKey>,
1709 sender_intended_htlc_amt_msat: u64,
1711 cltv_expiry_height: u32,
1712 payment_secret: PaymentSecret,
1713 payment_constraints: PaymentConstraints,
1714 payment_context: PaymentContext,
1715 intro_node_blinding_point: Option<PublicKey>,
1716 keysend_preimage: Option<PaymentPreimage>,
1717 custom_tlvs: Vec<(u64, Vec<u8>)>,
1721 pub(crate) enum OutboundOnionPayload {
1723 short_channel_id: u64,
1724 /// The value, in msat, of the payment after this hop's fee is deducted.
1725 amt_to_forward: u64,
1726 outgoing_cltv_value: u32,
1729 TrampolineEntrypoint {
1730 amt_to_forward: u64,
1731 outgoing_cltv_value: u32,
1732 multipath_trampoline_data: Option<FinalOnionHopData>,
1733 trampoline_packet: TrampolineOnionPacket,
1736 payment_data: Option<FinalOnionHopData>,
1737 payment_metadata: Option<Vec<u8>>,
1738 keysend_preimage: Option<PaymentPreimage>,
1739 custom_tlvs: Vec<(u64, Vec<u8>)>,
1740 sender_intended_htlc_amt_msat: u64,
1741 cltv_expiry_height: u32,
1744 encrypted_tlvs: Vec<u8>,
1745 intro_node_blinding_point: Option<PublicKey>,
1748 sender_intended_htlc_amt_msat: u64,
1750 cltv_expiry_height: u32,
1751 encrypted_tlvs: Vec<u8>,
1752 intro_node_blinding_point: Option<PublicKey>, // Set if the introduction node of the blinded path is the final node
1753 keysend_preimage: Option<PaymentPreimage>,
1754 custom_tlvs: Vec<(u64, Vec<u8>)>,
1758 pub(crate) enum OutboundTrampolinePayload {
1761 /// The value, in msat, of the payment after this hop's fee is deducted.
1762 amt_to_forward: u64,
1763 outgoing_cltv_value: u32,
1764 /// The node id to which the trampoline node must find a route
1765 outgoing_node_id: PublicKey,
1769 pub struct DecodedOnionErrorPacket {
1770 pub(crate) hmac: [u8; 32],
1771 pub(crate) failuremsg: Vec<u8>,
1772 pub(crate) pad: Vec<u8>,
1776 pub use self::fuzzy_internal_msgs::*;
1777 #[cfg(not(fuzzing))]
1778 pub(crate) use self::fuzzy_internal_msgs::*;
1780 /// BOLT 4 onion packet including hop data for the next peer.
1781 #[derive(Clone, Hash, PartialEq, Eq)]
1782 pub struct OnionPacket {
1783 /// BOLT 4 version number.
1785 /// In order to ensure we always return an error on onion decode in compliance with [BOLT
1786 /// #4](https://github.com/lightning/bolts/blob/master/04-onion-routing.md), we have to
1787 /// deserialize `OnionPacket`s contained in [`UpdateAddHTLC`] messages even if the ephemeral
1788 /// public key (here) is bogus, so we hold a [`Result`] instead of a [`PublicKey`] as we'd
1790 pub public_key: Result<PublicKey, secp256k1::Error>,
1791 /// 1300 bytes encrypted payload for the next hop.
1792 pub hop_data: [u8; 20*65],
1793 /// HMAC to verify the integrity of hop_data.
1797 impl onion_utils::Packet for OnionPacket {
1798 type Data = onion_utils::FixedSizeOnionPacket;
1799 fn new(pubkey: PublicKey, hop_data: onion_utils::FixedSizeOnionPacket, hmac: [u8; 32]) -> Self {
1802 public_key: Ok(pubkey),
1803 hop_data: hop_data.0,
1809 impl fmt::Debug for OnionPacket {
1810 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1811 f.write_fmt(format_args!("OnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
1815 /// BOLT 4 onion packet including hop data for the next peer.
1816 #[derive(Clone, Hash, PartialEq, Eq)]
1817 pub struct TrampolineOnionPacket {
1818 /// Bolt 04 version number
1820 /// A random sepc256k1 point, used to build the ECDH shared secret to decrypt hop_data
1821 pub public_key: PublicKey,
1822 /// Encrypted payload for the next hop
1824 // Unlike the onion packets used for payments, Trampoline onion packets have to be shorter than
1825 // 1300 bytes. The expected default is 650 bytes.
1826 // TODO: if 650 ends up being the most common size, optimize this to be:
1827 // enum { SixFifty([u8; 650]), VarLen(Vec<u8>) }
1828 pub hop_data: Vec<u8>,
1829 /// HMAC to verify the integrity of hop_data
1833 impl onion_utils::Packet for TrampolineOnionPacket {
1834 type Data = Vec<u8>;
1835 fn new(public_key: PublicKey, hop_data: Vec<u8>, hmac: [u8; 32]) -> Self {
1845 impl Writeable for TrampolineOnionPacket {
1846 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1847 self.version.write(w)?;
1848 self.public_key.write(w)?;
1849 w.write_all(&self.hop_data)?;
1850 self.hmac.write(w)?;
1855 impl Debug for TrampolineOnionPacket {
1856 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1857 f.write_fmt(format_args!("TrampolineOnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
1861 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1862 pub(crate) struct OnionErrorPacket {
1863 // This really should be a constant size slice, but the spec lets these things be up to 128KB?
1864 // (TODO) We limit it in decode to much lower...
1865 pub(crate) data: Vec<u8>,
1868 impl fmt::Display for DecodeError {
1869 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1871 DecodeError::UnknownVersion => f.write_str("Unknown realm byte in Onion packet"),
1872 DecodeError::UnknownRequiredFeature => f.write_str("Unknown required feature preventing decode"),
1873 DecodeError::InvalidValue => f.write_str("Nonsense bytes didn't map to the type they were interpreted as"),
1874 DecodeError::ShortRead => f.write_str("Packet extended beyond the provided bytes"),
1875 DecodeError::BadLengthDescriptor => f.write_str("A length descriptor in the packet didn't describe the later data correctly"),
1876 DecodeError::Io(ref e) => fmt::Debug::fmt(e, f),
1877 DecodeError::UnsupportedCompression => f.write_str("We don't support receiving messages with zlib-compressed fields"),
1878 DecodeError::DangerousValue => f.write_str("Value would be dangerous to continue execution with"),
1883 impl From<io::Error> for DecodeError {
1884 fn from(e: io::Error) -> Self {
1885 if e.kind() == io::ErrorKind::UnexpectedEof {
1886 DecodeError::ShortRead
1888 DecodeError::Io(e.kind())
1893 impl Writeable for AcceptChannel {
1894 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1895 self.common_fields.temporary_channel_id.write(w)?;
1896 self.common_fields.dust_limit_satoshis.write(w)?;
1897 self.common_fields.max_htlc_value_in_flight_msat.write(w)?;
1898 self.channel_reserve_satoshis.write(w)?;
1899 self.common_fields.htlc_minimum_msat.write(w)?;
1900 self.common_fields.minimum_depth.write(w)?;
1901 self.common_fields.to_self_delay.write(w)?;
1902 self.common_fields.max_accepted_htlcs.write(w)?;
1903 self.common_fields.funding_pubkey.write(w)?;
1904 self.common_fields.revocation_basepoint.write(w)?;
1905 self.common_fields.payment_basepoint.write(w)?;
1906 self.common_fields.delayed_payment_basepoint.write(w)?;
1907 self.common_fields.htlc_basepoint.write(w)?;
1908 self.common_fields.first_per_commitment_point.write(w)?;
1909 #[cfg(not(taproot))]
1910 encode_tlv_stream!(w, {
1911 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
1912 (1, self.common_fields.channel_type, option),
1915 encode_tlv_stream!(w, {
1916 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
1917 (1, self.common_fields.channel_type, option),
1918 (4, self.next_local_nonce, option),
1924 impl Readable for AcceptChannel {
1925 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1926 let temporary_channel_id: ChannelId = Readable::read(r)?;
1927 let dust_limit_satoshis: u64 = Readable::read(r)?;
1928 let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;
1929 let channel_reserve_satoshis: u64 = Readable::read(r)?;
1930 let htlc_minimum_msat: u64 = Readable::read(r)?;
1931 let minimum_depth: u32 = Readable::read(r)?;
1932 let to_self_delay: u16 = Readable::read(r)?;
1933 let max_accepted_htlcs: u16 = Readable::read(r)?;
1934 let funding_pubkey: PublicKey = Readable::read(r)?;
1935 let revocation_basepoint: PublicKey = Readable::read(r)?;
1936 let payment_basepoint: PublicKey = Readable::read(r)?;
1937 let delayed_payment_basepoint: PublicKey = Readable::read(r)?;
1938 let htlc_basepoint: PublicKey = Readable::read(r)?;
1939 let first_per_commitment_point: PublicKey = Readable::read(r)?;
1941 let mut shutdown_scriptpubkey: Option<ScriptBuf> = None;
1942 let mut channel_type: Option<ChannelTypeFeatures> = None;
1943 #[cfg(not(taproot))]
1944 decode_tlv_stream!(r, {
1945 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
1946 (1, channel_type, option),
1949 let mut next_local_nonce: Option<musig2::types::PublicNonce> = None;
1951 decode_tlv_stream!(r, {
1952 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
1953 (1, channel_type, option),
1954 (4, next_local_nonce, option),
1958 common_fields: CommonAcceptChannelFields {
1959 temporary_channel_id,
1960 dust_limit_satoshis,
1961 max_htlc_value_in_flight_msat,
1967 revocation_basepoint,
1969 delayed_payment_basepoint,
1971 first_per_commitment_point,
1972 shutdown_scriptpubkey,
1975 channel_reserve_satoshis,
1982 impl Writeable for AcceptChannelV2 {
1983 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1984 self.common_fields.temporary_channel_id.write(w)?;
1985 self.funding_satoshis.write(w)?;
1986 self.common_fields.dust_limit_satoshis.write(w)?;
1987 self.common_fields.max_htlc_value_in_flight_msat.write(w)?;
1988 self.common_fields.htlc_minimum_msat.write(w)?;
1989 self.common_fields.minimum_depth.write(w)?;
1990 self.common_fields.to_self_delay.write(w)?;
1991 self.common_fields.max_accepted_htlcs.write(w)?;
1992 self.common_fields.funding_pubkey.write(w)?;
1993 self.common_fields.revocation_basepoint.write(w)?;
1994 self.common_fields.payment_basepoint.write(w)?;
1995 self.common_fields.delayed_payment_basepoint.write(w)?;
1996 self.common_fields.htlc_basepoint.write(w)?;
1997 self.common_fields.first_per_commitment_point.write(w)?;
1998 self.second_per_commitment_point.write(w)?;
2000 encode_tlv_stream!(w, {
2001 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
2002 (1, self.common_fields.channel_type, option),
2003 (2, self.require_confirmed_inputs, option),
2009 impl Readable for AcceptChannelV2 {
2010 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2011 let temporary_channel_id: ChannelId = Readable::read(r)?;
2012 let funding_satoshis: u64 = Readable::read(r)?;
2013 let dust_limit_satoshis: u64 = Readable::read(r)?;
2014 let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;
2015 let htlc_minimum_msat: u64 = Readable::read(r)?;
2016 let minimum_depth: u32 = Readable::read(r)?;
2017 let to_self_delay: u16 = Readable::read(r)?;
2018 let max_accepted_htlcs: u16 = Readable::read(r)?;
2019 let funding_pubkey: PublicKey = Readable::read(r)?;
2020 let revocation_basepoint: PublicKey = Readable::read(r)?;
2021 let payment_basepoint: PublicKey = Readable::read(r)?;
2022 let delayed_payment_basepoint: PublicKey = Readable::read(r)?;
2023 let htlc_basepoint: PublicKey = Readable::read(r)?;
2024 let first_per_commitment_point: PublicKey = Readable::read(r)?;
2025 let second_per_commitment_point: PublicKey = Readable::read(r)?;
2027 let mut shutdown_scriptpubkey: Option<ScriptBuf> = None;
2028 let mut channel_type: Option<ChannelTypeFeatures> = None;
2029 let mut require_confirmed_inputs: Option<()> = None;
2030 decode_tlv_stream!(r, {
2031 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
2032 (1, channel_type, option),
2033 (2, require_confirmed_inputs, option),
2036 Ok(AcceptChannelV2 {
2037 common_fields: CommonAcceptChannelFields {
2038 temporary_channel_id,
2039 dust_limit_satoshis,
2040 max_htlc_value_in_flight_msat,
2046 revocation_basepoint,
2048 delayed_payment_basepoint,
2050 first_per_commitment_point,
2051 shutdown_scriptpubkey,
2055 second_per_commitment_point,
2056 require_confirmed_inputs,
2061 impl_writeable_msg!(Stfu, {
2066 impl_writeable_msg!(Splice, {
2070 funding_feerate_perkw,
2075 impl_writeable_msg!(SpliceAck, {
2082 impl_writeable_msg!(SpliceLocked, {
2086 impl_writeable_msg!(TxAddInput, {
2094 impl_writeable_msg!(TxAddOutput, {
2101 impl_writeable_msg!(TxRemoveInput, {
2106 impl_writeable_msg!(TxRemoveOutput, {
2111 impl_writeable_msg!(TxComplete, {
2115 impl_writeable_msg!(TxSignatures, {
2121 impl_writeable_msg!(TxInitRbf, {
2124 feerate_sat_per_1000_weight,
2126 (0, funding_output_contribution, option),
2129 impl_writeable_msg!(TxAckRbf, {
2132 (0, funding_output_contribution, option),
2135 impl_writeable_msg!(TxAbort, {
2140 impl_writeable_msg!(AnnouncementSignatures, {
2147 impl_writeable_msg!(ChannelReestablish, {
2149 next_local_commitment_number,
2150 next_remote_commitment_number,
2151 your_last_per_commitment_secret,
2152 my_current_per_commitment_point,
2154 (0, next_funding_txid, option),
2157 impl_writeable_msg!(ClosingSigned,
2158 { channel_id, fee_satoshis, signature },
2159 { (1, fee_range, option) }
2162 impl_writeable!(ClosingSignedFeeRange, {
2167 #[cfg(not(taproot))]
2168 impl_writeable_msg!(CommitmentSigned, {
2175 impl_writeable_msg!(CommitmentSigned, {
2180 (2, partial_signature_with_nonce, option)
2183 impl_writeable!(DecodedOnionErrorPacket, {
2189 #[cfg(not(taproot))]
2190 impl_writeable_msg!(FundingCreated, {
2191 temporary_channel_id,
2193 funding_output_index,
2197 impl_writeable_msg!(FundingCreated, {
2198 temporary_channel_id,
2200 funding_output_index,
2203 (2, partial_signature_with_nonce, option),
2204 (4, next_local_nonce, option)
2207 #[cfg(not(taproot))]
2208 impl_writeable_msg!(FundingSigned, {
2214 impl_writeable_msg!(FundingSigned, {
2218 (2, partial_signature_with_nonce, option)
2221 impl_writeable_msg!(ChannelReady, {
2223 next_per_commitment_point,
2225 (1, short_channel_id_alias, option),
2228 impl Writeable for Init {
2229 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2230 // global_features gets the bottom 13 bits of our features, and local_features gets all of
2231 // our relevant feature bits. This keeps us compatible with old nodes.
2232 self.features.write_up_to_13(w)?;
2233 self.features.write(w)?;
2234 encode_tlv_stream!(w, {
2235 (1, self.networks.as_ref().map(|n| WithoutLength(n)), option),
2236 (3, self.remote_network_address, option),
2242 impl Readable for Init {
2243 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2244 let global_features: InitFeatures = Readable::read(r)?;
2245 let features: InitFeatures = Readable::read(r)?;
2246 let mut remote_network_address: Option<SocketAddress> = None;
2247 let mut networks: Option<WithoutLength<Vec<ChainHash>>> = None;
2248 decode_tlv_stream!(r, {
2249 (1, networks, option),
2250 (3, remote_network_address, option)
2253 features: features | global_features,
2254 networks: networks.map(|n| n.0),
2255 remote_network_address,
2260 impl Writeable for OpenChannel {
2261 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2262 self.common_fields.chain_hash.write(w)?;
2263 self.common_fields.temporary_channel_id.write(w)?;
2264 self.common_fields.funding_satoshis.write(w)?;
2265 self.push_msat.write(w)?;
2266 self.common_fields.dust_limit_satoshis.write(w)?;
2267 self.common_fields.max_htlc_value_in_flight_msat.write(w)?;
2268 self.channel_reserve_satoshis.write(w)?;
2269 self.common_fields.htlc_minimum_msat.write(w)?;
2270 self.common_fields.commitment_feerate_sat_per_1000_weight.write(w)?;
2271 self.common_fields.to_self_delay.write(w)?;
2272 self.common_fields.max_accepted_htlcs.write(w)?;
2273 self.common_fields.funding_pubkey.write(w)?;
2274 self.common_fields.revocation_basepoint.write(w)?;
2275 self.common_fields.payment_basepoint.write(w)?;
2276 self.common_fields.delayed_payment_basepoint.write(w)?;
2277 self.common_fields.htlc_basepoint.write(w)?;
2278 self.common_fields.first_per_commitment_point.write(w)?;
2279 self.common_fields.channel_flags.write(w)?;
2280 encode_tlv_stream!(w, {
2281 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
2282 (1, self.common_fields.channel_type, option),
2288 impl Readable for OpenChannel {
2289 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2290 let chain_hash: ChainHash = Readable::read(r)?;
2291 let temporary_channel_id: ChannelId = Readable::read(r)?;
2292 let funding_satoshis: u64 = Readable::read(r)?;
2293 let push_msat: u64 = Readable::read(r)?;
2294 let dust_limit_satoshis: u64 = Readable::read(r)?;
2295 let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;
2296 let channel_reserve_satoshis: u64 = Readable::read(r)?;
2297 let htlc_minimum_msat: u64 = Readable::read(r)?;
2298 let commitment_feerate_sat_per_1000_weight: u32 = Readable::read(r)?;
2299 let to_self_delay: u16 = Readable::read(r)?;
2300 let max_accepted_htlcs: u16 = Readable::read(r)?;
2301 let funding_pubkey: PublicKey = Readable::read(r)?;
2302 let revocation_basepoint: PublicKey = Readable::read(r)?;
2303 let payment_basepoint: PublicKey = Readable::read(r)?;
2304 let delayed_payment_basepoint: PublicKey = Readable::read(r)?;
2305 let htlc_basepoint: PublicKey = Readable::read(r)?;
2306 let first_per_commitment_point: PublicKey = Readable::read(r)?;
2307 let channel_flags: u8 = Readable::read(r)?;
2309 let mut shutdown_scriptpubkey: Option<ScriptBuf> = None;
2310 let mut channel_type: Option<ChannelTypeFeatures> = None;
2311 decode_tlv_stream!(r, {
2312 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
2313 (1, channel_type, option),
2316 common_fields: CommonOpenChannelFields {
2318 temporary_channel_id,
2320 dust_limit_satoshis,
2321 max_htlc_value_in_flight_msat,
2323 commitment_feerate_sat_per_1000_weight,
2327 revocation_basepoint,
2329 delayed_payment_basepoint,
2331 first_per_commitment_point,
2333 shutdown_scriptpubkey,
2337 channel_reserve_satoshis,
2342 impl Writeable for OpenChannelV2 {
2343 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2344 self.common_fields.chain_hash.write(w)?;
2345 self.common_fields.temporary_channel_id.write(w)?;
2346 self.funding_feerate_sat_per_1000_weight.write(w)?;
2347 self.common_fields.commitment_feerate_sat_per_1000_weight.write(w)?;
2348 self.common_fields.funding_satoshis.write(w)?;
2349 self.common_fields.dust_limit_satoshis.write(w)?;
2350 self.common_fields.max_htlc_value_in_flight_msat.write(w)?;
2351 self.common_fields.htlc_minimum_msat.write(w)?;
2352 self.common_fields.to_self_delay.write(w)?;
2353 self.common_fields.max_accepted_htlcs.write(w)?;
2354 self.locktime.write(w)?;
2355 self.common_fields.funding_pubkey.write(w)?;
2356 self.common_fields.revocation_basepoint.write(w)?;
2357 self.common_fields.payment_basepoint.write(w)?;
2358 self.common_fields.delayed_payment_basepoint.write(w)?;
2359 self.common_fields.htlc_basepoint.write(w)?;
2360 self.common_fields.first_per_commitment_point.write(w)?;
2361 self.second_per_commitment_point.write(w)?;
2362 self.common_fields.channel_flags.write(w)?;
2363 encode_tlv_stream!(w, {
2364 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
2365 (1, self.common_fields.channel_type, option),
2366 (2, self.require_confirmed_inputs, option),
2372 impl Readable for OpenChannelV2 {
2373 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2374 let chain_hash: ChainHash = Readable::read(r)?;
2375 let temporary_channel_id: ChannelId = Readable::read(r)?;
2376 let funding_feerate_sat_per_1000_weight: u32 = Readable::read(r)?;
2377 let commitment_feerate_sat_per_1000_weight: u32 = Readable::read(r)?;
2378 let funding_satoshis: u64 = Readable::read(r)?;
2379 let dust_limit_satoshis: u64 = Readable::read(r)?;
2380 let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;
2381 let htlc_minimum_msat: u64 = Readable::read(r)?;
2382 let to_self_delay: u16 = Readable::read(r)?;
2383 let max_accepted_htlcs: u16 = Readable::read(r)?;
2384 let locktime: u32 = Readable::read(r)?;
2385 let funding_pubkey: PublicKey = Readable::read(r)?;
2386 let revocation_basepoint: PublicKey = Readable::read(r)?;
2387 let payment_basepoint: PublicKey = Readable::read(r)?;
2388 let delayed_payment_basepoint: PublicKey = Readable::read(r)?;
2389 let htlc_basepoint: PublicKey = Readable::read(r)?;
2390 let first_per_commitment_point: PublicKey = Readable::read(r)?;
2391 let second_per_commitment_point: PublicKey = Readable::read(r)?;
2392 let channel_flags: u8 = Readable::read(r)?;
2394 let mut shutdown_scriptpubkey: Option<ScriptBuf> = None;
2395 let mut channel_type: Option<ChannelTypeFeatures> = None;
2396 let mut require_confirmed_inputs: Option<()> = None;
2397 decode_tlv_stream!(r, {
2398 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
2399 (1, channel_type, option),
2400 (2, require_confirmed_inputs, option),
2403 common_fields: CommonOpenChannelFields {
2405 temporary_channel_id,
2407 dust_limit_satoshis,
2408 max_htlc_value_in_flight_msat,
2410 commitment_feerate_sat_per_1000_weight,
2414 revocation_basepoint,
2416 delayed_payment_basepoint,
2418 first_per_commitment_point,
2420 shutdown_scriptpubkey,
2423 funding_feerate_sat_per_1000_weight,
2425 second_per_commitment_point,
2426 require_confirmed_inputs,
2431 #[cfg(not(taproot))]
2432 impl_writeable_msg!(RevokeAndACK, {
2434 per_commitment_secret,
2435 next_per_commitment_point
2439 impl_writeable_msg!(RevokeAndACK, {
2441 per_commitment_secret,
2442 next_per_commitment_point
2444 (4, next_local_nonce, option)
2447 impl_writeable_msg!(Shutdown, {
2452 impl_writeable_msg!(UpdateFailHTLC, {
2458 impl_writeable_msg!(UpdateFailMalformedHTLC, {
2465 impl_writeable_msg!(UpdateFee, {
2470 impl_writeable_msg!(UpdateFulfillHTLC, {
2476 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2477 // serialization format in a way which assumes we know the total serialized length/message end
2479 impl_writeable!(OnionErrorPacket, {
2483 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2484 // serialization format in a way which assumes we know the total serialized length/message end
2486 impl Writeable for OnionPacket {
2487 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2488 self.version.write(w)?;
2489 match self.public_key {
2490 Ok(pubkey) => pubkey.write(w)?,
2491 Err(_) => [0u8;33].write(w)?,
2493 w.write_all(&self.hop_data)?;
2494 self.hmac.write(w)?;
2499 impl Readable for OnionPacket {
2500 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2502 version: Readable::read(r)?,
2504 let mut buf = [0u8;33];
2505 r.read_exact(&mut buf)?;
2506 PublicKey::from_slice(&buf)
2508 hop_data: Readable::read(r)?,
2509 hmac: Readable::read(r)?,
2514 impl_writeable_msg!(UpdateAddHTLC, {
2520 onion_routing_packet,
2522 (0, blinding_point, option),
2523 (65537, skimmed_fee_msat, option)
2526 impl Readable for OnionMessage {
2527 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2528 let blinding_point: PublicKey = Readable::read(r)?;
2529 let len: u16 = Readable::read(r)?;
2530 let mut packet_reader = FixedLengthReader::new(r, len as u64);
2531 let onion_routing_packet: onion_message::packet::Packet =
2532 <onion_message::packet::Packet as LengthReadable>::read(&mut packet_reader)?;
2535 onion_routing_packet,
2540 impl Writeable for OnionMessage {
2541 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2542 self.blinding_point.write(w)?;
2543 let onion_packet_len = self.onion_routing_packet.serialized_length();
2544 (onion_packet_len as u16).write(w)?;
2545 self.onion_routing_packet.write(w)?;
2550 impl Writeable for FinalOnionHopData {
2551 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2552 self.payment_secret.0.write(w)?;
2553 HighZeroBytesDroppedBigSize(self.total_msat).write(w)
2557 impl Readable for FinalOnionHopData {
2558 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2559 let secret: [u8; 32] = Readable::read(r)?;
2560 let amt: HighZeroBytesDroppedBigSize<u64> = Readable::read(r)?;
2561 Ok(Self { payment_secret: PaymentSecret(secret), total_msat: amt.0 })
2565 impl Writeable for OutboundOnionPayload {
2566 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2568 Self::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } => {
2569 _encode_varint_length_prefixed_tlv!(w, {
2570 (2, HighZeroBytesDroppedBigSize(*amt_to_forward), required),
2571 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2572 (6, short_channel_id, required)
2575 Self::TrampolineEntrypoint {
2576 amt_to_forward, outgoing_cltv_value, ref multipath_trampoline_data,
2577 ref trampoline_packet
2579 _encode_varint_length_prefixed_tlv!(w, {
2580 (2, HighZeroBytesDroppedBigSize(*amt_to_forward), required),
2581 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2582 (8, multipath_trampoline_data, option),
2583 (20, trampoline_packet, required)
2587 ref payment_data, ref payment_metadata, ref keysend_preimage, sender_intended_htlc_amt_msat,
2588 cltv_expiry_height, ref custom_tlvs,
2590 // We need to update [`ln::outbound_payment::RecipientOnionFields::with_custom_tlvs`]
2591 // to reject any reserved types in the experimental range if new ones are ever
2593 let keysend_tlv = keysend_preimage.map(|preimage| (5482373484, preimage.encode()));
2594 let mut custom_tlvs: Vec<&(u64, Vec<u8>)> = custom_tlvs.iter().chain(keysend_tlv.iter()).collect();
2595 custom_tlvs.sort_unstable_by_key(|(typ, _)| *typ);
2596 _encode_varint_length_prefixed_tlv!(w, {
2597 (2, HighZeroBytesDroppedBigSize(*sender_intended_htlc_amt_msat), required),
2598 (4, HighZeroBytesDroppedBigSize(*cltv_expiry_height), required),
2599 (8, payment_data, option),
2600 (16, payment_metadata.as_ref().map(|m| WithoutLength(m)), option)
2601 }, custom_tlvs.iter());
2603 Self::BlindedForward { encrypted_tlvs, intro_node_blinding_point } => {
2604 _encode_varint_length_prefixed_tlv!(w, {
2605 (10, *encrypted_tlvs, required_vec),
2606 (12, intro_node_blinding_point, option)
2609 Self::BlindedReceive {
2610 sender_intended_htlc_amt_msat, total_msat, cltv_expiry_height, encrypted_tlvs,
2611 intro_node_blinding_point, keysend_preimage, ref custom_tlvs,
2613 // We need to update [`ln::outbound_payment::RecipientOnionFields::with_custom_tlvs`]
2614 // to reject any reserved types in the experimental range if new ones are ever
2616 let keysend_tlv = keysend_preimage.map(|preimage| (5482373484, preimage.encode()));
2617 let mut custom_tlvs: Vec<&(u64, Vec<u8>)> = custom_tlvs.iter().chain(keysend_tlv.iter()).collect();
2618 custom_tlvs.sort_unstable_by_key(|(typ, _)| *typ);
2619 _encode_varint_length_prefixed_tlv!(w, {
2620 (2, HighZeroBytesDroppedBigSize(*sender_intended_htlc_amt_msat), required),
2621 (4, HighZeroBytesDroppedBigSize(*cltv_expiry_height), required),
2622 (10, *encrypted_tlvs, required_vec),
2623 (12, intro_node_blinding_point, option),
2624 (18, HighZeroBytesDroppedBigSize(*total_msat), required)
2625 }, custom_tlvs.iter());
2632 impl Writeable for OutboundTrampolinePayload {
2633 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2635 Self::Forward { amt_to_forward, outgoing_cltv_value, outgoing_node_id } => {
2636 _encode_varint_length_prefixed_tlv!(w, {
2637 (2, HighZeroBytesDroppedBigSize(*amt_to_forward), required),
2638 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2639 (14, outgoing_node_id, required)
2648 impl<NS: Deref> ReadableArgs<(Option<PublicKey>, &NS)> for InboundOnionPayload where NS::Target: NodeSigner {
2649 fn read<R: Read>(r: &mut R, args: (Option<PublicKey>, &NS)) -> Result<Self, DecodeError> {
2650 let (update_add_blinding_point, node_signer) = args;
2653 let mut cltv_value = None;
2654 let mut short_id: Option<u64> = None;
2655 let mut payment_data: Option<FinalOnionHopData> = None;
2656 let mut encrypted_tlvs_opt: Option<WithoutLength<Vec<u8>>> = None;
2657 let mut intro_node_blinding_point = None;
2658 let mut payment_metadata: Option<WithoutLength<Vec<u8>>> = None;
2659 let mut total_msat = None;
2660 let mut keysend_preimage: Option<PaymentPreimage> = None;
2661 let mut custom_tlvs = Vec::new();
2663 let tlv_len = BigSize::read(r)?;
2664 let rd = FixedLengthReader::new(r, tlv_len.0);
2665 decode_tlv_stream_with_custom_tlv_decode!(rd, {
2666 (2, amt, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2667 (4, cltv_value, (option, encoding: (u32, HighZeroBytesDroppedBigSize))),
2668 (6, short_id, option),
2669 (8, payment_data, option),
2670 (10, encrypted_tlvs_opt, option),
2671 (12, intro_node_blinding_point, option),
2672 (16, payment_metadata, option),
2673 (18, total_msat, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2674 // See https://github.com/lightning/blips/blob/master/blip-0003.md
2675 (5482373484, keysend_preimage, option)
2676 }, |msg_type: u64, msg_reader: &mut FixedLengthReader<_>| -> Result<bool, DecodeError> {
2677 if msg_type < 1 << 16 { return Ok(false) }
2678 let mut value = Vec::new();
2679 msg_reader.read_to_end(&mut value)?;
2680 custom_tlvs.push((msg_type, value));
2684 if amt.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2685 if intro_node_blinding_point.is_some() && update_add_blinding_point.is_some() {
2686 return Err(DecodeError::InvalidValue)
2689 if let Some(blinding_point) = intro_node_blinding_point.or(update_add_blinding_point) {
2690 if short_id.is_some() || payment_data.is_some() || payment_metadata.is_some() {
2691 return Err(DecodeError::InvalidValue)
2693 let enc_tlvs = encrypted_tlvs_opt.ok_or(DecodeError::InvalidValue)?.0;
2694 let enc_tlvs_ss = node_signer.ecdh(Recipient::Node, &blinding_point, None)
2695 .map_err(|_| DecodeError::InvalidValue)?;
2696 let rho = onion_utils::gen_rho_from_shared_secret(&enc_tlvs_ss.secret_bytes());
2697 let mut s = Cursor::new(&enc_tlvs);
2698 let mut reader = FixedLengthReader::new(&mut s, enc_tlvs.len() as u64);
2699 match ChaChaPolyReadAdapter::read(&mut reader, rho)? {
2700 ChaChaPolyReadAdapter { readable: BlindedPaymentTlvs::Forward(ForwardTlvs {
2701 short_channel_id, payment_relay, payment_constraints, features
2703 if amt.is_some() || cltv_value.is_some() || total_msat.is_some() ||
2704 keysend_preimage.is_some()
2706 return Err(DecodeError::InvalidValue)
2708 Ok(Self::BlindedForward {
2711 payment_constraints,
2713 intro_node_blinding_point,
2716 ChaChaPolyReadAdapter { readable: BlindedPaymentTlvs::Receive(ReceiveTlvs {
2717 payment_secret, payment_constraints, payment_context
2719 if total_msat.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2720 Ok(Self::BlindedReceive {
2721 sender_intended_htlc_amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2722 total_msat: total_msat.ok_or(DecodeError::InvalidValue)?,
2723 cltv_expiry_height: cltv_value.ok_or(DecodeError::InvalidValue)?,
2725 payment_constraints,
2727 intro_node_blinding_point,
2733 } else if let Some(short_channel_id) = short_id {
2734 if payment_data.is_some() || payment_metadata.is_some() || encrypted_tlvs_opt.is_some() ||
2735 total_msat.is_some()
2736 { return Err(DecodeError::InvalidValue) }
2739 amt_to_forward: amt.ok_or(DecodeError::InvalidValue)?,
2740 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2743 if encrypted_tlvs_opt.is_some() || total_msat.is_some() {
2744 return Err(DecodeError::InvalidValue)
2746 if let Some(data) = &payment_data {
2747 if data.total_msat > MAX_VALUE_MSAT {
2748 return Err(DecodeError::InvalidValue);
2753 payment_metadata: payment_metadata.map(|w| w.0),
2755 sender_intended_htlc_amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2756 cltv_expiry_height: cltv_value.ok_or(DecodeError::InvalidValue)?,
2763 impl Writeable for Ping {
2764 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2765 self.ponglen.write(w)?;
2766 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2771 impl Readable for Ping {
2772 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2774 ponglen: Readable::read(r)?,
2776 let byteslen = Readable::read(r)?;
2777 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2784 impl Writeable for Pong {
2785 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2786 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2791 impl Readable for Pong {
2792 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2795 let byteslen = Readable::read(r)?;
2796 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2803 impl Writeable for UnsignedChannelAnnouncement {
2804 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2805 self.features.write(w)?;
2806 self.chain_hash.write(w)?;
2807 self.short_channel_id.write(w)?;
2808 self.node_id_1.write(w)?;
2809 self.node_id_2.write(w)?;
2810 self.bitcoin_key_1.write(w)?;
2811 self.bitcoin_key_2.write(w)?;
2812 w.write_all(&self.excess_data[..])?;
2817 impl Readable for UnsignedChannelAnnouncement {
2818 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2820 features: Readable::read(r)?,
2821 chain_hash: Readable::read(r)?,
2822 short_channel_id: Readable::read(r)?,
2823 node_id_1: Readable::read(r)?,
2824 node_id_2: Readable::read(r)?,
2825 bitcoin_key_1: Readable::read(r)?,
2826 bitcoin_key_2: Readable::read(r)?,
2827 excess_data: read_to_end(r)?,
2832 impl_writeable!(ChannelAnnouncement, {
2835 bitcoin_signature_1,
2836 bitcoin_signature_2,
2840 impl Writeable for UnsignedChannelUpdate {
2841 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2842 // `message_flags` used to indicate presence of `htlc_maximum_msat`, but was deprecated in the spec.
2843 const MESSAGE_FLAGS: u8 = 1;
2844 self.chain_hash.write(w)?;
2845 self.short_channel_id.write(w)?;
2846 self.timestamp.write(w)?;
2847 let all_flags = self.flags as u16 | ((MESSAGE_FLAGS as u16) << 8);
2848 all_flags.write(w)?;
2849 self.cltv_expiry_delta.write(w)?;
2850 self.htlc_minimum_msat.write(w)?;
2851 self.fee_base_msat.write(w)?;
2852 self.fee_proportional_millionths.write(w)?;
2853 self.htlc_maximum_msat.write(w)?;
2854 w.write_all(&self.excess_data[..])?;
2859 impl Readable for UnsignedChannelUpdate {
2860 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2862 chain_hash: Readable::read(r)?,
2863 short_channel_id: Readable::read(r)?,
2864 timestamp: Readable::read(r)?,
2866 let flags: u16 = Readable::read(r)?;
2867 // Note: we ignore the `message_flags` for now, since it was deprecated by the spec.
2870 cltv_expiry_delta: Readable::read(r)?,
2871 htlc_minimum_msat: Readable::read(r)?,
2872 fee_base_msat: Readable::read(r)?,
2873 fee_proportional_millionths: Readable::read(r)?,
2874 htlc_maximum_msat: Readable::read(r)?,
2875 excess_data: read_to_end(r)?,
2880 impl_writeable!(ChannelUpdate, {
2885 impl Writeable for ErrorMessage {
2886 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2887 self.channel_id.write(w)?;
2888 (self.data.len() as u16).write(w)?;
2889 w.write_all(self.data.as_bytes())?;
2894 impl Readable for ErrorMessage {
2895 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2897 channel_id: Readable::read(r)?,
2899 let sz: usize = <u16 as Readable>::read(r)? as usize;
2900 let mut data = Vec::with_capacity(sz);
2902 r.read_exact(&mut data)?;
2903 match String::from_utf8(data) {
2905 Err(_) => return Err(DecodeError::InvalidValue),
2912 impl Writeable for WarningMessage {
2913 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2914 self.channel_id.write(w)?;
2915 (self.data.len() as u16).write(w)?;
2916 w.write_all(self.data.as_bytes())?;
2921 impl Readable for WarningMessage {
2922 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2924 channel_id: Readable::read(r)?,
2926 let sz: usize = <u16 as Readable>::read(r)? as usize;
2927 let mut data = Vec::with_capacity(sz);
2929 r.read_exact(&mut data)?;
2930 match String::from_utf8(data) {
2932 Err(_) => return Err(DecodeError::InvalidValue),
2939 impl Writeable for UnsignedNodeAnnouncement {
2940 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2941 self.features.write(w)?;
2942 self.timestamp.write(w)?;
2943 self.node_id.write(w)?;
2944 w.write_all(&self.rgb)?;
2945 self.alias.write(w)?;
2947 let mut addr_len = 0;
2948 for addr in self.addresses.iter() {
2949 addr_len += 1 + addr.len();
2951 (addr_len + self.excess_address_data.len() as u16).write(w)?;
2952 for addr in self.addresses.iter() {
2955 w.write_all(&self.excess_address_data[..])?;
2956 w.write_all(&self.excess_data[..])?;
2961 impl Readable for UnsignedNodeAnnouncement {
2962 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2963 let features: NodeFeatures = Readable::read(r)?;
2964 let timestamp: u32 = Readable::read(r)?;
2965 let node_id: NodeId = Readable::read(r)?;
2966 let mut rgb = [0; 3];
2967 r.read_exact(&mut rgb)?;
2968 let alias: NodeAlias = Readable::read(r)?;
2970 let addr_len: u16 = Readable::read(r)?;
2971 let mut addresses: Vec<SocketAddress> = Vec::new();
2972 let mut addr_readpos = 0;
2973 let mut excess = false;
2974 let mut excess_byte = 0;
2976 if addr_len <= addr_readpos { break; }
2977 match Readable::read(r) {
2979 if addr_len < addr_readpos + 1 + addr.len() {
2980 return Err(DecodeError::BadLengthDescriptor);
2982 addr_readpos += (1 + addr.len()) as u16;
2983 addresses.push(addr);
2985 Ok(Err(unknown_descriptor)) => {
2987 excess_byte = unknown_descriptor;
2990 Err(DecodeError::ShortRead) => return Err(DecodeError::BadLengthDescriptor),
2991 Err(e) => return Err(e),
2995 let mut excess_data = vec![];
2996 let excess_address_data = if addr_readpos < addr_len {
2997 let mut excess_address_data = vec![0; (addr_len - addr_readpos) as usize];
2998 r.read_exact(&mut excess_address_data[if excess { 1 } else { 0 }..])?;
3000 excess_address_data[0] = excess_byte;
3005 excess_data.push(excess_byte);
3009 excess_data.extend(read_to_end(r)?.iter());
3010 Ok(UnsignedNodeAnnouncement {
3017 excess_address_data,
3023 impl_writeable!(NodeAnnouncement, {
3028 impl Readable for QueryShortChannelIds {
3029 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
3030 let chain_hash: ChainHash = Readable::read(r)?;
3032 let encoding_len: u16 = Readable::read(r)?;
3033 let encoding_type: u8 = Readable::read(r)?;
3035 // Must be encoding_type=0 uncompressed serialization. We do not
3036 // support encoding_type=1 zlib serialization.
3037 if encoding_type != EncodingType::Uncompressed as u8 {
3038 return Err(DecodeError::UnsupportedCompression);
3041 // We expect the encoding_len to always includes the 1-byte
3042 // encoding_type and that short_channel_ids are 8-bytes each
3043 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
3044 return Err(DecodeError::InvalidValue);
3047 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
3048 // less the 1-byte encoding_type
3049 let short_channel_id_count: u16 = (encoding_len - 1)/8;
3050 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
3051 for _ in 0..short_channel_id_count {
3052 short_channel_ids.push(Readable::read(r)?);
3055 Ok(QueryShortChannelIds {
3062 impl Writeable for QueryShortChannelIds {
3063 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
3064 // Calculated from 1-byte encoding_type plus 8-bytes per short_channel_id
3065 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
3067 self.chain_hash.write(w)?;
3068 encoding_len.write(w)?;
3070 // We only support type=0 uncompressed serialization
3071 (EncodingType::Uncompressed as u8).write(w)?;
3073 for scid in self.short_channel_ids.iter() {
3081 impl_writeable_msg!(ReplyShortChannelIdsEnd, {
3086 impl QueryChannelRange {
3087 /// Calculates the overflow safe ending block height for the query.
3089 /// Overflow returns `0xffffffff`, otherwise returns `first_blocknum + number_of_blocks`.
3090 pub fn end_blocknum(&self) -> u32 {
3091 match self.first_blocknum.checked_add(self.number_of_blocks) {
3092 Some(block) => block,
3093 None => u32::max_value(),
3098 impl_writeable_msg!(QueryChannelRange, {
3104 impl Readable for ReplyChannelRange {
3105 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
3106 let chain_hash: ChainHash = Readable::read(r)?;
3107 let first_blocknum: u32 = Readable::read(r)?;
3108 let number_of_blocks: u32 = Readable::read(r)?;
3109 let sync_complete: bool = Readable::read(r)?;
3111 let encoding_len: u16 = Readable::read(r)?;
3112 let encoding_type: u8 = Readable::read(r)?;
3114 // Must be encoding_type=0 uncompressed serialization. We do not
3115 // support encoding_type=1 zlib serialization.
3116 if encoding_type != EncodingType::Uncompressed as u8 {
3117 return Err(DecodeError::UnsupportedCompression);
3120 // We expect the encoding_len to always includes the 1-byte
3121 // encoding_type and that short_channel_ids are 8-bytes each
3122 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
3123 return Err(DecodeError::InvalidValue);
3126 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
3127 // less the 1-byte encoding_type
3128 let short_channel_id_count: u16 = (encoding_len - 1)/8;
3129 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
3130 for _ in 0..short_channel_id_count {
3131 short_channel_ids.push(Readable::read(r)?);
3134 Ok(ReplyChannelRange {
3144 impl Writeable for ReplyChannelRange {
3145 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
3146 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
3147 self.chain_hash.write(w)?;
3148 self.first_blocknum.write(w)?;
3149 self.number_of_blocks.write(w)?;
3150 self.sync_complete.write(w)?;
3152 encoding_len.write(w)?;
3153 (EncodingType::Uncompressed as u8).write(w)?;
3154 for scid in self.short_channel_ids.iter() {
3162 impl_writeable_msg!(GossipTimestampFilter, {
3170 use bitcoin::{Transaction, TxIn, ScriptBuf, Sequence, Witness, TxOut};
3171 use hex::DisplayHex;
3172 use crate::ln::{PaymentPreimage, PaymentHash, PaymentSecret};
3173 use crate::ln::ChannelId;
3174 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
3175 use crate::ln::msgs::{self, FinalOnionHopData, OnionErrorPacket, CommonOpenChannelFields, CommonAcceptChannelFields, TrampolineOnionPacket};
3176 use crate::ln::msgs::SocketAddress;
3177 use crate::routing::gossip::{NodeAlias, NodeId};
3178 use crate::util::ser::{BigSize, Hostname, Readable, ReadableArgs, TransactionU16LenLimited, Writeable};
3179 use crate::util::test_utils;
3181 use bitcoin::hashes::hex::FromHex;
3182 use bitcoin::address::Address;
3183 use bitcoin::network::constants::Network;
3184 use bitcoin::blockdata::constants::ChainHash;
3185 use bitcoin::blockdata::script::Builder;
3186 use bitcoin::blockdata::opcodes;
3187 use bitcoin::hash_types::Txid;
3188 use bitcoin::locktime::absolute::LockTime;
3190 use bitcoin::secp256k1::{PublicKey,SecretKey};
3191 use bitcoin::secp256k1::{Secp256k1, Message};
3193 use crate::io::{self, Cursor};
3194 use crate::prelude::*;
3195 use core::str::FromStr;
3196 use crate::chain::transaction::OutPoint;
3198 #[cfg(feature = "std")]
3199 use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6, ToSocketAddrs};
3200 #[cfg(feature = "std")]
3201 use crate::ln::msgs::SocketAddressParseError;
3204 fn encoding_channel_reestablish() {
3206 let secp_ctx = Secp256k1::new();
3207 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&<Vec<u8>>::from_hex("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
3210 let cr = msgs::ChannelReestablish {
3211 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]),
3212 next_local_commitment_number: 3,
3213 next_remote_commitment_number: 4,
3214 your_last_per_commitment_secret: [9;32],
3215 my_current_per_commitment_point: public_key,
3216 next_funding_txid: None,
3219 let encoded_value = cr.encode();
3223 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
3224 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
3225 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
3226 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
3227 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
3233 fn encoding_channel_reestablish_with_next_funding_txid() {
3235 let secp_ctx = Secp256k1::new();
3236 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&<Vec<u8>>::from_hex("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
3239 let cr = msgs::ChannelReestablish {
3240 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]),
3241 next_local_commitment_number: 3,
3242 next_remote_commitment_number: 4,
3243 your_last_per_commitment_secret: [9;32],
3244 my_current_per_commitment_point: public_key,
3245 next_funding_txid: Some(Txid::from_raw_hash(bitcoin::hashes::Hash::from_slice(&[
3246 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,
3250 let encoded_value = cr.encode();
3254 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
3255 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
3256 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
3257 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
3258 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
3259 0, // Type (next_funding_txid)
3261 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
3266 macro_rules! get_keys_from {
3267 ($slice: expr, $secp_ctx: expr) => {
3269 let privkey = SecretKey::from_slice(&<Vec<u8>>::from_hex($slice).unwrap()[..]).unwrap();
3270 let pubkey = PublicKey::from_secret_key(&$secp_ctx, &privkey);
3276 macro_rules! get_sig_on {
3277 ($privkey: expr, $ctx: expr, $string: expr) => {
3279 let sighash = Message::from_slice(&$string.into_bytes()[..]).unwrap();
3280 $ctx.sign_ecdsa(&sighash, &$privkey)
3286 fn encoding_announcement_signatures() {
3287 let secp_ctx = Secp256k1::new();
3288 let (privkey, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3289 let sig_1 = get_sig_on!(privkey, secp_ctx, String::from("01010101010101010101010101010101"));
3290 let sig_2 = get_sig_on!(privkey, secp_ctx, String::from("02020202020202020202020202020202"));
3291 let announcement_signatures = msgs::AnnouncementSignatures {
3292 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]),
3293 short_channel_id: 2316138423780173,
3294 node_signature: sig_1,
3295 bitcoin_signature: sig_2,
3298 let encoded_value = announcement_signatures.encode();
3299 assert_eq!(encoded_value, <Vec<u8>>::from_hex("040000000000000005000000000000000600000000000000070000000000000000083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073acf9953cef4700860f5967838eba2bae89288ad188ebf8b20bf995c3ea53a26df1876d0a3a0e13172ba286a673140190c02ba9da60a2e43a745188c8a83c7f3ef").unwrap());
3302 fn do_encoding_channel_announcement(unknown_features_bits: bool, excess_data: bool) {
3303 let secp_ctx = Secp256k1::new();
3304 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3305 let (privkey_2, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3306 let (privkey_3, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3307 let (privkey_4, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3308 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3309 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
3310 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
3311 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
3312 let mut features = ChannelFeatures::empty();
3313 if unknown_features_bits {
3314 features = ChannelFeatures::from_le_bytes(vec![0xFF, 0xFF]);
3316 let unsigned_channel_announcement = msgs::UnsignedChannelAnnouncement {
3318 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3319 short_channel_id: 2316138423780173,
3320 node_id_1: NodeId::from_pubkey(&pubkey_1),
3321 node_id_2: NodeId::from_pubkey(&pubkey_2),
3322 bitcoin_key_1: NodeId::from_pubkey(&pubkey_3),
3323 bitcoin_key_2: NodeId::from_pubkey(&pubkey_4),
3324 excess_data: if excess_data { vec![10, 0, 0, 20, 0, 0, 30, 0, 0, 40] } else { Vec::new() },
3326 let channel_announcement = msgs::ChannelAnnouncement {
3327 node_signature_1: sig_1,
3328 node_signature_2: sig_2,
3329 bitcoin_signature_1: sig_3,
3330 bitcoin_signature_2: sig_4,
3331 contents: unsigned_channel_announcement,
3333 let encoded_value = channel_announcement.encode();
3334 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a1735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap();
3335 if unknown_features_bits {
3336 target_value.append(&mut <Vec<u8>>::from_hex("0002ffff").unwrap());
3338 target_value.append(&mut <Vec<u8>>::from_hex("0000").unwrap());
3340 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3341 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
3343 target_value.append(&mut <Vec<u8>>::from_hex("0a00001400001e000028").unwrap());
3345 assert_eq!(encoded_value, target_value);
3349 fn encoding_channel_announcement() {
3350 do_encoding_channel_announcement(true, false);
3351 do_encoding_channel_announcement(false, true);
3352 do_encoding_channel_announcement(false, false);
3353 do_encoding_channel_announcement(true, true);
3356 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) {
3357 let secp_ctx = Secp256k1::new();
3358 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3359 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3360 let features = if unknown_features_bits {
3361 NodeFeatures::from_le_bytes(vec![0xFF, 0xFF])
3363 // Set to some features we may support
3364 NodeFeatures::from_le_bytes(vec![2 | 1 << 5])
3366 let mut addresses = Vec::new();
3368 addresses.push(SocketAddress::TcpIpV4 {
3369 addr: [255, 254, 253, 252],
3374 addresses.push(SocketAddress::TcpIpV6 {
3375 addr: [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240],
3380 addresses.push(msgs::SocketAddress::OnionV2(
3381 [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 38, 7]
3385 addresses.push(msgs::SocketAddress::OnionV3 {
3386 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],
3393 addresses.push(SocketAddress::Hostname {
3394 hostname: Hostname::try_from(String::from("host")).unwrap(),
3398 let mut addr_len = 0;
3399 for addr in &addresses {
3400 addr_len += addr.len() + 1;
3402 let unsigned_node_announcement = msgs::UnsignedNodeAnnouncement {
3404 timestamp: 20190119,
3405 node_id: NodeId::from_pubkey(&pubkey_1),
3407 alias: NodeAlias([16;32]),
3409 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() },
3410 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() },
3412 addr_len += unsigned_node_announcement.excess_address_data.len() as u16;
3413 let node_announcement = msgs::NodeAnnouncement {
3415 contents: unsigned_node_announcement,
3417 let encoded_value = node_announcement.encode();
3418 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3419 if unknown_features_bits {
3420 target_value.append(&mut <Vec<u8>>::from_hex("0002ffff").unwrap());
3422 target_value.append(&mut <Vec<u8>>::from_hex("000122").unwrap());
3424 target_value.append(&mut <Vec<u8>>::from_hex("013413a7031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f2020201010101010101010101010101010101010101010101010101010101010101010").unwrap());
3425 target_value.append(&mut vec![(addr_len >> 8) as u8, addr_len as u8]);
3427 target_value.append(&mut <Vec<u8>>::from_hex("01fffefdfc2607").unwrap());
3430 target_value.append(&mut <Vec<u8>>::from_hex("02fffefdfcfbfaf9f8f7f6f5f4f3f2f1f02607").unwrap());
3433 target_value.append(&mut <Vec<u8>>::from_hex("03fffefdfcfbfaf9f8f7f62607").unwrap());
3436 target_value.append(&mut <Vec<u8>>::from_hex("04fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0efeeedecebeae9e8e7e6e5e4e3e2e1e00020102607").unwrap());
3439 target_value.append(&mut <Vec<u8>>::from_hex("0504686f73742607").unwrap());
3441 if excess_address_data {
3442 target_value.append(&mut <Vec<u8>>::from_hex("216c280b5395a2546e7e4b2663e04f811622f15a4f92e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d269").unwrap());
3445 target_value.append(&mut <Vec<u8>>::from_hex("3b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
3447 assert_eq!(encoded_value, target_value);
3451 fn encoding_node_announcement() {
3452 do_encoding_node_announcement(true, true, true, true, true, true, true, true);
3453 do_encoding_node_announcement(false, false, false, false, false, false, false, false);
3454 do_encoding_node_announcement(false, true, false, false, false, false, false, false);
3455 do_encoding_node_announcement(false, false, true, false, false, false, false, false);
3456 do_encoding_node_announcement(false, false, false, true, false, false, false, false);
3457 do_encoding_node_announcement(false, false, false, false, true, false, false, false);
3458 do_encoding_node_announcement(false, false, false, false, false, true, false, false);
3459 do_encoding_node_announcement(false, false, false, false, false, false, true, false);
3460 do_encoding_node_announcement(false, true, false, true, false, false, true, false);
3461 do_encoding_node_announcement(false, false, true, false, true, false, false, false);
3464 fn do_encoding_channel_update(direction: bool, disable: bool, excess_data: bool) {
3465 let secp_ctx = Secp256k1::new();
3466 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3467 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3468 let unsigned_channel_update = msgs::UnsignedChannelUpdate {
3469 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3470 short_channel_id: 2316138423780173,
3471 timestamp: 20190119,
3472 flags: if direction { 1 } else { 0 } | if disable { 1 << 1 } else { 0 },
3473 cltv_expiry_delta: 144,
3474 htlc_minimum_msat: 1000000,
3475 htlc_maximum_msat: 131355275467161,
3476 fee_base_msat: 10000,
3477 fee_proportional_millionths: 20,
3478 excess_data: if excess_data { vec![0, 0, 0, 0, 59, 154, 202, 0] } else { Vec::new() }
3480 let channel_update = msgs::ChannelUpdate {
3482 contents: unsigned_channel_update
3484 let encoded_value = channel_update.encode();
3485 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3486 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3487 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d013413a7").unwrap());
3488 target_value.append(&mut <Vec<u8>>::from_hex("01").unwrap());
3489 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3491 let flag = target_value.last_mut().unwrap();
3495 let flag = target_value.last_mut().unwrap();
3496 *flag = *flag | 1 << 1;
3498 target_value.append(&mut <Vec<u8>>::from_hex("009000000000000f42400000271000000014").unwrap());
3499 target_value.append(&mut <Vec<u8>>::from_hex("0000777788889999").unwrap());
3501 target_value.append(&mut <Vec<u8>>::from_hex("000000003b9aca00").unwrap());
3503 assert_eq!(encoded_value, target_value);
3507 fn encoding_channel_update() {
3508 do_encoding_channel_update(false, false, false);
3509 do_encoding_channel_update(false, false, true);
3510 do_encoding_channel_update(true, false, false);
3511 do_encoding_channel_update(true, false, true);
3512 do_encoding_channel_update(false, true, false);
3513 do_encoding_channel_update(false, true, true);
3514 do_encoding_channel_update(true, true, false);
3515 do_encoding_channel_update(true, true, true);
3518 fn do_encoding_open_channel(random_bit: bool, shutdown: bool, incl_chan_type: bool) {
3519 let secp_ctx = Secp256k1::new();
3520 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3521 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3522 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3523 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3524 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3525 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3526 let open_channel = msgs::OpenChannel {
3527 common_fields: CommonOpenChannelFields {
3528 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3529 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3530 funding_satoshis: 1311768467284833366,
3531 dust_limit_satoshis: 3608586615801332854,
3532 max_htlc_value_in_flight_msat: 8517154655701053848,
3533 htlc_minimum_msat: 2316138423780173,
3534 commitment_feerate_sat_per_1000_weight: 821716,
3535 to_self_delay: 49340,
3536 max_accepted_htlcs: 49340,
3537 funding_pubkey: pubkey_1,
3538 revocation_basepoint: pubkey_2,
3539 payment_basepoint: pubkey_3,
3540 delayed_payment_basepoint: pubkey_4,
3541 htlc_basepoint: pubkey_5,
3542 first_per_commitment_point: pubkey_6,
3543 channel_flags: if random_bit { 1 << 5 } else { 0 },
3544 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3545 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3547 push_msat: 2536655962884945560,
3548 channel_reserve_satoshis: 8665828695742877976,
3550 let encoded_value = open_channel.encode();
3551 let mut target_value = Vec::new();
3552 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3553 target_value.append(&mut <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202021234567890123456233403289122369832144668701144767633030896203198784335490624111800083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3555 target_value.append(&mut <Vec<u8>>::from_hex("20").unwrap());
3557 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3560 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3563 target_value.append(&mut <Vec<u8>>::from_hex("0100").unwrap());
3565 assert_eq!(encoded_value, target_value);
3569 fn encoding_open_channel() {
3570 do_encoding_open_channel(false, false, false);
3571 do_encoding_open_channel(false, false, true);
3572 do_encoding_open_channel(false, true, false);
3573 do_encoding_open_channel(false, true, true);
3574 do_encoding_open_channel(true, false, false);
3575 do_encoding_open_channel(true, false, true);
3576 do_encoding_open_channel(true, true, false);
3577 do_encoding_open_channel(true, true, true);
3580 fn do_encoding_open_channelv2(random_bit: bool, shutdown: bool, incl_chan_type: bool, require_confirmed_inputs: bool) {
3581 let secp_ctx = Secp256k1::new();
3582 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3583 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3584 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3585 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3586 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3587 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3588 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3589 let open_channelv2 = msgs::OpenChannelV2 {
3590 common_fields: CommonOpenChannelFields {
3591 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3592 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3593 commitment_feerate_sat_per_1000_weight: 821716,
3594 funding_satoshis: 1311768467284833366,
3595 dust_limit_satoshis: 3608586615801332854,
3596 max_htlc_value_in_flight_msat: 8517154655701053848,
3597 htlc_minimum_msat: 2316138423780173,
3598 to_self_delay: 49340,
3599 max_accepted_htlcs: 49340,
3600 funding_pubkey: pubkey_1,
3601 revocation_basepoint: pubkey_2,
3602 payment_basepoint: pubkey_3,
3603 delayed_payment_basepoint: pubkey_4,
3604 htlc_basepoint: pubkey_5,
3605 first_per_commitment_point: pubkey_6,
3606 channel_flags: if random_bit { 1 << 5 } else { 0 },
3607 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3608 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3610 funding_feerate_sat_per_1000_weight: 821716,
3611 locktime: 305419896,
3612 second_per_commitment_point: pubkey_7,
3613 require_confirmed_inputs: if require_confirmed_inputs { Some(()) } else { None },
3615 let encoded_value = open_channelv2.encode();
3616 let mut target_value = Vec::new();
3617 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3618 target_value.append(&mut <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap());
3619 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap());
3620 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap());
3621 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap());
3622 target_value.append(&mut <Vec<u8>>::from_hex("3214466870114476").unwrap());
3623 target_value.append(&mut <Vec<u8>>::from_hex("7633030896203198").unwrap());
3624 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d").unwrap());
3625 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap());
3626 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap());
3627 target_value.append(&mut <Vec<u8>>::from_hex("12345678").unwrap());
3628 target_value.append(&mut <Vec<u8>>::from_hex("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap());
3629 target_value.append(&mut <Vec<u8>>::from_hex("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap());
3630 target_value.append(&mut <Vec<u8>>::from_hex("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap());
3631 target_value.append(&mut <Vec<u8>>::from_hex("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
3632 target_value.append(&mut <Vec<u8>>::from_hex("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap());
3633 target_value.append(&mut <Vec<u8>>::from_hex("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3634 target_value.append(&mut <Vec<u8>>::from_hex("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap());
3637 target_value.append(&mut <Vec<u8>>::from_hex("20").unwrap());
3639 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3642 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3645 target_value.append(&mut <Vec<u8>>::from_hex("0100").unwrap());
3647 if require_confirmed_inputs {
3648 target_value.append(&mut <Vec<u8>>::from_hex("0200").unwrap());
3650 assert_eq!(encoded_value, target_value);
3654 fn encoding_open_channelv2() {
3655 do_encoding_open_channelv2(false, false, false, false);
3656 do_encoding_open_channelv2(false, false, false, true);
3657 do_encoding_open_channelv2(false, false, true, false);
3658 do_encoding_open_channelv2(false, false, true, true);
3659 do_encoding_open_channelv2(false, true, false, false);
3660 do_encoding_open_channelv2(false, true, false, true);
3661 do_encoding_open_channelv2(false, true, true, false);
3662 do_encoding_open_channelv2(false, true, true, true);
3663 do_encoding_open_channelv2(true, false, false, false);
3664 do_encoding_open_channelv2(true, false, false, true);
3665 do_encoding_open_channelv2(true, false, true, false);
3666 do_encoding_open_channelv2(true, false, true, true);
3667 do_encoding_open_channelv2(true, true, false, false);
3668 do_encoding_open_channelv2(true, true, false, true);
3669 do_encoding_open_channelv2(true, true, true, false);
3670 do_encoding_open_channelv2(true, true, true, true);
3673 fn do_encoding_accept_channel(shutdown: bool) {
3674 let secp_ctx = Secp256k1::new();
3675 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3676 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3677 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3678 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3679 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3680 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3681 let accept_channel = msgs::AcceptChannel {
3682 common_fields: CommonAcceptChannelFields {
3683 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3684 dust_limit_satoshis: 1311768467284833366,
3685 max_htlc_value_in_flight_msat: 2536655962884945560,
3686 htlc_minimum_msat: 2316138423780173,
3687 minimum_depth: 821716,
3688 to_self_delay: 49340,
3689 max_accepted_htlcs: 49340,
3690 funding_pubkey: pubkey_1,
3691 revocation_basepoint: pubkey_2,
3692 payment_basepoint: pubkey_3,
3693 delayed_payment_basepoint: pubkey_4,
3694 htlc_basepoint: pubkey_5,
3695 first_per_commitment_point: pubkey_6,
3696 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3699 channel_reserve_satoshis: 3608586615801332854,
3701 next_local_nonce: None,
3703 let encoded_value = accept_channel.encode();
3704 let mut target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020212345678901234562334032891223698321446687011447600083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap();
3706 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3708 assert_eq!(encoded_value, target_value);
3712 fn encoding_accept_channel() {
3713 do_encoding_accept_channel(false);
3714 do_encoding_accept_channel(true);
3717 fn do_encoding_accept_channelv2(shutdown: bool) {
3718 let secp_ctx = Secp256k1::new();
3719 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3720 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3721 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3722 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3723 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3724 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3725 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3726 let accept_channelv2 = msgs::AcceptChannelV2 {
3727 common_fields: CommonAcceptChannelFields {
3728 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3729 dust_limit_satoshis: 1311768467284833366,
3730 max_htlc_value_in_flight_msat: 2536655962884945560,
3731 htlc_minimum_msat: 2316138423780173,
3732 minimum_depth: 821716,
3733 to_self_delay: 49340,
3734 max_accepted_htlcs: 49340,
3735 funding_pubkey: pubkey_1,
3736 revocation_basepoint: pubkey_2,
3737 payment_basepoint: pubkey_3,
3738 delayed_payment_basepoint: pubkey_4,
3739 htlc_basepoint: pubkey_5,
3740 first_per_commitment_point: pubkey_6,
3741 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3744 funding_satoshis: 1311768467284833366,
3745 second_per_commitment_point: pubkey_7,
3746 require_confirmed_inputs: None,
3748 let encoded_value = accept_channelv2.encode();
3749 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // temporary_channel_id
3750 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap()); // funding_satoshis
3751 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap()); // dust_limit_satoshis
3752 target_value.append(&mut <Vec<u8>>::from_hex("2334032891223698").unwrap()); // max_htlc_value_in_flight_msat
3753 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d").unwrap()); // htlc_minimum_msat
3754 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap()); // minimum_depth
3755 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap()); // to_self_delay
3756 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap()); // max_accepted_htlcs
3757 target_value.append(&mut <Vec<u8>>::from_hex("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap()); // funding_pubkey
3758 target_value.append(&mut <Vec<u8>>::from_hex("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap()); // revocation_basepoint
3759 target_value.append(&mut <Vec<u8>>::from_hex("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap()); // payment_basepoint
3760 target_value.append(&mut <Vec<u8>>::from_hex("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap()); // delayed_payment_basepoint
3761 target_value.append(&mut <Vec<u8>>::from_hex("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap()); // htlc_basepoint
3762 target_value.append(&mut <Vec<u8>>::from_hex("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap()); // first_per_commitment_point
3763 target_value.append(&mut <Vec<u8>>::from_hex("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap()); // second_per_commitment_point
3765 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3767 assert_eq!(encoded_value, target_value);
3771 fn encoding_accept_channelv2() {
3772 do_encoding_accept_channelv2(false);
3773 do_encoding_accept_channelv2(true);
3777 fn encoding_funding_created() {
3778 let secp_ctx = Secp256k1::new();
3779 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3780 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3781 let funding_created = msgs::FundingCreated {
3782 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3783 funding_txid: Txid::from_str("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3784 funding_output_index: 255,
3787 partial_signature_with_nonce: None,
3789 next_local_nonce: None,
3791 let encoded_value = funding_created.encode();
3792 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202026e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c200ffd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3793 assert_eq!(encoded_value, target_value);
3797 fn encoding_funding_signed() {
3798 let secp_ctx = Secp256k1::new();
3799 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3800 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3801 let funding_signed = msgs::FundingSigned {
3802 channel_id: ChannelId::from_bytes([2; 32]),
3805 partial_signature_with_nonce: None,
3807 let encoded_value = funding_signed.encode();
3808 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3809 assert_eq!(encoded_value, target_value);
3813 fn encoding_channel_ready() {
3814 let secp_ctx = Secp256k1::new();
3815 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3816 let channel_ready = msgs::ChannelReady {
3817 channel_id: ChannelId::from_bytes([2; 32]),
3818 next_per_commitment_point: pubkey_1,
3819 short_channel_id_alias: None,
3821 let encoded_value = channel_ready.encode();
3822 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3823 assert_eq!(encoded_value, target_value);
3827 fn encoding_splice() {
3828 let secp_ctx = Secp256k1::new();
3829 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3830 let splice = msgs::Splice {
3831 chain_hash: ChainHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
3832 channel_id: ChannelId::from_bytes([2; 32]),
3833 relative_satoshis: 123456,
3834 funding_feerate_perkw: 2000,
3836 funding_pubkey: pubkey_1,
3838 let encoded_value = splice.encode();
3839 assert_eq!(encoded_value.as_hex().to_string(), "02020202020202020202020202020202020202020202020202020202020202026fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000000000000001e240000007d000000000031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f");
3843 fn encoding_stfu() {
3844 let stfu = msgs::Stfu {
3845 channel_id: ChannelId::from_bytes([2; 32]),
3848 let encoded_value = stfu.encode();
3849 assert_eq!(encoded_value.as_hex().to_string(), "020202020202020202020202020202020202020202020202020202020202020201");
3853 fn encoding_splice_ack() {
3854 let secp_ctx = Secp256k1::new();
3855 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3856 let splice = msgs::SpliceAck {
3857 chain_hash: ChainHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
3858 channel_id: ChannelId::from_bytes([2; 32]),
3859 relative_satoshis: 123456,
3860 funding_pubkey: pubkey_1,
3862 let encoded_value = splice.encode();
3863 assert_eq!(encoded_value.as_hex().to_string(), "02020202020202020202020202020202020202020202020202020202020202026fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000000000000001e240031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f");
3867 fn encoding_splice_locked() {
3868 let splice = msgs::SpliceLocked {
3869 channel_id: ChannelId::from_bytes([2; 32]),
3871 let encoded_value = splice.encode();
3872 assert_eq!(encoded_value.as_hex().to_string(), "0202020202020202020202020202020202020202020202020202020202020202");
3876 fn encoding_tx_add_input() {
3877 let tx_add_input = msgs::TxAddInput {
3878 channel_id: ChannelId::from_bytes([2; 32]),
3879 serial_id: 4886718345,
3880 prevtx: TransactionU16LenLimited::new(Transaction {
3882 lock_time: LockTime::ZERO,
3884 previous_output: OutPoint { txid: Txid::from_str("305bab643ee297b8b6b76b320792c8223d55082122cb606bf89382146ced9c77").unwrap(), index: 2 }.into_bitcoin_outpoint(),
3885 script_sig: ScriptBuf::new(),
3886 sequence: Sequence(0xfffffffd),
3887 witness: Witness::from_slice(&vec![
3888 <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3889 <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3894 script_pubkey: Address::from_str("bc1qzlffunw52jav8vwdu5x3jfk6sr8u22rmq3xzw2").unwrap().payload.script_pubkey(),
3898 script_pubkey: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().payload.script_pubkey(),
3902 prevtx_out: 305419896,
3903 sequence: 305419896,
3905 let encoded_value = tx_add_input.encode();
3906 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000000012345678900de02000000000101779ced6c148293f86b60cb222108553d22c89207326bb7b6b897e23e64ab5b300200000000fdffffff0236dbc1000000000016001417d29e4dd454bac3b1cde50d1926da80cfc5287b9cbd03000000000016001436ec78d514df462da95e6a00c24daa8915362d420247304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701210301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944000000001234567812345678").unwrap();
3907 assert_eq!(encoded_value, target_value);
3911 fn encoding_tx_add_output() {
3912 let tx_add_output = msgs::TxAddOutput {
3913 channel_id: ChannelId::from_bytes([2; 32]),
3914 serial_id: 4886718345,
3916 script: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().payload.script_pubkey(),
3918 let encoded_value = tx_add_output.encode();
3919 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000000012345678900000001234567890016001436ec78d514df462da95e6a00c24daa8915362d42").unwrap();
3920 assert_eq!(encoded_value, target_value);
3924 fn encoding_tx_remove_input() {
3925 let tx_remove_input = msgs::TxRemoveInput {
3926 channel_id: ChannelId::from_bytes([2; 32]),
3927 serial_id: 4886718345,
3929 let encoded_value = tx_remove_input.encode();
3930 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3931 assert_eq!(encoded_value, target_value);
3935 fn encoding_tx_remove_output() {
3936 let tx_remove_output = msgs::TxRemoveOutput {
3937 channel_id: ChannelId::from_bytes([2; 32]),
3938 serial_id: 4886718345,
3940 let encoded_value = tx_remove_output.encode();
3941 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3942 assert_eq!(encoded_value, target_value);
3946 fn encoding_tx_complete() {
3947 let tx_complete = msgs::TxComplete {
3948 channel_id: ChannelId::from_bytes([2; 32]),
3950 let encoded_value = tx_complete.encode();
3951 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3952 assert_eq!(encoded_value, target_value);
3956 fn encoding_tx_signatures() {
3957 let tx_signatures = msgs::TxSignatures {
3958 channel_id: ChannelId::from_bytes([2; 32]),
3959 tx_hash: Txid::from_str("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3961 Witness::from_slice(&vec![
3962 <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3963 <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3964 Witness::from_slice(&vec![
3965 <Vec<u8>>::from_hex("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap(),
3966 <Vec<u8>>::from_hex("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap()]),
3969 let encoded_value = tx_signatures.encode();
3970 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3971 target_value.append(&mut <Vec<u8>>::from_hex("6e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c2").unwrap()); // tx_hash (sha256) (big endian byte order)
3972 target_value.append(&mut <Vec<u8>>::from_hex("0002").unwrap()); // num_witnesses (u16)
3974 target_value.append(&mut <Vec<u8>>::from_hex("006b").unwrap()); // len of witness_data
3975 target_value.append(&mut <Vec<u8>>::from_hex("02").unwrap()); // num_witness_elements (VarInt)
3976 target_value.append(&mut <Vec<u8>>::from_hex("47").unwrap()); // len of witness element data (VarInt)
3977 target_value.append(&mut <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap());
3978 target_value.append(&mut <Vec<u8>>::from_hex("21").unwrap()); // len of witness element data (VarInt)
3979 target_value.append(&mut <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap());
3981 target_value.append(&mut <Vec<u8>>::from_hex("006c").unwrap()); // len of witness_data
3982 target_value.append(&mut <Vec<u8>>::from_hex("02").unwrap()); // num_witness_elements (VarInt)
3983 target_value.append(&mut <Vec<u8>>::from_hex("48").unwrap()); // len of witness element data (VarInt)
3984 target_value.append(&mut <Vec<u8>>::from_hex("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap());
3985 target_value.append(&mut <Vec<u8>>::from_hex("21").unwrap()); // len of witness element data (VarInt)
3986 target_value.append(&mut <Vec<u8>>::from_hex("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap());
3987 assert_eq!(encoded_value, target_value);
3990 fn do_encoding_tx_init_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3991 let tx_init_rbf = msgs::TxInitRbf {
3992 channel_id: ChannelId::from_bytes([2; 32]),
3993 locktime: 305419896,
3994 feerate_sat_per_1000_weight: 20190119,
3995 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3997 let encoded_value = tx_init_rbf.encode();
3998 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3999 target_value.append(&mut <Vec<u8>>::from_hex("12345678").unwrap()); // locktime
4000 target_value.append(&mut <Vec<u8>>::from_hex("013413a7").unwrap()); // feerate_sat_per_1000_weight
4001 if let Some((_, target)) = funding_value_with_hex_target {
4002 target_value.push(0x00); // Type
4003 target_value.push(target.len() as u8 / 2); // Length
4004 target_value.append(&mut <Vec<u8>>::from_hex(target).unwrap()); // Value (i64)
4006 assert_eq!(encoded_value, target_value);
4010 fn encoding_tx_init_rbf() {
4011 do_encoding_tx_init_rbf(Some((1311768467284833366, "1234567890123456")));
4012 do_encoding_tx_init_rbf(Some((13117684672, "000000030DDFFBC0")));
4013 do_encoding_tx_init_rbf(None);
4016 fn do_encoding_tx_ack_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
4017 let tx_ack_rbf = msgs::TxAckRbf {
4018 channel_id: ChannelId::from_bytes([2; 32]),
4019 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
4021 let encoded_value = tx_ack_rbf.encode();
4022 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
4023 if let Some((_, target)) = funding_value_with_hex_target {
4024 target_value.push(0x00); // Type
4025 target_value.push(target.len() as u8 / 2); // Length
4026 target_value.append(&mut <Vec<u8>>::from_hex(target).unwrap()); // Value (i64)
4028 assert_eq!(encoded_value, target_value);
4032 fn encoding_tx_ack_rbf() {
4033 do_encoding_tx_ack_rbf(Some((1311768467284833366, "1234567890123456")));
4034 do_encoding_tx_ack_rbf(Some((13117684672, "000000030DDFFBC0")));
4035 do_encoding_tx_ack_rbf(None);
4039 fn encoding_tx_abort() {
4040 let tx_abort = msgs::TxAbort {
4041 channel_id: ChannelId::from_bytes([2; 32]),
4042 data: <Vec<u8>>::from_hex("54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap(),
4044 let encoded_value = tx_abort.encode();
4045 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202002C54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap();
4046 assert_eq!(encoded_value, target_value);
4049 fn do_encoding_shutdown(script_type: u8) {
4050 let secp_ctx = Secp256k1::new();
4051 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4052 let script = Builder::new().push_opcode(opcodes::OP_TRUE).into_script();
4053 let shutdown = msgs::Shutdown {
4054 channel_id: ChannelId::from_bytes([2; 32]),
4056 if script_type == 1 { Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey() }
4057 else if script_type == 2 { Address::p2sh(&script, Network::Testnet).unwrap().script_pubkey() }
4058 else if script_type == 3 { Address::p2wpkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).unwrap().script_pubkey() }
4059 else { Address::p2wsh(&script, Network::Testnet).script_pubkey() },
4061 let encoded_value = shutdown.encode();
4062 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
4063 if script_type == 1 {
4064 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
4065 } else if script_type == 2 {
4066 target_value.append(&mut <Vec<u8>>::from_hex("0017a914da1745e9b549bd0bfa1a569971c77eba30cd5a4b87").unwrap());
4067 } else if script_type == 3 {
4068 target_value.append(&mut <Vec<u8>>::from_hex("0016001479b000887626b294a914501a4cd226b58b235983").unwrap());
4069 } else if script_type == 4 {
4070 target_value.append(&mut <Vec<u8>>::from_hex("002200204ae81572f06e1b88fd5ced7a1a000945432e83e1551e6f721ee9c00b8cc33260").unwrap());
4072 assert_eq!(encoded_value, target_value);
4076 fn encoding_shutdown() {
4077 do_encoding_shutdown(1);
4078 do_encoding_shutdown(2);
4079 do_encoding_shutdown(3);
4080 do_encoding_shutdown(4);
4084 fn encoding_closing_signed() {
4085 let secp_ctx = Secp256k1::new();
4086 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4087 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
4088 let closing_signed = msgs::ClosingSigned {
4089 channel_id: ChannelId::from_bytes([2; 32]),
4090 fee_satoshis: 2316138423780173,
4094 let encoded_value = closing_signed.encode();
4095 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
4096 assert_eq!(encoded_value, target_value);
4097 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value)).unwrap(), closing_signed);
4099 let closing_signed_with_range = msgs::ClosingSigned {
4100 channel_id: ChannelId::from_bytes([2; 32]),
4101 fee_satoshis: 2316138423780173,
4103 fee_range: Some(msgs::ClosingSignedFeeRange {
4104 min_fee_satoshis: 0xdeadbeef,
4105 max_fee_satoshis: 0x1badcafe01234567,
4108 let encoded_value_with_range = closing_signed_with_range.encode();
4109 let target_value_with_range = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a011000000000deadbeef1badcafe01234567").unwrap();
4110 assert_eq!(encoded_value_with_range, target_value_with_range);
4111 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value_with_range)).unwrap(),
4112 closing_signed_with_range);
4116 fn encoding_update_add_htlc() {
4117 let secp_ctx = Secp256k1::new();
4118 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4119 let onion_routing_packet = msgs::OnionPacket {
4121 public_key: Ok(pubkey_1),
4122 hop_data: [1; 20*65],
4125 let update_add_htlc = msgs::UpdateAddHTLC {
4126 channel_id: ChannelId::from_bytes([2; 32]),
4127 htlc_id: 2316138423780173,
4128 amount_msat: 3608586615801332854,
4129 payment_hash: PaymentHash([1; 32]),
4130 cltv_expiry: 821716,
4131 onion_routing_packet,
4132 skimmed_fee_msat: None,
4133 blinding_point: None,
4135 let encoded_value = update_add_htlc.encode();
4136 let target_value = <Vec<u8>>::from_hex("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").unwrap();
4137 assert_eq!(encoded_value, target_value);
4141 fn encoding_update_fulfill_htlc() {
4142 let update_fulfill_htlc = msgs::UpdateFulfillHTLC {
4143 channel_id: ChannelId::from_bytes([2; 32]),
4144 htlc_id: 2316138423780173,
4145 payment_preimage: PaymentPreimage([1; 32]),
4147 let encoded_value = update_fulfill_htlc.encode();
4148 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d0101010101010101010101010101010101010101010101010101010101010101").unwrap();
4149 assert_eq!(encoded_value, target_value);
4153 fn encoding_update_fail_htlc() {
4154 let reason = OnionErrorPacket {
4155 data: [1; 32].to_vec(),
4157 let update_fail_htlc = msgs::UpdateFailHTLC {
4158 channel_id: ChannelId::from_bytes([2; 32]),
4159 htlc_id: 2316138423780173,
4162 let encoded_value = update_fail_htlc.encode();
4163 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d00200101010101010101010101010101010101010101010101010101010101010101").unwrap();
4164 assert_eq!(encoded_value, target_value);
4168 fn encoding_update_fail_malformed_htlc() {
4169 let update_fail_malformed_htlc = msgs::UpdateFailMalformedHTLC {
4170 channel_id: ChannelId::from_bytes([2; 32]),
4171 htlc_id: 2316138423780173,
4172 sha256_of_onion: [1; 32],
4175 let encoded_value = update_fail_malformed_htlc.encode();
4176 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d010101010101010101010101010101010101010101010101010101010101010100ff").unwrap();
4177 assert_eq!(encoded_value, target_value);
4180 fn do_encoding_commitment_signed(htlcs: bool) {
4181 let secp_ctx = Secp256k1::new();
4182 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4183 let (privkey_2, _) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
4184 let (privkey_3, _) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
4185 let (privkey_4, _) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
4186 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
4187 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
4188 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
4189 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
4190 let commitment_signed = msgs::CommitmentSigned {
4191 channel_id: ChannelId::from_bytes([2; 32]),
4193 htlc_signatures: if htlcs { vec![sig_2, sig_3, sig_4] } else { Vec::new() },
4195 partial_signature_with_nonce: None,
4197 let encoded_value = commitment_signed.encode();
4198 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
4200 target_value.append(&mut <Vec<u8>>::from_hex("00031735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
4202 target_value.append(&mut <Vec<u8>>::from_hex("0000").unwrap());
4204 assert_eq!(encoded_value, target_value);
4208 fn encoding_commitment_signed() {
4209 do_encoding_commitment_signed(true);
4210 do_encoding_commitment_signed(false);
4214 fn encoding_revoke_and_ack() {
4215 let secp_ctx = Secp256k1::new();
4216 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4217 let raa = msgs::RevokeAndACK {
4218 channel_id: ChannelId::from_bytes([2; 32]),
4219 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],
4220 next_per_commitment_point: pubkey_1,
4222 next_local_nonce: None,
4224 let encoded_value = raa.encode();
4225 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020101010101010101010101010101010101010101010101010101010101010101031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
4226 assert_eq!(encoded_value, target_value);
4230 fn encoding_update_fee() {
4231 let update_fee = msgs::UpdateFee {
4232 channel_id: ChannelId::from_bytes([2; 32]),
4233 feerate_per_kw: 20190119,
4235 let encoded_value = update_fee.encode();
4236 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202013413a7").unwrap();
4237 assert_eq!(encoded_value, target_value);
4241 fn encoding_init() {
4242 let mainnet_hash = ChainHash::using_genesis_block(Network::Bitcoin);
4243 assert_eq!(msgs::Init {
4244 features: InitFeatures::from_le_bytes(vec![0xFF, 0xFF, 0xFF]),
4245 networks: Some(vec![mainnet_hash]),
4246 remote_network_address: None,
4247 }.encode(), <Vec<u8>>::from_hex("00023fff0003ffffff01206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
4248 assert_eq!(msgs::Init {
4249 features: InitFeatures::from_le_bytes(vec![0xFF]),
4251 remote_network_address: None,
4252 }.encode(), <Vec<u8>>::from_hex("0001ff0001ff").unwrap());
4253 assert_eq!(msgs::Init {
4254 features: InitFeatures::from_le_bytes(vec![]),
4255 networks: Some(vec![mainnet_hash]),
4256 remote_network_address: None,
4257 }.encode(), <Vec<u8>>::from_hex("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
4258 assert_eq!(msgs::Init {
4259 features: InitFeatures::from_le_bytes(vec![]),
4260 networks: Some(vec![ChainHash::from(&[1; 32]), ChainHash::from(&[2; 32])]),
4261 remote_network_address: None,
4262 }.encode(), <Vec<u8>>::from_hex("00000000014001010101010101010101010101010101010101010101010101010101010101010202020202020202020202020202020202020202020202020202020202020202").unwrap());
4263 let init_msg = msgs::Init { features: InitFeatures::from_le_bytes(vec![]),
4264 networks: Some(vec![mainnet_hash]),
4265 remote_network_address: Some(SocketAddress::TcpIpV4 {
4266 addr: [127, 0, 0, 1],
4270 let encoded_value = init_msg.encode();
4271 let target_value = <Vec<u8>>::from_hex("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d61900000000000307017f00000103e8").unwrap();
4272 assert_eq!(encoded_value, target_value);
4273 assert_eq!(msgs::Init::read(&mut Cursor::new(&target_value)).unwrap(), init_msg);
4277 fn encoding_error() {
4278 let error = msgs::ErrorMessage {
4279 channel_id: ChannelId::from_bytes([2; 32]),
4280 data: String::from("rust-lightning"),
4282 let encoded_value = error.encode();
4283 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
4284 assert_eq!(encoded_value, target_value);
4288 fn encoding_warning() {
4289 let error = msgs::WarningMessage {
4290 channel_id: ChannelId::from_bytes([2; 32]),
4291 data: String::from("rust-lightning"),
4293 let encoded_value = error.encode();
4294 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
4295 assert_eq!(encoded_value, target_value);
4299 fn encoding_ping() {
4300 let ping = msgs::Ping {
4304 let encoded_value = ping.encode();
4305 let target_value = <Vec<u8>>::from_hex("0040004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
4306 assert_eq!(encoded_value, target_value);
4310 fn encoding_pong() {
4311 let pong = msgs::Pong {
4314 let encoded_value = pong.encode();
4315 let target_value = <Vec<u8>>::from_hex("004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
4316 assert_eq!(encoded_value, target_value);
4320 fn encoding_nonfinal_onion_hop_data() {
4321 let outbound_msg = msgs::OutboundOnionPayload::Forward {
4322 short_channel_id: 0xdeadbeef1bad1dea,
4323 amt_to_forward: 0x0badf00d01020304,
4324 outgoing_cltv_value: 0xffffffff,
4326 let encoded_value = outbound_msg.encode();
4327 let target_value = <Vec<u8>>::from_hex("1a02080badf00d010203040404ffffffff0608deadbeef1bad1dea").unwrap();
4328 assert_eq!(encoded_value, target_value);
4330 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4331 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4332 if let msgs::InboundOnionPayload::Forward {
4333 short_channel_id, amt_to_forward, outgoing_cltv_value
4335 assert_eq!(short_channel_id, 0xdeadbeef1bad1dea);
4336 assert_eq!(amt_to_forward, 0x0badf00d01020304);
4337 assert_eq!(outgoing_cltv_value, 0xffffffff);
4338 } else { panic!(); }
4342 fn encoding_final_onion_hop_data() {
4343 let outbound_msg = msgs::OutboundOnionPayload::Receive {
4345 payment_metadata: None,
4346 keysend_preimage: None,
4347 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4348 cltv_expiry_height: 0xffffffff,
4349 custom_tlvs: vec![],
4351 let encoded_value = outbound_msg.encode();
4352 let target_value = <Vec<u8>>::from_hex("1002080badf00d010203040404ffffffff").unwrap();
4353 assert_eq!(encoded_value, target_value);
4355 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4356 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4357 if let msgs::InboundOnionPayload::Receive {
4358 payment_data: None, sender_intended_htlc_amt_msat, cltv_expiry_height, ..
4360 assert_eq!(sender_intended_htlc_amt_msat, 0x0badf00d01020304);
4361 assert_eq!(cltv_expiry_height, 0xffffffff);
4362 } else { panic!(); }
4366 fn encoding_final_onion_hop_data_with_secret() {
4367 let expected_payment_secret = PaymentSecret([0x42u8; 32]);
4368 let outbound_msg = msgs::OutboundOnionPayload::Receive {
4369 payment_data: Some(FinalOnionHopData {
4370 payment_secret: expected_payment_secret,
4371 total_msat: 0x1badca1f
4373 payment_metadata: None,
4374 keysend_preimage: None,
4375 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4376 cltv_expiry_height: 0xffffffff,
4377 custom_tlvs: vec![],
4379 let encoded_value = outbound_msg.encode();
4380 let target_value = <Vec<u8>>::from_hex("3602080badf00d010203040404ffffffff082442424242424242424242424242424242424242424242424242424242424242421badca1f").unwrap();
4381 assert_eq!(encoded_value, target_value);
4383 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4384 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4385 if let msgs::InboundOnionPayload::Receive {
4386 payment_data: Some(FinalOnionHopData {
4388 total_msat: 0x1badca1f
4390 sender_intended_htlc_amt_msat, cltv_expiry_height,
4391 payment_metadata: None,
4392 keysend_preimage: None,
4395 assert_eq!(payment_secret, expected_payment_secret);
4396 assert_eq!(sender_intended_htlc_amt_msat, 0x0badf00d01020304);
4397 assert_eq!(cltv_expiry_height, 0xffffffff);
4398 assert_eq!(custom_tlvs, vec![]);
4399 } else { panic!(); }
4403 fn encoding_final_onion_hop_data_with_bad_custom_tlvs() {
4404 // If custom TLVs have type number within the range reserved for protocol, treat them as if
4406 let bad_type_range_tlvs = vec![
4407 ((1 << 16) - 4, vec![42]),
4408 ((1 << 16) - 2, vec![42; 32]),
4410 let mut msg = msgs::OutboundOnionPayload::Receive {
4412 payment_metadata: None,
4413 keysend_preimage: None,
4414 custom_tlvs: bad_type_range_tlvs,
4415 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4416 cltv_expiry_height: 0xffffffff,
4418 let encoded_value = msg.encode();
4419 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4420 assert!(msgs::InboundOnionPayload::read(&mut Cursor::new(&encoded_value[..]), (None, &&node_signer)).is_err());
4421 let good_type_range_tlvs = vec![
4422 ((1 << 16) - 3, vec![42]),
4423 ((1 << 16) - 1, vec![42; 32]),
4425 if let msgs::OutboundOnionPayload::Receive { ref mut custom_tlvs, .. } = msg {
4426 *custom_tlvs = good_type_range_tlvs.clone();
4428 let encoded_value = msg.encode();
4429 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&encoded_value[..]), (None, &&node_signer)).unwrap();
4431 msgs::InboundOnionPayload::Receive { custom_tlvs, .. } => assert!(custom_tlvs.is_empty()),
4437 fn encoding_final_onion_hop_data_with_custom_tlvs() {
4438 let expected_custom_tlvs = vec![
4439 (5482373483, vec![0x12, 0x34]),
4440 (5482373487, vec![0x42u8; 8]),
4442 let msg = msgs::OutboundOnionPayload::Receive {
4444 payment_metadata: None,
4445 keysend_preimage: None,
4446 custom_tlvs: expected_custom_tlvs.clone(),
4447 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4448 cltv_expiry_height: 0xffffffff,
4450 let encoded_value = msg.encode();
4451 let target_value = <Vec<u8>>::from_hex("2e02080badf00d010203040404ffffffffff0000000146c6616b021234ff0000000146c6616f084242424242424242").unwrap();
4452 assert_eq!(encoded_value, target_value);
4453 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4454 let inbound_msg: msgs::InboundOnionPayload = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4455 if let msgs::InboundOnionPayload::Receive {
4457 payment_metadata: None,
4458 keysend_preimage: None,
4460 sender_intended_htlc_amt_msat,
4461 cltv_expiry_height: outgoing_cltv_value,
4464 assert_eq!(custom_tlvs, expected_custom_tlvs);
4465 assert_eq!(sender_intended_htlc_amt_msat, 0x0badf00d01020304);
4466 assert_eq!(outgoing_cltv_value, 0xffffffff);
4467 } else { panic!(); }
4471 fn encoding_final_onion_hop_data_with_trampoline_packet() {
4472 let secp_ctx = Secp256k1::new();
4473 let (_private_key, public_key) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4475 let compressed_public_key = public_key.serialize();
4476 assert_eq!(compressed_public_key.len(), 33);
4478 let trampoline_packet = TrampolineOnionPacket {
4481 hop_data: vec![1; 650], // this should be the standard encoded length
4484 let encoded_trampoline_packet = trampoline_packet.encode();
4485 assert_eq!(encoded_trampoline_packet.len(), 716);
4487 let msg = msgs::OutboundOnionPayload::TrampolineEntrypoint {
4488 multipath_trampoline_data: None,
4489 amt_to_forward: 0x0badf00d01020304,
4490 outgoing_cltv_value: 0xffffffff,
4493 let encoded_payload = msg.encode();
4495 let trampoline_type_bytes = &encoded_payload[19..=19];
4496 let mut trampoline_type_cursor = Cursor::new(trampoline_type_bytes);
4497 let trampoline_type_big_size: BigSize = Readable::read(&mut trampoline_type_cursor).unwrap();
4498 assert_eq!(trampoline_type_big_size.0, 20);
4500 let trampoline_length_bytes = &encoded_payload[20..=22];
4501 let mut trampoline_length_cursor = Cursor::new(trampoline_length_bytes);
4502 let trampoline_length_big_size: BigSize = Readable::read(&mut trampoline_length_cursor).unwrap();
4503 assert_eq!(trampoline_length_big_size.0, encoded_trampoline_packet.len() as u64);
4507 fn encoding_final_onion_hop_data_with_eclair_trampoline_packet() {
4508 let public_key = PublicKey::from_slice(&<Vec<u8>>::from_hex("02eec7245d6b7d2ccb30380bfbe2a3648cd7a942653f5aa340edcea1f283686619").unwrap()).unwrap();
4509 let hop_data = <Vec<u8>>::from_hex("cff34152f3a36e52ca94e74927203a560392b9cc7ce3c45809c6be52166c24a595716880f95f178bf5b30ca63141f74db6e92795c6130877cfdac3d4bd3087ee73c65d627ddd709112a848cc99e303f3706509aa43ba7c8a88cba175fccf9a8f5016ef06d3b935dbb15196d7ce16dc1a7157845566901d7b2197e52cab4ce487014b14816e5805f9fcacb4f8f88b8ff176f1b94f6ce6b00bc43221130c17d20ef629db7c5f7eafaa166578c720619561dd14b3277db557ec7dcdb793771aef0f2f667cfdbeae3ac8d331c5994779dffb31e5fc0dbdedc0c592ca6d21c18e47fe3528d6975c19517d7e2ea8c5391cf17d0fe30c80913ed887234ccb48808f7ef9425bcd815c3b586210979e3bb286ef2851bf9ce04e28c40a203df98fd648d2f1936fd2f1def0e77eecb277229b4b682322371c0a1dbfcd723a991993df8cc1f2696b84b055b40a1792a29f710295a18fbd351b0f3ff34cd13941131b8278ba79303c89117120eea691738a9954908195143b039dbeed98f26a92585f3d15cf742c953799d3272e0545e9b744be9d3b4c").unwrap();
4510 let hmac_vector = <Vec<u8>>::from_hex("bb079bfc4b35190eee9f59a1d7b41ba2f773179f322dafb4b1af900c289ebd6c").unwrap();
4511 let mut hmac = [0; 32];
4512 hmac.copy_from_slice(&hmac_vector);
4514 let compressed_public_key = public_key.serialize();
4515 assert_eq!(compressed_public_key.len(), 33);
4517 let trampoline_packet = TrampolineOnionPacket {
4523 let encoded_trampoline_packet = trampoline_packet.encode();
4524 let expected_eclair_trampoline_packet = <Vec<u8>>::from_hex("0002eec7245d6b7d2ccb30380bfbe2a3648cd7a942653f5aa340edcea1f283686619cff34152f3a36e52ca94e74927203a560392b9cc7ce3c45809c6be52166c24a595716880f95f178bf5b30ca63141f74db6e92795c6130877cfdac3d4bd3087ee73c65d627ddd709112a848cc99e303f3706509aa43ba7c8a88cba175fccf9a8f5016ef06d3b935dbb15196d7ce16dc1a7157845566901d7b2197e52cab4ce487014b14816e5805f9fcacb4f8f88b8ff176f1b94f6ce6b00bc43221130c17d20ef629db7c5f7eafaa166578c720619561dd14b3277db557ec7dcdb793771aef0f2f667cfdbeae3ac8d331c5994779dffb31e5fc0dbdedc0c592ca6d21c18e47fe3528d6975c19517d7e2ea8c5391cf17d0fe30c80913ed887234ccb48808f7ef9425bcd815c3b586210979e3bb286ef2851bf9ce04e28c40a203df98fd648d2f1936fd2f1def0e77eecb277229b4b682322371c0a1dbfcd723a991993df8cc1f2696b84b055b40a1792a29f710295a18fbd351b0f3ff34cd13941131b8278ba79303c89117120eea691738a9954908195143b039dbeed98f26a92585f3d15cf742c953799d3272e0545e9b744be9d3b4cbb079bfc4b35190eee9f59a1d7b41ba2f773179f322dafb4b1af900c289ebd6c").unwrap();
4525 assert_eq!(encoded_trampoline_packet, expected_eclair_trampoline_packet);
4529 fn query_channel_range_end_blocknum() {
4530 let tests: Vec<(u32, u32, u32)> = vec![
4531 (10000, 1500, 11500),
4532 (0, 0xffffffff, 0xffffffff),
4533 (1, 0xffffffff, 0xffffffff),
4536 for (first_blocknum, number_of_blocks, expected) in tests.into_iter() {
4537 let sut = msgs::QueryChannelRange {
4538 chain_hash: ChainHash::using_genesis_block(Network::Regtest),
4542 assert_eq!(sut.end_blocknum(), expected);
4547 fn encoding_query_channel_range() {
4548 let mut query_channel_range = msgs::QueryChannelRange {
4549 chain_hash: ChainHash::using_genesis_block(Network::Regtest),
4550 first_blocknum: 100000,
4551 number_of_blocks: 1500,
4553 let encoded_value = query_channel_range.encode();
4554 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000186a0000005dc").unwrap();
4555 assert_eq!(encoded_value, target_value);
4557 query_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4558 assert_eq!(query_channel_range.first_blocknum, 100000);
4559 assert_eq!(query_channel_range.number_of_blocks, 1500);
4563 fn encoding_reply_channel_range() {
4564 do_encoding_reply_channel_range(0);
4565 do_encoding_reply_channel_range(1);
4568 fn do_encoding_reply_channel_range(encoding_type: u8) {
4569 let mut target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000b8a06000005dc01").unwrap();
4570 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4571 let mut reply_channel_range = msgs::ReplyChannelRange {
4572 chain_hash: expected_chain_hash,
4573 first_blocknum: 756230,
4574 number_of_blocks: 1500,
4575 sync_complete: true,
4576 short_channel_ids: vec![0x000000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
4579 if encoding_type == 0 {
4580 target_value.append(&mut <Vec<u8>>::from_hex("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
4581 let encoded_value = reply_channel_range.encode();
4582 assert_eq!(encoded_value, target_value);
4584 reply_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4585 assert_eq!(reply_channel_range.chain_hash, expected_chain_hash);
4586 assert_eq!(reply_channel_range.first_blocknum, 756230);
4587 assert_eq!(reply_channel_range.number_of_blocks, 1500);
4588 assert_eq!(reply_channel_range.sync_complete, true);
4589 assert_eq!(reply_channel_range.short_channel_ids[0], 0x000000000000008e);
4590 assert_eq!(reply_channel_range.short_channel_ids[1], 0x0000000000003c69);
4591 assert_eq!(reply_channel_range.short_channel_ids[2], 0x000000000045a6c4);
4593 target_value.append(&mut <Vec<u8>>::from_hex("001601789c636000833e08659309a65878be010010a9023a").unwrap());
4594 let result: Result<msgs::ReplyChannelRange, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
4595 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
4600 fn encoding_query_short_channel_ids() {
4601 do_encoding_query_short_channel_ids(0);
4602 do_encoding_query_short_channel_ids(1);
4605 fn do_encoding_query_short_channel_ids(encoding_type: u8) {
4606 let mut target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
4607 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4608 let mut query_short_channel_ids = msgs::QueryShortChannelIds {
4609 chain_hash: expected_chain_hash,
4610 short_channel_ids: vec![0x0000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
4613 if encoding_type == 0 {
4614 target_value.append(&mut <Vec<u8>>::from_hex("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
4615 let encoded_value = query_short_channel_ids.encode();
4616 assert_eq!(encoded_value, target_value);
4618 query_short_channel_ids = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4619 assert_eq!(query_short_channel_ids.chain_hash, expected_chain_hash);
4620 assert_eq!(query_short_channel_ids.short_channel_ids[0], 0x000000000000008e);
4621 assert_eq!(query_short_channel_ids.short_channel_ids[1], 0x0000000000003c69);
4622 assert_eq!(query_short_channel_ids.short_channel_ids[2], 0x000000000045a6c4);
4624 target_value.append(&mut <Vec<u8>>::from_hex("001601789c636000833e08659309a65878be010010a9023a").unwrap());
4625 let result: Result<msgs::QueryShortChannelIds, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
4626 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
4631 fn encoding_reply_short_channel_ids_end() {
4632 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4633 let mut reply_short_channel_ids_end = msgs::ReplyShortChannelIdsEnd {
4634 chain_hash: expected_chain_hash,
4635 full_information: true,
4637 let encoded_value = reply_short_channel_ids_end.encode();
4638 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f01").unwrap();
4639 assert_eq!(encoded_value, target_value);
4641 reply_short_channel_ids_end = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4642 assert_eq!(reply_short_channel_ids_end.chain_hash, expected_chain_hash);
4643 assert_eq!(reply_short_channel_ids_end.full_information, true);
4647 fn encoding_gossip_timestamp_filter(){
4648 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4649 let mut gossip_timestamp_filter = msgs::GossipTimestampFilter {
4650 chain_hash: expected_chain_hash,
4651 first_timestamp: 1590000000,
4652 timestamp_range: 0xffff_ffff,
4654 let encoded_value = gossip_timestamp_filter.encode();
4655 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f5ec57980ffffffff").unwrap();
4656 assert_eq!(encoded_value, target_value);
4658 gossip_timestamp_filter = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4659 assert_eq!(gossip_timestamp_filter.chain_hash, expected_chain_hash);
4660 assert_eq!(gossip_timestamp_filter.first_timestamp, 1590000000);
4661 assert_eq!(gossip_timestamp_filter.timestamp_range, 0xffff_ffff);
4665 fn decode_onion_hop_data_len_as_bigsize() {
4666 // Tests that we can decode an onion payload that is >253 bytes.
4667 // Previously, receiving a payload of this size could've caused us to fail to decode a valid
4668 // payload, because we were decoding the length (a BigSize, big-endian) as a VarInt
4671 // Encode a test onion payload with a big custom TLV such that it's >253 bytes, forcing the
4672 // payload length to be encoded over multiple bytes rather than a single u8.
4673 let big_payload = encode_big_payload().unwrap();
4674 let mut rd = Cursor::new(&big_payload[..]);
4676 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4677 <msgs::InboundOnionPayload as ReadableArgs<(Option<PublicKey>, &&test_utils::TestKeysInterface)>>
4678 ::read(&mut rd, (None, &&node_signer)).unwrap();
4680 // see above test, needs to be a separate method for use of the serialization macros.
4681 fn encode_big_payload() -> Result<Vec<u8>, io::Error> {
4682 use crate::util::ser::HighZeroBytesDroppedBigSize;
4683 let payload = msgs::OutboundOnionPayload::Forward {
4684 short_channel_id: 0xdeadbeef1bad1dea,
4685 amt_to_forward: 1000,
4686 outgoing_cltv_value: 0xffffffff,
4688 let mut encoded_payload = Vec::new();
4689 let test_bytes = vec![42u8; 1000];
4690 if let msgs::OutboundOnionPayload::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } = payload {
4691 _encode_varint_length_prefixed_tlv!(&mut encoded_payload, {
4692 (1, test_bytes, required_vec),
4693 (2, HighZeroBytesDroppedBigSize(amt_to_forward), required),
4694 (4, HighZeroBytesDroppedBigSize(outgoing_cltv_value), required),
4695 (6, short_channel_id, required)
4702 #[cfg(feature = "std")]
4703 fn test_socket_address_from_str() {
4704 let tcpip_v4 = SocketAddress::TcpIpV4 {
4705 addr: Ipv4Addr::new(127, 0, 0, 1).octets(),
4708 assert_eq!(tcpip_v4, SocketAddress::from_str("127.0.0.1:1234").unwrap());
4709 assert_eq!(tcpip_v4, SocketAddress::from_str(&tcpip_v4.to_string()).unwrap());
4711 let tcpip_v6 = SocketAddress::TcpIpV6 {
4712 addr: Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1).octets(),
4715 assert_eq!(tcpip_v6, SocketAddress::from_str("[0:0:0:0:0:0:0:1]:1234").unwrap());
4716 assert_eq!(tcpip_v6, SocketAddress::from_str(&tcpip_v6.to_string()).unwrap());
4718 let hostname = SocketAddress::Hostname {
4719 hostname: Hostname::try_from("lightning-node.mydomain.com".to_string()).unwrap(),
4722 assert_eq!(hostname, SocketAddress::from_str("lightning-node.mydomain.com:1234").unwrap());
4723 assert_eq!(hostname, SocketAddress::from_str(&hostname.to_string()).unwrap());
4725 let onion_v2 = SocketAddress::OnionV2 ([40, 4, 64, 185, 202, 19, 162, 75, 90, 200, 38, 7],);
4726 assert_eq!("OnionV2([40, 4, 64, 185, 202, 19, 162, 75, 90, 200, 38, 7])", &onion_v2.to_string());
4727 assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("FACEBOOKCOREWWWI.onion:9735"));
4729 let onion_v3 = SocketAddress::OnionV3 {
4730 ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102, 182, 107, 4, 105, 247, 246, 85,
4731 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31, 33, 71, 3],
4736 assert_eq!(onion_v3, SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion:1234").unwrap());
4737 assert_eq!(onion_v3, SocketAddress::from_str(&onion_v3.to_string()).unwrap());
4739 assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6.onion:1234"));
4740 assert_eq!(Err(SocketAddressParseError::InvalidInput), SocketAddress::from_str("127.0.0.1@1234"));
4741 assert_eq!(Err(SocketAddressParseError::InvalidInput), "".parse::<SocketAddress>());
4742 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:9735:94").is_err());
4743 assert!(SocketAddress::from_str("wrong$%#.com:1234").is_err());
4744 assert_eq!(Err(SocketAddressParseError::InvalidPort), SocketAddress::from_str("example.com:wrong"));
4745 assert!("localhost".parse::<SocketAddress>().is_err());
4746 assert!("localhost:invalid-port".parse::<SocketAddress>().is_err());
4747 assert!( "invalid-onion-v3-hostname.onion:8080".parse::<SocketAddress>().is_err());
4748 assert!("b32.example.onion:invalid-port".parse::<SocketAddress>().is_err());
4749 assert!("invalid-address".parse::<SocketAddress>().is_err());
4750 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:1234").is_err());
4754 #[cfg(feature = "std")]
4755 fn test_socket_address_to_socket_addrs() {
4756 assert_eq!(SocketAddress::TcpIpV4 {addr:[0u8; 4], port: 1337,}.to_socket_addrs().unwrap().next().unwrap(),
4757 SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(0,0,0,0), 1337)));
4758 assert_eq!(SocketAddress::TcpIpV6 {addr:[0u8; 16], port: 1337,}.to_socket_addrs().unwrap().next().unwrap(),
4759 SocketAddr::V6(SocketAddrV6::new(Ipv6Addr::from([0u8; 16]), 1337, 0, 0)));
4760 assert_eq!(SocketAddress::Hostname { hostname: Hostname::try_from("0.0.0.0".to_string()).unwrap(), port: 0 }
4761 .to_socket_addrs().unwrap().next().unwrap(), SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::from([0u8; 4]),0)));
4762 assert!(SocketAddress::OnionV2([0u8; 12]).to_socket_addrs().is_err());
4763 assert!(SocketAddress::OnionV3{ ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102,
4764 182, 107, 4, 105, 247, 246, 85, 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31,
4768 port: 1234 }.to_socket_addrs().is_err());