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::crypto::streams::ChaChaPolyReadAdapter;
57 use crate::util::logger;
58 use crate::util::ser::{LengthReadable, LengthReadableArgs, Readable, ReadableArgs, Writeable, Writer, WithoutLength, FixedLengthReader, HighZeroBytesDroppedBigSize, Hostname, TransactionU16LenLimited, BigSize};
59 use crate::util::base32;
61 use crate::routing::gossip::{NodeAlias, NodeId};
63 /// 21 million * 10^8 * 1000
64 pub(crate) const MAX_VALUE_MSAT: u64 = 21_000_000_0000_0000_000;
67 /// A partial signature that also contains the Musig2 nonce its signer used
68 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
69 pub struct PartialSignatureWithNonce(pub musig2::types::PartialSignature, pub musig2::types::PublicNonce);
71 /// An error in decoding a message or struct.
72 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
73 pub enum DecodeError {
74 /// A version byte specified something we don't know how to handle.
76 /// Includes unknown realm byte in an onion hop data packet.
78 /// Unknown feature mandating we fail to parse message (e.g., TLV with an even, unknown type)
79 UnknownRequiredFeature,
80 /// Value was invalid.
82 /// For example, a byte which was supposed to be a bool was something other than a 0
83 /// or 1, a public key/private key/signature was invalid, text wasn't UTF-8, TLV was
84 /// syntactically incorrect, etc.
86 /// The buffer to be read was too short.
88 /// A length descriptor in the packet didn't describe the later data correctly.
90 /// Error from [`std::io`].
92 /// The message included zlib-compressed values, which we don't support.
93 UnsupportedCompression,
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.
1136 pub enum UnsignedGossipMessage {
1137 /// An unsigned channel announcement.
1138 ChannelAnnouncement(UnsignedChannelAnnouncement),
1139 /// An unsigned channel update.
1140 ChannelUpdate(UnsignedChannelUpdate),
1141 /// An unsigned node announcement.
1142 NodeAnnouncement(UnsignedNodeAnnouncement)
1145 impl Writeable for UnsignedGossipMessage {
1146 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
1148 UnsignedGossipMessage::ChannelAnnouncement(ref msg) => msg.write(writer),
1149 UnsignedGossipMessage::ChannelUpdate(ref msg) => msg.write(writer),
1150 UnsignedGossipMessage::NodeAnnouncement(ref msg) => msg.write(writer),
1155 /// The unsigned part of a [`node_announcement`] message.
1157 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
1158 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1159 pub struct UnsignedNodeAnnouncement {
1160 /// The advertised features
1161 pub features: NodeFeatures,
1162 /// A strictly monotonic announcement counter, with gaps allowed
1164 /// The `node_id` this announcement originated from (don't rebroadcast the `node_announcement` back
1166 pub node_id: NodeId,
1167 /// An RGB color for UI purposes
1169 /// An alias, for UI purposes.
1171 /// This should be sanitized before use. There is no guarantee of uniqueness.
1172 pub alias: NodeAlias,
1173 /// List of addresses on which this node is reachable
1174 pub addresses: Vec<SocketAddress>,
1175 pub(crate) excess_address_data: Vec<u8>,
1176 pub(crate) excess_data: Vec<u8>,
1178 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1179 /// A [`node_announcement`] message to be sent to or received from a peer.
1181 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
1182 pub struct NodeAnnouncement {
1183 /// The signature by the node key
1184 pub signature: Signature,
1185 /// The actual content of the announcement
1186 pub contents: UnsignedNodeAnnouncement,
1189 /// The unsigned part of a [`channel_announcement`] message.
1191 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
1192 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1193 pub struct UnsignedChannelAnnouncement {
1194 /// The advertised channel features
1195 pub features: ChannelFeatures,
1196 /// The genesis hash of the blockchain where the channel is to be opened
1197 pub chain_hash: ChainHash,
1198 /// The short channel ID
1199 pub short_channel_id: u64,
1200 /// One of the two `node_id`s which are endpoints of this channel
1201 pub node_id_1: NodeId,
1202 /// The other of the two `node_id`s which are endpoints of this channel
1203 pub node_id_2: NodeId,
1204 /// The funding key for the first node
1205 pub bitcoin_key_1: NodeId,
1206 /// The funding key for the second node
1207 pub bitcoin_key_2: NodeId,
1208 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1211 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1212 pub excess_data: Vec<u8>,
1214 /// A [`channel_announcement`] message to be sent to or received from a peer.
1216 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
1217 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1218 pub struct ChannelAnnouncement {
1219 /// Authentication of the announcement by the first public node
1220 pub node_signature_1: Signature,
1221 /// Authentication of the announcement by the second public node
1222 pub node_signature_2: Signature,
1223 /// Proof of funding UTXO ownership by the first public node
1224 pub bitcoin_signature_1: Signature,
1225 /// Proof of funding UTXO ownership by the second public node
1226 pub bitcoin_signature_2: Signature,
1227 /// The actual announcement
1228 pub contents: UnsignedChannelAnnouncement,
1231 /// The unsigned part of a [`channel_update`] message.
1233 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1234 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1235 pub struct UnsignedChannelUpdate {
1236 /// The genesis hash of the blockchain where the channel is to be opened
1237 pub chain_hash: ChainHash,
1238 /// The short channel ID
1239 pub short_channel_id: u64,
1240 /// A strictly monotonic announcement counter, with gaps allowed, specific to this channel
1244 /// The number of blocks such that if:
1245 /// `incoming_htlc.cltv_expiry < outgoing_htlc.cltv_expiry + cltv_expiry_delta`
1246 /// then we need to fail the HTLC backwards. When forwarding an HTLC, `cltv_expiry_delta` determines
1247 /// the outgoing HTLC's minimum `cltv_expiry` value -- so, if an incoming HTLC comes in with a
1248 /// `cltv_expiry` of 100000, and the node we're forwarding to has a `cltv_expiry_delta` value of 10,
1249 /// then we'll check that the outgoing HTLC's `cltv_expiry` value is at least 100010 before
1250 /// forwarding. Note that the HTLC sender is the one who originally sets this value when
1251 /// constructing the route.
1252 pub cltv_expiry_delta: u16,
1253 /// The minimum HTLC size incoming to sender, in milli-satoshi
1254 pub htlc_minimum_msat: u64,
1255 /// The maximum HTLC value incoming to sender, in milli-satoshi.
1257 /// This used to be optional.
1258 pub htlc_maximum_msat: u64,
1259 /// The base HTLC fee charged by sender, in milli-satoshi
1260 pub fee_base_msat: u32,
1261 /// The amount to fee multiplier, in micro-satoshi
1262 pub fee_proportional_millionths: u32,
1263 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1266 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1267 pub excess_data: Vec<u8>,
1269 /// A [`channel_update`] message to be sent to or received from a peer.
1271 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1272 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1273 pub struct ChannelUpdate {
1274 /// A signature of the channel update
1275 pub signature: Signature,
1276 /// The actual channel update
1277 pub contents: UnsignedChannelUpdate,
1280 /// A [`query_channel_range`] message is used to query a peer for channel
1281 /// UTXOs in a range of blocks. The recipient of a query makes a best
1282 /// effort to reply to the query using one or more [`ReplyChannelRange`]
1285 /// [`query_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1286 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1287 pub struct QueryChannelRange {
1288 /// The genesis hash of the blockchain being queried
1289 pub chain_hash: ChainHash,
1290 /// The height of the first block for the channel UTXOs being queried
1291 pub first_blocknum: u32,
1292 /// The number of blocks to include in the query results
1293 pub number_of_blocks: u32,
1296 /// A [`reply_channel_range`] message is a reply to a [`QueryChannelRange`]
1299 /// Multiple `reply_channel_range` messages can be sent in reply
1300 /// to a single [`QueryChannelRange`] message. The query recipient makes a
1301 /// best effort to respond based on their local network view which may
1302 /// not be a perfect view of the network. The `short_channel_id`s in the
1303 /// reply are encoded. We only support `encoding_type=0` uncompressed
1304 /// serialization and do not support `encoding_type=1` zlib serialization.
1306 /// [`reply_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1307 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1308 pub struct ReplyChannelRange {
1309 /// The genesis hash of the blockchain being queried
1310 pub chain_hash: ChainHash,
1311 /// The height of the first block in the range of the reply
1312 pub first_blocknum: u32,
1313 /// The number of blocks included in the range of the reply
1314 pub number_of_blocks: u32,
1315 /// True when this is the final reply for a query
1316 pub sync_complete: bool,
1317 /// The `short_channel_id`s in the channel range
1318 pub short_channel_ids: Vec<u64>,
1321 /// A [`query_short_channel_ids`] message is used to query a peer for
1322 /// routing gossip messages related to one or more `short_channel_id`s.
1324 /// The query recipient will reply with the latest, if available,
1325 /// [`ChannelAnnouncement`], [`ChannelUpdate`] and [`NodeAnnouncement`] messages
1326 /// it maintains for the requested `short_channel_id`s followed by a
1327 /// [`ReplyShortChannelIdsEnd`] message. The `short_channel_id`s sent in
1328 /// this query are encoded. We only support `encoding_type=0` uncompressed
1329 /// serialization and do not support `encoding_type=1` zlib serialization.
1331 /// [`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
1332 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1333 pub struct QueryShortChannelIds {
1334 /// The genesis hash of the blockchain being queried
1335 pub chain_hash: ChainHash,
1336 /// The short_channel_ids that are being queried
1337 pub short_channel_ids: Vec<u64>,
1340 /// A [`reply_short_channel_ids_end`] message is sent as a reply to a
1341 /// message. The query recipient makes a best
1342 /// effort to respond based on their local network view which may not be
1343 /// a perfect view of the network.
1345 /// [`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
1346 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1347 pub struct ReplyShortChannelIdsEnd {
1348 /// The genesis hash of the blockchain that was queried
1349 pub chain_hash: ChainHash,
1350 /// Indicates if the query recipient maintains up-to-date channel
1351 /// information for the `chain_hash`
1352 pub full_information: bool,
1355 /// A [`gossip_timestamp_filter`] message is used by a node to request
1356 /// gossip relay for messages in the requested time range when the
1357 /// `gossip_queries` feature has been negotiated.
1359 /// [`gossip_timestamp_filter`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-gossip_timestamp_filter-message
1360 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1361 pub struct GossipTimestampFilter {
1362 /// The genesis hash of the blockchain for channel and node information
1363 pub chain_hash: ChainHash,
1364 /// The starting unix timestamp
1365 pub first_timestamp: u32,
1366 /// The range of information in seconds
1367 pub timestamp_range: u32,
1370 /// Encoding type for data compression of collections in gossip queries.
1372 /// We do not support `encoding_type=1` zlib serialization [defined in BOLT
1373 /// #7](https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#query-messages).
1375 Uncompressed = 0x00,
1378 /// Used to put an error message in a [`LightningError`].
1379 #[derive(Clone, Debug, Hash, PartialEq)]
1380 pub enum ErrorAction {
1381 /// The peer took some action which made us think they were useless. Disconnect them.
1383 /// An error message which we should make an effort to send before we disconnect.
1384 msg: Option<ErrorMessage>
1386 /// The peer did something incorrect. Tell them without closing any channels and disconnect them.
1387 DisconnectPeerWithWarning {
1388 /// A warning message which we should make an effort to send before we disconnect.
1389 msg: WarningMessage,
1391 /// The peer did something harmless that we weren't able to process, just log and ignore
1392 // New code should *not* use this. New code must use IgnoreAndLog, below!
1394 /// The peer did something harmless that we weren't able to meaningfully process.
1395 /// If the error is logged, log it at the given level.
1396 IgnoreAndLog(logger::Level),
1397 /// The peer provided us with a gossip message which we'd already seen. In most cases this
1398 /// should be ignored, but it may result in the message being forwarded if it is a duplicate of
1399 /// our own channel announcements.
1400 IgnoreDuplicateGossip,
1401 /// The peer did something incorrect. Tell them.
1403 /// The message to send.
1406 /// The peer did something incorrect. Tell them without closing any channels.
1407 SendWarningMessage {
1408 /// The message to send.
1409 msg: WarningMessage,
1410 /// The peer may have done something harmless that we weren't able to meaningfully process,
1411 /// though we should still tell them about it.
1412 /// If this event is logged, log it at the given level.
1413 log_level: logger::Level,
1417 /// An Err type for failure to process messages.
1418 #[derive(Clone, Debug)]
1419 pub struct LightningError {
1420 /// A human-readable message describing the error
1422 /// The action which should be taken against the offending peer.
1423 pub action: ErrorAction,
1426 /// Struct used to return values from [`RevokeAndACK`] messages, containing a bunch of commitment
1427 /// transaction updates if they were pending.
1428 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1429 pub struct CommitmentUpdate {
1430 /// `update_add_htlc` messages which should be sent
1431 pub update_add_htlcs: Vec<UpdateAddHTLC>,
1432 /// `update_fulfill_htlc` messages which should be sent
1433 pub update_fulfill_htlcs: Vec<UpdateFulfillHTLC>,
1434 /// `update_fail_htlc` messages which should be sent
1435 pub update_fail_htlcs: Vec<UpdateFailHTLC>,
1436 /// `update_fail_malformed_htlc` messages which should be sent
1437 pub update_fail_malformed_htlcs: Vec<UpdateFailMalformedHTLC>,
1438 /// An `update_fee` message which should be sent
1439 pub update_fee: Option<UpdateFee>,
1440 /// A `commitment_signed` message which should be sent
1441 pub commitment_signed: CommitmentSigned,
1444 /// A trait to describe an object which can receive channel messages.
1446 /// Messages MAY be called in parallel when they originate from different `their_node_ids`, however
1447 /// they MUST NOT be called in parallel when the two calls have the same `their_node_id`.
1448 pub trait ChannelMessageHandler : MessageSendEventsProvider {
1450 /// Handle an incoming `open_channel` message from the given peer.
1451 fn handle_open_channel(&self, their_node_id: &PublicKey, msg: &OpenChannel);
1452 /// Handle an incoming `open_channel2` message from the given peer.
1453 fn handle_open_channel_v2(&self, their_node_id: &PublicKey, msg: &OpenChannelV2);
1454 /// Handle an incoming `accept_channel` message from the given peer.
1455 fn handle_accept_channel(&self, their_node_id: &PublicKey, msg: &AcceptChannel);
1456 /// Handle an incoming `accept_channel2` message from the given peer.
1457 fn handle_accept_channel_v2(&self, their_node_id: &PublicKey, msg: &AcceptChannelV2);
1458 /// Handle an incoming `funding_created` message from the given peer.
1459 fn handle_funding_created(&self, their_node_id: &PublicKey, msg: &FundingCreated);
1460 /// Handle an incoming `funding_signed` message from the given peer.
1461 fn handle_funding_signed(&self, their_node_id: &PublicKey, msg: &FundingSigned);
1462 /// Handle an incoming `channel_ready` message from the given peer.
1463 fn handle_channel_ready(&self, their_node_id: &PublicKey, msg: &ChannelReady);
1466 /// Handle an incoming `shutdown` message from the given peer.
1467 fn handle_shutdown(&self, their_node_id: &PublicKey, msg: &Shutdown);
1468 /// Handle an incoming `closing_signed` message from the given peer.
1469 fn handle_closing_signed(&self, their_node_id: &PublicKey, msg: &ClosingSigned);
1472 /// Handle an incoming `stfu` message from the given peer.
1473 fn handle_stfu(&self, their_node_id: &PublicKey, msg: &Stfu);
1476 /// Handle an incoming `splice` message from the given peer.
1477 fn handle_splice(&self, their_node_id: &PublicKey, msg: &Splice);
1478 /// Handle an incoming `splice_ack` message from the given peer.
1479 fn handle_splice_ack(&self, their_node_id: &PublicKey, msg: &SpliceAck);
1480 /// Handle an incoming `splice_locked` message from the given peer.
1481 fn handle_splice_locked(&self, their_node_id: &PublicKey, msg: &SpliceLocked);
1483 // Interactive channel construction
1484 /// Handle an incoming `tx_add_input message` from the given peer.
1485 fn handle_tx_add_input(&self, their_node_id: &PublicKey, msg: &TxAddInput);
1486 /// Handle an incoming `tx_add_output` message from the given peer.
1487 fn handle_tx_add_output(&self, their_node_id: &PublicKey, msg: &TxAddOutput);
1488 /// Handle an incoming `tx_remove_input` message from the given peer.
1489 fn handle_tx_remove_input(&self, their_node_id: &PublicKey, msg: &TxRemoveInput);
1490 /// Handle an incoming `tx_remove_output` message from the given peer.
1491 fn handle_tx_remove_output(&self, their_node_id: &PublicKey, msg: &TxRemoveOutput);
1492 /// Handle an incoming `tx_complete message` from the given peer.
1493 fn handle_tx_complete(&self, their_node_id: &PublicKey, msg: &TxComplete);
1494 /// Handle an incoming `tx_signatures` message from the given peer.
1495 fn handle_tx_signatures(&self, their_node_id: &PublicKey, msg: &TxSignatures);
1496 /// Handle an incoming `tx_init_rbf` message from the given peer.
1497 fn handle_tx_init_rbf(&self, their_node_id: &PublicKey, msg: &TxInitRbf);
1498 /// Handle an incoming `tx_ack_rbf` message from the given peer.
1499 fn handle_tx_ack_rbf(&self, their_node_id: &PublicKey, msg: &TxAckRbf);
1500 /// Handle an incoming `tx_abort message` from the given peer.
1501 fn handle_tx_abort(&self, their_node_id: &PublicKey, msg: &TxAbort);
1504 /// Handle an incoming `update_add_htlc` message from the given peer.
1505 fn handle_update_add_htlc(&self, their_node_id: &PublicKey, msg: &UpdateAddHTLC);
1506 /// Handle an incoming `update_fulfill_htlc` message from the given peer.
1507 fn handle_update_fulfill_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFulfillHTLC);
1508 /// Handle an incoming `update_fail_htlc` message from the given peer.
1509 fn handle_update_fail_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailHTLC);
1510 /// Handle an incoming `update_fail_malformed_htlc` message from the given peer.
1511 fn handle_update_fail_malformed_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailMalformedHTLC);
1512 /// Handle an incoming `commitment_signed` message from the given peer.
1513 fn handle_commitment_signed(&self, their_node_id: &PublicKey, msg: &CommitmentSigned);
1514 /// Handle an incoming `revoke_and_ack` message from the given peer.
1515 fn handle_revoke_and_ack(&self, their_node_id: &PublicKey, msg: &RevokeAndACK);
1517 /// Handle an incoming `update_fee` message from the given peer.
1518 fn handle_update_fee(&self, their_node_id: &PublicKey, msg: &UpdateFee);
1520 // Channel-to-announce:
1521 /// Handle an incoming `announcement_signatures` message from the given peer.
1522 fn handle_announcement_signatures(&self, their_node_id: &PublicKey, msg: &AnnouncementSignatures);
1524 // Connection loss/reestablish:
1525 /// Indicates a connection to the peer failed/an existing connection was lost.
1526 fn peer_disconnected(&self, their_node_id: &PublicKey);
1528 /// Handle a peer reconnecting, possibly generating `channel_reestablish` message(s).
1530 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1531 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1532 /// message handlers may still wish to communicate with this peer.
1533 fn peer_connected(&self, their_node_id: &PublicKey, msg: &Init, inbound: bool) -> Result<(), ()>;
1534 /// Handle an incoming `channel_reestablish` message from the given peer.
1535 fn handle_channel_reestablish(&self, their_node_id: &PublicKey, msg: &ChannelReestablish);
1537 /// Handle an incoming `channel_update` message from the given peer.
1538 fn handle_channel_update(&self, their_node_id: &PublicKey, msg: &ChannelUpdate);
1541 /// Handle an incoming `error` message from the given peer.
1542 fn handle_error(&self, their_node_id: &PublicKey, msg: &ErrorMessage);
1544 // Handler information:
1545 /// Gets the node feature flags which this handler itself supports. All available handlers are
1546 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1547 /// which are broadcasted in our [`NodeAnnouncement`] message.
1548 fn provided_node_features(&self) -> NodeFeatures;
1550 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1551 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1552 /// which are sent in our [`Init`] message.
1554 /// Note that this method is called before [`Self::peer_connected`].
1555 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1557 /// Gets the chain hashes for this `ChannelMessageHandler` indicating which chains it supports.
1559 /// If it's `None`, then no particular network chain hash compatibility will be enforced when
1560 /// connecting to peers.
1561 fn get_chain_hashes(&self) -> Option<Vec<ChainHash>>;
1564 /// A trait to describe an object which can receive routing messages.
1566 /// # Implementor DoS Warnings
1568 /// For messages enabled with the `gossip_queries` feature there are potential DoS vectors when
1569 /// handling inbound queries. Implementors using an on-disk network graph should be aware of
1570 /// repeated disk I/O for queries accessing different parts of the network graph.
1571 pub trait RoutingMessageHandler : MessageSendEventsProvider {
1572 /// Handle an incoming `node_announcement` message, returning `true` if it should be forwarded on,
1573 /// `false` or returning an `Err` otherwise.
1574 fn handle_node_announcement(&self, msg: &NodeAnnouncement) -> Result<bool, LightningError>;
1575 /// Handle a `channel_announcement` message, returning `true` if it should be forwarded on, `false`
1576 /// or returning an `Err` otherwise.
1577 fn handle_channel_announcement(&self, msg: &ChannelAnnouncement) -> Result<bool, LightningError>;
1578 /// Handle an incoming `channel_update` message, returning true if it should be forwarded on,
1579 /// `false` or returning an `Err` otherwise.
1580 fn handle_channel_update(&self, msg: &ChannelUpdate) -> Result<bool, LightningError>;
1581 /// Gets channel announcements and updates required to dump our routing table to a remote node,
1582 /// starting at the `short_channel_id` indicated by `starting_point` and including announcements
1583 /// for a single channel.
1584 fn get_next_channel_announcement(&self, starting_point: u64) -> Option<(ChannelAnnouncement, Option<ChannelUpdate>, Option<ChannelUpdate>)>;
1585 /// Gets a node announcement required to dump our routing table to a remote node, starting at
1586 /// the node *after* the provided pubkey and including up to one announcement immediately
1587 /// higher (as defined by `<PublicKey as Ord>::cmp`) than `starting_point`.
1588 /// If `None` is provided for `starting_point`, we start at the first node.
1589 fn get_next_node_announcement(&self, starting_point: Option<&NodeId>) -> Option<NodeAnnouncement>;
1590 /// Called when a connection is established with a peer. This can be used to
1591 /// perform routing table synchronization using a strategy defined by the
1594 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1595 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1596 /// message handlers may still wish to communicate with this peer.
1597 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1598 /// Handles the reply of a query we initiated to learn about channels
1599 /// for a given range of blocks. We can expect to receive one or more
1600 /// replies to a single query.
1601 fn handle_reply_channel_range(&self, their_node_id: &PublicKey, msg: ReplyChannelRange) -> Result<(), LightningError>;
1602 /// Handles the reply of a query we initiated asking for routing gossip
1603 /// messages for a list of channels. We should receive this message when
1604 /// a node has completed its best effort to send us the pertaining routing
1605 /// gossip messages.
1606 fn handle_reply_short_channel_ids_end(&self, their_node_id: &PublicKey, msg: ReplyShortChannelIdsEnd) -> Result<(), LightningError>;
1607 /// Handles when a peer asks us to send a list of `short_channel_id`s
1608 /// for the requested range of blocks.
1609 fn handle_query_channel_range(&self, their_node_id: &PublicKey, msg: QueryChannelRange) -> Result<(), LightningError>;
1610 /// Handles when a peer asks us to send routing gossip messages for a
1611 /// list of `short_channel_id`s.
1612 fn handle_query_short_channel_ids(&self, their_node_id: &PublicKey, msg: QueryShortChannelIds) -> Result<(), LightningError>;
1614 // Handler queueing status:
1615 /// Indicates that there are a large number of [`ChannelAnnouncement`] (or other) messages
1616 /// pending some async action. While there is no guarantee of the rate of future messages, the
1617 /// caller should seek to reduce the rate of new gossip messages handled, especially
1618 /// [`ChannelAnnouncement`]s.
1619 fn processing_queue_high(&self) -> bool;
1621 // Handler information:
1622 /// Gets the node feature flags which this handler itself supports. All available handlers are
1623 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1624 /// which are broadcasted in our [`NodeAnnouncement`] message.
1625 fn provided_node_features(&self) -> NodeFeatures;
1626 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1627 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1628 /// which are sent in our [`Init`] message.
1630 /// Note that this method is called before [`Self::peer_connected`].
1631 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1634 /// A handler for received [`OnionMessage`]s and for providing generated ones to send.
1635 pub trait OnionMessageHandler {
1636 /// Because much of the lightning network does not yet support forwarding onion messages, we
1637 /// may need to directly connect to a node which will forward a message for us. In such a case,
1638 /// this method will return the set of nodes which need connection by node_id and the
1639 /// corresponding socket addresses where they may accept incoming connections.
1641 /// Thus, this method should be polled regularly to detect messages await such a direct
1643 fn get_and_clear_connections_needed(&self) -> Vec<(PublicKey, Vec<SocketAddress>)>;
1645 /// Handle an incoming `onion_message` message from the given peer.
1646 fn handle_onion_message(&self, peer_node_id: &PublicKey, msg: &OnionMessage);
1648 /// Returns the next pending onion message for the peer with the given node id.
1649 fn next_onion_message_for_peer(&self, peer_node_id: PublicKey) -> Option<OnionMessage>;
1651 /// Called when a connection is established with a peer. Can be used to track which peers
1652 /// advertise onion message support and are online.
1654 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1655 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1656 /// message handlers may still wish to communicate with this peer.
1657 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1659 /// Indicates a connection to the peer failed/an existing connection was lost. Allows handlers to
1660 /// drop and refuse to forward onion messages to this peer.
1661 fn peer_disconnected(&self, their_node_id: &PublicKey);
1663 /// Performs actions that should happen roughly every ten seconds after startup. Allows handlers
1664 /// to drop any buffered onion messages intended for prospective peers.
1665 fn timer_tick_occurred(&self);
1667 // Handler information:
1668 /// Gets the node feature flags which this handler itself supports. All available handlers are
1669 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1670 /// which are broadcasted in our [`NodeAnnouncement`] message.
1671 fn provided_node_features(&self) -> NodeFeatures;
1673 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1674 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1675 /// which are sent in our [`Init`] message.
1677 /// Note that this method is called before [`Self::peer_connected`].
1678 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1682 #[cfg_attr(test, derive(Debug, PartialEq))]
1683 /// Information communicated in the onion to the recipient for multi-part tracking and proof that
1684 /// the payment is associated with an invoice.
1685 pub struct FinalOnionHopData {
1686 /// When sending a multi-part payment, this secret is used to identify a payment across HTLCs.
1687 /// Because it is generated by the recipient and included in the invoice, it also provides
1688 /// proof to the recipient that the payment was sent by someone with the generated invoice.
1689 pub payment_secret: PaymentSecret,
1690 /// The intended total amount that this payment is for.
1692 /// Message serialization may panic if this value is more than 21 million Bitcoin.
1693 pub total_msat: u64,
1696 mod fuzzy_internal_msgs {
1697 use bitcoin::secp256k1::PublicKey;
1698 use crate::blinded_path::payment::{PaymentConstraints, PaymentRelay};
1699 use crate::prelude::*;
1700 use crate::ln::{PaymentPreimage, PaymentSecret};
1701 use crate::ln::features::BlindedHopFeatures;
1702 use super::FinalOnionHopData;
1704 // These types aren't intended to be pub, but are exposed for direct fuzzing (as we deserialize
1705 // them from untrusted input):
1707 pub enum InboundOnionPayload {
1709 short_channel_id: u64,
1710 /// The value, in msat, of the payment after this hop's fee is deducted.
1711 amt_to_forward: u64,
1712 outgoing_cltv_value: u32,
1715 payment_data: Option<FinalOnionHopData>,
1716 payment_metadata: Option<Vec<u8>>,
1717 keysend_preimage: Option<PaymentPreimage>,
1718 custom_tlvs: Vec<(u64, Vec<u8>)>,
1719 sender_intended_htlc_amt_msat: u64,
1720 cltv_expiry_height: u32,
1723 short_channel_id: u64,
1724 payment_relay: PaymentRelay,
1725 payment_constraints: PaymentConstraints,
1726 features: BlindedHopFeatures,
1727 intro_node_blinding_point: Option<PublicKey>,
1730 sender_intended_htlc_amt_msat: u64,
1732 cltv_expiry_height: u32,
1733 payment_secret: PaymentSecret,
1734 payment_constraints: PaymentConstraints,
1735 intro_node_blinding_point: Option<PublicKey>,
1739 pub(crate) enum OutboundOnionPayload {
1741 short_channel_id: u64,
1742 /// The value, in msat, of the payment after this hop's fee is deducted.
1743 amt_to_forward: u64,
1744 outgoing_cltv_value: u32,
1747 payment_data: Option<FinalOnionHopData>,
1748 payment_metadata: Option<Vec<u8>>,
1749 keysend_preimage: Option<PaymentPreimage>,
1750 custom_tlvs: Vec<(u64, Vec<u8>)>,
1751 sender_intended_htlc_amt_msat: u64,
1752 cltv_expiry_height: u32,
1755 encrypted_tlvs: Vec<u8>,
1756 intro_node_blinding_point: Option<PublicKey>,
1759 sender_intended_htlc_amt_msat: u64,
1761 cltv_expiry_height: u32,
1762 encrypted_tlvs: Vec<u8>,
1763 intro_node_blinding_point: Option<PublicKey>, // Set if the introduction node of the blinded path is the final node
1767 pub struct DecodedOnionErrorPacket {
1768 pub(crate) hmac: [u8; 32],
1769 pub(crate) failuremsg: Vec<u8>,
1770 pub(crate) pad: Vec<u8>,
1774 pub use self::fuzzy_internal_msgs::*;
1775 #[cfg(not(fuzzing))]
1776 pub(crate) use self::fuzzy_internal_msgs::*;
1778 /// BOLT 4 onion packet including hop data for the next peer.
1779 #[derive(Clone, Hash, PartialEq, Eq)]
1780 pub struct OnionPacket {
1781 /// BOLT 4 version number.
1783 /// In order to ensure we always return an error on onion decode in compliance with [BOLT
1784 /// #4](https://github.com/lightning/bolts/blob/master/04-onion-routing.md), we have to
1785 /// deserialize `OnionPacket`s contained in [`UpdateAddHTLC`] messages even if the ephemeral
1786 /// public key (here) is bogus, so we hold a [`Result`] instead of a [`PublicKey`] as we'd
1788 pub public_key: Result<PublicKey, secp256k1::Error>,
1789 /// 1300 bytes encrypted payload for the next hop.
1790 pub hop_data: [u8; 20*65],
1791 /// HMAC to verify the integrity of hop_data.
1795 impl onion_utils::Packet for OnionPacket {
1796 type Data = onion_utils::FixedSizeOnionPacket;
1797 fn new(pubkey: PublicKey, hop_data: onion_utils::FixedSizeOnionPacket, hmac: [u8; 32]) -> Self {
1800 public_key: Ok(pubkey),
1801 hop_data: hop_data.0,
1807 impl fmt::Debug for OnionPacket {
1808 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1809 f.write_fmt(format_args!("OnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
1813 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1814 pub(crate) struct OnionErrorPacket {
1815 // This really should be a constant size slice, but the spec lets these things be up to 128KB?
1816 // (TODO) We limit it in decode to much lower...
1817 pub(crate) data: Vec<u8>,
1820 impl fmt::Display for DecodeError {
1821 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1823 DecodeError::UnknownVersion => f.write_str("Unknown realm byte in Onion packet"),
1824 DecodeError::UnknownRequiredFeature => f.write_str("Unknown required feature preventing decode"),
1825 DecodeError::InvalidValue => f.write_str("Nonsense bytes didn't map to the type they were interpreted as"),
1826 DecodeError::ShortRead => f.write_str("Packet extended beyond the provided bytes"),
1827 DecodeError::BadLengthDescriptor => f.write_str("A length descriptor in the packet didn't describe the later data correctly"),
1828 DecodeError::Io(ref e) => fmt::Debug::fmt(e, f),
1829 DecodeError::UnsupportedCompression => f.write_str("We don't support receiving messages with zlib-compressed fields"),
1834 impl From<io::Error> for DecodeError {
1835 fn from(e: io::Error) -> Self {
1836 if e.kind() == io::ErrorKind::UnexpectedEof {
1837 DecodeError::ShortRead
1839 DecodeError::Io(e.kind())
1844 #[cfg(not(taproot))]
1845 impl_writeable_msg!(AcceptChannel, {
1846 temporary_channel_id,
1847 dust_limit_satoshis,
1848 max_htlc_value_in_flight_msat,
1849 channel_reserve_satoshis,
1855 revocation_basepoint,
1857 delayed_payment_basepoint,
1859 first_per_commitment_point,
1861 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))), // Don't encode length twice.
1862 (1, channel_type, option),
1866 impl_writeable_msg!(AcceptChannel, {
1867 temporary_channel_id,
1868 dust_limit_satoshis,
1869 max_htlc_value_in_flight_msat,
1870 channel_reserve_satoshis,
1876 revocation_basepoint,
1878 delayed_payment_basepoint,
1880 first_per_commitment_point,
1882 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))), // Don't encode length twice.
1883 (1, channel_type, option),
1884 (4, next_local_nonce, option),
1887 impl_writeable_msg!(AcceptChannelV2, {
1888 temporary_channel_id,
1890 dust_limit_satoshis,
1891 max_htlc_value_in_flight_msat,
1897 revocation_basepoint,
1899 delayed_payment_basepoint,
1901 first_per_commitment_point,
1902 second_per_commitment_point,
1904 (0, shutdown_scriptpubkey, option),
1905 (1, channel_type, option),
1906 (2, require_confirmed_inputs, option),
1909 impl_writeable_msg!(Stfu, {
1914 impl_writeable_msg!(Splice, {
1918 funding_feerate_perkw,
1923 impl_writeable_msg!(SpliceAck, {
1930 impl_writeable_msg!(SpliceLocked, {
1934 impl_writeable_msg!(TxAddInput, {
1942 impl_writeable_msg!(TxAddOutput, {
1949 impl_writeable_msg!(TxRemoveInput, {
1954 impl_writeable_msg!(TxRemoveOutput, {
1959 impl_writeable_msg!(TxComplete, {
1963 impl_writeable_msg!(TxSignatures, {
1969 impl_writeable_msg!(TxInitRbf, {
1972 feerate_sat_per_1000_weight,
1974 (0, funding_output_contribution, option),
1977 impl_writeable_msg!(TxAckRbf, {
1980 (0, funding_output_contribution, option),
1983 impl_writeable_msg!(TxAbort, {
1988 impl_writeable_msg!(AnnouncementSignatures, {
1995 impl_writeable_msg!(ChannelReestablish, {
1997 next_local_commitment_number,
1998 next_remote_commitment_number,
1999 your_last_per_commitment_secret,
2000 my_current_per_commitment_point,
2002 (0, next_funding_txid, option),
2005 impl_writeable_msg!(ClosingSigned,
2006 { channel_id, fee_satoshis, signature },
2007 { (1, fee_range, option) }
2010 impl_writeable!(ClosingSignedFeeRange, {
2015 #[cfg(not(taproot))]
2016 impl_writeable_msg!(CommitmentSigned, {
2023 impl_writeable_msg!(CommitmentSigned, {
2028 (2, partial_signature_with_nonce, option)
2031 impl_writeable!(DecodedOnionErrorPacket, {
2037 #[cfg(not(taproot))]
2038 impl_writeable_msg!(FundingCreated, {
2039 temporary_channel_id,
2041 funding_output_index,
2045 impl_writeable_msg!(FundingCreated, {
2046 temporary_channel_id,
2048 funding_output_index,
2051 (2, partial_signature_with_nonce, option),
2052 (4, next_local_nonce, option)
2055 #[cfg(not(taproot))]
2056 impl_writeable_msg!(FundingSigned, {
2062 impl_writeable_msg!(FundingSigned, {
2066 (2, partial_signature_with_nonce, option)
2069 impl_writeable_msg!(ChannelReady, {
2071 next_per_commitment_point,
2073 (1, short_channel_id_alias, option),
2076 impl Writeable for Init {
2077 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2078 // global_features gets the bottom 13 bits of our features, and local_features gets all of
2079 // our relevant feature bits. This keeps us compatible with old nodes.
2080 self.features.write_up_to_13(w)?;
2081 self.features.write(w)?;
2082 encode_tlv_stream!(w, {
2083 (1, self.networks.as_ref().map(|n| WithoutLength(n)), option),
2084 (3, self.remote_network_address, option),
2090 impl Readable for Init {
2091 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2092 let global_features: InitFeatures = Readable::read(r)?;
2093 let features: InitFeatures = Readable::read(r)?;
2094 let mut remote_network_address: Option<SocketAddress> = None;
2095 let mut networks: Option<WithoutLength<Vec<ChainHash>>> = None;
2096 decode_tlv_stream!(r, {
2097 (1, networks, option),
2098 (3, remote_network_address, option)
2101 features: features | global_features,
2102 networks: networks.map(|n| n.0),
2103 remote_network_address,
2108 impl_writeable_msg!(OpenChannel, {
2110 temporary_channel_id,
2113 dust_limit_satoshis,
2114 max_htlc_value_in_flight_msat,
2115 channel_reserve_satoshis,
2121 revocation_basepoint,
2123 delayed_payment_basepoint,
2125 first_per_commitment_point,
2128 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))), // Don't encode length twice.
2129 (1, channel_type, option),
2132 impl_writeable_msg!(OpenChannelV2, {
2134 temporary_channel_id,
2135 funding_feerate_sat_per_1000_weight,
2136 commitment_feerate_sat_per_1000_weight,
2138 dust_limit_satoshis,
2139 max_htlc_value_in_flight_msat,
2145 revocation_basepoint,
2147 delayed_payment_basepoint,
2149 first_per_commitment_point,
2150 second_per_commitment_point,
2153 (0, shutdown_scriptpubkey, option),
2154 (1, channel_type, option),
2155 (2, require_confirmed_inputs, option),
2158 #[cfg(not(taproot))]
2159 impl_writeable_msg!(RevokeAndACK, {
2161 per_commitment_secret,
2162 next_per_commitment_point
2166 impl_writeable_msg!(RevokeAndACK, {
2168 per_commitment_secret,
2169 next_per_commitment_point
2171 (4, next_local_nonce, option)
2174 impl_writeable_msg!(Shutdown, {
2179 impl_writeable_msg!(UpdateFailHTLC, {
2185 impl_writeable_msg!(UpdateFailMalformedHTLC, {
2192 impl_writeable_msg!(UpdateFee, {
2197 impl_writeable_msg!(UpdateFulfillHTLC, {
2203 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2204 // serialization format in a way which assumes we know the total serialized length/message end
2206 impl_writeable!(OnionErrorPacket, {
2210 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2211 // serialization format in a way which assumes we know the total serialized length/message end
2213 impl Writeable for OnionPacket {
2214 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2215 self.version.write(w)?;
2216 match self.public_key {
2217 Ok(pubkey) => pubkey.write(w)?,
2218 Err(_) => [0u8;33].write(w)?,
2220 w.write_all(&self.hop_data)?;
2221 self.hmac.write(w)?;
2226 impl Readable for OnionPacket {
2227 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2229 version: Readable::read(r)?,
2231 let mut buf = [0u8;33];
2232 r.read_exact(&mut buf)?;
2233 PublicKey::from_slice(&buf)
2235 hop_data: Readable::read(r)?,
2236 hmac: Readable::read(r)?,
2241 impl_writeable_msg!(UpdateAddHTLC, {
2247 onion_routing_packet,
2249 (0, blinding_point, option),
2250 (65537, skimmed_fee_msat, option)
2253 impl Readable for OnionMessage {
2254 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2255 let blinding_point: PublicKey = Readable::read(r)?;
2256 let len: u16 = Readable::read(r)?;
2257 let mut packet_reader = FixedLengthReader::new(r, len as u64);
2258 let onion_routing_packet: onion_message::packet::Packet =
2259 <onion_message::packet::Packet as LengthReadable>::read(&mut packet_reader)?;
2262 onion_routing_packet,
2267 impl Writeable for OnionMessage {
2268 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2269 self.blinding_point.write(w)?;
2270 let onion_packet_len = self.onion_routing_packet.serialized_length();
2271 (onion_packet_len as u16).write(w)?;
2272 self.onion_routing_packet.write(w)?;
2277 impl Writeable for FinalOnionHopData {
2278 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2279 self.payment_secret.0.write(w)?;
2280 HighZeroBytesDroppedBigSize(self.total_msat).write(w)
2284 impl Readable for FinalOnionHopData {
2285 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2286 let secret: [u8; 32] = Readable::read(r)?;
2287 let amt: HighZeroBytesDroppedBigSize<u64> = Readable::read(r)?;
2288 Ok(Self { payment_secret: PaymentSecret(secret), total_msat: amt.0 })
2292 impl Writeable for OutboundOnionPayload {
2293 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2295 Self::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } => {
2296 _encode_varint_length_prefixed_tlv!(w, {
2297 (2, HighZeroBytesDroppedBigSize(*amt_to_forward), required),
2298 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2299 (6, short_channel_id, required)
2303 ref payment_data, ref payment_metadata, ref keysend_preimage, sender_intended_htlc_amt_msat,
2304 cltv_expiry_height, ref custom_tlvs,
2306 // We need to update [`ln::outbound_payment::RecipientOnionFields::with_custom_tlvs`]
2307 // to reject any reserved types in the experimental range if new ones are ever
2309 let keysend_tlv = keysend_preimage.map(|preimage| (5482373484, preimage.encode()));
2310 let mut custom_tlvs: Vec<&(u64, Vec<u8>)> = custom_tlvs.iter().chain(keysend_tlv.iter()).collect();
2311 custom_tlvs.sort_unstable_by_key(|(typ, _)| *typ);
2312 _encode_varint_length_prefixed_tlv!(w, {
2313 (2, HighZeroBytesDroppedBigSize(*sender_intended_htlc_amt_msat), required),
2314 (4, HighZeroBytesDroppedBigSize(*cltv_expiry_height), required),
2315 (8, payment_data, option),
2316 (16, payment_metadata.as_ref().map(|m| WithoutLength(m)), option)
2317 }, custom_tlvs.iter());
2319 Self::BlindedForward { encrypted_tlvs, intro_node_blinding_point } => {
2320 _encode_varint_length_prefixed_tlv!(w, {
2321 (10, *encrypted_tlvs, required_vec),
2322 (12, intro_node_blinding_point, option)
2325 Self::BlindedReceive {
2326 sender_intended_htlc_amt_msat, total_msat, cltv_expiry_height, encrypted_tlvs,
2327 intro_node_blinding_point,
2329 _encode_varint_length_prefixed_tlv!(w, {
2330 (2, HighZeroBytesDroppedBigSize(*sender_intended_htlc_amt_msat), required),
2331 (4, HighZeroBytesDroppedBigSize(*cltv_expiry_height), required),
2332 (10, *encrypted_tlvs, required_vec),
2333 (12, intro_node_blinding_point, option),
2334 (18, HighZeroBytesDroppedBigSize(*total_msat), required)
2342 impl<NS: Deref> ReadableArgs<(Option<PublicKey>, &NS)> for InboundOnionPayload where NS::Target: NodeSigner {
2343 fn read<R: Read>(r: &mut R, args: (Option<PublicKey>, &NS)) -> Result<Self, DecodeError> {
2344 let (update_add_blinding_point, node_signer) = args;
2347 let mut cltv_value = None;
2348 let mut short_id: Option<u64> = None;
2349 let mut payment_data: Option<FinalOnionHopData> = None;
2350 let mut encrypted_tlvs_opt: Option<WithoutLength<Vec<u8>>> = None;
2351 let mut intro_node_blinding_point = None;
2352 let mut payment_metadata: Option<WithoutLength<Vec<u8>>> = None;
2353 let mut total_msat = None;
2354 let mut keysend_preimage: Option<PaymentPreimage> = None;
2355 let mut custom_tlvs = Vec::new();
2357 let tlv_len = BigSize::read(r)?;
2358 let rd = FixedLengthReader::new(r, tlv_len.0);
2359 decode_tlv_stream_with_custom_tlv_decode!(rd, {
2360 (2, amt, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2361 (4, cltv_value, (option, encoding: (u32, HighZeroBytesDroppedBigSize))),
2362 (6, short_id, option),
2363 (8, payment_data, option),
2364 (10, encrypted_tlvs_opt, option),
2365 (12, intro_node_blinding_point, option),
2366 (16, payment_metadata, option),
2367 (18, total_msat, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2368 // See https://github.com/lightning/blips/blob/master/blip-0003.md
2369 (5482373484, keysend_preimage, option)
2370 }, |msg_type: u64, msg_reader: &mut FixedLengthReader<_>| -> Result<bool, DecodeError> {
2371 if msg_type < 1 << 16 { return Ok(false) }
2372 let mut value = Vec::new();
2373 msg_reader.read_to_end(&mut value)?;
2374 custom_tlvs.push((msg_type, value));
2378 if amt.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2379 if intro_node_blinding_point.is_some() && update_add_blinding_point.is_some() {
2380 return Err(DecodeError::InvalidValue)
2383 if let Some(blinding_point) = intro_node_blinding_point.or(update_add_blinding_point) {
2384 if short_id.is_some() || payment_data.is_some() || payment_metadata.is_some() ||
2385 keysend_preimage.is_some()
2387 return Err(DecodeError::InvalidValue)
2389 let enc_tlvs = encrypted_tlvs_opt.ok_or(DecodeError::InvalidValue)?.0;
2390 let enc_tlvs_ss = node_signer.ecdh(Recipient::Node, &blinding_point, None)
2391 .map_err(|_| DecodeError::InvalidValue)?;
2392 let rho = onion_utils::gen_rho_from_shared_secret(&enc_tlvs_ss.secret_bytes());
2393 let mut s = Cursor::new(&enc_tlvs);
2394 let mut reader = FixedLengthReader::new(&mut s, enc_tlvs.len() as u64);
2395 match ChaChaPolyReadAdapter::read(&mut reader, rho)? {
2396 ChaChaPolyReadAdapter { readable: BlindedPaymentTlvs::Forward(ForwardTlvs {
2397 short_channel_id, payment_relay, payment_constraints, features
2399 if amt.is_some() || cltv_value.is_some() || total_msat.is_some() {
2400 return Err(DecodeError::InvalidValue)
2402 Ok(Self::BlindedForward {
2405 payment_constraints,
2407 intro_node_blinding_point,
2410 ChaChaPolyReadAdapter { readable: BlindedPaymentTlvs::Receive(ReceiveTlvs {
2411 payment_secret, payment_constraints
2413 if total_msat.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2414 Ok(Self::BlindedReceive {
2415 sender_intended_htlc_amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2416 total_msat: total_msat.ok_or(DecodeError::InvalidValue)?,
2417 cltv_expiry_height: cltv_value.ok_or(DecodeError::InvalidValue)?,
2419 payment_constraints,
2420 intro_node_blinding_point,
2424 } else if let Some(short_channel_id) = short_id {
2425 if payment_data.is_some() || payment_metadata.is_some() || encrypted_tlvs_opt.is_some() ||
2426 total_msat.is_some()
2427 { return Err(DecodeError::InvalidValue) }
2430 amt_to_forward: amt.ok_or(DecodeError::InvalidValue)?,
2431 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2434 if encrypted_tlvs_opt.is_some() || total_msat.is_some() {
2435 return Err(DecodeError::InvalidValue)
2437 if let Some(data) = &payment_data {
2438 if data.total_msat > MAX_VALUE_MSAT {
2439 return Err(DecodeError::InvalidValue);
2444 payment_metadata: payment_metadata.map(|w| w.0),
2446 sender_intended_htlc_amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2447 cltv_expiry_height: cltv_value.ok_or(DecodeError::InvalidValue)?,
2454 impl Writeable for Ping {
2455 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2456 self.ponglen.write(w)?;
2457 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2462 impl Readable for Ping {
2463 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2465 ponglen: Readable::read(r)?,
2467 let byteslen = Readable::read(r)?;
2468 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2475 impl Writeable for Pong {
2476 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2477 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2482 impl Readable for Pong {
2483 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2486 let byteslen = Readable::read(r)?;
2487 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2494 impl Writeable for UnsignedChannelAnnouncement {
2495 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2496 self.features.write(w)?;
2497 self.chain_hash.write(w)?;
2498 self.short_channel_id.write(w)?;
2499 self.node_id_1.write(w)?;
2500 self.node_id_2.write(w)?;
2501 self.bitcoin_key_1.write(w)?;
2502 self.bitcoin_key_2.write(w)?;
2503 w.write_all(&self.excess_data[..])?;
2508 impl Readable for UnsignedChannelAnnouncement {
2509 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2511 features: Readable::read(r)?,
2512 chain_hash: Readable::read(r)?,
2513 short_channel_id: Readable::read(r)?,
2514 node_id_1: Readable::read(r)?,
2515 node_id_2: Readable::read(r)?,
2516 bitcoin_key_1: Readable::read(r)?,
2517 bitcoin_key_2: Readable::read(r)?,
2518 excess_data: read_to_end(r)?,
2523 impl_writeable!(ChannelAnnouncement, {
2526 bitcoin_signature_1,
2527 bitcoin_signature_2,
2531 impl Writeable for UnsignedChannelUpdate {
2532 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2533 // `message_flags` used to indicate presence of `htlc_maximum_msat`, but was deprecated in the spec.
2534 const MESSAGE_FLAGS: u8 = 1;
2535 self.chain_hash.write(w)?;
2536 self.short_channel_id.write(w)?;
2537 self.timestamp.write(w)?;
2538 let all_flags = self.flags as u16 | ((MESSAGE_FLAGS as u16) << 8);
2539 all_flags.write(w)?;
2540 self.cltv_expiry_delta.write(w)?;
2541 self.htlc_minimum_msat.write(w)?;
2542 self.fee_base_msat.write(w)?;
2543 self.fee_proportional_millionths.write(w)?;
2544 self.htlc_maximum_msat.write(w)?;
2545 w.write_all(&self.excess_data[..])?;
2550 impl Readable for UnsignedChannelUpdate {
2551 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2553 chain_hash: Readable::read(r)?,
2554 short_channel_id: Readable::read(r)?,
2555 timestamp: Readable::read(r)?,
2557 let flags: u16 = Readable::read(r)?;
2558 // Note: we ignore the `message_flags` for now, since it was deprecated by the spec.
2561 cltv_expiry_delta: Readable::read(r)?,
2562 htlc_minimum_msat: Readable::read(r)?,
2563 fee_base_msat: Readable::read(r)?,
2564 fee_proportional_millionths: Readable::read(r)?,
2565 htlc_maximum_msat: Readable::read(r)?,
2566 excess_data: read_to_end(r)?,
2571 impl_writeable!(ChannelUpdate, {
2576 impl Writeable for ErrorMessage {
2577 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2578 self.channel_id.write(w)?;
2579 (self.data.len() as u16).write(w)?;
2580 w.write_all(self.data.as_bytes())?;
2585 impl Readable for ErrorMessage {
2586 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2588 channel_id: Readable::read(r)?,
2590 let sz: usize = <u16 as Readable>::read(r)? as usize;
2591 let mut data = Vec::with_capacity(sz);
2593 r.read_exact(&mut data)?;
2594 match String::from_utf8(data) {
2596 Err(_) => return Err(DecodeError::InvalidValue),
2603 impl Writeable for WarningMessage {
2604 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2605 self.channel_id.write(w)?;
2606 (self.data.len() as u16).write(w)?;
2607 w.write_all(self.data.as_bytes())?;
2612 impl Readable for WarningMessage {
2613 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2615 channel_id: Readable::read(r)?,
2617 let sz: usize = <u16 as Readable>::read(r)? as usize;
2618 let mut data = Vec::with_capacity(sz);
2620 r.read_exact(&mut data)?;
2621 match String::from_utf8(data) {
2623 Err(_) => return Err(DecodeError::InvalidValue),
2630 impl Writeable for UnsignedNodeAnnouncement {
2631 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2632 self.features.write(w)?;
2633 self.timestamp.write(w)?;
2634 self.node_id.write(w)?;
2635 w.write_all(&self.rgb)?;
2636 self.alias.write(w)?;
2638 let mut addr_len = 0;
2639 for addr in self.addresses.iter() {
2640 addr_len += 1 + addr.len();
2642 (addr_len + self.excess_address_data.len() as u16).write(w)?;
2643 for addr in self.addresses.iter() {
2646 w.write_all(&self.excess_address_data[..])?;
2647 w.write_all(&self.excess_data[..])?;
2652 impl Readable for UnsignedNodeAnnouncement {
2653 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2654 let features: NodeFeatures = Readable::read(r)?;
2655 let timestamp: u32 = Readable::read(r)?;
2656 let node_id: NodeId = Readable::read(r)?;
2657 let mut rgb = [0; 3];
2658 r.read_exact(&mut rgb)?;
2659 let alias: NodeAlias = Readable::read(r)?;
2661 let addr_len: u16 = Readable::read(r)?;
2662 let mut addresses: Vec<SocketAddress> = Vec::new();
2663 let mut addr_readpos = 0;
2664 let mut excess = false;
2665 let mut excess_byte = 0;
2667 if addr_len <= addr_readpos { break; }
2668 match Readable::read(r) {
2670 if addr_len < addr_readpos + 1 + addr.len() {
2671 return Err(DecodeError::BadLengthDescriptor);
2673 addr_readpos += (1 + addr.len()) as u16;
2674 addresses.push(addr);
2676 Ok(Err(unknown_descriptor)) => {
2678 excess_byte = unknown_descriptor;
2681 Err(DecodeError::ShortRead) => return Err(DecodeError::BadLengthDescriptor),
2682 Err(e) => return Err(e),
2686 let mut excess_data = vec![];
2687 let excess_address_data = if addr_readpos < addr_len {
2688 let mut excess_address_data = vec![0; (addr_len - addr_readpos) as usize];
2689 r.read_exact(&mut excess_address_data[if excess { 1 } else { 0 }..])?;
2691 excess_address_data[0] = excess_byte;
2696 excess_data.push(excess_byte);
2700 excess_data.extend(read_to_end(r)?.iter());
2701 Ok(UnsignedNodeAnnouncement {
2708 excess_address_data,
2714 impl_writeable!(NodeAnnouncement, {
2719 impl Readable for QueryShortChannelIds {
2720 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2721 let chain_hash: ChainHash = Readable::read(r)?;
2723 let encoding_len: u16 = Readable::read(r)?;
2724 let encoding_type: u8 = Readable::read(r)?;
2726 // Must be encoding_type=0 uncompressed serialization. We do not
2727 // support encoding_type=1 zlib serialization.
2728 if encoding_type != EncodingType::Uncompressed as u8 {
2729 return Err(DecodeError::UnsupportedCompression);
2732 // We expect the encoding_len to always includes the 1-byte
2733 // encoding_type and that short_channel_ids are 8-bytes each
2734 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2735 return Err(DecodeError::InvalidValue);
2738 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2739 // less the 1-byte encoding_type
2740 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2741 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2742 for _ in 0..short_channel_id_count {
2743 short_channel_ids.push(Readable::read(r)?);
2746 Ok(QueryShortChannelIds {
2753 impl Writeable for QueryShortChannelIds {
2754 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2755 // Calculated from 1-byte encoding_type plus 8-bytes per short_channel_id
2756 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2758 self.chain_hash.write(w)?;
2759 encoding_len.write(w)?;
2761 // We only support type=0 uncompressed serialization
2762 (EncodingType::Uncompressed as u8).write(w)?;
2764 for scid in self.short_channel_ids.iter() {
2772 impl_writeable_msg!(ReplyShortChannelIdsEnd, {
2777 impl QueryChannelRange {
2778 /// Calculates the overflow safe ending block height for the query.
2780 /// Overflow returns `0xffffffff`, otherwise returns `first_blocknum + number_of_blocks`.
2781 pub fn end_blocknum(&self) -> u32 {
2782 match self.first_blocknum.checked_add(self.number_of_blocks) {
2783 Some(block) => block,
2784 None => u32::max_value(),
2789 impl_writeable_msg!(QueryChannelRange, {
2795 impl Readable for ReplyChannelRange {
2796 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2797 let chain_hash: ChainHash = Readable::read(r)?;
2798 let first_blocknum: u32 = Readable::read(r)?;
2799 let number_of_blocks: u32 = Readable::read(r)?;
2800 let sync_complete: bool = Readable::read(r)?;
2802 let encoding_len: u16 = Readable::read(r)?;
2803 let encoding_type: u8 = Readable::read(r)?;
2805 // Must be encoding_type=0 uncompressed serialization. We do not
2806 // support encoding_type=1 zlib serialization.
2807 if encoding_type != EncodingType::Uncompressed as u8 {
2808 return Err(DecodeError::UnsupportedCompression);
2811 // We expect the encoding_len to always includes the 1-byte
2812 // encoding_type and that short_channel_ids are 8-bytes each
2813 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2814 return Err(DecodeError::InvalidValue);
2817 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2818 // less the 1-byte encoding_type
2819 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2820 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2821 for _ in 0..short_channel_id_count {
2822 short_channel_ids.push(Readable::read(r)?);
2825 Ok(ReplyChannelRange {
2835 impl Writeable for ReplyChannelRange {
2836 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2837 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2838 self.chain_hash.write(w)?;
2839 self.first_blocknum.write(w)?;
2840 self.number_of_blocks.write(w)?;
2841 self.sync_complete.write(w)?;
2843 encoding_len.write(w)?;
2844 (EncodingType::Uncompressed as u8).write(w)?;
2845 for scid in self.short_channel_ids.iter() {
2853 impl_writeable_msg!(GossipTimestampFilter, {
2861 use std::convert::TryFrom;
2862 use bitcoin::{Transaction, TxIn, ScriptBuf, Sequence, Witness, TxOut};
2863 use hex::DisplayHex;
2864 use crate::ln::{PaymentPreimage, PaymentHash, PaymentSecret};
2865 use crate::ln::ChannelId;
2866 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
2867 use crate::ln::msgs::{self, FinalOnionHopData, OnionErrorPacket};
2868 use crate::ln::msgs::SocketAddress;
2869 use crate::routing::gossip::{NodeAlias, NodeId};
2870 use crate::util::ser::{Writeable, Readable, ReadableArgs, Hostname, TransactionU16LenLimited};
2871 use crate::util::test_utils;
2873 use bitcoin::hashes::hex::FromHex;
2874 use bitcoin::address::Address;
2875 use bitcoin::network::constants::Network;
2876 use bitcoin::blockdata::constants::ChainHash;
2877 use bitcoin::blockdata::script::Builder;
2878 use bitcoin::blockdata::opcodes;
2879 use bitcoin::hash_types::Txid;
2880 use bitcoin::locktime::absolute::LockTime;
2882 use bitcoin::secp256k1::{PublicKey,SecretKey};
2883 use bitcoin::secp256k1::{Secp256k1, Message};
2885 use crate::io::{self, Cursor};
2886 use crate::prelude::*;
2887 use core::str::FromStr;
2888 use crate::chain::transaction::OutPoint;
2890 #[cfg(feature = "std")]
2891 use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6, ToSocketAddrs};
2892 #[cfg(feature = "std")]
2893 use crate::ln::msgs::SocketAddressParseError;
2896 fn encoding_channel_reestablish() {
2898 let secp_ctx = Secp256k1::new();
2899 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&<Vec<u8>>::from_hex("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2902 let cr = msgs::ChannelReestablish {
2903 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]),
2904 next_local_commitment_number: 3,
2905 next_remote_commitment_number: 4,
2906 your_last_per_commitment_secret: [9;32],
2907 my_current_per_commitment_point: public_key,
2908 next_funding_txid: None,
2911 let encoded_value = cr.encode();
2915 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
2916 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2917 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2918 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
2919 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
2925 fn encoding_channel_reestablish_with_next_funding_txid() {
2927 let secp_ctx = Secp256k1::new();
2928 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&<Vec<u8>>::from_hex("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2931 let cr = msgs::ChannelReestablish {
2932 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]),
2933 next_local_commitment_number: 3,
2934 next_remote_commitment_number: 4,
2935 your_last_per_commitment_secret: [9;32],
2936 my_current_per_commitment_point: public_key,
2937 next_funding_txid: Some(Txid::from_raw_hash(bitcoin::hashes::Hash::from_slice(&[
2938 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,
2942 let encoded_value = cr.encode();
2946 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
2947 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2948 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2949 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
2950 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
2951 0, // Type (next_funding_txid)
2953 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
2958 macro_rules! get_keys_from {
2959 ($slice: expr, $secp_ctx: expr) => {
2961 let privkey = SecretKey::from_slice(&<Vec<u8>>::from_hex($slice).unwrap()[..]).unwrap();
2962 let pubkey = PublicKey::from_secret_key(&$secp_ctx, &privkey);
2968 macro_rules! get_sig_on {
2969 ($privkey: expr, $ctx: expr, $string: expr) => {
2971 let sighash = Message::from_slice(&$string.into_bytes()[..]).unwrap();
2972 $ctx.sign_ecdsa(&sighash, &$privkey)
2978 fn encoding_announcement_signatures() {
2979 let secp_ctx = Secp256k1::new();
2980 let (privkey, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2981 let sig_1 = get_sig_on!(privkey, secp_ctx, String::from("01010101010101010101010101010101"));
2982 let sig_2 = get_sig_on!(privkey, secp_ctx, String::from("02020202020202020202020202020202"));
2983 let announcement_signatures = msgs::AnnouncementSignatures {
2984 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]),
2985 short_channel_id: 2316138423780173,
2986 node_signature: sig_1,
2987 bitcoin_signature: sig_2,
2990 let encoded_value = announcement_signatures.encode();
2991 assert_eq!(encoded_value, <Vec<u8>>::from_hex("040000000000000005000000000000000600000000000000070000000000000000083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073acf9953cef4700860f5967838eba2bae89288ad188ebf8b20bf995c3ea53a26df1876d0a3a0e13172ba286a673140190c02ba9da60a2e43a745188c8a83c7f3ef").unwrap());
2994 fn do_encoding_channel_announcement(unknown_features_bits: bool, excess_data: bool) {
2995 let secp_ctx = Secp256k1::new();
2996 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2997 let (privkey_2, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2998 let (privkey_3, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2999 let (privkey_4, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3000 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3001 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
3002 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
3003 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
3004 let mut features = ChannelFeatures::empty();
3005 if unknown_features_bits {
3006 features = ChannelFeatures::from_le_bytes(vec![0xFF, 0xFF]);
3008 let unsigned_channel_announcement = msgs::UnsignedChannelAnnouncement {
3010 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3011 short_channel_id: 2316138423780173,
3012 node_id_1: NodeId::from_pubkey(&pubkey_1),
3013 node_id_2: NodeId::from_pubkey(&pubkey_2),
3014 bitcoin_key_1: NodeId::from_pubkey(&pubkey_3),
3015 bitcoin_key_2: NodeId::from_pubkey(&pubkey_4),
3016 excess_data: if excess_data { vec![10, 0, 0, 20, 0, 0, 30, 0, 0, 40] } else { Vec::new() },
3018 let channel_announcement = msgs::ChannelAnnouncement {
3019 node_signature_1: sig_1,
3020 node_signature_2: sig_2,
3021 bitcoin_signature_1: sig_3,
3022 bitcoin_signature_2: sig_4,
3023 contents: unsigned_channel_announcement,
3025 let encoded_value = channel_announcement.encode();
3026 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a1735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap();
3027 if unknown_features_bits {
3028 target_value.append(&mut <Vec<u8>>::from_hex("0002ffff").unwrap());
3030 target_value.append(&mut <Vec<u8>>::from_hex("0000").unwrap());
3032 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3033 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
3035 target_value.append(&mut <Vec<u8>>::from_hex("0a00001400001e000028").unwrap());
3037 assert_eq!(encoded_value, target_value);
3041 fn encoding_channel_announcement() {
3042 do_encoding_channel_announcement(true, false);
3043 do_encoding_channel_announcement(false, true);
3044 do_encoding_channel_announcement(false, false);
3045 do_encoding_channel_announcement(true, true);
3048 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) {
3049 let secp_ctx = Secp256k1::new();
3050 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3051 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3052 let features = if unknown_features_bits {
3053 NodeFeatures::from_le_bytes(vec![0xFF, 0xFF])
3055 // Set to some features we may support
3056 NodeFeatures::from_le_bytes(vec![2 | 1 << 5])
3058 let mut addresses = Vec::new();
3060 addresses.push(SocketAddress::TcpIpV4 {
3061 addr: [255, 254, 253, 252],
3066 addresses.push(SocketAddress::TcpIpV6 {
3067 addr: [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240],
3072 addresses.push(msgs::SocketAddress::OnionV2(
3073 [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 38, 7]
3077 addresses.push(msgs::SocketAddress::OnionV3 {
3078 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],
3085 addresses.push(SocketAddress::Hostname {
3086 hostname: Hostname::try_from(String::from("host")).unwrap(),
3090 let mut addr_len = 0;
3091 for addr in &addresses {
3092 addr_len += addr.len() + 1;
3094 let unsigned_node_announcement = msgs::UnsignedNodeAnnouncement {
3096 timestamp: 20190119,
3097 node_id: NodeId::from_pubkey(&pubkey_1),
3099 alias: NodeAlias([16;32]),
3101 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() },
3102 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() },
3104 addr_len += unsigned_node_announcement.excess_address_data.len() as u16;
3105 let node_announcement = msgs::NodeAnnouncement {
3107 contents: unsigned_node_announcement,
3109 let encoded_value = node_announcement.encode();
3110 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3111 if unknown_features_bits {
3112 target_value.append(&mut <Vec<u8>>::from_hex("0002ffff").unwrap());
3114 target_value.append(&mut <Vec<u8>>::from_hex("000122").unwrap());
3116 target_value.append(&mut <Vec<u8>>::from_hex("013413a7031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f2020201010101010101010101010101010101010101010101010101010101010101010").unwrap());
3117 target_value.append(&mut vec![(addr_len >> 8) as u8, addr_len as u8]);
3119 target_value.append(&mut <Vec<u8>>::from_hex("01fffefdfc2607").unwrap());
3122 target_value.append(&mut <Vec<u8>>::from_hex("02fffefdfcfbfaf9f8f7f6f5f4f3f2f1f02607").unwrap());
3125 target_value.append(&mut <Vec<u8>>::from_hex("03fffefdfcfbfaf9f8f7f62607").unwrap());
3128 target_value.append(&mut <Vec<u8>>::from_hex("04fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0efeeedecebeae9e8e7e6e5e4e3e2e1e00020102607").unwrap());
3131 target_value.append(&mut <Vec<u8>>::from_hex("0504686f73742607").unwrap());
3133 if excess_address_data {
3134 target_value.append(&mut <Vec<u8>>::from_hex("216c280b5395a2546e7e4b2663e04f811622f15a4f92e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d269").unwrap());
3137 target_value.append(&mut <Vec<u8>>::from_hex("3b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
3139 assert_eq!(encoded_value, target_value);
3143 fn encoding_node_announcement() {
3144 do_encoding_node_announcement(true, true, true, true, true, true, true, true);
3145 do_encoding_node_announcement(false, false, false, false, false, false, false, false);
3146 do_encoding_node_announcement(false, true, false, false, false, false, false, false);
3147 do_encoding_node_announcement(false, false, true, false, false, false, false, false);
3148 do_encoding_node_announcement(false, false, false, true, false, false, false, false);
3149 do_encoding_node_announcement(false, false, false, false, true, false, false, false);
3150 do_encoding_node_announcement(false, false, false, false, false, true, false, false);
3151 do_encoding_node_announcement(false, false, false, false, false, false, true, false);
3152 do_encoding_node_announcement(false, true, false, true, false, false, true, false);
3153 do_encoding_node_announcement(false, false, true, false, true, false, false, false);
3156 fn do_encoding_channel_update(direction: bool, disable: bool, excess_data: bool) {
3157 let secp_ctx = Secp256k1::new();
3158 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3159 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3160 let unsigned_channel_update = msgs::UnsignedChannelUpdate {
3161 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3162 short_channel_id: 2316138423780173,
3163 timestamp: 20190119,
3164 flags: if direction { 1 } else { 0 } | if disable { 1 << 1 } else { 0 },
3165 cltv_expiry_delta: 144,
3166 htlc_minimum_msat: 1000000,
3167 htlc_maximum_msat: 131355275467161,
3168 fee_base_msat: 10000,
3169 fee_proportional_millionths: 20,
3170 excess_data: if excess_data { vec![0, 0, 0, 0, 59, 154, 202, 0] } else { Vec::new() }
3172 let channel_update = msgs::ChannelUpdate {
3174 contents: unsigned_channel_update
3176 let encoded_value = channel_update.encode();
3177 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3178 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3179 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d013413a7").unwrap());
3180 target_value.append(&mut <Vec<u8>>::from_hex("01").unwrap());
3181 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3183 let flag = target_value.last_mut().unwrap();
3187 let flag = target_value.last_mut().unwrap();
3188 *flag = *flag | 1 << 1;
3190 target_value.append(&mut <Vec<u8>>::from_hex("009000000000000f42400000271000000014").unwrap());
3191 target_value.append(&mut <Vec<u8>>::from_hex("0000777788889999").unwrap());
3193 target_value.append(&mut <Vec<u8>>::from_hex("000000003b9aca00").unwrap());
3195 assert_eq!(encoded_value, target_value);
3199 fn encoding_channel_update() {
3200 do_encoding_channel_update(false, false, false);
3201 do_encoding_channel_update(false, false, true);
3202 do_encoding_channel_update(true, false, false);
3203 do_encoding_channel_update(true, false, true);
3204 do_encoding_channel_update(false, true, false);
3205 do_encoding_channel_update(false, true, true);
3206 do_encoding_channel_update(true, true, false);
3207 do_encoding_channel_update(true, true, true);
3210 fn do_encoding_open_channel(random_bit: bool, shutdown: bool, incl_chan_type: bool) {
3211 let secp_ctx = Secp256k1::new();
3212 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3213 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3214 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3215 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3216 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3217 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3218 let open_channel = msgs::OpenChannel {
3219 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3220 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3221 funding_satoshis: 1311768467284833366,
3222 push_msat: 2536655962884945560,
3223 dust_limit_satoshis: 3608586615801332854,
3224 max_htlc_value_in_flight_msat: 8517154655701053848,
3225 channel_reserve_satoshis: 8665828695742877976,
3226 htlc_minimum_msat: 2316138423780173,
3227 feerate_per_kw: 821716,
3228 to_self_delay: 49340,
3229 max_accepted_htlcs: 49340,
3230 funding_pubkey: pubkey_1,
3231 revocation_basepoint: pubkey_2,
3232 payment_point: pubkey_3,
3233 delayed_payment_basepoint: pubkey_4,
3234 htlc_basepoint: pubkey_5,
3235 first_per_commitment_point: pubkey_6,
3236 channel_flags: if random_bit { 1 << 5 } else { 0 },
3237 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3238 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3240 let encoded_value = open_channel.encode();
3241 let mut target_value = Vec::new();
3242 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3243 target_value.append(&mut <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202021234567890123456233403289122369832144668701144767633030896203198784335490624111800083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3245 target_value.append(&mut <Vec<u8>>::from_hex("20").unwrap());
3247 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3250 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3253 target_value.append(&mut <Vec<u8>>::from_hex("0100").unwrap());
3255 assert_eq!(encoded_value, target_value);
3259 fn encoding_open_channel() {
3260 do_encoding_open_channel(false, false, false);
3261 do_encoding_open_channel(false, false, true);
3262 do_encoding_open_channel(false, true, false);
3263 do_encoding_open_channel(false, true, true);
3264 do_encoding_open_channel(true, false, false);
3265 do_encoding_open_channel(true, false, true);
3266 do_encoding_open_channel(true, true, false);
3267 do_encoding_open_channel(true, true, true);
3270 fn do_encoding_open_channelv2(random_bit: bool, shutdown: bool, incl_chan_type: bool, require_confirmed_inputs: bool) {
3271 let secp_ctx = Secp256k1::new();
3272 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3273 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3274 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3275 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3276 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3277 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3278 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3279 let open_channelv2 = msgs::OpenChannelV2 {
3280 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3281 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3282 funding_feerate_sat_per_1000_weight: 821716,
3283 commitment_feerate_sat_per_1000_weight: 821716,
3284 funding_satoshis: 1311768467284833366,
3285 dust_limit_satoshis: 3608586615801332854,
3286 max_htlc_value_in_flight_msat: 8517154655701053848,
3287 htlc_minimum_msat: 2316138423780173,
3288 to_self_delay: 49340,
3289 max_accepted_htlcs: 49340,
3290 locktime: 305419896,
3291 funding_pubkey: pubkey_1,
3292 revocation_basepoint: pubkey_2,
3293 payment_basepoint: pubkey_3,
3294 delayed_payment_basepoint: pubkey_4,
3295 htlc_basepoint: pubkey_5,
3296 first_per_commitment_point: pubkey_6,
3297 second_per_commitment_point: pubkey_7,
3298 channel_flags: if random_bit { 1 << 5 } else { 0 },
3299 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3300 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3301 require_confirmed_inputs: if require_confirmed_inputs { Some(()) } else { None },
3303 let encoded_value = open_channelv2.encode();
3304 let mut target_value = Vec::new();
3305 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3306 target_value.append(&mut <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap());
3307 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap());
3308 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap());
3309 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap());
3310 target_value.append(&mut <Vec<u8>>::from_hex("3214466870114476").unwrap());
3311 target_value.append(&mut <Vec<u8>>::from_hex("7633030896203198").unwrap());
3312 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d").unwrap());
3313 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap());
3314 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap());
3315 target_value.append(&mut <Vec<u8>>::from_hex("12345678").unwrap());
3316 target_value.append(&mut <Vec<u8>>::from_hex("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap());
3317 target_value.append(&mut <Vec<u8>>::from_hex("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap());
3318 target_value.append(&mut <Vec<u8>>::from_hex("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap());
3319 target_value.append(&mut <Vec<u8>>::from_hex("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
3320 target_value.append(&mut <Vec<u8>>::from_hex("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap());
3321 target_value.append(&mut <Vec<u8>>::from_hex("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3322 target_value.append(&mut <Vec<u8>>::from_hex("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap());
3325 target_value.append(&mut <Vec<u8>>::from_hex("20").unwrap());
3327 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3330 target_value.append(&mut <Vec<u8>>::from_hex("001b").unwrap()); // Type 0 + Length 27
3331 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3334 target_value.append(&mut <Vec<u8>>::from_hex("0100").unwrap());
3336 if require_confirmed_inputs {
3337 target_value.append(&mut <Vec<u8>>::from_hex("0200").unwrap());
3339 assert_eq!(encoded_value, target_value);
3343 fn encoding_open_channelv2() {
3344 do_encoding_open_channelv2(false, false, false, false);
3345 do_encoding_open_channelv2(false, false, false, true);
3346 do_encoding_open_channelv2(false, false, true, false);
3347 do_encoding_open_channelv2(false, false, true, true);
3348 do_encoding_open_channelv2(false, true, false, false);
3349 do_encoding_open_channelv2(false, true, false, true);
3350 do_encoding_open_channelv2(false, true, true, false);
3351 do_encoding_open_channelv2(false, true, true, true);
3352 do_encoding_open_channelv2(true, false, false, false);
3353 do_encoding_open_channelv2(true, false, false, true);
3354 do_encoding_open_channelv2(true, false, true, false);
3355 do_encoding_open_channelv2(true, false, true, true);
3356 do_encoding_open_channelv2(true, true, false, false);
3357 do_encoding_open_channelv2(true, true, false, true);
3358 do_encoding_open_channelv2(true, true, true, false);
3359 do_encoding_open_channelv2(true, true, true, true);
3362 fn do_encoding_accept_channel(shutdown: bool) {
3363 let secp_ctx = Secp256k1::new();
3364 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3365 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3366 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3367 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3368 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3369 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3370 let accept_channel = msgs::AcceptChannel {
3371 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3372 dust_limit_satoshis: 1311768467284833366,
3373 max_htlc_value_in_flight_msat: 2536655962884945560,
3374 channel_reserve_satoshis: 3608586615801332854,
3375 htlc_minimum_msat: 2316138423780173,
3376 minimum_depth: 821716,
3377 to_self_delay: 49340,
3378 max_accepted_htlcs: 49340,
3379 funding_pubkey: pubkey_1,
3380 revocation_basepoint: pubkey_2,
3381 payment_point: pubkey_3,
3382 delayed_payment_basepoint: pubkey_4,
3383 htlc_basepoint: pubkey_5,
3384 first_per_commitment_point: pubkey_6,
3385 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3388 next_local_nonce: None,
3390 let encoded_value = accept_channel.encode();
3391 let mut target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020212345678901234562334032891223698321446687011447600083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap();
3393 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3395 assert_eq!(encoded_value, target_value);
3399 fn encoding_accept_channel() {
3400 do_encoding_accept_channel(false);
3401 do_encoding_accept_channel(true);
3404 fn do_encoding_accept_channelv2(shutdown: bool) {
3405 let secp_ctx = Secp256k1::new();
3406 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3407 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3408 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3409 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3410 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3411 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3412 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3413 let accept_channelv2 = msgs::AcceptChannelV2 {
3414 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3415 funding_satoshis: 1311768467284833366,
3416 dust_limit_satoshis: 1311768467284833366,
3417 max_htlc_value_in_flight_msat: 2536655962884945560,
3418 htlc_minimum_msat: 2316138423780173,
3419 minimum_depth: 821716,
3420 to_self_delay: 49340,
3421 max_accepted_htlcs: 49340,
3422 funding_pubkey: pubkey_1,
3423 revocation_basepoint: pubkey_2,
3424 payment_basepoint: pubkey_3,
3425 delayed_payment_basepoint: pubkey_4,
3426 htlc_basepoint: pubkey_5,
3427 first_per_commitment_point: pubkey_6,
3428 second_per_commitment_point: pubkey_7,
3429 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3431 require_confirmed_inputs: None,
3433 let encoded_value = accept_channelv2.encode();
3434 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // temporary_channel_id
3435 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap()); // funding_satoshis
3436 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap()); // dust_limit_satoshis
3437 target_value.append(&mut <Vec<u8>>::from_hex("2334032891223698").unwrap()); // max_htlc_value_in_flight_msat
3438 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d").unwrap()); // htlc_minimum_msat
3439 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap()); // minimum_depth
3440 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap()); // to_self_delay
3441 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap()); // max_accepted_htlcs
3442 target_value.append(&mut <Vec<u8>>::from_hex("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap()); // funding_pubkey
3443 target_value.append(&mut <Vec<u8>>::from_hex("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap()); // revocation_basepoint
3444 target_value.append(&mut <Vec<u8>>::from_hex("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap()); // payment_basepoint
3445 target_value.append(&mut <Vec<u8>>::from_hex("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap()); // delayed_payment_basepoint
3446 target_value.append(&mut <Vec<u8>>::from_hex("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap()); // htlc_basepoint
3447 target_value.append(&mut <Vec<u8>>::from_hex("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap()); // first_per_commitment_point
3448 target_value.append(&mut <Vec<u8>>::from_hex("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap()); // second_per_commitment_point
3450 target_value.append(&mut <Vec<u8>>::from_hex("001b").unwrap()); // Type 0 + Length 27
3451 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3453 assert_eq!(encoded_value, target_value);
3457 fn encoding_accept_channelv2() {
3458 do_encoding_accept_channelv2(false);
3459 do_encoding_accept_channelv2(true);
3463 fn encoding_funding_created() {
3464 let secp_ctx = Secp256k1::new();
3465 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3466 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3467 let funding_created = msgs::FundingCreated {
3468 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3469 funding_txid: Txid::from_str("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3470 funding_output_index: 255,
3473 partial_signature_with_nonce: None,
3475 next_local_nonce: None,
3477 let encoded_value = funding_created.encode();
3478 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202026e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c200ffd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3479 assert_eq!(encoded_value, target_value);
3483 fn encoding_funding_signed() {
3484 let secp_ctx = Secp256k1::new();
3485 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3486 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3487 let funding_signed = msgs::FundingSigned {
3488 channel_id: ChannelId::from_bytes([2; 32]),
3491 partial_signature_with_nonce: None,
3493 let encoded_value = funding_signed.encode();
3494 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3495 assert_eq!(encoded_value, target_value);
3499 fn encoding_channel_ready() {
3500 let secp_ctx = Secp256k1::new();
3501 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3502 let channel_ready = msgs::ChannelReady {
3503 channel_id: ChannelId::from_bytes([2; 32]),
3504 next_per_commitment_point: pubkey_1,
3505 short_channel_id_alias: None,
3507 let encoded_value = channel_ready.encode();
3508 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3509 assert_eq!(encoded_value, target_value);
3513 fn encoding_splice() {
3514 let secp_ctx = Secp256k1::new();
3515 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3516 let splice = msgs::Splice {
3517 chain_hash: ChainHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
3518 channel_id: ChannelId::from_bytes([2; 32]),
3519 relative_satoshis: 123456,
3520 funding_feerate_perkw: 2000,
3522 funding_pubkey: pubkey_1,
3524 let encoded_value = splice.encode();
3525 assert_eq!(encoded_value.as_hex().to_string(), "02020202020202020202020202020202020202020202020202020202020202026fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000000000000001e240000007d000000000031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f");
3529 fn encoding_stfu() {
3530 let stfu = msgs::Stfu {
3531 channel_id: ChannelId::from_bytes([2; 32]),
3534 let encoded_value = stfu.encode();
3535 assert_eq!(encoded_value.as_hex().to_string(), "020202020202020202020202020202020202020202020202020202020202020201");
3539 fn encoding_splice_ack() {
3540 let secp_ctx = Secp256k1::new();
3541 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3542 let splice = msgs::SpliceAck {
3543 chain_hash: ChainHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
3544 channel_id: ChannelId::from_bytes([2; 32]),
3545 relative_satoshis: 123456,
3546 funding_pubkey: pubkey_1,
3548 let encoded_value = splice.encode();
3549 assert_eq!(encoded_value.as_hex().to_string(), "02020202020202020202020202020202020202020202020202020202020202026fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000000000000001e240031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f");
3553 fn encoding_splice_locked() {
3554 let splice = msgs::SpliceLocked {
3555 channel_id: ChannelId::from_bytes([2; 32]),
3557 let encoded_value = splice.encode();
3558 assert_eq!(encoded_value.as_hex().to_string(), "0202020202020202020202020202020202020202020202020202020202020202");
3562 fn encoding_tx_add_input() {
3563 let tx_add_input = msgs::TxAddInput {
3564 channel_id: ChannelId::from_bytes([2; 32]),
3565 serial_id: 4886718345,
3566 prevtx: TransactionU16LenLimited::new(Transaction {
3568 lock_time: LockTime::ZERO,
3570 previous_output: OutPoint { txid: Txid::from_str("305bab643ee297b8b6b76b320792c8223d55082122cb606bf89382146ced9c77").unwrap(), index: 2 }.into_bitcoin_outpoint(),
3571 script_sig: ScriptBuf::new(),
3572 sequence: Sequence(0xfffffffd),
3573 witness: Witness::from_slice(&vec![
3574 <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3575 <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3580 script_pubkey: Address::from_str("bc1qzlffunw52jav8vwdu5x3jfk6sr8u22rmq3xzw2").unwrap().payload.script_pubkey(),
3584 script_pubkey: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().payload.script_pubkey(),
3588 prevtx_out: 305419896,
3589 sequence: 305419896,
3591 let encoded_value = tx_add_input.encode();
3592 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000000012345678900de02000000000101779ced6c148293f86b60cb222108553d22c89207326bb7b6b897e23e64ab5b300200000000fdffffff0236dbc1000000000016001417d29e4dd454bac3b1cde50d1926da80cfc5287b9cbd03000000000016001436ec78d514df462da95e6a00c24daa8915362d420247304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701210301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944000000001234567812345678").unwrap();
3593 assert_eq!(encoded_value, target_value);
3597 fn encoding_tx_add_output() {
3598 let tx_add_output = msgs::TxAddOutput {
3599 channel_id: ChannelId::from_bytes([2; 32]),
3600 serial_id: 4886718345,
3602 script: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().payload.script_pubkey(),
3604 let encoded_value = tx_add_output.encode();
3605 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000000012345678900000001234567890016001436ec78d514df462da95e6a00c24daa8915362d42").unwrap();
3606 assert_eq!(encoded_value, target_value);
3610 fn encoding_tx_remove_input() {
3611 let tx_remove_input = msgs::TxRemoveInput {
3612 channel_id: ChannelId::from_bytes([2; 32]),
3613 serial_id: 4886718345,
3615 let encoded_value = tx_remove_input.encode();
3616 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3617 assert_eq!(encoded_value, target_value);
3621 fn encoding_tx_remove_output() {
3622 let tx_remove_output = msgs::TxRemoveOutput {
3623 channel_id: ChannelId::from_bytes([2; 32]),
3624 serial_id: 4886718345,
3626 let encoded_value = tx_remove_output.encode();
3627 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3628 assert_eq!(encoded_value, target_value);
3632 fn encoding_tx_complete() {
3633 let tx_complete = msgs::TxComplete {
3634 channel_id: ChannelId::from_bytes([2; 32]),
3636 let encoded_value = tx_complete.encode();
3637 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3638 assert_eq!(encoded_value, target_value);
3642 fn encoding_tx_signatures() {
3643 let tx_signatures = msgs::TxSignatures {
3644 channel_id: ChannelId::from_bytes([2; 32]),
3645 tx_hash: Txid::from_str("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3647 Witness::from_slice(&vec![
3648 <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3649 <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3650 Witness::from_slice(&vec![
3651 <Vec<u8>>::from_hex("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap(),
3652 <Vec<u8>>::from_hex("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap()]),
3655 let encoded_value = tx_signatures.encode();
3656 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3657 target_value.append(&mut <Vec<u8>>::from_hex("6e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c2").unwrap()); // tx_hash (sha256) (big endian byte order)
3658 target_value.append(&mut <Vec<u8>>::from_hex("0002").unwrap()); // num_witnesses (u16)
3660 target_value.append(&mut <Vec<u8>>::from_hex("006b").unwrap()); // len of witness_data
3661 target_value.append(&mut <Vec<u8>>::from_hex("02").unwrap()); // num_witness_elements (VarInt)
3662 target_value.append(&mut <Vec<u8>>::from_hex("47").unwrap()); // len of witness element data (VarInt)
3663 target_value.append(&mut <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap());
3664 target_value.append(&mut <Vec<u8>>::from_hex("21").unwrap()); // len of witness element data (VarInt)
3665 target_value.append(&mut <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap());
3667 target_value.append(&mut <Vec<u8>>::from_hex("006c").unwrap()); // len of witness_data
3668 target_value.append(&mut <Vec<u8>>::from_hex("02").unwrap()); // num_witness_elements (VarInt)
3669 target_value.append(&mut <Vec<u8>>::from_hex("48").unwrap()); // len of witness element data (VarInt)
3670 target_value.append(&mut <Vec<u8>>::from_hex("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap());
3671 target_value.append(&mut <Vec<u8>>::from_hex("21").unwrap()); // len of witness element data (VarInt)
3672 target_value.append(&mut <Vec<u8>>::from_hex("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap());
3673 assert_eq!(encoded_value, target_value);
3676 fn do_encoding_tx_init_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3677 let tx_init_rbf = msgs::TxInitRbf {
3678 channel_id: ChannelId::from_bytes([2; 32]),
3679 locktime: 305419896,
3680 feerate_sat_per_1000_weight: 20190119,
3681 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3683 let encoded_value = tx_init_rbf.encode();
3684 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3685 target_value.append(&mut <Vec<u8>>::from_hex("12345678").unwrap()); // locktime
3686 target_value.append(&mut <Vec<u8>>::from_hex("013413a7").unwrap()); // feerate_sat_per_1000_weight
3687 if let Some((_, target)) = funding_value_with_hex_target {
3688 target_value.push(0x00); // Type
3689 target_value.push(target.len() as u8 / 2); // Length
3690 target_value.append(&mut <Vec<u8>>::from_hex(target).unwrap()); // Value (i64)
3692 assert_eq!(encoded_value, target_value);
3696 fn encoding_tx_init_rbf() {
3697 do_encoding_tx_init_rbf(Some((1311768467284833366, "1234567890123456")));
3698 do_encoding_tx_init_rbf(Some((13117684672, "000000030DDFFBC0")));
3699 do_encoding_tx_init_rbf(None);
3702 fn do_encoding_tx_ack_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3703 let tx_ack_rbf = msgs::TxAckRbf {
3704 channel_id: ChannelId::from_bytes([2; 32]),
3705 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3707 let encoded_value = tx_ack_rbf.encode();
3708 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3709 if let Some((_, target)) = funding_value_with_hex_target {
3710 target_value.push(0x00); // Type
3711 target_value.push(target.len() as u8 / 2); // Length
3712 target_value.append(&mut <Vec<u8>>::from_hex(target).unwrap()); // Value (i64)
3714 assert_eq!(encoded_value, target_value);
3718 fn encoding_tx_ack_rbf() {
3719 do_encoding_tx_ack_rbf(Some((1311768467284833366, "1234567890123456")));
3720 do_encoding_tx_ack_rbf(Some((13117684672, "000000030DDFFBC0")));
3721 do_encoding_tx_ack_rbf(None);
3725 fn encoding_tx_abort() {
3726 let tx_abort = msgs::TxAbort {
3727 channel_id: ChannelId::from_bytes([2; 32]),
3728 data: <Vec<u8>>::from_hex("54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap(),
3730 let encoded_value = tx_abort.encode();
3731 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202002C54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap();
3732 assert_eq!(encoded_value, target_value);
3735 fn do_encoding_shutdown(script_type: u8) {
3736 let secp_ctx = Secp256k1::new();
3737 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3738 let script = Builder::new().push_opcode(opcodes::OP_TRUE).into_script();
3739 let shutdown = msgs::Shutdown {
3740 channel_id: ChannelId::from_bytes([2; 32]),
3742 if script_type == 1 { Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey() }
3743 else if script_type == 2 { Address::p2sh(&script, Network::Testnet).unwrap().script_pubkey() }
3744 else if script_type == 3 { Address::p2wpkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).unwrap().script_pubkey() }
3745 else { Address::p2wsh(&script, Network::Testnet).script_pubkey() },
3747 let encoded_value = shutdown.encode();
3748 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3749 if script_type == 1 {
3750 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3751 } else if script_type == 2 {
3752 target_value.append(&mut <Vec<u8>>::from_hex("0017a914da1745e9b549bd0bfa1a569971c77eba30cd5a4b87").unwrap());
3753 } else if script_type == 3 {
3754 target_value.append(&mut <Vec<u8>>::from_hex("0016001479b000887626b294a914501a4cd226b58b235983").unwrap());
3755 } else if script_type == 4 {
3756 target_value.append(&mut <Vec<u8>>::from_hex("002200204ae81572f06e1b88fd5ced7a1a000945432e83e1551e6f721ee9c00b8cc33260").unwrap());
3758 assert_eq!(encoded_value, target_value);
3762 fn encoding_shutdown() {
3763 do_encoding_shutdown(1);
3764 do_encoding_shutdown(2);
3765 do_encoding_shutdown(3);
3766 do_encoding_shutdown(4);
3770 fn encoding_closing_signed() {
3771 let secp_ctx = Secp256k1::new();
3772 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3773 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3774 let closing_signed = msgs::ClosingSigned {
3775 channel_id: ChannelId::from_bytes([2; 32]),
3776 fee_satoshis: 2316138423780173,
3780 let encoded_value = closing_signed.encode();
3781 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3782 assert_eq!(encoded_value, target_value);
3783 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value)).unwrap(), closing_signed);
3785 let closing_signed_with_range = msgs::ClosingSigned {
3786 channel_id: ChannelId::from_bytes([2; 32]),
3787 fee_satoshis: 2316138423780173,
3789 fee_range: Some(msgs::ClosingSignedFeeRange {
3790 min_fee_satoshis: 0xdeadbeef,
3791 max_fee_satoshis: 0x1badcafe01234567,
3794 let encoded_value_with_range = closing_signed_with_range.encode();
3795 let target_value_with_range = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a011000000000deadbeef1badcafe01234567").unwrap();
3796 assert_eq!(encoded_value_with_range, target_value_with_range);
3797 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value_with_range)).unwrap(),
3798 closing_signed_with_range);
3802 fn encoding_update_add_htlc() {
3803 let secp_ctx = Secp256k1::new();
3804 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3805 let onion_routing_packet = msgs::OnionPacket {
3807 public_key: Ok(pubkey_1),
3808 hop_data: [1; 20*65],
3811 let update_add_htlc = msgs::UpdateAddHTLC {
3812 channel_id: ChannelId::from_bytes([2; 32]),
3813 htlc_id: 2316138423780173,
3814 amount_msat: 3608586615801332854,
3815 payment_hash: PaymentHash([1; 32]),
3816 cltv_expiry: 821716,
3817 onion_routing_packet,
3818 skimmed_fee_msat: None,
3819 blinding_point: None,
3821 let encoded_value = update_add_htlc.encode();
3822 let target_value = <Vec<u8>>::from_hex("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").unwrap();
3823 assert_eq!(encoded_value, target_value);
3827 fn encoding_update_fulfill_htlc() {
3828 let update_fulfill_htlc = msgs::UpdateFulfillHTLC {
3829 channel_id: ChannelId::from_bytes([2; 32]),
3830 htlc_id: 2316138423780173,
3831 payment_preimage: PaymentPreimage([1; 32]),
3833 let encoded_value = update_fulfill_htlc.encode();
3834 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d0101010101010101010101010101010101010101010101010101010101010101").unwrap();
3835 assert_eq!(encoded_value, target_value);
3839 fn encoding_update_fail_htlc() {
3840 let reason = OnionErrorPacket {
3841 data: [1; 32].to_vec(),
3843 let update_fail_htlc = msgs::UpdateFailHTLC {
3844 channel_id: ChannelId::from_bytes([2; 32]),
3845 htlc_id: 2316138423780173,
3848 let encoded_value = update_fail_htlc.encode();
3849 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d00200101010101010101010101010101010101010101010101010101010101010101").unwrap();
3850 assert_eq!(encoded_value, target_value);
3854 fn encoding_update_fail_malformed_htlc() {
3855 let update_fail_malformed_htlc = msgs::UpdateFailMalformedHTLC {
3856 channel_id: ChannelId::from_bytes([2; 32]),
3857 htlc_id: 2316138423780173,
3858 sha256_of_onion: [1; 32],
3861 let encoded_value = update_fail_malformed_htlc.encode();
3862 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d010101010101010101010101010101010101010101010101010101010101010100ff").unwrap();
3863 assert_eq!(encoded_value, target_value);
3866 fn do_encoding_commitment_signed(htlcs: bool) {
3867 let secp_ctx = Secp256k1::new();
3868 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3869 let (privkey_2, _) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3870 let (privkey_3, _) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3871 let (privkey_4, _) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3872 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3873 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
3874 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
3875 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
3876 let commitment_signed = msgs::CommitmentSigned {
3877 channel_id: ChannelId::from_bytes([2; 32]),
3879 htlc_signatures: if htlcs { vec![sig_2, sig_3, sig_4] } else { Vec::new() },
3881 partial_signature_with_nonce: None,
3883 let encoded_value = commitment_signed.encode();
3884 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3886 target_value.append(&mut <Vec<u8>>::from_hex("00031735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
3888 target_value.append(&mut <Vec<u8>>::from_hex("0000").unwrap());
3890 assert_eq!(encoded_value, target_value);
3894 fn encoding_commitment_signed() {
3895 do_encoding_commitment_signed(true);
3896 do_encoding_commitment_signed(false);
3900 fn encoding_revoke_and_ack() {
3901 let secp_ctx = Secp256k1::new();
3902 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3903 let raa = msgs::RevokeAndACK {
3904 channel_id: ChannelId::from_bytes([2; 32]),
3905 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],
3906 next_per_commitment_point: pubkey_1,
3908 next_local_nonce: None,
3910 let encoded_value = raa.encode();
3911 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020101010101010101010101010101010101010101010101010101010101010101031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3912 assert_eq!(encoded_value, target_value);
3916 fn encoding_update_fee() {
3917 let update_fee = msgs::UpdateFee {
3918 channel_id: ChannelId::from_bytes([2; 32]),
3919 feerate_per_kw: 20190119,
3921 let encoded_value = update_fee.encode();
3922 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202013413a7").unwrap();
3923 assert_eq!(encoded_value, target_value);
3927 fn encoding_init() {
3928 let mainnet_hash = ChainHash::using_genesis_block(Network::Bitcoin);
3929 assert_eq!(msgs::Init {
3930 features: InitFeatures::from_le_bytes(vec![0xFF, 0xFF, 0xFF]),
3931 networks: Some(vec![mainnet_hash]),
3932 remote_network_address: None,
3933 }.encode(), <Vec<u8>>::from_hex("00023fff0003ffffff01206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3934 assert_eq!(msgs::Init {
3935 features: InitFeatures::from_le_bytes(vec![0xFF]),
3937 remote_network_address: None,
3938 }.encode(), <Vec<u8>>::from_hex("0001ff0001ff").unwrap());
3939 assert_eq!(msgs::Init {
3940 features: InitFeatures::from_le_bytes(vec![]),
3941 networks: Some(vec![mainnet_hash]),
3942 remote_network_address: None,
3943 }.encode(), <Vec<u8>>::from_hex("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3944 assert_eq!(msgs::Init {
3945 features: InitFeatures::from_le_bytes(vec![]),
3946 networks: Some(vec![ChainHash::from(&[1; 32]), ChainHash::from(&[2; 32])]),
3947 remote_network_address: None,
3948 }.encode(), <Vec<u8>>::from_hex("00000000014001010101010101010101010101010101010101010101010101010101010101010202020202020202020202020202020202020202020202020202020202020202").unwrap());
3949 let init_msg = msgs::Init { features: InitFeatures::from_le_bytes(vec![]),
3950 networks: Some(vec![mainnet_hash]),
3951 remote_network_address: Some(SocketAddress::TcpIpV4 {
3952 addr: [127, 0, 0, 1],
3956 let encoded_value = init_msg.encode();
3957 let target_value = <Vec<u8>>::from_hex("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d61900000000000307017f00000103e8").unwrap();
3958 assert_eq!(encoded_value, target_value);
3959 assert_eq!(msgs::Init::read(&mut Cursor::new(&target_value)).unwrap(), init_msg);
3963 fn encoding_error() {
3964 let error = msgs::ErrorMessage {
3965 channel_id: ChannelId::from_bytes([2; 32]),
3966 data: String::from("rust-lightning"),
3968 let encoded_value = error.encode();
3969 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3970 assert_eq!(encoded_value, target_value);
3974 fn encoding_warning() {
3975 let error = msgs::WarningMessage {
3976 channel_id: ChannelId::from_bytes([2; 32]),
3977 data: String::from("rust-lightning"),
3979 let encoded_value = error.encode();
3980 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3981 assert_eq!(encoded_value, target_value);
3985 fn encoding_ping() {
3986 let ping = msgs::Ping {
3990 let encoded_value = ping.encode();
3991 let target_value = <Vec<u8>>::from_hex("0040004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3992 assert_eq!(encoded_value, target_value);
3996 fn encoding_pong() {
3997 let pong = msgs::Pong {
4000 let encoded_value = pong.encode();
4001 let target_value = <Vec<u8>>::from_hex("004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
4002 assert_eq!(encoded_value, target_value);
4006 fn encoding_nonfinal_onion_hop_data() {
4007 let outbound_msg = msgs::OutboundOnionPayload::Forward {
4008 short_channel_id: 0xdeadbeef1bad1dea,
4009 amt_to_forward: 0x0badf00d01020304,
4010 outgoing_cltv_value: 0xffffffff,
4012 let encoded_value = outbound_msg.encode();
4013 let target_value = <Vec<u8>>::from_hex("1a02080badf00d010203040404ffffffff0608deadbeef1bad1dea").unwrap();
4014 assert_eq!(encoded_value, target_value);
4016 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4017 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4018 if let msgs::InboundOnionPayload::Forward {
4019 short_channel_id, amt_to_forward, outgoing_cltv_value
4021 assert_eq!(short_channel_id, 0xdeadbeef1bad1dea);
4022 assert_eq!(amt_to_forward, 0x0badf00d01020304);
4023 assert_eq!(outgoing_cltv_value, 0xffffffff);
4024 } else { panic!(); }
4028 fn encoding_final_onion_hop_data() {
4029 let outbound_msg = msgs::OutboundOnionPayload::Receive {
4031 payment_metadata: None,
4032 keysend_preimage: None,
4033 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4034 cltv_expiry_height: 0xffffffff,
4035 custom_tlvs: vec![],
4037 let encoded_value = outbound_msg.encode();
4038 let target_value = <Vec<u8>>::from_hex("1002080badf00d010203040404ffffffff").unwrap();
4039 assert_eq!(encoded_value, target_value);
4041 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4042 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4043 if let msgs::InboundOnionPayload::Receive {
4044 payment_data: None, sender_intended_htlc_amt_msat, cltv_expiry_height, ..
4046 assert_eq!(sender_intended_htlc_amt_msat, 0x0badf00d01020304);
4047 assert_eq!(cltv_expiry_height, 0xffffffff);
4048 } else { panic!(); }
4052 fn encoding_final_onion_hop_data_with_secret() {
4053 let expected_payment_secret = PaymentSecret([0x42u8; 32]);
4054 let outbound_msg = msgs::OutboundOnionPayload::Receive {
4055 payment_data: Some(FinalOnionHopData {
4056 payment_secret: expected_payment_secret,
4057 total_msat: 0x1badca1f
4059 payment_metadata: None,
4060 keysend_preimage: None,
4061 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4062 cltv_expiry_height: 0xffffffff,
4063 custom_tlvs: vec![],
4065 let encoded_value = outbound_msg.encode();
4066 let target_value = <Vec<u8>>::from_hex("3602080badf00d010203040404ffffffff082442424242424242424242424242424242424242424242424242424242424242421badca1f").unwrap();
4067 assert_eq!(encoded_value, target_value);
4069 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4070 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4071 if let msgs::InboundOnionPayload::Receive {
4072 payment_data: Some(FinalOnionHopData {
4074 total_msat: 0x1badca1f
4076 sender_intended_htlc_amt_msat, cltv_expiry_height,
4077 payment_metadata: None,
4078 keysend_preimage: None,
4081 assert_eq!(payment_secret, expected_payment_secret);
4082 assert_eq!(sender_intended_htlc_amt_msat, 0x0badf00d01020304);
4083 assert_eq!(cltv_expiry_height, 0xffffffff);
4084 assert_eq!(custom_tlvs, vec![]);
4085 } else { panic!(); }
4089 fn encoding_final_onion_hop_data_with_bad_custom_tlvs() {
4090 // If custom TLVs have type number within the range reserved for protocol, treat them as if
4092 let bad_type_range_tlvs = vec![
4093 ((1 << 16) - 4, vec![42]),
4094 ((1 << 16) - 2, vec![42; 32]),
4096 let mut msg = msgs::OutboundOnionPayload::Receive {
4098 payment_metadata: None,
4099 keysend_preimage: None,
4100 custom_tlvs: bad_type_range_tlvs,
4101 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4102 cltv_expiry_height: 0xffffffff,
4104 let encoded_value = msg.encode();
4105 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4106 assert!(msgs::InboundOnionPayload::read(&mut Cursor::new(&encoded_value[..]), (None, &&node_signer)).is_err());
4107 let good_type_range_tlvs = vec![
4108 ((1 << 16) - 3, vec![42]),
4109 ((1 << 16) - 1, vec![42; 32]),
4111 if let msgs::OutboundOnionPayload::Receive { ref mut custom_tlvs, .. } = msg {
4112 *custom_tlvs = good_type_range_tlvs.clone();
4114 let encoded_value = msg.encode();
4115 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&encoded_value[..]), (None, &&node_signer)).unwrap();
4117 msgs::InboundOnionPayload::Receive { custom_tlvs, .. } => assert!(custom_tlvs.is_empty()),
4123 fn encoding_final_onion_hop_data_with_custom_tlvs() {
4124 let expected_custom_tlvs = vec![
4125 (5482373483, vec![0x12, 0x34]),
4126 (5482373487, vec![0x42u8; 8]),
4128 let msg = msgs::OutboundOnionPayload::Receive {
4130 payment_metadata: None,
4131 keysend_preimage: None,
4132 custom_tlvs: expected_custom_tlvs.clone(),
4133 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4134 cltv_expiry_height: 0xffffffff,
4136 let encoded_value = msg.encode();
4137 let target_value = <Vec<u8>>::from_hex("2e02080badf00d010203040404ffffffffff0000000146c6616b021234ff0000000146c6616f084242424242424242").unwrap();
4138 assert_eq!(encoded_value, target_value);
4139 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4140 let inbound_msg: msgs::InboundOnionPayload = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4141 if let msgs::InboundOnionPayload::Receive {
4143 payment_metadata: None,
4144 keysend_preimage: None,
4146 sender_intended_htlc_amt_msat,
4147 cltv_expiry_height: outgoing_cltv_value,
4150 assert_eq!(custom_tlvs, expected_custom_tlvs);
4151 assert_eq!(sender_intended_htlc_amt_msat, 0x0badf00d01020304);
4152 assert_eq!(outgoing_cltv_value, 0xffffffff);
4153 } else { panic!(); }
4157 fn query_channel_range_end_blocknum() {
4158 let tests: Vec<(u32, u32, u32)> = vec![
4159 (10000, 1500, 11500),
4160 (0, 0xffffffff, 0xffffffff),
4161 (1, 0xffffffff, 0xffffffff),
4164 for (first_blocknum, number_of_blocks, expected) in tests.into_iter() {
4165 let sut = msgs::QueryChannelRange {
4166 chain_hash: ChainHash::using_genesis_block(Network::Regtest),
4170 assert_eq!(sut.end_blocknum(), expected);
4175 fn encoding_query_channel_range() {
4176 let mut query_channel_range = msgs::QueryChannelRange {
4177 chain_hash: ChainHash::using_genesis_block(Network::Regtest),
4178 first_blocknum: 100000,
4179 number_of_blocks: 1500,
4181 let encoded_value = query_channel_range.encode();
4182 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000186a0000005dc").unwrap();
4183 assert_eq!(encoded_value, target_value);
4185 query_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4186 assert_eq!(query_channel_range.first_blocknum, 100000);
4187 assert_eq!(query_channel_range.number_of_blocks, 1500);
4191 fn encoding_reply_channel_range() {
4192 do_encoding_reply_channel_range(0);
4193 do_encoding_reply_channel_range(1);
4196 fn do_encoding_reply_channel_range(encoding_type: u8) {
4197 let mut target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000b8a06000005dc01").unwrap();
4198 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4199 let mut reply_channel_range = msgs::ReplyChannelRange {
4200 chain_hash: expected_chain_hash,
4201 first_blocknum: 756230,
4202 number_of_blocks: 1500,
4203 sync_complete: true,
4204 short_channel_ids: vec![0x000000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
4207 if encoding_type == 0 {
4208 target_value.append(&mut <Vec<u8>>::from_hex("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
4209 let encoded_value = reply_channel_range.encode();
4210 assert_eq!(encoded_value, target_value);
4212 reply_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4213 assert_eq!(reply_channel_range.chain_hash, expected_chain_hash);
4214 assert_eq!(reply_channel_range.first_blocknum, 756230);
4215 assert_eq!(reply_channel_range.number_of_blocks, 1500);
4216 assert_eq!(reply_channel_range.sync_complete, true);
4217 assert_eq!(reply_channel_range.short_channel_ids[0], 0x000000000000008e);
4218 assert_eq!(reply_channel_range.short_channel_ids[1], 0x0000000000003c69);
4219 assert_eq!(reply_channel_range.short_channel_ids[2], 0x000000000045a6c4);
4221 target_value.append(&mut <Vec<u8>>::from_hex("001601789c636000833e08659309a65878be010010a9023a").unwrap());
4222 let result: Result<msgs::ReplyChannelRange, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
4223 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
4228 fn encoding_query_short_channel_ids() {
4229 do_encoding_query_short_channel_ids(0);
4230 do_encoding_query_short_channel_ids(1);
4233 fn do_encoding_query_short_channel_ids(encoding_type: u8) {
4234 let mut target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
4235 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4236 let mut query_short_channel_ids = msgs::QueryShortChannelIds {
4237 chain_hash: expected_chain_hash,
4238 short_channel_ids: vec![0x0000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
4241 if encoding_type == 0 {
4242 target_value.append(&mut <Vec<u8>>::from_hex("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
4243 let encoded_value = query_short_channel_ids.encode();
4244 assert_eq!(encoded_value, target_value);
4246 query_short_channel_ids = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4247 assert_eq!(query_short_channel_ids.chain_hash, expected_chain_hash);
4248 assert_eq!(query_short_channel_ids.short_channel_ids[0], 0x000000000000008e);
4249 assert_eq!(query_short_channel_ids.short_channel_ids[1], 0x0000000000003c69);
4250 assert_eq!(query_short_channel_ids.short_channel_ids[2], 0x000000000045a6c4);
4252 target_value.append(&mut <Vec<u8>>::from_hex("001601789c636000833e08659309a65878be010010a9023a").unwrap());
4253 let result: Result<msgs::QueryShortChannelIds, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
4254 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
4259 fn encoding_reply_short_channel_ids_end() {
4260 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4261 let mut reply_short_channel_ids_end = msgs::ReplyShortChannelIdsEnd {
4262 chain_hash: expected_chain_hash,
4263 full_information: true,
4265 let encoded_value = reply_short_channel_ids_end.encode();
4266 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f01").unwrap();
4267 assert_eq!(encoded_value, target_value);
4269 reply_short_channel_ids_end = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4270 assert_eq!(reply_short_channel_ids_end.chain_hash, expected_chain_hash);
4271 assert_eq!(reply_short_channel_ids_end.full_information, true);
4275 fn encoding_gossip_timestamp_filter(){
4276 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4277 let mut gossip_timestamp_filter = msgs::GossipTimestampFilter {
4278 chain_hash: expected_chain_hash,
4279 first_timestamp: 1590000000,
4280 timestamp_range: 0xffff_ffff,
4282 let encoded_value = gossip_timestamp_filter.encode();
4283 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f5ec57980ffffffff").unwrap();
4284 assert_eq!(encoded_value, target_value);
4286 gossip_timestamp_filter = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4287 assert_eq!(gossip_timestamp_filter.chain_hash, expected_chain_hash);
4288 assert_eq!(gossip_timestamp_filter.first_timestamp, 1590000000);
4289 assert_eq!(gossip_timestamp_filter.timestamp_range, 0xffff_ffff);
4293 fn decode_onion_hop_data_len_as_bigsize() {
4294 // Tests that we can decode an onion payload that is >253 bytes.
4295 // Previously, receiving a payload of this size could've caused us to fail to decode a valid
4296 // payload, because we were decoding the length (a BigSize, big-endian) as a VarInt
4299 // Encode a test onion payload with a big custom TLV such that it's >253 bytes, forcing the
4300 // payload length to be encoded over multiple bytes rather than a single u8.
4301 let big_payload = encode_big_payload().unwrap();
4302 let mut rd = Cursor::new(&big_payload[..]);
4304 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4305 <msgs::InboundOnionPayload as ReadableArgs<(Option<PublicKey>, &&test_utils::TestKeysInterface)>>
4306 ::read(&mut rd, (None, &&node_signer)).unwrap();
4308 // see above test, needs to be a separate method for use of the serialization macros.
4309 fn encode_big_payload() -> Result<Vec<u8>, io::Error> {
4310 use crate::util::ser::HighZeroBytesDroppedBigSize;
4311 let payload = msgs::OutboundOnionPayload::Forward {
4312 short_channel_id: 0xdeadbeef1bad1dea,
4313 amt_to_forward: 1000,
4314 outgoing_cltv_value: 0xffffffff,
4316 let mut encoded_payload = Vec::new();
4317 let test_bytes = vec![42u8; 1000];
4318 if let msgs::OutboundOnionPayload::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } = payload {
4319 _encode_varint_length_prefixed_tlv!(&mut encoded_payload, {
4320 (1, test_bytes, required_vec),
4321 (2, HighZeroBytesDroppedBigSize(amt_to_forward), required),
4322 (4, HighZeroBytesDroppedBigSize(outgoing_cltv_value), required),
4323 (6, short_channel_id, required)
4330 #[cfg(feature = "std")]
4331 fn test_socket_address_from_str() {
4332 let tcpip_v4 = SocketAddress::TcpIpV4 {
4333 addr: Ipv4Addr::new(127, 0, 0, 1).octets(),
4336 assert_eq!(tcpip_v4, SocketAddress::from_str("127.0.0.1:1234").unwrap());
4337 assert_eq!(tcpip_v4, SocketAddress::from_str(&tcpip_v4.to_string()).unwrap());
4339 let tcpip_v6 = SocketAddress::TcpIpV6 {
4340 addr: Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1).octets(),
4343 assert_eq!(tcpip_v6, SocketAddress::from_str("[0:0:0:0:0:0:0:1]:1234").unwrap());
4344 assert_eq!(tcpip_v6, SocketAddress::from_str(&tcpip_v6.to_string()).unwrap());
4346 let hostname = SocketAddress::Hostname {
4347 hostname: Hostname::try_from("lightning-node.mydomain.com".to_string()).unwrap(),
4350 assert_eq!(hostname, SocketAddress::from_str("lightning-node.mydomain.com:1234").unwrap());
4351 assert_eq!(hostname, SocketAddress::from_str(&hostname.to_string()).unwrap());
4353 let onion_v2 = SocketAddress::OnionV2 ([40, 4, 64, 185, 202, 19, 162, 75, 90, 200, 38, 7],);
4354 assert_eq!("OnionV2([40, 4, 64, 185, 202, 19, 162, 75, 90, 200, 38, 7])", &onion_v2.to_string());
4355 assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("FACEBOOKCOREWWWI.onion:9735"));
4357 let onion_v3 = SocketAddress::OnionV3 {
4358 ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102, 182, 107, 4, 105, 247, 246, 85,
4359 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31, 33, 71, 3],
4364 assert_eq!(onion_v3, SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion:1234").unwrap());
4365 assert_eq!(onion_v3, SocketAddress::from_str(&onion_v3.to_string()).unwrap());
4367 assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6.onion:1234"));
4368 assert_eq!(Err(SocketAddressParseError::InvalidInput), SocketAddress::from_str("127.0.0.1@1234"));
4369 assert_eq!(Err(SocketAddressParseError::InvalidInput), "".parse::<SocketAddress>());
4370 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:9735:94").is_err());
4371 assert!(SocketAddress::from_str("wrong$%#.com:1234").is_err());
4372 assert_eq!(Err(SocketAddressParseError::InvalidPort), SocketAddress::from_str("example.com:wrong"));
4373 assert!("localhost".parse::<SocketAddress>().is_err());
4374 assert!("localhost:invalid-port".parse::<SocketAddress>().is_err());
4375 assert!( "invalid-onion-v3-hostname.onion:8080".parse::<SocketAddress>().is_err());
4376 assert!("b32.example.onion:invalid-port".parse::<SocketAddress>().is_err());
4377 assert!("invalid-address".parse::<SocketAddress>().is_err());
4378 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:1234").is_err());
4382 #[cfg(feature = "std")]
4383 fn test_socket_address_to_socket_addrs() {
4384 assert_eq!(SocketAddress::TcpIpV4 {addr:[0u8; 4], port: 1337,}.to_socket_addrs().unwrap().next().unwrap(),
4385 SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(0,0,0,0), 1337)));
4386 assert_eq!(SocketAddress::TcpIpV6 {addr:[0u8; 16], port: 1337,}.to_socket_addrs().unwrap().next().unwrap(),
4387 SocketAddr::V6(SocketAddrV6::new(Ipv6Addr::from([0u8; 16]), 1337, 0, 0)));
4388 assert_eq!(SocketAddress::Hostname { hostname: Hostname::try_from("0.0.0.0".to_string()).unwrap(), port: 0 }
4389 .to_socket_addrs().unwrap().next().unwrap(), SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::from([0u8; 4]),0)));
4390 assert!(SocketAddress::OnionV2([0u8; 12]).to_socket_addrs().is_err());
4391 assert!(SocketAddress::OnionV3{ ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102,
4392 182, 107, 4, 105, 247, 246, 85, 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31,
4396 port: 1234 }.to_socket_addrs().is_err());