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 /// Excess data which was signed as a part of the message which we do not (yet) understand how
979 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
980 pub excess_data: Vec<u8>,
982 /// A [`channel_announcement`] message to be sent to or received from a peer.
984 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
985 #[derive(Clone, Debug, PartialEq, Eq)]
986 pub struct ChannelAnnouncement {
987 /// Authentication of the announcement by the first public node
988 pub node_signature_1: Signature,
989 /// Authentication of the announcement by the second public node
990 pub node_signature_2: Signature,
991 /// Proof of funding UTXO ownership by the first public node
992 pub bitcoin_signature_1: Signature,
993 /// Proof of funding UTXO ownership by the second public node
994 pub bitcoin_signature_2: Signature,
995 /// The actual announcement
996 pub contents: UnsignedChannelAnnouncement,
999 /// The unsigned part of a [`channel_update`] message.
1001 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1002 #[derive(Clone, Debug, PartialEq, Eq)]
1003 pub struct UnsignedChannelUpdate {
1004 /// The genesis hash of the blockchain where the channel is to be opened
1005 pub chain_hash: BlockHash,
1006 /// The short channel ID
1007 pub short_channel_id: u64,
1008 /// A strictly monotonic announcement counter, with gaps allowed, specific to this channel
1012 /// The number of blocks such that if:
1013 /// `incoming_htlc.cltv_expiry < outgoing_htlc.cltv_expiry + cltv_expiry_delta`
1014 /// then we need to fail the HTLC backwards. When forwarding an HTLC, `cltv_expiry_delta` determines
1015 /// the outgoing HTLC's minimum `cltv_expiry` value -- so, if an incoming HTLC comes in with a
1016 /// `cltv_expiry` of 100000, and the node we're forwarding to has a `cltv_expiry_delta` value of 10,
1017 /// then we'll check that the outgoing HTLC's `cltv_expiry` value is at least 100010 before
1018 /// forwarding. Note that the HTLC sender is the one who originally sets this value when
1019 /// constructing the route.
1020 pub cltv_expiry_delta: u16,
1021 /// The minimum HTLC size incoming to sender, in milli-satoshi
1022 pub htlc_minimum_msat: u64,
1023 /// The maximum HTLC value incoming to sender, in milli-satoshi.
1025 /// This used to be optional.
1026 pub htlc_maximum_msat: u64,
1027 /// The base HTLC fee charged by sender, in milli-satoshi
1028 pub fee_base_msat: u32,
1029 /// The amount to fee multiplier, in micro-satoshi
1030 pub fee_proportional_millionths: u32,
1031 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1034 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1035 pub excess_data: Vec<u8>,
1037 /// A [`channel_update`] message to be sent to or received from a peer.
1039 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1040 #[derive(Clone, Debug, PartialEq, Eq)]
1041 pub struct ChannelUpdate {
1042 /// A signature of the channel update
1043 pub signature: Signature,
1044 /// The actual channel update
1045 pub contents: UnsignedChannelUpdate,
1048 /// A [`query_channel_range`] message is used to query a peer for channel
1049 /// UTXOs in a range of blocks. The recipient of a query makes a best
1050 /// effort to reply to the query using one or more [`ReplyChannelRange`]
1053 /// [`query_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1054 #[derive(Clone, Debug, PartialEq, Eq)]
1055 pub struct QueryChannelRange {
1056 /// The genesis hash of the blockchain being queried
1057 pub chain_hash: BlockHash,
1058 /// The height of the first block for the channel UTXOs being queried
1059 pub first_blocknum: u32,
1060 /// The number of blocks to include in the query results
1061 pub number_of_blocks: u32,
1064 /// A [`reply_channel_range`] message is a reply to a [`QueryChannelRange`]
1067 /// Multiple `reply_channel_range` messages can be sent in reply
1068 /// to a single [`QueryChannelRange`] message. The query recipient makes a
1069 /// best effort to respond based on their local network view which may
1070 /// not be a perfect view of the network. The `short_channel_id`s in the
1071 /// reply are encoded. We only support `encoding_type=0` uncompressed
1072 /// serialization and do not support `encoding_type=1` zlib serialization.
1074 /// [`reply_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1075 #[derive(Clone, Debug, PartialEq, Eq)]
1076 pub struct ReplyChannelRange {
1077 /// The genesis hash of the blockchain being queried
1078 pub chain_hash: BlockHash,
1079 /// The height of the first block in the range of the reply
1080 pub first_blocknum: u32,
1081 /// The number of blocks included in the range of the reply
1082 pub number_of_blocks: u32,
1083 /// True when this is the final reply for a query
1084 pub sync_complete: bool,
1085 /// The `short_channel_id`s in the channel range
1086 pub short_channel_ids: Vec<u64>,
1089 /// A [`query_short_channel_ids`] message is used to query a peer for
1090 /// routing gossip messages related to one or more `short_channel_id`s.
1092 /// The query recipient will reply with the latest, if available,
1093 /// [`ChannelAnnouncement`], [`ChannelUpdate`] and [`NodeAnnouncement`] messages
1094 /// it maintains for the requested `short_channel_id`s followed by a
1095 /// [`ReplyShortChannelIdsEnd`] message. The `short_channel_id`s sent in
1096 /// this query are encoded. We only support `encoding_type=0` uncompressed
1097 /// serialization and do not support `encoding_type=1` zlib serialization.
1099 /// [`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
1100 #[derive(Clone, Debug, PartialEq, Eq)]
1101 pub struct QueryShortChannelIds {
1102 /// The genesis hash of the blockchain being queried
1103 pub chain_hash: BlockHash,
1104 /// The short_channel_ids that are being queried
1105 pub short_channel_ids: Vec<u64>,
1108 /// A [`reply_short_channel_ids_end`] message is sent as a reply to a
1109 /// message. The query recipient makes a best
1110 /// effort to respond based on their local network view which may not be
1111 /// a perfect view of the network.
1113 /// [`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
1114 #[derive(Clone, Debug, PartialEq, Eq)]
1115 pub struct ReplyShortChannelIdsEnd {
1116 /// The genesis hash of the blockchain that was queried
1117 pub chain_hash: BlockHash,
1118 /// Indicates if the query recipient maintains up-to-date channel
1119 /// information for the `chain_hash`
1120 pub full_information: bool,
1123 /// A [`gossip_timestamp_filter`] message is used by a node to request
1124 /// gossip relay for messages in the requested time range when the
1125 /// `gossip_queries` feature has been negotiated.
1127 /// [`gossip_timestamp_filter`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-gossip_timestamp_filter-message
1128 #[derive(Clone, Debug, PartialEq, Eq)]
1129 pub struct GossipTimestampFilter {
1130 /// The genesis hash of the blockchain for channel and node information
1131 pub chain_hash: BlockHash,
1132 /// The starting unix timestamp
1133 pub first_timestamp: u32,
1134 /// The range of information in seconds
1135 pub timestamp_range: u32,
1138 /// Encoding type for data compression of collections in gossip queries.
1140 /// We do not support `encoding_type=1` zlib serialization [defined in BOLT
1141 /// #7](https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#query-messages).
1143 Uncompressed = 0x00,
1146 /// Used to put an error message in a [`LightningError`].
1147 #[derive(Clone, Debug)]
1148 pub enum ErrorAction {
1149 /// The peer took some action which made us think they were useless. Disconnect them.
1151 /// An error message which we should make an effort to send before we disconnect.
1152 msg: Option<ErrorMessage>
1154 /// The peer did something incorrect. Tell them without closing any channels and disconnect them.
1155 DisconnectPeerWithWarning {
1156 /// A warning message which we should make an effort to send before we disconnect.
1157 msg: WarningMessage,
1159 /// The peer did something harmless that we weren't able to process, just log and ignore
1160 // New code should *not* use this. New code must use IgnoreAndLog, below!
1162 /// The peer did something harmless that we weren't able to meaningfully process.
1163 /// If the error is logged, log it at the given level.
1164 IgnoreAndLog(logger::Level),
1165 /// The peer provided us with a gossip message which we'd already seen. In most cases this
1166 /// should be ignored, but it may result in the message being forwarded if it is a duplicate of
1167 /// our own channel announcements.
1168 IgnoreDuplicateGossip,
1169 /// The peer did something incorrect. Tell them.
1171 /// The message to send.
1174 /// The peer did something incorrect. Tell them without closing any channels.
1175 SendWarningMessage {
1176 /// The message to send.
1177 msg: WarningMessage,
1178 /// The peer may have done something harmless that we weren't able to meaningfully process,
1179 /// though we should still tell them about it.
1180 /// If this event is logged, log it at the given level.
1181 log_level: logger::Level,
1185 /// An Err type for failure to process messages.
1186 #[derive(Clone, Debug)]
1187 pub struct LightningError {
1188 /// A human-readable message describing the error
1190 /// The action which should be taken against the offending peer.
1191 pub action: ErrorAction,
1194 /// Struct used to return values from [`RevokeAndACK`] messages, containing a bunch of commitment
1195 /// transaction updates if they were pending.
1196 #[derive(Clone, Debug, PartialEq, Eq)]
1197 pub struct CommitmentUpdate {
1198 /// `update_add_htlc` messages which should be sent
1199 pub update_add_htlcs: Vec<UpdateAddHTLC>,
1200 /// `update_fulfill_htlc` messages which should be sent
1201 pub update_fulfill_htlcs: Vec<UpdateFulfillHTLC>,
1202 /// `update_fail_htlc` messages which should be sent
1203 pub update_fail_htlcs: Vec<UpdateFailHTLC>,
1204 /// `update_fail_malformed_htlc` messages which should be sent
1205 pub update_fail_malformed_htlcs: Vec<UpdateFailMalformedHTLC>,
1206 /// An `update_fee` message which should be sent
1207 pub update_fee: Option<UpdateFee>,
1208 /// A `commitment_signed` message which should be sent
1209 pub commitment_signed: CommitmentSigned,
1212 /// A trait to describe an object which can receive channel messages.
1214 /// Messages MAY be called in parallel when they originate from different `their_node_ids`, however
1215 /// they MUST NOT be called in parallel when the two calls have the same `their_node_id`.
1216 pub trait ChannelMessageHandler : MessageSendEventsProvider {
1218 /// Handle an incoming `open_channel` message from the given peer.
1219 fn handle_open_channel(&self, their_node_id: &PublicKey, msg: &OpenChannel);
1220 /// Handle an incoming `open_channel2` message from the given peer.
1221 fn handle_open_channel_v2(&self, their_node_id: &PublicKey, msg: &OpenChannelV2);
1222 /// Handle an incoming `accept_channel` message from the given peer.
1223 fn handle_accept_channel(&self, their_node_id: &PublicKey, msg: &AcceptChannel);
1224 /// Handle an incoming `accept_channel2` message from the given peer.
1225 fn handle_accept_channel_v2(&self, their_node_id: &PublicKey, msg: &AcceptChannelV2);
1226 /// Handle an incoming `funding_created` message from the given peer.
1227 fn handle_funding_created(&self, their_node_id: &PublicKey, msg: &FundingCreated);
1228 /// Handle an incoming `funding_signed` message from the given peer.
1229 fn handle_funding_signed(&self, their_node_id: &PublicKey, msg: &FundingSigned);
1230 /// Handle an incoming `channel_ready` message from the given peer.
1231 fn handle_channel_ready(&self, their_node_id: &PublicKey, msg: &ChannelReady);
1234 /// Handle an incoming `shutdown` message from the given peer.
1235 fn handle_shutdown(&self, their_node_id: &PublicKey, msg: &Shutdown);
1236 /// Handle an incoming `closing_signed` message from the given peer.
1237 fn handle_closing_signed(&self, their_node_id: &PublicKey, msg: &ClosingSigned);
1239 // Interactive channel construction
1240 /// Handle an incoming `tx_add_input message` from the given peer.
1241 fn handle_tx_add_input(&self, their_node_id: &PublicKey, msg: &TxAddInput);
1242 /// Handle an incoming `tx_add_output` message from the given peer.
1243 fn handle_tx_add_output(&self, their_node_id: &PublicKey, msg: &TxAddOutput);
1244 /// Handle an incoming `tx_remove_input` message from the given peer.
1245 fn handle_tx_remove_input(&self, their_node_id: &PublicKey, msg: &TxRemoveInput);
1246 /// Handle an incoming `tx_remove_output` message from the given peer.
1247 fn handle_tx_remove_output(&self, their_node_id: &PublicKey, msg: &TxRemoveOutput);
1248 /// Handle an incoming `tx_complete message` from the given peer.
1249 fn handle_tx_complete(&self, their_node_id: &PublicKey, msg: &TxComplete);
1250 /// Handle an incoming `tx_signatures` message from the given peer.
1251 fn handle_tx_signatures(&self, their_node_id: &PublicKey, msg: &TxSignatures);
1252 /// Handle an incoming `tx_init_rbf` message from the given peer.
1253 fn handle_tx_init_rbf(&self, their_node_id: &PublicKey, msg: &TxInitRbf);
1254 /// Handle an incoming `tx_ack_rbf` message from the given peer.
1255 fn handle_tx_ack_rbf(&self, their_node_id: &PublicKey, msg: &TxAckRbf);
1256 /// Handle an incoming `tx_abort message` from the given peer.
1257 fn handle_tx_abort(&self, their_node_id: &PublicKey, msg: &TxAbort);
1260 /// Handle an incoming `update_add_htlc` message from the given peer.
1261 fn handle_update_add_htlc(&self, their_node_id: &PublicKey, msg: &UpdateAddHTLC);
1262 /// Handle an incoming `update_fulfill_htlc` message from the given peer.
1263 fn handle_update_fulfill_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFulfillHTLC);
1264 /// Handle an incoming `update_fail_htlc` message from the given peer.
1265 fn handle_update_fail_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailHTLC);
1266 /// Handle an incoming `update_fail_malformed_htlc` message from the given peer.
1267 fn handle_update_fail_malformed_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailMalformedHTLC);
1268 /// Handle an incoming `commitment_signed` message from the given peer.
1269 fn handle_commitment_signed(&self, their_node_id: &PublicKey, msg: &CommitmentSigned);
1270 /// Handle an incoming `revoke_and_ack` message from the given peer.
1271 fn handle_revoke_and_ack(&self, their_node_id: &PublicKey, msg: &RevokeAndACK);
1273 /// Handle an incoming `update_fee` message from the given peer.
1274 fn handle_update_fee(&self, their_node_id: &PublicKey, msg: &UpdateFee);
1276 // Channel-to-announce:
1277 /// Handle an incoming `announcement_signatures` message from the given peer.
1278 fn handle_announcement_signatures(&self, their_node_id: &PublicKey, msg: &AnnouncementSignatures);
1280 // Connection loss/reestablish:
1281 /// Indicates a connection to the peer failed/an existing connection was lost.
1282 fn peer_disconnected(&self, their_node_id: &PublicKey);
1284 /// Handle a peer reconnecting, possibly generating `channel_reestablish` message(s).
1286 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1287 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1288 /// message handlers may still wish to communicate with this peer.
1289 fn peer_connected(&self, their_node_id: &PublicKey, msg: &Init, inbound: bool) -> Result<(), ()>;
1290 /// Handle an incoming `channel_reestablish` message from the given peer.
1291 fn handle_channel_reestablish(&self, their_node_id: &PublicKey, msg: &ChannelReestablish);
1293 /// Handle an incoming `channel_update` message from the given peer.
1294 fn handle_channel_update(&self, their_node_id: &PublicKey, msg: &ChannelUpdate);
1297 /// Handle an incoming `error` message from the given peer.
1298 fn handle_error(&self, their_node_id: &PublicKey, msg: &ErrorMessage);
1300 // Handler information:
1301 /// Gets the node feature flags which this handler itself supports. All available handlers are
1302 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1303 /// which are broadcasted in our [`NodeAnnouncement`] message.
1304 fn provided_node_features(&self) -> NodeFeatures;
1306 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1307 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1308 /// which are sent in our [`Init`] message.
1310 /// Note that this method is called before [`Self::peer_connected`].
1311 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1313 /// Gets the genesis hashes for this `ChannelMessageHandler` indicating which chains it supports.
1315 /// If it's `None`, then no particular network chain hash compatibility will be enforced when
1316 /// connecting to peers.
1317 fn get_genesis_hashes(&self) -> Option<Vec<ChainHash>>;
1320 /// A trait to describe an object which can receive routing messages.
1322 /// # Implementor DoS Warnings
1324 /// For messages enabled with the `gossip_queries` feature there are potential DoS vectors when
1325 /// handling inbound queries. Implementors using an on-disk network graph should be aware of
1326 /// repeated disk I/O for queries accessing different parts of the network graph.
1327 pub trait RoutingMessageHandler : MessageSendEventsProvider {
1328 /// Handle an incoming `node_announcement` message, returning `true` if it should be forwarded on,
1329 /// `false` or returning an `Err` otherwise.
1330 fn handle_node_announcement(&self, msg: &NodeAnnouncement) -> Result<bool, LightningError>;
1331 /// Handle a `channel_announcement` message, returning `true` if it should be forwarded on, `false`
1332 /// or returning an `Err` otherwise.
1333 fn handle_channel_announcement(&self, msg: &ChannelAnnouncement) -> Result<bool, LightningError>;
1334 /// Handle an incoming `channel_update` message, returning true if it should be forwarded on,
1335 /// `false` or returning an `Err` otherwise.
1336 fn handle_channel_update(&self, msg: &ChannelUpdate) -> Result<bool, LightningError>;
1337 /// Gets channel announcements and updates required to dump our routing table to a remote node,
1338 /// starting at the `short_channel_id` indicated by `starting_point` and including announcements
1339 /// for a single channel.
1340 fn get_next_channel_announcement(&self, starting_point: u64) -> Option<(ChannelAnnouncement, Option<ChannelUpdate>, Option<ChannelUpdate>)>;
1341 /// Gets a node announcement required to dump our routing table to a remote node, starting at
1342 /// the node *after* the provided pubkey and including up to one announcement immediately
1343 /// higher (as defined by `<PublicKey as Ord>::cmp`) than `starting_point`.
1344 /// If `None` is provided for `starting_point`, we start at the first node.
1345 fn get_next_node_announcement(&self, starting_point: Option<&NodeId>) -> Option<NodeAnnouncement>;
1346 /// Called when a connection is established with a peer. This can be used to
1347 /// perform routing table synchronization using a strategy defined by the
1350 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1351 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1352 /// message handlers may still wish to communicate with this peer.
1353 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1354 /// Handles the reply of a query we initiated to learn about channels
1355 /// for a given range of blocks. We can expect to receive one or more
1356 /// replies to a single query.
1357 fn handle_reply_channel_range(&self, their_node_id: &PublicKey, msg: ReplyChannelRange) -> Result<(), LightningError>;
1358 /// Handles the reply of a query we initiated asking for routing gossip
1359 /// messages for a list of channels. We should receive this message when
1360 /// a node has completed its best effort to send us the pertaining routing
1361 /// gossip messages.
1362 fn handle_reply_short_channel_ids_end(&self, their_node_id: &PublicKey, msg: ReplyShortChannelIdsEnd) -> Result<(), LightningError>;
1363 /// Handles when a peer asks us to send a list of `short_channel_id`s
1364 /// for the requested range of blocks.
1365 fn handle_query_channel_range(&self, their_node_id: &PublicKey, msg: QueryChannelRange) -> Result<(), LightningError>;
1366 /// Handles when a peer asks us to send routing gossip messages for a
1367 /// list of `short_channel_id`s.
1368 fn handle_query_short_channel_ids(&self, their_node_id: &PublicKey, msg: QueryShortChannelIds) -> Result<(), LightningError>;
1370 // Handler queueing status:
1371 /// Indicates that there are a large number of [`ChannelAnnouncement`] (or other) messages
1372 /// pending some async action. While there is no guarantee of the rate of future messages, the
1373 /// caller should seek to reduce the rate of new gossip messages handled, especially
1374 /// [`ChannelAnnouncement`]s.
1375 fn processing_queue_high(&self) -> bool;
1377 // Handler information:
1378 /// Gets the node feature flags which this handler itself supports. All available handlers are
1379 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1380 /// which are broadcasted in our [`NodeAnnouncement`] message.
1381 fn provided_node_features(&self) -> NodeFeatures;
1382 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1383 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1384 /// which are sent in our [`Init`] message.
1386 /// Note that this method is called before [`Self::peer_connected`].
1387 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1390 /// A trait to describe an object that can receive onion messages.
1391 pub trait OnionMessageHandler : OnionMessageProvider {
1392 /// Handle an incoming `onion_message` message from the given peer.
1393 fn handle_onion_message(&self, peer_node_id: &PublicKey, msg: &OnionMessage);
1394 /// Called when a connection is established with a peer. Can be used to track which peers
1395 /// advertise onion message support and are online.
1397 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1398 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1399 /// message handlers may still wish to communicate with this peer.
1400 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1401 /// Indicates a connection to the peer failed/an existing connection was lost. Allows handlers to
1402 /// drop and refuse to forward onion messages to this peer.
1403 fn peer_disconnected(&self, their_node_id: &PublicKey);
1405 // Handler information:
1406 /// Gets the node feature flags which this handler itself supports. All available handlers are
1407 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1408 /// which are broadcasted in our [`NodeAnnouncement`] message.
1409 fn provided_node_features(&self) -> NodeFeatures;
1411 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1412 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1413 /// which are sent in our [`Init`] message.
1415 /// Note that this method is called before [`Self::peer_connected`].
1416 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1419 mod fuzzy_internal_msgs {
1420 use crate::prelude::*;
1421 use crate::ln::{PaymentPreimage, PaymentSecret};
1423 // These types aren't intended to be pub, but are exposed for direct fuzzing (as we deserialize
1424 // them from untrusted input):
1426 pub struct FinalOnionHopData {
1427 pub payment_secret: PaymentSecret,
1428 /// The total value, in msat, of the payment as received by the ultimate recipient.
1429 /// Message serialization may panic if this value is more than 21 million Bitcoin.
1430 pub total_msat: u64,
1433 pub enum InboundOnionPayload {
1435 short_channel_id: u64,
1436 /// The value, in msat, of the payment after this hop's fee is deducted.
1437 amt_to_forward: u64,
1438 outgoing_cltv_value: u32,
1441 payment_data: Option<FinalOnionHopData>,
1442 payment_metadata: Option<Vec<u8>>,
1443 keysend_preimage: Option<PaymentPreimage>,
1445 outgoing_cltv_value: u32,
1449 pub(crate) enum OutboundOnionPayload {
1451 short_channel_id: u64,
1452 /// The value, in msat, of the payment after this hop's fee is deducted.
1453 amt_to_forward: u64,
1454 outgoing_cltv_value: u32,
1457 payment_data: Option<FinalOnionHopData>,
1458 payment_metadata: Option<Vec<u8>>,
1459 keysend_preimage: Option<PaymentPreimage>,
1461 outgoing_cltv_value: u32,
1465 pub struct DecodedOnionErrorPacket {
1466 pub(crate) hmac: [u8; 32],
1467 pub(crate) failuremsg: Vec<u8>,
1468 pub(crate) pad: Vec<u8>,
1472 pub use self::fuzzy_internal_msgs::*;
1473 #[cfg(not(fuzzing))]
1474 pub(crate) use self::fuzzy_internal_msgs::*;
1477 pub(crate) struct OnionPacket {
1478 pub(crate) version: u8,
1479 /// In order to ensure we always return an error on onion decode in compliance with [BOLT
1480 /// #4](https://github.com/lightning/bolts/blob/master/04-onion-routing.md), we have to
1481 /// deserialize `OnionPacket`s contained in [`UpdateAddHTLC`] messages even if the ephemeral
1482 /// public key (here) is bogus, so we hold a [`Result`] instead of a [`PublicKey`] as we'd
1484 pub(crate) public_key: Result<PublicKey, secp256k1::Error>,
1485 pub(crate) hop_data: [u8; 20*65],
1486 pub(crate) hmac: [u8; 32],
1489 impl onion_utils::Packet for OnionPacket {
1490 type Data = onion_utils::FixedSizeOnionPacket;
1491 fn new(pubkey: PublicKey, hop_data: onion_utils::FixedSizeOnionPacket, hmac: [u8; 32]) -> Self {
1494 public_key: Ok(pubkey),
1495 hop_data: hop_data.0,
1501 impl Eq for OnionPacket { }
1502 impl PartialEq for OnionPacket {
1503 fn eq(&self, other: &OnionPacket) -> bool {
1504 for (i, j) in self.hop_data.iter().zip(other.hop_data.iter()) {
1505 if i != j { return false; }
1507 self.version == other.version &&
1508 self.public_key == other.public_key &&
1509 self.hmac == other.hmac
1513 impl fmt::Debug for OnionPacket {
1514 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1515 f.write_fmt(format_args!("OnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
1519 #[derive(Clone, Debug, PartialEq, Eq)]
1520 pub(crate) struct OnionErrorPacket {
1521 // This really should be a constant size slice, but the spec lets these things be up to 128KB?
1522 // (TODO) We limit it in decode to much lower...
1523 pub(crate) data: Vec<u8>,
1526 impl fmt::Display for DecodeError {
1527 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1529 DecodeError::UnknownVersion => f.write_str("Unknown realm byte in Onion packet"),
1530 DecodeError::UnknownRequiredFeature => f.write_str("Unknown required feature preventing decode"),
1531 DecodeError::InvalidValue => f.write_str("Nonsense bytes didn't map to the type they were interpreted as"),
1532 DecodeError::ShortRead => f.write_str("Packet extended beyond the provided bytes"),
1533 DecodeError::BadLengthDescriptor => f.write_str("A length descriptor in the packet didn't describe the later data correctly"),
1534 DecodeError::Io(ref e) => fmt::Debug::fmt(e, f),
1535 DecodeError::UnsupportedCompression => f.write_str("We don't support receiving messages with zlib-compressed fields"),
1540 impl From<io::Error> for DecodeError {
1541 fn from(e: io::Error) -> Self {
1542 if e.kind() == io::ErrorKind::UnexpectedEof {
1543 DecodeError::ShortRead
1545 DecodeError::Io(e.kind())
1550 #[cfg(not(taproot))]
1551 impl_writeable_msg!(AcceptChannel, {
1552 temporary_channel_id,
1553 dust_limit_satoshis,
1554 max_htlc_value_in_flight_msat,
1555 channel_reserve_satoshis,
1561 revocation_basepoint,
1563 delayed_payment_basepoint,
1565 first_per_commitment_point,
1567 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1568 (1, channel_type, option),
1572 impl_writeable_msg!(AcceptChannel, {
1573 temporary_channel_id,
1574 dust_limit_satoshis,
1575 max_htlc_value_in_flight_msat,
1576 channel_reserve_satoshis,
1582 revocation_basepoint,
1584 delayed_payment_basepoint,
1586 first_per_commitment_point,
1588 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1589 (1, channel_type, option),
1590 (4, next_local_nonce, option),
1593 impl_writeable_msg!(AcceptChannelV2, {
1594 temporary_channel_id,
1596 dust_limit_satoshis,
1597 max_htlc_value_in_flight_msat,
1603 revocation_basepoint,
1605 delayed_payment_basepoint,
1607 first_per_commitment_point,
1608 second_per_commitment_point,
1610 (0, shutdown_scriptpubkey, option),
1611 (1, channel_type, option),
1612 (2, require_confirmed_inputs, option),
1615 impl_writeable_msg!(TxAddInput, {
1623 impl_writeable_msg!(TxAddOutput, {
1630 impl_writeable_msg!(TxRemoveInput, {
1635 impl_writeable_msg!(TxRemoveOutput, {
1640 impl_writeable_msg!(TxComplete, {
1644 impl_writeable_msg!(TxSignatures, {
1650 impl_writeable_msg!(TxInitRbf, {
1653 feerate_sat_per_1000_weight,
1655 (0, funding_output_contribution, option),
1658 impl_writeable_msg!(TxAckRbf, {
1661 (0, funding_output_contribution, option),
1664 impl_writeable_msg!(TxAbort, {
1669 impl_writeable_msg!(AnnouncementSignatures, {
1676 impl_writeable_msg!(ChannelReestablish, {
1678 next_local_commitment_number,
1679 next_remote_commitment_number,
1680 your_last_per_commitment_secret,
1681 my_current_per_commitment_point,
1683 (0, next_funding_txid, option),
1686 impl_writeable_msg!(ClosingSigned,
1687 { channel_id, fee_satoshis, signature },
1688 { (1, fee_range, option) }
1691 impl_writeable!(ClosingSignedFeeRange, {
1696 #[cfg(not(taproot))]
1697 impl_writeable_msg!(CommitmentSigned, {
1704 impl_writeable_msg!(CommitmentSigned, {
1709 (2, partial_signature_with_nonce, option)
1712 impl_writeable!(DecodedOnionErrorPacket, {
1718 #[cfg(not(taproot))]
1719 impl_writeable_msg!(FundingCreated, {
1720 temporary_channel_id,
1722 funding_output_index,
1726 impl_writeable_msg!(FundingCreated, {
1727 temporary_channel_id,
1729 funding_output_index,
1732 (2, partial_signature_with_nonce, option),
1733 (4, next_local_nonce, option)
1736 #[cfg(not(taproot))]
1737 impl_writeable_msg!(FundingSigned, {
1743 impl_writeable_msg!(FundingSigned, {
1747 (2, partial_signature_with_nonce, option)
1750 impl_writeable_msg!(ChannelReady, {
1752 next_per_commitment_point,
1754 (1, short_channel_id_alias, option),
1757 impl Writeable for Init {
1758 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1759 // global_features gets the bottom 13 bits of our features, and local_features gets all of
1760 // our relevant feature bits. This keeps us compatible with old nodes.
1761 self.features.write_up_to_13(w)?;
1762 self.features.write(w)?;
1763 encode_tlv_stream!(w, {
1764 (1, self.networks.as_ref().map(|n| WithoutLength(n)), option),
1765 (3, self.remote_network_address, option),
1771 impl Readable for Init {
1772 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1773 let global_features: InitFeatures = Readable::read(r)?;
1774 let features: InitFeatures = Readable::read(r)?;
1775 let mut remote_network_address: Option<NetAddress> = None;
1776 let mut networks: Option<WithoutLength<Vec<ChainHash>>> = None;
1777 decode_tlv_stream!(r, {
1778 (1, networks, option),
1779 (3, remote_network_address, option)
1782 features: features | global_features,
1783 networks: networks.map(|n| n.0),
1784 remote_network_address,
1789 impl_writeable_msg!(OpenChannel, {
1791 temporary_channel_id,
1794 dust_limit_satoshis,
1795 max_htlc_value_in_flight_msat,
1796 channel_reserve_satoshis,
1802 revocation_basepoint,
1804 delayed_payment_basepoint,
1806 first_per_commitment_point,
1809 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1810 (1, channel_type, option),
1813 impl_writeable_msg!(OpenChannelV2, {
1815 temporary_channel_id,
1816 funding_feerate_sat_per_1000_weight,
1817 commitment_feerate_sat_per_1000_weight,
1819 dust_limit_satoshis,
1820 max_htlc_value_in_flight_msat,
1826 revocation_basepoint,
1828 delayed_payment_basepoint,
1830 first_per_commitment_point,
1831 second_per_commitment_point,
1834 (0, shutdown_scriptpubkey, option),
1835 (1, channel_type, option),
1836 (2, require_confirmed_inputs, option),
1839 #[cfg(not(taproot))]
1840 impl_writeable_msg!(RevokeAndACK, {
1842 per_commitment_secret,
1843 next_per_commitment_point
1847 impl_writeable_msg!(RevokeAndACK, {
1849 per_commitment_secret,
1850 next_per_commitment_point
1852 (4, next_local_nonce, option)
1855 impl_writeable_msg!(Shutdown, {
1860 impl_writeable_msg!(UpdateFailHTLC, {
1866 impl_writeable_msg!(UpdateFailMalformedHTLC, {
1873 impl_writeable_msg!(UpdateFee, {
1878 impl_writeable_msg!(UpdateFulfillHTLC, {
1884 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
1885 // serialization format in a way which assumes we know the total serialized length/message end
1887 impl_writeable!(OnionErrorPacket, {
1891 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
1892 // serialization format in a way which assumes we know the total serialized length/message end
1894 impl Writeable for OnionPacket {
1895 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1896 self.version.write(w)?;
1897 match self.public_key {
1898 Ok(pubkey) => pubkey.write(w)?,
1899 Err(_) => [0u8;33].write(w)?,
1901 w.write_all(&self.hop_data)?;
1902 self.hmac.write(w)?;
1907 impl Readable for OnionPacket {
1908 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1910 version: Readable::read(r)?,
1912 let mut buf = [0u8;33];
1913 r.read_exact(&mut buf)?;
1914 PublicKey::from_slice(&buf)
1916 hop_data: Readable::read(r)?,
1917 hmac: Readable::read(r)?,
1922 impl_writeable_msg!(UpdateAddHTLC, {
1928 onion_routing_packet,
1930 (65537, skimmed_fee_msat, option)
1933 impl Readable for OnionMessage {
1934 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1935 let blinding_point: PublicKey = Readable::read(r)?;
1936 let len: u16 = Readable::read(r)?;
1937 let mut packet_reader = FixedLengthReader::new(r, len as u64);
1938 let onion_routing_packet: onion_message::Packet = <onion_message::Packet as LengthReadable>::read(&mut packet_reader)?;
1941 onion_routing_packet,
1946 impl Writeable for OnionMessage {
1947 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1948 self.blinding_point.write(w)?;
1949 let onion_packet_len = self.onion_routing_packet.serialized_length();
1950 (onion_packet_len as u16).write(w)?;
1951 self.onion_routing_packet.write(w)?;
1956 impl Writeable for FinalOnionHopData {
1957 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1958 self.payment_secret.0.write(w)?;
1959 HighZeroBytesDroppedBigSize(self.total_msat).write(w)
1963 impl Readable for FinalOnionHopData {
1964 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1965 let secret: [u8; 32] = Readable::read(r)?;
1966 let amt: HighZeroBytesDroppedBigSize<u64> = Readable::read(r)?;
1967 Ok(Self { payment_secret: PaymentSecret(secret), total_msat: amt.0 })
1971 impl Writeable for OutboundOnionPayload {
1972 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1974 Self::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } => {
1975 _encode_varint_length_prefixed_tlv!(w, {
1976 (2, HighZeroBytesDroppedBigSize(*amt_to_forward), required),
1977 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
1978 (6, short_channel_id, required)
1982 ref payment_data, ref payment_metadata, ref keysend_preimage, amt_msat, outgoing_cltv_value
1984 _encode_varint_length_prefixed_tlv!(w, {
1985 (2, HighZeroBytesDroppedBigSize(*amt_msat), required),
1986 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
1987 (8, payment_data, option),
1988 (16, payment_metadata.as_ref().map(|m| WithoutLength(m)), option),
1989 (5482373484, keysend_preimage, option)
1997 impl Readable for InboundOnionPayload {
1998 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1999 let mut amt = HighZeroBytesDroppedBigSize(0u64);
2000 let mut cltv_value = HighZeroBytesDroppedBigSize(0u32);
2001 let mut short_id: Option<u64> = None;
2002 let mut payment_data: Option<FinalOnionHopData> = None;
2003 let mut payment_metadata: Option<WithoutLength<Vec<u8>>> = None;
2004 let mut keysend_preimage: Option<PaymentPreimage> = None;
2005 read_tlv_fields!(r, {
2007 (4, cltv_value, required),
2008 (6, short_id, option),
2009 (8, payment_data, option),
2010 (16, payment_metadata, option),
2011 // See https://github.com/lightning/blips/blob/master/blip-0003.md
2012 (5482373484, keysend_preimage, option)
2015 if amt.0 > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2016 if let Some(short_channel_id) = short_id {
2017 if payment_data.is_some() { return Err(DecodeError::InvalidValue) }
2018 if payment_metadata.is_some() { return Err(DecodeError::InvalidValue); }
2021 amt_to_forward: amt.0,
2022 outgoing_cltv_value: cltv_value.0,
2025 if let Some(data) = &payment_data {
2026 if data.total_msat > MAX_VALUE_MSAT {
2027 return Err(DecodeError::InvalidValue);
2032 payment_metadata: payment_metadata.map(|w| w.0),
2035 outgoing_cltv_value: cltv_value.0,
2041 // ReadableArgs because we need onion_utils::decode_next_hop to accommodate payment packets and
2042 // onion message packets.
2043 impl ReadableArgs<()> for InboundOnionPayload {
2044 fn read<R: Read>(r: &mut R, _arg: ()) -> Result<Self, DecodeError> {
2045 <Self as Readable>::read(r)
2049 impl Writeable for Ping {
2050 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2051 self.ponglen.write(w)?;
2052 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2057 impl Readable for Ping {
2058 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2060 ponglen: Readable::read(r)?,
2062 let byteslen = Readable::read(r)?;
2063 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2070 impl Writeable for Pong {
2071 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2072 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2077 impl Readable for Pong {
2078 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2081 let byteslen = Readable::read(r)?;
2082 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2089 impl Writeable for UnsignedChannelAnnouncement {
2090 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2091 self.features.write(w)?;
2092 self.chain_hash.write(w)?;
2093 self.short_channel_id.write(w)?;
2094 self.node_id_1.write(w)?;
2095 self.node_id_2.write(w)?;
2096 self.bitcoin_key_1.write(w)?;
2097 self.bitcoin_key_2.write(w)?;
2098 w.write_all(&self.excess_data[..])?;
2103 impl Readable for UnsignedChannelAnnouncement {
2104 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2106 features: Readable::read(r)?,
2107 chain_hash: Readable::read(r)?,
2108 short_channel_id: Readable::read(r)?,
2109 node_id_1: Readable::read(r)?,
2110 node_id_2: Readable::read(r)?,
2111 bitcoin_key_1: Readable::read(r)?,
2112 bitcoin_key_2: Readable::read(r)?,
2113 excess_data: read_to_end(r)?,
2118 impl_writeable!(ChannelAnnouncement, {
2121 bitcoin_signature_1,
2122 bitcoin_signature_2,
2126 impl Writeable for UnsignedChannelUpdate {
2127 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2128 // `message_flags` used to indicate presence of `htlc_maximum_msat`, but was deprecated in the spec.
2129 const MESSAGE_FLAGS: u8 = 1;
2130 self.chain_hash.write(w)?;
2131 self.short_channel_id.write(w)?;
2132 self.timestamp.write(w)?;
2133 let all_flags = self.flags as u16 | ((MESSAGE_FLAGS as u16) << 8);
2134 all_flags.write(w)?;
2135 self.cltv_expiry_delta.write(w)?;
2136 self.htlc_minimum_msat.write(w)?;
2137 self.fee_base_msat.write(w)?;
2138 self.fee_proportional_millionths.write(w)?;
2139 self.htlc_maximum_msat.write(w)?;
2140 w.write_all(&self.excess_data[..])?;
2145 impl Readable for UnsignedChannelUpdate {
2146 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2148 chain_hash: Readable::read(r)?,
2149 short_channel_id: Readable::read(r)?,
2150 timestamp: Readable::read(r)?,
2152 let flags: u16 = Readable::read(r)?;
2153 // Note: we ignore the `message_flags` for now, since it was deprecated by the spec.
2156 cltv_expiry_delta: Readable::read(r)?,
2157 htlc_minimum_msat: Readable::read(r)?,
2158 fee_base_msat: Readable::read(r)?,
2159 fee_proportional_millionths: Readable::read(r)?,
2160 htlc_maximum_msat: Readable::read(r)?,
2161 excess_data: read_to_end(r)?,
2166 impl_writeable!(ChannelUpdate, {
2171 impl Writeable for ErrorMessage {
2172 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2173 self.channel_id.write(w)?;
2174 (self.data.len() as u16).write(w)?;
2175 w.write_all(self.data.as_bytes())?;
2180 impl Readable for ErrorMessage {
2181 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2183 channel_id: Readable::read(r)?,
2185 let sz: usize = <u16 as Readable>::read(r)? as usize;
2186 let mut data = Vec::with_capacity(sz);
2188 r.read_exact(&mut data)?;
2189 match String::from_utf8(data) {
2191 Err(_) => return Err(DecodeError::InvalidValue),
2198 impl Writeable for WarningMessage {
2199 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2200 self.channel_id.write(w)?;
2201 (self.data.len() as u16).write(w)?;
2202 w.write_all(self.data.as_bytes())?;
2207 impl Readable for WarningMessage {
2208 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2210 channel_id: Readable::read(r)?,
2212 let sz: usize = <u16 as Readable>::read(r)? as usize;
2213 let mut data = Vec::with_capacity(sz);
2215 r.read_exact(&mut data)?;
2216 match String::from_utf8(data) {
2218 Err(_) => return Err(DecodeError::InvalidValue),
2225 impl Writeable for UnsignedNodeAnnouncement {
2226 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2227 self.features.write(w)?;
2228 self.timestamp.write(w)?;
2229 self.node_id.write(w)?;
2230 w.write_all(&self.rgb)?;
2231 self.alias.write(w)?;
2233 let mut addr_len = 0;
2234 for addr in self.addresses.iter() {
2235 addr_len += 1 + addr.len();
2237 (addr_len + self.excess_address_data.len() as u16).write(w)?;
2238 for addr in self.addresses.iter() {
2241 w.write_all(&self.excess_address_data[..])?;
2242 w.write_all(&self.excess_data[..])?;
2247 impl Readable for UnsignedNodeAnnouncement {
2248 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2249 let features: NodeFeatures = Readable::read(r)?;
2250 let timestamp: u32 = Readable::read(r)?;
2251 let node_id: NodeId = Readable::read(r)?;
2252 let mut rgb = [0; 3];
2253 r.read_exact(&mut rgb)?;
2254 let alias: NodeAlias = Readable::read(r)?;
2256 let addr_len: u16 = Readable::read(r)?;
2257 let mut addresses: Vec<NetAddress> = Vec::new();
2258 let mut addr_readpos = 0;
2259 let mut excess = false;
2260 let mut excess_byte = 0;
2262 if addr_len <= addr_readpos { break; }
2263 match Readable::read(r) {
2265 if addr_len < addr_readpos + 1 + addr.len() {
2266 return Err(DecodeError::BadLengthDescriptor);
2268 addr_readpos += (1 + addr.len()) as u16;
2269 addresses.push(addr);
2271 Ok(Err(unknown_descriptor)) => {
2273 excess_byte = unknown_descriptor;
2276 Err(DecodeError::ShortRead) => return Err(DecodeError::BadLengthDescriptor),
2277 Err(e) => return Err(e),
2281 let mut excess_data = vec![];
2282 let excess_address_data = if addr_readpos < addr_len {
2283 let mut excess_address_data = vec![0; (addr_len - addr_readpos) as usize];
2284 r.read_exact(&mut excess_address_data[if excess { 1 } else { 0 }..])?;
2286 excess_address_data[0] = excess_byte;
2291 excess_data.push(excess_byte);
2295 excess_data.extend(read_to_end(r)?.iter());
2296 Ok(UnsignedNodeAnnouncement {
2303 excess_address_data,
2309 impl_writeable!(NodeAnnouncement, {
2314 impl Readable for QueryShortChannelIds {
2315 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2316 let chain_hash: BlockHash = Readable::read(r)?;
2318 let encoding_len: u16 = Readable::read(r)?;
2319 let encoding_type: u8 = Readable::read(r)?;
2321 // Must be encoding_type=0 uncompressed serialization. We do not
2322 // support encoding_type=1 zlib serialization.
2323 if encoding_type != EncodingType::Uncompressed as u8 {
2324 return Err(DecodeError::UnsupportedCompression);
2327 // We expect the encoding_len to always includes the 1-byte
2328 // encoding_type and that short_channel_ids are 8-bytes each
2329 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2330 return Err(DecodeError::InvalidValue);
2333 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2334 // less the 1-byte encoding_type
2335 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2336 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2337 for _ in 0..short_channel_id_count {
2338 short_channel_ids.push(Readable::read(r)?);
2341 Ok(QueryShortChannelIds {
2348 impl Writeable for QueryShortChannelIds {
2349 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2350 // Calculated from 1-byte encoding_type plus 8-bytes per short_channel_id
2351 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2353 self.chain_hash.write(w)?;
2354 encoding_len.write(w)?;
2356 // We only support type=0 uncompressed serialization
2357 (EncodingType::Uncompressed as u8).write(w)?;
2359 for scid in self.short_channel_ids.iter() {
2367 impl_writeable_msg!(ReplyShortChannelIdsEnd, {
2372 impl QueryChannelRange {
2373 /// Calculates the overflow safe ending block height for the query.
2375 /// Overflow returns `0xffffffff`, otherwise returns `first_blocknum + number_of_blocks`.
2376 pub fn end_blocknum(&self) -> u32 {
2377 match self.first_blocknum.checked_add(self.number_of_blocks) {
2378 Some(block) => block,
2379 None => u32::max_value(),
2384 impl_writeable_msg!(QueryChannelRange, {
2390 impl Readable for ReplyChannelRange {
2391 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2392 let chain_hash: BlockHash = Readable::read(r)?;
2393 let first_blocknum: u32 = Readable::read(r)?;
2394 let number_of_blocks: u32 = Readable::read(r)?;
2395 let sync_complete: bool = Readable::read(r)?;
2397 let encoding_len: u16 = Readable::read(r)?;
2398 let encoding_type: u8 = Readable::read(r)?;
2400 // Must be encoding_type=0 uncompressed serialization. We do not
2401 // support encoding_type=1 zlib serialization.
2402 if encoding_type != EncodingType::Uncompressed as u8 {
2403 return Err(DecodeError::UnsupportedCompression);
2406 // We expect the encoding_len to always includes the 1-byte
2407 // encoding_type and that short_channel_ids are 8-bytes each
2408 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2409 return Err(DecodeError::InvalidValue);
2412 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2413 // less the 1-byte encoding_type
2414 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2415 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2416 for _ in 0..short_channel_id_count {
2417 short_channel_ids.push(Readable::read(r)?);
2420 Ok(ReplyChannelRange {
2430 impl Writeable for ReplyChannelRange {
2431 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2432 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2433 self.chain_hash.write(w)?;
2434 self.first_blocknum.write(w)?;
2435 self.number_of_blocks.write(w)?;
2436 self.sync_complete.write(w)?;
2438 encoding_len.write(w)?;
2439 (EncodingType::Uncompressed as u8).write(w)?;
2440 for scid in self.short_channel_ids.iter() {
2448 impl_writeable_msg!(GossipTimestampFilter, {
2456 use bitcoin::blockdata::constants::ChainHash;
2457 use bitcoin::{Transaction, PackedLockTime, TxIn, Script, Sequence, Witness, TxOut};
2459 use crate::ln::{PaymentPreimage, PaymentHash, PaymentSecret};
2460 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
2461 use crate::ln::msgs::{self, FinalOnionHopData, OnionErrorPacket};
2462 use crate::routing::gossip::{NodeAlias, NodeId};
2463 use crate::util::ser::{Writeable, Readable, Hostname, TransactionU16LenLimited};
2465 use bitcoin::hashes::hex::FromHex;
2466 use bitcoin::util::address::Address;
2467 use bitcoin::network::constants::Network;
2468 use bitcoin::blockdata::script::Builder;
2469 use bitcoin::blockdata::opcodes;
2470 use bitcoin::hash_types::{Txid, BlockHash};
2472 use bitcoin::secp256k1::{PublicKey,SecretKey};
2473 use bitcoin::secp256k1::{Secp256k1, Message};
2475 use crate::io::{self, Cursor};
2476 use crate::prelude::*;
2477 use core::convert::TryFrom;
2478 use core::str::FromStr;
2480 use crate::chain::transaction::OutPoint;
2483 fn encoding_channel_reestablish() {
2485 let secp_ctx = Secp256k1::new();
2486 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2489 let cr = msgs::ChannelReestablish {
2490 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],
2491 next_local_commitment_number: 3,
2492 next_remote_commitment_number: 4,
2493 your_last_per_commitment_secret: [9;32],
2494 my_current_per_commitment_point: public_key,
2495 next_funding_txid: None,
2498 let encoded_value = cr.encode();
2502 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
2503 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2504 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2505 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
2506 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
2512 fn encoding_channel_reestablish_with_next_funding_txid() {
2514 let secp_ctx = Secp256k1::new();
2515 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2518 let cr = msgs::ChannelReestablish {
2519 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],
2520 next_local_commitment_number: 3,
2521 next_remote_commitment_number: 4,
2522 your_last_per_commitment_secret: [9;32],
2523 my_current_per_commitment_point: public_key,
2524 next_funding_txid: Some(Txid::from_hash(bitcoin::hashes::Hash::from_slice(&[
2525 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,
2529 let encoded_value = cr.encode();
2533 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
2534 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2535 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2536 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
2537 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
2538 0, // Type (next_funding_txid)
2540 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
2545 macro_rules! get_keys_from {
2546 ($slice: expr, $secp_ctx: expr) => {
2548 let privkey = SecretKey::from_slice(&hex::decode($slice).unwrap()[..]).unwrap();
2549 let pubkey = PublicKey::from_secret_key(&$secp_ctx, &privkey);
2555 macro_rules! get_sig_on {
2556 ($privkey: expr, $ctx: expr, $string: expr) => {
2558 let sighash = Message::from_slice(&$string.into_bytes()[..]).unwrap();
2559 $ctx.sign_ecdsa(&sighash, &$privkey)
2565 fn encoding_announcement_signatures() {
2566 let secp_ctx = Secp256k1::new();
2567 let (privkey, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2568 let sig_1 = get_sig_on!(privkey, secp_ctx, String::from("01010101010101010101010101010101"));
2569 let sig_2 = get_sig_on!(privkey, secp_ctx, String::from("02020202020202020202020202020202"));
2570 let announcement_signatures = msgs::AnnouncementSignatures {
2571 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],
2572 short_channel_id: 2316138423780173,
2573 node_signature: sig_1,
2574 bitcoin_signature: sig_2,
2577 let encoded_value = announcement_signatures.encode();
2578 assert_eq!(encoded_value, hex::decode("040000000000000005000000000000000600000000000000070000000000000000083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073acf9953cef4700860f5967838eba2bae89288ad188ebf8b20bf995c3ea53a26df1876d0a3a0e13172ba286a673140190c02ba9da60a2e43a745188c8a83c7f3ef").unwrap());
2581 fn do_encoding_channel_announcement(unknown_features_bits: bool, excess_data: bool) {
2582 let secp_ctx = Secp256k1::new();
2583 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2584 let (privkey_2, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2585 let (privkey_3, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2586 let (privkey_4, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2587 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2588 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
2589 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
2590 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
2591 let mut features = ChannelFeatures::empty();
2592 if unknown_features_bits {
2593 features = ChannelFeatures::from_le_bytes(vec![0xFF, 0xFF]);
2595 let unsigned_channel_announcement = msgs::UnsignedChannelAnnouncement {
2597 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2598 short_channel_id: 2316138423780173,
2599 node_id_1: NodeId::from_pubkey(&pubkey_1),
2600 node_id_2: NodeId::from_pubkey(&pubkey_2),
2601 bitcoin_key_1: NodeId::from_pubkey(&pubkey_3),
2602 bitcoin_key_2: NodeId::from_pubkey(&pubkey_4),
2603 excess_data: if excess_data { vec![10, 0, 0, 20, 0, 0, 30, 0, 0, 40] } else { Vec::new() },
2605 let channel_announcement = msgs::ChannelAnnouncement {
2606 node_signature_1: sig_1,
2607 node_signature_2: sig_2,
2608 bitcoin_signature_1: sig_3,
2609 bitcoin_signature_2: sig_4,
2610 contents: unsigned_channel_announcement,
2612 let encoded_value = channel_announcement.encode();
2613 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a1735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap();
2614 if unknown_features_bits {
2615 target_value.append(&mut hex::decode("0002ffff").unwrap());
2617 target_value.append(&mut hex::decode("0000").unwrap());
2619 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2620 target_value.append(&mut hex::decode("00083a840000034d031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
2622 target_value.append(&mut hex::decode("0a00001400001e000028").unwrap());
2624 assert_eq!(encoded_value, target_value);
2628 fn encoding_channel_announcement() {
2629 do_encoding_channel_announcement(true, false);
2630 do_encoding_channel_announcement(false, true);
2631 do_encoding_channel_announcement(false, false);
2632 do_encoding_channel_announcement(true, true);
2635 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) {
2636 let secp_ctx = Secp256k1::new();
2637 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2638 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2639 let features = if unknown_features_bits {
2640 NodeFeatures::from_le_bytes(vec![0xFF, 0xFF])
2642 // Set to some features we may support
2643 NodeFeatures::from_le_bytes(vec![2 | 1 << 5])
2645 let mut addresses = Vec::new();
2647 addresses.push(msgs::NetAddress::IPv4 {
2648 addr: [255, 254, 253, 252],
2653 addresses.push(msgs::NetAddress::IPv6 {
2654 addr: [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240],
2659 addresses.push(msgs::NetAddress::OnionV2(
2660 [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 38, 7]
2664 addresses.push(msgs::NetAddress::OnionV3 {
2665 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],
2672 addresses.push(msgs::NetAddress::Hostname {
2673 hostname: Hostname::try_from(String::from("host")).unwrap(),
2677 let mut addr_len = 0;
2678 for addr in &addresses {
2679 addr_len += addr.len() + 1;
2681 let unsigned_node_announcement = msgs::UnsignedNodeAnnouncement {
2683 timestamp: 20190119,
2684 node_id: NodeId::from_pubkey(&pubkey_1),
2686 alias: NodeAlias([16;32]),
2688 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() },
2689 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() },
2691 addr_len += unsigned_node_announcement.excess_address_data.len() as u16;
2692 let node_announcement = msgs::NodeAnnouncement {
2694 contents: unsigned_node_announcement,
2696 let encoded_value = node_announcement.encode();
2697 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
2698 if unknown_features_bits {
2699 target_value.append(&mut hex::decode("0002ffff").unwrap());
2701 target_value.append(&mut hex::decode("000122").unwrap());
2703 target_value.append(&mut hex::decode("013413a7031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f2020201010101010101010101010101010101010101010101010101010101010101010").unwrap());
2704 target_value.append(&mut vec![(addr_len >> 8) as u8, addr_len as u8]);
2706 target_value.append(&mut hex::decode("01fffefdfc2607").unwrap());
2709 target_value.append(&mut hex::decode("02fffefdfcfbfaf9f8f7f6f5f4f3f2f1f02607").unwrap());
2712 target_value.append(&mut hex::decode("03fffefdfcfbfaf9f8f7f62607").unwrap());
2715 target_value.append(&mut hex::decode("04fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0efeeedecebeae9e8e7e6e5e4e3e2e1e00020102607").unwrap());
2718 target_value.append(&mut hex::decode("0504686f73742607").unwrap());
2720 if excess_address_data {
2721 target_value.append(&mut hex::decode("216c280b5395a2546e7e4b2663e04f811622f15a4f92e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d269").unwrap());
2724 target_value.append(&mut hex::decode("3b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
2726 assert_eq!(encoded_value, target_value);
2730 fn encoding_node_announcement() {
2731 do_encoding_node_announcement(true, true, true, true, true, true, true, true);
2732 do_encoding_node_announcement(false, false, false, false, false, false, false, false);
2733 do_encoding_node_announcement(false, true, false, false, false, false, false, false);
2734 do_encoding_node_announcement(false, false, true, false, false, false, false, false);
2735 do_encoding_node_announcement(false, false, false, true, false, false, false, false);
2736 do_encoding_node_announcement(false, false, false, false, true, false, false, false);
2737 do_encoding_node_announcement(false, false, false, false, false, true, false, false);
2738 do_encoding_node_announcement(false, false, false, false, false, false, true, false);
2739 do_encoding_node_announcement(false, true, false, true, false, false, true, false);
2740 do_encoding_node_announcement(false, false, true, false, true, false, false, false);
2743 fn do_encoding_channel_update(direction: bool, disable: bool, excess_data: bool) {
2744 let secp_ctx = Secp256k1::new();
2745 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2746 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2747 let unsigned_channel_update = msgs::UnsignedChannelUpdate {
2748 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2749 short_channel_id: 2316138423780173,
2750 timestamp: 20190119,
2751 flags: if direction { 1 } else { 0 } | if disable { 1 << 1 } else { 0 },
2752 cltv_expiry_delta: 144,
2753 htlc_minimum_msat: 1000000,
2754 htlc_maximum_msat: 131355275467161,
2755 fee_base_msat: 10000,
2756 fee_proportional_millionths: 20,
2757 excess_data: if excess_data { vec![0, 0, 0, 0, 59, 154, 202, 0] } else { Vec::new() }
2759 let channel_update = msgs::ChannelUpdate {
2761 contents: unsigned_channel_update
2763 let encoded_value = channel_update.encode();
2764 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
2765 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2766 target_value.append(&mut hex::decode("00083a840000034d013413a7").unwrap());
2767 target_value.append(&mut hex::decode("01").unwrap());
2768 target_value.append(&mut hex::decode("00").unwrap());
2770 let flag = target_value.last_mut().unwrap();
2774 let flag = target_value.last_mut().unwrap();
2775 *flag = *flag | 1 << 1;
2777 target_value.append(&mut hex::decode("009000000000000f42400000271000000014").unwrap());
2778 target_value.append(&mut hex::decode("0000777788889999").unwrap());
2780 target_value.append(&mut hex::decode("000000003b9aca00").unwrap());
2782 assert_eq!(encoded_value, target_value);
2786 fn encoding_channel_update() {
2787 do_encoding_channel_update(false, false, false);
2788 do_encoding_channel_update(false, false, true);
2789 do_encoding_channel_update(true, false, false);
2790 do_encoding_channel_update(true, false, true);
2791 do_encoding_channel_update(false, true, false);
2792 do_encoding_channel_update(false, true, true);
2793 do_encoding_channel_update(true, true, false);
2794 do_encoding_channel_update(true, true, true);
2797 fn do_encoding_open_channel(random_bit: bool, shutdown: bool, incl_chan_type: bool) {
2798 let secp_ctx = Secp256k1::new();
2799 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2800 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2801 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2802 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2803 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
2804 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
2805 let open_channel = msgs::OpenChannel {
2806 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2807 temporary_channel_id: [2; 32],
2808 funding_satoshis: 1311768467284833366,
2809 push_msat: 2536655962884945560,
2810 dust_limit_satoshis: 3608586615801332854,
2811 max_htlc_value_in_flight_msat: 8517154655701053848,
2812 channel_reserve_satoshis: 8665828695742877976,
2813 htlc_minimum_msat: 2316138423780173,
2814 feerate_per_kw: 821716,
2815 to_self_delay: 49340,
2816 max_accepted_htlcs: 49340,
2817 funding_pubkey: pubkey_1,
2818 revocation_basepoint: pubkey_2,
2819 payment_point: pubkey_3,
2820 delayed_payment_basepoint: pubkey_4,
2821 htlc_basepoint: pubkey_5,
2822 first_per_commitment_point: pubkey_6,
2823 channel_flags: if random_bit { 1 << 5 } else { 0 },
2824 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
2825 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
2827 let encoded_value = open_channel.encode();
2828 let mut target_value = Vec::new();
2829 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2830 target_value.append(&mut hex::decode("02020202020202020202020202020202020202020202020202020202020202021234567890123456233403289122369832144668701144767633030896203198784335490624111800083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
2832 target_value.append(&mut hex::decode("20").unwrap());
2834 target_value.append(&mut hex::decode("00").unwrap());
2837 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
2840 target_value.append(&mut hex::decode("0100").unwrap());
2842 assert_eq!(encoded_value, target_value);
2846 fn encoding_open_channel() {
2847 do_encoding_open_channel(false, false, false);
2848 do_encoding_open_channel(false, false, true);
2849 do_encoding_open_channel(false, true, false);
2850 do_encoding_open_channel(false, true, true);
2851 do_encoding_open_channel(true, false, false);
2852 do_encoding_open_channel(true, false, true);
2853 do_encoding_open_channel(true, true, false);
2854 do_encoding_open_channel(true, true, true);
2857 fn do_encoding_open_channelv2(random_bit: bool, shutdown: bool, incl_chan_type: bool, require_confirmed_inputs: bool) {
2858 let secp_ctx = Secp256k1::new();
2859 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2860 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2861 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2862 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2863 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
2864 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
2865 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
2866 let open_channelv2 = msgs::OpenChannelV2 {
2867 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2868 temporary_channel_id: [2; 32],
2869 funding_feerate_sat_per_1000_weight: 821716,
2870 commitment_feerate_sat_per_1000_weight: 821716,
2871 funding_satoshis: 1311768467284833366,
2872 dust_limit_satoshis: 3608586615801332854,
2873 max_htlc_value_in_flight_msat: 8517154655701053848,
2874 htlc_minimum_msat: 2316138423780173,
2875 to_self_delay: 49340,
2876 max_accepted_htlcs: 49340,
2877 locktime: 305419896,
2878 funding_pubkey: pubkey_1,
2879 revocation_basepoint: pubkey_2,
2880 payment_basepoint: pubkey_3,
2881 delayed_payment_basepoint: pubkey_4,
2882 htlc_basepoint: pubkey_5,
2883 first_per_commitment_point: pubkey_6,
2884 second_per_commitment_point: pubkey_7,
2885 channel_flags: if random_bit { 1 << 5 } else { 0 },
2886 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
2887 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
2888 require_confirmed_inputs: if require_confirmed_inputs { Some(()) } else { None },
2890 let encoded_value = open_channelv2.encode();
2891 let mut target_value = Vec::new();
2892 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2893 target_value.append(&mut hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap());
2894 target_value.append(&mut hex::decode("000c89d4").unwrap());
2895 target_value.append(&mut hex::decode("000c89d4").unwrap());
2896 target_value.append(&mut hex::decode("1234567890123456").unwrap());
2897 target_value.append(&mut hex::decode("3214466870114476").unwrap());
2898 target_value.append(&mut hex::decode("7633030896203198").unwrap());
2899 target_value.append(&mut hex::decode("00083a840000034d").unwrap());
2900 target_value.append(&mut hex::decode("c0bc").unwrap());
2901 target_value.append(&mut hex::decode("c0bc").unwrap());
2902 target_value.append(&mut hex::decode("12345678").unwrap());
2903 target_value.append(&mut hex::decode("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap());
2904 target_value.append(&mut hex::decode("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap());
2905 target_value.append(&mut hex::decode("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap());
2906 target_value.append(&mut hex::decode("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
2907 target_value.append(&mut hex::decode("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap());
2908 target_value.append(&mut hex::decode("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
2909 target_value.append(&mut hex::decode("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap());
2912 target_value.append(&mut hex::decode("20").unwrap());
2914 target_value.append(&mut hex::decode("00").unwrap());
2917 target_value.append(&mut hex::decode("001b").unwrap()); // Type 0 + Length 27
2918 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
2921 target_value.append(&mut hex::decode("0100").unwrap());
2923 if require_confirmed_inputs {
2924 target_value.append(&mut hex::decode("0200").unwrap());
2926 assert_eq!(encoded_value, target_value);
2930 fn encoding_open_channelv2() {
2931 do_encoding_open_channelv2(false, false, false, false);
2932 do_encoding_open_channelv2(false, false, false, true);
2933 do_encoding_open_channelv2(false, false, true, false);
2934 do_encoding_open_channelv2(false, false, true, true);
2935 do_encoding_open_channelv2(false, true, false, false);
2936 do_encoding_open_channelv2(false, true, false, true);
2937 do_encoding_open_channelv2(false, true, true, false);
2938 do_encoding_open_channelv2(false, true, true, true);
2939 do_encoding_open_channelv2(true, false, false, false);
2940 do_encoding_open_channelv2(true, false, false, true);
2941 do_encoding_open_channelv2(true, false, true, false);
2942 do_encoding_open_channelv2(true, false, true, true);
2943 do_encoding_open_channelv2(true, true, false, false);
2944 do_encoding_open_channelv2(true, true, false, true);
2945 do_encoding_open_channelv2(true, true, true, false);
2946 do_encoding_open_channelv2(true, true, true, true);
2949 fn do_encoding_accept_channel(shutdown: bool) {
2950 let secp_ctx = Secp256k1::new();
2951 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2952 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2953 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2954 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2955 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
2956 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
2957 let accept_channel = msgs::AcceptChannel {
2958 temporary_channel_id: [2; 32],
2959 dust_limit_satoshis: 1311768467284833366,
2960 max_htlc_value_in_flight_msat: 2536655962884945560,
2961 channel_reserve_satoshis: 3608586615801332854,
2962 htlc_minimum_msat: 2316138423780173,
2963 minimum_depth: 821716,
2964 to_self_delay: 49340,
2965 max_accepted_htlcs: 49340,
2966 funding_pubkey: pubkey_1,
2967 revocation_basepoint: pubkey_2,
2968 payment_point: pubkey_3,
2969 delayed_payment_basepoint: pubkey_4,
2970 htlc_basepoint: pubkey_5,
2971 first_per_commitment_point: pubkey_6,
2972 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
2975 next_local_nonce: None,
2977 let encoded_value = accept_channel.encode();
2978 let mut target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020212345678901234562334032891223698321446687011447600083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap();
2980 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
2982 assert_eq!(encoded_value, target_value);
2986 fn encoding_accept_channel() {
2987 do_encoding_accept_channel(false);
2988 do_encoding_accept_channel(true);
2991 fn do_encoding_accept_channelv2(shutdown: bool) {
2992 let secp_ctx = Secp256k1::new();
2993 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2994 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2995 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2996 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2997 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
2998 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
2999 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3000 let accept_channelv2 = msgs::AcceptChannelV2 {
3001 temporary_channel_id: [2; 32],
3002 funding_satoshis: 1311768467284833366,
3003 dust_limit_satoshis: 1311768467284833366,
3004 max_htlc_value_in_flight_msat: 2536655962884945560,
3005 htlc_minimum_msat: 2316138423780173,
3006 minimum_depth: 821716,
3007 to_self_delay: 49340,
3008 max_accepted_htlcs: 49340,
3009 funding_pubkey: pubkey_1,
3010 revocation_basepoint: pubkey_2,
3011 payment_basepoint: pubkey_3,
3012 delayed_payment_basepoint: pubkey_4,
3013 htlc_basepoint: pubkey_5,
3014 first_per_commitment_point: pubkey_6,
3015 second_per_commitment_point: pubkey_7,
3016 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3018 require_confirmed_inputs: None,
3020 let encoded_value = accept_channelv2.encode();
3021 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // temporary_channel_id
3022 target_value.append(&mut hex::decode("1234567890123456").unwrap()); // funding_satoshis
3023 target_value.append(&mut hex::decode("1234567890123456").unwrap()); // dust_limit_satoshis
3024 target_value.append(&mut hex::decode("2334032891223698").unwrap()); // max_htlc_value_in_flight_msat
3025 target_value.append(&mut hex::decode("00083a840000034d").unwrap()); // htlc_minimum_msat
3026 target_value.append(&mut hex::decode("000c89d4").unwrap()); // minimum_depth
3027 target_value.append(&mut hex::decode("c0bc").unwrap()); // to_self_delay
3028 target_value.append(&mut hex::decode("c0bc").unwrap()); // max_accepted_htlcs
3029 target_value.append(&mut hex::decode("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap()); // funding_pubkey
3030 target_value.append(&mut hex::decode("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap()); // revocation_basepoint
3031 target_value.append(&mut hex::decode("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap()); // payment_basepoint
3032 target_value.append(&mut hex::decode("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap()); // delayed_payment_basepoint
3033 target_value.append(&mut hex::decode("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap()); // htlc_basepoint
3034 target_value.append(&mut hex::decode("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap()); // first_per_commitment_point
3035 target_value.append(&mut hex::decode("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap()); // second_per_commitment_point
3037 target_value.append(&mut hex::decode("001b").unwrap()); // Type 0 + Length 27
3038 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3040 assert_eq!(encoded_value, target_value);
3044 fn encoding_accept_channelv2() {
3045 do_encoding_accept_channelv2(false);
3046 do_encoding_accept_channelv2(true);
3050 fn encoding_funding_created() {
3051 let secp_ctx = Secp256k1::new();
3052 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3053 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3054 let funding_created = msgs::FundingCreated {
3055 temporary_channel_id: [2; 32],
3056 funding_txid: Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3057 funding_output_index: 255,
3060 partial_signature_with_nonce: None,
3062 next_local_nonce: None,
3064 let encoded_value = funding_created.encode();
3065 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202026e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c200ffd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3066 assert_eq!(encoded_value, target_value);
3070 fn encoding_funding_signed() {
3071 let secp_ctx = Secp256k1::new();
3072 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3073 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3074 let funding_signed = msgs::FundingSigned {
3075 channel_id: [2; 32],
3078 partial_signature_with_nonce: None,
3080 let encoded_value = funding_signed.encode();
3081 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3082 assert_eq!(encoded_value, target_value);
3086 fn encoding_channel_ready() {
3087 let secp_ctx = Secp256k1::new();
3088 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3089 let channel_ready = msgs::ChannelReady {
3090 channel_id: [2; 32],
3091 next_per_commitment_point: pubkey_1,
3092 short_channel_id_alias: None,
3094 let encoded_value = channel_ready.encode();
3095 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3096 assert_eq!(encoded_value, target_value);
3100 fn encoding_tx_add_input() {
3101 let tx_add_input = msgs::TxAddInput {
3102 channel_id: [2; 32],
3103 serial_id: 4886718345,
3104 prevtx: TransactionU16LenLimited::new(Transaction {
3106 lock_time: PackedLockTime(0),
3108 previous_output: OutPoint { txid: Txid::from_hex("305bab643ee297b8b6b76b320792c8223d55082122cb606bf89382146ced9c77").unwrap(), index: 2 }.into_bitcoin_outpoint(),
3109 script_sig: Script::new(),
3110 sequence: Sequence(0xfffffffd),
3111 witness: Witness::from_vec(vec![
3112 hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3113 hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3118 script_pubkey: Address::from_str("bc1qzlffunw52jav8vwdu5x3jfk6sr8u22rmq3xzw2").unwrap().script_pubkey(),
3122 script_pubkey: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().script_pubkey(),
3126 prevtx_out: 305419896,
3127 sequence: 305419896,
3129 let encoded_value = tx_add_input.encode();
3130 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000000012345678900de02000000000101779ced6c148293f86b60cb222108553d22c89207326bb7b6b897e23e64ab5b300200000000fdffffff0236dbc1000000000016001417d29e4dd454bac3b1cde50d1926da80cfc5287b9cbd03000000000016001436ec78d514df462da95e6a00c24daa8915362d420247304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701210301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944000000001234567812345678").unwrap();
3131 assert_eq!(encoded_value, target_value);
3135 fn encoding_tx_add_output() {
3136 let tx_add_output = msgs::TxAddOutput {
3137 channel_id: [2; 32],
3138 serial_id: 4886718345,
3140 script: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().script_pubkey(),
3142 let encoded_value = tx_add_output.encode();
3143 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000000012345678900000001234567890016001436ec78d514df462da95e6a00c24daa8915362d42").unwrap();
3144 assert_eq!(encoded_value, target_value);
3148 fn encoding_tx_remove_input() {
3149 let tx_remove_input = msgs::TxRemoveInput {
3150 channel_id: [2; 32],
3151 serial_id: 4886718345,
3153 let encoded_value = tx_remove_input.encode();
3154 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3155 assert_eq!(encoded_value, target_value);
3159 fn encoding_tx_remove_output() {
3160 let tx_remove_output = msgs::TxRemoveOutput {
3161 channel_id: [2; 32],
3162 serial_id: 4886718345,
3164 let encoded_value = tx_remove_output.encode();
3165 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3166 assert_eq!(encoded_value, target_value);
3170 fn encoding_tx_complete() {
3171 let tx_complete = msgs::TxComplete {
3172 channel_id: [2; 32],
3174 let encoded_value = tx_complete.encode();
3175 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3176 assert_eq!(encoded_value, target_value);
3180 fn encoding_tx_signatures() {
3181 let tx_signatures = msgs::TxSignatures {
3182 channel_id: [2; 32],
3183 tx_hash: Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3185 Witness::from_vec(vec![
3186 hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3187 hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3188 Witness::from_vec(vec![
3189 hex::decode("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap(),
3190 hex::decode("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap()]),
3193 let encoded_value = tx_signatures.encode();
3194 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3195 target_value.append(&mut hex::decode("6e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c2").unwrap()); // tx_hash (sha256) (big endian byte order)
3196 target_value.append(&mut hex::decode("0002").unwrap()); // num_witnesses (u16)
3198 target_value.append(&mut hex::decode("006b").unwrap()); // len of witness_data
3199 target_value.append(&mut hex::decode("02").unwrap()); // num_witness_elements (VarInt)
3200 target_value.append(&mut hex::decode("47").unwrap()); // len of witness element data (VarInt)
3201 target_value.append(&mut hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap());
3202 target_value.append(&mut hex::decode("21").unwrap()); // len of witness element data (VarInt)
3203 target_value.append(&mut hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap());
3205 target_value.append(&mut hex::decode("006c").unwrap()); // len of witness_data
3206 target_value.append(&mut hex::decode("02").unwrap()); // num_witness_elements (VarInt)
3207 target_value.append(&mut hex::decode("48").unwrap()); // len of witness element data (VarInt)
3208 target_value.append(&mut hex::decode("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap());
3209 target_value.append(&mut hex::decode("21").unwrap()); // len of witness element data (VarInt)
3210 target_value.append(&mut hex::decode("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap());
3211 assert_eq!(encoded_value, target_value);
3214 fn do_encoding_tx_init_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3215 let tx_init_rbf = msgs::TxInitRbf {
3216 channel_id: [2; 32],
3217 locktime: 305419896,
3218 feerate_sat_per_1000_weight: 20190119,
3219 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3221 let encoded_value = tx_init_rbf.encode();
3222 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3223 target_value.append(&mut hex::decode("12345678").unwrap()); // locktime
3224 target_value.append(&mut hex::decode("013413a7").unwrap()); // feerate_sat_per_1000_weight
3225 if let Some((_, target)) = funding_value_with_hex_target {
3226 target_value.push(0x00); // Type
3227 target_value.push(target.len() as u8 / 2); // Length
3228 target_value.append(&mut hex::decode(target).unwrap()); // Value (i64)
3230 assert_eq!(encoded_value, target_value);
3234 fn encoding_tx_init_rbf() {
3235 do_encoding_tx_init_rbf(Some((1311768467284833366, "1234567890123456")));
3236 do_encoding_tx_init_rbf(Some((13117684672, "000000030DDFFBC0")));
3237 do_encoding_tx_init_rbf(None);
3240 fn do_encoding_tx_ack_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3241 let tx_ack_rbf = msgs::TxAckRbf {
3242 channel_id: [2; 32],
3243 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3245 let encoded_value = tx_ack_rbf.encode();
3246 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3247 if let Some((_, target)) = funding_value_with_hex_target {
3248 target_value.push(0x00); // Type
3249 target_value.push(target.len() as u8 / 2); // Length
3250 target_value.append(&mut hex::decode(target).unwrap()); // Value (i64)
3252 assert_eq!(encoded_value, target_value);
3256 fn encoding_tx_ack_rbf() {
3257 do_encoding_tx_ack_rbf(Some((1311768467284833366, "1234567890123456")));
3258 do_encoding_tx_ack_rbf(Some((13117684672, "000000030DDFFBC0")));
3259 do_encoding_tx_ack_rbf(None);
3263 fn encoding_tx_abort() {
3264 let tx_abort = msgs::TxAbort {
3265 channel_id: [2; 32],
3266 data: hex::decode("54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap(),
3268 let encoded_value = tx_abort.encode();
3269 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202002C54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap();
3270 assert_eq!(encoded_value, target_value);
3273 fn do_encoding_shutdown(script_type: u8) {
3274 let secp_ctx = Secp256k1::new();
3275 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3276 let script = Builder::new().push_opcode(opcodes::OP_TRUE).into_script();
3277 let shutdown = msgs::Shutdown {
3278 channel_id: [2; 32],
3280 if script_type == 1 { Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey() }
3281 else if script_type == 2 { Address::p2sh(&script, Network::Testnet).unwrap().script_pubkey() }
3282 else if script_type == 3 { Address::p2wpkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).unwrap().script_pubkey() }
3283 else { Address::p2wsh(&script, Network::Testnet).script_pubkey() },
3285 let encoded_value = shutdown.encode();
3286 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3287 if script_type == 1 {
3288 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3289 } else if script_type == 2 {
3290 target_value.append(&mut hex::decode("0017a914da1745e9b549bd0bfa1a569971c77eba30cd5a4b87").unwrap());
3291 } else if script_type == 3 {
3292 target_value.append(&mut hex::decode("0016001479b000887626b294a914501a4cd226b58b235983").unwrap());
3293 } else if script_type == 4 {
3294 target_value.append(&mut hex::decode("002200204ae81572f06e1b88fd5ced7a1a000945432e83e1551e6f721ee9c00b8cc33260").unwrap());
3296 assert_eq!(encoded_value, target_value);
3300 fn encoding_shutdown() {
3301 do_encoding_shutdown(1);
3302 do_encoding_shutdown(2);
3303 do_encoding_shutdown(3);
3304 do_encoding_shutdown(4);
3308 fn encoding_closing_signed() {
3309 let secp_ctx = Secp256k1::new();
3310 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3311 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3312 let closing_signed = msgs::ClosingSigned {
3313 channel_id: [2; 32],
3314 fee_satoshis: 2316138423780173,
3318 let encoded_value = closing_signed.encode();
3319 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3320 assert_eq!(encoded_value, target_value);
3321 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value)).unwrap(), closing_signed);
3323 let closing_signed_with_range = msgs::ClosingSigned {
3324 channel_id: [2; 32],
3325 fee_satoshis: 2316138423780173,
3327 fee_range: Some(msgs::ClosingSignedFeeRange {
3328 min_fee_satoshis: 0xdeadbeef,
3329 max_fee_satoshis: 0x1badcafe01234567,
3332 let encoded_value_with_range = closing_signed_with_range.encode();
3333 let target_value_with_range = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a011000000000deadbeef1badcafe01234567").unwrap();
3334 assert_eq!(encoded_value_with_range, target_value_with_range);
3335 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value_with_range)).unwrap(),
3336 closing_signed_with_range);
3340 fn encoding_update_add_htlc() {
3341 let secp_ctx = Secp256k1::new();
3342 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3343 let onion_routing_packet = msgs::OnionPacket {
3345 public_key: Ok(pubkey_1),
3346 hop_data: [1; 20*65],
3349 let update_add_htlc = msgs::UpdateAddHTLC {
3350 channel_id: [2; 32],
3351 htlc_id: 2316138423780173,
3352 amount_msat: 3608586615801332854,
3353 payment_hash: PaymentHash([1; 32]),
3354 cltv_expiry: 821716,
3355 onion_routing_packet,
3356 skimmed_fee_msat: None,
3358 let encoded_value = update_add_htlc.encode();
3359 let target_value = hex::decode("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").unwrap();
3360 assert_eq!(encoded_value, target_value);
3364 fn encoding_update_fulfill_htlc() {
3365 let update_fulfill_htlc = msgs::UpdateFulfillHTLC {
3366 channel_id: [2; 32],
3367 htlc_id: 2316138423780173,
3368 payment_preimage: PaymentPreimage([1; 32]),
3370 let encoded_value = update_fulfill_htlc.encode();
3371 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d0101010101010101010101010101010101010101010101010101010101010101").unwrap();
3372 assert_eq!(encoded_value, target_value);
3376 fn encoding_update_fail_htlc() {
3377 let reason = OnionErrorPacket {
3378 data: [1; 32].to_vec(),
3380 let update_fail_htlc = msgs::UpdateFailHTLC {
3381 channel_id: [2; 32],
3382 htlc_id: 2316138423780173,
3385 let encoded_value = update_fail_htlc.encode();
3386 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d00200101010101010101010101010101010101010101010101010101010101010101").unwrap();
3387 assert_eq!(encoded_value, target_value);
3391 fn encoding_update_fail_malformed_htlc() {
3392 let update_fail_malformed_htlc = msgs::UpdateFailMalformedHTLC {
3393 channel_id: [2; 32],
3394 htlc_id: 2316138423780173,
3395 sha256_of_onion: [1; 32],
3398 let encoded_value = update_fail_malformed_htlc.encode();
3399 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d010101010101010101010101010101010101010101010101010101010101010100ff").unwrap();
3400 assert_eq!(encoded_value, target_value);
3403 fn do_encoding_commitment_signed(htlcs: bool) {
3404 let secp_ctx = Secp256k1::new();
3405 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3406 let (privkey_2, _) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3407 let (privkey_3, _) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3408 let (privkey_4, _) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3409 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3410 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
3411 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
3412 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
3413 let commitment_signed = msgs::CommitmentSigned {
3414 channel_id: [2; 32],
3416 htlc_signatures: if htlcs { vec![sig_2, sig_3, sig_4] } else { Vec::new() },
3418 partial_signature_with_nonce: None,
3420 let encoded_value = commitment_signed.encode();
3421 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3423 target_value.append(&mut hex::decode("00031735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
3425 target_value.append(&mut hex::decode("0000").unwrap());
3427 assert_eq!(encoded_value, target_value);
3431 fn encoding_commitment_signed() {
3432 do_encoding_commitment_signed(true);
3433 do_encoding_commitment_signed(false);
3437 fn encoding_revoke_and_ack() {
3438 let secp_ctx = Secp256k1::new();
3439 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3440 let raa = msgs::RevokeAndACK {
3441 channel_id: [2; 32],
3442 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],
3443 next_per_commitment_point: pubkey_1,
3445 next_local_nonce: None,
3447 let encoded_value = raa.encode();
3448 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020101010101010101010101010101010101010101010101010101010101010101031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3449 assert_eq!(encoded_value, target_value);
3453 fn encoding_update_fee() {
3454 let update_fee = msgs::UpdateFee {
3455 channel_id: [2; 32],
3456 feerate_per_kw: 20190119,
3458 let encoded_value = update_fee.encode();
3459 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202013413a7").unwrap();
3460 assert_eq!(encoded_value, target_value);
3464 fn encoding_init() {
3465 let mainnet_hash = ChainHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap();
3466 assert_eq!(msgs::Init {
3467 features: InitFeatures::from_le_bytes(vec![0xFF, 0xFF, 0xFF]),
3468 networks: Some(vec![mainnet_hash]),
3469 remote_network_address: None,
3470 }.encode(), hex::decode("00023fff0003ffffff01206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3471 assert_eq!(msgs::Init {
3472 features: InitFeatures::from_le_bytes(vec![0xFF]),
3474 remote_network_address: None,
3475 }.encode(), hex::decode("0001ff0001ff").unwrap());
3476 assert_eq!(msgs::Init {
3477 features: InitFeatures::from_le_bytes(vec![]),
3478 networks: Some(vec![mainnet_hash]),
3479 remote_network_address: None,
3480 }.encode(), hex::decode("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3481 assert_eq!(msgs::Init {
3482 features: InitFeatures::from_le_bytes(vec![]),
3483 networks: Some(vec![ChainHash::from(&[1; 32][..]), ChainHash::from(&[2; 32][..])]),
3484 remote_network_address: None,
3485 }.encode(), hex::decode("00000000014001010101010101010101010101010101010101010101010101010101010101010202020202020202020202020202020202020202020202020202020202020202").unwrap());
3486 let init_msg = msgs::Init { features: InitFeatures::from_le_bytes(vec![]),
3487 networks: Some(vec![mainnet_hash]),
3488 remote_network_address: Some(msgs::NetAddress::IPv4 {
3489 addr: [127, 0, 0, 1],
3493 let encoded_value = init_msg.encode();
3494 let target_value = hex::decode("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d61900000000000307017f00000103e8").unwrap();
3495 assert_eq!(encoded_value, target_value);
3496 assert_eq!(msgs::Init::read(&mut Cursor::new(&target_value)).unwrap(), init_msg);
3500 fn encoding_error() {
3501 let error = msgs::ErrorMessage {
3502 channel_id: [2; 32],
3503 data: String::from("rust-lightning"),
3505 let encoded_value = error.encode();
3506 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3507 assert_eq!(encoded_value, target_value);
3511 fn encoding_warning() {
3512 let error = msgs::WarningMessage {
3513 channel_id: [2; 32],
3514 data: String::from("rust-lightning"),
3516 let encoded_value = error.encode();
3517 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3518 assert_eq!(encoded_value, target_value);
3522 fn encoding_ping() {
3523 let ping = msgs::Ping {
3527 let encoded_value = ping.encode();
3528 let target_value = hex::decode("0040004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3529 assert_eq!(encoded_value, target_value);
3533 fn encoding_pong() {
3534 let pong = msgs::Pong {
3537 let encoded_value = pong.encode();
3538 let target_value = hex::decode("004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3539 assert_eq!(encoded_value, target_value);
3543 fn encoding_nonfinal_onion_hop_data() {
3544 let outbound_msg = msgs::OutboundOnionPayload::Forward {
3545 short_channel_id: 0xdeadbeef1bad1dea,
3546 amt_to_forward: 0x0badf00d01020304,
3547 outgoing_cltv_value: 0xffffffff,
3549 let encoded_value = outbound_msg.encode();
3550 let target_value = hex::decode("1a02080badf00d010203040404ffffffff0608deadbeef1bad1dea").unwrap();
3551 assert_eq!(encoded_value, target_value);
3553 let inbound_msg = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3554 if let msgs::InboundOnionPayload::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } = inbound_msg {
3555 assert_eq!(short_channel_id, 0xdeadbeef1bad1dea);
3556 assert_eq!(amt_to_forward, 0x0badf00d01020304);
3557 assert_eq!(outgoing_cltv_value, 0xffffffff);
3558 } else { panic!(); }
3562 fn encoding_final_onion_hop_data() {
3563 let outbound_msg = msgs::OutboundOnionPayload::Receive {
3565 payment_metadata: None,
3566 keysend_preimage: None,
3567 amt_msat: 0x0badf00d01020304,
3568 outgoing_cltv_value: 0xffffffff,
3570 let encoded_value = outbound_msg.encode();
3571 let target_value = hex::decode("1002080badf00d010203040404ffffffff").unwrap();
3572 assert_eq!(encoded_value, target_value);
3574 let inbound_msg = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3575 if let msgs::InboundOnionPayload::Receive { payment_data: None, amt_msat, outgoing_cltv_value, .. } = inbound_msg {
3576 assert_eq!(amt_msat, 0x0badf00d01020304);
3577 assert_eq!(outgoing_cltv_value, 0xffffffff);
3578 } else { panic!(); }
3582 fn encoding_final_onion_hop_data_with_secret() {
3583 let expected_payment_secret = PaymentSecret([0x42u8; 32]);
3584 let outbound_msg = msgs::OutboundOnionPayload::Receive {
3585 payment_data: Some(FinalOnionHopData {
3586 payment_secret: expected_payment_secret,
3587 total_msat: 0x1badca1f
3589 payment_metadata: None,
3590 keysend_preimage: None,
3591 amt_msat: 0x0badf00d01020304,
3592 outgoing_cltv_value: 0xffffffff,
3594 let encoded_value = outbound_msg.encode();
3595 let target_value = hex::decode("3602080badf00d010203040404ffffffff082442424242424242424242424242424242424242424242424242424242424242421badca1f").unwrap();
3596 assert_eq!(encoded_value, target_value);
3598 let inbound_msg = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3599 if let msgs::InboundOnionPayload::Receive {
3600 payment_data: Some(FinalOnionHopData {
3602 total_msat: 0x1badca1f
3604 amt_msat, outgoing_cltv_value,
3605 payment_metadata: None,
3606 keysend_preimage: None,
3608 assert_eq!(payment_secret, expected_payment_secret);
3609 assert_eq!(amt_msat, 0x0badf00d01020304);
3610 assert_eq!(outgoing_cltv_value, 0xffffffff);
3611 } else { panic!(); }
3615 fn query_channel_range_end_blocknum() {
3616 let tests: Vec<(u32, u32, u32)> = vec![
3617 (10000, 1500, 11500),
3618 (0, 0xffffffff, 0xffffffff),
3619 (1, 0xffffffff, 0xffffffff),
3622 for (first_blocknum, number_of_blocks, expected) in tests.into_iter() {
3623 let sut = msgs::QueryChannelRange {
3624 chain_hash: BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap(),
3628 assert_eq!(sut.end_blocknum(), expected);
3633 fn encoding_query_channel_range() {
3634 let mut query_channel_range = msgs::QueryChannelRange {
3635 chain_hash: BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap(),
3636 first_blocknum: 100000,
3637 number_of_blocks: 1500,
3639 let encoded_value = query_channel_range.encode();
3640 let target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206000186a0000005dc").unwrap();
3641 assert_eq!(encoded_value, target_value);
3643 query_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3644 assert_eq!(query_channel_range.first_blocknum, 100000);
3645 assert_eq!(query_channel_range.number_of_blocks, 1500);
3649 fn encoding_reply_channel_range() {
3650 do_encoding_reply_channel_range(0);
3651 do_encoding_reply_channel_range(1);
3654 fn do_encoding_reply_channel_range(encoding_type: u8) {
3655 let mut target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206000b8a06000005dc01").unwrap();
3656 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3657 let mut reply_channel_range = msgs::ReplyChannelRange {
3658 chain_hash: expected_chain_hash,
3659 first_blocknum: 756230,
3660 number_of_blocks: 1500,
3661 sync_complete: true,
3662 short_channel_ids: vec![0x000000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
3665 if encoding_type == 0 {
3666 target_value.append(&mut hex::decode("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
3667 let encoded_value = reply_channel_range.encode();
3668 assert_eq!(encoded_value, target_value);
3670 reply_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3671 assert_eq!(reply_channel_range.chain_hash, expected_chain_hash);
3672 assert_eq!(reply_channel_range.first_blocknum, 756230);
3673 assert_eq!(reply_channel_range.number_of_blocks, 1500);
3674 assert_eq!(reply_channel_range.sync_complete, true);
3675 assert_eq!(reply_channel_range.short_channel_ids[0], 0x000000000000008e);
3676 assert_eq!(reply_channel_range.short_channel_ids[1], 0x0000000000003c69);
3677 assert_eq!(reply_channel_range.short_channel_ids[2], 0x000000000045a6c4);
3679 target_value.append(&mut hex::decode("001601789c636000833e08659309a65878be010010a9023a").unwrap());
3680 let result: Result<msgs::ReplyChannelRange, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
3681 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
3686 fn encoding_query_short_channel_ids() {
3687 do_encoding_query_short_channel_ids(0);
3688 do_encoding_query_short_channel_ids(1);
3691 fn do_encoding_query_short_channel_ids(encoding_type: u8) {
3692 let mut target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206").unwrap();
3693 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3694 let mut query_short_channel_ids = msgs::QueryShortChannelIds {
3695 chain_hash: expected_chain_hash,
3696 short_channel_ids: vec![0x0000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
3699 if encoding_type == 0 {
3700 target_value.append(&mut hex::decode("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
3701 let encoded_value = query_short_channel_ids.encode();
3702 assert_eq!(encoded_value, target_value);
3704 query_short_channel_ids = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3705 assert_eq!(query_short_channel_ids.chain_hash, expected_chain_hash);
3706 assert_eq!(query_short_channel_ids.short_channel_ids[0], 0x000000000000008e);
3707 assert_eq!(query_short_channel_ids.short_channel_ids[1], 0x0000000000003c69);
3708 assert_eq!(query_short_channel_ids.short_channel_ids[2], 0x000000000045a6c4);
3710 target_value.append(&mut hex::decode("001601789c636000833e08659309a65878be010010a9023a").unwrap());
3711 let result: Result<msgs::QueryShortChannelIds, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
3712 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
3717 fn encoding_reply_short_channel_ids_end() {
3718 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3719 let mut reply_short_channel_ids_end = msgs::ReplyShortChannelIdsEnd {
3720 chain_hash: expected_chain_hash,
3721 full_information: true,
3723 let encoded_value = reply_short_channel_ids_end.encode();
3724 let target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e220601").unwrap();
3725 assert_eq!(encoded_value, target_value);
3727 reply_short_channel_ids_end = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3728 assert_eq!(reply_short_channel_ids_end.chain_hash, expected_chain_hash);
3729 assert_eq!(reply_short_channel_ids_end.full_information, true);
3733 fn encoding_gossip_timestamp_filter(){
3734 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3735 let mut gossip_timestamp_filter = msgs::GossipTimestampFilter {
3736 chain_hash: expected_chain_hash,
3737 first_timestamp: 1590000000,
3738 timestamp_range: 0xffff_ffff,
3740 let encoded_value = gossip_timestamp_filter.encode();
3741 let target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e22065ec57980ffffffff").unwrap();
3742 assert_eq!(encoded_value, target_value);
3744 gossip_timestamp_filter = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3745 assert_eq!(gossip_timestamp_filter.chain_hash, expected_chain_hash);
3746 assert_eq!(gossip_timestamp_filter.first_timestamp, 1590000000);
3747 assert_eq!(gossip_timestamp_filter.timestamp_range, 0xffff_ffff);
3751 fn decode_onion_hop_data_len_as_bigsize() {
3752 // Tests that we can decode an onion payload that is >253 bytes.
3753 // Previously, receiving a payload of this size could've caused us to fail to decode a valid
3754 // payload, because we were decoding the length (a BigSize, big-endian) as a VarInt
3757 // Encode a test onion payload with a big custom TLV such that it's >253 bytes, forcing the
3758 // payload length to be encoded over multiple bytes rather than a single u8.
3759 let big_payload = encode_big_payload().unwrap();
3760 let mut rd = Cursor::new(&big_payload[..]);
3761 <msgs::InboundOnionPayload as Readable>::read(&mut rd).unwrap();
3763 // see above test, needs to be a separate method for use of the serialization macros.
3764 fn encode_big_payload() -> Result<Vec<u8>, io::Error> {
3765 use crate::util::ser::HighZeroBytesDroppedBigSize;
3766 let payload = msgs::OutboundOnionPayload::Forward {
3767 short_channel_id: 0xdeadbeef1bad1dea,
3768 amt_to_forward: 1000,
3769 outgoing_cltv_value: 0xffffffff,
3771 let mut encoded_payload = Vec::new();
3772 let test_bytes = vec![42u8; 1000];
3773 if let msgs::OutboundOnionPayload::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } = payload {
3774 _encode_varint_length_prefixed_tlv!(&mut encoded_payload, {
3775 (1, test_bytes, required_vec),
3776 (2, HighZeroBytesDroppedBigSize(amt_to_forward), required),
3777 (4, HighZeroBytesDroppedBigSize(outgoing_cltv_value), required),
3778 (6, short_channel_id, required)