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.
905 pub enum UnsignedGossipMessage {
906 /// An unsigned channel announcement.
907 ChannelAnnouncement(UnsignedChannelAnnouncement),
908 /// An unsigned channel update.
909 ChannelUpdate(UnsignedChannelUpdate),
910 /// An unsigned node announcement.
911 NodeAnnouncement(UnsignedNodeAnnouncement)
914 impl Writeable for UnsignedGossipMessage {
915 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
917 UnsignedGossipMessage::ChannelAnnouncement(ref msg) => msg.write(writer),
918 UnsignedGossipMessage::ChannelUpdate(ref msg) => msg.write(writer),
919 UnsignedGossipMessage::NodeAnnouncement(ref msg) => msg.write(writer),
924 /// The unsigned part of a [`node_announcement`] message.
926 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
927 #[derive(Clone, Debug, PartialEq, Eq)]
928 pub struct UnsignedNodeAnnouncement {
929 /// The advertised features
930 pub features: NodeFeatures,
931 /// A strictly monotonic announcement counter, with gaps allowed
933 /// The `node_id` this announcement originated from (don't rebroadcast the `node_announcement` back
936 /// An RGB color for UI purposes
938 /// An alias, for UI purposes.
940 /// This should be sanitized before use. There is no guarantee of uniqueness.
941 pub alias: NodeAlias,
942 /// List of addresses on which this node is reachable
943 pub addresses: Vec<NetAddress>,
944 pub(crate) excess_address_data: Vec<u8>,
945 pub(crate) excess_data: Vec<u8>,
947 #[derive(Clone, Debug, PartialEq, Eq)]
948 /// A [`node_announcement`] message to be sent to or received from a peer.
950 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
951 pub struct NodeAnnouncement {
952 /// The signature by the node key
953 pub signature: Signature,
954 /// The actual content of the announcement
955 pub contents: UnsignedNodeAnnouncement,
958 /// The unsigned part of a [`channel_announcement`] message.
960 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
961 #[derive(Clone, Debug, PartialEq, Eq)]
962 pub struct UnsignedChannelAnnouncement {
963 /// The advertised channel features
964 pub features: ChannelFeatures,
965 /// The genesis hash of the blockchain where the channel is to be opened
966 pub chain_hash: BlockHash,
967 /// The short channel ID
968 pub short_channel_id: u64,
969 /// One of the two `node_id`s which are endpoints of this channel
970 pub node_id_1: NodeId,
971 /// The other of the two `node_id`s which are endpoints of this channel
972 pub node_id_2: NodeId,
973 /// The funding key for the first node
974 pub bitcoin_key_1: NodeId,
975 /// The funding key for the second node
976 pub bitcoin_key_2: NodeId,
977 pub(crate) excess_data: Vec<u8>,
979 /// A [`channel_announcement`] message to be sent to or received from a peer.
981 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
982 #[derive(Clone, Debug, PartialEq, Eq)]
983 pub struct ChannelAnnouncement {
984 /// Authentication of the announcement by the first public node
985 pub node_signature_1: Signature,
986 /// Authentication of the announcement by the second public node
987 pub node_signature_2: Signature,
988 /// Proof of funding UTXO ownership by the first public node
989 pub bitcoin_signature_1: Signature,
990 /// Proof of funding UTXO ownership by the second public node
991 pub bitcoin_signature_2: Signature,
992 /// The actual announcement
993 pub contents: UnsignedChannelAnnouncement,
996 /// The unsigned part of a [`channel_update`] message.
998 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
999 #[derive(Clone, Debug, PartialEq, Eq)]
1000 pub struct UnsignedChannelUpdate {
1001 /// The genesis hash of the blockchain where the channel is to be opened
1002 pub chain_hash: BlockHash,
1003 /// The short channel ID
1004 pub short_channel_id: u64,
1005 /// A strictly monotonic announcement counter, with gaps allowed, specific to this channel
1009 /// The number of blocks such that if:
1010 /// `incoming_htlc.cltv_expiry < outgoing_htlc.cltv_expiry + cltv_expiry_delta`
1011 /// then we need to fail the HTLC backwards. When forwarding an HTLC, `cltv_expiry_delta` determines
1012 /// the outgoing HTLC's minimum `cltv_expiry` value -- so, if an incoming HTLC comes in with a
1013 /// `cltv_expiry` of 100000, and the node we're forwarding to has a `cltv_expiry_delta` value of 10,
1014 /// then we'll check that the outgoing HTLC's `cltv_expiry` value is at least 100010 before
1015 /// forwarding. Note that the HTLC sender is the one who originally sets this value when
1016 /// constructing the route.
1017 pub cltv_expiry_delta: u16,
1018 /// The minimum HTLC size incoming to sender, in milli-satoshi
1019 pub htlc_minimum_msat: u64,
1020 /// The maximum HTLC value incoming to sender, in milli-satoshi.
1022 /// This used to be optional.
1023 pub htlc_maximum_msat: u64,
1024 /// The base HTLC fee charged by sender, in milli-satoshi
1025 pub fee_base_msat: u32,
1026 /// The amount to fee multiplier, in micro-satoshi
1027 pub fee_proportional_millionths: u32,
1028 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1031 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1032 pub excess_data: Vec<u8>,
1034 /// A [`channel_update`] message to be sent to or received from a peer.
1036 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1037 #[derive(Clone, Debug, PartialEq, Eq)]
1038 pub struct ChannelUpdate {
1039 /// A signature of the channel update
1040 pub signature: Signature,
1041 /// The actual channel update
1042 pub contents: UnsignedChannelUpdate,
1045 /// A [`query_channel_range`] message is used to query a peer for channel
1046 /// UTXOs in a range of blocks. The recipient of a query makes a best
1047 /// effort to reply to the query using one or more [`ReplyChannelRange`]
1050 /// [`query_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1051 #[derive(Clone, Debug, PartialEq, Eq)]
1052 pub struct QueryChannelRange {
1053 /// The genesis hash of the blockchain being queried
1054 pub chain_hash: BlockHash,
1055 /// The height of the first block for the channel UTXOs being queried
1056 pub first_blocknum: u32,
1057 /// The number of blocks to include in the query results
1058 pub number_of_blocks: u32,
1061 /// A [`reply_channel_range`] message is a reply to a [`QueryChannelRange`]
1064 /// Multiple `reply_channel_range` messages can be sent in reply
1065 /// to a single [`QueryChannelRange`] message. The query recipient makes a
1066 /// best effort to respond based on their local network view which may
1067 /// not be a perfect view of the network. The `short_channel_id`s in the
1068 /// reply are encoded. We only support `encoding_type=0` uncompressed
1069 /// serialization and do not support `encoding_type=1` zlib serialization.
1071 /// [`reply_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1072 #[derive(Clone, Debug, PartialEq, Eq)]
1073 pub struct ReplyChannelRange {
1074 /// The genesis hash of the blockchain being queried
1075 pub chain_hash: BlockHash,
1076 /// The height of the first block in the range of the reply
1077 pub first_blocknum: u32,
1078 /// The number of blocks included in the range of the reply
1079 pub number_of_blocks: u32,
1080 /// True when this is the final reply for a query
1081 pub sync_complete: bool,
1082 /// The `short_channel_id`s in the channel range
1083 pub short_channel_ids: Vec<u64>,
1086 /// A [`query_short_channel_ids`] message is used to query a peer for
1087 /// routing gossip messages related to one or more `short_channel_id`s.
1089 /// The query recipient will reply with the latest, if available,
1090 /// [`ChannelAnnouncement`], [`ChannelUpdate`] and [`NodeAnnouncement`] messages
1091 /// it maintains for the requested `short_channel_id`s followed by a
1092 /// [`ReplyShortChannelIdsEnd`] message. The `short_channel_id`s sent in
1093 /// this query are encoded. We only support `encoding_type=0` uncompressed
1094 /// serialization and do not support `encoding_type=1` zlib serialization.
1096 /// [`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
1097 #[derive(Clone, Debug, PartialEq, Eq)]
1098 pub struct QueryShortChannelIds {
1099 /// The genesis hash of the blockchain being queried
1100 pub chain_hash: BlockHash,
1101 /// The short_channel_ids that are being queried
1102 pub short_channel_ids: Vec<u64>,
1105 /// A [`reply_short_channel_ids_end`] message is sent as a reply to a
1106 /// message. The query recipient makes a best
1107 /// effort to respond based on their local network view which may not be
1108 /// a perfect view of the network.
1110 /// [`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
1111 #[derive(Clone, Debug, PartialEq, Eq)]
1112 pub struct ReplyShortChannelIdsEnd {
1113 /// The genesis hash of the blockchain that was queried
1114 pub chain_hash: BlockHash,
1115 /// Indicates if the query recipient maintains up-to-date channel
1116 /// information for the `chain_hash`
1117 pub full_information: bool,
1120 /// A [`gossip_timestamp_filter`] message is used by a node to request
1121 /// gossip relay for messages in the requested time range when the
1122 /// `gossip_queries` feature has been negotiated.
1124 /// [`gossip_timestamp_filter`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-gossip_timestamp_filter-message
1125 #[derive(Clone, Debug, PartialEq, Eq)]
1126 pub struct GossipTimestampFilter {
1127 /// The genesis hash of the blockchain for channel and node information
1128 pub chain_hash: BlockHash,
1129 /// The starting unix timestamp
1130 pub first_timestamp: u32,
1131 /// The range of information in seconds
1132 pub timestamp_range: u32,
1135 /// Encoding type for data compression of collections in gossip queries.
1137 /// We do not support `encoding_type=1` zlib serialization [defined in BOLT
1138 /// #7](https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#query-messages).
1140 Uncompressed = 0x00,
1143 /// Used to put an error message in a [`LightningError`].
1144 #[derive(Clone, Debug)]
1145 pub enum ErrorAction {
1146 /// The peer took some action which made us think they were useless. Disconnect them.
1148 /// An error message which we should make an effort to send before we disconnect.
1149 msg: Option<ErrorMessage>
1151 /// The peer did something incorrect. Tell them without closing any channels and disconnect them.
1152 DisconnectPeerWithWarning {
1153 /// A warning message which we should make an effort to send before we disconnect.
1154 msg: WarningMessage,
1156 /// The peer did something harmless that we weren't able to process, just log and ignore
1157 // New code should *not* use this. New code must use IgnoreAndLog, below!
1159 /// The peer did something harmless that we weren't able to meaningfully process.
1160 /// If the error is logged, log it at the given level.
1161 IgnoreAndLog(logger::Level),
1162 /// The peer provided us with a gossip message which we'd already seen. In most cases this
1163 /// should be ignored, but it may result in the message being forwarded if it is a duplicate of
1164 /// our own channel announcements.
1165 IgnoreDuplicateGossip,
1166 /// The peer did something incorrect. Tell them.
1168 /// The message to send.
1171 /// The peer did something incorrect. Tell them without closing any channels.
1172 SendWarningMessage {
1173 /// The message to send.
1174 msg: WarningMessage,
1175 /// The peer may have done something harmless that we weren't able to meaningfully process,
1176 /// though we should still tell them about it.
1177 /// If this event is logged, log it at the given level.
1178 log_level: logger::Level,
1182 /// An Err type for failure to process messages.
1183 #[derive(Clone, Debug)]
1184 pub struct LightningError {
1185 /// A human-readable message describing the error
1187 /// The action which should be taken against the offending peer.
1188 pub action: ErrorAction,
1191 /// Struct used to return values from [`RevokeAndACK`] messages, containing a bunch of commitment
1192 /// transaction updates if they were pending.
1193 #[derive(Clone, Debug, PartialEq, Eq)]
1194 pub struct CommitmentUpdate {
1195 /// `update_add_htlc` messages which should be sent
1196 pub update_add_htlcs: Vec<UpdateAddHTLC>,
1197 /// `update_fulfill_htlc` messages which should be sent
1198 pub update_fulfill_htlcs: Vec<UpdateFulfillHTLC>,
1199 /// `update_fail_htlc` messages which should be sent
1200 pub update_fail_htlcs: Vec<UpdateFailHTLC>,
1201 /// `update_fail_malformed_htlc` messages which should be sent
1202 pub update_fail_malformed_htlcs: Vec<UpdateFailMalformedHTLC>,
1203 /// An `update_fee` message which should be sent
1204 pub update_fee: Option<UpdateFee>,
1205 /// A `commitment_signed` message which should be sent
1206 pub commitment_signed: CommitmentSigned,
1209 /// A trait to describe an object which can receive channel messages.
1211 /// Messages MAY be called in parallel when they originate from different `their_node_ids`, however
1212 /// they MUST NOT be called in parallel when the two calls have the same `their_node_id`.
1213 pub trait ChannelMessageHandler : MessageSendEventsProvider {
1215 /// Handle an incoming `open_channel` message from the given peer.
1216 fn handle_open_channel(&self, their_node_id: &PublicKey, msg: &OpenChannel);
1217 /// Handle an incoming `open_channel2` message from the given peer.
1218 fn handle_open_channel_v2(&self, their_node_id: &PublicKey, msg: &OpenChannelV2);
1219 /// Handle an incoming `accept_channel` message from the given peer.
1220 fn handle_accept_channel(&self, their_node_id: &PublicKey, msg: &AcceptChannel);
1221 /// Handle an incoming `accept_channel2` message from the given peer.
1222 fn handle_accept_channel_v2(&self, their_node_id: &PublicKey, msg: &AcceptChannelV2);
1223 /// Handle an incoming `funding_created` message from the given peer.
1224 fn handle_funding_created(&self, their_node_id: &PublicKey, msg: &FundingCreated);
1225 /// Handle an incoming `funding_signed` message from the given peer.
1226 fn handle_funding_signed(&self, their_node_id: &PublicKey, msg: &FundingSigned);
1227 /// Handle an incoming `channel_ready` message from the given peer.
1228 fn handle_channel_ready(&self, their_node_id: &PublicKey, msg: &ChannelReady);
1231 /// Handle an incoming `shutdown` message from the given peer.
1232 fn handle_shutdown(&self, their_node_id: &PublicKey, msg: &Shutdown);
1233 /// Handle an incoming `closing_signed` message from the given peer.
1234 fn handle_closing_signed(&self, their_node_id: &PublicKey, msg: &ClosingSigned);
1236 // Interactive channel construction
1237 /// Handle an incoming `tx_add_input message` from the given peer.
1238 fn handle_tx_add_input(&self, their_node_id: &PublicKey, msg: &TxAddInput);
1239 /// Handle an incoming `tx_add_output` message from the given peer.
1240 fn handle_tx_add_output(&self, their_node_id: &PublicKey, msg: &TxAddOutput);
1241 /// Handle an incoming `tx_remove_input` message from the given peer.
1242 fn handle_tx_remove_input(&self, their_node_id: &PublicKey, msg: &TxRemoveInput);
1243 /// Handle an incoming `tx_remove_output` message from the given peer.
1244 fn handle_tx_remove_output(&self, their_node_id: &PublicKey, msg: &TxRemoveOutput);
1245 /// Handle an incoming `tx_complete message` from the given peer.
1246 fn handle_tx_complete(&self, their_node_id: &PublicKey, msg: &TxComplete);
1247 /// Handle an incoming `tx_signatures` message from the given peer.
1248 fn handle_tx_signatures(&self, their_node_id: &PublicKey, msg: &TxSignatures);
1249 /// Handle an incoming `tx_init_rbf` message from the given peer.
1250 fn handle_tx_init_rbf(&self, their_node_id: &PublicKey, msg: &TxInitRbf);
1251 /// Handle an incoming `tx_ack_rbf` message from the given peer.
1252 fn handle_tx_ack_rbf(&self, their_node_id: &PublicKey, msg: &TxAckRbf);
1253 /// Handle an incoming `tx_abort message` from the given peer.
1254 fn handle_tx_abort(&self, their_node_id: &PublicKey, msg: &TxAbort);
1257 /// Handle an incoming `update_add_htlc` message from the given peer.
1258 fn handle_update_add_htlc(&self, their_node_id: &PublicKey, msg: &UpdateAddHTLC);
1259 /// Handle an incoming `update_fulfill_htlc` message from the given peer.
1260 fn handle_update_fulfill_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFulfillHTLC);
1261 /// Handle an incoming `update_fail_htlc` message from the given peer.
1262 fn handle_update_fail_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailHTLC);
1263 /// Handle an incoming `update_fail_malformed_htlc` message from the given peer.
1264 fn handle_update_fail_malformed_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailMalformedHTLC);
1265 /// Handle an incoming `commitment_signed` message from the given peer.
1266 fn handle_commitment_signed(&self, their_node_id: &PublicKey, msg: &CommitmentSigned);
1267 /// Handle an incoming `revoke_and_ack` message from the given peer.
1268 fn handle_revoke_and_ack(&self, their_node_id: &PublicKey, msg: &RevokeAndACK);
1270 /// Handle an incoming `update_fee` message from the given peer.
1271 fn handle_update_fee(&self, their_node_id: &PublicKey, msg: &UpdateFee);
1273 // Channel-to-announce:
1274 /// Handle an incoming `announcement_signatures` message from the given peer.
1275 fn handle_announcement_signatures(&self, their_node_id: &PublicKey, msg: &AnnouncementSignatures);
1277 // Connection loss/reestablish:
1278 /// Indicates a connection to the peer failed/an existing connection was lost.
1279 fn peer_disconnected(&self, their_node_id: &PublicKey);
1281 /// Handle a peer reconnecting, possibly generating `channel_reestablish` message(s).
1283 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1284 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1285 /// message handlers may still wish to communicate with this peer.
1286 fn peer_connected(&self, their_node_id: &PublicKey, msg: &Init, inbound: bool) -> Result<(), ()>;
1287 /// Handle an incoming `channel_reestablish` message from the given peer.
1288 fn handle_channel_reestablish(&self, their_node_id: &PublicKey, msg: &ChannelReestablish);
1290 /// Handle an incoming `channel_update` message from the given peer.
1291 fn handle_channel_update(&self, their_node_id: &PublicKey, msg: &ChannelUpdate);
1294 /// Handle an incoming `error` message from the given peer.
1295 fn handle_error(&self, their_node_id: &PublicKey, msg: &ErrorMessage);
1297 // Handler information:
1298 /// Gets the node feature flags which this handler itself supports. All available handlers are
1299 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1300 /// which are broadcasted in our [`NodeAnnouncement`] message.
1301 fn provided_node_features(&self) -> NodeFeatures;
1303 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1304 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1305 /// which are sent in our [`Init`] message.
1307 /// Note that this method is called before [`Self::peer_connected`].
1308 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1310 /// Gets the genesis hashes for this `ChannelMessageHandler` indicating which chains it supports.
1312 /// If it's `None`, then no particular network chain hash compatibility will be enforced when
1313 /// connecting to peers.
1314 fn get_genesis_hashes(&self) -> Option<Vec<ChainHash>>;
1317 /// A trait to describe an object which can receive routing messages.
1319 /// # Implementor DoS Warnings
1321 /// For messages enabled with the `gossip_queries` feature there are potential DoS vectors when
1322 /// handling inbound queries. Implementors using an on-disk network graph should be aware of
1323 /// repeated disk I/O for queries accessing different parts of the network graph.
1324 pub trait RoutingMessageHandler : MessageSendEventsProvider {
1325 /// Handle an incoming `node_announcement` message, returning `true` if it should be forwarded on,
1326 /// `false` or returning an `Err` otherwise.
1327 fn handle_node_announcement(&self, msg: &NodeAnnouncement) -> Result<bool, LightningError>;
1328 /// Handle a `channel_announcement` message, returning `true` if it should be forwarded on, `false`
1329 /// or returning an `Err` otherwise.
1330 fn handle_channel_announcement(&self, msg: &ChannelAnnouncement) -> Result<bool, LightningError>;
1331 /// Handle an incoming `channel_update` message, returning true if it should be forwarded on,
1332 /// `false` or returning an `Err` otherwise.
1333 fn handle_channel_update(&self, msg: &ChannelUpdate) -> Result<bool, LightningError>;
1334 /// Gets channel announcements and updates required to dump our routing table to a remote node,
1335 /// starting at the `short_channel_id` indicated by `starting_point` and including announcements
1336 /// for a single channel.
1337 fn get_next_channel_announcement(&self, starting_point: u64) -> Option<(ChannelAnnouncement, Option<ChannelUpdate>, Option<ChannelUpdate>)>;
1338 /// Gets a node announcement required to dump our routing table to a remote node, starting at
1339 /// the node *after* the provided pubkey and including up to one announcement immediately
1340 /// higher (as defined by `<PublicKey as Ord>::cmp`) than `starting_point`.
1341 /// If `None` is provided for `starting_point`, we start at the first node.
1342 fn get_next_node_announcement(&self, starting_point: Option<&NodeId>) -> Option<NodeAnnouncement>;
1343 /// Called when a connection is established with a peer. This can be used to
1344 /// perform routing table synchronization using a strategy defined by the
1347 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1348 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1349 /// message handlers may still wish to communicate with this peer.
1350 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1351 /// Handles the reply of a query we initiated to learn about channels
1352 /// for a given range of blocks. We can expect to receive one or more
1353 /// replies to a single query.
1354 fn handle_reply_channel_range(&self, their_node_id: &PublicKey, msg: ReplyChannelRange) -> Result<(), LightningError>;
1355 /// Handles the reply of a query we initiated asking for routing gossip
1356 /// messages for a list of channels. We should receive this message when
1357 /// a node has completed its best effort to send us the pertaining routing
1358 /// gossip messages.
1359 fn handle_reply_short_channel_ids_end(&self, their_node_id: &PublicKey, msg: ReplyShortChannelIdsEnd) -> Result<(), LightningError>;
1360 /// Handles when a peer asks us to send a list of `short_channel_id`s
1361 /// for the requested range of blocks.
1362 fn handle_query_channel_range(&self, their_node_id: &PublicKey, msg: QueryChannelRange) -> Result<(), LightningError>;
1363 /// Handles when a peer asks us to send routing gossip messages for a
1364 /// list of `short_channel_id`s.
1365 fn handle_query_short_channel_ids(&self, their_node_id: &PublicKey, msg: QueryShortChannelIds) -> Result<(), LightningError>;
1367 // Handler queueing status:
1368 /// Indicates that there are a large number of [`ChannelAnnouncement`] (or other) messages
1369 /// pending some async action. While there is no guarantee of the rate of future messages, the
1370 /// caller should seek to reduce the rate of new gossip messages handled, especially
1371 /// [`ChannelAnnouncement`]s.
1372 fn processing_queue_high(&self) -> bool;
1374 // Handler information:
1375 /// Gets the node feature flags which this handler itself supports. All available handlers are
1376 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1377 /// which are broadcasted in our [`NodeAnnouncement`] message.
1378 fn provided_node_features(&self) -> NodeFeatures;
1379 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1380 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1381 /// which are sent in our [`Init`] message.
1383 /// Note that this method is called before [`Self::peer_connected`].
1384 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1387 /// A trait to describe an object that can receive onion messages.
1388 pub trait OnionMessageHandler : OnionMessageProvider {
1389 /// Handle an incoming `onion_message` message from the given peer.
1390 fn handle_onion_message(&self, peer_node_id: &PublicKey, msg: &OnionMessage);
1391 /// Called when a connection is established with a peer. Can be used to track which peers
1392 /// advertise onion message support and are online.
1394 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1395 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1396 /// message handlers may still wish to communicate with this peer.
1397 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1398 /// Indicates a connection to the peer failed/an existing connection was lost. Allows handlers to
1399 /// drop and refuse to forward onion messages to this peer.
1400 fn peer_disconnected(&self, their_node_id: &PublicKey);
1402 // Handler information:
1403 /// Gets the node feature flags which this handler itself supports. All available handlers are
1404 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1405 /// which are broadcasted in our [`NodeAnnouncement`] message.
1406 fn provided_node_features(&self) -> NodeFeatures;
1408 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1409 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1410 /// which are sent in our [`Init`] message.
1412 /// Note that this method is called before [`Self::peer_connected`].
1413 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1416 mod fuzzy_internal_msgs {
1417 use crate::prelude::*;
1418 use crate::ln::{PaymentPreimage, PaymentSecret};
1420 // These types aren't intended to be pub, but are exposed for direct fuzzing (as we deserialize
1421 // them from untrusted input):
1423 pub(crate) struct FinalOnionHopData {
1424 pub(crate) payment_secret: PaymentSecret,
1425 /// The total value, in msat, of the payment as received by the ultimate recipient.
1426 /// Message serialization may panic if this value is more than 21 million Bitcoin.
1427 pub(crate) total_msat: u64,
1430 pub(crate) enum OnionHopDataFormat {
1432 short_channel_id: u64,
1435 payment_data: Option<FinalOnionHopData>,
1436 payment_metadata: Option<Vec<u8>>,
1437 keysend_preimage: Option<PaymentPreimage>,
1441 pub struct OnionHopData {
1442 pub(crate) format: OnionHopDataFormat,
1443 /// The value, in msat, of the payment after this hop's fee is deducted.
1444 /// Message serialization may panic if this value is more than 21 million Bitcoin.
1445 pub(crate) amt_to_forward: u64,
1446 pub(crate) outgoing_cltv_value: u32,
1449 pub struct DecodedOnionErrorPacket {
1450 pub(crate) hmac: [u8; 32],
1451 pub(crate) failuremsg: Vec<u8>,
1452 pub(crate) pad: Vec<u8>,
1456 pub use self::fuzzy_internal_msgs::*;
1457 #[cfg(not(fuzzing))]
1458 pub(crate) use self::fuzzy_internal_msgs::*;
1461 pub(crate) struct OnionPacket {
1462 pub(crate) version: u8,
1463 /// In order to ensure we always return an error on onion decode in compliance with [BOLT
1464 /// #4](https://github.com/lightning/bolts/blob/master/04-onion-routing.md), we have to
1465 /// deserialize `OnionPacket`s contained in [`UpdateAddHTLC`] messages even if the ephemeral
1466 /// public key (here) is bogus, so we hold a [`Result`] instead of a [`PublicKey`] as we'd
1468 pub(crate) public_key: Result<PublicKey, secp256k1::Error>,
1469 pub(crate) hop_data: [u8; 20*65],
1470 pub(crate) hmac: [u8; 32],
1473 impl onion_utils::Packet for OnionPacket {
1474 type Data = onion_utils::FixedSizeOnionPacket;
1475 fn new(pubkey: PublicKey, hop_data: onion_utils::FixedSizeOnionPacket, hmac: [u8; 32]) -> Self {
1478 public_key: Ok(pubkey),
1479 hop_data: hop_data.0,
1485 impl Eq for OnionPacket { }
1486 impl PartialEq for OnionPacket {
1487 fn eq(&self, other: &OnionPacket) -> bool {
1488 for (i, j) in self.hop_data.iter().zip(other.hop_data.iter()) {
1489 if i != j { return false; }
1491 self.version == other.version &&
1492 self.public_key == other.public_key &&
1493 self.hmac == other.hmac
1497 impl fmt::Debug for OnionPacket {
1498 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1499 f.write_fmt(format_args!("OnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
1503 #[derive(Clone, Debug, PartialEq, Eq)]
1504 pub(crate) struct OnionErrorPacket {
1505 // This really should be a constant size slice, but the spec lets these things be up to 128KB?
1506 // (TODO) We limit it in decode to much lower...
1507 pub(crate) data: Vec<u8>,
1510 impl fmt::Display for DecodeError {
1511 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1513 DecodeError::UnknownVersion => f.write_str("Unknown realm byte in Onion packet"),
1514 DecodeError::UnknownRequiredFeature => f.write_str("Unknown required feature preventing decode"),
1515 DecodeError::InvalidValue => f.write_str("Nonsense bytes didn't map to the type they were interpreted as"),
1516 DecodeError::ShortRead => f.write_str("Packet extended beyond the provided bytes"),
1517 DecodeError::BadLengthDescriptor => f.write_str("A length descriptor in the packet didn't describe the later data correctly"),
1518 DecodeError::Io(ref e) => fmt::Debug::fmt(e, f),
1519 DecodeError::UnsupportedCompression => f.write_str("We don't support receiving messages with zlib-compressed fields"),
1524 impl From<io::Error> for DecodeError {
1525 fn from(e: io::Error) -> Self {
1526 if e.kind() == io::ErrorKind::UnexpectedEof {
1527 DecodeError::ShortRead
1529 DecodeError::Io(e.kind())
1534 #[cfg(not(taproot))]
1535 impl_writeable_msg!(AcceptChannel, {
1536 temporary_channel_id,
1537 dust_limit_satoshis,
1538 max_htlc_value_in_flight_msat,
1539 channel_reserve_satoshis,
1545 revocation_basepoint,
1547 delayed_payment_basepoint,
1549 first_per_commitment_point,
1551 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1552 (1, channel_type, option),
1556 impl_writeable_msg!(AcceptChannel, {
1557 temporary_channel_id,
1558 dust_limit_satoshis,
1559 max_htlc_value_in_flight_msat,
1560 channel_reserve_satoshis,
1566 revocation_basepoint,
1568 delayed_payment_basepoint,
1570 first_per_commitment_point,
1572 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1573 (1, channel_type, option),
1574 (4, next_local_nonce, option),
1577 impl_writeable_msg!(AcceptChannelV2, {
1578 temporary_channel_id,
1580 dust_limit_satoshis,
1581 max_htlc_value_in_flight_msat,
1587 revocation_basepoint,
1589 delayed_payment_basepoint,
1591 first_per_commitment_point,
1592 second_per_commitment_point,
1594 (0, shutdown_scriptpubkey, option),
1595 (1, channel_type, option),
1596 (2, require_confirmed_inputs, option),
1599 impl_writeable_msg!(TxAddInput, {
1607 impl_writeable_msg!(TxAddOutput, {
1614 impl_writeable_msg!(TxRemoveInput, {
1619 impl_writeable_msg!(TxRemoveOutput, {
1624 impl_writeable_msg!(TxComplete, {
1628 impl_writeable_msg!(TxSignatures, {
1634 impl_writeable_msg!(TxInitRbf, {
1637 feerate_sat_per_1000_weight,
1639 (0, funding_output_contribution, option),
1642 impl_writeable_msg!(TxAckRbf, {
1645 (0, funding_output_contribution, option),
1648 impl_writeable_msg!(TxAbort, {
1653 impl_writeable_msg!(AnnouncementSignatures, {
1660 impl_writeable_msg!(ChannelReestablish, {
1662 next_local_commitment_number,
1663 next_remote_commitment_number,
1664 your_last_per_commitment_secret,
1665 my_current_per_commitment_point,
1667 (0, next_funding_txid, option),
1670 impl_writeable_msg!(ClosingSigned,
1671 { channel_id, fee_satoshis, signature },
1672 { (1, fee_range, option) }
1675 impl_writeable!(ClosingSignedFeeRange, {
1680 #[cfg(not(taproot))]
1681 impl_writeable_msg!(CommitmentSigned, {
1688 impl_writeable_msg!(CommitmentSigned, {
1693 (2, partial_signature_with_nonce, option)
1696 impl_writeable!(DecodedOnionErrorPacket, {
1702 #[cfg(not(taproot))]
1703 impl_writeable_msg!(FundingCreated, {
1704 temporary_channel_id,
1706 funding_output_index,
1710 impl_writeable_msg!(FundingCreated, {
1711 temporary_channel_id,
1713 funding_output_index,
1716 (2, partial_signature_with_nonce, option),
1717 (4, next_local_nonce, option)
1720 #[cfg(not(taproot))]
1721 impl_writeable_msg!(FundingSigned, {
1727 impl_writeable_msg!(FundingSigned, {
1731 (2, partial_signature_with_nonce, option)
1734 impl_writeable_msg!(ChannelReady, {
1736 next_per_commitment_point,
1738 (1, short_channel_id_alias, option),
1741 impl Writeable for Init {
1742 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1743 // global_features gets the bottom 13 bits of our features, and local_features gets all of
1744 // our relevant feature bits. This keeps us compatible with old nodes.
1745 self.features.write_up_to_13(w)?;
1746 self.features.write(w)?;
1747 encode_tlv_stream!(w, {
1748 (1, self.networks.as_ref().map(|n| WithoutLength(n)), option),
1749 (3, self.remote_network_address, option),
1755 impl Readable for Init {
1756 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1757 let global_features: InitFeatures = Readable::read(r)?;
1758 let features: InitFeatures = Readable::read(r)?;
1759 let mut remote_network_address: Option<NetAddress> = None;
1760 let mut networks: Option<WithoutLength<Vec<ChainHash>>> = None;
1761 decode_tlv_stream!(r, {
1762 (1, networks, option),
1763 (3, remote_network_address, option)
1766 features: features | global_features,
1767 networks: networks.map(|n| n.0),
1768 remote_network_address,
1773 impl_writeable_msg!(OpenChannel, {
1775 temporary_channel_id,
1778 dust_limit_satoshis,
1779 max_htlc_value_in_flight_msat,
1780 channel_reserve_satoshis,
1786 revocation_basepoint,
1788 delayed_payment_basepoint,
1790 first_per_commitment_point,
1793 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1794 (1, channel_type, option),
1797 impl_writeable_msg!(OpenChannelV2, {
1799 temporary_channel_id,
1800 funding_feerate_sat_per_1000_weight,
1801 commitment_feerate_sat_per_1000_weight,
1803 dust_limit_satoshis,
1804 max_htlc_value_in_flight_msat,
1810 revocation_basepoint,
1812 delayed_payment_basepoint,
1814 first_per_commitment_point,
1815 second_per_commitment_point,
1818 (0, shutdown_scriptpubkey, option),
1819 (1, channel_type, option),
1820 (2, require_confirmed_inputs, option),
1823 #[cfg(not(taproot))]
1824 impl_writeable_msg!(RevokeAndACK, {
1826 per_commitment_secret,
1827 next_per_commitment_point
1831 impl_writeable_msg!(RevokeAndACK, {
1833 per_commitment_secret,
1834 next_per_commitment_point
1836 (4, next_local_nonce, option)
1839 impl_writeable_msg!(Shutdown, {
1844 impl_writeable_msg!(UpdateFailHTLC, {
1850 impl_writeable_msg!(UpdateFailMalformedHTLC, {
1857 impl_writeable_msg!(UpdateFee, {
1862 impl_writeable_msg!(UpdateFulfillHTLC, {
1868 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
1869 // serialization format in a way which assumes we know the total serialized length/message end
1871 impl_writeable!(OnionErrorPacket, {
1875 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
1876 // serialization format in a way which assumes we know the total serialized length/message end
1878 impl Writeable for OnionPacket {
1879 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1880 self.version.write(w)?;
1881 match self.public_key {
1882 Ok(pubkey) => pubkey.write(w)?,
1883 Err(_) => [0u8;33].write(w)?,
1885 w.write_all(&self.hop_data)?;
1886 self.hmac.write(w)?;
1891 impl Readable for OnionPacket {
1892 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1894 version: Readable::read(r)?,
1896 let mut buf = [0u8;33];
1897 r.read_exact(&mut buf)?;
1898 PublicKey::from_slice(&buf)
1900 hop_data: Readable::read(r)?,
1901 hmac: Readable::read(r)?,
1906 impl_writeable_msg!(UpdateAddHTLC, {
1912 onion_routing_packet,
1914 (65537, skimmed_fee_msat, option)
1917 impl Readable for OnionMessage {
1918 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1919 let blinding_point: PublicKey = Readable::read(r)?;
1920 let len: u16 = Readable::read(r)?;
1921 let mut packet_reader = FixedLengthReader::new(r, len as u64);
1922 let onion_routing_packet: onion_message::Packet = <onion_message::Packet as LengthReadable>::read(&mut packet_reader)?;
1925 onion_routing_packet,
1930 impl Writeable for OnionMessage {
1931 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1932 self.blinding_point.write(w)?;
1933 let onion_packet_len = self.onion_routing_packet.serialized_length();
1934 (onion_packet_len as u16).write(w)?;
1935 self.onion_routing_packet.write(w)?;
1940 impl Writeable for FinalOnionHopData {
1941 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1942 self.payment_secret.0.write(w)?;
1943 HighZeroBytesDroppedBigSize(self.total_msat).write(w)
1947 impl Readable for FinalOnionHopData {
1948 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1949 let secret: [u8; 32] = Readable::read(r)?;
1950 let amt: HighZeroBytesDroppedBigSize<u64> = Readable::read(r)?;
1951 Ok(Self { payment_secret: PaymentSecret(secret), total_msat: amt.0 })
1955 impl Writeable for OnionHopData {
1956 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1958 OnionHopDataFormat::NonFinalNode { short_channel_id } => {
1959 _encode_varint_length_prefixed_tlv!(w, {
1960 (2, HighZeroBytesDroppedBigSize(self.amt_to_forward), required),
1961 (4, HighZeroBytesDroppedBigSize(self.outgoing_cltv_value), required),
1962 (6, short_channel_id, required)
1965 OnionHopDataFormat::FinalNode { ref payment_data, ref payment_metadata, ref keysend_preimage } => {
1966 _encode_varint_length_prefixed_tlv!(w, {
1967 (2, HighZeroBytesDroppedBigSize(self.amt_to_forward), required),
1968 (4, HighZeroBytesDroppedBigSize(self.outgoing_cltv_value), required),
1969 (8, payment_data, option),
1970 (16, payment_metadata.as_ref().map(|m| WithoutLength(m)), option),
1971 (5482373484, keysend_preimage, option)
1979 impl Readable for OnionHopData {
1980 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1981 let mut amt = HighZeroBytesDroppedBigSize(0u64);
1982 let mut cltv_value = HighZeroBytesDroppedBigSize(0u32);
1983 let mut short_id: Option<u64> = None;
1984 let mut payment_data: Option<FinalOnionHopData> = None;
1985 let mut payment_metadata: Option<WithoutLength<Vec<u8>>> = None;
1986 let mut keysend_preimage: Option<PaymentPreimage> = None;
1987 read_tlv_fields!(r, {
1989 (4, cltv_value, required),
1990 (6, short_id, option),
1991 (8, payment_data, option),
1992 (16, payment_metadata, option),
1993 // See https://github.com/lightning/blips/blob/master/blip-0003.md
1994 (5482373484, keysend_preimage, option)
1997 let format = if let Some(short_channel_id) = short_id {
1998 if payment_data.is_some() { return Err(DecodeError::InvalidValue); }
1999 if payment_metadata.is_some() { return Err(DecodeError::InvalidValue); }
2000 OnionHopDataFormat::NonFinalNode {
2004 if let Some(data) = &payment_data {
2005 if data.total_msat > MAX_VALUE_MSAT {
2006 return Err(DecodeError::InvalidValue);
2009 OnionHopDataFormat::FinalNode {
2011 payment_metadata: payment_metadata.map(|w| w.0),
2016 if amt.0 > MAX_VALUE_MSAT {
2017 return Err(DecodeError::InvalidValue);
2021 amt_to_forward: amt.0,
2022 outgoing_cltv_value: cltv_value.0,
2027 // ReadableArgs because we need onion_utils::decode_next_hop to accommodate payment packets and
2028 // onion message packets.
2029 impl ReadableArgs<()> for OnionHopData {
2030 fn read<R: Read>(r: &mut R, _arg: ()) -> Result<Self, DecodeError> {
2031 <Self as Readable>::read(r)
2035 impl Writeable for Ping {
2036 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2037 self.ponglen.write(w)?;
2038 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2043 impl Readable for Ping {
2044 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2046 ponglen: Readable::read(r)?,
2048 let byteslen = Readable::read(r)?;
2049 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2056 impl Writeable for Pong {
2057 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2058 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2063 impl Readable for Pong {
2064 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2067 let byteslen = Readable::read(r)?;
2068 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2075 impl Writeable for UnsignedChannelAnnouncement {
2076 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2077 self.features.write(w)?;
2078 self.chain_hash.write(w)?;
2079 self.short_channel_id.write(w)?;
2080 self.node_id_1.write(w)?;
2081 self.node_id_2.write(w)?;
2082 self.bitcoin_key_1.write(w)?;
2083 self.bitcoin_key_2.write(w)?;
2084 w.write_all(&self.excess_data[..])?;
2089 impl Readable for UnsignedChannelAnnouncement {
2090 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2092 features: Readable::read(r)?,
2093 chain_hash: Readable::read(r)?,
2094 short_channel_id: Readable::read(r)?,
2095 node_id_1: Readable::read(r)?,
2096 node_id_2: Readable::read(r)?,
2097 bitcoin_key_1: Readable::read(r)?,
2098 bitcoin_key_2: Readable::read(r)?,
2099 excess_data: read_to_end(r)?,
2104 impl_writeable!(ChannelAnnouncement, {
2107 bitcoin_signature_1,
2108 bitcoin_signature_2,
2112 impl Writeable for UnsignedChannelUpdate {
2113 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2114 // `message_flags` used to indicate presence of `htlc_maximum_msat`, but was deprecated in the spec.
2115 const MESSAGE_FLAGS: u8 = 1;
2116 self.chain_hash.write(w)?;
2117 self.short_channel_id.write(w)?;
2118 self.timestamp.write(w)?;
2119 let all_flags = self.flags as u16 | ((MESSAGE_FLAGS as u16) << 8);
2120 all_flags.write(w)?;
2121 self.cltv_expiry_delta.write(w)?;
2122 self.htlc_minimum_msat.write(w)?;
2123 self.fee_base_msat.write(w)?;
2124 self.fee_proportional_millionths.write(w)?;
2125 self.htlc_maximum_msat.write(w)?;
2126 w.write_all(&self.excess_data[..])?;
2131 impl Readable for UnsignedChannelUpdate {
2132 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2134 chain_hash: Readable::read(r)?,
2135 short_channel_id: Readable::read(r)?,
2136 timestamp: Readable::read(r)?,
2138 let flags: u16 = Readable::read(r)?;
2139 // Note: we ignore the `message_flags` for now, since it was deprecated by the spec.
2142 cltv_expiry_delta: Readable::read(r)?,
2143 htlc_minimum_msat: Readable::read(r)?,
2144 fee_base_msat: Readable::read(r)?,
2145 fee_proportional_millionths: Readable::read(r)?,
2146 htlc_maximum_msat: Readable::read(r)?,
2147 excess_data: read_to_end(r)?,
2152 impl_writeable!(ChannelUpdate, {
2157 impl Writeable for ErrorMessage {
2158 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2159 self.channel_id.write(w)?;
2160 (self.data.len() as u16).write(w)?;
2161 w.write_all(self.data.as_bytes())?;
2166 impl Readable for ErrorMessage {
2167 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2169 channel_id: Readable::read(r)?,
2171 let sz: usize = <u16 as Readable>::read(r)? as usize;
2172 let mut data = Vec::with_capacity(sz);
2174 r.read_exact(&mut data)?;
2175 match String::from_utf8(data) {
2177 Err(_) => return Err(DecodeError::InvalidValue),
2184 impl Writeable for WarningMessage {
2185 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2186 self.channel_id.write(w)?;
2187 (self.data.len() as u16).write(w)?;
2188 w.write_all(self.data.as_bytes())?;
2193 impl Readable for WarningMessage {
2194 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2196 channel_id: Readable::read(r)?,
2198 let sz: usize = <u16 as Readable>::read(r)? as usize;
2199 let mut data = Vec::with_capacity(sz);
2201 r.read_exact(&mut data)?;
2202 match String::from_utf8(data) {
2204 Err(_) => return Err(DecodeError::InvalidValue),
2211 impl Writeable for UnsignedNodeAnnouncement {
2212 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2213 self.features.write(w)?;
2214 self.timestamp.write(w)?;
2215 self.node_id.write(w)?;
2216 w.write_all(&self.rgb)?;
2217 self.alias.write(w)?;
2219 let mut addr_len = 0;
2220 for addr in self.addresses.iter() {
2221 addr_len += 1 + addr.len();
2223 (addr_len + self.excess_address_data.len() as u16).write(w)?;
2224 for addr in self.addresses.iter() {
2227 w.write_all(&self.excess_address_data[..])?;
2228 w.write_all(&self.excess_data[..])?;
2233 impl Readable for UnsignedNodeAnnouncement {
2234 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2235 let features: NodeFeatures = Readable::read(r)?;
2236 let timestamp: u32 = Readable::read(r)?;
2237 let node_id: NodeId = Readable::read(r)?;
2238 let mut rgb = [0; 3];
2239 r.read_exact(&mut rgb)?;
2240 let alias: NodeAlias = Readable::read(r)?;
2242 let addr_len: u16 = Readable::read(r)?;
2243 let mut addresses: Vec<NetAddress> = Vec::new();
2244 let mut addr_readpos = 0;
2245 let mut excess = false;
2246 let mut excess_byte = 0;
2248 if addr_len <= addr_readpos { break; }
2249 match Readable::read(r) {
2251 if addr_len < addr_readpos + 1 + addr.len() {
2252 return Err(DecodeError::BadLengthDescriptor);
2254 addr_readpos += (1 + addr.len()) as u16;
2255 addresses.push(addr);
2257 Ok(Err(unknown_descriptor)) => {
2259 excess_byte = unknown_descriptor;
2262 Err(DecodeError::ShortRead) => return Err(DecodeError::BadLengthDescriptor),
2263 Err(e) => return Err(e),
2267 let mut excess_data = vec![];
2268 let excess_address_data = if addr_readpos < addr_len {
2269 let mut excess_address_data = vec![0; (addr_len - addr_readpos) as usize];
2270 r.read_exact(&mut excess_address_data[if excess { 1 } else { 0 }..])?;
2272 excess_address_data[0] = excess_byte;
2277 excess_data.push(excess_byte);
2281 excess_data.extend(read_to_end(r)?.iter());
2282 Ok(UnsignedNodeAnnouncement {
2289 excess_address_data,
2295 impl_writeable!(NodeAnnouncement, {
2300 impl Readable for QueryShortChannelIds {
2301 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2302 let chain_hash: BlockHash = Readable::read(r)?;
2304 let encoding_len: u16 = Readable::read(r)?;
2305 let encoding_type: u8 = Readable::read(r)?;
2307 // Must be encoding_type=0 uncompressed serialization. We do not
2308 // support encoding_type=1 zlib serialization.
2309 if encoding_type != EncodingType::Uncompressed as u8 {
2310 return Err(DecodeError::UnsupportedCompression);
2313 // We expect the encoding_len to always includes the 1-byte
2314 // encoding_type and that short_channel_ids are 8-bytes each
2315 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2316 return Err(DecodeError::InvalidValue);
2319 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2320 // less the 1-byte encoding_type
2321 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2322 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2323 for _ in 0..short_channel_id_count {
2324 short_channel_ids.push(Readable::read(r)?);
2327 Ok(QueryShortChannelIds {
2334 impl Writeable for QueryShortChannelIds {
2335 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2336 // Calculated from 1-byte encoding_type plus 8-bytes per short_channel_id
2337 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2339 self.chain_hash.write(w)?;
2340 encoding_len.write(w)?;
2342 // We only support type=0 uncompressed serialization
2343 (EncodingType::Uncompressed as u8).write(w)?;
2345 for scid in self.short_channel_ids.iter() {
2353 impl_writeable_msg!(ReplyShortChannelIdsEnd, {
2358 impl QueryChannelRange {
2359 /// Calculates the overflow safe ending block height for the query.
2361 /// Overflow returns `0xffffffff`, otherwise returns `first_blocknum + number_of_blocks`.
2362 pub fn end_blocknum(&self) -> u32 {
2363 match self.first_blocknum.checked_add(self.number_of_blocks) {
2364 Some(block) => block,
2365 None => u32::max_value(),
2370 impl_writeable_msg!(QueryChannelRange, {
2376 impl Readable for ReplyChannelRange {
2377 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2378 let chain_hash: BlockHash = Readable::read(r)?;
2379 let first_blocknum: u32 = Readable::read(r)?;
2380 let number_of_blocks: u32 = Readable::read(r)?;
2381 let sync_complete: bool = Readable::read(r)?;
2383 let encoding_len: u16 = Readable::read(r)?;
2384 let encoding_type: u8 = Readable::read(r)?;
2386 // Must be encoding_type=0 uncompressed serialization. We do not
2387 // support encoding_type=1 zlib serialization.
2388 if encoding_type != EncodingType::Uncompressed as u8 {
2389 return Err(DecodeError::UnsupportedCompression);
2392 // We expect the encoding_len to always includes the 1-byte
2393 // encoding_type and that short_channel_ids are 8-bytes each
2394 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2395 return Err(DecodeError::InvalidValue);
2398 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2399 // less the 1-byte encoding_type
2400 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2401 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2402 for _ in 0..short_channel_id_count {
2403 short_channel_ids.push(Readable::read(r)?);
2406 Ok(ReplyChannelRange {
2416 impl Writeable for ReplyChannelRange {
2417 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2418 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2419 self.chain_hash.write(w)?;
2420 self.first_blocknum.write(w)?;
2421 self.number_of_blocks.write(w)?;
2422 self.sync_complete.write(w)?;
2424 encoding_len.write(w)?;
2425 (EncodingType::Uncompressed as u8).write(w)?;
2426 for scid in self.short_channel_ids.iter() {
2434 impl_writeable_msg!(GossipTimestampFilter, {
2442 use bitcoin::blockdata::constants::ChainHash;
2443 use bitcoin::{Transaction, PackedLockTime, TxIn, Script, Sequence, Witness, TxOut};
2445 use crate::ln::{PaymentPreimage, PaymentHash, PaymentSecret};
2446 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
2447 use crate::ln::msgs::{self, FinalOnionHopData, OnionErrorPacket, OnionHopDataFormat};
2448 use crate::routing::gossip::{NodeAlias, NodeId};
2449 use crate::util::ser::{Writeable, Readable, Hostname, TransactionU16LenLimited};
2451 use bitcoin::hashes::hex::FromHex;
2452 use bitcoin::util::address::Address;
2453 use bitcoin::network::constants::Network;
2454 use bitcoin::blockdata::script::Builder;
2455 use bitcoin::blockdata::opcodes;
2456 use bitcoin::hash_types::{Txid, BlockHash};
2458 use bitcoin::secp256k1::{PublicKey,SecretKey};
2459 use bitcoin::secp256k1::{Secp256k1, Message};
2461 use crate::io::{self, Cursor};
2462 use crate::prelude::*;
2463 use core::convert::TryFrom;
2464 use core::str::FromStr;
2466 use crate::chain::transaction::OutPoint;
2469 fn encoding_channel_reestablish() {
2471 let secp_ctx = Secp256k1::new();
2472 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2475 let cr = msgs::ChannelReestablish {
2476 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],
2477 next_local_commitment_number: 3,
2478 next_remote_commitment_number: 4,
2479 your_last_per_commitment_secret: [9;32],
2480 my_current_per_commitment_point: public_key,
2481 next_funding_txid: None,
2484 let encoded_value = cr.encode();
2488 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
2489 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2490 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2491 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
2492 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
2498 fn encoding_channel_reestablish_with_next_funding_txid() {
2500 let secp_ctx = Secp256k1::new();
2501 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2504 let cr = msgs::ChannelReestablish {
2505 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],
2506 next_local_commitment_number: 3,
2507 next_remote_commitment_number: 4,
2508 your_last_per_commitment_secret: [9;32],
2509 my_current_per_commitment_point: public_key,
2510 next_funding_txid: Some(Txid::from_hash(bitcoin::hashes::Hash::from_slice(&[
2511 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,
2515 let encoded_value = cr.encode();
2519 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
2520 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2521 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2522 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
2523 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
2524 0, // Type (next_funding_txid)
2526 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
2531 macro_rules! get_keys_from {
2532 ($slice: expr, $secp_ctx: expr) => {
2534 let privkey = SecretKey::from_slice(&hex::decode($slice).unwrap()[..]).unwrap();
2535 let pubkey = PublicKey::from_secret_key(&$secp_ctx, &privkey);
2541 macro_rules! get_sig_on {
2542 ($privkey: expr, $ctx: expr, $string: expr) => {
2544 let sighash = Message::from_slice(&$string.into_bytes()[..]).unwrap();
2545 $ctx.sign_ecdsa(&sighash, &$privkey)
2551 fn encoding_announcement_signatures() {
2552 let secp_ctx = Secp256k1::new();
2553 let (privkey, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2554 let sig_1 = get_sig_on!(privkey, secp_ctx, String::from("01010101010101010101010101010101"));
2555 let sig_2 = get_sig_on!(privkey, secp_ctx, String::from("02020202020202020202020202020202"));
2556 let announcement_signatures = msgs::AnnouncementSignatures {
2557 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],
2558 short_channel_id: 2316138423780173,
2559 node_signature: sig_1,
2560 bitcoin_signature: sig_2,
2563 let encoded_value = announcement_signatures.encode();
2564 assert_eq!(encoded_value, hex::decode("040000000000000005000000000000000600000000000000070000000000000000083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073acf9953cef4700860f5967838eba2bae89288ad188ebf8b20bf995c3ea53a26df1876d0a3a0e13172ba286a673140190c02ba9da60a2e43a745188c8a83c7f3ef").unwrap());
2567 fn do_encoding_channel_announcement(unknown_features_bits: bool, excess_data: bool) {
2568 let secp_ctx = Secp256k1::new();
2569 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2570 let (privkey_2, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2571 let (privkey_3, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2572 let (privkey_4, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2573 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2574 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
2575 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
2576 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
2577 let mut features = ChannelFeatures::empty();
2578 if unknown_features_bits {
2579 features = ChannelFeatures::from_le_bytes(vec![0xFF, 0xFF]);
2581 let unsigned_channel_announcement = msgs::UnsignedChannelAnnouncement {
2583 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2584 short_channel_id: 2316138423780173,
2585 node_id_1: NodeId::from_pubkey(&pubkey_1),
2586 node_id_2: NodeId::from_pubkey(&pubkey_2),
2587 bitcoin_key_1: NodeId::from_pubkey(&pubkey_3),
2588 bitcoin_key_2: NodeId::from_pubkey(&pubkey_4),
2589 excess_data: if excess_data { vec![10, 0, 0, 20, 0, 0, 30, 0, 0, 40] } else { Vec::new() },
2591 let channel_announcement = msgs::ChannelAnnouncement {
2592 node_signature_1: sig_1,
2593 node_signature_2: sig_2,
2594 bitcoin_signature_1: sig_3,
2595 bitcoin_signature_2: sig_4,
2596 contents: unsigned_channel_announcement,
2598 let encoded_value = channel_announcement.encode();
2599 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a1735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap();
2600 if unknown_features_bits {
2601 target_value.append(&mut hex::decode("0002ffff").unwrap());
2603 target_value.append(&mut hex::decode("0000").unwrap());
2605 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2606 target_value.append(&mut hex::decode("00083a840000034d031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
2608 target_value.append(&mut hex::decode("0a00001400001e000028").unwrap());
2610 assert_eq!(encoded_value, target_value);
2614 fn encoding_channel_announcement() {
2615 do_encoding_channel_announcement(true, false);
2616 do_encoding_channel_announcement(false, true);
2617 do_encoding_channel_announcement(false, false);
2618 do_encoding_channel_announcement(true, true);
2621 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) {
2622 let secp_ctx = Secp256k1::new();
2623 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2624 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2625 let features = if unknown_features_bits {
2626 NodeFeatures::from_le_bytes(vec![0xFF, 0xFF])
2628 // Set to some features we may support
2629 NodeFeatures::from_le_bytes(vec![2 | 1 << 5])
2631 let mut addresses = Vec::new();
2633 addresses.push(msgs::NetAddress::IPv4 {
2634 addr: [255, 254, 253, 252],
2639 addresses.push(msgs::NetAddress::IPv6 {
2640 addr: [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240],
2645 addresses.push(msgs::NetAddress::OnionV2(
2646 [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 38, 7]
2650 addresses.push(msgs::NetAddress::OnionV3 {
2651 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],
2658 addresses.push(msgs::NetAddress::Hostname {
2659 hostname: Hostname::try_from(String::from("host")).unwrap(),
2663 let mut addr_len = 0;
2664 for addr in &addresses {
2665 addr_len += addr.len() + 1;
2667 let unsigned_node_announcement = msgs::UnsignedNodeAnnouncement {
2669 timestamp: 20190119,
2670 node_id: NodeId::from_pubkey(&pubkey_1),
2672 alias: NodeAlias([16;32]),
2674 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() },
2675 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() },
2677 addr_len += unsigned_node_announcement.excess_address_data.len() as u16;
2678 let node_announcement = msgs::NodeAnnouncement {
2680 contents: unsigned_node_announcement,
2682 let encoded_value = node_announcement.encode();
2683 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
2684 if unknown_features_bits {
2685 target_value.append(&mut hex::decode("0002ffff").unwrap());
2687 target_value.append(&mut hex::decode("000122").unwrap());
2689 target_value.append(&mut hex::decode("013413a7031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f2020201010101010101010101010101010101010101010101010101010101010101010").unwrap());
2690 target_value.append(&mut vec![(addr_len >> 8) as u8, addr_len as u8]);
2692 target_value.append(&mut hex::decode("01fffefdfc2607").unwrap());
2695 target_value.append(&mut hex::decode("02fffefdfcfbfaf9f8f7f6f5f4f3f2f1f02607").unwrap());
2698 target_value.append(&mut hex::decode("03fffefdfcfbfaf9f8f7f62607").unwrap());
2701 target_value.append(&mut hex::decode("04fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0efeeedecebeae9e8e7e6e5e4e3e2e1e00020102607").unwrap());
2704 target_value.append(&mut hex::decode("0504686f73742607").unwrap());
2706 if excess_address_data {
2707 target_value.append(&mut hex::decode("216c280b5395a2546e7e4b2663e04f811622f15a4f92e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d269").unwrap());
2710 target_value.append(&mut hex::decode("3b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
2712 assert_eq!(encoded_value, target_value);
2716 fn encoding_node_announcement() {
2717 do_encoding_node_announcement(true, true, true, true, true, true, true, true);
2718 do_encoding_node_announcement(false, false, false, false, false, false, false, false);
2719 do_encoding_node_announcement(false, true, false, false, false, false, false, false);
2720 do_encoding_node_announcement(false, false, true, false, false, false, false, false);
2721 do_encoding_node_announcement(false, false, false, true, false, false, false, false);
2722 do_encoding_node_announcement(false, false, false, false, true, false, false, false);
2723 do_encoding_node_announcement(false, false, false, false, false, true, false, false);
2724 do_encoding_node_announcement(false, false, false, false, false, false, true, false);
2725 do_encoding_node_announcement(false, true, false, true, false, false, true, false);
2726 do_encoding_node_announcement(false, false, true, false, true, false, false, false);
2729 fn do_encoding_channel_update(direction: bool, disable: bool, excess_data: bool) {
2730 let secp_ctx = Secp256k1::new();
2731 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2732 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2733 let unsigned_channel_update = msgs::UnsignedChannelUpdate {
2734 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2735 short_channel_id: 2316138423780173,
2736 timestamp: 20190119,
2737 flags: if direction { 1 } else { 0 } | if disable { 1 << 1 } else { 0 },
2738 cltv_expiry_delta: 144,
2739 htlc_minimum_msat: 1000000,
2740 htlc_maximum_msat: 131355275467161,
2741 fee_base_msat: 10000,
2742 fee_proportional_millionths: 20,
2743 excess_data: if excess_data { vec![0, 0, 0, 0, 59, 154, 202, 0] } else { Vec::new() }
2745 let channel_update = msgs::ChannelUpdate {
2747 contents: unsigned_channel_update
2749 let encoded_value = channel_update.encode();
2750 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
2751 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2752 target_value.append(&mut hex::decode("00083a840000034d013413a7").unwrap());
2753 target_value.append(&mut hex::decode("01").unwrap());
2754 target_value.append(&mut hex::decode("00").unwrap());
2756 let flag = target_value.last_mut().unwrap();
2760 let flag = target_value.last_mut().unwrap();
2761 *flag = *flag | 1 << 1;
2763 target_value.append(&mut hex::decode("009000000000000f42400000271000000014").unwrap());
2764 target_value.append(&mut hex::decode("0000777788889999").unwrap());
2766 target_value.append(&mut hex::decode("000000003b9aca00").unwrap());
2768 assert_eq!(encoded_value, target_value);
2772 fn encoding_channel_update() {
2773 do_encoding_channel_update(false, false, false);
2774 do_encoding_channel_update(false, false, true);
2775 do_encoding_channel_update(true, false, false);
2776 do_encoding_channel_update(true, false, true);
2777 do_encoding_channel_update(false, true, false);
2778 do_encoding_channel_update(false, true, true);
2779 do_encoding_channel_update(true, true, false);
2780 do_encoding_channel_update(true, true, true);
2783 fn do_encoding_open_channel(random_bit: bool, shutdown: bool, incl_chan_type: bool) {
2784 let secp_ctx = Secp256k1::new();
2785 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2786 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2787 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2788 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2789 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
2790 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
2791 let open_channel = msgs::OpenChannel {
2792 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2793 temporary_channel_id: [2; 32],
2794 funding_satoshis: 1311768467284833366,
2795 push_msat: 2536655962884945560,
2796 dust_limit_satoshis: 3608586615801332854,
2797 max_htlc_value_in_flight_msat: 8517154655701053848,
2798 channel_reserve_satoshis: 8665828695742877976,
2799 htlc_minimum_msat: 2316138423780173,
2800 feerate_per_kw: 821716,
2801 to_self_delay: 49340,
2802 max_accepted_htlcs: 49340,
2803 funding_pubkey: pubkey_1,
2804 revocation_basepoint: pubkey_2,
2805 payment_point: pubkey_3,
2806 delayed_payment_basepoint: pubkey_4,
2807 htlc_basepoint: pubkey_5,
2808 first_per_commitment_point: pubkey_6,
2809 channel_flags: if random_bit { 1 << 5 } else { 0 },
2810 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
2811 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
2813 let encoded_value = open_channel.encode();
2814 let mut target_value = Vec::new();
2815 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2816 target_value.append(&mut hex::decode("02020202020202020202020202020202020202020202020202020202020202021234567890123456233403289122369832144668701144767633030896203198784335490624111800083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
2818 target_value.append(&mut hex::decode("20").unwrap());
2820 target_value.append(&mut hex::decode("00").unwrap());
2823 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
2826 target_value.append(&mut hex::decode("0100").unwrap());
2828 assert_eq!(encoded_value, target_value);
2832 fn encoding_open_channel() {
2833 do_encoding_open_channel(false, false, false);
2834 do_encoding_open_channel(false, false, true);
2835 do_encoding_open_channel(false, true, false);
2836 do_encoding_open_channel(false, true, true);
2837 do_encoding_open_channel(true, false, false);
2838 do_encoding_open_channel(true, false, true);
2839 do_encoding_open_channel(true, true, false);
2840 do_encoding_open_channel(true, true, true);
2843 fn do_encoding_open_channelv2(random_bit: bool, shutdown: bool, incl_chan_type: bool, require_confirmed_inputs: bool) {
2844 let secp_ctx = Secp256k1::new();
2845 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2846 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2847 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2848 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2849 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
2850 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
2851 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
2852 let open_channelv2 = msgs::OpenChannelV2 {
2853 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2854 temporary_channel_id: [2; 32],
2855 funding_feerate_sat_per_1000_weight: 821716,
2856 commitment_feerate_sat_per_1000_weight: 821716,
2857 funding_satoshis: 1311768467284833366,
2858 dust_limit_satoshis: 3608586615801332854,
2859 max_htlc_value_in_flight_msat: 8517154655701053848,
2860 htlc_minimum_msat: 2316138423780173,
2861 to_self_delay: 49340,
2862 max_accepted_htlcs: 49340,
2863 locktime: 305419896,
2864 funding_pubkey: pubkey_1,
2865 revocation_basepoint: pubkey_2,
2866 payment_basepoint: pubkey_3,
2867 delayed_payment_basepoint: pubkey_4,
2868 htlc_basepoint: pubkey_5,
2869 first_per_commitment_point: pubkey_6,
2870 second_per_commitment_point: pubkey_7,
2871 channel_flags: if random_bit { 1 << 5 } else { 0 },
2872 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
2873 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
2874 require_confirmed_inputs: if require_confirmed_inputs { Some(()) } else { None },
2876 let encoded_value = open_channelv2.encode();
2877 let mut target_value = Vec::new();
2878 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2879 target_value.append(&mut hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap());
2880 target_value.append(&mut hex::decode("000c89d4").unwrap());
2881 target_value.append(&mut hex::decode("000c89d4").unwrap());
2882 target_value.append(&mut hex::decode("1234567890123456").unwrap());
2883 target_value.append(&mut hex::decode("3214466870114476").unwrap());
2884 target_value.append(&mut hex::decode("7633030896203198").unwrap());
2885 target_value.append(&mut hex::decode("00083a840000034d").unwrap());
2886 target_value.append(&mut hex::decode("c0bc").unwrap());
2887 target_value.append(&mut hex::decode("c0bc").unwrap());
2888 target_value.append(&mut hex::decode("12345678").unwrap());
2889 target_value.append(&mut hex::decode("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap());
2890 target_value.append(&mut hex::decode("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap());
2891 target_value.append(&mut hex::decode("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap());
2892 target_value.append(&mut hex::decode("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
2893 target_value.append(&mut hex::decode("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap());
2894 target_value.append(&mut hex::decode("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
2895 target_value.append(&mut hex::decode("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap());
2898 target_value.append(&mut hex::decode("20").unwrap());
2900 target_value.append(&mut hex::decode("00").unwrap());
2903 target_value.append(&mut hex::decode("001b").unwrap()); // Type 0 + Length 27
2904 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
2907 target_value.append(&mut hex::decode("0100").unwrap());
2909 if require_confirmed_inputs {
2910 target_value.append(&mut hex::decode("0200").unwrap());
2912 assert_eq!(encoded_value, target_value);
2916 fn encoding_open_channelv2() {
2917 do_encoding_open_channelv2(false, false, false, false);
2918 do_encoding_open_channelv2(false, false, false, true);
2919 do_encoding_open_channelv2(false, false, true, false);
2920 do_encoding_open_channelv2(false, false, true, true);
2921 do_encoding_open_channelv2(false, true, false, false);
2922 do_encoding_open_channelv2(false, true, false, true);
2923 do_encoding_open_channelv2(false, true, true, false);
2924 do_encoding_open_channelv2(false, true, true, true);
2925 do_encoding_open_channelv2(true, false, false, false);
2926 do_encoding_open_channelv2(true, false, false, true);
2927 do_encoding_open_channelv2(true, false, true, false);
2928 do_encoding_open_channelv2(true, false, true, true);
2929 do_encoding_open_channelv2(true, true, false, false);
2930 do_encoding_open_channelv2(true, true, false, true);
2931 do_encoding_open_channelv2(true, true, true, false);
2932 do_encoding_open_channelv2(true, true, true, true);
2935 fn do_encoding_accept_channel(shutdown: bool) {
2936 let secp_ctx = Secp256k1::new();
2937 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2938 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2939 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2940 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2941 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
2942 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
2943 let accept_channel = msgs::AcceptChannel {
2944 temporary_channel_id: [2; 32],
2945 dust_limit_satoshis: 1311768467284833366,
2946 max_htlc_value_in_flight_msat: 2536655962884945560,
2947 channel_reserve_satoshis: 3608586615801332854,
2948 htlc_minimum_msat: 2316138423780173,
2949 minimum_depth: 821716,
2950 to_self_delay: 49340,
2951 max_accepted_htlcs: 49340,
2952 funding_pubkey: pubkey_1,
2953 revocation_basepoint: pubkey_2,
2954 payment_point: pubkey_3,
2955 delayed_payment_basepoint: pubkey_4,
2956 htlc_basepoint: pubkey_5,
2957 first_per_commitment_point: pubkey_6,
2958 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
2961 next_local_nonce: None,
2963 let encoded_value = accept_channel.encode();
2964 let mut target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020212345678901234562334032891223698321446687011447600083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap();
2966 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
2968 assert_eq!(encoded_value, target_value);
2972 fn encoding_accept_channel() {
2973 do_encoding_accept_channel(false);
2974 do_encoding_accept_channel(true);
2977 fn do_encoding_accept_channelv2(shutdown: bool) {
2978 let secp_ctx = Secp256k1::new();
2979 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2980 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2981 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2982 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2983 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
2984 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
2985 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
2986 let accept_channelv2 = msgs::AcceptChannelV2 {
2987 temporary_channel_id: [2; 32],
2988 funding_satoshis: 1311768467284833366,
2989 dust_limit_satoshis: 1311768467284833366,
2990 max_htlc_value_in_flight_msat: 2536655962884945560,
2991 htlc_minimum_msat: 2316138423780173,
2992 minimum_depth: 821716,
2993 to_self_delay: 49340,
2994 max_accepted_htlcs: 49340,
2995 funding_pubkey: pubkey_1,
2996 revocation_basepoint: pubkey_2,
2997 payment_basepoint: pubkey_3,
2998 delayed_payment_basepoint: pubkey_4,
2999 htlc_basepoint: pubkey_5,
3000 first_per_commitment_point: pubkey_6,
3001 second_per_commitment_point: pubkey_7,
3002 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3004 require_confirmed_inputs: None,
3006 let encoded_value = accept_channelv2.encode();
3007 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // temporary_channel_id
3008 target_value.append(&mut hex::decode("1234567890123456").unwrap()); // funding_satoshis
3009 target_value.append(&mut hex::decode("1234567890123456").unwrap()); // dust_limit_satoshis
3010 target_value.append(&mut hex::decode("2334032891223698").unwrap()); // max_htlc_value_in_flight_msat
3011 target_value.append(&mut hex::decode("00083a840000034d").unwrap()); // htlc_minimum_msat
3012 target_value.append(&mut hex::decode("000c89d4").unwrap()); // minimum_depth
3013 target_value.append(&mut hex::decode("c0bc").unwrap()); // to_self_delay
3014 target_value.append(&mut hex::decode("c0bc").unwrap()); // max_accepted_htlcs
3015 target_value.append(&mut hex::decode("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap()); // funding_pubkey
3016 target_value.append(&mut hex::decode("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap()); // revocation_basepoint
3017 target_value.append(&mut hex::decode("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap()); // payment_basepoint
3018 target_value.append(&mut hex::decode("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap()); // delayed_payment_basepoint
3019 target_value.append(&mut hex::decode("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap()); // htlc_basepoint
3020 target_value.append(&mut hex::decode("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap()); // first_per_commitment_point
3021 target_value.append(&mut hex::decode("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap()); // second_per_commitment_point
3023 target_value.append(&mut hex::decode("001b").unwrap()); // Type 0 + Length 27
3024 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3026 assert_eq!(encoded_value, target_value);
3030 fn encoding_accept_channelv2() {
3031 do_encoding_accept_channelv2(false);
3032 do_encoding_accept_channelv2(true);
3036 fn encoding_funding_created() {
3037 let secp_ctx = Secp256k1::new();
3038 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3039 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3040 let funding_created = msgs::FundingCreated {
3041 temporary_channel_id: [2; 32],
3042 funding_txid: Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3043 funding_output_index: 255,
3046 partial_signature_with_nonce: None,
3048 next_local_nonce: None,
3050 let encoded_value = funding_created.encode();
3051 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202026e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c200ffd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3052 assert_eq!(encoded_value, target_value);
3056 fn encoding_funding_signed() {
3057 let secp_ctx = Secp256k1::new();
3058 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3059 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3060 let funding_signed = msgs::FundingSigned {
3061 channel_id: [2; 32],
3064 partial_signature_with_nonce: None,
3066 let encoded_value = funding_signed.encode();
3067 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3068 assert_eq!(encoded_value, target_value);
3072 fn encoding_channel_ready() {
3073 let secp_ctx = Secp256k1::new();
3074 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3075 let channel_ready = msgs::ChannelReady {
3076 channel_id: [2; 32],
3077 next_per_commitment_point: pubkey_1,
3078 short_channel_id_alias: None,
3080 let encoded_value = channel_ready.encode();
3081 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3082 assert_eq!(encoded_value, target_value);
3086 fn encoding_tx_add_input() {
3087 let tx_add_input = msgs::TxAddInput {
3088 channel_id: [2; 32],
3089 serial_id: 4886718345,
3090 prevtx: TransactionU16LenLimited::new(Transaction {
3092 lock_time: PackedLockTime(0),
3094 previous_output: OutPoint { txid: Txid::from_hex("305bab643ee297b8b6b76b320792c8223d55082122cb606bf89382146ced9c77").unwrap(), index: 2 }.into_bitcoin_outpoint(),
3095 script_sig: Script::new(),
3096 sequence: Sequence(0xfffffffd),
3097 witness: Witness::from_vec(vec![
3098 hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3099 hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3104 script_pubkey: Address::from_str("bc1qzlffunw52jav8vwdu5x3jfk6sr8u22rmq3xzw2").unwrap().script_pubkey(),
3108 script_pubkey: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().script_pubkey(),
3112 prevtx_out: 305419896,
3113 sequence: 305419896,
3115 let encoded_value = tx_add_input.encode();
3116 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000000012345678900de02000000000101779ced6c148293f86b60cb222108553d22c89207326bb7b6b897e23e64ab5b300200000000fdffffff0236dbc1000000000016001417d29e4dd454bac3b1cde50d1926da80cfc5287b9cbd03000000000016001436ec78d514df462da95e6a00c24daa8915362d420247304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701210301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944000000001234567812345678").unwrap();
3117 assert_eq!(encoded_value, target_value);
3121 fn encoding_tx_add_output() {
3122 let tx_add_output = msgs::TxAddOutput {
3123 channel_id: [2; 32],
3124 serial_id: 4886718345,
3126 script: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().script_pubkey(),
3128 let encoded_value = tx_add_output.encode();
3129 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000000012345678900000001234567890016001436ec78d514df462da95e6a00c24daa8915362d42").unwrap();
3130 assert_eq!(encoded_value, target_value);
3134 fn encoding_tx_remove_input() {
3135 let tx_remove_input = msgs::TxRemoveInput {
3136 channel_id: [2; 32],
3137 serial_id: 4886718345,
3139 let encoded_value = tx_remove_input.encode();
3140 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3141 assert_eq!(encoded_value, target_value);
3145 fn encoding_tx_remove_output() {
3146 let tx_remove_output = msgs::TxRemoveOutput {
3147 channel_id: [2; 32],
3148 serial_id: 4886718345,
3150 let encoded_value = tx_remove_output.encode();
3151 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3152 assert_eq!(encoded_value, target_value);
3156 fn encoding_tx_complete() {
3157 let tx_complete = msgs::TxComplete {
3158 channel_id: [2; 32],
3160 let encoded_value = tx_complete.encode();
3161 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3162 assert_eq!(encoded_value, target_value);
3166 fn encoding_tx_signatures() {
3167 let tx_signatures = msgs::TxSignatures {
3168 channel_id: [2; 32],
3169 tx_hash: Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3171 Witness::from_vec(vec![
3172 hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3173 hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3174 Witness::from_vec(vec![
3175 hex::decode("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap(),
3176 hex::decode("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap()]),
3179 let encoded_value = tx_signatures.encode();
3180 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3181 target_value.append(&mut hex::decode("6e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c2").unwrap()); // tx_hash (sha256) (big endian byte order)
3182 target_value.append(&mut hex::decode("0002").unwrap()); // num_witnesses (u16)
3184 target_value.append(&mut hex::decode("006b").unwrap()); // len of witness_data
3185 target_value.append(&mut hex::decode("02").unwrap()); // num_witness_elements (VarInt)
3186 target_value.append(&mut hex::decode("47").unwrap()); // len of witness element data (VarInt)
3187 target_value.append(&mut hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap());
3188 target_value.append(&mut hex::decode("21").unwrap()); // len of witness element data (VarInt)
3189 target_value.append(&mut hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap());
3191 target_value.append(&mut hex::decode("006c").unwrap()); // len of witness_data
3192 target_value.append(&mut hex::decode("02").unwrap()); // num_witness_elements (VarInt)
3193 target_value.append(&mut hex::decode("48").unwrap()); // len of witness element data (VarInt)
3194 target_value.append(&mut hex::decode("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap());
3195 target_value.append(&mut hex::decode("21").unwrap()); // len of witness element data (VarInt)
3196 target_value.append(&mut hex::decode("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap());
3197 assert_eq!(encoded_value, target_value);
3200 fn do_encoding_tx_init_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3201 let tx_init_rbf = msgs::TxInitRbf {
3202 channel_id: [2; 32],
3203 locktime: 305419896,
3204 feerate_sat_per_1000_weight: 20190119,
3205 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3207 let encoded_value = tx_init_rbf.encode();
3208 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3209 target_value.append(&mut hex::decode("12345678").unwrap()); // locktime
3210 target_value.append(&mut hex::decode("013413a7").unwrap()); // feerate_sat_per_1000_weight
3211 if let Some((_, target)) = funding_value_with_hex_target {
3212 target_value.push(0x00); // Type
3213 target_value.push(target.len() as u8 / 2); // Length
3214 target_value.append(&mut hex::decode(target).unwrap()); // Value (i64)
3216 assert_eq!(encoded_value, target_value);
3220 fn encoding_tx_init_rbf() {
3221 do_encoding_tx_init_rbf(Some((1311768467284833366, "1234567890123456")));
3222 do_encoding_tx_init_rbf(Some((13117684672, "000000030DDFFBC0")));
3223 do_encoding_tx_init_rbf(None);
3226 fn do_encoding_tx_ack_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3227 let tx_ack_rbf = msgs::TxAckRbf {
3228 channel_id: [2; 32],
3229 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3231 let encoded_value = tx_ack_rbf.encode();
3232 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3233 if let Some((_, target)) = funding_value_with_hex_target {
3234 target_value.push(0x00); // Type
3235 target_value.push(target.len() as u8 / 2); // Length
3236 target_value.append(&mut hex::decode(target).unwrap()); // Value (i64)
3238 assert_eq!(encoded_value, target_value);
3242 fn encoding_tx_ack_rbf() {
3243 do_encoding_tx_ack_rbf(Some((1311768467284833366, "1234567890123456")));
3244 do_encoding_tx_ack_rbf(Some((13117684672, "000000030DDFFBC0")));
3245 do_encoding_tx_ack_rbf(None);
3249 fn encoding_tx_abort() {
3250 let tx_abort = msgs::TxAbort {
3251 channel_id: [2; 32],
3252 data: hex::decode("54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap(),
3254 let encoded_value = tx_abort.encode();
3255 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202002C54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap();
3256 assert_eq!(encoded_value, target_value);
3259 fn do_encoding_shutdown(script_type: u8) {
3260 let secp_ctx = Secp256k1::new();
3261 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3262 let script = Builder::new().push_opcode(opcodes::OP_TRUE).into_script();
3263 let shutdown = msgs::Shutdown {
3264 channel_id: [2; 32],
3266 if script_type == 1 { Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey() }
3267 else if script_type == 2 { Address::p2sh(&script, Network::Testnet).unwrap().script_pubkey() }
3268 else if script_type == 3 { Address::p2wpkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).unwrap().script_pubkey() }
3269 else { Address::p2wsh(&script, Network::Testnet).script_pubkey() },
3271 let encoded_value = shutdown.encode();
3272 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3273 if script_type == 1 {
3274 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3275 } else if script_type == 2 {
3276 target_value.append(&mut hex::decode("0017a914da1745e9b549bd0bfa1a569971c77eba30cd5a4b87").unwrap());
3277 } else if script_type == 3 {
3278 target_value.append(&mut hex::decode("0016001479b000887626b294a914501a4cd226b58b235983").unwrap());
3279 } else if script_type == 4 {
3280 target_value.append(&mut hex::decode("002200204ae81572f06e1b88fd5ced7a1a000945432e83e1551e6f721ee9c00b8cc33260").unwrap());
3282 assert_eq!(encoded_value, target_value);
3286 fn encoding_shutdown() {
3287 do_encoding_shutdown(1);
3288 do_encoding_shutdown(2);
3289 do_encoding_shutdown(3);
3290 do_encoding_shutdown(4);
3294 fn encoding_closing_signed() {
3295 let secp_ctx = Secp256k1::new();
3296 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3297 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3298 let closing_signed = msgs::ClosingSigned {
3299 channel_id: [2; 32],
3300 fee_satoshis: 2316138423780173,
3304 let encoded_value = closing_signed.encode();
3305 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3306 assert_eq!(encoded_value, target_value);
3307 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value)).unwrap(), closing_signed);
3309 let closing_signed_with_range = msgs::ClosingSigned {
3310 channel_id: [2; 32],
3311 fee_satoshis: 2316138423780173,
3313 fee_range: Some(msgs::ClosingSignedFeeRange {
3314 min_fee_satoshis: 0xdeadbeef,
3315 max_fee_satoshis: 0x1badcafe01234567,
3318 let encoded_value_with_range = closing_signed_with_range.encode();
3319 let target_value_with_range = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a011000000000deadbeef1badcafe01234567").unwrap();
3320 assert_eq!(encoded_value_with_range, target_value_with_range);
3321 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value_with_range)).unwrap(),
3322 closing_signed_with_range);
3326 fn encoding_update_add_htlc() {
3327 let secp_ctx = Secp256k1::new();
3328 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3329 let onion_routing_packet = msgs::OnionPacket {
3331 public_key: Ok(pubkey_1),
3332 hop_data: [1; 20*65],
3335 let update_add_htlc = msgs::UpdateAddHTLC {
3336 channel_id: [2; 32],
3337 htlc_id: 2316138423780173,
3338 amount_msat: 3608586615801332854,
3339 payment_hash: PaymentHash([1; 32]),
3340 cltv_expiry: 821716,
3341 onion_routing_packet,
3342 skimmed_fee_msat: None,
3344 let encoded_value = update_add_htlc.encode();
3345 let target_value = hex::decode("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").unwrap();
3346 assert_eq!(encoded_value, target_value);
3350 fn encoding_update_fulfill_htlc() {
3351 let update_fulfill_htlc = msgs::UpdateFulfillHTLC {
3352 channel_id: [2; 32],
3353 htlc_id: 2316138423780173,
3354 payment_preimage: PaymentPreimage([1; 32]),
3356 let encoded_value = update_fulfill_htlc.encode();
3357 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d0101010101010101010101010101010101010101010101010101010101010101").unwrap();
3358 assert_eq!(encoded_value, target_value);
3362 fn encoding_update_fail_htlc() {
3363 let reason = OnionErrorPacket {
3364 data: [1; 32].to_vec(),
3366 let update_fail_htlc = msgs::UpdateFailHTLC {
3367 channel_id: [2; 32],
3368 htlc_id: 2316138423780173,
3371 let encoded_value = update_fail_htlc.encode();
3372 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d00200101010101010101010101010101010101010101010101010101010101010101").unwrap();
3373 assert_eq!(encoded_value, target_value);
3377 fn encoding_update_fail_malformed_htlc() {
3378 let update_fail_malformed_htlc = msgs::UpdateFailMalformedHTLC {
3379 channel_id: [2; 32],
3380 htlc_id: 2316138423780173,
3381 sha256_of_onion: [1; 32],
3384 let encoded_value = update_fail_malformed_htlc.encode();
3385 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d010101010101010101010101010101010101010101010101010101010101010100ff").unwrap();
3386 assert_eq!(encoded_value, target_value);
3389 fn do_encoding_commitment_signed(htlcs: bool) {
3390 let secp_ctx = Secp256k1::new();
3391 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3392 let (privkey_2, _) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3393 let (privkey_3, _) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3394 let (privkey_4, _) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3395 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3396 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
3397 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
3398 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
3399 let commitment_signed = msgs::CommitmentSigned {
3400 channel_id: [2; 32],
3402 htlc_signatures: if htlcs { vec![sig_2, sig_3, sig_4] } else { Vec::new() },
3404 partial_signature_with_nonce: None,
3406 let encoded_value = commitment_signed.encode();
3407 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3409 target_value.append(&mut hex::decode("00031735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
3411 target_value.append(&mut hex::decode("0000").unwrap());
3413 assert_eq!(encoded_value, target_value);
3417 fn encoding_commitment_signed() {
3418 do_encoding_commitment_signed(true);
3419 do_encoding_commitment_signed(false);
3423 fn encoding_revoke_and_ack() {
3424 let secp_ctx = Secp256k1::new();
3425 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3426 let raa = msgs::RevokeAndACK {
3427 channel_id: [2; 32],
3428 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],
3429 next_per_commitment_point: pubkey_1,
3431 next_local_nonce: None,
3433 let encoded_value = raa.encode();
3434 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020101010101010101010101010101010101010101010101010101010101010101031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3435 assert_eq!(encoded_value, target_value);
3439 fn encoding_update_fee() {
3440 let update_fee = msgs::UpdateFee {
3441 channel_id: [2; 32],
3442 feerate_per_kw: 20190119,
3444 let encoded_value = update_fee.encode();
3445 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202013413a7").unwrap();
3446 assert_eq!(encoded_value, target_value);
3450 fn encoding_init() {
3451 let mainnet_hash = ChainHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap();
3452 assert_eq!(msgs::Init {
3453 features: InitFeatures::from_le_bytes(vec![0xFF, 0xFF, 0xFF]),
3454 networks: Some(vec![mainnet_hash]),
3455 remote_network_address: None,
3456 }.encode(), hex::decode("00023fff0003ffffff01206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3457 assert_eq!(msgs::Init {
3458 features: InitFeatures::from_le_bytes(vec![0xFF]),
3460 remote_network_address: None,
3461 }.encode(), hex::decode("0001ff0001ff").unwrap());
3462 assert_eq!(msgs::Init {
3463 features: InitFeatures::from_le_bytes(vec![]),
3464 networks: Some(vec![mainnet_hash]),
3465 remote_network_address: None,
3466 }.encode(), hex::decode("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3467 assert_eq!(msgs::Init {
3468 features: InitFeatures::from_le_bytes(vec![]),
3469 networks: Some(vec![ChainHash::from(&[1; 32][..]), ChainHash::from(&[2; 32][..])]),
3470 remote_network_address: None,
3471 }.encode(), hex::decode("00000000014001010101010101010101010101010101010101010101010101010101010101010202020202020202020202020202020202020202020202020202020202020202").unwrap());
3472 let init_msg = msgs::Init { features: InitFeatures::from_le_bytes(vec![]),
3473 networks: Some(vec![mainnet_hash]),
3474 remote_network_address: Some(msgs::NetAddress::IPv4 {
3475 addr: [127, 0, 0, 1],
3479 let encoded_value = init_msg.encode();
3480 let target_value = hex::decode("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d61900000000000307017f00000103e8").unwrap();
3481 assert_eq!(encoded_value, target_value);
3482 assert_eq!(msgs::Init::read(&mut Cursor::new(&target_value)).unwrap(), init_msg);
3486 fn encoding_error() {
3487 let error = msgs::ErrorMessage {
3488 channel_id: [2; 32],
3489 data: String::from("rust-lightning"),
3491 let encoded_value = error.encode();
3492 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3493 assert_eq!(encoded_value, target_value);
3497 fn encoding_warning() {
3498 let error = msgs::WarningMessage {
3499 channel_id: [2; 32],
3500 data: String::from("rust-lightning"),
3502 let encoded_value = error.encode();
3503 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3504 assert_eq!(encoded_value, target_value);
3508 fn encoding_ping() {
3509 let ping = msgs::Ping {
3513 let encoded_value = ping.encode();
3514 let target_value = hex::decode("0040004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3515 assert_eq!(encoded_value, target_value);
3519 fn encoding_pong() {
3520 let pong = msgs::Pong {
3523 let encoded_value = pong.encode();
3524 let target_value = hex::decode("004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3525 assert_eq!(encoded_value, target_value);
3529 fn encoding_nonfinal_onion_hop_data() {
3530 let mut msg = msgs::OnionHopData {
3531 format: OnionHopDataFormat::NonFinalNode {
3532 short_channel_id: 0xdeadbeef1bad1dea,
3534 amt_to_forward: 0x0badf00d01020304,
3535 outgoing_cltv_value: 0xffffffff,
3537 let encoded_value = msg.encode();
3538 let target_value = hex::decode("1a02080badf00d010203040404ffffffff0608deadbeef1bad1dea").unwrap();
3539 assert_eq!(encoded_value, target_value);
3540 msg = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3541 if let OnionHopDataFormat::NonFinalNode { short_channel_id } = msg.format {
3542 assert_eq!(short_channel_id, 0xdeadbeef1bad1dea);
3543 } else { panic!(); }
3544 assert_eq!(msg.amt_to_forward, 0x0badf00d01020304);
3545 assert_eq!(msg.outgoing_cltv_value, 0xffffffff);
3549 fn encoding_final_onion_hop_data() {
3550 let mut msg = msgs::OnionHopData {
3551 format: OnionHopDataFormat::FinalNode {
3553 payment_metadata: None,
3554 keysend_preimage: None,
3556 amt_to_forward: 0x0badf00d01020304,
3557 outgoing_cltv_value: 0xffffffff,
3559 let encoded_value = msg.encode();
3560 let target_value = hex::decode("1002080badf00d010203040404ffffffff").unwrap();
3561 assert_eq!(encoded_value, target_value);
3562 msg = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3563 if let OnionHopDataFormat::FinalNode { payment_data: None, .. } = msg.format { } else { panic!(); }
3564 assert_eq!(msg.amt_to_forward, 0x0badf00d01020304);
3565 assert_eq!(msg.outgoing_cltv_value, 0xffffffff);
3569 fn encoding_final_onion_hop_data_with_secret() {
3570 let expected_payment_secret = PaymentSecret([0x42u8; 32]);
3571 let mut msg = msgs::OnionHopData {
3572 format: OnionHopDataFormat::FinalNode {
3573 payment_data: Some(FinalOnionHopData {
3574 payment_secret: expected_payment_secret,
3575 total_msat: 0x1badca1f
3577 payment_metadata: None,
3578 keysend_preimage: None,
3580 amt_to_forward: 0x0badf00d01020304,
3581 outgoing_cltv_value: 0xffffffff,
3583 let encoded_value = msg.encode();
3584 let target_value = hex::decode("3602080badf00d010203040404ffffffff082442424242424242424242424242424242424242424242424242424242424242421badca1f").unwrap();
3585 assert_eq!(encoded_value, target_value);
3586 msg = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3587 if let OnionHopDataFormat::FinalNode {
3588 payment_data: Some(FinalOnionHopData {
3590 total_msat: 0x1badca1f
3592 payment_metadata: None,
3593 keysend_preimage: None,
3595 assert_eq!(payment_secret, expected_payment_secret);
3596 } else { panic!(); }
3597 assert_eq!(msg.amt_to_forward, 0x0badf00d01020304);
3598 assert_eq!(msg.outgoing_cltv_value, 0xffffffff);
3602 fn query_channel_range_end_blocknum() {
3603 let tests: Vec<(u32, u32, u32)> = vec![
3604 (10000, 1500, 11500),
3605 (0, 0xffffffff, 0xffffffff),
3606 (1, 0xffffffff, 0xffffffff),
3609 for (first_blocknum, number_of_blocks, expected) in tests.into_iter() {
3610 let sut = msgs::QueryChannelRange {
3611 chain_hash: BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap(),
3615 assert_eq!(sut.end_blocknum(), expected);
3620 fn encoding_query_channel_range() {
3621 let mut query_channel_range = msgs::QueryChannelRange {
3622 chain_hash: BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap(),
3623 first_blocknum: 100000,
3624 number_of_blocks: 1500,
3626 let encoded_value = query_channel_range.encode();
3627 let target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206000186a0000005dc").unwrap();
3628 assert_eq!(encoded_value, target_value);
3630 query_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3631 assert_eq!(query_channel_range.first_blocknum, 100000);
3632 assert_eq!(query_channel_range.number_of_blocks, 1500);
3636 fn encoding_reply_channel_range() {
3637 do_encoding_reply_channel_range(0);
3638 do_encoding_reply_channel_range(1);
3641 fn do_encoding_reply_channel_range(encoding_type: u8) {
3642 let mut target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206000b8a06000005dc01").unwrap();
3643 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3644 let mut reply_channel_range = msgs::ReplyChannelRange {
3645 chain_hash: expected_chain_hash,
3646 first_blocknum: 756230,
3647 number_of_blocks: 1500,
3648 sync_complete: true,
3649 short_channel_ids: vec![0x000000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
3652 if encoding_type == 0 {
3653 target_value.append(&mut hex::decode("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
3654 let encoded_value = reply_channel_range.encode();
3655 assert_eq!(encoded_value, target_value);
3657 reply_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3658 assert_eq!(reply_channel_range.chain_hash, expected_chain_hash);
3659 assert_eq!(reply_channel_range.first_blocknum, 756230);
3660 assert_eq!(reply_channel_range.number_of_blocks, 1500);
3661 assert_eq!(reply_channel_range.sync_complete, true);
3662 assert_eq!(reply_channel_range.short_channel_ids[0], 0x000000000000008e);
3663 assert_eq!(reply_channel_range.short_channel_ids[1], 0x0000000000003c69);
3664 assert_eq!(reply_channel_range.short_channel_ids[2], 0x000000000045a6c4);
3666 target_value.append(&mut hex::decode("001601789c636000833e08659309a65878be010010a9023a").unwrap());
3667 let result: Result<msgs::ReplyChannelRange, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
3668 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
3673 fn encoding_query_short_channel_ids() {
3674 do_encoding_query_short_channel_ids(0);
3675 do_encoding_query_short_channel_ids(1);
3678 fn do_encoding_query_short_channel_ids(encoding_type: u8) {
3679 let mut target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206").unwrap();
3680 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3681 let mut query_short_channel_ids = msgs::QueryShortChannelIds {
3682 chain_hash: expected_chain_hash,
3683 short_channel_ids: vec![0x0000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
3686 if encoding_type == 0 {
3687 target_value.append(&mut hex::decode("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
3688 let encoded_value = query_short_channel_ids.encode();
3689 assert_eq!(encoded_value, target_value);
3691 query_short_channel_ids = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3692 assert_eq!(query_short_channel_ids.chain_hash, expected_chain_hash);
3693 assert_eq!(query_short_channel_ids.short_channel_ids[0], 0x000000000000008e);
3694 assert_eq!(query_short_channel_ids.short_channel_ids[1], 0x0000000000003c69);
3695 assert_eq!(query_short_channel_ids.short_channel_ids[2], 0x000000000045a6c4);
3697 target_value.append(&mut hex::decode("001601789c636000833e08659309a65878be010010a9023a").unwrap());
3698 let result: Result<msgs::QueryShortChannelIds, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
3699 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
3704 fn encoding_reply_short_channel_ids_end() {
3705 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3706 let mut reply_short_channel_ids_end = msgs::ReplyShortChannelIdsEnd {
3707 chain_hash: expected_chain_hash,
3708 full_information: true,
3710 let encoded_value = reply_short_channel_ids_end.encode();
3711 let target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e220601").unwrap();
3712 assert_eq!(encoded_value, target_value);
3714 reply_short_channel_ids_end = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3715 assert_eq!(reply_short_channel_ids_end.chain_hash, expected_chain_hash);
3716 assert_eq!(reply_short_channel_ids_end.full_information, true);
3720 fn encoding_gossip_timestamp_filter(){
3721 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3722 let mut gossip_timestamp_filter = msgs::GossipTimestampFilter {
3723 chain_hash: expected_chain_hash,
3724 first_timestamp: 1590000000,
3725 timestamp_range: 0xffff_ffff,
3727 let encoded_value = gossip_timestamp_filter.encode();
3728 let target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e22065ec57980ffffffff").unwrap();
3729 assert_eq!(encoded_value, target_value);
3731 gossip_timestamp_filter = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3732 assert_eq!(gossip_timestamp_filter.chain_hash, expected_chain_hash);
3733 assert_eq!(gossip_timestamp_filter.first_timestamp, 1590000000);
3734 assert_eq!(gossip_timestamp_filter.timestamp_range, 0xffff_ffff);
3738 fn decode_onion_hop_data_len_as_bigsize() {
3739 // Tests that we can decode an onion payload that is >253 bytes.
3740 // Previously, receiving a payload of this size could've caused us to fail to decode a valid
3741 // payload, because we were decoding the length (a BigSize, big-endian) as a VarInt
3744 // Encode a test onion payload with a big custom TLV such that it's >253 bytes, forcing the
3745 // payload length to be encoded over multiple bytes rather than a single u8.
3746 let big_payload = encode_big_payload().unwrap();
3747 let mut rd = Cursor::new(&big_payload[..]);
3748 <msgs::OnionHopData as Readable>::read(&mut rd).unwrap();
3750 // see above test, needs to be a separate method for use of the serialization macros.
3751 fn encode_big_payload() -> Result<Vec<u8>, io::Error> {
3752 use crate::util::ser::HighZeroBytesDroppedBigSize;
3753 let payload = msgs::OnionHopData {
3754 format: OnionHopDataFormat::NonFinalNode {
3755 short_channel_id: 0xdeadbeef1bad1dea,
3757 amt_to_forward: 1000,
3758 outgoing_cltv_value: 0xffffffff,
3760 let mut encoded_payload = Vec::new();
3761 let test_bytes = vec![42u8; 1000];
3762 if let OnionHopDataFormat::NonFinalNode { short_channel_id } = payload.format {
3763 _encode_varint_length_prefixed_tlv!(&mut encoded_payload, {
3764 (1, test_bytes, required_vec),
3765 (2, HighZeroBytesDroppedBigSize(payload.amt_to_forward), required),
3766 (4, HighZeroBytesDroppedBigSize(payload.outgoing_cltv_value), required),
3767 (6, short_channel_id, required)