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>,
546 /// Optional signature for the shared input -- the previous funding outpoint -- signed by both peers
547 pub funding_outpoint_sig: Option<Signature>,
550 /// A tx_init_rbf message which initiates a replacement of the transaction after it's been
553 // TODO(dual_funding): Add spec link for `tx_init_rbf`.
554 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
555 pub struct TxInitRbf {
557 pub channel_id: ChannelId,
558 /// The locktime of the transaction
560 /// The feerate of the transaction
561 pub feerate_sat_per_1000_weight: u32,
562 /// The number of satoshis the sender will contribute to or, if negative, remove from
563 /// (e.g. splice-out) the funding output of the transaction
564 pub funding_output_contribution: Option<i64>,
567 /// A tx_ack_rbf message which acknowledges replacement of the transaction after it's been
570 // TODO(dual_funding): Add spec link for `tx_ack_rbf`.
571 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
572 pub struct TxAckRbf {
574 pub channel_id: ChannelId,
575 /// The number of satoshis the sender will contribute to or, if negative, remove from
576 /// (e.g. splice-out) the funding output of the transaction
577 pub funding_output_contribution: Option<i64>,
580 /// A tx_abort message which signals the cancellation of an in-progress transaction negotiation.
582 // TODO(dual_funding): Add spec link for `tx_abort`.
583 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
586 pub channel_id: ChannelId,
591 /// A [`shutdown`] message to be sent to or received from a peer.
593 /// [`shutdown`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-initiation-shutdown
594 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
595 pub struct Shutdown {
597 pub channel_id: ChannelId,
598 /// The destination of this peer's funds on closing.
600 /// Must be in one of these forms: P2PKH, P2SH, P2WPKH, P2WSH, P2TR.
601 pub scriptpubkey: ScriptBuf,
604 /// The minimum and maximum fees which the sender is willing to place on the closing transaction.
606 /// This is provided in [`ClosingSigned`] by both sides to indicate the fee range they are willing
608 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
609 pub struct ClosingSignedFeeRange {
610 /// The minimum absolute fee, in satoshis, which the sender is willing to place on the closing
612 pub min_fee_satoshis: u64,
613 /// The maximum absolute fee, in satoshis, which the sender is willing to place on the closing
615 pub max_fee_satoshis: u64,
618 /// A [`closing_signed`] message to be sent to or received from a peer.
620 /// [`closing_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-negotiation-closing_signed
621 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
622 pub struct ClosingSigned {
624 pub channel_id: ChannelId,
625 /// The proposed total fee for the closing transaction
626 pub fee_satoshis: u64,
627 /// A signature on the closing transaction
628 pub signature: Signature,
629 /// The minimum and maximum fees which the sender is willing to accept, provided only by new
631 pub fee_range: Option<ClosingSignedFeeRange>,
634 /// An [`update_add_htlc`] message to be sent to or received from a peer.
636 /// [`update_add_htlc`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#adding-an-htlc-update_add_htlc
637 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
638 pub struct UpdateAddHTLC {
640 pub channel_id: ChannelId,
643 /// The HTLC value in milli-satoshi
644 pub amount_msat: u64,
645 /// The payment hash, the pre-image of which controls HTLC redemption
646 pub payment_hash: PaymentHash,
647 /// The expiry height of the HTLC
648 pub cltv_expiry: u32,
649 /// The extra fee skimmed by the sender of this message. See
650 /// [`ChannelConfig::accept_underpaying_htlcs`].
652 /// [`ChannelConfig::accept_underpaying_htlcs`]: crate::util::config::ChannelConfig::accept_underpaying_htlcs
653 pub skimmed_fee_msat: Option<u64>,
654 /// The onion routing packet with encrypted data for the next hop.
655 pub onion_routing_packet: OnionPacket,
656 /// Provided if we are relaying or receiving a payment within a blinded path, to decrypt the onion
657 /// routing packet and the recipient-provided encrypted payload within.
658 pub blinding_point: Option<PublicKey>,
661 /// An onion message to be sent to or received from a peer.
663 // TODO: update with link to OM when they are merged into the BOLTs
664 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
665 pub struct OnionMessage {
666 /// Used in decrypting the onion packet's payload.
667 pub blinding_point: PublicKey,
668 /// The full onion packet including hop data, pubkey, and hmac
669 pub onion_routing_packet: onion_message::packet::Packet,
672 /// An [`update_fulfill_htlc`] message to be sent to or received from a peer.
674 /// [`update_fulfill_htlc`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#removing-an-htlc-update_fulfill_htlc-update_fail_htlc-and-update_fail_malformed_htlc
675 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
676 pub struct UpdateFulfillHTLC {
678 pub channel_id: ChannelId,
681 /// The pre-image of the payment hash, allowing HTLC redemption
682 pub payment_preimage: PaymentPreimage,
685 /// An [`update_fail_htlc`] message to be sent to or received from a peer.
687 /// [`update_fail_htlc`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#removing-an-htlc-update_fulfill_htlc-update_fail_htlc-and-update_fail_malformed_htlc
688 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
689 pub struct UpdateFailHTLC {
691 pub channel_id: ChannelId,
694 pub(crate) reason: OnionErrorPacket,
697 /// An [`update_fail_malformed_htlc`] message to be sent to or received from a peer.
699 /// [`update_fail_malformed_htlc`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#removing-an-htlc-update_fulfill_htlc-update_fail_htlc-and-update_fail_malformed_htlc
700 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
701 pub struct UpdateFailMalformedHTLC {
703 pub channel_id: ChannelId,
706 pub(crate) sha256_of_onion: [u8; 32],
708 pub failure_code: u16,
711 /// A [`commitment_signed`] message to be sent to or received from a peer.
713 /// [`commitment_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#committing-updates-so-far-commitment_signed
714 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
715 pub struct CommitmentSigned {
717 pub channel_id: ChannelId,
718 /// A signature on the commitment transaction
719 pub signature: Signature,
720 /// Signatures on the HTLC transactions
721 pub htlc_signatures: Vec<Signature>,
723 /// The partial Taproot signature on the commitment transaction
724 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
727 /// A [`revoke_and_ack`] message to be sent to or received from a peer.
729 /// [`revoke_and_ack`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#completing-the-transition-to-the-updated-state-revoke_and_ack
730 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
731 pub struct RevokeAndACK {
733 pub channel_id: ChannelId,
734 /// The secret corresponding to the per-commitment point
735 pub per_commitment_secret: [u8; 32],
736 /// The next sender-broadcast commitment transaction's per-commitment point
737 pub next_per_commitment_point: PublicKey,
739 /// Musig nonce the recipient should use in their next commitment signature message
740 pub next_local_nonce: Option<musig2::types::PublicNonce>
743 /// An [`update_fee`] message to be sent to or received from a peer
745 /// [`update_fee`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#updating-fees-update_fee
746 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
747 pub struct UpdateFee {
749 pub channel_id: ChannelId,
750 /// Fee rate per 1000-weight of the transaction
751 pub feerate_per_kw: u32,
754 /// A [`channel_reestablish`] message to be sent to or received from a peer.
756 /// [`channel_reestablish`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#message-retransmission
757 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
758 pub struct ChannelReestablish {
760 pub channel_id: ChannelId,
761 /// The next commitment number for the sender
762 pub next_local_commitment_number: u64,
763 /// The next commitment number for the recipient
764 pub next_remote_commitment_number: u64,
765 /// Proof that the sender knows the per-commitment secret of a specific commitment transaction
766 /// belonging to the recipient
767 pub your_last_per_commitment_secret: [u8; 32],
768 /// The sender's per-commitment point for their current commitment transaction
769 pub my_current_per_commitment_point: PublicKey,
770 /// The next funding transaction ID
771 pub next_funding_txid: Option<Txid>,
774 /// An [`announcement_signatures`] message to be sent to or received from a peer.
776 /// [`announcement_signatures`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-announcement_signatures-message
777 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
778 pub struct AnnouncementSignatures {
780 pub channel_id: ChannelId,
781 /// The short channel ID
782 pub short_channel_id: u64,
783 /// A signature by the node key
784 pub node_signature: Signature,
785 /// A signature by the funding key
786 pub bitcoin_signature: Signature,
789 /// An address which can be used to connect to a remote peer.
790 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
791 pub enum SocketAddress {
792 /// An IPv4 address and port on which the peer is listening.
794 /// The 4-byte IPv4 address
796 /// The port on which the node is listening
799 /// An IPv6 address and port on which the peer is listening.
801 /// The 16-byte IPv6 address
803 /// The port on which the node is listening
806 /// An old-style Tor onion address/port on which the peer is listening.
808 /// This field is deprecated and the Tor network generally no longer supports V2 Onion
809 /// addresses. Thus, the details are not parsed here.
811 /// A new-style Tor onion address/port on which the peer is listening.
813 /// To create the human-readable "hostname", concatenate the ED25519 pubkey, checksum, and version,
814 /// wrap as base32 and append ".onion".
816 /// The ed25519 long-term public key of the peer
817 ed25519_pubkey: [u8; 32],
818 /// The checksum of the pubkey and version, as included in the onion address
820 /// The version byte, as defined by the Tor Onion v3 spec.
822 /// The port on which the node is listening
825 /// A hostname/port on which the peer is listening.
827 /// The hostname on which the node is listening.
829 /// The port on which the node is listening.
834 /// Gets the ID of this address type. Addresses in [`NodeAnnouncement`] messages should be sorted
836 pub(crate) fn get_id(&self) -> u8 {
838 &SocketAddress::TcpIpV4 {..} => { 1 },
839 &SocketAddress::TcpIpV6 {..} => { 2 },
840 &SocketAddress::OnionV2(_) => { 3 },
841 &SocketAddress::OnionV3 {..} => { 4 },
842 &SocketAddress::Hostname {..} => { 5 },
846 /// Strict byte-length of address descriptor, 1-byte type not recorded
847 fn len(&self) -> u16 {
849 &SocketAddress::TcpIpV4 { .. } => { 6 },
850 &SocketAddress::TcpIpV6 { .. } => { 18 },
851 &SocketAddress::OnionV2(_) => { 12 },
852 &SocketAddress::OnionV3 { .. } => { 37 },
853 // Consists of 1-byte hostname length, hostname bytes, and 2-byte port.
854 &SocketAddress::Hostname { ref hostname, .. } => { u16::from(hostname.len()) + 3 },
858 /// The maximum length of any address descriptor, not including the 1-byte type.
859 /// This maximum length is reached by a hostname address descriptor:
860 /// a hostname with a maximum length of 255, its 1-byte length and a 2-byte port.
861 pub(crate) const MAX_LEN: u16 = 258;
863 pub(crate) fn is_tor(&self) -> bool {
865 &SocketAddress::TcpIpV4 {..} => false,
866 &SocketAddress::TcpIpV6 {..} => false,
867 &SocketAddress::OnionV2(_) => true,
868 &SocketAddress::OnionV3 {..} => true,
869 &SocketAddress::Hostname {..} => false,
874 impl Writeable for SocketAddress {
875 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
877 &SocketAddress::TcpIpV4 { ref addr, ref port } => {
882 &SocketAddress::TcpIpV6 { ref addr, ref port } => {
887 &SocketAddress::OnionV2(bytes) => {
889 bytes.write(writer)?;
891 &SocketAddress::OnionV3 { ref ed25519_pubkey, ref checksum, ref version, ref port } => {
893 ed25519_pubkey.write(writer)?;
894 checksum.write(writer)?;
895 version.write(writer)?;
898 &SocketAddress::Hostname { ref hostname, ref port } => {
900 hostname.write(writer)?;
908 impl Readable for Result<SocketAddress, u8> {
909 fn read<R: Read>(reader: &mut R) -> Result<Result<SocketAddress, u8>, DecodeError> {
910 let byte = <u8 as Readable>::read(reader)?;
913 Ok(Ok(SocketAddress::TcpIpV4 {
914 addr: Readable::read(reader)?,
915 port: Readable::read(reader)?,
919 Ok(Ok(SocketAddress::TcpIpV6 {
920 addr: Readable::read(reader)?,
921 port: Readable::read(reader)?,
924 3 => Ok(Ok(SocketAddress::OnionV2(Readable::read(reader)?))),
926 Ok(Ok(SocketAddress::OnionV3 {
927 ed25519_pubkey: Readable::read(reader)?,
928 checksum: Readable::read(reader)?,
929 version: Readable::read(reader)?,
930 port: Readable::read(reader)?,
934 Ok(Ok(SocketAddress::Hostname {
935 hostname: Readable::read(reader)?,
936 port: Readable::read(reader)?,
939 _ => return Ok(Err(byte)),
944 impl Readable for SocketAddress {
945 fn read<R: Read>(reader: &mut R) -> Result<SocketAddress, DecodeError> {
946 match Readable::read(reader) {
947 Ok(Ok(res)) => Ok(res),
948 Ok(Err(_)) => Err(DecodeError::UnknownVersion),
954 /// [`SocketAddress`] error variants
955 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
956 pub enum SocketAddressParseError {
957 /// Socket address (IPv4/IPv6) parsing error
959 /// Invalid input format
963 /// Invalid onion v3 address
967 impl fmt::Display for SocketAddressParseError {
968 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
970 SocketAddressParseError::SocketAddrParse => write!(f, "Socket address (IPv4/IPv6) parsing error"),
971 SocketAddressParseError::InvalidInput => write!(f, "Invalid input format. \
972 Expected: \"<ipv4>:<port>\", \"[<ipv6>]:<port>\", \"<onion address>.onion:<port>\" or \"<hostname>:<port>\""),
973 SocketAddressParseError::InvalidPort => write!(f, "Invalid port"),
974 SocketAddressParseError::InvalidOnionV3 => write!(f, "Invalid onion v3 address"),
979 #[cfg(feature = "std")]
980 impl From<std::net::SocketAddrV4> for SocketAddress {
981 fn from(addr: std::net::SocketAddrV4) -> Self {
982 SocketAddress::TcpIpV4 { addr: addr.ip().octets(), port: addr.port() }
986 #[cfg(feature = "std")]
987 impl From<std::net::SocketAddrV6> for SocketAddress {
988 fn from(addr: std::net::SocketAddrV6) -> Self {
989 SocketAddress::TcpIpV6 { addr: addr.ip().octets(), port: addr.port() }
993 #[cfg(feature = "std")]
994 impl From<std::net::SocketAddr> for SocketAddress {
995 fn from(addr: std::net::SocketAddr) -> Self {
997 std::net::SocketAddr::V4(addr) => addr.into(),
998 std::net::SocketAddr::V6(addr) => addr.into(),
1003 #[cfg(feature = "std")]
1004 impl std::net::ToSocketAddrs for SocketAddress {
1005 type Iter = std::vec::IntoIter<std::net::SocketAddr>;
1007 fn to_socket_addrs(&self) -> std::io::Result<Self::Iter> {
1009 SocketAddress::TcpIpV4 { addr, port } => {
1010 let ip_addr = std::net::Ipv4Addr::from(*addr);
1011 let socket_addr = SocketAddr::new(ip_addr.into(), *port);
1012 Ok(vec![socket_addr].into_iter())
1014 SocketAddress::TcpIpV6 { addr, port } => {
1015 let ip_addr = std::net::Ipv6Addr::from(*addr);
1016 let socket_addr = SocketAddr::new(ip_addr.into(), *port);
1017 Ok(vec![socket_addr].into_iter())
1019 SocketAddress::Hostname { ref hostname, port } => {
1020 (hostname.as_str(), *port).to_socket_addrs()
1022 SocketAddress::OnionV2(..) => {
1023 Err(std::io::Error::new(std::io::ErrorKind::Other, "Resolution of OnionV2 \
1024 addresses is currently unsupported."))
1026 SocketAddress::OnionV3 { .. } => {
1027 Err(std::io::Error::new(std::io::ErrorKind::Other, "Resolution of OnionV3 \
1028 addresses is currently unsupported."))
1034 /// Parses an OnionV3 host and port into a [`SocketAddress::OnionV3`].
1036 /// The host part must end with ".onion".
1037 pub fn parse_onion_address(host: &str, port: u16) -> Result<SocketAddress, SocketAddressParseError> {
1038 if host.ends_with(".onion") {
1039 let domain = &host[..host.len() - ".onion".len()];
1040 if domain.len() != 56 {
1041 return Err(SocketAddressParseError::InvalidOnionV3);
1043 let onion = base32::Alphabet::RFC4648 { padding: false }.decode(&domain).map_err(|_| SocketAddressParseError::InvalidOnionV3)?;
1044 if onion.len() != 35 {
1045 return Err(SocketAddressParseError::InvalidOnionV3);
1047 let version = onion[0];
1048 let first_checksum_flag = onion[1];
1049 let second_checksum_flag = onion[2];
1050 let mut ed25519_pubkey = [0; 32];
1051 ed25519_pubkey.copy_from_slice(&onion[3..35]);
1052 let checksum = u16::from_be_bytes([first_checksum_flag, second_checksum_flag]);
1053 return Ok(SocketAddress::OnionV3 { ed25519_pubkey, checksum, version, port });
1056 return Err(SocketAddressParseError::InvalidInput);
1060 impl Display for SocketAddress {
1061 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1063 SocketAddress::TcpIpV4{addr, port} => write!(
1064 f, "{}.{}.{}.{}:{}", addr[0], addr[1], addr[2], addr[3], port)?,
1065 SocketAddress::TcpIpV6{addr, port} => write!(
1067 "[{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}]:{}",
1068 addr[0], addr[1], addr[2], addr[3], addr[4], addr[5], addr[6], addr[7], addr[8], addr[9], addr[10], addr[11], addr[12], addr[13], addr[14], addr[15], port
1070 SocketAddress::OnionV2(bytes) => write!(f, "OnionV2({:?})", bytes)?,
1071 SocketAddress::OnionV3 {
1077 let [first_checksum_flag, second_checksum_flag] = checksum.to_be_bytes();
1078 let mut addr = vec![*version, first_checksum_flag, second_checksum_flag];
1079 addr.extend_from_slice(ed25519_pubkey);
1080 let onion = base32::Alphabet::RFC4648 { padding: false }.encode(&addr);
1081 write!(f, "{}.onion:{}", onion, port)?
1083 SocketAddress::Hostname { hostname, port } => write!(f, "{}:{}", hostname, port)?,
1089 #[cfg(feature = "std")]
1090 impl FromStr for SocketAddress {
1091 type Err = SocketAddressParseError;
1093 fn from_str(s: &str) -> Result<Self, Self::Err> {
1094 match std::net::SocketAddr::from_str(s) {
1095 Ok(addr) => Ok(addr.into()),
1097 let trimmed_input = match s.rfind(":") {
1099 None => return Err(SocketAddressParseError::InvalidInput),
1101 let host = &s[..trimmed_input];
1102 let port: u16 = s[trimmed_input + 1..].parse().map_err(|_| SocketAddressParseError::InvalidPort)?;
1103 if host.ends_with(".onion") {
1104 return parse_onion_address(host, port);
1106 if let Ok(hostname) = Hostname::try_from(s[..trimmed_input].to_string()) {
1107 return Ok(SocketAddress::Hostname { hostname, port });
1109 return Err(SocketAddressParseError::SocketAddrParse)
1115 /// Represents the set of gossip messages that require a signature from a node's identity key.
1116 pub enum UnsignedGossipMessage<'a> {
1117 /// An unsigned channel announcement.
1118 ChannelAnnouncement(&'a UnsignedChannelAnnouncement),
1119 /// An unsigned channel update.
1120 ChannelUpdate(&'a UnsignedChannelUpdate),
1121 /// An unsigned node announcement.
1122 NodeAnnouncement(&'a UnsignedNodeAnnouncement)
1125 impl<'a> Writeable for UnsignedGossipMessage<'a> {
1126 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
1128 UnsignedGossipMessage::ChannelAnnouncement(ref msg) => msg.write(writer),
1129 UnsignedGossipMessage::ChannelUpdate(ref msg) => msg.write(writer),
1130 UnsignedGossipMessage::NodeAnnouncement(ref msg) => msg.write(writer),
1135 /// The unsigned part of a [`node_announcement`] message.
1137 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
1138 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1139 pub struct UnsignedNodeAnnouncement {
1140 /// The advertised features
1141 pub features: NodeFeatures,
1142 /// A strictly monotonic announcement counter, with gaps allowed
1144 /// The `node_id` this announcement originated from (don't rebroadcast the `node_announcement` back
1146 pub node_id: NodeId,
1147 /// An RGB color for UI purposes
1149 /// An alias, for UI purposes.
1151 /// This should be sanitized before use. There is no guarantee of uniqueness.
1152 pub alias: NodeAlias,
1153 /// List of addresses on which this node is reachable
1154 pub addresses: Vec<SocketAddress>,
1155 /// Excess address data which was signed as a part of the message which we do not (yet) understand how
1158 /// This is stored to ensure forward-compatibility as new address types are added to the lightning gossip protocol.
1159 pub excess_address_data: Vec<u8>,
1160 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1163 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1164 pub excess_data: Vec<u8>,
1166 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1167 /// A [`node_announcement`] message to be sent to or received from a peer.
1169 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
1170 pub struct NodeAnnouncement {
1171 /// The signature by the node key
1172 pub signature: Signature,
1173 /// The actual content of the announcement
1174 pub contents: UnsignedNodeAnnouncement,
1177 /// The unsigned part of a [`channel_announcement`] message.
1179 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
1180 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1181 pub struct UnsignedChannelAnnouncement {
1182 /// The advertised channel features
1183 pub features: ChannelFeatures,
1184 /// The genesis hash of the blockchain where the channel is to be opened
1185 pub chain_hash: ChainHash,
1186 /// The short channel ID
1187 pub short_channel_id: u64,
1188 /// One of the two `node_id`s which are endpoints of this channel
1189 pub node_id_1: NodeId,
1190 /// The other of the two `node_id`s which are endpoints of this channel
1191 pub node_id_2: NodeId,
1192 /// The funding key for the first node
1193 pub bitcoin_key_1: NodeId,
1194 /// The funding key for the second node
1195 pub bitcoin_key_2: NodeId,
1196 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1199 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1200 pub excess_data: Vec<u8>,
1202 /// A [`channel_announcement`] message to be sent to or received from a peer.
1204 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
1205 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1206 pub struct ChannelAnnouncement {
1207 /// Authentication of the announcement by the first public node
1208 pub node_signature_1: Signature,
1209 /// Authentication of the announcement by the second public node
1210 pub node_signature_2: Signature,
1211 /// Proof of funding UTXO ownership by the first public node
1212 pub bitcoin_signature_1: Signature,
1213 /// Proof of funding UTXO ownership by the second public node
1214 pub bitcoin_signature_2: Signature,
1215 /// The actual announcement
1216 pub contents: UnsignedChannelAnnouncement,
1219 /// The unsigned part of a [`channel_update`] message.
1221 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1222 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1223 pub struct UnsignedChannelUpdate {
1224 /// The genesis hash of the blockchain where the channel is to be opened
1225 pub chain_hash: ChainHash,
1226 /// The short channel ID
1227 pub short_channel_id: u64,
1228 /// A strictly monotonic announcement counter, with gaps allowed, specific to this channel
1232 /// The number of blocks such that if:
1233 /// `incoming_htlc.cltv_expiry < outgoing_htlc.cltv_expiry + cltv_expiry_delta`
1234 /// then we need to fail the HTLC backwards. When forwarding an HTLC, `cltv_expiry_delta` determines
1235 /// the outgoing HTLC's minimum `cltv_expiry` value -- so, if an incoming HTLC comes in with a
1236 /// `cltv_expiry` of 100000, and the node we're forwarding to has a `cltv_expiry_delta` value of 10,
1237 /// then we'll check that the outgoing HTLC's `cltv_expiry` value is at least 100010 before
1238 /// forwarding. Note that the HTLC sender is the one who originally sets this value when
1239 /// constructing the route.
1240 pub cltv_expiry_delta: u16,
1241 /// The minimum HTLC size incoming to sender, in milli-satoshi
1242 pub htlc_minimum_msat: u64,
1243 /// The maximum HTLC value incoming to sender, in milli-satoshi.
1245 /// This used to be optional.
1246 pub htlc_maximum_msat: u64,
1247 /// The base HTLC fee charged by sender, in milli-satoshi
1248 pub fee_base_msat: u32,
1249 /// The amount to fee multiplier, in micro-satoshi
1250 pub fee_proportional_millionths: u32,
1251 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1254 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1255 pub excess_data: Vec<u8>,
1257 /// A [`channel_update`] message to be sent to or received from a peer.
1259 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1260 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1261 pub struct ChannelUpdate {
1262 /// A signature of the channel update
1263 pub signature: Signature,
1264 /// The actual channel update
1265 pub contents: UnsignedChannelUpdate,
1268 /// A [`query_channel_range`] message is used to query a peer for channel
1269 /// UTXOs in a range of blocks. The recipient of a query makes a best
1270 /// effort to reply to the query using one or more [`ReplyChannelRange`]
1273 /// [`query_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1274 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1275 pub struct QueryChannelRange {
1276 /// The genesis hash of the blockchain being queried
1277 pub chain_hash: ChainHash,
1278 /// The height of the first block for the channel UTXOs being queried
1279 pub first_blocknum: u32,
1280 /// The number of blocks to include in the query results
1281 pub number_of_blocks: u32,
1284 /// A [`reply_channel_range`] message is a reply to a [`QueryChannelRange`]
1287 /// Multiple `reply_channel_range` messages can be sent in reply
1288 /// to a single [`QueryChannelRange`] message. The query recipient makes a
1289 /// best effort to respond based on their local network view which may
1290 /// not be a perfect view of the network. The `short_channel_id`s in the
1291 /// reply are encoded. We only support `encoding_type=0` uncompressed
1292 /// serialization and do not support `encoding_type=1` zlib serialization.
1294 /// [`reply_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1295 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1296 pub struct ReplyChannelRange {
1297 /// The genesis hash of the blockchain being queried
1298 pub chain_hash: ChainHash,
1299 /// The height of the first block in the range of the reply
1300 pub first_blocknum: u32,
1301 /// The number of blocks included in the range of the reply
1302 pub number_of_blocks: u32,
1303 /// True when this is the final reply for a query
1304 pub sync_complete: bool,
1305 /// The `short_channel_id`s in the channel range
1306 pub short_channel_ids: Vec<u64>,
1309 /// A [`query_short_channel_ids`] message is used to query a peer for
1310 /// routing gossip messages related to one or more `short_channel_id`s.
1312 /// The query recipient will reply with the latest, if available,
1313 /// [`ChannelAnnouncement`], [`ChannelUpdate`] and [`NodeAnnouncement`] messages
1314 /// it maintains for the requested `short_channel_id`s followed by a
1315 /// [`ReplyShortChannelIdsEnd`] message. The `short_channel_id`s sent in
1316 /// this query are encoded. We only support `encoding_type=0` uncompressed
1317 /// serialization and do not support `encoding_type=1` zlib serialization.
1319 /// [`query_short_channel_ids`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_short_channel_idsreply_short_channel_ids_end-messages
1320 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1321 pub struct QueryShortChannelIds {
1322 /// The genesis hash of the blockchain being queried
1323 pub chain_hash: ChainHash,
1324 /// The short_channel_ids that are being queried
1325 pub short_channel_ids: Vec<u64>,
1328 /// A [`reply_short_channel_ids_end`] message is sent as a reply to a
1329 /// message. The query recipient makes a best
1330 /// effort to respond based on their local network view which may not be
1331 /// a perfect view of the network.
1333 /// [`reply_short_channel_ids_end`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_short_channel_idsreply_short_channel_ids_end-messages
1334 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1335 pub struct ReplyShortChannelIdsEnd {
1336 /// The genesis hash of the blockchain that was queried
1337 pub chain_hash: ChainHash,
1338 /// Indicates if the query recipient maintains up-to-date channel
1339 /// information for the `chain_hash`
1340 pub full_information: bool,
1343 /// A [`gossip_timestamp_filter`] message is used by a node to request
1344 /// gossip relay for messages in the requested time range when the
1345 /// `gossip_queries` feature has been negotiated.
1347 /// [`gossip_timestamp_filter`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-gossip_timestamp_filter-message
1348 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1349 pub struct GossipTimestampFilter {
1350 /// The genesis hash of the blockchain for channel and node information
1351 pub chain_hash: ChainHash,
1352 /// The starting unix timestamp
1353 pub first_timestamp: u32,
1354 /// The range of information in seconds
1355 pub timestamp_range: u32,
1358 /// Encoding type for data compression of collections in gossip queries.
1360 /// We do not support `encoding_type=1` zlib serialization [defined in BOLT
1361 /// #7](https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#query-messages).
1363 Uncompressed = 0x00,
1366 /// Used to put an error message in a [`LightningError`].
1367 #[derive(Clone, Debug, Hash, PartialEq)]
1368 pub enum ErrorAction {
1369 /// The peer took some action which made us think they were useless. Disconnect them.
1371 /// An error message which we should make an effort to send before we disconnect.
1372 msg: Option<ErrorMessage>
1374 /// The peer did something incorrect. Tell them without closing any channels and disconnect them.
1375 DisconnectPeerWithWarning {
1376 /// A warning message which we should make an effort to send before we disconnect.
1377 msg: WarningMessage,
1379 /// The peer did something harmless that we weren't able to process, just log and ignore
1380 // New code should *not* use this. New code must use IgnoreAndLog, below!
1382 /// The peer did something harmless that we weren't able to meaningfully process.
1383 /// If the error is logged, log it at the given level.
1384 IgnoreAndLog(logger::Level),
1385 /// The peer provided us with a gossip message which we'd already seen. In most cases this
1386 /// should be ignored, but it may result in the message being forwarded if it is a duplicate of
1387 /// our own channel announcements.
1388 IgnoreDuplicateGossip,
1389 /// The peer did something incorrect. Tell them.
1391 /// The message to send.
1394 /// The peer did something incorrect. Tell them without closing any channels.
1395 SendWarningMessage {
1396 /// The message to send.
1397 msg: WarningMessage,
1398 /// The peer may have done something harmless that we weren't able to meaningfully process,
1399 /// though we should still tell them about it.
1400 /// If this event is logged, log it at the given level.
1401 log_level: logger::Level,
1405 /// An Err type for failure to process messages.
1406 #[derive(Clone, Debug)]
1407 pub struct LightningError {
1408 /// A human-readable message describing the error
1410 /// The action which should be taken against the offending peer.
1411 pub action: ErrorAction,
1414 /// Struct used to return values from [`RevokeAndACK`] messages, containing a bunch of commitment
1415 /// transaction updates if they were pending.
1416 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1417 pub struct CommitmentUpdate {
1418 /// `update_add_htlc` messages which should be sent
1419 pub update_add_htlcs: Vec<UpdateAddHTLC>,
1420 /// `update_fulfill_htlc` messages which should be sent
1421 pub update_fulfill_htlcs: Vec<UpdateFulfillHTLC>,
1422 /// `update_fail_htlc` messages which should be sent
1423 pub update_fail_htlcs: Vec<UpdateFailHTLC>,
1424 /// `update_fail_malformed_htlc` messages which should be sent
1425 pub update_fail_malformed_htlcs: Vec<UpdateFailMalformedHTLC>,
1426 /// An `update_fee` message which should be sent
1427 pub update_fee: Option<UpdateFee>,
1428 /// A `commitment_signed` message which should be sent
1429 pub commitment_signed: CommitmentSigned,
1432 /// A trait to describe an object which can receive channel messages.
1434 /// Messages MAY be called in parallel when they originate from different `their_node_ids`, however
1435 /// they MUST NOT be called in parallel when the two calls have the same `their_node_id`.
1436 pub trait ChannelMessageHandler : MessageSendEventsProvider {
1438 /// Handle an incoming `open_channel` message from the given peer.
1439 fn handle_open_channel(&self, their_node_id: &PublicKey, msg: &OpenChannel);
1440 /// Handle an incoming `open_channel2` message from the given peer.
1441 fn handle_open_channel_v2(&self, their_node_id: &PublicKey, msg: &OpenChannelV2);
1442 /// Handle an incoming `accept_channel` message from the given peer.
1443 fn handle_accept_channel(&self, their_node_id: &PublicKey, msg: &AcceptChannel);
1444 /// Handle an incoming `accept_channel2` message from the given peer.
1445 fn handle_accept_channel_v2(&self, their_node_id: &PublicKey, msg: &AcceptChannelV2);
1446 /// Handle an incoming `funding_created` message from the given peer.
1447 fn handle_funding_created(&self, their_node_id: &PublicKey, msg: &FundingCreated);
1448 /// Handle an incoming `funding_signed` message from the given peer.
1449 fn handle_funding_signed(&self, their_node_id: &PublicKey, msg: &FundingSigned);
1450 /// Handle an incoming `channel_ready` message from the given peer.
1451 fn handle_channel_ready(&self, their_node_id: &PublicKey, msg: &ChannelReady);
1454 /// Handle an incoming `shutdown` message from the given peer.
1455 fn handle_shutdown(&self, their_node_id: &PublicKey, msg: &Shutdown);
1456 /// Handle an incoming `closing_signed` message from the given peer.
1457 fn handle_closing_signed(&self, their_node_id: &PublicKey, msg: &ClosingSigned);
1460 /// Handle an incoming `stfu` message from the given peer.
1461 fn handle_stfu(&self, their_node_id: &PublicKey, msg: &Stfu);
1464 /// Handle an incoming `splice` message from the given peer.
1465 #[cfg(dual_funding)]
1466 fn handle_splice(&self, their_node_id: &PublicKey, msg: &Splice);
1467 /// Handle an incoming `splice_ack` message from the given peer.
1468 #[cfg(dual_funding)]
1469 fn handle_splice_ack(&self, their_node_id: &PublicKey, msg: &SpliceAck);
1470 /// Handle an incoming `splice_locked` message from the given peer.
1471 #[cfg(dual_funding)]
1472 fn handle_splice_locked(&self, their_node_id: &PublicKey, msg: &SpliceLocked);
1474 // Interactive channel construction
1475 /// Handle an incoming `tx_add_input message` from the given peer.
1476 fn handle_tx_add_input(&self, their_node_id: &PublicKey, msg: &TxAddInput);
1477 /// Handle an incoming `tx_add_output` message from the given peer.
1478 fn handle_tx_add_output(&self, their_node_id: &PublicKey, msg: &TxAddOutput);
1479 /// Handle an incoming `tx_remove_input` message from the given peer.
1480 fn handle_tx_remove_input(&self, their_node_id: &PublicKey, msg: &TxRemoveInput);
1481 /// Handle an incoming `tx_remove_output` message from the given peer.
1482 fn handle_tx_remove_output(&self, their_node_id: &PublicKey, msg: &TxRemoveOutput);
1483 /// Handle an incoming `tx_complete message` from the given peer.
1484 fn handle_tx_complete(&self, their_node_id: &PublicKey, msg: &TxComplete);
1485 /// Handle an incoming `tx_signatures` message from the given peer.
1486 fn handle_tx_signatures(&self, their_node_id: &PublicKey, msg: &TxSignatures);
1487 /// Handle an incoming `tx_init_rbf` message from the given peer.
1488 fn handle_tx_init_rbf(&self, their_node_id: &PublicKey, msg: &TxInitRbf);
1489 /// Handle an incoming `tx_ack_rbf` message from the given peer.
1490 fn handle_tx_ack_rbf(&self, their_node_id: &PublicKey, msg: &TxAckRbf);
1491 /// Handle an incoming `tx_abort message` from the given peer.
1492 fn handle_tx_abort(&self, their_node_id: &PublicKey, msg: &TxAbort);
1495 /// Handle an incoming `update_add_htlc` message from the given peer.
1496 fn handle_update_add_htlc(&self, their_node_id: &PublicKey, msg: &UpdateAddHTLC);
1497 /// Handle an incoming `update_fulfill_htlc` message from the given peer.
1498 fn handle_update_fulfill_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFulfillHTLC);
1499 /// Handle an incoming `update_fail_htlc` message from the given peer.
1500 fn handle_update_fail_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailHTLC);
1501 /// Handle an incoming `update_fail_malformed_htlc` message from the given peer.
1502 fn handle_update_fail_malformed_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailMalformedHTLC);
1503 /// Handle an incoming `commitment_signed` message from the given peer.
1504 fn handle_commitment_signed(&self, their_node_id: &PublicKey, msg: &CommitmentSigned);
1505 /// Handle an incoming `revoke_and_ack` message from the given peer.
1506 fn handle_revoke_and_ack(&self, their_node_id: &PublicKey, msg: &RevokeAndACK);
1508 /// Handle an incoming `update_fee` message from the given peer.
1509 fn handle_update_fee(&self, their_node_id: &PublicKey, msg: &UpdateFee);
1511 // Channel-to-announce:
1512 /// Handle an incoming `announcement_signatures` message from the given peer.
1513 fn handle_announcement_signatures(&self, their_node_id: &PublicKey, msg: &AnnouncementSignatures);
1515 // Connection loss/reestablish:
1516 /// Indicates a connection to the peer failed/an existing connection was lost.
1517 fn peer_disconnected(&self, their_node_id: &PublicKey);
1519 /// Handle a peer reconnecting, possibly generating `channel_reestablish` message(s).
1521 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1522 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1523 /// message handlers may still wish to communicate with this peer.
1524 fn peer_connected(&self, their_node_id: &PublicKey, msg: &Init, inbound: bool) -> Result<(), ()>;
1525 /// Handle an incoming `channel_reestablish` message from the given peer.
1526 fn handle_channel_reestablish(&self, their_node_id: &PublicKey, msg: &ChannelReestablish);
1528 /// Handle an incoming `channel_update` message from the given peer.
1529 fn handle_channel_update(&self, their_node_id: &PublicKey, msg: &ChannelUpdate);
1532 /// Handle an incoming `error` message from the given peer.
1533 fn handle_error(&self, their_node_id: &PublicKey, msg: &ErrorMessage);
1535 // Handler information:
1536 /// Gets the node feature flags which this handler itself supports. All available handlers are
1537 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1538 /// which are broadcasted in our [`NodeAnnouncement`] message.
1539 fn provided_node_features(&self) -> NodeFeatures;
1541 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1542 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1543 /// which are sent in our [`Init`] message.
1545 /// Note that this method is called before [`Self::peer_connected`].
1546 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1548 /// Gets the chain hashes for this `ChannelMessageHandler` indicating which chains it supports.
1550 /// If it's `None`, then no particular network chain hash compatibility will be enforced when
1551 /// connecting to peers.
1552 fn get_chain_hashes(&self) -> Option<Vec<ChainHash>>;
1555 /// A trait to describe an object which can receive routing messages.
1557 /// # Implementor DoS Warnings
1559 /// For messages enabled with the `gossip_queries` feature there are potential DoS vectors when
1560 /// handling inbound queries. Implementors using an on-disk network graph should be aware of
1561 /// repeated disk I/O for queries accessing different parts of the network graph.
1562 pub trait RoutingMessageHandler : MessageSendEventsProvider {
1563 /// Handle an incoming `node_announcement` message, returning `true` if it should be forwarded on,
1564 /// `false` or returning an `Err` otherwise.
1565 fn handle_node_announcement(&self, msg: &NodeAnnouncement) -> Result<bool, LightningError>;
1566 /// Handle a `channel_announcement` message, returning `true` if it should be forwarded on, `false`
1567 /// or returning an `Err` otherwise.
1568 fn handle_channel_announcement(&self, msg: &ChannelAnnouncement) -> Result<bool, LightningError>;
1569 /// Handle an incoming `channel_update` message, returning true if it should be forwarded on,
1570 /// `false` or returning an `Err` otherwise.
1571 fn handle_channel_update(&self, msg: &ChannelUpdate) -> Result<bool, LightningError>;
1572 /// Gets channel announcements and updates required to dump our routing table to a remote node,
1573 /// starting at the `short_channel_id` indicated by `starting_point` and including announcements
1574 /// for a single channel.
1575 fn get_next_channel_announcement(&self, starting_point: u64) -> Option<(ChannelAnnouncement, Option<ChannelUpdate>, Option<ChannelUpdate>)>;
1576 /// Gets a node announcement required to dump our routing table to a remote node, starting at
1577 /// the node *after* the provided pubkey and including up to one announcement immediately
1578 /// higher (as defined by `<PublicKey as Ord>::cmp`) than `starting_point`.
1579 /// If `None` is provided for `starting_point`, we start at the first node.
1580 fn get_next_node_announcement(&self, starting_point: Option<&NodeId>) -> Option<NodeAnnouncement>;
1581 /// Called when a connection is established with a peer. This can be used to
1582 /// perform routing table synchronization using a strategy defined by the
1585 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1586 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1587 /// message handlers may still wish to communicate with this peer.
1588 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1589 /// Handles the reply of a query we initiated to learn about channels
1590 /// for a given range of blocks. We can expect to receive one or more
1591 /// replies to a single query.
1592 fn handle_reply_channel_range(&self, their_node_id: &PublicKey, msg: ReplyChannelRange) -> Result<(), LightningError>;
1593 /// Handles the reply of a query we initiated asking for routing gossip
1594 /// messages for a list of channels. We should receive this message when
1595 /// a node has completed its best effort to send us the pertaining routing
1596 /// gossip messages.
1597 fn handle_reply_short_channel_ids_end(&self, their_node_id: &PublicKey, msg: ReplyShortChannelIdsEnd) -> Result<(), LightningError>;
1598 /// Handles when a peer asks us to send a list of `short_channel_id`s
1599 /// for the requested range of blocks.
1600 fn handle_query_channel_range(&self, their_node_id: &PublicKey, msg: QueryChannelRange) -> Result<(), LightningError>;
1601 /// Handles when a peer asks us to send routing gossip messages for a
1602 /// list of `short_channel_id`s.
1603 fn handle_query_short_channel_ids(&self, their_node_id: &PublicKey, msg: QueryShortChannelIds) -> Result<(), LightningError>;
1605 // Handler queueing status:
1606 /// Indicates that there are a large number of [`ChannelAnnouncement`] (or other) messages
1607 /// pending some async action. While there is no guarantee of the rate of future messages, the
1608 /// caller should seek to reduce the rate of new gossip messages handled, especially
1609 /// [`ChannelAnnouncement`]s.
1610 fn processing_queue_high(&self) -> bool;
1612 // Handler information:
1613 /// Gets the node feature flags which this handler itself supports. All available handlers are
1614 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1615 /// which are broadcasted in our [`NodeAnnouncement`] message.
1616 fn provided_node_features(&self) -> NodeFeatures;
1617 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1618 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1619 /// which are sent in our [`Init`] message.
1621 /// Note that this method is called before [`Self::peer_connected`].
1622 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1625 /// A handler for received [`OnionMessage`]s and for providing generated ones to send.
1626 pub trait OnionMessageHandler: EventsProvider {
1627 /// Handle an incoming `onion_message` message from the given peer.
1628 fn handle_onion_message(&self, peer_node_id: &PublicKey, msg: &OnionMessage);
1630 /// Returns the next pending onion message for the peer with the given node id.
1631 fn next_onion_message_for_peer(&self, peer_node_id: PublicKey) -> Option<OnionMessage>;
1633 /// Called when a connection is established with a peer. Can be used to track which peers
1634 /// advertise onion message support and are online.
1636 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1637 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1638 /// message handlers may still wish to communicate with this peer.
1639 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1641 /// Indicates a connection to the peer failed/an existing connection was lost. Allows handlers to
1642 /// drop and refuse to forward onion messages to this peer.
1643 fn peer_disconnected(&self, their_node_id: &PublicKey);
1645 /// Performs actions that should happen roughly every ten seconds after startup. Allows handlers
1646 /// to drop any buffered onion messages intended for prospective peers.
1647 fn timer_tick_occurred(&self);
1649 // Handler information:
1650 /// Gets the node feature flags which this handler itself supports. All available handlers are
1651 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1652 /// which are broadcasted in our [`NodeAnnouncement`] message.
1653 fn provided_node_features(&self) -> NodeFeatures;
1655 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1656 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1657 /// which are sent in our [`Init`] message.
1659 /// Note that this method is called before [`Self::peer_connected`].
1660 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1664 #[cfg_attr(test, derive(Debug, PartialEq))]
1665 /// Information communicated in the onion to the recipient for multi-part tracking and proof that
1666 /// the payment is associated with an invoice.
1667 pub struct FinalOnionHopData {
1668 /// When sending a multi-part payment, this secret is used to identify a payment across HTLCs.
1669 /// Because it is generated by the recipient and included in the invoice, it also provides
1670 /// proof to the recipient that the payment was sent by someone with the generated invoice.
1671 pub payment_secret: PaymentSecret,
1672 /// The intended total amount that this payment is for.
1674 /// Message serialization may panic if this value is more than 21 million Bitcoin.
1675 pub total_msat: u64,
1678 mod fuzzy_internal_msgs {
1679 use bitcoin::secp256k1::PublicKey;
1680 use crate::blinded_path::payment::{PaymentConstraints, PaymentRelay};
1681 use crate::ln::{PaymentPreimage, PaymentSecret};
1682 use crate::ln::features::BlindedHopFeatures;
1683 use super::{FinalOnionHopData, TrampolineOnionPacket};
1685 #[allow(unused_imports)]
1686 use crate::prelude::*;
1688 // These types aren't intended to be pub, but are exposed for direct fuzzing (as we deserialize
1689 // them from untrusted input):
1691 pub enum InboundOnionPayload {
1693 short_channel_id: u64,
1694 /// The value, in msat, of the payment after this hop's fee is deducted.
1695 amt_to_forward: u64,
1696 outgoing_cltv_value: u32,
1699 payment_data: Option<FinalOnionHopData>,
1700 payment_metadata: Option<Vec<u8>>,
1701 keysend_preimage: Option<PaymentPreimage>,
1702 custom_tlvs: Vec<(u64, Vec<u8>)>,
1703 sender_intended_htlc_amt_msat: u64,
1704 cltv_expiry_height: u32,
1707 short_channel_id: u64,
1708 payment_relay: PaymentRelay,
1709 payment_constraints: PaymentConstraints,
1710 features: BlindedHopFeatures,
1711 intro_node_blinding_point: Option<PublicKey>,
1714 sender_intended_htlc_amt_msat: u64,
1716 cltv_expiry_height: u32,
1717 payment_secret: PaymentSecret,
1718 payment_constraints: PaymentConstraints,
1719 intro_node_blinding_point: Option<PublicKey>,
1720 keysend_preimage: Option<PaymentPreimage>,
1721 custom_tlvs: Vec<(u64, Vec<u8>)>,
1725 pub(crate) enum OutboundOnionPayload {
1727 short_channel_id: u64,
1728 /// The value, in msat, of the payment after this hop's fee is deducted.
1729 amt_to_forward: u64,
1730 outgoing_cltv_value: u32,
1733 TrampolineEntrypoint {
1734 amt_to_forward: u64,
1735 outgoing_cltv_value: u32,
1736 multipath_trampoline_data: Option<FinalOnionHopData>,
1737 trampoline_packet: TrampolineOnionPacket,
1740 payment_data: Option<FinalOnionHopData>,
1741 payment_metadata: Option<Vec<u8>>,
1742 keysend_preimage: Option<PaymentPreimage>,
1743 custom_tlvs: Vec<(u64, Vec<u8>)>,
1744 sender_intended_htlc_amt_msat: u64,
1745 cltv_expiry_height: u32,
1748 encrypted_tlvs: Vec<u8>,
1749 intro_node_blinding_point: Option<PublicKey>,
1752 sender_intended_htlc_amt_msat: u64,
1754 cltv_expiry_height: u32,
1755 encrypted_tlvs: Vec<u8>,
1756 intro_node_blinding_point: Option<PublicKey>, // Set if the introduction node of the blinded path is the final node
1757 keysend_preimage: Option<PaymentPreimage>,
1758 custom_tlvs: Vec<(u64, Vec<u8>)>,
1762 pub(crate) enum OutboundTrampolinePayload {
1765 /// The value, in msat, of the payment after this hop's fee is deducted.
1766 amt_to_forward: u64,
1767 outgoing_cltv_value: u32,
1768 /// The node id to which the trampoline node must find a route
1769 outgoing_node_id: PublicKey,
1773 pub struct DecodedOnionErrorPacket {
1774 pub(crate) hmac: [u8; 32],
1775 pub(crate) failuremsg: Vec<u8>,
1776 pub(crate) pad: Vec<u8>,
1780 pub use self::fuzzy_internal_msgs::*;
1781 #[cfg(not(fuzzing))]
1782 pub(crate) use self::fuzzy_internal_msgs::*;
1784 /// BOLT 4 onion packet including hop data for the next peer.
1785 #[derive(Clone, Hash, PartialEq, Eq)]
1786 pub struct OnionPacket {
1787 /// BOLT 4 version number.
1789 /// In order to ensure we always return an error on onion decode in compliance with [BOLT
1790 /// #4](https://github.com/lightning/bolts/blob/master/04-onion-routing.md), we have to
1791 /// deserialize `OnionPacket`s contained in [`UpdateAddHTLC`] messages even if the ephemeral
1792 /// public key (here) is bogus, so we hold a [`Result`] instead of a [`PublicKey`] as we'd
1794 pub public_key: Result<PublicKey, secp256k1::Error>,
1795 /// 1300 bytes encrypted payload for the next hop.
1796 pub hop_data: [u8; 20*65],
1797 /// HMAC to verify the integrity of hop_data.
1801 impl onion_utils::Packet for OnionPacket {
1802 type Data = onion_utils::FixedSizeOnionPacket;
1803 fn new(pubkey: PublicKey, hop_data: onion_utils::FixedSizeOnionPacket, hmac: [u8; 32]) -> Self {
1806 public_key: Ok(pubkey),
1807 hop_data: hop_data.0,
1813 impl fmt::Debug for OnionPacket {
1814 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1815 f.write_fmt(format_args!("OnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
1819 /// BOLT 4 onion packet including hop data for the next peer.
1820 #[derive(Clone, Hash, PartialEq, Eq)]
1821 pub struct TrampolineOnionPacket {
1822 /// Bolt 04 version number
1824 /// A random sepc256k1 point, used to build the ECDH shared secret to decrypt hop_data
1825 pub public_key: PublicKey,
1826 /// Encrypted payload for the next hop
1828 // Unlike the onion packets used for payments, Trampoline onion packets have to be shorter than
1829 // 1300 bytes. The expected default is 650 bytes.
1830 // TODO: if 650 ends up being the most common size, optimize this to be:
1831 // enum { SixFifty([u8; 650]), VarLen(Vec<u8>) }
1832 pub hop_data: Vec<u8>,
1833 /// HMAC to verify the integrity of hop_data
1837 impl onion_utils::Packet for TrampolineOnionPacket {
1838 type Data = Vec<u8>;
1839 fn new(public_key: PublicKey, hop_data: Vec<u8>, hmac: [u8; 32]) -> Self {
1849 impl Writeable for TrampolineOnionPacket {
1850 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1851 self.version.write(w)?;
1852 self.public_key.write(w)?;
1853 w.write_all(&self.hop_data)?;
1854 self.hmac.write(w)?;
1859 impl Debug for TrampolineOnionPacket {
1860 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1861 f.write_fmt(format_args!("TrampolineOnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
1865 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1866 pub(crate) struct OnionErrorPacket {
1867 // This really should be a constant size slice, but the spec lets these things be up to 128KB?
1868 // (TODO) We limit it in decode to much lower...
1869 pub(crate) data: Vec<u8>,
1872 impl fmt::Display for DecodeError {
1873 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1875 DecodeError::UnknownVersion => f.write_str("Unknown realm byte in Onion packet"),
1876 DecodeError::UnknownRequiredFeature => f.write_str("Unknown required feature preventing decode"),
1877 DecodeError::InvalidValue => f.write_str("Nonsense bytes didn't map to the type they were interpreted as"),
1878 DecodeError::ShortRead => f.write_str("Packet extended beyond the provided bytes"),
1879 DecodeError::BadLengthDescriptor => f.write_str("A length descriptor in the packet didn't describe the later data correctly"),
1880 DecodeError::Io(ref e) => fmt::Debug::fmt(e, f),
1881 DecodeError::UnsupportedCompression => f.write_str("We don't support receiving messages with zlib-compressed fields"),
1882 DecodeError::DangerousValue => f.write_str("Value would be dangerous to continue execution with"),
1887 impl From<io::Error> for DecodeError {
1888 fn from(e: io::Error) -> Self {
1889 if e.kind() == io::ErrorKind::UnexpectedEof {
1890 DecodeError::ShortRead
1892 DecodeError::Io(e.kind())
1897 impl Writeable for AcceptChannel {
1898 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1899 self.common_fields.temporary_channel_id.write(w)?;
1900 self.common_fields.dust_limit_satoshis.write(w)?;
1901 self.common_fields.max_htlc_value_in_flight_msat.write(w)?;
1902 self.channel_reserve_satoshis.write(w)?;
1903 self.common_fields.htlc_minimum_msat.write(w)?;
1904 self.common_fields.minimum_depth.write(w)?;
1905 self.common_fields.to_self_delay.write(w)?;
1906 self.common_fields.max_accepted_htlcs.write(w)?;
1907 self.common_fields.funding_pubkey.write(w)?;
1908 self.common_fields.revocation_basepoint.write(w)?;
1909 self.common_fields.payment_basepoint.write(w)?;
1910 self.common_fields.delayed_payment_basepoint.write(w)?;
1911 self.common_fields.htlc_basepoint.write(w)?;
1912 self.common_fields.first_per_commitment_point.write(w)?;
1913 #[cfg(not(taproot))]
1914 encode_tlv_stream!(w, {
1915 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
1916 (1, self.common_fields.channel_type, option),
1919 encode_tlv_stream!(w, {
1920 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
1921 (1, self.common_fields.channel_type, option),
1922 (4, self.next_local_nonce, option),
1928 impl Readable for AcceptChannel {
1929 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1930 let temporary_channel_id: ChannelId = Readable::read(r)?;
1931 let dust_limit_satoshis: u64 = Readable::read(r)?;
1932 let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;
1933 let channel_reserve_satoshis: u64 = Readable::read(r)?;
1934 let htlc_minimum_msat: u64 = Readable::read(r)?;
1935 let minimum_depth: u32 = Readable::read(r)?;
1936 let to_self_delay: u16 = Readable::read(r)?;
1937 let max_accepted_htlcs: u16 = Readable::read(r)?;
1938 let funding_pubkey: PublicKey = Readable::read(r)?;
1939 let revocation_basepoint: PublicKey = Readable::read(r)?;
1940 let payment_basepoint: PublicKey = Readable::read(r)?;
1941 let delayed_payment_basepoint: PublicKey = Readable::read(r)?;
1942 let htlc_basepoint: PublicKey = Readable::read(r)?;
1943 let first_per_commitment_point: PublicKey = Readable::read(r)?;
1945 let mut shutdown_scriptpubkey: Option<ScriptBuf> = None;
1946 let mut channel_type: Option<ChannelTypeFeatures> = None;
1947 #[cfg(not(taproot))]
1948 decode_tlv_stream!(r, {
1949 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
1950 (1, channel_type, option),
1953 let mut next_local_nonce: Option<musig2::types::PublicNonce> = None;
1955 decode_tlv_stream!(r, {
1956 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
1957 (1, channel_type, option),
1958 (4, next_local_nonce, option),
1962 common_fields: CommonAcceptChannelFields {
1963 temporary_channel_id,
1964 dust_limit_satoshis,
1965 max_htlc_value_in_flight_msat,
1971 revocation_basepoint,
1973 delayed_payment_basepoint,
1975 first_per_commitment_point,
1976 shutdown_scriptpubkey,
1979 channel_reserve_satoshis,
1986 impl Writeable for AcceptChannelV2 {
1987 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1988 self.common_fields.temporary_channel_id.write(w)?;
1989 self.funding_satoshis.write(w)?;
1990 self.common_fields.dust_limit_satoshis.write(w)?;
1991 self.common_fields.max_htlc_value_in_flight_msat.write(w)?;
1992 self.common_fields.htlc_minimum_msat.write(w)?;
1993 self.common_fields.minimum_depth.write(w)?;
1994 self.common_fields.to_self_delay.write(w)?;
1995 self.common_fields.max_accepted_htlcs.write(w)?;
1996 self.common_fields.funding_pubkey.write(w)?;
1997 self.common_fields.revocation_basepoint.write(w)?;
1998 self.common_fields.payment_basepoint.write(w)?;
1999 self.common_fields.delayed_payment_basepoint.write(w)?;
2000 self.common_fields.htlc_basepoint.write(w)?;
2001 self.common_fields.first_per_commitment_point.write(w)?;
2002 self.second_per_commitment_point.write(w)?;
2004 encode_tlv_stream!(w, {
2005 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
2006 (1, self.common_fields.channel_type, option),
2007 (2, self.require_confirmed_inputs, option),
2013 impl Readable for AcceptChannelV2 {
2014 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2015 let temporary_channel_id: ChannelId = Readable::read(r)?;
2016 let funding_satoshis: u64 = Readable::read(r)?;
2017 let dust_limit_satoshis: u64 = Readable::read(r)?;
2018 let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;
2019 let htlc_minimum_msat: u64 = Readable::read(r)?;
2020 let minimum_depth: u32 = Readable::read(r)?;
2021 let to_self_delay: u16 = Readable::read(r)?;
2022 let max_accepted_htlcs: u16 = Readable::read(r)?;
2023 let funding_pubkey: PublicKey = Readable::read(r)?;
2024 let revocation_basepoint: PublicKey = Readable::read(r)?;
2025 let payment_basepoint: PublicKey = Readable::read(r)?;
2026 let delayed_payment_basepoint: PublicKey = Readable::read(r)?;
2027 let htlc_basepoint: PublicKey = Readable::read(r)?;
2028 let first_per_commitment_point: PublicKey = Readable::read(r)?;
2029 let second_per_commitment_point: PublicKey = Readable::read(r)?;
2031 let mut shutdown_scriptpubkey: Option<ScriptBuf> = None;
2032 let mut channel_type: Option<ChannelTypeFeatures> = None;
2033 let mut require_confirmed_inputs: Option<()> = None;
2034 decode_tlv_stream!(r, {
2035 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
2036 (1, channel_type, option),
2037 (2, require_confirmed_inputs, option),
2040 Ok(AcceptChannelV2 {
2041 common_fields: CommonAcceptChannelFields {
2042 temporary_channel_id,
2043 dust_limit_satoshis,
2044 max_htlc_value_in_flight_msat,
2050 revocation_basepoint,
2052 delayed_payment_basepoint,
2054 first_per_commitment_point,
2055 shutdown_scriptpubkey,
2059 second_per_commitment_point,
2060 require_confirmed_inputs,
2065 impl_writeable_msg!(Stfu, {
2070 impl_writeable_msg!(Splice, {
2074 funding_feerate_perkw,
2079 impl_writeable_msg!(SpliceAck, {
2086 impl_writeable_msg!(SpliceLocked, {
2090 impl_writeable_msg!(TxAddInput, {
2098 impl_writeable_msg!(TxAddOutput, {
2105 impl_writeable_msg!(TxRemoveInput, {
2110 impl_writeable_msg!(TxRemoveOutput, {
2115 impl_writeable_msg!(TxComplete, {
2119 impl_writeable_msg!(TxSignatures, {
2124 (0, funding_outpoint_sig, option),
2127 impl_writeable_msg!(TxInitRbf, {
2130 feerate_sat_per_1000_weight,
2132 (0, funding_output_contribution, option),
2135 impl_writeable_msg!(TxAckRbf, {
2138 (0, funding_output_contribution, option),
2141 impl_writeable_msg!(TxAbort, {
2146 impl_writeable_msg!(AnnouncementSignatures, {
2153 impl_writeable_msg!(ChannelReestablish, {
2155 next_local_commitment_number,
2156 next_remote_commitment_number,
2157 your_last_per_commitment_secret,
2158 my_current_per_commitment_point,
2160 (0, next_funding_txid, option),
2163 impl_writeable_msg!(ClosingSigned,
2164 { channel_id, fee_satoshis, signature },
2165 { (1, fee_range, option) }
2168 impl_writeable!(ClosingSignedFeeRange, {
2173 #[cfg(not(taproot))]
2174 impl_writeable_msg!(CommitmentSigned, {
2181 impl_writeable_msg!(CommitmentSigned, {
2186 (2, partial_signature_with_nonce, option)
2189 impl_writeable!(DecodedOnionErrorPacket, {
2195 #[cfg(not(taproot))]
2196 impl_writeable_msg!(FundingCreated, {
2197 temporary_channel_id,
2199 funding_output_index,
2203 impl_writeable_msg!(FundingCreated, {
2204 temporary_channel_id,
2206 funding_output_index,
2209 (2, partial_signature_with_nonce, option),
2210 (4, next_local_nonce, option)
2213 #[cfg(not(taproot))]
2214 impl_writeable_msg!(FundingSigned, {
2220 impl_writeable_msg!(FundingSigned, {
2224 (2, partial_signature_with_nonce, option)
2227 impl_writeable_msg!(ChannelReady, {
2229 next_per_commitment_point,
2231 (1, short_channel_id_alias, option),
2234 impl Writeable for Init {
2235 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2236 // global_features gets the bottom 13 bits of our features, and local_features gets all of
2237 // our relevant feature bits. This keeps us compatible with old nodes.
2238 self.features.write_up_to_13(w)?;
2239 self.features.write(w)?;
2240 encode_tlv_stream!(w, {
2241 (1, self.networks.as_ref().map(|n| WithoutLength(n)), option),
2242 (3, self.remote_network_address, option),
2248 impl Readable for Init {
2249 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2250 let global_features: InitFeatures = Readable::read(r)?;
2251 let features: InitFeatures = Readable::read(r)?;
2252 let mut remote_network_address: Option<SocketAddress> = None;
2253 let mut networks: Option<WithoutLength<Vec<ChainHash>>> = None;
2254 decode_tlv_stream!(r, {
2255 (1, networks, option),
2256 (3, remote_network_address, option)
2259 features: features | global_features,
2260 networks: networks.map(|n| n.0),
2261 remote_network_address,
2266 impl Writeable for OpenChannel {
2267 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2268 self.common_fields.chain_hash.write(w)?;
2269 self.common_fields.temporary_channel_id.write(w)?;
2270 self.common_fields.funding_satoshis.write(w)?;
2271 self.push_msat.write(w)?;
2272 self.common_fields.dust_limit_satoshis.write(w)?;
2273 self.common_fields.max_htlc_value_in_flight_msat.write(w)?;
2274 self.channel_reserve_satoshis.write(w)?;
2275 self.common_fields.htlc_minimum_msat.write(w)?;
2276 self.common_fields.commitment_feerate_sat_per_1000_weight.write(w)?;
2277 self.common_fields.to_self_delay.write(w)?;
2278 self.common_fields.max_accepted_htlcs.write(w)?;
2279 self.common_fields.funding_pubkey.write(w)?;
2280 self.common_fields.revocation_basepoint.write(w)?;
2281 self.common_fields.payment_basepoint.write(w)?;
2282 self.common_fields.delayed_payment_basepoint.write(w)?;
2283 self.common_fields.htlc_basepoint.write(w)?;
2284 self.common_fields.first_per_commitment_point.write(w)?;
2285 self.common_fields.channel_flags.write(w)?;
2286 encode_tlv_stream!(w, {
2287 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
2288 (1, self.common_fields.channel_type, option),
2294 impl Readable for OpenChannel {
2295 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2296 let chain_hash: ChainHash = Readable::read(r)?;
2297 let temporary_channel_id: ChannelId = Readable::read(r)?;
2298 let funding_satoshis: u64 = Readable::read(r)?;
2299 let push_msat: u64 = Readable::read(r)?;
2300 let dust_limit_satoshis: u64 = Readable::read(r)?;
2301 let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;
2302 let channel_reserve_satoshis: u64 = Readable::read(r)?;
2303 let htlc_minimum_msat: u64 = Readable::read(r)?;
2304 let commitment_feerate_sat_per_1000_weight: u32 = Readable::read(r)?;
2305 let to_self_delay: u16 = Readable::read(r)?;
2306 let max_accepted_htlcs: u16 = Readable::read(r)?;
2307 let funding_pubkey: PublicKey = Readable::read(r)?;
2308 let revocation_basepoint: PublicKey = Readable::read(r)?;
2309 let payment_basepoint: PublicKey = Readable::read(r)?;
2310 let delayed_payment_basepoint: PublicKey = Readable::read(r)?;
2311 let htlc_basepoint: PublicKey = Readable::read(r)?;
2312 let first_per_commitment_point: PublicKey = Readable::read(r)?;
2313 let channel_flags: u8 = Readable::read(r)?;
2315 let mut shutdown_scriptpubkey: Option<ScriptBuf> = None;
2316 let mut channel_type: Option<ChannelTypeFeatures> = None;
2317 decode_tlv_stream!(r, {
2318 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
2319 (1, channel_type, option),
2322 common_fields: CommonOpenChannelFields {
2324 temporary_channel_id,
2326 dust_limit_satoshis,
2327 max_htlc_value_in_flight_msat,
2329 commitment_feerate_sat_per_1000_weight,
2333 revocation_basepoint,
2335 delayed_payment_basepoint,
2337 first_per_commitment_point,
2339 shutdown_scriptpubkey,
2343 channel_reserve_satoshis,
2348 impl Writeable for OpenChannelV2 {
2349 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2350 self.common_fields.chain_hash.write(w)?;
2351 self.common_fields.temporary_channel_id.write(w)?;
2352 self.funding_feerate_sat_per_1000_weight.write(w)?;
2353 self.common_fields.commitment_feerate_sat_per_1000_weight.write(w)?;
2354 self.common_fields.funding_satoshis.write(w)?;
2355 self.common_fields.dust_limit_satoshis.write(w)?;
2356 self.common_fields.max_htlc_value_in_flight_msat.write(w)?;
2357 self.common_fields.htlc_minimum_msat.write(w)?;
2358 self.common_fields.to_self_delay.write(w)?;
2359 self.common_fields.max_accepted_htlcs.write(w)?;
2360 self.locktime.write(w)?;
2361 self.common_fields.funding_pubkey.write(w)?;
2362 self.common_fields.revocation_basepoint.write(w)?;
2363 self.common_fields.payment_basepoint.write(w)?;
2364 self.common_fields.delayed_payment_basepoint.write(w)?;
2365 self.common_fields.htlc_basepoint.write(w)?;
2366 self.common_fields.first_per_commitment_point.write(w)?;
2367 self.second_per_commitment_point.write(w)?;
2368 self.common_fields.channel_flags.write(w)?;
2369 encode_tlv_stream!(w, {
2370 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
2371 (1, self.common_fields.channel_type, option),
2372 (2, self.require_confirmed_inputs, option),
2378 impl Readable for OpenChannelV2 {
2379 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2380 let chain_hash: ChainHash = Readable::read(r)?;
2381 let temporary_channel_id: ChannelId = Readable::read(r)?;
2382 let funding_feerate_sat_per_1000_weight: u32 = Readable::read(r)?;
2383 let commitment_feerate_sat_per_1000_weight: u32 = Readable::read(r)?;
2384 let funding_satoshis: u64 = Readable::read(r)?;
2385 let dust_limit_satoshis: u64 = Readable::read(r)?;
2386 let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;
2387 let htlc_minimum_msat: u64 = Readable::read(r)?;
2388 let to_self_delay: u16 = Readable::read(r)?;
2389 let max_accepted_htlcs: u16 = Readable::read(r)?;
2390 let locktime: u32 = Readable::read(r)?;
2391 let funding_pubkey: PublicKey = Readable::read(r)?;
2392 let revocation_basepoint: PublicKey = Readable::read(r)?;
2393 let payment_basepoint: PublicKey = Readable::read(r)?;
2394 let delayed_payment_basepoint: PublicKey = Readable::read(r)?;
2395 let htlc_basepoint: PublicKey = Readable::read(r)?;
2396 let first_per_commitment_point: PublicKey = Readable::read(r)?;
2397 let second_per_commitment_point: PublicKey = Readable::read(r)?;
2398 let channel_flags: u8 = Readable::read(r)?;
2400 let mut shutdown_scriptpubkey: Option<ScriptBuf> = None;
2401 let mut channel_type: Option<ChannelTypeFeatures> = None;
2402 let mut require_confirmed_inputs: Option<()> = None;
2403 decode_tlv_stream!(r, {
2404 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
2405 (1, channel_type, option),
2406 (2, require_confirmed_inputs, option),
2409 common_fields: CommonOpenChannelFields {
2411 temporary_channel_id,
2413 dust_limit_satoshis,
2414 max_htlc_value_in_flight_msat,
2416 commitment_feerate_sat_per_1000_weight,
2420 revocation_basepoint,
2422 delayed_payment_basepoint,
2424 first_per_commitment_point,
2426 shutdown_scriptpubkey,
2429 funding_feerate_sat_per_1000_weight,
2431 second_per_commitment_point,
2432 require_confirmed_inputs,
2437 #[cfg(not(taproot))]
2438 impl_writeable_msg!(RevokeAndACK, {
2440 per_commitment_secret,
2441 next_per_commitment_point
2445 impl_writeable_msg!(RevokeAndACK, {
2447 per_commitment_secret,
2448 next_per_commitment_point
2450 (4, next_local_nonce, option)
2453 impl_writeable_msg!(Shutdown, {
2458 impl_writeable_msg!(UpdateFailHTLC, {
2464 impl_writeable_msg!(UpdateFailMalformedHTLC, {
2471 impl_writeable_msg!(UpdateFee, {
2476 impl_writeable_msg!(UpdateFulfillHTLC, {
2482 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2483 // serialization format in a way which assumes we know the total serialized length/message end
2485 impl_writeable!(OnionErrorPacket, {
2489 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2490 // serialization format in a way which assumes we know the total serialized length/message end
2492 impl Writeable for OnionPacket {
2493 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2494 self.version.write(w)?;
2495 match self.public_key {
2496 Ok(pubkey) => pubkey.write(w)?,
2497 Err(_) => [0u8;33].write(w)?,
2499 w.write_all(&self.hop_data)?;
2500 self.hmac.write(w)?;
2505 impl Readable for OnionPacket {
2506 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2508 version: Readable::read(r)?,
2510 let mut buf = [0u8;33];
2511 r.read_exact(&mut buf)?;
2512 PublicKey::from_slice(&buf)
2514 hop_data: Readable::read(r)?,
2515 hmac: Readable::read(r)?,
2520 impl_writeable_msg!(UpdateAddHTLC, {
2526 onion_routing_packet,
2528 (0, blinding_point, option),
2529 (65537, skimmed_fee_msat, option)
2532 impl Readable for OnionMessage {
2533 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2534 let blinding_point: PublicKey = Readable::read(r)?;
2535 let len: u16 = Readable::read(r)?;
2536 let mut packet_reader = FixedLengthReader::new(r, len as u64);
2537 let onion_routing_packet: onion_message::packet::Packet =
2538 <onion_message::packet::Packet as LengthReadable>::read(&mut packet_reader)?;
2541 onion_routing_packet,
2546 impl Writeable for OnionMessage {
2547 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2548 self.blinding_point.write(w)?;
2549 let onion_packet_len = self.onion_routing_packet.serialized_length();
2550 (onion_packet_len as u16).write(w)?;
2551 self.onion_routing_packet.write(w)?;
2556 impl Writeable for FinalOnionHopData {
2557 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2558 self.payment_secret.0.write(w)?;
2559 HighZeroBytesDroppedBigSize(self.total_msat).write(w)
2563 impl Readable for FinalOnionHopData {
2564 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2565 let secret: [u8; 32] = Readable::read(r)?;
2566 let amt: HighZeroBytesDroppedBigSize<u64> = Readable::read(r)?;
2567 Ok(Self { payment_secret: PaymentSecret(secret), total_msat: amt.0 })
2571 impl Writeable for OutboundOnionPayload {
2572 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2574 Self::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } => {
2575 _encode_varint_length_prefixed_tlv!(w, {
2576 (2, HighZeroBytesDroppedBigSize(*amt_to_forward), required),
2577 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2578 (6, short_channel_id, required)
2581 Self::TrampolineEntrypoint {
2582 amt_to_forward, outgoing_cltv_value, ref multipath_trampoline_data,
2583 ref trampoline_packet
2585 _encode_varint_length_prefixed_tlv!(w, {
2586 (2, HighZeroBytesDroppedBigSize(*amt_to_forward), required),
2587 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2588 (8, multipath_trampoline_data, option),
2589 (20, trampoline_packet, required)
2593 ref payment_data, ref payment_metadata, ref keysend_preimage, sender_intended_htlc_amt_msat,
2594 cltv_expiry_height, ref custom_tlvs,
2596 // We need to update [`ln::outbound_payment::RecipientOnionFields::with_custom_tlvs`]
2597 // to reject any reserved types in the experimental range if new ones are ever
2599 let keysend_tlv = keysend_preimage.map(|preimage| (5482373484, preimage.encode()));
2600 let mut custom_tlvs: Vec<&(u64, Vec<u8>)> = custom_tlvs.iter().chain(keysend_tlv.iter()).collect();
2601 custom_tlvs.sort_unstable_by_key(|(typ, _)| *typ);
2602 _encode_varint_length_prefixed_tlv!(w, {
2603 (2, HighZeroBytesDroppedBigSize(*sender_intended_htlc_amt_msat), required),
2604 (4, HighZeroBytesDroppedBigSize(*cltv_expiry_height), required),
2605 (8, payment_data, option),
2606 (16, payment_metadata.as_ref().map(|m| WithoutLength(m)), option)
2607 }, custom_tlvs.iter());
2609 Self::BlindedForward { encrypted_tlvs, intro_node_blinding_point } => {
2610 _encode_varint_length_prefixed_tlv!(w, {
2611 (10, *encrypted_tlvs, required_vec),
2612 (12, intro_node_blinding_point, option)
2615 Self::BlindedReceive {
2616 sender_intended_htlc_amt_msat, total_msat, cltv_expiry_height, encrypted_tlvs,
2617 intro_node_blinding_point, keysend_preimage, ref custom_tlvs,
2619 // We need to update [`ln::outbound_payment::RecipientOnionFields::with_custom_tlvs`]
2620 // to reject any reserved types in the experimental range if new ones are ever
2622 let keysend_tlv = keysend_preimage.map(|preimage| (5482373484, preimage.encode()));
2623 let mut custom_tlvs: Vec<&(u64, Vec<u8>)> = custom_tlvs.iter().chain(keysend_tlv.iter()).collect();
2624 custom_tlvs.sort_unstable_by_key(|(typ, _)| *typ);
2625 _encode_varint_length_prefixed_tlv!(w, {
2626 (2, HighZeroBytesDroppedBigSize(*sender_intended_htlc_amt_msat), required),
2627 (4, HighZeroBytesDroppedBigSize(*cltv_expiry_height), required),
2628 (10, *encrypted_tlvs, required_vec),
2629 (12, intro_node_blinding_point, option),
2630 (18, HighZeroBytesDroppedBigSize(*total_msat), required)
2631 }, custom_tlvs.iter());
2638 impl Writeable for OutboundTrampolinePayload {
2639 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2641 Self::Forward { amt_to_forward, outgoing_cltv_value, outgoing_node_id } => {
2642 _encode_varint_length_prefixed_tlv!(w, {
2643 (2, HighZeroBytesDroppedBigSize(*amt_to_forward), required),
2644 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2645 (14, outgoing_node_id, required)
2654 impl<NS: Deref> ReadableArgs<(Option<PublicKey>, &NS)> for InboundOnionPayload where NS::Target: NodeSigner {
2655 fn read<R: Read>(r: &mut R, args: (Option<PublicKey>, &NS)) -> Result<Self, DecodeError> {
2656 let (update_add_blinding_point, node_signer) = args;
2659 let mut cltv_value = None;
2660 let mut short_id: Option<u64> = None;
2661 let mut payment_data: Option<FinalOnionHopData> = None;
2662 let mut encrypted_tlvs_opt: Option<WithoutLength<Vec<u8>>> = None;
2663 let mut intro_node_blinding_point = None;
2664 let mut payment_metadata: Option<WithoutLength<Vec<u8>>> = None;
2665 let mut total_msat = None;
2666 let mut keysend_preimage: Option<PaymentPreimage> = None;
2667 let mut custom_tlvs = Vec::new();
2669 let tlv_len = BigSize::read(r)?;
2670 let rd = FixedLengthReader::new(r, tlv_len.0);
2671 decode_tlv_stream_with_custom_tlv_decode!(rd, {
2672 (2, amt, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2673 (4, cltv_value, (option, encoding: (u32, HighZeroBytesDroppedBigSize))),
2674 (6, short_id, option),
2675 (8, payment_data, option),
2676 (10, encrypted_tlvs_opt, option),
2677 (12, intro_node_blinding_point, option),
2678 (16, payment_metadata, option),
2679 (18, total_msat, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2680 // See https://github.com/lightning/blips/blob/master/blip-0003.md
2681 (5482373484, keysend_preimage, option)
2682 }, |msg_type: u64, msg_reader: &mut FixedLengthReader<_>| -> Result<bool, DecodeError> {
2683 if msg_type < 1 << 16 { return Ok(false) }
2684 let mut value = Vec::new();
2685 msg_reader.read_to_end(&mut value)?;
2686 custom_tlvs.push((msg_type, value));
2690 if amt.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2691 if intro_node_blinding_point.is_some() && update_add_blinding_point.is_some() {
2692 return Err(DecodeError::InvalidValue)
2695 if let Some(blinding_point) = intro_node_blinding_point.or(update_add_blinding_point) {
2696 if short_id.is_some() || payment_data.is_some() || payment_metadata.is_some() {
2697 return Err(DecodeError::InvalidValue)
2699 let enc_tlvs = encrypted_tlvs_opt.ok_or(DecodeError::InvalidValue)?.0;
2700 let enc_tlvs_ss = node_signer.ecdh(Recipient::Node, &blinding_point, None)
2701 .map_err(|_| DecodeError::InvalidValue)?;
2702 let rho = onion_utils::gen_rho_from_shared_secret(&enc_tlvs_ss.secret_bytes());
2703 let mut s = Cursor::new(&enc_tlvs);
2704 let mut reader = FixedLengthReader::new(&mut s, enc_tlvs.len() as u64);
2705 match ChaChaPolyReadAdapter::read(&mut reader, rho)? {
2706 ChaChaPolyReadAdapter { readable: BlindedPaymentTlvs::Forward(ForwardTlvs {
2707 short_channel_id, payment_relay, payment_constraints, features
2709 if amt.is_some() || cltv_value.is_some() || total_msat.is_some() ||
2710 keysend_preimage.is_some()
2712 return Err(DecodeError::InvalidValue)
2714 Ok(Self::BlindedForward {
2717 payment_constraints,
2719 intro_node_blinding_point,
2722 ChaChaPolyReadAdapter { readable: BlindedPaymentTlvs::Receive(ReceiveTlvs {
2723 payment_secret, payment_constraints
2725 if total_msat.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2726 Ok(Self::BlindedReceive {
2727 sender_intended_htlc_amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2728 total_msat: total_msat.ok_or(DecodeError::InvalidValue)?,
2729 cltv_expiry_height: cltv_value.ok_or(DecodeError::InvalidValue)?,
2731 payment_constraints,
2732 intro_node_blinding_point,
2738 } else if let Some(short_channel_id) = short_id {
2739 if payment_data.is_some() || payment_metadata.is_some() || encrypted_tlvs_opt.is_some() ||
2740 total_msat.is_some()
2741 { return Err(DecodeError::InvalidValue) }
2744 amt_to_forward: amt.ok_or(DecodeError::InvalidValue)?,
2745 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2748 if encrypted_tlvs_opt.is_some() || total_msat.is_some() {
2749 return Err(DecodeError::InvalidValue)
2751 if let Some(data) = &payment_data {
2752 if data.total_msat > MAX_VALUE_MSAT {
2753 return Err(DecodeError::InvalidValue);
2758 payment_metadata: payment_metadata.map(|w| w.0),
2760 sender_intended_htlc_amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2761 cltv_expiry_height: cltv_value.ok_or(DecodeError::InvalidValue)?,
2768 impl Writeable for Ping {
2769 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2770 self.ponglen.write(w)?;
2771 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2776 impl Readable for Ping {
2777 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2779 ponglen: Readable::read(r)?,
2781 let byteslen = Readable::read(r)?;
2782 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2789 impl Writeable for Pong {
2790 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2791 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2796 impl Readable for Pong {
2797 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2800 let byteslen = Readable::read(r)?;
2801 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2808 impl Writeable for UnsignedChannelAnnouncement {
2809 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2810 self.features.write(w)?;
2811 self.chain_hash.write(w)?;
2812 self.short_channel_id.write(w)?;
2813 self.node_id_1.write(w)?;
2814 self.node_id_2.write(w)?;
2815 self.bitcoin_key_1.write(w)?;
2816 self.bitcoin_key_2.write(w)?;
2817 w.write_all(&self.excess_data[..])?;
2822 impl Readable for UnsignedChannelAnnouncement {
2823 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2825 features: Readable::read(r)?,
2826 chain_hash: Readable::read(r)?,
2827 short_channel_id: Readable::read(r)?,
2828 node_id_1: Readable::read(r)?,
2829 node_id_2: Readable::read(r)?,
2830 bitcoin_key_1: Readable::read(r)?,
2831 bitcoin_key_2: Readable::read(r)?,
2832 excess_data: read_to_end(r)?,
2837 impl_writeable!(ChannelAnnouncement, {
2840 bitcoin_signature_1,
2841 bitcoin_signature_2,
2845 impl Writeable for UnsignedChannelUpdate {
2846 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2847 // `message_flags` used to indicate presence of `htlc_maximum_msat`, but was deprecated in the spec.
2848 const MESSAGE_FLAGS: u8 = 1;
2849 self.chain_hash.write(w)?;
2850 self.short_channel_id.write(w)?;
2851 self.timestamp.write(w)?;
2852 let all_flags = self.flags as u16 | ((MESSAGE_FLAGS as u16) << 8);
2853 all_flags.write(w)?;
2854 self.cltv_expiry_delta.write(w)?;
2855 self.htlc_minimum_msat.write(w)?;
2856 self.fee_base_msat.write(w)?;
2857 self.fee_proportional_millionths.write(w)?;
2858 self.htlc_maximum_msat.write(w)?;
2859 w.write_all(&self.excess_data[..])?;
2864 impl Readable for UnsignedChannelUpdate {
2865 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2867 chain_hash: Readable::read(r)?,
2868 short_channel_id: Readable::read(r)?,
2869 timestamp: Readable::read(r)?,
2871 let flags: u16 = Readable::read(r)?;
2872 // Note: we ignore the `message_flags` for now, since it was deprecated by the spec.
2875 cltv_expiry_delta: Readable::read(r)?,
2876 htlc_minimum_msat: Readable::read(r)?,
2877 fee_base_msat: Readable::read(r)?,
2878 fee_proportional_millionths: Readable::read(r)?,
2879 htlc_maximum_msat: Readable::read(r)?,
2880 excess_data: read_to_end(r)?,
2885 impl_writeable!(ChannelUpdate, {
2890 impl Writeable for ErrorMessage {
2891 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2892 self.channel_id.write(w)?;
2893 (self.data.len() as u16).write(w)?;
2894 w.write_all(self.data.as_bytes())?;
2899 impl Readable for ErrorMessage {
2900 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2902 channel_id: Readable::read(r)?,
2904 let sz: usize = <u16 as Readable>::read(r)? as usize;
2905 let mut data = Vec::with_capacity(sz);
2907 r.read_exact(&mut data)?;
2908 match String::from_utf8(data) {
2910 Err(_) => return Err(DecodeError::InvalidValue),
2917 impl Writeable for WarningMessage {
2918 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2919 self.channel_id.write(w)?;
2920 (self.data.len() as u16).write(w)?;
2921 w.write_all(self.data.as_bytes())?;
2926 impl Readable for WarningMessage {
2927 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2929 channel_id: Readable::read(r)?,
2931 let sz: usize = <u16 as Readable>::read(r)? as usize;
2932 let mut data = Vec::with_capacity(sz);
2934 r.read_exact(&mut data)?;
2935 match String::from_utf8(data) {
2937 Err(_) => return Err(DecodeError::InvalidValue),
2944 impl Writeable for UnsignedNodeAnnouncement {
2945 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2946 self.features.write(w)?;
2947 self.timestamp.write(w)?;
2948 self.node_id.write(w)?;
2949 w.write_all(&self.rgb)?;
2950 self.alias.write(w)?;
2952 let mut addr_len = 0;
2953 for addr in self.addresses.iter() {
2954 addr_len += 1 + addr.len();
2956 (addr_len + self.excess_address_data.len() as u16).write(w)?;
2957 for addr in self.addresses.iter() {
2960 w.write_all(&self.excess_address_data[..])?;
2961 w.write_all(&self.excess_data[..])?;
2966 impl Readable for UnsignedNodeAnnouncement {
2967 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2968 let features: NodeFeatures = Readable::read(r)?;
2969 let timestamp: u32 = Readable::read(r)?;
2970 let node_id: NodeId = Readable::read(r)?;
2971 let mut rgb = [0; 3];
2972 r.read_exact(&mut rgb)?;
2973 let alias: NodeAlias = Readable::read(r)?;
2975 let addr_len: u16 = Readable::read(r)?;
2976 let mut addresses: Vec<SocketAddress> = Vec::new();
2977 let mut addr_readpos = 0;
2978 let mut excess = false;
2979 let mut excess_byte = 0;
2981 if addr_len <= addr_readpos { break; }
2982 match Readable::read(r) {
2984 if addr_len < addr_readpos + 1 + addr.len() {
2985 return Err(DecodeError::BadLengthDescriptor);
2987 addr_readpos += (1 + addr.len()) as u16;
2988 addresses.push(addr);
2990 Ok(Err(unknown_descriptor)) => {
2992 excess_byte = unknown_descriptor;
2995 Err(DecodeError::ShortRead) => return Err(DecodeError::BadLengthDescriptor),
2996 Err(e) => return Err(e),
3000 let mut excess_data = vec![];
3001 let excess_address_data = if addr_readpos < addr_len {
3002 let mut excess_address_data = vec![0; (addr_len - addr_readpos) as usize];
3003 r.read_exact(&mut excess_address_data[if excess { 1 } else { 0 }..])?;
3005 excess_address_data[0] = excess_byte;
3010 excess_data.push(excess_byte);
3014 excess_data.extend(read_to_end(r)?.iter());
3015 Ok(UnsignedNodeAnnouncement {
3022 excess_address_data,
3028 impl_writeable!(NodeAnnouncement, {
3033 impl Readable for QueryShortChannelIds {
3034 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
3035 let chain_hash: ChainHash = Readable::read(r)?;
3037 let encoding_len: u16 = Readable::read(r)?;
3038 let encoding_type: u8 = Readable::read(r)?;
3040 // Must be encoding_type=0 uncompressed serialization. We do not
3041 // support encoding_type=1 zlib serialization.
3042 if encoding_type != EncodingType::Uncompressed as u8 {
3043 return Err(DecodeError::UnsupportedCompression);
3046 // We expect the encoding_len to always includes the 1-byte
3047 // encoding_type and that short_channel_ids are 8-bytes each
3048 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
3049 return Err(DecodeError::InvalidValue);
3052 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
3053 // less the 1-byte encoding_type
3054 let short_channel_id_count: u16 = (encoding_len - 1)/8;
3055 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
3056 for _ in 0..short_channel_id_count {
3057 short_channel_ids.push(Readable::read(r)?);
3060 Ok(QueryShortChannelIds {
3067 impl Writeable for QueryShortChannelIds {
3068 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
3069 // Calculated from 1-byte encoding_type plus 8-bytes per short_channel_id
3070 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
3072 self.chain_hash.write(w)?;
3073 encoding_len.write(w)?;
3075 // We only support type=0 uncompressed serialization
3076 (EncodingType::Uncompressed as u8).write(w)?;
3078 for scid in self.short_channel_ids.iter() {
3086 impl_writeable_msg!(ReplyShortChannelIdsEnd, {
3091 impl QueryChannelRange {
3092 /// Calculates the overflow safe ending block height for the query.
3094 /// Overflow returns `0xffffffff`, otherwise returns `first_blocknum + number_of_blocks`.
3095 pub fn end_blocknum(&self) -> u32 {
3096 match self.first_blocknum.checked_add(self.number_of_blocks) {
3097 Some(block) => block,
3098 None => u32::max_value(),
3103 impl_writeable_msg!(QueryChannelRange, {
3109 impl Readable for ReplyChannelRange {
3110 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
3111 let chain_hash: ChainHash = Readable::read(r)?;
3112 let first_blocknum: u32 = Readable::read(r)?;
3113 let number_of_blocks: u32 = Readable::read(r)?;
3114 let sync_complete: bool = Readable::read(r)?;
3116 let encoding_len: u16 = Readable::read(r)?;
3117 let encoding_type: u8 = Readable::read(r)?;
3119 // Must be encoding_type=0 uncompressed serialization. We do not
3120 // support encoding_type=1 zlib serialization.
3121 if encoding_type != EncodingType::Uncompressed as u8 {
3122 return Err(DecodeError::UnsupportedCompression);
3125 // We expect the encoding_len to always includes the 1-byte
3126 // encoding_type and that short_channel_ids are 8-bytes each
3127 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
3128 return Err(DecodeError::InvalidValue);
3131 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
3132 // less the 1-byte encoding_type
3133 let short_channel_id_count: u16 = (encoding_len - 1)/8;
3134 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
3135 for _ in 0..short_channel_id_count {
3136 short_channel_ids.push(Readable::read(r)?);
3139 Ok(ReplyChannelRange {
3149 impl Writeable for ReplyChannelRange {
3150 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
3151 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
3152 self.chain_hash.write(w)?;
3153 self.first_blocknum.write(w)?;
3154 self.number_of_blocks.write(w)?;
3155 self.sync_complete.write(w)?;
3157 encoding_len.write(w)?;
3158 (EncodingType::Uncompressed as u8).write(w)?;
3159 for scid in self.short_channel_ids.iter() {
3167 impl_writeable_msg!(GossipTimestampFilter, {
3175 use bitcoin::{Transaction, TxIn, ScriptBuf, Sequence, Witness, TxOut};
3176 use hex::DisplayHex;
3177 use crate::ln::{PaymentPreimage, PaymentHash, PaymentSecret};
3178 use crate::ln::ChannelId;
3179 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
3180 use crate::ln::msgs::{self, FinalOnionHopData, OnionErrorPacket, CommonOpenChannelFields, CommonAcceptChannelFields, TrampolineOnionPacket};
3181 use crate::ln::msgs::SocketAddress;
3182 use crate::routing::gossip::{NodeAlias, NodeId};
3183 use crate::util::ser::{BigSize, Hostname, Readable, ReadableArgs, TransactionU16LenLimited, Writeable};
3184 use crate::util::test_utils;
3186 use bitcoin::hashes::hex::FromHex;
3187 use bitcoin::address::Address;
3188 use bitcoin::network::constants::Network;
3189 use bitcoin::blockdata::constants::ChainHash;
3190 use bitcoin::blockdata::script::Builder;
3191 use bitcoin::blockdata::opcodes;
3192 use bitcoin::hash_types::Txid;
3193 use bitcoin::locktime::absolute::LockTime;
3195 use bitcoin::secp256k1::{PublicKey,SecretKey};
3196 use bitcoin::secp256k1::{Secp256k1, Message};
3198 use crate::io::{self, Cursor};
3199 use crate::prelude::*;
3200 use core::str::FromStr;
3201 use crate::chain::transaction::OutPoint;
3203 #[cfg(feature = "std")]
3204 use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6, ToSocketAddrs};
3205 #[cfg(feature = "std")]
3206 use crate::ln::msgs::SocketAddressParseError;
3209 fn encoding_channel_reestablish() {
3211 let secp_ctx = Secp256k1::new();
3212 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&<Vec<u8>>::from_hex("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
3215 let cr = msgs::ChannelReestablish {
3216 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]),
3217 next_local_commitment_number: 3,
3218 next_remote_commitment_number: 4,
3219 your_last_per_commitment_secret: [9;32],
3220 my_current_per_commitment_point: public_key,
3221 next_funding_txid: None,
3224 let encoded_value = cr.encode();
3228 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
3229 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
3230 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
3231 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
3232 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
3238 fn encoding_channel_reestablish_with_next_funding_txid() {
3240 let secp_ctx = Secp256k1::new();
3241 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&<Vec<u8>>::from_hex("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
3244 let cr = msgs::ChannelReestablish {
3245 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]),
3246 next_local_commitment_number: 3,
3247 next_remote_commitment_number: 4,
3248 your_last_per_commitment_secret: [9;32],
3249 my_current_per_commitment_point: public_key,
3250 next_funding_txid: Some(Txid::from_raw_hash(bitcoin::hashes::Hash::from_slice(&[
3251 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,
3255 let encoded_value = cr.encode();
3259 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
3260 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
3261 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
3262 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
3263 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
3264 0, // Type (next_funding_txid)
3266 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
3271 macro_rules! get_keys_from {
3272 ($slice: expr, $secp_ctx: expr) => {
3274 let privkey = SecretKey::from_slice(&<Vec<u8>>::from_hex($slice).unwrap()[..]).unwrap();
3275 let pubkey = PublicKey::from_secret_key(&$secp_ctx, &privkey);
3281 macro_rules! get_sig_on {
3282 ($privkey: expr, $ctx: expr, $string: expr) => {
3284 let sighash = Message::from_slice(&$string.into_bytes()[..]).unwrap();
3285 $ctx.sign_ecdsa(&sighash, &$privkey)
3291 fn encoding_announcement_signatures() {
3292 let secp_ctx = Secp256k1::new();
3293 let (privkey, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3294 let sig_1 = get_sig_on!(privkey, secp_ctx, String::from("01010101010101010101010101010101"));
3295 let sig_2 = get_sig_on!(privkey, secp_ctx, String::from("02020202020202020202020202020202"));
3296 let announcement_signatures = msgs::AnnouncementSignatures {
3297 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]),
3298 short_channel_id: 2316138423780173,
3299 node_signature: sig_1,
3300 bitcoin_signature: sig_2,
3303 let encoded_value = announcement_signatures.encode();
3304 assert_eq!(encoded_value, <Vec<u8>>::from_hex("040000000000000005000000000000000600000000000000070000000000000000083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073acf9953cef4700860f5967838eba2bae89288ad188ebf8b20bf995c3ea53a26df1876d0a3a0e13172ba286a673140190c02ba9da60a2e43a745188c8a83c7f3ef").unwrap());
3307 fn do_encoding_channel_announcement(unknown_features_bits: bool, excess_data: bool) {
3308 let secp_ctx = Secp256k1::new();
3309 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3310 let (privkey_2, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3311 let (privkey_3, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3312 let (privkey_4, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3313 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3314 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
3315 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
3316 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
3317 let mut features = ChannelFeatures::empty();
3318 if unknown_features_bits {
3319 features = ChannelFeatures::from_le_bytes(vec![0xFF, 0xFF]);
3321 let unsigned_channel_announcement = msgs::UnsignedChannelAnnouncement {
3323 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3324 short_channel_id: 2316138423780173,
3325 node_id_1: NodeId::from_pubkey(&pubkey_1),
3326 node_id_2: NodeId::from_pubkey(&pubkey_2),
3327 bitcoin_key_1: NodeId::from_pubkey(&pubkey_3),
3328 bitcoin_key_2: NodeId::from_pubkey(&pubkey_4),
3329 excess_data: if excess_data { vec![10, 0, 0, 20, 0, 0, 30, 0, 0, 40] } else { Vec::new() },
3331 let channel_announcement = msgs::ChannelAnnouncement {
3332 node_signature_1: sig_1,
3333 node_signature_2: sig_2,
3334 bitcoin_signature_1: sig_3,
3335 bitcoin_signature_2: sig_4,
3336 contents: unsigned_channel_announcement,
3338 let encoded_value = channel_announcement.encode();
3339 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a1735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap();
3340 if unknown_features_bits {
3341 target_value.append(&mut <Vec<u8>>::from_hex("0002ffff").unwrap());
3343 target_value.append(&mut <Vec<u8>>::from_hex("0000").unwrap());
3345 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3346 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
3348 target_value.append(&mut <Vec<u8>>::from_hex("0a00001400001e000028").unwrap());
3350 assert_eq!(encoded_value, target_value);
3354 fn encoding_channel_announcement() {
3355 do_encoding_channel_announcement(true, false);
3356 do_encoding_channel_announcement(false, true);
3357 do_encoding_channel_announcement(false, false);
3358 do_encoding_channel_announcement(true, true);
3361 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) {
3362 let secp_ctx = Secp256k1::new();
3363 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3364 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3365 let features = if unknown_features_bits {
3366 NodeFeatures::from_le_bytes(vec![0xFF, 0xFF])
3368 // Set to some features we may support
3369 NodeFeatures::from_le_bytes(vec![2 | 1 << 5])
3371 let mut addresses = Vec::new();
3373 addresses.push(SocketAddress::TcpIpV4 {
3374 addr: [255, 254, 253, 252],
3379 addresses.push(SocketAddress::TcpIpV6 {
3380 addr: [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240],
3385 addresses.push(msgs::SocketAddress::OnionV2(
3386 [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 38, 7]
3390 addresses.push(msgs::SocketAddress::OnionV3 {
3391 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],
3398 addresses.push(SocketAddress::Hostname {
3399 hostname: Hostname::try_from(String::from("host")).unwrap(),
3403 let mut addr_len = 0;
3404 for addr in &addresses {
3405 addr_len += addr.len() + 1;
3407 let unsigned_node_announcement = msgs::UnsignedNodeAnnouncement {
3409 timestamp: 20190119,
3410 node_id: NodeId::from_pubkey(&pubkey_1),
3412 alias: NodeAlias([16;32]),
3414 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() },
3415 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() },
3417 addr_len += unsigned_node_announcement.excess_address_data.len() as u16;
3418 let node_announcement = msgs::NodeAnnouncement {
3420 contents: unsigned_node_announcement,
3422 let encoded_value = node_announcement.encode();
3423 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3424 if unknown_features_bits {
3425 target_value.append(&mut <Vec<u8>>::from_hex("0002ffff").unwrap());
3427 target_value.append(&mut <Vec<u8>>::from_hex("000122").unwrap());
3429 target_value.append(&mut <Vec<u8>>::from_hex("013413a7031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f2020201010101010101010101010101010101010101010101010101010101010101010").unwrap());
3430 target_value.append(&mut vec![(addr_len >> 8) as u8, addr_len as u8]);
3432 target_value.append(&mut <Vec<u8>>::from_hex("01fffefdfc2607").unwrap());
3435 target_value.append(&mut <Vec<u8>>::from_hex("02fffefdfcfbfaf9f8f7f6f5f4f3f2f1f02607").unwrap());
3438 target_value.append(&mut <Vec<u8>>::from_hex("03fffefdfcfbfaf9f8f7f62607").unwrap());
3441 target_value.append(&mut <Vec<u8>>::from_hex("04fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0efeeedecebeae9e8e7e6e5e4e3e2e1e00020102607").unwrap());
3444 target_value.append(&mut <Vec<u8>>::from_hex("0504686f73742607").unwrap());
3446 if excess_address_data {
3447 target_value.append(&mut <Vec<u8>>::from_hex("216c280b5395a2546e7e4b2663e04f811622f15a4f92e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d269").unwrap());
3450 target_value.append(&mut <Vec<u8>>::from_hex("3b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
3452 assert_eq!(encoded_value, target_value);
3456 fn encoding_node_announcement() {
3457 do_encoding_node_announcement(true, true, true, true, true, true, true, true);
3458 do_encoding_node_announcement(false, false, false, false, false, false, false, false);
3459 do_encoding_node_announcement(false, true, false, false, false, false, false, false);
3460 do_encoding_node_announcement(false, false, true, false, false, false, false, false);
3461 do_encoding_node_announcement(false, false, false, true, false, false, false, false);
3462 do_encoding_node_announcement(false, false, false, false, true, false, false, false);
3463 do_encoding_node_announcement(false, false, false, false, false, true, false, false);
3464 do_encoding_node_announcement(false, false, false, false, false, false, true, false);
3465 do_encoding_node_announcement(false, true, false, true, false, false, true, false);
3466 do_encoding_node_announcement(false, false, true, false, true, false, false, false);
3469 fn do_encoding_channel_update(direction: bool, disable: bool, excess_data: bool) {
3470 let secp_ctx = Secp256k1::new();
3471 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3472 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3473 let unsigned_channel_update = msgs::UnsignedChannelUpdate {
3474 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3475 short_channel_id: 2316138423780173,
3476 timestamp: 20190119,
3477 flags: if direction { 1 } else { 0 } | if disable { 1 << 1 } else { 0 },
3478 cltv_expiry_delta: 144,
3479 htlc_minimum_msat: 1000000,
3480 htlc_maximum_msat: 131355275467161,
3481 fee_base_msat: 10000,
3482 fee_proportional_millionths: 20,
3483 excess_data: if excess_data { vec![0, 0, 0, 0, 59, 154, 202, 0] } else { Vec::new() }
3485 let channel_update = msgs::ChannelUpdate {
3487 contents: unsigned_channel_update
3489 let encoded_value = channel_update.encode();
3490 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3491 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3492 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d013413a7").unwrap());
3493 target_value.append(&mut <Vec<u8>>::from_hex("01").unwrap());
3494 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3496 let flag = target_value.last_mut().unwrap();
3500 let flag = target_value.last_mut().unwrap();
3501 *flag = *flag | 1 << 1;
3503 target_value.append(&mut <Vec<u8>>::from_hex("009000000000000f42400000271000000014").unwrap());
3504 target_value.append(&mut <Vec<u8>>::from_hex("0000777788889999").unwrap());
3506 target_value.append(&mut <Vec<u8>>::from_hex("000000003b9aca00").unwrap());
3508 assert_eq!(encoded_value, target_value);
3512 fn encoding_channel_update() {
3513 do_encoding_channel_update(false, false, false);
3514 do_encoding_channel_update(false, false, true);
3515 do_encoding_channel_update(true, false, false);
3516 do_encoding_channel_update(true, false, true);
3517 do_encoding_channel_update(false, true, false);
3518 do_encoding_channel_update(false, true, true);
3519 do_encoding_channel_update(true, true, false);
3520 do_encoding_channel_update(true, true, true);
3523 fn do_encoding_open_channel(random_bit: bool, shutdown: bool, incl_chan_type: bool) {
3524 let secp_ctx = Secp256k1::new();
3525 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3526 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3527 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3528 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3529 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3530 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3531 let open_channel = msgs::OpenChannel {
3532 common_fields: CommonOpenChannelFields {
3533 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3534 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3535 funding_satoshis: 1311768467284833366,
3536 dust_limit_satoshis: 3608586615801332854,
3537 max_htlc_value_in_flight_msat: 8517154655701053848,
3538 htlc_minimum_msat: 2316138423780173,
3539 commitment_feerate_sat_per_1000_weight: 821716,
3540 to_self_delay: 49340,
3541 max_accepted_htlcs: 49340,
3542 funding_pubkey: pubkey_1,
3543 revocation_basepoint: pubkey_2,
3544 payment_basepoint: pubkey_3,
3545 delayed_payment_basepoint: pubkey_4,
3546 htlc_basepoint: pubkey_5,
3547 first_per_commitment_point: pubkey_6,
3548 channel_flags: if random_bit { 1 << 5 } else { 0 },
3549 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3550 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3552 push_msat: 2536655962884945560,
3553 channel_reserve_satoshis: 8665828695742877976,
3555 let encoded_value = open_channel.encode();
3556 let mut target_value = Vec::new();
3557 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3558 target_value.append(&mut <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202021234567890123456233403289122369832144668701144767633030896203198784335490624111800083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3560 target_value.append(&mut <Vec<u8>>::from_hex("20").unwrap());
3562 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3565 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3568 target_value.append(&mut <Vec<u8>>::from_hex("0100").unwrap());
3570 assert_eq!(encoded_value, target_value);
3574 fn encoding_open_channel() {
3575 do_encoding_open_channel(false, false, false);
3576 do_encoding_open_channel(false, false, true);
3577 do_encoding_open_channel(false, true, false);
3578 do_encoding_open_channel(false, true, true);
3579 do_encoding_open_channel(true, false, false);
3580 do_encoding_open_channel(true, false, true);
3581 do_encoding_open_channel(true, true, false);
3582 do_encoding_open_channel(true, true, true);
3585 fn do_encoding_open_channelv2(random_bit: bool, shutdown: bool, incl_chan_type: bool, require_confirmed_inputs: bool) {
3586 let secp_ctx = Secp256k1::new();
3587 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3588 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3589 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3590 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3591 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3592 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3593 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3594 let open_channelv2 = msgs::OpenChannelV2 {
3595 common_fields: CommonOpenChannelFields {
3596 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3597 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3598 commitment_feerate_sat_per_1000_weight: 821716,
3599 funding_satoshis: 1311768467284833366,
3600 dust_limit_satoshis: 3608586615801332854,
3601 max_htlc_value_in_flight_msat: 8517154655701053848,
3602 htlc_minimum_msat: 2316138423780173,
3603 to_self_delay: 49340,
3604 max_accepted_htlcs: 49340,
3605 funding_pubkey: pubkey_1,
3606 revocation_basepoint: pubkey_2,
3607 payment_basepoint: pubkey_3,
3608 delayed_payment_basepoint: pubkey_4,
3609 htlc_basepoint: pubkey_5,
3610 first_per_commitment_point: pubkey_6,
3611 channel_flags: if random_bit { 1 << 5 } else { 0 },
3612 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3613 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3615 funding_feerate_sat_per_1000_weight: 821716,
3616 locktime: 305419896,
3617 second_per_commitment_point: pubkey_7,
3618 require_confirmed_inputs: if require_confirmed_inputs { Some(()) } else { None },
3620 let encoded_value = open_channelv2.encode();
3621 let mut target_value = Vec::new();
3622 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3623 target_value.append(&mut <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap());
3624 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap());
3625 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap());
3626 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap());
3627 target_value.append(&mut <Vec<u8>>::from_hex("3214466870114476").unwrap());
3628 target_value.append(&mut <Vec<u8>>::from_hex("7633030896203198").unwrap());
3629 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d").unwrap());
3630 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap());
3631 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap());
3632 target_value.append(&mut <Vec<u8>>::from_hex("12345678").unwrap());
3633 target_value.append(&mut <Vec<u8>>::from_hex("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap());
3634 target_value.append(&mut <Vec<u8>>::from_hex("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap());
3635 target_value.append(&mut <Vec<u8>>::from_hex("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap());
3636 target_value.append(&mut <Vec<u8>>::from_hex("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
3637 target_value.append(&mut <Vec<u8>>::from_hex("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap());
3638 target_value.append(&mut <Vec<u8>>::from_hex("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3639 target_value.append(&mut <Vec<u8>>::from_hex("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap());
3642 target_value.append(&mut <Vec<u8>>::from_hex("20").unwrap());
3644 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3647 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3650 target_value.append(&mut <Vec<u8>>::from_hex("0100").unwrap());
3652 if require_confirmed_inputs {
3653 target_value.append(&mut <Vec<u8>>::from_hex("0200").unwrap());
3655 assert_eq!(encoded_value, target_value);
3659 fn encoding_open_channelv2() {
3660 do_encoding_open_channelv2(false, false, false, false);
3661 do_encoding_open_channelv2(false, false, false, true);
3662 do_encoding_open_channelv2(false, false, true, false);
3663 do_encoding_open_channelv2(false, false, true, true);
3664 do_encoding_open_channelv2(false, true, false, false);
3665 do_encoding_open_channelv2(false, true, false, true);
3666 do_encoding_open_channelv2(false, true, true, false);
3667 do_encoding_open_channelv2(false, true, true, true);
3668 do_encoding_open_channelv2(true, false, false, false);
3669 do_encoding_open_channelv2(true, false, false, true);
3670 do_encoding_open_channelv2(true, false, true, false);
3671 do_encoding_open_channelv2(true, false, true, true);
3672 do_encoding_open_channelv2(true, true, false, false);
3673 do_encoding_open_channelv2(true, true, false, true);
3674 do_encoding_open_channelv2(true, true, true, false);
3675 do_encoding_open_channelv2(true, true, true, true);
3678 fn do_encoding_accept_channel(shutdown: bool) {
3679 let secp_ctx = Secp256k1::new();
3680 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3681 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3682 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3683 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3684 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3685 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3686 let accept_channel = msgs::AcceptChannel {
3687 common_fields: CommonAcceptChannelFields {
3688 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3689 dust_limit_satoshis: 1311768467284833366,
3690 max_htlc_value_in_flight_msat: 2536655962884945560,
3691 htlc_minimum_msat: 2316138423780173,
3692 minimum_depth: 821716,
3693 to_self_delay: 49340,
3694 max_accepted_htlcs: 49340,
3695 funding_pubkey: pubkey_1,
3696 revocation_basepoint: pubkey_2,
3697 payment_basepoint: pubkey_3,
3698 delayed_payment_basepoint: pubkey_4,
3699 htlc_basepoint: pubkey_5,
3700 first_per_commitment_point: pubkey_6,
3701 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3704 channel_reserve_satoshis: 3608586615801332854,
3706 next_local_nonce: None,
3708 let encoded_value = accept_channel.encode();
3709 let mut target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020212345678901234562334032891223698321446687011447600083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap();
3711 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3713 assert_eq!(encoded_value, target_value);
3717 fn encoding_accept_channel() {
3718 do_encoding_accept_channel(false);
3719 do_encoding_accept_channel(true);
3722 fn do_encoding_accept_channelv2(shutdown: bool) {
3723 let secp_ctx = Secp256k1::new();
3724 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3725 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3726 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3727 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3728 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3729 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3730 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3731 let accept_channelv2 = msgs::AcceptChannelV2 {
3732 common_fields: CommonAcceptChannelFields {
3733 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3734 dust_limit_satoshis: 1311768467284833366,
3735 max_htlc_value_in_flight_msat: 2536655962884945560,
3736 htlc_minimum_msat: 2316138423780173,
3737 minimum_depth: 821716,
3738 to_self_delay: 49340,
3739 max_accepted_htlcs: 49340,
3740 funding_pubkey: pubkey_1,
3741 revocation_basepoint: pubkey_2,
3742 payment_basepoint: pubkey_3,
3743 delayed_payment_basepoint: pubkey_4,
3744 htlc_basepoint: pubkey_5,
3745 first_per_commitment_point: pubkey_6,
3746 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3749 funding_satoshis: 1311768467284833366,
3750 second_per_commitment_point: pubkey_7,
3751 require_confirmed_inputs: None,
3753 let encoded_value = accept_channelv2.encode();
3754 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // temporary_channel_id
3755 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap()); // funding_satoshis
3756 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap()); // dust_limit_satoshis
3757 target_value.append(&mut <Vec<u8>>::from_hex("2334032891223698").unwrap()); // max_htlc_value_in_flight_msat
3758 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d").unwrap()); // htlc_minimum_msat
3759 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap()); // minimum_depth
3760 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap()); // to_self_delay
3761 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap()); // max_accepted_htlcs
3762 target_value.append(&mut <Vec<u8>>::from_hex("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap()); // funding_pubkey
3763 target_value.append(&mut <Vec<u8>>::from_hex("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap()); // revocation_basepoint
3764 target_value.append(&mut <Vec<u8>>::from_hex("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap()); // payment_basepoint
3765 target_value.append(&mut <Vec<u8>>::from_hex("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap()); // delayed_payment_basepoint
3766 target_value.append(&mut <Vec<u8>>::from_hex("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap()); // htlc_basepoint
3767 target_value.append(&mut <Vec<u8>>::from_hex("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap()); // first_per_commitment_point
3768 target_value.append(&mut <Vec<u8>>::from_hex("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap()); // second_per_commitment_point
3770 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3772 assert_eq!(encoded_value, target_value);
3776 fn encoding_accept_channelv2() {
3777 do_encoding_accept_channelv2(false);
3778 do_encoding_accept_channelv2(true);
3782 fn encoding_funding_created() {
3783 let secp_ctx = Secp256k1::new();
3784 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3785 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3786 let funding_created = msgs::FundingCreated {
3787 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3788 funding_txid: Txid::from_str("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3789 funding_output_index: 255,
3792 partial_signature_with_nonce: None,
3794 next_local_nonce: None,
3796 let encoded_value = funding_created.encode();
3797 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202026e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c200ffd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3798 assert_eq!(encoded_value, target_value);
3802 fn encoding_funding_signed() {
3803 let secp_ctx = Secp256k1::new();
3804 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3805 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3806 let funding_signed = msgs::FundingSigned {
3807 channel_id: ChannelId::from_bytes([2; 32]),
3810 partial_signature_with_nonce: None,
3812 let encoded_value = funding_signed.encode();
3813 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3814 assert_eq!(encoded_value, target_value);
3818 fn encoding_channel_ready() {
3819 let secp_ctx = Secp256k1::new();
3820 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3821 let channel_ready = msgs::ChannelReady {
3822 channel_id: ChannelId::from_bytes([2; 32]),
3823 next_per_commitment_point: pubkey_1,
3824 short_channel_id_alias: None,
3826 let encoded_value = channel_ready.encode();
3827 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3828 assert_eq!(encoded_value, target_value);
3832 fn encoding_splice() {
3833 let secp_ctx = Secp256k1::new();
3834 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3835 let splice = msgs::Splice {
3836 chain_hash: ChainHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
3837 channel_id: ChannelId::from_bytes([2; 32]),
3838 relative_satoshis: 123456,
3839 funding_feerate_perkw: 2000,
3841 funding_pubkey: pubkey_1,
3843 let encoded_value = splice.encode();
3844 assert_eq!(encoded_value.as_hex().to_string(), "02020202020202020202020202020202020202020202020202020202020202026fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000000000000001e240000007d000000000031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f");
3848 fn encoding_stfu() {
3849 let stfu = msgs::Stfu {
3850 channel_id: ChannelId::from_bytes([2; 32]),
3853 let encoded_value = stfu.encode();
3854 assert_eq!(encoded_value.as_hex().to_string(), "020202020202020202020202020202020202020202020202020202020202020201");
3858 fn encoding_splice_ack() {
3859 let secp_ctx = Secp256k1::new();
3860 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3861 let splice = msgs::SpliceAck {
3862 chain_hash: ChainHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
3863 channel_id: ChannelId::from_bytes([2; 32]),
3864 relative_satoshis: 123456,
3865 funding_pubkey: pubkey_1,
3867 let encoded_value = splice.encode();
3868 assert_eq!(encoded_value.as_hex().to_string(), "02020202020202020202020202020202020202020202020202020202020202026fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000000000000001e240031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f");
3872 fn encoding_splice_locked() {
3873 let splice = msgs::SpliceLocked {
3874 channel_id: ChannelId::from_bytes([2; 32]),
3876 let encoded_value = splice.encode();
3877 assert_eq!(encoded_value.as_hex().to_string(), "0202020202020202020202020202020202020202020202020202020202020202");
3881 fn encoding_tx_add_input() {
3882 let tx_add_input = msgs::TxAddInput {
3883 channel_id: ChannelId::from_bytes([2; 32]),
3884 serial_id: 4886718345,
3885 prevtx: TransactionU16LenLimited::new(Transaction {
3887 lock_time: LockTime::ZERO,
3889 previous_output: OutPoint { txid: Txid::from_str("305bab643ee297b8b6b76b320792c8223d55082122cb606bf89382146ced9c77").unwrap(), index: 2 }.into_bitcoin_outpoint(),
3890 script_sig: ScriptBuf::new(),
3891 sequence: Sequence(0xfffffffd),
3892 witness: Witness::from_slice(&vec![
3893 <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3894 <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3899 script_pubkey: Address::from_str("bc1qzlffunw52jav8vwdu5x3jfk6sr8u22rmq3xzw2").unwrap().payload.script_pubkey(),
3903 script_pubkey: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().payload.script_pubkey(),
3907 prevtx_out: 305419896,
3908 sequence: 305419896,
3910 let encoded_value = tx_add_input.encode();
3911 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000000012345678900de02000000000101779ced6c148293f86b60cb222108553d22c89207326bb7b6b897e23e64ab5b300200000000fdffffff0236dbc1000000000016001417d29e4dd454bac3b1cde50d1926da80cfc5287b9cbd03000000000016001436ec78d514df462da95e6a00c24daa8915362d420247304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701210301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944000000001234567812345678").unwrap();
3912 assert_eq!(encoded_value, target_value);
3916 fn encoding_tx_add_output() {
3917 let tx_add_output = msgs::TxAddOutput {
3918 channel_id: ChannelId::from_bytes([2; 32]),
3919 serial_id: 4886718345,
3921 script: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().payload.script_pubkey(),
3923 let encoded_value = tx_add_output.encode();
3924 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000000012345678900000001234567890016001436ec78d514df462da95e6a00c24daa8915362d42").unwrap();
3925 assert_eq!(encoded_value, target_value);
3929 fn encoding_tx_remove_input() {
3930 let tx_remove_input = msgs::TxRemoveInput {
3931 channel_id: ChannelId::from_bytes([2; 32]),
3932 serial_id: 4886718345,
3934 let encoded_value = tx_remove_input.encode();
3935 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3936 assert_eq!(encoded_value, target_value);
3940 fn encoding_tx_remove_output() {
3941 let tx_remove_output = msgs::TxRemoveOutput {
3942 channel_id: ChannelId::from_bytes([2; 32]),
3943 serial_id: 4886718345,
3945 let encoded_value = tx_remove_output.encode();
3946 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3947 assert_eq!(encoded_value, target_value);
3951 fn encoding_tx_complete() {
3952 let tx_complete = msgs::TxComplete {
3953 channel_id: ChannelId::from_bytes([2; 32]),
3955 let encoded_value = tx_complete.encode();
3956 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3957 assert_eq!(encoded_value, target_value);
3961 fn encoding_tx_signatures() {
3962 let secp_ctx = Secp256k1::new();
3963 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3964 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3966 let tx_signatures = msgs::TxSignatures {
3967 channel_id: ChannelId::from_bytes([2; 32]),
3968 tx_hash: Txid::from_str("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3970 Witness::from_slice(&vec![
3971 <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3972 <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3973 Witness::from_slice(&vec![
3974 <Vec<u8>>::from_hex("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap(),
3975 <Vec<u8>>::from_hex("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap()]),
3977 funding_outpoint_sig: Some(sig_1),
3979 let encoded_value = tx_signatures.encode();
3980 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3981 target_value.append(&mut <Vec<u8>>::from_hex("6e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c2").unwrap()); // tx_hash (sha256) (big endian byte order)
3982 target_value.append(&mut <Vec<u8>>::from_hex("0002").unwrap()); // num_witnesses (u16)
3984 target_value.append(&mut <Vec<u8>>::from_hex("006b").unwrap()); // len of witness_data
3985 target_value.append(&mut <Vec<u8>>::from_hex("02").unwrap()); // num_witness_elements (VarInt)
3986 target_value.append(&mut <Vec<u8>>::from_hex("47").unwrap()); // len of witness element data (VarInt)
3987 target_value.append(&mut <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap());
3988 target_value.append(&mut <Vec<u8>>::from_hex("21").unwrap()); // len of witness element data (VarInt)
3989 target_value.append(&mut <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap());
3991 target_value.append(&mut <Vec<u8>>::from_hex("006c").unwrap()); // len of witness_data
3992 target_value.append(&mut <Vec<u8>>::from_hex("02").unwrap()); // num_witness_elements (VarInt)
3993 target_value.append(&mut <Vec<u8>>::from_hex("48").unwrap()); // len of witness element data (VarInt)
3994 target_value.append(&mut <Vec<u8>>::from_hex("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap());
3995 target_value.append(&mut <Vec<u8>>::from_hex("21").unwrap()); // len of witness element data (VarInt)
3996 target_value.append(&mut <Vec<u8>>::from_hex("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap());
3997 target_value.append(&mut <Vec<u8>>::from_hex("0040").unwrap()); // type and len (64)
3998 target_value.append(&mut <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap());
3999 assert_eq!(encoded_value, target_value);
4002 fn do_encoding_tx_init_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
4003 let tx_init_rbf = msgs::TxInitRbf {
4004 channel_id: ChannelId::from_bytes([2; 32]),
4005 locktime: 305419896,
4006 feerate_sat_per_1000_weight: 20190119,
4007 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
4009 let encoded_value = tx_init_rbf.encode();
4010 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
4011 target_value.append(&mut <Vec<u8>>::from_hex("12345678").unwrap()); // locktime
4012 target_value.append(&mut <Vec<u8>>::from_hex("013413a7").unwrap()); // feerate_sat_per_1000_weight
4013 if let Some((_, target)) = funding_value_with_hex_target {
4014 target_value.push(0x00); // Type
4015 target_value.push(target.len() as u8 / 2); // Length
4016 target_value.append(&mut <Vec<u8>>::from_hex(target).unwrap()); // Value (i64)
4018 assert_eq!(encoded_value, target_value);
4022 fn encoding_tx_init_rbf() {
4023 do_encoding_tx_init_rbf(Some((1311768467284833366, "1234567890123456")));
4024 do_encoding_tx_init_rbf(Some((13117684672, "000000030DDFFBC0")));
4025 do_encoding_tx_init_rbf(None);
4028 fn do_encoding_tx_ack_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
4029 let tx_ack_rbf = msgs::TxAckRbf {
4030 channel_id: ChannelId::from_bytes([2; 32]),
4031 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
4033 let encoded_value = tx_ack_rbf.encode();
4034 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
4035 if let Some((_, target)) = funding_value_with_hex_target {
4036 target_value.push(0x00); // Type
4037 target_value.push(target.len() as u8 / 2); // Length
4038 target_value.append(&mut <Vec<u8>>::from_hex(target).unwrap()); // Value (i64)
4040 assert_eq!(encoded_value, target_value);
4044 fn encoding_tx_ack_rbf() {
4045 do_encoding_tx_ack_rbf(Some((1311768467284833366, "1234567890123456")));
4046 do_encoding_tx_ack_rbf(Some((13117684672, "000000030DDFFBC0")));
4047 do_encoding_tx_ack_rbf(None);
4051 fn encoding_tx_abort() {
4052 let tx_abort = msgs::TxAbort {
4053 channel_id: ChannelId::from_bytes([2; 32]),
4054 data: <Vec<u8>>::from_hex("54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap(),
4056 let encoded_value = tx_abort.encode();
4057 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202002C54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap();
4058 assert_eq!(encoded_value, target_value);
4061 fn do_encoding_shutdown(script_type: u8) {
4062 let secp_ctx = Secp256k1::new();
4063 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4064 let script = Builder::new().push_opcode(opcodes::OP_TRUE).into_script();
4065 let shutdown = msgs::Shutdown {
4066 channel_id: ChannelId::from_bytes([2; 32]),
4068 if script_type == 1 { Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey() }
4069 else if script_type == 2 { Address::p2sh(&script, Network::Testnet).unwrap().script_pubkey() }
4070 else if script_type == 3 { Address::p2wpkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).unwrap().script_pubkey() }
4071 else { Address::p2wsh(&script, Network::Testnet).script_pubkey() },
4073 let encoded_value = shutdown.encode();
4074 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
4075 if script_type == 1 {
4076 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
4077 } else if script_type == 2 {
4078 target_value.append(&mut <Vec<u8>>::from_hex("0017a914da1745e9b549bd0bfa1a569971c77eba30cd5a4b87").unwrap());
4079 } else if script_type == 3 {
4080 target_value.append(&mut <Vec<u8>>::from_hex("0016001479b000887626b294a914501a4cd226b58b235983").unwrap());
4081 } else if script_type == 4 {
4082 target_value.append(&mut <Vec<u8>>::from_hex("002200204ae81572f06e1b88fd5ced7a1a000945432e83e1551e6f721ee9c00b8cc33260").unwrap());
4084 assert_eq!(encoded_value, target_value);
4088 fn encoding_shutdown() {
4089 do_encoding_shutdown(1);
4090 do_encoding_shutdown(2);
4091 do_encoding_shutdown(3);
4092 do_encoding_shutdown(4);
4096 fn encoding_closing_signed() {
4097 let secp_ctx = Secp256k1::new();
4098 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4099 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
4100 let closing_signed = msgs::ClosingSigned {
4101 channel_id: ChannelId::from_bytes([2; 32]),
4102 fee_satoshis: 2316138423780173,
4106 let encoded_value = closing_signed.encode();
4107 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
4108 assert_eq!(encoded_value, target_value);
4109 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value)).unwrap(), closing_signed);
4111 let closing_signed_with_range = msgs::ClosingSigned {
4112 channel_id: ChannelId::from_bytes([2; 32]),
4113 fee_satoshis: 2316138423780173,
4115 fee_range: Some(msgs::ClosingSignedFeeRange {
4116 min_fee_satoshis: 0xdeadbeef,
4117 max_fee_satoshis: 0x1badcafe01234567,
4120 let encoded_value_with_range = closing_signed_with_range.encode();
4121 let target_value_with_range = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a011000000000deadbeef1badcafe01234567").unwrap();
4122 assert_eq!(encoded_value_with_range, target_value_with_range);
4123 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value_with_range)).unwrap(),
4124 closing_signed_with_range);
4128 fn encoding_update_add_htlc() {
4129 let secp_ctx = Secp256k1::new();
4130 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4131 let onion_routing_packet = msgs::OnionPacket {
4133 public_key: Ok(pubkey_1),
4134 hop_data: [1; 20*65],
4137 let update_add_htlc = msgs::UpdateAddHTLC {
4138 channel_id: ChannelId::from_bytes([2; 32]),
4139 htlc_id: 2316138423780173,
4140 amount_msat: 3608586615801332854,
4141 payment_hash: PaymentHash([1; 32]),
4142 cltv_expiry: 821716,
4143 onion_routing_packet,
4144 skimmed_fee_msat: None,
4145 blinding_point: None,
4147 let encoded_value = update_add_htlc.encode();
4148 let target_value = <Vec<u8>>::from_hex("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").unwrap();
4149 assert_eq!(encoded_value, target_value);
4153 fn encoding_update_fulfill_htlc() {
4154 let update_fulfill_htlc = msgs::UpdateFulfillHTLC {
4155 channel_id: ChannelId::from_bytes([2; 32]),
4156 htlc_id: 2316138423780173,
4157 payment_preimage: PaymentPreimage([1; 32]),
4159 let encoded_value = update_fulfill_htlc.encode();
4160 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d0101010101010101010101010101010101010101010101010101010101010101").unwrap();
4161 assert_eq!(encoded_value, target_value);
4165 fn encoding_update_fail_htlc() {
4166 let reason = OnionErrorPacket {
4167 data: [1; 32].to_vec(),
4169 let update_fail_htlc = msgs::UpdateFailHTLC {
4170 channel_id: ChannelId::from_bytes([2; 32]),
4171 htlc_id: 2316138423780173,
4174 let encoded_value = update_fail_htlc.encode();
4175 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d00200101010101010101010101010101010101010101010101010101010101010101").unwrap();
4176 assert_eq!(encoded_value, target_value);
4180 fn encoding_update_fail_malformed_htlc() {
4181 let update_fail_malformed_htlc = msgs::UpdateFailMalformedHTLC {
4182 channel_id: ChannelId::from_bytes([2; 32]),
4183 htlc_id: 2316138423780173,
4184 sha256_of_onion: [1; 32],
4187 let encoded_value = update_fail_malformed_htlc.encode();
4188 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d010101010101010101010101010101010101010101010101010101010101010100ff").unwrap();
4189 assert_eq!(encoded_value, target_value);
4192 fn do_encoding_commitment_signed(htlcs: bool) {
4193 let secp_ctx = Secp256k1::new();
4194 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4195 let (privkey_2, _) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
4196 let (privkey_3, _) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
4197 let (privkey_4, _) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
4198 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
4199 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
4200 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
4201 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
4202 let commitment_signed = msgs::CommitmentSigned {
4203 channel_id: ChannelId::from_bytes([2; 32]),
4205 htlc_signatures: if htlcs { vec![sig_2, sig_3, sig_4] } else { Vec::new() },
4207 partial_signature_with_nonce: None,
4209 let encoded_value = commitment_signed.encode();
4210 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
4212 target_value.append(&mut <Vec<u8>>::from_hex("00031735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
4214 target_value.append(&mut <Vec<u8>>::from_hex("0000").unwrap());
4216 assert_eq!(encoded_value, target_value);
4220 fn encoding_commitment_signed() {
4221 do_encoding_commitment_signed(true);
4222 do_encoding_commitment_signed(false);
4226 fn encoding_revoke_and_ack() {
4227 let secp_ctx = Secp256k1::new();
4228 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4229 let raa = msgs::RevokeAndACK {
4230 channel_id: ChannelId::from_bytes([2; 32]),
4231 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],
4232 next_per_commitment_point: pubkey_1,
4234 next_local_nonce: None,
4236 let encoded_value = raa.encode();
4237 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020101010101010101010101010101010101010101010101010101010101010101031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
4238 assert_eq!(encoded_value, target_value);
4242 fn encoding_update_fee() {
4243 let update_fee = msgs::UpdateFee {
4244 channel_id: ChannelId::from_bytes([2; 32]),
4245 feerate_per_kw: 20190119,
4247 let encoded_value = update_fee.encode();
4248 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202013413a7").unwrap();
4249 assert_eq!(encoded_value, target_value);
4253 fn encoding_init() {
4254 let mainnet_hash = ChainHash::using_genesis_block(Network::Bitcoin);
4255 assert_eq!(msgs::Init {
4256 features: InitFeatures::from_le_bytes(vec![0xFF, 0xFF, 0xFF]),
4257 networks: Some(vec![mainnet_hash]),
4258 remote_network_address: None,
4259 }.encode(), <Vec<u8>>::from_hex("00023fff0003ffffff01206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
4260 assert_eq!(msgs::Init {
4261 features: InitFeatures::from_le_bytes(vec![0xFF]),
4263 remote_network_address: None,
4264 }.encode(), <Vec<u8>>::from_hex("0001ff0001ff").unwrap());
4265 assert_eq!(msgs::Init {
4266 features: InitFeatures::from_le_bytes(vec![]),
4267 networks: Some(vec![mainnet_hash]),
4268 remote_network_address: None,
4269 }.encode(), <Vec<u8>>::from_hex("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
4270 assert_eq!(msgs::Init {
4271 features: InitFeatures::from_le_bytes(vec![]),
4272 networks: Some(vec![ChainHash::from(&[1; 32]), ChainHash::from(&[2; 32])]),
4273 remote_network_address: None,
4274 }.encode(), <Vec<u8>>::from_hex("00000000014001010101010101010101010101010101010101010101010101010101010101010202020202020202020202020202020202020202020202020202020202020202").unwrap());
4275 let init_msg = msgs::Init { features: InitFeatures::from_le_bytes(vec![]),
4276 networks: Some(vec![mainnet_hash]),
4277 remote_network_address: Some(SocketAddress::TcpIpV4 {
4278 addr: [127, 0, 0, 1],
4282 let encoded_value = init_msg.encode();
4283 let target_value = <Vec<u8>>::from_hex("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d61900000000000307017f00000103e8").unwrap();
4284 assert_eq!(encoded_value, target_value);
4285 assert_eq!(msgs::Init::read(&mut Cursor::new(&target_value)).unwrap(), init_msg);
4289 fn encoding_error() {
4290 let error = msgs::ErrorMessage {
4291 channel_id: ChannelId::from_bytes([2; 32]),
4292 data: String::from("rust-lightning"),
4294 let encoded_value = error.encode();
4295 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
4296 assert_eq!(encoded_value, target_value);
4300 fn encoding_warning() {
4301 let error = msgs::WarningMessage {
4302 channel_id: ChannelId::from_bytes([2; 32]),
4303 data: String::from("rust-lightning"),
4305 let encoded_value = error.encode();
4306 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
4307 assert_eq!(encoded_value, target_value);
4311 fn encoding_ping() {
4312 let ping = msgs::Ping {
4316 let encoded_value = ping.encode();
4317 let target_value = <Vec<u8>>::from_hex("0040004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
4318 assert_eq!(encoded_value, target_value);
4322 fn encoding_pong() {
4323 let pong = msgs::Pong {
4326 let encoded_value = pong.encode();
4327 let target_value = <Vec<u8>>::from_hex("004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
4328 assert_eq!(encoded_value, target_value);
4332 fn encoding_nonfinal_onion_hop_data() {
4333 let outbound_msg = msgs::OutboundOnionPayload::Forward {
4334 short_channel_id: 0xdeadbeef1bad1dea,
4335 amt_to_forward: 0x0badf00d01020304,
4336 outgoing_cltv_value: 0xffffffff,
4338 let encoded_value = outbound_msg.encode();
4339 let target_value = <Vec<u8>>::from_hex("1a02080badf00d010203040404ffffffff0608deadbeef1bad1dea").unwrap();
4340 assert_eq!(encoded_value, target_value);
4342 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4343 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4344 if let msgs::InboundOnionPayload::Forward {
4345 short_channel_id, amt_to_forward, outgoing_cltv_value
4347 assert_eq!(short_channel_id, 0xdeadbeef1bad1dea);
4348 assert_eq!(amt_to_forward, 0x0badf00d01020304);
4349 assert_eq!(outgoing_cltv_value, 0xffffffff);
4350 } else { panic!(); }
4354 fn encoding_final_onion_hop_data() {
4355 let outbound_msg = msgs::OutboundOnionPayload::Receive {
4357 payment_metadata: None,
4358 keysend_preimage: None,
4359 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4360 cltv_expiry_height: 0xffffffff,
4361 custom_tlvs: vec![],
4363 let encoded_value = outbound_msg.encode();
4364 let target_value = <Vec<u8>>::from_hex("1002080badf00d010203040404ffffffff").unwrap();
4365 assert_eq!(encoded_value, target_value);
4367 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4368 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4369 if let msgs::InboundOnionPayload::Receive {
4370 payment_data: None, sender_intended_htlc_amt_msat, cltv_expiry_height, ..
4372 assert_eq!(sender_intended_htlc_amt_msat, 0x0badf00d01020304);
4373 assert_eq!(cltv_expiry_height, 0xffffffff);
4374 } else { panic!(); }
4378 fn encoding_final_onion_hop_data_with_secret() {
4379 let expected_payment_secret = PaymentSecret([0x42u8; 32]);
4380 let outbound_msg = msgs::OutboundOnionPayload::Receive {
4381 payment_data: Some(FinalOnionHopData {
4382 payment_secret: expected_payment_secret,
4383 total_msat: 0x1badca1f
4385 payment_metadata: None,
4386 keysend_preimage: None,
4387 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4388 cltv_expiry_height: 0xffffffff,
4389 custom_tlvs: vec![],
4391 let encoded_value = outbound_msg.encode();
4392 let target_value = <Vec<u8>>::from_hex("3602080badf00d010203040404ffffffff082442424242424242424242424242424242424242424242424242424242424242421badca1f").unwrap();
4393 assert_eq!(encoded_value, target_value);
4395 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4396 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4397 if let msgs::InboundOnionPayload::Receive {
4398 payment_data: Some(FinalOnionHopData {
4400 total_msat: 0x1badca1f
4402 sender_intended_htlc_amt_msat, cltv_expiry_height,
4403 payment_metadata: None,
4404 keysend_preimage: None,
4407 assert_eq!(payment_secret, expected_payment_secret);
4408 assert_eq!(sender_intended_htlc_amt_msat, 0x0badf00d01020304);
4409 assert_eq!(cltv_expiry_height, 0xffffffff);
4410 assert_eq!(custom_tlvs, vec![]);
4411 } else { panic!(); }
4415 fn encoding_final_onion_hop_data_with_bad_custom_tlvs() {
4416 // If custom TLVs have type number within the range reserved for protocol, treat them as if
4418 let bad_type_range_tlvs = vec![
4419 ((1 << 16) - 4, vec![42]),
4420 ((1 << 16) - 2, vec![42; 32]),
4422 let mut msg = msgs::OutboundOnionPayload::Receive {
4424 payment_metadata: None,
4425 keysend_preimage: None,
4426 custom_tlvs: bad_type_range_tlvs,
4427 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4428 cltv_expiry_height: 0xffffffff,
4430 let encoded_value = msg.encode();
4431 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4432 assert!(msgs::InboundOnionPayload::read(&mut Cursor::new(&encoded_value[..]), (None, &&node_signer)).is_err());
4433 let good_type_range_tlvs = vec![
4434 ((1 << 16) - 3, vec![42]),
4435 ((1 << 16) - 1, vec![42; 32]),
4437 if let msgs::OutboundOnionPayload::Receive { ref mut custom_tlvs, .. } = msg {
4438 *custom_tlvs = good_type_range_tlvs.clone();
4440 let encoded_value = msg.encode();
4441 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&encoded_value[..]), (None, &&node_signer)).unwrap();
4443 msgs::InboundOnionPayload::Receive { custom_tlvs, .. } => assert!(custom_tlvs.is_empty()),
4449 fn encoding_final_onion_hop_data_with_custom_tlvs() {
4450 let expected_custom_tlvs = vec![
4451 (5482373483, vec![0x12, 0x34]),
4452 (5482373487, vec![0x42u8; 8]),
4454 let msg = msgs::OutboundOnionPayload::Receive {
4456 payment_metadata: None,
4457 keysend_preimage: None,
4458 custom_tlvs: expected_custom_tlvs.clone(),
4459 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4460 cltv_expiry_height: 0xffffffff,
4462 let encoded_value = msg.encode();
4463 let target_value = <Vec<u8>>::from_hex("2e02080badf00d010203040404ffffffffff0000000146c6616b021234ff0000000146c6616f084242424242424242").unwrap();
4464 assert_eq!(encoded_value, target_value);
4465 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4466 let inbound_msg: msgs::InboundOnionPayload = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4467 if let msgs::InboundOnionPayload::Receive {
4469 payment_metadata: None,
4470 keysend_preimage: None,
4472 sender_intended_htlc_amt_msat,
4473 cltv_expiry_height: outgoing_cltv_value,
4476 assert_eq!(custom_tlvs, expected_custom_tlvs);
4477 assert_eq!(sender_intended_htlc_amt_msat, 0x0badf00d01020304);
4478 assert_eq!(outgoing_cltv_value, 0xffffffff);
4479 } else { panic!(); }
4483 fn encoding_final_onion_hop_data_with_trampoline_packet() {
4484 let secp_ctx = Secp256k1::new();
4485 let (_private_key, public_key) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4487 let compressed_public_key = public_key.serialize();
4488 assert_eq!(compressed_public_key.len(), 33);
4490 let trampoline_packet = TrampolineOnionPacket {
4493 hop_data: vec![1; 650], // this should be the standard encoded length
4496 let encoded_trampoline_packet = trampoline_packet.encode();
4497 assert_eq!(encoded_trampoline_packet.len(), 716);
4499 let msg = msgs::OutboundOnionPayload::TrampolineEntrypoint {
4500 multipath_trampoline_data: None,
4501 amt_to_forward: 0x0badf00d01020304,
4502 outgoing_cltv_value: 0xffffffff,
4505 let encoded_payload = msg.encode();
4507 let trampoline_type_bytes = &encoded_payload[19..=19];
4508 let mut trampoline_type_cursor = Cursor::new(trampoline_type_bytes);
4509 let trampoline_type_big_size: BigSize = Readable::read(&mut trampoline_type_cursor).unwrap();
4510 assert_eq!(trampoline_type_big_size.0, 20);
4512 let trampoline_length_bytes = &encoded_payload[20..=22];
4513 let mut trampoline_length_cursor = Cursor::new(trampoline_length_bytes);
4514 let trampoline_length_big_size: BigSize = Readable::read(&mut trampoline_length_cursor).unwrap();
4515 assert_eq!(trampoline_length_big_size.0, encoded_trampoline_packet.len() as u64);
4519 fn encoding_final_onion_hop_data_with_eclair_trampoline_packet() {
4520 let public_key = PublicKey::from_slice(&<Vec<u8>>::from_hex("02eec7245d6b7d2ccb30380bfbe2a3648cd7a942653f5aa340edcea1f283686619").unwrap()).unwrap();
4521 let hop_data = <Vec<u8>>::from_hex("cff34152f3a36e52ca94e74927203a560392b9cc7ce3c45809c6be52166c24a595716880f95f178bf5b30ca63141f74db6e92795c6130877cfdac3d4bd3087ee73c65d627ddd709112a848cc99e303f3706509aa43ba7c8a88cba175fccf9a8f5016ef06d3b935dbb15196d7ce16dc1a7157845566901d7b2197e52cab4ce487014b14816e5805f9fcacb4f8f88b8ff176f1b94f6ce6b00bc43221130c17d20ef629db7c5f7eafaa166578c720619561dd14b3277db557ec7dcdb793771aef0f2f667cfdbeae3ac8d331c5994779dffb31e5fc0dbdedc0c592ca6d21c18e47fe3528d6975c19517d7e2ea8c5391cf17d0fe30c80913ed887234ccb48808f7ef9425bcd815c3b586210979e3bb286ef2851bf9ce04e28c40a203df98fd648d2f1936fd2f1def0e77eecb277229b4b682322371c0a1dbfcd723a991993df8cc1f2696b84b055b40a1792a29f710295a18fbd351b0f3ff34cd13941131b8278ba79303c89117120eea691738a9954908195143b039dbeed98f26a92585f3d15cf742c953799d3272e0545e9b744be9d3b4c").unwrap();
4522 let hmac_vector = <Vec<u8>>::from_hex("bb079bfc4b35190eee9f59a1d7b41ba2f773179f322dafb4b1af900c289ebd6c").unwrap();
4523 let mut hmac = [0; 32];
4524 hmac.copy_from_slice(&hmac_vector);
4526 let compressed_public_key = public_key.serialize();
4527 assert_eq!(compressed_public_key.len(), 33);
4529 let trampoline_packet = TrampolineOnionPacket {
4535 let encoded_trampoline_packet = trampoline_packet.encode();
4536 let expected_eclair_trampoline_packet = <Vec<u8>>::from_hex("0002eec7245d6b7d2ccb30380bfbe2a3648cd7a942653f5aa340edcea1f283686619cff34152f3a36e52ca94e74927203a560392b9cc7ce3c45809c6be52166c24a595716880f95f178bf5b30ca63141f74db6e92795c6130877cfdac3d4bd3087ee73c65d627ddd709112a848cc99e303f3706509aa43ba7c8a88cba175fccf9a8f5016ef06d3b935dbb15196d7ce16dc1a7157845566901d7b2197e52cab4ce487014b14816e5805f9fcacb4f8f88b8ff176f1b94f6ce6b00bc43221130c17d20ef629db7c5f7eafaa166578c720619561dd14b3277db557ec7dcdb793771aef0f2f667cfdbeae3ac8d331c5994779dffb31e5fc0dbdedc0c592ca6d21c18e47fe3528d6975c19517d7e2ea8c5391cf17d0fe30c80913ed887234ccb48808f7ef9425bcd815c3b586210979e3bb286ef2851bf9ce04e28c40a203df98fd648d2f1936fd2f1def0e77eecb277229b4b682322371c0a1dbfcd723a991993df8cc1f2696b84b055b40a1792a29f710295a18fbd351b0f3ff34cd13941131b8278ba79303c89117120eea691738a9954908195143b039dbeed98f26a92585f3d15cf742c953799d3272e0545e9b744be9d3b4cbb079bfc4b35190eee9f59a1d7b41ba2f773179f322dafb4b1af900c289ebd6c").unwrap();
4537 assert_eq!(encoded_trampoline_packet, expected_eclair_trampoline_packet);
4541 fn query_channel_range_end_blocknum() {
4542 let tests: Vec<(u32, u32, u32)> = vec![
4543 (10000, 1500, 11500),
4544 (0, 0xffffffff, 0xffffffff),
4545 (1, 0xffffffff, 0xffffffff),
4548 for (first_blocknum, number_of_blocks, expected) in tests.into_iter() {
4549 let sut = msgs::QueryChannelRange {
4550 chain_hash: ChainHash::using_genesis_block(Network::Regtest),
4554 assert_eq!(sut.end_blocknum(), expected);
4559 fn encoding_query_channel_range() {
4560 let mut query_channel_range = msgs::QueryChannelRange {
4561 chain_hash: ChainHash::using_genesis_block(Network::Regtest),
4562 first_blocknum: 100000,
4563 number_of_blocks: 1500,
4565 let encoded_value = query_channel_range.encode();
4566 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000186a0000005dc").unwrap();
4567 assert_eq!(encoded_value, target_value);
4569 query_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4570 assert_eq!(query_channel_range.first_blocknum, 100000);
4571 assert_eq!(query_channel_range.number_of_blocks, 1500);
4575 fn encoding_reply_channel_range() {
4576 do_encoding_reply_channel_range(0);
4577 do_encoding_reply_channel_range(1);
4580 fn do_encoding_reply_channel_range(encoding_type: u8) {
4581 let mut target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000b8a06000005dc01").unwrap();
4582 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4583 let mut reply_channel_range = msgs::ReplyChannelRange {
4584 chain_hash: expected_chain_hash,
4585 first_blocknum: 756230,
4586 number_of_blocks: 1500,
4587 sync_complete: true,
4588 short_channel_ids: vec![0x000000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
4591 if encoding_type == 0 {
4592 target_value.append(&mut <Vec<u8>>::from_hex("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
4593 let encoded_value = reply_channel_range.encode();
4594 assert_eq!(encoded_value, target_value);
4596 reply_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4597 assert_eq!(reply_channel_range.chain_hash, expected_chain_hash);
4598 assert_eq!(reply_channel_range.first_blocknum, 756230);
4599 assert_eq!(reply_channel_range.number_of_blocks, 1500);
4600 assert_eq!(reply_channel_range.sync_complete, true);
4601 assert_eq!(reply_channel_range.short_channel_ids[0], 0x000000000000008e);
4602 assert_eq!(reply_channel_range.short_channel_ids[1], 0x0000000000003c69);
4603 assert_eq!(reply_channel_range.short_channel_ids[2], 0x000000000045a6c4);
4605 target_value.append(&mut <Vec<u8>>::from_hex("001601789c636000833e08659309a65878be010010a9023a").unwrap());
4606 let result: Result<msgs::ReplyChannelRange, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
4607 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
4612 fn encoding_query_short_channel_ids() {
4613 do_encoding_query_short_channel_ids(0);
4614 do_encoding_query_short_channel_ids(1);
4617 fn do_encoding_query_short_channel_ids(encoding_type: u8) {
4618 let mut target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
4619 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4620 let mut query_short_channel_ids = msgs::QueryShortChannelIds {
4621 chain_hash: expected_chain_hash,
4622 short_channel_ids: vec![0x0000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
4625 if encoding_type == 0 {
4626 target_value.append(&mut <Vec<u8>>::from_hex("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
4627 let encoded_value = query_short_channel_ids.encode();
4628 assert_eq!(encoded_value, target_value);
4630 query_short_channel_ids = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4631 assert_eq!(query_short_channel_ids.chain_hash, expected_chain_hash);
4632 assert_eq!(query_short_channel_ids.short_channel_ids[0], 0x000000000000008e);
4633 assert_eq!(query_short_channel_ids.short_channel_ids[1], 0x0000000000003c69);
4634 assert_eq!(query_short_channel_ids.short_channel_ids[2], 0x000000000045a6c4);
4636 target_value.append(&mut <Vec<u8>>::from_hex("001601789c636000833e08659309a65878be010010a9023a").unwrap());
4637 let result: Result<msgs::QueryShortChannelIds, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
4638 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
4643 fn encoding_reply_short_channel_ids_end() {
4644 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4645 let mut reply_short_channel_ids_end = msgs::ReplyShortChannelIdsEnd {
4646 chain_hash: expected_chain_hash,
4647 full_information: true,
4649 let encoded_value = reply_short_channel_ids_end.encode();
4650 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f01").unwrap();
4651 assert_eq!(encoded_value, target_value);
4653 reply_short_channel_ids_end = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4654 assert_eq!(reply_short_channel_ids_end.chain_hash, expected_chain_hash);
4655 assert_eq!(reply_short_channel_ids_end.full_information, true);
4659 fn encoding_gossip_timestamp_filter(){
4660 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4661 let mut gossip_timestamp_filter = msgs::GossipTimestampFilter {
4662 chain_hash: expected_chain_hash,
4663 first_timestamp: 1590000000,
4664 timestamp_range: 0xffff_ffff,
4666 let encoded_value = gossip_timestamp_filter.encode();
4667 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f5ec57980ffffffff").unwrap();
4668 assert_eq!(encoded_value, target_value);
4670 gossip_timestamp_filter = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4671 assert_eq!(gossip_timestamp_filter.chain_hash, expected_chain_hash);
4672 assert_eq!(gossip_timestamp_filter.first_timestamp, 1590000000);
4673 assert_eq!(gossip_timestamp_filter.timestamp_range, 0xffff_ffff);
4677 fn decode_onion_hop_data_len_as_bigsize() {
4678 // Tests that we can decode an onion payload that is >253 bytes.
4679 // Previously, receiving a payload of this size could've caused us to fail to decode a valid
4680 // payload, because we were decoding the length (a BigSize, big-endian) as a VarInt
4683 // Encode a test onion payload with a big custom TLV such that it's >253 bytes, forcing the
4684 // payload length to be encoded over multiple bytes rather than a single u8.
4685 let big_payload = encode_big_payload().unwrap();
4686 let mut rd = Cursor::new(&big_payload[..]);
4688 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4689 <msgs::InboundOnionPayload as ReadableArgs<(Option<PublicKey>, &&test_utils::TestKeysInterface)>>
4690 ::read(&mut rd, (None, &&node_signer)).unwrap();
4692 // see above test, needs to be a separate method for use of the serialization macros.
4693 fn encode_big_payload() -> Result<Vec<u8>, io::Error> {
4694 use crate::util::ser::HighZeroBytesDroppedBigSize;
4695 let payload = msgs::OutboundOnionPayload::Forward {
4696 short_channel_id: 0xdeadbeef1bad1dea,
4697 amt_to_forward: 1000,
4698 outgoing_cltv_value: 0xffffffff,
4700 let mut encoded_payload = Vec::new();
4701 let test_bytes = vec![42u8; 1000];
4702 if let msgs::OutboundOnionPayload::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } = payload {
4703 _encode_varint_length_prefixed_tlv!(&mut encoded_payload, {
4704 (1, test_bytes, required_vec),
4705 (2, HighZeroBytesDroppedBigSize(amt_to_forward), required),
4706 (4, HighZeroBytesDroppedBigSize(outgoing_cltv_value), required),
4707 (6, short_channel_id, required)
4714 #[cfg(feature = "std")]
4715 fn test_socket_address_from_str() {
4716 let tcpip_v4 = SocketAddress::TcpIpV4 {
4717 addr: Ipv4Addr::new(127, 0, 0, 1).octets(),
4720 assert_eq!(tcpip_v4, SocketAddress::from_str("127.0.0.1:1234").unwrap());
4721 assert_eq!(tcpip_v4, SocketAddress::from_str(&tcpip_v4.to_string()).unwrap());
4723 let tcpip_v6 = SocketAddress::TcpIpV6 {
4724 addr: Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1).octets(),
4727 assert_eq!(tcpip_v6, SocketAddress::from_str("[0:0:0:0:0:0:0:1]:1234").unwrap());
4728 assert_eq!(tcpip_v6, SocketAddress::from_str(&tcpip_v6.to_string()).unwrap());
4730 let hostname = SocketAddress::Hostname {
4731 hostname: Hostname::try_from("lightning-node.mydomain.com".to_string()).unwrap(),
4734 assert_eq!(hostname, SocketAddress::from_str("lightning-node.mydomain.com:1234").unwrap());
4735 assert_eq!(hostname, SocketAddress::from_str(&hostname.to_string()).unwrap());
4737 let onion_v2 = SocketAddress::OnionV2 ([40, 4, 64, 185, 202, 19, 162, 75, 90, 200, 38, 7],);
4738 assert_eq!("OnionV2([40, 4, 64, 185, 202, 19, 162, 75, 90, 200, 38, 7])", &onion_v2.to_string());
4739 assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("FACEBOOKCOREWWWI.onion:9735"));
4741 let onion_v3 = SocketAddress::OnionV3 {
4742 ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102, 182, 107, 4, 105, 247, 246, 85,
4743 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31, 33, 71, 3],
4748 assert_eq!(onion_v3, SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion:1234").unwrap());
4749 assert_eq!(onion_v3, SocketAddress::from_str(&onion_v3.to_string()).unwrap());
4751 assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6.onion:1234"));
4752 assert_eq!(Err(SocketAddressParseError::InvalidInput), SocketAddress::from_str("127.0.0.1@1234"));
4753 assert_eq!(Err(SocketAddressParseError::InvalidInput), "".parse::<SocketAddress>());
4754 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:9735:94").is_err());
4755 assert!(SocketAddress::from_str("wrong$%#.com:1234").is_err());
4756 assert_eq!(Err(SocketAddressParseError::InvalidPort), SocketAddress::from_str("example.com:wrong"));
4757 assert!("localhost".parse::<SocketAddress>().is_err());
4758 assert!("localhost:invalid-port".parse::<SocketAddress>().is_err());
4759 assert!( "invalid-onion-v3-hostname.onion:8080".parse::<SocketAddress>().is_err());
4760 assert!("b32.example.onion:invalid-port".parse::<SocketAddress>().is_err());
4761 assert!("invalid-address".parse::<SocketAddress>().is_err());
4762 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:1234").is_err());
4766 #[cfg(feature = "std")]
4767 fn test_socket_address_to_socket_addrs() {
4768 assert_eq!(SocketAddress::TcpIpV4 {addr:[0u8; 4], port: 1337,}.to_socket_addrs().unwrap().next().unwrap(),
4769 SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(0,0,0,0), 1337)));
4770 assert_eq!(SocketAddress::TcpIpV6 {addr:[0u8; 16], port: 1337,}.to_socket_addrs().unwrap().next().unwrap(),
4771 SocketAddr::V6(SocketAddrV6::new(Ipv6Addr::from([0u8; 16]), 1337, 0, 0)));
4772 assert_eq!(SocketAddress::Hostname { hostname: Hostname::try_from("0.0.0.0".to_string()).unwrap(), port: 0 }
4773 .to_socket_addrs().unwrap().next().unwrap(), SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::from([0u8; 4]),0)));
4774 assert!(SocketAddress::OnionV2([0u8; 12]).to_socket_addrs().is_err());
4775 assert!(SocketAddress::OnionV3{ ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102,
4776 182, 107, 4, 105, 247, 246, 85, 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31,
4780 port: 1234 }.to_socket_addrs().is_err());