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::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;
1672 #[cfg_attr(test, derive(Debug, PartialEq))]
1673 /// Information communicated in the onion to the recipient for multi-part tracking and proof that
1674 /// the payment is associated with an invoice.
1675 pub struct FinalOnionHopData {
1676 /// When sending a multi-part payment, this secret is used to identify a payment across HTLCs.
1677 /// Because it is generated by the recipient and included in the invoice, it also provides
1678 /// proof to the recipient that the payment was sent by someone with the generated invoice.
1679 pub payment_secret: PaymentSecret,
1680 /// The intended total amount that this payment is for.
1682 /// Message serialization may panic if this value is more than 21 million Bitcoin.
1683 pub total_msat: u64,
1686 mod fuzzy_internal_msgs {
1687 use bitcoin::secp256k1::PublicKey;
1688 use crate::blinded_path::payment::{PaymentConstraints, PaymentRelay};
1689 use crate::prelude::*;
1690 use crate::ln::{PaymentPreimage, PaymentSecret};
1691 use crate::ln::features::BlindedHopFeatures;
1692 use super::FinalOnionHopData;
1694 // These types aren't intended to be pub, but are exposed for direct fuzzing (as we deserialize
1695 // them from untrusted input):
1697 pub enum InboundOnionPayload {
1699 short_channel_id: u64,
1700 /// The value, in msat, of the payment after this hop's fee is deducted.
1701 amt_to_forward: u64,
1702 outgoing_cltv_value: u32,
1705 payment_data: Option<FinalOnionHopData>,
1706 payment_metadata: Option<Vec<u8>>,
1707 keysend_preimage: Option<PaymentPreimage>,
1708 custom_tlvs: Vec<(u64, Vec<u8>)>,
1709 sender_intended_htlc_amt_msat: u64,
1710 cltv_expiry_height: u32,
1713 short_channel_id: u64,
1714 payment_relay: PaymentRelay,
1715 payment_constraints: PaymentConstraints,
1716 features: BlindedHopFeatures,
1717 intro_node_blinding_point: PublicKey,
1720 sender_intended_htlc_amt_msat: u64,
1722 cltv_expiry_height: u32,
1723 payment_secret: PaymentSecret,
1724 payment_constraints: PaymentConstraints,
1725 intro_node_blinding_point: Option<PublicKey>,
1729 pub(crate) enum OutboundOnionPayload {
1731 short_channel_id: u64,
1732 /// The value, in msat, of the payment after this hop's fee is deducted.
1733 amt_to_forward: u64,
1734 outgoing_cltv_value: u32,
1737 payment_data: Option<FinalOnionHopData>,
1738 payment_metadata: Option<Vec<u8>>,
1739 keysend_preimage: Option<PaymentPreimage>,
1740 custom_tlvs: Vec<(u64, Vec<u8>)>,
1741 sender_intended_htlc_amt_msat: u64,
1742 cltv_expiry_height: u32,
1745 encrypted_tlvs: Vec<u8>,
1746 intro_node_blinding_point: Option<PublicKey>,
1749 sender_intended_htlc_amt_msat: u64,
1751 cltv_expiry_height: u32,
1752 encrypted_tlvs: Vec<u8>,
1753 intro_node_blinding_point: Option<PublicKey>, // Set if the introduction node of the blinded path is the final node
1757 pub struct DecodedOnionErrorPacket {
1758 pub(crate) hmac: [u8; 32],
1759 pub(crate) failuremsg: Vec<u8>,
1760 pub(crate) pad: Vec<u8>,
1764 pub use self::fuzzy_internal_msgs::*;
1765 #[cfg(not(fuzzing))]
1766 pub(crate) use self::fuzzy_internal_msgs::*;
1768 /// BOLT 4 onion packet including hop data for the next peer.
1769 #[derive(Clone, Hash, PartialEq, Eq)]
1770 pub struct OnionPacket {
1771 /// BOLT 4 version number.
1773 /// In order to ensure we always return an error on onion decode in compliance with [BOLT
1774 /// #4](https://github.com/lightning/bolts/blob/master/04-onion-routing.md), we have to
1775 /// deserialize `OnionPacket`s contained in [`UpdateAddHTLC`] messages even if the ephemeral
1776 /// public key (here) is bogus, so we hold a [`Result`] instead of a [`PublicKey`] as we'd
1778 pub public_key: Result<PublicKey, secp256k1::Error>,
1779 /// 1300 bytes encrypted payload for the next hop.
1780 pub hop_data: [u8; 20*65],
1781 /// HMAC to verify the integrity of hop_data.
1785 impl onion_utils::Packet for OnionPacket {
1786 type Data = onion_utils::FixedSizeOnionPacket;
1787 fn new(pubkey: PublicKey, hop_data: onion_utils::FixedSizeOnionPacket, hmac: [u8; 32]) -> Self {
1790 public_key: Ok(pubkey),
1791 hop_data: hop_data.0,
1797 impl fmt::Debug for OnionPacket {
1798 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1799 f.write_fmt(format_args!("OnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
1803 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1804 pub(crate) struct OnionErrorPacket {
1805 // This really should be a constant size slice, but the spec lets these things be up to 128KB?
1806 // (TODO) We limit it in decode to much lower...
1807 pub(crate) data: Vec<u8>,
1810 impl fmt::Display for DecodeError {
1811 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1813 DecodeError::UnknownVersion => f.write_str("Unknown realm byte in Onion packet"),
1814 DecodeError::UnknownRequiredFeature => f.write_str("Unknown required feature preventing decode"),
1815 DecodeError::InvalidValue => f.write_str("Nonsense bytes didn't map to the type they were interpreted as"),
1816 DecodeError::ShortRead => f.write_str("Packet extended beyond the provided bytes"),
1817 DecodeError::BadLengthDescriptor => f.write_str("A length descriptor in the packet didn't describe the later data correctly"),
1818 DecodeError::Io(ref e) => fmt::Debug::fmt(e, f),
1819 DecodeError::UnsupportedCompression => f.write_str("We don't support receiving messages with zlib-compressed fields"),
1824 impl From<io::Error> for DecodeError {
1825 fn from(e: io::Error) -> Self {
1826 if e.kind() == io::ErrorKind::UnexpectedEof {
1827 DecodeError::ShortRead
1829 DecodeError::Io(e.kind())
1834 #[cfg(not(taproot))]
1835 impl_writeable_msg!(AcceptChannel, {
1836 temporary_channel_id,
1837 dust_limit_satoshis,
1838 max_htlc_value_in_flight_msat,
1839 channel_reserve_satoshis,
1845 revocation_basepoint,
1847 delayed_payment_basepoint,
1849 first_per_commitment_point,
1851 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))), // Don't encode length twice.
1852 (1, channel_type, option),
1856 impl_writeable_msg!(AcceptChannel, {
1857 temporary_channel_id,
1858 dust_limit_satoshis,
1859 max_htlc_value_in_flight_msat,
1860 channel_reserve_satoshis,
1866 revocation_basepoint,
1868 delayed_payment_basepoint,
1870 first_per_commitment_point,
1872 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))), // Don't encode length twice.
1873 (1, channel_type, option),
1874 (4, next_local_nonce, option),
1877 impl_writeable_msg!(AcceptChannelV2, {
1878 temporary_channel_id,
1880 dust_limit_satoshis,
1881 max_htlc_value_in_flight_msat,
1887 revocation_basepoint,
1889 delayed_payment_basepoint,
1891 first_per_commitment_point,
1892 second_per_commitment_point,
1894 (0, shutdown_scriptpubkey, option),
1895 (1, channel_type, option),
1896 (2, require_confirmed_inputs, option),
1899 impl_writeable_msg!(Stfu, {
1904 impl_writeable_msg!(Splice, {
1908 funding_feerate_perkw,
1913 impl_writeable_msg!(SpliceAck, {
1920 impl_writeable_msg!(SpliceLocked, {
1924 impl_writeable_msg!(TxAddInput, {
1932 impl_writeable_msg!(TxAddOutput, {
1939 impl_writeable_msg!(TxRemoveInput, {
1944 impl_writeable_msg!(TxRemoveOutput, {
1949 impl_writeable_msg!(TxComplete, {
1953 impl_writeable_msg!(TxSignatures, {
1959 impl_writeable_msg!(TxInitRbf, {
1962 feerate_sat_per_1000_weight,
1964 (0, funding_output_contribution, option),
1967 impl_writeable_msg!(TxAckRbf, {
1970 (0, funding_output_contribution, option),
1973 impl_writeable_msg!(TxAbort, {
1978 impl_writeable_msg!(AnnouncementSignatures, {
1985 impl_writeable_msg!(ChannelReestablish, {
1987 next_local_commitment_number,
1988 next_remote_commitment_number,
1989 your_last_per_commitment_secret,
1990 my_current_per_commitment_point,
1992 (0, next_funding_txid, option),
1995 impl_writeable_msg!(ClosingSigned,
1996 { channel_id, fee_satoshis, signature },
1997 { (1, fee_range, option) }
2000 impl_writeable!(ClosingSignedFeeRange, {
2005 #[cfg(not(taproot))]
2006 impl_writeable_msg!(CommitmentSigned, {
2013 impl_writeable_msg!(CommitmentSigned, {
2018 (2, partial_signature_with_nonce, option)
2021 impl_writeable!(DecodedOnionErrorPacket, {
2027 #[cfg(not(taproot))]
2028 impl_writeable_msg!(FundingCreated, {
2029 temporary_channel_id,
2031 funding_output_index,
2035 impl_writeable_msg!(FundingCreated, {
2036 temporary_channel_id,
2038 funding_output_index,
2041 (2, partial_signature_with_nonce, option),
2042 (4, next_local_nonce, option)
2045 #[cfg(not(taproot))]
2046 impl_writeable_msg!(FundingSigned, {
2052 impl_writeable_msg!(FundingSigned, {
2056 (2, partial_signature_with_nonce, option)
2059 impl_writeable_msg!(ChannelReady, {
2061 next_per_commitment_point,
2063 (1, short_channel_id_alias, option),
2066 impl Writeable for Init {
2067 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2068 // global_features gets the bottom 13 bits of our features, and local_features gets all of
2069 // our relevant feature bits. This keeps us compatible with old nodes.
2070 self.features.write_up_to_13(w)?;
2071 self.features.write(w)?;
2072 encode_tlv_stream!(w, {
2073 (1, self.networks.as_ref().map(|n| WithoutLength(n)), option),
2074 (3, self.remote_network_address, option),
2080 impl Readable for Init {
2081 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2082 let global_features: InitFeatures = Readable::read(r)?;
2083 let features: InitFeatures = Readable::read(r)?;
2084 let mut remote_network_address: Option<SocketAddress> = None;
2085 let mut networks: Option<WithoutLength<Vec<ChainHash>>> = None;
2086 decode_tlv_stream!(r, {
2087 (1, networks, option),
2088 (3, remote_network_address, option)
2091 features: features | global_features,
2092 networks: networks.map(|n| n.0),
2093 remote_network_address,
2098 impl_writeable_msg!(OpenChannel, {
2100 temporary_channel_id,
2103 dust_limit_satoshis,
2104 max_htlc_value_in_flight_msat,
2105 channel_reserve_satoshis,
2111 revocation_basepoint,
2113 delayed_payment_basepoint,
2115 first_per_commitment_point,
2118 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))), // Don't encode length twice.
2119 (1, channel_type, option),
2122 impl_writeable_msg!(OpenChannelV2, {
2124 temporary_channel_id,
2125 funding_feerate_sat_per_1000_weight,
2126 commitment_feerate_sat_per_1000_weight,
2128 dust_limit_satoshis,
2129 max_htlc_value_in_flight_msat,
2135 revocation_basepoint,
2137 delayed_payment_basepoint,
2139 first_per_commitment_point,
2140 second_per_commitment_point,
2143 (0, shutdown_scriptpubkey, option),
2144 (1, channel_type, option),
2145 (2, require_confirmed_inputs, option),
2148 #[cfg(not(taproot))]
2149 impl_writeable_msg!(RevokeAndACK, {
2151 per_commitment_secret,
2152 next_per_commitment_point
2156 impl_writeable_msg!(RevokeAndACK, {
2158 per_commitment_secret,
2159 next_per_commitment_point
2161 (4, next_local_nonce, option)
2164 impl_writeable_msg!(Shutdown, {
2169 impl_writeable_msg!(UpdateFailHTLC, {
2175 impl_writeable_msg!(UpdateFailMalformedHTLC, {
2182 impl_writeable_msg!(UpdateFee, {
2187 impl_writeable_msg!(UpdateFulfillHTLC, {
2193 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2194 // serialization format in a way which assumes we know the total serialized length/message end
2196 impl_writeable!(OnionErrorPacket, {
2200 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2201 // serialization format in a way which assumes we know the total serialized length/message end
2203 impl Writeable for OnionPacket {
2204 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2205 self.version.write(w)?;
2206 match self.public_key {
2207 Ok(pubkey) => pubkey.write(w)?,
2208 Err(_) => [0u8;33].write(w)?,
2210 w.write_all(&self.hop_data)?;
2211 self.hmac.write(w)?;
2216 impl Readable for OnionPacket {
2217 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2219 version: Readable::read(r)?,
2221 let mut buf = [0u8;33];
2222 r.read_exact(&mut buf)?;
2223 PublicKey::from_slice(&buf)
2225 hop_data: Readable::read(r)?,
2226 hmac: Readable::read(r)?,
2231 impl_writeable_msg!(UpdateAddHTLC, {
2237 onion_routing_packet,
2239 (0, blinding_point, option),
2240 (65537, skimmed_fee_msat, option)
2243 impl Readable for OnionMessage {
2244 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2245 let blinding_point: PublicKey = Readable::read(r)?;
2246 let len: u16 = Readable::read(r)?;
2247 let mut packet_reader = FixedLengthReader::new(r, len as u64);
2248 let onion_routing_packet: onion_message::packet::Packet =
2249 <onion_message::packet::Packet as LengthReadable>::read(&mut packet_reader)?;
2252 onion_routing_packet,
2257 impl Writeable for OnionMessage {
2258 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2259 self.blinding_point.write(w)?;
2260 let onion_packet_len = self.onion_routing_packet.serialized_length();
2261 (onion_packet_len as u16).write(w)?;
2262 self.onion_routing_packet.write(w)?;
2267 impl Writeable for FinalOnionHopData {
2268 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2269 self.payment_secret.0.write(w)?;
2270 HighZeroBytesDroppedBigSize(self.total_msat).write(w)
2274 impl Readable for FinalOnionHopData {
2275 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2276 let secret: [u8; 32] = Readable::read(r)?;
2277 let amt: HighZeroBytesDroppedBigSize<u64> = Readable::read(r)?;
2278 Ok(Self { payment_secret: PaymentSecret(secret), total_msat: amt.0 })
2282 impl Writeable for OutboundOnionPayload {
2283 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2285 Self::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } => {
2286 _encode_varint_length_prefixed_tlv!(w, {
2287 (2, HighZeroBytesDroppedBigSize(*amt_to_forward), required),
2288 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2289 (6, short_channel_id, required)
2293 ref payment_data, ref payment_metadata, ref keysend_preimage, sender_intended_htlc_amt_msat,
2294 cltv_expiry_height, ref custom_tlvs,
2296 // We need to update [`ln::outbound_payment::RecipientOnionFields::with_custom_tlvs`]
2297 // to reject any reserved types in the experimental range if new ones are ever
2299 let keysend_tlv = keysend_preimage.map(|preimage| (5482373484, preimage.encode()));
2300 let mut custom_tlvs: Vec<&(u64, Vec<u8>)> = custom_tlvs.iter().chain(keysend_tlv.iter()).collect();
2301 custom_tlvs.sort_unstable_by_key(|(typ, _)| *typ);
2302 _encode_varint_length_prefixed_tlv!(w, {
2303 (2, HighZeroBytesDroppedBigSize(*sender_intended_htlc_amt_msat), required),
2304 (4, HighZeroBytesDroppedBigSize(*cltv_expiry_height), required),
2305 (8, payment_data, option),
2306 (16, payment_metadata.as_ref().map(|m| WithoutLength(m)), option)
2307 }, custom_tlvs.iter());
2309 Self::BlindedForward { encrypted_tlvs, intro_node_blinding_point } => {
2310 _encode_varint_length_prefixed_tlv!(w, {
2311 (10, *encrypted_tlvs, required_vec),
2312 (12, intro_node_blinding_point, option)
2315 Self::BlindedReceive {
2316 sender_intended_htlc_amt_msat, total_msat, cltv_expiry_height, encrypted_tlvs,
2317 intro_node_blinding_point,
2319 _encode_varint_length_prefixed_tlv!(w, {
2320 (2, HighZeroBytesDroppedBigSize(*sender_intended_htlc_amt_msat), required),
2321 (4, HighZeroBytesDroppedBigSize(*cltv_expiry_height), required),
2322 (10, *encrypted_tlvs, required_vec),
2323 (12, intro_node_blinding_point, option),
2324 (18, HighZeroBytesDroppedBigSize(*total_msat), required)
2332 impl<NS: Deref> ReadableArgs<(Option<PublicKey>, &NS)> for InboundOnionPayload where NS::Target: NodeSigner {
2333 fn read<R: Read>(r: &mut R, args: (Option<PublicKey>, &NS)) -> Result<Self, DecodeError> {
2334 let (update_add_blinding_point, node_signer) = args;
2337 let mut cltv_value = None;
2338 let mut short_id: Option<u64> = None;
2339 let mut payment_data: Option<FinalOnionHopData> = None;
2340 let mut encrypted_tlvs_opt: Option<WithoutLength<Vec<u8>>> = None;
2341 let mut intro_node_blinding_point = None;
2342 let mut payment_metadata: Option<WithoutLength<Vec<u8>>> = None;
2343 let mut total_msat = None;
2344 let mut keysend_preimage: Option<PaymentPreimage> = None;
2345 let mut custom_tlvs = Vec::new();
2347 let tlv_len = BigSize::read(r)?;
2348 let rd = FixedLengthReader::new(r, tlv_len.0);
2349 decode_tlv_stream_with_custom_tlv_decode!(rd, {
2350 (2, amt, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2351 (4, cltv_value, (option, encoding: (u32, HighZeroBytesDroppedBigSize))),
2352 (6, short_id, option),
2353 (8, payment_data, option),
2354 (10, encrypted_tlvs_opt, option),
2355 (12, intro_node_blinding_point, option),
2356 (16, payment_metadata, option),
2357 (18, total_msat, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2358 // See https://github.com/lightning/blips/blob/master/blip-0003.md
2359 (5482373484, keysend_preimage, option)
2360 }, |msg_type: u64, msg_reader: &mut FixedLengthReader<_>| -> Result<bool, DecodeError> {
2361 if msg_type < 1 << 16 { return Ok(false) }
2362 let mut value = Vec::new();
2363 msg_reader.read_to_end(&mut value)?;
2364 custom_tlvs.push((msg_type, value));
2368 if amt.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2369 if intro_node_blinding_point.is_some() && update_add_blinding_point.is_some() {
2370 return Err(DecodeError::InvalidValue)
2373 if let Some(blinding_point) = intro_node_blinding_point.or(update_add_blinding_point) {
2374 if short_id.is_some() || payment_data.is_some() || payment_metadata.is_some() ||
2375 keysend_preimage.is_some()
2377 return Err(DecodeError::InvalidValue)
2379 let enc_tlvs = encrypted_tlvs_opt.ok_or(DecodeError::InvalidValue)?.0;
2380 let enc_tlvs_ss = node_signer.ecdh(Recipient::Node, &blinding_point, None)
2381 .map_err(|_| DecodeError::InvalidValue)?;
2382 let rho = onion_utils::gen_rho_from_shared_secret(&enc_tlvs_ss.secret_bytes());
2383 let mut s = Cursor::new(&enc_tlvs);
2384 let mut reader = FixedLengthReader::new(&mut s, enc_tlvs.len() as u64);
2385 match ChaChaPolyReadAdapter::read(&mut reader, rho)? {
2386 ChaChaPolyReadAdapter { readable: BlindedPaymentTlvs::Forward(ForwardTlvs {
2387 short_channel_id, payment_relay, payment_constraints, features
2389 if amt.is_some() || cltv_value.is_some() || total_msat.is_some() {
2390 return Err(DecodeError::InvalidValue)
2392 Ok(Self::BlindedForward {
2395 payment_constraints,
2397 intro_node_blinding_point: intro_node_blinding_point.ok_or(DecodeError::InvalidValue)?,
2400 ChaChaPolyReadAdapter { readable: BlindedPaymentTlvs::Receive(ReceiveTlvs {
2401 payment_secret, payment_constraints
2403 if total_msat.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2404 Ok(Self::BlindedReceive {
2405 sender_intended_htlc_amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2406 total_msat: total_msat.ok_or(DecodeError::InvalidValue)?,
2407 cltv_expiry_height: cltv_value.ok_or(DecodeError::InvalidValue)?,
2409 payment_constraints,
2410 intro_node_blinding_point,
2414 } else if let Some(short_channel_id) = short_id {
2415 if payment_data.is_some() || payment_metadata.is_some() || encrypted_tlvs_opt.is_some() ||
2416 total_msat.is_some()
2417 { return Err(DecodeError::InvalidValue) }
2420 amt_to_forward: amt.ok_or(DecodeError::InvalidValue)?,
2421 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2424 if encrypted_tlvs_opt.is_some() || total_msat.is_some() {
2425 return Err(DecodeError::InvalidValue)
2427 if let Some(data) = &payment_data {
2428 if data.total_msat > MAX_VALUE_MSAT {
2429 return Err(DecodeError::InvalidValue);
2434 payment_metadata: payment_metadata.map(|w| w.0),
2436 sender_intended_htlc_amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2437 cltv_expiry_height: cltv_value.ok_or(DecodeError::InvalidValue)?,
2444 impl Writeable for Ping {
2445 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2446 self.ponglen.write(w)?;
2447 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2452 impl Readable for Ping {
2453 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2455 ponglen: Readable::read(r)?,
2457 let byteslen = Readable::read(r)?;
2458 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2465 impl Writeable for Pong {
2466 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2467 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2472 impl Readable for Pong {
2473 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2476 let byteslen = Readable::read(r)?;
2477 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2484 impl Writeable for UnsignedChannelAnnouncement {
2485 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2486 self.features.write(w)?;
2487 self.chain_hash.write(w)?;
2488 self.short_channel_id.write(w)?;
2489 self.node_id_1.write(w)?;
2490 self.node_id_2.write(w)?;
2491 self.bitcoin_key_1.write(w)?;
2492 self.bitcoin_key_2.write(w)?;
2493 w.write_all(&self.excess_data[..])?;
2498 impl Readable for UnsignedChannelAnnouncement {
2499 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2501 features: Readable::read(r)?,
2502 chain_hash: Readable::read(r)?,
2503 short_channel_id: Readable::read(r)?,
2504 node_id_1: Readable::read(r)?,
2505 node_id_2: Readable::read(r)?,
2506 bitcoin_key_1: Readable::read(r)?,
2507 bitcoin_key_2: Readable::read(r)?,
2508 excess_data: read_to_end(r)?,
2513 impl_writeable!(ChannelAnnouncement, {
2516 bitcoin_signature_1,
2517 bitcoin_signature_2,
2521 impl Writeable for UnsignedChannelUpdate {
2522 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2523 // `message_flags` used to indicate presence of `htlc_maximum_msat`, but was deprecated in the spec.
2524 const MESSAGE_FLAGS: u8 = 1;
2525 self.chain_hash.write(w)?;
2526 self.short_channel_id.write(w)?;
2527 self.timestamp.write(w)?;
2528 let all_flags = self.flags as u16 | ((MESSAGE_FLAGS as u16) << 8);
2529 all_flags.write(w)?;
2530 self.cltv_expiry_delta.write(w)?;
2531 self.htlc_minimum_msat.write(w)?;
2532 self.fee_base_msat.write(w)?;
2533 self.fee_proportional_millionths.write(w)?;
2534 self.htlc_maximum_msat.write(w)?;
2535 w.write_all(&self.excess_data[..])?;
2540 impl Readable for UnsignedChannelUpdate {
2541 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2543 chain_hash: Readable::read(r)?,
2544 short_channel_id: Readable::read(r)?,
2545 timestamp: Readable::read(r)?,
2547 let flags: u16 = Readable::read(r)?;
2548 // Note: we ignore the `message_flags` for now, since it was deprecated by the spec.
2551 cltv_expiry_delta: Readable::read(r)?,
2552 htlc_minimum_msat: Readable::read(r)?,
2553 fee_base_msat: Readable::read(r)?,
2554 fee_proportional_millionths: Readable::read(r)?,
2555 htlc_maximum_msat: Readable::read(r)?,
2556 excess_data: read_to_end(r)?,
2561 impl_writeable!(ChannelUpdate, {
2566 impl Writeable for ErrorMessage {
2567 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2568 self.channel_id.write(w)?;
2569 (self.data.len() as u16).write(w)?;
2570 w.write_all(self.data.as_bytes())?;
2575 impl Readable for ErrorMessage {
2576 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2578 channel_id: Readable::read(r)?,
2580 let sz: usize = <u16 as Readable>::read(r)? as usize;
2581 let mut data = Vec::with_capacity(sz);
2583 r.read_exact(&mut data)?;
2584 match String::from_utf8(data) {
2586 Err(_) => return Err(DecodeError::InvalidValue),
2593 impl Writeable for WarningMessage {
2594 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2595 self.channel_id.write(w)?;
2596 (self.data.len() as u16).write(w)?;
2597 w.write_all(self.data.as_bytes())?;
2602 impl Readable for WarningMessage {
2603 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2605 channel_id: Readable::read(r)?,
2607 let sz: usize = <u16 as Readable>::read(r)? as usize;
2608 let mut data = Vec::with_capacity(sz);
2610 r.read_exact(&mut data)?;
2611 match String::from_utf8(data) {
2613 Err(_) => return Err(DecodeError::InvalidValue),
2620 impl Writeable for UnsignedNodeAnnouncement {
2621 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2622 self.features.write(w)?;
2623 self.timestamp.write(w)?;
2624 self.node_id.write(w)?;
2625 w.write_all(&self.rgb)?;
2626 self.alias.write(w)?;
2628 let mut addr_len = 0;
2629 for addr in self.addresses.iter() {
2630 addr_len += 1 + addr.len();
2632 (addr_len + self.excess_address_data.len() as u16).write(w)?;
2633 for addr in self.addresses.iter() {
2636 w.write_all(&self.excess_address_data[..])?;
2637 w.write_all(&self.excess_data[..])?;
2642 impl Readable for UnsignedNodeAnnouncement {
2643 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2644 let features: NodeFeatures = Readable::read(r)?;
2645 let timestamp: u32 = Readable::read(r)?;
2646 let node_id: NodeId = Readable::read(r)?;
2647 let mut rgb = [0; 3];
2648 r.read_exact(&mut rgb)?;
2649 let alias: NodeAlias = Readable::read(r)?;
2651 let addr_len: u16 = Readable::read(r)?;
2652 let mut addresses: Vec<SocketAddress> = Vec::new();
2653 let mut addr_readpos = 0;
2654 let mut excess = false;
2655 let mut excess_byte = 0;
2657 if addr_len <= addr_readpos { break; }
2658 match Readable::read(r) {
2660 if addr_len < addr_readpos + 1 + addr.len() {
2661 return Err(DecodeError::BadLengthDescriptor);
2663 addr_readpos += (1 + addr.len()) as u16;
2664 addresses.push(addr);
2666 Ok(Err(unknown_descriptor)) => {
2668 excess_byte = unknown_descriptor;
2671 Err(DecodeError::ShortRead) => return Err(DecodeError::BadLengthDescriptor),
2672 Err(e) => return Err(e),
2676 let mut excess_data = vec![];
2677 let excess_address_data = if addr_readpos < addr_len {
2678 let mut excess_address_data = vec![0; (addr_len - addr_readpos) as usize];
2679 r.read_exact(&mut excess_address_data[if excess { 1 } else { 0 }..])?;
2681 excess_address_data[0] = excess_byte;
2686 excess_data.push(excess_byte);
2690 excess_data.extend(read_to_end(r)?.iter());
2691 Ok(UnsignedNodeAnnouncement {
2698 excess_address_data,
2704 impl_writeable!(NodeAnnouncement, {
2709 impl Readable for QueryShortChannelIds {
2710 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2711 let chain_hash: ChainHash = Readable::read(r)?;
2713 let encoding_len: u16 = Readable::read(r)?;
2714 let encoding_type: u8 = Readable::read(r)?;
2716 // Must be encoding_type=0 uncompressed serialization. We do not
2717 // support encoding_type=1 zlib serialization.
2718 if encoding_type != EncodingType::Uncompressed as u8 {
2719 return Err(DecodeError::UnsupportedCompression);
2722 // We expect the encoding_len to always includes the 1-byte
2723 // encoding_type and that short_channel_ids are 8-bytes each
2724 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2725 return Err(DecodeError::InvalidValue);
2728 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2729 // less the 1-byte encoding_type
2730 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2731 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2732 for _ in 0..short_channel_id_count {
2733 short_channel_ids.push(Readable::read(r)?);
2736 Ok(QueryShortChannelIds {
2743 impl Writeable for QueryShortChannelIds {
2744 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2745 // Calculated from 1-byte encoding_type plus 8-bytes per short_channel_id
2746 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2748 self.chain_hash.write(w)?;
2749 encoding_len.write(w)?;
2751 // We only support type=0 uncompressed serialization
2752 (EncodingType::Uncompressed as u8).write(w)?;
2754 for scid in self.short_channel_ids.iter() {
2762 impl_writeable_msg!(ReplyShortChannelIdsEnd, {
2767 impl QueryChannelRange {
2768 /// Calculates the overflow safe ending block height for the query.
2770 /// Overflow returns `0xffffffff`, otherwise returns `first_blocknum + number_of_blocks`.
2771 pub fn end_blocknum(&self) -> u32 {
2772 match self.first_blocknum.checked_add(self.number_of_blocks) {
2773 Some(block) => block,
2774 None => u32::max_value(),
2779 impl_writeable_msg!(QueryChannelRange, {
2785 impl Readable for ReplyChannelRange {
2786 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2787 let chain_hash: ChainHash = Readable::read(r)?;
2788 let first_blocknum: u32 = Readable::read(r)?;
2789 let number_of_blocks: u32 = Readable::read(r)?;
2790 let sync_complete: bool = Readable::read(r)?;
2792 let encoding_len: u16 = Readable::read(r)?;
2793 let encoding_type: u8 = Readable::read(r)?;
2795 // Must be encoding_type=0 uncompressed serialization. We do not
2796 // support encoding_type=1 zlib serialization.
2797 if encoding_type != EncodingType::Uncompressed as u8 {
2798 return Err(DecodeError::UnsupportedCompression);
2801 // We expect the encoding_len to always includes the 1-byte
2802 // encoding_type and that short_channel_ids are 8-bytes each
2803 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2804 return Err(DecodeError::InvalidValue);
2807 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2808 // less the 1-byte encoding_type
2809 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2810 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2811 for _ in 0..short_channel_id_count {
2812 short_channel_ids.push(Readable::read(r)?);
2815 Ok(ReplyChannelRange {
2825 impl Writeable for ReplyChannelRange {
2826 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2827 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2828 self.chain_hash.write(w)?;
2829 self.first_blocknum.write(w)?;
2830 self.number_of_blocks.write(w)?;
2831 self.sync_complete.write(w)?;
2833 encoding_len.write(w)?;
2834 (EncodingType::Uncompressed as u8).write(w)?;
2835 for scid in self.short_channel_ids.iter() {
2843 impl_writeable_msg!(GossipTimestampFilter, {
2851 use std::convert::TryFrom;
2852 use bitcoin::{Transaction, TxIn, ScriptBuf, Sequence, Witness, TxOut};
2853 use hex::DisplayHex;
2854 use crate::ln::{PaymentPreimage, PaymentHash, PaymentSecret};
2855 use crate::ln::ChannelId;
2856 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
2857 use crate::ln::msgs::{self, FinalOnionHopData, OnionErrorPacket};
2858 use crate::ln::msgs::SocketAddress;
2859 use crate::routing::gossip::{NodeAlias, NodeId};
2860 use crate::util::ser::{Writeable, Readable, ReadableArgs, Hostname, TransactionU16LenLimited};
2861 use crate::util::test_utils;
2863 use bitcoin::hashes::hex::FromHex;
2864 use bitcoin::address::Address;
2865 use bitcoin::network::constants::Network;
2866 use bitcoin::blockdata::constants::ChainHash;
2867 use bitcoin::blockdata::script::Builder;
2868 use bitcoin::blockdata::opcodes;
2869 use bitcoin::hash_types::Txid;
2870 use bitcoin::locktime::absolute::LockTime;
2872 use bitcoin::secp256k1::{PublicKey,SecretKey};
2873 use bitcoin::secp256k1::{Secp256k1, Message};
2875 use crate::io::{self, Cursor};
2876 use crate::prelude::*;
2877 use core::str::FromStr;
2878 use crate::chain::transaction::OutPoint;
2880 #[cfg(feature = "std")]
2881 use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6, ToSocketAddrs};
2882 #[cfg(feature = "std")]
2883 use crate::ln::msgs::SocketAddressParseError;
2886 fn encoding_channel_reestablish() {
2888 let secp_ctx = Secp256k1::new();
2889 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&<Vec<u8>>::from_hex("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2892 let cr = msgs::ChannelReestablish {
2893 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]),
2894 next_local_commitment_number: 3,
2895 next_remote_commitment_number: 4,
2896 your_last_per_commitment_secret: [9;32],
2897 my_current_per_commitment_point: public_key,
2898 next_funding_txid: None,
2901 let encoded_value = cr.encode();
2905 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
2906 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2907 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2908 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
2909 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
2915 fn encoding_channel_reestablish_with_next_funding_txid() {
2917 let secp_ctx = Secp256k1::new();
2918 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&<Vec<u8>>::from_hex("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2921 let cr = msgs::ChannelReestablish {
2922 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]),
2923 next_local_commitment_number: 3,
2924 next_remote_commitment_number: 4,
2925 your_last_per_commitment_secret: [9;32],
2926 my_current_per_commitment_point: public_key,
2927 next_funding_txid: Some(Txid::from_raw_hash(bitcoin::hashes::Hash::from_slice(&[
2928 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,
2932 let encoded_value = cr.encode();
2936 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
2937 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2938 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2939 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
2940 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
2941 0, // Type (next_funding_txid)
2943 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
2948 macro_rules! get_keys_from {
2949 ($slice: expr, $secp_ctx: expr) => {
2951 let privkey = SecretKey::from_slice(&<Vec<u8>>::from_hex($slice).unwrap()[..]).unwrap();
2952 let pubkey = PublicKey::from_secret_key(&$secp_ctx, &privkey);
2958 macro_rules! get_sig_on {
2959 ($privkey: expr, $ctx: expr, $string: expr) => {
2961 let sighash = Message::from_slice(&$string.into_bytes()[..]).unwrap();
2962 $ctx.sign_ecdsa(&sighash, &$privkey)
2968 fn encoding_announcement_signatures() {
2969 let secp_ctx = Secp256k1::new();
2970 let (privkey, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2971 let sig_1 = get_sig_on!(privkey, secp_ctx, String::from("01010101010101010101010101010101"));
2972 let sig_2 = get_sig_on!(privkey, secp_ctx, String::from("02020202020202020202020202020202"));
2973 let announcement_signatures = msgs::AnnouncementSignatures {
2974 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]),
2975 short_channel_id: 2316138423780173,
2976 node_signature: sig_1,
2977 bitcoin_signature: sig_2,
2980 let encoded_value = announcement_signatures.encode();
2981 assert_eq!(encoded_value, <Vec<u8>>::from_hex("040000000000000005000000000000000600000000000000070000000000000000083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073acf9953cef4700860f5967838eba2bae89288ad188ebf8b20bf995c3ea53a26df1876d0a3a0e13172ba286a673140190c02ba9da60a2e43a745188c8a83c7f3ef").unwrap());
2984 fn do_encoding_channel_announcement(unknown_features_bits: bool, excess_data: bool) {
2985 let secp_ctx = Secp256k1::new();
2986 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2987 let (privkey_2, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2988 let (privkey_3, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2989 let (privkey_4, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2990 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2991 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
2992 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
2993 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
2994 let mut features = ChannelFeatures::empty();
2995 if unknown_features_bits {
2996 features = ChannelFeatures::from_le_bytes(vec![0xFF, 0xFF]);
2998 let unsigned_channel_announcement = msgs::UnsignedChannelAnnouncement {
3000 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3001 short_channel_id: 2316138423780173,
3002 node_id_1: NodeId::from_pubkey(&pubkey_1),
3003 node_id_2: NodeId::from_pubkey(&pubkey_2),
3004 bitcoin_key_1: NodeId::from_pubkey(&pubkey_3),
3005 bitcoin_key_2: NodeId::from_pubkey(&pubkey_4),
3006 excess_data: if excess_data { vec![10, 0, 0, 20, 0, 0, 30, 0, 0, 40] } else { Vec::new() },
3008 let channel_announcement = msgs::ChannelAnnouncement {
3009 node_signature_1: sig_1,
3010 node_signature_2: sig_2,
3011 bitcoin_signature_1: sig_3,
3012 bitcoin_signature_2: sig_4,
3013 contents: unsigned_channel_announcement,
3015 let encoded_value = channel_announcement.encode();
3016 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a1735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap();
3017 if unknown_features_bits {
3018 target_value.append(&mut <Vec<u8>>::from_hex("0002ffff").unwrap());
3020 target_value.append(&mut <Vec<u8>>::from_hex("0000").unwrap());
3022 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3023 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
3025 target_value.append(&mut <Vec<u8>>::from_hex("0a00001400001e000028").unwrap());
3027 assert_eq!(encoded_value, target_value);
3031 fn encoding_channel_announcement() {
3032 do_encoding_channel_announcement(true, false);
3033 do_encoding_channel_announcement(false, true);
3034 do_encoding_channel_announcement(false, false);
3035 do_encoding_channel_announcement(true, true);
3038 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) {
3039 let secp_ctx = Secp256k1::new();
3040 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3041 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3042 let features = if unknown_features_bits {
3043 NodeFeatures::from_le_bytes(vec![0xFF, 0xFF])
3045 // Set to some features we may support
3046 NodeFeatures::from_le_bytes(vec![2 | 1 << 5])
3048 let mut addresses = Vec::new();
3050 addresses.push(SocketAddress::TcpIpV4 {
3051 addr: [255, 254, 253, 252],
3056 addresses.push(SocketAddress::TcpIpV6 {
3057 addr: [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240],
3062 addresses.push(msgs::SocketAddress::OnionV2(
3063 [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 38, 7]
3067 addresses.push(msgs::SocketAddress::OnionV3 {
3068 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],
3075 addresses.push(SocketAddress::Hostname {
3076 hostname: Hostname::try_from(String::from("host")).unwrap(),
3080 let mut addr_len = 0;
3081 for addr in &addresses {
3082 addr_len += addr.len() + 1;
3084 let unsigned_node_announcement = msgs::UnsignedNodeAnnouncement {
3086 timestamp: 20190119,
3087 node_id: NodeId::from_pubkey(&pubkey_1),
3089 alias: NodeAlias([16;32]),
3091 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() },
3092 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() },
3094 addr_len += unsigned_node_announcement.excess_address_data.len() as u16;
3095 let node_announcement = msgs::NodeAnnouncement {
3097 contents: unsigned_node_announcement,
3099 let encoded_value = node_announcement.encode();
3100 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3101 if unknown_features_bits {
3102 target_value.append(&mut <Vec<u8>>::from_hex("0002ffff").unwrap());
3104 target_value.append(&mut <Vec<u8>>::from_hex("000122").unwrap());
3106 target_value.append(&mut <Vec<u8>>::from_hex("013413a7031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f2020201010101010101010101010101010101010101010101010101010101010101010").unwrap());
3107 target_value.append(&mut vec![(addr_len >> 8) as u8, addr_len as u8]);
3109 target_value.append(&mut <Vec<u8>>::from_hex("01fffefdfc2607").unwrap());
3112 target_value.append(&mut <Vec<u8>>::from_hex("02fffefdfcfbfaf9f8f7f6f5f4f3f2f1f02607").unwrap());
3115 target_value.append(&mut <Vec<u8>>::from_hex("03fffefdfcfbfaf9f8f7f62607").unwrap());
3118 target_value.append(&mut <Vec<u8>>::from_hex("04fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0efeeedecebeae9e8e7e6e5e4e3e2e1e00020102607").unwrap());
3121 target_value.append(&mut <Vec<u8>>::from_hex("0504686f73742607").unwrap());
3123 if excess_address_data {
3124 target_value.append(&mut <Vec<u8>>::from_hex("216c280b5395a2546e7e4b2663e04f811622f15a4f92e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d269").unwrap());
3127 target_value.append(&mut <Vec<u8>>::from_hex("3b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
3129 assert_eq!(encoded_value, target_value);
3133 fn encoding_node_announcement() {
3134 do_encoding_node_announcement(true, true, true, true, true, true, true, true);
3135 do_encoding_node_announcement(false, false, false, false, false, false, false, false);
3136 do_encoding_node_announcement(false, true, false, false, false, false, false, false);
3137 do_encoding_node_announcement(false, false, true, false, false, false, false, false);
3138 do_encoding_node_announcement(false, false, false, true, false, false, false, false);
3139 do_encoding_node_announcement(false, false, false, false, true, false, false, false);
3140 do_encoding_node_announcement(false, false, false, false, false, true, false, false);
3141 do_encoding_node_announcement(false, false, false, false, false, false, true, false);
3142 do_encoding_node_announcement(false, true, false, true, false, false, true, false);
3143 do_encoding_node_announcement(false, false, true, false, true, false, false, false);
3146 fn do_encoding_channel_update(direction: bool, disable: bool, excess_data: bool) {
3147 let secp_ctx = Secp256k1::new();
3148 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3149 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3150 let unsigned_channel_update = msgs::UnsignedChannelUpdate {
3151 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3152 short_channel_id: 2316138423780173,
3153 timestamp: 20190119,
3154 flags: if direction { 1 } else { 0 } | if disable { 1 << 1 } else { 0 },
3155 cltv_expiry_delta: 144,
3156 htlc_minimum_msat: 1000000,
3157 htlc_maximum_msat: 131355275467161,
3158 fee_base_msat: 10000,
3159 fee_proportional_millionths: 20,
3160 excess_data: if excess_data { vec![0, 0, 0, 0, 59, 154, 202, 0] } else { Vec::new() }
3162 let channel_update = msgs::ChannelUpdate {
3164 contents: unsigned_channel_update
3166 let encoded_value = channel_update.encode();
3167 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3168 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3169 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d013413a7").unwrap());
3170 target_value.append(&mut <Vec<u8>>::from_hex("01").unwrap());
3171 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3173 let flag = target_value.last_mut().unwrap();
3177 let flag = target_value.last_mut().unwrap();
3178 *flag = *flag | 1 << 1;
3180 target_value.append(&mut <Vec<u8>>::from_hex("009000000000000f42400000271000000014").unwrap());
3181 target_value.append(&mut <Vec<u8>>::from_hex("0000777788889999").unwrap());
3183 target_value.append(&mut <Vec<u8>>::from_hex("000000003b9aca00").unwrap());
3185 assert_eq!(encoded_value, target_value);
3189 fn encoding_channel_update() {
3190 do_encoding_channel_update(false, false, false);
3191 do_encoding_channel_update(false, false, true);
3192 do_encoding_channel_update(true, false, false);
3193 do_encoding_channel_update(true, false, true);
3194 do_encoding_channel_update(false, true, false);
3195 do_encoding_channel_update(false, true, true);
3196 do_encoding_channel_update(true, true, false);
3197 do_encoding_channel_update(true, true, true);
3200 fn do_encoding_open_channel(random_bit: bool, shutdown: bool, incl_chan_type: bool) {
3201 let secp_ctx = Secp256k1::new();
3202 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3203 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3204 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3205 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3206 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3207 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3208 let open_channel = msgs::OpenChannel {
3209 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3210 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3211 funding_satoshis: 1311768467284833366,
3212 push_msat: 2536655962884945560,
3213 dust_limit_satoshis: 3608586615801332854,
3214 max_htlc_value_in_flight_msat: 8517154655701053848,
3215 channel_reserve_satoshis: 8665828695742877976,
3216 htlc_minimum_msat: 2316138423780173,
3217 feerate_per_kw: 821716,
3218 to_self_delay: 49340,
3219 max_accepted_htlcs: 49340,
3220 funding_pubkey: pubkey_1,
3221 revocation_basepoint: pubkey_2,
3222 payment_point: pubkey_3,
3223 delayed_payment_basepoint: pubkey_4,
3224 htlc_basepoint: pubkey_5,
3225 first_per_commitment_point: pubkey_6,
3226 channel_flags: if random_bit { 1 << 5 } else { 0 },
3227 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3228 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3230 let encoded_value = open_channel.encode();
3231 let mut target_value = Vec::new();
3232 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3233 target_value.append(&mut <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202021234567890123456233403289122369832144668701144767633030896203198784335490624111800083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3235 target_value.append(&mut <Vec<u8>>::from_hex("20").unwrap());
3237 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3240 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3243 target_value.append(&mut <Vec<u8>>::from_hex("0100").unwrap());
3245 assert_eq!(encoded_value, target_value);
3249 fn encoding_open_channel() {
3250 do_encoding_open_channel(false, false, false);
3251 do_encoding_open_channel(false, false, true);
3252 do_encoding_open_channel(false, true, false);
3253 do_encoding_open_channel(false, true, true);
3254 do_encoding_open_channel(true, false, false);
3255 do_encoding_open_channel(true, false, true);
3256 do_encoding_open_channel(true, true, false);
3257 do_encoding_open_channel(true, true, true);
3260 fn do_encoding_open_channelv2(random_bit: bool, shutdown: bool, incl_chan_type: bool, require_confirmed_inputs: bool) {
3261 let secp_ctx = Secp256k1::new();
3262 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3263 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3264 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3265 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3266 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3267 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3268 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3269 let open_channelv2 = msgs::OpenChannelV2 {
3270 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3271 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3272 funding_feerate_sat_per_1000_weight: 821716,
3273 commitment_feerate_sat_per_1000_weight: 821716,
3274 funding_satoshis: 1311768467284833366,
3275 dust_limit_satoshis: 3608586615801332854,
3276 max_htlc_value_in_flight_msat: 8517154655701053848,
3277 htlc_minimum_msat: 2316138423780173,
3278 to_self_delay: 49340,
3279 max_accepted_htlcs: 49340,
3280 locktime: 305419896,
3281 funding_pubkey: pubkey_1,
3282 revocation_basepoint: pubkey_2,
3283 payment_basepoint: pubkey_3,
3284 delayed_payment_basepoint: pubkey_4,
3285 htlc_basepoint: pubkey_5,
3286 first_per_commitment_point: pubkey_6,
3287 second_per_commitment_point: pubkey_7,
3288 channel_flags: if random_bit { 1 << 5 } else { 0 },
3289 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3290 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3291 require_confirmed_inputs: if require_confirmed_inputs { Some(()) } else { None },
3293 let encoded_value = open_channelv2.encode();
3294 let mut target_value = Vec::new();
3295 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3296 target_value.append(&mut <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap());
3297 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap());
3298 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap());
3299 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap());
3300 target_value.append(&mut <Vec<u8>>::from_hex("3214466870114476").unwrap());
3301 target_value.append(&mut <Vec<u8>>::from_hex("7633030896203198").unwrap());
3302 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d").unwrap());
3303 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap());
3304 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap());
3305 target_value.append(&mut <Vec<u8>>::from_hex("12345678").unwrap());
3306 target_value.append(&mut <Vec<u8>>::from_hex("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap());
3307 target_value.append(&mut <Vec<u8>>::from_hex("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap());
3308 target_value.append(&mut <Vec<u8>>::from_hex("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap());
3309 target_value.append(&mut <Vec<u8>>::from_hex("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
3310 target_value.append(&mut <Vec<u8>>::from_hex("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap());
3311 target_value.append(&mut <Vec<u8>>::from_hex("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3312 target_value.append(&mut <Vec<u8>>::from_hex("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap());
3315 target_value.append(&mut <Vec<u8>>::from_hex("20").unwrap());
3317 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3320 target_value.append(&mut <Vec<u8>>::from_hex("001b").unwrap()); // Type 0 + Length 27
3321 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3324 target_value.append(&mut <Vec<u8>>::from_hex("0100").unwrap());
3326 if require_confirmed_inputs {
3327 target_value.append(&mut <Vec<u8>>::from_hex("0200").unwrap());
3329 assert_eq!(encoded_value, target_value);
3333 fn encoding_open_channelv2() {
3334 do_encoding_open_channelv2(false, false, false, false);
3335 do_encoding_open_channelv2(false, false, false, true);
3336 do_encoding_open_channelv2(false, false, true, false);
3337 do_encoding_open_channelv2(false, false, true, true);
3338 do_encoding_open_channelv2(false, true, false, false);
3339 do_encoding_open_channelv2(false, true, false, true);
3340 do_encoding_open_channelv2(false, true, true, false);
3341 do_encoding_open_channelv2(false, true, true, true);
3342 do_encoding_open_channelv2(true, false, false, false);
3343 do_encoding_open_channelv2(true, false, false, true);
3344 do_encoding_open_channelv2(true, false, true, false);
3345 do_encoding_open_channelv2(true, false, true, true);
3346 do_encoding_open_channelv2(true, true, false, false);
3347 do_encoding_open_channelv2(true, true, false, true);
3348 do_encoding_open_channelv2(true, true, true, false);
3349 do_encoding_open_channelv2(true, true, true, true);
3352 fn do_encoding_accept_channel(shutdown: bool) {
3353 let secp_ctx = Secp256k1::new();
3354 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3355 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3356 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3357 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3358 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3359 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3360 let accept_channel = msgs::AcceptChannel {
3361 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3362 dust_limit_satoshis: 1311768467284833366,
3363 max_htlc_value_in_flight_msat: 2536655962884945560,
3364 channel_reserve_satoshis: 3608586615801332854,
3365 htlc_minimum_msat: 2316138423780173,
3366 minimum_depth: 821716,
3367 to_self_delay: 49340,
3368 max_accepted_htlcs: 49340,
3369 funding_pubkey: pubkey_1,
3370 revocation_basepoint: pubkey_2,
3371 payment_point: pubkey_3,
3372 delayed_payment_basepoint: pubkey_4,
3373 htlc_basepoint: pubkey_5,
3374 first_per_commitment_point: pubkey_6,
3375 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3378 next_local_nonce: None,
3380 let encoded_value = accept_channel.encode();
3381 let mut target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020212345678901234562334032891223698321446687011447600083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap();
3383 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3385 assert_eq!(encoded_value, target_value);
3389 fn encoding_accept_channel() {
3390 do_encoding_accept_channel(false);
3391 do_encoding_accept_channel(true);
3394 fn do_encoding_accept_channelv2(shutdown: bool) {
3395 let secp_ctx = Secp256k1::new();
3396 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3397 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3398 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3399 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3400 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3401 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3402 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3403 let accept_channelv2 = msgs::AcceptChannelV2 {
3404 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3405 funding_satoshis: 1311768467284833366,
3406 dust_limit_satoshis: 1311768467284833366,
3407 max_htlc_value_in_flight_msat: 2536655962884945560,
3408 htlc_minimum_msat: 2316138423780173,
3409 minimum_depth: 821716,
3410 to_self_delay: 49340,
3411 max_accepted_htlcs: 49340,
3412 funding_pubkey: pubkey_1,
3413 revocation_basepoint: pubkey_2,
3414 payment_basepoint: pubkey_3,
3415 delayed_payment_basepoint: pubkey_4,
3416 htlc_basepoint: pubkey_5,
3417 first_per_commitment_point: pubkey_6,
3418 second_per_commitment_point: pubkey_7,
3419 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3421 require_confirmed_inputs: None,
3423 let encoded_value = accept_channelv2.encode();
3424 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // temporary_channel_id
3425 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap()); // funding_satoshis
3426 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap()); // dust_limit_satoshis
3427 target_value.append(&mut <Vec<u8>>::from_hex("2334032891223698").unwrap()); // max_htlc_value_in_flight_msat
3428 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d").unwrap()); // htlc_minimum_msat
3429 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap()); // minimum_depth
3430 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap()); // to_self_delay
3431 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap()); // max_accepted_htlcs
3432 target_value.append(&mut <Vec<u8>>::from_hex("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap()); // funding_pubkey
3433 target_value.append(&mut <Vec<u8>>::from_hex("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap()); // revocation_basepoint
3434 target_value.append(&mut <Vec<u8>>::from_hex("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap()); // payment_basepoint
3435 target_value.append(&mut <Vec<u8>>::from_hex("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap()); // delayed_payment_basepoint
3436 target_value.append(&mut <Vec<u8>>::from_hex("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap()); // htlc_basepoint
3437 target_value.append(&mut <Vec<u8>>::from_hex("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap()); // first_per_commitment_point
3438 target_value.append(&mut <Vec<u8>>::from_hex("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap()); // second_per_commitment_point
3440 target_value.append(&mut <Vec<u8>>::from_hex("001b").unwrap()); // Type 0 + Length 27
3441 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3443 assert_eq!(encoded_value, target_value);
3447 fn encoding_accept_channelv2() {
3448 do_encoding_accept_channelv2(false);
3449 do_encoding_accept_channelv2(true);
3453 fn encoding_funding_created() {
3454 let secp_ctx = Secp256k1::new();
3455 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3456 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3457 let funding_created = msgs::FundingCreated {
3458 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3459 funding_txid: Txid::from_str("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3460 funding_output_index: 255,
3463 partial_signature_with_nonce: None,
3465 next_local_nonce: None,
3467 let encoded_value = funding_created.encode();
3468 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202026e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c200ffd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3469 assert_eq!(encoded_value, target_value);
3473 fn encoding_funding_signed() {
3474 let secp_ctx = Secp256k1::new();
3475 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3476 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3477 let funding_signed = msgs::FundingSigned {
3478 channel_id: ChannelId::from_bytes([2; 32]),
3481 partial_signature_with_nonce: None,
3483 let encoded_value = funding_signed.encode();
3484 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3485 assert_eq!(encoded_value, target_value);
3489 fn encoding_channel_ready() {
3490 let secp_ctx = Secp256k1::new();
3491 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3492 let channel_ready = msgs::ChannelReady {
3493 channel_id: ChannelId::from_bytes([2; 32]),
3494 next_per_commitment_point: pubkey_1,
3495 short_channel_id_alias: None,
3497 let encoded_value = channel_ready.encode();
3498 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3499 assert_eq!(encoded_value, target_value);
3503 fn encoding_splice() {
3504 let secp_ctx = Secp256k1::new();
3505 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3506 let splice = msgs::Splice {
3507 chain_hash: ChainHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
3508 channel_id: ChannelId::from_bytes([2; 32]),
3509 relative_satoshis: 123456,
3510 funding_feerate_perkw: 2000,
3512 funding_pubkey: pubkey_1,
3514 let encoded_value = splice.encode();
3515 assert_eq!(encoded_value.as_hex().to_string(), "02020202020202020202020202020202020202020202020202020202020202026fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000000000000001e240000007d000000000031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f");
3519 fn encoding_stfu() {
3520 let stfu = msgs::Stfu {
3521 channel_id: ChannelId::from_bytes([2; 32]),
3524 let encoded_value = stfu.encode();
3525 assert_eq!(encoded_value.as_hex().to_string(), "020202020202020202020202020202020202020202020202020202020202020201");
3529 fn encoding_splice_ack() {
3530 let secp_ctx = Secp256k1::new();
3531 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3532 let splice = msgs::SpliceAck {
3533 chain_hash: ChainHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
3534 channel_id: ChannelId::from_bytes([2; 32]),
3535 relative_satoshis: 123456,
3536 funding_pubkey: pubkey_1,
3538 let encoded_value = splice.encode();
3539 assert_eq!(encoded_value.as_hex().to_string(), "02020202020202020202020202020202020202020202020202020202020202026fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000000000000001e240031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f");
3543 fn encoding_splice_locked() {
3544 let splice = msgs::SpliceLocked {
3545 channel_id: ChannelId::from_bytes([2; 32]),
3547 let encoded_value = splice.encode();
3548 assert_eq!(encoded_value.as_hex().to_string(), "0202020202020202020202020202020202020202020202020202020202020202");
3552 fn encoding_tx_add_input() {
3553 let tx_add_input = msgs::TxAddInput {
3554 channel_id: ChannelId::from_bytes([2; 32]),
3555 serial_id: 4886718345,
3556 prevtx: TransactionU16LenLimited::new(Transaction {
3558 lock_time: LockTime::ZERO,
3560 previous_output: OutPoint { txid: Txid::from_str("305bab643ee297b8b6b76b320792c8223d55082122cb606bf89382146ced9c77").unwrap(), index: 2 }.into_bitcoin_outpoint(),
3561 script_sig: ScriptBuf::new(),
3562 sequence: Sequence(0xfffffffd),
3563 witness: Witness::from_slice(&vec![
3564 <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3565 <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3570 script_pubkey: Address::from_str("bc1qzlffunw52jav8vwdu5x3jfk6sr8u22rmq3xzw2").unwrap().payload.script_pubkey(),
3574 script_pubkey: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().payload.script_pubkey(),
3578 prevtx_out: 305419896,
3579 sequence: 305419896,
3581 let encoded_value = tx_add_input.encode();
3582 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000000012345678900de02000000000101779ced6c148293f86b60cb222108553d22c89207326bb7b6b897e23e64ab5b300200000000fdffffff0236dbc1000000000016001417d29e4dd454bac3b1cde50d1926da80cfc5287b9cbd03000000000016001436ec78d514df462da95e6a00c24daa8915362d420247304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701210301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944000000001234567812345678").unwrap();
3583 assert_eq!(encoded_value, target_value);
3587 fn encoding_tx_add_output() {
3588 let tx_add_output = msgs::TxAddOutput {
3589 channel_id: ChannelId::from_bytes([2; 32]),
3590 serial_id: 4886718345,
3592 script: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().payload.script_pubkey(),
3594 let encoded_value = tx_add_output.encode();
3595 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000000012345678900000001234567890016001436ec78d514df462da95e6a00c24daa8915362d42").unwrap();
3596 assert_eq!(encoded_value, target_value);
3600 fn encoding_tx_remove_input() {
3601 let tx_remove_input = msgs::TxRemoveInput {
3602 channel_id: ChannelId::from_bytes([2; 32]),
3603 serial_id: 4886718345,
3605 let encoded_value = tx_remove_input.encode();
3606 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3607 assert_eq!(encoded_value, target_value);
3611 fn encoding_tx_remove_output() {
3612 let tx_remove_output = msgs::TxRemoveOutput {
3613 channel_id: ChannelId::from_bytes([2; 32]),
3614 serial_id: 4886718345,
3616 let encoded_value = tx_remove_output.encode();
3617 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3618 assert_eq!(encoded_value, target_value);
3622 fn encoding_tx_complete() {
3623 let tx_complete = msgs::TxComplete {
3624 channel_id: ChannelId::from_bytes([2; 32]),
3626 let encoded_value = tx_complete.encode();
3627 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3628 assert_eq!(encoded_value, target_value);
3632 fn encoding_tx_signatures() {
3633 let tx_signatures = msgs::TxSignatures {
3634 channel_id: ChannelId::from_bytes([2; 32]),
3635 tx_hash: Txid::from_str("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3637 Witness::from_slice(&vec![
3638 <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3639 <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3640 Witness::from_slice(&vec![
3641 <Vec<u8>>::from_hex("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap(),
3642 <Vec<u8>>::from_hex("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap()]),
3645 let encoded_value = tx_signatures.encode();
3646 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3647 target_value.append(&mut <Vec<u8>>::from_hex("6e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c2").unwrap()); // tx_hash (sha256) (big endian byte order)
3648 target_value.append(&mut <Vec<u8>>::from_hex("0002").unwrap()); // num_witnesses (u16)
3650 target_value.append(&mut <Vec<u8>>::from_hex("006b").unwrap()); // len of witness_data
3651 target_value.append(&mut <Vec<u8>>::from_hex("02").unwrap()); // num_witness_elements (VarInt)
3652 target_value.append(&mut <Vec<u8>>::from_hex("47").unwrap()); // len of witness element data (VarInt)
3653 target_value.append(&mut <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap());
3654 target_value.append(&mut <Vec<u8>>::from_hex("21").unwrap()); // len of witness element data (VarInt)
3655 target_value.append(&mut <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap());
3657 target_value.append(&mut <Vec<u8>>::from_hex("006c").unwrap()); // len of witness_data
3658 target_value.append(&mut <Vec<u8>>::from_hex("02").unwrap()); // num_witness_elements (VarInt)
3659 target_value.append(&mut <Vec<u8>>::from_hex("48").unwrap()); // len of witness element data (VarInt)
3660 target_value.append(&mut <Vec<u8>>::from_hex("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap());
3661 target_value.append(&mut <Vec<u8>>::from_hex("21").unwrap()); // len of witness element data (VarInt)
3662 target_value.append(&mut <Vec<u8>>::from_hex("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap());
3663 assert_eq!(encoded_value, target_value);
3666 fn do_encoding_tx_init_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3667 let tx_init_rbf = msgs::TxInitRbf {
3668 channel_id: ChannelId::from_bytes([2; 32]),
3669 locktime: 305419896,
3670 feerate_sat_per_1000_weight: 20190119,
3671 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3673 let encoded_value = tx_init_rbf.encode();
3674 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3675 target_value.append(&mut <Vec<u8>>::from_hex("12345678").unwrap()); // locktime
3676 target_value.append(&mut <Vec<u8>>::from_hex("013413a7").unwrap()); // feerate_sat_per_1000_weight
3677 if let Some((_, target)) = funding_value_with_hex_target {
3678 target_value.push(0x00); // Type
3679 target_value.push(target.len() as u8 / 2); // Length
3680 target_value.append(&mut <Vec<u8>>::from_hex(target).unwrap()); // Value (i64)
3682 assert_eq!(encoded_value, target_value);
3686 fn encoding_tx_init_rbf() {
3687 do_encoding_tx_init_rbf(Some((1311768467284833366, "1234567890123456")));
3688 do_encoding_tx_init_rbf(Some((13117684672, "000000030DDFFBC0")));
3689 do_encoding_tx_init_rbf(None);
3692 fn do_encoding_tx_ack_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3693 let tx_ack_rbf = msgs::TxAckRbf {
3694 channel_id: ChannelId::from_bytes([2; 32]),
3695 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3697 let encoded_value = tx_ack_rbf.encode();
3698 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3699 if let Some((_, target)) = funding_value_with_hex_target {
3700 target_value.push(0x00); // Type
3701 target_value.push(target.len() as u8 / 2); // Length
3702 target_value.append(&mut <Vec<u8>>::from_hex(target).unwrap()); // Value (i64)
3704 assert_eq!(encoded_value, target_value);
3708 fn encoding_tx_ack_rbf() {
3709 do_encoding_tx_ack_rbf(Some((1311768467284833366, "1234567890123456")));
3710 do_encoding_tx_ack_rbf(Some((13117684672, "000000030DDFFBC0")));
3711 do_encoding_tx_ack_rbf(None);
3715 fn encoding_tx_abort() {
3716 let tx_abort = msgs::TxAbort {
3717 channel_id: ChannelId::from_bytes([2; 32]),
3718 data: <Vec<u8>>::from_hex("54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap(),
3720 let encoded_value = tx_abort.encode();
3721 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202002C54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap();
3722 assert_eq!(encoded_value, target_value);
3725 fn do_encoding_shutdown(script_type: u8) {
3726 let secp_ctx = Secp256k1::new();
3727 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3728 let script = Builder::new().push_opcode(opcodes::OP_TRUE).into_script();
3729 let shutdown = msgs::Shutdown {
3730 channel_id: ChannelId::from_bytes([2; 32]),
3732 if script_type == 1 { Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey() }
3733 else if script_type == 2 { Address::p2sh(&script, Network::Testnet).unwrap().script_pubkey() }
3734 else if script_type == 3 { Address::p2wpkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).unwrap().script_pubkey() }
3735 else { Address::p2wsh(&script, Network::Testnet).script_pubkey() },
3737 let encoded_value = shutdown.encode();
3738 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3739 if script_type == 1 {
3740 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3741 } else if script_type == 2 {
3742 target_value.append(&mut <Vec<u8>>::from_hex("0017a914da1745e9b549bd0bfa1a569971c77eba30cd5a4b87").unwrap());
3743 } else if script_type == 3 {
3744 target_value.append(&mut <Vec<u8>>::from_hex("0016001479b000887626b294a914501a4cd226b58b235983").unwrap());
3745 } else if script_type == 4 {
3746 target_value.append(&mut <Vec<u8>>::from_hex("002200204ae81572f06e1b88fd5ced7a1a000945432e83e1551e6f721ee9c00b8cc33260").unwrap());
3748 assert_eq!(encoded_value, target_value);
3752 fn encoding_shutdown() {
3753 do_encoding_shutdown(1);
3754 do_encoding_shutdown(2);
3755 do_encoding_shutdown(3);
3756 do_encoding_shutdown(4);
3760 fn encoding_closing_signed() {
3761 let secp_ctx = Secp256k1::new();
3762 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3763 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3764 let closing_signed = msgs::ClosingSigned {
3765 channel_id: ChannelId::from_bytes([2; 32]),
3766 fee_satoshis: 2316138423780173,
3770 let encoded_value = closing_signed.encode();
3771 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3772 assert_eq!(encoded_value, target_value);
3773 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value)).unwrap(), closing_signed);
3775 let closing_signed_with_range = msgs::ClosingSigned {
3776 channel_id: ChannelId::from_bytes([2; 32]),
3777 fee_satoshis: 2316138423780173,
3779 fee_range: Some(msgs::ClosingSignedFeeRange {
3780 min_fee_satoshis: 0xdeadbeef,
3781 max_fee_satoshis: 0x1badcafe01234567,
3784 let encoded_value_with_range = closing_signed_with_range.encode();
3785 let target_value_with_range = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a011000000000deadbeef1badcafe01234567").unwrap();
3786 assert_eq!(encoded_value_with_range, target_value_with_range);
3787 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value_with_range)).unwrap(),
3788 closing_signed_with_range);
3792 fn encoding_update_add_htlc() {
3793 let secp_ctx = Secp256k1::new();
3794 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3795 let onion_routing_packet = msgs::OnionPacket {
3797 public_key: Ok(pubkey_1),
3798 hop_data: [1; 20*65],
3801 let update_add_htlc = msgs::UpdateAddHTLC {
3802 channel_id: ChannelId::from_bytes([2; 32]),
3803 htlc_id: 2316138423780173,
3804 amount_msat: 3608586615801332854,
3805 payment_hash: PaymentHash([1; 32]),
3806 cltv_expiry: 821716,
3807 onion_routing_packet,
3808 skimmed_fee_msat: None,
3809 blinding_point: None,
3811 let encoded_value = update_add_htlc.encode();
3812 let target_value = <Vec<u8>>::from_hex("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").unwrap();
3813 assert_eq!(encoded_value, target_value);
3817 fn encoding_update_fulfill_htlc() {
3818 let update_fulfill_htlc = msgs::UpdateFulfillHTLC {
3819 channel_id: ChannelId::from_bytes([2; 32]),
3820 htlc_id: 2316138423780173,
3821 payment_preimage: PaymentPreimage([1; 32]),
3823 let encoded_value = update_fulfill_htlc.encode();
3824 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d0101010101010101010101010101010101010101010101010101010101010101").unwrap();
3825 assert_eq!(encoded_value, target_value);
3829 fn encoding_update_fail_htlc() {
3830 let reason = OnionErrorPacket {
3831 data: [1; 32].to_vec(),
3833 let update_fail_htlc = msgs::UpdateFailHTLC {
3834 channel_id: ChannelId::from_bytes([2; 32]),
3835 htlc_id: 2316138423780173,
3838 let encoded_value = update_fail_htlc.encode();
3839 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d00200101010101010101010101010101010101010101010101010101010101010101").unwrap();
3840 assert_eq!(encoded_value, target_value);
3844 fn encoding_update_fail_malformed_htlc() {
3845 let update_fail_malformed_htlc = msgs::UpdateFailMalformedHTLC {
3846 channel_id: ChannelId::from_bytes([2; 32]),
3847 htlc_id: 2316138423780173,
3848 sha256_of_onion: [1; 32],
3851 let encoded_value = update_fail_malformed_htlc.encode();
3852 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d010101010101010101010101010101010101010101010101010101010101010100ff").unwrap();
3853 assert_eq!(encoded_value, target_value);
3856 fn do_encoding_commitment_signed(htlcs: bool) {
3857 let secp_ctx = Secp256k1::new();
3858 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3859 let (privkey_2, _) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3860 let (privkey_3, _) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3861 let (privkey_4, _) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3862 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3863 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
3864 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
3865 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
3866 let commitment_signed = msgs::CommitmentSigned {
3867 channel_id: ChannelId::from_bytes([2; 32]),
3869 htlc_signatures: if htlcs { vec![sig_2, sig_3, sig_4] } else { Vec::new() },
3871 partial_signature_with_nonce: None,
3873 let encoded_value = commitment_signed.encode();
3874 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3876 target_value.append(&mut <Vec<u8>>::from_hex("00031735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
3878 target_value.append(&mut <Vec<u8>>::from_hex("0000").unwrap());
3880 assert_eq!(encoded_value, target_value);
3884 fn encoding_commitment_signed() {
3885 do_encoding_commitment_signed(true);
3886 do_encoding_commitment_signed(false);
3890 fn encoding_revoke_and_ack() {
3891 let secp_ctx = Secp256k1::new();
3892 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3893 let raa = msgs::RevokeAndACK {
3894 channel_id: ChannelId::from_bytes([2; 32]),
3895 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],
3896 next_per_commitment_point: pubkey_1,
3898 next_local_nonce: None,
3900 let encoded_value = raa.encode();
3901 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020101010101010101010101010101010101010101010101010101010101010101031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3902 assert_eq!(encoded_value, target_value);
3906 fn encoding_update_fee() {
3907 let update_fee = msgs::UpdateFee {
3908 channel_id: ChannelId::from_bytes([2; 32]),
3909 feerate_per_kw: 20190119,
3911 let encoded_value = update_fee.encode();
3912 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202013413a7").unwrap();
3913 assert_eq!(encoded_value, target_value);
3917 fn encoding_init() {
3918 let mainnet_hash = ChainHash::using_genesis_block(Network::Bitcoin);
3919 assert_eq!(msgs::Init {
3920 features: InitFeatures::from_le_bytes(vec![0xFF, 0xFF, 0xFF]),
3921 networks: Some(vec![mainnet_hash]),
3922 remote_network_address: None,
3923 }.encode(), <Vec<u8>>::from_hex("00023fff0003ffffff01206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3924 assert_eq!(msgs::Init {
3925 features: InitFeatures::from_le_bytes(vec![0xFF]),
3927 remote_network_address: None,
3928 }.encode(), <Vec<u8>>::from_hex("0001ff0001ff").unwrap());
3929 assert_eq!(msgs::Init {
3930 features: InitFeatures::from_le_bytes(vec![]),
3931 networks: Some(vec![mainnet_hash]),
3932 remote_network_address: None,
3933 }.encode(), <Vec<u8>>::from_hex("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3934 assert_eq!(msgs::Init {
3935 features: InitFeatures::from_le_bytes(vec![]),
3936 networks: Some(vec![ChainHash::from(&[1; 32]), ChainHash::from(&[2; 32])]),
3937 remote_network_address: None,
3938 }.encode(), <Vec<u8>>::from_hex("00000000014001010101010101010101010101010101010101010101010101010101010101010202020202020202020202020202020202020202020202020202020202020202").unwrap());
3939 let init_msg = msgs::Init { features: InitFeatures::from_le_bytes(vec![]),
3940 networks: Some(vec![mainnet_hash]),
3941 remote_network_address: Some(SocketAddress::TcpIpV4 {
3942 addr: [127, 0, 0, 1],
3946 let encoded_value = init_msg.encode();
3947 let target_value = <Vec<u8>>::from_hex("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d61900000000000307017f00000103e8").unwrap();
3948 assert_eq!(encoded_value, target_value);
3949 assert_eq!(msgs::Init::read(&mut Cursor::new(&target_value)).unwrap(), init_msg);
3953 fn encoding_error() {
3954 let error = msgs::ErrorMessage {
3955 channel_id: ChannelId::from_bytes([2; 32]),
3956 data: String::from("rust-lightning"),
3958 let encoded_value = error.encode();
3959 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3960 assert_eq!(encoded_value, target_value);
3964 fn encoding_warning() {
3965 let error = msgs::WarningMessage {
3966 channel_id: ChannelId::from_bytes([2; 32]),
3967 data: String::from("rust-lightning"),
3969 let encoded_value = error.encode();
3970 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3971 assert_eq!(encoded_value, target_value);
3975 fn encoding_ping() {
3976 let ping = msgs::Ping {
3980 let encoded_value = ping.encode();
3981 let target_value = <Vec<u8>>::from_hex("0040004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3982 assert_eq!(encoded_value, target_value);
3986 fn encoding_pong() {
3987 let pong = msgs::Pong {
3990 let encoded_value = pong.encode();
3991 let target_value = <Vec<u8>>::from_hex("004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3992 assert_eq!(encoded_value, target_value);
3996 fn encoding_nonfinal_onion_hop_data() {
3997 let outbound_msg = msgs::OutboundOnionPayload::Forward {
3998 short_channel_id: 0xdeadbeef1bad1dea,
3999 amt_to_forward: 0x0badf00d01020304,
4000 outgoing_cltv_value: 0xffffffff,
4002 let encoded_value = outbound_msg.encode();
4003 let target_value = <Vec<u8>>::from_hex("1a02080badf00d010203040404ffffffff0608deadbeef1bad1dea").unwrap();
4004 assert_eq!(encoded_value, target_value);
4006 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4007 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4008 if let msgs::InboundOnionPayload::Forward {
4009 short_channel_id, amt_to_forward, outgoing_cltv_value
4011 assert_eq!(short_channel_id, 0xdeadbeef1bad1dea);
4012 assert_eq!(amt_to_forward, 0x0badf00d01020304);
4013 assert_eq!(outgoing_cltv_value, 0xffffffff);
4014 } else { panic!(); }
4018 fn encoding_final_onion_hop_data() {
4019 let outbound_msg = msgs::OutboundOnionPayload::Receive {
4021 payment_metadata: None,
4022 keysend_preimage: None,
4023 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4024 cltv_expiry_height: 0xffffffff,
4025 custom_tlvs: vec![],
4027 let encoded_value = outbound_msg.encode();
4028 let target_value = <Vec<u8>>::from_hex("1002080badf00d010203040404ffffffff").unwrap();
4029 assert_eq!(encoded_value, target_value);
4031 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4032 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4033 if let msgs::InboundOnionPayload::Receive {
4034 payment_data: None, sender_intended_htlc_amt_msat, cltv_expiry_height, ..
4036 assert_eq!(sender_intended_htlc_amt_msat, 0x0badf00d01020304);
4037 assert_eq!(cltv_expiry_height, 0xffffffff);
4038 } else { panic!(); }
4042 fn encoding_final_onion_hop_data_with_secret() {
4043 let expected_payment_secret = PaymentSecret([0x42u8; 32]);
4044 let outbound_msg = msgs::OutboundOnionPayload::Receive {
4045 payment_data: Some(FinalOnionHopData {
4046 payment_secret: expected_payment_secret,
4047 total_msat: 0x1badca1f
4049 payment_metadata: None,
4050 keysend_preimage: None,
4051 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4052 cltv_expiry_height: 0xffffffff,
4053 custom_tlvs: vec![],
4055 let encoded_value = outbound_msg.encode();
4056 let target_value = <Vec<u8>>::from_hex("3602080badf00d010203040404ffffffff082442424242424242424242424242424242424242424242424242424242424242421badca1f").unwrap();
4057 assert_eq!(encoded_value, target_value);
4059 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4060 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4061 if let msgs::InboundOnionPayload::Receive {
4062 payment_data: Some(FinalOnionHopData {
4064 total_msat: 0x1badca1f
4066 sender_intended_htlc_amt_msat, cltv_expiry_height,
4067 payment_metadata: None,
4068 keysend_preimage: None,
4071 assert_eq!(payment_secret, expected_payment_secret);
4072 assert_eq!(sender_intended_htlc_amt_msat, 0x0badf00d01020304);
4073 assert_eq!(cltv_expiry_height, 0xffffffff);
4074 assert_eq!(custom_tlvs, vec![]);
4075 } else { panic!(); }
4079 fn encoding_final_onion_hop_data_with_bad_custom_tlvs() {
4080 // If custom TLVs have type number within the range reserved for protocol, treat them as if
4082 let bad_type_range_tlvs = vec![
4083 ((1 << 16) - 4, vec![42]),
4084 ((1 << 16) - 2, vec![42; 32]),
4086 let mut msg = msgs::OutboundOnionPayload::Receive {
4088 payment_metadata: None,
4089 keysend_preimage: None,
4090 custom_tlvs: bad_type_range_tlvs,
4091 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4092 cltv_expiry_height: 0xffffffff,
4094 let encoded_value = msg.encode();
4095 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4096 assert!(msgs::InboundOnionPayload::read(&mut Cursor::new(&encoded_value[..]), (None, &&node_signer)).is_err());
4097 let good_type_range_tlvs = vec![
4098 ((1 << 16) - 3, vec![42]),
4099 ((1 << 16) - 1, vec![42; 32]),
4101 if let msgs::OutboundOnionPayload::Receive { ref mut custom_tlvs, .. } = msg {
4102 *custom_tlvs = good_type_range_tlvs.clone();
4104 let encoded_value = msg.encode();
4105 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&encoded_value[..]), (None, &&node_signer)).unwrap();
4107 msgs::InboundOnionPayload::Receive { custom_tlvs, .. } => assert!(custom_tlvs.is_empty()),
4113 fn encoding_final_onion_hop_data_with_custom_tlvs() {
4114 let expected_custom_tlvs = vec![
4115 (5482373483, vec![0x12, 0x34]),
4116 (5482373487, vec![0x42u8; 8]),
4118 let msg = msgs::OutboundOnionPayload::Receive {
4120 payment_metadata: None,
4121 keysend_preimage: None,
4122 custom_tlvs: expected_custom_tlvs.clone(),
4123 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4124 cltv_expiry_height: 0xffffffff,
4126 let encoded_value = msg.encode();
4127 let target_value = <Vec<u8>>::from_hex("2e02080badf00d010203040404ffffffffff0000000146c6616b021234ff0000000146c6616f084242424242424242").unwrap();
4128 assert_eq!(encoded_value, target_value);
4129 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4130 let inbound_msg: msgs::InboundOnionPayload = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4131 if let msgs::InboundOnionPayload::Receive {
4133 payment_metadata: None,
4134 keysend_preimage: None,
4136 sender_intended_htlc_amt_msat,
4137 cltv_expiry_height: outgoing_cltv_value,
4140 assert_eq!(custom_tlvs, expected_custom_tlvs);
4141 assert_eq!(sender_intended_htlc_amt_msat, 0x0badf00d01020304);
4142 assert_eq!(outgoing_cltv_value, 0xffffffff);
4143 } else { panic!(); }
4147 fn query_channel_range_end_blocknum() {
4148 let tests: Vec<(u32, u32, u32)> = vec![
4149 (10000, 1500, 11500),
4150 (0, 0xffffffff, 0xffffffff),
4151 (1, 0xffffffff, 0xffffffff),
4154 for (first_blocknum, number_of_blocks, expected) in tests.into_iter() {
4155 let sut = msgs::QueryChannelRange {
4156 chain_hash: ChainHash::using_genesis_block(Network::Regtest),
4160 assert_eq!(sut.end_blocknum(), expected);
4165 fn encoding_query_channel_range() {
4166 let mut query_channel_range = msgs::QueryChannelRange {
4167 chain_hash: ChainHash::using_genesis_block(Network::Regtest),
4168 first_blocknum: 100000,
4169 number_of_blocks: 1500,
4171 let encoded_value = query_channel_range.encode();
4172 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000186a0000005dc").unwrap();
4173 assert_eq!(encoded_value, target_value);
4175 query_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4176 assert_eq!(query_channel_range.first_blocknum, 100000);
4177 assert_eq!(query_channel_range.number_of_blocks, 1500);
4181 fn encoding_reply_channel_range() {
4182 do_encoding_reply_channel_range(0);
4183 do_encoding_reply_channel_range(1);
4186 fn do_encoding_reply_channel_range(encoding_type: u8) {
4187 let mut target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000b8a06000005dc01").unwrap();
4188 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4189 let mut reply_channel_range = msgs::ReplyChannelRange {
4190 chain_hash: expected_chain_hash,
4191 first_blocknum: 756230,
4192 number_of_blocks: 1500,
4193 sync_complete: true,
4194 short_channel_ids: vec![0x000000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
4197 if encoding_type == 0 {
4198 target_value.append(&mut <Vec<u8>>::from_hex("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
4199 let encoded_value = reply_channel_range.encode();
4200 assert_eq!(encoded_value, target_value);
4202 reply_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4203 assert_eq!(reply_channel_range.chain_hash, expected_chain_hash);
4204 assert_eq!(reply_channel_range.first_blocknum, 756230);
4205 assert_eq!(reply_channel_range.number_of_blocks, 1500);
4206 assert_eq!(reply_channel_range.sync_complete, true);
4207 assert_eq!(reply_channel_range.short_channel_ids[0], 0x000000000000008e);
4208 assert_eq!(reply_channel_range.short_channel_ids[1], 0x0000000000003c69);
4209 assert_eq!(reply_channel_range.short_channel_ids[2], 0x000000000045a6c4);
4211 target_value.append(&mut <Vec<u8>>::from_hex("001601789c636000833e08659309a65878be010010a9023a").unwrap());
4212 let result: Result<msgs::ReplyChannelRange, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
4213 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
4218 fn encoding_query_short_channel_ids() {
4219 do_encoding_query_short_channel_ids(0);
4220 do_encoding_query_short_channel_ids(1);
4223 fn do_encoding_query_short_channel_ids(encoding_type: u8) {
4224 let mut target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
4225 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4226 let mut query_short_channel_ids = msgs::QueryShortChannelIds {
4227 chain_hash: expected_chain_hash,
4228 short_channel_ids: vec![0x0000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
4231 if encoding_type == 0 {
4232 target_value.append(&mut <Vec<u8>>::from_hex("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
4233 let encoded_value = query_short_channel_ids.encode();
4234 assert_eq!(encoded_value, target_value);
4236 query_short_channel_ids = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4237 assert_eq!(query_short_channel_ids.chain_hash, expected_chain_hash);
4238 assert_eq!(query_short_channel_ids.short_channel_ids[0], 0x000000000000008e);
4239 assert_eq!(query_short_channel_ids.short_channel_ids[1], 0x0000000000003c69);
4240 assert_eq!(query_short_channel_ids.short_channel_ids[2], 0x000000000045a6c4);
4242 target_value.append(&mut <Vec<u8>>::from_hex("001601789c636000833e08659309a65878be010010a9023a").unwrap());
4243 let result: Result<msgs::QueryShortChannelIds, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
4244 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
4249 fn encoding_reply_short_channel_ids_end() {
4250 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4251 let mut reply_short_channel_ids_end = msgs::ReplyShortChannelIdsEnd {
4252 chain_hash: expected_chain_hash,
4253 full_information: true,
4255 let encoded_value = reply_short_channel_ids_end.encode();
4256 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f01").unwrap();
4257 assert_eq!(encoded_value, target_value);
4259 reply_short_channel_ids_end = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4260 assert_eq!(reply_short_channel_ids_end.chain_hash, expected_chain_hash);
4261 assert_eq!(reply_short_channel_ids_end.full_information, true);
4265 fn encoding_gossip_timestamp_filter(){
4266 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4267 let mut gossip_timestamp_filter = msgs::GossipTimestampFilter {
4268 chain_hash: expected_chain_hash,
4269 first_timestamp: 1590000000,
4270 timestamp_range: 0xffff_ffff,
4272 let encoded_value = gossip_timestamp_filter.encode();
4273 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f5ec57980ffffffff").unwrap();
4274 assert_eq!(encoded_value, target_value);
4276 gossip_timestamp_filter = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4277 assert_eq!(gossip_timestamp_filter.chain_hash, expected_chain_hash);
4278 assert_eq!(gossip_timestamp_filter.first_timestamp, 1590000000);
4279 assert_eq!(gossip_timestamp_filter.timestamp_range, 0xffff_ffff);
4283 fn decode_onion_hop_data_len_as_bigsize() {
4284 // Tests that we can decode an onion payload that is >253 bytes.
4285 // Previously, receiving a payload of this size could've caused us to fail to decode a valid
4286 // payload, because we were decoding the length (a BigSize, big-endian) as a VarInt
4289 // Encode a test onion payload with a big custom TLV such that it's >253 bytes, forcing the
4290 // payload length to be encoded over multiple bytes rather than a single u8.
4291 let big_payload = encode_big_payload().unwrap();
4292 let mut rd = Cursor::new(&big_payload[..]);
4294 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4295 <msgs::InboundOnionPayload as ReadableArgs<(Option<PublicKey>, &&test_utils::TestKeysInterface)>>
4296 ::read(&mut rd, (None, &&node_signer)).unwrap();
4298 // see above test, needs to be a separate method for use of the serialization macros.
4299 fn encode_big_payload() -> Result<Vec<u8>, io::Error> {
4300 use crate::util::ser::HighZeroBytesDroppedBigSize;
4301 let payload = msgs::OutboundOnionPayload::Forward {
4302 short_channel_id: 0xdeadbeef1bad1dea,
4303 amt_to_forward: 1000,
4304 outgoing_cltv_value: 0xffffffff,
4306 let mut encoded_payload = Vec::new();
4307 let test_bytes = vec![42u8; 1000];
4308 if let msgs::OutboundOnionPayload::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } = payload {
4309 _encode_varint_length_prefixed_tlv!(&mut encoded_payload, {
4310 (1, test_bytes, required_vec),
4311 (2, HighZeroBytesDroppedBigSize(amt_to_forward), required),
4312 (4, HighZeroBytesDroppedBigSize(outgoing_cltv_value), required),
4313 (6, short_channel_id, required)
4320 #[cfg(feature = "std")]
4321 fn test_socket_address_from_str() {
4322 let tcpip_v4 = SocketAddress::TcpIpV4 {
4323 addr: Ipv4Addr::new(127, 0, 0, 1).octets(),
4326 assert_eq!(tcpip_v4, SocketAddress::from_str("127.0.0.1:1234").unwrap());
4327 assert_eq!(tcpip_v4, SocketAddress::from_str(&tcpip_v4.to_string()).unwrap());
4329 let tcpip_v6 = SocketAddress::TcpIpV6 {
4330 addr: Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1).octets(),
4333 assert_eq!(tcpip_v6, SocketAddress::from_str("[0:0:0:0:0:0:0:1]:1234").unwrap());
4334 assert_eq!(tcpip_v6, SocketAddress::from_str(&tcpip_v6.to_string()).unwrap());
4336 let hostname = SocketAddress::Hostname {
4337 hostname: Hostname::try_from("lightning-node.mydomain.com".to_string()).unwrap(),
4340 assert_eq!(hostname, SocketAddress::from_str("lightning-node.mydomain.com:1234").unwrap());
4341 assert_eq!(hostname, SocketAddress::from_str(&hostname.to_string()).unwrap());
4343 let onion_v2 = SocketAddress::OnionV2 ([40, 4, 64, 185, 202, 19, 162, 75, 90, 200, 38, 7],);
4344 assert_eq!("OnionV2([40, 4, 64, 185, 202, 19, 162, 75, 90, 200, 38, 7])", &onion_v2.to_string());
4345 assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("FACEBOOKCOREWWWI.onion:9735"));
4347 let onion_v3 = SocketAddress::OnionV3 {
4348 ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102, 182, 107, 4, 105, 247, 246, 85,
4349 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31, 33, 71, 3],
4354 assert_eq!(onion_v3, SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion:1234").unwrap());
4355 assert_eq!(onion_v3, SocketAddress::from_str(&onion_v3.to_string()).unwrap());
4357 assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6.onion:1234"));
4358 assert_eq!(Err(SocketAddressParseError::InvalidInput), SocketAddress::from_str("127.0.0.1@1234"));
4359 assert_eq!(Err(SocketAddressParseError::InvalidInput), "".parse::<SocketAddress>());
4360 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:9735:94").is_err());
4361 assert!(SocketAddress::from_str("wrong$%#.com:1234").is_err());
4362 assert_eq!(Err(SocketAddressParseError::InvalidPort), SocketAddress::from_str("example.com:wrong"));
4363 assert!("localhost".parse::<SocketAddress>().is_err());
4364 assert!("localhost:invalid-port".parse::<SocketAddress>().is_err());
4365 assert!( "invalid-onion-v3-hostname.onion:8080".parse::<SocketAddress>().is_err());
4366 assert!("b32.example.onion:invalid-port".parse::<SocketAddress>().is_err());
4367 assert!("invalid-address".parse::<SocketAddress>().is_err());
4368 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:1234").is_err());
4372 #[cfg(feature = "std")]
4373 fn test_socket_address_to_socket_addrs() {
4374 assert_eq!(SocketAddress::TcpIpV4 {addr:[0u8; 4], port: 1337,}.to_socket_addrs().unwrap().next().unwrap(),
4375 SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(0,0,0,0), 1337)));
4376 assert_eq!(SocketAddress::TcpIpV6 {addr:[0u8; 16], port: 1337,}.to_socket_addrs().unwrap().next().unwrap(),
4377 SocketAddr::V6(SocketAddrV6::new(Ipv6Addr::from([0u8; 16]), 1337, 0, 0)));
4378 assert_eq!(SocketAddress::Hostname { hostname: Hostname::try_from("0.0.0.0".to_string()).unwrap(), port: 0 }
4379 .to_socket_addrs().unwrap().next().unwrap(), SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::from([0u8; 4]),0)));
4380 assert!(SocketAddress::OnionV2([0u8; 12]).to_socket_addrs().is_err());
4381 assert!(SocketAddress::OnionV3{ ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102,
4382 182, 107, 4, 105, 247, 246, 85, 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31,
4386 port: 1234 }.to_socket_addrs().is_err());