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::blinded_path::payment::ReceiveTlvs;
35 use crate::ln::{ChannelId, PaymentPreimage, PaymentHash, PaymentSecret};
36 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
37 use crate::ln::onion_utils;
38 use crate::onion_message;
39 use crate::sign::{NodeSigner, Recipient};
41 use crate::prelude::*;
42 use core::convert::TryFrom;
46 use core::str::FromStr;
47 use crate::io::{self, Cursor, Read};
48 use crate::io_extras::read_to_end;
50 use crate::events::{MessageSendEventsProvider, OnionMessageProvider};
51 use crate::util::chacha20poly1305rfc::ChaChaPolyReadAdapter;
52 use crate::util::logger;
53 use crate::util::ser::{LengthReadable, LengthReadableArgs, Readable, ReadableArgs, Writeable, Writer, WithoutLength, FixedLengthReader, HighZeroBytesDroppedBigSize, Hostname, TransactionU16LenLimited, BigSize};
54 use crate::util::base32;
56 use crate::routing::gossip::{NodeAlias, NodeId};
58 /// 21 million * 10^8 * 1000
59 pub(crate) const MAX_VALUE_MSAT: u64 = 21_000_000_0000_0000_000;
62 /// A partial signature that also contains the Musig2 nonce its signer used
63 #[derive(Clone, Debug, PartialEq, Eq)]
64 pub struct PartialSignatureWithNonce(pub musig2::types::PartialSignature, pub musig2::types::PublicNonce);
66 /// An error in decoding a message or struct.
67 #[derive(Clone, Debug, PartialEq, Eq)]
68 pub enum DecodeError {
69 /// A version byte specified something we don't know how to handle.
71 /// Includes unknown realm byte in an onion hop data packet.
73 /// Unknown feature mandating we fail to parse message (e.g., TLV with an even, unknown type)
74 UnknownRequiredFeature,
75 /// Value was invalid.
77 /// For example, a byte which was supposed to be a bool was something other than a 0
78 /// or 1, a public key/private key/signature was invalid, text wasn't UTF-8, TLV was
79 /// syntactically incorrect, etc.
81 /// The buffer to be read was too short.
83 /// A length descriptor in the packet didn't describe the later data correctly.
85 /// Error from [`std::io`].
87 /// The message included zlib-compressed values, which we don't support.
88 UnsupportedCompression,
91 /// An [`init`] message to be sent to or received from a peer.
93 /// [`init`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-init-message
94 #[derive(Clone, Debug, PartialEq, Eq)]
96 /// The relevant features which the sender supports.
97 pub features: InitFeatures,
98 /// Indicates chains the sender is interested in.
100 /// If there are no common chains, the connection will be closed.
101 pub networks: Option<Vec<ChainHash>>,
102 /// The receipient's network address.
104 /// This adds the option to report a remote IP address back to a connecting peer using the init
105 /// message. A node can decide to use that information to discover a potential update to its
106 /// public IPv4 address (NAT) and use that for a [`NodeAnnouncement`] update message containing
108 pub remote_network_address: Option<SocketAddress>,
111 /// An [`error`] message to be sent to or received from a peer.
113 /// [`error`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-error-and-warning-messages
114 #[derive(Clone, Debug, PartialEq, Eq)]
115 pub struct ErrorMessage {
116 /// The channel ID involved in the error.
118 /// All-0s indicates a general error unrelated to a specific channel, after which all channels
119 /// with the sending peer should be closed.
120 pub channel_id: ChannelId,
121 /// A possibly human-readable error description.
123 /// The string should be sanitized before it is used (e.g., emitted to logs or printed to
124 /// `stdout`). Otherwise, a well crafted error message may trigger a security vulnerability in
125 /// the terminal emulator or the logging subsystem.
129 /// A [`warning`] message to be sent to or received from a peer.
131 /// [`warning`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-error-and-warning-messages
132 #[derive(Clone, Debug, PartialEq, Eq)]
133 pub struct WarningMessage {
134 /// The channel ID involved in the warning.
136 /// All-0s indicates a warning unrelated to a specific channel.
137 pub channel_id: ChannelId,
138 /// A possibly human-readable warning description.
140 /// The string should be sanitized before it is used (e.g. emitted to logs or printed to
141 /// stdout). Otherwise, a well crafted error message may trigger a security vulnerability in
142 /// the terminal emulator or the logging subsystem.
146 /// A [`ping`] message to be sent to or received from a peer.
148 /// [`ping`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-ping-and-pong-messages
149 #[derive(Clone, Debug, PartialEq, Eq)]
151 /// The desired response length.
153 /// The ping packet size.
155 /// This field is not sent on the wire. byteslen zeros are sent.
159 /// A [`pong`] message to be sent to or received from a peer.
161 /// [`pong`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-ping-and-pong-messages
162 #[derive(Clone, Debug, PartialEq, Eq)]
164 /// The pong packet size.
166 /// This field is not sent on the wire. byteslen zeros are sent.
170 /// An [`open_channel`] message to be sent to or received from a peer.
172 /// Used in V1 channel establishment
174 /// [`open_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-open_channel-message
175 #[derive(Clone, Debug, PartialEq, Eq)]
176 pub struct OpenChannel {
177 /// The genesis hash of the blockchain where the channel is to be opened
178 pub chain_hash: BlockHash,
179 /// A temporary channel ID, until the funding outpoint is announced
180 pub temporary_channel_id: ChannelId,
181 /// The channel value
182 pub funding_satoshis: u64,
183 /// The amount to push to the counterparty as part of the open, in milli-satoshi
185 /// The threshold below which outputs on transactions broadcast by sender will be omitted
186 pub dust_limit_satoshis: u64,
187 /// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
188 pub max_htlc_value_in_flight_msat: u64,
189 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
190 pub channel_reserve_satoshis: u64,
191 /// The minimum HTLC size incoming to sender, in milli-satoshi
192 pub htlc_minimum_msat: u64,
193 /// The feerate per 1000-weight of sender generated transactions, until updated by
195 pub feerate_per_kw: u32,
196 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if
197 /// they broadcast a commitment transaction
198 pub to_self_delay: u16,
199 /// The maximum number of inbound HTLCs towards sender
200 pub max_accepted_htlcs: u16,
201 /// The sender's key controlling the funding transaction
202 pub funding_pubkey: PublicKey,
203 /// Used to derive a revocation key for transactions broadcast by counterparty
204 pub revocation_basepoint: PublicKey,
205 /// A payment key to sender for transactions broadcast by counterparty
206 pub payment_point: PublicKey,
207 /// Used to derive a payment key to sender for transactions broadcast by sender
208 pub delayed_payment_basepoint: PublicKey,
209 /// Used to derive an HTLC payment key to sender
210 pub htlc_basepoint: PublicKey,
211 /// The first to-be-broadcast-by-sender transaction's per commitment point
212 pub first_per_commitment_point: PublicKey,
213 /// The channel flags to be used
214 pub channel_flags: u8,
215 /// A request to pre-set the to-sender output's `scriptPubkey` for when we collaboratively close
216 pub shutdown_scriptpubkey: Option<Script>,
217 /// The channel type that this channel will represent
219 /// If this is `None`, we derive the channel type from the intersection of our
220 /// feature bits with our counterparty's feature bits from the [`Init`] message.
221 pub channel_type: Option<ChannelTypeFeatures>,
224 /// An open_channel2 message to be sent by or received from the channel initiator.
226 /// Used in V2 channel establishment
228 // TODO(dual_funding): Add spec link for `open_channel2`.
229 #[derive(Clone, Debug, PartialEq, Eq)]
230 pub struct OpenChannelV2 {
231 /// The genesis hash of the blockchain where the channel is to be opened
232 pub chain_hash: BlockHash,
233 /// A temporary channel ID derived using a zeroed out value for the channel acceptor's revocation basepoint
234 pub temporary_channel_id: ChannelId,
235 /// The feerate for the funding transaction set by the channel initiator
236 pub funding_feerate_sat_per_1000_weight: u32,
237 /// The feerate for the commitment transaction set by the channel initiator
238 pub commitment_feerate_sat_per_1000_weight: u32,
239 /// Part of the channel value contributed by the channel initiator
240 pub funding_satoshis: u64,
241 /// The threshold below which outputs on transactions broadcast by the channel initiator will be
243 pub dust_limit_satoshis: u64,
244 /// The maximum inbound HTLC value in flight towards channel initiator, in milli-satoshi
245 pub max_htlc_value_in_flight_msat: u64,
246 /// The minimum HTLC size incoming to channel initiator, in milli-satoshi
247 pub htlc_minimum_msat: u64,
248 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
249 /// broadcast a commitment transaction
250 pub to_self_delay: u16,
251 /// The maximum number of inbound HTLCs towards channel initiator
252 pub max_accepted_htlcs: u16,
253 /// The locktime for the funding transaction
255 /// The channel initiator's key controlling the funding transaction
256 pub funding_pubkey: PublicKey,
257 /// Used to derive a revocation key for transactions broadcast by counterparty
258 pub revocation_basepoint: PublicKey,
259 /// A payment key to channel initiator for transactions broadcast by counterparty
260 pub payment_basepoint: PublicKey,
261 /// Used to derive a payment key to channel initiator for transactions broadcast by channel
263 pub delayed_payment_basepoint: PublicKey,
264 /// Used to derive an HTLC payment key to channel initiator
265 pub htlc_basepoint: PublicKey,
266 /// The first to-be-broadcast-by-channel-initiator transaction's per commitment point
267 pub first_per_commitment_point: PublicKey,
268 /// The second to-be-broadcast-by-channel-initiator transaction's per commitment point
269 pub second_per_commitment_point: PublicKey,
271 pub channel_flags: u8,
272 /// Optionally, a request to pre-set the to-channel-initiator output's scriptPubkey for when we
273 /// collaboratively close
274 pub shutdown_scriptpubkey: Option<Script>,
275 /// The channel type that this channel will represent. If none is set, we derive the channel
276 /// type from the intersection of our feature bits with our counterparty's feature bits from
277 /// the Init message.
278 pub channel_type: Option<ChannelTypeFeatures>,
279 /// Optionally, a requirement that only confirmed inputs can be added
280 pub require_confirmed_inputs: Option<()>,
283 /// An [`accept_channel`] message to be sent to or received from a peer.
285 /// Used in V1 channel establishment
287 /// [`accept_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-accept_channel-message
288 #[derive(Clone, Debug, PartialEq, Eq)]
289 pub struct AcceptChannel {
290 /// A temporary channel ID, until the funding outpoint is announced
291 pub temporary_channel_id: ChannelId,
292 /// The threshold below which outputs on transactions broadcast by sender will be omitted
293 pub dust_limit_satoshis: u64,
294 /// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
295 pub max_htlc_value_in_flight_msat: u64,
296 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
297 pub channel_reserve_satoshis: u64,
298 /// The minimum HTLC size incoming to sender, in milli-satoshi
299 pub htlc_minimum_msat: u64,
300 /// Minimum depth of the funding transaction before the channel is considered open
301 pub minimum_depth: u32,
302 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they broadcast a commitment transaction
303 pub to_self_delay: u16,
304 /// The maximum number of inbound HTLCs towards sender
305 pub max_accepted_htlcs: u16,
306 /// The sender's key controlling the funding transaction
307 pub funding_pubkey: PublicKey,
308 /// Used to derive a revocation key for transactions broadcast by counterparty
309 pub revocation_basepoint: PublicKey,
310 /// A payment key to sender for transactions broadcast by counterparty
311 pub payment_point: PublicKey,
312 /// Used to derive a payment key to sender for transactions broadcast by sender
313 pub delayed_payment_basepoint: PublicKey,
314 /// Used to derive an HTLC payment key to sender for transactions broadcast by counterparty
315 pub htlc_basepoint: PublicKey,
316 /// The first to-be-broadcast-by-sender transaction's per commitment point
317 pub first_per_commitment_point: PublicKey,
318 /// A request to pre-set the to-sender output's scriptPubkey for when we collaboratively close
319 pub shutdown_scriptpubkey: Option<Script>,
320 /// The channel type that this channel will represent.
322 /// If this is `None`, we derive the channel type from the intersection of
323 /// our feature bits with our counterparty's feature bits from the [`Init`] message.
324 /// This is required to match the equivalent field in [`OpenChannel::channel_type`].
325 pub channel_type: Option<ChannelTypeFeatures>,
327 /// Next nonce the channel initiator should use to create a funding output signature against
328 pub next_local_nonce: Option<musig2::types::PublicNonce>,
331 /// An accept_channel2 message to be sent by or received from the channel accepter.
333 /// Used in V2 channel establishment
335 // TODO(dual_funding): Add spec link for `accept_channel2`.
336 #[derive(Clone, Debug, PartialEq, Eq)]
337 pub struct AcceptChannelV2 {
338 /// The same `temporary_channel_id` received from the initiator's `open_channel2` message.
339 pub temporary_channel_id: ChannelId,
340 /// Part of the channel value contributed by the channel acceptor
341 pub funding_satoshis: u64,
342 /// The threshold below which outputs on transactions broadcast by the channel acceptor will be
344 pub dust_limit_satoshis: u64,
345 /// The maximum inbound HTLC value in flight towards channel acceptor, in milli-satoshi
346 pub max_htlc_value_in_flight_msat: u64,
347 /// The minimum HTLC size incoming to channel acceptor, in milli-satoshi
348 pub htlc_minimum_msat: u64,
349 /// Minimum depth of the funding transaction before the channel is considered open
350 pub minimum_depth: u32,
351 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
352 /// broadcast a commitment transaction
353 pub to_self_delay: u16,
354 /// The maximum number of inbound HTLCs towards channel acceptor
355 pub max_accepted_htlcs: u16,
356 /// The channel acceptor's key controlling the funding transaction
357 pub funding_pubkey: PublicKey,
358 /// Used to derive a revocation key for transactions broadcast by counterparty
359 pub revocation_basepoint: PublicKey,
360 /// A payment key to channel acceptor for transactions broadcast by counterparty
361 pub payment_basepoint: PublicKey,
362 /// Used to derive a payment key to channel acceptor for transactions broadcast by channel
364 pub delayed_payment_basepoint: PublicKey,
365 /// Used to derive an HTLC payment key to channel acceptor for transactions broadcast by counterparty
366 pub htlc_basepoint: PublicKey,
367 /// The first to-be-broadcast-by-channel-acceptor transaction's per commitment point
368 pub first_per_commitment_point: PublicKey,
369 /// The second to-be-broadcast-by-channel-acceptor transaction's per commitment point
370 pub second_per_commitment_point: PublicKey,
371 /// Optionally, a request to pre-set the to-channel-acceptor output's scriptPubkey for when we
372 /// collaboratively close
373 pub shutdown_scriptpubkey: Option<Script>,
374 /// The channel type that this channel will represent. If none is set, we derive the channel
375 /// type from the intersection of our feature bits with our counterparty's feature bits from
376 /// the Init message.
378 /// This is required to match the equivalent field in [`OpenChannelV2::channel_type`].
379 pub channel_type: Option<ChannelTypeFeatures>,
380 /// Optionally, a requirement that only confirmed inputs can be added
381 pub require_confirmed_inputs: Option<()>,
384 /// A [`funding_created`] message to be sent to or received from a peer.
386 /// Used in V1 channel establishment
388 /// [`funding_created`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-funding_created-message
389 #[derive(Clone, Debug, PartialEq, Eq)]
390 pub struct FundingCreated {
391 /// A temporary channel ID, until the funding is established
392 pub temporary_channel_id: ChannelId,
393 /// The funding transaction ID
394 pub funding_txid: Txid,
395 /// The specific output index funding this channel
396 pub funding_output_index: u16,
397 /// The signature of the channel initiator (funder) on the initial commitment transaction
398 pub signature: Signature,
400 /// The partial signature of the channel initiator (funder)
401 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
403 /// Next nonce the channel acceptor should use to finalize the funding output signature
404 pub next_local_nonce: Option<musig2::types::PublicNonce>
407 /// A [`funding_signed`] message to be sent to or received from a peer.
409 /// Used in V1 channel establishment
411 /// [`funding_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-funding_signed-message
412 #[derive(Clone, Debug, PartialEq, Eq)]
413 pub struct FundingSigned {
415 pub channel_id: ChannelId,
416 /// The signature of the channel acceptor (fundee) on the initial commitment transaction
417 pub signature: Signature,
419 /// The partial signature of the channel acceptor (fundee)
420 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
423 /// A [`channel_ready`] message to be sent to or received from a peer.
425 /// [`channel_ready`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-channel_ready-message
426 #[derive(Clone, Debug, PartialEq, Eq)]
427 pub struct ChannelReady {
429 pub channel_id: ChannelId,
430 /// The per-commitment point of the second commitment transaction
431 pub next_per_commitment_point: PublicKey,
432 /// If set, provides a `short_channel_id` alias for this channel.
434 /// The sender will accept payments to be forwarded over this SCID and forward them to this
435 /// messages' recipient.
436 pub short_channel_id_alias: Option<u64>,
439 /// A tx_add_input message for adding an input during interactive transaction construction
441 // TODO(dual_funding): Add spec link for `tx_add_input`.
442 #[derive(Clone, Debug, PartialEq, Eq)]
443 pub struct TxAddInput {
445 pub channel_id: ChannelId,
446 /// A randomly chosen unique identifier for this input, which is even for initiators and odd for
449 /// Serialized transaction that contains the output this input spends to verify that it is non
451 pub prevtx: TransactionU16LenLimited,
452 /// The index of the output being spent
454 /// The sequence number of this input
458 /// A tx_add_output message for adding an output during interactive transaction construction.
460 // TODO(dual_funding): Add spec link for `tx_add_output`.
461 #[derive(Clone, Debug, PartialEq, Eq)]
462 pub struct TxAddOutput {
464 pub channel_id: ChannelId,
465 /// A randomly chosen unique identifier for this output, which is even for initiators and odd for
468 /// The satoshi value of the output
470 /// The scriptPubKey for the output
474 /// A tx_remove_input message for removing an input during interactive transaction construction.
476 // TODO(dual_funding): Add spec link for `tx_remove_input`.
477 #[derive(Clone, Debug, PartialEq, Eq)]
478 pub struct TxRemoveInput {
480 pub channel_id: ChannelId,
481 /// The serial ID of the input to be removed
485 /// A tx_remove_output message for removing an output during interactive transaction construction.
487 // TODO(dual_funding): Add spec link for `tx_remove_output`.
488 #[derive(Clone, Debug, PartialEq, Eq)]
489 pub struct TxRemoveOutput {
491 pub channel_id: ChannelId,
492 /// The serial ID of the output to be removed
496 /// A tx_complete message signalling the conclusion of a peer's transaction contributions during
497 /// interactive transaction construction.
499 // TODO(dual_funding): Add spec link for `tx_complete`.
500 #[derive(Clone, Debug, PartialEq, Eq)]
501 pub struct TxComplete {
503 pub channel_id: ChannelId,
506 /// A tx_signatures message containing the sender's signatures for a transaction constructed with
507 /// interactive transaction construction.
509 // TODO(dual_funding): Add spec link for `tx_signatures`.
510 #[derive(Clone, Debug, PartialEq, Eq)]
511 pub struct TxSignatures {
513 pub channel_id: ChannelId,
516 /// The list of witnesses
517 pub witnesses: Vec<Witness>,
520 /// A tx_init_rbf message which initiates a replacement of the transaction after it's been
523 // TODO(dual_funding): Add spec link for `tx_init_rbf`.
524 #[derive(Clone, Debug, PartialEq, Eq)]
525 pub struct TxInitRbf {
527 pub channel_id: ChannelId,
528 /// The locktime of the transaction
530 /// The feerate of the transaction
531 pub feerate_sat_per_1000_weight: u32,
532 /// The number of satoshis the sender will contribute to or, if negative, remove from
533 /// (e.g. splice-out) the funding output of the transaction
534 pub funding_output_contribution: Option<i64>,
537 /// A tx_ack_rbf message which acknowledges replacement of the transaction after it's been
540 // TODO(dual_funding): Add spec link for `tx_ack_rbf`.
541 #[derive(Clone, Debug, PartialEq, Eq)]
542 pub struct TxAckRbf {
544 pub channel_id: ChannelId,
545 /// The number of satoshis the sender will contribute to or, if negative, remove from
546 /// (e.g. splice-out) the funding output of the transaction
547 pub funding_output_contribution: Option<i64>,
550 /// A tx_abort message which signals the cancellation of an in-progress transaction negotiation.
552 // TODO(dual_funding): Add spec link for `tx_abort`.
553 #[derive(Clone, Debug, PartialEq, Eq)]
556 pub channel_id: ChannelId,
561 /// A [`shutdown`] message to be sent to or received from a peer.
563 /// [`shutdown`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-initiation-shutdown
564 #[derive(Clone, Debug, PartialEq, Eq)]
565 pub struct Shutdown {
567 pub channel_id: ChannelId,
568 /// The destination of this peer's funds on closing.
570 /// Must be in one of these forms: P2PKH, P2SH, P2WPKH, P2WSH, P2TR.
571 pub scriptpubkey: Script,
574 /// The minimum and maximum fees which the sender is willing to place on the closing transaction.
576 /// This is provided in [`ClosingSigned`] by both sides to indicate the fee range they are willing
578 #[derive(Clone, Debug, PartialEq, Eq)]
579 pub struct ClosingSignedFeeRange {
580 /// The minimum absolute fee, in satoshis, which the sender is willing to place on the closing
582 pub min_fee_satoshis: u64,
583 /// The maximum absolute fee, in satoshis, which the sender is willing to place on the closing
585 pub max_fee_satoshis: u64,
588 /// A [`closing_signed`] message to be sent to or received from a peer.
590 /// [`closing_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-negotiation-closing_signed
591 #[derive(Clone, Debug, PartialEq, Eq)]
592 pub struct ClosingSigned {
594 pub channel_id: ChannelId,
595 /// The proposed total fee for the closing transaction
596 pub fee_satoshis: u64,
597 /// A signature on the closing transaction
598 pub signature: Signature,
599 /// The minimum and maximum fees which the sender is willing to accept, provided only by new
601 pub fee_range: Option<ClosingSignedFeeRange>,
604 /// An [`update_add_htlc`] message to be sent to or received from a peer.
606 /// [`update_add_htlc`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#adding-an-htlc-update_add_htlc
607 #[derive(Clone, Debug, PartialEq, Eq)]
608 pub struct UpdateAddHTLC {
610 pub channel_id: ChannelId,
613 /// The HTLC value in milli-satoshi
614 pub amount_msat: u64,
615 /// The payment hash, the pre-image of which controls HTLC redemption
616 pub payment_hash: PaymentHash,
617 /// The expiry height of the HTLC
618 pub cltv_expiry: u32,
619 /// The extra fee skimmed by the sender of this message. See
620 /// [`ChannelConfig::accept_underpaying_htlcs`].
622 /// [`ChannelConfig::accept_underpaying_htlcs`]: crate::util::config::ChannelConfig::accept_underpaying_htlcs
623 pub skimmed_fee_msat: Option<u64>,
624 pub(crate) onion_routing_packet: OnionPacket,
627 /// An onion message to be sent to or received from a peer.
629 // TODO: update with link to OM when they are merged into the BOLTs
630 #[derive(Clone, Debug, PartialEq, Eq)]
631 pub struct OnionMessage {
632 /// Used in decrypting the onion packet's payload.
633 pub blinding_point: PublicKey,
634 /// The full onion packet including hop data, pubkey, and hmac
635 pub onion_routing_packet: onion_message::Packet,
638 /// An [`update_fulfill_htlc`] message to be sent to or received from a peer.
640 /// [`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
641 #[derive(Clone, Debug, PartialEq, Eq)]
642 pub struct UpdateFulfillHTLC {
644 pub channel_id: ChannelId,
647 /// The pre-image of the payment hash, allowing HTLC redemption
648 pub payment_preimage: PaymentPreimage,
651 /// An [`update_fail_htlc`] message to be sent to or received from a peer.
653 /// [`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
654 #[derive(Clone, Debug, PartialEq, Eq)]
655 pub struct UpdateFailHTLC {
657 pub channel_id: ChannelId,
660 pub(crate) reason: OnionErrorPacket,
663 /// An [`update_fail_malformed_htlc`] message to be sent to or received from a peer.
665 /// [`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
666 #[derive(Clone, Debug, PartialEq, Eq)]
667 pub struct UpdateFailMalformedHTLC {
669 pub channel_id: ChannelId,
672 pub(crate) sha256_of_onion: [u8; 32],
674 pub failure_code: u16,
677 /// A [`commitment_signed`] message to be sent to or received from a peer.
679 /// [`commitment_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#committing-updates-so-far-commitment_signed
680 #[derive(Clone, Debug, PartialEq, Eq)]
681 pub struct CommitmentSigned {
683 pub channel_id: ChannelId,
684 /// A signature on the commitment transaction
685 pub signature: Signature,
686 /// Signatures on the HTLC transactions
687 pub htlc_signatures: Vec<Signature>,
689 /// The partial Taproot signature on the commitment transaction
690 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
693 /// A [`revoke_and_ack`] message to be sent to or received from a peer.
695 /// [`revoke_and_ack`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#completing-the-transition-to-the-updated-state-revoke_and_ack
696 #[derive(Clone, Debug, PartialEq, Eq)]
697 pub struct RevokeAndACK {
699 pub channel_id: ChannelId,
700 /// The secret corresponding to the per-commitment point
701 pub per_commitment_secret: [u8; 32],
702 /// The next sender-broadcast commitment transaction's per-commitment point
703 pub next_per_commitment_point: PublicKey,
705 /// Musig nonce the recipient should use in their next commitment signature message
706 pub next_local_nonce: Option<musig2::types::PublicNonce>
709 /// An [`update_fee`] message to be sent to or received from a peer
711 /// [`update_fee`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#updating-fees-update_fee
712 #[derive(Clone, Debug, PartialEq, Eq)]
713 pub struct UpdateFee {
715 pub channel_id: ChannelId,
716 /// Fee rate per 1000-weight of the transaction
717 pub feerate_per_kw: u32,
720 /// A [`channel_reestablish`] message to be sent to or received from a peer.
722 /// [`channel_reestablish`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#message-retransmission
723 #[derive(Clone, Debug, PartialEq, Eq)]
724 pub struct ChannelReestablish {
726 pub channel_id: ChannelId,
727 /// The next commitment number for the sender
728 pub next_local_commitment_number: u64,
729 /// The next commitment number for the recipient
730 pub next_remote_commitment_number: u64,
731 /// Proof that the sender knows the per-commitment secret of a specific commitment transaction
732 /// belonging to the recipient
733 pub your_last_per_commitment_secret: [u8; 32],
734 /// The sender's per-commitment point for their current commitment transaction
735 pub my_current_per_commitment_point: PublicKey,
736 /// The next funding transaction ID
737 pub next_funding_txid: Option<Txid>,
740 /// An [`announcement_signatures`] message to be sent to or received from a peer.
742 /// [`announcement_signatures`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-announcement_signatures-message
743 #[derive(Clone, Debug, PartialEq, Eq)]
744 pub struct AnnouncementSignatures {
746 pub channel_id: ChannelId,
747 /// The short channel ID
748 pub short_channel_id: u64,
749 /// A signature by the node key
750 pub node_signature: Signature,
751 /// A signature by the funding key
752 pub bitcoin_signature: Signature,
755 /// An address which can be used to connect to a remote peer.
756 #[derive(Clone, Debug, PartialEq, Eq)]
757 pub enum SocketAddress {
758 /// An IPv4 address and port on which the peer is listening.
760 /// The 4-byte IPv4 address
762 /// The port on which the node is listening
765 /// An IPv6 address and port on which the peer is listening.
767 /// The 16-byte IPv6 address
769 /// The port on which the node is listening
772 /// An old-style Tor onion address/port on which the peer is listening.
774 /// This field is deprecated and the Tor network generally no longer supports V2 Onion
775 /// addresses. Thus, the details are not parsed here.
777 /// A new-style Tor onion address/port on which the peer is listening.
779 /// To create the human-readable "hostname", concatenate the ED25519 pubkey, checksum, and version,
780 /// wrap as base32 and append ".onion".
782 /// The ed25519 long-term public key of the peer
783 ed25519_pubkey: [u8; 32],
784 /// The checksum of the pubkey and version, as included in the onion address
786 /// The version byte, as defined by the Tor Onion v3 spec.
788 /// The port on which the node is listening
791 /// A hostname/port on which the peer is listening.
793 /// The hostname on which the node is listening.
795 /// The port on which the node is listening.
800 /// Gets the ID of this address type. Addresses in [`NodeAnnouncement`] messages should be sorted
802 pub(crate) fn get_id(&self) -> u8 {
804 &SocketAddress::TcpIpV4 {..} => { 1 },
805 &SocketAddress::TcpIpV6 {..} => { 2 },
806 &SocketAddress::OnionV2(_) => { 3 },
807 &SocketAddress::OnionV3 {..} => { 4 },
808 &SocketAddress::Hostname {..} => { 5 },
812 /// Strict byte-length of address descriptor, 1-byte type not recorded
813 fn len(&self) -> u16 {
815 &SocketAddress::TcpIpV4 { .. } => { 6 },
816 &SocketAddress::TcpIpV6 { .. } => { 18 },
817 &SocketAddress::OnionV2(_) => { 12 },
818 &SocketAddress::OnionV3 { .. } => { 37 },
819 // Consists of 1-byte hostname length, hostname bytes, and 2-byte port.
820 &SocketAddress::Hostname { ref hostname, .. } => { u16::from(hostname.len()) + 3 },
824 /// The maximum length of any address descriptor, not including the 1-byte type.
825 /// This maximum length is reached by a hostname address descriptor:
826 /// a hostname with a maximum length of 255, its 1-byte length and a 2-byte port.
827 pub(crate) const MAX_LEN: u16 = 258;
830 impl Writeable for SocketAddress {
831 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
833 &SocketAddress::TcpIpV4 { ref addr, ref port } => {
838 &SocketAddress::TcpIpV6 { ref addr, ref port } => {
843 &SocketAddress::OnionV2(bytes) => {
845 bytes.write(writer)?;
847 &SocketAddress::OnionV3 { ref ed25519_pubkey, ref checksum, ref version, ref port } => {
849 ed25519_pubkey.write(writer)?;
850 checksum.write(writer)?;
851 version.write(writer)?;
854 &SocketAddress::Hostname { ref hostname, ref port } => {
856 hostname.write(writer)?;
864 impl Readable for Result<SocketAddress, u8> {
865 fn read<R: Read>(reader: &mut R) -> Result<Result<SocketAddress, u8>, DecodeError> {
866 let byte = <u8 as Readable>::read(reader)?;
869 Ok(Ok(SocketAddress::TcpIpV4 {
870 addr: Readable::read(reader)?,
871 port: Readable::read(reader)?,
875 Ok(Ok(SocketAddress::TcpIpV6 {
876 addr: Readable::read(reader)?,
877 port: Readable::read(reader)?,
880 3 => Ok(Ok(SocketAddress::OnionV2(Readable::read(reader)?))),
882 Ok(Ok(SocketAddress::OnionV3 {
883 ed25519_pubkey: Readable::read(reader)?,
884 checksum: Readable::read(reader)?,
885 version: Readable::read(reader)?,
886 port: Readable::read(reader)?,
890 Ok(Ok(SocketAddress::Hostname {
891 hostname: Readable::read(reader)?,
892 port: Readable::read(reader)?,
895 _ => return Ok(Err(byte)),
900 impl Readable for SocketAddress {
901 fn read<R: Read>(reader: &mut R) -> Result<SocketAddress, DecodeError> {
902 match Readable::read(reader) {
903 Ok(Ok(res)) => Ok(res),
904 Ok(Err(_)) => Err(DecodeError::UnknownVersion),
910 /// [`SocketAddress`] error variants
911 #[derive(Debug, Eq, PartialEq, Clone)]
912 pub enum SocketAddressParseError {
913 /// Socket address (IPv4/IPv6) parsing error
915 /// Invalid input format
919 /// Invalid onion v3 address
923 impl fmt::Display for SocketAddressParseError {
924 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
926 SocketAddressParseError::SocketAddrParse => write!(f, "Socket address (IPv4/IPv6) parsing error"),
927 SocketAddressParseError::InvalidInput => write!(f, "Invalid input format. \
928 Expected: \"<ipv4>:<port>\", \"[<ipv6>]:<port>\", \"<onion address>.onion:<port>\" or \"<hostname>:<port>\""),
929 SocketAddressParseError::InvalidPort => write!(f, "Invalid port"),
930 SocketAddressParseError::InvalidOnionV3 => write!(f, "Invalid onion v3 address"),
935 #[cfg(feature = "std")]
936 impl From<std::net::SocketAddrV4> for SocketAddress {
937 fn from(addr: std::net::SocketAddrV4) -> Self {
938 SocketAddress::TcpIpV4 { addr: addr.ip().octets(), port: addr.port() }
942 #[cfg(feature = "std")]
943 impl From<std::net::SocketAddrV6> for SocketAddress {
944 fn from(addr: std::net::SocketAddrV6) -> Self {
945 SocketAddress::TcpIpV6 { addr: addr.ip().octets(), port: addr.port() }
949 #[cfg(feature = "std")]
950 impl From<std::net::SocketAddr> for SocketAddress {
951 fn from(addr: std::net::SocketAddr) -> Self {
953 std::net::SocketAddr::V4(addr) => addr.into(),
954 std::net::SocketAddr::V6(addr) => addr.into(),
959 fn parse_onion_address(host: &str, port: u16) -> Result<SocketAddress, SocketAddressParseError> {
960 if host.ends_with(".onion") {
961 let domain = &host[..host.len() - ".onion".len()];
962 if domain.len() != 56 {
963 return Err(SocketAddressParseError::InvalidOnionV3);
965 let onion = base32::Alphabet::RFC4648 { padding: false }.decode(&domain).map_err(|_| SocketAddressParseError::InvalidOnionV3)?;
966 if onion.len() != 35 {
967 return Err(SocketAddressParseError::InvalidOnionV3);
969 let version = onion[0];
970 let first_checksum_flag = onion[1];
971 let second_checksum_flag = onion[2];
972 let mut ed25519_pubkey = [0; 32];
973 ed25519_pubkey.copy_from_slice(&onion[3..35]);
974 let checksum = u16::from_be_bytes([first_checksum_flag, second_checksum_flag]);
975 return Ok(SocketAddress::OnionV3 { ed25519_pubkey, checksum, version, port });
978 return Err(SocketAddressParseError::InvalidInput);
982 #[cfg(feature = "std")]
983 impl FromStr for SocketAddress {
984 type Err = SocketAddressParseError;
986 fn from_str(s: &str) -> Result<Self, Self::Err> {
987 match std::net::SocketAddr::from_str(s) {
988 Ok(addr) => Ok(addr.into()),
990 let trimmed_input = match s.rfind(":") {
992 None => return Err(SocketAddressParseError::InvalidInput),
994 let host = &s[..trimmed_input];
995 let port: u16 = s[trimmed_input + 1..].parse().map_err(|_| SocketAddressParseError::InvalidPort)?;
996 if host.ends_with(".onion") {
997 return parse_onion_address(host, port);
999 if let Ok(hostname) = Hostname::try_from(s[..trimmed_input].to_string()) {
1000 return Ok(SocketAddress::Hostname { hostname, port });
1002 return Err(SocketAddressParseError::SocketAddrParse)
1008 /// Represents the set of gossip messages that require a signature from a node's identity key.
1009 pub enum UnsignedGossipMessage<'a> {
1010 /// An unsigned channel announcement.
1011 ChannelAnnouncement(&'a UnsignedChannelAnnouncement),
1012 /// An unsigned channel update.
1013 ChannelUpdate(&'a UnsignedChannelUpdate),
1014 /// An unsigned node announcement.
1015 NodeAnnouncement(&'a UnsignedNodeAnnouncement)
1018 impl<'a> Writeable for UnsignedGossipMessage<'a> {
1019 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
1021 UnsignedGossipMessage::ChannelAnnouncement(ref msg) => msg.write(writer),
1022 UnsignedGossipMessage::ChannelUpdate(ref msg) => msg.write(writer),
1023 UnsignedGossipMessage::NodeAnnouncement(ref msg) => msg.write(writer),
1028 /// The unsigned part of a [`node_announcement`] message.
1030 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
1031 #[derive(Clone, Debug, PartialEq, Eq)]
1032 pub struct UnsignedNodeAnnouncement {
1033 /// The advertised features
1034 pub features: NodeFeatures,
1035 /// A strictly monotonic announcement counter, with gaps allowed
1037 /// The `node_id` this announcement originated from (don't rebroadcast the `node_announcement` back
1039 pub node_id: NodeId,
1040 /// An RGB color for UI purposes
1042 /// An alias, for UI purposes.
1044 /// This should be sanitized before use. There is no guarantee of uniqueness.
1045 pub alias: NodeAlias,
1046 /// List of addresses on which this node is reachable
1047 pub addresses: Vec<SocketAddress>,
1048 pub(crate) excess_address_data: Vec<u8>,
1049 pub(crate) excess_data: Vec<u8>,
1051 #[derive(Clone, Debug, PartialEq, Eq)]
1052 /// A [`node_announcement`] message to be sent to or received from a peer.
1054 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
1055 pub struct NodeAnnouncement {
1056 /// The signature by the node key
1057 pub signature: Signature,
1058 /// The actual content of the announcement
1059 pub contents: UnsignedNodeAnnouncement,
1062 /// The unsigned part of a [`channel_announcement`] message.
1064 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
1065 #[derive(Clone, Debug, PartialEq, Eq)]
1066 pub struct UnsignedChannelAnnouncement {
1067 /// The advertised channel features
1068 pub features: ChannelFeatures,
1069 /// The genesis hash of the blockchain where the channel is to be opened
1070 pub chain_hash: BlockHash,
1071 /// The short channel ID
1072 pub short_channel_id: u64,
1073 /// One of the two `node_id`s which are endpoints of this channel
1074 pub node_id_1: NodeId,
1075 /// The other of the two `node_id`s which are endpoints of this channel
1076 pub node_id_2: NodeId,
1077 /// The funding key for the first node
1078 pub bitcoin_key_1: NodeId,
1079 /// The funding key for the second node
1080 pub bitcoin_key_2: NodeId,
1081 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1084 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1085 pub excess_data: Vec<u8>,
1087 /// A [`channel_announcement`] message to be sent to or received from a peer.
1089 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
1090 #[derive(Clone, Debug, PartialEq, Eq)]
1091 pub struct ChannelAnnouncement {
1092 /// Authentication of the announcement by the first public node
1093 pub node_signature_1: Signature,
1094 /// Authentication of the announcement by the second public node
1095 pub node_signature_2: Signature,
1096 /// Proof of funding UTXO ownership by the first public node
1097 pub bitcoin_signature_1: Signature,
1098 /// Proof of funding UTXO ownership by the second public node
1099 pub bitcoin_signature_2: Signature,
1100 /// The actual announcement
1101 pub contents: UnsignedChannelAnnouncement,
1104 /// The unsigned part of a [`channel_update`] message.
1106 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1107 #[derive(Clone, Debug, PartialEq, Eq)]
1108 pub struct UnsignedChannelUpdate {
1109 /// The genesis hash of the blockchain where the channel is to be opened
1110 pub chain_hash: BlockHash,
1111 /// The short channel ID
1112 pub short_channel_id: u64,
1113 /// A strictly monotonic announcement counter, with gaps allowed, specific to this channel
1117 /// The number of blocks such that if:
1118 /// `incoming_htlc.cltv_expiry < outgoing_htlc.cltv_expiry + cltv_expiry_delta`
1119 /// then we need to fail the HTLC backwards. When forwarding an HTLC, `cltv_expiry_delta` determines
1120 /// the outgoing HTLC's minimum `cltv_expiry` value -- so, if an incoming HTLC comes in with a
1121 /// `cltv_expiry` of 100000, and the node we're forwarding to has a `cltv_expiry_delta` value of 10,
1122 /// then we'll check that the outgoing HTLC's `cltv_expiry` value is at least 100010 before
1123 /// forwarding. Note that the HTLC sender is the one who originally sets this value when
1124 /// constructing the route.
1125 pub cltv_expiry_delta: u16,
1126 /// The minimum HTLC size incoming to sender, in milli-satoshi
1127 pub htlc_minimum_msat: u64,
1128 /// The maximum HTLC value incoming to sender, in milli-satoshi.
1130 /// This used to be optional.
1131 pub htlc_maximum_msat: u64,
1132 /// The base HTLC fee charged by sender, in milli-satoshi
1133 pub fee_base_msat: u32,
1134 /// The amount to fee multiplier, in micro-satoshi
1135 pub fee_proportional_millionths: u32,
1136 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1139 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1140 pub excess_data: Vec<u8>,
1142 /// A [`channel_update`] message to be sent to or received from a peer.
1144 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1145 #[derive(Clone, Debug, PartialEq, Eq)]
1146 pub struct ChannelUpdate {
1147 /// A signature of the channel update
1148 pub signature: Signature,
1149 /// The actual channel update
1150 pub contents: UnsignedChannelUpdate,
1153 /// A [`query_channel_range`] message is used to query a peer for channel
1154 /// UTXOs in a range of blocks. The recipient of a query makes a best
1155 /// effort to reply to the query using one or more [`ReplyChannelRange`]
1158 /// [`query_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1159 #[derive(Clone, Debug, PartialEq, Eq)]
1160 pub struct QueryChannelRange {
1161 /// The genesis hash of the blockchain being queried
1162 pub chain_hash: BlockHash,
1163 /// The height of the first block for the channel UTXOs being queried
1164 pub first_blocknum: u32,
1165 /// The number of blocks to include in the query results
1166 pub number_of_blocks: u32,
1169 /// A [`reply_channel_range`] message is a reply to a [`QueryChannelRange`]
1172 /// Multiple `reply_channel_range` messages can be sent in reply
1173 /// to a single [`QueryChannelRange`] message. The query recipient makes a
1174 /// best effort to respond based on their local network view which may
1175 /// not be a perfect view of the network. The `short_channel_id`s in the
1176 /// reply are encoded. We only support `encoding_type=0` uncompressed
1177 /// serialization and do not support `encoding_type=1` zlib serialization.
1179 /// [`reply_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1180 #[derive(Clone, Debug, PartialEq, Eq)]
1181 pub struct ReplyChannelRange {
1182 /// The genesis hash of the blockchain being queried
1183 pub chain_hash: BlockHash,
1184 /// The height of the first block in the range of the reply
1185 pub first_blocknum: u32,
1186 /// The number of blocks included in the range of the reply
1187 pub number_of_blocks: u32,
1188 /// True when this is the final reply for a query
1189 pub sync_complete: bool,
1190 /// The `short_channel_id`s in the channel range
1191 pub short_channel_ids: Vec<u64>,
1194 /// A [`query_short_channel_ids`] message is used to query a peer for
1195 /// routing gossip messages related to one or more `short_channel_id`s.
1197 /// The query recipient will reply with the latest, if available,
1198 /// [`ChannelAnnouncement`], [`ChannelUpdate`] and [`NodeAnnouncement`] messages
1199 /// it maintains for the requested `short_channel_id`s followed by a
1200 /// [`ReplyShortChannelIdsEnd`] message. The `short_channel_id`s sent in
1201 /// this query are encoded. We only support `encoding_type=0` uncompressed
1202 /// serialization and do not support `encoding_type=1` zlib serialization.
1204 /// [`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
1205 #[derive(Clone, Debug, PartialEq, Eq)]
1206 pub struct QueryShortChannelIds {
1207 /// The genesis hash of the blockchain being queried
1208 pub chain_hash: BlockHash,
1209 /// The short_channel_ids that are being queried
1210 pub short_channel_ids: Vec<u64>,
1213 /// A [`reply_short_channel_ids_end`] message is sent as a reply to a
1214 /// message. The query recipient makes a best
1215 /// effort to respond based on their local network view which may not be
1216 /// a perfect view of the network.
1218 /// [`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
1219 #[derive(Clone, Debug, PartialEq, Eq)]
1220 pub struct ReplyShortChannelIdsEnd {
1221 /// The genesis hash of the blockchain that was queried
1222 pub chain_hash: BlockHash,
1223 /// Indicates if the query recipient maintains up-to-date channel
1224 /// information for the `chain_hash`
1225 pub full_information: bool,
1228 /// A [`gossip_timestamp_filter`] message is used by a node to request
1229 /// gossip relay for messages in the requested time range when the
1230 /// `gossip_queries` feature has been negotiated.
1232 /// [`gossip_timestamp_filter`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-gossip_timestamp_filter-message
1233 #[derive(Clone, Debug, PartialEq, Eq)]
1234 pub struct GossipTimestampFilter {
1235 /// The genesis hash of the blockchain for channel and node information
1236 pub chain_hash: BlockHash,
1237 /// The starting unix timestamp
1238 pub first_timestamp: u32,
1239 /// The range of information in seconds
1240 pub timestamp_range: u32,
1243 /// Encoding type for data compression of collections in gossip queries.
1245 /// We do not support `encoding_type=1` zlib serialization [defined in BOLT
1246 /// #7](https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#query-messages).
1248 Uncompressed = 0x00,
1251 /// Used to put an error message in a [`LightningError`].
1252 #[derive(Clone, Debug, PartialEq)]
1253 pub enum ErrorAction {
1254 /// The peer took some action which made us think they were useless. Disconnect them.
1256 /// An error message which we should make an effort to send before we disconnect.
1257 msg: Option<ErrorMessage>
1259 /// The peer did something incorrect. Tell them without closing any channels and disconnect them.
1260 DisconnectPeerWithWarning {
1261 /// A warning message which we should make an effort to send before we disconnect.
1262 msg: WarningMessage,
1264 /// The peer did something harmless that we weren't able to process, just log and ignore
1265 // New code should *not* use this. New code must use IgnoreAndLog, below!
1267 /// The peer did something harmless that we weren't able to meaningfully process.
1268 /// If the error is logged, log it at the given level.
1269 IgnoreAndLog(logger::Level),
1270 /// The peer provided us with a gossip message which we'd already seen. In most cases this
1271 /// should be ignored, but it may result in the message being forwarded if it is a duplicate of
1272 /// our own channel announcements.
1273 IgnoreDuplicateGossip,
1274 /// The peer did something incorrect. Tell them.
1276 /// The message to send.
1279 /// The peer did something incorrect. Tell them without closing any channels.
1280 SendWarningMessage {
1281 /// The message to send.
1282 msg: WarningMessage,
1283 /// The peer may have done something harmless that we weren't able to meaningfully process,
1284 /// though we should still tell them about it.
1285 /// If this event is logged, log it at the given level.
1286 log_level: logger::Level,
1290 /// An Err type for failure to process messages.
1291 #[derive(Clone, Debug)]
1292 pub struct LightningError {
1293 /// A human-readable message describing the error
1295 /// The action which should be taken against the offending peer.
1296 pub action: ErrorAction,
1299 /// Struct used to return values from [`RevokeAndACK`] messages, containing a bunch of commitment
1300 /// transaction updates if they were pending.
1301 #[derive(Clone, Debug, PartialEq, Eq)]
1302 pub struct CommitmentUpdate {
1303 /// `update_add_htlc` messages which should be sent
1304 pub update_add_htlcs: Vec<UpdateAddHTLC>,
1305 /// `update_fulfill_htlc` messages which should be sent
1306 pub update_fulfill_htlcs: Vec<UpdateFulfillHTLC>,
1307 /// `update_fail_htlc` messages which should be sent
1308 pub update_fail_htlcs: Vec<UpdateFailHTLC>,
1309 /// `update_fail_malformed_htlc` messages which should be sent
1310 pub update_fail_malformed_htlcs: Vec<UpdateFailMalformedHTLC>,
1311 /// An `update_fee` message which should be sent
1312 pub update_fee: Option<UpdateFee>,
1313 /// A `commitment_signed` message which should be sent
1314 pub commitment_signed: CommitmentSigned,
1317 /// A trait to describe an object which can receive channel messages.
1319 /// Messages MAY be called in parallel when they originate from different `their_node_ids`, however
1320 /// they MUST NOT be called in parallel when the two calls have the same `their_node_id`.
1321 pub trait ChannelMessageHandler : MessageSendEventsProvider {
1323 /// Handle an incoming `open_channel` message from the given peer.
1324 fn handle_open_channel(&self, their_node_id: &PublicKey, msg: &OpenChannel);
1325 /// Handle an incoming `open_channel2` message from the given peer.
1326 fn handle_open_channel_v2(&self, their_node_id: &PublicKey, msg: &OpenChannelV2);
1327 /// Handle an incoming `accept_channel` message from the given peer.
1328 fn handle_accept_channel(&self, their_node_id: &PublicKey, msg: &AcceptChannel);
1329 /// Handle an incoming `accept_channel2` message from the given peer.
1330 fn handle_accept_channel_v2(&self, their_node_id: &PublicKey, msg: &AcceptChannelV2);
1331 /// Handle an incoming `funding_created` message from the given peer.
1332 fn handle_funding_created(&self, their_node_id: &PublicKey, msg: &FundingCreated);
1333 /// Handle an incoming `funding_signed` message from the given peer.
1334 fn handle_funding_signed(&self, their_node_id: &PublicKey, msg: &FundingSigned);
1335 /// Handle an incoming `channel_ready` message from the given peer.
1336 fn handle_channel_ready(&self, their_node_id: &PublicKey, msg: &ChannelReady);
1339 /// Handle an incoming `shutdown` message from the given peer.
1340 fn handle_shutdown(&self, their_node_id: &PublicKey, msg: &Shutdown);
1341 /// Handle an incoming `closing_signed` message from the given peer.
1342 fn handle_closing_signed(&self, their_node_id: &PublicKey, msg: &ClosingSigned);
1344 // Interactive channel construction
1345 /// Handle an incoming `tx_add_input message` from the given peer.
1346 fn handle_tx_add_input(&self, their_node_id: &PublicKey, msg: &TxAddInput);
1347 /// Handle an incoming `tx_add_output` message from the given peer.
1348 fn handle_tx_add_output(&self, their_node_id: &PublicKey, msg: &TxAddOutput);
1349 /// Handle an incoming `tx_remove_input` message from the given peer.
1350 fn handle_tx_remove_input(&self, their_node_id: &PublicKey, msg: &TxRemoveInput);
1351 /// Handle an incoming `tx_remove_output` message from the given peer.
1352 fn handle_tx_remove_output(&self, their_node_id: &PublicKey, msg: &TxRemoveOutput);
1353 /// Handle an incoming `tx_complete message` from the given peer.
1354 fn handle_tx_complete(&self, their_node_id: &PublicKey, msg: &TxComplete);
1355 /// Handle an incoming `tx_signatures` message from the given peer.
1356 fn handle_tx_signatures(&self, their_node_id: &PublicKey, msg: &TxSignatures);
1357 /// Handle an incoming `tx_init_rbf` message from the given peer.
1358 fn handle_tx_init_rbf(&self, their_node_id: &PublicKey, msg: &TxInitRbf);
1359 /// Handle an incoming `tx_ack_rbf` message from the given peer.
1360 fn handle_tx_ack_rbf(&self, their_node_id: &PublicKey, msg: &TxAckRbf);
1361 /// Handle an incoming `tx_abort message` from the given peer.
1362 fn handle_tx_abort(&self, their_node_id: &PublicKey, msg: &TxAbort);
1365 /// Handle an incoming `update_add_htlc` message from the given peer.
1366 fn handle_update_add_htlc(&self, their_node_id: &PublicKey, msg: &UpdateAddHTLC);
1367 /// Handle an incoming `update_fulfill_htlc` message from the given peer.
1368 fn handle_update_fulfill_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFulfillHTLC);
1369 /// Handle an incoming `update_fail_htlc` message from the given peer.
1370 fn handle_update_fail_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailHTLC);
1371 /// Handle an incoming `update_fail_malformed_htlc` message from the given peer.
1372 fn handle_update_fail_malformed_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailMalformedHTLC);
1373 /// Handle an incoming `commitment_signed` message from the given peer.
1374 fn handle_commitment_signed(&self, their_node_id: &PublicKey, msg: &CommitmentSigned);
1375 /// Handle an incoming `revoke_and_ack` message from the given peer.
1376 fn handle_revoke_and_ack(&self, their_node_id: &PublicKey, msg: &RevokeAndACK);
1378 /// Handle an incoming `update_fee` message from the given peer.
1379 fn handle_update_fee(&self, their_node_id: &PublicKey, msg: &UpdateFee);
1381 // Channel-to-announce:
1382 /// Handle an incoming `announcement_signatures` message from the given peer.
1383 fn handle_announcement_signatures(&self, their_node_id: &PublicKey, msg: &AnnouncementSignatures);
1385 // Connection loss/reestablish:
1386 /// Indicates a connection to the peer failed/an existing connection was lost.
1387 fn peer_disconnected(&self, their_node_id: &PublicKey);
1389 /// Handle a peer reconnecting, possibly generating `channel_reestablish` message(s).
1391 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1392 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1393 /// message handlers may still wish to communicate with this peer.
1394 fn peer_connected(&self, their_node_id: &PublicKey, msg: &Init, inbound: bool) -> Result<(), ()>;
1395 /// Handle an incoming `channel_reestablish` message from the given peer.
1396 fn handle_channel_reestablish(&self, their_node_id: &PublicKey, msg: &ChannelReestablish);
1398 /// Handle an incoming `channel_update` message from the given peer.
1399 fn handle_channel_update(&self, their_node_id: &PublicKey, msg: &ChannelUpdate);
1402 /// Handle an incoming `error` message from the given peer.
1403 fn handle_error(&self, their_node_id: &PublicKey, msg: &ErrorMessage);
1405 // Handler information:
1406 /// Gets the node feature flags which this handler itself supports. All available handlers are
1407 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1408 /// which are broadcasted in our [`NodeAnnouncement`] message.
1409 fn provided_node_features(&self) -> NodeFeatures;
1411 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1412 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1413 /// which are sent in our [`Init`] message.
1415 /// Note that this method is called before [`Self::peer_connected`].
1416 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1418 /// Gets the genesis hashes for this `ChannelMessageHandler` indicating which chains it supports.
1420 /// If it's `None`, then no particular network chain hash compatibility will be enforced when
1421 /// connecting to peers.
1422 fn get_genesis_hashes(&self) -> Option<Vec<ChainHash>>;
1425 /// A trait to describe an object which can receive routing messages.
1427 /// # Implementor DoS Warnings
1429 /// For messages enabled with the `gossip_queries` feature there are potential DoS vectors when
1430 /// handling inbound queries. Implementors using an on-disk network graph should be aware of
1431 /// repeated disk I/O for queries accessing different parts of the network graph.
1432 pub trait RoutingMessageHandler : MessageSendEventsProvider {
1433 /// Handle an incoming `node_announcement` message, returning `true` if it should be forwarded on,
1434 /// `false` or returning an `Err` otherwise.
1435 fn handle_node_announcement(&self, msg: &NodeAnnouncement) -> Result<bool, LightningError>;
1436 /// Handle a `channel_announcement` message, returning `true` if it should be forwarded on, `false`
1437 /// or returning an `Err` otherwise.
1438 fn handle_channel_announcement(&self, msg: &ChannelAnnouncement) -> Result<bool, LightningError>;
1439 /// Handle an incoming `channel_update` message, returning true if it should be forwarded on,
1440 /// `false` or returning an `Err` otherwise.
1441 fn handle_channel_update(&self, msg: &ChannelUpdate) -> Result<bool, LightningError>;
1442 /// Gets channel announcements and updates required to dump our routing table to a remote node,
1443 /// starting at the `short_channel_id` indicated by `starting_point` and including announcements
1444 /// for a single channel.
1445 fn get_next_channel_announcement(&self, starting_point: u64) -> Option<(ChannelAnnouncement, Option<ChannelUpdate>, Option<ChannelUpdate>)>;
1446 /// Gets a node announcement required to dump our routing table to a remote node, starting at
1447 /// the node *after* the provided pubkey and including up to one announcement immediately
1448 /// higher (as defined by `<PublicKey as Ord>::cmp`) than `starting_point`.
1449 /// If `None` is provided for `starting_point`, we start at the first node.
1450 fn get_next_node_announcement(&self, starting_point: Option<&NodeId>) -> Option<NodeAnnouncement>;
1451 /// Called when a connection is established with a peer. This can be used to
1452 /// perform routing table synchronization using a strategy defined by the
1455 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1456 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1457 /// message handlers may still wish to communicate with this peer.
1458 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1459 /// Handles the reply of a query we initiated to learn about channels
1460 /// for a given range of blocks. We can expect to receive one or more
1461 /// replies to a single query.
1462 fn handle_reply_channel_range(&self, their_node_id: &PublicKey, msg: ReplyChannelRange) -> Result<(), LightningError>;
1463 /// Handles the reply of a query we initiated asking for routing gossip
1464 /// messages for a list of channels. We should receive this message when
1465 /// a node has completed its best effort to send us the pertaining routing
1466 /// gossip messages.
1467 fn handle_reply_short_channel_ids_end(&self, their_node_id: &PublicKey, msg: ReplyShortChannelIdsEnd) -> Result<(), LightningError>;
1468 /// Handles when a peer asks us to send a list of `short_channel_id`s
1469 /// for the requested range of blocks.
1470 fn handle_query_channel_range(&self, their_node_id: &PublicKey, msg: QueryChannelRange) -> Result<(), LightningError>;
1471 /// Handles when a peer asks us to send routing gossip messages for a
1472 /// list of `short_channel_id`s.
1473 fn handle_query_short_channel_ids(&self, their_node_id: &PublicKey, msg: QueryShortChannelIds) -> Result<(), LightningError>;
1475 // Handler queueing status:
1476 /// Indicates that there are a large number of [`ChannelAnnouncement`] (or other) messages
1477 /// pending some async action. While there is no guarantee of the rate of future messages, the
1478 /// caller should seek to reduce the rate of new gossip messages handled, especially
1479 /// [`ChannelAnnouncement`]s.
1480 fn processing_queue_high(&self) -> bool;
1482 // Handler information:
1483 /// Gets the node feature flags which this handler itself supports. All available handlers are
1484 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1485 /// which are broadcasted in our [`NodeAnnouncement`] message.
1486 fn provided_node_features(&self) -> NodeFeatures;
1487 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1488 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1489 /// which are sent in our [`Init`] message.
1491 /// Note that this method is called before [`Self::peer_connected`].
1492 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1495 /// A trait to describe an object that can receive onion messages.
1496 pub trait OnionMessageHandler : OnionMessageProvider {
1497 /// Handle an incoming `onion_message` message from the given peer.
1498 fn handle_onion_message(&self, peer_node_id: &PublicKey, msg: &OnionMessage);
1499 /// Called when a connection is established with a peer. Can be used to track which peers
1500 /// advertise onion message support and are online.
1502 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1503 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1504 /// message handlers may still wish to communicate with this peer.
1505 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1506 /// Indicates a connection to the peer failed/an existing connection was lost. Allows handlers to
1507 /// drop and refuse to forward onion messages to this peer.
1508 fn peer_disconnected(&self, their_node_id: &PublicKey);
1510 // Handler information:
1511 /// Gets the node feature flags which this handler itself supports. All available handlers are
1512 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1513 /// which are broadcasted in our [`NodeAnnouncement`] message.
1514 fn provided_node_features(&self) -> NodeFeatures;
1516 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1517 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1518 /// which are sent in our [`Init`] message.
1520 /// Note that this method is called before [`Self::peer_connected`].
1521 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1524 mod fuzzy_internal_msgs {
1525 use bitcoin::secp256k1::PublicKey;
1526 use crate::blinded_path::payment::PaymentConstraints;
1527 use crate::prelude::*;
1528 use crate::ln::{PaymentPreimage, PaymentSecret};
1530 // These types aren't intended to be pub, but are exposed for direct fuzzing (as we deserialize
1531 // them from untrusted input):
1533 pub struct FinalOnionHopData {
1534 pub payment_secret: PaymentSecret,
1535 /// The total value, in msat, of the payment as received by the ultimate recipient.
1536 /// Message serialization may panic if this value is more than 21 million Bitcoin.
1537 pub total_msat: u64,
1540 pub enum InboundOnionPayload {
1542 short_channel_id: u64,
1543 /// The value, in msat, of the payment after this hop's fee is deducted.
1544 amt_to_forward: u64,
1545 outgoing_cltv_value: u32,
1548 payment_data: Option<FinalOnionHopData>,
1549 payment_metadata: Option<Vec<u8>>,
1550 keysend_preimage: Option<PaymentPreimage>,
1551 custom_tlvs: Vec<(u64, Vec<u8>)>,
1553 outgoing_cltv_value: u32,
1558 outgoing_cltv_value: u32,
1559 payment_secret: PaymentSecret,
1560 payment_constraints: PaymentConstraints,
1561 intro_node_blinding_point: PublicKey,
1565 pub(crate) enum OutboundOnionPayload {
1567 short_channel_id: u64,
1568 /// The value, in msat, of the payment after this hop's fee is deducted.
1569 amt_to_forward: u64,
1570 outgoing_cltv_value: u32,
1573 payment_data: Option<FinalOnionHopData>,
1574 payment_metadata: Option<Vec<u8>>,
1575 keysend_preimage: Option<PaymentPreimage>,
1576 custom_tlvs: Vec<(u64, Vec<u8>)>,
1578 outgoing_cltv_value: u32,
1581 encrypted_tlvs: Vec<u8>,
1582 intro_node_blinding_point: Option<PublicKey>,
1587 outgoing_cltv_value: u32,
1588 encrypted_tlvs: Vec<u8>,
1589 intro_node_blinding_point: Option<PublicKey>, // Set if the introduction node of the blinded path is the final node
1593 pub struct DecodedOnionErrorPacket {
1594 pub(crate) hmac: [u8; 32],
1595 pub(crate) failuremsg: Vec<u8>,
1596 pub(crate) pad: Vec<u8>,
1600 pub use self::fuzzy_internal_msgs::*;
1601 #[cfg(not(fuzzing))]
1602 pub(crate) use self::fuzzy_internal_msgs::*;
1605 pub(crate) struct OnionPacket {
1606 pub(crate) version: u8,
1607 /// In order to ensure we always return an error on onion decode in compliance with [BOLT
1608 /// #4](https://github.com/lightning/bolts/blob/master/04-onion-routing.md), we have to
1609 /// deserialize `OnionPacket`s contained in [`UpdateAddHTLC`] messages even if the ephemeral
1610 /// public key (here) is bogus, so we hold a [`Result`] instead of a [`PublicKey`] as we'd
1612 pub(crate) public_key: Result<PublicKey, secp256k1::Error>,
1613 pub(crate) hop_data: [u8; 20*65],
1614 pub(crate) hmac: [u8; 32],
1617 impl onion_utils::Packet for OnionPacket {
1618 type Data = onion_utils::FixedSizeOnionPacket;
1619 fn new(pubkey: PublicKey, hop_data: onion_utils::FixedSizeOnionPacket, hmac: [u8; 32]) -> Self {
1622 public_key: Ok(pubkey),
1623 hop_data: hop_data.0,
1629 impl Eq for OnionPacket { }
1630 impl PartialEq for OnionPacket {
1631 fn eq(&self, other: &OnionPacket) -> bool {
1632 for (i, j) in self.hop_data.iter().zip(other.hop_data.iter()) {
1633 if i != j { return false; }
1635 self.version == other.version &&
1636 self.public_key == other.public_key &&
1637 self.hmac == other.hmac
1641 impl fmt::Debug for OnionPacket {
1642 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1643 f.write_fmt(format_args!("OnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
1647 #[derive(Clone, Debug, PartialEq, Eq)]
1648 pub(crate) struct OnionErrorPacket {
1649 // This really should be a constant size slice, but the spec lets these things be up to 128KB?
1650 // (TODO) We limit it in decode to much lower...
1651 pub(crate) data: Vec<u8>,
1654 impl fmt::Display for DecodeError {
1655 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1657 DecodeError::UnknownVersion => f.write_str("Unknown realm byte in Onion packet"),
1658 DecodeError::UnknownRequiredFeature => f.write_str("Unknown required feature preventing decode"),
1659 DecodeError::InvalidValue => f.write_str("Nonsense bytes didn't map to the type they were interpreted as"),
1660 DecodeError::ShortRead => f.write_str("Packet extended beyond the provided bytes"),
1661 DecodeError::BadLengthDescriptor => f.write_str("A length descriptor in the packet didn't describe the later data correctly"),
1662 DecodeError::Io(ref e) => fmt::Debug::fmt(e, f),
1663 DecodeError::UnsupportedCompression => f.write_str("We don't support receiving messages with zlib-compressed fields"),
1668 impl From<io::Error> for DecodeError {
1669 fn from(e: io::Error) -> Self {
1670 if e.kind() == io::ErrorKind::UnexpectedEof {
1671 DecodeError::ShortRead
1673 DecodeError::Io(e.kind())
1678 #[cfg(not(taproot))]
1679 impl_writeable_msg!(AcceptChannel, {
1680 temporary_channel_id,
1681 dust_limit_satoshis,
1682 max_htlc_value_in_flight_msat,
1683 channel_reserve_satoshis,
1689 revocation_basepoint,
1691 delayed_payment_basepoint,
1693 first_per_commitment_point,
1695 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1696 (1, channel_type, option),
1700 impl_writeable_msg!(AcceptChannel, {
1701 temporary_channel_id,
1702 dust_limit_satoshis,
1703 max_htlc_value_in_flight_msat,
1704 channel_reserve_satoshis,
1710 revocation_basepoint,
1712 delayed_payment_basepoint,
1714 first_per_commitment_point,
1716 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1717 (1, channel_type, option),
1718 (4, next_local_nonce, option),
1721 impl_writeable_msg!(AcceptChannelV2, {
1722 temporary_channel_id,
1724 dust_limit_satoshis,
1725 max_htlc_value_in_flight_msat,
1731 revocation_basepoint,
1733 delayed_payment_basepoint,
1735 first_per_commitment_point,
1736 second_per_commitment_point,
1738 (0, shutdown_scriptpubkey, option),
1739 (1, channel_type, option),
1740 (2, require_confirmed_inputs, option),
1743 impl_writeable_msg!(TxAddInput, {
1751 impl_writeable_msg!(TxAddOutput, {
1758 impl_writeable_msg!(TxRemoveInput, {
1763 impl_writeable_msg!(TxRemoveOutput, {
1768 impl_writeable_msg!(TxComplete, {
1772 impl_writeable_msg!(TxSignatures, {
1778 impl_writeable_msg!(TxInitRbf, {
1781 feerate_sat_per_1000_weight,
1783 (0, funding_output_contribution, option),
1786 impl_writeable_msg!(TxAckRbf, {
1789 (0, funding_output_contribution, option),
1792 impl_writeable_msg!(TxAbort, {
1797 impl_writeable_msg!(AnnouncementSignatures, {
1804 impl_writeable_msg!(ChannelReestablish, {
1806 next_local_commitment_number,
1807 next_remote_commitment_number,
1808 your_last_per_commitment_secret,
1809 my_current_per_commitment_point,
1811 (0, next_funding_txid, option),
1814 impl_writeable_msg!(ClosingSigned,
1815 { channel_id, fee_satoshis, signature },
1816 { (1, fee_range, option) }
1819 impl_writeable!(ClosingSignedFeeRange, {
1824 #[cfg(not(taproot))]
1825 impl_writeable_msg!(CommitmentSigned, {
1832 impl_writeable_msg!(CommitmentSigned, {
1837 (2, partial_signature_with_nonce, option)
1840 impl_writeable!(DecodedOnionErrorPacket, {
1846 #[cfg(not(taproot))]
1847 impl_writeable_msg!(FundingCreated, {
1848 temporary_channel_id,
1850 funding_output_index,
1854 impl_writeable_msg!(FundingCreated, {
1855 temporary_channel_id,
1857 funding_output_index,
1860 (2, partial_signature_with_nonce, option),
1861 (4, next_local_nonce, option)
1864 #[cfg(not(taproot))]
1865 impl_writeable_msg!(FundingSigned, {
1871 impl_writeable_msg!(FundingSigned, {
1875 (2, partial_signature_with_nonce, option)
1878 impl_writeable_msg!(ChannelReady, {
1880 next_per_commitment_point,
1882 (1, short_channel_id_alias, option),
1885 impl Writeable for Init {
1886 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1887 // global_features gets the bottom 13 bits of our features, and local_features gets all of
1888 // our relevant feature bits. This keeps us compatible with old nodes.
1889 self.features.write_up_to_13(w)?;
1890 self.features.write(w)?;
1891 encode_tlv_stream!(w, {
1892 (1, self.networks.as_ref().map(|n| WithoutLength(n)), option),
1893 (3, self.remote_network_address, option),
1899 impl Readable for Init {
1900 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1901 let global_features: InitFeatures = Readable::read(r)?;
1902 let features: InitFeatures = Readable::read(r)?;
1903 let mut remote_network_address: Option<SocketAddress> = None;
1904 let mut networks: Option<WithoutLength<Vec<ChainHash>>> = None;
1905 decode_tlv_stream!(r, {
1906 (1, networks, option),
1907 (3, remote_network_address, option)
1910 features: features | global_features,
1911 networks: networks.map(|n| n.0),
1912 remote_network_address,
1917 impl_writeable_msg!(OpenChannel, {
1919 temporary_channel_id,
1922 dust_limit_satoshis,
1923 max_htlc_value_in_flight_msat,
1924 channel_reserve_satoshis,
1930 revocation_basepoint,
1932 delayed_payment_basepoint,
1934 first_per_commitment_point,
1937 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1938 (1, channel_type, option),
1941 impl_writeable_msg!(OpenChannelV2, {
1943 temporary_channel_id,
1944 funding_feerate_sat_per_1000_weight,
1945 commitment_feerate_sat_per_1000_weight,
1947 dust_limit_satoshis,
1948 max_htlc_value_in_flight_msat,
1954 revocation_basepoint,
1956 delayed_payment_basepoint,
1958 first_per_commitment_point,
1959 second_per_commitment_point,
1962 (0, shutdown_scriptpubkey, option),
1963 (1, channel_type, option),
1964 (2, require_confirmed_inputs, option),
1967 #[cfg(not(taproot))]
1968 impl_writeable_msg!(RevokeAndACK, {
1970 per_commitment_secret,
1971 next_per_commitment_point
1975 impl_writeable_msg!(RevokeAndACK, {
1977 per_commitment_secret,
1978 next_per_commitment_point
1980 (4, next_local_nonce, option)
1983 impl_writeable_msg!(Shutdown, {
1988 impl_writeable_msg!(UpdateFailHTLC, {
1994 impl_writeable_msg!(UpdateFailMalformedHTLC, {
2001 impl_writeable_msg!(UpdateFee, {
2006 impl_writeable_msg!(UpdateFulfillHTLC, {
2012 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2013 // serialization format in a way which assumes we know the total serialized length/message end
2015 impl_writeable!(OnionErrorPacket, {
2019 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2020 // serialization format in a way which assumes we know the total serialized length/message end
2022 impl Writeable for OnionPacket {
2023 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2024 self.version.write(w)?;
2025 match self.public_key {
2026 Ok(pubkey) => pubkey.write(w)?,
2027 Err(_) => [0u8;33].write(w)?,
2029 w.write_all(&self.hop_data)?;
2030 self.hmac.write(w)?;
2035 impl Readable for OnionPacket {
2036 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2038 version: Readable::read(r)?,
2040 let mut buf = [0u8;33];
2041 r.read_exact(&mut buf)?;
2042 PublicKey::from_slice(&buf)
2044 hop_data: Readable::read(r)?,
2045 hmac: Readable::read(r)?,
2050 impl_writeable_msg!(UpdateAddHTLC, {
2056 onion_routing_packet,
2058 (65537, skimmed_fee_msat, option)
2061 impl Readable for OnionMessage {
2062 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2063 let blinding_point: PublicKey = Readable::read(r)?;
2064 let len: u16 = Readable::read(r)?;
2065 let mut packet_reader = FixedLengthReader::new(r, len as u64);
2066 let onion_routing_packet: onion_message::Packet = <onion_message::Packet as LengthReadable>::read(&mut packet_reader)?;
2069 onion_routing_packet,
2074 impl Writeable for OnionMessage {
2075 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2076 self.blinding_point.write(w)?;
2077 let onion_packet_len = self.onion_routing_packet.serialized_length();
2078 (onion_packet_len as u16).write(w)?;
2079 self.onion_routing_packet.write(w)?;
2084 impl Writeable for FinalOnionHopData {
2085 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2086 self.payment_secret.0.write(w)?;
2087 HighZeroBytesDroppedBigSize(self.total_msat).write(w)
2091 impl Readable for FinalOnionHopData {
2092 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2093 let secret: [u8; 32] = Readable::read(r)?;
2094 let amt: HighZeroBytesDroppedBigSize<u64> = Readable::read(r)?;
2095 Ok(Self { payment_secret: PaymentSecret(secret), total_msat: amt.0 })
2099 impl Writeable for OutboundOnionPayload {
2100 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2102 Self::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } => {
2103 _encode_varint_length_prefixed_tlv!(w, {
2104 (2, HighZeroBytesDroppedBigSize(*amt_to_forward), required),
2105 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2106 (6, short_channel_id, required)
2110 ref payment_data, ref payment_metadata, ref keysend_preimage, amt_msat,
2111 outgoing_cltv_value, ref custom_tlvs,
2113 // We need to update [`ln::outbound_payment::RecipientOnionFields::with_custom_tlvs`]
2114 // to reject any reserved types in the experimental range if new ones are ever
2116 let keysend_tlv = keysend_preimage.map(|preimage| (5482373484, preimage.encode()));
2117 let mut custom_tlvs: Vec<&(u64, Vec<u8>)> = custom_tlvs.iter().chain(keysend_tlv.iter()).collect();
2118 custom_tlvs.sort_unstable_by_key(|(typ, _)| *typ);
2119 _encode_varint_length_prefixed_tlv!(w, {
2120 (2, HighZeroBytesDroppedBigSize(*amt_msat), required),
2121 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2122 (8, payment_data, option),
2123 (16, payment_metadata.as_ref().map(|m| WithoutLength(m)), option)
2124 }, custom_tlvs.iter());
2126 Self::BlindedForward { encrypted_tlvs, intro_node_blinding_point } => {
2127 _encode_varint_length_prefixed_tlv!(w, {
2128 (10, *encrypted_tlvs, required_vec),
2129 (12, intro_node_blinding_point, option)
2132 Self::BlindedReceive {
2133 amt_msat, total_msat, outgoing_cltv_value, encrypted_tlvs,
2134 intro_node_blinding_point,
2136 _encode_varint_length_prefixed_tlv!(w, {
2137 (2, HighZeroBytesDroppedBigSize(*amt_msat), required),
2138 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2139 (10, *encrypted_tlvs, required_vec),
2140 (12, intro_node_blinding_point, option),
2141 (18, HighZeroBytesDroppedBigSize(*total_msat), required)
2149 impl<NS: Deref> ReadableArgs<&NS> for InboundOnionPayload where NS::Target: NodeSigner {
2150 fn read<R: Read>(r: &mut R, node_signer: &NS) -> Result<Self, DecodeError> {
2152 let mut cltv_value = None;
2153 let mut short_id: Option<u64> = None;
2154 let mut payment_data: Option<FinalOnionHopData> = None;
2155 let mut encrypted_tlvs_opt: Option<WithoutLength<Vec<u8>>> = None;
2156 let mut intro_node_blinding_point = None;
2157 let mut payment_metadata: Option<WithoutLength<Vec<u8>>> = None;
2158 let mut total_msat = None;
2159 let mut keysend_preimage: Option<PaymentPreimage> = None;
2160 let mut custom_tlvs = Vec::new();
2162 let tlv_len = BigSize::read(r)?;
2163 let rd = FixedLengthReader::new(r, tlv_len.0);
2164 decode_tlv_stream_with_custom_tlv_decode!(rd, {
2165 (2, amt, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2166 (4, cltv_value, (option, encoding: (u32, HighZeroBytesDroppedBigSize))),
2167 (6, short_id, option),
2168 (8, payment_data, option),
2169 (10, encrypted_tlvs_opt, option),
2170 (12, intro_node_blinding_point, option),
2171 (16, payment_metadata, option),
2172 (18, total_msat, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2173 // See https://github.com/lightning/blips/blob/master/blip-0003.md
2174 (5482373484, keysend_preimage, option)
2175 }, |msg_type: u64, msg_reader: &mut FixedLengthReader<_>| -> Result<bool, DecodeError> {
2176 if msg_type < 1 << 16 { return Ok(false) }
2177 let mut value = Vec::new();
2178 msg_reader.read_to_end(&mut value)?;
2179 custom_tlvs.push((msg_type, value));
2183 if amt.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2185 if let Some(blinding_point) = intro_node_blinding_point {
2186 if short_id.is_some() || payment_data.is_some() || payment_metadata.is_some() {
2187 return Err(DecodeError::InvalidValue)
2189 let enc_tlvs = encrypted_tlvs_opt.ok_or(DecodeError::InvalidValue)?.0;
2190 let enc_tlvs_ss = node_signer.ecdh(Recipient::Node, &blinding_point, None)
2191 .map_err(|_| DecodeError::InvalidValue)?;
2192 let rho = onion_utils::gen_rho_from_shared_secret(&enc_tlvs_ss.secret_bytes());
2193 let mut s = Cursor::new(&enc_tlvs);
2194 let mut reader = FixedLengthReader::new(&mut s, enc_tlvs.len() as u64);
2195 match ChaChaPolyReadAdapter::read(&mut reader, rho)? {
2196 ChaChaPolyReadAdapter { readable: ReceiveTlvs { payment_secret, payment_constraints }} => {
2197 if total_msat.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2198 Ok(Self::BlindedReceive {
2199 amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2200 total_msat: total_msat.ok_or(DecodeError::InvalidValue)?,
2201 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2203 payment_constraints,
2204 intro_node_blinding_point: blinding_point,
2208 } else if let Some(short_channel_id) = short_id {
2209 if payment_data.is_some() || payment_metadata.is_some() || encrypted_tlvs_opt.is_some() ||
2210 total_msat.is_some()
2211 { return Err(DecodeError::InvalidValue) }
2214 amt_to_forward: amt.ok_or(DecodeError::InvalidValue)?,
2215 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2218 if encrypted_tlvs_opt.is_some() || total_msat.is_some() {
2219 return Err(DecodeError::InvalidValue)
2221 if let Some(data) = &payment_data {
2222 if data.total_msat > MAX_VALUE_MSAT {
2223 return Err(DecodeError::InvalidValue);
2228 payment_metadata: payment_metadata.map(|w| w.0),
2230 amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2231 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2238 impl Writeable for Ping {
2239 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2240 self.ponglen.write(w)?;
2241 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2246 impl Readable for Ping {
2247 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2249 ponglen: Readable::read(r)?,
2251 let byteslen = Readable::read(r)?;
2252 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2259 impl Writeable for Pong {
2260 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2261 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2266 impl Readable for Pong {
2267 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2270 let byteslen = Readable::read(r)?;
2271 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2278 impl Writeable for UnsignedChannelAnnouncement {
2279 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2280 self.features.write(w)?;
2281 self.chain_hash.write(w)?;
2282 self.short_channel_id.write(w)?;
2283 self.node_id_1.write(w)?;
2284 self.node_id_2.write(w)?;
2285 self.bitcoin_key_1.write(w)?;
2286 self.bitcoin_key_2.write(w)?;
2287 w.write_all(&self.excess_data[..])?;
2292 impl Readable for UnsignedChannelAnnouncement {
2293 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2295 features: Readable::read(r)?,
2296 chain_hash: Readable::read(r)?,
2297 short_channel_id: Readable::read(r)?,
2298 node_id_1: Readable::read(r)?,
2299 node_id_2: Readable::read(r)?,
2300 bitcoin_key_1: Readable::read(r)?,
2301 bitcoin_key_2: Readable::read(r)?,
2302 excess_data: read_to_end(r)?,
2307 impl_writeable!(ChannelAnnouncement, {
2310 bitcoin_signature_1,
2311 bitcoin_signature_2,
2315 impl Writeable for UnsignedChannelUpdate {
2316 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2317 // `message_flags` used to indicate presence of `htlc_maximum_msat`, but was deprecated in the spec.
2318 const MESSAGE_FLAGS: u8 = 1;
2319 self.chain_hash.write(w)?;
2320 self.short_channel_id.write(w)?;
2321 self.timestamp.write(w)?;
2322 let all_flags = self.flags as u16 | ((MESSAGE_FLAGS as u16) << 8);
2323 all_flags.write(w)?;
2324 self.cltv_expiry_delta.write(w)?;
2325 self.htlc_minimum_msat.write(w)?;
2326 self.fee_base_msat.write(w)?;
2327 self.fee_proportional_millionths.write(w)?;
2328 self.htlc_maximum_msat.write(w)?;
2329 w.write_all(&self.excess_data[..])?;
2334 impl Readable for UnsignedChannelUpdate {
2335 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2337 chain_hash: Readable::read(r)?,
2338 short_channel_id: Readable::read(r)?,
2339 timestamp: Readable::read(r)?,
2341 let flags: u16 = Readable::read(r)?;
2342 // Note: we ignore the `message_flags` for now, since it was deprecated by the spec.
2345 cltv_expiry_delta: Readable::read(r)?,
2346 htlc_minimum_msat: Readable::read(r)?,
2347 fee_base_msat: Readable::read(r)?,
2348 fee_proportional_millionths: Readable::read(r)?,
2349 htlc_maximum_msat: Readable::read(r)?,
2350 excess_data: read_to_end(r)?,
2355 impl_writeable!(ChannelUpdate, {
2360 impl Writeable for ErrorMessage {
2361 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2362 self.channel_id.write(w)?;
2363 (self.data.len() as u16).write(w)?;
2364 w.write_all(self.data.as_bytes())?;
2369 impl Readable for ErrorMessage {
2370 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2372 channel_id: Readable::read(r)?,
2374 let sz: usize = <u16 as Readable>::read(r)? as usize;
2375 let mut data = Vec::with_capacity(sz);
2377 r.read_exact(&mut data)?;
2378 match String::from_utf8(data) {
2380 Err(_) => return Err(DecodeError::InvalidValue),
2387 impl Writeable for WarningMessage {
2388 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2389 self.channel_id.write(w)?;
2390 (self.data.len() as u16).write(w)?;
2391 w.write_all(self.data.as_bytes())?;
2396 impl Readable for WarningMessage {
2397 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2399 channel_id: Readable::read(r)?,
2401 let sz: usize = <u16 as Readable>::read(r)? as usize;
2402 let mut data = Vec::with_capacity(sz);
2404 r.read_exact(&mut data)?;
2405 match String::from_utf8(data) {
2407 Err(_) => return Err(DecodeError::InvalidValue),
2414 impl Writeable for UnsignedNodeAnnouncement {
2415 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2416 self.features.write(w)?;
2417 self.timestamp.write(w)?;
2418 self.node_id.write(w)?;
2419 w.write_all(&self.rgb)?;
2420 self.alias.write(w)?;
2422 let mut addr_len = 0;
2423 for addr in self.addresses.iter() {
2424 addr_len += 1 + addr.len();
2426 (addr_len + self.excess_address_data.len() as u16).write(w)?;
2427 for addr in self.addresses.iter() {
2430 w.write_all(&self.excess_address_data[..])?;
2431 w.write_all(&self.excess_data[..])?;
2436 impl Readable for UnsignedNodeAnnouncement {
2437 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2438 let features: NodeFeatures = Readable::read(r)?;
2439 let timestamp: u32 = Readable::read(r)?;
2440 let node_id: NodeId = Readable::read(r)?;
2441 let mut rgb = [0; 3];
2442 r.read_exact(&mut rgb)?;
2443 let alias: NodeAlias = Readable::read(r)?;
2445 let addr_len: u16 = Readable::read(r)?;
2446 let mut addresses: Vec<SocketAddress> = Vec::new();
2447 let mut addr_readpos = 0;
2448 let mut excess = false;
2449 let mut excess_byte = 0;
2451 if addr_len <= addr_readpos { break; }
2452 match Readable::read(r) {
2454 if addr_len < addr_readpos + 1 + addr.len() {
2455 return Err(DecodeError::BadLengthDescriptor);
2457 addr_readpos += (1 + addr.len()) as u16;
2458 addresses.push(addr);
2460 Ok(Err(unknown_descriptor)) => {
2462 excess_byte = unknown_descriptor;
2465 Err(DecodeError::ShortRead) => return Err(DecodeError::BadLengthDescriptor),
2466 Err(e) => return Err(e),
2470 let mut excess_data = vec![];
2471 let excess_address_data = if addr_readpos < addr_len {
2472 let mut excess_address_data = vec![0; (addr_len - addr_readpos) as usize];
2473 r.read_exact(&mut excess_address_data[if excess { 1 } else { 0 }..])?;
2475 excess_address_data[0] = excess_byte;
2480 excess_data.push(excess_byte);
2484 excess_data.extend(read_to_end(r)?.iter());
2485 Ok(UnsignedNodeAnnouncement {
2492 excess_address_data,
2498 impl_writeable!(NodeAnnouncement, {
2503 impl Readable for QueryShortChannelIds {
2504 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2505 let chain_hash: BlockHash = Readable::read(r)?;
2507 let encoding_len: u16 = Readable::read(r)?;
2508 let encoding_type: u8 = Readable::read(r)?;
2510 // Must be encoding_type=0 uncompressed serialization. We do not
2511 // support encoding_type=1 zlib serialization.
2512 if encoding_type != EncodingType::Uncompressed as u8 {
2513 return Err(DecodeError::UnsupportedCompression);
2516 // We expect the encoding_len to always includes the 1-byte
2517 // encoding_type and that short_channel_ids are 8-bytes each
2518 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2519 return Err(DecodeError::InvalidValue);
2522 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2523 // less the 1-byte encoding_type
2524 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2525 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2526 for _ in 0..short_channel_id_count {
2527 short_channel_ids.push(Readable::read(r)?);
2530 Ok(QueryShortChannelIds {
2537 impl Writeable for QueryShortChannelIds {
2538 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2539 // Calculated from 1-byte encoding_type plus 8-bytes per short_channel_id
2540 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2542 self.chain_hash.write(w)?;
2543 encoding_len.write(w)?;
2545 // We only support type=0 uncompressed serialization
2546 (EncodingType::Uncompressed as u8).write(w)?;
2548 for scid in self.short_channel_ids.iter() {
2556 impl_writeable_msg!(ReplyShortChannelIdsEnd, {
2561 impl QueryChannelRange {
2562 /// Calculates the overflow safe ending block height for the query.
2564 /// Overflow returns `0xffffffff`, otherwise returns `first_blocknum + number_of_blocks`.
2565 pub fn end_blocknum(&self) -> u32 {
2566 match self.first_blocknum.checked_add(self.number_of_blocks) {
2567 Some(block) => block,
2568 None => u32::max_value(),
2573 impl_writeable_msg!(QueryChannelRange, {
2579 impl Readable for ReplyChannelRange {
2580 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2581 let chain_hash: BlockHash = Readable::read(r)?;
2582 let first_blocknum: u32 = Readable::read(r)?;
2583 let number_of_blocks: u32 = Readable::read(r)?;
2584 let sync_complete: bool = Readable::read(r)?;
2586 let encoding_len: u16 = Readable::read(r)?;
2587 let encoding_type: u8 = Readable::read(r)?;
2589 // Must be encoding_type=0 uncompressed serialization. We do not
2590 // support encoding_type=1 zlib serialization.
2591 if encoding_type != EncodingType::Uncompressed as u8 {
2592 return Err(DecodeError::UnsupportedCompression);
2595 // We expect the encoding_len to always includes the 1-byte
2596 // encoding_type and that short_channel_ids are 8-bytes each
2597 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2598 return Err(DecodeError::InvalidValue);
2601 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2602 // less the 1-byte encoding_type
2603 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2604 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2605 for _ in 0..short_channel_id_count {
2606 short_channel_ids.push(Readable::read(r)?);
2609 Ok(ReplyChannelRange {
2619 impl Writeable for ReplyChannelRange {
2620 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2621 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2622 self.chain_hash.write(w)?;
2623 self.first_blocknum.write(w)?;
2624 self.number_of_blocks.write(w)?;
2625 self.sync_complete.write(w)?;
2627 encoding_len.write(w)?;
2628 (EncodingType::Uncompressed as u8).write(w)?;
2629 for scid in self.short_channel_ids.iter() {
2637 impl_writeable_msg!(GossipTimestampFilter, {
2645 use std::convert::TryFrom;
2646 use bitcoin::blockdata::constants::ChainHash;
2647 use bitcoin::{Transaction, PackedLockTime, TxIn, Script, Sequence, Witness, TxOut};
2649 use crate::ln::{PaymentPreimage, PaymentHash, PaymentSecret};
2650 use crate::ln::ChannelId;
2651 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
2652 use crate::ln::msgs::{self, FinalOnionHopData, OnionErrorPacket};
2653 use crate::ln::msgs::SocketAddress;
2654 use crate::routing::gossip::{NodeAlias, NodeId};
2655 use crate::util::ser::{Writeable, Readable, ReadableArgs, Hostname, TransactionU16LenLimited};
2656 use crate::util::test_utils;
2658 use bitcoin::hashes::hex::FromHex;
2659 use bitcoin::util::address::Address;
2660 use bitcoin::network::constants::Network;
2661 use bitcoin::blockdata::script::Builder;
2662 use bitcoin::blockdata::opcodes;
2663 use bitcoin::hash_types::{Txid, BlockHash};
2665 use bitcoin::secp256k1::{PublicKey,SecretKey};
2666 use bitcoin::secp256k1::{Secp256k1, Message};
2668 use crate::io::{self, Cursor};
2669 use crate::prelude::*;
2670 use core::str::FromStr;
2671 use crate::chain::transaction::OutPoint;
2673 #[cfg(feature = "std")]
2674 use std::net::{Ipv4Addr, Ipv6Addr};
2675 use crate::ln::msgs::SocketAddressParseError;
2678 fn encoding_channel_reestablish() {
2680 let secp_ctx = Secp256k1::new();
2681 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2684 let cr = msgs::ChannelReestablish {
2685 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]),
2686 next_local_commitment_number: 3,
2687 next_remote_commitment_number: 4,
2688 your_last_per_commitment_secret: [9;32],
2689 my_current_per_commitment_point: public_key,
2690 next_funding_txid: None,
2693 let encoded_value = cr.encode();
2697 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
2698 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2699 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2700 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
2701 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
2707 fn encoding_channel_reestablish_with_next_funding_txid() {
2709 let secp_ctx = Secp256k1::new();
2710 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2713 let cr = msgs::ChannelReestablish {
2714 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]),
2715 next_local_commitment_number: 3,
2716 next_remote_commitment_number: 4,
2717 your_last_per_commitment_secret: [9;32],
2718 my_current_per_commitment_point: public_key,
2719 next_funding_txid: Some(Txid::from_hash(bitcoin::hashes::Hash::from_slice(&[
2720 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,
2724 let encoded_value = cr.encode();
2728 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
2729 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2730 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2731 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
2732 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
2733 0, // Type (next_funding_txid)
2735 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
2740 macro_rules! get_keys_from {
2741 ($slice: expr, $secp_ctx: expr) => {
2743 let privkey = SecretKey::from_slice(&hex::decode($slice).unwrap()[..]).unwrap();
2744 let pubkey = PublicKey::from_secret_key(&$secp_ctx, &privkey);
2750 macro_rules! get_sig_on {
2751 ($privkey: expr, $ctx: expr, $string: expr) => {
2753 let sighash = Message::from_slice(&$string.into_bytes()[..]).unwrap();
2754 $ctx.sign_ecdsa(&sighash, &$privkey)
2760 fn encoding_announcement_signatures() {
2761 let secp_ctx = Secp256k1::new();
2762 let (privkey, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2763 let sig_1 = get_sig_on!(privkey, secp_ctx, String::from("01010101010101010101010101010101"));
2764 let sig_2 = get_sig_on!(privkey, secp_ctx, String::from("02020202020202020202020202020202"));
2765 let announcement_signatures = msgs::AnnouncementSignatures {
2766 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]),
2767 short_channel_id: 2316138423780173,
2768 node_signature: sig_1,
2769 bitcoin_signature: sig_2,
2772 let encoded_value = announcement_signatures.encode();
2773 assert_eq!(encoded_value, hex::decode("040000000000000005000000000000000600000000000000070000000000000000083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073acf9953cef4700860f5967838eba2bae89288ad188ebf8b20bf995c3ea53a26df1876d0a3a0e13172ba286a673140190c02ba9da60a2e43a745188c8a83c7f3ef").unwrap());
2776 fn do_encoding_channel_announcement(unknown_features_bits: bool, excess_data: bool) {
2777 let secp_ctx = Secp256k1::new();
2778 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2779 let (privkey_2, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2780 let (privkey_3, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2781 let (privkey_4, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2782 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2783 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
2784 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
2785 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
2786 let mut features = ChannelFeatures::empty();
2787 if unknown_features_bits {
2788 features = ChannelFeatures::from_le_bytes(vec![0xFF, 0xFF]);
2790 let unsigned_channel_announcement = msgs::UnsignedChannelAnnouncement {
2792 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2793 short_channel_id: 2316138423780173,
2794 node_id_1: NodeId::from_pubkey(&pubkey_1),
2795 node_id_2: NodeId::from_pubkey(&pubkey_2),
2796 bitcoin_key_1: NodeId::from_pubkey(&pubkey_3),
2797 bitcoin_key_2: NodeId::from_pubkey(&pubkey_4),
2798 excess_data: if excess_data { vec![10, 0, 0, 20, 0, 0, 30, 0, 0, 40] } else { Vec::new() },
2800 let channel_announcement = msgs::ChannelAnnouncement {
2801 node_signature_1: sig_1,
2802 node_signature_2: sig_2,
2803 bitcoin_signature_1: sig_3,
2804 bitcoin_signature_2: sig_4,
2805 contents: unsigned_channel_announcement,
2807 let encoded_value = channel_announcement.encode();
2808 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a1735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap();
2809 if unknown_features_bits {
2810 target_value.append(&mut hex::decode("0002ffff").unwrap());
2812 target_value.append(&mut hex::decode("0000").unwrap());
2814 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2815 target_value.append(&mut hex::decode("00083a840000034d031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
2817 target_value.append(&mut hex::decode("0a00001400001e000028").unwrap());
2819 assert_eq!(encoded_value, target_value);
2823 fn encoding_channel_announcement() {
2824 do_encoding_channel_announcement(true, false);
2825 do_encoding_channel_announcement(false, true);
2826 do_encoding_channel_announcement(false, false);
2827 do_encoding_channel_announcement(true, true);
2830 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) {
2831 let secp_ctx = Secp256k1::new();
2832 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2833 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2834 let features = if unknown_features_bits {
2835 NodeFeatures::from_le_bytes(vec![0xFF, 0xFF])
2837 // Set to some features we may support
2838 NodeFeatures::from_le_bytes(vec![2 | 1 << 5])
2840 let mut addresses = Vec::new();
2842 addresses.push(SocketAddress::TcpIpV4 {
2843 addr: [255, 254, 253, 252],
2848 addresses.push(SocketAddress::TcpIpV6 {
2849 addr: [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240],
2854 addresses.push(msgs::SocketAddress::OnionV2(
2855 [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 38, 7]
2859 addresses.push(msgs::SocketAddress::OnionV3 {
2860 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],
2867 addresses.push(SocketAddress::Hostname {
2868 hostname: Hostname::try_from(String::from("host")).unwrap(),
2872 let mut addr_len = 0;
2873 for addr in &addresses {
2874 addr_len += addr.len() + 1;
2876 let unsigned_node_announcement = msgs::UnsignedNodeAnnouncement {
2878 timestamp: 20190119,
2879 node_id: NodeId::from_pubkey(&pubkey_1),
2881 alias: NodeAlias([16;32]),
2883 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() },
2884 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() },
2886 addr_len += unsigned_node_announcement.excess_address_data.len() as u16;
2887 let node_announcement = msgs::NodeAnnouncement {
2889 contents: unsigned_node_announcement,
2891 let encoded_value = node_announcement.encode();
2892 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
2893 if unknown_features_bits {
2894 target_value.append(&mut hex::decode("0002ffff").unwrap());
2896 target_value.append(&mut hex::decode("000122").unwrap());
2898 target_value.append(&mut hex::decode("013413a7031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f2020201010101010101010101010101010101010101010101010101010101010101010").unwrap());
2899 target_value.append(&mut vec![(addr_len >> 8) as u8, addr_len as u8]);
2901 target_value.append(&mut hex::decode("01fffefdfc2607").unwrap());
2904 target_value.append(&mut hex::decode("02fffefdfcfbfaf9f8f7f6f5f4f3f2f1f02607").unwrap());
2907 target_value.append(&mut hex::decode("03fffefdfcfbfaf9f8f7f62607").unwrap());
2910 target_value.append(&mut hex::decode("04fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0efeeedecebeae9e8e7e6e5e4e3e2e1e00020102607").unwrap());
2913 target_value.append(&mut hex::decode("0504686f73742607").unwrap());
2915 if excess_address_data {
2916 target_value.append(&mut hex::decode("216c280b5395a2546e7e4b2663e04f811622f15a4f92e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d269").unwrap());
2919 target_value.append(&mut hex::decode("3b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
2921 assert_eq!(encoded_value, target_value);
2925 fn encoding_node_announcement() {
2926 do_encoding_node_announcement(true, true, true, true, true, true, true, true);
2927 do_encoding_node_announcement(false, false, false, false, false, false, false, false);
2928 do_encoding_node_announcement(false, true, false, false, false, false, false, false);
2929 do_encoding_node_announcement(false, false, true, false, false, false, false, false);
2930 do_encoding_node_announcement(false, false, false, true, false, false, false, false);
2931 do_encoding_node_announcement(false, false, false, false, true, false, false, false);
2932 do_encoding_node_announcement(false, false, false, false, false, true, false, false);
2933 do_encoding_node_announcement(false, false, false, false, false, false, true, false);
2934 do_encoding_node_announcement(false, true, false, true, false, false, true, false);
2935 do_encoding_node_announcement(false, false, true, false, true, false, false, false);
2938 fn do_encoding_channel_update(direction: bool, disable: bool, excess_data: bool) {
2939 let secp_ctx = Secp256k1::new();
2940 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2941 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2942 let unsigned_channel_update = msgs::UnsignedChannelUpdate {
2943 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2944 short_channel_id: 2316138423780173,
2945 timestamp: 20190119,
2946 flags: if direction { 1 } else { 0 } | if disable { 1 << 1 } else { 0 },
2947 cltv_expiry_delta: 144,
2948 htlc_minimum_msat: 1000000,
2949 htlc_maximum_msat: 131355275467161,
2950 fee_base_msat: 10000,
2951 fee_proportional_millionths: 20,
2952 excess_data: if excess_data { vec![0, 0, 0, 0, 59, 154, 202, 0] } else { Vec::new() }
2954 let channel_update = msgs::ChannelUpdate {
2956 contents: unsigned_channel_update
2958 let encoded_value = channel_update.encode();
2959 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
2960 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2961 target_value.append(&mut hex::decode("00083a840000034d013413a7").unwrap());
2962 target_value.append(&mut hex::decode("01").unwrap());
2963 target_value.append(&mut hex::decode("00").unwrap());
2965 let flag = target_value.last_mut().unwrap();
2969 let flag = target_value.last_mut().unwrap();
2970 *flag = *flag | 1 << 1;
2972 target_value.append(&mut hex::decode("009000000000000f42400000271000000014").unwrap());
2973 target_value.append(&mut hex::decode("0000777788889999").unwrap());
2975 target_value.append(&mut hex::decode("000000003b9aca00").unwrap());
2977 assert_eq!(encoded_value, target_value);
2981 fn encoding_channel_update() {
2982 do_encoding_channel_update(false, false, false);
2983 do_encoding_channel_update(false, false, true);
2984 do_encoding_channel_update(true, false, false);
2985 do_encoding_channel_update(true, false, true);
2986 do_encoding_channel_update(false, true, false);
2987 do_encoding_channel_update(false, true, true);
2988 do_encoding_channel_update(true, true, false);
2989 do_encoding_channel_update(true, true, true);
2992 fn do_encoding_open_channel(random_bit: bool, shutdown: bool, incl_chan_type: bool) {
2993 let secp_ctx = Secp256k1::new();
2994 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2995 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2996 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2997 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2998 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
2999 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3000 let open_channel = msgs::OpenChannel {
3001 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
3002 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3003 funding_satoshis: 1311768467284833366,
3004 push_msat: 2536655962884945560,
3005 dust_limit_satoshis: 3608586615801332854,
3006 max_htlc_value_in_flight_msat: 8517154655701053848,
3007 channel_reserve_satoshis: 8665828695742877976,
3008 htlc_minimum_msat: 2316138423780173,
3009 feerate_per_kw: 821716,
3010 to_self_delay: 49340,
3011 max_accepted_htlcs: 49340,
3012 funding_pubkey: pubkey_1,
3013 revocation_basepoint: pubkey_2,
3014 payment_point: pubkey_3,
3015 delayed_payment_basepoint: pubkey_4,
3016 htlc_basepoint: pubkey_5,
3017 first_per_commitment_point: pubkey_6,
3018 channel_flags: if random_bit { 1 << 5 } else { 0 },
3019 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3020 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3022 let encoded_value = open_channel.encode();
3023 let mut target_value = Vec::new();
3024 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
3025 target_value.append(&mut hex::decode("02020202020202020202020202020202020202020202020202020202020202021234567890123456233403289122369832144668701144767633030896203198784335490624111800083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3027 target_value.append(&mut hex::decode("20").unwrap());
3029 target_value.append(&mut hex::decode("00").unwrap());
3032 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3035 target_value.append(&mut hex::decode("0100").unwrap());
3037 assert_eq!(encoded_value, target_value);
3041 fn encoding_open_channel() {
3042 do_encoding_open_channel(false, false, false);
3043 do_encoding_open_channel(false, false, true);
3044 do_encoding_open_channel(false, true, false);
3045 do_encoding_open_channel(false, true, true);
3046 do_encoding_open_channel(true, false, false);
3047 do_encoding_open_channel(true, false, true);
3048 do_encoding_open_channel(true, true, false);
3049 do_encoding_open_channel(true, true, true);
3052 fn do_encoding_open_channelv2(random_bit: bool, shutdown: bool, incl_chan_type: bool, require_confirmed_inputs: bool) {
3053 let secp_ctx = Secp256k1::new();
3054 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3055 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3056 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3057 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3058 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3059 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3060 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3061 let open_channelv2 = msgs::OpenChannelV2 {
3062 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
3063 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3064 funding_feerate_sat_per_1000_weight: 821716,
3065 commitment_feerate_sat_per_1000_weight: 821716,
3066 funding_satoshis: 1311768467284833366,
3067 dust_limit_satoshis: 3608586615801332854,
3068 max_htlc_value_in_flight_msat: 8517154655701053848,
3069 htlc_minimum_msat: 2316138423780173,
3070 to_self_delay: 49340,
3071 max_accepted_htlcs: 49340,
3072 locktime: 305419896,
3073 funding_pubkey: pubkey_1,
3074 revocation_basepoint: pubkey_2,
3075 payment_basepoint: pubkey_3,
3076 delayed_payment_basepoint: pubkey_4,
3077 htlc_basepoint: pubkey_5,
3078 first_per_commitment_point: pubkey_6,
3079 second_per_commitment_point: pubkey_7,
3080 channel_flags: if random_bit { 1 << 5 } else { 0 },
3081 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3082 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3083 require_confirmed_inputs: if require_confirmed_inputs { Some(()) } else { None },
3085 let encoded_value = open_channelv2.encode();
3086 let mut target_value = Vec::new();
3087 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
3088 target_value.append(&mut hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap());
3089 target_value.append(&mut hex::decode("000c89d4").unwrap());
3090 target_value.append(&mut hex::decode("000c89d4").unwrap());
3091 target_value.append(&mut hex::decode("1234567890123456").unwrap());
3092 target_value.append(&mut hex::decode("3214466870114476").unwrap());
3093 target_value.append(&mut hex::decode("7633030896203198").unwrap());
3094 target_value.append(&mut hex::decode("00083a840000034d").unwrap());
3095 target_value.append(&mut hex::decode("c0bc").unwrap());
3096 target_value.append(&mut hex::decode("c0bc").unwrap());
3097 target_value.append(&mut hex::decode("12345678").unwrap());
3098 target_value.append(&mut hex::decode("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap());
3099 target_value.append(&mut hex::decode("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap());
3100 target_value.append(&mut hex::decode("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap());
3101 target_value.append(&mut hex::decode("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
3102 target_value.append(&mut hex::decode("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap());
3103 target_value.append(&mut hex::decode("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3104 target_value.append(&mut hex::decode("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap());
3107 target_value.append(&mut hex::decode("20").unwrap());
3109 target_value.append(&mut hex::decode("00").unwrap());
3112 target_value.append(&mut hex::decode("001b").unwrap()); // Type 0 + Length 27
3113 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3116 target_value.append(&mut hex::decode("0100").unwrap());
3118 if require_confirmed_inputs {
3119 target_value.append(&mut hex::decode("0200").unwrap());
3121 assert_eq!(encoded_value, target_value);
3125 fn encoding_open_channelv2() {
3126 do_encoding_open_channelv2(false, false, false, false);
3127 do_encoding_open_channelv2(false, false, false, true);
3128 do_encoding_open_channelv2(false, false, true, false);
3129 do_encoding_open_channelv2(false, false, true, true);
3130 do_encoding_open_channelv2(false, true, false, false);
3131 do_encoding_open_channelv2(false, true, false, true);
3132 do_encoding_open_channelv2(false, true, true, false);
3133 do_encoding_open_channelv2(false, true, true, true);
3134 do_encoding_open_channelv2(true, false, false, false);
3135 do_encoding_open_channelv2(true, false, false, true);
3136 do_encoding_open_channelv2(true, false, true, false);
3137 do_encoding_open_channelv2(true, false, true, true);
3138 do_encoding_open_channelv2(true, true, false, false);
3139 do_encoding_open_channelv2(true, true, false, true);
3140 do_encoding_open_channelv2(true, true, true, false);
3141 do_encoding_open_channelv2(true, true, true, true);
3144 fn do_encoding_accept_channel(shutdown: bool) {
3145 let secp_ctx = Secp256k1::new();
3146 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3147 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3148 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3149 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3150 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3151 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3152 let accept_channel = msgs::AcceptChannel {
3153 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3154 dust_limit_satoshis: 1311768467284833366,
3155 max_htlc_value_in_flight_msat: 2536655962884945560,
3156 channel_reserve_satoshis: 3608586615801332854,
3157 htlc_minimum_msat: 2316138423780173,
3158 minimum_depth: 821716,
3159 to_self_delay: 49340,
3160 max_accepted_htlcs: 49340,
3161 funding_pubkey: pubkey_1,
3162 revocation_basepoint: pubkey_2,
3163 payment_point: pubkey_3,
3164 delayed_payment_basepoint: pubkey_4,
3165 htlc_basepoint: pubkey_5,
3166 first_per_commitment_point: pubkey_6,
3167 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3170 next_local_nonce: None,
3172 let encoded_value = accept_channel.encode();
3173 let mut target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020212345678901234562334032891223698321446687011447600083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap();
3175 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3177 assert_eq!(encoded_value, target_value);
3181 fn encoding_accept_channel() {
3182 do_encoding_accept_channel(false);
3183 do_encoding_accept_channel(true);
3186 fn do_encoding_accept_channelv2(shutdown: bool) {
3187 let secp_ctx = Secp256k1::new();
3188 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3189 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3190 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3191 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3192 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3193 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3194 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3195 let accept_channelv2 = msgs::AcceptChannelV2 {
3196 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3197 funding_satoshis: 1311768467284833366,
3198 dust_limit_satoshis: 1311768467284833366,
3199 max_htlc_value_in_flight_msat: 2536655962884945560,
3200 htlc_minimum_msat: 2316138423780173,
3201 minimum_depth: 821716,
3202 to_self_delay: 49340,
3203 max_accepted_htlcs: 49340,
3204 funding_pubkey: pubkey_1,
3205 revocation_basepoint: pubkey_2,
3206 payment_basepoint: pubkey_3,
3207 delayed_payment_basepoint: pubkey_4,
3208 htlc_basepoint: pubkey_5,
3209 first_per_commitment_point: pubkey_6,
3210 second_per_commitment_point: pubkey_7,
3211 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3213 require_confirmed_inputs: None,
3215 let encoded_value = accept_channelv2.encode();
3216 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // temporary_channel_id
3217 target_value.append(&mut hex::decode("1234567890123456").unwrap()); // funding_satoshis
3218 target_value.append(&mut hex::decode("1234567890123456").unwrap()); // dust_limit_satoshis
3219 target_value.append(&mut hex::decode("2334032891223698").unwrap()); // max_htlc_value_in_flight_msat
3220 target_value.append(&mut hex::decode("00083a840000034d").unwrap()); // htlc_minimum_msat
3221 target_value.append(&mut hex::decode("000c89d4").unwrap()); // minimum_depth
3222 target_value.append(&mut hex::decode("c0bc").unwrap()); // to_self_delay
3223 target_value.append(&mut hex::decode("c0bc").unwrap()); // max_accepted_htlcs
3224 target_value.append(&mut hex::decode("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap()); // funding_pubkey
3225 target_value.append(&mut hex::decode("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap()); // revocation_basepoint
3226 target_value.append(&mut hex::decode("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap()); // payment_basepoint
3227 target_value.append(&mut hex::decode("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap()); // delayed_payment_basepoint
3228 target_value.append(&mut hex::decode("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap()); // htlc_basepoint
3229 target_value.append(&mut hex::decode("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap()); // first_per_commitment_point
3230 target_value.append(&mut hex::decode("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap()); // second_per_commitment_point
3232 target_value.append(&mut hex::decode("001b").unwrap()); // Type 0 + Length 27
3233 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3235 assert_eq!(encoded_value, target_value);
3239 fn encoding_accept_channelv2() {
3240 do_encoding_accept_channelv2(false);
3241 do_encoding_accept_channelv2(true);
3245 fn encoding_funding_created() {
3246 let secp_ctx = Secp256k1::new();
3247 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3248 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3249 let funding_created = msgs::FundingCreated {
3250 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3251 funding_txid: Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3252 funding_output_index: 255,
3255 partial_signature_with_nonce: None,
3257 next_local_nonce: None,
3259 let encoded_value = funding_created.encode();
3260 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202026e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c200ffd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3261 assert_eq!(encoded_value, target_value);
3265 fn encoding_funding_signed() {
3266 let secp_ctx = Secp256k1::new();
3267 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3268 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3269 let funding_signed = msgs::FundingSigned {
3270 channel_id: ChannelId::from_bytes([2; 32]),
3273 partial_signature_with_nonce: None,
3275 let encoded_value = funding_signed.encode();
3276 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3277 assert_eq!(encoded_value, target_value);
3281 fn encoding_channel_ready() {
3282 let secp_ctx = Secp256k1::new();
3283 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3284 let channel_ready = msgs::ChannelReady {
3285 channel_id: ChannelId::from_bytes([2; 32]),
3286 next_per_commitment_point: pubkey_1,
3287 short_channel_id_alias: None,
3289 let encoded_value = channel_ready.encode();
3290 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3291 assert_eq!(encoded_value, target_value);
3295 fn encoding_tx_add_input() {
3296 let tx_add_input = msgs::TxAddInput {
3297 channel_id: ChannelId::from_bytes([2; 32]),
3298 serial_id: 4886718345,
3299 prevtx: TransactionU16LenLimited::new(Transaction {
3301 lock_time: PackedLockTime(0),
3303 previous_output: OutPoint { txid: Txid::from_hex("305bab643ee297b8b6b76b320792c8223d55082122cb606bf89382146ced9c77").unwrap(), index: 2 }.into_bitcoin_outpoint(),
3304 script_sig: Script::new(),
3305 sequence: Sequence(0xfffffffd),
3306 witness: Witness::from_vec(vec![
3307 hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3308 hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3313 script_pubkey: Address::from_str("bc1qzlffunw52jav8vwdu5x3jfk6sr8u22rmq3xzw2").unwrap().script_pubkey(),
3317 script_pubkey: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().script_pubkey(),
3321 prevtx_out: 305419896,
3322 sequence: 305419896,
3324 let encoded_value = tx_add_input.encode();
3325 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000000012345678900de02000000000101779ced6c148293f86b60cb222108553d22c89207326bb7b6b897e23e64ab5b300200000000fdffffff0236dbc1000000000016001417d29e4dd454bac3b1cde50d1926da80cfc5287b9cbd03000000000016001436ec78d514df462da95e6a00c24daa8915362d420247304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701210301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944000000001234567812345678").unwrap();
3326 assert_eq!(encoded_value, target_value);
3330 fn encoding_tx_add_output() {
3331 let tx_add_output = msgs::TxAddOutput {
3332 channel_id: ChannelId::from_bytes([2; 32]),
3333 serial_id: 4886718345,
3335 script: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().script_pubkey(),
3337 let encoded_value = tx_add_output.encode();
3338 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000000012345678900000001234567890016001436ec78d514df462da95e6a00c24daa8915362d42").unwrap();
3339 assert_eq!(encoded_value, target_value);
3343 fn encoding_tx_remove_input() {
3344 let tx_remove_input = msgs::TxRemoveInput {
3345 channel_id: ChannelId::from_bytes([2; 32]),
3346 serial_id: 4886718345,
3348 let encoded_value = tx_remove_input.encode();
3349 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3350 assert_eq!(encoded_value, target_value);
3354 fn encoding_tx_remove_output() {
3355 let tx_remove_output = msgs::TxRemoveOutput {
3356 channel_id: ChannelId::from_bytes([2; 32]),
3357 serial_id: 4886718345,
3359 let encoded_value = tx_remove_output.encode();
3360 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3361 assert_eq!(encoded_value, target_value);
3365 fn encoding_tx_complete() {
3366 let tx_complete = msgs::TxComplete {
3367 channel_id: ChannelId::from_bytes([2; 32]),
3369 let encoded_value = tx_complete.encode();
3370 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3371 assert_eq!(encoded_value, target_value);
3375 fn encoding_tx_signatures() {
3376 let tx_signatures = msgs::TxSignatures {
3377 channel_id: ChannelId::from_bytes([2; 32]),
3378 tx_hash: Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3380 Witness::from_vec(vec![
3381 hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3382 hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3383 Witness::from_vec(vec![
3384 hex::decode("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap(),
3385 hex::decode("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap()]),
3388 let encoded_value = tx_signatures.encode();
3389 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3390 target_value.append(&mut hex::decode("6e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c2").unwrap()); // tx_hash (sha256) (big endian byte order)
3391 target_value.append(&mut hex::decode("0002").unwrap()); // num_witnesses (u16)
3393 target_value.append(&mut hex::decode("006b").unwrap()); // len of witness_data
3394 target_value.append(&mut hex::decode("02").unwrap()); // num_witness_elements (VarInt)
3395 target_value.append(&mut hex::decode("47").unwrap()); // len of witness element data (VarInt)
3396 target_value.append(&mut hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap());
3397 target_value.append(&mut hex::decode("21").unwrap()); // len of witness element data (VarInt)
3398 target_value.append(&mut hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap());
3400 target_value.append(&mut hex::decode("006c").unwrap()); // len of witness_data
3401 target_value.append(&mut hex::decode("02").unwrap()); // num_witness_elements (VarInt)
3402 target_value.append(&mut hex::decode("48").unwrap()); // len of witness element data (VarInt)
3403 target_value.append(&mut hex::decode("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap());
3404 target_value.append(&mut hex::decode("21").unwrap()); // len of witness element data (VarInt)
3405 target_value.append(&mut hex::decode("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap());
3406 assert_eq!(encoded_value, target_value);
3409 fn do_encoding_tx_init_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3410 let tx_init_rbf = msgs::TxInitRbf {
3411 channel_id: ChannelId::from_bytes([2; 32]),
3412 locktime: 305419896,
3413 feerate_sat_per_1000_weight: 20190119,
3414 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3416 let encoded_value = tx_init_rbf.encode();
3417 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3418 target_value.append(&mut hex::decode("12345678").unwrap()); // locktime
3419 target_value.append(&mut hex::decode("013413a7").unwrap()); // feerate_sat_per_1000_weight
3420 if let Some((_, target)) = funding_value_with_hex_target {
3421 target_value.push(0x00); // Type
3422 target_value.push(target.len() as u8 / 2); // Length
3423 target_value.append(&mut hex::decode(target).unwrap()); // Value (i64)
3425 assert_eq!(encoded_value, target_value);
3429 fn encoding_tx_init_rbf() {
3430 do_encoding_tx_init_rbf(Some((1311768467284833366, "1234567890123456")));
3431 do_encoding_tx_init_rbf(Some((13117684672, "000000030DDFFBC0")));
3432 do_encoding_tx_init_rbf(None);
3435 fn do_encoding_tx_ack_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3436 let tx_ack_rbf = msgs::TxAckRbf {
3437 channel_id: ChannelId::from_bytes([2; 32]),
3438 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3440 let encoded_value = tx_ack_rbf.encode();
3441 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3442 if let Some((_, target)) = funding_value_with_hex_target {
3443 target_value.push(0x00); // Type
3444 target_value.push(target.len() as u8 / 2); // Length
3445 target_value.append(&mut hex::decode(target).unwrap()); // Value (i64)
3447 assert_eq!(encoded_value, target_value);
3451 fn encoding_tx_ack_rbf() {
3452 do_encoding_tx_ack_rbf(Some((1311768467284833366, "1234567890123456")));
3453 do_encoding_tx_ack_rbf(Some((13117684672, "000000030DDFFBC0")));
3454 do_encoding_tx_ack_rbf(None);
3458 fn encoding_tx_abort() {
3459 let tx_abort = msgs::TxAbort {
3460 channel_id: ChannelId::from_bytes([2; 32]),
3461 data: hex::decode("54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap(),
3463 let encoded_value = tx_abort.encode();
3464 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202002C54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap();
3465 assert_eq!(encoded_value, target_value);
3468 fn do_encoding_shutdown(script_type: u8) {
3469 let secp_ctx = Secp256k1::new();
3470 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3471 let script = Builder::new().push_opcode(opcodes::OP_TRUE).into_script();
3472 let shutdown = msgs::Shutdown {
3473 channel_id: ChannelId::from_bytes([2; 32]),
3475 if script_type == 1 { Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey() }
3476 else if script_type == 2 { Address::p2sh(&script, Network::Testnet).unwrap().script_pubkey() }
3477 else if script_type == 3 { Address::p2wpkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).unwrap().script_pubkey() }
3478 else { Address::p2wsh(&script, Network::Testnet).script_pubkey() },
3480 let encoded_value = shutdown.encode();
3481 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3482 if script_type == 1 {
3483 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3484 } else if script_type == 2 {
3485 target_value.append(&mut hex::decode("0017a914da1745e9b549bd0bfa1a569971c77eba30cd5a4b87").unwrap());
3486 } else if script_type == 3 {
3487 target_value.append(&mut hex::decode("0016001479b000887626b294a914501a4cd226b58b235983").unwrap());
3488 } else if script_type == 4 {
3489 target_value.append(&mut hex::decode("002200204ae81572f06e1b88fd5ced7a1a000945432e83e1551e6f721ee9c00b8cc33260").unwrap());
3491 assert_eq!(encoded_value, target_value);
3495 fn encoding_shutdown() {
3496 do_encoding_shutdown(1);
3497 do_encoding_shutdown(2);
3498 do_encoding_shutdown(3);
3499 do_encoding_shutdown(4);
3503 fn encoding_closing_signed() {
3504 let secp_ctx = Secp256k1::new();
3505 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3506 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3507 let closing_signed = msgs::ClosingSigned {
3508 channel_id: ChannelId::from_bytes([2; 32]),
3509 fee_satoshis: 2316138423780173,
3513 let encoded_value = closing_signed.encode();
3514 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3515 assert_eq!(encoded_value, target_value);
3516 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value)).unwrap(), closing_signed);
3518 let closing_signed_with_range = msgs::ClosingSigned {
3519 channel_id: ChannelId::from_bytes([2; 32]),
3520 fee_satoshis: 2316138423780173,
3522 fee_range: Some(msgs::ClosingSignedFeeRange {
3523 min_fee_satoshis: 0xdeadbeef,
3524 max_fee_satoshis: 0x1badcafe01234567,
3527 let encoded_value_with_range = closing_signed_with_range.encode();
3528 let target_value_with_range = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a011000000000deadbeef1badcafe01234567").unwrap();
3529 assert_eq!(encoded_value_with_range, target_value_with_range);
3530 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value_with_range)).unwrap(),
3531 closing_signed_with_range);
3535 fn encoding_update_add_htlc() {
3536 let secp_ctx = Secp256k1::new();
3537 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3538 let onion_routing_packet = msgs::OnionPacket {
3540 public_key: Ok(pubkey_1),
3541 hop_data: [1; 20*65],
3544 let update_add_htlc = msgs::UpdateAddHTLC {
3545 channel_id: ChannelId::from_bytes([2; 32]),
3546 htlc_id: 2316138423780173,
3547 amount_msat: 3608586615801332854,
3548 payment_hash: PaymentHash([1; 32]),
3549 cltv_expiry: 821716,
3550 onion_routing_packet,
3551 skimmed_fee_msat: None,
3553 let encoded_value = update_add_htlc.encode();
3554 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d32144668701144760101010101010101010101010101010101010101010101010101010101010101000c89d4ff031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010202020202020202020202020202020202020202020202020202020202020202").unwrap();
3555 assert_eq!(encoded_value, target_value);
3559 fn encoding_update_fulfill_htlc() {
3560 let update_fulfill_htlc = msgs::UpdateFulfillHTLC {
3561 channel_id: ChannelId::from_bytes([2; 32]),
3562 htlc_id: 2316138423780173,
3563 payment_preimage: PaymentPreimage([1; 32]),
3565 let encoded_value = update_fulfill_htlc.encode();
3566 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d0101010101010101010101010101010101010101010101010101010101010101").unwrap();
3567 assert_eq!(encoded_value, target_value);
3571 fn encoding_update_fail_htlc() {
3572 let reason = OnionErrorPacket {
3573 data: [1; 32].to_vec(),
3575 let update_fail_htlc = msgs::UpdateFailHTLC {
3576 channel_id: ChannelId::from_bytes([2; 32]),
3577 htlc_id: 2316138423780173,
3580 let encoded_value = update_fail_htlc.encode();
3581 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d00200101010101010101010101010101010101010101010101010101010101010101").unwrap();
3582 assert_eq!(encoded_value, target_value);
3586 fn encoding_update_fail_malformed_htlc() {
3587 let update_fail_malformed_htlc = msgs::UpdateFailMalformedHTLC {
3588 channel_id: ChannelId::from_bytes([2; 32]),
3589 htlc_id: 2316138423780173,
3590 sha256_of_onion: [1; 32],
3593 let encoded_value = update_fail_malformed_htlc.encode();
3594 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d010101010101010101010101010101010101010101010101010101010101010100ff").unwrap();
3595 assert_eq!(encoded_value, target_value);
3598 fn do_encoding_commitment_signed(htlcs: bool) {
3599 let secp_ctx = Secp256k1::new();
3600 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3601 let (privkey_2, _) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3602 let (privkey_3, _) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3603 let (privkey_4, _) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3604 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3605 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
3606 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
3607 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
3608 let commitment_signed = msgs::CommitmentSigned {
3609 channel_id: ChannelId::from_bytes([2; 32]),
3611 htlc_signatures: if htlcs { vec![sig_2, sig_3, sig_4] } else { Vec::new() },
3613 partial_signature_with_nonce: None,
3615 let encoded_value = commitment_signed.encode();
3616 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3618 target_value.append(&mut hex::decode("00031735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
3620 target_value.append(&mut hex::decode("0000").unwrap());
3622 assert_eq!(encoded_value, target_value);
3626 fn encoding_commitment_signed() {
3627 do_encoding_commitment_signed(true);
3628 do_encoding_commitment_signed(false);
3632 fn encoding_revoke_and_ack() {
3633 let secp_ctx = Secp256k1::new();
3634 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3635 let raa = msgs::RevokeAndACK {
3636 channel_id: ChannelId::from_bytes([2; 32]),
3637 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],
3638 next_per_commitment_point: pubkey_1,
3640 next_local_nonce: None,
3642 let encoded_value = raa.encode();
3643 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020101010101010101010101010101010101010101010101010101010101010101031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3644 assert_eq!(encoded_value, target_value);
3648 fn encoding_update_fee() {
3649 let update_fee = msgs::UpdateFee {
3650 channel_id: ChannelId::from_bytes([2; 32]),
3651 feerate_per_kw: 20190119,
3653 let encoded_value = update_fee.encode();
3654 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202013413a7").unwrap();
3655 assert_eq!(encoded_value, target_value);
3659 fn encoding_init() {
3660 let mainnet_hash = ChainHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap();
3661 assert_eq!(msgs::Init {
3662 features: InitFeatures::from_le_bytes(vec![0xFF, 0xFF, 0xFF]),
3663 networks: Some(vec![mainnet_hash]),
3664 remote_network_address: None,
3665 }.encode(), hex::decode("00023fff0003ffffff01206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3666 assert_eq!(msgs::Init {
3667 features: InitFeatures::from_le_bytes(vec![0xFF]),
3669 remote_network_address: None,
3670 }.encode(), hex::decode("0001ff0001ff").unwrap());
3671 assert_eq!(msgs::Init {
3672 features: InitFeatures::from_le_bytes(vec![]),
3673 networks: Some(vec![mainnet_hash]),
3674 remote_network_address: None,
3675 }.encode(), hex::decode("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3676 assert_eq!(msgs::Init {
3677 features: InitFeatures::from_le_bytes(vec![]),
3678 networks: Some(vec![ChainHash::from(&[1; 32][..]), ChainHash::from(&[2; 32][..])]),
3679 remote_network_address: None,
3680 }.encode(), hex::decode("00000000014001010101010101010101010101010101010101010101010101010101010101010202020202020202020202020202020202020202020202020202020202020202").unwrap());
3681 let init_msg = msgs::Init { features: InitFeatures::from_le_bytes(vec![]),
3682 networks: Some(vec![mainnet_hash]),
3683 remote_network_address: Some(SocketAddress::TcpIpV4 {
3684 addr: [127, 0, 0, 1],
3688 let encoded_value = init_msg.encode();
3689 let target_value = hex::decode("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d61900000000000307017f00000103e8").unwrap();
3690 assert_eq!(encoded_value, target_value);
3691 assert_eq!(msgs::Init::read(&mut Cursor::new(&target_value)).unwrap(), init_msg);
3695 fn encoding_error() {
3696 let error = msgs::ErrorMessage {
3697 channel_id: ChannelId::from_bytes([2; 32]),
3698 data: String::from("rust-lightning"),
3700 let encoded_value = error.encode();
3701 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3702 assert_eq!(encoded_value, target_value);
3706 fn encoding_warning() {
3707 let error = msgs::WarningMessage {
3708 channel_id: ChannelId::from_bytes([2; 32]),
3709 data: String::from("rust-lightning"),
3711 let encoded_value = error.encode();
3712 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3713 assert_eq!(encoded_value, target_value);
3717 fn encoding_ping() {
3718 let ping = msgs::Ping {
3722 let encoded_value = ping.encode();
3723 let target_value = hex::decode("0040004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3724 assert_eq!(encoded_value, target_value);
3728 fn encoding_pong() {
3729 let pong = msgs::Pong {
3732 let encoded_value = pong.encode();
3733 let target_value = hex::decode("004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3734 assert_eq!(encoded_value, target_value);
3738 fn encoding_nonfinal_onion_hop_data() {
3739 let outbound_msg = msgs::OutboundOnionPayload::Forward {
3740 short_channel_id: 0xdeadbeef1bad1dea,
3741 amt_to_forward: 0x0badf00d01020304,
3742 outgoing_cltv_value: 0xffffffff,
3744 let encoded_value = outbound_msg.encode();
3745 let target_value = hex::decode("1a02080badf00d010203040404ffffffff0608deadbeef1bad1dea").unwrap();
3746 assert_eq!(encoded_value, target_value);
3748 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3749 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
3750 if let msgs::InboundOnionPayload::Forward {
3751 short_channel_id, amt_to_forward, outgoing_cltv_value
3753 assert_eq!(short_channel_id, 0xdeadbeef1bad1dea);
3754 assert_eq!(amt_to_forward, 0x0badf00d01020304);
3755 assert_eq!(outgoing_cltv_value, 0xffffffff);
3756 } else { panic!(); }
3760 fn encoding_final_onion_hop_data() {
3761 let outbound_msg = msgs::OutboundOnionPayload::Receive {
3763 payment_metadata: None,
3764 keysend_preimage: None,
3765 amt_msat: 0x0badf00d01020304,
3766 outgoing_cltv_value: 0xffffffff,
3767 custom_tlvs: vec![],
3769 let encoded_value = outbound_msg.encode();
3770 let target_value = hex::decode("1002080badf00d010203040404ffffffff").unwrap();
3771 assert_eq!(encoded_value, target_value);
3773 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3774 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
3775 if let msgs::InboundOnionPayload::Receive {
3776 payment_data: None, amt_msat, outgoing_cltv_value, ..
3778 assert_eq!(amt_msat, 0x0badf00d01020304);
3779 assert_eq!(outgoing_cltv_value, 0xffffffff);
3780 } else { panic!(); }
3784 fn encoding_final_onion_hop_data_with_secret() {
3785 let expected_payment_secret = PaymentSecret([0x42u8; 32]);
3786 let outbound_msg = msgs::OutboundOnionPayload::Receive {
3787 payment_data: Some(FinalOnionHopData {
3788 payment_secret: expected_payment_secret,
3789 total_msat: 0x1badca1f
3791 payment_metadata: None,
3792 keysend_preimage: None,
3793 amt_msat: 0x0badf00d01020304,
3794 outgoing_cltv_value: 0xffffffff,
3795 custom_tlvs: vec![],
3797 let encoded_value = outbound_msg.encode();
3798 let target_value = hex::decode("3602080badf00d010203040404ffffffff082442424242424242424242424242424242424242424242424242424242424242421badca1f").unwrap();
3799 assert_eq!(encoded_value, target_value);
3801 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3802 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
3803 if let msgs::InboundOnionPayload::Receive {
3804 payment_data: Some(FinalOnionHopData {
3806 total_msat: 0x1badca1f
3808 amt_msat, outgoing_cltv_value,
3809 payment_metadata: None,
3810 keysend_preimage: None,
3813 assert_eq!(payment_secret, expected_payment_secret);
3814 assert_eq!(amt_msat, 0x0badf00d01020304);
3815 assert_eq!(outgoing_cltv_value, 0xffffffff);
3816 assert_eq!(custom_tlvs, vec![]);
3817 } else { panic!(); }
3821 fn encoding_final_onion_hop_data_with_bad_custom_tlvs() {
3822 // If custom TLVs have type number within the range reserved for protocol, treat them as if
3824 let bad_type_range_tlvs = vec![
3825 ((1 << 16) - 4, vec![42]),
3826 ((1 << 16) - 2, vec![42; 32]),
3828 let mut msg = msgs::OutboundOnionPayload::Receive {
3830 payment_metadata: None,
3831 keysend_preimage: None,
3832 custom_tlvs: bad_type_range_tlvs,
3833 amt_msat: 0x0badf00d01020304,
3834 outgoing_cltv_value: 0xffffffff,
3836 let encoded_value = msg.encode();
3837 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3838 assert!(msgs::InboundOnionPayload::read(&mut Cursor::new(&encoded_value[..]), &&node_signer).is_err());
3839 let good_type_range_tlvs = vec![
3840 ((1 << 16) - 3, vec![42]),
3841 ((1 << 16) - 1, vec![42; 32]),
3843 if let msgs::OutboundOnionPayload::Receive { ref mut custom_tlvs, .. } = msg {
3844 *custom_tlvs = good_type_range_tlvs.clone();
3846 let encoded_value = msg.encode();
3847 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&encoded_value[..]), &&node_signer).unwrap();
3849 msgs::InboundOnionPayload::Receive { custom_tlvs, .. } => assert!(custom_tlvs.is_empty()),
3855 fn encoding_final_onion_hop_data_with_custom_tlvs() {
3856 let expected_custom_tlvs = vec![
3857 (5482373483, vec![0x12, 0x34]),
3858 (5482373487, vec![0x42u8; 8]),
3860 let msg = msgs::OutboundOnionPayload::Receive {
3862 payment_metadata: None,
3863 keysend_preimage: None,
3864 custom_tlvs: expected_custom_tlvs.clone(),
3865 amt_msat: 0x0badf00d01020304,
3866 outgoing_cltv_value: 0xffffffff,
3868 let encoded_value = msg.encode();
3869 let target_value = hex::decode("2e02080badf00d010203040404ffffffffff0000000146c6616b021234ff0000000146c6616f084242424242424242").unwrap();
3870 assert_eq!(encoded_value, target_value);
3871 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3872 let inbound_msg: msgs::InboundOnionPayload = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
3873 if let msgs::InboundOnionPayload::Receive {
3875 payment_metadata: None,
3876 keysend_preimage: None,
3879 outgoing_cltv_value,
3882 assert_eq!(custom_tlvs, expected_custom_tlvs);
3883 assert_eq!(amt_msat, 0x0badf00d01020304);
3884 assert_eq!(outgoing_cltv_value, 0xffffffff);
3885 } else { panic!(); }
3889 fn query_channel_range_end_blocknum() {
3890 let tests: Vec<(u32, u32, u32)> = vec![
3891 (10000, 1500, 11500),
3892 (0, 0xffffffff, 0xffffffff),
3893 (1, 0xffffffff, 0xffffffff),
3896 for (first_blocknum, number_of_blocks, expected) in tests.into_iter() {
3897 let sut = msgs::QueryChannelRange {
3898 chain_hash: BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap(),
3902 assert_eq!(sut.end_blocknum(), expected);
3907 fn encoding_query_channel_range() {
3908 let mut query_channel_range = msgs::QueryChannelRange {
3909 chain_hash: BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap(),
3910 first_blocknum: 100000,
3911 number_of_blocks: 1500,
3913 let encoded_value = query_channel_range.encode();
3914 let target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206000186a0000005dc").unwrap();
3915 assert_eq!(encoded_value, target_value);
3917 query_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3918 assert_eq!(query_channel_range.first_blocknum, 100000);
3919 assert_eq!(query_channel_range.number_of_blocks, 1500);
3923 fn encoding_reply_channel_range() {
3924 do_encoding_reply_channel_range(0);
3925 do_encoding_reply_channel_range(1);
3928 fn do_encoding_reply_channel_range(encoding_type: u8) {
3929 let mut target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206000b8a06000005dc01").unwrap();
3930 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3931 let mut reply_channel_range = msgs::ReplyChannelRange {
3932 chain_hash: expected_chain_hash,
3933 first_blocknum: 756230,
3934 number_of_blocks: 1500,
3935 sync_complete: true,
3936 short_channel_ids: vec![0x000000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
3939 if encoding_type == 0 {
3940 target_value.append(&mut hex::decode("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
3941 let encoded_value = reply_channel_range.encode();
3942 assert_eq!(encoded_value, target_value);
3944 reply_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3945 assert_eq!(reply_channel_range.chain_hash, expected_chain_hash);
3946 assert_eq!(reply_channel_range.first_blocknum, 756230);
3947 assert_eq!(reply_channel_range.number_of_blocks, 1500);
3948 assert_eq!(reply_channel_range.sync_complete, true);
3949 assert_eq!(reply_channel_range.short_channel_ids[0], 0x000000000000008e);
3950 assert_eq!(reply_channel_range.short_channel_ids[1], 0x0000000000003c69);
3951 assert_eq!(reply_channel_range.short_channel_ids[2], 0x000000000045a6c4);
3953 target_value.append(&mut hex::decode("001601789c636000833e08659309a65878be010010a9023a").unwrap());
3954 let result: Result<msgs::ReplyChannelRange, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
3955 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
3960 fn encoding_query_short_channel_ids() {
3961 do_encoding_query_short_channel_ids(0);
3962 do_encoding_query_short_channel_ids(1);
3965 fn do_encoding_query_short_channel_ids(encoding_type: u8) {
3966 let mut target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206").unwrap();
3967 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3968 let mut query_short_channel_ids = msgs::QueryShortChannelIds {
3969 chain_hash: expected_chain_hash,
3970 short_channel_ids: vec![0x0000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
3973 if encoding_type == 0 {
3974 target_value.append(&mut hex::decode("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
3975 let encoded_value = query_short_channel_ids.encode();
3976 assert_eq!(encoded_value, target_value);
3978 query_short_channel_ids = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3979 assert_eq!(query_short_channel_ids.chain_hash, expected_chain_hash);
3980 assert_eq!(query_short_channel_ids.short_channel_ids[0], 0x000000000000008e);
3981 assert_eq!(query_short_channel_ids.short_channel_ids[1], 0x0000000000003c69);
3982 assert_eq!(query_short_channel_ids.short_channel_ids[2], 0x000000000045a6c4);
3984 target_value.append(&mut hex::decode("001601789c636000833e08659309a65878be010010a9023a").unwrap());
3985 let result: Result<msgs::QueryShortChannelIds, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
3986 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
3991 fn encoding_reply_short_channel_ids_end() {
3992 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3993 let mut reply_short_channel_ids_end = msgs::ReplyShortChannelIdsEnd {
3994 chain_hash: expected_chain_hash,
3995 full_information: true,
3997 let encoded_value = reply_short_channel_ids_end.encode();
3998 let target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e220601").unwrap();
3999 assert_eq!(encoded_value, target_value);
4001 reply_short_channel_ids_end = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4002 assert_eq!(reply_short_channel_ids_end.chain_hash, expected_chain_hash);
4003 assert_eq!(reply_short_channel_ids_end.full_information, true);
4007 fn encoding_gossip_timestamp_filter(){
4008 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
4009 let mut gossip_timestamp_filter = msgs::GossipTimestampFilter {
4010 chain_hash: expected_chain_hash,
4011 first_timestamp: 1590000000,
4012 timestamp_range: 0xffff_ffff,
4014 let encoded_value = gossip_timestamp_filter.encode();
4015 let target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e22065ec57980ffffffff").unwrap();
4016 assert_eq!(encoded_value, target_value);
4018 gossip_timestamp_filter = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4019 assert_eq!(gossip_timestamp_filter.chain_hash, expected_chain_hash);
4020 assert_eq!(gossip_timestamp_filter.first_timestamp, 1590000000);
4021 assert_eq!(gossip_timestamp_filter.timestamp_range, 0xffff_ffff);
4025 fn decode_onion_hop_data_len_as_bigsize() {
4026 // Tests that we can decode an onion payload that is >253 bytes.
4027 // Previously, receiving a payload of this size could've caused us to fail to decode a valid
4028 // payload, because we were decoding the length (a BigSize, big-endian) as a VarInt
4031 // Encode a test onion payload with a big custom TLV such that it's >253 bytes, forcing the
4032 // payload length to be encoded over multiple bytes rather than a single u8.
4033 let big_payload = encode_big_payload().unwrap();
4034 let mut rd = Cursor::new(&big_payload[..]);
4036 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4037 <msgs::InboundOnionPayload as ReadableArgs<&&test_utils::TestKeysInterface>>
4038 ::read(&mut rd, &&node_signer).unwrap();
4040 // see above test, needs to be a separate method for use of the serialization macros.
4041 fn encode_big_payload() -> Result<Vec<u8>, io::Error> {
4042 use crate::util::ser::HighZeroBytesDroppedBigSize;
4043 let payload = msgs::OutboundOnionPayload::Forward {
4044 short_channel_id: 0xdeadbeef1bad1dea,
4045 amt_to_forward: 1000,
4046 outgoing_cltv_value: 0xffffffff,
4048 let mut encoded_payload = Vec::new();
4049 let test_bytes = vec![42u8; 1000];
4050 if let msgs::OutboundOnionPayload::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } = payload {
4051 _encode_varint_length_prefixed_tlv!(&mut encoded_payload, {
4052 (1, test_bytes, required_vec),
4053 (2, HighZeroBytesDroppedBigSize(amt_to_forward), required),
4054 (4, HighZeroBytesDroppedBigSize(outgoing_cltv_value), required),
4055 (6, short_channel_id, required)
4062 #[cfg(feature = "std")]
4063 fn test_socket_address_from_str() {
4064 assert_eq!(SocketAddress::TcpIpV4 {
4065 addr: Ipv4Addr::new(127, 0, 0, 1).octets(),
4067 }, SocketAddress::from_str("127.0.0.1:1234").unwrap());
4069 assert_eq!(SocketAddress::TcpIpV6 {
4070 addr: Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1).octets(),
4072 }, SocketAddress::from_str("[0:0:0:0:0:0:0:1]:1234").unwrap());
4074 SocketAddress::Hostname {
4075 hostname: Hostname::try_from("lightning-node.mydomain.com".to_string()).unwrap(),
4077 }, SocketAddress::from_str("lightning-node.mydomain.com:1234").unwrap());
4079 SocketAddress::Hostname {
4080 hostname: Hostname::try_from("example.com".to_string()).unwrap(),
4082 }, SocketAddress::from_str("example.com:1234").unwrap());
4083 assert_eq!(SocketAddress::OnionV3 {
4084 ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102, 182, 107, 4, 105, 247, 246, 85,
4085 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31, 33, 71, 3],
4089 }, SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion:1234").unwrap());
4090 assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6.onion:1234"));
4091 assert_eq!(Err(SocketAddressParseError::InvalidInput), SocketAddress::from_str("127.0.0.1@1234"));
4092 assert_eq!(Err(SocketAddressParseError::InvalidInput), "".parse::<SocketAddress>());
4093 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:9735:94").is_err());
4094 assert!(SocketAddress::from_str("wrong$%#.com:1234").is_err());
4095 assert_eq!(Err(SocketAddressParseError::InvalidPort), SocketAddress::from_str("example.com:wrong"));
4096 assert!("localhost".parse::<SocketAddress>().is_err());
4097 assert!("localhost:invalid-port".parse::<SocketAddress>().is_err());
4098 assert!( "invalid-onion-v3-hostname.onion:8080".parse::<SocketAddress>().is_err());
4099 assert!("b32.example.onion:invalid-port".parse::<SocketAddress>().is_err());
4100 assert!("invalid-address".parse::<SocketAddress>().is_err());
4101 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:1234").is_err());