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::Script;
32 use bitcoin::hash_types::{Txid, BlockHash};
34 use crate::ln::{ChannelId, PaymentPreimage, PaymentHash, PaymentSecret};
35 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
36 use crate::ln::onion_utils;
37 use crate::onion_message;
39 use crate::prelude::*;
40 use core::convert::TryFrom;
43 use core::str::FromStr;
44 use crate::io::{self, Read};
45 use crate::io_extras::read_to_end;
47 use crate::events::{MessageSendEventsProvider, OnionMessageProvider};
48 use crate::util::logger;
49 use crate::util::ser::{LengthReadable, Readable, ReadableArgs, Writeable, Writer, WithoutLength, FixedLengthReader, HighZeroBytesDroppedBigSize, Hostname, TransactionU16LenLimited, BigSize};
50 use crate::util::base32;
52 use crate::routing::gossip::{NodeAlias, NodeId};
54 /// 21 million * 10^8 * 1000
55 pub(crate) const MAX_VALUE_MSAT: u64 = 21_000_000_0000_0000_000;
58 /// A partial signature that also contains the Musig2 nonce its signer used
59 #[derive(Clone, Debug, PartialEq, Eq)]
60 pub struct PartialSignatureWithNonce(pub musig2::types::PartialSignature, pub musig2::types::PublicNonce);
62 /// An error in decoding a message or struct.
63 #[derive(Clone, Debug, PartialEq, Eq)]
64 pub enum DecodeError {
65 /// A version byte specified something we don't know how to handle.
67 /// Includes unknown realm byte in an onion hop data packet.
69 /// Unknown feature mandating we fail to parse message (e.g., TLV with an even, unknown type)
70 UnknownRequiredFeature,
71 /// Value was invalid.
73 /// For example, a byte which was supposed to be a bool was something other than a 0
74 /// or 1, a public key/private key/signature was invalid, text wasn't UTF-8, TLV was
75 /// syntactically incorrect, etc.
77 /// The buffer to be read was too short.
79 /// A length descriptor in the packet didn't describe the later data correctly.
81 /// Error from [`std::io`].
83 /// The message included zlib-compressed values, which we don't support.
84 UnsupportedCompression,
87 /// An [`init`] message to be sent to or received from a peer.
89 /// [`init`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-init-message
90 #[derive(Clone, Debug, PartialEq, Eq)]
92 /// The relevant features which the sender supports.
93 pub features: InitFeatures,
94 /// Indicates chains the sender is interested in.
96 /// If there are no common chains, the connection will be closed.
97 pub networks: Option<Vec<ChainHash>>,
98 /// The receipient's network address.
100 /// This adds the option to report a remote IP address back to a connecting peer using the init
101 /// message. A node can decide to use that information to discover a potential update to its
102 /// public IPv4 address (NAT) and use that for a [`NodeAnnouncement`] update message containing
104 pub remote_network_address: Option<NetAddress>,
107 /// An [`error`] message to be sent to or received from a peer.
109 /// [`error`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-error-and-warning-messages
110 #[derive(Clone, Debug, PartialEq, Eq)]
111 pub struct ErrorMessage {
112 /// The channel ID involved in the error.
114 /// All-0s indicates a general error unrelated to a specific channel, after which all channels
115 /// with the sending peer should be closed.
116 pub channel_id: ChannelId,
117 /// A possibly human-readable error description.
119 /// The string should be sanitized before it is used (e.g., emitted to logs or printed to
120 /// `stdout`). Otherwise, a well crafted error message may trigger a security vulnerability in
121 /// the terminal emulator or the logging subsystem.
125 /// A [`warning`] message to be sent to or received from a peer.
127 /// [`warning`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-error-and-warning-messages
128 #[derive(Clone, Debug, PartialEq, Eq)]
129 pub struct WarningMessage {
130 /// The channel ID involved in the warning.
132 /// All-0s indicates a warning unrelated to a specific channel.
133 pub channel_id: ChannelId,
134 /// A possibly human-readable warning description.
136 /// The string should be sanitized before it is used (e.g. emitted to logs or printed to
137 /// stdout). Otherwise, a well crafted error message may trigger a security vulnerability in
138 /// the terminal emulator or the logging subsystem.
142 /// A [`ping`] message to be sent to or received from a peer.
144 /// [`ping`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-ping-and-pong-messages
145 #[derive(Clone, Debug, PartialEq, Eq)]
147 /// The desired response length.
149 /// The ping packet size.
151 /// This field is not sent on the wire. byteslen zeros are sent.
155 /// A [`pong`] message to be sent to or received from a peer.
157 /// [`pong`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-ping-and-pong-messages
158 #[derive(Clone, Debug, PartialEq, Eq)]
160 /// The pong packet size.
162 /// This field is not sent on the wire. byteslen zeros are sent.
166 /// An [`open_channel`] message to be sent to or received from a peer.
168 /// Used in V1 channel establishment
170 /// [`open_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-open_channel-message
171 #[derive(Clone, Debug, PartialEq, Eq)]
172 pub struct OpenChannel {
173 /// The genesis hash of the blockchain where the channel is to be opened
174 pub chain_hash: BlockHash,
175 /// A temporary channel ID, until the funding outpoint is announced
176 pub temporary_channel_id: ChannelId,
177 /// The channel value
178 pub funding_satoshis: u64,
179 /// The amount to push to the counterparty as part of the open, in milli-satoshi
181 /// The threshold below which outputs on transactions broadcast by sender will be omitted
182 pub dust_limit_satoshis: u64,
183 /// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
184 pub max_htlc_value_in_flight_msat: u64,
185 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
186 pub channel_reserve_satoshis: u64,
187 /// The minimum HTLC size incoming to sender, in milli-satoshi
188 pub htlc_minimum_msat: u64,
189 /// The feerate per 1000-weight of sender generated transactions, until updated by
191 pub feerate_per_kw: u32,
192 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if
193 /// they broadcast a commitment transaction
194 pub to_self_delay: u16,
195 /// The maximum number of inbound HTLCs towards sender
196 pub max_accepted_htlcs: u16,
197 /// The sender's key controlling the funding transaction
198 pub funding_pubkey: PublicKey,
199 /// Used to derive a revocation key for transactions broadcast by counterparty
200 pub revocation_basepoint: PublicKey,
201 /// A payment key to sender for transactions broadcast by counterparty
202 pub payment_point: PublicKey,
203 /// Used to derive a payment key to sender for transactions broadcast by sender
204 pub delayed_payment_basepoint: PublicKey,
205 /// Used to derive an HTLC payment key to sender
206 pub htlc_basepoint: PublicKey,
207 /// The first to-be-broadcast-by-sender transaction's per commitment point
208 pub first_per_commitment_point: PublicKey,
209 /// The channel flags to be used
210 pub channel_flags: u8,
211 /// A request to pre-set the to-sender output's `scriptPubkey` for when we collaboratively close
212 pub shutdown_scriptpubkey: Option<Script>,
213 /// The channel type that this channel will represent
215 /// If this is `None`, we derive the channel type from the intersection of our
216 /// feature bits with our counterparty's feature bits from the [`Init`] message.
217 pub channel_type: Option<ChannelTypeFeatures>,
220 /// An open_channel2 message to be sent by or received from the channel initiator.
222 /// Used in V2 channel establishment
224 // TODO(dual_funding): Add spec link for `open_channel2`.
225 #[derive(Clone, Debug, PartialEq, Eq)]
226 pub struct OpenChannelV2 {
227 /// The genesis hash of the blockchain where the channel is to be opened
228 pub chain_hash: BlockHash,
229 /// A temporary channel ID derived using a zeroed out value for the channel acceptor's revocation basepoint
230 pub temporary_channel_id: ChannelId,
231 /// The feerate for the funding transaction set by the channel initiator
232 pub funding_feerate_sat_per_1000_weight: u32,
233 /// The feerate for the commitment transaction set by the channel initiator
234 pub commitment_feerate_sat_per_1000_weight: u32,
235 /// Part of the channel value contributed by the channel initiator
236 pub funding_satoshis: u64,
237 /// The threshold below which outputs on transactions broadcast by the channel initiator will be
239 pub dust_limit_satoshis: u64,
240 /// The maximum inbound HTLC value in flight towards channel initiator, in milli-satoshi
241 pub max_htlc_value_in_flight_msat: u64,
242 /// The minimum HTLC size incoming to channel initiator, in milli-satoshi
243 pub htlc_minimum_msat: u64,
244 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
245 /// broadcast a commitment transaction
246 pub to_self_delay: u16,
247 /// The maximum number of inbound HTLCs towards channel initiator
248 pub max_accepted_htlcs: u16,
249 /// The locktime for the funding transaction
251 /// The channel initiator's key controlling the funding transaction
252 pub funding_pubkey: PublicKey,
253 /// Used to derive a revocation key for transactions broadcast by counterparty
254 pub revocation_basepoint: PublicKey,
255 /// A payment key to channel initiator for transactions broadcast by counterparty
256 pub payment_basepoint: PublicKey,
257 /// Used to derive a payment key to channel initiator for transactions broadcast by channel
259 pub delayed_payment_basepoint: PublicKey,
260 /// Used to derive an HTLC payment key to channel initiator
261 pub htlc_basepoint: PublicKey,
262 /// The first to-be-broadcast-by-channel-initiator transaction's per commitment point
263 pub first_per_commitment_point: PublicKey,
264 /// The second to-be-broadcast-by-channel-initiator transaction's per commitment point
265 pub second_per_commitment_point: PublicKey,
267 pub channel_flags: u8,
268 /// Optionally, a request to pre-set the to-channel-initiator output's scriptPubkey for when we
269 /// collaboratively close
270 pub shutdown_scriptpubkey: Option<Script>,
271 /// The channel type that this channel will represent. If none is set, we derive the channel
272 /// type from the intersection of our feature bits with our counterparty's feature bits from
273 /// the Init message.
274 pub channel_type: Option<ChannelTypeFeatures>,
275 /// Optionally, a requirement that only confirmed inputs can be added
276 pub require_confirmed_inputs: Option<()>,
279 /// An [`accept_channel`] message to be sent to or received from a peer.
281 /// Used in V1 channel establishment
283 /// [`accept_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-accept_channel-message
284 #[derive(Clone, Debug, PartialEq, Eq)]
285 pub struct AcceptChannel {
286 /// A temporary channel ID, until the funding outpoint is announced
287 pub temporary_channel_id: ChannelId,
288 /// The threshold below which outputs on transactions broadcast by sender will be omitted
289 pub dust_limit_satoshis: u64,
290 /// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
291 pub max_htlc_value_in_flight_msat: u64,
292 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
293 pub channel_reserve_satoshis: u64,
294 /// The minimum HTLC size incoming to sender, in milli-satoshi
295 pub htlc_minimum_msat: u64,
296 /// Minimum depth of the funding transaction before the channel is considered open
297 pub minimum_depth: u32,
298 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they broadcast a commitment transaction
299 pub to_self_delay: u16,
300 /// The maximum number of inbound HTLCs towards sender
301 pub max_accepted_htlcs: u16,
302 /// The sender's key controlling the funding transaction
303 pub funding_pubkey: PublicKey,
304 /// Used to derive a revocation key for transactions broadcast by counterparty
305 pub revocation_basepoint: PublicKey,
306 /// A payment key to sender for transactions broadcast by counterparty
307 pub payment_point: PublicKey,
308 /// Used to derive a payment key to sender for transactions broadcast by sender
309 pub delayed_payment_basepoint: PublicKey,
310 /// Used to derive an HTLC payment key to sender for transactions broadcast by counterparty
311 pub htlc_basepoint: PublicKey,
312 /// The first to-be-broadcast-by-sender transaction's per commitment point
313 pub first_per_commitment_point: PublicKey,
314 /// A request to pre-set the to-sender output's scriptPubkey for when we collaboratively close
315 pub shutdown_scriptpubkey: Option<Script>,
316 /// The channel type that this channel will represent.
318 /// If this is `None`, we derive the channel type from the intersection of
319 /// our feature bits with our counterparty's feature bits from the [`Init`] message.
320 /// This is required to match the equivalent field in [`OpenChannel::channel_type`].
321 pub channel_type: Option<ChannelTypeFeatures>,
323 /// Next nonce the channel initiator should use to create a funding output signature against
324 pub next_local_nonce: Option<musig2::types::PublicNonce>,
327 /// An accept_channel2 message to be sent by or received from the channel accepter.
329 /// Used in V2 channel establishment
331 // TODO(dual_funding): Add spec link for `accept_channel2`.
332 #[derive(Clone, Debug, PartialEq, Eq)]
333 pub struct AcceptChannelV2 {
334 /// The same `temporary_channel_id` received from the initiator's `open_channel2` message.
335 pub temporary_channel_id: ChannelId,
336 /// Part of the channel value contributed by the channel acceptor
337 pub funding_satoshis: u64,
338 /// The threshold below which outputs on transactions broadcast by the channel acceptor will be
340 pub dust_limit_satoshis: u64,
341 /// The maximum inbound HTLC value in flight towards channel acceptor, in milli-satoshi
342 pub max_htlc_value_in_flight_msat: u64,
343 /// The minimum HTLC size incoming to channel acceptor, in milli-satoshi
344 pub htlc_minimum_msat: u64,
345 /// Minimum depth of the funding transaction before the channel is considered open
346 pub minimum_depth: u32,
347 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
348 /// broadcast a commitment transaction
349 pub to_self_delay: u16,
350 /// The maximum number of inbound HTLCs towards channel acceptor
351 pub max_accepted_htlcs: u16,
352 /// The channel acceptor's key controlling the funding transaction
353 pub funding_pubkey: PublicKey,
354 /// Used to derive a revocation key for transactions broadcast by counterparty
355 pub revocation_basepoint: PublicKey,
356 /// A payment key to channel acceptor for transactions broadcast by counterparty
357 pub payment_basepoint: PublicKey,
358 /// Used to derive a payment key to channel acceptor for transactions broadcast by channel
360 pub delayed_payment_basepoint: PublicKey,
361 /// Used to derive an HTLC payment key to channel acceptor for transactions broadcast by counterparty
362 pub htlc_basepoint: PublicKey,
363 /// The first to-be-broadcast-by-channel-acceptor transaction's per commitment point
364 pub first_per_commitment_point: PublicKey,
365 /// The second to-be-broadcast-by-channel-acceptor transaction's per commitment point
366 pub second_per_commitment_point: PublicKey,
367 /// Optionally, a request to pre-set the to-channel-acceptor output's scriptPubkey for when we
368 /// collaboratively close
369 pub shutdown_scriptpubkey: Option<Script>,
370 /// The channel type that this channel will represent. If none is set, we derive the channel
371 /// type from the intersection of our feature bits with our counterparty's feature bits from
372 /// the Init message.
374 /// This is required to match the equivalent field in [`OpenChannelV2::channel_type`].
375 pub channel_type: Option<ChannelTypeFeatures>,
376 /// Optionally, a requirement that only confirmed inputs can be added
377 pub require_confirmed_inputs: Option<()>,
380 /// A [`funding_created`] message to be sent to or received from a peer.
382 /// Used in V1 channel establishment
384 /// [`funding_created`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-funding_created-message
385 #[derive(Clone, Debug, PartialEq, Eq)]
386 pub struct FundingCreated {
387 /// A temporary channel ID, until the funding is established
388 pub temporary_channel_id: ChannelId,
389 /// The funding transaction ID
390 pub funding_txid: Txid,
391 /// The specific output index funding this channel
392 pub funding_output_index: u16,
393 /// The signature of the channel initiator (funder) on the initial commitment transaction
394 pub signature: Signature,
396 /// The partial signature of the channel initiator (funder)
397 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
399 /// Next nonce the channel acceptor should use to finalize the funding output signature
400 pub next_local_nonce: Option<musig2::types::PublicNonce>
403 /// A [`funding_signed`] message to be sent to or received from a peer.
405 /// Used in V1 channel establishment
407 /// [`funding_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-funding_signed-message
408 #[derive(Clone, Debug, PartialEq, Eq)]
409 pub struct FundingSigned {
411 pub channel_id: ChannelId,
412 /// The signature of the channel acceptor (fundee) on the initial commitment transaction
413 pub signature: Signature,
415 /// The partial signature of the channel acceptor (fundee)
416 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
419 /// A [`channel_ready`] message to be sent to or received from a peer.
421 /// [`channel_ready`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-channel_ready-message
422 #[derive(Clone, Debug, PartialEq, Eq)]
423 pub struct ChannelReady {
425 pub channel_id: ChannelId,
426 /// The per-commitment point of the second commitment transaction
427 pub next_per_commitment_point: PublicKey,
428 /// If set, provides a `short_channel_id` alias for this channel.
430 /// The sender will accept payments to be forwarded over this SCID and forward them to this
431 /// messages' recipient.
432 pub short_channel_id_alias: Option<u64>,
435 /// A tx_add_input message for adding an input during interactive transaction construction
437 // TODO(dual_funding): Add spec link for `tx_add_input`.
438 #[derive(Clone, Debug, PartialEq, Eq)]
439 pub struct TxAddInput {
441 pub channel_id: ChannelId,
442 /// A randomly chosen unique identifier for this input, which is even for initiators and odd for
445 /// Serialized transaction that contains the output this input spends to verify that it is non
447 pub prevtx: TransactionU16LenLimited,
448 /// The index of the output being spent
450 /// The sequence number of this input
454 /// A tx_add_output message for adding an output during interactive transaction construction.
456 // TODO(dual_funding): Add spec link for `tx_add_output`.
457 #[derive(Clone, Debug, PartialEq, Eq)]
458 pub struct TxAddOutput {
460 pub channel_id: ChannelId,
461 /// A randomly chosen unique identifier for this output, which is even for initiators and odd for
464 /// The satoshi value of the output
466 /// The scriptPubKey for the output
470 /// A tx_remove_input message for removing an input during interactive transaction construction.
472 // TODO(dual_funding): Add spec link for `tx_remove_input`.
473 #[derive(Clone, Debug, PartialEq, Eq)]
474 pub struct TxRemoveInput {
476 pub channel_id: ChannelId,
477 /// The serial ID of the input to be removed
481 /// A tx_remove_output message for removing an output during interactive transaction construction.
483 // TODO(dual_funding): Add spec link for `tx_remove_output`.
484 #[derive(Clone, Debug, PartialEq, Eq)]
485 pub struct TxRemoveOutput {
487 pub channel_id: ChannelId,
488 /// The serial ID of the output to be removed
492 /// A tx_complete message signalling the conclusion of a peer's transaction contributions during
493 /// interactive transaction construction.
495 // TODO(dual_funding): Add spec link for `tx_complete`.
496 #[derive(Clone, Debug, PartialEq, Eq)]
497 pub struct TxComplete {
499 pub channel_id: ChannelId,
502 /// A tx_signatures message containing the sender's signatures for a transaction constructed with
503 /// interactive transaction construction.
505 // TODO(dual_funding): Add spec link for `tx_signatures`.
506 #[derive(Clone, Debug, PartialEq, Eq)]
507 pub struct TxSignatures {
509 pub channel_id: ChannelId,
512 /// The list of witnesses
513 pub witnesses: Vec<Witness>,
516 /// A tx_init_rbf message which initiates a replacement of the transaction after it's been
519 // TODO(dual_funding): Add spec link for `tx_init_rbf`.
520 #[derive(Clone, Debug, PartialEq, Eq)]
521 pub struct TxInitRbf {
523 pub channel_id: ChannelId,
524 /// The locktime of the transaction
526 /// The feerate of the transaction
527 pub feerate_sat_per_1000_weight: u32,
528 /// The number of satoshis the sender will contribute to or, if negative, remove from
529 /// (e.g. splice-out) the funding output of the transaction
530 pub funding_output_contribution: Option<i64>,
533 /// A tx_ack_rbf message which acknowledges replacement of the transaction after it's been
536 // TODO(dual_funding): Add spec link for `tx_ack_rbf`.
537 #[derive(Clone, Debug, PartialEq, Eq)]
538 pub struct TxAckRbf {
540 pub channel_id: ChannelId,
541 /// The number of satoshis the sender will contribute to or, if negative, remove from
542 /// (e.g. splice-out) the funding output of the transaction
543 pub funding_output_contribution: Option<i64>,
546 /// A tx_abort message which signals the cancellation of an in-progress transaction negotiation.
548 // TODO(dual_funding): Add spec link for `tx_abort`.
549 #[derive(Clone, Debug, PartialEq, Eq)]
552 pub channel_id: ChannelId,
557 /// A [`shutdown`] message to be sent to or received from a peer.
559 /// [`shutdown`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-initiation-shutdown
560 #[derive(Clone, Debug, PartialEq, Eq)]
561 pub struct Shutdown {
563 pub channel_id: ChannelId,
564 /// The destination of this peer's funds on closing.
566 /// Must be in one of these forms: P2PKH, P2SH, P2WPKH, P2WSH, P2TR.
567 pub scriptpubkey: Script,
570 /// The minimum and maximum fees which the sender is willing to place on the closing transaction.
572 /// This is provided in [`ClosingSigned`] by both sides to indicate the fee range they are willing
574 #[derive(Clone, Debug, PartialEq, Eq)]
575 pub struct ClosingSignedFeeRange {
576 /// The minimum absolute fee, in satoshis, which the sender is willing to place on the closing
578 pub min_fee_satoshis: u64,
579 /// The maximum absolute fee, in satoshis, which the sender is willing to place on the closing
581 pub max_fee_satoshis: u64,
584 /// A [`closing_signed`] message to be sent to or received from a peer.
586 /// [`closing_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-negotiation-closing_signed
587 #[derive(Clone, Debug, PartialEq, Eq)]
588 pub struct ClosingSigned {
590 pub channel_id: ChannelId,
591 /// The proposed total fee for the closing transaction
592 pub fee_satoshis: u64,
593 /// A signature on the closing transaction
594 pub signature: Signature,
595 /// The minimum and maximum fees which the sender is willing to accept, provided only by new
597 pub fee_range: Option<ClosingSignedFeeRange>,
600 /// An [`update_add_htlc`] message to be sent to or received from a peer.
602 /// [`update_add_htlc`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#adding-an-htlc-update_add_htlc
603 #[derive(Clone, Debug, PartialEq, Eq)]
604 pub struct UpdateAddHTLC {
606 pub channel_id: ChannelId,
609 /// The HTLC value in milli-satoshi
610 pub amount_msat: u64,
611 /// The payment hash, the pre-image of which controls HTLC redemption
612 pub payment_hash: PaymentHash,
613 /// The expiry height of the HTLC
614 pub cltv_expiry: u32,
615 /// The extra fee skimmed by the sender of this message. See
616 /// [`ChannelConfig::accept_underpaying_htlcs`].
618 /// [`ChannelConfig::accept_underpaying_htlcs`]: crate::util::config::ChannelConfig::accept_underpaying_htlcs
619 pub skimmed_fee_msat: Option<u64>,
620 pub(crate) onion_routing_packet: OnionPacket,
623 /// An onion message to be sent to or received from a peer.
625 // TODO: update with link to OM when they are merged into the BOLTs
626 #[derive(Clone, Debug, PartialEq, Eq)]
627 pub struct OnionMessage {
628 /// Used in decrypting the onion packet's payload.
629 pub blinding_point: PublicKey,
630 pub(crate) onion_routing_packet: onion_message::Packet,
633 /// An [`update_fulfill_htlc`] message to be sent to or received from a peer.
635 /// [`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
636 #[derive(Clone, Debug, PartialEq, Eq)]
637 pub struct UpdateFulfillHTLC {
639 pub channel_id: ChannelId,
642 /// The pre-image of the payment hash, allowing HTLC redemption
643 pub payment_preimage: PaymentPreimage,
646 /// An [`update_fail_htlc`] message to be sent to or received from a peer.
648 /// [`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
649 #[derive(Clone, Debug, PartialEq, Eq)]
650 pub struct UpdateFailHTLC {
652 pub channel_id: ChannelId,
655 pub(crate) reason: OnionErrorPacket,
658 /// An [`update_fail_malformed_htlc`] message to be sent to or received from a peer.
660 /// [`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
661 #[derive(Clone, Debug, PartialEq, Eq)]
662 pub struct UpdateFailMalformedHTLC {
664 pub channel_id: ChannelId,
667 pub(crate) sha256_of_onion: [u8; 32],
669 pub failure_code: u16,
672 /// A [`commitment_signed`] message to be sent to or received from a peer.
674 /// [`commitment_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#committing-updates-so-far-commitment_signed
675 #[derive(Clone, Debug, PartialEq, Eq)]
676 pub struct CommitmentSigned {
678 pub channel_id: ChannelId,
679 /// A signature on the commitment transaction
680 pub signature: Signature,
681 /// Signatures on the HTLC transactions
682 pub htlc_signatures: Vec<Signature>,
684 /// The partial Taproot signature on the commitment transaction
685 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
688 /// A [`revoke_and_ack`] message to be sent to or received from a peer.
690 /// [`revoke_and_ack`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#completing-the-transition-to-the-updated-state-revoke_and_ack
691 #[derive(Clone, Debug, PartialEq, Eq)]
692 pub struct RevokeAndACK {
694 pub channel_id: ChannelId,
695 /// The secret corresponding to the per-commitment point
696 pub per_commitment_secret: [u8; 32],
697 /// The next sender-broadcast commitment transaction's per-commitment point
698 pub next_per_commitment_point: PublicKey,
700 /// Musig nonce the recipient should use in their next commitment signature message
701 pub next_local_nonce: Option<musig2::types::PublicNonce>
704 /// An [`update_fee`] message to be sent to or received from a peer
706 /// [`update_fee`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#updating-fees-update_fee
707 #[derive(Clone, Debug, PartialEq, Eq)]
708 pub struct UpdateFee {
710 pub channel_id: ChannelId,
711 /// Fee rate per 1000-weight of the transaction
712 pub feerate_per_kw: u32,
715 /// A [`channel_reestablish`] message to be sent to or received from a peer.
717 /// [`channel_reestablish`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#message-retransmission
718 #[derive(Clone, Debug, PartialEq, Eq)]
719 pub struct ChannelReestablish {
721 pub channel_id: ChannelId,
722 /// The next commitment number for the sender
723 pub next_local_commitment_number: u64,
724 /// The next commitment number for the recipient
725 pub next_remote_commitment_number: u64,
726 /// Proof that the sender knows the per-commitment secret of a specific commitment transaction
727 /// belonging to the recipient
728 pub your_last_per_commitment_secret: [u8; 32],
729 /// The sender's per-commitment point for their current commitment transaction
730 pub my_current_per_commitment_point: PublicKey,
731 /// The next funding transaction ID
732 pub next_funding_txid: Option<Txid>,
735 /// An [`announcement_signatures`] message to be sent to or received from a peer.
737 /// [`announcement_signatures`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-announcement_signatures-message
738 #[derive(Clone, Debug, PartialEq, Eq)]
739 pub struct AnnouncementSignatures {
741 pub channel_id: ChannelId,
742 /// The short channel ID
743 pub short_channel_id: u64,
744 /// A signature by the node key
745 pub node_signature: Signature,
746 /// A signature by the funding key
747 pub bitcoin_signature: Signature,
750 /// An address which can be used to connect to a remote peer.
751 #[derive(Clone, Debug, PartialEq, Eq)]
752 pub enum NetAddress {
753 /// An IPv4 address/port on which the peer is listening.
755 /// The 4-byte IPv4 address
757 /// The port on which the node is listening
760 /// An IPv6 address/port on which the peer is listening.
762 /// The 16-byte IPv6 address
764 /// The port on which the node is listening
767 /// An old-style Tor onion address/port on which the peer is listening.
769 /// This field is deprecated and the Tor network generally no longer supports V2 Onion
770 /// addresses. Thus, the details are not parsed here.
772 /// A new-style Tor onion address/port on which the peer is listening.
774 /// To create the human-readable "hostname", concatenate the ED25519 pubkey, checksum, and version,
775 /// wrap as base32 and append ".onion".
777 /// The ed25519 long-term public key of the peer
778 ed25519_pubkey: [u8; 32],
779 /// The checksum of the pubkey and version, as included in the onion address
781 /// The version byte, as defined by the Tor Onion v3 spec.
783 /// The port on which the node is listening
786 /// A hostname/port on which the peer is listening.
788 /// The hostname on which the node is listening.
790 /// The port on which the node is listening.
795 /// Gets the ID of this address type. Addresses in [`NodeAnnouncement`] messages should be sorted
797 pub(crate) fn get_id(&self) -> u8 {
799 &NetAddress::IPv4 {..} => { 1 },
800 &NetAddress::IPv6 {..} => { 2 },
801 &NetAddress::OnionV2(_) => { 3 },
802 &NetAddress::OnionV3 {..} => { 4 },
803 &NetAddress::Hostname {..} => { 5 },
807 /// Strict byte-length of address descriptor, 1-byte type not recorded
808 fn len(&self) -> u16 {
810 &NetAddress::IPv4 { .. } => { 6 },
811 &NetAddress::IPv6 { .. } => { 18 },
812 &NetAddress::OnionV2(_) => { 12 },
813 &NetAddress::OnionV3 { .. } => { 37 },
814 // Consists of 1-byte hostname length, hostname bytes, and 2-byte port.
815 &NetAddress::Hostname { ref hostname, .. } => { u16::from(hostname.len()) + 3 },
819 /// The maximum length of any address descriptor, not including the 1-byte type.
820 /// This maximum length is reached by a hostname address descriptor:
821 /// a hostname with a maximum length of 255, its 1-byte length and a 2-byte port.
822 pub(crate) const MAX_LEN: u16 = 258;
825 impl Writeable for NetAddress {
826 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
828 &NetAddress::IPv4 { ref addr, ref port } => {
833 &NetAddress::IPv6 { ref addr, ref port } => {
838 &NetAddress::OnionV2(bytes) => {
840 bytes.write(writer)?;
842 &NetAddress::OnionV3 { ref ed25519_pubkey, ref checksum, ref version, ref port } => {
844 ed25519_pubkey.write(writer)?;
845 checksum.write(writer)?;
846 version.write(writer)?;
849 &NetAddress::Hostname { ref hostname, ref port } => {
851 hostname.write(writer)?;
859 impl Readable for Result<NetAddress, u8> {
860 fn read<R: Read>(reader: &mut R) -> Result<Result<NetAddress, u8>, DecodeError> {
861 let byte = <u8 as Readable>::read(reader)?;
864 Ok(Ok(NetAddress::IPv4 {
865 addr: Readable::read(reader)?,
866 port: Readable::read(reader)?,
870 Ok(Ok(NetAddress::IPv6 {
871 addr: Readable::read(reader)?,
872 port: Readable::read(reader)?,
875 3 => Ok(Ok(NetAddress::OnionV2(Readable::read(reader)?))),
877 Ok(Ok(NetAddress::OnionV3 {
878 ed25519_pubkey: Readable::read(reader)?,
879 checksum: Readable::read(reader)?,
880 version: Readable::read(reader)?,
881 port: Readable::read(reader)?,
885 Ok(Ok(NetAddress::Hostname {
886 hostname: Readable::read(reader)?,
887 port: Readable::read(reader)?,
890 _ => return Ok(Err(byte)),
895 impl Readable for NetAddress {
896 fn read<R: Read>(reader: &mut R) -> Result<NetAddress, DecodeError> {
897 match Readable::read(reader) {
898 Ok(Ok(res)) => Ok(res),
899 Ok(Err(_)) => Err(DecodeError::UnknownVersion),
905 /// [`NetAddress`] error variants
906 #[derive(Debug, Eq, PartialEq, Clone)]
907 pub enum NetAddressParseError {
908 /// Socket address (IPv4/IPv6) parsing error
910 /// Invalid input format
914 /// Invalid onion v3 address
918 impl fmt::Display for NetAddressParseError {
919 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
921 NetAddressParseError::SocketAddrParse => write!(f, "Socket address (IPv4/IPv6) parsing error"),
922 NetAddressParseError::InvalidInput => write!(f, "Invalid input format. \
923 Expected: \"<ipv4>:<port>\", \"[<ipv6>]:<port>\", \"<onion address>.onion:<port>\" or \"<hostname>:<port>\""),
924 NetAddressParseError::InvalidPort => write!(f, "Invalid port"),
925 NetAddressParseError::InvalidOnionV3 => write!(f, "Invalid onion v3 address"),
930 #[cfg(feature = "std")]
931 impl From<std::net::SocketAddrV4> for NetAddress {
932 fn from(addr: std::net::SocketAddrV4) -> Self {
933 NetAddress::IPv4 { addr: addr.ip().octets(), port: addr.port() }
937 #[cfg(feature = "std")]
938 impl From<std::net::SocketAddrV6> for NetAddress {
939 fn from(addr: std::net::SocketAddrV6) -> Self {
940 NetAddress::IPv6 { addr: addr.ip().octets(), port: addr.port() }
944 #[cfg(feature = "std")]
945 impl From<std::net::SocketAddr> for NetAddress {
946 fn from(addr: std::net::SocketAddr) -> Self {
948 std::net::SocketAddr::V4(addr) => addr.into(),
949 std::net::SocketAddr::V6(addr) => addr.into(),
954 fn parse_onion_address(host: &str, port: u16) -> Result<NetAddress, NetAddressParseError> {
955 if host.ends_with(".onion") {
956 let domain = &host[..host.len() - ".onion".len()];
957 if domain.len() != 56 {
958 return Err(NetAddressParseError::InvalidOnionV3);
960 let onion = base32::Alphabet::RFC4648 { padding: false }.decode(&domain).map_err(|_| NetAddressParseError::InvalidOnionV3)?;
961 if onion.len() != 35 {
962 return Err(NetAddressParseError::InvalidOnionV3);
964 let version = onion[0];
965 let first_checksum_flag = onion[1];
966 let second_checksum_flag = onion[2];
967 let mut ed25519_pubkey = [0; 32];
968 ed25519_pubkey.copy_from_slice(&onion[3..35]);
969 let checksum = u16::from_be_bytes([first_checksum_flag, second_checksum_flag]);
970 return Ok(NetAddress::OnionV3 { ed25519_pubkey, checksum, version, port });
973 return Err(NetAddressParseError::InvalidInput);
977 #[cfg(feature = "std")]
978 impl FromStr for NetAddress {
979 type Err = NetAddressParseError;
981 fn from_str(s: &str) -> Result<Self, Self::Err> {
982 match std::net::SocketAddr::from_str(s) {
983 Ok(addr) => Ok(addr.into()),
985 let trimmed_input = match s.rfind(":") {
987 None => return Err(NetAddressParseError::InvalidInput),
989 let host = &s[..trimmed_input];
990 let port: u16 = s[trimmed_input + 1..].parse().map_err(|_| NetAddressParseError::InvalidPort)?;
991 if host.ends_with(".onion") {
992 return parse_onion_address(host, port);
994 if let Ok(hostname) = Hostname::try_from(s[..trimmed_input].to_string()) {
995 return Ok(NetAddress::Hostname { hostname, port });
997 return Err(NetAddressParseError::SocketAddrParse)
1003 /// Represents the set of gossip messages that require a signature from a node's identity key.
1004 pub enum UnsignedGossipMessage<'a> {
1005 /// An unsigned channel announcement.
1006 ChannelAnnouncement(&'a UnsignedChannelAnnouncement),
1007 /// An unsigned channel update.
1008 ChannelUpdate(&'a UnsignedChannelUpdate),
1009 /// An unsigned node announcement.
1010 NodeAnnouncement(&'a UnsignedNodeAnnouncement)
1013 impl<'a> Writeable for UnsignedGossipMessage<'a> {
1014 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
1016 UnsignedGossipMessage::ChannelAnnouncement(ref msg) => msg.write(writer),
1017 UnsignedGossipMessage::ChannelUpdate(ref msg) => msg.write(writer),
1018 UnsignedGossipMessage::NodeAnnouncement(ref msg) => msg.write(writer),
1023 /// The unsigned part of a [`node_announcement`] message.
1025 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
1026 #[derive(Clone, Debug, PartialEq, Eq)]
1027 pub struct UnsignedNodeAnnouncement {
1028 /// The advertised features
1029 pub features: NodeFeatures,
1030 /// A strictly monotonic announcement counter, with gaps allowed
1032 /// The `node_id` this announcement originated from (don't rebroadcast the `node_announcement` back
1034 pub node_id: NodeId,
1035 /// An RGB color for UI purposes
1037 /// An alias, for UI purposes.
1039 /// This should be sanitized before use. There is no guarantee of uniqueness.
1040 pub alias: NodeAlias,
1041 /// List of addresses on which this node is reachable
1042 pub addresses: Vec<NetAddress>,
1043 pub(crate) excess_address_data: Vec<u8>,
1044 pub(crate) excess_data: Vec<u8>,
1046 #[derive(Clone, Debug, PartialEq, Eq)]
1047 /// A [`node_announcement`] message to be sent to or received from a peer.
1049 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
1050 pub struct NodeAnnouncement {
1051 /// The signature by the node key
1052 pub signature: Signature,
1053 /// The actual content of the announcement
1054 pub contents: UnsignedNodeAnnouncement,
1057 /// The unsigned part of a [`channel_announcement`] message.
1059 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
1060 #[derive(Clone, Debug, PartialEq, Eq)]
1061 pub struct UnsignedChannelAnnouncement {
1062 /// The advertised channel features
1063 pub features: ChannelFeatures,
1064 /// The genesis hash of the blockchain where the channel is to be opened
1065 pub chain_hash: BlockHash,
1066 /// The short channel ID
1067 pub short_channel_id: u64,
1068 /// One of the two `node_id`s which are endpoints of this channel
1069 pub node_id_1: NodeId,
1070 /// The other of the two `node_id`s which are endpoints of this channel
1071 pub node_id_2: NodeId,
1072 /// The funding key for the first node
1073 pub bitcoin_key_1: NodeId,
1074 /// The funding key for the second node
1075 pub bitcoin_key_2: NodeId,
1076 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1079 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1080 pub excess_data: Vec<u8>,
1082 /// A [`channel_announcement`] message to be sent to or received from a peer.
1084 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
1085 #[derive(Clone, Debug, PartialEq, Eq)]
1086 pub struct ChannelAnnouncement {
1087 /// Authentication of the announcement by the first public node
1088 pub node_signature_1: Signature,
1089 /// Authentication of the announcement by the second public node
1090 pub node_signature_2: Signature,
1091 /// Proof of funding UTXO ownership by the first public node
1092 pub bitcoin_signature_1: Signature,
1093 /// Proof of funding UTXO ownership by the second public node
1094 pub bitcoin_signature_2: Signature,
1095 /// The actual announcement
1096 pub contents: UnsignedChannelAnnouncement,
1099 /// The unsigned part of a [`channel_update`] message.
1101 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1102 #[derive(Clone, Debug, PartialEq, Eq)]
1103 pub struct UnsignedChannelUpdate {
1104 /// The genesis hash of the blockchain where the channel is to be opened
1105 pub chain_hash: BlockHash,
1106 /// The short channel ID
1107 pub short_channel_id: u64,
1108 /// A strictly monotonic announcement counter, with gaps allowed, specific to this channel
1112 /// The number of blocks such that if:
1113 /// `incoming_htlc.cltv_expiry < outgoing_htlc.cltv_expiry + cltv_expiry_delta`
1114 /// then we need to fail the HTLC backwards. When forwarding an HTLC, `cltv_expiry_delta` determines
1115 /// the outgoing HTLC's minimum `cltv_expiry` value -- so, if an incoming HTLC comes in with a
1116 /// `cltv_expiry` of 100000, and the node we're forwarding to has a `cltv_expiry_delta` value of 10,
1117 /// then we'll check that the outgoing HTLC's `cltv_expiry` value is at least 100010 before
1118 /// forwarding. Note that the HTLC sender is the one who originally sets this value when
1119 /// constructing the route.
1120 pub cltv_expiry_delta: u16,
1121 /// The minimum HTLC size incoming to sender, in milli-satoshi
1122 pub htlc_minimum_msat: u64,
1123 /// The maximum HTLC value incoming to sender, in milli-satoshi.
1125 /// This used to be optional.
1126 pub htlc_maximum_msat: u64,
1127 /// The base HTLC fee charged by sender, in milli-satoshi
1128 pub fee_base_msat: u32,
1129 /// The amount to fee multiplier, in micro-satoshi
1130 pub fee_proportional_millionths: u32,
1131 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1134 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1135 pub excess_data: Vec<u8>,
1137 /// A [`channel_update`] message to be sent to or received from a peer.
1139 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1140 #[derive(Clone, Debug, PartialEq, Eq)]
1141 pub struct ChannelUpdate {
1142 /// A signature of the channel update
1143 pub signature: Signature,
1144 /// The actual channel update
1145 pub contents: UnsignedChannelUpdate,
1148 /// A [`query_channel_range`] message is used to query a peer for channel
1149 /// UTXOs in a range of blocks. The recipient of a query makes a best
1150 /// effort to reply to the query using one or more [`ReplyChannelRange`]
1153 /// [`query_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1154 #[derive(Clone, Debug, PartialEq, Eq)]
1155 pub struct QueryChannelRange {
1156 /// The genesis hash of the blockchain being queried
1157 pub chain_hash: BlockHash,
1158 /// The height of the first block for the channel UTXOs being queried
1159 pub first_blocknum: u32,
1160 /// The number of blocks to include in the query results
1161 pub number_of_blocks: u32,
1164 /// A [`reply_channel_range`] message is a reply to a [`QueryChannelRange`]
1167 /// Multiple `reply_channel_range` messages can be sent in reply
1168 /// to a single [`QueryChannelRange`] message. The query recipient makes a
1169 /// best effort to respond based on their local network view which may
1170 /// not be a perfect view of the network. The `short_channel_id`s in the
1171 /// reply are encoded. We only support `encoding_type=0` uncompressed
1172 /// serialization and do not support `encoding_type=1` zlib serialization.
1174 /// [`reply_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1175 #[derive(Clone, Debug, PartialEq, Eq)]
1176 pub struct ReplyChannelRange {
1177 /// The genesis hash of the blockchain being queried
1178 pub chain_hash: BlockHash,
1179 /// The height of the first block in the range of the reply
1180 pub first_blocknum: u32,
1181 /// The number of blocks included in the range of the reply
1182 pub number_of_blocks: u32,
1183 /// True when this is the final reply for a query
1184 pub sync_complete: bool,
1185 /// The `short_channel_id`s in the channel range
1186 pub short_channel_ids: Vec<u64>,
1189 /// A [`query_short_channel_ids`] message is used to query a peer for
1190 /// routing gossip messages related to one or more `short_channel_id`s.
1192 /// The query recipient will reply with the latest, if available,
1193 /// [`ChannelAnnouncement`], [`ChannelUpdate`] and [`NodeAnnouncement`] messages
1194 /// it maintains for the requested `short_channel_id`s followed by a
1195 /// [`ReplyShortChannelIdsEnd`] message. The `short_channel_id`s sent in
1196 /// this query are encoded. We only support `encoding_type=0` uncompressed
1197 /// serialization and do not support `encoding_type=1` zlib serialization.
1199 /// [`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
1200 #[derive(Clone, Debug, PartialEq, Eq)]
1201 pub struct QueryShortChannelIds {
1202 /// The genesis hash of the blockchain being queried
1203 pub chain_hash: BlockHash,
1204 /// The short_channel_ids that are being queried
1205 pub short_channel_ids: Vec<u64>,
1208 /// A [`reply_short_channel_ids_end`] message is sent as a reply to a
1209 /// message. The query recipient makes a best
1210 /// effort to respond based on their local network view which may not be
1211 /// a perfect view of the network.
1213 /// [`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
1214 #[derive(Clone, Debug, PartialEq, Eq)]
1215 pub struct ReplyShortChannelIdsEnd {
1216 /// The genesis hash of the blockchain that was queried
1217 pub chain_hash: BlockHash,
1218 /// Indicates if the query recipient maintains up-to-date channel
1219 /// information for the `chain_hash`
1220 pub full_information: bool,
1223 /// A [`gossip_timestamp_filter`] message is used by a node to request
1224 /// gossip relay for messages in the requested time range when the
1225 /// `gossip_queries` feature has been negotiated.
1227 /// [`gossip_timestamp_filter`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-gossip_timestamp_filter-message
1228 #[derive(Clone, Debug, PartialEq, Eq)]
1229 pub struct GossipTimestampFilter {
1230 /// The genesis hash of the blockchain for channel and node information
1231 pub chain_hash: BlockHash,
1232 /// The starting unix timestamp
1233 pub first_timestamp: u32,
1234 /// The range of information in seconds
1235 pub timestamp_range: u32,
1238 /// Encoding type for data compression of collections in gossip queries.
1240 /// We do not support `encoding_type=1` zlib serialization [defined in BOLT
1241 /// #7](https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#query-messages).
1243 Uncompressed = 0x00,
1246 /// Used to put an error message in a [`LightningError`].
1247 #[derive(Clone, Debug, PartialEq)]
1248 pub enum ErrorAction {
1249 /// The peer took some action which made us think they were useless. Disconnect them.
1251 /// An error message which we should make an effort to send before we disconnect.
1252 msg: Option<ErrorMessage>
1254 /// The peer did something incorrect. Tell them without closing any channels and disconnect them.
1255 DisconnectPeerWithWarning {
1256 /// A warning message which we should make an effort to send before we disconnect.
1257 msg: WarningMessage,
1259 /// The peer did something harmless that we weren't able to process, just log and ignore
1260 // New code should *not* use this. New code must use IgnoreAndLog, below!
1262 /// The peer did something harmless that we weren't able to meaningfully process.
1263 /// If the error is logged, log it at the given level.
1264 IgnoreAndLog(logger::Level),
1265 /// The peer provided us with a gossip message which we'd already seen. In most cases this
1266 /// should be ignored, but it may result in the message being forwarded if it is a duplicate of
1267 /// our own channel announcements.
1268 IgnoreDuplicateGossip,
1269 /// The peer did something incorrect. Tell them.
1271 /// The message to send.
1274 /// The peer did something incorrect. Tell them without closing any channels.
1275 SendWarningMessage {
1276 /// The message to send.
1277 msg: WarningMessage,
1278 /// The peer may have done something harmless that we weren't able to meaningfully process,
1279 /// though we should still tell them about it.
1280 /// If this event is logged, log it at the given level.
1281 log_level: logger::Level,
1285 /// An Err type for failure to process messages.
1286 #[derive(Clone, Debug)]
1287 pub struct LightningError {
1288 /// A human-readable message describing the error
1290 /// The action which should be taken against the offending peer.
1291 pub action: ErrorAction,
1294 /// Struct used to return values from [`RevokeAndACK`] messages, containing a bunch of commitment
1295 /// transaction updates if they were pending.
1296 #[derive(Clone, Debug, PartialEq, Eq)]
1297 pub struct CommitmentUpdate {
1298 /// `update_add_htlc` messages which should be sent
1299 pub update_add_htlcs: Vec<UpdateAddHTLC>,
1300 /// `update_fulfill_htlc` messages which should be sent
1301 pub update_fulfill_htlcs: Vec<UpdateFulfillHTLC>,
1302 /// `update_fail_htlc` messages which should be sent
1303 pub update_fail_htlcs: Vec<UpdateFailHTLC>,
1304 /// `update_fail_malformed_htlc` messages which should be sent
1305 pub update_fail_malformed_htlcs: Vec<UpdateFailMalformedHTLC>,
1306 /// An `update_fee` message which should be sent
1307 pub update_fee: Option<UpdateFee>,
1308 /// A `commitment_signed` message which should be sent
1309 pub commitment_signed: CommitmentSigned,
1312 /// A trait to describe an object which can receive channel messages.
1314 /// Messages MAY be called in parallel when they originate from different `their_node_ids`, however
1315 /// they MUST NOT be called in parallel when the two calls have the same `their_node_id`.
1316 pub trait ChannelMessageHandler : MessageSendEventsProvider {
1318 /// Handle an incoming `open_channel` message from the given peer.
1319 fn handle_open_channel(&self, their_node_id: &PublicKey, msg: &OpenChannel);
1320 /// Handle an incoming `open_channel2` message from the given peer.
1321 fn handle_open_channel_v2(&self, their_node_id: &PublicKey, msg: &OpenChannelV2);
1322 /// Handle an incoming `accept_channel` message from the given peer.
1323 fn handle_accept_channel(&self, their_node_id: &PublicKey, msg: &AcceptChannel);
1324 /// Handle an incoming `accept_channel2` message from the given peer.
1325 fn handle_accept_channel_v2(&self, their_node_id: &PublicKey, msg: &AcceptChannelV2);
1326 /// Handle an incoming `funding_created` message from the given peer.
1327 fn handle_funding_created(&self, their_node_id: &PublicKey, msg: &FundingCreated);
1328 /// Handle an incoming `funding_signed` message from the given peer.
1329 fn handle_funding_signed(&self, their_node_id: &PublicKey, msg: &FundingSigned);
1330 /// Handle an incoming `channel_ready` message from the given peer.
1331 fn handle_channel_ready(&self, their_node_id: &PublicKey, msg: &ChannelReady);
1334 /// Handle an incoming `shutdown` message from the given peer.
1335 fn handle_shutdown(&self, their_node_id: &PublicKey, msg: &Shutdown);
1336 /// Handle an incoming `closing_signed` message from the given peer.
1337 fn handle_closing_signed(&self, their_node_id: &PublicKey, msg: &ClosingSigned);
1339 // Interactive channel construction
1340 /// Handle an incoming `tx_add_input message` from the given peer.
1341 fn handle_tx_add_input(&self, their_node_id: &PublicKey, msg: &TxAddInput);
1342 /// Handle an incoming `tx_add_output` message from the given peer.
1343 fn handle_tx_add_output(&self, their_node_id: &PublicKey, msg: &TxAddOutput);
1344 /// Handle an incoming `tx_remove_input` message from the given peer.
1345 fn handle_tx_remove_input(&self, their_node_id: &PublicKey, msg: &TxRemoveInput);
1346 /// Handle an incoming `tx_remove_output` message from the given peer.
1347 fn handle_tx_remove_output(&self, their_node_id: &PublicKey, msg: &TxRemoveOutput);
1348 /// Handle an incoming `tx_complete message` from the given peer.
1349 fn handle_tx_complete(&self, their_node_id: &PublicKey, msg: &TxComplete);
1350 /// Handle an incoming `tx_signatures` message from the given peer.
1351 fn handle_tx_signatures(&self, their_node_id: &PublicKey, msg: &TxSignatures);
1352 /// Handle an incoming `tx_init_rbf` message from the given peer.
1353 fn handle_tx_init_rbf(&self, their_node_id: &PublicKey, msg: &TxInitRbf);
1354 /// Handle an incoming `tx_ack_rbf` message from the given peer.
1355 fn handle_tx_ack_rbf(&self, their_node_id: &PublicKey, msg: &TxAckRbf);
1356 /// Handle an incoming `tx_abort message` from the given peer.
1357 fn handle_tx_abort(&self, their_node_id: &PublicKey, msg: &TxAbort);
1360 /// Handle an incoming `update_add_htlc` message from the given peer.
1361 fn handle_update_add_htlc(&self, their_node_id: &PublicKey, msg: &UpdateAddHTLC);
1362 /// Handle an incoming `update_fulfill_htlc` message from the given peer.
1363 fn handle_update_fulfill_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFulfillHTLC);
1364 /// Handle an incoming `update_fail_htlc` message from the given peer.
1365 fn handle_update_fail_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailHTLC);
1366 /// Handle an incoming `update_fail_malformed_htlc` message from the given peer.
1367 fn handle_update_fail_malformed_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailMalformedHTLC);
1368 /// Handle an incoming `commitment_signed` message from the given peer.
1369 fn handle_commitment_signed(&self, their_node_id: &PublicKey, msg: &CommitmentSigned);
1370 /// Handle an incoming `revoke_and_ack` message from the given peer.
1371 fn handle_revoke_and_ack(&self, their_node_id: &PublicKey, msg: &RevokeAndACK);
1373 /// Handle an incoming `update_fee` message from the given peer.
1374 fn handle_update_fee(&self, their_node_id: &PublicKey, msg: &UpdateFee);
1376 // Channel-to-announce:
1377 /// Handle an incoming `announcement_signatures` message from the given peer.
1378 fn handle_announcement_signatures(&self, their_node_id: &PublicKey, msg: &AnnouncementSignatures);
1380 // Connection loss/reestablish:
1381 /// Indicates a connection to the peer failed/an existing connection was lost.
1382 fn peer_disconnected(&self, their_node_id: &PublicKey);
1384 /// Handle a peer reconnecting, possibly generating `channel_reestablish` message(s).
1386 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1387 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1388 /// message handlers may still wish to communicate with this peer.
1389 fn peer_connected(&self, their_node_id: &PublicKey, msg: &Init, inbound: bool) -> Result<(), ()>;
1390 /// Handle an incoming `channel_reestablish` message from the given peer.
1391 fn handle_channel_reestablish(&self, their_node_id: &PublicKey, msg: &ChannelReestablish);
1393 /// Handle an incoming `channel_update` message from the given peer.
1394 fn handle_channel_update(&self, their_node_id: &PublicKey, msg: &ChannelUpdate);
1397 /// Handle an incoming `error` message from the given peer.
1398 fn handle_error(&self, their_node_id: &PublicKey, msg: &ErrorMessage);
1400 // Handler information:
1401 /// Gets the node feature flags which this handler itself supports. All available handlers are
1402 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1403 /// which are broadcasted in our [`NodeAnnouncement`] message.
1404 fn provided_node_features(&self) -> NodeFeatures;
1406 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1407 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1408 /// which are sent in our [`Init`] message.
1410 /// Note that this method is called before [`Self::peer_connected`].
1411 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1413 /// Gets the genesis hashes for this `ChannelMessageHandler` indicating which chains it supports.
1415 /// If it's `None`, then no particular network chain hash compatibility will be enforced when
1416 /// connecting to peers.
1417 fn get_genesis_hashes(&self) -> Option<Vec<ChainHash>>;
1420 /// A trait to describe an object which can receive routing messages.
1422 /// # Implementor DoS Warnings
1424 /// For messages enabled with the `gossip_queries` feature there are potential DoS vectors when
1425 /// handling inbound queries. Implementors using an on-disk network graph should be aware of
1426 /// repeated disk I/O for queries accessing different parts of the network graph.
1427 pub trait RoutingMessageHandler : MessageSendEventsProvider {
1428 /// Handle an incoming `node_announcement` message, returning `true` if it should be forwarded on,
1429 /// `false` or returning an `Err` otherwise.
1430 fn handle_node_announcement(&self, msg: &NodeAnnouncement) -> Result<bool, LightningError>;
1431 /// Handle a `channel_announcement` message, returning `true` if it should be forwarded on, `false`
1432 /// or returning an `Err` otherwise.
1433 fn handle_channel_announcement(&self, msg: &ChannelAnnouncement) -> Result<bool, LightningError>;
1434 /// Handle an incoming `channel_update` message, returning true if it should be forwarded on,
1435 /// `false` or returning an `Err` otherwise.
1436 fn handle_channel_update(&self, msg: &ChannelUpdate) -> Result<bool, LightningError>;
1437 /// Gets channel announcements and updates required to dump our routing table to a remote node,
1438 /// starting at the `short_channel_id` indicated by `starting_point` and including announcements
1439 /// for a single channel.
1440 fn get_next_channel_announcement(&self, starting_point: u64) -> Option<(ChannelAnnouncement, Option<ChannelUpdate>, Option<ChannelUpdate>)>;
1441 /// Gets a node announcement required to dump our routing table to a remote node, starting at
1442 /// the node *after* the provided pubkey and including up to one announcement immediately
1443 /// higher (as defined by `<PublicKey as Ord>::cmp`) than `starting_point`.
1444 /// If `None` is provided for `starting_point`, we start at the first node.
1445 fn get_next_node_announcement(&self, starting_point: Option<&NodeId>) -> Option<NodeAnnouncement>;
1446 /// Called when a connection is established with a peer. This can be used to
1447 /// perform routing table synchronization using a strategy defined by the
1450 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1451 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1452 /// message handlers may still wish to communicate with this peer.
1453 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1454 /// Handles the reply of a query we initiated to learn about channels
1455 /// for a given range of blocks. We can expect to receive one or more
1456 /// replies to a single query.
1457 fn handle_reply_channel_range(&self, their_node_id: &PublicKey, msg: ReplyChannelRange) -> Result<(), LightningError>;
1458 /// Handles the reply of a query we initiated asking for routing gossip
1459 /// messages for a list of channels. We should receive this message when
1460 /// a node has completed its best effort to send us the pertaining routing
1461 /// gossip messages.
1462 fn handle_reply_short_channel_ids_end(&self, their_node_id: &PublicKey, msg: ReplyShortChannelIdsEnd) -> Result<(), LightningError>;
1463 /// Handles when a peer asks us to send a list of `short_channel_id`s
1464 /// for the requested range of blocks.
1465 fn handle_query_channel_range(&self, their_node_id: &PublicKey, msg: QueryChannelRange) -> Result<(), LightningError>;
1466 /// Handles when a peer asks us to send routing gossip messages for a
1467 /// list of `short_channel_id`s.
1468 fn handle_query_short_channel_ids(&self, their_node_id: &PublicKey, msg: QueryShortChannelIds) -> Result<(), LightningError>;
1470 // Handler queueing status:
1471 /// Indicates that there are a large number of [`ChannelAnnouncement`] (or other) messages
1472 /// pending some async action. While there is no guarantee of the rate of future messages, the
1473 /// caller should seek to reduce the rate of new gossip messages handled, especially
1474 /// [`ChannelAnnouncement`]s.
1475 fn processing_queue_high(&self) -> bool;
1477 // Handler information:
1478 /// Gets the node feature flags which this handler itself supports. All available handlers are
1479 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1480 /// which are broadcasted in our [`NodeAnnouncement`] message.
1481 fn provided_node_features(&self) -> NodeFeatures;
1482 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1483 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1484 /// which are sent in our [`Init`] message.
1486 /// Note that this method is called before [`Self::peer_connected`].
1487 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1490 /// A trait to describe an object that can receive onion messages.
1491 pub trait OnionMessageHandler : OnionMessageProvider {
1492 /// Handle an incoming `onion_message` message from the given peer.
1493 fn handle_onion_message(&self, peer_node_id: &PublicKey, msg: &OnionMessage);
1494 /// Called when a connection is established with a peer. Can be used to track which peers
1495 /// advertise onion message support and are online.
1497 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1498 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1499 /// message handlers may still wish to communicate with this peer.
1500 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1501 /// Indicates a connection to the peer failed/an existing connection was lost. Allows handlers to
1502 /// drop and refuse to forward onion messages to this peer.
1503 fn peer_disconnected(&self, their_node_id: &PublicKey);
1505 // Handler information:
1506 /// Gets the node feature flags which this handler itself supports. All available handlers are
1507 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1508 /// which are broadcasted in our [`NodeAnnouncement`] message.
1509 fn provided_node_features(&self) -> NodeFeatures;
1511 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1512 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1513 /// which are sent in our [`Init`] message.
1515 /// Note that this method is called before [`Self::peer_connected`].
1516 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1519 mod fuzzy_internal_msgs {
1520 use crate::prelude::*;
1521 use crate::ln::{PaymentPreimage, PaymentSecret};
1523 // These types aren't intended to be pub, but are exposed for direct fuzzing (as we deserialize
1524 // them from untrusted input):
1526 pub struct FinalOnionHopData {
1527 pub payment_secret: PaymentSecret,
1528 /// The total value, in msat, of the payment as received by the ultimate recipient.
1529 /// Message serialization may panic if this value is more than 21 million Bitcoin.
1530 pub total_msat: u64,
1533 pub enum InboundOnionPayload {
1535 short_channel_id: u64,
1536 /// The value, in msat, of the payment after this hop's fee is deducted.
1537 amt_to_forward: u64,
1538 outgoing_cltv_value: u32,
1541 payment_data: Option<FinalOnionHopData>,
1542 payment_metadata: Option<Vec<u8>>,
1543 keysend_preimage: Option<PaymentPreimage>,
1544 custom_tlvs: Vec<(u64, Vec<u8>)>,
1546 outgoing_cltv_value: u32,
1550 pub(crate) enum OutboundOnionPayload {
1552 short_channel_id: u64,
1553 /// The value, in msat, of the payment after this hop's fee is deducted.
1554 amt_to_forward: u64,
1555 outgoing_cltv_value: u32,
1558 payment_data: Option<FinalOnionHopData>,
1559 payment_metadata: Option<Vec<u8>>,
1560 keysend_preimage: Option<PaymentPreimage>,
1561 custom_tlvs: Vec<(u64, Vec<u8>)>,
1563 outgoing_cltv_value: u32,
1567 pub struct DecodedOnionErrorPacket {
1568 pub(crate) hmac: [u8; 32],
1569 pub(crate) failuremsg: Vec<u8>,
1570 pub(crate) pad: Vec<u8>,
1574 pub use self::fuzzy_internal_msgs::*;
1575 #[cfg(not(fuzzing))]
1576 pub(crate) use self::fuzzy_internal_msgs::*;
1579 pub(crate) struct OnionPacket {
1580 pub(crate) version: u8,
1581 /// In order to ensure we always return an error on onion decode in compliance with [BOLT
1582 /// #4](https://github.com/lightning/bolts/blob/master/04-onion-routing.md), we have to
1583 /// deserialize `OnionPacket`s contained in [`UpdateAddHTLC`] messages even if the ephemeral
1584 /// public key (here) is bogus, so we hold a [`Result`] instead of a [`PublicKey`] as we'd
1586 pub(crate) public_key: Result<PublicKey, secp256k1::Error>,
1587 pub(crate) hop_data: [u8; 20*65],
1588 pub(crate) hmac: [u8; 32],
1591 impl onion_utils::Packet for OnionPacket {
1592 type Data = onion_utils::FixedSizeOnionPacket;
1593 fn new(pubkey: PublicKey, hop_data: onion_utils::FixedSizeOnionPacket, hmac: [u8; 32]) -> Self {
1596 public_key: Ok(pubkey),
1597 hop_data: hop_data.0,
1603 impl Eq for OnionPacket { }
1604 impl PartialEq for OnionPacket {
1605 fn eq(&self, other: &OnionPacket) -> bool {
1606 for (i, j) in self.hop_data.iter().zip(other.hop_data.iter()) {
1607 if i != j { return false; }
1609 self.version == other.version &&
1610 self.public_key == other.public_key &&
1611 self.hmac == other.hmac
1615 impl fmt::Debug for OnionPacket {
1616 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1617 f.write_fmt(format_args!("OnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
1621 #[derive(Clone, Debug, PartialEq, Eq)]
1622 pub(crate) struct OnionErrorPacket {
1623 // This really should be a constant size slice, but the spec lets these things be up to 128KB?
1624 // (TODO) We limit it in decode to much lower...
1625 pub(crate) data: Vec<u8>,
1628 impl fmt::Display for DecodeError {
1629 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1631 DecodeError::UnknownVersion => f.write_str("Unknown realm byte in Onion packet"),
1632 DecodeError::UnknownRequiredFeature => f.write_str("Unknown required feature preventing decode"),
1633 DecodeError::InvalidValue => f.write_str("Nonsense bytes didn't map to the type they were interpreted as"),
1634 DecodeError::ShortRead => f.write_str("Packet extended beyond the provided bytes"),
1635 DecodeError::BadLengthDescriptor => f.write_str("A length descriptor in the packet didn't describe the later data correctly"),
1636 DecodeError::Io(ref e) => fmt::Debug::fmt(e, f),
1637 DecodeError::UnsupportedCompression => f.write_str("We don't support receiving messages with zlib-compressed fields"),
1642 impl From<io::Error> for DecodeError {
1643 fn from(e: io::Error) -> Self {
1644 if e.kind() == io::ErrorKind::UnexpectedEof {
1645 DecodeError::ShortRead
1647 DecodeError::Io(e.kind())
1652 #[cfg(not(taproot))]
1653 impl_writeable_msg!(AcceptChannel, {
1654 temporary_channel_id,
1655 dust_limit_satoshis,
1656 max_htlc_value_in_flight_msat,
1657 channel_reserve_satoshis,
1663 revocation_basepoint,
1665 delayed_payment_basepoint,
1667 first_per_commitment_point,
1669 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1670 (1, channel_type, option),
1674 impl_writeable_msg!(AcceptChannel, {
1675 temporary_channel_id,
1676 dust_limit_satoshis,
1677 max_htlc_value_in_flight_msat,
1678 channel_reserve_satoshis,
1684 revocation_basepoint,
1686 delayed_payment_basepoint,
1688 first_per_commitment_point,
1690 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1691 (1, channel_type, option),
1692 (4, next_local_nonce, option),
1695 impl_writeable_msg!(AcceptChannelV2, {
1696 temporary_channel_id,
1698 dust_limit_satoshis,
1699 max_htlc_value_in_flight_msat,
1705 revocation_basepoint,
1707 delayed_payment_basepoint,
1709 first_per_commitment_point,
1710 second_per_commitment_point,
1712 (0, shutdown_scriptpubkey, option),
1713 (1, channel_type, option),
1714 (2, require_confirmed_inputs, option),
1717 impl_writeable_msg!(TxAddInput, {
1725 impl_writeable_msg!(TxAddOutput, {
1732 impl_writeable_msg!(TxRemoveInput, {
1737 impl_writeable_msg!(TxRemoveOutput, {
1742 impl_writeable_msg!(TxComplete, {
1746 impl_writeable_msg!(TxSignatures, {
1752 impl_writeable_msg!(TxInitRbf, {
1755 feerate_sat_per_1000_weight,
1757 (0, funding_output_contribution, option),
1760 impl_writeable_msg!(TxAckRbf, {
1763 (0, funding_output_contribution, option),
1766 impl_writeable_msg!(TxAbort, {
1771 impl_writeable_msg!(AnnouncementSignatures, {
1778 impl_writeable_msg!(ChannelReestablish, {
1780 next_local_commitment_number,
1781 next_remote_commitment_number,
1782 your_last_per_commitment_secret,
1783 my_current_per_commitment_point,
1785 (0, next_funding_txid, option),
1788 impl_writeable_msg!(ClosingSigned,
1789 { channel_id, fee_satoshis, signature },
1790 { (1, fee_range, option) }
1793 impl_writeable!(ClosingSignedFeeRange, {
1798 #[cfg(not(taproot))]
1799 impl_writeable_msg!(CommitmentSigned, {
1806 impl_writeable_msg!(CommitmentSigned, {
1811 (2, partial_signature_with_nonce, option)
1814 impl_writeable!(DecodedOnionErrorPacket, {
1820 #[cfg(not(taproot))]
1821 impl_writeable_msg!(FundingCreated, {
1822 temporary_channel_id,
1824 funding_output_index,
1828 impl_writeable_msg!(FundingCreated, {
1829 temporary_channel_id,
1831 funding_output_index,
1834 (2, partial_signature_with_nonce, option),
1835 (4, next_local_nonce, option)
1838 #[cfg(not(taproot))]
1839 impl_writeable_msg!(FundingSigned, {
1845 impl_writeable_msg!(FundingSigned, {
1849 (2, partial_signature_with_nonce, option)
1852 impl_writeable_msg!(ChannelReady, {
1854 next_per_commitment_point,
1856 (1, short_channel_id_alias, option),
1859 impl Writeable for Init {
1860 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1861 // global_features gets the bottom 13 bits of our features, and local_features gets all of
1862 // our relevant feature bits. This keeps us compatible with old nodes.
1863 self.features.write_up_to_13(w)?;
1864 self.features.write(w)?;
1865 encode_tlv_stream!(w, {
1866 (1, self.networks.as_ref().map(|n| WithoutLength(n)), option),
1867 (3, self.remote_network_address, option),
1873 impl Readable for Init {
1874 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1875 let global_features: InitFeatures = Readable::read(r)?;
1876 let features: InitFeatures = Readable::read(r)?;
1877 let mut remote_network_address: Option<NetAddress> = None;
1878 let mut networks: Option<WithoutLength<Vec<ChainHash>>> = None;
1879 decode_tlv_stream!(r, {
1880 (1, networks, option),
1881 (3, remote_network_address, option)
1884 features: features | global_features,
1885 networks: networks.map(|n| n.0),
1886 remote_network_address,
1891 impl_writeable_msg!(OpenChannel, {
1893 temporary_channel_id,
1896 dust_limit_satoshis,
1897 max_htlc_value_in_flight_msat,
1898 channel_reserve_satoshis,
1904 revocation_basepoint,
1906 delayed_payment_basepoint,
1908 first_per_commitment_point,
1911 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1912 (1, channel_type, option),
1915 impl_writeable_msg!(OpenChannelV2, {
1917 temporary_channel_id,
1918 funding_feerate_sat_per_1000_weight,
1919 commitment_feerate_sat_per_1000_weight,
1921 dust_limit_satoshis,
1922 max_htlc_value_in_flight_msat,
1928 revocation_basepoint,
1930 delayed_payment_basepoint,
1932 first_per_commitment_point,
1933 second_per_commitment_point,
1936 (0, shutdown_scriptpubkey, option),
1937 (1, channel_type, option),
1938 (2, require_confirmed_inputs, option),
1941 #[cfg(not(taproot))]
1942 impl_writeable_msg!(RevokeAndACK, {
1944 per_commitment_secret,
1945 next_per_commitment_point
1949 impl_writeable_msg!(RevokeAndACK, {
1951 per_commitment_secret,
1952 next_per_commitment_point
1954 (4, next_local_nonce, option)
1957 impl_writeable_msg!(Shutdown, {
1962 impl_writeable_msg!(UpdateFailHTLC, {
1968 impl_writeable_msg!(UpdateFailMalformedHTLC, {
1975 impl_writeable_msg!(UpdateFee, {
1980 impl_writeable_msg!(UpdateFulfillHTLC, {
1986 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
1987 // serialization format in a way which assumes we know the total serialized length/message end
1989 impl_writeable!(OnionErrorPacket, {
1993 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
1994 // serialization format in a way which assumes we know the total serialized length/message end
1996 impl Writeable for OnionPacket {
1997 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1998 self.version.write(w)?;
1999 match self.public_key {
2000 Ok(pubkey) => pubkey.write(w)?,
2001 Err(_) => [0u8;33].write(w)?,
2003 w.write_all(&self.hop_data)?;
2004 self.hmac.write(w)?;
2009 impl Readable for OnionPacket {
2010 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2012 version: Readable::read(r)?,
2014 let mut buf = [0u8;33];
2015 r.read_exact(&mut buf)?;
2016 PublicKey::from_slice(&buf)
2018 hop_data: Readable::read(r)?,
2019 hmac: Readable::read(r)?,
2024 impl_writeable_msg!(UpdateAddHTLC, {
2030 onion_routing_packet,
2032 (65537, skimmed_fee_msat, option)
2035 impl Readable for OnionMessage {
2036 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2037 let blinding_point: PublicKey = Readable::read(r)?;
2038 let len: u16 = Readable::read(r)?;
2039 let mut packet_reader = FixedLengthReader::new(r, len as u64);
2040 let onion_routing_packet: onion_message::Packet = <onion_message::Packet as LengthReadable>::read(&mut packet_reader)?;
2043 onion_routing_packet,
2048 impl Writeable for OnionMessage {
2049 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2050 self.blinding_point.write(w)?;
2051 let onion_packet_len = self.onion_routing_packet.serialized_length();
2052 (onion_packet_len as u16).write(w)?;
2053 self.onion_routing_packet.write(w)?;
2058 impl Writeable for FinalOnionHopData {
2059 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2060 self.payment_secret.0.write(w)?;
2061 HighZeroBytesDroppedBigSize(self.total_msat).write(w)
2065 impl Readable for FinalOnionHopData {
2066 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2067 let secret: [u8; 32] = Readable::read(r)?;
2068 let amt: HighZeroBytesDroppedBigSize<u64> = Readable::read(r)?;
2069 Ok(Self { payment_secret: PaymentSecret(secret), total_msat: amt.0 })
2073 impl Writeable for OutboundOnionPayload {
2074 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2076 Self::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } => {
2077 _encode_varint_length_prefixed_tlv!(w, {
2078 (2, HighZeroBytesDroppedBigSize(*amt_to_forward), required),
2079 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2080 (6, short_channel_id, required)
2084 ref payment_data, ref payment_metadata, ref keysend_preimage, amt_msat,
2085 outgoing_cltv_value, ref custom_tlvs,
2087 // We need to update [`ln::outbound_payment::RecipientOnionFields::with_custom_tlvs`]
2088 // to reject any reserved types in the experimental range if new ones are ever
2090 let keysend_tlv = keysend_preimage.map(|preimage| (5482373484, preimage.encode()));
2091 let mut custom_tlvs: Vec<&(u64, Vec<u8>)> = custom_tlvs.iter().chain(keysend_tlv.iter()).collect();
2092 custom_tlvs.sort_unstable_by_key(|(typ, _)| *typ);
2093 _encode_varint_length_prefixed_tlv!(w, {
2094 (2, HighZeroBytesDroppedBigSize(*amt_msat), required),
2095 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2096 (8, payment_data, option),
2097 (16, payment_metadata.as_ref().map(|m| WithoutLength(m)), option)
2098 }, custom_tlvs.iter());
2105 impl Readable for InboundOnionPayload {
2106 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2107 let mut amt = HighZeroBytesDroppedBigSize(0u64);
2108 let mut cltv_value = HighZeroBytesDroppedBigSize(0u32);
2109 let mut short_id: Option<u64> = None;
2110 let mut payment_data: Option<FinalOnionHopData> = None;
2111 let mut payment_metadata: Option<WithoutLength<Vec<u8>>> = None;
2112 let mut keysend_preimage: Option<PaymentPreimage> = None;
2113 let mut custom_tlvs = Vec::new();
2115 let tlv_len = BigSize::read(r)?;
2116 let rd = FixedLengthReader::new(r, tlv_len.0);
2117 decode_tlv_stream_with_custom_tlv_decode!(rd, {
2119 (4, cltv_value, required),
2120 (6, short_id, option),
2121 (8, payment_data, option),
2122 (16, payment_metadata, option),
2123 // See https://github.com/lightning/blips/blob/master/blip-0003.md
2124 (5482373484, keysend_preimage, option)
2125 }, |msg_type: u64, msg_reader: &mut FixedLengthReader<_>| -> Result<bool, DecodeError> {
2126 if msg_type < 1 << 16 { return Ok(false) }
2127 let mut value = Vec::new();
2128 msg_reader.read_to_end(&mut value)?;
2129 custom_tlvs.push((msg_type, value));
2133 if amt.0 > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2134 if let Some(short_channel_id) = short_id {
2135 if payment_data.is_some() { return Err(DecodeError::InvalidValue) }
2136 if payment_metadata.is_some() { return Err(DecodeError::InvalidValue); }
2139 amt_to_forward: amt.0,
2140 outgoing_cltv_value: cltv_value.0,
2143 if let Some(data) = &payment_data {
2144 if data.total_msat > MAX_VALUE_MSAT {
2145 return Err(DecodeError::InvalidValue);
2150 payment_metadata: payment_metadata.map(|w| w.0),
2153 outgoing_cltv_value: cltv_value.0,
2160 // ReadableArgs because we need onion_utils::decode_next_hop to accommodate payment packets and
2161 // onion message packets.
2162 impl ReadableArgs<()> for InboundOnionPayload {
2163 fn read<R: Read>(r: &mut R, _arg: ()) -> Result<Self, DecodeError> {
2164 <Self as Readable>::read(r)
2168 impl Writeable for Ping {
2169 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2170 self.ponglen.write(w)?;
2171 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2176 impl Readable for Ping {
2177 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2179 ponglen: Readable::read(r)?,
2181 let byteslen = Readable::read(r)?;
2182 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2189 impl Writeable for Pong {
2190 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2191 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2196 impl Readable for Pong {
2197 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2200 let byteslen = Readable::read(r)?;
2201 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2208 impl Writeable for UnsignedChannelAnnouncement {
2209 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2210 self.features.write(w)?;
2211 self.chain_hash.write(w)?;
2212 self.short_channel_id.write(w)?;
2213 self.node_id_1.write(w)?;
2214 self.node_id_2.write(w)?;
2215 self.bitcoin_key_1.write(w)?;
2216 self.bitcoin_key_2.write(w)?;
2217 w.write_all(&self.excess_data[..])?;
2222 impl Readable for UnsignedChannelAnnouncement {
2223 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2225 features: Readable::read(r)?,
2226 chain_hash: Readable::read(r)?,
2227 short_channel_id: Readable::read(r)?,
2228 node_id_1: Readable::read(r)?,
2229 node_id_2: Readable::read(r)?,
2230 bitcoin_key_1: Readable::read(r)?,
2231 bitcoin_key_2: Readable::read(r)?,
2232 excess_data: read_to_end(r)?,
2237 impl_writeable!(ChannelAnnouncement, {
2240 bitcoin_signature_1,
2241 bitcoin_signature_2,
2245 impl Writeable for UnsignedChannelUpdate {
2246 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2247 // `message_flags` used to indicate presence of `htlc_maximum_msat`, but was deprecated in the spec.
2248 const MESSAGE_FLAGS: u8 = 1;
2249 self.chain_hash.write(w)?;
2250 self.short_channel_id.write(w)?;
2251 self.timestamp.write(w)?;
2252 let all_flags = self.flags as u16 | ((MESSAGE_FLAGS as u16) << 8);
2253 all_flags.write(w)?;
2254 self.cltv_expiry_delta.write(w)?;
2255 self.htlc_minimum_msat.write(w)?;
2256 self.fee_base_msat.write(w)?;
2257 self.fee_proportional_millionths.write(w)?;
2258 self.htlc_maximum_msat.write(w)?;
2259 w.write_all(&self.excess_data[..])?;
2264 impl Readable for UnsignedChannelUpdate {
2265 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2267 chain_hash: Readable::read(r)?,
2268 short_channel_id: Readable::read(r)?,
2269 timestamp: Readable::read(r)?,
2271 let flags: u16 = Readable::read(r)?;
2272 // Note: we ignore the `message_flags` for now, since it was deprecated by the spec.
2275 cltv_expiry_delta: Readable::read(r)?,
2276 htlc_minimum_msat: Readable::read(r)?,
2277 fee_base_msat: Readable::read(r)?,
2278 fee_proportional_millionths: Readable::read(r)?,
2279 htlc_maximum_msat: Readable::read(r)?,
2280 excess_data: read_to_end(r)?,
2285 impl_writeable!(ChannelUpdate, {
2290 impl Writeable for ErrorMessage {
2291 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2292 self.channel_id.write(w)?;
2293 (self.data.len() as u16).write(w)?;
2294 w.write_all(self.data.as_bytes())?;
2299 impl Readable for ErrorMessage {
2300 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2302 channel_id: Readable::read(r)?,
2304 let sz: usize = <u16 as Readable>::read(r)? as usize;
2305 let mut data = Vec::with_capacity(sz);
2307 r.read_exact(&mut data)?;
2308 match String::from_utf8(data) {
2310 Err(_) => return Err(DecodeError::InvalidValue),
2317 impl Writeable for WarningMessage {
2318 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2319 self.channel_id.write(w)?;
2320 (self.data.len() as u16).write(w)?;
2321 w.write_all(self.data.as_bytes())?;
2326 impl Readable for WarningMessage {
2327 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2329 channel_id: Readable::read(r)?,
2331 let sz: usize = <u16 as Readable>::read(r)? as usize;
2332 let mut data = Vec::with_capacity(sz);
2334 r.read_exact(&mut data)?;
2335 match String::from_utf8(data) {
2337 Err(_) => return Err(DecodeError::InvalidValue),
2344 impl Writeable for UnsignedNodeAnnouncement {
2345 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2346 self.features.write(w)?;
2347 self.timestamp.write(w)?;
2348 self.node_id.write(w)?;
2349 w.write_all(&self.rgb)?;
2350 self.alias.write(w)?;
2352 let mut addr_len = 0;
2353 for addr in self.addresses.iter() {
2354 addr_len += 1 + addr.len();
2356 (addr_len + self.excess_address_data.len() as u16).write(w)?;
2357 for addr in self.addresses.iter() {
2360 w.write_all(&self.excess_address_data[..])?;
2361 w.write_all(&self.excess_data[..])?;
2366 impl Readable for UnsignedNodeAnnouncement {
2367 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2368 let features: NodeFeatures = Readable::read(r)?;
2369 let timestamp: u32 = Readable::read(r)?;
2370 let node_id: NodeId = Readable::read(r)?;
2371 let mut rgb = [0; 3];
2372 r.read_exact(&mut rgb)?;
2373 let alias: NodeAlias = Readable::read(r)?;
2375 let addr_len: u16 = Readable::read(r)?;
2376 let mut addresses: Vec<NetAddress> = Vec::new();
2377 let mut addr_readpos = 0;
2378 let mut excess = false;
2379 let mut excess_byte = 0;
2381 if addr_len <= addr_readpos { break; }
2382 match Readable::read(r) {
2384 if addr_len < addr_readpos + 1 + addr.len() {
2385 return Err(DecodeError::BadLengthDescriptor);
2387 addr_readpos += (1 + addr.len()) as u16;
2388 addresses.push(addr);
2390 Ok(Err(unknown_descriptor)) => {
2392 excess_byte = unknown_descriptor;
2395 Err(DecodeError::ShortRead) => return Err(DecodeError::BadLengthDescriptor),
2396 Err(e) => return Err(e),
2400 let mut excess_data = vec![];
2401 let excess_address_data = if addr_readpos < addr_len {
2402 let mut excess_address_data = vec![0; (addr_len - addr_readpos) as usize];
2403 r.read_exact(&mut excess_address_data[if excess { 1 } else { 0 }..])?;
2405 excess_address_data[0] = excess_byte;
2410 excess_data.push(excess_byte);
2414 excess_data.extend(read_to_end(r)?.iter());
2415 Ok(UnsignedNodeAnnouncement {
2422 excess_address_data,
2428 impl_writeable!(NodeAnnouncement, {
2433 impl Readable for QueryShortChannelIds {
2434 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2435 let chain_hash: BlockHash = Readable::read(r)?;
2437 let encoding_len: u16 = Readable::read(r)?;
2438 let encoding_type: u8 = Readable::read(r)?;
2440 // Must be encoding_type=0 uncompressed serialization. We do not
2441 // support encoding_type=1 zlib serialization.
2442 if encoding_type != EncodingType::Uncompressed as u8 {
2443 return Err(DecodeError::UnsupportedCompression);
2446 // We expect the encoding_len to always includes the 1-byte
2447 // encoding_type and that short_channel_ids are 8-bytes each
2448 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2449 return Err(DecodeError::InvalidValue);
2452 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2453 // less the 1-byte encoding_type
2454 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2455 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2456 for _ in 0..short_channel_id_count {
2457 short_channel_ids.push(Readable::read(r)?);
2460 Ok(QueryShortChannelIds {
2467 impl Writeable for QueryShortChannelIds {
2468 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2469 // Calculated from 1-byte encoding_type plus 8-bytes per short_channel_id
2470 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2472 self.chain_hash.write(w)?;
2473 encoding_len.write(w)?;
2475 // We only support type=0 uncompressed serialization
2476 (EncodingType::Uncompressed as u8).write(w)?;
2478 for scid in self.short_channel_ids.iter() {
2486 impl_writeable_msg!(ReplyShortChannelIdsEnd, {
2491 impl QueryChannelRange {
2492 /// Calculates the overflow safe ending block height for the query.
2494 /// Overflow returns `0xffffffff`, otherwise returns `first_blocknum + number_of_blocks`.
2495 pub fn end_blocknum(&self) -> u32 {
2496 match self.first_blocknum.checked_add(self.number_of_blocks) {
2497 Some(block) => block,
2498 None => u32::max_value(),
2503 impl_writeable_msg!(QueryChannelRange, {
2509 impl Readable for ReplyChannelRange {
2510 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2511 let chain_hash: BlockHash = Readable::read(r)?;
2512 let first_blocknum: u32 = Readable::read(r)?;
2513 let number_of_blocks: u32 = Readable::read(r)?;
2514 let sync_complete: bool = Readable::read(r)?;
2516 let encoding_len: u16 = Readable::read(r)?;
2517 let encoding_type: u8 = Readable::read(r)?;
2519 // Must be encoding_type=0 uncompressed serialization. We do not
2520 // support encoding_type=1 zlib serialization.
2521 if encoding_type != EncodingType::Uncompressed as u8 {
2522 return Err(DecodeError::UnsupportedCompression);
2525 // We expect the encoding_len to always includes the 1-byte
2526 // encoding_type and that short_channel_ids are 8-bytes each
2527 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2528 return Err(DecodeError::InvalidValue);
2531 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2532 // less the 1-byte encoding_type
2533 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2534 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2535 for _ in 0..short_channel_id_count {
2536 short_channel_ids.push(Readable::read(r)?);
2539 Ok(ReplyChannelRange {
2549 impl Writeable for ReplyChannelRange {
2550 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2551 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2552 self.chain_hash.write(w)?;
2553 self.first_blocknum.write(w)?;
2554 self.number_of_blocks.write(w)?;
2555 self.sync_complete.write(w)?;
2557 encoding_len.write(w)?;
2558 (EncodingType::Uncompressed as u8).write(w)?;
2559 for scid in self.short_channel_ids.iter() {
2567 impl_writeable_msg!(GossipTimestampFilter, {
2575 use std::convert::TryFrom;
2576 use bitcoin::blockdata::constants::ChainHash;
2577 use bitcoin::{Transaction, PackedLockTime, TxIn, Script, Sequence, Witness, TxOut};
2579 use crate::ln::{PaymentPreimage, PaymentHash, PaymentSecret};
2580 use crate::ln::ChannelId;
2581 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
2582 use crate::ln::msgs::{self, FinalOnionHopData, OnionErrorPacket};
2583 use crate::ln::msgs::NetAddress;
2584 use crate::routing::gossip::{NodeAlias, NodeId};
2585 use crate::util::ser::{Writeable, Readable, Hostname, TransactionU16LenLimited};
2587 use bitcoin::hashes::hex::FromHex;
2588 use bitcoin::util::address::Address;
2589 use bitcoin::network::constants::Network;
2590 use bitcoin::blockdata::script::Builder;
2591 use bitcoin::blockdata::opcodes;
2592 use bitcoin::hash_types::{Txid, BlockHash};
2594 use bitcoin::secp256k1::{PublicKey,SecretKey};
2595 use bitcoin::secp256k1::{Secp256k1, Message};
2597 use crate::io::{self, Cursor};
2598 use crate::prelude::*;
2599 use core::str::FromStr;
2600 use crate::chain::transaction::OutPoint;
2602 #[cfg(feature = "std")]
2603 use std::net::{Ipv4Addr, Ipv6Addr};
2604 use crate::ln::msgs::NetAddressParseError;
2607 fn encoding_channel_reestablish() {
2609 let secp_ctx = Secp256k1::new();
2610 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2613 let cr = msgs::ChannelReestablish {
2614 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]),
2615 next_local_commitment_number: 3,
2616 next_remote_commitment_number: 4,
2617 your_last_per_commitment_secret: [9;32],
2618 my_current_per_commitment_point: public_key,
2619 next_funding_txid: None,
2622 let encoded_value = cr.encode();
2626 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
2627 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2628 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2629 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
2630 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
2636 fn encoding_channel_reestablish_with_next_funding_txid() {
2638 let secp_ctx = Secp256k1::new();
2639 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2642 let cr = msgs::ChannelReestablish {
2643 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]),
2644 next_local_commitment_number: 3,
2645 next_remote_commitment_number: 4,
2646 your_last_per_commitment_secret: [9;32],
2647 my_current_per_commitment_point: public_key,
2648 next_funding_txid: Some(Txid::from_hash(bitcoin::hashes::Hash::from_slice(&[
2649 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,
2653 let encoded_value = cr.encode();
2657 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
2658 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2659 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2660 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
2661 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
2662 0, // Type (next_funding_txid)
2664 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
2669 macro_rules! get_keys_from {
2670 ($slice: expr, $secp_ctx: expr) => {
2672 let privkey = SecretKey::from_slice(&hex::decode($slice).unwrap()[..]).unwrap();
2673 let pubkey = PublicKey::from_secret_key(&$secp_ctx, &privkey);
2679 macro_rules! get_sig_on {
2680 ($privkey: expr, $ctx: expr, $string: expr) => {
2682 let sighash = Message::from_slice(&$string.into_bytes()[..]).unwrap();
2683 $ctx.sign_ecdsa(&sighash, &$privkey)
2689 fn encoding_announcement_signatures() {
2690 let secp_ctx = Secp256k1::new();
2691 let (privkey, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2692 let sig_1 = get_sig_on!(privkey, secp_ctx, String::from("01010101010101010101010101010101"));
2693 let sig_2 = get_sig_on!(privkey, secp_ctx, String::from("02020202020202020202020202020202"));
2694 let announcement_signatures = msgs::AnnouncementSignatures {
2695 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]),
2696 short_channel_id: 2316138423780173,
2697 node_signature: sig_1,
2698 bitcoin_signature: sig_2,
2701 let encoded_value = announcement_signatures.encode();
2702 assert_eq!(encoded_value, hex::decode("040000000000000005000000000000000600000000000000070000000000000000083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073acf9953cef4700860f5967838eba2bae89288ad188ebf8b20bf995c3ea53a26df1876d0a3a0e13172ba286a673140190c02ba9da60a2e43a745188c8a83c7f3ef").unwrap());
2705 fn do_encoding_channel_announcement(unknown_features_bits: bool, excess_data: bool) {
2706 let secp_ctx = Secp256k1::new();
2707 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2708 let (privkey_2, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2709 let (privkey_3, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2710 let (privkey_4, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2711 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2712 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
2713 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
2714 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
2715 let mut features = ChannelFeatures::empty();
2716 if unknown_features_bits {
2717 features = ChannelFeatures::from_le_bytes(vec![0xFF, 0xFF]);
2719 let unsigned_channel_announcement = msgs::UnsignedChannelAnnouncement {
2721 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2722 short_channel_id: 2316138423780173,
2723 node_id_1: NodeId::from_pubkey(&pubkey_1),
2724 node_id_2: NodeId::from_pubkey(&pubkey_2),
2725 bitcoin_key_1: NodeId::from_pubkey(&pubkey_3),
2726 bitcoin_key_2: NodeId::from_pubkey(&pubkey_4),
2727 excess_data: if excess_data { vec![10, 0, 0, 20, 0, 0, 30, 0, 0, 40] } else { Vec::new() },
2729 let channel_announcement = msgs::ChannelAnnouncement {
2730 node_signature_1: sig_1,
2731 node_signature_2: sig_2,
2732 bitcoin_signature_1: sig_3,
2733 bitcoin_signature_2: sig_4,
2734 contents: unsigned_channel_announcement,
2736 let encoded_value = channel_announcement.encode();
2737 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a1735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap();
2738 if unknown_features_bits {
2739 target_value.append(&mut hex::decode("0002ffff").unwrap());
2741 target_value.append(&mut hex::decode("0000").unwrap());
2743 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2744 target_value.append(&mut hex::decode("00083a840000034d031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
2746 target_value.append(&mut hex::decode("0a00001400001e000028").unwrap());
2748 assert_eq!(encoded_value, target_value);
2752 fn encoding_channel_announcement() {
2753 do_encoding_channel_announcement(true, false);
2754 do_encoding_channel_announcement(false, true);
2755 do_encoding_channel_announcement(false, false);
2756 do_encoding_channel_announcement(true, true);
2759 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) {
2760 let secp_ctx = Secp256k1::new();
2761 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2762 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2763 let features = if unknown_features_bits {
2764 NodeFeatures::from_le_bytes(vec![0xFF, 0xFF])
2766 // Set to some features we may support
2767 NodeFeatures::from_le_bytes(vec![2 | 1 << 5])
2769 let mut addresses = Vec::new();
2771 addresses.push(NetAddress::IPv4 {
2772 addr: [255, 254, 253, 252],
2777 addresses.push(NetAddress::IPv6 {
2778 addr: [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240],
2783 addresses.push(NetAddress::OnionV2(
2784 [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 38, 7]
2788 addresses.push(NetAddress::OnionV3 {
2789 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],
2796 addresses.push(NetAddress::Hostname {
2797 hostname: Hostname::try_from(String::from("host")).unwrap(),
2801 let mut addr_len = 0;
2802 for addr in &addresses {
2803 addr_len += addr.len() + 1;
2805 let unsigned_node_announcement = msgs::UnsignedNodeAnnouncement {
2807 timestamp: 20190119,
2808 node_id: NodeId::from_pubkey(&pubkey_1),
2810 alias: NodeAlias([16;32]),
2812 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() },
2813 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() },
2815 addr_len += unsigned_node_announcement.excess_address_data.len() as u16;
2816 let node_announcement = msgs::NodeAnnouncement {
2818 contents: unsigned_node_announcement,
2820 let encoded_value = node_announcement.encode();
2821 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
2822 if unknown_features_bits {
2823 target_value.append(&mut hex::decode("0002ffff").unwrap());
2825 target_value.append(&mut hex::decode("000122").unwrap());
2827 target_value.append(&mut hex::decode("013413a7031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f2020201010101010101010101010101010101010101010101010101010101010101010").unwrap());
2828 target_value.append(&mut vec![(addr_len >> 8) as u8, addr_len as u8]);
2830 target_value.append(&mut hex::decode("01fffefdfc2607").unwrap());
2833 target_value.append(&mut hex::decode("02fffefdfcfbfaf9f8f7f6f5f4f3f2f1f02607").unwrap());
2836 target_value.append(&mut hex::decode("03fffefdfcfbfaf9f8f7f62607").unwrap());
2839 target_value.append(&mut hex::decode("04fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0efeeedecebeae9e8e7e6e5e4e3e2e1e00020102607").unwrap());
2842 target_value.append(&mut hex::decode("0504686f73742607").unwrap());
2844 if excess_address_data {
2845 target_value.append(&mut hex::decode("216c280b5395a2546e7e4b2663e04f811622f15a4f92e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d269").unwrap());
2848 target_value.append(&mut hex::decode("3b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
2850 assert_eq!(encoded_value, target_value);
2854 fn encoding_node_announcement() {
2855 do_encoding_node_announcement(true, true, true, true, true, true, true, true);
2856 do_encoding_node_announcement(false, false, false, false, false, false, false, false);
2857 do_encoding_node_announcement(false, true, false, false, false, false, false, false);
2858 do_encoding_node_announcement(false, false, true, false, false, false, false, false);
2859 do_encoding_node_announcement(false, false, false, true, false, false, false, false);
2860 do_encoding_node_announcement(false, false, false, false, true, false, false, false);
2861 do_encoding_node_announcement(false, false, false, false, false, true, false, false);
2862 do_encoding_node_announcement(false, false, false, false, false, false, true, false);
2863 do_encoding_node_announcement(false, true, false, true, false, false, true, false);
2864 do_encoding_node_announcement(false, false, true, false, true, false, false, false);
2867 fn do_encoding_channel_update(direction: bool, disable: bool, excess_data: bool) {
2868 let secp_ctx = Secp256k1::new();
2869 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2870 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2871 let unsigned_channel_update = msgs::UnsignedChannelUpdate {
2872 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2873 short_channel_id: 2316138423780173,
2874 timestamp: 20190119,
2875 flags: if direction { 1 } else { 0 } | if disable { 1 << 1 } else { 0 },
2876 cltv_expiry_delta: 144,
2877 htlc_minimum_msat: 1000000,
2878 htlc_maximum_msat: 131355275467161,
2879 fee_base_msat: 10000,
2880 fee_proportional_millionths: 20,
2881 excess_data: if excess_data { vec![0, 0, 0, 0, 59, 154, 202, 0] } else { Vec::new() }
2883 let channel_update = msgs::ChannelUpdate {
2885 contents: unsigned_channel_update
2887 let encoded_value = channel_update.encode();
2888 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
2889 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2890 target_value.append(&mut hex::decode("00083a840000034d013413a7").unwrap());
2891 target_value.append(&mut hex::decode("01").unwrap());
2892 target_value.append(&mut hex::decode("00").unwrap());
2894 let flag = target_value.last_mut().unwrap();
2898 let flag = target_value.last_mut().unwrap();
2899 *flag = *flag | 1 << 1;
2901 target_value.append(&mut hex::decode("009000000000000f42400000271000000014").unwrap());
2902 target_value.append(&mut hex::decode("0000777788889999").unwrap());
2904 target_value.append(&mut hex::decode("000000003b9aca00").unwrap());
2906 assert_eq!(encoded_value, target_value);
2910 fn encoding_channel_update() {
2911 do_encoding_channel_update(false, false, false);
2912 do_encoding_channel_update(false, false, true);
2913 do_encoding_channel_update(true, false, false);
2914 do_encoding_channel_update(true, false, true);
2915 do_encoding_channel_update(false, true, false);
2916 do_encoding_channel_update(false, true, true);
2917 do_encoding_channel_update(true, true, false);
2918 do_encoding_channel_update(true, true, true);
2921 fn do_encoding_open_channel(random_bit: bool, shutdown: bool, incl_chan_type: bool) {
2922 let secp_ctx = Secp256k1::new();
2923 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2924 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2925 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2926 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2927 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
2928 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
2929 let open_channel = msgs::OpenChannel {
2930 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2931 temporary_channel_id: ChannelId::from_bytes([2; 32]),
2932 funding_satoshis: 1311768467284833366,
2933 push_msat: 2536655962884945560,
2934 dust_limit_satoshis: 3608586615801332854,
2935 max_htlc_value_in_flight_msat: 8517154655701053848,
2936 channel_reserve_satoshis: 8665828695742877976,
2937 htlc_minimum_msat: 2316138423780173,
2938 feerate_per_kw: 821716,
2939 to_self_delay: 49340,
2940 max_accepted_htlcs: 49340,
2941 funding_pubkey: pubkey_1,
2942 revocation_basepoint: pubkey_2,
2943 payment_point: pubkey_3,
2944 delayed_payment_basepoint: pubkey_4,
2945 htlc_basepoint: pubkey_5,
2946 first_per_commitment_point: pubkey_6,
2947 channel_flags: if random_bit { 1 << 5 } else { 0 },
2948 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
2949 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
2951 let encoded_value = open_channel.encode();
2952 let mut target_value = Vec::new();
2953 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2954 target_value.append(&mut hex::decode("02020202020202020202020202020202020202020202020202020202020202021234567890123456233403289122369832144668701144767633030896203198784335490624111800083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
2956 target_value.append(&mut hex::decode("20").unwrap());
2958 target_value.append(&mut hex::decode("00").unwrap());
2961 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
2964 target_value.append(&mut hex::decode("0100").unwrap());
2966 assert_eq!(encoded_value, target_value);
2970 fn encoding_open_channel() {
2971 do_encoding_open_channel(false, false, false);
2972 do_encoding_open_channel(false, false, true);
2973 do_encoding_open_channel(false, true, false);
2974 do_encoding_open_channel(false, true, true);
2975 do_encoding_open_channel(true, false, false);
2976 do_encoding_open_channel(true, false, true);
2977 do_encoding_open_channel(true, true, false);
2978 do_encoding_open_channel(true, true, true);
2981 fn do_encoding_open_channelv2(random_bit: bool, shutdown: bool, incl_chan_type: bool, require_confirmed_inputs: bool) {
2982 let secp_ctx = Secp256k1::new();
2983 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2984 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2985 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2986 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2987 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
2988 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
2989 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
2990 let open_channelv2 = msgs::OpenChannelV2 {
2991 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2992 temporary_channel_id: ChannelId::from_bytes([2; 32]),
2993 funding_feerate_sat_per_1000_weight: 821716,
2994 commitment_feerate_sat_per_1000_weight: 821716,
2995 funding_satoshis: 1311768467284833366,
2996 dust_limit_satoshis: 3608586615801332854,
2997 max_htlc_value_in_flight_msat: 8517154655701053848,
2998 htlc_minimum_msat: 2316138423780173,
2999 to_self_delay: 49340,
3000 max_accepted_htlcs: 49340,
3001 locktime: 305419896,
3002 funding_pubkey: pubkey_1,
3003 revocation_basepoint: pubkey_2,
3004 payment_basepoint: pubkey_3,
3005 delayed_payment_basepoint: pubkey_4,
3006 htlc_basepoint: pubkey_5,
3007 first_per_commitment_point: pubkey_6,
3008 second_per_commitment_point: pubkey_7,
3009 channel_flags: if random_bit { 1 << 5 } else { 0 },
3010 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3011 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3012 require_confirmed_inputs: if require_confirmed_inputs { Some(()) } else { None },
3014 let encoded_value = open_channelv2.encode();
3015 let mut target_value = Vec::new();
3016 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
3017 target_value.append(&mut hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap());
3018 target_value.append(&mut hex::decode("000c89d4").unwrap());
3019 target_value.append(&mut hex::decode("000c89d4").unwrap());
3020 target_value.append(&mut hex::decode("1234567890123456").unwrap());
3021 target_value.append(&mut hex::decode("3214466870114476").unwrap());
3022 target_value.append(&mut hex::decode("7633030896203198").unwrap());
3023 target_value.append(&mut hex::decode("00083a840000034d").unwrap());
3024 target_value.append(&mut hex::decode("c0bc").unwrap());
3025 target_value.append(&mut hex::decode("c0bc").unwrap());
3026 target_value.append(&mut hex::decode("12345678").unwrap());
3027 target_value.append(&mut hex::decode("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap());
3028 target_value.append(&mut hex::decode("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap());
3029 target_value.append(&mut hex::decode("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap());
3030 target_value.append(&mut hex::decode("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
3031 target_value.append(&mut hex::decode("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap());
3032 target_value.append(&mut hex::decode("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3033 target_value.append(&mut hex::decode("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap());
3036 target_value.append(&mut hex::decode("20").unwrap());
3038 target_value.append(&mut hex::decode("00").unwrap());
3041 target_value.append(&mut hex::decode("001b").unwrap()); // Type 0 + Length 27
3042 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3045 target_value.append(&mut hex::decode("0100").unwrap());
3047 if require_confirmed_inputs {
3048 target_value.append(&mut hex::decode("0200").unwrap());
3050 assert_eq!(encoded_value, target_value);
3054 fn encoding_open_channelv2() {
3055 do_encoding_open_channelv2(false, false, false, false);
3056 do_encoding_open_channelv2(false, false, false, true);
3057 do_encoding_open_channelv2(false, false, true, false);
3058 do_encoding_open_channelv2(false, false, true, true);
3059 do_encoding_open_channelv2(false, true, false, false);
3060 do_encoding_open_channelv2(false, true, false, true);
3061 do_encoding_open_channelv2(false, true, true, false);
3062 do_encoding_open_channelv2(false, true, true, true);
3063 do_encoding_open_channelv2(true, false, false, false);
3064 do_encoding_open_channelv2(true, false, false, true);
3065 do_encoding_open_channelv2(true, false, true, false);
3066 do_encoding_open_channelv2(true, false, true, true);
3067 do_encoding_open_channelv2(true, true, false, false);
3068 do_encoding_open_channelv2(true, true, false, true);
3069 do_encoding_open_channelv2(true, true, true, false);
3070 do_encoding_open_channelv2(true, true, true, true);
3073 fn do_encoding_accept_channel(shutdown: bool) {
3074 let secp_ctx = Secp256k1::new();
3075 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3076 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3077 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3078 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3079 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3080 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3081 let accept_channel = msgs::AcceptChannel {
3082 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3083 dust_limit_satoshis: 1311768467284833366,
3084 max_htlc_value_in_flight_msat: 2536655962884945560,
3085 channel_reserve_satoshis: 3608586615801332854,
3086 htlc_minimum_msat: 2316138423780173,
3087 minimum_depth: 821716,
3088 to_self_delay: 49340,
3089 max_accepted_htlcs: 49340,
3090 funding_pubkey: pubkey_1,
3091 revocation_basepoint: pubkey_2,
3092 payment_point: pubkey_3,
3093 delayed_payment_basepoint: pubkey_4,
3094 htlc_basepoint: pubkey_5,
3095 first_per_commitment_point: pubkey_6,
3096 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3099 next_local_nonce: None,
3101 let encoded_value = accept_channel.encode();
3102 let mut target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020212345678901234562334032891223698321446687011447600083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap();
3104 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3106 assert_eq!(encoded_value, target_value);
3110 fn encoding_accept_channel() {
3111 do_encoding_accept_channel(false);
3112 do_encoding_accept_channel(true);
3115 fn do_encoding_accept_channelv2(shutdown: bool) {
3116 let secp_ctx = Secp256k1::new();
3117 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3118 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3119 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3120 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3121 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3122 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3123 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3124 let accept_channelv2 = msgs::AcceptChannelV2 {
3125 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3126 funding_satoshis: 1311768467284833366,
3127 dust_limit_satoshis: 1311768467284833366,
3128 max_htlc_value_in_flight_msat: 2536655962884945560,
3129 htlc_minimum_msat: 2316138423780173,
3130 minimum_depth: 821716,
3131 to_self_delay: 49340,
3132 max_accepted_htlcs: 49340,
3133 funding_pubkey: pubkey_1,
3134 revocation_basepoint: pubkey_2,
3135 payment_basepoint: pubkey_3,
3136 delayed_payment_basepoint: pubkey_4,
3137 htlc_basepoint: pubkey_5,
3138 first_per_commitment_point: pubkey_6,
3139 second_per_commitment_point: pubkey_7,
3140 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3142 require_confirmed_inputs: None,
3144 let encoded_value = accept_channelv2.encode();
3145 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // temporary_channel_id
3146 target_value.append(&mut hex::decode("1234567890123456").unwrap()); // funding_satoshis
3147 target_value.append(&mut hex::decode("1234567890123456").unwrap()); // dust_limit_satoshis
3148 target_value.append(&mut hex::decode("2334032891223698").unwrap()); // max_htlc_value_in_flight_msat
3149 target_value.append(&mut hex::decode("00083a840000034d").unwrap()); // htlc_minimum_msat
3150 target_value.append(&mut hex::decode("000c89d4").unwrap()); // minimum_depth
3151 target_value.append(&mut hex::decode("c0bc").unwrap()); // to_self_delay
3152 target_value.append(&mut hex::decode("c0bc").unwrap()); // max_accepted_htlcs
3153 target_value.append(&mut hex::decode("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap()); // funding_pubkey
3154 target_value.append(&mut hex::decode("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap()); // revocation_basepoint
3155 target_value.append(&mut hex::decode("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap()); // payment_basepoint
3156 target_value.append(&mut hex::decode("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap()); // delayed_payment_basepoint
3157 target_value.append(&mut hex::decode("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap()); // htlc_basepoint
3158 target_value.append(&mut hex::decode("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap()); // first_per_commitment_point
3159 target_value.append(&mut hex::decode("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap()); // second_per_commitment_point
3161 target_value.append(&mut hex::decode("001b").unwrap()); // Type 0 + Length 27
3162 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3164 assert_eq!(encoded_value, target_value);
3168 fn encoding_accept_channelv2() {
3169 do_encoding_accept_channelv2(false);
3170 do_encoding_accept_channelv2(true);
3174 fn encoding_funding_created() {
3175 let secp_ctx = Secp256k1::new();
3176 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3177 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3178 let funding_created = msgs::FundingCreated {
3179 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3180 funding_txid: Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3181 funding_output_index: 255,
3184 partial_signature_with_nonce: None,
3186 next_local_nonce: None,
3188 let encoded_value = funding_created.encode();
3189 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202026e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c200ffd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3190 assert_eq!(encoded_value, target_value);
3194 fn encoding_funding_signed() {
3195 let secp_ctx = Secp256k1::new();
3196 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3197 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3198 let funding_signed = msgs::FundingSigned {
3199 channel_id: ChannelId::from_bytes([2; 32]),
3202 partial_signature_with_nonce: None,
3204 let encoded_value = funding_signed.encode();
3205 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3206 assert_eq!(encoded_value, target_value);
3210 fn encoding_channel_ready() {
3211 let secp_ctx = Secp256k1::new();
3212 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3213 let channel_ready = msgs::ChannelReady {
3214 channel_id: ChannelId::from_bytes([2; 32]),
3215 next_per_commitment_point: pubkey_1,
3216 short_channel_id_alias: None,
3218 let encoded_value = channel_ready.encode();
3219 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3220 assert_eq!(encoded_value, target_value);
3224 fn encoding_tx_add_input() {
3225 let tx_add_input = msgs::TxAddInput {
3226 channel_id: ChannelId::from_bytes([2; 32]),
3227 serial_id: 4886718345,
3228 prevtx: TransactionU16LenLimited::new(Transaction {
3230 lock_time: PackedLockTime(0),
3232 previous_output: OutPoint { txid: Txid::from_hex("305bab643ee297b8b6b76b320792c8223d55082122cb606bf89382146ced9c77").unwrap(), index: 2 }.into_bitcoin_outpoint(),
3233 script_sig: Script::new(),
3234 sequence: Sequence(0xfffffffd),
3235 witness: Witness::from_vec(vec![
3236 hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3237 hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3242 script_pubkey: Address::from_str("bc1qzlffunw52jav8vwdu5x3jfk6sr8u22rmq3xzw2").unwrap().script_pubkey(),
3246 script_pubkey: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().script_pubkey(),
3250 prevtx_out: 305419896,
3251 sequence: 305419896,
3253 let encoded_value = tx_add_input.encode();
3254 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000000012345678900de02000000000101779ced6c148293f86b60cb222108553d22c89207326bb7b6b897e23e64ab5b300200000000fdffffff0236dbc1000000000016001417d29e4dd454bac3b1cde50d1926da80cfc5287b9cbd03000000000016001436ec78d514df462da95e6a00c24daa8915362d420247304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701210301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944000000001234567812345678").unwrap();
3255 assert_eq!(encoded_value, target_value);
3259 fn encoding_tx_add_output() {
3260 let tx_add_output = msgs::TxAddOutput {
3261 channel_id: ChannelId::from_bytes([2; 32]),
3262 serial_id: 4886718345,
3264 script: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().script_pubkey(),
3266 let encoded_value = tx_add_output.encode();
3267 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000000012345678900000001234567890016001436ec78d514df462da95e6a00c24daa8915362d42").unwrap();
3268 assert_eq!(encoded_value, target_value);
3272 fn encoding_tx_remove_input() {
3273 let tx_remove_input = msgs::TxRemoveInput {
3274 channel_id: ChannelId::from_bytes([2; 32]),
3275 serial_id: 4886718345,
3277 let encoded_value = tx_remove_input.encode();
3278 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3279 assert_eq!(encoded_value, target_value);
3283 fn encoding_tx_remove_output() {
3284 let tx_remove_output = msgs::TxRemoveOutput {
3285 channel_id: ChannelId::from_bytes([2; 32]),
3286 serial_id: 4886718345,
3288 let encoded_value = tx_remove_output.encode();
3289 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3290 assert_eq!(encoded_value, target_value);
3294 fn encoding_tx_complete() {
3295 let tx_complete = msgs::TxComplete {
3296 channel_id: ChannelId::from_bytes([2; 32]),
3298 let encoded_value = tx_complete.encode();
3299 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3300 assert_eq!(encoded_value, target_value);
3304 fn encoding_tx_signatures() {
3305 let tx_signatures = msgs::TxSignatures {
3306 channel_id: ChannelId::from_bytes([2; 32]),
3307 tx_hash: Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3309 Witness::from_vec(vec![
3310 hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3311 hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3312 Witness::from_vec(vec![
3313 hex::decode("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap(),
3314 hex::decode("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap()]),
3317 let encoded_value = tx_signatures.encode();
3318 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3319 target_value.append(&mut hex::decode("6e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c2").unwrap()); // tx_hash (sha256) (big endian byte order)
3320 target_value.append(&mut hex::decode("0002").unwrap()); // num_witnesses (u16)
3322 target_value.append(&mut hex::decode("006b").unwrap()); // len of witness_data
3323 target_value.append(&mut hex::decode("02").unwrap()); // num_witness_elements (VarInt)
3324 target_value.append(&mut hex::decode("47").unwrap()); // len of witness element data (VarInt)
3325 target_value.append(&mut hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap());
3326 target_value.append(&mut hex::decode("21").unwrap()); // len of witness element data (VarInt)
3327 target_value.append(&mut hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap());
3329 target_value.append(&mut hex::decode("006c").unwrap()); // len of witness_data
3330 target_value.append(&mut hex::decode("02").unwrap()); // num_witness_elements (VarInt)
3331 target_value.append(&mut hex::decode("48").unwrap()); // len of witness element data (VarInt)
3332 target_value.append(&mut hex::decode("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap());
3333 target_value.append(&mut hex::decode("21").unwrap()); // len of witness element data (VarInt)
3334 target_value.append(&mut hex::decode("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap());
3335 assert_eq!(encoded_value, target_value);
3338 fn do_encoding_tx_init_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3339 let tx_init_rbf = msgs::TxInitRbf {
3340 channel_id: ChannelId::from_bytes([2; 32]),
3341 locktime: 305419896,
3342 feerate_sat_per_1000_weight: 20190119,
3343 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3345 let encoded_value = tx_init_rbf.encode();
3346 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3347 target_value.append(&mut hex::decode("12345678").unwrap()); // locktime
3348 target_value.append(&mut hex::decode("013413a7").unwrap()); // feerate_sat_per_1000_weight
3349 if let Some((_, target)) = funding_value_with_hex_target {
3350 target_value.push(0x00); // Type
3351 target_value.push(target.len() as u8 / 2); // Length
3352 target_value.append(&mut hex::decode(target).unwrap()); // Value (i64)
3354 assert_eq!(encoded_value, target_value);
3358 fn encoding_tx_init_rbf() {
3359 do_encoding_tx_init_rbf(Some((1311768467284833366, "1234567890123456")));
3360 do_encoding_tx_init_rbf(Some((13117684672, "000000030DDFFBC0")));
3361 do_encoding_tx_init_rbf(None);
3364 fn do_encoding_tx_ack_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3365 let tx_ack_rbf = msgs::TxAckRbf {
3366 channel_id: ChannelId::from_bytes([2; 32]),
3367 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3369 let encoded_value = tx_ack_rbf.encode();
3370 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3371 if let Some((_, target)) = funding_value_with_hex_target {
3372 target_value.push(0x00); // Type
3373 target_value.push(target.len() as u8 / 2); // Length
3374 target_value.append(&mut hex::decode(target).unwrap()); // Value (i64)
3376 assert_eq!(encoded_value, target_value);
3380 fn encoding_tx_ack_rbf() {
3381 do_encoding_tx_ack_rbf(Some((1311768467284833366, "1234567890123456")));
3382 do_encoding_tx_ack_rbf(Some((13117684672, "000000030DDFFBC0")));
3383 do_encoding_tx_ack_rbf(None);
3387 fn encoding_tx_abort() {
3388 let tx_abort = msgs::TxAbort {
3389 channel_id: ChannelId::from_bytes([2; 32]),
3390 data: hex::decode("54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap(),
3392 let encoded_value = tx_abort.encode();
3393 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202002C54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap();
3394 assert_eq!(encoded_value, target_value);
3397 fn do_encoding_shutdown(script_type: u8) {
3398 let secp_ctx = Secp256k1::new();
3399 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3400 let script = Builder::new().push_opcode(opcodes::OP_TRUE).into_script();
3401 let shutdown = msgs::Shutdown {
3402 channel_id: ChannelId::from_bytes([2; 32]),
3404 if script_type == 1 { Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey() }
3405 else if script_type == 2 { Address::p2sh(&script, Network::Testnet).unwrap().script_pubkey() }
3406 else if script_type == 3 { Address::p2wpkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).unwrap().script_pubkey() }
3407 else { Address::p2wsh(&script, Network::Testnet).script_pubkey() },
3409 let encoded_value = shutdown.encode();
3410 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3411 if script_type == 1 {
3412 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3413 } else if script_type == 2 {
3414 target_value.append(&mut hex::decode("0017a914da1745e9b549bd0bfa1a569971c77eba30cd5a4b87").unwrap());
3415 } else if script_type == 3 {
3416 target_value.append(&mut hex::decode("0016001479b000887626b294a914501a4cd226b58b235983").unwrap());
3417 } else if script_type == 4 {
3418 target_value.append(&mut hex::decode("002200204ae81572f06e1b88fd5ced7a1a000945432e83e1551e6f721ee9c00b8cc33260").unwrap());
3420 assert_eq!(encoded_value, target_value);
3424 fn encoding_shutdown() {
3425 do_encoding_shutdown(1);
3426 do_encoding_shutdown(2);
3427 do_encoding_shutdown(3);
3428 do_encoding_shutdown(4);
3432 fn encoding_closing_signed() {
3433 let secp_ctx = Secp256k1::new();
3434 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3435 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3436 let closing_signed = msgs::ClosingSigned {
3437 channel_id: ChannelId::from_bytes([2; 32]),
3438 fee_satoshis: 2316138423780173,
3442 let encoded_value = closing_signed.encode();
3443 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3444 assert_eq!(encoded_value, target_value);
3445 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value)).unwrap(), closing_signed);
3447 let closing_signed_with_range = msgs::ClosingSigned {
3448 channel_id: ChannelId::from_bytes([2; 32]),
3449 fee_satoshis: 2316138423780173,
3451 fee_range: Some(msgs::ClosingSignedFeeRange {
3452 min_fee_satoshis: 0xdeadbeef,
3453 max_fee_satoshis: 0x1badcafe01234567,
3456 let encoded_value_with_range = closing_signed_with_range.encode();
3457 let target_value_with_range = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a011000000000deadbeef1badcafe01234567").unwrap();
3458 assert_eq!(encoded_value_with_range, target_value_with_range);
3459 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value_with_range)).unwrap(),
3460 closing_signed_with_range);
3464 fn encoding_update_add_htlc() {
3465 let secp_ctx = Secp256k1::new();
3466 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3467 let onion_routing_packet = msgs::OnionPacket {
3469 public_key: Ok(pubkey_1),
3470 hop_data: [1; 20*65],
3473 let update_add_htlc = msgs::UpdateAddHTLC {
3474 channel_id: ChannelId::from_bytes([2; 32]),
3475 htlc_id: 2316138423780173,
3476 amount_msat: 3608586615801332854,
3477 payment_hash: PaymentHash([1; 32]),
3478 cltv_expiry: 821716,
3479 onion_routing_packet,
3480 skimmed_fee_msat: None,
3482 let encoded_value = update_add_htlc.encode();
3483 let target_value = hex::decode("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").unwrap();
3484 assert_eq!(encoded_value, target_value);
3488 fn encoding_update_fulfill_htlc() {
3489 let update_fulfill_htlc = msgs::UpdateFulfillHTLC {
3490 channel_id: ChannelId::from_bytes([2; 32]),
3491 htlc_id: 2316138423780173,
3492 payment_preimage: PaymentPreimage([1; 32]),
3494 let encoded_value = update_fulfill_htlc.encode();
3495 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d0101010101010101010101010101010101010101010101010101010101010101").unwrap();
3496 assert_eq!(encoded_value, target_value);
3500 fn encoding_update_fail_htlc() {
3501 let reason = OnionErrorPacket {
3502 data: [1; 32].to_vec(),
3504 let update_fail_htlc = msgs::UpdateFailHTLC {
3505 channel_id: ChannelId::from_bytes([2; 32]),
3506 htlc_id: 2316138423780173,
3509 let encoded_value = update_fail_htlc.encode();
3510 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d00200101010101010101010101010101010101010101010101010101010101010101").unwrap();
3511 assert_eq!(encoded_value, target_value);
3515 fn encoding_update_fail_malformed_htlc() {
3516 let update_fail_malformed_htlc = msgs::UpdateFailMalformedHTLC {
3517 channel_id: ChannelId::from_bytes([2; 32]),
3518 htlc_id: 2316138423780173,
3519 sha256_of_onion: [1; 32],
3522 let encoded_value = update_fail_malformed_htlc.encode();
3523 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d010101010101010101010101010101010101010101010101010101010101010100ff").unwrap();
3524 assert_eq!(encoded_value, target_value);
3527 fn do_encoding_commitment_signed(htlcs: bool) {
3528 let secp_ctx = Secp256k1::new();
3529 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3530 let (privkey_2, _) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3531 let (privkey_3, _) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3532 let (privkey_4, _) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3533 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3534 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
3535 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
3536 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
3537 let commitment_signed = msgs::CommitmentSigned {
3538 channel_id: ChannelId::from_bytes([2; 32]),
3540 htlc_signatures: if htlcs { vec![sig_2, sig_3, sig_4] } else { Vec::new() },
3542 partial_signature_with_nonce: None,
3544 let encoded_value = commitment_signed.encode();
3545 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3547 target_value.append(&mut hex::decode("00031735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
3549 target_value.append(&mut hex::decode("0000").unwrap());
3551 assert_eq!(encoded_value, target_value);
3555 fn encoding_commitment_signed() {
3556 do_encoding_commitment_signed(true);
3557 do_encoding_commitment_signed(false);
3561 fn encoding_revoke_and_ack() {
3562 let secp_ctx = Secp256k1::new();
3563 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3564 let raa = msgs::RevokeAndACK {
3565 channel_id: ChannelId::from_bytes([2; 32]),
3566 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],
3567 next_per_commitment_point: pubkey_1,
3569 next_local_nonce: None,
3571 let encoded_value = raa.encode();
3572 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020101010101010101010101010101010101010101010101010101010101010101031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3573 assert_eq!(encoded_value, target_value);
3577 fn encoding_update_fee() {
3578 let update_fee = msgs::UpdateFee {
3579 channel_id: ChannelId::from_bytes([2; 32]),
3580 feerate_per_kw: 20190119,
3582 let encoded_value = update_fee.encode();
3583 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202013413a7").unwrap();
3584 assert_eq!(encoded_value, target_value);
3588 fn encoding_init() {
3589 let mainnet_hash = ChainHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap();
3590 assert_eq!(msgs::Init {
3591 features: InitFeatures::from_le_bytes(vec![0xFF, 0xFF, 0xFF]),
3592 networks: Some(vec![mainnet_hash]),
3593 remote_network_address: None,
3594 }.encode(), hex::decode("00023fff0003ffffff01206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3595 assert_eq!(msgs::Init {
3596 features: InitFeatures::from_le_bytes(vec![0xFF]),
3598 remote_network_address: None,
3599 }.encode(), hex::decode("0001ff0001ff").unwrap());
3600 assert_eq!(msgs::Init {
3601 features: InitFeatures::from_le_bytes(vec![]),
3602 networks: Some(vec![mainnet_hash]),
3603 remote_network_address: None,
3604 }.encode(), hex::decode("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3605 assert_eq!(msgs::Init {
3606 features: InitFeatures::from_le_bytes(vec![]),
3607 networks: Some(vec![ChainHash::from(&[1; 32][..]), ChainHash::from(&[2; 32][..])]),
3608 remote_network_address: None,
3609 }.encode(), hex::decode("00000000014001010101010101010101010101010101010101010101010101010101010101010202020202020202020202020202020202020202020202020202020202020202").unwrap());
3610 let init_msg = msgs::Init { features: InitFeatures::from_le_bytes(vec![]),
3611 networks: Some(vec![mainnet_hash]),
3612 remote_network_address: Some(NetAddress::IPv4 {
3613 addr: [127, 0, 0, 1],
3617 let encoded_value = init_msg.encode();
3618 let target_value = hex::decode("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d61900000000000307017f00000103e8").unwrap();
3619 assert_eq!(encoded_value, target_value);
3620 assert_eq!(msgs::Init::read(&mut Cursor::new(&target_value)).unwrap(), init_msg);
3624 fn encoding_error() {
3625 let error = msgs::ErrorMessage {
3626 channel_id: ChannelId::from_bytes([2; 32]),
3627 data: String::from("rust-lightning"),
3629 let encoded_value = error.encode();
3630 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3631 assert_eq!(encoded_value, target_value);
3635 fn encoding_warning() {
3636 let error = msgs::WarningMessage {
3637 channel_id: ChannelId::from_bytes([2; 32]),
3638 data: String::from("rust-lightning"),
3640 let encoded_value = error.encode();
3641 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3642 assert_eq!(encoded_value, target_value);
3646 fn encoding_ping() {
3647 let ping = msgs::Ping {
3651 let encoded_value = ping.encode();
3652 let target_value = hex::decode("0040004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3653 assert_eq!(encoded_value, target_value);
3657 fn encoding_pong() {
3658 let pong = msgs::Pong {
3661 let encoded_value = pong.encode();
3662 let target_value = hex::decode("004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3663 assert_eq!(encoded_value, target_value);
3667 fn encoding_nonfinal_onion_hop_data() {
3668 let outbound_msg = msgs::OutboundOnionPayload::Forward {
3669 short_channel_id: 0xdeadbeef1bad1dea,
3670 amt_to_forward: 0x0badf00d01020304,
3671 outgoing_cltv_value: 0xffffffff,
3673 let encoded_value = outbound_msg.encode();
3674 let target_value = hex::decode("1a02080badf00d010203040404ffffffff0608deadbeef1bad1dea").unwrap();
3675 assert_eq!(encoded_value, target_value);
3677 let inbound_msg = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3678 if let msgs::InboundOnionPayload::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } = inbound_msg {
3679 assert_eq!(short_channel_id, 0xdeadbeef1bad1dea);
3680 assert_eq!(amt_to_forward, 0x0badf00d01020304);
3681 assert_eq!(outgoing_cltv_value, 0xffffffff);
3682 } else { panic!(); }
3686 fn encoding_final_onion_hop_data() {
3687 let outbound_msg = msgs::OutboundOnionPayload::Receive {
3689 payment_metadata: None,
3690 keysend_preimage: None,
3691 amt_msat: 0x0badf00d01020304,
3692 outgoing_cltv_value: 0xffffffff,
3693 custom_tlvs: vec![],
3695 let encoded_value = outbound_msg.encode();
3696 let target_value = hex::decode("1002080badf00d010203040404ffffffff").unwrap();
3697 assert_eq!(encoded_value, target_value);
3699 let inbound_msg = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3700 if let msgs::InboundOnionPayload::Receive { payment_data: None, amt_msat, outgoing_cltv_value, .. } = inbound_msg {
3701 assert_eq!(amt_msat, 0x0badf00d01020304);
3702 assert_eq!(outgoing_cltv_value, 0xffffffff);
3703 } else { panic!(); }
3707 fn encoding_final_onion_hop_data_with_secret() {
3708 let expected_payment_secret = PaymentSecret([0x42u8; 32]);
3709 let outbound_msg = msgs::OutboundOnionPayload::Receive {
3710 payment_data: Some(FinalOnionHopData {
3711 payment_secret: expected_payment_secret,
3712 total_msat: 0x1badca1f
3714 payment_metadata: None,
3715 keysend_preimage: None,
3716 amt_msat: 0x0badf00d01020304,
3717 outgoing_cltv_value: 0xffffffff,
3718 custom_tlvs: vec![],
3720 let encoded_value = outbound_msg.encode();
3721 let target_value = hex::decode("3602080badf00d010203040404ffffffff082442424242424242424242424242424242424242424242424242424242424242421badca1f").unwrap();
3722 assert_eq!(encoded_value, target_value);
3724 let inbound_msg = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3725 if let msgs::InboundOnionPayload::Receive {
3726 payment_data: Some(FinalOnionHopData {
3728 total_msat: 0x1badca1f
3730 amt_msat, outgoing_cltv_value,
3731 payment_metadata: None,
3732 keysend_preimage: None,
3735 assert_eq!(payment_secret, expected_payment_secret);
3736 assert_eq!(amt_msat, 0x0badf00d01020304);
3737 assert_eq!(outgoing_cltv_value, 0xffffffff);
3738 assert_eq!(custom_tlvs, vec![]);
3739 } else { panic!(); }
3743 fn encoding_final_onion_hop_data_with_bad_custom_tlvs() {
3744 // If custom TLVs have type number within the range reserved for protocol, treat them as if
3746 let bad_type_range_tlvs = vec![
3747 ((1 << 16) - 4, vec![42]),
3748 ((1 << 16) - 2, vec![42; 32]),
3750 let mut msg = msgs::OutboundOnionPayload::Receive {
3752 payment_metadata: None,
3753 keysend_preimage: None,
3754 custom_tlvs: bad_type_range_tlvs,
3755 amt_msat: 0x0badf00d01020304,
3756 outgoing_cltv_value: 0xffffffff,
3758 let encoded_value = msg.encode();
3759 assert!(msgs::InboundOnionPayload::read(&mut Cursor::new(&encoded_value[..])).is_err());
3760 let good_type_range_tlvs = vec![
3761 ((1 << 16) - 3, vec![42]),
3762 ((1 << 16) - 1, vec![42; 32]),
3764 if let msgs::OutboundOnionPayload::Receive { ref mut custom_tlvs, .. } = msg {
3765 *custom_tlvs = good_type_range_tlvs.clone();
3767 let encoded_value = msg.encode();
3768 let inbound_msg = Readable::read(&mut Cursor::new(&encoded_value[..])).unwrap();
3770 msgs::InboundOnionPayload::Receive { custom_tlvs, .. } => assert!(custom_tlvs.is_empty()),
3776 fn encoding_final_onion_hop_data_with_custom_tlvs() {
3777 let expected_custom_tlvs = vec![
3778 (5482373483, vec![0x12, 0x34]),
3779 (5482373487, vec![0x42u8; 8]),
3781 let msg = msgs::OutboundOnionPayload::Receive {
3783 payment_metadata: None,
3784 keysend_preimage: None,
3785 custom_tlvs: expected_custom_tlvs.clone(),
3786 amt_msat: 0x0badf00d01020304,
3787 outgoing_cltv_value: 0xffffffff,
3789 let encoded_value = msg.encode();
3790 let target_value = hex::decode("2e02080badf00d010203040404ffffffffff0000000146c6616b021234ff0000000146c6616f084242424242424242").unwrap();
3791 assert_eq!(encoded_value, target_value);
3792 let inbound_msg: msgs::InboundOnionPayload = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3793 if let msgs::InboundOnionPayload::Receive {
3795 payment_metadata: None,
3796 keysend_preimage: None,
3799 outgoing_cltv_value,
3802 assert_eq!(custom_tlvs, expected_custom_tlvs);
3803 assert_eq!(amt_msat, 0x0badf00d01020304);
3804 assert_eq!(outgoing_cltv_value, 0xffffffff);
3805 } else { panic!(); }
3809 fn query_channel_range_end_blocknum() {
3810 let tests: Vec<(u32, u32, u32)> = vec![
3811 (10000, 1500, 11500),
3812 (0, 0xffffffff, 0xffffffff),
3813 (1, 0xffffffff, 0xffffffff),
3816 for (first_blocknum, number_of_blocks, expected) in tests.into_iter() {
3817 let sut = msgs::QueryChannelRange {
3818 chain_hash: BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap(),
3822 assert_eq!(sut.end_blocknum(), expected);
3827 fn encoding_query_channel_range() {
3828 let mut query_channel_range = msgs::QueryChannelRange {
3829 chain_hash: BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap(),
3830 first_blocknum: 100000,
3831 number_of_blocks: 1500,
3833 let encoded_value = query_channel_range.encode();
3834 let target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206000186a0000005dc").unwrap();
3835 assert_eq!(encoded_value, target_value);
3837 query_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3838 assert_eq!(query_channel_range.first_blocknum, 100000);
3839 assert_eq!(query_channel_range.number_of_blocks, 1500);
3843 fn encoding_reply_channel_range() {
3844 do_encoding_reply_channel_range(0);
3845 do_encoding_reply_channel_range(1);
3848 fn do_encoding_reply_channel_range(encoding_type: u8) {
3849 let mut target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206000b8a06000005dc01").unwrap();
3850 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3851 let mut reply_channel_range = msgs::ReplyChannelRange {
3852 chain_hash: expected_chain_hash,
3853 first_blocknum: 756230,
3854 number_of_blocks: 1500,
3855 sync_complete: true,
3856 short_channel_ids: vec![0x000000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
3859 if encoding_type == 0 {
3860 target_value.append(&mut hex::decode("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
3861 let encoded_value = reply_channel_range.encode();
3862 assert_eq!(encoded_value, target_value);
3864 reply_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3865 assert_eq!(reply_channel_range.chain_hash, expected_chain_hash);
3866 assert_eq!(reply_channel_range.first_blocknum, 756230);
3867 assert_eq!(reply_channel_range.number_of_blocks, 1500);
3868 assert_eq!(reply_channel_range.sync_complete, true);
3869 assert_eq!(reply_channel_range.short_channel_ids[0], 0x000000000000008e);
3870 assert_eq!(reply_channel_range.short_channel_ids[1], 0x0000000000003c69);
3871 assert_eq!(reply_channel_range.short_channel_ids[2], 0x000000000045a6c4);
3873 target_value.append(&mut hex::decode("001601789c636000833e08659309a65878be010010a9023a").unwrap());
3874 let result: Result<msgs::ReplyChannelRange, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
3875 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
3880 fn encoding_query_short_channel_ids() {
3881 do_encoding_query_short_channel_ids(0);
3882 do_encoding_query_short_channel_ids(1);
3885 fn do_encoding_query_short_channel_ids(encoding_type: u8) {
3886 let mut target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206").unwrap();
3887 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3888 let mut query_short_channel_ids = msgs::QueryShortChannelIds {
3889 chain_hash: expected_chain_hash,
3890 short_channel_ids: vec![0x0000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
3893 if encoding_type == 0 {
3894 target_value.append(&mut hex::decode("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
3895 let encoded_value = query_short_channel_ids.encode();
3896 assert_eq!(encoded_value, target_value);
3898 query_short_channel_ids = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3899 assert_eq!(query_short_channel_ids.chain_hash, expected_chain_hash);
3900 assert_eq!(query_short_channel_ids.short_channel_ids[0], 0x000000000000008e);
3901 assert_eq!(query_short_channel_ids.short_channel_ids[1], 0x0000000000003c69);
3902 assert_eq!(query_short_channel_ids.short_channel_ids[2], 0x000000000045a6c4);
3904 target_value.append(&mut hex::decode("001601789c636000833e08659309a65878be010010a9023a").unwrap());
3905 let result: Result<msgs::QueryShortChannelIds, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
3906 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
3911 fn encoding_reply_short_channel_ids_end() {
3912 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3913 let mut reply_short_channel_ids_end = msgs::ReplyShortChannelIdsEnd {
3914 chain_hash: expected_chain_hash,
3915 full_information: true,
3917 let encoded_value = reply_short_channel_ids_end.encode();
3918 let target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e220601").unwrap();
3919 assert_eq!(encoded_value, target_value);
3921 reply_short_channel_ids_end = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3922 assert_eq!(reply_short_channel_ids_end.chain_hash, expected_chain_hash);
3923 assert_eq!(reply_short_channel_ids_end.full_information, true);
3927 fn encoding_gossip_timestamp_filter(){
3928 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3929 let mut gossip_timestamp_filter = msgs::GossipTimestampFilter {
3930 chain_hash: expected_chain_hash,
3931 first_timestamp: 1590000000,
3932 timestamp_range: 0xffff_ffff,
3934 let encoded_value = gossip_timestamp_filter.encode();
3935 let target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e22065ec57980ffffffff").unwrap();
3936 assert_eq!(encoded_value, target_value);
3938 gossip_timestamp_filter = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3939 assert_eq!(gossip_timestamp_filter.chain_hash, expected_chain_hash);
3940 assert_eq!(gossip_timestamp_filter.first_timestamp, 1590000000);
3941 assert_eq!(gossip_timestamp_filter.timestamp_range, 0xffff_ffff);
3945 fn decode_onion_hop_data_len_as_bigsize() {
3946 // Tests that we can decode an onion payload that is >253 bytes.
3947 // Previously, receiving a payload of this size could've caused us to fail to decode a valid
3948 // payload, because we were decoding the length (a BigSize, big-endian) as a VarInt
3951 // Encode a test onion payload with a big custom TLV such that it's >253 bytes, forcing the
3952 // payload length to be encoded over multiple bytes rather than a single u8.
3953 let big_payload = encode_big_payload().unwrap();
3954 let mut rd = Cursor::new(&big_payload[..]);
3955 <msgs::InboundOnionPayload as Readable>::read(&mut rd).unwrap();
3957 // see above test, needs to be a separate method for use of the serialization macros.
3958 fn encode_big_payload() -> Result<Vec<u8>, io::Error> {
3959 use crate::util::ser::HighZeroBytesDroppedBigSize;
3960 let payload = msgs::OutboundOnionPayload::Forward {
3961 short_channel_id: 0xdeadbeef1bad1dea,
3962 amt_to_forward: 1000,
3963 outgoing_cltv_value: 0xffffffff,
3965 let mut encoded_payload = Vec::new();
3966 let test_bytes = vec![42u8; 1000];
3967 if let msgs::OutboundOnionPayload::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } = payload {
3968 _encode_varint_length_prefixed_tlv!(&mut encoded_payload, {
3969 (1, test_bytes, required_vec),
3970 (2, HighZeroBytesDroppedBigSize(amt_to_forward), required),
3971 (4, HighZeroBytesDroppedBigSize(outgoing_cltv_value), required),
3972 (6, short_channel_id, required)
3979 #[cfg(feature = "std")]
3980 fn test_net_address_from_str() {
3981 assert_eq!(NetAddress::IPv4 {
3982 addr: Ipv4Addr::new(127, 0, 0, 1).octets(),
3984 }, NetAddress::from_str("127.0.0.1:1234").unwrap());
3986 assert_eq!(NetAddress::IPv6 {
3987 addr: Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1).octets(),
3989 }, NetAddress::from_str("[0:0:0:0:0:0:0:1]:1234").unwrap());
3991 NetAddress::Hostname {
3992 hostname: Hostname::try_from("lightning-node.mydomain.com".to_string()).unwrap(),
3994 }, NetAddress::from_str("lightning-node.mydomain.com:1234").unwrap());
3996 NetAddress::Hostname {
3997 hostname: Hostname::try_from("example.com".to_string()).unwrap(),
3999 }, NetAddress::from_str("example.com:1234").unwrap());
4000 assert_eq!(NetAddress::OnionV3 {
4001 ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102, 182, 107, 4, 105, 247, 246, 85,
4002 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31, 33, 71, 3],
4006 }, NetAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion:1234").unwrap());
4007 assert_eq!(Err(NetAddressParseError::InvalidOnionV3), NetAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6.onion:1234"));
4008 assert_eq!(Err(NetAddressParseError::InvalidInput), NetAddress::from_str("127.0.0.1@1234"));
4009 assert_eq!(Err(NetAddressParseError::InvalidInput), "".parse::<NetAddress>());
4010 assert!(NetAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:9735:94").is_err());
4011 assert!(NetAddress::from_str("wrong$%#.com:1234").is_err());
4012 assert_eq!(Err(NetAddressParseError::InvalidPort), NetAddress::from_str("example.com:wrong"));
4013 assert!("localhost".parse::<NetAddress>().is_err());
4014 assert!("localhost:invalid-port".parse::<NetAddress>().is_err());
4015 assert!( "invalid-onion-v3-hostname.onion:8080".parse::<NetAddress>().is_err());
4016 assert!("b32.example.onion:invalid-port".parse::<NetAddress>().is_err());
4017 assert!("invalid-address".parse::<NetAddress>().is_err());
4018 assert!(NetAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:1234").is_err());