1 // This file is Copyright its original authors, visible in version control
4 // This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
5 // or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
6 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
7 // You may not use this file except in accordance with one or both of these
10 //! Wire messages, traits representing wire message handlers, and a few error types live here.
12 //! For a normal node you probably don't need to use anything here, however, if you wish to split a
13 //! node into an internet-facing route/message socket handling daemon and a separate daemon (or
14 //! server entirely) which handles only channel-related messages you may wish to implement
15 //! [`ChannelMessageHandler`] yourself and use it to re-serialize messages and pass them across
18 //! Note that if you go with such an architecture (instead of passing raw socket events to a
19 //! non-internet-facing system) you trust the frontend internet-facing system to not lie about the
20 //! source `node_id` of the message, however this does allow you to significantly reduce bandwidth
21 //! between the systems as routing messages can represent a significant chunk of bandwidth usage
22 //! (especially for non-channel-publicly-announcing nodes). As an alternate design which avoids
23 //! this issue, if you have sufficient bidirectional bandwidth between your systems, you may send
24 //! raw socket events into your non-internet-facing system and then send routing events back to
25 //! track the network on the less-secure system.
27 use bitcoin::blockdata::constants::ChainHash;
28 use bitcoin::secp256k1::PublicKey;
29 use bitcoin::secp256k1::ecdsa::Signature;
30 use bitcoin::{secp256k1, Witness};
31 use bitcoin::blockdata::script::Script;
32 use bitcoin::hash_types::{Txid, BlockHash};
34 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
35 use crate::ln::onion_utils;
36 use crate::onion_message;
38 use crate::prelude::*;
41 use crate::io::{self, Read};
42 use crate::io_extras::read_to_end;
44 use crate::events::{MessageSendEventsProvider, OnionMessageProvider};
45 use crate::util::logger;
46 use crate::util::ser::{LengthReadable, Readable, ReadableArgs, Writeable, Writer, WithoutLength, FixedLengthReader, HighZeroBytesDroppedBigSize, Hostname, TransactionU16LenLimited};
48 use crate::ln::{PaymentPreimage, PaymentHash, PaymentSecret};
50 use crate::routing::gossip::{NodeAlias, NodeId};
52 /// 21 million * 10^8 * 1000
53 pub(crate) const MAX_VALUE_MSAT: u64 = 21_000_000_0000_0000_000;
56 /// A partial signature that also contains the Musig2 nonce its signer used
57 #[derive(Clone, Debug, PartialEq, Eq)]
58 pub struct PartialSignatureWithNonce(pub musig2::types::PartialSignature, pub musig2::types::PublicNonce);
60 /// An error in decoding a message or struct.
61 #[derive(Clone, Debug, PartialEq, Eq)]
62 pub enum DecodeError {
63 /// A version byte specified something we don't know how to handle.
65 /// Includes unknown realm byte in an onion hop data packet.
67 /// Unknown feature mandating we fail to parse message (e.g., TLV with an even, unknown type)
68 UnknownRequiredFeature,
69 /// Value was invalid.
71 /// For example, a byte which was supposed to be a bool was something other than a 0
72 /// or 1, a public key/private key/signature was invalid, text wasn't UTF-8, TLV was
73 /// syntactically incorrect, etc.
75 /// The buffer to be read was too short.
77 /// A length descriptor in the packet didn't describe the later data correctly.
79 /// Error from [`std::io`].
81 /// The message included zlib-compressed values, which we don't support.
82 UnsupportedCompression,
85 /// An [`init`] message to be sent to or received from a peer.
87 /// [`init`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-init-message
88 #[derive(Clone, Debug, PartialEq, Eq)]
90 /// The relevant features which the sender supports.
91 pub features: InitFeatures,
92 /// Indicates chains the sender is interested in.
94 /// If there are no common chains, the connection will be closed.
95 pub networks: Option<Vec<ChainHash>>,
96 /// The receipient's network address.
98 /// This adds the option to report a remote IP address back to a connecting peer using the init
99 /// message. A node can decide to use that information to discover a potential update to its
100 /// public IPv4 address (NAT) and use that for a [`NodeAnnouncement`] update message containing
102 pub remote_network_address: Option<NetAddress>,
105 /// An [`error`] message to be sent to or received from a peer.
107 /// [`error`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-error-and-warning-messages
108 #[derive(Clone, Debug, PartialEq, Eq)]
109 pub struct ErrorMessage {
110 /// The channel ID involved in the error.
112 /// All-0s indicates a general error unrelated to a specific channel, after which all channels
113 /// with the sending peer should be closed.
114 pub channel_id: [u8; 32],
115 /// A possibly human-readable error description.
117 /// The string should be sanitized before it is used (e.g., emitted to logs or printed to
118 /// `stdout`). Otherwise, a well crafted error message may trigger a security vulnerability in
119 /// the terminal emulator or the logging subsystem.
123 /// A [`warning`] message to be sent to or received from a peer.
125 /// [`warning`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-error-and-warning-messages
126 #[derive(Clone, Debug, PartialEq, Eq)]
127 pub struct WarningMessage {
128 /// The channel ID involved in the warning.
130 /// All-0s indicates a warning unrelated to a specific channel.
131 pub channel_id: [u8; 32],
132 /// A possibly human-readable warning description.
134 /// The string should be sanitized before it is used (e.g. emitted to logs or printed to
135 /// stdout). Otherwise, a well crafted error message may trigger a security vulnerability in
136 /// the terminal emulator or the logging subsystem.
140 /// A [`ping`] message to be sent to or received from a peer.
142 /// [`ping`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-ping-and-pong-messages
143 #[derive(Clone, Debug, PartialEq, Eq)]
145 /// The desired response length.
147 /// The ping packet size.
149 /// This field is not sent on the wire. byteslen zeros are sent.
153 /// A [`pong`] message to be sent to or received from a peer.
155 /// [`pong`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-ping-and-pong-messages
156 #[derive(Clone, Debug, PartialEq, Eq)]
158 /// The pong packet size.
160 /// This field is not sent on the wire. byteslen zeros are sent.
164 /// An [`open_channel`] message to be sent to or received from a peer.
166 /// Used in V1 channel establishment
168 /// [`open_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-open_channel-message
169 #[derive(Clone, Debug, PartialEq, Eq)]
170 pub struct OpenChannel {
171 /// The genesis hash of the blockchain where the channel is to be opened
172 pub chain_hash: BlockHash,
173 /// A temporary channel ID, until the funding outpoint is announced
174 pub temporary_channel_id: [u8; 32],
175 /// The channel value
176 pub funding_satoshis: u64,
177 /// The amount to push to the counterparty as part of the open, in milli-satoshi
179 /// The threshold below which outputs on transactions broadcast by sender will be omitted
180 pub dust_limit_satoshis: u64,
181 /// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
182 pub max_htlc_value_in_flight_msat: u64,
183 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
184 pub channel_reserve_satoshis: u64,
185 /// The minimum HTLC size incoming to sender, in milli-satoshi
186 pub htlc_minimum_msat: u64,
187 /// The feerate per 1000-weight of sender generated transactions, until updated by
189 pub feerate_per_kw: u32,
190 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if
191 /// they broadcast a commitment transaction
192 pub to_self_delay: u16,
193 /// The maximum number of inbound HTLCs towards sender
194 pub max_accepted_htlcs: u16,
195 /// The sender's key controlling the funding transaction
196 pub funding_pubkey: PublicKey,
197 /// Used to derive a revocation key for transactions broadcast by counterparty
198 pub revocation_basepoint: PublicKey,
199 /// A payment key to sender for transactions broadcast by counterparty
200 pub payment_point: PublicKey,
201 /// Used to derive a payment key to sender for transactions broadcast by sender
202 pub delayed_payment_basepoint: PublicKey,
203 /// Used to derive an HTLC payment key to sender
204 pub htlc_basepoint: PublicKey,
205 /// The first to-be-broadcast-by-sender transaction's per commitment point
206 pub first_per_commitment_point: PublicKey,
207 /// The channel flags to be used
208 pub channel_flags: u8,
209 /// A request to pre-set the to-sender output's `scriptPubkey` for when we collaboratively close
210 pub shutdown_scriptpubkey: Option<Script>,
211 /// The channel type that this channel will represent
213 /// If this is `None`, we derive the channel type from the intersection of our
214 /// feature bits with our counterparty's feature bits from the [`Init`] message.
215 pub channel_type: Option<ChannelTypeFeatures>,
218 /// An open_channel2 message to be sent by or received from the channel initiator.
220 /// Used in V2 channel establishment
222 // TODO(dual_funding): Add spec link for `open_channel2`.
223 #[derive(Clone, Debug, PartialEq, Eq)]
224 pub struct OpenChannelV2 {
225 /// The genesis hash of the blockchain where the channel is to be opened
226 pub chain_hash: BlockHash,
227 /// A temporary channel ID derived using a zeroed out value for the channel acceptor's revocation basepoint
228 pub temporary_channel_id: [u8; 32],
229 /// The feerate for the funding transaction set by the channel initiator
230 pub funding_feerate_sat_per_1000_weight: u32,
231 /// The feerate for the commitment transaction set by the channel initiator
232 pub commitment_feerate_sat_per_1000_weight: u32,
233 /// Part of the channel value contributed by the channel initiator
234 pub funding_satoshis: u64,
235 /// The threshold below which outputs on transactions broadcast by the channel initiator will be
237 pub dust_limit_satoshis: u64,
238 /// The maximum inbound HTLC value in flight towards channel initiator, in milli-satoshi
239 pub max_htlc_value_in_flight_msat: u64,
240 /// The minimum HTLC size incoming to channel initiator, in milli-satoshi
241 pub htlc_minimum_msat: u64,
242 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
243 /// broadcast a commitment transaction
244 pub to_self_delay: u16,
245 /// The maximum number of inbound HTLCs towards channel initiator
246 pub max_accepted_htlcs: u16,
247 /// The locktime for the funding transaction
249 /// The channel initiator's key controlling the funding transaction
250 pub funding_pubkey: PublicKey,
251 /// Used to derive a revocation key for transactions broadcast by counterparty
252 pub revocation_basepoint: PublicKey,
253 /// A payment key to channel initiator for transactions broadcast by counterparty
254 pub payment_basepoint: PublicKey,
255 /// Used to derive a payment key to channel initiator for transactions broadcast by channel
257 pub delayed_payment_basepoint: PublicKey,
258 /// Used to derive an HTLC payment key to channel initiator
259 pub htlc_basepoint: PublicKey,
260 /// The first to-be-broadcast-by-channel-initiator transaction's per commitment point
261 pub first_per_commitment_point: PublicKey,
262 /// The second to-be-broadcast-by-channel-initiator transaction's per commitment point
263 pub second_per_commitment_point: PublicKey,
265 pub channel_flags: u8,
266 /// Optionally, a request to pre-set the to-channel-initiator output's scriptPubkey for when we
267 /// collaboratively close
268 pub shutdown_scriptpubkey: Option<Script>,
269 /// The channel type that this channel will represent. If none is set, we derive the channel
270 /// type from the intersection of our feature bits with our counterparty's feature bits from
271 /// the Init message.
272 pub channel_type: Option<ChannelTypeFeatures>,
273 /// Optionally, a requirement that only confirmed inputs can be added
274 pub require_confirmed_inputs: Option<()>,
277 /// An [`accept_channel`] message to be sent to or received from a peer.
279 /// Used in V1 channel establishment
281 /// [`accept_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-accept_channel-message
282 #[derive(Clone, Debug, PartialEq, Eq)]
283 pub struct AcceptChannel {
284 /// A temporary channel ID, until the funding outpoint is announced
285 pub temporary_channel_id: [u8; 32],
286 /// The threshold below which outputs on transactions broadcast by sender will be omitted
287 pub dust_limit_satoshis: u64,
288 /// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
289 pub max_htlc_value_in_flight_msat: u64,
290 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
291 pub channel_reserve_satoshis: u64,
292 /// The minimum HTLC size incoming to sender, in milli-satoshi
293 pub htlc_minimum_msat: u64,
294 /// Minimum depth of the funding transaction before the channel is considered open
295 pub minimum_depth: u32,
296 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they broadcast a commitment transaction
297 pub to_self_delay: u16,
298 /// The maximum number of inbound HTLCs towards sender
299 pub max_accepted_htlcs: u16,
300 /// The sender's key controlling the funding transaction
301 pub funding_pubkey: PublicKey,
302 /// Used to derive a revocation key for transactions broadcast by counterparty
303 pub revocation_basepoint: PublicKey,
304 /// A payment key to sender for transactions broadcast by counterparty
305 pub payment_point: PublicKey,
306 /// Used to derive a payment key to sender for transactions broadcast by sender
307 pub delayed_payment_basepoint: PublicKey,
308 /// Used to derive an HTLC payment key to sender for transactions broadcast by counterparty
309 pub htlc_basepoint: PublicKey,
310 /// The first to-be-broadcast-by-sender transaction's per commitment point
311 pub first_per_commitment_point: PublicKey,
312 /// A request to pre-set the to-sender output's scriptPubkey for when we collaboratively close
313 pub shutdown_scriptpubkey: Option<Script>,
314 /// The channel type that this channel will represent.
316 /// If this is `None`, we derive the channel type from the intersection of
317 /// our feature bits with our counterparty's feature bits from the [`Init`] message.
318 /// This is required to match the equivalent field in [`OpenChannel::channel_type`].
319 pub channel_type: Option<ChannelTypeFeatures>,
321 /// Next nonce the channel initiator should use to create a funding output signature against
322 pub next_local_nonce: Option<musig2::types::PublicNonce>,
325 /// An accept_channel2 message to be sent by or received from the channel accepter.
327 /// Used in V2 channel establishment
329 // TODO(dual_funding): Add spec link for `accept_channel2`.
330 #[derive(Clone, Debug, PartialEq, Eq)]
331 pub struct AcceptChannelV2 {
332 /// The same `temporary_channel_id` received from the initiator's `open_channel2` message.
333 pub temporary_channel_id: [u8; 32],
334 /// Part of the channel value contributed by the channel acceptor
335 pub funding_satoshis: u64,
336 /// The threshold below which outputs on transactions broadcast by the channel acceptor will be
338 pub dust_limit_satoshis: u64,
339 /// The maximum inbound HTLC value in flight towards channel acceptor, in milli-satoshi
340 pub max_htlc_value_in_flight_msat: u64,
341 /// The minimum HTLC size incoming to channel acceptor, in milli-satoshi
342 pub htlc_minimum_msat: u64,
343 /// Minimum depth of the funding transaction before the channel is considered open
344 pub minimum_depth: u32,
345 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
346 /// broadcast a commitment transaction
347 pub to_self_delay: u16,
348 /// The maximum number of inbound HTLCs towards channel acceptor
349 pub max_accepted_htlcs: u16,
350 /// The channel acceptor's key controlling the funding transaction
351 pub funding_pubkey: PublicKey,
352 /// Used to derive a revocation key for transactions broadcast by counterparty
353 pub revocation_basepoint: PublicKey,
354 /// A payment key to channel acceptor for transactions broadcast by counterparty
355 pub payment_basepoint: PublicKey,
356 /// Used to derive a payment key to channel acceptor for transactions broadcast by channel
358 pub delayed_payment_basepoint: PublicKey,
359 /// Used to derive an HTLC payment key to channel acceptor for transactions broadcast by counterparty
360 pub htlc_basepoint: PublicKey,
361 /// The first to-be-broadcast-by-channel-acceptor transaction's per commitment point
362 pub first_per_commitment_point: PublicKey,
363 /// The second to-be-broadcast-by-channel-acceptor transaction's per commitment point
364 pub second_per_commitment_point: PublicKey,
365 /// Optionally, a request to pre-set the to-channel-acceptor output's scriptPubkey for when we
366 /// collaboratively close
367 pub shutdown_scriptpubkey: Option<Script>,
368 /// The channel type that this channel will represent. If none is set, we derive the channel
369 /// type from the intersection of our feature bits with our counterparty's feature bits from
370 /// the Init message.
372 /// This is required to match the equivalent field in [`OpenChannelV2::channel_type`].
373 pub channel_type: Option<ChannelTypeFeatures>,
374 /// Optionally, a requirement that only confirmed inputs can be added
375 pub require_confirmed_inputs: Option<()>,
378 /// A [`funding_created`] message to be sent to or received from a peer.
380 /// Used in V1 channel establishment
382 /// [`funding_created`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-funding_created-message
383 #[derive(Clone, Debug, PartialEq, Eq)]
384 pub struct FundingCreated {
385 /// A temporary channel ID, until the funding is established
386 pub temporary_channel_id: [u8; 32],
387 /// The funding transaction ID
388 pub funding_txid: Txid,
389 /// The specific output index funding this channel
390 pub funding_output_index: u16,
391 /// The signature of the channel initiator (funder) on the initial commitment transaction
392 pub signature: Signature,
394 /// The partial signature of the channel initiator (funder)
395 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
397 /// Next nonce the channel acceptor should use to finalize the funding output signature
398 pub next_local_nonce: Option<musig2::types::PublicNonce>
401 /// A [`funding_signed`] message to be sent to or received from a peer.
403 /// Used in V1 channel establishment
405 /// [`funding_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-funding_signed-message
406 #[derive(Clone, Debug, PartialEq, Eq)]
407 pub struct FundingSigned {
409 pub channel_id: [u8; 32],
410 /// The signature of the channel acceptor (fundee) on the initial commitment transaction
411 pub signature: Signature,
413 /// The partial signature of the channel acceptor (fundee)
414 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
417 /// A [`channel_ready`] message to be sent to or received from a peer.
419 /// [`channel_ready`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-channel_ready-message
420 #[derive(Clone, Debug, PartialEq, Eq)]
421 pub struct ChannelReady {
423 pub channel_id: [u8; 32],
424 /// The per-commitment point of the second commitment transaction
425 pub next_per_commitment_point: PublicKey,
426 /// If set, provides a `short_channel_id` alias for this channel.
428 /// The sender will accept payments to be forwarded over this SCID and forward them to this
429 /// messages' recipient.
430 pub short_channel_id_alias: Option<u64>,
433 /// A tx_add_input message for adding an input during interactive transaction construction
435 // TODO(dual_funding): Add spec link for `tx_add_input`.
436 #[derive(Clone, Debug, PartialEq, Eq)]
437 pub struct TxAddInput {
439 pub channel_id: [u8; 32],
440 /// A randomly chosen unique identifier for this input, which is even for initiators and odd for
443 /// Serialized transaction that contains the output this input spends to verify that it is non
445 pub prevtx: TransactionU16LenLimited,
446 /// The index of the output being spent
448 /// The sequence number of this input
452 /// A tx_add_output message for adding an output during interactive transaction construction.
454 // TODO(dual_funding): Add spec link for `tx_add_output`.
455 #[derive(Clone, Debug, PartialEq, Eq)]
456 pub struct TxAddOutput {
458 pub channel_id: [u8; 32],
459 /// A randomly chosen unique identifier for this output, which is even for initiators and odd for
462 /// The satoshi value of the output
464 /// The scriptPubKey for the output
468 /// A tx_remove_input message for removing an input during interactive transaction construction.
470 // TODO(dual_funding): Add spec link for `tx_remove_input`.
471 #[derive(Clone, Debug, PartialEq, Eq)]
472 pub struct TxRemoveInput {
474 pub channel_id: [u8; 32],
475 /// The serial ID of the input to be removed
479 /// A tx_remove_output message for removing an output during interactive transaction construction.
481 // TODO(dual_funding): Add spec link for `tx_remove_output`.
482 #[derive(Clone, Debug, PartialEq, Eq)]
483 pub struct TxRemoveOutput {
485 pub channel_id: [u8; 32],
486 /// The serial ID of the output to be removed
490 /// A tx_complete message signalling the conclusion of a peer's transaction contributions during
491 /// interactive transaction construction.
493 // TODO(dual_funding): Add spec link for `tx_complete`.
494 #[derive(Clone, Debug, PartialEq, Eq)]
495 pub struct TxComplete {
497 pub channel_id: [u8; 32],
500 /// A tx_signatures message containing the sender's signatures for a transaction constructed with
501 /// interactive transaction construction.
503 // TODO(dual_funding): Add spec link for `tx_signatures`.
504 #[derive(Clone, Debug, PartialEq, Eq)]
505 pub struct TxSignatures {
507 pub channel_id: [u8; 32],
510 /// The list of witnesses
511 pub witnesses: Vec<Witness>,
514 /// A tx_init_rbf message which initiates a replacement of the transaction after it's been
517 // TODO(dual_funding): Add spec link for `tx_init_rbf`.
518 #[derive(Clone, Debug, PartialEq, Eq)]
519 pub struct TxInitRbf {
521 pub channel_id: [u8; 32],
522 /// The locktime of the transaction
524 /// The feerate of the transaction
525 pub feerate_sat_per_1000_weight: u32,
526 /// The number of satoshis the sender will contribute to or, if negative, remove from
527 /// (e.g. splice-out) the funding output of the transaction
528 pub funding_output_contribution: Option<i64>,
531 /// A tx_ack_rbf message which acknowledges replacement of the transaction after it's been
534 // TODO(dual_funding): Add spec link for `tx_ack_rbf`.
535 #[derive(Clone, Debug, PartialEq, Eq)]
536 pub struct TxAckRbf {
538 pub channel_id: [u8; 32],
539 /// The number of satoshis the sender will contribute to or, if negative, remove from
540 /// (e.g. splice-out) the funding output of the transaction
541 pub funding_output_contribution: Option<i64>,
544 /// A tx_abort message which signals the cancellation of an in-progress transaction negotiation.
546 // TODO(dual_funding): Add spec link for `tx_abort`.
547 #[derive(Clone, Debug, PartialEq, Eq)]
550 pub channel_id: [u8; 32],
555 /// A [`shutdown`] message to be sent to or received from a peer.
557 /// [`shutdown`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-initiation-shutdown
558 #[derive(Clone, Debug, PartialEq, Eq)]
559 pub struct Shutdown {
561 pub channel_id: [u8; 32],
562 /// The destination of this peer's funds on closing.
564 /// Must be in one of these forms: P2PKH, P2SH, P2WPKH, P2WSH, P2TR.
565 pub scriptpubkey: Script,
568 /// The minimum and maximum fees which the sender is willing to place on the closing transaction.
570 /// This is provided in [`ClosingSigned`] by both sides to indicate the fee range they are willing
572 #[derive(Clone, Debug, PartialEq, Eq)]
573 pub struct ClosingSignedFeeRange {
574 /// The minimum absolute fee, in satoshis, which the sender is willing to place on the closing
576 pub min_fee_satoshis: u64,
577 /// The maximum absolute fee, in satoshis, which the sender is willing to place on the closing
579 pub max_fee_satoshis: u64,
582 /// A [`closing_signed`] message to be sent to or received from a peer.
584 /// [`closing_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-negotiation-closing_signed
585 #[derive(Clone, Debug, PartialEq, Eq)]
586 pub struct ClosingSigned {
588 pub channel_id: [u8; 32],
589 /// The proposed total fee for the closing transaction
590 pub fee_satoshis: u64,
591 /// A signature on the closing transaction
592 pub signature: Signature,
593 /// The minimum and maximum fees which the sender is willing to accept, provided only by new
595 pub fee_range: Option<ClosingSignedFeeRange>,
598 /// An [`update_add_htlc`] message to be sent to or received from a peer.
600 /// [`update_add_htlc`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#adding-an-htlc-update_add_htlc
601 #[derive(Clone, Debug, PartialEq, Eq)]
602 pub struct UpdateAddHTLC {
604 pub channel_id: [u8; 32],
607 /// The HTLC value in milli-satoshi
608 pub amount_msat: u64,
609 /// The payment hash, the pre-image of which controls HTLC redemption
610 pub payment_hash: PaymentHash,
611 /// The expiry height of the HTLC
612 pub cltv_expiry: u32,
613 /// The extra fee skimmed by the sender of this message. See
614 /// [`ChannelConfig::accept_underpaying_htlcs`].
616 /// [`ChannelConfig::accept_underpaying_htlcs`]: crate::util::config::ChannelConfig::accept_underpaying_htlcs
617 pub skimmed_fee_msat: Option<u64>,
618 pub(crate) onion_routing_packet: OnionPacket,
621 /// An onion message to be sent to or received from a peer.
623 // TODO: update with link to OM when they are merged into the BOLTs
624 #[derive(Clone, Debug, PartialEq, Eq)]
625 pub struct OnionMessage {
626 /// Used in decrypting the onion packet's payload.
627 pub blinding_point: PublicKey,
628 pub(crate) onion_routing_packet: onion_message::Packet,
631 /// An [`update_fulfill_htlc`] message to be sent to or received from a peer.
633 /// [`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
634 #[derive(Clone, Debug, PartialEq, Eq)]
635 pub struct UpdateFulfillHTLC {
637 pub channel_id: [u8; 32],
640 /// The pre-image of the payment hash, allowing HTLC redemption
641 pub payment_preimage: PaymentPreimage,
644 /// An [`update_fail_htlc`] message to be sent to or received from a peer.
646 /// [`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
647 #[derive(Clone, Debug, PartialEq, Eq)]
648 pub struct UpdateFailHTLC {
650 pub channel_id: [u8; 32],
653 pub(crate) reason: OnionErrorPacket,
656 /// An [`update_fail_malformed_htlc`] message to be sent to or received from a peer.
658 /// [`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
659 #[derive(Clone, Debug, PartialEq, Eq)]
660 pub struct UpdateFailMalformedHTLC {
662 pub channel_id: [u8; 32],
665 pub(crate) sha256_of_onion: [u8; 32],
667 pub failure_code: u16,
670 /// A [`commitment_signed`] message to be sent to or received from a peer.
672 /// [`commitment_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#committing-updates-so-far-commitment_signed
673 #[derive(Clone, Debug, PartialEq, Eq)]
674 pub struct CommitmentSigned {
676 pub channel_id: [u8; 32],
677 /// A signature on the commitment transaction
678 pub signature: Signature,
679 /// Signatures on the HTLC transactions
680 pub htlc_signatures: Vec<Signature>,
682 /// The partial Taproot signature on the commitment transaction
683 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
686 /// A [`revoke_and_ack`] message to be sent to or received from a peer.
688 /// [`revoke_and_ack`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#completing-the-transition-to-the-updated-state-revoke_and_ack
689 #[derive(Clone, Debug, PartialEq, Eq)]
690 pub struct RevokeAndACK {
692 pub channel_id: [u8; 32],
693 /// The secret corresponding to the per-commitment point
694 pub per_commitment_secret: [u8; 32],
695 /// The next sender-broadcast commitment transaction's per-commitment point
696 pub next_per_commitment_point: PublicKey,
698 /// Musig nonce the recipient should use in their next commitment signature message
699 pub next_local_nonce: Option<musig2::types::PublicNonce>
702 /// An [`update_fee`] message to be sent to or received from a peer
704 /// [`update_fee`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#updating-fees-update_fee
705 #[derive(Clone, Debug, PartialEq, Eq)]
706 pub struct UpdateFee {
708 pub channel_id: [u8; 32],
709 /// Fee rate per 1000-weight of the transaction
710 pub feerate_per_kw: u32,
713 /// A [`channel_reestablish`] message to be sent to or received from a peer.
715 /// [`channel_reestablish`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#message-retransmission
716 #[derive(Clone, Debug, PartialEq, Eq)]
717 pub struct ChannelReestablish {
719 pub channel_id: [u8; 32],
720 /// The next commitment number for the sender
721 pub next_local_commitment_number: u64,
722 /// The next commitment number for the recipient
723 pub next_remote_commitment_number: u64,
724 /// Proof that the sender knows the per-commitment secret of a specific commitment transaction
725 /// belonging to the recipient
726 pub your_last_per_commitment_secret: [u8; 32],
727 /// The sender's per-commitment point for their current commitment transaction
728 pub my_current_per_commitment_point: PublicKey,
729 /// The next funding transaction ID
730 pub next_funding_txid: Option<Txid>,
733 /// An [`announcement_signatures`] message to be sent to or received from a peer.
735 /// [`announcement_signatures`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-announcement_signatures-message
736 #[derive(Clone, Debug, PartialEq, Eq)]
737 pub struct AnnouncementSignatures {
739 pub channel_id: [u8; 32],
740 /// The short channel ID
741 pub short_channel_id: u64,
742 /// A signature by the node key
743 pub node_signature: Signature,
744 /// A signature by the funding key
745 pub bitcoin_signature: Signature,
748 /// An address which can be used to connect to a remote peer.
749 #[derive(Clone, Debug, PartialEq, Eq)]
750 pub enum NetAddress {
751 /// An IPv4 address/port on which the peer is listening.
753 /// The 4-byte IPv4 address
755 /// The port on which the node is listening
758 /// An IPv6 address/port on which the peer is listening.
760 /// The 16-byte IPv6 address
762 /// The port on which the node is listening
765 /// An old-style Tor onion address/port on which the peer is listening.
767 /// This field is deprecated and the Tor network generally no longer supports V2 Onion
768 /// addresses. Thus, the details are not parsed here.
770 /// A new-style Tor onion address/port on which the peer is listening.
772 /// To create the human-readable "hostname", concatenate the ED25519 pubkey, checksum, and version,
773 /// wrap as base32 and append ".onion".
775 /// The ed25519 long-term public key of the peer
776 ed25519_pubkey: [u8; 32],
777 /// The checksum of the pubkey and version, as included in the onion address
779 /// The version byte, as defined by the Tor Onion v3 spec.
781 /// The port on which the node is listening
784 /// A hostname/port on which the peer is listening.
786 /// The hostname on which the node is listening.
788 /// The port on which the node is listening.
793 /// Gets the ID of this address type. Addresses in [`NodeAnnouncement`] messages should be sorted
795 pub(crate) fn get_id(&self) -> u8 {
797 &NetAddress::IPv4 {..} => { 1 },
798 &NetAddress::IPv6 {..} => { 2 },
799 &NetAddress::OnionV2(_) => { 3 },
800 &NetAddress::OnionV3 {..} => { 4 },
801 &NetAddress::Hostname {..} => { 5 },
805 /// Strict byte-length of address descriptor, 1-byte type not recorded
806 fn len(&self) -> u16 {
808 &NetAddress::IPv4 { .. } => { 6 },
809 &NetAddress::IPv6 { .. } => { 18 },
810 &NetAddress::OnionV2(_) => { 12 },
811 &NetAddress::OnionV3 { .. } => { 37 },
812 // Consists of 1-byte hostname length, hostname bytes, and 2-byte port.
813 &NetAddress::Hostname { ref hostname, .. } => { u16::from(hostname.len()) + 3 },
817 /// The maximum length of any address descriptor, not including the 1-byte type.
818 /// This maximum length is reached by a hostname address descriptor:
819 /// a hostname with a maximum length of 255, its 1-byte length and a 2-byte port.
820 pub(crate) const MAX_LEN: u16 = 258;
823 impl Writeable for NetAddress {
824 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
826 &NetAddress::IPv4 { ref addr, ref port } => {
831 &NetAddress::IPv6 { ref addr, ref port } => {
836 &NetAddress::OnionV2(bytes) => {
838 bytes.write(writer)?;
840 &NetAddress::OnionV3 { ref ed25519_pubkey, ref checksum, ref version, ref port } => {
842 ed25519_pubkey.write(writer)?;
843 checksum.write(writer)?;
844 version.write(writer)?;
847 &NetAddress::Hostname { ref hostname, ref port } => {
849 hostname.write(writer)?;
857 impl Readable for Result<NetAddress, u8> {
858 fn read<R: Read>(reader: &mut R) -> Result<Result<NetAddress, u8>, DecodeError> {
859 let byte = <u8 as Readable>::read(reader)?;
862 Ok(Ok(NetAddress::IPv4 {
863 addr: Readable::read(reader)?,
864 port: Readable::read(reader)?,
868 Ok(Ok(NetAddress::IPv6 {
869 addr: Readable::read(reader)?,
870 port: Readable::read(reader)?,
873 3 => Ok(Ok(NetAddress::OnionV2(Readable::read(reader)?))),
875 Ok(Ok(NetAddress::OnionV3 {
876 ed25519_pubkey: Readable::read(reader)?,
877 checksum: Readable::read(reader)?,
878 version: Readable::read(reader)?,
879 port: Readable::read(reader)?,
883 Ok(Ok(NetAddress::Hostname {
884 hostname: Readable::read(reader)?,
885 port: Readable::read(reader)?,
888 _ => return Ok(Err(byte)),
893 impl Readable for NetAddress {
894 fn read<R: Read>(reader: &mut R) -> Result<NetAddress, DecodeError> {
895 match Readable::read(reader) {
896 Ok(Ok(res)) => Ok(res),
897 Ok(Err(_)) => Err(DecodeError::UnknownVersion),
903 /// Represents the set of gossip messages that require a signature from a node's identity key.
904 pub enum UnsignedGossipMessage<'a> {
905 /// An unsigned channel announcement.
906 ChannelAnnouncement(&'a UnsignedChannelAnnouncement),
907 /// An unsigned channel update.
908 ChannelUpdate(&'a UnsignedChannelUpdate),
909 /// An unsigned node announcement.
910 NodeAnnouncement(&'a UnsignedNodeAnnouncement)
913 impl<'a> Writeable for UnsignedGossipMessage<'a> {
914 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
916 UnsignedGossipMessage::ChannelAnnouncement(ref msg) => msg.write(writer),
917 UnsignedGossipMessage::ChannelUpdate(ref msg) => msg.write(writer),
918 UnsignedGossipMessage::NodeAnnouncement(ref msg) => msg.write(writer),
923 /// The unsigned part of a [`node_announcement`] message.
925 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
926 #[derive(Clone, Debug, PartialEq, Eq)]
927 pub struct UnsignedNodeAnnouncement {
928 /// The advertised features
929 pub features: NodeFeatures,
930 /// A strictly monotonic announcement counter, with gaps allowed
932 /// The `node_id` this announcement originated from (don't rebroadcast the `node_announcement` back
935 /// An RGB color for UI purposes
937 /// An alias, for UI purposes.
939 /// This should be sanitized before use. There is no guarantee of uniqueness.
940 pub alias: NodeAlias,
941 /// List of addresses on which this node is reachable
942 pub addresses: Vec<NetAddress>,
943 pub(crate) excess_address_data: Vec<u8>,
944 pub(crate) excess_data: Vec<u8>,
946 #[derive(Clone, Debug, PartialEq, Eq)]
947 /// A [`node_announcement`] message to be sent to or received from a peer.
949 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
950 pub struct NodeAnnouncement {
951 /// The signature by the node key
952 pub signature: Signature,
953 /// The actual content of the announcement
954 pub contents: UnsignedNodeAnnouncement,
957 /// The unsigned part of a [`channel_announcement`] message.
959 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
960 #[derive(Clone, Debug, PartialEq, Eq)]
961 pub struct UnsignedChannelAnnouncement {
962 /// The advertised channel features
963 pub features: ChannelFeatures,
964 /// The genesis hash of the blockchain where the channel is to be opened
965 pub chain_hash: BlockHash,
966 /// The short channel ID
967 pub short_channel_id: u64,
968 /// One of the two `node_id`s which are endpoints of this channel
969 pub node_id_1: NodeId,
970 /// The other of the two `node_id`s which are endpoints of this channel
971 pub node_id_2: NodeId,
972 /// The funding key for the first node
973 pub bitcoin_key_1: NodeId,
974 /// The funding key for the second node
975 pub bitcoin_key_2: NodeId,
976 pub(crate) excess_data: Vec<u8>,
978 /// A [`channel_announcement`] message to be sent to or received from a peer.
980 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
981 #[derive(Clone, Debug, PartialEq, Eq)]
982 pub struct ChannelAnnouncement {
983 /// Authentication of the announcement by the first public node
984 pub node_signature_1: Signature,
985 /// Authentication of the announcement by the second public node
986 pub node_signature_2: Signature,
987 /// Proof of funding UTXO ownership by the first public node
988 pub bitcoin_signature_1: Signature,
989 /// Proof of funding UTXO ownership by the second public node
990 pub bitcoin_signature_2: Signature,
991 /// The actual announcement
992 pub contents: UnsignedChannelAnnouncement,
995 /// The unsigned part of a [`channel_update`] message.
997 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
998 #[derive(Clone, Debug, PartialEq, Eq)]
999 pub struct UnsignedChannelUpdate {
1000 /// The genesis hash of the blockchain where the channel is to be opened
1001 pub chain_hash: BlockHash,
1002 /// The short channel ID
1003 pub short_channel_id: u64,
1004 /// A strictly monotonic announcement counter, with gaps allowed, specific to this channel
1008 /// The number of blocks such that if:
1009 /// `incoming_htlc.cltv_expiry < outgoing_htlc.cltv_expiry + cltv_expiry_delta`
1010 /// then we need to fail the HTLC backwards. When forwarding an HTLC, `cltv_expiry_delta` determines
1011 /// the outgoing HTLC's minimum `cltv_expiry` value -- so, if an incoming HTLC comes in with a
1012 /// `cltv_expiry` of 100000, and the node we're forwarding to has a `cltv_expiry_delta` value of 10,
1013 /// then we'll check that the outgoing HTLC's `cltv_expiry` value is at least 100010 before
1014 /// forwarding. Note that the HTLC sender is the one who originally sets this value when
1015 /// constructing the route.
1016 pub cltv_expiry_delta: u16,
1017 /// The minimum HTLC size incoming to sender, in milli-satoshi
1018 pub htlc_minimum_msat: u64,
1019 /// The maximum HTLC value incoming to sender, in milli-satoshi.
1021 /// This used to be optional.
1022 pub htlc_maximum_msat: u64,
1023 /// The base HTLC fee charged by sender, in milli-satoshi
1024 pub fee_base_msat: u32,
1025 /// The amount to fee multiplier, in micro-satoshi
1026 pub fee_proportional_millionths: u32,
1027 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1030 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1031 pub excess_data: Vec<u8>,
1033 /// A [`channel_update`] message to be sent to or received from a peer.
1035 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1036 #[derive(Clone, Debug, PartialEq, Eq)]
1037 pub struct ChannelUpdate {
1038 /// A signature of the channel update
1039 pub signature: Signature,
1040 /// The actual channel update
1041 pub contents: UnsignedChannelUpdate,
1044 /// A [`query_channel_range`] message is used to query a peer for channel
1045 /// UTXOs in a range of blocks. The recipient of a query makes a best
1046 /// effort to reply to the query using one or more [`ReplyChannelRange`]
1049 /// [`query_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1050 #[derive(Clone, Debug, PartialEq, Eq)]
1051 pub struct QueryChannelRange {
1052 /// The genesis hash of the blockchain being queried
1053 pub chain_hash: BlockHash,
1054 /// The height of the first block for the channel UTXOs being queried
1055 pub first_blocknum: u32,
1056 /// The number of blocks to include in the query results
1057 pub number_of_blocks: u32,
1060 /// A [`reply_channel_range`] message is a reply to a [`QueryChannelRange`]
1063 /// Multiple `reply_channel_range` messages can be sent in reply
1064 /// to a single [`QueryChannelRange`] message. The query recipient makes a
1065 /// best effort to respond based on their local network view which may
1066 /// not be a perfect view of the network. The `short_channel_id`s in the
1067 /// reply are encoded. We only support `encoding_type=0` uncompressed
1068 /// serialization and do not support `encoding_type=1` zlib serialization.
1070 /// [`reply_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1071 #[derive(Clone, Debug, PartialEq, Eq)]
1072 pub struct ReplyChannelRange {
1073 /// The genesis hash of the blockchain being queried
1074 pub chain_hash: BlockHash,
1075 /// The height of the first block in the range of the reply
1076 pub first_blocknum: u32,
1077 /// The number of blocks included in the range of the reply
1078 pub number_of_blocks: u32,
1079 /// True when this is the final reply for a query
1080 pub sync_complete: bool,
1081 /// The `short_channel_id`s in the channel range
1082 pub short_channel_ids: Vec<u64>,
1085 /// A [`query_short_channel_ids`] message is used to query a peer for
1086 /// routing gossip messages related to one or more `short_channel_id`s.
1088 /// The query recipient will reply with the latest, if available,
1089 /// [`ChannelAnnouncement`], [`ChannelUpdate`] and [`NodeAnnouncement`] messages
1090 /// it maintains for the requested `short_channel_id`s followed by a
1091 /// [`ReplyShortChannelIdsEnd`] message. The `short_channel_id`s sent in
1092 /// this query are encoded. We only support `encoding_type=0` uncompressed
1093 /// serialization and do not support `encoding_type=1` zlib serialization.
1095 /// [`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
1096 #[derive(Clone, Debug, PartialEq, Eq)]
1097 pub struct QueryShortChannelIds {
1098 /// The genesis hash of the blockchain being queried
1099 pub chain_hash: BlockHash,
1100 /// The short_channel_ids that are being queried
1101 pub short_channel_ids: Vec<u64>,
1104 /// A [`reply_short_channel_ids_end`] message is sent as a reply to a
1105 /// message. The query recipient makes a best
1106 /// effort to respond based on their local network view which may not be
1107 /// a perfect view of the network.
1109 /// [`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
1110 #[derive(Clone, Debug, PartialEq, Eq)]
1111 pub struct ReplyShortChannelIdsEnd {
1112 /// The genesis hash of the blockchain that was queried
1113 pub chain_hash: BlockHash,
1114 /// Indicates if the query recipient maintains up-to-date channel
1115 /// information for the `chain_hash`
1116 pub full_information: bool,
1119 /// A [`gossip_timestamp_filter`] message is used by a node to request
1120 /// gossip relay for messages in the requested time range when the
1121 /// `gossip_queries` feature has been negotiated.
1123 /// [`gossip_timestamp_filter`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-gossip_timestamp_filter-message
1124 #[derive(Clone, Debug, PartialEq, Eq)]
1125 pub struct GossipTimestampFilter {
1126 /// The genesis hash of the blockchain for channel and node information
1127 pub chain_hash: BlockHash,
1128 /// The starting unix timestamp
1129 pub first_timestamp: u32,
1130 /// The range of information in seconds
1131 pub timestamp_range: u32,
1134 /// Encoding type for data compression of collections in gossip queries.
1136 /// We do not support `encoding_type=1` zlib serialization [defined in BOLT
1137 /// #7](https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#query-messages).
1139 Uncompressed = 0x00,
1142 /// Used to put an error message in a [`LightningError`].
1143 #[derive(Clone, Debug)]
1144 pub enum ErrorAction {
1145 /// The peer took some action which made us think they were useless. Disconnect them.
1147 /// An error message which we should make an effort to send before we disconnect.
1148 msg: Option<ErrorMessage>
1150 /// The peer did something incorrect. Tell them without closing any channels and disconnect them.
1151 DisconnectPeerWithWarning {
1152 /// A warning message which we should make an effort to send before we disconnect.
1153 msg: WarningMessage,
1155 /// The peer did something harmless that we weren't able to process, just log and ignore
1156 // New code should *not* use this. New code must use IgnoreAndLog, below!
1158 /// The peer did something harmless that we weren't able to meaningfully process.
1159 /// If the error is logged, log it at the given level.
1160 IgnoreAndLog(logger::Level),
1161 /// The peer provided us with a gossip message which we'd already seen. In most cases this
1162 /// should be ignored, but it may result in the message being forwarded if it is a duplicate of
1163 /// our own channel announcements.
1164 IgnoreDuplicateGossip,
1165 /// The peer did something incorrect. Tell them.
1167 /// The message to send.
1170 /// The peer did something incorrect. Tell them without closing any channels.
1171 SendWarningMessage {
1172 /// The message to send.
1173 msg: WarningMessage,
1174 /// The peer may have done something harmless that we weren't able to meaningfully process,
1175 /// though we should still tell them about it.
1176 /// If this event is logged, log it at the given level.
1177 log_level: logger::Level,
1181 /// An Err type for failure to process messages.
1182 #[derive(Clone, Debug)]
1183 pub struct LightningError {
1184 /// A human-readable message describing the error
1186 /// The action which should be taken against the offending peer.
1187 pub action: ErrorAction,
1190 /// Struct used to return values from [`RevokeAndACK`] messages, containing a bunch of commitment
1191 /// transaction updates if they were pending.
1192 #[derive(Clone, Debug, PartialEq, Eq)]
1193 pub struct CommitmentUpdate {
1194 /// `update_add_htlc` messages which should be sent
1195 pub update_add_htlcs: Vec<UpdateAddHTLC>,
1196 /// `update_fulfill_htlc` messages which should be sent
1197 pub update_fulfill_htlcs: Vec<UpdateFulfillHTLC>,
1198 /// `update_fail_htlc` messages which should be sent
1199 pub update_fail_htlcs: Vec<UpdateFailHTLC>,
1200 /// `update_fail_malformed_htlc` messages which should be sent
1201 pub update_fail_malformed_htlcs: Vec<UpdateFailMalformedHTLC>,
1202 /// An `update_fee` message which should be sent
1203 pub update_fee: Option<UpdateFee>,
1204 /// A `commitment_signed` message which should be sent
1205 pub commitment_signed: CommitmentSigned,
1208 /// A trait to describe an object which can receive channel messages.
1210 /// Messages MAY be called in parallel when they originate from different `their_node_ids`, however
1211 /// they MUST NOT be called in parallel when the two calls have the same `their_node_id`.
1212 pub trait ChannelMessageHandler : MessageSendEventsProvider {
1214 /// Handle an incoming `open_channel` message from the given peer.
1215 fn handle_open_channel(&self, their_node_id: &PublicKey, msg: &OpenChannel);
1216 /// Handle an incoming `open_channel2` message from the given peer.
1217 fn handle_open_channel_v2(&self, their_node_id: &PublicKey, msg: &OpenChannelV2);
1218 /// Handle an incoming `accept_channel` message from the given peer.
1219 fn handle_accept_channel(&self, their_node_id: &PublicKey, msg: &AcceptChannel);
1220 /// Handle an incoming `accept_channel2` message from the given peer.
1221 fn handle_accept_channel_v2(&self, their_node_id: &PublicKey, msg: &AcceptChannelV2);
1222 /// Handle an incoming `funding_created` message from the given peer.
1223 fn handle_funding_created(&self, their_node_id: &PublicKey, msg: &FundingCreated);
1224 /// Handle an incoming `funding_signed` message from the given peer.
1225 fn handle_funding_signed(&self, their_node_id: &PublicKey, msg: &FundingSigned);
1226 /// Handle an incoming `channel_ready` message from the given peer.
1227 fn handle_channel_ready(&self, their_node_id: &PublicKey, msg: &ChannelReady);
1230 /// Handle an incoming `shutdown` message from the given peer.
1231 fn handle_shutdown(&self, their_node_id: &PublicKey, msg: &Shutdown);
1232 /// Handle an incoming `closing_signed` message from the given peer.
1233 fn handle_closing_signed(&self, their_node_id: &PublicKey, msg: &ClosingSigned);
1235 // Interactive channel construction
1236 /// Handle an incoming `tx_add_input message` from the given peer.
1237 fn handle_tx_add_input(&self, their_node_id: &PublicKey, msg: &TxAddInput);
1238 /// Handle an incoming `tx_add_output` message from the given peer.
1239 fn handle_tx_add_output(&self, their_node_id: &PublicKey, msg: &TxAddOutput);
1240 /// Handle an incoming `tx_remove_input` message from the given peer.
1241 fn handle_tx_remove_input(&self, their_node_id: &PublicKey, msg: &TxRemoveInput);
1242 /// Handle an incoming `tx_remove_output` message from the given peer.
1243 fn handle_tx_remove_output(&self, their_node_id: &PublicKey, msg: &TxRemoveOutput);
1244 /// Handle an incoming `tx_complete message` from the given peer.
1245 fn handle_tx_complete(&self, their_node_id: &PublicKey, msg: &TxComplete);
1246 /// Handle an incoming `tx_signatures` message from the given peer.
1247 fn handle_tx_signatures(&self, their_node_id: &PublicKey, msg: &TxSignatures);
1248 /// Handle an incoming `tx_init_rbf` message from the given peer.
1249 fn handle_tx_init_rbf(&self, their_node_id: &PublicKey, msg: &TxInitRbf);
1250 /// Handle an incoming `tx_ack_rbf` message from the given peer.
1251 fn handle_tx_ack_rbf(&self, their_node_id: &PublicKey, msg: &TxAckRbf);
1252 /// Handle an incoming `tx_abort message` from the given peer.
1253 fn handle_tx_abort(&self, their_node_id: &PublicKey, msg: &TxAbort);
1256 /// Handle an incoming `update_add_htlc` message from the given peer.
1257 fn handle_update_add_htlc(&self, their_node_id: &PublicKey, msg: &UpdateAddHTLC);
1258 /// Handle an incoming `update_fulfill_htlc` message from the given peer.
1259 fn handle_update_fulfill_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFulfillHTLC);
1260 /// Handle an incoming `update_fail_htlc` message from the given peer.
1261 fn handle_update_fail_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailHTLC);
1262 /// Handle an incoming `update_fail_malformed_htlc` message from the given peer.
1263 fn handle_update_fail_malformed_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailMalformedHTLC);
1264 /// Handle an incoming `commitment_signed` message from the given peer.
1265 fn handle_commitment_signed(&self, their_node_id: &PublicKey, msg: &CommitmentSigned);
1266 /// Handle an incoming `revoke_and_ack` message from the given peer.
1267 fn handle_revoke_and_ack(&self, their_node_id: &PublicKey, msg: &RevokeAndACK);
1269 /// Handle an incoming `update_fee` message from the given peer.
1270 fn handle_update_fee(&self, their_node_id: &PublicKey, msg: &UpdateFee);
1272 // Channel-to-announce:
1273 /// Handle an incoming `announcement_signatures` message from the given peer.
1274 fn handle_announcement_signatures(&self, their_node_id: &PublicKey, msg: &AnnouncementSignatures);
1276 // Connection loss/reestablish:
1277 /// Indicates a connection to the peer failed/an existing connection was lost.
1278 fn peer_disconnected(&self, their_node_id: &PublicKey);
1280 /// Handle a peer reconnecting, possibly generating `channel_reestablish` message(s).
1282 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1283 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1284 /// message handlers may still wish to communicate with this peer.
1285 fn peer_connected(&self, their_node_id: &PublicKey, msg: &Init, inbound: bool) -> Result<(), ()>;
1286 /// Handle an incoming `channel_reestablish` message from the given peer.
1287 fn handle_channel_reestablish(&self, their_node_id: &PublicKey, msg: &ChannelReestablish);
1289 /// Handle an incoming `channel_update` message from the given peer.
1290 fn handle_channel_update(&self, their_node_id: &PublicKey, msg: &ChannelUpdate);
1293 /// Handle an incoming `error` message from the given peer.
1294 fn handle_error(&self, their_node_id: &PublicKey, msg: &ErrorMessage);
1296 // Handler information:
1297 /// Gets the node feature flags which this handler itself supports. All available handlers are
1298 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1299 /// which are broadcasted in our [`NodeAnnouncement`] message.
1300 fn provided_node_features(&self) -> NodeFeatures;
1302 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1303 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1304 /// which are sent in our [`Init`] message.
1306 /// Note that this method is called before [`Self::peer_connected`].
1307 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1309 /// Gets the genesis hashes for this `ChannelMessageHandler` indicating which chains it supports.
1311 /// If it's `None`, then no particular network chain hash compatibility will be enforced when
1312 /// connecting to peers.
1313 fn get_genesis_hashes(&self) -> Option<Vec<ChainHash>>;
1316 /// A trait to describe an object which can receive routing messages.
1318 /// # Implementor DoS Warnings
1320 /// For messages enabled with the `gossip_queries` feature there are potential DoS vectors when
1321 /// handling inbound queries. Implementors using an on-disk network graph should be aware of
1322 /// repeated disk I/O for queries accessing different parts of the network graph.
1323 pub trait RoutingMessageHandler : MessageSendEventsProvider {
1324 /// Handle an incoming `node_announcement` message, returning `true` if it should be forwarded on,
1325 /// `false` or returning an `Err` otherwise.
1326 fn handle_node_announcement(&self, msg: &NodeAnnouncement) -> Result<bool, LightningError>;
1327 /// Handle a `channel_announcement` message, returning `true` if it should be forwarded on, `false`
1328 /// or returning an `Err` otherwise.
1329 fn handle_channel_announcement(&self, msg: &ChannelAnnouncement) -> Result<bool, LightningError>;
1330 /// Handle an incoming `channel_update` message, returning true if it should be forwarded on,
1331 /// `false` or returning an `Err` otherwise.
1332 fn handle_channel_update(&self, msg: &ChannelUpdate) -> Result<bool, LightningError>;
1333 /// Gets channel announcements and updates required to dump our routing table to a remote node,
1334 /// starting at the `short_channel_id` indicated by `starting_point` and including announcements
1335 /// for a single channel.
1336 fn get_next_channel_announcement(&self, starting_point: u64) -> Option<(ChannelAnnouncement, Option<ChannelUpdate>, Option<ChannelUpdate>)>;
1337 /// Gets a node announcement required to dump our routing table to a remote node, starting at
1338 /// the node *after* the provided pubkey and including up to one announcement immediately
1339 /// higher (as defined by `<PublicKey as Ord>::cmp`) than `starting_point`.
1340 /// If `None` is provided for `starting_point`, we start at the first node.
1341 fn get_next_node_announcement(&self, starting_point: Option<&NodeId>) -> Option<NodeAnnouncement>;
1342 /// Called when a connection is established with a peer. This can be used to
1343 /// perform routing table synchronization using a strategy defined by the
1346 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1347 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1348 /// message handlers may still wish to communicate with this peer.
1349 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1350 /// Handles the reply of a query we initiated to learn about channels
1351 /// for a given range of blocks. We can expect to receive one or more
1352 /// replies to a single query.
1353 fn handle_reply_channel_range(&self, their_node_id: &PublicKey, msg: ReplyChannelRange) -> Result<(), LightningError>;
1354 /// Handles the reply of a query we initiated asking for routing gossip
1355 /// messages for a list of channels. We should receive this message when
1356 /// a node has completed its best effort to send us the pertaining routing
1357 /// gossip messages.
1358 fn handle_reply_short_channel_ids_end(&self, their_node_id: &PublicKey, msg: ReplyShortChannelIdsEnd) -> Result<(), LightningError>;
1359 /// Handles when a peer asks us to send a list of `short_channel_id`s
1360 /// for the requested range of blocks.
1361 fn handle_query_channel_range(&self, their_node_id: &PublicKey, msg: QueryChannelRange) -> Result<(), LightningError>;
1362 /// Handles when a peer asks us to send routing gossip messages for a
1363 /// list of `short_channel_id`s.
1364 fn handle_query_short_channel_ids(&self, their_node_id: &PublicKey, msg: QueryShortChannelIds) -> Result<(), LightningError>;
1366 // Handler queueing status:
1367 /// Indicates that there are a large number of [`ChannelAnnouncement`] (or other) messages
1368 /// pending some async action. While there is no guarantee of the rate of future messages, the
1369 /// caller should seek to reduce the rate of new gossip messages handled, especially
1370 /// [`ChannelAnnouncement`]s.
1371 fn processing_queue_high(&self) -> bool;
1373 // Handler information:
1374 /// Gets the node feature flags which this handler itself supports. All available handlers are
1375 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1376 /// which are broadcasted in our [`NodeAnnouncement`] message.
1377 fn provided_node_features(&self) -> NodeFeatures;
1378 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1379 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1380 /// which are sent in our [`Init`] message.
1382 /// Note that this method is called before [`Self::peer_connected`].
1383 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1386 /// A trait to describe an object that can receive onion messages.
1387 pub trait OnionMessageHandler : OnionMessageProvider {
1388 /// Handle an incoming `onion_message` message from the given peer.
1389 fn handle_onion_message(&self, peer_node_id: &PublicKey, msg: &OnionMessage);
1390 /// Called when a connection is established with a peer. Can be used to track which peers
1391 /// advertise onion message support and are online.
1393 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1394 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1395 /// message handlers may still wish to communicate with this peer.
1396 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1397 /// Indicates a connection to the peer failed/an existing connection was lost. Allows handlers to
1398 /// drop and refuse to forward onion messages to this peer.
1399 fn peer_disconnected(&self, their_node_id: &PublicKey);
1401 // Handler information:
1402 /// Gets the node feature flags which this handler itself supports. All available handlers are
1403 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1404 /// which are broadcasted in our [`NodeAnnouncement`] message.
1405 fn provided_node_features(&self) -> NodeFeatures;
1407 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1408 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1409 /// which are sent in our [`Init`] message.
1411 /// Note that this method is called before [`Self::peer_connected`].
1412 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1415 mod fuzzy_internal_msgs {
1416 use crate::prelude::*;
1417 use crate::ln::{PaymentPreimage, PaymentSecret};
1419 // These types aren't intended to be pub, but are exposed for direct fuzzing (as we deserialize
1420 // them from untrusted input):
1422 pub(crate) struct FinalOnionHopData {
1423 pub(crate) payment_secret: PaymentSecret,
1424 /// The total value, in msat, of the payment as received by the ultimate recipient.
1425 /// Message serialization may panic if this value is more than 21 million Bitcoin.
1426 pub(crate) total_msat: u64,
1429 pub(crate) enum OnionHopDataFormat {
1431 short_channel_id: u64,
1434 payment_data: Option<FinalOnionHopData>,
1435 payment_metadata: Option<Vec<u8>>,
1436 keysend_preimage: Option<PaymentPreimage>,
1440 pub struct OnionHopData {
1441 pub(crate) format: OnionHopDataFormat,
1442 /// The value, in msat, of the payment after this hop's fee is deducted.
1443 pub(crate) amt_to_forward: u64,
1444 pub(crate) outgoing_cltv_value: u32,
1447 pub struct DecodedOnionErrorPacket {
1448 pub(crate) hmac: [u8; 32],
1449 pub(crate) failuremsg: Vec<u8>,
1450 pub(crate) pad: Vec<u8>,
1454 pub use self::fuzzy_internal_msgs::*;
1455 #[cfg(not(fuzzing))]
1456 pub(crate) use self::fuzzy_internal_msgs::*;
1459 pub(crate) struct OnionPacket {
1460 pub(crate) version: u8,
1461 /// In order to ensure we always return an error on onion decode in compliance with [BOLT
1462 /// #4](https://github.com/lightning/bolts/blob/master/04-onion-routing.md), we have to
1463 /// deserialize `OnionPacket`s contained in [`UpdateAddHTLC`] messages even if the ephemeral
1464 /// public key (here) is bogus, so we hold a [`Result`] instead of a [`PublicKey`] as we'd
1466 pub(crate) public_key: Result<PublicKey, secp256k1::Error>,
1467 pub(crate) hop_data: [u8; 20*65],
1468 pub(crate) hmac: [u8; 32],
1471 impl onion_utils::Packet for OnionPacket {
1472 type Data = onion_utils::FixedSizeOnionPacket;
1473 fn new(pubkey: PublicKey, hop_data: onion_utils::FixedSizeOnionPacket, hmac: [u8; 32]) -> Self {
1476 public_key: Ok(pubkey),
1477 hop_data: hop_data.0,
1483 impl Eq for OnionPacket { }
1484 impl PartialEq for OnionPacket {
1485 fn eq(&self, other: &OnionPacket) -> bool {
1486 for (i, j) in self.hop_data.iter().zip(other.hop_data.iter()) {
1487 if i != j { return false; }
1489 self.version == other.version &&
1490 self.public_key == other.public_key &&
1491 self.hmac == other.hmac
1495 impl fmt::Debug for OnionPacket {
1496 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1497 f.write_fmt(format_args!("OnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
1501 #[derive(Clone, Debug, PartialEq, Eq)]
1502 pub(crate) struct OnionErrorPacket {
1503 // This really should be a constant size slice, but the spec lets these things be up to 128KB?
1504 // (TODO) We limit it in decode to much lower...
1505 pub(crate) data: Vec<u8>,
1508 impl fmt::Display for DecodeError {
1509 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1511 DecodeError::UnknownVersion => f.write_str("Unknown realm byte in Onion packet"),
1512 DecodeError::UnknownRequiredFeature => f.write_str("Unknown required feature preventing decode"),
1513 DecodeError::InvalidValue => f.write_str("Nonsense bytes didn't map to the type they were interpreted as"),
1514 DecodeError::ShortRead => f.write_str("Packet extended beyond the provided bytes"),
1515 DecodeError::BadLengthDescriptor => f.write_str("A length descriptor in the packet didn't describe the later data correctly"),
1516 DecodeError::Io(ref e) => fmt::Debug::fmt(e, f),
1517 DecodeError::UnsupportedCompression => f.write_str("We don't support receiving messages with zlib-compressed fields"),
1522 impl From<io::Error> for DecodeError {
1523 fn from(e: io::Error) -> Self {
1524 if e.kind() == io::ErrorKind::UnexpectedEof {
1525 DecodeError::ShortRead
1527 DecodeError::Io(e.kind())
1532 #[cfg(not(taproot))]
1533 impl_writeable_msg!(AcceptChannel, {
1534 temporary_channel_id,
1535 dust_limit_satoshis,
1536 max_htlc_value_in_flight_msat,
1537 channel_reserve_satoshis,
1543 revocation_basepoint,
1545 delayed_payment_basepoint,
1547 first_per_commitment_point,
1549 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1550 (1, channel_type, option),
1554 impl_writeable_msg!(AcceptChannel, {
1555 temporary_channel_id,
1556 dust_limit_satoshis,
1557 max_htlc_value_in_flight_msat,
1558 channel_reserve_satoshis,
1564 revocation_basepoint,
1566 delayed_payment_basepoint,
1568 first_per_commitment_point,
1570 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1571 (1, channel_type, option),
1572 (4, next_local_nonce, option),
1575 impl_writeable_msg!(AcceptChannelV2, {
1576 temporary_channel_id,
1578 dust_limit_satoshis,
1579 max_htlc_value_in_flight_msat,
1585 revocation_basepoint,
1587 delayed_payment_basepoint,
1589 first_per_commitment_point,
1590 second_per_commitment_point,
1592 (0, shutdown_scriptpubkey, option),
1593 (1, channel_type, option),
1594 (2, require_confirmed_inputs, option),
1597 impl_writeable_msg!(TxAddInput, {
1605 impl_writeable_msg!(TxAddOutput, {
1612 impl_writeable_msg!(TxRemoveInput, {
1617 impl_writeable_msg!(TxRemoveOutput, {
1622 impl_writeable_msg!(TxComplete, {
1626 impl_writeable_msg!(TxSignatures, {
1632 impl_writeable_msg!(TxInitRbf, {
1635 feerate_sat_per_1000_weight,
1637 (0, funding_output_contribution, option),
1640 impl_writeable_msg!(TxAckRbf, {
1643 (0, funding_output_contribution, option),
1646 impl_writeable_msg!(TxAbort, {
1651 impl_writeable_msg!(AnnouncementSignatures, {
1658 impl_writeable_msg!(ChannelReestablish, {
1660 next_local_commitment_number,
1661 next_remote_commitment_number,
1662 your_last_per_commitment_secret,
1663 my_current_per_commitment_point,
1665 (0, next_funding_txid, option),
1668 impl_writeable_msg!(ClosingSigned,
1669 { channel_id, fee_satoshis, signature },
1670 { (1, fee_range, option) }
1673 impl_writeable!(ClosingSignedFeeRange, {
1678 #[cfg(not(taproot))]
1679 impl_writeable_msg!(CommitmentSigned, {
1686 impl_writeable_msg!(CommitmentSigned, {
1691 (2, partial_signature_with_nonce, option)
1694 impl_writeable!(DecodedOnionErrorPacket, {
1700 #[cfg(not(taproot))]
1701 impl_writeable_msg!(FundingCreated, {
1702 temporary_channel_id,
1704 funding_output_index,
1708 impl_writeable_msg!(FundingCreated, {
1709 temporary_channel_id,
1711 funding_output_index,
1714 (2, partial_signature_with_nonce, option),
1715 (4, next_local_nonce, option)
1718 #[cfg(not(taproot))]
1719 impl_writeable_msg!(FundingSigned, {
1725 impl_writeable_msg!(FundingSigned, {
1729 (2, partial_signature_with_nonce, option)
1732 impl_writeable_msg!(ChannelReady, {
1734 next_per_commitment_point,
1736 (1, short_channel_id_alias, option),
1739 impl Writeable for Init {
1740 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1741 // global_features gets the bottom 13 bits of our features, and local_features gets all of
1742 // our relevant feature bits. This keeps us compatible with old nodes.
1743 self.features.write_up_to_13(w)?;
1744 self.features.write(w)?;
1745 encode_tlv_stream!(w, {
1746 (1, self.networks.as_ref().map(|n| WithoutLength(n)), option),
1747 (3, self.remote_network_address, option),
1753 impl Readable for Init {
1754 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1755 let global_features: InitFeatures = Readable::read(r)?;
1756 let features: InitFeatures = Readable::read(r)?;
1757 let mut remote_network_address: Option<NetAddress> = None;
1758 let mut networks: Option<WithoutLength<Vec<ChainHash>>> = None;
1759 decode_tlv_stream!(r, {
1760 (1, networks, option),
1761 (3, remote_network_address, option)
1764 features: features | global_features,
1765 networks: networks.map(|n| n.0),
1766 remote_network_address,
1771 impl_writeable_msg!(OpenChannel, {
1773 temporary_channel_id,
1776 dust_limit_satoshis,
1777 max_htlc_value_in_flight_msat,
1778 channel_reserve_satoshis,
1784 revocation_basepoint,
1786 delayed_payment_basepoint,
1788 first_per_commitment_point,
1791 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1792 (1, channel_type, option),
1795 impl_writeable_msg!(OpenChannelV2, {
1797 temporary_channel_id,
1798 funding_feerate_sat_per_1000_weight,
1799 commitment_feerate_sat_per_1000_weight,
1801 dust_limit_satoshis,
1802 max_htlc_value_in_flight_msat,
1808 revocation_basepoint,
1810 delayed_payment_basepoint,
1812 first_per_commitment_point,
1813 second_per_commitment_point,
1816 (0, shutdown_scriptpubkey, option),
1817 (1, channel_type, option),
1818 (2, require_confirmed_inputs, option),
1821 #[cfg(not(taproot))]
1822 impl_writeable_msg!(RevokeAndACK, {
1824 per_commitment_secret,
1825 next_per_commitment_point
1829 impl_writeable_msg!(RevokeAndACK, {
1831 per_commitment_secret,
1832 next_per_commitment_point
1834 (4, next_local_nonce, option)
1837 impl_writeable_msg!(Shutdown, {
1842 impl_writeable_msg!(UpdateFailHTLC, {
1848 impl_writeable_msg!(UpdateFailMalformedHTLC, {
1855 impl_writeable_msg!(UpdateFee, {
1860 impl_writeable_msg!(UpdateFulfillHTLC, {
1866 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
1867 // serialization format in a way which assumes we know the total serialized length/message end
1869 impl_writeable!(OnionErrorPacket, {
1873 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
1874 // serialization format in a way which assumes we know the total serialized length/message end
1876 impl Writeable for OnionPacket {
1877 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1878 self.version.write(w)?;
1879 match self.public_key {
1880 Ok(pubkey) => pubkey.write(w)?,
1881 Err(_) => [0u8;33].write(w)?,
1883 w.write_all(&self.hop_data)?;
1884 self.hmac.write(w)?;
1889 impl Readable for OnionPacket {
1890 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1892 version: Readable::read(r)?,
1894 let mut buf = [0u8;33];
1895 r.read_exact(&mut buf)?;
1896 PublicKey::from_slice(&buf)
1898 hop_data: Readable::read(r)?,
1899 hmac: Readable::read(r)?,
1904 impl_writeable_msg!(UpdateAddHTLC, {
1910 onion_routing_packet,
1912 (65537, skimmed_fee_msat, option)
1915 impl Readable for OnionMessage {
1916 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1917 let blinding_point: PublicKey = Readable::read(r)?;
1918 let len: u16 = Readable::read(r)?;
1919 let mut packet_reader = FixedLengthReader::new(r, len as u64);
1920 let onion_routing_packet: onion_message::Packet = <onion_message::Packet as LengthReadable>::read(&mut packet_reader)?;
1923 onion_routing_packet,
1928 impl Writeable for OnionMessage {
1929 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1930 self.blinding_point.write(w)?;
1931 let onion_packet_len = self.onion_routing_packet.serialized_length();
1932 (onion_packet_len as u16).write(w)?;
1933 self.onion_routing_packet.write(w)?;
1938 impl Writeable for FinalOnionHopData {
1939 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1940 self.payment_secret.0.write(w)?;
1941 HighZeroBytesDroppedBigSize(self.total_msat).write(w)
1945 impl Readable for FinalOnionHopData {
1946 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1947 let secret: [u8; 32] = Readable::read(r)?;
1948 let amt: HighZeroBytesDroppedBigSize<u64> = Readable::read(r)?;
1949 Ok(Self { payment_secret: PaymentSecret(secret), total_msat: amt.0 })
1953 impl Writeable for OnionHopData {
1954 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1956 OnionHopDataFormat::NonFinalNode { short_channel_id } => {
1957 _encode_varint_length_prefixed_tlv!(w, {
1958 (2, HighZeroBytesDroppedBigSize(self.amt_to_forward), required),
1959 (4, HighZeroBytesDroppedBigSize(self.outgoing_cltv_value), required),
1960 (6, short_channel_id, required)
1963 OnionHopDataFormat::FinalNode { ref payment_data, ref payment_metadata, ref keysend_preimage } => {
1964 _encode_varint_length_prefixed_tlv!(w, {
1965 (2, HighZeroBytesDroppedBigSize(self.amt_to_forward), required),
1966 (4, HighZeroBytesDroppedBigSize(self.outgoing_cltv_value), required),
1967 (8, payment_data, option),
1968 (16, payment_metadata.as_ref().map(|m| WithoutLength(m)), option),
1969 (5482373484, keysend_preimage, option)
1977 impl Readable for OnionHopData {
1978 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1979 let mut amt = HighZeroBytesDroppedBigSize(0u64);
1980 let mut cltv_value = HighZeroBytesDroppedBigSize(0u32);
1981 let mut short_id: Option<u64> = None;
1982 let mut payment_data: Option<FinalOnionHopData> = None;
1983 let mut payment_metadata: Option<WithoutLength<Vec<u8>>> = None;
1984 let mut keysend_preimage: Option<PaymentPreimage> = None;
1985 read_tlv_fields!(r, {
1987 (4, cltv_value, required),
1988 (6, short_id, option),
1989 (8, payment_data, option),
1990 (16, payment_metadata, option),
1991 // See https://github.com/lightning/blips/blob/master/blip-0003.md
1992 (5482373484, keysend_preimage, option)
1995 let format = if let Some(short_channel_id) = short_id {
1996 if payment_data.is_some() { return Err(DecodeError::InvalidValue); }
1997 if payment_metadata.is_some() { return Err(DecodeError::InvalidValue); }
1998 OnionHopDataFormat::NonFinalNode {
2002 if let Some(data) = &payment_data {
2003 if data.total_msat > MAX_VALUE_MSAT {
2004 return Err(DecodeError::InvalidValue);
2007 OnionHopDataFormat::FinalNode {
2009 payment_metadata: payment_metadata.map(|w| w.0),
2014 if amt.0 > MAX_VALUE_MSAT {
2015 return Err(DecodeError::InvalidValue);
2019 amt_to_forward: amt.0,
2020 outgoing_cltv_value: cltv_value.0,
2025 // ReadableArgs because we need onion_utils::decode_next_hop to accommodate payment packets and
2026 // onion message packets.
2027 impl ReadableArgs<()> for OnionHopData {
2028 fn read<R: Read>(r: &mut R, _arg: ()) -> Result<Self, DecodeError> {
2029 <Self as Readable>::read(r)
2033 impl Writeable for Ping {
2034 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2035 self.ponglen.write(w)?;
2036 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2041 impl Readable for Ping {
2042 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2044 ponglen: Readable::read(r)?,
2046 let byteslen = Readable::read(r)?;
2047 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2054 impl Writeable for Pong {
2055 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2056 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2061 impl Readable for Pong {
2062 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2065 let byteslen = Readable::read(r)?;
2066 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2073 impl Writeable for UnsignedChannelAnnouncement {
2074 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2075 self.features.write(w)?;
2076 self.chain_hash.write(w)?;
2077 self.short_channel_id.write(w)?;
2078 self.node_id_1.write(w)?;
2079 self.node_id_2.write(w)?;
2080 self.bitcoin_key_1.write(w)?;
2081 self.bitcoin_key_2.write(w)?;
2082 w.write_all(&self.excess_data[..])?;
2087 impl Readable for UnsignedChannelAnnouncement {
2088 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2090 features: Readable::read(r)?,
2091 chain_hash: Readable::read(r)?,
2092 short_channel_id: Readable::read(r)?,
2093 node_id_1: Readable::read(r)?,
2094 node_id_2: Readable::read(r)?,
2095 bitcoin_key_1: Readable::read(r)?,
2096 bitcoin_key_2: Readable::read(r)?,
2097 excess_data: read_to_end(r)?,
2102 impl_writeable!(ChannelAnnouncement, {
2105 bitcoin_signature_1,
2106 bitcoin_signature_2,
2110 impl Writeable for UnsignedChannelUpdate {
2111 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2112 // `message_flags` used to indicate presence of `htlc_maximum_msat`, but was deprecated in the spec.
2113 const MESSAGE_FLAGS: u8 = 1;
2114 self.chain_hash.write(w)?;
2115 self.short_channel_id.write(w)?;
2116 self.timestamp.write(w)?;
2117 let all_flags = self.flags as u16 | ((MESSAGE_FLAGS as u16) << 8);
2118 all_flags.write(w)?;
2119 self.cltv_expiry_delta.write(w)?;
2120 self.htlc_minimum_msat.write(w)?;
2121 self.fee_base_msat.write(w)?;
2122 self.fee_proportional_millionths.write(w)?;
2123 self.htlc_maximum_msat.write(w)?;
2124 w.write_all(&self.excess_data[..])?;
2129 impl Readable for UnsignedChannelUpdate {
2130 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2132 chain_hash: Readable::read(r)?,
2133 short_channel_id: Readable::read(r)?,
2134 timestamp: Readable::read(r)?,
2136 let flags: u16 = Readable::read(r)?;
2137 // Note: we ignore the `message_flags` for now, since it was deprecated by the spec.
2140 cltv_expiry_delta: Readable::read(r)?,
2141 htlc_minimum_msat: Readable::read(r)?,
2142 fee_base_msat: Readable::read(r)?,
2143 fee_proportional_millionths: Readable::read(r)?,
2144 htlc_maximum_msat: Readable::read(r)?,
2145 excess_data: read_to_end(r)?,
2150 impl_writeable!(ChannelUpdate, {
2155 impl Writeable for ErrorMessage {
2156 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2157 self.channel_id.write(w)?;
2158 (self.data.len() as u16).write(w)?;
2159 w.write_all(self.data.as_bytes())?;
2164 impl Readable for ErrorMessage {
2165 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2167 channel_id: Readable::read(r)?,
2169 let sz: usize = <u16 as Readable>::read(r)? as usize;
2170 let mut data = Vec::with_capacity(sz);
2172 r.read_exact(&mut data)?;
2173 match String::from_utf8(data) {
2175 Err(_) => return Err(DecodeError::InvalidValue),
2182 impl Writeable for WarningMessage {
2183 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2184 self.channel_id.write(w)?;
2185 (self.data.len() as u16).write(w)?;
2186 w.write_all(self.data.as_bytes())?;
2191 impl Readable for WarningMessage {
2192 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2194 channel_id: Readable::read(r)?,
2196 let sz: usize = <u16 as Readable>::read(r)? as usize;
2197 let mut data = Vec::with_capacity(sz);
2199 r.read_exact(&mut data)?;
2200 match String::from_utf8(data) {
2202 Err(_) => return Err(DecodeError::InvalidValue),
2209 impl Writeable for UnsignedNodeAnnouncement {
2210 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2211 self.features.write(w)?;
2212 self.timestamp.write(w)?;
2213 self.node_id.write(w)?;
2214 w.write_all(&self.rgb)?;
2215 self.alias.write(w)?;
2217 let mut addr_len = 0;
2218 for addr in self.addresses.iter() {
2219 addr_len += 1 + addr.len();
2221 (addr_len + self.excess_address_data.len() as u16).write(w)?;
2222 for addr in self.addresses.iter() {
2225 w.write_all(&self.excess_address_data[..])?;
2226 w.write_all(&self.excess_data[..])?;
2231 impl Readable for UnsignedNodeAnnouncement {
2232 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2233 let features: NodeFeatures = Readable::read(r)?;
2234 let timestamp: u32 = Readable::read(r)?;
2235 let node_id: NodeId = Readable::read(r)?;
2236 let mut rgb = [0; 3];
2237 r.read_exact(&mut rgb)?;
2238 let alias: NodeAlias = Readable::read(r)?;
2240 let addr_len: u16 = Readable::read(r)?;
2241 let mut addresses: Vec<NetAddress> = Vec::new();
2242 let mut addr_readpos = 0;
2243 let mut excess = false;
2244 let mut excess_byte = 0;
2246 if addr_len <= addr_readpos { break; }
2247 match Readable::read(r) {
2249 if addr_len < addr_readpos + 1 + addr.len() {
2250 return Err(DecodeError::BadLengthDescriptor);
2252 addr_readpos += (1 + addr.len()) as u16;
2253 addresses.push(addr);
2255 Ok(Err(unknown_descriptor)) => {
2257 excess_byte = unknown_descriptor;
2260 Err(DecodeError::ShortRead) => return Err(DecodeError::BadLengthDescriptor),
2261 Err(e) => return Err(e),
2265 let mut excess_data = vec![];
2266 let excess_address_data = if addr_readpos < addr_len {
2267 let mut excess_address_data = vec![0; (addr_len - addr_readpos) as usize];
2268 r.read_exact(&mut excess_address_data[if excess { 1 } else { 0 }..])?;
2270 excess_address_data[0] = excess_byte;
2275 excess_data.push(excess_byte);
2279 excess_data.extend(read_to_end(r)?.iter());
2280 Ok(UnsignedNodeAnnouncement {
2287 excess_address_data,
2293 impl_writeable!(NodeAnnouncement, {
2298 impl Readable for QueryShortChannelIds {
2299 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2300 let chain_hash: BlockHash = Readable::read(r)?;
2302 let encoding_len: u16 = Readable::read(r)?;
2303 let encoding_type: u8 = Readable::read(r)?;
2305 // Must be encoding_type=0 uncompressed serialization. We do not
2306 // support encoding_type=1 zlib serialization.
2307 if encoding_type != EncodingType::Uncompressed as u8 {
2308 return Err(DecodeError::UnsupportedCompression);
2311 // We expect the encoding_len to always includes the 1-byte
2312 // encoding_type and that short_channel_ids are 8-bytes each
2313 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2314 return Err(DecodeError::InvalidValue);
2317 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2318 // less the 1-byte encoding_type
2319 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2320 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2321 for _ in 0..short_channel_id_count {
2322 short_channel_ids.push(Readable::read(r)?);
2325 Ok(QueryShortChannelIds {
2332 impl Writeable for QueryShortChannelIds {
2333 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2334 // Calculated from 1-byte encoding_type plus 8-bytes per short_channel_id
2335 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2337 self.chain_hash.write(w)?;
2338 encoding_len.write(w)?;
2340 // We only support type=0 uncompressed serialization
2341 (EncodingType::Uncompressed as u8).write(w)?;
2343 for scid in self.short_channel_ids.iter() {
2351 impl_writeable_msg!(ReplyShortChannelIdsEnd, {
2356 impl QueryChannelRange {
2357 /// Calculates the overflow safe ending block height for the query.
2359 /// Overflow returns `0xffffffff`, otherwise returns `first_blocknum + number_of_blocks`.
2360 pub fn end_blocknum(&self) -> u32 {
2361 match self.first_blocknum.checked_add(self.number_of_blocks) {
2362 Some(block) => block,
2363 None => u32::max_value(),
2368 impl_writeable_msg!(QueryChannelRange, {
2374 impl Readable for ReplyChannelRange {
2375 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2376 let chain_hash: BlockHash = Readable::read(r)?;
2377 let first_blocknum: u32 = Readable::read(r)?;
2378 let number_of_blocks: u32 = Readable::read(r)?;
2379 let sync_complete: bool = Readable::read(r)?;
2381 let encoding_len: u16 = Readable::read(r)?;
2382 let encoding_type: u8 = Readable::read(r)?;
2384 // Must be encoding_type=0 uncompressed serialization. We do not
2385 // support encoding_type=1 zlib serialization.
2386 if encoding_type != EncodingType::Uncompressed as u8 {
2387 return Err(DecodeError::UnsupportedCompression);
2390 // We expect the encoding_len to always includes the 1-byte
2391 // encoding_type and that short_channel_ids are 8-bytes each
2392 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2393 return Err(DecodeError::InvalidValue);
2396 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2397 // less the 1-byte encoding_type
2398 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2399 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2400 for _ in 0..short_channel_id_count {
2401 short_channel_ids.push(Readable::read(r)?);
2404 Ok(ReplyChannelRange {
2414 impl Writeable for ReplyChannelRange {
2415 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2416 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2417 self.chain_hash.write(w)?;
2418 self.first_blocknum.write(w)?;
2419 self.number_of_blocks.write(w)?;
2420 self.sync_complete.write(w)?;
2422 encoding_len.write(w)?;
2423 (EncodingType::Uncompressed as u8).write(w)?;
2424 for scid in self.short_channel_ids.iter() {
2432 impl_writeable_msg!(GossipTimestampFilter, {
2440 use bitcoin::blockdata::constants::ChainHash;
2441 use bitcoin::{Transaction, PackedLockTime, TxIn, Script, Sequence, Witness, TxOut};
2443 use crate::ln::{PaymentPreimage, PaymentHash, PaymentSecret};
2444 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
2445 use crate::ln::msgs::{self, FinalOnionHopData, OnionErrorPacket, OnionHopDataFormat};
2446 use crate::routing::gossip::{NodeAlias, NodeId};
2447 use crate::util::ser::{Writeable, Readable, Hostname, TransactionU16LenLimited};
2449 use bitcoin::hashes::hex::FromHex;
2450 use bitcoin::util::address::Address;
2451 use bitcoin::network::constants::Network;
2452 use bitcoin::blockdata::script::Builder;
2453 use bitcoin::blockdata::opcodes;
2454 use bitcoin::hash_types::{Txid, BlockHash};
2456 use bitcoin::secp256k1::{PublicKey,SecretKey};
2457 use bitcoin::secp256k1::{Secp256k1, Message};
2459 use crate::io::{self, Cursor};
2460 use crate::prelude::*;
2461 use core::convert::TryFrom;
2462 use core::str::FromStr;
2464 use crate::chain::transaction::OutPoint;
2467 fn encoding_channel_reestablish() {
2469 let secp_ctx = Secp256k1::new();
2470 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2473 let cr = msgs::ChannelReestablish {
2474 channel_id: [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],
2475 next_local_commitment_number: 3,
2476 next_remote_commitment_number: 4,
2477 your_last_per_commitment_secret: [9;32],
2478 my_current_per_commitment_point: public_key,
2479 next_funding_txid: None,
2482 let encoded_value = cr.encode();
2486 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
2487 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2488 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2489 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
2490 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
2496 fn encoding_channel_reestablish_with_next_funding_txid() {
2498 let secp_ctx = Secp256k1::new();
2499 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2502 let cr = msgs::ChannelReestablish {
2503 channel_id: [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],
2504 next_local_commitment_number: 3,
2505 next_remote_commitment_number: 4,
2506 your_last_per_commitment_secret: [9;32],
2507 my_current_per_commitment_point: public_key,
2508 next_funding_txid: Some(Txid::from_hash(bitcoin::hashes::Hash::from_slice(&[
2509 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,
2513 let encoded_value = cr.encode();
2517 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
2518 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2519 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2520 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
2521 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
2522 0, // Type (next_funding_txid)
2524 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
2529 macro_rules! get_keys_from {
2530 ($slice: expr, $secp_ctx: expr) => {
2532 let privkey = SecretKey::from_slice(&hex::decode($slice).unwrap()[..]).unwrap();
2533 let pubkey = PublicKey::from_secret_key(&$secp_ctx, &privkey);
2539 macro_rules! get_sig_on {
2540 ($privkey: expr, $ctx: expr, $string: expr) => {
2542 let sighash = Message::from_slice(&$string.into_bytes()[..]).unwrap();
2543 $ctx.sign_ecdsa(&sighash, &$privkey)
2549 fn encoding_announcement_signatures() {
2550 let secp_ctx = Secp256k1::new();
2551 let (privkey, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2552 let sig_1 = get_sig_on!(privkey, secp_ctx, String::from("01010101010101010101010101010101"));
2553 let sig_2 = get_sig_on!(privkey, secp_ctx, String::from("02020202020202020202020202020202"));
2554 let announcement_signatures = msgs::AnnouncementSignatures {
2555 channel_id: [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],
2556 short_channel_id: 2316138423780173,
2557 node_signature: sig_1,
2558 bitcoin_signature: sig_2,
2561 let encoded_value = announcement_signatures.encode();
2562 assert_eq!(encoded_value, hex::decode("040000000000000005000000000000000600000000000000070000000000000000083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073acf9953cef4700860f5967838eba2bae89288ad188ebf8b20bf995c3ea53a26df1876d0a3a0e13172ba286a673140190c02ba9da60a2e43a745188c8a83c7f3ef").unwrap());
2565 fn do_encoding_channel_announcement(unknown_features_bits: bool, excess_data: bool) {
2566 let secp_ctx = Secp256k1::new();
2567 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2568 let (privkey_2, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2569 let (privkey_3, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2570 let (privkey_4, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2571 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2572 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
2573 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
2574 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
2575 let mut features = ChannelFeatures::empty();
2576 if unknown_features_bits {
2577 features = ChannelFeatures::from_le_bytes(vec![0xFF, 0xFF]);
2579 let unsigned_channel_announcement = msgs::UnsignedChannelAnnouncement {
2581 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2582 short_channel_id: 2316138423780173,
2583 node_id_1: NodeId::from_pubkey(&pubkey_1),
2584 node_id_2: NodeId::from_pubkey(&pubkey_2),
2585 bitcoin_key_1: NodeId::from_pubkey(&pubkey_3),
2586 bitcoin_key_2: NodeId::from_pubkey(&pubkey_4),
2587 excess_data: if excess_data { vec![10, 0, 0, 20, 0, 0, 30, 0, 0, 40] } else { Vec::new() },
2589 let channel_announcement = msgs::ChannelAnnouncement {
2590 node_signature_1: sig_1,
2591 node_signature_2: sig_2,
2592 bitcoin_signature_1: sig_3,
2593 bitcoin_signature_2: sig_4,
2594 contents: unsigned_channel_announcement,
2596 let encoded_value = channel_announcement.encode();
2597 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a1735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap();
2598 if unknown_features_bits {
2599 target_value.append(&mut hex::decode("0002ffff").unwrap());
2601 target_value.append(&mut hex::decode("0000").unwrap());
2603 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2604 target_value.append(&mut hex::decode("00083a840000034d031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
2606 target_value.append(&mut hex::decode("0a00001400001e000028").unwrap());
2608 assert_eq!(encoded_value, target_value);
2612 fn encoding_channel_announcement() {
2613 do_encoding_channel_announcement(true, false);
2614 do_encoding_channel_announcement(false, true);
2615 do_encoding_channel_announcement(false, false);
2616 do_encoding_channel_announcement(true, true);
2619 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) {
2620 let secp_ctx = Secp256k1::new();
2621 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2622 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2623 let features = if unknown_features_bits {
2624 NodeFeatures::from_le_bytes(vec![0xFF, 0xFF])
2626 // Set to some features we may support
2627 NodeFeatures::from_le_bytes(vec![2 | 1 << 5])
2629 let mut addresses = Vec::new();
2631 addresses.push(msgs::NetAddress::IPv4 {
2632 addr: [255, 254, 253, 252],
2637 addresses.push(msgs::NetAddress::IPv6 {
2638 addr: [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240],
2643 addresses.push(msgs::NetAddress::OnionV2(
2644 [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 38, 7]
2648 addresses.push(msgs::NetAddress::OnionV3 {
2649 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],
2656 addresses.push(msgs::NetAddress::Hostname {
2657 hostname: Hostname::try_from(String::from("host")).unwrap(),
2661 let mut addr_len = 0;
2662 for addr in &addresses {
2663 addr_len += addr.len() + 1;
2665 let unsigned_node_announcement = msgs::UnsignedNodeAnnouncement {
2667 timestamp: 20190119,
2668 node_id: NodeId::from_pubkey(&pubkey_1),
2670 alias: NodeAlias([16;32]),
2672 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() },
2673 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() },
2675 addr_len += unsigned_node_announcement.excess_address_data.len() as u16;
2676 let node_announcement = msgs::NodeAnnouncement {
2678 contents: unsigned_node_announcement,
2680 let encoded_value = node_announcement.encode();
2681 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
2682 if unknown_features_bits {
2683 target_value.append(&mut hex::decode("0002ffff").unwrap());
2685 target_value.append(&mut hex::decode("000122").unwrap());
2687 target_value.append(&mut hex::decode("013413a7031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f2020201010101010101010101010101010101010101010101010101010101010101010").unwrap());
2688 target_value.append(&mut vec![(addr_len >> 8) as u8, addr_len as u8]);
2690 target_value.append(&mut hex::decode("01fffefdfc2607").unwrap());
2693 target_value.append(&mut hex::decode("02fffefdfcfbfaf9f8f7f6f5f4f3f2f1f02607").unwrap());
2696 target_value.append(&mut hex::decode("03fffefdfcfbfaf9f8f7f62607").unwrap());
2699 target_value.append(&mut hex::decode("04fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0efeeedecebeae9e8e7e6e5e4e3e2e1e00020102607").unwrap());
2702 target_value.append(&mut hex::decode("0504686f73742607").unwrap());
2704 if excess_address_data {
2705 target_value.append(&mut hex::decode("216c280b5395a2546e7e4b2663e04f811622f15a4f92e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d269").unwrap());
2708 target_value.append(&mut hex::decode("3b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
2710 assert_eq!(encoded_value, target_value);
2714 fn encoding_node_announcement() {
2715 do_encoding_node_announcement(true, true, true, true, true, true, true, true);
2716 do_encoding_node_announcement(false, false, false, false, false, false, false, false);
2717 do_encoding_node_announcement(false, true, false, false, false, false, false, false);
2718 do_encoding_node_announcement(false, false, true, false, false, false, false, false);
2719 do_encoding_node_announcement(false, false, false, true, false, false, false, false);
2720 do_encoding_node_announcement(false, false, false, false, true, false, false, false);
2721 do_encoding_node_announcement(false, false, false, false, false, true, false, false);
2722 do_encoding_node_announcement(false, false, false, false, false, false, true, false);
2723 do_encoding_node_announcement(false, true, false, true, false, false, true, false);
2724 do_encoding_node_announcement(false, false, true, false, true, false, false, false);
2727 fn do_encoding_channel_update(direction: bool, disable: bool, excess_data: bool) {
2728 let secp_ctx = Secp256k1::new();
2729 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2730 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2731 let unsigned_channel_update = msgs::UnsignedChannelUpdate {
2732 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2733 short_channel_id: 2316138423780173,
2734 timestamp: 20190119,
2735 flags: if direction { 1 } else { 0 } | if disable { 1 << 1 } else { 0 },
2736 cltv_expiry_delta: 144,
2737 htlc_minimum_msat: 1000000,
2738 htlc_maximum_msat: 131355275467161,
2739 fee_base_msat: 10000,
2740 fee_proportional_millionths: 20,
2741 excess_data: if excess_data { vec![0, 0, 0, 0, 59, 154, 202, 0] } else { Vec::new() }
2743 let channel_update = msgs::ChannelUpdate {
2745 contents: unsigned_channel_update
2747 let encoded_value = channel_update.encode();
2748 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
2749 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2750 target_value.append(&mut hex::decode("00083a840000034d013413a7").unwrap());
2751 target_value.append(&mut hex::decode("01").unwrap());
2752 target_value.append(&mut hex::decode("00").unwrap());
2754 let flag = target_value.last_mut().unwrap();
2758 let flag = target_value.last_mut().unwrap();
2759 *flag = *flag | 1 << 1;
2761 target_value.append(&mut hex::decode("009000000000000f42400000271000000014").unwrap());
2762 target_value.append(&mut hex::decode("0000777788889999").unwrap());
2764 target_value.append(&mut hex::decode("000000003b9aca00").unwrap());
2766 assert_eq!(encoded_value, target_value);
2770 fn encoding_channel_update() {
2771 do_encoding_channel_update(false, false, false);
2772 do_encoding_channel_update(false, false, true);
2773 do_encoding_channel_update(true, false, false);
2774 do_encoding_channel_update(true, false, true);
2775 do_encoding_channel_update(false, true, false);
2776 do_encoding_channel_update(false, true, true);
2777 do_encoding_channel_update(true, true, false);
2778 do_encoding_channel_update(true, true, true);
2781 fn do_encoding_open_channel(random_bit: bool, shutdown: bool, incl_chan_type: bool) {
2782 let secp_ctx = Secp256k1::new();
2783 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2784 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2785 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2786 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2787 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
2788 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
2789 let open_channel = msgs::OpenChannel {
2790 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2791 temporary_channel_id: [2; 32],
2792 funding_satoshis: 1311768467284833366,
2793 push_msat: 2536655962884945560,
2794 dust_limit_satoshis: 3608586615801332854,
2795 max_htlc_value_in_flight_msat: 8517154655701053848,
2796 channel_reserve_satoshis: 8665828695742877976,
2797 htlc_minimum_msat: 2316138423780173,
2798 feerate_per_kw: 821716,
2799 to_self_delay: 49340,
2800 max_accepted_htlcs: 49340,
2801 funding_pubkey: pubkey_1,
2802 revocation_basepoint: pubkey_2,
2803 payment_point: pubkey_3,
2804 delayed_payment_basepoint: pubkey_4,
2805 htlc_basepoint: pubkey_5,
2806 first_per_commitment_point: pubkey_6,
2807 channel_flags: if random_bit { 1 << 5 } else { 0 },
2808 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
2809 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
2811 let encoded_value = open_channel.encode();
2812 let mut target_value = Vec::new();
2813 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2814 target_value.append(&mut hex::decode("02020202020202020202020202020202020202020202020202020202020202021234567890123456233403289122369832144668701144767633030896203198784335490624111800083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
2816 target_value.append(&mut hex::decode("20").unwrap());
2818 target_value.append(&mut hex::decode("00").unwrap());
2821 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
2824 target_value.append(&mut hex::decode("0100").unwrap());
2826 assert_eq!(encoded_value, target_value);
2830 fn encoding_open_channel() {
2831 do_encoding_open_channel(false, false, false);
2832 do_encoding_open_channel(false, false, true);
2833 do_encoding_open_channel(false, true, false);
2834 do_encoding_open_channel(false, true, true);
2835 do_encoding_open_channel(true, false, false);
2836 do_encoding_open_channel(true, false, true);
2837 do_encoding_open_channel(true, true, false);
2838 do_encoding_open_channel(true, true, true);
2841 fn do_encoding_open_channelv2(random_bit: bool, shutdown: bool, incl_chan_type: bool, require_confirmed_inputs: bool) {
2842 let secp_ctx = Secp256k1::new();
2843 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2844 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2845 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2846 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2847 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
2848 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
2849 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
2850 let open_channelv2 = msgs::OpenChannelV2 {
2851 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2852 temporary_channel_id: [2; 32],
2853 funding_feerate_sat_per_1000_weight: 821716,
2854 commitment_feerate_sat_per_1000_weight: 821716,
2855 funding_satoshis: 1311768467284833366,
2856 dust_limit_satoshis: 3608586615801332854,
2857 max_htlc_value_in_flight_msat: 8517154655701053848,
2858 htlc_minimum_msat: 2316138423780173,
2859 to_self_delay: 49340,
2860 max_accepted_htlcs: 49340,
2861 locktime: 305419896,
2862 funding_pubkey: pubkey_1,
2863 revocation_basepoint: pubkey_2,
2864 payment_basepoint: pubkey_3,
2865 delayed_payment_basepoint: pubkey_4,
2866 htlc_basepoint: pubkey_5,
2867 first_per_commitment_point: pubkey_6,
2868 second_per_commitment_point: pubkey_7,
2869 channel_flags: if random_bit { 1 << 5 } else { 0 },
2870 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
2871 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
2872 require_confirmed_inputs: if require_confirmed_inputs { Some(()) } else { None },
2874 let encoded_value = open_channelv2.encode();
2875 let mut target_value = Vec::new();
2876 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2877 target_value.append(&mut hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap());
2878 target_value.append(&mut hex::decode("000c89d4").unwrap());
2879 target_value.append(&mut hex::decode("000c89d4").unwrap());
2880 target_value.append(&mut hex::decode("1234567890123456").unwrap());
2881 target_value.append(&mut hex::decode("3214466870114476").unwrap());
2882 target_value.append(&mut hex::decode("7633030896203198").unwrap());
2883 target_value.append(&mut hex::decode("00083a840000034d").unwrap());
2884 target_value.append(&mut hex::decode("c0bc").unwrap());
2885 target_value.append(&mut hex::decode("c0bc").unwrap());
2886 target_value.append(&mut hex::decode("12345678").unwrap());
2887 target_value.append(&mut hex::decode("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap());
2888 target_value.append(&mut hex::decode("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap());
2889 target_value.append(&mut hex::decode("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap());
2890 target_value.append(&mut hex::decode("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
2891 target_value.append(&mut hex::decode("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap());
2892 target_value.append(&mut hex::decode("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
2893 target_value.append(&mut hex::decode("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap());
2896 target_value.append(&mut hex::decode("20").unwrap());
2898 target_value.append(&mut hex::decode("00").unwrap());
2901 target_value.append(&mut hex::decode("001b").unwrap()); // Type 0 + Length 27
2902 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
2905 target_value.append(&mut hex::decode("0100").unwrap());
2907 if require_confirmed_inputs {
2908 target_value.append(&mut hex::decode("0200").unwrap());
2910 assert_eq!(encoded_value, target_value);
2914 fn encoding_open_channelv2() {
2915 do_encoding_open_channelv2(false, false, false, false);
2916 do_encoding_open_channelv2(false, false, false, true);
2917 do_encoding_open_channelv2(false, false, true, false);
2918 do_encoding_open_channelv2(false, false, true, true);
2919 do_encoding_open_channelv2(false, true, false, false);
2920 do_encoding_open_channelv2(false, true, false, true);
2921 do_encoding_open_channelv2(false, true, true, false);
2922 do_encoding_open_channelv2(false, true, true, true);
2923 do_encoding_open_channelv2(true, false, false, false);
2924 do_encoding_open_channelv2(true, false, false, true);
2925 do_encoding_open_channelv2(true, false, true, false);
2926 do_encoding_open_channelv2(true, false, true, true);
2927 do_encoding_open_channelv2(true, true, false, false);
2928 do_encoding_open_channelv2(true, true, false, true);
2929 do_encoding_open_channelv2(true, true, true, false);
2930 do_encoding_open_channelv2(true, true, true, true);
2933 fn do_encoding_accept_channel(shutdown: bool) {
2934 let secp_ctx = Secp256k1::new();
2935 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2936 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2937 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2938 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2939 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
2940 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
2941 let accept_channel = msgs::AcceptChannel {
2942 temporary_channel_id: [2; 32],
2943 dust_limit_satoshis: 1311768467284833366,
2944 max_htlc_value_in_flight_msat: 2536655962884945560,
2945 channel_reserve_satoshis: 3608586615801332854,
2946 htlc_minimum_msat: 2316138423780173,
2947 minimum_depth: 821716,
2948 to_self_delay: 49340,
2949 max_accepted_htlcs: 49340,
2950 funding_pubkey: pubkey_1,
2951 revocation_basepoint: pubkey_2,
2952 payment_point: pubkey_3,
2953 delayed_payment_basepoint: pubkey_4,
2954 htlc_basepoint: pubkey_5,
2955 first_per_commitment_point: pubkey_6,
2956 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
2959 next_local_nonce: None,
2961 let encoded_value = accept_channel.encode();
2962 let mut target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020212345678901234562334032891223698321446687011447600083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap();
2964 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
2966 assert_eq!(encoded_value, target_value);
2970 fn encoding_accept_channel() {
2971 do_encoding_accept_channel(false);
2972 do_encoding_accept_channel(true);
2975 fn do_encoding_accept_channelv2(shutdown: bool) {
2976 let secp_ctx = Secp256k1::new();
2977 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2978 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2979 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2980 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2981 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
2982 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
2983 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
2984 let accept_channelv2 = msgs::AcceptChannelV2 {
2985 temporary_channel_id: [2; 32],
2986 funding_satoshis: 1311768467284833366,
2987 dust_limit_satoshis: 1311768467284833366,
2988 max_htlc_value_in_flight_msat: 2536655962884945560,
2989 htlc_minimum_msat: 2316138423780173,
2990 minimum_depth: 821716,
2991 to_self_delay: 49340,
2992 max_accepted_htlcs: 49340,
2993 funding_pubkey: pubkey_1,
2994 revocation_basepoint: pubkey_2,
2995 payment_basepoint: pubkey_3,
2996 delayed_payment_basepoint: pubkey_4,
2997 htlc_basepoint: pubkey_5,
2998 first_per_commitment_point: pubkey_6,
2999 second_per_commitment_point: pubkey_7,
3000 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3002 require_confirmed_inputs: None,
3004 let encoded_value = accept_channelv2.encode();
3005 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // temporary_channel_id
3006 target_value.append(&mut hex::decode("1234567890123456").unwrap()); // funding_satoshis
3007 target_value.append(&mut hex::decode("1234567890123456").unwrap()); // dust_limit_satoshis
3008 target_value.append(&mut hex::decode("2334032891223698").unwrap()); // max_htlc_value_in_flight_msat
3009 target_value.append(&mut hex::decode("00083a840000034d").unwrap()); // htlc_minimum_msat
3010 target_value.append(&mut hex::decode("000c89d4").unwrap()); // minimum_depth
3011 target_value.append(&mut hex::decode("c0bc").unwrap()); // to_self_delay
3012 target_value.append(&mut hex::decode("c0bc").unwrap()); // max_accepted_htlcs
3013 target_value.append(&mut hex::decode("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap()); // funding_pubkey
3014 target_value.append(&mut hex::decode("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap()); // revocation_basepoint
3015 target_value.append(&mut hex::decode("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap()); // payment_basepoint
3016 target_value.append(&mut hex::decode("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap()); // delayed_payment_basepoint
3017 target_value.append(&mut hex::decode("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap()); // htlc_basepoint
3018 target_value.append(&mut hex::decode("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap()); // first_per_commitment_point
3019 target_value.append(&mut hex::decode("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap()); // second_per_commitment_point
3021 target_value.append(&mut hex::decode("001b").unwrap()); // Type 0 + Length 27
3022 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3024 assert_eq!(encoded_value, target_value);
3028 fn encoding_accept_channelv2() {
3029 do_encoding_accept_channelv2(false);
3030 do_encoding_accept_channelv2(true);
3034 fn encoding_funding_created() {
3035 let secp_ctx = Secp256k1::new();
3036 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3037 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3038 let funding_created = msgs::FundingCreated {
3039 temporary_channel_id: [2; 32],
3040 funding_txid: Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3041 funding_output_index: 255,
3044 partial_signature_with_nonce: None,
3046 next_local_nonce: None,
3048 let encoded_value = funding_created.encode();
3049 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202026e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c200ffd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3050 assert_eq!(encoded_value, target_value);
3054 fn encoding_funding_signed() {
3055 let secp_ctx = Secp256k1::new();
3056 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3057 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3058 let funding_signed = msgs::FundingSigned {
3059 channel_id: [2; 32],
3062 partial_signature_with_nonce: None,
3064 let encoded_value = funding_signed.encode();
3065 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3066 assert_eq!(encoded_value, target_value);
3070 fn encoding_channel_ready() {
3071 let secp_ctx = Secp256k1::new();
3072 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3073 let channel_ready = msgs::ChannelReady {
3074 channel_id: [2; 32],
3075 next_per_commitment_point: pubkey_1,
3076 short_channel_id_alias: None,
3078 let encoded_value = channel_ready.encode();
3079 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3080 assert_eq!(encoded_value, target_value);
3084 fn encoding_tx_add_input() {
3085 let tx_add_input = msgs::TxAddInput {
3086 channel_id: [2; 32],
3087 serial_id: 4886718345,
3088 prevtx: TransactionU16LenLimited::new(Transaction {
3090 lock_time: PackedLockTime(0),
3092 previous_output: OutPoint { txid: Txid::from_hex("305bab643ee297b8b6b76b320792c8223d55082122cb606bf89382146ced9c77").unwrap(), index: 2 }.into_bitcoin_outpoint(),
3093 script_sig: Script::new(),
3094 sequence: Sequence(0xfffffffd),
3095 witness: Witness::from_vec(vec![
3096 hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3097 hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3102 script_pubkey: Address::from_str("bc1qzlffunw52jav8vwdu5x3jfk6sr8u22rmq3xzw2").unwrap().script_pubkey(),
3106 script_pubkey: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().script_pubkey(),
3110 prevtx_out: 305419896,
3111 sequence: 305419896,
3113 let encoded_value = tx_add_input.encode();
3114 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000000012345678900de02000000000101779ced6c148293f86b60cb222108553d22c89207326bb7b6b897e23e64ab5b300200000000fdffffff0236dbc1000000000016001417d29e4dd454bac3b1cde50d1926da80cfc5287b9cbd03000000000016001436ec78d514df462da95e6a00c24daa8915362d420247304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701210301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944000000001234567812345678").unwrap();
3115 assert_eq!(encoded_value, target_value);
3119 fn encoding_tx_add_output() {
3120 let tx_add_output = msgs::TxAddOutput {
3121 channel_id: [2; 32],
3122 serial_id: 4886718345,
3124 script: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().script_pubkey(),
3126 let encoded_value = tx_add_output.encode();
3127 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000000012345678900000001234567890016001436ec78d514df462da95e6a00c24daa8915362d42").unwrap();
3128 assert_eq!(encoded_value, target_value);
3132 fn encoding_tx_remove_input() {
3133 let tx_remove_input = msgs::TxRemoveInput {
3134 channel_id: [2; 32],
3135 serial_id: 4886718345,
3137 let encoded_value = tx_remove_input.encode();
3138 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3139 assert_eq!(encoded_value, target_value);
3143 fn encoding_tx_remove_output() {
3144 let tx_remove_output = msgs::TxRemoveOutput {
3145 channel_id: [2; 32],
3146 serial_id: 4886718345,
3148 let encoded_value = tx_remove_output.encode();
3149 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3150 assert_eq!(encoded_value, target_value);
3154 fn encoding_tx_complete() {
3155 let tx_complete = msgs::TxComplete {
3156 channel_id: [2; 32],
3158 let encoded_value = tx_complete.encode();
3159 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3160 assert_eq!(encoded_value, target_value);
3164 fn encoding_tx_signatures() {
3165 let tx_signatures = msgs::TxSignatures {
3166 channel_id: [2; 32],
3167 tx_hash: Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3169 Witness::from_vec(vec![
3170 hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3171 hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3172 Witness::from_vec(vec![
3173 hex::decode("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap(),
3174 hex::decode("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap()]),
3177 let encoded_value = tx_signatures.encode();
3178 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3179 target_value.append(&mut hex::decode("6e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c2").unwrap()); // tx_hash (sha256) (big endian byte order)
3180 target_value.append(&mut hex::decode("0002").unwrap()); // num_witnesses (u16)
3182 target_value.append(&mut hex::decode("006b").unwrap()); // len of witness_data
3183 target_value.append(&mut hex::decode("02").unwrap()); // num_witness_elements (VarInt)
3184 target_value.append(&mut hex::decode("47").unwrap()); // len of witness element data (VarInt)
3185 target_value.append(&mut hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap());
3186 target_value.append(&mut hex::decode("21").unwrap()); // len of witness element data (VarInt)
3187 target_value.append(&mut hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap());
3189 target_value.append(&mut hex::decode("006c").unwrap()); // len of witness_data
3190 target_value.append(&mut hex::decode("02").unwrap()); // num_witness_elements (VarInt)
3191 target_value.append(&mut hex::decode("48").unwrap()); // len of witness element data (VarInt)
3192 target_value.append(&mut hex::decode("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap());
3193 target_value.append(&mut hex::decode("21").unwrap()); // len of witness element data (VarInt)
3194 target_value.append(&mut hex::decode("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap());
3195 assert_eq!(encoded_value, target_value);
3198 fn do_encoding_tx_init_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3199 let tx_init_rbf = msgs::TxInitRbf {
3200 channel_id: [2; 32],
3201 locktime: 305419896,
3202 feerate_sat_per_1000_weight: 20190119,
3203 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3205 let encoded_value = tx_init_rbf.encode();
3206 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3207 target_value.append(&mut hex::decode("12345678").unwrap()); // locktime
3208 target_value.append(&mut hex::decode("013413a7").unwrap()); // feerate_sat_per_1000_weight
3209 if let Some((_, target)) = funding_value_with_hex_target {
3210 target_value.push(0x00); // Type
3211 target_value.push(target.len() as u8 / 2); // Length
3212 target_value.append(&mut hex::decode(target).unwrap()); // Value (i64)
3214 assert_eq!(encoded_value, target_value);
3218 fn encoding_tx_init_rbf() {
3219 do_encoding_tx_init_rbf(Some((1311768467284833366, "1234567890123456")));
3220 do_encoding_tx_init_rbf(Some((13117684672, "000000030DDFFBC0")));
3221 do_encoding_tx_init_rbf(None);
3224 fn do_encoding_tx_ack_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3225 let tx_ack_rbf = msgs::TxAckRbf {
3226 channel_id: [2; 32],
3227 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3229 let encoded_value = tx_ack_rbf.encode();
3230 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3231 if let Some((_, target)) = funding_value_with_hex_target {
3232 target_value.push(0x00); // Type
3233 target_value.push(target.len() as u8 / 2); // Length
3234 target_value.append(&mut hex::decode(target).unwrap()); // Value (i64)
3236 assert_eq!(encoded_value, target_value);
3240 fn encoding_tx_ack_rbf() {
3241 do_encoding_tx_ack_rbf(Some((1311768467284833366, "1234567890123456")));
3242 do_encoding_tx_ack_rbf(Some((13117684672, "000000030DDFFBC0")));
3243 do_encoding_tx_ack_rbf(None);
3247 fn encoding_tx_abort() {
3248 let tx_abort = msgs::TxAbort {
3249 channel_id: [2; 32],
3250 data: hex::decode("54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap(),
3252 let encoded_value = tx_abort.encode();
3253 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202002C54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap();
3254 assert_eq!(encoded_value, target_value);
3257 fn do_encoding_shutdown(script_type: u8) {
3258 let secp_ctx = Secp256k1::new();
3259 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3260 let script = Builder::new().push_opcode(opcodes::OP_TRUE).into_script();
3261 let shutdown = msgs::Shutdown {
3262 channel_id: [2; 32],
3264 if script_type == 1 { Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey() }
3265 else if script_type == 2 { Address::p2sh(&script, Network::Testnet).unwrap().script_pubkey() }
3266 else if script_type == 3 { Address::p2wpkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).unwrap().script_pubkey() }
3267 else { Address::p2wsh(&script, Network::Testnet).script_pubkey() },
3269 let encoded_value = shutdown.encode();
3270 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3271 if script_type == 1 {
3272 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3273 } else if script_type == 2 {
3274 target_value.append(&mut hex::decode("0017a914da1745e9b549bd0bfa1a569971c77eba30cd5a4b87").unwrap());
3275 } else if script_type == 3 {
3276 target_value.append(&mut hex::decode("0016001479b000887626b294a914501a4cd226b58b235983").unwrap());
3277 } else if script_type == 4 {
3278 target_value.append(&mut hex::decode("002200204ae81572f06e1b88fd5ced7a1a000945432e83e1551e6f721ee9c00b8cc33260").unwrap());
3280 assert_eq!(encoded_value, target_value);
3284 fn encoding_shutdown() {
3285 do_encoding_shutdown(1);
3286 do_encoding_shutdown(2);
3287 do_encoding_shutdown(3);
3288 do_encoding_shutdown(4);
3292 fn encoding_closing_signed() {
3293 let secp_ctx = Secp256k1::new();
3294 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3295 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3296 let closing_signed = msgs::ClosingSigned {
3297 channel_id: [2; 32],
3298 fee_satoshis: 2316138423780173,
3302 let encoded_value = closing_signed.encode();
3303 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3304 assert_eq!(encoded_value, target_value);
3305 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value)).unwrap(), closing_signed);
3307 let closing_signed_with_range = msgs::ClosingSigned {
3308 channel_id: [2; 32],
3309 fee_satoshis: 2316138423780173,
3311 fee_range: Some(msgs::ClosingSignedFeeRange {
3312 min_fee_satoshis: 0xdeadbeef,
3313 max_fee_satoshis: 0x1badcafe01234567,
3316 let encoded_value_with_range = closing_signed_with_range.encode();
3317 let target_value_with_range = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a011000000000deadbeef1badcafe01234567").unwrap();
3318 assert_eq!(encoded_value_with_range, target_value_with_range);
3319 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value_with_range)).unwrap(),
3320 closing_signed_with_range);
3324 fn encoding_update_add_htlc() {
3325 let secp_ctx = Secp256k1::new();
3326 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3327 let onion_routing_packet = msgs::OnionPacket {
3329 public_key: Ok(pubkey_1),
3330 hop_data: [1; 20*65],
3333 let update_add_htlc = msgs::UpdateAddHTLC {
3334 channel_id: [2; 32],
3335 htlc_id: 2316138423780173,
3336 amount_msat: 3608586615801332854,
3337 payment_hash: PaymentHash([1; 32]),
3338 cltv_expiry: 821716,
3339 onion_routing_packet,
3340 skimmed_fee_msat: None,
3342 let encoded_value = update_add_htlc.encode();
3343 let target_value = hex::decode("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").unwrap();
3344 assert_eq!(encoded_value, target_value);
3348 fn encoding_update_fulfill_htlc() {
3349 let update_fulfill_htlc = msgs::UpdateFulfillHTLC {
3350 channel_id: [2; 32],
3351 htlc_id: 2316138423780173,
3352 payment_preimage: PaymentPreimage([1; 32]),
3354 let encoded_value = update_fulfill_htlc.encode();
3355 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d0101010101010101010101010101010101010101010101010101010101010101").unwrap();
3356 assert_eq!(encoded_value, target_value);
3360 fn encoding_update_fail_htlc() {
3361 let reason = OnionErrorPacket {
3362 data: [1; 32].to_vec(),
3364 let update_fail_htlc = msgs::UpdateFailHTLC {
3365 channel_id: [2; 32],
3366 htlc_id: 2316138423780173,
3369 let encoded_value = update_fail_htlc.encode();
3370 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d00200101010101010101010101010101010101010101010101010101010101010101").unwrap();
3371 assert_eq!(encoded_value, target_value);
3375 fn encoding_update_fail_malformed_htlc() {
3376 let update_fail_malformed_htlc = msgs::UpdateFailMalformedHTLC {
3377 channel_id: [2; 32],
3378 htlc_id: 2316138423780173,
3379 sha256_of_onion: [1; 32],
3382 let encoded_value = update_fail_malformed_htlc.encode();
3383 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d010101010101010101010101010101010101010101010101010101010101010100ff").unwrap();
3384 assert_eq!(encoded_value, target_value);
3387 fn do_encoding_commitment_signed(htlcs: bool) {
3388 let secp_ctx = Secp256k1::new();
3389 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3390 let (privkey_2, _) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3391 let (privkey_3, _) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3392 let (privkey_4, _) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3393 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3394 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
3395 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
3396 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
3397 let commitment_signed = msgs::CommitmentSigned {
3398 channel_id: [2; 32],
3400 htlc_signatures: if htlcs { vec![sig_2, sig_3, sig_4] } else { Vec::new() },
3402 partial_signature_with_nonce: None,
3404 let encoded_value = commitment_signed.encode();
3405 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3407 target_value.append(&mut hex::decode("00031735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
3409 target_value.append(&mut hex::decode("0000").unwrap());
3411 assert_eq!(encoded_value, target_value);
3415 fn encoding_commitment_signed() {
3416 do_encoding_commitment_signed(true);
3417 do_encoding_commitment_signed(false);
3421 fn encoding_revoke_and_ack() {
3422 let secp_ctx = Secp256k1::new();
3423 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3424 let raa = msgs::RevokeAndACK {
3425 channel_id: [2; 32],
3426 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],
3427 next_per_commitment_point: pubkey_1,
3429 next_local_nonce: None,
3431 let encoded_value = raa.encode();
3432 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020101010101010101010101010101010101010101010101010101010101010101031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3433 assert_eq!(encoded_value, target_value);
3437 fn encoding_update_fee() {
3438 let update_fee = msgs::UpdateFee {
3439 channel_id: [2; 32],
3440 feerate_per_kw: 20190119,
3442 let encoded_value = update_fee.encode();
3443 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202013413a7").unwrap();
3444 assert_eq!(encoded_value, target_value);
3448 fn encoding_init() {
3449 let mainnet_hash = ChainHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap();
3450 assert_eq!(msgs::Init {
3451 features: InitFeatures::from_le_bytes(vec![0xFF, 0xFF, 0xFF]),
3452 networks: Some(vec![mainnet_hash]),
3453 remote_network_address: None,
3454 }.encode(), hex::decode("00023fff0003ffffff01206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3455 assert_eq!(msgs::Init {
3456 features: InitFeatures::from_le_bytes(vec![0xFF]),
3458 remote_network_address: None,
3459 }.encode(), hex::decode("0001ff0001ff").unwrap());
3460 assert_eq!(msgs::Init {
3461 features: InitFeatures::from_le_bytes(vec![]),
3462 networks: Some(vec![mainnet_hash]),
3463 remote_network_address: None,
3464 }.encode(), hex::decode("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3465 assert_eq!(msgs::Init {
3466 features: InitFeatures::from_le_bytes(vec![]),
3467 networks: Some(vec![ChainHash::from(&[1; 32][..]), ChainHash::from(&[2; 32][..])]),
3468 remote_network_address: None,
3469 }.encode(), hex::decode("00000000014001010101010101010101010101010101010101010101010101010101010101010202020202020202020202020202020202020202020202020202020202020202").unwrap());
3470 let init_msg = msgs::Init { features: InitFeatures::from_le_bytes(vec![]),
3471 networks: Some(vec![mainnet_hash]),
3472 remote_network_address: Some(msgs::NetAddress::IPv4 {
3473 addr: [127, 0, 0, 1],
3477 let encoded_value = init_msg.encode();
3478 let target_value = hex::decode("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d61900000000000307017f00000103e8").unwrap();
3479 assert_eq!(encoded_value, target_value);
3480 assert_eq!(msgs::Init::read(&mut Cursor::new(&target_value)).unwrap(), init_msg);
3484 fn encoding_error() {
3485 let error = msgs::ErrorMessage {
3486 channel_id: [2; 32],
3487 data: String::from("rust-lightning"),
3489 let encoded_value = error.encode();
3490 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3491 assert_eq!(encoded_value, target_value);
3495 fn encoding_warning() {
3496 let error = msgs::WarningMessage {
3497 channel_id: [2; 32],
3498 data: String::from("rust-lightning"),
3500 let encoded_value = error.encode();
3501 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3502 assert_eq!(encoded_value, target_value);
3506 fn encoding_ping() {
3507 let ping = msgs::Ping {
3511 let encoded_value = ping.encode();
3512 let target_value = hex::decode("0040004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3513 assert_eq!(encoded_value, target_value);
3517 fn encoding_pong() {
3518 let pong = msgs::Pong {
3521 let encoded_value = pong.encode();
3522 let target_value = hex::decode("004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3523 assert_eq!(encoded_value, target_value);
3527 fn encoding_nonfinal_onion_hop_data() {
3528 let mut msg = msgs::OnionHopData {
3529 format: OnionHopDataFormat::NonFinalNode {
3530 short_channel_id: 0xdeadbeef1bad1dea,
3532 amt_to_forward: 0x0badf00d01020304,
3533 outgoing_cltv_value: 0xffffffff,
3535 let encoded_value = msg.encode();
3536 let target_value = hex::decode("1a02080badf00d010203040404ffffffff0608deadbeef1bad1dea").unwrap();
3537 assert_eq!(encoded_value, target_value);
3538 msg = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3539 if let OnionHopDataFormat::NonFinalNode { short_channel_id } = msg.format {
3540 assert_eq!(short_channel_id, 0xdeadbeef1bad1dea);
3541 } else { panic!(); }
3542 assert_eq!(msg.amt_to_forward, 0x0badf00d01020304);
3543 assert_eq!(msg.outgoing_cltv_value, 0xffffffff);
3547 fn encoding_final_onion_hop_data() {
3548 let mut msg = msgs::OnionHopData {
3549 format: OnionHopDataFormat::FinalNode {
3551 payment_metadata: None,
3552 keysend_preimage: None,
3554 amt_to_forward: 0x0badf00d01020304,
3555 outgoing_cltv_value: 0xffffffff,
3557 let encoded_value = msg.encode();
3558 let target_value = hex::decode("1002080badf00d010203040404ffffffff").unwrap();
3559 assert_eq!(encoded_value, target_value);
3560 msg = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3561 if let OnionHopDataFormat::FinalNode { payment_data: None, .. } = msg.format { } else { panic!(); }
3562 assert_eq!(msg.amt_to_forward, 0x0badf00d01020304);
3563 assert_eq!(msg.outgoing_cltv_value, 0xffffffff);
3567 fn encoding_final_onion_hop_data_with_secret() {
3568 let expected_payment_secret = PaymentSecret([0x42u8; 32]);
3569 let mut msg = msgs::OnionHopData {
3570 format: OnionHopDataFormat::FinalNode {
3571 payment_data: Some(FinalOnionHopData {
3572 payment_secret: expected_payment_secret,
3573 total_msat: 0x1badca1f
3575 payment_metadata: None,
3576 keysend_preimage: None,
3578 amt_to_forward: 0x0badf00d01020304,
3579 outgoing_cltv_value: 0xffffffff,
3581 let encoded_value = msg.encode();
3582 let target_value = hex::decode("3602080badf00d010203040404ffffffff082442424242424242424242424242424242424242424242424242424242424242421badca1f").unwrap();
3583 assert_eq!(encoded_value, target_value);
3584 msg = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3585 if let OnionHopDataFormat::FinalNode {
3586 payment_data: Some(FinalOnionHopData {
3588 total_msat: 0x1badca1f
3590 payment_metadata: None,
3591 keysend_preimage: None,
3593 assert_eq!(payment_secret, expected_payment_secret);
3594 } else { panic!(); }
3595 assert_eq!(msg.amt_to_forward, 0x0badf00d01020304);
3596 assert_eq!(msg.outgoing_cltv_value, 0xffffffff);
3600 fn query_channel_range_end_blocknum() {
3601 let tests: Vec<(u32, u32, u32)> = vec![
3602 (10000, 1500, 11500),
3603 (0, 0xffffffff, 0xffffffff),
3604 (1, 0xffffffff, 0xffffffff),
3607 for (first_blocknum, number_of_blocks, expected) in tests.into_iter() {
3608 let sut = msgs::QueryChannelRange {
3609 chain_hash: BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap(),
3613 assert_eq!(sut.end_blocknum(), expected);
3618 fn encoding_query_channel_range() {
3619 let mut query_channel_range = msgs::QueryChannelRange {
3620 chain_hash: BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap(),
3621 first_blocknum: 100000,
3622 number_of_blocks: 1500,
3624 let encoded_value = query_channel_range.encode();
3625 let target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206000186a0000005dc").unwrap();
3626 assert_eq!(encoded_value, target_value);
3628 query_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3629 assert_eq!(query_channel_range.first_blocknum, 100000);
3630 assert_eq!(query_channel_range.number_of_blocks, 1500);
3634 fn encoding_reply_channel_range() {
3635 do_encoding_reply_channel_range(0);
3636 do_encoding_reply_channel_range(1);
3639 fn do_encoding_reply_channel_range(encoding_type: u8) {
3640 let mut target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206000b8a06000005dc01").unwrap();
3641 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3642 let mut reply_channel_range = msgs::ReplyChannelRange {
3643 chain_hash: expected_chain_hash,
3644 first_blocknum: 756230,
3645 number_of_blocks: 1500,
3646 sync_complete: true,
3647 short_channel_ids: vec![0x000000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
3650 if encoding_type == 0 {
3651 target_value.append(&mut hex::decode("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
3652 let encoded_value = reply_channel_range.encode();
3653 assert_eq!(encoded_value, target_value);
3655 reply_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3656 assert_eq!(reply_channel_range.chain_hash, expected_chain_hash);
3657 assert_eq!(reply_channel_range.first_blocknum, 756230);
3658 assert_eq!(reply_channel_range.number_of_blocks, 1500);
3659 assert_eq!(reply_channel_range.sync_complete, true);
3660 assert_eq!(reply_channel_range.short_channel_ids[0], 0x000000000000008e);
3661 assert_eq!(reply_channel_range.short_channel_ids[1], 0x0000000000003c69);
3662 assert_eq!(reply_channel_range.short_channel_ids[2], 0x000000000045a6c4);
3664 target_value.append(&mut hex::decode("001601789c636000833e08659309a65878be010010a9023a").unwrap());
3665 let result: Result<msgs::ReplyChannelRange, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
3666 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
3671 fn encoding_query_short_channel_ids() {
3672 do_encoding_query_short_channel_ids(0);
3673 do_encoding_query_short_channel_ids(1);
3676 fn do_encoding_query_short_channel_ids(encoding_type: u8) {
3677 let mut target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206").unwrap();
3678 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3679 let mut query_short_channel_ids = msgs::QueryShortChannelIds {
3680 chain_hash: expected_chain_hash,
3681 short_channel_ids: vec![0x0000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
3684 if encoding_type == 0 {
3685 target_value.append(&mut hex::decode("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
3686 let encoded_value = query_short_channel_ids.encode();
3687 assert_eq!(encoded_value, target_value);
3689 query_short_channel_ids = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3690 assert_eq!(query_short_channel_ids.chain_hash, expected_chain_hash);
3691 assert_eq!(query_short_channel_ids.short_channel_ids[0], 0x000000000000008e);
3692 assert_eq!(query_short_channel_ids.short_channel_ids[1], 0x0000000000003c69);
3693 assert_eq!(query_short_channel_ids.short_channel_ids[2], 0x000000000045a6c4);
3695 target_value.append(&mut hex::decode("001601789c636000833e08659309a65878be010010a9023a").unwrap());
3696 let result: Result<msgs::QueryShortChannelIds, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
3697 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
3702 fn encoding_reply_short_channel_ids_end() {
3703 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3704 let mut reply_short_channel_ids_end = msgs::ReplyShortChannelIdsEnd {
3705 chain_hash: expected_chain_hash,
3706 full_information: true,
3708 let encoded_value = reply_short_channel_ids_end.encode();
3709 let target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e220601").unwrap();
3710 assert_eq!(encoded_value, target_value);
3712 reply_short_channel_ids_end = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3713 assert_eq!(reply_short_channel_ids_end.chain_hash, expected_chain_hash);
3714 assert_eq!(reply_short_channel_ids_end.full_information, true);
3718 fn encoding_gossip_timestamp_filter(){
3719 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3720 let mut gossip_timestamp_filter = msgs::GossipTimestampFilter {
3721 chain_hash: expected_chain_hash,
3722 first_timestamp: 1590000000,
3723 timestamp_range: 0xffff_ffff,
3725 let encoded_value = gossip_timestamp_filter.encode();
3726 let target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e22065ec57980ffffffff").unwrap();
3727 assert_eq!(encoded_value, target_value);
3729 gossip_timestamp_filter = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3730 assert_eq!(gossip_timestamp_filter.chain_hash, expected_chain_hash);
3731 assert_eq!(gossip_timestamp_filter.first_timestamp, 1590000000);
3732 assert_eq!(gossip_timestamp_filter.timestamp_range, 0xffff_ffff);
3736 fn decode_onion_hop_data_len_as_bigsize() {
3737 // Tests that we can decode an onion payload that is >253 bytes.
3738 // Previously, receiving a payload of this size could've caused us to fail to decode a valid
3739 // payload, because we were decoding the length (a BigSize, big-endian) as a VarInt
3742 // Encode a test onion payload with a big custom TLV such that it's >253 bytes, forcing the
3743 // payload length to be encoded over multiple bytes rather than a single u8.
3744 let big_payload = encode_big_payload().unwrap();
3745 let mut rd = Cursor::new(&big_payload[..]);
3746 <msgs::OnionHopData as Readable>::read(&mut rd).unwrap();
3748 // see above test, needs to be a separate method for use of the serialization macros.
3749 fn encode_big_payload() -> Result<Vec<u8>, io::Error> {
3750 use crate::util::ser::HighZeroBytesDroppedBigSize;
3751 let payload = msgs::OnionHopData {
3752 format: OnionHopDataFormat::NonFinalNode {
3753 short_channel_id: 0xdeadbeef1bad1dea,
3755 amt_to_forward: 1000,
3756 outgoing_cltv_value: 0xffffffff,
3758 let mut encoded_payload = Vec::new();
3759 let test_bytes = vec![42u8; 1000];
3760 if let OnionHopDataFormat::NonFinalNode { short_channel_id } = payload.format {
3761 _encode_varint_length_prefixed_tlv!(&mut encoded_payload, {
3762 (1, test_bytes, required_vec),
3763 (2, HighZeroBytesDroppedBigSize(payload.amt_to_forward), required),
3764 (4, HighZeroBytesDroppedBigSize(payload.outgoing_cltv_value), required),
3765 (6, short_channel_id, required)