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::ReceiveTlvs;
35 use crate::ln::{ChannelId, PaymentPreimage, PaymentHash, PaymentSecret};
36 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
37 use crate::ln::onion_utils;
38 use crate::onion_message;
39 use crate::sign::{NodeSigner, Recipient};
41 use crate::prelude::*;
42 #[cfg(feature = "std")]
43 use core::convert::TryFrom;
47 #[cfg(feature = "std")]
48 use core::str::FromStr;
49 #[cfg(feature = "std")]
50 use std::net::SocketAddr;
51 use core::fmt::Display;
52 use crate::io::{self, Cursor, Read};
53 use crate::io_extras::read_to_end;
55 use crate::events::MessageSendEventsProvider;
56 use crate::util::chacha20poly1305rfc::ChaChaPolyReadAdapter;
57 use crate::util::logger;
58 use crate::util::ser::{LengthReadable, LengthReadableArgs, Readable, ReadableArgs, Writeable, Writer, WithoutLength, FixedLengthReader, HighZeroBytesDroppedBigSize, Hostname, TransactionU16LenLimited, BigSize};
59 use crate::util::base32;
61 use crate::routing::gossip::{NodeAlias, NodeId};
63 /// 21 million * 10^8 * 1000
64 pub(crate) const MAX_VALUE_MSAT: u64 = 21_000_000_0000_0000_000;
67 /// A partial signature that also contains the Musig2 nonce its signer used
68 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
69 pub struct PartialSignatureWithNonce(pub musig2::types::PartialSignature, pub musig2::types::PublicNonce);
71 /// An error in decoding a message or struct.
72 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
73 pub enum DecodeError {
74 /// A version byte specified something we don't know how to handle.
76 /// Includes unknown realm byte in an onion hop data packet.
78 /// Unknown feature mandating we fail to parse message (e.g., TLV with an even, unknown type)
79 UnknownRequiredFeature,
80 /// Value was invalid.
82 /// For example, a byte which was supposed to be a bool was something other than a 0
83 /// or 1, a public key/private key/signature was invalid, text wasn't UTF-8, TLV was
84 /// syntactically incorrect, etc.
86 /// The buffer to be read was too short.
88 /// A length descriptor in the packet didn't describe the later data correctly.
90 /// Error from [`std::io`].
92 /// The message included zlib-compressed values, which we don't support.
93 UnsupportedCompression,
96 /// An [`init`] message to be sent to or received from a peer.
98 /// [`init`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-init-message
99 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
101 /// The relevant features which the sender supports.
102 pub features: InitFeatures,
103 /// Indicates chains the sender is interested in.
105 /// If there are no common chains, the connection will be closed.
106 pub networks: Option<Vec<ChainHash>>,
107 /// The receipient's network address.
109 /// This adds the option to report a remote IP address back to a connecting peer using the init
110 /// message. A node can decide to use that information to discover a potential update to its
111 /// public IPv4 address (NAT) and use that for a [`NodeAnnouncement`] update message containing
113 pub remote_network_address: Option<SocketAddress>,
116 /// An [`error`] message to be sent to or received from a peer.
118 /// [`error`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-error-and-warning-messages
119 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
120 pub struct ErrorMessage {
121 /// The channel ID involved in the error.
123 /// All-0s indicates a general error unrelated to a specific channel, after which all channels
124 /// with the sending peer should be closed.
125 pub channel_id: ChannelId,
126 /// A possibly human-readable error description.
128 /// The string should be sanitized before it is used (e.g., emitted to logs or printed to
129 /// `stdout`). Otherwise, a well crafted error message may trigger a security vulnerability in
130 /// the terminal emulator or the logging subsystem.
134 /// A [`warning`] message to be sent to or received from a peer.
136 /// [`warning`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-error-and-warning-messages
137 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
138 pub struct WarningMessage {
139 /// The channel ID involved in the warning.
141 /// All-0s indicates a warning unrelated to a specific channel.
142 pub channel_id: ChannelId,
143 /// A possibly human-readable warning description.
145 /// The string should be sanitized before it is used (e.g. emitted to logs or printed to
146 /// stdout). Otherwise, a well crafted error message may trigger a security vulnerability in
147 /// the terminal emulator or the logging subsystem.
151 /// A [`ping`] message to be sent to or received from a peer.
153 /// [`ping`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-ping-and-pong-messages
154 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
156 /// The desired response length.
158 /// The ping packet size.
160 /// This field is not sent on the wire. byteslen zeros are sent.
164 /// A [`pong`] message to be sent to or received from a peer.
166 /// [`pong`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-ping-and-pong-messages
167 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
169 /// The pong packet size.
171 /// This field is not sent on the wire. byteslen zeros are sent.
175 /// An [`open_channel`] message to be sent to or received from a peer.
177 /// Used in V1 channel establishment
179 /// [`open_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-open_channel-message
180 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
181 pub struct OpenChannel {
182 /// The genesis hash of the blockchain where the channel is to be opened
183 pub chain_hash: ChainHash,
184 /// A temporary channel ID, until the funding outpoint is announced
185 pub temporary_channel_id: ChannelId,
186 /// The channel value
187 pub funding_satoshis: u64,
188 /// The amount to push to the counterparty as part of the open, in milli-satoshi
190 /// The threshold below which outputs on transactions broadcast by sender will be omitted
191 pub dust_limit_satoshis: u64,
192 /// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
193 pub max_htlc_value_in_flight_msat: u64,
194 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
195 pub channel_reserve_satoshis: u64,
196 /// The minimum HTLC size incoming to sender, in milli-satoshi
197 pub htlc_minimum_msat: u64,
198 /// The feerate per 1000-weight of sender generated transactions, until updated by
200 pub feerate_per_kw: u32,
201 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if
202 /// they broadcast a commitment transaction
203 pub to_self_delay: u16,
204 /// The maximum number of inbound HTLCs towards sender
205 pub max_accepted_htlcs: u16,
206 /// The sender's key controlling the funding transaction
207 pub funding_pubkey: PublicKey,
208 /// Used to derive a revocation key for transactions broadcast by counterparty
209 pub revocation_basepoint: PublicKey,
210 /// A payment key to sender for transactions broadcast by counterparty
211 pub payment_point: PublicKey,
212 /// Used to derive a payment key to sender for transactions broadcast by sender
213 pub delayed_payment_basepoint: PublicKey,
214 /// Used to derive an HTLC payment key to sender
215 pub htlc_basepoint: PublicKey,
216 /// The first to-be-broadcast-by-sender transaction's per commitment point
217 pub first_per_commitment_point: PublicKey,
218 /// The channel flags to be used
219 pub channel_flags: u8,
220 /// A request to pre-set the to-sender output's `scriptPubkey` for when we collaboratively close
221 pub shutdown_scriptpubkey: Option<ScriptBuf>,
222 /// The channel type that this channel will represent
224 /// If this is `None`, we derive the channel type from the intersection of our
225 /// feature bits with our counterparty's feature bits from the [`Init`] message.
226 pub channel_type: Option<ChannelTypeFeatures>,
229 /// An open_channel2 message to be sent by or received from the channel initiator.
231 /// Used in V2 channel establishment
233 // TODO(dual_funding): Add spec link for `open_channel2`.
234 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
235 pub struct OpenChannelV2 {
236 /// The genesis hash of the blockchain where the channel is to be opened
237 pub chain_hash: ChainHash,
238 /// A temporary channel ID derived using a zeroed out value for the channel acceptor's revocation basepoint
239 pub temporary_channel_id: ChannelId,
240 /// The feerate for the funding transaction set by the channel initiator
241 pub funding_feerate_sat_per_1000_weight: u32,
242 /// The feerate for the commitment transaction set by the channel initiator
243 pub commitment_feerate_sat_per_1000_weight: u32,
244 /// Part of the channel value contributed by the channel initiator
245 pub funding_satoshis: u64,
246 /// The threshold below which outputs on transactions broadcast by the channel initiator will be
248 pub dust_limit_satoshis: u64,
249 /// The maximum inbound HTLC value in flight towards channel initiator, in milli-satoshi
250 pub max_htlc_value_in_flight_msat: u64,
251 /// The minimum HTLC size incoming to channel initiator, in milli-satoshi
252 pub htlc_minimum_msat: u64,
253 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
254 /// broadcast a commitment transaction
255 pub to_self_delay: u16,
256 /// The maximum number of inbound HTLCs towards channel initiator
257 pub max_accepted_htlcs: u16,
258 /// The locktime for the funding transaction
260 /// The channel initiator's key controlling the funding transaction
261 pub funding_pubkey: PublicKey,
262 /// Used to derive a revocation key for transactions broadcast by counterparty
263 pub revocation_basepoint: PublicKey,
264 /// A payment key to channel initiator for transactions broadcast by counterparty
265 pub payment_basepoint: PublicKey,
266 /// Used to derive a payment key to channel initiator for transactions broadcast by channel
268 pub delayed_payment_basepoint: PublicKey,
269 /// Used to derive an HTLC payment key to channel initiator
270 pub htlc_basepoint: PublicKey,
271 /// The first to-be-broadcast-by-channel-initiator transaction's per commitment point
272 pub first_per_commitment_point: PublicKey,
273 /// The second to-be-broadcast-by-channel-initiator transaction's per commitment point
274 pub second_per_commitment_point: PublicKey,
276 pub channel_flags: u8,
277 /// Optionally, a request to pre-set the to-channel-initiator output's scriptPubkey for when we
278 /// collaboratively close
279 pub shutdown_scriptpubkey: Option<ScriptBuf>,
280 /// The channel type that this channel will represent. If none is set, we derive the channel
281 /// type from the intersection of our feature bits with our counterparty's feature bits from
282 /// the Init message.
283 pub channel_type: Option<ChannelTypeFeatures>,
284 /// Optionally, a requirement that only confirmed inputs can be added
285 pub require_confirmed_inputs: Option<()>,
288 /// An [`accept_channel`] message to be sent to or received from a peer.
290 /// Used in V1 channel establishment
292 /// [`accept_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-accept_channel-message
293 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
294 pub struct AcceptChannel {
295 /// A temporary channel ID, until the funding outpoint is announced
296 pub temporary_channel_id: ChannelId,
297 /// The threshold below which outputs on transactions broadcast by sender will be omitted
298 pub dust_limit_satoshis: u64,
299 /// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
300 pub max_htlc_value_in_flight_msat: u64,
301 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
302 pub channel_reserve_satoshis: u64,
303 /// The minimum HTLC size incoming to sender, in milli-satoshi
304 pub htlc_minimum_msat: u64,
305 /// Minimum depth of the funding transaction before the channel is considered open
306 pub minimum_depth: u32,
307 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they broadcast a commitment transaction
308 pub to_self_delay: u16,
309 /// The maximum number of inbound HTLCs towards sender
310 pub max_accepted_htlcs: u16,
311 /// The sender's key controlling the funding transaction
312 pub funding_pubkey: PublicKey,
313 /// Used to derive a revocation key for transactions broadcast by counterparty
314 pub revocation_basepoint: PublicKey,
315 /// A payment key to sender for transactions broadcast by counterparty
316 pub payment_point: PublicKey,
317 /// Used to derive a payment key to sender for transactions broadcast by sender
318 pub delayed_payment_basepoint: PublicKey,
319 /// Used to derive an HTLC payment key to sender for transactions broadcast by counterparty
320 pub htlc_basepoint: PublicKey,
321 /// The first to-be-broadcast-by-sender transaction's per commitment point
322 pub first_per_commitment_point: PublicKey,
323 /// A request to pre-set the to-sender output's scriptPubkey for when we collaboratively close
324 pub shutdown_scriptpubkey: Option<ScriptBuf>,
325 /// The channel type that this channel will represent.
327 /// If this is `None`, we derive the channel type from the intersection of
328 /// our feature bits with our counterparty's feature bits from the [`Init`] message.
329 /// This is required to match the equivalent field in [`OpenChannel::channel_type`].
330 pub channel_type: Option<ChannelTypeFeatures>,
332 /// Next nonce the channel initiator should use to create a funding output signature against
333 pub next_local_nonce: Option<musig2::types::PublicNonce>,
336 /// An accept_channel2 message to be sent by or received from the channel accepter.
338 /// Used in V2 channel establishment
340 // TODO(dual_funding): Add spec link for `accept_channel2`.
341 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
342 pub struct AcceptChannelV2 {
343 /// The same `temporary_channel_id` received from the initiator's `open_channel2` message.
344 pub temporary_channel_id: ChannelId,
345 /// Part of the channel value contributed by the channel acceptor
346 pub funding_satoshis: u64,
347 /// The threshold below which outputs on transactions broadcast by the channel acceptor will be
349 pub dust_limit_satoshis: u64,
350 /// The maximum inbound HTLC value in flight towards channel acceptor, in milli-satoshi
351 pub max_htlc_value_in_flight_msat: u64,
352 /// The minimum HTLC size incoming to channel acceptor, in milli-satoshi
353 pub htlc_minimum_msat: u64,
354 /// Minimum depth of the funding transaction before the channel is considered open
355 pub minimum_depth: u32,
356 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
357 /// broadcast a commitment transaction
358 pub to_self_delay: u16,
359 /// The maximum number of inbound HTLCs towards channel acceptor
360 pub max_accepted_htlcs: u16,
361 /// The channel acceptor's key controlling the funding transaction
362 pub funding_pubkey: PublicKey,
363 /// Used to derive a revocation key for transactions broadcast by counterparty
364 pub revocation_basepoint: PublicKey,
365 /// A payment key to channel acceptor for transactions broadcast by counterparty
366 pub payment_basepoint: PublicKey,
367 /// Used to derive a payment key to channel acceptor for transactions broadcast by channel
369 pub delayed_payment_basepoint: PublicKey,
370 /// Used to derive an HTLC payment key to channel acceptor for transactions broadcast by counterparty
371 pub htlc_basepoint: PublicKey,
372 /// The first to-be-broadcast-by-channel-acceptor transaction's per commitment point
373 pub first_per_commitment_point: PublicKey,
374 /// The second to-be-broadcast-by-channel-acceptor transaction's per commitment point
375 pub second_per_commitment_point: PublicKey,
376 /// Optionally, a request to pre-set the to-channel-acceptor output's scriptPubkey for when we
377 /// collaboratively close
378 pub shutdown_scriptpubkey: Option<ScriptBuf>,
379 /// The channel type that this channel will represent. If none is set, we derive the channel
380 /// type from the intersection of our feature bits with our counterparty's feature bits from
381 /// the Init message.
383 /// This is required to match the equivalent field in [`OpenChannelV2::channel_type`].
384 pub channel_type: Option<ChannelTypeFeatures>,
385 /// Optionally, a requirement that only confirmed inputs can be added
386 pub require_confirmed_inputs: Option<()>,
389 /// A [`funding_created`] message to be sent to or received from a peer.
391 /// Used in V1 channel establishment
393 /// [`funding_created`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-funding_created-message
394 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
395 pub struct FundingCreated {
396 /// A temporary channel ID, until the funding is established
397 pub temporary_channel_id: ChannelId,
398 /// The funding transaction ID
399 pub funding_txid: Txid,
400 /// The specific output index funding this channel
401 pub funding_output_index: u16,
402 /// The signature of the channel initiator (funder) on the initial commitment transaction
403 pub signature: Signature,
405 /// The partial signature of the channel initiator (funder)
406 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
408 /// Next nonce the channel acceptor should use to finalize the funding output signature
409 pub next_local_nonce: Option<musig2::types::PublicNonce>
412 /// A [`funding_signed`] message to be sent to or received from a peer.
414 /// Used in V1 channel establishment
416 /// [`funding_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-funding_signed-message
417 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
418 pub struct FundingSigned {
420 pub channel_id: ChannelId,
421 /// The signature of the channel acceptor (fundee) on the initial commitment transaction
422 pub signature: Signature,
424 /// The partial signature of the channel acceptor (fundee)
425 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
428 /// A [`channel_ready`] message to be sent to or received from a peer.
430 /// [`channel_ready`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-channel_ready-message
431 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
432 pub struct ChannelReady {
434 pub channel_id: ChannelId,
435 /// The per-commitment point of the second commitment transaction
436 pub next_per_commitment_point: PublicKey,
437 /// If set, provides a `short_channel_id` alias for this channel.
439 /// The sender will accept payments to be forwarded over this SCID and forward them to this
440 /// messages' recipient.
441 pub short_channel_id_alias: Option<u64>,
444 /// An stfu (quiescence) message to be sent by or received from the stfu initiator.
445 // TODO(splicing): Add spec link for `stfu`; still in draft, using from https://github.com/lightning/bolts/pull/863
446 #[derive(Clone, Debug, PartialEq, Eq)]
448 /// The channel ID where quiescence is intended
449 pub channel_id: ChannelId,
450 /// Initiator flag, 1 if initiating, 0 if replying to an stfu.
454 /// A splice message to be sent by or received from the stfu initiator (splice initiator).
455 // TODO(splicing): Add spec link for `splice`; still in draft, using from https://github.com/lightning/bolts/pull/863
456 #[derive(Clone, Debug, PartialEq, Eq)]
458 /// The channel ID where splicing is intended
459 pub channel_id: ChannelId,
460 /// The genesis hash of the blockchain where the channel is intended to be spliced
461 pub chain_hash: ChainHash,
462 /// The intended change in channel capacity: the amount to be added (positive value)
463 /// or removed (negative value) by the sender (splice initiator) by splicing into/from the channel.
464 pub relative_satoshis: i64,
465 /// The feerate for the new funding transaction, set by the splice initiator
466 pub funding_feerate_perkw: u32,
467 /// The locktime for the new funding transaction
469 /// The key of the sender (splice initiator) controlling the new funding transaction
470 pub funding_pubkey: PublicKey,
473 /// A splice_ack message to be received by or sent to the splice initiator.
475 // TODO(splicing): Add spec link for `splice_ack`; still in draft, using from https://github.com/lightning/bolts/pull/863
476 #[derive(Clone, Debug, PartialEq, Eq)]
477 pub struct SpliceAck {
478 /// The channel ID where splicing is intended
479 pub channel_id: ChannelId,
480 /// The genesis hash of the blockchain where the channel is intended to be spliced
481 pub chain_hash: ChainHash,
482 /// The intended change in channel capacity: the amount to be added (positive value)
483 /// or removed (negative value) by the sender (splice acceptor) by splicing into/from the channel.
484 pub relative_satoshis: i64,
485 /// The key of the sender (splice acceptor) controlling the new funding transaction
486 pub funding_pubkey: PublicKey,
489 /// A splice_locked message to be sent to or received from a peer.
491 // TODO(splicing): Add spec link for `splice_locked`; still in draft, using from https://github.com/lightning/bolts/pull/863
492 #[derive(Clone, Debug, PartialEq, Eq)]
493 pub struct SpliceLocked {
495 pub channel_id: ChannelId,
498 /// A tx_add_input message for adding an input during interactive transaction construction
500 // TODO(dual_funding): Add spec link for `tx_add_input`.
501 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
502 pub struct TxAddInput {
504 pub channel_id: ChannelId,
505 /// A randomly chosen unique identifier for this input, which is even for initiators and odd for
508 /// Serialized transaction that contains the output this input spends to verify that it is non
510 pub prevtx: TransactionU16LenLimited,
511 /// The index of the output being spent
513 /// The sequence number of this input
517 /// A tx_add_output message for adding an output during interactive transaction construction.
519 // TODO(dual_funding): Add spec link for `tx_add_output`.
520 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
521 pub struct TxAddOutput {
523 pub channel_id: ChannelId,
524 /// A randomly chosen unique identifier for this output, which is even for initiators and odd for
527 /// The satoshi value of the output
529 /// The scriptPubKey for the output
530 pub script: ScriptBuf,
533 /// A tx_remove_input message for removing an input during interactive transaction construction.
535 // TODO(dual_funding): Add spec link for `tx_remove_input`.
536 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
537 pub struct TxRemoveInput {
539 pub channel_id: ChannelId,
540 /// The serial ID of the input to be removed
544 /// A tx_remove_output message for removing an output during interactive transaction construction.
546 // TODO(dual_funding): Add spec link for `tx_remove_output`.
547 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
548 pub struct TxRemoveOutput {
550 pub channel_id: ChannelId,
551 /// The serial ID of the output to be removed
555 /// A tx_complete message signalling the conclusion of a peer's transaction contributions during
556 /// interactive transaction construction.
558 // TODO(dual_funding): Add spec link for `tx_complete`.
559 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
560 pub struct TxComplete {
562 pub channel_id: ChannelId,
565 /// A tx_signatures message containing the sender's signatures for a transaction constructed with
566 /// interactive transaction construction.
568 // TODO(dual_funding): Add spec link for `tx_signatures`.
569 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
570 pub struct TxSignatures {
572 pub channel_id: ChannelId,
575 /// The list of witnesses
576 pub witnesses: Vec<Witness>,
579 /// A tx_init_rbf message which initiates a replacement of the transaction after it's been
582 // TODO(dual_funding): Add spec link for `tx_init_rbf`.
583 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
584 pub struct TxInitRbf {
586 pub channel_id: ChannelId,
587 /// The locktime of the transaction
589 /// The feerate of the transaction
590 pub feerate_sat_per_1000_weight: u32,
591 /// The number of satoshis the sender will contribute to or, if negative, remove from
592 /// (e.g. splice-out) the funding output of the transaction
593 pub funding_output_contribution: Option<i64>,
596 /// A tx_ack_rbf message which acknowledges replacement of the transaction after it's been
599 // TODO(dual_funding): Add spec link for `tx_ack_rbf`.
600 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
601 pub struct TxAckRbf {
603 pub channel_id: ChannelId,
604 /// The number of satoshis the sender will contribute to or, if negative, remove from
605 /// (e.g. splice-out) the funding output of the transaction
606 pub funding_output_contribution: Option<i64>,
609 /// A tx_abort message which signals the cancellation of an in-progress transaction negotiation.
611 // TODO(dual_funding): Add spec link for `tx_abort`.
612 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
615 pub channel_id: ChannelId,
620 /// A [`shutdown`] message to be sent to or received from a peer.
622 /// [`shutdown`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-initiation-shutdown
623 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
624 pub struct Shutdown {
626 pub channel_id: ChannelId,
627 /// The destination of this peer's funds on closing.
629 /// Must be in one of these forms: P2PKH, P2SH, P2WPKH, P2WSH, P2TR.
630 pub scriptpubkey: ScriptBuf,
633 /// The minimum and maximum fees which the sender is willing to place on the closing transaction.
635 /// This is provided in [`ClosingSigned`] by both sides to indicate the fee range they are willing
637 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
638 pub struct ClosingSignedFeeRange {
639 /// The minimum absolute fee, in satoshis, which the sender is willing to place on the closing
641 pub min_fee_satoshis: u64,
642 /// The maximum absolute fee, in satoshis, which the sender is willing to place on the closing
644 pub max_fee_satoshis: u64,
647 /// A [`closing_signed`] message to be sent to or received from a peer.
649 /// [`closing_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-negotiation-closing_signed
650 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
651 pub struct ClosingSigned {
653 pub channel_id: ChannelId,
654 /// The proposed total fee for the closing transaction
655 pub fee_satoshis: u64,
656 /// A signature on the closing transaction
657 pub signature: Signature,
658 /// The minimum and maximum fees which the sender is willing to accept, provided only by new
660 pub fee_range: Option<ClosingSignedFeeRange>,
663 /// An [`update_add_htlc`] message to be sent to or received from a peer.
665 /// [`update_add_htlc`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#adding-an-htlc-update_add_htlc
666 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
667 pub struct UpdateAddHTLC {
669 pub channel_id: ChannelId,
672 /// The HTLC value in milli-satoshi
673 pub amount_msat: u64,
674 /// The payment hash, the pre-image of which controls HTLC redemption
675 pub payment_hash: PaymentHash,
676 /// The expiry height of the HTLC
677 pub cltv_expiry: u32,
678 /// The extra fee skimmed by the sender of this message. See
679 /// [`ChannelConfig::accept_underpaying_htlcs`].
681 /// [`ChannelConfig::accept_underpaying_htlcs`]: crate::util::config::ChannelConfig::accept_underpaying_htlcs
682 pub skimmed_fee_msat: Option<u64>,
683 /// The onion routing packet with encrypted data for the next hop.
684 pub onion_routing_packet: OnionPacket,
687 /// An onion message to be sent to or received from a peer.
689 // TODO: update with link to OM when they are merged into the BOLTs
690 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
691 pub struct OnionMessage {
692 /// Used in decrypting the onion packet's payload.
693 pub blinding_point: PublicKey,
694 /// The full onion packet including hop data, pubkey, and hmac
695 pub onion_routing_packet: onion_message::Packet,
698 /// An [`update_fulfill_htlc`] message to be sent to or received from a peer.
700 /// [`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
701 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
702 pub struct UpdateFulfillHTLC {
704 pub channel_id: ChannelId,
707 /// The pre-image of the payment hash, allowing HTLC redemption
708 pub payment_preimage: PaymentPreimage,
711 /// An [`update_fail_htlc`] message to be sent to or received from a peer.
713 /// [`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
714 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
715 pub struct UpdateFailHTLC {
717 pub channel_id: ChannelId,
720 pub(crate) reason: OnionErrorPacket,
723 /// An [`update_fail_malformed_htlc`] message to be sent to or received from a peer.
725 /// [`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
726 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
727 pub struct UpdateFailMalformedHTLC {
729 pub channel_id: ChannelId,
732 pub(crate) sha256_of_onion: [u8; 32],
734 pub failure_code: u16,
737 /// A [`commitment_signed`] message to be sent to or received from a peer.
739 /// [`commitment_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#committing-updates-so-far-commitment_signed
740 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
741 pub struct CommitmentSigned {
743 pub channel_id: ChannelId,
744 /// A signature on the commitment transaction
745 pub signature: Signature,
746 /// Signatures on the HTLC transactions
747 pub htlc_signatures: Vec<Signature>,
749 /// The partial Taproot signature on the commitment transaction
750 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
753 /// A [`revoke_and_ack`] message to be sent to or received from a peer.
755 /// [`revoke_and_ack`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#completing-the-transition-to-the-updated-state-revoke_and_ack
756 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
757 pub struct RevokeAndACK {
759 pub channel_id: ChannelId,
760 /// The secret corresponding to the per-commitment point
761 pub per_commitment_secret: [u8; 32],
762 /// The next sender-broadcast commitment transaction's per-commitment point
763 pub next_per_commitment_point: PublicKey,
765 /// Musig nonce the recipient should use in their next commitment signature message
766 pub next_local_nonce: Option<musig2::types::PublicNonce>
769 /// An [`update_fee`] message to be sent to or received from a peer
771 /// [`update_fee`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#updating-fees-update_fee
772 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
773 pub struct UpdateFee {
775 pub channel_id: ChannelId,
776 /// Fee rate per 1000-weight of the transaction
777 pub feerate_per_kw: u32,
780 /// A [`channel_reestablish`] message to be sent to or received from a peer.
782 /// [`channel_reestablish`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#message-retransmission
783 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
784 pub struct ChannelReestablish {
786 pub channel_id: ChannelId,
787 /// The next commitment number for the sender
788 pub next_local_commitment_number: u64,
789 /// The next commitment number for the recipient
790 pub next_remote_commitment_number: u64,
791 /// Proof that the sender knows the per-commitment secret of a specific commitment transaction
792 /// belonging to the recipient
793 pub your_last_per_commitment_secret: [u8; 32],
794 /// The sender's per-commitment point for their current commitment transaction
795 pub my_current_per_commitment_point: PublicKey,
796 /// The next funding transaction ID
797 pub next_funding_txid: Option<Txid>,
800 /// An [`announcement_signatures`] message to be sent to or received from a peer.
802 /// [`announcement_signatures`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-announcement_signatures-message
803 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
804 pub struct AnnouncementSignatures {
806 pub channel_id: ChannelId,
807 /// The short channel ID
808 pub short_channel_id: u64,
809 /// A signature by the node key
810 pub node_signature: Signature,
811 /// A signature by the funding key
812 pub bitcoin_signature: Signature,
815 /// An address which can be used to connect to a remote peer.
816 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
817 pub enum SocketAddress {
818 /// An IPv4 address and port on which the peer is listening.
820 /// The 4-byte IPv4 address
822 /// The port on which the node is listening
825 /// An IPv6 address and port on which the peer is listening.
827 /// The 16-byte IPv6 address
829 /// The port on which the node is listening
832 /// An old-style Tor onion address/port on which the peer is listening.
834 /// This field is deprecated and the Tor network generally no longer supports V2 Onion
835 /// addresses. Thus, the details are not parsed here.
837 /// A new-style Tor onion address/port on which the peer is listening.
839 /// To create the human-readable "hostname", concatenate the ED25519 pubkey, checksum, and version,
840 /// wrap as base32 and append ".onion".
842 /// The ed25519 long-term public key of the peer
843 ed25519_pubkey: [u8; 32],
844 /// The checksum of the pubkey and version, as included in the onion address
846 /// The version byte, as defined by the Tor Onion v3 spec.
848 /// The port on which the node is listening
851 /// A hostname/port on which the peer is listening.
853 /// The hostname on which the node is listening.
855 /// The port on which the node is listening.
860 /// Gets the ID of this address type. Addresses in [`NodeAnnouncement`] messages should be sorted
862 pub(crate) fn get_id(&self) -> u8 {
864 &SocketAddress::TcpIpV4 {..} => { 1 },
865 &SocketAddress::TcpIpV6 {..} => { 2 },
866 &SocketAddress::OnionV2(_) => { 3 },
867 &SocketAddress::OnionV3 {..} => { 4 },
868 &SocketAddress::Hostname {..} => { 5 },
872 /// Strict byte-length of address descriptor, 1-byte type not recorded
873 fn len(&self) -> u16 {
875 &SocketAddress::TcpIpV4 { .. } => { 6 },
876 &SocketAddress::TcpIpV6 { .. } => { 18 },
877 &SocketAddress::OnionV2(_) => { 12 },
878 &SocketAddress::OnionV3 { .. } => { 37 },
879 // Consists of 1-byte hostname length, hostname bytes, and 2-byte port.
880 &SocketAddress::Hostname { ref hostname, .. } => { u16::from(hostname.len()) + 3 },
884 /// The maximum length of any address descriptor, not including the 1-byte type.
885 /// This maximum length is reached by a hostname address descriptor:
886 /// a hostname with a maximum length of 255, its 1-byte length and a 2-byte port.
887 pub(crate) const MAX_LEN: u16 = 258;
890 impl Writeable for SocketAddress {
891 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
893 &SocketAddress::TcpIpV4 { ref addr, ref port } => {
898 &SocketAddress::TcpIpV6 { ref addr, ref port } => {
903 &SocketAddress::OnionV2(bytes) => {
905 bytes.write(writer)?;
907 &SocketAddress::OnionV3 { ref ed25519_pubkey, ref checksum, ref version, ref port } => {
909 ed25519_pubkey.write(writer)?;
910 checksum.write(writer)?;
911 version.write(writer)?;
914 &SocketAddress::Hostname { ref hostname, ref port } => {
916 hostname.write(writer)?;
924 impl Readable for Result<SocketAddress, u8> {
925 fn read<R: Read>(reader: &mut R) -> Result<Result<SocketAddress, u8>, DecodeError> {
926 let byte = <u8 as Readable>::read(reader)?;
929 Ok(Ok(SocketAddress::TcpIpV4 {
930 addr: Readable::read(reader)?,
931 port: Readable::read(reader)?,
935 Ok(Ok(SocketAddress::TcpIpV6 {
936 addr: Readable::read(reader)?,
937 port: Readable::read(reader)?,
940 3 => Ok(Ok(SocketAddress::OnionV2(Readable::read(reader)?))),
942 Ok(Ok(SocketAddress::OnionV3 {
943 ed25519_pubkey: Readable::read(reader)?,
944 checksum: Readable::read(reader)?,
945 version: Readable::read(reader)?,
946 port: Readable::read(reader)?,
950 Ok(Ok(SocketAddress::Hostname {
951 hostname: Readable::read(reader)?,
952 port: Readable::read(reader)?,
955 _ => return Ok(Err(byte)),
960 impl Readable for SocketAddress {
961 fn read<R: Read>(reader: &mut R) -> Result<SocketAddress, DecodeError> {
962 match Readable::read(reader) {
963 Ok(Ok(res)) => Ok(res),
964 Ok(Err(_)) => Err(DecodeError::UnknownVersion),
970 /// [`SocketAddress`] error variants
971 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
972 pub enum SocketAddressParseError {
973 /// Socket address (IPv4/IPv6) parsing error
975 /// Invalid input format
979 /// Invalid onion v3 address
983 impl fmt::Display for SocketAddressParseError {
984 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
986 SocketAddressParseError::SocketAddrParse => write!(f, "Socket address (IPv4/IPv6) parsing error"),
987 SocketAddressParseError::InvalidInput => write!(f, "Invalid input format. \
988 Expected: \"<ipv4>:<port>\", \"[<ipv6>]:<port>\", \"<onion address>.onion:<port>\" or \"<hostname>:<port>\""),
989 SocketAddressParseError::InvalidPort => write!(f, "Invalid port"),
990 SocketAddressParseError::InvalidOnionV3 => write!(f, "Invalid onion v3 address"),
995 #[cfg(feature = "std")]
996 impl From<std::net::SocketAddrV4> for SocketAddress {
997 fn from(addr: std::net::SocketAddrV4) -> Self {
998 SocketAddress::TcpIpV4 { addr: addr.ip().octets(), port: addr.port() }
1002 #[cfg(feature = "std")]
1003 impl From<std::net::SocketAddrV6> for SocketAddress {
1004 fn from(addr: std::net::SocketAddrV6) -> Self {
1005 SocketAddress::TcpIpV6 { addr: addr.ip().octets(), port: addr.port() }
1009 #[cfg(feature = "std")]
1010 impl From<std::net::SocketAddr> for SocketAddress {
1011 fn from(addr: std::net::SocketAddr) -> Self {
1013 std::net::SocketAddr::V4(addr) => addr.into(),
1014 std::net::SocketAddr::V6(addr) => addr.into(),
1019 #[cfg(feature = "std")]
1020 impl std::net::ToSocketAddrs for SocketAddress {
1021 type Iter = std::vec::IntoIter<std::net::SocketAddr>;
1023 fn to_socket_addrs(&self) -> std::io::Result<Self::Iter> {
1025 SocketAddress::TcpIpV4 { addr, port } => {
1026 let ip_addr = std::net::Ipv4Addr::from(*addr);
1027 let socket_addr = SocketAddr::new(ip_addr.into(), *port);
1028 Ok(vec![socket_addr].into_iter())
1030 SocketAddress::TcpIpV6 { addr, port } => {
1031 let ip_addr = std::net::Ipv6Addr::from(*addr);
1032 let socket_addr = SocketAddr::new(ip_addr.into(), *port);
1033 Ok(vec![socket_addr].into_iter())
1035 SocketAddress::Hostname { ref hostname, port } => {
1036 (hostname.as_str(), *port).to_socket_addrs()
1038 SocketAddress::OnionV2(..) => {
1039 Err(std::io::Error::new(std::io::ErrorKind::Other, "Resolution of OnionV2 \
1040 addresses is currently unsupported."))
1042 SocketAddress::OnionV3 { .. } => {
1043 Err(std::io::Error::new(std::io::ErrorKind::Other, "Resolution of OnionV3 \
1044 addresses is currently unsupported."))
1050 /// Parses an OnionV3 host and port into a [`SocketAddress::OnionV3`].
1052 /// The host part must end with ".onion".
1053 pub fn parse_onion_address(host: &str, port: u16) -> Result<SocketAddress, SocketAddressParseError> {
1054 if host.ends_with(".onion") {
1055 let domain = &host[..host.len() - ".onion".len()];
1056 if domain.len() != 56 {
1057 return Err(SocketAddressParseError::InvalidOnionV3);
1059 let onion = base32::Alphabet::RFC4648 { padding: false }.decode(&domain).map_err(|_| SocketAddressParseError::InvalidOnionV3)?;
1060 if onion.len() != 35 {
1061 return Err(SocketAddressParseError::InvalidOnionV3);
1063 let version = onion[0];
1064 let first_checksum_flag = onion[1];
1065 let second_checksum_flag = onion[2];
1066 let mut ed25519_pubkey = [0; 32];
1067 ed25519_pubkey.copy_from_slice(&onion[3..35]);
1068 let checksum = u16::from_be_bytes([first_checksum_flag, second_checksum_flag]);
1069 return Ok(SocketAddress::OnionV3 { ed25519_pubkey, checksum, version, port });
1072 return Err(SocketAddressParseError::InvalidInput);
1076 impl Display for SocketAddress {
1077 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1079 SocketAddress::TcpIpV4{addr, port} => write!(
1080 f, "{}.{}.{}.{}:{}", addr[0], addr[1], addr[2], addr[3], port)?,
1081 SocketAddress::TcpIpV6{addr, port} => write!(
1083 "[{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}]:{}",
1084 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
1086 SocketAddress::OnionV2(bytes) => write!(f, "OnionV2({:?})", bytes)?,
1087 SocketAddress::OnionV3 {
1093 let [first_checksum_flag, second_checksum_flag] = checksum.to_be_bytes();
1094 let mut addr = vec![*version, first_checksum_flag, second_checksum_flag];
1095 addr.extend_from_slice(ed25519_pubkey);
1096 let onion = base32::Alphabet::RFC4648 { padding: false }.encode(&addr);
1097 write!(f, "{}.onion:{}", onion, port)?
1099 SocketAddress::Hostname { hostname, port } => write!(f, "{}:{}", hostname, port)?,
1105 #[cfg(feature = "std")]
1106 impl FromStr for SocketAddress {
1107 type Err = SocketAddressParseError;
1109 fn from_str(s: &str) -> Result<Self, Self::Err> {
1110 match std::net::SocketAddr::from_str(s) {
1111 Ok(addr) => Ok(addr.into()),
1113 let trimmed_input = match s.rfind(":") {
1115 None => return Err(SocketAddressParseError::InvalidInput),
1117 let host = &s[..trimmed_input];
1118 let port: u16 = s[trimmed_input + 1..].parse().map_err(|_| SocketAddressParseError::InvalidPort)?;
1119 if host.ends_with(".onion") {
1120 return parse_onion_address(host, port);
1122 if let Ok(hostname) = Hostname::try_from(s[..trimmed_input].to_string()) {
1123 return Ok(SocketAddress::Hostname { hostname, port });
1125 return Err(SocketAddressParseError::SocketAddrParse)
1131 /// Represents the set of gossip messages that require a signature from a node's identity key.
1132 pub enum UnsignedGossipMessage<'a> {
1133 /// An unsigned channel announcement.
1134 ChannelAnnouncement(&'a UnsignedChannelAnnouncement),
1135 /// An unsigned channel update.
1136 ChannelUpdate(&'a UnsignedChannelUpdate),
1137 /// An unsigned node announcement.
1138 NodeAnnouncement(&'a UnsignedNodeAnnouncement)
1141 impl<'a> Writeable for UnsignedGossipMessage<'a> {
1142 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
1144 UnsignedGossipMessage::ChannelAnnouncement(ref msg) => msg.write(writer),
1145 UnsignedGossipMessage::ChannelUpdate(ref msg) => msg.write(writer),
1146 UnsignedGossipMessage::NodeAnnouncement(ref msg) => msg.write(writer),
1151 /// The unsigned part of a [`node_announcement`] message.
1153 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
1154 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1155 pub struct UnsignedNodeAnnouncement {
1156 /// The advertised features
1157 pub features: NodeFeatures,
1158 /// A strictly monotonic announcement counter, with gaps allowed
1160 /// The `node_id` this announcement originated from (don't rebroadcast the `node_announcement` back
1162 pub node_id: NodeId,
1163 /// An RGB color for UI purposes
1165 /// An alias, for UI purposes.
1167 /// This should be sanitized before use. There is no guarantee of uniqueness.
1168 pub alias: NodeAlias,
1169 /// List of addresses on which this node is reachable
1170 pub addresses: Vec<SocketAddress>,
1171 pub(crate) excess_address_data: Vec<u8>,
1172 pub(crate) excess_data: Vec<u8>,
1174 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1175 /// A [`node_announcement`] message to be sent to or received from a peer.
1177 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
1178 pub struct NodeAnnouncement {
1179 /// The signature by the node key
1180 pub signature: Signature,
1181 /// The actual content of the announcement
1182 pub contents: UnsignedNodeAnnouncement,
1185 /// The unsigned part of a [`channel_announcement`] message.
1187 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
1188 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1189 pub struct UnsignedChannelAnnouncement {
1190 /// The advertised channel features
1191 pub features: ChannelFeatures,
1192 /// The genesis hash of the blockchain where the channel is to be opened
1193 pub chain_hash: ChainHash,
1194 /// The short channel ID
1195 pub short_channel_id: u64,
1196 /// One of the two `node_id`s which are endpoints of this channel
1197 pub node_id_1: NodeId,
1198 /// The other of the two `node_id`s which are endpoints of this channel
1199 pub node_id_2: NodeId,
1200 /// The funding key for the first node
1201 pub bitcoin_key_1: NodeId,
1202 /// The funding key for the second node
1203 pub bitcoin_key_2: NodeId,
1204 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1207 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1208 pub excess_data: Vec<u8>,
1210 /// A [`channel_announcement`] message to be sent to or received from a peer.
1212 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
1213 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1214 pub struct ChannelAnnouncement {
1215 /// Authentication of the announcement by the first public node
1216 pub node_signature_1: Signature,
1217 /// Authentication of the announcement by the second public node
1218 pub node_signature_2: Signature,
1219 /// Proof of funding UTXO ownership by the first public node
1220 pub bitcoin_signature_1: Signature,
1221 /// Proof of funding UTXO ownership by the second public node
1222 pub bitcoin_signature_2: Signature,
1223 /// The actual announcement
1224 pub contents: UnsignedChannelAnnouncement,
1227 /// The unsigned part of a [`channel_update`] message.
1229 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1230 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1231 pub struct UnsignedChannelUpdate {
1232 /// The genesis hash of the blockchain where the channel is to be opened
1233 pub chain_hash: ChainHash,
1234 /// The short channel ID
1235 pub short_channel_id: u64,
1236 /// A strictly monotonic announcement counter, with gaps allowed, specific to this channel
1240 /// The number of blocks such that if:
1241 /// `incoming_htlc.cltv_expiry < outgoing_htlc.cltv_expiry + cltv_expiry_delta`
1242 /// then we need to fail the HTLC backwards. When forwarding an HTLC, `cltv_expiry_delta` determines
1243 /// the outgoing HTLC's minimum `cltv_expiry` value -- so, if an incoming HTLC comes in with a
1244 /// `cltv_expiry` of 100000, and the node we're forwarding to has a `cltv_expiry_delta` value of 10,
1245 /// then we'll check that the outgoing HTLC's `cltv_expiry` value is at least 100010 before
1246 /// forwarding. Note that the HTLC sender is the one who originally sets this value when
1247 /// constructing the route.
1248 pub cltv_expiry_delta: u16,
1249 /// The minimum HTLC size incoming to sender, in milli-satoshi
1250 pub htlc_minimum_msat: u64,
1251 /// The maximum HTLC value incoming to sender, in milli-satoshi.
1253 /// This used to be optional.
1254 pub htlc_maximum_msat: u64,
1255 /// The base HTLC fee charged by sender, in milli-satoshi
1256 pub fee_base_msat: u32,
1257 /// The amount to fee multiplier, in micro-satoshi
1258 pub fee_proportional_millionths: u32,
1259 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1262 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1263 pub excess_data: Vec<u8>,
1265 /// A [`channel_update`] message to be sent to or received from a peer.
1267 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1268 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1269 pub struct ChannelUpdate {
1270 /// A signature of the channel update
1271 pub signature: Signature,
1272 /// The actual channel update
1273 pub contents: UnsignedChannelUpdate,
1276 /// A [`query_channel_range`] message is used to query a peer for channel
1277 /// UTXOs in a range of blocks. The recipient of a query makes a best
1278 /// effort to reply to the query using one or more [`ReplyChannelRange`]
1281 /// [`query_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1282 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1283 pub struct QueryChannelRange {
1284 /// The genesis hash of the blockchain being queried
1285 pub chain_hash: ChainHash,
1286 /// The height of the first block for the channel UTXOs being queried
1287 pub first_blocknum: u32,
1288 /// The number of blocks to include in the query results
1289 pub number_of_blocks: u32,
1292 /// A [`reply_channel_range`] message is a reply to a [`QueryChannelRange`]
1295 /// Multiple `reply_channel_range` messages can be sent in reply
1296 /// to a single [`QueryChannelRange`] message. The query recipient makes a
1297 /// best effort to respond based on their local network view which may
1298 /// not be a perfect view of the network. The `short_channel_id`s in the
1299 /// reply are encoded. We only support `encoding_type=0` uncompressed
1300 /// serialization and do not support `encoding_type=1` zlib serialization.
1302 /// [`reply_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1303 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1304 pub struct ReplyChannelRange {
1305 /// The genesis hash of the blockchain being queried
1306 pub chain_hash: ChainHash,
1307 /// The height of the first block in the range of the reply
1308 pub first_blocknum: u32,
1309 /// The number of blocks included in the range of the reply
1310 pub number_of_blocks: u32,
1311 /// True when this is the final reply for a query
1312 pub sync_complete: bool,
1313 /// The `short_channel_id`s in the channel range
1314 pub short_channel_ids: Vec<u64>,
1317 /// A [`query_short_channel_ids`] message is used to query a peer for
1318 /// routing gossip messages related to one or more `short_channel_id`s.
1320 /// The query recipient will reply with the latest, if available,
1321 /// [`ChannelAnnouncement`], [`ChannelUpdate`] and [`NodeAnnouncement`] messages
1322 /// it maintains for the requested `short_channel_id`s followed by a
1323 /// [`ReplyShortChannelIdsEnd`] message. The `short_channel_id`s sent in
1324 /// this query are encoded. We only support `encoding_type=0` uncompressed
1325 /// serialization and do not support `encoding_type=1` zlib serialization.
1327 /// [`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
1328 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1329 pub struct QueryShortChannelIds {
1330 /// The genesis hash of the blockchain being queried
1331 pub chain_hash: ChainHash,
1332 /// The short_channel_ids that are being queried
1333 pub short_channel_ids: Vec<u64>,
1336 /// A [`reply_short_channel_ids_end`] message is sent as a reply to a
1337 /// message. The query recipient makes a best
1338 /// effort to respond based on their local network view which may not be
1339 /// a perfect view of the network.
1341 /// [`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
1342 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1343 pub struct ReplyShortChannelIdsEnd {
1344 /// The genesis hash of the blockchain that was queried
1345 pub chain_hash: ChainHash,
1346 /// Indicates if the query recipient maintains up-to-date channel
1347 /// information for the `chain_hash`
1348 pub full_information: bool,
1351 /// A [`gossip_timestamp_filter`] message is used by a node to request
1352 /// gossip relay for messages in the requested time range when the
1353 /// `gossip_queries` feature has been negotiated.
1355 /// [`gossip_timestamp_filter`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-gossip_timestamp_filter-message
1356 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1357 pub struct GossipTimestampFilter {
1358 /// The genesis hash of the blockchain for channel and node information
1359 pub chain_hash: ChainHash,
1360 /// The starting unix timestamp
1361 pub first_timestamp: u32,
1362 /// The range of information in seconds
1363 pub timestamp_range: u32,
1366 /// Encoding type for data compression of collections in gossip queries.
1368 /// We do not support `encoding_type=1` zlib serialization [defined in BOLT
1369 /// #7](https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#query-messages).
1371 Uncompressed = 0x00,
1374 /// Used to put an error message in a [`LightningError`].
1375 #[derive(Clone, Debug, Hash, PartialEq)]
1376 pub enum ErrorAction {
1377 /// The peer took some action which made us think they were useless. Disconnect them.
1379 /// An error message which we should make an effort to send before we disconnect.
1380 msg: Option<ErrorMessage>
1382 /// The peer did something incorrect. Tell them without closing any channels and disconnect them.
1383 DisconnectPeerWithWarning {
1384 /// A warning message which we should make an effort to send before we disconnect.
1385 msg: WarningMessage,
1387 /// The peer did something harmless that we weren't able to process, just log and ignore
1388 // New code should *not* use this. New code must use IgnoreAndLog, below!
1390 /// The peer did something harmless that we weren't able to meaningfully process.
1391 /// If the error is logged, log it at the given level.
1392 IgnoreAndLog(logger::Level),
1393 /// The peer provided us with a gossip message which we'd already seen. In most cases this
1394 /// should be ignored, but it may result in the message being forwarded if it is a duplicate of
1395 /// our own channel announcements.
1396 IgnoreDuplicateGossip,
1397 /// The peer did something incorrect. Tell them.
1399 /// The message to send.
1402 /// The peer did something incorrect. Tell them without closing any channels.
1403 SendWarningMessage {
1404 /// The message to send.
1405 msg: WarningMessage,
1406 /// The peer may have done something harmless that we weren't able to meaningfully process,
1407 /// though we should still tell them about it.
1408 /// If this event is logged, log it at the given level.
1409 log_level: logger::Level,
1413 /// An Err type for failure to process messages.
1414 #[derive(Clone, Debug)]
1415 pub struct LightningError {
1416 /// A human-readable message describing the error
1418 /// The action which should be taken against the offending peer.
1419 pub action: ErrorAction,
1422 /// Struct used to return values from [`RevokeAndACK`] messages, containing a bunch of commitment
1423 /// transaction updates if they were pending.
1424 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1425 pub struct CommitmentUpdate {
1426 /// `update_add_htlc` messages which should be sent
1427 pub update_add_htlcs: Vec<UpdateAddHTLC>,
1428 /// `update_fulfill_htlc` messages which should be sent
1429 pub update_fulfill_htlcs: Vec<UpdateFulfillHTLC>,
1430 /// `update_fail_htlc` messages which should be sent
1431 pub update_fail_htlcs: Vec<UpdateFailHTLC>,
1432 /// `update_fail_malformed_htlc` messages which should be sent
1433 pub update_fail_malformed_htlcs: Vec<UpdateFailMalformedHTLC>,
1434 /// An `update_fee` message which should be sent
1435 pub update_fee: Option<UpdateFee>,
1436 /// A `commitment_signed` message which should be sent
1437 pub commitment_signed: CommitmentSigned,
1440 /// A trait to describe an object which can receive channel messages.
1442 /// Messages MAY be called in parallel when they originate from different `their_node_ids`, however
1443 /// they MUST NOT be called in parallel when the two calls have the same `their_node_id`.
1444 pub trait ChannelMessageHandler : MessageSendEventsProvider {
1446 /// Handle an incoming `open_channel` message from the given peer.
1447 fn handle_open_channel(&self, their_node_id: &PublicKey, msg: &OpenChannel);
1448 /// Handle an incoming `open_channel2` message from the given peer.
1449 fn handle_open_channel_v2(&self, their_node_id: &PublicKey, msg: &OpenChannelV2);
1450 /// Handle an incoming `accept_channel` message from the given peer.
1451 fn handle_accept_channel(&self, their_node_id: &PublicKey, msg: &AcceptChannel);
1452 /// Handle an incoming `accept_channel2` message from the given peer.
1453 fn handle_accept_channel_v2(&self, their_node_id: &PublicKey, msg: &AcceptChannelV2);
1454 /// Handle an incoming `funding_created` message from the given peer.
1455 fn handle_funding_created(&self, their_node_id: &PublicKey, msg: &FundingCreated);
1456 /// Handle an incoming `funding_signed` message from the given peer.
1457 fn handle_funding_signed(&self, their_node_id: &PublicKey, msg: &FundingSigned);
1458 /// Handle an incoming `channel_ready` message from the given peer.
1459 fn handle_channel_ready(&self, their_node_id: &PublicKey, msg: &ChannelReady);
1462 /// Handle an incoming `shutdown` message from the given peer.
1463 fn handle_shutdown(&self, their_node_id: &PublicKey, msg: &Shutdown);
1464 /// Handle an incoming `closing_signed` message from the given peer.
1465 fn handle_closing_signed(&self, their_node_id: &PublicKey, msg: &ClosingSigned);
1468 /// Handle an incoming `stfu` message from the given peer.
1469 fn handle_stfu(&self, their_node_id: &PublicKey, msg: &Stfu);
1472 /// Handle an incoming `splice` message from the given peer.
1473 fn handle_splice(&self, their_node_id: &PublicKey, msg: &Splice);
1474 /// Handle an incoming `splice_ack` message from the given peer.
1475 fn handle_splice_ack(&self, their_node_id: &PublicKey, msg: &SpliceAck);
1476 /// Handle an incoming `splice_locked` message from the given peer.
1477 fn handle_splice_locked(&self, their_node_id: &PublicKey, msg: &SpliceLocked);
1479 // Interactive channel construction
1480 /// Handle an incoming `tx_add_input message` from the given peer.
1481 fn handle_tx_add_input(&self, their_node_id: &PublicKey, msg: &TxAddInput);
1482 /// Handle an incoming `tx_add_output` message from the given peer.
1483 fn handle_tx_add_output(&self, their_node_id: &PublicKey, msg: &TxAddOutput);
1484 /// Handle an incoming `tx_remove_input` message from the given peer.
1485 fn handle_tx_remove_input(&self, their_node_id: &PublicKey, msg: &TxRemoveInput);
1486 /// Handle an incoming `tx_remove_output` message from the given peer.
1487 fn handle_tx_remove_output(&self, their_node_id: &PublicKey, msg: &TxRemoveOutput);
1488 /// Handle an incoming `tx_complete message` from the given peer.
1489 fn handle_tx_complete(&self, their_node_id: &PublicKey, msg: &TxComplete);
1490 /// Handle an incoming `tx_signatures` message from the given peer.
1491 fn handle_tx_signatures(&self, their_node_id: &PublicKey, msg: &TxSignatures);
1492 /// Handle an incoming `tx_init_rbf` message from the given peer.
1493 fn handle_tx_init_rbf(&self, their_node_id: &PublicKey, msg: &TxInitRbf);
1494 /// Handle an incoming `tx_ack_rbf` message from the given peer.
1495 fn handle_tx_ack_rbf(&self, their_node_id: &PublicKey, msg: &TxAckRbf);
1496 /// Handle an incoming `tx_abort message` from the given peer.
1497 fn handle_tx_abort(&self, their_node_id: &PublicKey, msg: &TxAbort);
1500 /// Handle an incoming `update_add_htlc` message from the given peer.
1501 fn handle_update_add_htlc(&self, their_node_id: &PublicKey, msg: &UpdateAddHTLC);
1502 /// Handle an incoming `update_fulfill_htlc` message from the given peer.
1503 fn handle_update_fulfill_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFulfillHTLC);
1504 /// Handle an incoming `update_fail_htlc` message from the given peer.
1505 fn handle_update_fail_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailHTLC);
1506 /// Handle an incoming `update_fail_malformed_htlc` message from the given peer.
1507 fn handle_update_fail_malformed_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailMalformedHTLC);
1508 /// Handle an incoming `commitment_signed` message from the given peer.
1509 fn handle_commitment_signed(&self, their_node_id: &PublicKey, msg: &CommitmentSigned);
1510 /// Handle an incoming `revoke_and_ack` message from the given peer.
1511 fn handle_revoke_and_ack(&self, their_node_id: &PublicKey, msg: &RevokeAndACK);
1513 /// Handle an incoming `update_fee` message from the given peer.
1514 fn handle_update_fee(&self, their_node_id: &PublicKey, msg: &UpdateFee);
1516 // Channel-to-announce:
1517 /// Handle an incoming `announcement_signatures` message from the given peer.
1518 fn handle_announcement_signatures(&self, their_node_id: &PublicKey, msg: &AnnouncementSignatures);
1520 // Connection loss/reestablish:
1521 /// Indicates a connection to the peer failed/an existing connection was lost.
1522 fn peer_disconnected(&self, their_node_id: &PublicKey);
1524 /// Handle a peer reconnecting, possibly generating `channel_reestablish` message(s).
1526 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1527 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1528 /// message handlers may still wish to communicate with this peer.
1529 fn peer_connected(&self, their_node_id: &PublicKey, msg: &Init, inbound: bool) -> Result<(), ()>;
1530 /// Handle an incoming `channel_reestablish` message from the given peer.
1531 fn handle_channel_reestablish(&self, their_node_id: &PublicKey, msg: &ChannelReestablish);
1533 /// Handle an incoming `channel_update` message from the given peer.
1534 fn handle_channel_update(&self, their_node_id: &PublicKey, msg: &ChannelUpdate);
1537 /// Handle an incoming `error` message from the given peer.
1538 fn handle_error(&self, their_node_id: &PublicKey, msg: &ErrorMessage);
1540 // Handler information:
1541 /// Gets the node feature flags which this handler itself supports. All available handlers are
1542 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1543 /// which are broadcasted in our [`NodeAnnouncement`] message.
1544 fn provided_node_features(&self) -> NodeFeatures;
1546 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1547 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1548 /// which are sent in our [`Init`] message.
1550 /// Note that this method is called before [`Self::peer_connected`].
1551 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1553 /// Gets the chain hashes for this `ChannelMessageHandler` indicating which chains it supports.
1555 /// If it's `None`, then no particular network chain hash compatibility will be enforced when
1556 /// connecting to peers.
1557 fn get_chain_hashes(&self) -> Option<Vec<ChainHash>>;
1560 /// A trait to describe an object which can receive routing messages.
1562 /// # Implementor DoS Warnings
1564 /// For messages enabled with the `gossip_queries` feature there are potential DoS vectors when
1565 /// handling inbound queries. Implementors using an on-disk network graph should be aware of
1566 /// repeated disk I/O for queries accessing different parts of the network graph.
1567 pub trait RoutingMessageHandler : MessageSendEventsProvider {
1568 /// Handle an incoming `node_announcement` message, returning `true` if it should be forwarded on,
1569 /// `false` or returning an `Err` otherwise.
1570 fn handle_node_announcement(&self, msg: &NodeAnnouncement) -> Result<bool, LightningError>;
1571 /// Handle a `channel_announcement` message, returning `true` if it should be forwarded on, `false`
1572 /// or returning an `Err` otherwise.
1573 fn handle_channel_announcement(&self, msg: &ChannelAnnouncement) -> Result<bool, LightningError>;
1574 /// Handle an incoming `channel_update` message, returning true if it should be forwarded on,
1575 /// `false` or returning an `Err` otherwise.
1576 fn handle_channel_update(&self, msg: &ChannelUpdate) -> Result<bool, LightningError>;
1577 /// Gets channel announcements and updates required to dump our routing table to a remote node,
1578 /// starting at the `short_channel_id` indicated by `starting_point` and including announcements
1579 /// for a single channel.
1580 fn get_next_channel_announcement(&self, starting_point: u64) -> Option<(ChannelAnnouncement, Option<ChannelUpdate>, Option<ChannelUpdate>)>;
1581 /// Gets a node announcement required to dump our routing table to a remote node, starting at
1582 /// the node *after* the provided pubkey and including up to one announcement immediately
1583 /// higher (as defined by `<PublicKey as Ord>::cmp`) than `starting_point`.
1584 /// If `None` is provided for `starting_point`, we start at the first node.
1585 fn get_next_node_announcement(&self, starting_point: Option<&NodeId>) -> Option<NodeAnnouncement>;
1586 /// Called when a connection is established with a peer. This can be used to
1587 /// perform routing table synchronization using a strategy defined by the
1590 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1591 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1592 /// message handlers may still wish to communicate with this peer.
1593 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1594 /// Handles the reply of a query we initiated to learn about channels
1595 /// for a given range of blocks. We can expect to receive one or more
1596 /// replies to a single query.
1597 fn handle_reply_channel_range(&self, their_node_id: &PublicKey, msg: ReplyChannelRange) -> Result<(), LightningError>;
1598 /// Handles the reply of a query we initiated asking for routing gossip
1599 /// messages for a list of channels. We should receive this message when
1600 /// a node has completed its best effort to send us the pertaining routing
1601 /// gossip messages.
1602 fn handle_reply_short_channel_ids_end(&self, their_node_id: &PublicKey, msg: ReplyShortChannelIdsEnd) -> Result<(), LightningError>;
1603 /// Handles when a peer asks us to send a list of `short_channel_id`s
1604 /// for the requested range of blocks.
1605 fn handle_query_channel_range(&self, their_node_id: &PublicKey, msg: QueryChannelRange) -> Result<(), LightningError>;
1606 /// Handles when a peer asks us to send routing gossip messages for a
1607 /// list of `short_channel_id`s.
1608 fn handle_query_short_channel_ids(&self, their_node_id: &PublicKey, msg: QueryShortChannelIds) -> Result<(), LightningError>;
1610 // Handler queueing status:
1611 /// Indicates that there are a large number of [`ChannelAnnouncement`] (or other) messages
1612 /// pending some async action. While there is no guarantee of the rate of future messages, the
1613 /// caller should seek to reduce the rate of new gossip messages handled, especially
1614 /// [`ChannelAnnouncement`]s.
1615 fn processing_queue_high(&self) -> bool;
1617 // Handler information:
1618 /// Gets the node feature flags which this handler itself supports. All available handlers are
1619 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1620 /// which are broadcasted in our [`NodeAnnouncement`] message.
1621 fn provided_node_features(&self) -> NodeFeatures;
1622 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1623 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1624 /// which are sent in our [`Init`] message.
1626 /// Note that this method is called before [`Self::peer_connected`].
1627 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1630 /// A handler for received [`OnionMessage`]s and for providing generated ones to send.
1631 pub trait OnionMessageHandler {
1632 /// Handle an incoming `onion_message` message from the given peer.
1633 fn handle_onion_message(&self, peer_node_id: &PublicKey, msg: &OnionMessage);
1635 /// Returns the next pending onion message for the peer with the given node id.
1636 fn next_onion_message_for_peer(&self, peer_node_id: PublicKey) -> Option<OnionMessage>;
1638 /// Called when a connection is established with a peer. Can be used to track which peers
1639 /// advertise onion message support and are online.
1641 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1642 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1643 /// message handlers may still wish to communicate with this peer.
1644 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1646 /// Indicates a connection to the peer failed/an existing connection was lost. Allows handlers to
1647 /// drop and refuse to forward onion messages to this peer.
1648 fn peer_disconnected(&self, their_node_id: &PublicKey);
1650 // Handler information:
1651 /// Gets the node feature flags which this handler itself supports. All available handlers are
1652 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1653 /// which are broadcasted in our [`NodeAnnouncement`] message.
1654 fn provided_node_features(&self) -> NodeFeatures;
1656 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1657 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1658 /// which are sent in our [`Init`] message.
1660 /// Note that this method is called before [`Self::peer_connected`].
1661 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1664 mod fuzzy_internal_msgs {
1665 use bitcoin::secp256k1::PublicKey;
1666 use crate::blinded_path::payment::PaymentConstraints;
1667 use crate::prelude::*;
1668 use crate::ln::{PaymentPreimage, PaymentSecret};
1670 // These types aren't intended to be pub, but are exposed for direct fuzzing (as we deserialize
1671 // them from untrusted input):
1673 pub struct FinalOnionHopData {
1674 pub payment_secret: PaymentSecret,
1675 /// The total value, in msat, of the payment as received by the ultimate recipient.
1676 /// Message serialization may panic if this value is more than 21 million Bitcoin.
1677 pub total_msat: u64,
1680 pub enum InboundOnionPayload {
1682 short_channel_id: u64,
1683 /// The value, in msat, of the payment after this hop's fee is deducted.
1684 amt_to_forward: u64,
1685 outgoing_cltv_value: u32,
1688 payment_data: Option<FinalOnionHopData>,
1689 payment_metadata: Option<Vec<u8>>,
1690 keysend_preimage: Option<PaymentPreimage>,
1691 custom_tlvs: Vec<(u64, Vec<u8>)>,
1693 outgoing_cltv_value: u32,
1698 outgoing_cltv_value: u32,
1699 payment_secret: PaymentSecret,
1700 payment_constraints: PaymentConstraints,
1701 intro_node_blinding_point: PublicKey,
1705 pub(crate) enum OutboundOnionPayload {
1707 short_channel_id: u64,
1708 /// The value, in msat, of the payment after this hop's fee is deducted.
1709 amt_to_forward: u64,
1710 outgoing_cltv_value: u32,
1713 payment_data: Option<FinalOnionHopData>,
1714 payment_metadata: Option<Vec<u8>>,
1715 keysend_preimage: Option<PaymentPreimage>,
1716 custom_tlvs: Vec<(u64, Vec<u8>)>,
1718 outgoing_cltv_value: u32,
1721 encrypted_tlvs: Vec<u8>,
1722 intro_node_blinding_point: Option<PublicKey>,
1727 outgoing_cltv_value: u32,
1728 encrypted_tlvs: Vec<u8>,
1729 intro_node_blinding_point: Option<PublicKey>, // Set if the introduction node of the blinded path is the final node
1733 pub struct DecodedOnionErrorPacket {
1734 pub(crate) hmac: [u8; 32],
1735 pub(crate) failuremsg: Vec<u8>,
1736 pub(crate) pad: Vec<u8>,
1740 pub use self::fuzzy_internal_msgs::*;
1741 #[cfg(not(fuzzing))]
1742 pub(crate) use self::fuzzy_internal_msgs::*;
1744 /// BOLT 4 onion packet including hop data for the next peer.
1745 #[derive(Clone, Hash, PartialEq, Eq)]
1746 pub struct OnionPacket {
1747 /// BOLT 4 version number.
1749 /// In order to ensure we always return an error on onion decode in compliance with [BOLT
1750 /// #4](https://github.com/lightning/bolts/blob/master/04-onion-routing.md), we have to
1751 /// deserialize `OnionPacket`s contained in [`UpdateAddHTLC`] messages even if the ephemeral
1752 /// public key (here) is bogus, so we hold a [`Result`] instead of a [`PublicKey`] as we'd
1754 pub public_key: Result<PublicKey, secp256k1::Error>,
1755 /// 1300 bytes encrypted payload for the next hop.
1756 pub hop_data: [u8; 20*65],
1757 /// HMAC to verify the integrity of hop_data.
1761 impl onion_utils::Packet for OnionPacket {
1762 type Data = onion_utils::FixedSizeOnionPacket;
1763 fn new(pubkey: PublicKey, hop_data: onion_utils::FixedSizeOnionPacket, hmac: [u8; 32]) -> Self {
1766 public_key: Ok(pubkey),
1767 hop_data: hop_data.0,
1773 impl fmt::Debug for OnionPacket {
1774 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1775 f.write_fmt(format_args!("OnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
1779 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1780 pub(crate) struct OnionErrorPacket {
1781 // This really should be a constant size slice, but the spec lets these things be up to 128KB?
1782 // (TODO) We limit it in decode to much lower...
1783 pub(crate) data: Vec<u8>,
1786 impl fmt::Display for DecodeError {
1787 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1789 DecodeError::UnknownVersion => f.write_str("Unknown realm byte in Onion packet"),
1790 DecodeError::UnknownRequiredFeature => f.write_str("Unknown required feature preventing decode"),
1791 DecodeError::InvalidValue => f.write_str("Nonsense bytes didn't map to the type they were interpreted as"),
1792 DecodeError::ShortRead => f.write_str("Packet extended beyond the provided bytes"),
1793 DecodeError::BadLengthDescriptor => f.write_str("A length descriptor in the packet didn't describe the later data correctly"),
1794 DecodeError::Io(ref e) => fmt::Debug::fmt(e, f),
1795 DecodeError::UnsupportedCompression => f.write_str("We don't support receiving messages with zlib-compressed fields"),
1800 impl From<io::Error> for DecodeError {
1801 fn from(e: io::Error) -> Self {
1802 if e.kind() == io::ErrorKind::UnexpectedEof {
1803 DecodeError::ShortRead
1805 DecodeError::Io(e.kind())
1810 #[cfg(not(taproot))]
1811 impl_writeable_msg!(AcceptChannel, {
1812 temporary_channel_id,
1813 dust_limit_satoshis,
1814 max_htlc_value_in_flight_msat,
1815 channel_reserve_satoshis,
1821 revocation_basepoint,
1823 delayed_payment_basepoint,
1825 first_per_commitment_point,
1827 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))), // Don't encode length twice.
1828 (1, channel_type, option),
1832 impl_writeable_msg!(AcceptChannel, {
1833 temporary_channel_id,
1834 dust_limit_satoshis,
1835 max_htlc_value_in_flight_msat,
1836 channel_reserve_satoshis,
1842 revocation_basepoint,
1844 delayed_payment_basepoint,
1846 first_per_commitment_point,
1848 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))), // Don't encode length twice.
1849 (1, channel_type, option),
1850 (4, next_local_nonce, option),
1853 impl_writeable_msg!(AcceptChannelV2, {
1854 temporary_channel_id,
1856 dust_limit_satoshis,
1857 max_htlc_value_in_flight_msat,
1863 revocation_basepoint,
1865 delayed_payment_basepoint,
1867 first_per_commitment_point,
1868 second_per_commitment_point,
1870 (0, shutdown_scriptpubkey, option),
1871 (1, channel_type, option),
1872 (2, require_confirmed_inputs, option),
1875 impl_writeable_msg!(Stfu, {
1880 impl_writeable_msg!(Splice, {
1884 funding_feerate_perkw,
1889 impl_writeable_msg!(SpliceAck, {
1896 impl_writeable_msg!(SpliceLocked, {
1900 impl_writeable_msg!(TxAddInput, {
1908 impl_writeable_msg!(TxAddOutput, {
1915 impl_writeable_msg!(TxRemoveInput, {
1920 impl_writeable_msg!(TxRemoveOutput, {
1925 impl_writeable_msg!(TxComplete, {
1929 impl_writeable_msg!(TxSignatures, {
1935 impl_writeable_msg!(TxInitRbf, {
1938 feerate_sat_per_1000_weight,
1940 (0, funding_output_contribution, option),
1943 impl_writeable_msg!(TxAckRbf, {
1946 (0, funding_output_contribution, option),
1949 impl_writeable_msg!(TxAbort, {
1954 impl_writeable_msg!(AnnouncementSignatures, {
1961 impl_writeable_msg!(ChannelReestablish, {
1963 next_local_commitment_number,
1964 next_remote_commitment_number,
1965 your_last_per_commitment_secret,
1966 my_current_per_commitment_point,
1968 (0, next_funding_txid, option),
1971 impl_writeable_msg!(ClosingSigned,
1972 { channel_id, fee_satoshis, signature },
1973 { (1, fee_range, option) }
1976 impl_writeable!(ClosingSignedFeeRange, {
1981 #[cfg(not(taproot))]
1982 impl_writeable_msg!(CommitmentSigned, {
1989 impl_writeable_msg!(CommitmentSigned, {
1994 (2, partial_signature_with_nonce, option)
1997 impl_writeable!(DecodedOnionErrorPacket, {
2003 #[cfg(not(taproot))]
2004 impl_writeable_msg!(FundingCreated, {
2005 temporary_channel_id,
2007 funding_output_index,
2011 impl_writeable_msg!(FundingCreated, {
2012 temporary_channel_id,
2014 funding_output_index,
2017 (2, partial_signature_with_nonce, option),
2018 (4, next_local_nonce, option)
2021 #[cfg(not(taproot))]
2022 impl_writeable_msg!(FundingSigned, {
2028 impl_writeable_msg!(FundingSigned, {
2032 (2, partial_signature_with_nonce, option)
2035 impl_writeable_msg!(ChannelReady, {
2037 next_per_commitment_point,
2039 (1, short_channel_id_alias, option),
2042 impl Writeable for Init {
2043 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2044 // global_features gets the bottom 13 bits of our features, and local_features gets all of
2045 // our relevant feature bits. This keeps us compatible with old nodes.
2046 self.features.write_up_to_13(w)?;
2047 self.features.write(w)?;
2048 encode_tlv_stream!(w, {
2049 (1, self.networks.as_ref().map(|n| WithoutLength(n)), option),
2050 (3, self.remote_network_address, option),
2056 impl Readable for Init {
2057 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2058 let global_features: InitFeatures = Readable::read(r)?;
2059 let features: InitFeatures = Readable::read(r)?;
2060 let mut remote_network_address: Option<SocketAddress> = None;
2061 let mut networks: Option<WithoutLength<Vec<ChainHash>>> = None;
2062 decode_tlv_stream!(r, {
2063 (1, networks, option),
2064 (3, remote_network_address, option)
2067 features: features | global_features,
2068 networks: networks.map(|n| n.0),
2069 remote_network_address,
2074 impl_writeable_msg!(OpenChannel, {
2076 temporary_channel_id,
2079 dust_limit_satoshis,
2080 max_htlc_value_in_flight_msat,
2081 channel_reserve_satoshis,
2087 revocation_basepoint,
2089 delayed_payment_basepoint,
2091 first_per_commitment_point,
2094 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))), // Don't encode length twice.
2095 (1, channel_type, option),
2098 impl_writeable_msg!(OpenChannelV2, {
2100 temporary_channel_id,
2101 funding_feerate_sat_per_1000_weight,
2102 commitment_feerate_sat_per_1000_weight,
2104 dust_limit_satoshis,
2105 max_htlc_value_in_flight_msat,
2111 revocation_basepoint,
2113 delayed_payment_basepoint,
2115 first_per_commitment_point,
2116 second_per_commitment_point,
2119 (0, shutdown_scriptpubkey, option),
2120 (1, channel_type, option),
2121 (2, require_confirmed_inputs, option),
2124 #[cfg(not(taproot))]
2125 impl_writeable_msg!(RevokeAndACK, {
2127 per_commitment_secret,
2128 next_per_commitment_point
2132 impl_writeable_msg!(RevokeAndACK, {
2134 per_commitment_secret,
2135 next_per_commitment_point
2137 (4, next_local_nonce, option)
2140 impl_writeable_msg!(Shutdown, {
2145 impl_writeable_msg!(UpdateFailHTLC, {
2151 impl_writeable_msg!(UpdateFailMalformedHTLC, {
2158 impl_writeable_msg!(UpdateFee, {
2163 impl_writeable_msg!(UpdateFulfillHTLC, {
2169 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2170 // serialization format in a way which assumes we know the total serialized length/message end
2172 impl_writeable!(OnionErrorPacket, {
2176 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2177 // serialization format in a way which assumes we know the total serialized length/message end
2179 impl Writeable for OnionPacket {
2180 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2181 self.version.write(w)?;
2182 match self.public_key {
2183 Ok(pubkey) => pubkey.write(w)?,
2184 Err(_) => [0u8;33].write(w)?,
2186 w.write_all(&self.hop_data)?;
2187 self.hmac.write(w)?;
2192 impl Readable for OnionPacket {
2193 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2195 version: Readable::read(r)?,
2197 let mut buf = [0u8;33];
2198 r.read_exact(&mut buf)?;
2199 PublicKey::from_slice(&buf)
2201 hop_data: Readable::read(r)?,
2202 hmac: Readable::read(r)?,
2207 impl_writeable_msg!(UpdateAddHTLC, {
2213 onion_routing_packet,
2215 (65537, skimmed_fee_msat, option)
2218 impl Readable for OnionMessage {
2219 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2220 let blinding_point: PublicKey = Readable::read(r)?;
2221 let len: u16 = Readable::read(r)?;
2222 let mut packet_reader = FixedLengthReader::new(r, len as u64);
2223 let onion_routing_packet: onion_message::Packet = <onion_message::Packet as LengthReadable>::read(&mut packet_reader)?;
2226 onion_routing_packet,
2231 impl Writeable for OnionMessage {
2232 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2233 self.blinding_point.write(w)?;
2234 let onion_packet_len = self.onion_routing_packet.serialized_length();
2235 (onion_packet_len as u16).write(w)?;
2236 self.onion_routing_packet.write(w)?;
2241 impl Writeable for FinalOnionHopData {
2242 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2243 self.payment_secret.0.write(w)?;
2244 HighZeroBytesDroppedBigSize(self.total_msat).write(w)
2248 impl Readable for FinalOnionHopData {
2249 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2250 let secret: [u8; 32] = Readable::read(r)?;
2251 let amt: HighZeroBytesDroppedBigSize<u64> = Readable::read(r)?;
2252 Ok(Self { payment_secret: PaymentSecret(secret), total_msat: amt.0 })
2256 impl Writeable for OutboundOnionPayload {
2257 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2259 Self::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } => {
2260 _encode_varint_length_prefixed_tlv!(w, {
2261 (2, HighZeroBytesDroppedBigSize(*amt_to_forward), required),
2262 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2263 (6, short_channel_id, required)
2267 ref payment_data, ref payment_metadata, ref keysend_preimage, amt_msat,
2268 outgoing_cltv_value, ref custom_tlvs,
2270 // We need to update [`ln::outbound_payment::RecipientOnionFields::with_custom_tlvs`]
2271 // to reject any reserved types in the experimental range if new ones are ever
2273 let keysend_tlv = keysend_preimage.map(|preimage| (5482373484, preimage.encode()));
2274 let mut custom_tlvs: Vec<&(u64, Vec<u8>)> = custom_tlvs.iter().chain(keysend_tlv.iter()).collect();
2275 custom_tlvs.sort_unstable_by_key(|(typ, _)| *typ);
2276 _encode_varint_length_prefixed_tlv!(w, {
2277 (2, HighZeroBytesDroppedBigSize(*amt_msat), required),
2278 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2279 (8, payment_data, option),
2280 (16, payment_metadata.as_ref().map(|m| WithoutLength(m)), option)
2281 }, custom_tlvs.iter());
2283 Self::BlindedForward { encrypted_tlvs, intro_node_blinding_point } => {
2284 _encode_varint_length_prefixed_tlv!(w, {
2285 (10, *encrypted_tlvs, required_vec),
2286 (12, intro_node_blinding_point, option)
2289 Self::BlindedReceive {
2290 amt_msat, total_msat, outgoing_cltv_value, encrypted_tlvs,
2291 intro_node_blinding_point,
2293 _encode_varint_length_prefixed_tlv!(w, {
2294 (2, HighZeroBytesDroppedBigSize(*amt_msat), required),
2295 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2296 (10, *encrypted_tlvs, required_vec),
2297 (12, intro_node_blinding_point, option),
2298 (18, HighZeroBytesDroppedBigSize(*total_msat), required)
2306 impl<NS: Deref> ReadableArgs<&NS> for InboundOnionPayload where NS::Target: NodeSigner {
2307 fn read<R: Read>(r: &mut R, node_signer: &NS) -> Result<Self, DecodeError> {
2309 let mut cltv_value = None;
2310 let mut short_id: Option<u64> = None;
2311 let mut payment_data: Option<FinalOnionHopData> = None;
2312 let mut encrypted_tlvs_opt: Option<WithoutLength<Vec<u8>>> = None;
2313 let mut intro_node_blinding_point = None;
2314 let mut payment_metadata: Option<WithoutLength<Vec<u8>>> = None;
2315 let mut total_msat = None;
2316 let mut keysend_preimage: Option<PaymentPreimage> = None;
2317 let mut custom_tlvs = Vec::new();
2319 let tlv_len = BigSize::read(r)?;
2320 let rd = FixedLengthReader::new(r, tlv_len.0);
2321 decode_tlv_stream_with_custom_tlv_decode!(rd, {
2322 (2, amt, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2323 (4, cltv_value, (option, encoding: (u32, HighZeroBytesDroppedBigSize))),
2324 (6, short_id, option),
2325 (8, payment_data, option),
2326 (10, encrypted_tlvs_opt, option),
2327 (12, intro_node_blinding_point, option),
2328 (16, payment_metadata, option),
2329 (18, total_msat, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2330 // See https://github.com/lightning/blips/blob/master/blip-0003.md
2331 (5482373484, keysend_preimage, option)
2332 }, |msg_type: u64, msg_reader: &mut FixedLengthReader<_>| -> Result<bool, DecodeError> {
2333 if msg_type < 1 << 16 { return Ok(false) }
2334 let mut value = Vec::new();
2335 msg_reader.read_to_end(&mut value)?;
2336 custom_tlvs.push((msg_type, value));
2340 if amt.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2342 if let Some(blinding_point) = intro_node_blinding_point {
2343 if short_id.is_some() || payment_data.is_some() || payment_metadata.is_some() {
2344 return Err(DecodeError::InvalidValue)
2346 let enc_tlvs = encrypted_tlvs_opt.ok_or(DecodeError::InvalidValue)?.0;
2347 let enc_tlvs_ss = node_signer.ecdh(Recipient::Node, &blinding_point, None)
2348 .map_err(|_| DecodeError::InvalidValue)?;
2349 let rho = onion_utils::gen_rho_from_shared_secret(&enc_tlvs_ss.secret_bytes());
2350 let mut s = Cursor::new(&enc_tlvs);
2351 let mut reader = FixedLengthReader::new(&mut s, enc_tlvs.len() as u64);
2352 match ChaChaPolyReadAdapter::read(&mut reader, rho)? {
2353 ChaChaPolyReadAdapter { readable: ReceiveTlvs { payment_secret, payment_constraints }} => {
2354 if total_msat.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2355 Ok(Self::BlindedReceive {
2356 amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2357 total_msat: total_msat.ok_or(DecodeError::InvalidValue)?,
2358 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2360 payment_constraints,
2361 intro_node_blinding_point: blinding_point,
2365 } else if let Some(short_channel_id) = short_id {
2366 if payment_data.is_some() || payment_metadata.is_some() || encrypted_tlvs_opt.is_some() ||
2367 total_msat.is_some()
2368 { return Err(DecodeError::InvalidValue) }
2371 amt_to_forward: amt.ok_or(DecodeError::InvalidValue)?,
2372 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2375 if encrypted_tlvs_opt.is_some() || total_msat.is_some() {
2376 return Err(DecodeError::InvalidValue)
2378 if let Some(data) = &payment_data {
2379 if data.total_msat > MAX_VALUE_MSAT {
2380 return Err(DecodeError::InvalidValue);
2385 payment_metadata: payment_metadata.map(|w| w.0),
2387 amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2388 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2395 impl Writeable for Ping {
2396 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2397 self.ponglen.write(w)?;
2398 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2403 impl Readable for Ping {
2404 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2406 ponglen: Readable::read(r)?,
2408 let byteslen = Readable::read(r)?;
2409 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2416 impl Writeable for Pong {
2417 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2418 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2423 impl Readable for Pong {
2424 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2427 let byteslen = Readable::read(r)?;
2428 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2435 impl Writeable for UnsignedChannelAnnouncement {
2436 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2437 self.features.write(w)?;
2438 self.chain_hash.write(w)?;
2439 self.short_channel_id.write(w)?;
2440 self.node_id_1.write(w)?;
2441 self.node_id_2.write(w)?;
2442 self.bitcoin_key_1.write(w)?;
2443 self.bitcoin_key_2.write(w)?;
2444 w.write_all(&self.excess_data[..])?;
2449 impl Readable for UnsignedChannelAnnouncement {
2450 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2452 features: Readable::read(r)?,
2453 chain_hash: Readable::read(r)?,
2454 short_channel_id: Readable::read(r)?,
2455 node_id_1: Readable::read(r)?,
2456 node_id_2: Readable::read(r)?,
2457 bitcoin_key_1: Readable::read(r)?,
2458 bitcoin_key_2: Readable::read(r)?,
2459 excess_data: read_to_end(r)?,
2464 impl_writeable!(ChannelAnnouncement, {
2467 bitcoin_signature_1,
2468 bitcoin_signature_2,
2472 impl Writeable for UnsignedChannelUpdate {
2473 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2474 // `message_flags` used to indicate presence of `htlc_maximum_msat`, but was deprecated in the spec.
2475 const MESSAGE_FLAGS: u8 = 1;
2476 self.chain_hash.write(w)?;
2477 self.short_channel_id.write(w)?;
2478 self.timestamp.write(w)?;
2479 let all_flags = self.flags as u16 | ((MESSAGE_FLAGS as u16) << 8);
2480 all_flags.write(w)?;
2481 self.cltv_expiry_delta.write(w)?;
2482 self.htlc_minimum_msat.write(w)?;
2483 self.fee_base_msat.write(w)?;
2484 self.fee_proportional_millionths.write(w)?;
2485 self.htlc_maximum_msat.write(w)?;
2486 w.write_all(&self.excess_data[..])?;
2491 impl Readable for UnsignedChannelUpdate {
2492 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2494 chain_hash: Readable::read(r)?,
2495 short_channel_id: Readable::read(r)?,
2496 timestamp: Readable::read(r)?,
2498 let flags: u16 = Readable::read(r)?;
2499 // Note: we ignore the `message_flags` for now, since it was deprecated by the spec.
2502 cltv_expiry_delta: Readable::read(r)?,
2503 htlc_minimum_msat: Readable::read(r)?,
2504 fee_base_msat: Readable::read(r)?,
2505 fee_proportional_millionths: Readable::read(r)?,
2506 htlc_maximum_msat: Readable::read(r)?,
2507 excess_data: read_to_end(r)?,
2512 impl_writeable!(ChannelUpdate, {
2517 impl Writeable for ErrorMessage {
2518 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2519 self.channel_id.write(w)?;
2520 (self.data.len() as u16).write(w)?;
2521 w.write_all(self.data.as_bytes())?;
2526 impl Readable for ErrorMessage {
2527 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2529 channel_id: Readable::read(r)?,
2531 let sz: usize = <u16 as Readable>::read(r)? as usize;
2532 let mut data = Vec::with_capacity(sz);
2534 r.read_exact(&mut data)?;
2535 match String::from_utf8(data) {
2537 Err(_) => return Err(DecodeError::InvalidValue),
2544 impl Writeable for WarningMessage {
2545 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2546 self.channel_id.write(w)?;
2547 (self.data.len() as u16).write(w)?;
2548 w.write_all(self.data.as_bytes())?;
2553 impl Readable for WarningMessage {
2554 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2556 channel_id: Readable::read(r)?,
2558 let sz: usize = <u16 as Readable>::read(r)? as usize;
2559 let mut data = Vec::with_capacity(sz);
2561 r.read_exact(&mut data)?;
2562 match String::from_utf8(data) {
2564 Err(_) => return Err(DecodeError::InvalidValue),
2571 impl Writeable for UnsignedNodeAnnouncement {
2572 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2573 self.features.write(w)?;
2574 self.timestamp.write(w)?;
2575 self.node_id.write(w)?;
2576 w.write_all(&self.rgb)?;
2577 self.alias.write(w)?;
2579 let mut addr_len = 0;
2580 for addr in self.addresses.iter() {
2581 addr_len += 1 + addr.len();
2583 (addr_len + self.excess_address_data.len() as u16).write(w)?;
2584 for addr in self.addresses.iter() {
2587 w.write_all(&self.excess_address_data[..])?;
2588 w.write_all(&self.excess_data[..])?;
2593 impl Readable for UnsignedNodeAnnouncement {
2594 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2595 let features: NodeFeatures = Readable::read(r)?;
2596 let timestamp: u32 = Readable::read(r)?;
2597 let node_id: NodeId = Readable::read(r)?;
2598 let mut rgb = [0; 3];
2599 r.read_exact(&mut rgb)?;
2600 let alias: NodeAlias = Readable::read(r)?;
2602 let addr_len: u16 = Readable::read(r)?;
2603 let mut addresses: Vec<SocketAddress> = Vec::new();
2604 let mut addr_readpos = 0;
2605 let mut excess = false;
2606 let mut excess_byte = 0;
2608 if addr_len <= addr_readpos { break; }
2609 match Readable::read(r) {
2611 if addr_len < addr_readpos + 1 + addr.len() {
2612 return Err(DecodeError::BadLengthDescriptor);
2614 addr_readpos += (1 + addr.len()) as u16;
2615 addresses.push(addr);
2617 Ok(Err(unknown_descriptor)) => {
2619 excess_byte = unknown_descriptor;
2622 Err(DecodeError::ShortRead) => return Err(DecodeError::BadLengthDescriptor),
2623 Err(e) => return Err(e),
2627 let mut excess_data = vec![];
2628 let excess_address_data = if addr_readpos < addr_len {
2629 let mut excess_address_data = vec![0; (addr_len - addr_readpos) as usize];
2630 r.read_exact(&mut excess_address_data[if excess { 1 } else { 0 }..])?;
2632 excess_address_data[0] = excess_byte;
2637 excess_data.push(excess_byte);
2641 excess_data.extend(read_to_end(r)?.iter());
2642 Ok(UnsignedNodeAnnouncement {
2649 excess_address_data,
2655 impl_writeable!(NodeAnnouncement, {
2660 impl Readable for QueryShortChannelIds {
2661 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2662 let chain_hash: ChainHash = Readable::read(r)?;
2664 let encoding_len: u16 = Readable::read(r)?;
2665 let encoding_type: u8 = Readable::read(r)?;
2667 // Must be encoding_type=0 uncompressed serialization. We do not
2668 // support encoding_type=1 zlib serialization.
2669 if encoding_type != EncodingType::Uncompressed as u8 {
2670 return Err(DecodeError::UnsupportedCompression);
2673 // We expect the encoding_len to always includes the 1-byte
2674 // encoding_type and that short_channel_ids are 8-bytes each
2675 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2676 return Err(DecodeError::InvalidValue);
2679 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2680 // less the 1-byte encoding_type
2681 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2682 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2683 for _ in 0..short_channel_id_count {
2684 short_channel_ids.push(Readable::read(r)?);
2687 Ok(QueryShortChannelIds {
2694 impl Writeable for QueryShortChannelIds {
2695 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2696 // Calculated from 1-byte encoding_type plus 8-bytes per short_channel_id
2697 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2699 self.chain_hash.write(w)?;
2700 encoding_len.write(w)?;
2702 // We only support type=0 uncompressed serialization
2703 (EncodingType::Uncompressed as u8).write(w)?;
2705 for scid in self.short_channel_ids.iter() {
2713 impl_writeable_msg!(ReplyShortChannelIdsEnd, {
2718 impl QueryChannelRange {
2719 /// Calculates the overflow safe ending block height for the query.
2721 /// Overflow returns `0xffffffff`, otherwise returns `first_blocknum + number_of_blocks`.
2722 pub fn end_blocknum(&self) -> u32 {
2723 match self.first_blocknum.checked_add(self.number_of_blocks) {
2724 Some(block) => block,
2725 None => u32::max_value(),
2730 impl_writeable_msg!(QueryChannelRange, {
2736 impl Readable for ReplyChannelRange {
2737 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2738 let chain_hash: ChainHash = Readable::read(r)?;
2739 let first_blocknum: u32 = Readable::read(r)?;
2740 let number_of_blocks: u32 = Readable::read(r)?;
2741 let sync_complete: bool = Readable::read(r)?;
2743 let encoding_len: u16 = Readable::read(r)?;
2744 let encoding_type: u8 = Readable::read(r)?;
2746 // Must be encoding_type=0 uncompressed serialization. We do not
2747 // support encoding_type=1 zlib serialization.
2748 if encoding_type != EncodingType::Uncompressed as u8 {
2749 return Err(DecodeError::UnsupportedCompression);
2752 // We expect the encoding_len to always includes the 1-byte
2753 // encoding_type and that short_channel_ids are 8-bytes each
2754 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2755 return Err(DecodeError::InvalidValue);
2758 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2759 // less the 1-byte encoding_type
2760 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2761 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2762 for _ in 0..short_channel_id_count {
2763 short_channel_ids.push(Readable::read(r)?);
2766 Ok(ReplyChannelRange {
2776 impl Writeable for ReplyChannelRange {
2777 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2778 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2779 self.chain_hash.write(w)?;
2780 self.first_blocknum.write(w)?;
2781 self.number_of_blocks.write(w)?;
2782 self.sync_complete.write(w)?;
2784 encoding_len.write(w)?;
2785 (EncodingType::Uncompressed as u8).write(w)?;
2786 for scid in self.short_channel_ids.iter() {
2794 impl_writeable_msg!(GossipTimestampFilter, {
2802 use std::convert::TryFrom;
2803 use bitcoin::{Transaction, TxIn, ScriptBuf, Sequence, Witness, TxOut};
2804 use hex::DisplayHex;
2805 use crate::ln::{PaymentPreimage, PaymentHash, PaymentSecret};
2806 use crate::ln::ChannelId;
2807 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
2808 use crate::ln::msgs::{self, FinalOnionHopData, OnionErrorPacket};
2809 use crate::ln::msgs::SocketAddress;
2810 use crate::routing::gossip::{NodeAlias, NodeId};
2811 use crate::util::ser::{Writeable, Readable, ReadableArgs, Hostname, TransactionU16LenLimited};
2812 use crate::util::test_utils;
2814 use bitcoin::hashes::hex::FromHex;
2815 use bitcoin::address::Address;
2816 use bitcoin::network::constants::Network;
2817 use bitcoin::blockdata::constants::ChainHash;
2818 use bitcoin::blockdata::script::Builder;
2819 use bitcoin::blockdata::opcodes;
2820 use bitcoin::hash_types::Txid;
2821 use bitcoin::locktime::absolute::LockTime;
2823 use bitcoin::secp256k1::{PublicKey,SecretKey};
2824 use bitcoin::secp256k1::{Secp256k1, Message};
2826 use crate::io::{self, Cursor};
2827 use crate::prelude::*;
2828 use core::str::FromStr;
2829 use crate::chain::transaction::OutPoint;
2831 #[cfg(feature = "std")]
2832 use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6, ToSocketAddrs};
2833 #[cfg(feature = "std")]
2834 use crate::ln::msgs::SocketAddressParseError;
2837 fn encoding_channel_reestablish() {
2839 let secp_ctx = Secp256k1::new();
2840 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&<Vec<u8>>::from_hex("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2843 let cr = msgs::ChannelReestablish {
2844 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]),
2845 next_local_commitment_number: 3,
2846 next_remote_commitment_number: 4,
2847 your_last_per_commitment_secret: [9;32],
2848 my_current_per_commitment_point: public_key,
2849 next_funding_txid: None,
2852 let encoded_value = cr.encode();
2856 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
2857 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2858 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2859 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
2860 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
2866 fn encoding_channel_reestablish_with_next_funding_txid() {
2868 let secp_ctx = Secp256k1::new();
2869 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&<Vec<u8>>::from_hex("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2872 let cr = msgs::ChannelReestablish {
2873 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]),
2874 next_local_commitment_number: 3,
2875 next_remote_commitment_number: 4,
2876 your_last_per_commitment_secret: [9;32],
2877 my_current_per_commitment_point: public_key,
2878 next_funding_txid: Some(Txid::from_raw_hash(bitcoin::hashes::Hash::from_slice(&[
2879 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,
2883 let encoded_value = cr.encode();
2887 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
2888 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2889 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2890 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
2891 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
2892 0, // Type (next_funding_txid)
2894 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
2899 macro_rules! get_keys_from {
2900 ($slice: expr, $secp_ctx: expr) => {
2902 let privkey = SecretKey::from_slice(&<Vec<u8>>::from_hex($slice).unwrap()[..]).unwrap();
2903 let pubkey = PublicKey::from_secret_key(&$secp_ctx, &privkey);
2909 macro_rules! get_sig_on {
2910 ($privkey: expr, $ctx: expr, $string: expr) => {
2912 let sighash = Message::from_slice(&$string.into_bytes()[..]).unwrap();
2913 $ctx.sign_ecdsa(&sighash, &$privkey)
2919 fn encoding_announcement_signatures() {
2920 let secp_ctx = Secp256k1::new();
2921 let (privkey, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2922 let sig_1 = get_sig_on!(privkey, secp_ctx, String::from("01010101010101010101010101010101"));
2923 let sig_2 = get_sig_on!(privkey, secp_ctx, String::from("02020202020202020202020202020202"));
2924 let announcement_signatures = msgs::AnnouncementSignatures {
2925 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]),
2926 short_channel_id: 2316138423780173,
2927 node_signature: sig_1,
2928 bitcoin_signature: sig_2,
2931 let encoded_value = announcement_signatures.encode();
2932 assert_eq!(encoded_value, <Vec<u8>>::from_hex("040000000000000005000000000000000600000000000000070000000000000000083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073acf9953cef4700860f5967838eba2bae89288ad188ebf8b20bf995c3ea53a26df1876d0a3a0e13172ba286a673140190c02ba9da60a2e43a745188c8a83c7f3ef").unwrap());
2935 fn do_encoding_channel_announcement(unknown_features_bits: bool, excess_data: bool) {
2936 let secp_ctx = Secp256k1::new();
2937 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2938 let (privkey_2, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2939 let (privkey_3, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2940 let (privkey_4, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2941 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2942 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
2943 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
2944 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
2945 let mut features = ChannelFeatures::empty();
2946 if unknown_features_bits {
2947 features = ChannelFeatures::from_le_bytes(vec![0xFF, 0xFF]);
2949 let unsigned_channel_announcement = msgs::UnsignedChannelAnnouncement {
2951 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
2952 short_channel_id: 2316138423780173,
2953 node_id_1: NodeId::from_pubkey(&pubkey_1),
2954 node_id_2: NodeId::from_pubkey(&pubkey_2),
2955 bitcoin_key_1: NodeId::from_pubkey(&pubkey_3),
2956 bitcoin_key_2: NodeId::from_pubkey(&pubkey_4),
2957 excess_data: if excess_data { vec![10, 0, 0, 20, 0, 0, 30, 0, 0, 40] } else { Vec::new() },
2959 let channel_announcement = msgs::ChannelAnnouncement {
2960 node_signature_1: sig_1,
2961 node_signature_2: sig_2,
2962 bitcoin_signature_1: sig_3,
2963 bitcoin_signature_2: sig_4,
2964 contents: unsigned_channel_announcement,
2966 let encoded_value = channel_announcement.encode();
2967 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a1735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap();
2968 if unknown_features_bits {
2969 target_value.append(&mut <Vec<u8>>::from_hex("0002ffff").unwrap());
2971 target_value.append(&mut <Vec<u8>>::from_hex("0000").unwrap());
2973 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
2974 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
2976 target_value.append(&mut <Vec<u8>>::from_hex("0a00001400001e000028").unwrap());
2978 assert_eq!(encoded_value, target_value);
2982 fn encoding_channel_announcement() {
2983 do_encoding_channel_announcement(true, false);
2984 do_encoding_channel_announcement(false, true);
2985 do_encoding_channel_announcement(false, false);
2986 do_encoding_channel_announcement(true, true);
2989 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) {
2990 let secp_ctx = Secp256k1::new();
2991 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2992 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2993 let features = if unknown_features_bits {
2994 NodeFeatures::from_le_bytes(vec![0xFF, 0xFF])
2996 // Set to some features we may support
2997 NodeFeatures::from_le_bytes(vec![2 | 1 << 5])
2999 let mut addresses = Vec::new();
3001 addresses.push(SocketAddress::TcpIpV4 {
3002 addr: [255, 254, 253, 252],
3007 addresses.push(SocketAddress::TcpIpV6 {
3008 addr: [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240],
3013 addresses.push(msgs::SocketAddress::OnionV2(
3014 [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 38, 7]
3018 addresses.push(msgs::SocketAddress::OnionV3 {
3019 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],
3026 addresses.push(SocketAddress::Hostname {
3027 hostname: Hostname::try_from(String::from("host")).unwrap(),
3031 let mut addr_len = 0;
3032 for addr in &addresses {
3033 addr_len += addr.len() + 1;
3035 let unsigned_node_announcement = msgs::UnsignedNodeAnnouncement {
3037 timestamp: 20190119,
3038 node_id: NodeId::from_pubkey(&pubkey_1),
3040 alias: NodeAlias([16;32]),
3042 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() },
3043 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() },
3045 addr_len += unsigned_node_announcement.excess_address_data.len() as u16;
3046 let node_announcement = msgs::NodeAnnouncement {
3048 contents: unsigned_node_announcement,
3050 let encoded_value = node_announcement.encode();
3051 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3052 if unknown_features_bits {
3053 target_value.append(&mut <Vec<u8>>::from_hex("0002ffff").unwrap());
3055 target_value.append(&mut <Vec<u8>>::from_hex("000122").unwrap());
3057 target_value.append(&mut <Vec<u8>>::from_hex("013413a7031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f2020201010101010101010101010101010101010101010101010101010101010101010").unwrap());
3058 target_value.append(&mut vec![(addr_len >> 8) as u8, addr_len as u8]);
3060 target_value.append(&mut <Vec<u8>>::from_hex("01fffefdfc2607").unwrap());
3063 target_value.append(&mut <Vec<u8>>::from_hex("02fffefdfcfbfaf9f8f7f6f5f4f3f2f1f02607").unwrap());
3066 target_value.append(&mut <Vec<u8>>::from_hex("03fffefdfcfbfaf9f8f7f62607").unwrap());
3069 target_value.append(&mut <Vec<u8>>::from_hex("04fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0efeeedecebeae9e8e7e6e5e4e3e2e1e00020102607").unwrap());
3072 target_value.append(&mut <Vec<u8>>::from_hex("0504686f73742607").unwrap());
3074 if excess_address_data {
3075 target_value.append(&mut <Vec<u8>>::from_hex("216c280b5395a2546e7e4b2663e04f811622f15a4f92e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d269").unwrap());
3078 target_value.append(&mut <Vec<u8>>::from_hex("3b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
3080 assert_eq!(encoded_value, target_value);
3084 fn encoding_node_announcement() {
3085 do_encoding_node_announcement(true, true, true, true, true, true, true, true);
3086 do_encoding_node_announcement(false, false, false, false, false, false, false, false);
3087 do_encoding_node_announcement(false, true, false, false, false, false, false, false);
3088 do_encoding_node_announcement(false, false, true, false, false, false, false, false);
3089 do_encoding_node_announcement(false, false, false, true, false, false, false, false);
3090 do_encoding_node_announcement(false, false, false, false, true, false, false, false);
3091 do_encoding_node_announcement(false, false, false, false, false, true, false, false);
3092 do_encoding_node_announcement(false, false, false, false, false, false, true, false);
3093 do_encoding_node_announcement(false, true, false, true, false, false, true, false);
3094 do_encoding_node_announcement(false, false, true, false, true, false, false, false);
3097 fn do_encoding_channel_update(direction: bool, disable: bool, excess_data: bool) {
3098 let secp_ctx = Secp256k1::new();
3099 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3100 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3101 let unsigned_channel_update = msgs::UnsignedChannelUpdate {
3102 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3103 short_channel_id: 2316138423780173,
3104 timestamp: 20190119,
3105 flags: if direction { 1 } else { 0 } | if disable { 1 << 1 } else { 0 },
3106 cltv_expiry_delta: 144,
3107 htlc_minimum_msat: 1000000,
3108 htlc_maximum_msat: 131355275467161,
3109 fee_base_msat: 10000,
3110 fee_proportional_millionths: 20,
3111 excess_data: if excess_data { vec![0, 0, 0, 0, 59, 154, 202, 0] } else { Vec::new() }
3113 let channel_update = msgs::ChannelUpdate {
3115 contents: unsigned_channel_update
3117 let encoded_value = channel_update.encode();
3118 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3119 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3120 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d013413a7").unwrap());
3121 target_value.append(&mut <Vec<u8>>::from_hex("01").unwrap());
3122 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3124 let flag = target_value.last_mut().unwrap();
3128 let flag = target_value.last_mut().unwrap();
3129 *flag = *flag | 1 << 1;
3131 target_value.append(&mut <Vec<u8>>::from_hex("009000000000000f42400000271000000014").unwrap());
3132 target_value.append(&mut <Vec<u8>>::from_hex("0000777788889999").unwrap());
3134 target_value.append(&mut <Vec<u8>>::from_hex("000000003b9aca00").unwrap());
3136 assert_eq!(encoded_value, target_value);
3140 fn encoding_channel_update() {
3141 do_encoding_channel_update(false, false, false);
3142 do_encoding_channel_update(false, false, true);
3143 do_encoding_channel_update(true, false, false);
3144 do_encoding_channel_update(true, false, true);
3145 do_encoding_channel_update(false, true, false);
3146 do_encoding_channel_update(false, true, true);
3147 do_encoding_channel_update(true, true, false);
3148 do_encoding_channel_update(true, true, true);
3151 fn do_encoding_open_channel(random_bit: bool, shutdown: bool, incl_chan_type: bool) {
3152 let secp_ctx = Secp256k1::new();
3153 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3154 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3155 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3156 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3157 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3158 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3159 let open_channel = msgs::OpenChannel {
3160 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3161 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3162 funding_satoshis: 1311768467284833366,
3163 push_msat: 2536655962884945560,
3164 dust_limit_satoshis: 3608586615801332854,
3165 max_htlc_value_in_flight_msat: 8517154655701053848,
3166 channel_reserve_satoshis: 8665828695742877976,
3167 htlc_minimum_msat: 2316138423780173,
3168 feerate_per_kw: 821716,
3169 to_self_delay: 49340,
3170 max_accepted_htlcs: 49340,
3171 funding_pubkey: pubkey_1,
3172 revocation_basepoint: pubkey_2,
3173 payment_point: pubkey_3,
3174 delayed_payment_basepoint: pubkey_4,
3175 htlc_basepoint: pubkey_5,
3176 first_per_commitment_point: pubkey_6,
3177 channel_flags: if random_bit { 1 << 5 } else { 0 },
3178 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3179 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3181 let encoded_value = open_channel.encode();
3182 let mut target_value = Vec::new();
3183 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3184 target_value.append(&mut <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202021234567890123456233403289122369832144668701144767633030896203198784335490624111800083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3186 target_value.append(&mut <Vec<u8>>::from_hex("20").unwrap());
3188 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3191 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3194 target_value.append(&mut <Vec<u8>>::from_hex("0100").unwrap());
3196 assert_eq!(encoded_value, target_value);
3200 fn encoding_open_channel() {
3201 do_encoding_open_channel(false, false, false);
3202 do_encoding_open_channel(false, false, true);
3203 do_encoding_open_channel(false, true, false);
3204 do_encoding_open_channel(false, true, true);
3205 do_encoding_open_channel(true, false, false);
3206 do_encoding_open_channel(true, false, true);
3207 do_encoding_open_channel(true, true, false);
3208 do_encoding_open_channel(true, true, true);
3211 fn do_encoding_open_channelv2(random_bit: bool, shutdown: bool, incl_chan_type: bool, require_confirmed_inputs: bool) {
3212 let secp_ctx = Secp256k1::new();
3213 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3214 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3215 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3216 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3217 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3218 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3219 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3220 let open_channelv2 = msgs::OpenChannelV2 {
3221 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3222 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3223 funding_feerate_sat_per_1000_weight: 821716,
3224 commitment_feerate_sat_per_1000_weight: 821716,
3225 funding_satoshis: 1311768467284833366,
3226 dust_limit_satoshis: 3608586615801332854,
3227 max_htlc_value_in_flight_msat: 8517154655701053848,
3228 htlc_minimum_msat: 2316138423780173,
3229 to_self_delay: 49340,
3230 max_accepted_htlcs: 49340,
3231 locktime: 305419896,
3232 funding_pubkey: pubkey_1,
3233 revocation_basepoint: pubkey_2,
3234 payment_basepoint: pubkey_3,
3235 delayed_payment_basepoint: pubkey_4,
3236 htlc_basepoint: pubkey_5,
3237 first_per_commitment_point: pubkey_6,
3238 second_per_commitment_point: pubkey_7,
3239 channel_flags: if random_bit { 1 << 5 } else { 0 },
3240 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3241 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3242 require_confirmed_inputs: if require_confirmed_inputs { Some(()) } else { None },
3244 let encoded_value = open_channelv2.encode();
3245 let mut target_value = Vec::new();
3246 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3247 target_value.append(&mut <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap());
3248 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap());
3249 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap());
3250 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap());
3251 target_value.append(&mut <Vec<u8>>::from_hex("3214466870114476").unwrap());
3252 target_value.append(&mut <Vec<u8>>::from_hex("7633030896203198").unwrap());
3253 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d").unwrap());
3254 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap());
3255 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap());
3256 target_value.append(&mut <Vec<u8>>::from_hex("12345678").unwrap());
3257 target_value.append(&mut <Vec<u8>>::from_hex("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap());
3258 target_value.append(&mut <Vec<u8>>::from_hex("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap());
3259 target_value.append(&mut <Vec<u8>>::from_hex("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap());
3260 target_value.append(&mut <Vec<u8>>::from_hex("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
3261 target_value.append(&mut <Vec<u8>>::from_hex("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap());
3262 target_value.append(&mut <Vec<u8>>::from_hex("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3263 target_value.append(&mut <Vec<u8>>::from_hex("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap());
3266 target_value.append(&mut <Vec<u8>>::from_hex("20").unwrap());
3268 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3271 target_value.append(&mut <Vec<u8>>::from_hex("001b").unwrap()); // Type 0 + Length 27
3272 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3275 target_value.append(&mut <Vec<u8>>::from_hex("0100").unwrap());
3277 if require_confirmed_inputs {
3278 target_value.append(&mut <Vec<u8>>::from_hex("0200").unwrap());
3280 assert_eq!(encoded_value, target_value);
3284 fn encoding_open_channelv2() {
3285 do_encoding_open_channelv2(false, false, false, false);
3286 do_encoding_open_channelv2(false, false, false, true);
3287 do_encoding_open_channelv2(false, false, true, false);
3288 do_encoding_open_channelv2(false, false, true, true);
3289 do_encoding_open_channelv2(false, true, false, false);
3290 do_encoding_open_channelv2(false, true, false, true);
3291 do_encoding_open_channelv2(false, true, true, false);
3292 do_encoding_open_channelv2(false, true, true, true);
3293 do_encoding_open_channelv2(true, false, false, false);
3294 do_encoding_open_channelv2(true, false, false, true);
3295 do_encoding_open_channelv2(true, false, true, false);
3296 do_encoding_open_channelv2(true, false, true, true);
3297 do_encoding_open_channelv2(true, true, false, false);
3298 do_encoding_open_channelv2(true, true, false, true);
3299 do_encoding_open_channelv2(true, true, true, false);
3300 do_encoding_open_channelv2(true, true, true, true);
3303 fn do_encoding_accept_channel(shutdown: bool) {
3304 let secp_ctx = Secp256k1::new();
3305 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3306 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3307 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3308 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3309 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3310 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3311 let accept_channel = msgs::AcceptChannel {
3312 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3313 dust_limit_satoshis: 1311768467284833366,
3314 max_htlc_value_in_flight_msat: 2536655962884945560,
3315 channel_reserve_satoshis: 3608586615801332854,
3316 htlc_minimum_msat: 2316138423780173,
3317 minimum_depth: 821716,
3318 to_self_delay: 49340,
3319 max_accepted_htlcs: 49340,
3320 funding_pubkey: pubkey_1,
3321 revocation_basepoint: pubkey_2,
3322 payment_point: pubkey_3,
3323 delayed_payment_basepoint: pubkey_4,
3324 htlc_basepoint: pubkey_5,
3325 first_per_commitment_point: pubkey_6,
3326 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3329 next_local_nonce: None,
3331 let encoded_value = accept_channel.encode();
3332 let mut target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020212345678901234562334032891223698321446687011447600083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap();
3334 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3336 assert_eq!(encoded_value, target_value);
3340 fn encoding_accept_channel() {
3341 do_encoding_accept_channel(false);
3342 do_encoding_accept_channel(true);
3345 fn do_encoding_accept_channelv2(shutdown: bool) {
3346 let secp_ctx = Secp256k1::new();
3347 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3348 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3349 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3350 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3351 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3352 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3353 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3354 let accept_channelv2 = msgs::AcceptChannelV2 {
3355 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3356 funding_satoshis: 1311768467284833366,
3357 dust_limit_satoshis: 1311768467284833366,
3358 max_htlc_value_in_flight_msat: 2536655962884945560,
3359 htlc_minimum_msat: 2316138423780173,
3360 minimum_depth: 821716,
3361 to_self_delay: 49340,
3362 max_accepted_htlcs: 49340,
3363 funding_pubkey: pubkey_1,
3364 revocation_basepoint: pubkey_2,
3365 payment_basepoint: pubkey_3,
3366 delayed_payment_basepoint: pubkey_4,
3367 htlc_basepoint: pubkey_5,
3368 first_per_commitment_point: pubkey_6,
3369 second_per_commitment_point: pubkey_7,
3370 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3372 require_confirmed_inputs: None,
3374 let encoded_value = accept_channelv2.encode();
3375 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // temporary_channel_id
3376 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap()); // funding_satoshis
3377 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap()); // dust_limit_satoshis
3378 target_value.append(&mut <Vec<u8>>::from_hex("2334032891223698").unwrap()); // max_htlc_value_in_flight_msat
3379 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d").unwrap()); // htlc_minimum_msat
3380 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap()); // minimum_depth
3381 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap()); // to_self_delay
3382 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap()); // max_accepted_htlcs
3383 target_value.append(&mut <Vec<u8>>::from_hex("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap()); // funding_pubkey
3384 target_value.append(&mut <Vec<u8>>::from_hex("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap()); // revocation_basepoint
3385 target_value.append(&mut <Vec<u8>>::from_hex("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap()); // payment_basepoint
3386 target_value.append(&mut <Vec<u8>>::from_hex("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap()); // delayed_payment_basepoint
3387 target_value.append(&mut <Vec<u8>>::from_hex("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap()); // htlc_basepoint
3388 target_value.append(&mut <Vec<u8>>::from_hex("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap()); // first_per_commitment_point
3389 target_value.append(&mut <Vec<u8>>::from_hex("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap()); // second_per_commitment_point
3391 target_value.append(&mut <Vec<u8>>::from_hex("001b").unwrap()); // Type 0 + Length 27
3392 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3394 assert_eq!(encoded_value, target_value);
3398 fn encoding_accept_channelv2() {
3399 do_encoding_accept_channelv2(false);
3400 do_encoding_accept_channelv2(true);
3404 fn encoding_funding_created() {
3405 let secp_ctx = Secp256k1::new();
3406 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3407 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3408 let funding_created = msgs::FundingCreated {
3409 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3410 funding_txid: Txid::from_str("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3411 funding_output_index: 255,
3414 partial_signature_with_nonce: None,
3416 next_local_nonce: None,
3418 let encoded_value = funding_created.encode();
3419 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202026e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c200ffd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3420 assert_eq!(encoded_value, target_value);
3424 fn encoding_funding_signed() {
3425 let secp_ctx = Secp256k1::new();
3426 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3427 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3428 let funding_signed = msgs::FundingSigned {
3429 channel_id: ChannelId::from_bytes([2; 32]),
3432 partial_signature_with_nonce: None,
3434 let encoded_value = funding_signed.encode();
3435 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3436 assert_eq!(encoded_value, target_value);
3440 fn encoding_channel_ready() {
3441 let secp_ctx = Secp256k1::new();
3442 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3443 let channel_ready = msgs::ChannelReady {
3444 channel_id: ChannelId::from_bytes([2; 32]),
3445 next_per_commitment_point: pubkey_1,
3446 short_channel_id_alias: None,
3448 let encoded_value = channel_ready.encode();
3449 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3450 assert_eq!(encoded_value, target_value);
3454 fn encoding_splice() {
3455 let secp_ctx = Secp256k1::new();
3456 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3457 let splice = msgs::Splice {
3458 chain_hash: ChainHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
3459 channel_id: ChannelId::from_bytes([2; 32]),
3460 relative_satoshis: 123456,
3461 funding_feerate_perkw: 2000,
3463 funding_pubkey: pubkey_1,
3465 let encoded_value = splice.encode();
3466 assert_eq!(encoded_value.as_hex().to_string(), "02020202020202020202020202020202020202020202020202020202020202026fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000000000000001e240000007d000000000031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f");
3470 fn encoding_stfu() {
3471 let stfu = msgs::Stfu {
3472 channel_id: ChannelId::from_bytes([2; 32]),
3475 let encoded_value = stfu.encode();
3476 assert_eq!(encoded_value.as_hex().to_string(), "020202020202020202020202020202020202020202020202020202020202020201");
3480 fn encoding_splice_ack() {
3481 let secp_ctx = Secp256k1::new();
3482 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3483 let splice = msgs::SpliceAck {
3484 chain_hash: ChainHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
3485 channel_id: ChannelId::from_bytes([2; 32]),
3486 relative_satoshis: 123456,
3487 funding_pubkey: pubkey_1,
3489 let encoded_value = splice.encode();
3490 assert_eq!(encoded_value.as_hex().to_string(), "02020202020202020202020202020202020202020202020202020202020202026fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000000000000001e240031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f");
3494 fn encoding_splice_locked() {
3495 let splice = msgs::SpliceLocked {
3496 channel_id: ChannelId::from_bytes([2; 32]),
3498 let encoded_value = splice.encode();
3499 assert_eq!(encoded_value.as_hex().to_string(), "0202020202020202020202020202020202020202020202020202020202020202");
3503 fn encoding_tx_add_input() {
3504 let tx_add_input = msgs::TxAddInput {
3505 channel_id: ChannelId::from_bytes([2; 32]),
3506 serial_id: 4886718345,
3507 prevtx: TransactionU16LenLimited::new(Transaction {
3509 lock_time: LockTime::ZERO,
3511 previous_output: OutPoint { txid: Txid::from_str("305bab643ee297b8b6b76b320792c8223d55082122cb606bf89382146ced9c77").unwrap(), index: 2 }.into_bitcoin_outpoint(),
3512 script_sig: ScriptBuf::new(),
3513 sequence: Sequence(0xfffffffd),
3514 witness: Witness::from_slice(&vec![
3515 <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3516 <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3521 script_pubkey: Address::from_str("bc1qzlffunw52jav8vwdu5x3jfk6sr8u22rmq3xzw2").unwrap().payload.script_pubkey(),
3525 script_pubkey: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().payload.script_pubkey(),
3529 prevtx_out: 305419896,
3530 sequence: 305419896,
3532 let encoded_value = tx_add_input.encode();
3533 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000000012345678900de02000000000101779ced6c148293f86b60cb222108553d22c89207326bb7b6b897e23e64ab5b300200000000fdffffff0236dbc1000000000016001417d29e4dd454bac3b1cde50d1926da80cfc5287b9cbd03000000000016001436ec78d514df462da95e6a00c24daa8915362d420247304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701210301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944000000001234567812345678").unwrap();
3534 assert_eq!(encoded_value, target_value);
3538 fn encoding_tx_add_output() {
3539 let tx_add_output = msgs::TxAddOutput {
3540 channel_id: ChannelId::from_bytes([2; 32]),
3541 serial_id: 4886718345,
3543 script: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().payload.script_pubkey(),
3545 let encoded_value = tx_add_output.encode();
3546 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000000012345678900000001234567890016001436ec78d514df462da95e6a00c24daa8915362d42").unwrap();
3547 assert_eq!(encoded_value, target_value);
3551 fn encoding_tx_remove_input() {
3552 let tx_remove_input = msgs::TxRemoveInput {
3553 channel_id: ChannelId::from_bytes([2; 32]),
3554 serial_id: 4886718345,
3556 let encoded_value = tx_remove_input.encode();
3557 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3558 assert_eq!(encoded_value, target_value);
3562 fn encoding_tx_remove_output() {
3563 let tx_remove_output = msgs::TxRemoveOutput {
3564 channel_id: ChannelId::from_bytes([2; 32]),
3565 serial_id: 4886718345,
3567 let encoded_value = tx_remove_output.encode();
3568 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3569 assert_eq!(encoded_value, target_value);
3573 fn encoding_tx_complete() {
3574 let tx_complete = msgs::TxComplete {
3575 channel_id: ChannelId::from_bytes([2; 32]),
3577 let encoded_value = tx_complete.encode();
3578 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3579 assert_eq!(encoded_value, target_value);
3583 fn encoding_tx_signatures() {
3584 let tx_signatures = msgs::TxSignatures {
3585 channel_id: ChannelId::from_bytes([2; 32]),
3586 tx_hash: Txid::from_str("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3588 Witness::from_slice(&vec![
3589 <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3590 <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3591 Witness::from_slice(&vec![
3592 <Vec<u8>>::from_hex("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap(),
3593 <Vec<u8>>::from_hex("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap()]),
3596 let encoded_value = tx_signatures.encode();
3597 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3598 target_value.append(&mut <Vec<u8>>::from_hex("6e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c2").unwrap()); // tx_hash (sha256) (big endian byte order)
3599 target_value.append(&mut <Vec<u8>>::from_hex("0002").unwrap()); // num_witnesses (u16)
3601 target_value.append(&mut <Vec<u8>>::from_hex("006b").unwrap()); // len of witness_data
3602 target_value.append(&mut <Vec<u8>>::from_hex("02").unwrap()); // num_witness_elements (VarInt)
3603 target_value.append(&mut <Vec<u8>>::from_hex("47").unwrap()); // len of witness element data (VarInt)
3604 target_value.append(&mut <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap());
3605 target_value.append(&mut <Vec<u8>>::from_hex("21").unwrap()); // len of witness element data (VarInt)
3606 target_value.append(&mut <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap());
3608 target_value.append(&mut <Vec<u8>>::from_hex("006c").unwrap()); // len of witness_data
3609 target_value.append(&mut <Vec<u8>>::from_hex("02").unwrap()); // num_witness_elements (VarInt)
3610 target_value.append(&mut <Vec<u8>>::from_hex("48").unwrap()); // len of witness element data (VarInt)
3611 target_value.append(&mut <Vec<u8>>::from_hex("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap());
3612 target_value.append(&mut <Vec<u8>>::from_hex("21").unwrap()); // len of witness element data (VarInt)
3613 target_value.append(&mut <Vec<u8>>::from_hex("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap());
3614 assert_eq!(encoded_value, target_value);
3617 fn do_encoding_tx_init_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3618 let tx_init_rbf = msgs::TxInitRbf {
3619 channel_id: ChannelId::from_bytes([2; 32]),
3620 locktime: 305419896,
3621 feerate_sat_per_1000_weight: 20190119,
3622 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3624 let encoded_value = tx_init_rbf.encode();
3625 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3626 target_value.append(&mut <Vec<u8>>::from_hex("12345678").unwrap()); // locktime
3627 target_value.append(&mut <Vec<u8>>::from_hex("013413a7").unwrap()); // feerate_sat_per_1000_weight
3628 if let Some((_, target)) = funding_value_with_hex_target {
3629 target_value.push(0x00); // Type
3630 target_value.push(target.len() as u8 / 2); // Length
3631 target_value.append(&mut <Vec<u8>>::from_hex(target).unwrap()); // Value (i64)
3633 assert_eq!(encoded_value, target_value);
3637 fn encoding_tx_init_rbf() {
3638 do_encoding_tx_init_rbf(Some((1311768467284833366, "1234567890123456")));
3639 do_encoding_tx_init_rbf(Some((13117684672, "000000030DDFFBC0")));
3640 do_encoding_tx_init_rbf(None);
3643 fn do_encoding_tx_ack_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3644 let tx_ack_rbf = msgs::TxAckRbf {
3645 channel_id: ChannelId::from_bytes([2; 32]),
3646 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3648 let encoded_value = tx_ack_rbf.encode();
3649 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3650 if let Some((_, target)) = funding_value_with_hex_target {
3651 target_value.push(0x00); // Type
3652 target_value.push(target.len() as u8 / 2); // Length
3653 target_value.append(&mut <Vec<u8>>::from_hex(target).unwrap()); // Value (i64)
3655 assert_eq!(encoded_value, target_value);
3659 fn encoding_tx_ack_rbf() {
3660 do_encoding_tx_ack_rbf(Some((1311768467284833366, "1234567890123456")));
3661 do_encoding_tx_ack_rbf(Some((13117684672, "000000030DDFFBC0")));
3662 do_encoding_tx_ack_rbf(None);
3666 fn encoding_tx_abort() {
3667 let tx_abort = msgs::TxAbort {
3668 channel_id: ChannelId::from_bytes([2; 32]),
3669 data: <Vec<u8>>::from_hex("54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap(),
3671 let encoded_value = tx_abort.encode();
3672 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202002C54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap();
3673 assert_eq!(encoded_value, target_value);
3676 fn do_encoding_shutdown(script_type: u8) {
3677 let secp_ctx = Secp256k1::new();
3678 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3679 let script = Builder::new().push_opcode(opcodes::OP_TRUE).into_script();
3680 let shutdown = msgs::Shutdown {
3681 channel_id: ChannelId::from_bytes([2; 32]),
3683 if script_type == 1 { Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey() }
3684 else if script_type == 2 { Address::p2sh(&script, Network::Testnet).unwrap().script_pubkey() }
3685 else if script_type == 3 { Address::p2wpkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).unwrap().script_pubkey() }
3686 else { Address::p2wsh(&script, Network::Testnet).script_pubkey() },
3688 let encoded_value = shutdown.encode();
3689 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3690 if script_type == 1 {
3691 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3692 } else if script_type == 2 {
3693 target_value.append(&mut <Vec<u8>>::from_hex("0017a914da1745e9b549bd0bfa1a569971c77eba30cd5a4b87").unwrap());
3694 } else if script_type == 3 {
3695 target_value.append(&mut <Vec<u8>>::from_hex("0016001479b000887626b294a914501a4cd226b58b235983").unwrap());
3696 } else if script_type == 4 {
3697 target_value.append(&mut <Vec<u8>>::from_hex("002200204ae81572f06e1b88fd5ced7a1a000945432e83e1551e6f721ee9c00b8cc33260").unwrap());
3699 assert_eq!(encoded_value, target_value);
3703 fn encoding_shutdown() {
3704 do_encoding_shutdown(1);
3705 do_encoding_shutdown(2);
3706 do_encoding_shutdown(3);
3707 do_encoding_shutdown(4);
3711 fn encoding_closing_signed() {
3712 let secp_ctx = Secp256k1::new();
3713 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3714 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3715 let closing_signed = msgs::ClosingSigned {
3716 channel_id: ChannelId::from_bytes([2; 32]),
3717 fee_satoshis: 2316138423780173,
3721 let encoded_value = closing_signed.encode();
3722 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3723 assert_eq!(encoded_value, target_value);
3724 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value)).unwrap(), closing_signed);
3726 let closing_signed_with_range = msgs::ClosingSigned {
3727 channel_id: ChannelId::from_bytes([2; 32]),
3728 fee_satoshis: 2316138423780173,
3730 fee_range: Some(msgs::ClosingSignedFeeRange {
3731 min_fee_satoshis: 0xdeadbeef,
3732 max_fee_satoshis: 0x1badcafe01234567,
3735 let encoded_value_with_range = closing_signed_with_range.encode();
3736 let target_value_with_range = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a011000000000deadbeef1badcafe01234567").unwrap();
3737 assert_eq!(encoded_value_with_range, target_value_with_range);
3738 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value_with_range)).unwrap(),
3739 closing_signed_with_range);
3743 fn encoding_update_add_htlc() {
3744 let secp_ctx = Secp256k1::new();
3745 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3746 let onion_routing_packet = msgs::OnionPacket {
3748 public_key: Ok(pubkey_1),
3749 hop_data: [1; 20*65],
3752 let update_add_htlc = msgs::UpdateAddHTLC {
3753 channel_id: ChannelId::from_bytes([2; 32]),
3754 htlc_id: 2316138423780173,
3755 amount_msat: 3608586615801332854,
3756 payment_hash: PaymentHash([1; 32]),
3757 cltv_expiry: 821716,
3758 onion_routing_packet,
3759 skimmed_fee_msat: None,
3761 let encoded_value = update_add_htlc.encode();
3762 let target_value = <Vec<u8>>::from_hex("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").unwrap();
3763 assert_eq!(encoded_value, target_value);
3767 fn encoding_update_fulfill_htlc() {
3768 let update_fulfill_htlc = msgs::UpdateFulfillHTLC {
3769 channel_id: ChannelId::from_bytes([2; 32]),
3770 htlc_id: 2316138423780173,
3771 payment_preimage: PaymentPreimage([1; 32]),
3773 let encoded_value = update_fulfill_htlc.encode();
3774 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d0101010101010101010101010101010101010101010101010101010101010101").unwrap();
3775 assert_eq!(encoded_value, target_value);
3779 fn encoding_update_fail_htlc() {
3780 let reason = OnionErrorPacket {
3781 data: [1; 32].to_vec(),
3783 let update_fail_htlc = msgs::UpdateFailHTLC {
3784 channel_id: ChannelId::from_bytes([2; 32]),
3785 htlc_id: 2316138423780173,
3788 let encoded_value = update_fail_htlc.encode();
3789 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d00200101010101010101010101010101010101010101010101010101010101010101").unwrap();
3790 assert_eq!(encoded_value, target_value);
3794 fn encoding_update_fail_malformed_htlc() {
3795 let update_fail_malformed_htlc = msgs::UpdateFailMalformedHTLC {
3796 channel_id: ChannelId::from_bytes([2; 32]),
3797 htlc_id: 2316138423780173,
3798 sha256_of_onion: [1; 32],
3801 let encoded_value = update_fail_malformed_htlc.encode();
3802 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d010101010101010101010101010101010101010101010101010101010101010100ff").unwrap();
3803 assert_eq!(encoded_value, target_value);
3806 fn do_encoding_commitment_signed(htlcs: bool) {
3807 let secp_ctx = Secp256k1::new();
3808 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3809 let (privkey_2, _) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3810 let (privkey_3, _) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3811 let (privkey_4, _) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3812 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3813 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
3814 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
3815 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
3816 let commitment_signed = msgs::CommitmentSigned {
3817 channel_id: ChannelId::from_bytes([2; 32]),
3819 htlc_signatures: if htlcs { vec![sig_2, sig_3, sig_4] } else { Vec::new() },
3821 partial_signature_with_nonce: None,
3823 let encoded_value = commitment_signed.encode();
3824 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3826 target_value.append(&mut <Vec<u8>>::from_hex("00031735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
3828 target_value.append(&mut <Vec<u8>>::from_hex("0000").unwrap());
3830 assert_eq!(encoded_value, target_value);
3834 fn encoding_commitment_signed() {
3835 do_encoding_commitment_signed(true);
3836 do_encoding_commitment_signed(false);
3840 fn encoding_revoke_and_ack() {
3841 let secp_ctx = Secp256k1::new();
3842 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3843 let raa = msgs::RevokeAndACK {
3844 channel_id: ChannelId::from_bytes([2; 32]),
3845 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],
3846 next_per_commitment_point: pubkey_1,
3848 next_local_nonce: None,
3850 let encoded_value = raa.encode();
3851 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020101010101010101010101010101010101010101010101010101010101010101031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3852 assert_eq!(encoded_value, target_value);
3856 fn encoding_update_fee() {
3857 let update_fee = msgs::UpdateFee {
3858 channel_id: ChannelId::from_bytes([2; 32]),
3859 feerate_per_kw: 20190119,
3861 let encoded_value = update_fee.encode();
3862 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202013413a7").unwrap();
3863 assert_eq!(encoded_value, target_value);
3867 fn encoding_init() {
3868 let mainnet_hash = ChainHash::using_genesis_block(Network::Bitcoin);
3869 assert_eq!(msgs::Init {
3870 features: InitFeatures::from_le_bytes(vec![0xFF, 0xFF, 0xFF]),
3871 networks: Some(vec![mainnet_hash]),
3872 remote_network_address: None,
3873 }.encode(), <Vec<u8>>::from_hex("00023fff0003ffffff01206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3874 assert_eq!(msgs::Init {
3875 features: InitFeatures::from_le_bytes(vec![0xFF]),
3877 remote_network_address: None,
3878 }.encode(), <Vec<u8>>::from_hex("0001ff0001ff").unwrap());
3879 assert_eq!(msgs::Init {
3880 features: InitFeatures::from_le_bytes(vec![]),
3881 networks: Some(vec![mainnet_hash]),
3882 remote_network_address: None,
3883 }.encode(), <Vec<u8>>::from_hex("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3884 assert_eq!(msgs::Init {
3885 features: InitFeatures::from_le_bytes(vec![]),
3886 networks: Some(vec![ChainHash::from(&[1; 32]), ChainHash::from(&[2; 32])]),
3887 remote_network_address: None,
3888 }.encode(), <Vec<u8>>::from_hex("00000000014001010101010101010101010101010101010101010101010101010101010101010202020202020202020202020202020202020202020202020202020202020202").unwrap());
3889 let init_msg = msgs::Init { features: InitFeatures::from_le_bytes(vec![]),
3890 networks: Some(vec![mainnet_hash]),
3891 remote_network_address: Some(SocketAddress::TcpIpV4 {
3892 addr: [127, 0, 0, 1],
3896 let encoded_value = init_msg.encode();
3897 let target_value = <Vec<u8>>::from_hex("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d61900000000000307017f00000103e8").unwrap();
3898 assert_eq!(encoded_value, target_value);
3899 assert_eq!(msgs::Init::read(&mut Cursor::new(&target_value)).unwrap(), init_msg);
3903 fn encoding_error() {
3904 let error = msgs::ErrorMessage {
3905 channel_id: ChannelId::from_bytes([2; 32]),
3906 data: String::from("rust-lightning"),
3908 let encoded_value = error.encode();
3909 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3910 assert_eq!(encoded_value, target_value);
3914 fn encoding_warning() {
3915 let error = msgs::WarningMessage {
3916 channel_id: ChannelId::from_bytes([2; 32]),
3917 data: String::from("rust-lightning"),
3919 let encoded_value = error.encode();
3920 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3921 assert_eq!(encoded_value, target_value);
3925 fn encoding_ping() {
3926 let ping = msgs::Ping {
3930 let encoded_value = ping.encode();
3931 let target_value = <Vec<u8>>::from_hex("0040004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3932 assert_eq!(encoded_value, target_value);
3936 fn encoding_pong() {
3937 let pong = msgs::Pong {
3940 let encoded_value = pong.encode();
3941 let target_value = <Vec<u8>>::from_hex("004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3942 assert_eq!(encoded_value, target_value);
3946 fn encoding_nonfinal_onion_hop_data() {
3947 let outbound_msg = msgs::OutboundOnionPayload::Forward {
3948 short_channel_id: 0xdeadbeef1bad1dea,
3949 amt_to_forward: 0x0badf00d01020304,
3950 outgoing_cltv_value: 0xffffffff,
3952 let encoded_value = outbound_msg.encode();
3953 let target_value = <Vec<u8>>::from_hex("1a02080badf00d010203040404ffffffff0608deadbeef1bad1dea").unwrap();
3954 assert_eq!(encoded_value, target_value);
3956 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3957 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
3958 if let msgs::InboundOnionPayload::Forward {
3959 short_channel_id, amt_to_forward, outgoing_cltv_value
3961 assert_eq!(short_channel_id, 0xdeadbeef1bad1dea);
3962 assert_eq!(amt_to_forward, 0x0badf00d01020304);
3963 assert_eq!(outgoing_cltv_value, 0xffffffff);
3964 } else { panic!(); }
3968 fn encoding_final_onion_hop_data() {
3969 let outbound_msg = msgs::OutboundOnionPayload::Receive {
3971 payment_metadata: None,
3972 keysend_preimage: None,
3973 amt_msat: 0x0badf00d01020304,
3974 outgoing_cltv_value: 0xffffffff,
3975 custom_tlvs: vec![],
3977 let encoded_value = outbound_msg.encode();
3978 let target_value = <Vec<u8>>::from_hex("1002080badf00d010203040404ffffffff").unwrap();
3979 assert_eq!(encoded_value, target_value);
3981 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3982 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
3983 if let msgs::InboundOnionPayload::Receive {
3984 payment_data: None, amt_msat, outgoing_cltv_value, ..
3986 assert_eq!(amt_msat, 0x0badf00d01020304);
3987 assert_eq!(outgoing_cltv_value, 0xffffffff);
3988 } else { panic!(); }
3992 fn encoding_final_onion_hop_data_with_secret() {
3993 let expected_payment_secret = PaymentSecret([0x42u8; 32]);
3994 let outbound_msg = msgs::OutboundOnionPayload::Receive {
3995 payment_data: Some(FinalOnionHopData {
3996 payment_secret: expected_payment_secret,
3997 total_msat: 0x1badca1f
3999 payment_metadata: None,
4000 keysend_preimage: None,
4001 amt_msat: 0x0badf00d01020304,
4002 outgoing_cltv_value: 0xffffffff,
4003 custom_tlvs: vec![],
4005 let encoded_value = outbound_msg.encode();
4006 let target_value = <Vec<u8>>::from_hex("3602080badf00d010203040404ffffffff082442424242424242424242424242424242424242424242424242424242424242421badca1f").unwrap();
4007 assert_eq!(encoded_value, target_value);
4009 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4010 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
4011 if let msgs::InboundOnionPayload::Receive {
4012 payment_data: Some(FinalOnionHopData {
4014 total_msat: 0x1badca1f
4016 amt_msat, outgoing_cltv_value,
4017 payment_metadata: None,
4018 keysend_preimage: None,
4021 assert_eq!(payment_secret, expected_payment_secret);
4022 assert_eq!(amt_msat, 0x0badf00d01020304);
4023 assert_eq!(outgoing_cltv_value, 0xffffffff);
4024 assert_eq!(custom_tlvs, vec![]);
4025 } else { panic!(); }
4029 fn encoding_final_onion_hop_data_with_bad_custom_tlvs() {
4030 // If custom TLVs have type number within the range reserved for protocol, treat them as if
4032 let bad_type_range_tlvs = vec![
4033 ((1 << 16) - 4, vec![42]),
4034 ((1 << 16) - 2, vec![42; 32]),
4036 let mut msg = msgs::OutboundOnionPayload::Receive {
4038 payment_metadata: None,
4039 keysend_preimage: None,
4040 custom_tlvs: bad_type_range_tlvs,
4041 amt_msat: 0x0badf00d01020304,
4042 outgoing_cltv_value: 0xffffffff,
4044 let encoded_value = msg.encode();
4045 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4046 assert!(msgs::InboundOnionPayload::read(&mut Cursor::new(&encoded_value[..]), &&node_signer).is_err());
4047 let good_type_range_tlvs = vec![
4048 ((1 << 16) - 3, vec![42]),
4049 ((1 << 16) - 1, vec![42; 32]),
4051 if let msgs::OutboundOnionPayload::Receive { ref mut custom_tlvs, .. } = msg {
4052 *custom_tlvs = good_type_range_tlvs.clone();
4054 let encoded_value = msg.encode();
4055 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&encoded_value[..]), &&node_signer).unwrap();
4057 msgs::InboundOnionPayload::Receive { custom_tlvs, .. } => assert!(custom_tlvs.is_empty()),
4063 fn encoding_final_onion_hop_data_with_custom_tlvs() {
4064 let expected_custom_tlvs = vec![
4065 (5482373483, vec![0x12, 0x34]),
4066 (5482373487, vec![0x42u8; 8]),
4068 let msg = msgs::OutboundOnionPayload::Receive {
4070 payment_metadata: None,
4071 keysend_preimage: None,
4072 custom_tlvs: expected_custom_tlvs.clone(),
4073 amt_msat: 0x0badf00d01020304,
4074 outgoing_cltv_value: 0xffffffff,
4076 let encoded_value = msg.encode();
4077 let target_value = <Vec<u8>>::from_hex("2e02080badf00d010203040404ffffffffff0000000146c6616b021234ff0000000146c6616f084242424242424242").unwrap();
4078 assert_eq!(encoded_value, target_value);
4079 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4080 let inbound_msg: msgs::InboundOnionPayload = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
4081 if let msgs::InboundOnionPayload::Receive {
4083 payment_metadata: None,
4084 keysend_preimage: None,
4087 outgoing_cltv_value,
4090 assert_eq!(custom_tlvs, expected_custom_tlvs);
4091 assert_eq!(amt_msat, 0x0badf00d01020304);
4092 assert_eq!(outgoing_cltv_value, 0xffffffff);
4093 } else { panic!(); }
4097 fn query_channel_range_end_blocknum() {
4098 let tests: Vec<(u32, u32, u32)> = vec![
4099 (10000, 1500, 11500),
4100 (0, 0xffffffff, 0xffffffff),
4101 (1, 0xffffffff, 0xffffffff),
4104 for (first_blocknum, number_of_blocks, expected) in tests.into_iter() {
4105 let sut = msgs::QueryChannelRange {
4106 chain_hash: ChainHash::using_genesis_block(Network::Regtest),
4110 assert_eq!(sut.end_blocknum(), expected);
4115 fn encoding_query_channel_range() {
4116 let mut query_channel_range = msgs::QueryChannelRange {
4117 chain_hash: ChainHash::using_genesis_block(Network::Regtest),
4118 first_blocknum: 100000,
4119 number_of_blocks: 1500,
4121 let encoded_value = query_channel_range.encode();
4122 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000186a0000005dc").unwrap();
4123 assert_eq!(encoded_value, target_value);
4125 query_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4126 assert_eq!(query_channel_range.first_blocknum, 100000);
4127 assert_eq!(query_channel_range.number_of_blocks, 1500);
4131 fn encoding_reply_channel_range() {
4132 do_encoding_reply_channel_range(0);
4133 do_encoding_reply_channel_range(1);
4136 fn do_encoding_reply_channel_range(encoding_type: u8) {
4137 let mut target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000b8a06000005dc01").unwrap();
4138 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4139 let mut reply_channel_range = msgs::ReplyChannelRange {
4140 chain_hash: expected_chain_hash,
4141 first_blocknum: 756230,
4142 number_of_blocks: 1500,
4143 sync_complete: true,
4144 short_channel_ids: vec![0x000000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
4147 if encoding_type == 0 {
4148 target_value.append(&mut <Vec<u8>>::from_hex("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
4149 let encoded_value = reply_channel_range.encode();
4150 assert_eq!(encoded_value, target_value);
4152 reply_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4153 assert_eq!(reply_channel_range.chain_hash, expected_chain_hash);
4154 assert_eq!(reply_channel_range.first_blocknum, 756230);
4155 assert_eq!(reply_channel_range.number_of_blocks, 1500);
4156 assert_eq!(reply_channel_range.sync_complete, true);
4157 assert_eq!(reply_channel_range.short_channel_ids[0], 0x000000000000008e);
4158 assert_eq!(reply_channel_range.short_channel_ids[1], 0x0000000000003c69);
4159 assert_eq!(reply_channel_range.short_channel_ids[2], 0x000000000045a6c4);
4161 target_value.append(&mut <Vec<u8>>::from_hex("001601789c636000833e08659309a65878be010010a9023a").unwrap());
4162 let result: Result<msgs::ReplyChannelRange, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
4163 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
4168 fn encoding_query_short_channel_ids() {
4169 do_encoding_query_short_channel_ids(0);
4170 do_encoding_query_short_channel_ids(1);
4173 fn do_encoding_query_short_channel_ids(encoding_type: u8) {
4174 let mut target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
4175 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4176 let mut query_short_channel_ids = msgs::QueryShortChannelIds {
4177 chain_hash: expected_chain_hash,
4178 short_channel_ids: vec![0x0000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
4181 if encoding_type == 0 {
4182 target_value.append(&mut <Vec<u8>>::from_hex("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
4183 let encoded_value = query_short_channel_ids.encode();
4184 assert_eq!(encoded_value, target_value);
4186 query_short_channel_ids = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4187 assert_eq!(query_short_channel_ids.chain_hash, expected_chain_hash);
4188 assert_eq!(query_short_channel_ids.short_channel_ids[0], 0x000000000000008e);
4189 assert_eq!(query_short_channel_ids.short_channel_ids[1], 0x0000000000003c69);
4190 assert_eq!(query_short_channel_ids.short_channel_ids[2], 0x000000000045a6c4);
4192 target_value.append(&mut <Vec<u8>>::from_hex("001601789c636000833e08659309a65878be010010a9023a").unwrap());
4193 let result: Result<msgs::QueryShortChannelIds, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
4194 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
4199 fn encoding_reply_short_channel_ids_end() {
4200 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4201 let mut reply_short_channel_ids_end = msgs::ReplyShortChannelIdsEnd {
4202 chain_hash: expected_chain_hash,
4203 full_information: true,
4205 let encoded_value = reply_short_channel_ids_end.encode();
4206 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f01").unwrap();
4207 assert_eq!(encoded_value, target_value);
4209 reply_short_channel_ids_end = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4210 assert_eq!(reply_short_channel_ids_end.chain_hash, expected_chain_hash);
4211 assert_eq!(reply_short_channel_ids_end.full_information, true);
4215 fn encoding_gossip_timestamp_filter(){
4216 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4217 let mut gossip_timestamp_filter = msgs::GossipTimestampFilter {
4218 chain_hash: expected_chain_hash,
4219 first_timestamp: 1590000000,
4220 timestamp_range: 0xffff_ffff,
4222 let encoded_value = gossip_timestamp_filter.encode();
4223 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f5ec57980ffffffff").unwrap();
4224 assert_eq!(encoded_value, target_value);
4226 gossip_timestamp_filter = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4227 assert_eq!(gossip_timestamp_filter.chain_hash, expected_chain_hash);
4228 assert_eq!(gossip_timestamp_filter.first_timestamp, 1590000000);
4229 assert_eq!(gossip_timestamp_filter.timestamp_range, 0xffff_ffff);
4233 fn decode_onion_hop_data_len_as_bigsize() {
4234 // Tests that we can decode an onion payload that is >253 bytes.
4235 // Previously, receiving a payload of this size could've caused us to fail to decode a valid
4236 // payload, because we were decoding the length (a BigSize, big-endian) as a VarInt
4239 // Encode a test onion payload with a big custom TLV such that it's >253 bytes, forcing the
4240 // payload length to be encoded over multiple bytes rather than a single u8.
4241 let big_payload = encode_big_payload().unwrap();
4242 let mut rd = Cursor::new(&big_payload[..]);
4244 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4245 <msgs::InboundOnionPayload as ReadableArgs<&&test_utils::TestKeysInterface>>
4246 ::read(&mut rd, &&node_signer).unwrap();
4248 // see above test, needs to be a separate method for use of the serialization macros.
4249 fn encode_big_payload() -> Result<Vec<u8>, io::Error> {
4250 use crate::util::ser::HighZeroBytesDroppedBigSize;
4251 let payload = msgs::OutboundOnionPayload::Forward {
4252 short_channel_id: 0xdeadbeef1bad1dea,
4253 amt_to_forward: 1000,
4254 outgoing_cltv_value: 0xffffffff,
4256 let mut encoded_payload = Vec::new();
4257 let test_bytes = vec![42u8; 1000];
4258 if let msgs::OutboundOnionPayload::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } = payload {
4259 _encode_varint_length_prefixed_tlv!(&mut encoded_payload, {
4260 (1, test_bytes, required_vec),
4261 (2, HighZeroBytesDroppedBigSize(amt_to_forward), required),
4262 (4, HighZeroBytesDroppedBigSize(outgoing_cltv_value), required),
4263 (6, short_channel_id, required)
4270 #[cfg(feature = "std")]
4271 fn test_socket_address_from_str() {
4272 let tcpip_v4 = SocketAddress::TcpIpV4 {
4273 addr: Ipv4Addr::new(127, 0, 0, 1).octets(),
4276 assert_eq!(tcpip_v4, SocketAddress::from_str("127.0.0.1:1234").unwrap());
4277 assert_eq!(tcpip_v4, SocketAddress::from_str(&tcpip_v4.to_string()).unwrap());
4279 let tcpip_v6 = SocketAddress::TcpIpV6 {
4280 addr: Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1).octets(),
4283 assert_eq!(tcpip_v6, SocketAddress::from_str("[0:0:0:0:0:0:0:1]:1234").unwrap());
4284 assert_eq!(tcpip_v6, SocketAddress::from_str(&tcpip_v6.to_string()).unwrap());
4286 let hostname = SocketAddress::Hostname {
4287 hostname: Hostname::try_from("lightning-node.mydomain.com".to_string()).unwrap(),
4290 assert_eq!(hostname, SocketAddress::from_str("lightning-node.mydomain.com:1234").unwrap());
4291 assert_eq!(hostname, SocketAddress::from_str(&hostname.to_string()).unwrap());
4293 let onion_v2 = SocketAddress::OnionV2 ([40, 4, 64, 185, 202, 19, 162, 75, 90, 200, 38, 7],);
4294 assert_eq!("OnionV2([40, 4, 64, 185, 202, 19, 162, 75, 90, 200, 38, 7])", &onion_v2.to_string());
4295 assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("FACEBOOKCOREWWWI.onion:9735"));
4297 let onion_v3 = SocketAddress::OnionV3 {
4298 ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102, 182, 107, 4, 105, 247, 246, 85,
4299 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31, 33, 71, 3],
4304 assert_eq!(onion_v3, SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion:1234").unwrap());
4305 assert_eq!(onion_v3, SocketAddress::from_str(&onion_v3.to_string()).unwrap());
4307 assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6.onion:1234"));
4308 assert_eq!(Err(SocketAddressParseError::InvalidInput), SocketAddress::from_str("127.0.0.1@1234"));
4309 assert_eq!(Err(SocketAddressParseError::InvalidInput), "".parse::<SocketAddress>());
4310 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:9735:94").is_err());
4311 assert!(SocketAddress::from_str("wrong$%#.com:1234").is_err());
4312 assert_eq!(Err(SocketAddressParseError::InvalidPort), SocketAddress::from_str("example.com:wrong"));
4313 assert!("localhost".parse::<SocketAddress>().is_err());
4314 assert!("localhost:invalid-port".parse::<SocketAddress>().is_err());
4315 assert!( "invalid-onion-v3-hostname.onion:8080".parse::<SocketAddress>().is_err());
4316 assert!("b32.example.onion:invalid-port".parse::<SocketAddress>().is_err());
4317 assert!("invalid-address".parse::<SocketAddress>().is_err());
4318 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:1234").is_err());
4322 #[cfg(feature = "std")]
4323 fn test_socket_address_to_socket_addrs() {
4324 assert_eq!(SocketAddress::TcpIpV4 {addr:[0u8; 4], port: 1337,}.to_socket_addrs().unwrap().next().unwrap(),
4325 SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(0,0,0,0), 1337)));
4326 assert_eq!(SocketAddress::TcpIpV6 {addr:[0u8; 16], port: 1337,}.to_socket_addrs().unwrap().next().unwrap(),
4327 SocketAddr::V6(SocketAddrV6::new(Ipv6Addr::from([0u8; 16]), 1337, 0, 0)));
4328 assert_eq!(SocketAddress::Hostname { hostname: Hostname::try_from("0.0.0.0".to_string()).unwrap(), port: 0 }
4329 .to_socket_addrs().unwrap().next().unwrap(), SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::from([0u8; 4]),0)));
4330 assert!(SocketAddress::OnionV2([0u8; 12]).to_socket_addrs().is_err());
4331 assert!(SocketAddress::OnionV3{ ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102,
4332 182, 107, 4, 105, 247, 246, 85, 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31,
4336 port: 1234 }.to_socket_addrs().is_err());