1 // This file is Copyright its original authors, visible in version control
4 // This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
5 // or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
6 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
7 // You may not use this file except in accordance with one or both of these
10 //! Wire messages, traits representing wire message handlers, and a few error types live here.
12 //! For a normal node you probably don't need to use anything here, however, if you wish to split a
13 //! node into an internet-facing route/message socket handling daemon and a separate daemon (or
14 //! server entirely) which handles only channel-related messages you may wish to implement
15 //! [`ChannelMessageHandler`] yourself and use it to re-serialize messages and pass them across
18 //! Note that if you go with such an architecture (instead of passing raw socket events to a
19 //! non-internet-facing system) you trust the frontend internet-facing system to not lie about the
20 //! source `node_id` of the message, however this does allow you to significantly reduce bandwidth
21 //! between the systems as routing messages can represent a significant chunk of bandwidth usage
22 //! (especially for non-channel-publicly-announcing nodes). As an alternate design which avoids
23 //! this issue, if you have sufficient bidirectional bandwidth between your systems, you may send
24 //! raw socket events into your non-internet-facing system and then send routing events back to
25 //! track the network on the less-secure system.
27 use bitcoin::blockdata::constants::ChainHash;
28 use bitcoin::secp256k1::PublicKey;
29 use bitcoin::secp256k1::ecdsa::Signature;
30 use bitcoin::{secp256k1, Witness};
31 use bitcoin::blockdata::script::ScriptBuf;
32 use bitcoin::hash_types::Txid;
34 use crate::blinded_path::payment::{BlindedPaymentTlvs, ForwardTlvs, ReceiveTlvs};
35 use crate::ln::{ChannelId, PaymentPreimage, PaymentHash, PaymentSecret};
36 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
37 use crate::ln::onion_utils;
38 use crate::onion_message;
39 use crate::sign::{NodeSigner, Recipient};
41 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::{EventsProvider, 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,
685 /// Provided if we are relaying or receiving a payment within a blinded path, to decrypt the onion
686 /// routing packet and the recipient-provided encrypted payload within.
687 pub blinding_point: Option<PublicKey>,
690 /// An onion message to be sent to or received from a peer.
692 // TODO: update with link to OM when they are merged into the BOLTs
693 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
694 pub struct OnionMessage {
695 /// Used in decrypting the onion packet's payload.
696 pub blinding_point: PublicKey,
697 /// The full onion packet including hop data, pubkey, and hmac
698 pub onion_routing_packet: onion_message::Packet,
701 /// An [`update_fulfill_htlc`] message to be sent to or received from a peer.
703 /// [`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
704 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
705 pub struct UpdateFulfillHTLC {
707 pub channel_id: ChannelId,
710 /// The pre-image of the payment hash, allowing HTLC redemption
711 pub payment_preimage: PaymentPreimage,
714 /// An [`update_fail_htlc`] message to be sent to or received from a peer.
716 /// [`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
717 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
718 pub struct UpdateFailHTLC {
720 pub channel_id: ChannelId,
723 pub(crate) reason: OnionErrorPacket,
726 /// An [`update_fail_malformed_htlc`] message to be sent to or received from a peer.
728 /// [`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
729 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
730 pub struct UpdateFailMalformedHTLC {
732 pub channel_id: ChannelId,
735 pub(crate) sha256_of_onion: [u8; 32],
737 pub failure_code: u16,
740 /// A [`commitment_signed`] message to be sent to or received from a peer.
742 /// [`commitment_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#committing-updates-so-far-commitment_signed
743 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
744 pub struct CommitmentSigned {
746 pub channel_id: ChannelId,
747 /// A signature on the commitment transaction
748 pub signature: Signature,
749 /// Signatures on the HTLC transactions
750 pub htlc_signatures: Vec<Signature>,
752 /// The partial Taproot signature on the commitment transaction
753 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
756 /// A [`revoke_and_ack`] message to be sent to or received from a peer.
758 /// [`revoke_and_ack`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#completing-the-transition-to-the-updated-state-revoke_and_ack
759 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
760 pub struct RevokeAndACK {
762 pub channel_id: ChannelId,
763 /// The secret corresponding to the per-commitment point
764 pub per_commitment_secret: [u8; 32],
765 /// The next sender-broadcast commitment transaction's per-commitment point
766 pub next_per_commitment_point: PublicKey,
768 /// Musig nonce the recipient should use in their next commitment signature message
769 pub next_local_nonce: Option<musig2::types::PublicNonce>
772 /// An [`update_fee`] message to be sent to or received from a peer
774 /// [`update_fee`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#updating-fees-update_fee
775 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
776 pub struct UpdateFee {
778 pub channel_id: ChannelId,
779 /// Fee rate per 1000-weight of the transaction
780 pub feerate_per_kw: u32,
783 /// A [`channel_reestablish`] message to be sent to or received from a peer.
785 /// [`channel_reestablish`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#message-retransmission
786 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
787 pub struct ChannelReestablish {
789 pub channel_id: ChannelId,
790 /// The next commitment number for the sender
791 pub next_local_commitment_number: u64,
792 /// The next commitment number for the recipient
793 pub next_remote_commitment_number: u64,
794 /// Proof that the sender knows the per-commitment secret of a specific commitment transaction
795 /// belonging to the recipient
796 pub your_last_per_commitment_secret: [u8; 32],
797 /// The sender's per-commitment point for their current commitment transaction
798 pub my_current_per_commitment_point: PublicKey,
799 /// The next funding transaction ID
800 pub next_funding_txid: Option<Txid>,
803 /// An [`announcement_signatures`] message to be sent to or received from a peer.
805 /// [`announcement_signatures`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-announcement_signatures-message
806 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
807 pub struct AnnouncementSignatures {
809 pub channel_id: ChannelId,
810 /// The short channel ID
811 pub short_channel_id: u64,
812 /// A signature by the node key
813 pub node_signature: Signature,
814 /// A signature by the funding key
815 pub bitcoin_signature: Signature,
818 /// An address which can be used to connect to a remote peer.
819 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
820 pub enum SocketAddress {
821 /// An IPv4 address and port on which the peer is listening.
823 /// The 4-byte IPv4 address
825 /// The port on which the node is listening
828 /// An IPv6 address and port on which the peer is listening.
830 /// The 16-byte IPv6 address
832 /// The port on which the node is listening
835 /// An old-style Tor onion address/port on which the peer is listening.
837 /// This field is deprecated and the Tor network generally no longer supports V2 Onion
838 /// addresses. Thus, the details are not parsed here.
840 /// A new-style Tor onion address/port on which the peer is listening.
842 /// To create the human-readable "hostname", concatenate the ED25519 pubkey, checksum, and version,
843 /// wrap as base32 and append ".onion".
845 /// The ed25519 long-term public key of the peer
846 ed25519_pubkey: [u8; 32],
847 /// The checksum of the pubkey and version, as included in the onion address
849 /// The version byte, as defined by the Tor Onion v3 spec.
851 /// The port on which the node is listening
854 /// A hostname/port on which the peer is listening.
856 /// The hostname on which the node is listening.
858 /// The port on which the node is listening.
863 /// Gets the ID of this address type. Addresses in [`NodeAnnouncement`] messages should be sorted
865 pub(crate) fn get_id(&self) -> u8 {
867 &SocketAddress::TcpIpV4 {..} => { 1 },
868 &SocketAddress::TcpIpV6 {..} => { 2 },
869 &SocketAddress::OnionV2(_) => { 3 },
870 &SocketAddress::OnionV3 {..} => { 4 },
871 &SocketAddress::Hostname {..} => { 5 },
875 /// Strict byte-length of address descriptor, 1-byte type not recorded
876 fn len(&self) -> u16 {
878 &SocketAddress::TcpIpV4 { .. } => { 6 },
879 &SocketAddress::TcpIpV6 { .. } => { 18 },
880 &SocketAddress::OnionV2(_) => { 12 },
881 &SocketAddress::OnionV3 { .. } => { 37 },
882 // Consists of 1-byte hostname length, hostname bytes, and 2-byte port.
883 &SocketAddress::Hostname { ref hostname, .. } => { u16::from(hostname.len()) + 3 },
887 /// The maximum length of any address descriptor, not including the 1-byte type.
888 /// This maximum length is reached by a hostname address descriptor:
889 /// a hostname with a maximum length of 255, its 1-byte length and a 2-byte port.
890 pub(crate) const MAX_LEN: u16 = 258;
893 impl Writeable for SocketAddress {
894 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
896 &SocketAddress::TcpIpV4 { ref addr, ref port } => {
901 &SocketAddress::TcpIpV6 { ref addr, ref port } => {
906 &SocketAddress::OnionV2(bytes) => {
908 bytes.write(writer)?;
910 &SocketAddress::OnionV3 { ref ed25519_pubkey, ref checksum, ref version, ref port } => {
912 ed25519_pubkey.write(writer)?;
913 checksum.write(writer)?;
914 version.write(writer)?;
917 &SocketAddress::Hostname { ref hostname, ref port } => {
919 hostname.write(writer)?;
927 impl Readable for Result<SocketAddress, u8> {
928 fn read<R: Read>(reader: &mut R) -> Result<Result<SocketAddress, u8>, DecodeError> {
929 let byte = <u8 as Readable>::read(reader)?;
932 Ok(Ok(SocketAddress::TcpIpV4 {
933 addr: Readable::read(reader)?,
934 port: Readable::read(reader)?,
938 Ok(Ok(SocketAddress::TcpIpV6 {
939 addr: Readable::read(reader)?,
940 port: Readable::read(reader)?,
943 3 => Ok(Ok(SocketAddress::OnionV2(Readable::read(reader)?))),
945 Ok(Ok(SocketAddress::OnionV3 {
946 ed25519_pubkey: Readable::read(reader)?,
947 checksum: Readable::read(reader)?,
948 version: Readable::read(reader)?,
949 port: Readable::read(reader)?,
953 Ok(Ok(SocketAddress::Hostname {
954 hostname: Readable::read(reader)?,
955 port: Readable::read(reader)?,
958 _ => return Ok(Err(byte)),
963 impl Readable for SocketAddress {
964 fn read<R: Read>(reader: &mut R) -> Result<SocketAddress, DecodeError> {
965 match Readable::read(reader) {
966 Ok(Ok(res)) => Ok(res),
967 Ok(Err(_)) => Err(DecodeError::UnknownVersion),
973 /// [`SocketAddress`] error variants
974 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
975 pub enum SocketAddressParseError {
976 /// Socket address (IPv4/IPv6) parsing error
978 /// Invalid input format
982 /// Invalid onion v3 address
986 impl fmt::Display for SocketAddressParseError {
987 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
989 SocketAddressParseError::SocketAddrParse => write!(f, "Socket address (IPv4/IPv6) parsing error"),
990 SocketAddressParseError::InvalidInput => write!(f, "Invalid input format. \
991 Expected: \"<ipv4>:<port>\", \"[<ipv6>]:<port>\", \"<onion address>.onion:<port>\" or \"<hostname>:<port>\""),
992 SocketAddressParseError::InvalidPort => write!(f, "Invalid port"),
993 SocketAddressParseError::InvalidOnionV3 => write!(f, "Invalid onion v3 address"),
998 #[cfg(feature = "std")]
999 impl From<std::net::SocketAddrV4> for SocketAddress {
1000 fn from(addr: std::net::SocketAddrV4) -> Self {
1001 SocketAddress::TcpIpV4 { addr: addr.ip().octets(), port: addr.port() }
1005 #[cfg(feature = "std")]
1006 impl From<std::net::SocketAddrV6> for SocketAddress {
1007 fn from(addr: std::net::SocketAddrV6) -> Self {
1008 SocketAddress::TcpIpV6 { addr: addr.ip().octets(), port: addr.port() }
1012 #[cfg(feature = "std")]
1013 impl From<std::net::SocketAddr> for SocketAddress {
1014 fn from(addr: std::net::SocketAddr) -> Self {
1016 std::net::SocketAddr::V4(addr) => addr.into(),
1017 std::net::SocketAddr::V6(addr) => addr.into(),
1022 #[cfg(feature = "std")]
1023 impl std::net::ToSocketAddrs for SocketAddress {
1024 type Iter = std::vec::IntoIter<std::net::SocketAddr>;
1026 fn to_socket_addrs(&self) -> std::io::Result<Self::Iter> {
1028 SocketAddress::TcpIpV4 { addr, port } => {
1029 let ip_addr = std::net::Ipv4Addr::from(*addr);
1030 let socket_addr = SocketAddr::new(ip_addr.into(), *port);
1031 Ok(vec![socket_addr].into_iter())
1033 SocketAddress::TcpIpV6 { addr, port } => {
1034 let ip_addr = std::net::Ipv6Addr::from(*addr);
1035 let socket_addr = SocketAddr::new(ip_addr.into(), *port);
1036 Ok(vec![socket_addr].into_iter())
1038 SocketAddress::Hostname { ref hostname, port } => {
1039 (hostname.as_str(), *port).to_socket_addrs()
1041 SocketAddress::OnionV2(..) => {
1042 Err(std::io::Error::new(std::io::ErrorKind::Other, "Resolution of OnionV2 \
1043 addresses is currently unsupported."))
1045 SocketAddress::OnionV3 { .. } => {
1046 Err(std::io::Error::new(std::io::ErrorKind::Other, "Resolution of OnionV3 \
1047 addresses is currently unsupported."))
1053 /// Parses an OnionV3 host and port into a [`SocketAddress::OnionV3`].
1055 /// The host part must end with ".onion".
1056 pub fn parse_onion_address(host: &str, port: u16) -> Result<SocketAddress, SocketAddressParseError> {
1057 if host.ends_with(".onion") {
1058 let domain = &host[..host.len() - ".onion".len()];
1059 if domain.len() != 56 {
1060 return Err(SocketAddressParseError::InvalidOnionV3);
1062 let onion = base32::Alphabet::RFC4648 { padding: false }.decode(&domain).map_err(|_| SocketAddressParseError::InvalidOnionV3)?;
1063 if onion.len() != 35 {
1064 return Err(SocketAddressParseError::InvalidOnionV3);
1066 let version = onion[0];
1067 let first_checksum_flag = onion[1];
1068 let second_checksum_flag = onion[2];
1069 let mut ed25519_pubkey = [0; 32];
1070 ed25519_pubkey.copy_from_slice(&onion[3..35]);
1071 let checksum = u16::from_be_bytes([first_checksum_flag, second_checksum_flag]);
1072 return Ok(SocketAddress::OnionV3 { ed25519_pubkey, checksum, version, port });
1075 return Err(SocketAddressParseError::InvalidInput);
1079 impl Display for SocketAddress {
1080 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1082 SocketAddress::TcpIpV4{addr, port} => write!(
1083 f, "{}.{}.{}.{}:{}", addr[0], addr[1], addr[2], addr[3], port)?,
1084 SocketAddress::TcpIpV6{addr, port} => write!(
1086 "[{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}]:{}",
1087 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
1089 SocketAddress::OnionV2(bytes) => write!(f, "OnionV2({:?})", bytes)?,
1090 SocketAddress::OnionV3 {
1096 let [first_checksum_flag, second_checksum_flag] = checksum.to_be_bytes();
1097 let mut addr = vec![*version, first_checksum_flag, second_checksum_flag];
1098 addr.extend_from_slice(ed25519_pubkey);
1099 let onion = base32::Alphabet::RFC4648 { padding: false }.encode(&addr);
1100 write!(f, "{}.onion:{}", onion, port)?
1102 SocketAddress::Hostname { hostname, port } => write!(f, "{}:{}", hostname, port)?,
1108 #[cfg(feature = "std")]
1109 impl FromStr for SocketAddress {
1110 type Err = SocketAddressParseError;
1112 fn from_str(s: &str) -> Result<Self, Self::Err> {
1113 match std::net::SocketAddr::from_str(s) {
1114 Ok(addr) => Ok(addr.into()),
1116 let trimmed_input = match s.rfind(":") {
1118 None => return Err(SocketAddressParseError::InvalidInput),
1120 let host = &s[..trimmed_input];
1121 let port: u16 = s[trimmed_input + 1..].parse().map_err(|_| SocketAddressParseError::InvalidPort)?;
1122 if host.ends_with(".onion") {
1123 return parse_onion_address(host, port);
1125 if let Ok(hostname) = Hostname::try_from(s[..trimmed_input].to_string()) {
1126 return Ok(SocketAddress::Hostname { hostname, port });
1128 return Err(SocketAddressParseError::SocketAddrParse)
1134 /// Represents the set of gossip messages that require a signature from a node's identity key.
1135 pub enum UnsignedGossipMessage<'a> {
1136 /// An unsigned channel announcement.
1137 ChannelAnnouncement(&'a UnsignedChannelAnnouncement),
1138 /// An unsigned channel update.
1139 ChannelUpdate(&'a UnsignedChannelUpdate),
1140 /// An unsigned node announcement.
1141 NodeAnnouncement(&'a UnsignedNodeAnnouncement)
1144 impl<'a> Writeable for UnsignedGossipMessage<'a> {
1145 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
1147 UnsignedGossipMessage::ChannelAnnouncement(ref msg) => msg.write(writer),
1148 UnsignedGossipMessage::ChannelUpdate(ref msg) => msg.write(writer),
1149 UnsignedGossipMessage::NodeAnnouncement(ref msg) => msg.write(writer),
1154 /// The unsigned part of a [`node_announcement`] message.
1156 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
1157 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1158 pub struct UnsignedNodeAnnouncement {
1159 /// The advertised features
1160 pub features: NodeFeatures,
1161 /// A strictly monotonic announcement counter, with gaps allowed
1163 /// The `node_id` this announcement originated from (don't rebroadcast the `node_announcement` back
1165 pub node_id: NodeId,
1166 /// An RGB color for UI purposes
1168 /// An alias, for UI purposes.
1170 /// This should be sanitized before use. There is no guarantee of uniqueness.
1171 pub alias: NodeAlias,
1172 /// List of addresses on which this node is reachable
1173 pub addresses: Vec<SocketAddress>,
1174 pub(crate) excess_address_data: Vec<u8>,
1175 pub(crate) excess_data: Vec<u8>,
1177 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1178 /// A [`node_announcement`] message to be sent to or received from a peer.
1180 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
1181 pub struct NodeAnnouncement {
1182 /// The signature by the node key
1183 pub signature: Signature,
1184 /// The actual content of the announcement
1185 pub contents: UnsignedNodeAnnouncement,
1188 /// The unsigned part of a [`channel_announcement`] message.
1190 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
1191 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1192 pub struct UnsignedChannelAnnouncement {
1193 /// The advertised channel features
1194 pub features: ChannelFeatures,
1195 /// The genesis hash of the blockchain where the channel is to be opened
1196 pub chain_hash: ChainHash,
1197 /// The short channel ID
1198 pub short_channel_id: u64,
1199 /// One of the two `node_id`s which are endpoints of this channel
1200 pub node_id_1: NodeId,
1201 /// The other of the two `node_id`s which are endpoints of this channel
1202 pub node_id_2: NodeId,
1203 /// The funding key for the first node
1204 pub bitcoin_key_1: NodeId,
1205 /// The funding key for the second node
1206 pub bitcoin_key_2: NodeId,
1207 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1210 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1211 pub excess_data: Vec<u8>,
1213 /// A [`channel_announcement`] message to be sent to or received from a peer.
1215 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
1216 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1217 pub struct ChannelAnnouncement {
1218 /// Authentication of the announcement by the first public node
1219 pub node_signature_1: Signature,
1220 /// Authentication of the announcement by the second public node
1221 pub node_signature_2: Signature,
1222 /// Proof of funding UTXO ownership by the first public node
1223 pub bitcoin_signature_1: Signature,
1224 /// Proof of funding UTXO ownership by the second public node
1225 pub bitcoin_signature_2: Signature,
1226 /// The actual announcement
1227 pub contents: UnsignedChannelAnnouncement,
1230 /// The unsigned part of a [`channel_update`] message.
1232 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1233 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1234 pub struct UnsignedChannelUpdate {
1235 /// The genesis hash of the blockchain where the channel is to be opened
1236 pub chain_hash: ChainHash,
1237 /// The short channel ID
1238 pub short_channel_id: u64,
1239 /// A strictly monotonic announcement counter, with gaps allowed, specific to this channel
1243 /// The number of blocks such that if:
1244 /// `incoming_htlc.cltv_expiry < outgoing_htlc.cltv_expiry + cltv_expiry_delta`
1245 /// then we need to fail the HTLC backwards. When forwarding an HTLC, `cltv_expiry_delta` determines
1246 /// the outgoing HTLC's minimum `cltv_expiry` value -- so, if an incoming HTLC comes in with a
1247 /// `cltv_expiry` of 100000, and the node we're forwarding to has a `cltv_expiry_delta` value of 10,
1248 /// then we'll check that the outgoing HTLC's `cltv_expiry` value is at least 100010 before
1249 /// forwarding. Note that the HTLC sender is the one who originally sets this value when
1250 /// constructing the route.
1251 pub cltv_expiry_delta: u16,
1252 /// The minimum HTLC size incoming to sender, in milli-satoshi
1253 pub htlc_minimum_msat: u64,
1254 /// The maximum HTLC value incoming to sender, in milli-satoshi.
1256 /// This used to be optional.
1257 pub htlc_maximum_msat: u64,
1258 /// The base HTLC fee charged by sender, in milli-satoshi
1259 pub fee_base_msat: u32,
1260 /// The amount to fee multiplier, in micro-satoshi
1261 pub fee_proportional_millionths: u32,
1262 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1265 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1266 pub excess_data: Vec<u8>,
1268 /// A [`channel_update`] message to be sent to or received from a peer.
1270 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1271 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1272 pub struct ChannelUpdate {
1273 /// A signature of the channel update
1274 pub signature: Signature,
1275 /// The actual channel update
1276 pub contents: UnsignedChannelUpdate,
1279 /// A [`query_channel_range`] message is used to query a peer for channel
1280 /// UTXOs in a range of blocks. The recipient of a query makes a best
1281 /// effort to reply to the query using one or more [`ReplyChannelRange`]
1284 /// [`query_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1285 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1286 pub struct QueryChannelRange {
1287 /// The genesis hash of the blockchain being queried
1288 pub chain_hash: ChainHash,
1289 /// The height of the first block for the channel UTXOs being queried
1290 pub first_blocknum: u32,
1291 /// The number of blocks to include in the query results
1292 pub number_of_blocks: u32,
1295 /// A [`reply_channel_range`] message is a reply to a [`QueryChannelRange`]
1298 /// Multiple `reply_channel_range` messages can be sent in reply
1299 /// to a single [`QueryChannelRange`] message. The query recipient makes a
1300 /// best effort to respond based on their local network view which may
1301 /// not be a perfect view of the network. The `short_channel_id`s in the
1302 /// reply are encoded. We only support `encoding_type=0` uncompressed
1303 /// serialization and do not support `encoding_type=1` zlib serialization.
1305 /// [`reply_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1306 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1307 pub struct ReplyChannelRange {
1308 /// The genesis hash of the blockchain being queried
1309 pub chain_hash: ChainHash,
1310 /// The height of the first block in the range of the reply
1311 pub first_blocknum: u32,
1312 /// The number of blocks included in the range of the reply
1313 pub number_of_blocks: u32,
1314 /// True when this is the final reply for a query
1315 pub sync_complete: bool,
1316 /// The `short_channel_id`s in the channel range
1317 pub short_channel_ids: Vec<u64>,
1320 /// A [`query_short_channel_ids`] message is used to query a peer for
1321 /// routing gossip messages related to one or more `short_channel_id`s.
1323 /// The query recipient will reply with the latest, if available,
1324 /// [`ChannelAnnouncement`], [`ChannelUpdate`] and [`NodeAnnouncement`] messages
1325 /// it maintains for the requested `short_channel_id`s followed by a
1326 /// [`ReplyShortChannelIdsEnd`] message. The `short_channel_id`s sent in
1327 /// this query are encoded. We only support `encoding_type=0` uncompressed
1328 /// serialization and do not support `encoding_type=1` zlib serialization.
1330 /// [`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
1331 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1332 pub struct QueryShortChannelIds {
1333 /// The genesis hash of the blockchain being queried
1334 pub chain_hash: ChainHash,
1335 /// The short_channel_ids that are being queried
1336 pub short_channel_ids: Vec<u64>,
1339 /// A [`reply_short_channel_ids_end`] message is sent as a reply to a
1340 /// message. The query recipient makes a best
1341 /// effort to respond based on their local network view which may not be
1342 /// a perfect view of the network.
1344 /// [`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
1345 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1346 pub struct ReplyShortChannelIdsEnd {
1347 /// The genesis hash of the blockchain that was queried
1348 pub chain_hash: ChainHash,
1349 /// Indicates if the query recipient maintains up-to-date channel
1350 /// information for the `chain_hash`
1351 pub full_information: bool,
1354 /// A [`gossip_timestamp_filter`] message is used by a node to request
1355 /// gossip relay for messages in the requested time range when the
1356 /// `gossip_queries` feature has been negotiated.
1358 /// [`gossip_timestamp_filter`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-gossip_timestamp_filter-message
1359 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1360 pub struct GossipTimestampFilter {
1361 /// The genesis hash of the blockchain for channel and node information
1362 pub chain_hash: ChainHash,
1363 /// The starting unix timestamp
1364 pub first_timestamp: u32,
1365 /// The range of information in seconds
1366 pub timestamp_range: u32,
1369 /// Encoding type for data compression of collections in gossip queries.
1371 /// We do not support `encoding_type=1` zlib serialization [defined in BOLT
1372 /// #7](https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#query-messages).
1374 Uncompressed = 0x00,
1377 /// Used to put an error message in a [`LightningError`].
1378 #[derive(Clone, Debug, Hash, PartialEq)]
1379 pub enum ErrorAction {
1380 /// The peer took some action which made us think they were useless. Disconnect them.
1382 /// An error message which we should make an effort to send before we disconnect.
1383 msg: Option<ErrorMessage>
1385 /// The peer did something incorrect. Tell them without closing any channels and disconnect them.
1386 DisconnectPeerWithWarning {
1387 /// A warning message which we should make an effort to send before we disconnect.
1388 msg: WarningMessage,
1390 /// The peer did something harmless that we weren't able to process, just log and ignore
1391 // New code should *not* use this. New code must use IgnoreAndLog, below!
1393 /// The peer did something harmless that we weren't able to meaningfully process.
1394 /// If the error is logged, log it at the given level.
1395 IgnoreAndLog(logger::Level),
1396 /// The peer provided us with a gossip message which we'd already seen. In most cases this
1397 /// should be ignored, but it may result in the message being forwarded if it is a duplicate of
1398 /// our own channel announcements.
1399 IgnoreDuplicateGossip,
1400 /// The peer did something incorrect. Tell them.
1402 /// The message to send.
1405 /// The peer did something incorrect. Tell them without closing any channels.
1406 SendWarningMessage {
1407 /// The message to send.
1408 msg: WarningMessage,
1409 /// The peer may have done something harmless that we weren't able to meaningfully process,
1410 /// though we should still tell them about it.
1411 /// If this event is logged, log it at the given level.
1412 log_level: logger::Level,
1416 /// An Err type for failure to process messages.
1417 #[derive(Clone, Debug)]
1418 pub struct LightningError {
1419 /// A human-readable message describing the error
1421 /// The action which should be taken against the offending peer.
1422 pub action: ErrorAction,
1425 /// Struct used to return values from [`RevokeAndACK`] messages, containing a bunch of commitment
1426 /// transaction updates if they were pending.
1427 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1428 pub struct CommitmentUpdate {
1429 /// `update_add_htlc` messages which should be sent
1430 pub update_add_htlcs: Vec<UpdateAddHTLC>,
1431 /// `update_fulfill_htlc` messages which should be sent
1432 pub update_fulfill_htlcs: Vec<UpdateFulfillHTLC>,
1433 /// `update_fail_htlc` messages which should be sent
1434 pub update_fail_htlcs: Vec<UpdateFailHTLC>,
1435 /// `update_fail_malformed_htlc` messages which should be sent
1436 pub update_fail_malformed_htlcs: Vec<UpdateFailMalformedHTLC>,
1437 /// An `update_fee` message which should be sent
1438 pub update_fee: Option<UpdateFee>,
1439 /// A `commitment_signed` message which should be sent
1440 pub commitment_signed: CommitmentSigned,
1443 /// A trait to describe an object which can receive channel messages.
1445 /// Messages MAY be called in parallel when they originate from different `their_node_ids`, however
1446 /// they MUST NOT be called in parallel when the two calls have the same `their_node_id`.
1447 pub trait ChannelMessageHandler : MessageSendEventsProvider {
1449 /// Handle an incoming `open_channel` message from the given peer.
1450 fn handle_open_channel(&self, their_node_id: &PublicKey, msg: &OpenChannel);
1451 /// Handle an incoming `open_channel2` message from the given peer.
1452 fn handle_open_channel_v2(&self, their_node_id: &PublicKey, msg: &OpenChannelV2);
1453 /// Handle an incoming `accept_channel` message from the given peer.
1454 fn handle_accept_channel(&self, their_node_id: &PublicKey, msg: &AcceptChannel);
1455 /// Handle an incoming `accept_channel2` message from the given peer.
1456 fn handle_accept_channel_v2(&self, their_node_id: &PublicKey, msg: &AcceptChannelV2);
1457 /// Handle an incoming `funding_created` message from the given peer.
1458 fn handle_funding_created(&self, their_node_id: &PublicKey, msg: &FundingCreated);
1459 /// Handle an incoming `funding_signed` message from the given peer.
1460 fn handle_funding_signed(&self, their_node_id: &PublicKey, msg: &FundingSigned);
1461 /// Handle an incoming `channel_ready` message from the given peer.
1462 fn handle_channel_ready(&self, their_node_id: &PublicKey, msg: &ChannelReady);
1465 /// Handle an incoming `shutdown` message from the given peer.
1466 fn handle_shutdown(&self, their_node_id: &PublicKey, msg: &Shutdown);
1467 /// Handle an incoming `closing_signed` message from the given peer.
1468 fn handle_closing_signed(&self, their_node_id: &PublicKey, msg: &ClosingSigned);
1471 /// Handle an incoming `stfu` message from the given peer.
1472 fn handle_stfu(&self, their_node_id: &PublicKey, msg: &Stfu);
1475 /// Handle an incoming `splice` message from the given peer.
1476 fn handle_splice(&self, their_node_id: &PublicKey, msg: &Splice);
1477 /// Handle an incoming `splice_ack` message from the given peer.
1478 fn handle_splice_ack(&self, their_node_id: &PublicKey, msg: &SpliceAck);
1479 /// Handle an incoming `splice_locked` message from the given peer.
1480 fn handle_splice_locked(&self, their_node_id: &PublicKey, msg: &SpliceLocked);
1482 // Interactive channel construction
1483 /// Handle an incoming `tx_add_input message` from the given peer.
1484 fn handle_tx_add_input(&self, their_node_id: &PublicKey, msg: &TxAddInput);
1485 /// Handle an incoming `tx_add_output` message from the given peer.
1486 fn handle_tx_add_output(&self, their_node_id: &PublicKey, msg: &TxAddOutput);
1487 /// Handle an incoming `tx_remove_input` message from the given peer.
1488 fn handle_tx_remove_input(&self, their_node_id: &PublicKey, msg: &TxRemoveInput);
1489 /// Handle an incoming `tx_remove_output` message from the given peer.
1490 fn handle_tx_remove_output(&self, their_node_id: &PublicKey, msg: &TxRemoveOutput);
1491 /// Handle an incoming `tx_complete message` from the given peer.
1492 fn handle_tx_complete(&self, their_node_id: &PublicKey, msg: &TxComplete);
1493 /// Handle an incoming `tx_signatures` message from the given peer.
1494 fn handle_tx_signatures(&self, their_node_id: &PublicKey, msg: &TxSignatures);
1495 /// Handle an incoming `tx_init_rbf` message from the given peer.
1496 fn handle_tx_init_rbf(&self, their_node_id: &PublicKey, msg: &TxInitRbf);
1497 /// Handle an incoming `tx_ack_rbf` message from the given peer.
1498 fn handle_tx_ack_rbf(&self, their_node_id: &PublicKey, msg: &TxAckRbf);
1499 /// Handle an incoming `tx_abort message` from the given peer.
1500 fn handle_tx_abort(&self, their_node_id: &PublicKey, msg: &TxAbort);
1503 /// Handle an incoming `update_add_htlc` message from the given peer.
1504 fn handle_update_add_htlc(&self, their_node_id: &PublicKey, msg: &UpdateAddHTLC);
1505 /// Handle an incoming `update_fulfill_htlc` message from the given peer.
1506 fn handle_update_fulfill_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFulfillHTLC);
1507 /// Handle an incoming `update_fail_htlc` message from the given peer.
1508 fn handle_update_fail_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailHTLC);
1509 /// Handle an incoming `update_fail_malformed_htlc` message from the given peer.
1510 fn handle_update_fail_malformed_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailMalformedHTLC);
1511 /// Handle an incoming `commitment_signed` message from the given peer.
1512 fn handle_commitment_signed(&self, their_node_id: &PublicKey, msg: &CommitmentSigned);
1513 /// Handle an incoming `revoke_and_ack` message from the given peer.
1514 fn handle_revoke_and_ack(&self, their_node_id: &PublicKey, msg: &RevokeAndACK);
1516 /// Handle an incoming `update_fee` message from the given peer.
1517 fn handle_update_fee(&self, their_node_id: &PublicKey, msg: &UpdateFee);
1519 // Channel-to-announce:
1520 /// Handle an incoming `announcement_signatures` message from the given peer.
1521 fn handle_announcement_signatures(&self, their_node_id: &PublicKey, msg: &AnnouncementSignatures);
1523 // Connection loss/reestablish:
1524 /// Indicates a connection to the peer failed/an existing connection was lost.
1525 fn peer_disconnected(&self, their_node_id: &PublicKey);
1527 /// Handle a peer reconnecting, possibly generating `channel_reestablish` message(s).
1529 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1530 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1531 /// message handlers may still wish to communicate with this peer.
1532 fn peer_connected(&self, their_node_id: &PublicKey, msg: &Init, inbound: bool) -> Result<(), ()>;
1533 /// Handle an incoming `channel_reestablish` message from the given peer.
1534 fn handle_channel_reestablish(&self, their_node_id: &PublicKey, msg: &ChannelReestablish);
1536 /// Handle an incoming `channel_update` message from the given peer.
1537 fn handle_channel_update(&self, their_node_id: &PublicKey, msg: &ChannelUpdate);
1540 /// Handle an incoming `error` message from the given peer.
1541 fn handle_error(&self, their_node_id: &PublicKey, msg: &ErrorMessage);
1543 // Handler information:
1544 /// Gets the node feature flags which this handler itself supports. All available handlers are
1545 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1546 /// which are broadcasted in our [`NodeAnnouncement`] message.
1547 fn provided_node_features(&self) -> NodeFeatures;
1549 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1550 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1551 /// which are sent in our [`Init`] message.
1553 /// Note that this method is called before [`Self::peer_connected`].
1554 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1556 /// Gets the chain hashes for this `ChannelMessageHandler` indicating which chains it supports.
1558 /// If it's `None`, then no particular network chain hash compatibility will be enforced when
1559 /// connecting to peers.
1560 fn get_chain_hashes(&self) -> Option<Vec<ChainHash>>;
1563 /// A trait to describe an object which can receive routing messages.
1565 /// # Implementor DoS Warnings
1567 /// For messages enabled with the `gossip_queries` feature there are potential DoS vectors when
1568 /// handling inbound queries. Implementors using an on-disk network graph should be aware of
1569 /// repeated disk I/O for queries accessing different parts of the network graph.
1570 pub trait RoutingMessageHandler : MessageSendEventsProvider {
1571 /// Handle an incoming `node_announcement` message, returning `true` if it should be forwarded on,
1572 /// `false` or returning an `Err` otherwise.
1573 fn handle_node_announcement(&self, msg: &NodeAnnouncement) -> Result<bool, LightningError>;
1574 /// Handle a `channel_announcement` message, returning `true` if it should be forwarded on, `false`
1575 /// or returning an `Err` otherwise.
1576 fn handle_channel_announcement(&self, msg: &ChannelAnnouncement) -> Result<bool, LightningError>;
1577 /// Handle an incoming `channel_update` message, returning true if it should be forwarded on,
1578 /// `false` or returning an `Err` otherwise.
1579 fn handle_channel_update(&self, msg: &ChannelUpdate) -> Result<bool, LightningError>;
1580 /// Gets channel announcements and updates required to dump our routing table to a remote node,
1581 /// starting at the `short_channel_id` indicated by `starting_point` and including announcements
1582 /// for a single channel.
1583 fn get_next_channel_announcement(&self, starting_point: u64) -> Option<(ChannelAnnouncement, Option<ChannelUpdate>, Option<ChannelUpdate>)>;
1584 /// Gets a node announcement required to dump our routing table to a remote node, starting at
1585 /// the node *after* the provided pubkey and including up to one announcement immediately
1586 /// higher (as defined by `<PublicKey as Ord>::cmp`) than `starting_point`.
1587 /// If `None` is provided for `starting_point`, we start at the first node.
1588 fn get_next_node_announcement(&self, starting_point: Option<&NodeId>) -> Option<NodeAnnouncement>;
1589 /// Called when a connection is established with a peer. This can be used to
1590 /// perform routing table synchronization using a strategy defined by the
1593 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1594 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1595 /// message handlers may still wish to communicate with this peer.
1596 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1597 /// Handles the reply of a query we initiated to learn about channels
1598 /// for a given range of blocks. We can expect to receive one or more
1599 /// replies to a single query.
1600 fn handle_reply_channel_range(&self, their_node_id: &PublicKey, msg: ReplyChannelRange) -> Result<(), LightningError>;
1601 /// Handles the reply of a query we initiated asking for routing gossip
1602 /// messages for a list of channels. We should receive this message when
1603 /// a node has completed its best effort to send us the pertaining routing
1604 /// gossip messages.
1605 fn handle_reply_short_channel_ids_end(&self, their_node_id: &PublicKey, msg: ReplyShortChannelIdsEnd) -> Result<(), LightningError>;
1606 /// Handles when a peer asks us to send a list of `short_channel_id`s
1607 /// for the requested range of blocks.
1608 fn handle_query_channel_range(&self, their_node_id: &PublicKey, msg: QueryChannelRange) -> Result<(), LightningError>;
1609 /// Handles when a peer asks us to send routing gossip messages for a
1610 /// list of `short_channel_id`s.
1611 fn handle_query_short_channel_ids(&self, their_node_id: &PublicKey, msg: QueryShortChannelIds) -> Result<(), LightningError>;
1613 // Handler queueing status:
1614 /// Indicates that there are a large number of [`ChannelAnnouncement`] (or other) messages
1615 /// pending some async action. While there is no guarantee of the rate of future messages, the
1616 /// caller should seek to reduce the rate of new gossip messages handled, especially
1617 /// [`ChannelAnnouncement`]s.
1618 fn processing_queue_high(&self) -> bool;
1620 // Handler information:
1621 /// Gets the node feature flags which this handler itself supports. All available handlers are
1622 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1623 /// which are broadcasted in our [`NodeAnnouncement`] message.
1624 fn provided_node_features(&self) -> NodeFeatures;
1625 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1626 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1627 /// which are sent in our [`Init`] message.
1629 /// Note that this method is called before [`Self::peer_connected`].
1630 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1633 /// A handler for received [`OnionMessage`]s and for providing generated ones to send.
1634 pub trait OnionMessageHandler: EventsProvider {
1635 /// Handle an incoming `onion_message` message from the given peer.
1636 fn handle_onion_message(&self, peer_node_id: &PublicKey, msg: &OnionMessage);
1638 /// Returns the next pending onion message for the peer with the given node id.
1639 fn next_onion_message_for_peer(&self, peer_node_id: PublicKey) -> Option<OnionMessage>;
1641 /// Called when a connection is established with a peer. Can be used to track which peers
1642 /// advertise onion message support and are online.
1644 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1645 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1646 /// message handlers may still wish to communicate with this peer.
1647 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1649 /// Indicates a connection to the peer failed/an existing connection was lost. Allows handlers to
1650 /// drop and refuse to forward onion messages to this peer.
1651 fn peer_disconnected(&self, their_node_id: &PublicKey);
1653 /// Performs actions that should happen roughly every ten seconds after startup. Allows handlers
1654 /// to drop any buffered onion messages intended for prospective peers.
1655 fn timer_tick_occurred(&self);
1657 // Handler information:
1658 /// Gets the node feature flags which this handler itself supports. All available handlers are
1659 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1660 /// which are broadcasted in our [`NodeAnnouncement`] message.
1661 fn provided_node_features(&self) -> NodeFeatures;
1663 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1664 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1665 /// which are sent in our [`Init`] message.
1667 /// Note that this method is called before [`Self::peer_connected`].
1668 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1671 mod fuzzy_internal_msgs {
1672 use bitcoin::secp256k1::PublicKey;
1673 use crate::blinded_path::payment::{PaymentConstraints, PaymentRelay};
1674 use crate::prelude::*;
1675 use crate::ln::{PaymentPreimage, PaymentSecret};
1676 use crate::ln::features::BlindedHopFeatures;
1678 // These types aren't intended to be pub, but are exposed for direct fuzzing (as we deserialize
1679 // them from untrusted input):
1681 pub struct FinalOnionHopData {
1682 pub payment_secret: PaymentSecret,
1683 /// The total value, in msat, of the payment as received by the ultimate recipient.
1684 /// Message serialization may panic if this value is more than 21 million Bitcoin.
1685 pub total_msat: u64,
1688 pub enum InboundOnionPayload {
1690 short_channel_id: u64,
1691 /// The value, in msat, of the payment after this hop's fee is deducted.
1692 amt_to_forward: u64,
1693 outgoing_cltv_value: u32,
1696 payment_data: Option<FinalOnionHopData>,
1697 payment_metadata: Option<Vec<u8>>,
1698 keysend_preimage: Option<PaymentPreimage>,
1699 custom_tlvs: Vec<(u64, Vec<u8>)>,
1701 outgoing_cltv_value: u32,
1704 short_channel_id: u64,
1705 payment_relay: PaymentRelay,
1706 payment_constraints: PaymentConstraints,
1707 features: BlindedHopFeatures,
1708 intro_node_blinding_point: PublicKey,
1713 outgoing_cltv_value: u32,
1714 payment_secret: PaymentSecret,
1715 payment_constraints: PaymentConstraints,
1716 intro_node_blinding_point: PublicKey,
1720 pub(crate) enum OutboundOnionPayload {
1722 short_channel_id: u64,
1723 /// The value, in msat, of the payment after this hop's fee is deducted.
1724 amt_to_forward: u64,
1725 outgoing_cltv_value: u32,
1728 payment_data: Option<FinalOnionHopData>,
1729 payment_metadata: Option<Vec<u8>>,
1730 keysend_preimage: Option<PaymentPreimage>,
1731 custom_tlvs: Vec<(u64, Vec<u8>)>,
1733 outgoing_cltv_value: u32,
1736 encrypted_tlvs: Vec<u8>,
1737 intro_node_blinding_point: Option<PublicKey>,
1742 outgoing_cltv_value: u32,
1743 encrypted_tlvs: Vec<u8>,
1744 intro_node_blinding_point: Option<PublicKey>, // Set if the introduction node of the blinded path is the final node
1748 pub struct DecodedOnionErrorPacket {
1749 pub(crate) hmac: [u8; 32],
1750 pub(crate) failuremsg: Vec<u8>,
1751 pub(crate) pad: Vec<u8>,
1755 pub use self::fuzzy_internal_msgs::*;
1756 #[cfg(not(fuzzing))]
1757 pub(crate) use self::fuzzy_internal_msgs::*;
1759 /// BOLT 4 onion packet including hop data for the next peer.
1760 #[derive(Clone, Hash, PartialEq, Eq)]
1761 pub struct OnionPacket {
1762 /// BOLT 4 version number.
1764 /// In order to ensure we always return an error on onion decode in compliance with [BOLT
1765 /// #4](https://github.com/lightning/bolts/blob/master/04-onion-routing.md), we have to
1766 /// deserialize `OnionPacket`s contained in [`UpdateAddHTLC`] messages even if the ephemeral
1767 /// public key (here) is bogus, so we hold a [`Result`] instead of a [`PublicKey`] as we'd
1769 pub public_key: Result<PublicKey, secp256k1::Error>,
1770 /// 1300 bytes encrypted payload for the next hop.
1771 pub hop_data: [u8; 20*65],
1772 /// HMAC to verify the integrity of hop_data.
1776 impl onion_utils::Packet for OnionPacket {
1777 type Data = onion_utils::FixedSizeOnionPacket;
1778 fn new(pubkey: PublicKey, hop_data: onion_utils::FixedSizeOnionPacket, hmac: [u8; 32]) -> Self {
1781 public_key: Ok(pubkey),
1782 hop_data: hop_data.0,
1788 impl fmt::Debug for OnionPacket {
1789 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1790 f.write_fmt(format_args!("OnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
1794 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1795 pub(crate) struct OnionErrorPacket {
1796 // This really should be a constant size slice, but the spec lets these things be up to 128KB?
1797 // (TODO) We limit it in decode to much lower...
1798 pub(crate) data: Vec<u8>,
1801 impl fmt::Display for DecodeError {
1802 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1804 DecodeError::UnknownVersion => f.write_str("Unknown realm byte in Onion packet"),
1805 DecodeError::UnknownRequiredFeature => f.write_str("Unknown required feature preventing decode"),
1806 DecodeError::InvalidValue => f.write_str("Nonsense bytes didn't map to the type they were interpreted as"),
1807 DecodeError::ShortRead => f.write_str("Packet extended beyond the provided bytes"),
1808 DecodeError::BadLengthDescriptor => f.write_str("A length descriptor in the packet didn't describe the later data correctly"),
1809 DecodeError::Io(ref e) => fmt::Debug::fmt(e, f),
1810 DecodeError::UnsupportedCompression => f.write_str("We don't support receiving messages with zlib-compressed fields"),
1815 impl From<io::Error> for DecodeError {
1816 fn from(e: io::Error) -> Self {
1817 if e.kind() == io::ErrorKind::UnexpectedEof {
1818 DecodeError::ShortRead
1820 DecodeError::Io(e.kind())
1825 #[cfg(not(taproot))]
1826 impl_writeable_msg!(AcceptChannel, {
1827 temporary_channel_id,
1828 dust_limit_satoshis,
1829 max_htlc_value_in_flight_msat,
1830 channel_reserve_satoshis,
1836 revocation_basepoint,
1838 delayed_payment_basepoint,
1840 first_per_commitment_point,
1842 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))), // Don't encode length twice.
1843 (1, channel_type, option),
1847 impl_writeable_msg!(AcceptChannel, {
1848 temporary_channel_id,
1849 dust_limit_satoshis,
1850 max_htlc_value_in_flight_msat,
1851 channel_reserve_satoshis,
1857 revocation_basepoint,
1859 delayed_payment_basepoint,
1861 first_per_commitment_point,
1863 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))), // Don't encode length twice.
1864 (1, channel_type, option),
1865 (4, next_local_nonce, option),
1868 impl_writeable_msg!(AcceptChannelV2, {
1869 temporary_channel_id,
1871 dust_limit_satoshis,
1872 max_htlc_value_in_flight_msat,
1878 revocation_basepoint,
1880 delayed_payment_basepoint,
1882 first_per_commitment_point,
1883 second_per_commitment_point,
1885 (0, shutdown_scriptpubkey, option),
1886 (1, channel_type, option),
1887 (2, require_confirmed_inputs, option),
1890 impl_writeable_msg!(Stfu, {
1895 impl_writeable_msg!(Splice, {
1899 funding_feerate_perkw,
1904 impl_writeable_msg!(SpliceAck, {
1911 impl_writeable_msg!(SpliceLocked, {
1915 impl_writeable_msg!(TxAddInput, {
1923 impl_writeable_msg!(TxAddOutput, {
1930 impl_writeable_msg!(TxRemoveInput, {
1935 impl_writeable_msg!(TxRemoveOutput, {
1940 impl_writeable_msg!(TxComplete, {
1944 impl_writeable_msg!(TxSignatures, {
1950 impl_writeable_msg!(TxInitRbf, {
1953 feerate_sat_per_1000_weight,
1955 (0, funding_output_contribution, option),
1958 impl_writeable_msg!(TxAckRbf, {
1961 (0, funding_output_contribution, option),
1964 impl_writeable_msg!(TxAbort, {
1969 impl_writeable_msg!(AnnouncementSignatures, {
1976 impl_writeable_msg!(ChannelReestablish, {
1978 next_local_commitment_number,
1979 next_remote_commitment_number,
1980 your_last_per_commitment_secret,
1981 my_current_per_commitment_point,
1983 (0, next_funding_txid, option),
1986 impl_writeable_msg!(ClosingSigned,
1987 { channel_id, fee_satoshis, signature },
1988 { (1, fee_range, option) }
1991 impl_writeable!(ClosingSignedFeeRange, {
1996 #[cfg(not(taproot))]
1997 impl_writeable_msg!(CommitmentSigned, {
2004 impl_writeable_msg!(CommitmentSigned, {
2009 (2, partial_signature_with_nonce, option)
2012 impl_writeable!(DecodedOnionErrorPacket, {
2018 #[cfg(not(taproot))]
2019 impl_writeable_msg!(FundingCreated, {
2020 temporary_channel_id,
2022 funding_output_index,
2026 impl_writeable_msg!(FundingCreated, {
2027 temporary_channel_id,
2029 funding_output_index,
2032 (2, partial_signature_with_nonce, option),
2033 (4, next_local_nonce, option)
2036 #[cfg(not(taproot))]
2037 impl_writeable_msg!(FundingSigned, {
2043 impl_writeable_msg!(FundingSigned, {
2047 (2, partial_signature_with_nonce, option)
2050 impl_writeable_msg!(ChannelReady, {
2052 next_per_commitment_point,
2054 (1, short_channel_id_alias, option),
2057 impl Writeable for Init {
2058 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2059 // global_features gets the bottom 13 bits of our features, and local_features gets all of
2060 // our relevant feature bits. This keeps us compatible with old nodes.
2061 self.features.write_up_to_13(w)?;
2062 self.features.write(w)?;
2063 encode_tlv_stream!(w, {
2064 (1, self.networks.as_ref().map(|n| WithoutLength(n)), option),
2065 (3, self.remote_network_address, option),
2071 impl Readable for Init {
2072 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2073 let global_features: InitFeatures = Readable::read(r)?;
2074 let features: InitFeatures = Readable::read(r)?;
2075 let mut remote_network_address: Option<SocketAddress> = None;
2076 let mut networks: Option<WithoutLength<Vec<ChainHash>>> = None;
2077 decode_tlv_stream!(r, {
2078 (1, networks, option),
2079 (3, remote_network_address, option)
2082 features: features | global_features,
2083 networks: networks.map(|n| n.0),
2084 remote_network_address,
2089 impl_writeable_msg!(OpenChannel, {
2091 temporary_channel_id,
2094 dust_limit_satoshis,
2095 max_htlc_value_in_flight_msat,
2096 channel_reserve_satoshis,
2102 revocation_basepoint,
2104 delayed_payment_basepoint,
2106 first_per_commitment_point,
2109 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))), // Don't encode length twice.
2110 (1, channel_type, option),
2113 impl_writeable_msg!(OpenChannelV2, {
2115 temporary_channel_id,
2116 funding_feerate_sat_per_1000_weight,
2117 commitment_feerate_sat_per_1000_weight,
2119 dust_limit_satoshis,
2120 max_htlc_value_in_flight_msat,
2126 revocation_basepoint,
2128 delayed_payment_basepoint,
2130 first_per_commitment_point,
2131 second_per_commitment_point,
2134 (0, shutdown_scriptpubkey, option),
2135 (1, channel_type, option),
2136 (2, require_confirmed_inputs, option),
2139 #[cfg(not(taproot))]
2140 impl_writeable_msg!(RevokeAndACK, {
2142 per_commitment_secret,
2143 next_per_commitment_point
2147 impl_writeable_msg!(RevokeAndACK, {
2149 per_commitment_secret,
2150 next_per_commitment_point
2152 (4, next_local_nonce, option)
2155 impl_writeable_msg!(Shutdown, {
2160 impl_writeable_msg!(UpdateFailHTLC, {
2166 impl_writeable_msg!(UpdateFailMalformedHTLC, {
2173 impl_writeable_msg!(UpdateFee, {
2178 impl_writeable_msg!(UpdateFulfillHTLC, {
2184 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2185 // serialization format in a way which assumes we know the total serialized length/message end
2187 impl_writeable!(OnionErrorPacket, {
2191 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2192 // serialization format in a way which assumes we know the total serialized length/message end
2194 impl Writeable for OnionPacket {
2195 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2196 self.version.write(w)?;
2197 match self.public_key {
2198 Ok(pubkey) => pubkey.write(w)?,
2199 Err(_) => [0u8;33].write(w)?,
2201 w.write_all(&self.hop_data)?;
2202 self.hmac.write(w)?;
2207 impl Readable for OnionPacket {
2208 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2210 version: Readable::read(r)?,
2212 let mut buf = [0u8;33];
2213 r.read_exact(&mut buf)?;
2214 PublicKey::from_slice(&buf)
2216 hop_data: Readable::read(r)?,
2217 hmac: Readable::read(r)?,
2222 impl_writeable_msg!(UpdateAddHTLC, {
2228 onion_routing_packet,
2230 (0, blinding_point, option),
2231 (65537, skimmed_fee_msat, option)
2234 impl Readable for OnionMessage {
2235 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2236 let blinding_point: PublicKey = Readable::read(r)?;
2237 let len: u16 = Readable::read(r)?;
2238 let mut packet_reader = FixedLengthReader::new(r, len as u64);
2239 let onion_routing_packet: onion_message::Packet = <onion_message::Packet as LengthReadable>::read(&mut packet_reader)?;
2242 onion_routing_packet,
2247 impl Writeable for OnionMessage {
2248 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2249 self.blinding_point.write(w)?;
2250 let onion_packet_len = self.onion_routing_packet.serialized_length();
2251 (onion_packet_len as u16).write(w)?;
2252 self.onion_routing_packet.write(w)?;
2257 impl Writeable for FinalOnionHopData {
2258 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2259 self.payment_secret.0.write(w)?;
2260 HighZeroBytesDroppedBigSize(self.total_msat).write(w)
2264 impl Readable for FinalOnionHopData {
2265 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2266 let secret: [u8; 32] = Readable::read(r)?;
2267 let amt: HighZeroBytesDroppedBigSize<u64> = Readable::read(r)?;
2268 Ok(Self { payment_secret: PaymentSecret(secret), total_msat: amt.0 })
2272 impl Writeable for OutboundOnionPayload {
2273 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2275 Self::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } => {
2276 _encode_varint_length_prefixed_tlv!(w, {
2277 (2, HighZeroBytesDroppedBigSize(*amt_to_forward), required),
2278 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2279 (6, short_channel_id, required)
2283 ref payment_data, ref payment_metadata, ref keysend_preimage, amt_msat,
2284 outgoing_cltv_value, ref custom_tlvs,
2286 // We need to update [`ln::outbound_payment::RecipientOnionFields::with_custom_tlvs`]
2287 // to reject any reserved types in the experimental range if new ones are ever
2289 let keysend_tlv = keysend_preimage.map(|preimage| (5482373484, preimage.encode()));
2290 let mut custom_tlvs: Vec<&(u64, Vec<u8>)> = custom_tlvs.iter().chain(keysend_tlv.iter()).collect();
2291 custom_tlvs.sort_unstable_by_key(|(typ, _)| *typ);
2292 _encode_varint_length_prefixed_tlv!(w, {
2293 (2, HighZeroBytesDroppedBigSize(*amt_msat), required),
2294 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2295 (8, payment_data, option),
2296 (16, payment_metadata.as_ref().map(|m| WithoutLength(m)), option)
2297 }, custom_tlvs.iter());
2299 Self::BlindedForward { encrypted_tlvs, intro_node_blinding_point } => {
2300 _encode_varint_length_prefixed_tlv!(w, {
2301 (10, *encrypted_tlvs, required_vec),
2302 (12, intro_node_blinding_point, option)
2305 Self::BlindedReceive {
2306 amt_msat, total_msat, outgoing_cltv_value, encrypted_tlvs,
2307 intro_node_blinding_point,
2309 _encode_varint_length_prefixed_tlv!(w, {
2310 (2, HighZeroBytesDroppedBigSize(*amt_msat), required),
2311 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2312 (10, *encrypted_tlvs, required_vec),
2313 (12, intro_node_blinding_point, option),
2314 (18, HighZeroBytesDroppedBigSize(*total_msat), required)
2322 impl<NS: Deref> ReadableArgs<&NS> for InboundOnionPayload where NS::Target: NodeSigner {
2323 fn read<R: Read>(r: &mut R, node_signer: &NS) -> Result<Self, DecodeError> {
2325 let mut cltv_value = None;
2326 let mut short_id: Option<u64> = None;
2327 let mut payment_data: Option<FinalOnionHopData> = None;
2328 let mut encrypted_tlvs_opt: Option<WithoutLength<Vec<u8>>> = None;
2329 let mut intro_node_blinding_point = None;
2330 let mut payment_metadata: Option<WithoutLength<Vec<u8>>> = None;
2331 let mut total_msat = None;
2332 let mut keysend_preimage: Option<PaymentPreimage> = None;
2333 let mut custom_tlvs = Vec::new();
2335 let tlv_len = BigSize::read(r)?;
2336 let rd = FixedLengthReader::new(r, tlv_len.0);
2337 decode_tlv_stream_with_custom_tlv_decode!(rd, {
2338 (2, amt, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2339 (4, cltv_value, (option, encoding: (u32, HighZeroBytesDroppedBigSize))),
2340 (6, short_id, option),
2341 (8, payment_data, option),
2342 (10, encrypted_tlvs_opt, option),
2343 (12, intro_node_blinding_point, option),
2344 (16, payment_metadata, option),
2345 (18, total_msat, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2346 // See https://github.com/lightning/blips/blob/master/blip-0003.md
2347 (5482373484, keysend_preimage, option)
2348 }, |msg_type: u64, msg_reader: &mut FixedLengthReader<_>| -> Result<bool, DecodeError> {
2349 if msg_type < 1 << 16 { return Ok(false) }
2350 let mut value = Vec::new();
2351 msg_reader.read_to_end(&mut value)?;
2352 custom_tlvs.push((msg_type, value));
2356 if amt.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2358 if let Some(blinding_point) = intro_node_blinding_point {
2359 if short_id.is_some() || payment_data.is_some() || payment_metadata.is_some() {
2360 return Err(DecodeError::InvalidValue)
2362 let enc_tlvs = encrypted_tlvs_opt.ok_or(DecodeError::InvalidValue)?.0;
2363 let enc_tlvs_ss = node_signer.ecdh(Recipient::Node, &blinding_point, None)
2364 .map_err(|_| DecodeError::InvalidValue)?;
2365 let rho = onion_utils::gen_rho_from_shared_secret(&enc_tlvs_ss.secret_bytes());
2366 let mut s = Cursor::new(&enc_tlvs);
2367 let mut reader = FixedLengthReader::new(&mut s, enc_tlvs.len() as u64);
2368 match ChaChaPolyReadAdapter::read(&mut reader, rho)? {
2369 ChaChaPolyReadAdapter { readable: BlindedPaymentTlvs::Forward(ForwardTlvs {
2370 short_channel_id, payment_relay, payment_constraints, features
2372 if amt.is_some() || cltv_value.is_some() || total_msat.is_some() {
2373 return Err(DecodeError::InvalidValue)
2375 Ok(Self::BlindedForward {
2378 payment_constraints,
2380 intro_node_blinding_point: blinding_point,
2383 ChaChaPolyReadAdapter { readable: BlindedPaymentTlvs::Receive(ReceiveTlvs {
2384 payment_secret, payment_constraints
2386 if total_msat.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2387 Ok(Self::BlindedReceive {
2388 amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2389 total_msat: total_msat.ok_or(DecodeError::InvalidValue)?,
2390 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2392 payment_constraints,
2393 intro_node_blinding_point: blinding_point,
2397 } else if let Some(short_channel_id) = short_id {
2398 if payment_data.is_some() || payment_metadata.is_some() || encrypted_tlvs_opt.is_some() ||
2399 total_msat.is_some()
2400 { return Err(DecodeError::InvalidValue) }
2403 amt_to_forward: amt.ok_or(DecodeError::InvalidValue)?,
2404 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2407 if encrypted_tlvs_opt.is_some() || total_msat.is_some() {
2408 return Err(DecodeError::InvalidValue)
2410 if let Some(data) = &payment_data {
2411 if data.total_msat > MAX_VALUE_MSAT {
2412 return Err(DecodeError::InvalidValue);
2417 payment_metadata: payment_metadata.map(|w| w.0),
2419 amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2420 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2427 impl Writeable for Ping {
2428 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2429 self.ponglen.write(w)?;
2430 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2435 impl Readable for Ping {
2436 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2438 ponglen: Readable::read(r)?,
2440 let byteslen = Readable::read(r)?;
2441 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2448 impl Writeable for Pong {
2449 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2450 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2455 impl Readable for Pong {
2456 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2459 let byteslen = Readable::read(r)?;
2460 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2467 impl Writeable for UnsignedChannelAnnouncement {
2468 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2469 self.features.write(w)?;
2470 self.chain_hash.write(w)?;
2471 self.short_channel_id.write(w)?;
2472 self.node_id_1.write(w)?;
2473 self.node_id_2.write(w)?;
2474 self.bitcoin_key_1.write(w)?;
2475 self.bitcoin_key_2.write(w)?;
2476 w.write_all(&self.excess_data[..])?;
2481 impl Readable for UnsignedChannelAnnouncement {
2482 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2484 features: Readable::read(r)?,
2485 chain_hash: Readable::read(r)?,
2486 short_channel_id: Readable::read(r)?,
2487 node_id_1: Readable::read(r)?,
2488 node_id_2: Readable::read(r)?,
2489 bitcoin_key_1: Readable::read(r)?,
2490 bitcoin_key_2: Readable::read(r)?,
2491 excess_data: read_to_end(r)?,
2496 impl_writeable!(ChannelAnnouncement, {
2499 bitcoin_signature_1,
2500 bitcoin_signature_2,
2504 impl Writeable for UnsignedChannelUpdate {
2505 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2506 // `message_flags` used to indicate presence of `htlc_maximum_msat`, but was deprecated in the spec.
2507 const MESSAGE_FLAGS: u8 = 1;
2508 self.chain_hash.write(w)?;
2509 self.short_channel_id.write(w)?;
2510 self.timestamp.write(w)?;
2511 let all_flags = self.flags as u16 | ((MESSAGE_FLAGS as u16) << 8);
2512 all_flags.write(w)?;
2513 self.cltv_expiry_delta.write(w)?;
2514 self.htlc_minimum_msat.write(w)?;
2515 self.fee_base_msat.write(w)?;
2516 self.fee_proportional_millionths.write(w)?;
2517 self.htlc_maximum_msat.write(w)?;
2518 w.write_all(&self.excess_data[..])?;
2523 impl Readable for UnsignedChannelUpdate {
2524 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2526 chain_hash: Readable::read(r)?,
2527 short_channel_id: Readable::read(r)?,
2528 timestamp: Readable::read(r)?,
2530 let flags: u16 = Readable::read(r)?;
2531 // Note: we ignore the `message_flags` for now, since it was deprecated by the spec.
2534 cltv_expiry_delta: Readable::read(r)?,
2535 htlc_minimum_msat: Readable::read(r)?,
2536 fee_base_msat: Readable::read(r)?,
2537 fee_proportional_millionths: Readable::read(r)?,
2538 htlc_maximum_msat: Readable::read(r)?,
2539 excess_data: read_to_end(r)?,
2544 impl_writeable!(ChannelUpdate, {
2549 impl Writeable for ErrorMessage {
2550 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2551 self.channel_id.write(w)?;
2552 (self.data.len() as u16).write(w)?;
2553 w.write_all(self.data.as_bytes())?;
2558 impl Readable for ErrorMessage {
2559 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2561 channel_id: Readable::read(r)?,
2563 let sz: usize = <u16 as Readable>::read(r)? as usize;
2564 let mut data = Vec::with_capacity(sz);
2566 r.read_exact(&mut data)?;
2567 match String::from_utf8(data) {
2569 Err(_) => return Err(DecodeError::InvalidValue),
2576 impl Writeable for WarningMessage {
2577 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2578 self.channel_id.write(w)?;
2579 (self.data.len() as u16).write(w)?;
2580 w.write_all(self.data.as_bytes())?;
2585 impl Readable for WarningMessage {
2586 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2588 channel_id: Readable::read(r)?,
2590 let sz: usize = <u16 as Readable>::read(r)? as usize;
2591 let mut data = Vec::with_capacity(sz);
2593 r.read_exact(&mut data)?;
2594 match String::from_utf8(data) {
2596 Err(_) => return Err(DecodeError::InvalidValue),
2603 impl Writeable for UnsignedNodeAnnouncement {
2604 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2605 self.features.write(w)?;
2606 self.timestamp.write(w)?;
2607 self.node_id.write(w)?;
2608 w.write_all(&self.rgb)?;
2609 self.alias.write(w)?;
2611 let mut addr_len = 0;
2612 for addr in self.addresses.iter() {
2613 addr_len += 1 + addr.len();
2615 (addr_len + self.excess_address_data.len() as u16).write(w)?;
2616 for addr in self.addresses.iter() {
2619 w.write_all(&self.excess_address_data[..])?;
2620 w.write_all(&self.excess_data[..])?;
2625 impl Readable for UnsignedNodeAnnouncement {
2626 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2627 let features: NodeFeatures = Readable::read(r)?;
2628 let timestamp: u32 = Readable::read(r)?;
2629 let node_id: NodeId = Readable::read(r)?;
2630 let mut rgb = [0; 3];
2631 r.read_exact(&mut rgb)?;
2632 let alias: NodeAlias = Readable::read(r)?;
2634 let addr_len: u16 = Readable::read(r)?;
2635 let mut addresses: Vec<SocketAddress> = Vec::new();
2636 let mut addr_readpos = 0;
2637 let mut excess = false;
2638 let mut excess_byte = 0;
2640 if addr_len <= addr_readpos { break; }
2641 match Readable::read(r) {
2643 if addr_len < addr_readpos + 1 + addr.len() {
2644 return Err(DecodeError::BadLengthDescriptor);
2646 addr_readpos += (1 + addr.len()) as u16;
2647 addresses.push(addr);
2649 Ok(Err(unknown_descriptor)) => {
2651 excess_byte = unknown_descriptor;
2654 Err(DecodeError::ShortRead) => return Err(DecodeError::BadLengthDescriptor),
2655 Err(e) => return Err(e),
2659 let mut excess_data = vec![];
2660 let excess_address_data = if addr_readpos < addr_len {
2661 let mut excess_address_data = vec![0; (addr_len - addr_readpos) as usize];
2662 r.read_exact(&mut excess_address_data[if excess { 1 } else { 0 }..])?;
2664 excess_address_data[0] = excess_byte;
2669 excess_data.push(excess_byte);
2673 excess_data.extend(read_to_end(r)?.iter());
2674 Ok(UnsignedNodeAnnouncement {
2681 excess_address_data,
2687 impl_writeable!(NodeAnnouncement, {
2692 impl Readable for QueryShortChannelIds {
2693 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2694 let chain_hash: ChainHash = Readable::read(r)?;
2696 let encoding_len: u16 = Readable::read(r)?;
2697 let encoding_type: u8 = Readable::read(r)?;
2699 // Must be encoding_type=0 uncompressed serialization. We do not
2700 // support encoding_type=1 zlib serialization.
2701 if encoding_type != EncodingType::Uncompressed as u8 {
2702 return Err(DecodeError::UnsupportedCompression);
2705 // We expect the encoding_len to always includes the 1-byte
2706 // encoding_type and that short_channel_ids are 8-bytes each
2707 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2708 return Err(DecodeError::InvalidValue);
2711 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2712 // less the 1-byte encoding_type
2713 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2714 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2715 for _ in 0..short_channel_id_count {
2716 short_channel_ids.push(Readable::read(r)?);
2719 Ok(QueryShortChannelIds {
2726 impl Writeable for QueryShortChannelIds {
2727 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2728 // Calculated from 1-byte encoding_type plus 8-bytes per short_channel_id
2729 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2731 self.chain_hash.write(w)?;
2732 encoding_len.write(w)?;
2734 // We only support type=0 uncompressed serialization
2735 (EncodingType::Uncompressed as u8).write(w)?;
2737 for scid in self.short_channel_ids.iter() {
2745 impl_writeable_msg!(ReplyShortChannelIdsEnd, {
2750 impl QueryChannelRange {
2751 /// Calculates the overflow safe ending block height for the query.
2753 /// Overflow returns `0xffffffff`, otherwise returns `first_blocknum + number_of_blocks`.
2754 pub fn end_blocknum(&self) -> u32 {
2755 match self.first_blocknum.checked_add(self.number_of_blocks) {
2756 Some(block) => block,
2757 None => u32::max_value(),
2762 impl_writeable_msg!(QueryChannelRange, {
2768 impl Readable for ReplyChannelRange {
2769 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2770 let chain_hash: ChainHash = Readable::read(r)?;
2771 let first_blocknum: u32 = Readable::read(r)?;
2772 let number_of_blocks: u32 = Readable::read(r)?;
2773 let sync_complete: bool = Readable::read(r)?;
2775 let encoding_len: u16 = Readable::read(r)?;
2776 let encoding_type: u8 = Readable::read(r)?;
2778 // Must be encoding_type=0 uncompressed serialization. We do not
2779 // support encoding_type=1 zlib serialization.
2780 if encoding_type != EncodingType::Uncompressed as u8 {
2781 return Err(DecodeError::UnsupportedCompression);
2784 // We expect the encoding_len to always includes the 1-byte
2785 // encoding_type and that short_channel_ids are 8-bytes each
2786 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2787 return Err(DecodeError::InvalidValue);
2790 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2791 // less the 1-byte encoding_type
2792 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2793 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2794 for _ in 0..short_channel_id_count {
2795 short_channel_ids.push(Readable::read(r)?);
2798 Ok(ReplyChannelRange {
2808 impl Writeable for ReplyChannelRange {
2809 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2810 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2811 self.chain_hash.write(w)?;
2812 self.first_blocknum.write(w)?;
2813 self.number_of_blocks.write(w)?;
2814 self.sync_complete.write(w)?;
2816 encoding_len.write(w)?;
2817 (EncodingType::Uncompressed as u8).write(w)?;
2818 for scid in self.short_channel_ids.iter() {
2826 impl_writeable_msg!(GossipTimestampFilter, {
2834 use std::convert::TryFrom;
2835 use bitcoin::{Transaction, TxIn, ScriptBuf, Sequence, Witness, TxOut};
2836 use hex::DisplayHex;
2837 use crate::ln::{PaymentPreimage, PaymentHash, PaymentSecret};
2838 use crate::ln::ChannelId;
2839 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
2840 use crate::ln::msgs::{self, FinalOnionHopData, OnionErrorPacket};
2841 use crate::ln::msgs::SocketAddress;
2842 use crate::routing::gossip::{NodeAlias, NodeId};
2843 use crate::util::ser::{Writeable, Readable, ReadableArgs, Hostname, TransactionU16LenLimited};
2844 use crate::util::test_utils;
2846 use bitcoin::hashes::hex::FromHex;
2847 use bitcoin::address::Address;
2848 use bitcoin::network::constants::Network;
2849 use bitcoin::blockdata::constants::ChainHash;
2850 use bitcoin::blockdata::script::Builder;
2851 use bitcoin::blockdata::opcodes;
2852 use bitcoin::hash_types::Txid;
2853 use bitcoin::locktime::absolute::LockTime;
2855 use bitcoin::secp256k1::{PublicKey,SecretKey};
2856 use bitcoin::secp256k1::{Secp256k1, Message};
2858 use crate::io::{self, Cursor};
2859 use crate::prelude::*;
2860 use core::str::FromStr;
2861 use crate::chain::transaction::OutPoint;
2863 #[cfg(feature = "std")]
2864 use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6, ToSocketAddrs};
2865 #[cfg(feature = "std")]
2866 use crate::ln::msgs::SocketAddressParseError;
2869 fn encoding_channel_reestablish() {
2871 let secp_ctx = Secp256k1::new();
2872 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&<Vec<u8>>::from_hex("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2875 let cr = msgs::ChannelReestablish {
2876 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]),
2877 next_local_commitment_number: 3,
2878 next_remote_commitment_number: 4,
2879 your_last_per_commitment_secret: [9;32],
2880 my_current_per_commitment_point: public_key,
2881 next_funding_txid: None,
2884 let encoded_value = cr.encode();
2888 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
2889 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2890 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2891 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
2892 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
2898 fn encoding_channel_reestablish_with_next_funding_txid() {
2900 let secp_ctx = Secp256k1::new();
2901 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&<Vec<u8>>::from_hex("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2904 let cr = msgs::ChannelReestablish {
2905 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]),
2906 next_local_commitment_number: 3,
2907 next_remote_commitment_number: 4,
2908 your_last_per_commitment_secret: [9;32],
2909 my_current_per_commitment_point: public_key,
2910 next_funding_txid: Some(Txid::from_raw_hash(bitcoin::hashes::Hash::from_slice(&[
2911 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,
2915 let encoded_value = cr.encode();
2919 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
2920 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2921 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2922 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
2923 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
2924 0, // Type (next_funding_txid)
2926 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
2931 macro_rules! get_keys_from {
2932 ($slice: expr, $secp_ctx: expr) => {
2934 let privkey = SecretKey::from_slice(&<Vec<u8>>::from_hex($slice).unwrap()[..]).unwrap();
2935 let pubkey = PublicKey::from_secret_key(&$secp_ctx, &privkey);
2941 macro_rules! get_sig_on {
2942 ($privkey: expr, $ctx: expr, $string: expr) => {
2944 let sighash = Message::from_slice(&$string.into_bytes()[..]).unwrap();
2945 $ctx.sign_ecdsa(&sighash, &$privkey)
2951 fn encoding_announcement_signatures() {
2952 let secp_ctx = Secp256k1::new();
2953 let (privkey, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2954 let sig_1 = get_sig_on!(privkey, secp_ctx, String::from("01010101010101010101010101010101"));
2955 let sig_2 = get_sig_on!(privkey, secp_ctx, String::from("02020202020202020202020202020202"));
2956 let announcement_signatures = msgs::AnnouncementSignatures {
2957 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]),
2958 short_channel_id: 2316138423780173,
2959 node_signature: sig_1,
2960 bitcoin_signature: sig_2,
2963 let encoded_value = announcement_signatures.encode();
2964 assert_eq!(encoded_value, <Vec<u8>>::from_hex("040000000000000005000000000000000600000000000000070000000000000000083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073acf9953cef4700860f5967838eba2bae89288ad188ebf8b20bf995c3ea53a26df1876d0a3a0e13172ba286a673140190c02ba9da60a2e43a745188c8a83c7f3ef").unwrap());
2967 fn do_encoding_channel_announcement(unknown_features_bits: bool, excess_data: bool) {
2968 let secp_ctx = Secp256k1::new();
2969 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2970 let (privkey_2, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2971 let (privkey_3, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2972 let (privkey_4, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2973 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2974 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
2975 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
2976 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
2977 let mut features = ChannelFeatures::empty();
2978 if unknown_features_bits {
2979 features = ChannelFeatures::from_le_bytes(vec![0xFF, 0xFF]);
2981 let unsigned_channel_announcement = msgs::UnsignedChannelAnnouncement {
2983 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
2984 short_channel_id: 2316138423780173,
2985 node_id_1: NodeId::from_pubkey(&pubkey_1),
2986 node_id_2: NodeId::from_pubkey(&pubkey_2),
2987 bitcoin_key_1: NodeId::from_pubkey(&pubkey_3),
2988 bitcoin_key_2: NodeId::from_pubkey(&pubkey_4),
2989 excess_data: if excess_data { vec![10, 0, 0, 20, 0, 0, 30, 0, 0, 40] } else { Vec::new() },
2991 let channel_announcement = msgs::ChannelAnnouncement {
2992 node_signature_1: sig_1,
2993 node_signature_2: sig_2,
2994 bitcoin_signature_1: sig_3,
2995 bitcoin_signature_2: sig_4,
2996 contents: unsigned_channel_announcement,
2998 let encoded_value = channel_announcement.encode();
2999 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a1735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap();
3000 if unknown_features_bits {
3001 target_value.append(&mut <Vec<u8>>::from_hex("0002ffff").unwrap());
3003 target_value.append(&mut <Vec<u8>>::from_hex("0000").unwrap());
3005 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3006 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
3008 target_value.append(&mut <Vec<u8>>::from_hex("0a00001400001e000028").unwrap());
3010 assert_eq!(encoded_value, target_value);
3014 fn encoding_channel_announcement() {
3015 do_encoding_channel_announcement(true, false);
3016 do_encoding_channel_announcement(false, true);
3017 do_encoding_channel_announcement(false, false);
3018 do_encoding_channel_announcement(true, true);
3021 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) {
3022 let secp_ctx = Secp256k1::new();
3023 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3024 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3025 let features = if unknown_features_bits {
3026 NodeFeatures::from_le_bytes(vec![0xFF, 0xFF])
3028 // Set to some features we may support
3029 NodeFeatures::from_le_bytes(vec![2 | 1 << 5])
3031 let mut addresses = Vec::new();
3033 addresses.push(SocketAddress::TcpIpV4 {
3034 addr: [255, 254, 253, 252],
3039 addresses.push(SocketAddress::TcpIpV6 {
3040 addr: [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240],
3045 addresses.push(msgs::SocketAddress::OnionV2(
3046 [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 38, 7]
3050 addresses.push(msgs::SocketAddress::OnionV3 {
3051 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],
3058 addresses.push(SocketAddress::Hostname {
3059 hostname: Hostname::try_from(String::from("host")).unwrap(),
3063 let mut addr_len = 0;
3064 for addr in &addresses {
3065 addr_len += addr.len() + 1;
3067 let unsigned_node_announcement = msgs::UnsignedNodeAnnouncement {
3069 timestamp: 20190119,
3070 node_id: NodeId::from_pubkey(&pubkey_1),
3072 alias: NodeAlias([16;32]),
3074 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() },
3075 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() },
3077 addr_len += unsigned_node_announcement.excess_address_data.len() as u16;
3078 let node_announcement = msgs::NodeAnnouncement {
3080 contents: unsigned_node_announcement,
3082 let encoded_value = node_announcement.encode();
3083 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3084 if unknown_features_bits {
3085 target_value.append(&mut <Vec<u8>>::from_hex("0002ffff").unwrap());
3087 target_value.append(&mut <Vec<u8>>::from_hex("000122").unwrap());
3089 target_value.append(&mut <Vec<u8>>::from_hex("013413a7031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f2020201010101010101010101010101010101010101010101010101010101010101010").unwrap());
3090 target_value.append(&mut vec![(addr_len >> 8) as u8, addr_len as u8]);
3092 target_value.append(&mut <Vec<u8>>::from_hex("01fffefdfc2607").unwrap());
3095 target_value.append(&mut <Vec<u8>>::from_hex("02fffefdfcfbfaf9f8f7f6f5f4f3f2f1f02607").unwrap());
3098 target_value.append(&mut <Vec<u8>>::from_hex("03fffefdfcfbfaf9f8f7f62607").unwrap());
3101 target_value.append(&mut <Vec<u8>>::from_hex("04fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0efeeedecebeae9e8e7e6e5e4e3e2e1e00020102607").unwrap());
3104 target_value.append(&mut <Vec<u8>>::from_hex("0504686f73742607").unwrap());
3106 if excess_address_data {
3107 target_value.append(&mut <Vec<u8>>::from_hex("216c280b5395a2546e7e4b2663e04f811622f15a4f92e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d269").unwrap());
3110 target_value.append(&mut <Vec<u8>>::from_hex("3b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
3112 assert_eq!(encoded_value, target_value);
3116 fn encoding_node_announcement() {
3117 do_encoding_node_announcement(true, true, true, true, true, true, true, true);
3118 do_encoding_node_announcement(false, false, false, false, false, false, false, false);
3119 do_encoding_node_announcement(false, true, false, false, false, false, false, false);
3120 do_encoding_node_announcement(false, false, true, false, false, false, false, false);
3121 do_encoding_node_announcement(false, false, false, true, false, false, false, false);
3122 do_encoding_node_announcement(false, false, false, false, true, false, false, false);
3123 do_encoding_node_announcement(false, false, false, false, false, true, false, false);
3124 do_encoding_node_announcement(false, false, false, false, false, false, true, false);
3125 do_encoding_node_announcement(false, true, false, true, false, false, true, false);
3126 do_encoding_node_announcement(false, false, true, false, true, false, false, false);
3129 fn do_encoding_channel_update(direction: bool, disable: bool, excess_data: bool) {
3130 let secp_ctx = Secp256k1::new();
3131 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3132 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3133 let unsigned_channel_update = msgs::UnsignedChannelUpdate {
3134 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3135 short_channel_id: 2316138423780173,
3136 timestamp: 20190119,
3137 flags: if direction { 1 } else { 0 } | if disable { 1 << 1 } else { 0 },
3138 cltv_expiry_delta: 144,
3139 htlc_minimum_msat: 1000000,
3140 htlc_maximum_msat: 131355275467161,
3141 fee_base_msat: 10000,
3142 fee_proportional_millionths: 20,
3143 excess_data: if excess_data { vec![0, 0, 0, 0, 59, 154, 202, 0] } else { Vec::new() }
3145 let channel_update = msgs::ChannelUpdate {
3147 contents: unsigned_channel_update
3149 let encoded_value = channel_update.encode();
3150 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3151 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3152 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d013413a7").unwrap());
3153 target_value.append(&mut <Vec<u8>>::from_hex("01").unwrap());
3154 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3156 let flag = target_value.last_mut().unwrap();
3160 let flag = target_value.last_mut().unwrap();
3161 *flag = *flag | 1 << 1;
3163 target_value.append(&mut <Vec<u8>>::from_hex("009000000000000f42400000271000000014").unwrap());
3164 target_value.append(&mut <Vec<u8>>::from_hex("0000777788889999").unwrap());
3166 target_value.append(&mut <Vec<u8>>::from_hex("000000003b9aca00").unwrap());
3168 assert_eq!(encoded_value, target_value);
3172 fn encoding_channel_update() {
3173 do_encoding_channel_update(false, false, false);
3174 do_encoding_channel_update(false, false, true);
3175 do_encoding_channel_update(true, false, false);
3176 do_encoding_channel_update(true, false, true);
3177 do_encoding_channel_update(false, true, false);
3178 do_encoding_channel_update(false, true, true);
3179 do_encoding_channel_update(true, true, false);
3180 do_encoding_channel_update(true, true, true);
3183 fn do_encoding_open_channel(random_bit: bool, shutdown: bool, incl_chan_type: bool) {
3184 let secp_ctx = Secp256k1::new();
3185 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3186 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3187 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3188 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3189 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3190 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3191 let open_channel = msgs::OpenChannel {
3192 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3193 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3194 funding_satoshis: 1311768467284833366,
3195 push_msat: 2536655962884945560,
3196 dust_limit_satoshis: 3608586615801332854,
3197 max_htlc_value_in_flight_msat: 8517154655701053848,
3198 channel_reserve_satoshis: 8665828695742877976,
3199 htlc_minimum_msat: 2316138423780173,
3200 feerate_per_kw: 821716,
3201 to_self_delay: 49340,
3202 max_accepted_htlcs: 49340,
3203 funding_pubkey: pubkey_1,
3204 revocation_basepoint: pubkey_2,
3205 payment_point: pubkey_3,
3206 delayed_payment_basepoint: pubkey_4,
3207 htlc_basepoint: pubkey_5,
3208 first_per_commitment_point: pubkey_6,
3209 channel_flags: if random_bit { 1 << 5 } else { 0 },
3210 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3211 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3213 let encoded_value = open_channel.encode();
3214 let mut target_value = Vec::new();
3215 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3216 target_value.append(&mut <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202021234567890123456233403289122369832144668701144767633030896203198784335490624111800083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3218 target_value.append(&mut <Vec<u8>>::from_hex("20").unwrap());
3220 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3223 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3226 target_value.append(&mut <Vec<u8>>::from_hex("0100").unwrap());
3228 assert_eq!(encoded_value, target_value);
3232 fn encoding_open_channel() {
3233 do_encoding_open_channel(false, false, false);
3234 do_encoding_open_channel(false, false, true);
3235 do_encoding_open_channel(false, true, false);
3236 do_encoding_open_channel(false, true, true);
3237 do_encoding_open_channel(true, false, false);
3238 do_encoding_open_channel(true, false, true);
3239 do_encoding_open_channel(true, true, false);
3240 do_encoding_open_channel(true, true, true);
3243 fn do_encoding_open_channelv2(random_bit: bool, shutdown: bool, incl_chan_type: bool, require_confirmed_inputs: bool) {
3244 let secp_ctx = Secp256k1::new();
3245 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3246 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3247 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3248 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3249 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3250 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3251 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3252 let open_channelv2 = msgs::OpenChannelV2 {
3253 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3254 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3255 funding_feerate_sat_per_1000_weight: 821716,
3256 commitment_feerate_sat_per_1000_weight: 821716,
3257 funding_satoshis: 1311768467284833366,
3258 dust_limit_satoshis: 3608586615801332854,
3259 max_htlc_value_in_flight_msat: 8517154655701053848,
3260 htlc_minimum_msat: 2316138423780173,
3261 to_self_delay: 49340,
3262 max_accepted_htlcs: 49340,
3263 locktime: 305419896,
3264 funding_pubkey: pubkey_1,
3265 revocation_basepoint: pubkey_2,
3266 payment_basepoint: pubkey_3,
3267 delayed_payment_basepoint: pubkey_4,
3268 htlc_basepoint: pubkey_5,
3269 first_per_commitment_point: pubkey_6,
3270 second_per_commitment_point: pubkey_7,
3271 channel_flags: if random_bit { 1 << 5 } else { 0 },
3272 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3273 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3274 require_confirmed_inputs: if require_confirmed_inputs { Some(()) } else { None },
3276 let encoded_value = open_channelv2.encode();
3277 let mut target_value = Vec::new();
3278 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3279 target_value.append(&mut <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap());
3280 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap());
3281 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap());
3282 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap());
3283 target_value.append(&mut <Vec<u8>>::from_hex("3214466870114476").unwrap());
3284 target_value.append(&mut <Vec<u8>>::from_hex("7633030896203198").unwrap());
3285 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d").unwrap());
3286 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap());
3287 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap());
3288 target_value.append(&mut <Vec<u8>>::from_hex("12345678").unwrap());
3289 target_value.append(&mut <Vec<u8>>::from_hex("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap());
3290 target_value.append(&mut <Vec<u8>>::from_hex("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap());
3291 target_value.append(&mut <Vec<u8>>::from_hex("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap());
3292 target_value.append(&mut <Vec<u8>>::from_hex("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
3293 target_value.append(&mut <Vec<u8>>::from_hex("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap());
3294 target_value.append(&mut <Vec<u8>>::from_hex("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3295 target_value.append(&mut <Vec<u8>>::from_hex("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap());
3298 target_value.append(&mut <Vec<u8>>::from_hex("20").unwrap());
3300 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3303 target_value.append(&mut <Vec<u8>>::from_hex("001b").unwrap()); // Type 0 + Length 27
3304 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3307 target_value.append(&mut <Vec<u8>>::from_hex("0100").unwrap());
3309 if require_confirmed_inputs {
3310 target_value.append(&mut <Vec<u8>>::from_hex("0200").unwrap());
3312 assert_eq!(encoded_value, target_value);
3316 fn encoding_open_channelv2() {
3317 do_encoding_open_channelv2(false, false, false, false);
3318 do_encoding_open_channelv2(false, false, false, true);
3319 do_encoding_open_channelv2(false, false, true, false);
3320 do_encoding_open_channelv2(false, false, true, true);
3321 do_encoding_open_channelv2(false, true, false, false);
3322 do_encoding_open_channelv2(false, true, false, true);
3323 do_encoding_open_channelv2(false, true, true, false);
3324 do_encoding_open_channelv2(false, true, true, true);
3325 do_encoding_open_channelv2(true, false, false, false);
3326 do_encoding_open_channelv2(true, false, false, true);
3327 do_encoding_open_channelv2(true, false, true, false);
3328 do_encoding_open_channelv2(true, false, true, true);
3329 do_encoding_open_channelv2(true, true, false, false);
3330 do_encoding_open_channelv2(true, true, false, true);
3331 do_encoding_open_channelv2(true, true, true, false);
3332 do_encoding_open_channelv2(true, true, true, true);
3335 fn do_encoding_accept_channel(shutdown: bool) {
3336 let secp_ctx = Secp256k1::new();
3337 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3338 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3339 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3340 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3341 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3342 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3343 let accept_channel = msgs::AcceptChannel {
3344 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3345 dust_limit_satoshis: 1311768467284833366,
3346 max_htlc_value_in_flight_msat: 2536655962884945560,
3347 channel_reserve_satoshis: 3608586615801332854,
3348 htlc_minimum_msat: 2316138423780173,
3349 minimum_depth: 821716,
3350 to_self_delay: 49340,
3351 max_accepted_htlcs: 49340,
3352 funding_pubkey: pubkey_1,
3353 revocation_basepoint: pubkey_2,
3354 payment_point: pubkey_3,
3355 delayed_payment_basepoint: pubkey_4,
3356 htlc_basepoint: pubkey_5,
3357 first_per_commitment_point: pubkey_6,
3358 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3361 next_local_nonce: None,
3363 let encoded_value = accept_channel.encode();
3364 let mut target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020212345678901234562334032891223698321446687011447600083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap();
3366 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3368 assert_eq!(encoded_value, target_value);
3372 fn encoding_accept_channel() {
3373 do_encoding_accept_channel(false);
3374 do_encoding_accept_channel(true);
3377 fn do_encoding_accept_channelv2(shutdown: bool) {
3378 let secp_ctx = Secp256k1::new();
3379 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3380 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3381 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3382 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3383 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3384 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3385 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3386 let accept_channelv2 = msgs::AcceptChannelV2 {
3387 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3388 funding_satoshis: 1311768467284833366,
3389 dust_limit_satoshis: 1311768467284833366,
3390 max_htlc_value_in_flight_msat: 2536655962884945560,
3391 htlc_minimum_msat: 2316138423780173,
3392 minimum_depth: 821716,
3393 to_self_delay: 49340,
3394 max_accepted_htlcs: 49340,
3395 funding_pubkey: pubkey_1,
3396 revocation_basepoint: pubkey_2,
3397 payment_basepoint: pubkey_3,
3398 delayed_payment_basepoint: pubkey_4,
3399 htlc_basepoint: pubkey_5,
3400 first_per_commitment_point: pubkey_6,
3401 second_per_commitment_point: pubkey_7,
3402 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3404 require_confirmed_inputs: None,
3406 let encoded_value = accept_channelv2.encode();
3407 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // temporary_channel_id
3408 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap()); // funding_satoshis
3409 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap()); // dust_limit_satoshis
3410 target_value.append(&mut <Vec<u8>>::from_hex("2334032891223698").unwrap()); // max_htlc_value_in_flight_msat
3411 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d").unwrap()); // htlc_minimum_msat
3412 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap()); // minimum_depth
3413 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap()); // to_self_delay
3414 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap()); // max_accepted_htlcs
3415 target_value.append(&mut <Vec<u8>>::from_hex("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap()); // funding_pubkey
3416 target_value.append(&mut <Vec<u8>>::from_hex("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap()); // revocation_basepoint
3417 target_value.append(&mut <Vec<u8>>::from_hex("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap()); // payment_basepoint
3418 target_value.append(&mut <Vec<u8>>::from_hex("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap()); // delayed_payment_basepoint
3419 target_value.append(&mut <Vec<u8>>::from_hex("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap()); // htlc_basepoint
3420 target_value.append(&mut <Vec<u8>>::from_hex("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap()); // first_per_commitment_point
3421 target_value.append(&mut <Vec<u8>>::from_hex("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap()); // second_per_commitment_point
3423 target_value.append(&mut <Vec<u8>>::from_hex("001b").unwrap()); // Type 0 + Length 27
3424 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3426 assert_eq!(encoded_value, target_value);
3430 fn encoding_accept_channelv2() {
3431 do_encoding_accept_channelv2(false);
3432 do_encoding_accept_channelv2(true);
3436 fn encoding_funding_created() {
3437 let secp_ctx = Secp256k1::new();
3438 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3439 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3440 let funding_created = msgs::FundingCreated {
3441 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3442 funding_txid: Txid::from_str("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3443 funding_output_index: 255,
3446 partial_signature_with_nonce: None,
3448 next_local_nonce: None,
3450 let encoded_value = funding_created.encode();
3451 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202026e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c200ffd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3452 assert_eq!(encoded_value, target_value);
3456 fn encoding_funding_signed() {
3457 let secp_ctx = Secp256k1::new();
3458 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3459 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3460 let funding_signed = msgs::FundingSigned {
3461 channel_id: ChannelId::from_bytes([2; 32]),
3464 partial_signature_with_nonce: None,
3466 let encoded_value = funding_signed.encode();
3467 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3468 assert_eq!(encoded_value, target_value);
3472 fn encoding_channel_ready() {
3473 let secp_ctx = Secp256k1::new();
3474 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3475 let channel_ready = msgs::ChannelReady {
3476 channel_id: ChannelId::from_bytes([2; 32]),
3477 next_per_commitment_point: pubkey_1,
3478 short_channel_id_alias: None,
3480 let encoded_value = channel_ready.encode();
3481 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3482 assert_eq!(encoded_value, target_value);
3486 fn encoding_splice() {
3487 let secp_ctx = Secp256k1::new();
3488 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3489 let splice = msgs::Splice {
3490 chain_hash: ChainHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
3491 channel_id: ChannelId::from_bytes([2; 32]),
3492 relative_satoshis: 123456,
3493 funding_feerate_perkw: 2000,
3495 funding_pubkey: pubkey_1,
3497 let encoded_value = splice.encode();
3498 assert_eq!(encoded_value.as_hex().to_string(), "02020202020202020202020202020202020202020202020202020202020202026fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000000000000001e240000007d000000000031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f");
3502 fn encoding_stfu() {
3503 let stfu = msgs::Stfu {
3504 channel_id: ChannelId::from_bytes([2; 32]),
3507 let encoded_value = stfu.encode();
3508 assert_eq!(encoded_value.as_hex().to_string(), "020202020202020202020202020202020202020202020202020202020202020201");
3512 fn encoding_splice_ack() {
3513 let secp_ctx = Secp256k1::new();
3514 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3515 let splice = msgs::SpliceAck {
3516 chain_hash: ChainHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
3517 channel_id: ChannelId::from_bytes([2; 32]),
3518 relative_satoshis: 123456,
3519 funding_pubkey: pubkey_1,
3521 let encoded_value = splice.encode();
3522 assert_eq!(encoded_value.as_hex().to_string(), "02020202020202020202020202020202020202020202020202020202020202026fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000000000000001e240031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f");
3526 fn encoding_splice_locked() {
3527 let splice = msgs::SpliceLocked {
3528 channel_id: ChannelId::from_bytes([2; 32]),
3530 let encoded_value = splice.encode();
3531 assert_eq!(encoded_value.as_hex().to_string(), "0202020202020202020202020202020202020202020202020202020202020202");
3535 fn encoding_tx_add_input() {
3536 let tx_add_input = msgs::TxAddInput {
3537 channel_id: ChannelId::from_bytes([2; 32]),
3538 serial_id: 4886718345,
3539 prevtx: TransactionU16LenLimited::new(Transaction {
3541 lock_time: LockTime::ZERO,
3543 previous_output: OutPoint { txid: Txid::from_str("305bab643ee297b8b6b76b320792c8223d55082122cb606bf89382146ced9c77").unwrap(), index: 2 }.into_bitcoin_outpoint(),
3544 script_sig: ScriptBuf::new(),
3545 sequence: Sequence(0xfffffffd),
3546 witness: Witness::from_slice(&vec![
3547 <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3548 <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3553 script_pubkey: Address::from_str("bc1qzlffunw52jav8vwdu5x3jfk6sr8u22rmq3xzw2").unwrap().payload.script_pubkey(),
3557 script_pubkey: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().payload.script_pubkey(),
3561 prevtx_out: 305419896,
3562 sequence: 305419896,
3564 let encoded_value = tx_add_input.encode();
3565 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000000012345678900de02000000000101779ced6c148293f86b60cb222108553d22c89207326bb7b6b897e23e64ab5b300200000000fdffffff0236dbc1000000000016001417d29e4dd454bac3b1cde50d1926da80cfc5287b9cbd03000000000016001436ec78d514df462da95e6a00c24daa8915362d420247304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701210301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944000000001234567812345678").unwrap();
3566 assert_eq!(encoded_value, target_value);
3570 fn encoding_tx_add_output() {
3571 let tx_add_output = msgs::TxAddOutput {
3572 channel_id: ChannelId::from_bytes([2; 32]),
3573 serial_id: 4886718345,
3575 script: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().payload.script_pubkey(),
3577 let encoded_value = tx_add_output.encode();
3578 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000000012345678900000001234567890016001436ec78d514df462da95e6a00c24daa8915362d42").unwrap();
3579 assert_eq!(encoded_value, target_value);
3583 fn encoding_tx_remove_input() {
3584 let tx_remove_input = msgs::TxRemoveInput {
3585 channel_id: ChannelId::from_bytes([2; 32]),
3586 serial_id: 4886718345,
3588 let encoded_value = tx_remove_input.encode();
3589 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3590 assert_eq!(encoded_value, target_value);
3594 fn encoding_tx_remove_output() {
3595 let tx_remove_output = msgs::TxRemoveOutput {
3596 channel_id: ChannelId::from_bytes([2; 32]),
3597 serial_id: 4886718345,
3599 let encoded_value = tx_remove_output.encode();
3600 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3601 assert_eq!(encoded_value, target_value);
3605 fn encoding_tx_complete() {
3606 let tx_complete = msgs::TxComplete {
3607 channel_id: ChannelId::from_bytes([2; 32]),
3609 let encoded_value = tx_complete.encode();
3610 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3611 assert_eq!(encoded_value, target_value);
3615 fn encoding_tx_signatures() {
3616 let tx_signatures = msgs::TxSignatures {
3617 channel_id: ChannelId::from_bytes([2; 32]),
3618 tx_hash: Txid::from_str("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3620 Witness::from_slice(&vec![
3621 <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3622 <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3623 Witness::from_slice(&vec![
3624 <Vec<u8>>::from_hex("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap(),
3625 <Vec<u8>>::from_hex("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap()]),
3628 let encoded_value = tx_signatures.encode();
3629 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3630 target_value.append(&mut <Vec<u8>>::from_hex("6e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c2").unwrap()); // tx_hash (sha256) (big endian byte order)
3631 target_value.append(&mut <Vec<u8>>::from_hex("0002").unwrap()); // num_witnesses (u16)
3633 target_value.append(&mut <Vec<u8>>::from_hex("006b").unwrap()); // len of witness_data
3634 target_value.append(&mut <Vec<u8>>::from_hex("02").unwrap()); // num_witness_elements (VarInt)
3635 target_value.append(&mut <Vec<u8>>::from_hex("47").unwrap()); // len of witness element data (VarInt)
3636 target_value.append(&mut <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap());
3637 target_value.append(&mut <Vec<u8>>::from_hex("21").unwrap()); // len of witness element data (VarInt)
3638 target_value.append(&mut <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap());
3640 target_value.append(&mut <Vec<u8>>::from_hex("006c").unwrap()); // len of witness_data
3641 target_value.append(&mut <Vec<u8>>::from_hex("02").unwrap()); // num_witness_elements (VarInt)
3642 target_value.append(&mut <Vec<u8>>::from_hex("48").unwrap()); // len of witness element data (VarInt)
3643 target_value.append(&mut <Vec<u8>>::from_hex("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap());
3644 target_value.append(&mut <Vec<u8>>::from_hex("21").unwrap()); // len of witness element data (VarInt)
3645 target_value.append(&mut <Vec<u8>>::from_hex("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap());
3646 assert_eq!(encoded_value, target_value);
3649 fn do_encoding_tx_init_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3650 let tx_init_rbf = msgs::TxInitRbf {
3651 channel_id: ChannelId::from_bytes([2; 32]),
3652 locktime: 305419896,
3653 feerate_sat_per_1000_weight: 20190119,
3654 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3656 let encoded_value = tx_init_rbf.encode();
3657 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3658 target_value.append(&mut <Vec<u8>>::from_hex("12345678").unwrap()); // locktime
3659 target_value.append(&mut <Vec<u8>>::from_hex("013413a7").unwrap()); // feerate_sat_per_1000_weight
3660 if let Some((_, target)) = funding_value_with_hex_target {
3661 target_value.push(0x00); // Type
3662 target_value.push(target.len() as u8 / 2); // Length
3663 target_value.append(&mut <Vec<u8>>::from_hex(target).unwrap()); // Value (i64)
3665 assert_eq!(encoded_value, target_value);
3669 fn encoding_tx_init_rbf() {
3670 do_encoding_tx_init_rbf(Some((1311768467284833366, "1234567890123456")));
3671 do_encoding_tx_init_rbf(Some((13117684672, "000000030DDFFBC0")));
3672 do_encoding_tx_init_rbf(None);
3675 fn do_encoding_tx_ack_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3676 let tx_ack_rbf = msgs::TxAckRbf {
3677 channel_id: ChannelId::from_bytes([2; 32]),
3678 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3680 let encoded_value = tx_ack_rbf.encode();
3681 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3682 if let Some((_, target)) = funding_value_with_hex_target {
3683 target_value.push(0x00); // Type
3684 target_value.push(target.len() as u8 / 2); // Length
3685 target_value.append(&mut <Vec<u8>>::from_hex(target).unwrap()); // Value (i64)
3687 assert_eq!(encoded_value, target_value);
3691 fn encoding_tx_ack_rbf() {
3692 do_encoding_tx_ack_rbf(Some((1311768467284833366, "1234567890123456")));
3693 do_encoding_tx_ack_rbf(Some((13117684672, "000000030DDFFBC0")));
3694 do_encoding_tx_ack_rbf(None);
3698 fn encoding_tx_abort() {
3699 let tx_abort = msgs::TxAbort {
3700 channel_id: ChannelId::from_bytes([2; 32]),
3701 data: <Vec<u8>>::from_hex("54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap(),
3703 let encoded_value = tx_abort.encode();
3704 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202002C54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap();
3705 assert_eq!(encoded_value, target_value);
3708 fn do_encoding_shutdown(script_type: u8) {
3709 let secp_ctx = Secp256k1::new();
3710 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3711 let script = Builder::new().push_opcode(opcodes::OP_TRUE).into_script();
3712 let shutdown = msgs::Shutdown {
3713 channel_id: ChannelId::from_bytes([2; 32]),
3715 if script_type == 1 { Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey() }
3716 else if script_type == 2 { Address::p2sh(&script, Network::Testnet).unwrap().script_pubkey() }
3717 else if script_type == 3 { Address::p2wpkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).unwrap().script_pubkey() }
3718 else { Address::p2wsh(&script, Network::Testnet).script_pubkey() },
3720 let encoded_value = shutdown.encode();
3721 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3722 if script_type == 1 {
3723 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3724 } else if script_type == 2 {
3725 target_value.append(&mut <Vec<u8>>::from_hex("0017a914da1745e9b549bd0bfa1a569971c77eba30cd5a4b87").unwrap());
3726 } else if script_type == 3 {
3727 target_value.append(&mut <Vec<u8>>::from_hex("0016001479b000887626b294a914501a4cd226b58b235983").unwrap());
3728 } else if script_type == 4 {
3729 target_value.append(&mut <Vec<u8>>::from_hex("002200204ae81572f06e1b88fd5ced7a1a000945432e83e1551e6f721ee9c00b8cc33260").unwrap());
3731 assert_eq!(encoded_value, target_value);
3735 fn encoding_shutdown() {
3736 do_encoding_shutdown(1);
3737 do_encoding_shutdown(2);
3738 do_encoding_shutdown(3);
3739 do_encoding_shutdown(4);
3743 fn encoding_closing_signed() {
3744 let secp_ctx = Secp256k1::new();
3745 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3746 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3747 let closing_signed = msgs::ClosingSigned {
3748 channel_id: ChannelId::from_bytes([2; 32]),
3749 fee_satoshis: 2316138423780173,
3753 let encoded_value = closing_signed.encode();
3754 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3755 assert_eq!(encoded_value, target_value);
3756 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value)).unwrap(), closing_signed);
3758 let closing_signed_with_range = msgs::ClosingSigned {
3759 channel_id: ChannelId::from_bytes([2; 32]),
3760 fee_satoshis: 2316138423780173,
3762 fee_range: Some(msgs::ClosingSignedFeeRange {
3763 min_fee_satoshis: 0xdeadbeef,
3764 max_fee_satoshis: 0x1badcafe01234567,
3767 let encoded_value_with_range = closing_signed_with_range.encode();
3768 let target_value_with_range = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a011000000000deadbeef1badcafe01234567").unwrap();
3769 assert_eq!(encoded_value_with_range, target_value_with_range);
3770 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value_with_range)).unwrap(),
3771 closing_signed_with_range);
3775 fn encoding_update_add_htlc() {
3776 let secp_ctx = Secp256k1::new();
3777 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3778 let onion_routing_packet = msgs::OnionPacket {
3780 public_key: Ok(pubkey_1),
3781 hop_data: [1; 20*65],
3784 let update_add_htlc = msgs::UpdateAddHTLC {
3785 channel_id: ChannelId::from_bytes([2; 32]),
3786 htlc_id: 2316138423780173,
3787 amount_msat: 3608586615801332854,
3788 payment_hash: PaymentHash([1; 32]),
3789 cltv_expiry: 821716,
3790 onion_routing_packet,
3791 skimmed_fee_msat: None,
3792 blinding_point: None,
3794 let encoded_value = update_add_htlc.encode();
3795 let target_value = <Vec<u8>>::from_hex("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").unwrap();
3796 assert_eq!(encoded_value, target_value);
3800 fn encoding_update_fulfill_htlc() {
3801 let update_fulfill_htlc = msgs::UpdateFulfillHTLC {
3802 channel_id: ChannelId::from_bytes([2; 32]),
3803 htlc_id: 2316138423780173,
3804 payment_preimage: PaymentPreimage([1; 32]),
3806 let encoded_value = update_fulfill_htlc.encode();
3807 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d0101010101010101010101010101010101010101010101010101010101010101").unwrap();
3808 assert_eq!(encoded_value, target_value);
3812 fn encoding_update_fail_htlc() {
3813 let reason = OnionErrorPacket {
3814 data: [1; 32].to_vec(),
3816 let update_fail_htlc = msgs::UpdateFailHTLC {
3817 channel_id: ChannelId::from_bytes([2; 32]),
3818 htlc_id: 2316138423780173,
3821 let encoded_value = update_fail_htlc.encode();
3822 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d00200101010101010101010101010101010101010101010101010101010101010101").unwrap();
3823 assert_eq!(encoded_value, target_value);
3827 fn encoding_update_fail_malformed_htlc() {
3828 let update_fail_malformed_htlc = msgs::UpdateFailMalformedHTLC {
3829 channel_id: ChannelId::from_bytes([2; 32]),
3830 htlc_id: 2316138423780173,
3831 sha256_of_onion: [1; 32],
3834 let encoded_value = update_fail_malformed_htlc.encode();
3835 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d010101010101010101010101010101010101010101010101010101010101010100ff").unwrap();
3836 assert_eq!(encoded_value, target_value);
3839 fn do_encoding_commitment_signed(htlcs: bool) {
3840 let secp_ctx = Secp256k1::new();
3841 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3842 let (privkey_2, _) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3843 let (privkey_3, _) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3844 let (privkey_4, _) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3845 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3846 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
3847 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
3848 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
3849 let commitment_signed = msgs::CommitmentSigned {
3850 channel_id: ChannelId::from_bytes([2; 32]),
3852 htlc_signatures: if htlcs { vec![sig_2, sig_3, sig_4] } else { Vec::new() },
3854 partial_signature_with_nonce: None,
3856 let encoded_value = commitment_signed.encode();
3857 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3859 target_value.append(&mut <Vec<u8>>::from_hex("00031735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
3861 target_value.append(&mut <Vec<u8>>::from_hex("0000").unwrap());
3863 assert_eq!(encoded_value, target_value);
3867 fn encoding_commitment_signed() {
3868 do_encoding_commitment_signed(true);
3869 do_encoding_commitment_signed(false);
3873 fn encoding_revoke_and_ack() {
3874 let secp_ctx = Secp256k1::new();
3875 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3876 let raa = msgs::RevokeAndACK {
3877 channel_id: ChannelId::from_bytes([2; 32]),
3878 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],
3879 next_per_commitment_point: pubkey_1,
3881 next_local_nonce: None,
3883 let encoded_value = raa.encode();
3884 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020101010101010101010101010101010101010101010101010101010101010101031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3885 assert_eq!(encoded_value, target_value);
3889 fn encoding_update_fee() {
3890 let update_fee = msgs::UpdateFee {
3891 channel_id: ChannelId::from_bytes([2; 32]),
3892 feerate_per_kw: 20190119,
3894 let encoded_value = update_fee.encode();
3895 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202013413a7").unwrap();
3896 assert_eq!(encoded_value, target_value);
3900 fn encoding_init() {
3901 let mainnet_hash = ChainHash::using_genesis_block(Network::Bitcoin);
3902 assert_eq!(msgs::Init {
3903 features: InitFeatures::from_le_bytes(vec![0xFF, 0xFF, 0xFF]),
3904 networks: Some(vec![mainnet_hash]),
3905 remote_network_address: None,
3906 }.encode(), <Vec<u8>>::from_hex("00023fff0003ffffff01206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3907 assert_eq!(msgs::Init {
3908 features: InitFeatures::from_le_bytes(vec![0xFF]),
3910 remote_network_address: None,
3911 }.encode(), <Vec<u8>>::from_hex("0001ff0001ff").unwrap());
3912 assert_eq!(msgs::Init {
3913 features: InitFeatures::from_le_bytes(vec![]),
3914 networks: Some(vec![mainnet_hash]),
3915 remote_network_address: None,
3916 }.encode(), <Vec<u8>>::from_hex("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3917 assert_eq!(msgs::Init {
3918 features: InitFeatures::from_le_bytes(vec![]),
3919 networks: Some(vec![ChainHash::from(&[1; 32]), ChainHash::from(&[2; 32])]),
3920 remote_network_address: None,
3921 }.encode(), <Vec<u8>>::from_hex("00000000014001010101010101010101010101010101010101010101010101010101010101010202020202020202020202020202020202020202020202020202020202020202").unwrap());
3922 let init_msg = msgs::Init { features: InitFeatures::from_le_bytes(vec![]),
3923 networks: Some(vec![mainnet_hash]),
3924 remote_network_address: Some(SocketAddress::TcpIpV4 {
3925 addr: [127, 0, 0, 1],
3929 let encoded_value = init_msg.encode();
3930 let target_value = <Vec<u8>>::from_hex("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d61900000000000307017f00000103e8").unwrap();
3931 assert_eq!(encoded_value, target_value);
3932 assert_eq!(msgs::Init::read(&mut Cursor::new(&target_value)).unwrap(), init_msg);
3936 fn encoding_error() {
3937 let error = msgs::ErrorMessage {
3938 channel_id: ChannelId::from_bytes([2; 32]),
3939 data: String::from("rust-lightning"),
3941 let encoded_value = error.encode();
3942 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3943 assert_eq!(encoded_value, target_value);
3947 fn encoding_warning() {
3948 let error = msgs::WarningMessage {
3949 channel_id: ChannelId::from_bytes([2; 32]),
3950 data: String::from("rust-lightning"),
3952 let encoded_value = error.encode();
3953 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3954 assert_eq!(encoded_value, target_value);
3958 fn encoding_ping() {
3959 let ping = msgs::Ping {
3963 let encoded_value = ping.encode();
3964 let target_value = <Vec<u8>>::from_hex("0040004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3965 assert_eq!(encoded_value, target_value);
3969 fn encoding_pong() {
3970 let pong = msgs::Pong {
3973 let encoded_value = pong.encode();
3974 let target_value = <Vec<u8>>::from_hex("004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3975 assert_eq!(encoded_value, target_value);
3979 fn encoding_nonfinal_onion_hop_data() {
3980 let outbound_msg = msgs::OutboundOnionPayload::Forward {
3981 short_channel_id: 0xdeadbeef1bad1dea,
3982 amt_to_forward: 0x0badf00d01020304,
3983 outgoing_cltv_value: 0xffffffff,
3985 let encoded_value = outbound_msg.encode();
3986 let target_value = <Vec<u8>>::from_hex("1a02080badf00d010203040404ffffffff0608deadbeef1bad1dea").unwrap();
3987 assert_eq!(encoded_value, target_value);
3989 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3990 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
3991 if let msgs::InboundOnionPayload::Forward {
3992 short_channel_id, amt_to_forward, outgoing_cltv_value
3994 assert_eq!(short_channel_id, 0xdeadbeef1bad1dea);
3995 assert_eq!(amt_to_forward, 0x0badf00d01020304);
3996 assert_eq!(outgoing_cltv_value, 0xffffffff);
3997 } else { panic!(); }
4001 fn encoding_final_onion_hop_data() {
4002 let outbound_msg = msgs::OutboundOnionPayload::Receive {
4004 payment_metadata: None,
4005 keysend_preimage: None,
4006 amt_msat: 0x0badf00d01020304,
4007 outgoing_cltv_value: 0xffffffff,
4008 custom_tlvs: vec![],
4010 let encoded_value = outbound_msg.encode();
4011 let target_value = <Vec<u8>>::from_hex("1002080badf00d010203040404ffffffff").unwrap();
4012 assert_eq!(encoded_value, target_value);
4014 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4015 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
4016 if let msgs::InboundOnionPayload::Receive {
4017 payment_data: None, amt_msat, outgoing_cltv_value, ..
4019 assert_eq!(amt_msat, 0x0badf00d01020304);
4020 assert_eq!(outgoing_cltv_value, 0xffffffff);
4021 } else { panic!(); }
4025 fn encoding_final_onion_hop_data_with_secret() {
4026 let expected_payment_secret = PaymentSecret([0x42u8; 32]);
4027 let outbound_msg = msgs::OutboundOnionPayload::Receive {
4028 payment_data: Some(FinalOnionHopData {
4029 payment_secret: expected_payment_secret,
4030 total_msat: 0x1badca1f
4032 payment_metadata: None,
4033 keysend_preimage: None,
4034 amt_msat: 0x0badf00d01020304,
4035 outgoing_cltv_value: 0xffffffff,
4036 custom_tlvs: vec![],
4038 let encoded_value = outbound_msg.encode();
4039 let target_value = <Vec<u8>>::from_hex("3602080badf00d010203040404ffffffff082442424242424242424242424242424242424242424242424242424242424242421badca1f").unwrap();
4040 assert_eq!(encoded_value, target_value);
4042 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4043 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
4044 if let msgs::InboundOnionPayload::Receive {
4045 payment_data: Some(FinalOnionHopData {
4047 total_msat: 0x1badca1f
4049 amt_msat, outgoing_cltv_value,
4050 payment_metadata: None,
4051 keysend_preimage: None,
4054 assert_eq!(payment_secret, expected_payment_secret);
4055 assert_eq!(amt_msat, 0x0badf00d01020304);
4056 assert_eq!(outgoing_cltv_value, 0xffffffff);
4057 assert_eq!(custom_tlvs, vec![]);
4058 } else { panic!(); }
4062 fn encoding_final_onion_hop_data_with_bad_custom_tlvs() {
4063 // If custom TLVs have type number within the range reserved for protocol, treat them as if
4065 let bad_type_range_tlvs = vec![
4066 ((1 << 16) - 4, vec![42]),
4067 ((1 << 16) - 2, vec![42; 32]),
4069 let mut msg = msgs::OutboundOnionPayload::Receive {
4071 payment_metadata: None,
4072 keysend_preimage: None,
4073 custom_tlvs: bad_type_range_tlvs,
4074 amt_msat: 0x0badf00d01020304,
4075 outgoing_cltv_value: 0xffffffff,
4077 let encoded_value = msg.encode();
4078 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4079 assert!(msgs::InboundOnionPayload::read(&mut Cursor::new(&encoded_value[..]), &&node_signer).is_err());
4080 let good_type_range_tlvs = vec![
4081 ((1 << 16) - 3, vec![42]),
4082 ((1 << 16) - 1, vec![42; 32]),
4084 if let msgs::OutboundOnionPayload::Receive { ref mut custom_tlvs, .. } = msg {
4085 *custom_tlvs = good_type_range_tlvs.clone();
4087 let encoded_value = msg.encode();
4088 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&encoded_value[..]), &&node_signer).unwrap();
4090 msgs::InboundOnionPayload::Receive { custom_tlvs, .. } => assert!(custom_tlvs.is_empty()),
4096 fn encoding_final_onion_hop_data_with_custom_tlvs() {
4097 let expected_custom_tlvs = vec![
4098 (5482373483, vec![0x12, 0x34]),
4099 (5482373487, vec![0x42u8; 8]),
4101 let msg = msgs::OutboundOnionPayload::Receive {
4103 payment_metadata: None,
4104 keysend_preimage: None,
4105 custom_tlvs: expected_custom_tlvs.clone(),
4106 amt_msat: 0x0badf00d01020304,
4107 outgoing_cltv_value: 0xffffffff,
4109 let encoded_value = msg.encode();
4110 let target_value = <Vec<u8>>::from_hex("2e02080badf00d010203040404ffffffffff0000000146c6616b021234ff0000000146c6616f084242424242424242").unwrap();
4111 assert_eq!(encoded_value, target_value);
4112 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4113 let inbound_msg: msgs::InboundOnionPayload = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
4114 if let msgs::InboundOnionPayload::Receive {
4116 payment_metadata: None,
4117 keysend_preimage: None,
4120 outgoing_cltv_value,
4123 assert_eq!(custom_tlvs, expected_custom_tlvs);
4124 assert_eq!(amt_msat, 0x0badf00d01020304);
4125 assert_eq!(outgoing_cltv_value, 0xffffffff);
4126 } else { panic!(); }
4130 fn query_channel_range_end_blocknum() {
4131 let tests: Vec<(u32, u32, u32)> = vec![
4132 (10000, 1500, 11500),
4133 (0, 0xffffffff, 0xffffffff),
4134 (1, 0xffffffff, 0xffffffff),
4137 for (first_blocknum, number_of_blocks, expected) in tests.into_iter() {
4138 let sut = msgs::QueryChannelRange {
4139 chain_hash: ChainHash::using_genesis_block(Network::Regtest),
4143 assert_eq!(sut.end_blocknum(), expected);
4148 fn encoding_query_channel_range() {
4149 let mut query_channel_range = msgs::QueryChannelRange {
4150 chain_hash: ChainHash::using_genesis_block(Network::Regtest),
4151 first_blocknum: 100000,
4152 number_of_blocks: 1500,
4154 let encoded_value = query_channel_range.encode();
4155 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000186a0000005dc").unwrap();
4156 assert_eq!(encoded_value, target_value);
4158 query_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4159 assert_eq!(query_channel_range.first_blocknum, 100000);
4160 assert_eq!(query_channel_range.number_of_blocks, 1500);
4164 fn encoding_reply_channel_range() {
4165 do_encoding_reply_channel_range(0);
4166 do_encoding_reply_channel_range(1);
4169 fn do_encoding_reply_channel_range(encoding_type: u8) {
4170 let mut target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000b8a06000005dc01").unwrap();
4171 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4172 let mut reply_channel_range = msgs::ReplyChannelRange {
4173 chain_hash: expected_chain_hash,
4174 first_blocknum: 756230,
4175 number_of_blocks: 1500,
4176 sync_complete: true,
4177 short_channel_ids: vec![0x000000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
4180 if encoding_type == 0 {
4181 target_value.append(&mut <Vec<u8>>::from_hex("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
4182 let encoded_value = reply_channel_range.encode();
4183 assert_eq!(encoded_value, target_value);
4185 reply_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4186 assert_eq!(reply_channel_range.chain_hash, expected_chain_hash);
4187 assert_eq!(reply_channel_range.first_blocknum, 756230);
4188 assert_eq!(reply_channel_range.number_of_blocks, 1500);
4189 assert_eq!(reply_channel_range.sync_complete, true);
4190 assert_eq!(reply_channel_range.short_channel_ids[0], 0x000000000000008e);
4191 assert_eq!(reply_channel_range.short_channel_ids[1], 0x0000000000003c69);
4192 assert_eq!(reply_channel_range.short_channel_ids[2], 0x000000000045a6c4);
4194 target_value.append(&mut <Vec<u8>>::from_hex("001601789c636000833e08659309a65878be010010a9023a").unwrap());
4195 let result: Result<msgs::ReplyChannelRange, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
4196 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
4201 fn encoding_query_short_channel_ids() {
4202 do_encoding_query_short_channel_ids(0);
4203 do_encoding_query_short_channel_ids(1);
4206 fn do_encoding_query_short_channel_ids(encoding_type: u8) {
4207 let mut target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
4208 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4209 let mut query_short_channel_ids = msgs::QueryShortChannelIds {
4210 chain_hash: expected_chain_hash,
4211 short_channel_ids: vec![0x0000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
4214 if encoding_type == 0 {
4215 target_value.append(&mut <Vec<u8>>::from_hex("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
4216 let encoded_value = query_short_channel_ids.encode();
4217 assert_eq!(encoded_value, target_value);
4219 query_short_channel_ids = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4220 assert_eq!(query_short_channel_ids.chain_hash, expected_chain_hash);
4221 assert_eq!(query_short_channel_ids.short_channel_ids[0], 0x000000000000008e);
4222 assert_eq!(query_short_channel_ids.short_channel_ids[1], 0x0000000000003c69);
4223 assert_eq!(query_short_channel_ids.short_channel_ids[2], 0x000000000045a6c4);
4225 target_value.append(&mut <Vec<u8>>::from_hex("001601789c636000833e08659309a65878be010010a9023a").unwrap());
4226 let result: Result<msgs::QueryShortChannelIds, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
4227 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
4232 fn encoding_reply_short_channel_ids_end() {
4233 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4234 let mut reply_short_channel_ids_end = msgs::ReplyShortChannelIdsEnd {
4235 chain_hash: expected_chain_hash,
4236 full_information: true,
4238 let encoded_value = reply_short_channel_ids_end.encode();
4239 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f01").unwrap();
4240 assert_eq!(encoded_value, target_value);
4242 reply_short_channel_ids_end = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4243 assert_eq!(reply_short_channel_ids_end.chain_hash, expected_chain_hash);
4244 assert_eq!(reply_short_channel_ids_end.full_information, true);
4248 fn encoding_gossip_timestamp_filter(){
4249 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4250 let mut gossip_timestamp_filter = msgs::GossipTimestampFilter {
4251 chain_hash: expected_chain_hash,
4252 first_timestamp: 1590000000,
4253 timestamp_range: 0xffff_ffff,
4255 let encoded_value = gossip_timestamp_filter.encode();
4256 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f5ec57980ffffffff").unwrap();
4257 assert_eq!(encoded_value, target_value);
4259 gossip_timestamp_filter = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4260 assert_eq!(gossip_timestamp_filter.chain_hash, expected_chain_hash);
4261 assert_eq!(gossip_timestamp_filter.first_timestamp, 1590000000);
4262 assert_eq!(gossip_timestamp_filter.timestamp_range, 0xffff_ffff);
4266 fn decode_onion_hop_data_len_as_bigsize() {
4267 // Tests that we can decode an onion payload that is >253 bytes.
4268 // Previously, receiving a payload of this size could've caused us to fail to decode a valid
4269 // payload, because we were decoding the length (a BigSize, big-endian) as a VarInt
4272 // Encode a test onion payload with a big custom TLV such that it's >253 bytes, forcing the
4273 // payload length to be encoded over multiple bytes rather than a single u8.
4274 let big_payload = encode_big_payload().unwrap();
4275 let mut rd = Cursor::new(&big_payload[..]);
4277 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4278 <msgs::InboundOnionPayload as ReadableArgs<&&test_utils::TestKeysInterface>>
4279 ::read(&mut rd, &&node_signer).unwrap();
4281 // see above test, needs to be a separate method for use of the serialization macros.
4282 fn encode_big_payload() -> Result<Vec<u8>, io::Error> {
4283 use crate::util::ser::HighZeroBytesDroppedBigSize;
4284 let payload = msgs::OutboundOnionPayload::Forward {
4285 short_channel_id: 0xdeadbeef1bad1dea,
4286 amt_to_forward: 1000,
4287 outgoing_cltv_value: 0xffffffff,
4289 let mut encoded_payload = Vec::new();
4290 let test_bytes = vec![42u8; 1000];
4291 if let msgs::OutboundOnionPayload::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } = payload {
4292 _encode_varint_length_prefixed_tlv!(&mut encoded_payload, {
4293 (1, test_bytes, required_vec),
4294 (2, HighZeroBytesDroppedBigSize(amt_to_forward), required),
4295 (4, HighZeroBytesDroppedBigSize(outgoing_cltv_value), required),
4296 (6, short_channel_id, required)
4303 #[cfg(feature = "std")]
4304 fn test_socket_address_from_str() {
4305 let tcpip_v4 = SocketAddress::TcpIpV4 {
4306 addr: Ipv4Addr::new(127, 0, 0, 1).octets(),
4309 assert_eq!(tcpip_v4, SocketAddress::from_str("127.0.0.1:1234").unwrap());
4310 assert_eq!(tcpip_v4, SocketAddress::from_str(&tcpip_v4.to_string()).unwrap());
4312 let tcpip_v6 = SocketAddress::TcpIpV6 {
4313 addr: Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1).octets(),
4316 assert_eq!(tcpip_v6, SocketAddress::from_str("[0:0:0:0:0:0:0:1]:1234").unwrap());
4317 assert_eq!(tcpip_v6, SocketAddress::from_str(&tcpip_v6.to_string()).unwrap());
4319 let hostname = SocketAddress::Hostname {
4320 hostname: Hostname::try_from("lightning-node.mydomain.com".to_string()).unwrap(),
4323 assert_eq!(hostname, SocketAddress::from_str("lightning-node.mydomain.com:1234").unwrap());
4324 assert_eq!(hostname, SocketAddress::from_str(&hostname.to_string()).unwrap());
4326 let onion_v2 = SocketAddress::OnionV2 ([40, 4, 64, 185, 202, 19, 162, 75, 90, 200, 38, 7],);
4327 assert_eq!("OnionV2([40, 4, 64, 185, 202, 19, 162, 75, 90, 200, 38, 7])", &onion_v2.to_string());
4328 assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("FACEBOOKCOREWWWI.onion:9735"));
4330 let onion_v3 = SocketAddress::OnionV3 {
4331 ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102, 182, 107, 4, 105, 247, 246, 85,
4332 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31, 33, 71, 3],
4337 assert_eq!(onion_v3, SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion:1234").unwrap());
4338 assert_eq!(onion_v3, SocketAddress::from_str(&onion_v3.to_string()).unwrap());
4340 assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6.onion:1234"));
4341 assert_eq!(Err(SocketAddressParseError::InvalidInput), SocketAddress::from_str("127.0.0.1@1234"));
4342 assert_eq!(Err(SocketAddressParseError::InvalidInput), "".parse::<SocketAddress>());
4343 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:9735:94").is_err());
4344 assert!(SocketAddress::from_str("wrong$%#.com:1234").is_err());
4345 assert_eq!(Err(SocketAddressParseError::InvalidPort), SocketAddress::from_str("example.com:wrong"));
4346 assert!("localhost".parse::<SocketAddress>().is_err());
4347 assert!("localhost:invalid-port".parse::<SocketAddress>().is_err());
4348 assert!( "invalid-onion-v3-hostname.onion:8080".parse::<SocketAddress>().is_err());
4349 assert!("b32.example.onion:invalid-port".parse::<SocketAddress>().is_err());
4350 assert!("invalid-address".parse::<SocketAddress>().is_err());
4351 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:1234").is_err());
4355 #[cfg(feature = "std")]
4356 fn test_socket_address_to_socket_addrs() {
4357 assert_eq!(SocketAddress::TcpIpV4 {addr:[0u8; 4], port: 1337,}.to_socket_addrs().unwrap().next().unwrap(),
4358 SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(0,0,0,0), 1337)));
4359 assert_eq!(SocketAddress::TcpIpV6 {addr:[0u8; 16], port: 1337,}.to_socket_addrs().unwrap().next().unwrap(),
4360 SocketAddr::V6(SocketAddrV6::new(Ipv6Addr::from([0u8; 16]), 1337, 0, 0)));
4361 assert_eq!(SocketAddress::Hostname { hostname: Hostname::try_from("0.0.0.0".to_string()).unwrap(), port: 0 }
4362 .to_socket_addrs().unwrap().next().unwrap(), SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::from([0u8; 4]),0)));
4363 assert!(SocketAddress::OnionV2([0u8; 12]).to_socket_addrs().is_err());
4364 assert!(SocketAddress::OnionV3{ ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102,
4365 182, 107, 4, 105, 247, 246, 85, 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31,
4369 port: 1234 }.to_socket_addrs().is_err());