1 // This file is Copyright its original authors, visible in version control
4 // This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
5 // or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
6 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
7 // You may not use this file except in accordance with one or both of these
10 //! Wire messages, traits representing wire message handlers, and a few error types live here.
12 //! For a normal node you probably don't need to use anything here, however, if you wish to split a
13 //! node into an internet-facing route/message socket handling daemon and a separate daemon (or
14 //! server entirely) which handles only channel-related messages you may wish to implement
15 //! [`ChannelMessageHandler`] yourself and use it to re-serialize messages and pass them across
18 //! Note that if you go with such an architecture (instead of passing raw socket events to a
19 //! non-internet-facing system) you trust the frontend internet-facing system to not lie about the
20 //! source `node_id` of the message, however this does allow you to significantly reduce bandwidth
21 //! between the systems as routing messages can represent a significant chunk of bandwidth usage
22 //! (especially for non-channel-publicly-announcing nodes). As an alternate design which avoids
23 //! this issue, if you have sufficient bidirectional bandwidth between your systems, you may send
24 //! raw socket events into your non-internet-facing system and then send routing events back to
25 //! track the network on the less-secure system.
27 use bitcoin::blockdata::constants::ChainHash;
28 use bitcoin::secp256k1::PublicKey;
29 use bitcoin::secp256k1::ecdsa::Signature;
30 use bitcoin::{secp256k1, Witness};
31 use bitcoin::blockdata::script::Script;
32 use bitcoin::hash_types::{Txid, BlockHash};
34 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
35 use crate::ln::onion_utils;
36 use crate::onion_message;
38 use crate::prelude::*;
41 use crate::io::{self, Read};
42 use crate::io_extras::read_to_end;
44 use crate::events::{MessageSendEventsProvider, OnionMessageProvider};
45 use crate::util::logger;
46 use crate::util::ser::{LengthReadable, Readable, ReadableArgs, Writeable, Writer, WithoutLength, FixedLengthReader, HighZeroBytesDroppedBigSize, Hostname, TransactionU16LenLimited};
48 use crate::ln::{PaymentPreimage, PaymentHash, PaymentSecret};
50 use crate::routing::gossip::{NodeAlias, NodeId};
52 /// 21 million * 10^8 * 1000
53 pub(crate) const MAX_VALUE_MSAT: u64 = 21_000_000_0000_0000_000;
56 /// A partial signature that also contains the Musig2 nonce its signer used
57 #[derive(Clone, Debug, PartialEq, Eq)]
58 pub struct PartialSignatureWithNonce(pub musig2::types::PartialSignature, pub musig2::types::PublicNonce);
60 /// An error in decoding a message or struct.
61 #[derive(Clone, Debug, PartialEq, Eq)]
62 pub enum DecodeError {
63 /// A version byte specified something we don't know how to handle.
65 /// Includes unknown realm byte in an onion hop data packet.
67 /// Unknown feature mandating we fail to parse message (e.g., TLV with an even, unknown type)
68 UnknownRequiredFeature,
69 /// Value was invalid.
71 /// For example, a byte which was supposed to be a bool was something other than a 0
72 /// or 1, a public key/private key/signature was invalid, text wasn't UTF-8, TLV was
73 /// syntactically incorrect, etc.
75 /// The buffer to be read was too short.
77 /// A length descriptor in the packet didn't describe the later data correctly.
79 /// Error from [`std::io`].
81 /// The message included zlib-compressed values, which we don't support.
82 UnsupportedCompression,
85 /// An [`init`] message to be sent to or received from a peer.
87 /// [`init`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-init-message
88 #[derive(Clone, Debug, PartialEq, Eq)]
90 /// The relevant features which the sender supports.
91 pub features: InitFeatures,
92 /// Indicates chains the sender is interested in.
94 /// If there are no common chains, the connection will be closed.
95 pub networks: Option<Vec<ChainHash>>,
96 /// The receipient's network address.
98 /// This adds the option to report a remote IP address back to a connecting peer using the init
99 /// message. A node can decide to use that information to discover a potential update to its
100 /// public IPv4 address (NAT) and use that for a [`NodeAnnouncement`] update message containing
102 pub remote_network_address: Option<NetAddress>,
105 /// An [`error`] message to be sent to or received from a peer.
107 /// [`error`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-error-and-warning-messages
108 #[derive(Clone, Debug, PartialEq, Eq)]
109 pub struct ErrorMessage {
110 /// The channel ID involved in the error.
112 /// All-0s indicates a general error unrelated to a specific channel, after which all channels
113 /// with the sending peer should be closed.
114 pub channel_id: [u8; 32],
115 /// A possibly human-readable error description.
117 /// The string should be sanitized before it is used (e.g., emitted to logs or printed to
118 /// `stdout`). Otherwise, a well crafted error message may trigger a security vulnerability in
119 /// the terminal emulator or the logging subsystem.
123 /// A [`warning`] message to be sent to or received from a peer.
125 /// [`warning`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-error-and-warning-messages
126 #[derive(Clone, Debug, PartialEq, Eq)]
127 pub struct WarningMessage {
128 /// The channel ID involved in the warning.
130 /// All-0s indicates a warning unrelated to a specific channel.
131 pub channel_id: [u8; 32],
132 /// A possibly human-readable warning description.
134 /// The string should be sanitized before it is used (e.g. emitted to logs or printed to
135 /// stdout). Otherwise, a well crafted error message may trigger a security vulnerability in
136 /// the terminal emulator or the logging subsystem.
140 /// A [`ping`] message to be sent to or received from a peer.
142 /// [`ping`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-ping-and-pong-messages
143 #[derive(Clone, Debug, PartialEq, Eq)]
145 /// The desired response length.
147 /// The ping packet size.
149 /// This field is not sent on the wire. byteslen zeros are sent.
153 /// A [`pong`] message to be sent to or received from a peer.
155 /// [`pong`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-ping-and-pong-messages
156 #[derive(Clone, Debug, PartialEq, Eq)]
158 /// The pong packet size.
160 /// This field is not sent on the wire. byteslen zeros are sent.
164 /// An [`open_channel`] message to be sent to or received from a peer.
166 /// Used in V1 channel establishment
168 /// [`open_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-open_channel-message
169 #[derive(Clone, Debug, PartialEq, Eq)]
170 pub struct OpenChannel {
171 /// The genesis hash of the blockchain where the channel is to be opened
172 pub chain_hash: BlockHash,
173 /// A temporary channel ID, until the funding outpoint is announced
174 pub temporary_channel_id: [u8; 32],
175 /// The channel value
176 pub funding_satoshis: u64,
177 /// The amount to push to the counterparty as part of the open, in milli-satoshi
179 /// The threshold below which outputs on transactions broadcast by sender will be omitted
180 pub dust_limit_satoshis: u64,
181 /// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
182 pub max_htlc_value_in_flight_msat: u64,
183 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
184 pub channel_reserve_satoshis: u64,
185 /// The minimum HTLC size incoming to sender, in milli-satoshi
186 pub htlc_minimum_msat: u64,
187 /// The feerate per 1000-weight of sender generated transactions, until updated by
189 pub feerate_per_kw: u32,
190 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if
191 /// they broadcast a commitment transaction
192 pub to_self_delay: u16,
193 /// The maximum number of inbound HTLCs towards sender
194 pub max_accepted_htlcs: u16,
195 /// The sender's key controlling the funding transaction
196 pub funding_pubkey: PublicKey,
197 /// Used to derive a revocation key for transactions broadcast by counterparty
198 pub revocation_basepoint: PublicKey,
199 /// A payment key to sender for transactions broadcast by counterparty
200 pub payment_point: PublicKey,
201 /// Used to derive a payment key to sender for transactions broadcast by sender
202 pub delayed_payment_basepoint: PublicKey,
203 /// Used to derive an HTLC payment key to sender
204 pub htlc_basepoint: PublicKey,
205 /// The first to-be-broadcast-by-sender transaction's per commitment point
206 pub first_per_commitment_point: PublicKey,
207 /// The channel flags to be used
208 pub channel_flags: u8,
209 /// A request to pre-set the to-sender output's `scriptPubkey` for when we collaboratively close
210 pub shutdown_scriptpubkey: Option<Script>,
211 /// The channel type that this channel will represent
213 /// If this is `None`, we derive the channel type from the intersection of our
214 /// feature bits with our counterparty's feature bits from the [`Init`] message.
215 pub channel_type: Option<ChannelTypeFeatures>,
218 /// An open_channel2 message to be sent by or received from the channel initiator.
220 /// Used in V2 channel establishment
222 // TODO(dual_funding): Add spec link for `open_channel2`.
223 #[derive(Clone, Debug, PartialEq, Eq)]
224 pub struct OpenChannelV2 {
225 /// The genesis hash of the blockchain where the channel is to be opened
226 pub chain_hash: BlockHash,
227 /// A temporary channel ID derived using a zeroed out value for the channel acceptor's revocation basepoint
228 pub temporary_channel_id: [u8; 32],
229 /// The feerate for the funding transaction set by the channel initiator
230 pub funding_feerate_sat_per_1000_weight: u32,
231 /// The feerate for the commitment transaction set by the channel initiator
232 pub commitment_feerate_sat_per_1000_weight: u32,
233 /// Part of the channel value contributed by the channel initiator
234 pub funding_satoshis: u64,
235 /// The threshold below which outputs on transactions broadcast by the channel initiator will be
237 pub dust_limit_satoshis: u64,
238 /// The maximum inbound HTLC value in flight towards channel initiator, in milli-satoshi
239 pub max_htlc_value_in_flight_msat: u64,
240 /// The minimum HTLC size incoming to channel initiator, in milli-satoshi
241 pub htlc_minimum_msat: u64,
242 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
243 /// broadcast a commitment transaction
244 pub to_self_delay: u16,
245 /// The maximum number of inbound HTLCs towards channel initiator
246 pub max_accepted_htlcs: u16,
247 /// The locktime for the funding transaction
249 /// The channel initiator's key controlling the funding transaction
250 pub funding_pubkey: PublicKey,
251 /// Used to derive a revocation key for transactions broadcast by counterparty
252 pub revocation_basepoint: PublicKey,
253 /// A payment key to channel initiator for transactions broadcast by counterparty
254 pub payment_basepoint: PublicKey,
255 /// Used to derive a payment key to channel initiator for transactions broadcast by channel
257 pub delayed_payment_basepoint: PublicKey,
258 /// Used to derive an HTLC payment key to channel initiator
259 pub htlc_basepoint: PublicKey,
260 /// The first to-be-broadcast-by-channel-initiator transaction's per commitment point
261 pub first_per_commitment_point: PublicKey,
262 /// The second to-be-broadcast-by-channel-initiator transaction's per commitment point
263 pub second_per_commitment_point: PublicKey,
265 pub channel_flags: u8,
266 /// Optionally, a request to pre-set the to-channel-initiator output's scriptPubkey for when we
267 /// collaboratively close
268 pub shutdown_scriptpubkey: Option<Script>,
269 /// The channel type that this channel will represent. If none is set, we derive the channel
270 /// type from the intersection of our feature bits with our counterparty's feature bits from
271 /// the Init message.
272 pub channel_type: Option<ChannelTypeFeatures>,
273 /// Optionally, a requirement that only confirmed inputs can be added
274 pub require_confirmed_inputs: Option<()>,
277 /// An [`accept_channel`] message to be sent to or received from a peer.
279 /// Used in V1 channel establishment
281 /// [`accept_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-accept_channel-message
282 #[derive(Clone, Debug, PartialEq, Eq)]
283 pub struct AcceptChannel {
284 /// A temporary channel ID, until the funding outpoint is announced
285 pub temporary_channel_id: [u8; 32],
286 /// The threshold below which outputs on transactions broadcast by sender will be omitted
287 pub dust_limit_satoshis: u64,
288 /// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
289 pub max_htlc_value_in_flight_msat: u64,
290 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
291 pub channel_reserve_satoshis: u64,
292 /// The minimum HTLC size incoming to sender, in milli-satoshi
293 pub htlc_minimum_msat: u64,
294 /// Minimum depth of the funding transaction before the channel is considered open
295 pub minimum_depth: u32,
296 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they broadcast a commitment transaction
297 pub to_self_delay: u16,
298 /// The maximum number of inbound HTLCs towards sender
299 pub max_accepted_htlcs: u16,
300 /// The sender's key controlling the funding transaction
301 pub funding_pubkey: PublicKey,
302 /// Used to derive a revocation key for transactions broadcast by counterparty
303 pub revocation_basepoint: PublicKey,
304 /// A payment key to sender for transactions broadcast by counterparty
305 pub payment_point: PublicKey,
306 /// Used to derive a payment key to sender for transactions broadcast by sender
307 pub delayed_payment_basepoint: PublicKey,
308 /// Used to derive an HTLC payment key to sender for transactions broadcast by counterparty
309 pub htlc_basepoint: PublicKey,
310 /// The first to-be-broadcast-by-sender transaction's per commitment point
311 pub first_per_commitment_point: PublicKey,
312 /// A request to pre-set the to-sender output's scriptPubkey for when we collaboratively close
313 pub shutdown_scriptpubkey: Option<Script>,
314 /// The channel type that this channel will represent.
316 /// If this is `None`, we derive the channel type from the intersection of
317 /// our feature bits with our counterparty's feature bits from the [`Init`] message.
318 /// This is required to match the equivalent field in [`OpenChannel::channel_type`].
319 pub channel_type: Option<ChannelTypeFeatures>,
321 /// Next nonce the channel initiator should use to create a funding output signature against
322 pub next_local_nonce: Option<musig2::types::PublicNonce>,
325 /// An accept_channel2 message to be sent by or received from the channel accepter.
327 /// Used in V2 channel establishment
329 // TODO(dual_funding): Add spec link for `accept_channel2`.
330 #[derive(Clone, Debug, PartialEq, Eq)]
331 pub struct AcceptChannelV2 {
332 /// The same `temporary_channel_id` received from the initiator's `open_channel2` message.
333 pub temporary_channel_id: [u8; 32],
334 /// Part of the channel value contributed by the channel acceptor
335 pub funding_satoshis: u64,
336 /// The threshold below which outputs on transactions broadcast by the channel acceptor will be
338 pub dust_limit_satoshis: u64,
339 /// The maximum inbound HTLC value in flight towards channel acceptor, in milli-satoshi
340 pub max_htlc_value_in_flight_msat: u64,
341 /// The minimum HTLC size incoming to channel acceptor, in milli-satoshi
342 pub htlc_minimum_msat: u64,
343 /// Minimum depth of the funding transaction before the channel is considered open
344 pub minimum_depth: u32,
345 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
346 /// broadcast a commitment transaction
347 pub to_self_delay: u16,
348 /// The maximum number of inbound HTLCs towards channel acceptor
349 pub max_accepted_htlcs: u16,
350 /// The channel acceptor's key controlling the funding transaction
351 pub funding_pubkey: PublicKey,
352 /// Used to derive a revocation key for transactions broadcast by counterparty
353 pub revocation_basepoint: PublicKey,
354 /// A payment key to channel acceptor for transactions broadcast by counterparty
355 pub payment_basepoint: PublicKey,
356 /// Used to derive a payment key to channel acceptor for transactions broadcast by channel
358 pub delayed_payment_basepoint: PublicKey,
359 /// Used to derive an HTLC payment key to channel acceptor for transactions broadcast by counterparty
360 pub htlc_basepoint: PublicKey,
361 /// The first to-be-broadcast-by-channel-acceptor transaction's per commitment point
362 pub first_per_commitment_point: PublicKey,
363 /// The second to-be-broadcast-by-channel-acceptor transaction's per commitment point
364 pub second_per_commitment_point: PublicKey,
365 /// Optionally, a request to pre-set the to-channel-acceptor output's scriptPubkey for when we
366 /// collaboratively close
367 pub shutdown_scriptpubkey: Option<Script>,
368 /// The channel type that this channel will represent. If none is set, we derive the channel
369 /// type from the intersection of our feature bits with our counterparty's feature bits from
370 /// the Init message.
372 /// This is required to match the equivalent field in [`OpenChannelV2::channel_type`].
373 pub channel_type: Option<ChannelTypeFeatures>,
374 /// Optionally, a requirement that only confirmed inputs can be added
375 pub require_confirmed_inputs: Option<()>,
378 /// A [`funding_created`] message to be sent to or received from a peer.
380 /// Used in V1 channel establishment
382 /// [`funding_created`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-funding_created-message
383 #[derive(Clone, Debug, PartialEq, Eq)]
384 pub struct FundingCreated {
385 /// A temporary channel ID, until the funding is established
386 pub temporary_channel_id: [u8; 32],
387 /// The funding transaction ID
388 pub funding_txid: Txid,
389 /// The specific output index funding this channel
390 pub funding_output_index: u16,
391 /// The signature of the channel initiator (funder) on the initial commitment transaction
392 pub signature: Signature,
394 /// The partial signature of the channel initiator (funder)
395 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
397 /// Next nonce the channel acceptor should use to finalize the funding output signature
398 pub next_local_nonce: Option<musig2::types::PublicNonce>
401 /// A [`funding_signed`] message to be sent to or received from a peer.
403 /// Used in V1 channel establishment
405 /// [`funding_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-funding_signed-message
406 #[derive(Clone, Debug, PartialEq, Eq)]
407 pub struct FundingSigned {
409 pub channel_id: [u8; 32],
410 /// The signature of the channel acceptor (fundee) on the initial commitment transaction
411 pub signature: Signature,
413 /// The partial signature of the channel acceptor (fundee)
414 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
417 /// A [`channel_ready`] message to be sent to or received from a peer.
419 /// [`channel_ready`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-channel_ready-message
420 #[derive(Clone, Debug, PartialEq, Eq)]
421 pub struct ChannelReady {
423 pub channel_id: [u8; 32],
424 /// The per-commitment point of the second commitment transaction
425 pub next_per_commitment_point: PublicKey,
426 /// If set, provides a `short_channel_id` alias for this channel.
428 /// The sender will accept payments to be forwarded over this SCID and forward them to this
429 /// messages' recipient.
430 pub short_channel_id_alias: Option<u64>,
433 /// A tx_add_input message for adding an input during interactive transaction construction
435 // TODO(dual_funding): Add spec link for `tx_add_input`.
436 #[derive(Clone, Debug, PartialEq, Eq)]
437 pub struct TxAddInput {
439 pub channel_id: [u8; 32],
440 /// A randomly chosen unique identifier for this input, which is even for initiators and odd for
443 /// Serialized transaction that contains the output this input spends to verify that it is non
445 pub prevtx: TransactionU16LenLimited,
446 /// The index of the output being spent
448 /// The sequence number of this input
452 /// A tx_add_output message for adding an output during interactive transaction construction.
454 // TODO(dual_funding): Add spec link for `tx_add_output`.
455 #[derive(Clone, Debug, PartialEq, Eq)]
456 pub struct TxAddOutput {
458 pub channel_id: [u8; 32],
459 /// A randomly chosen unique identifier for this output, which is even for initiators and odd for
462 /// The satoshi value of the output
464 /// The scriptPubKey for the output
468 /// A tx_remove_input message for removing an input during interactive transaction construction.
470 // TODO(dual_funding): Add spec link for `tx_remove_input`.
471 #[derive(Clone, Debug, PartialEq, Eq)]
472 pub struct TxRemoveInput {
474 pub channel_id: [u8; 32],
475 /// The serial ID of the input to be removed
479 /// A tx_remove_output message for removing an output during interactive transaction construction.
481 // TODO(dual_funding): Add spec link for `tx_remove_output`.
482 #[derive(Clone, Debug, PartialEq, Eq)]
483 pub struct TxRemoveOutput {
485 pub channel_id: [u8; 32],
486 /// The serial ID of the output to be removed
490 /// A tx_complete message signalling the conclusion of a peer's transaction contributions during
491 /// interactive transaction construction.
493 // TODO(dual_funding): Add spec link for `tx_complete`.
494 #[derive(Clone, Debug, PartialEq, Eq)]
495 pub struct TxComplete {
497 pub channel_id: [u8; 32],
500 /// A tx_signatures message containing the sender's signatures for a transaction constructed with
501 /// interactive transaction construction.
503 // TODO(dual_funding): Add spec link for `tx_signatures`.
504 #[derive(Clone, Debug, PartialEq, Eq)]
505 pub struct TxSignatures {
507 pub channel_id: [u8; 32],
510 /// The list of witnesses
511 pub witnesses: Vec<Witness>,
514 /// A tx_init_rbf message which initiates a replacement of the transaction after it's been
517 // TODO(dual_funding): Add spec link for `tx_init_rbf`.
518 #[derive(Clone, Debug, PartialEq, Eq)]
519 pub struct TxInitRbf {
521 pub channel_id: [u8; 32],
522 /// The locktime of the transaction
524 /// The feerate of the transaction
525 pub feerate_sat_per_1000_weight: u32,
526 /// The number of satoshis the sender will contribute to or, if negative, remove from
527 /// (e.g. splice-out) the funding output of the transaction
528 pub funding_output_contribution: Option<i64>,
531 /// A tx_ack_rbf message which acknowledges replacement of the transaction after it's been
534 // TODO(dual_funding): Add spec link for `tx_ack_rbf`.
535 #[derive(Clone, Debug, PartialEq, Eq)]
536 pub struct TxAckRbf {
538 pub channel_id: [u8; 32],
539 /// The number of satoshis the sender will contribute to or, if negative, remove from
540 /// (e.g. splice-out) the funding output of the transaction
541 pub funding_output_contribution: Option<i64>,
544 /// A tx_abort message which signals the cancellation of an in-progress transaction negotiation.
546 // TODO(dual_funding): Add spec link for `tx_abort`.
547 #[derive(Clone, Debug, PartialEq, Eq)]
550 pub channel_id: [u8; 32],
555 /// A [`shutdown`] message to be sent to or received from a peer.
557 /// [`shutdown`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-initiation-shutdown
558 #[derive(Clone, Debug, PartialEq, Eq)]
559 pub struct Shutdown {
561 pub channel_id: [u8; 32],
562 /// The destination of this peer's funds on closing.
564 /// Must be in one of these forms: P2PKH, P2SH, P2WPKH, P2WSH, P2TR.
565 pub scriptpubkey: Script,
568 /// The minimum and maximum fees which the sender is willing to place on the closing transaction.
570 /// This is provided in [`ClosingSigned`] by both sides to indicate the fee range they are willing
572 #[derive(Clone, Debug, PartialEq, Eq)]
573 pub struct ClosingSignedFeeRange {
574 /// The minimum absolute fee, in satoshis, which the sender is willing to place on the closing
576 pub min_fee_satoshis: u64,
577 /// The maximum absolute fee, in satoshis, which the sender is willing to place on the closing
579 pub max_fee_satoshis: u64,
582 /// A [`closing_signed`] message to be sent to or received from a peer.
584 /// [`closing_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-negotiation-closing_signed
585 #[derive(Clone, Debug, PartialEq, Eq)]
586 pub struct ClosingSigned {
588 pub channel_id: [u8; 32],
589 /// The proposed total fee for the closing transaction
590 pub fee_satoshis: u64,
591 /// A signature on the closing transaction
592 pub signature: Signature,
593 /// The minimum and maximum fees which the sender is willing to accept, provided only by new
595 pub fee_range: Option<ClosingSignedFeeRange>,
598 /// An [`update_add_htlc`] message to be sent to or received from a peer.
600 /// [`update_add_htlc`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#adding-an-htlc-update_add_htlc
601 #[derive(Clone, Debug, PartialEq, Eq)]
602 pub struct UpdateAddHTLC {
604 pub channel_id: [u8; 32],
607 /// The HTLC value in milli-satoshi
608 pub amount_msat: u64,
609 /// The payment hash, the pre-image of which controls HTLC redemption
610 pub payment_hash: PaymentHash,
611 /// The expiry height of the HTLC
612 pub cltv_expiry: u32,
613 /// The extra fee skimmed by the sender of this message. See
614 /// [`ChannelConfig::accept_underpaying_htlcs`].
616 /// [`ChannelConfig::accept_underpaying_htlcs`]: crate::util::config::ChannelConfig::accept_underpaying_htlcs
617 pub skimmed_fee_msat: Option<u64>,
618 pub(crate) onion_routing_packet: OnionPacket,
621 /// An onion message to be sent to or received from a peer.
623 // TODO: update with link to OM when they are merged into the BOLTs
624 #[derive(Clone, Debug, PartialEq, Eq)]
625 pub struct OnionMessage {
626 /// Used in decrypting the onion packet's payload.
627 pub blinding_point: PublicKey,
628 pub(crate) onion_routing_packet: onion_message::Packet,
631 /// An [`update_fulfill_htlc`] message to be sent to or received from a peer.
633 /// [`update_fulfill_htlc`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#removing-an-htlc-update_fulfill_htlc-update_fail_htlc-and-update_fail_malformed_htlc
634 #[derive(Clone, Debug, PartialEq, Eq)]
635 pub struct UpdateFulfillHTLC {
637 pub channel_id: [u8; 32],
640 /// The pre-image of the payment hash, allowing HTLC redemption
641 pub payment_preimage: PaymentPreimage,
644 /// An [`update_fail_htlc`] message to be sent to or received from a peer.
646 /// [`update_fail_htlc`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#removing-an-htlc-update_fulfill_htlc-update_fail_htlc-and-update_fail_malformed_htlc
647 #[derive(Clone, Debug, PartialEq, Eq)]
648 pub struct UpdateFailHTLC {
650 pub channel_id: [u8; 32],
653 pub(crate) reason: OnionErrorPacket,
656 /// An [`update_fail_malformed_htlc`] message to be sent to or received from a peer.
658 /// [`update_fail_malformed_htlc`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#removing-an-htlc-update_fulfill_htlc-update_fail_htlc-and-update_fail_malformed_htlc
659 #[derive(Clone, Debug, PartialEq, Eq)]
660 pub struct UpdateFailMalformedHTLC {
662 pub channel_id: [u8; 32],
665 pub(crate) sha256_of_onion: [u8; 32],
667 pub failure_code: u16,
670 /// A [`commitment_signed`] message to be sent to or received from a peer.
672 /// [`commitment_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#committing-updates-so-far-commitment_signed
673 #[derive(Clone, Debug, PartialEq, Eq)]
674 pub struct CommitmentSigned {
676 pub channel_id: [u8; 32],
677 /// A signature on the commitment transaction
678 pub signature: Signature,
679 /// Signatures on the HTLC transactions
680 pub htlc_signatures: Vec<Signature>,
682 /// The partial Taproot signature on the commitment transaction
683 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
686 /// A [`revoke_and_ack`] message to be sent to or received from a peer.
688 /// [`revoke_and_ack`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#completing-the-transition-to-the-updated-state-revoke_and_ack
689 #[derive(Clone, Debug, PartialEq, Eq)]
690 pub struct RevokeAndACK {
692 pub channel_id: [u8; 32],
693 /// The secret corresponding to the per-commitment point
694 pub per_commitment_secret: [u8; 32],
695 /// The next sender-broadcast commitment transaction's per-commitment point
696 pub next_per_commitment_point: PublicKey,
698 /// Musig nonce the recipient should use in their next commitment signature message
699 pub next_local_nonce: Option<musig2::types::PublicNonce>
702 /// An [`update_fee`] message to be sent to or received from a peer
704 /// [`update_fee`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#updating-fees-update_fee
705 #[derive(Clone, Debug, PartialEq, Eq)]
706 pub struct UpdateFee {
708 pub channel_id: [u8; 32],
709 /// Fee rate per 1000-weight of the transaction
710 pub feerate_per_kw: u32,
713 /// A [`channel_reestablish`] message to be sent to or received from a peer.
715 /// [`channel_reestablish`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#message-retransmission
716 #[derive(Clone, Debug, PartialEq, Eq)]
717 pub struct ChannelReestablish {
719 pub channel_id: [u8; 32],
720 /// The next commitment number for the sender
721 pub next_local_commitment_number: u64,
722 /// The next commitment number for the recipient
723 pub next_remote_commitment_number: u64,
724 /// Proof that the sender knows the per-commitment secret of a specific commitment transaction
725 /// belonging to the recipient
726 pub your_last_per_commitment_secret: [u8; 32],
727 /// The sender's per-commitment point for their current commitment transaction
728 pub my_current_per_commitment_point: PublicKey,
729 /// The next funding transaction ID
730 pub next_funding_txid: Option<Txid>,
733 /// An [`announcement_signatures`] message to be sent to or received from a peer.
735 /// [`announcement_signatures`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-announcement_signatures-message
736 #[derive(Clone, Debug, PartialEq, Eq)]
737 pub struct AnnouncementSignatures {
739 pub channel_id: [u8; 32],
740 /// The short channel ID
741 pub short_channel_id: u64,
742 /// A signature by the node key
743 pub node_signature: Signature,
744 /// A signature by the funding key
745 pub bitcoin_signature: Signature,
748 /// An address which can be used to connect to a remote peer.
749 #[derive(Clone, Debug, PartialEq, Eq)]
750 pub enum NetAddress {
751 /// An IPv4 address/port on which the peer is listening.
753 /// The 4-byte IPv4 address
755 /// The port on which the node is listening
758 /// An IPv6 address/port on which the peer is listening.
760 /// The 16-byte IPv6 address
762 /// The port on which the node is listening
765 /// An old-style Tor onion address/port on which the peer is listening.
767 /// This field is deprecated and the Tor network generally no longer supports V2 Onion
768 /// addresses. Thus, the details are not parsed here.
770 /// A new-style Tor onion address/port on which the peer is listening.
772 /// To create the human-readable "hostname", concatenate the ED25519 pubkey, checksum, and version,
773 /// wrap as base32 and append ".onion".
775 /// The ed25519 long-term public key of the peer
776 ed25519_pubkey: [u8; 32],
777 /// The checksum of the pubkey and version, as included in the onion address
779 /// The version byte, as defined by the Tor Onion v3 spec.
781 /// The port on which the node is listening
784 /// A hostname/port on which the peer is listening.
786 /// The hostname on which the node is listening.
788 /// The port on which the node is listening.
793 /// Gets the ID of this address type. Addresses in [`NodeAnnouncement`] messages should be sorted
795 pub(crate) fn get_id(&self) -> u8 {
797 &NetAddress::IPv4 {..} => { 1 },
798 &NetAddress::IPv6 {..} => { 2 },
799 &NetAddress::OnionV2(_) => { 3 },
800 &NetAddress::OnionV3 {..} => { 4 },
801 &NetAddress::Hostname {..} => { 5 },
805 /// Strict byte-length of address descriptor, 1-byte type not recorded
806 fn len(&self) -> u16 {
808 &NetAddress::IPv4 { .. } => { 6 },
809 &NetAddress::IPv6 { .. } => { 18 },
810 &NetAddress::OnionV2(_) => { 12 },
811 &NetAddress::OnionV3 { .. } => { 37 },
812 // Consists of 1-byte hostname length, hostname bytes, and 2-byte port.
813 &NetAddress::Hostname { ref hostname, .. } => { u16::from(hostname.len()) + 3 },
817 /// The maximum length of any address descriptor, not including the 1-byte type.
818 /// This maximum length is reached by a hostname address descriptor:
819 /// a hostname with a maximum length of 255, its 1-byte length and a 2-byte port.
820 pub(crate) const MAX_LEN: u16 = 258;
823 impl Writeable for NetAddress {
824 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
826 &NetAddress::IPv4 { ref addr, ref port } => {
831 &NetAddress::IPv6 { ref addr, ref port } => {
836 &NetAddress::OnionV2(bytes) => {
838 bytes.write(writer)?;
840 &NetAddress::OnionV3 { ref ed25519_pubkey, ref checksum, ref version, ref port } => {
842 ed25519_pubkey.write(writer)?;
843 checksum.write(writer)?;
844 version.write(writer)?;
847 &NetAddress::Hostname { ref hostname, ref port } => {
849 hostname.write(writer)?;
857 impl Readable for Result<NetAddress, u8> {
858 fn read<R: Read>(reader: &mut R) -> Result<Result<NetAddress, u8>, DecodeError> {
859 let byte = <u8 as Readable>::read(reader)?;
862 Ok(Ok(NetAddress::IPv4 {
863 addr: Readable::read(reader)?,
864 port: Readable::read(reader)?,
868 Ok(Ok(NetAddress::IPv6 {
869 addr: Readable::read(reader)?,
870 port: Readable::read(reader)?,
873 3 => Ok(Ok(NetAddress::OnionV2(Readable::read(reader)?))),
875 Ok(Ok(NetAddress::OnionV3 {
876 ed25519_pubkey: Readable::read(reader)?,
877 checksum: Readable::read(reader)?,
878 version: Readable::read(reader)?,
879 port: Readable::read(reader)?,
883 Ok(Ok(NetAddress::Hostname {
884 hostname: Readable::read(reader)?,
885 port: Readable::read(reader)?,
888 _ => return Ok(Err(byte)),
893 impl Readable for NetAddress {
894 fn read<R: Read>(reader: &mut R) -> Result<NetAddress, DecodeError> {
895 match Readable::read(reader) {
896 Ok(Ok(res)) => Ok(res),
897 Ok(Err(_)) => Err(DecodeError::UnknownVersion),
903 /// Represents the set of gossip messages that require a signature from a node's identity key.
904 pub enum UnsignedGossipMessage<'a> {
905 /// An unsigned channel announcement.
906 ChannelAnnouncement(&'a UnsignedChannelAnnouncement),
907 /// An unsigned channel update.
908 ChannelUpdate(&'a UnsignedChannelUpdate),
909 /// An unsigned node announcement.
910 NodeAnnouncement(&'a UnsignedNodeAnnouncement)
913 impl<'a> Writeable for UnsignedGossipMessage<'a> {
914 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
916 UnsignedGossipMessage::ChannelAnnouncement(ref msg) => msg.write(writer),
917 UnsignedGossipMessage::ChannelUpdate(ref msg) => msg.write(writer),
918 UnsignedGossipMessage::NodeAnnouncement(ref msg) => msg.write(writer),
923 /// The unsigned part of a [`node_announcement`] message.
925 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
926 #[derive(Clone, Debug, PartialEq, Eq)]
927 pub struct UnsignedNodeAnnouncement {
928 /// The advertised features
929 pub features: NodeFeatures,
930 /// A strictly monotonic announcement counter, with gaps allowed
932 /// The `node_id` this announcement originated from (don't rebroadcast the `node_announcement` back
935 /// An RGB color for UI purposes
937 /// An alias, for UI purposes.
939 /// This should be sanitized before use. There is no guarantee of uniqueness.
940 pub alias: NodeAlias,
941 /// List of addresses on which this node is reachable
942 pub addresses: Vec<NetAddress>,
943 pub(crate) excess_address_data: Vec<u8>,
944 pub(crate) excess_data: Vec<u8>,
946 #[derive(Clone, Debug, PartialEq, Eq)]
947 /// A [`node_announcement`] message to be sent to or received from a peer.
949 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
950 pub struct NodeAnnouncement {
951 /// The signature by the node key
952 pub signature: Signature,
953 /// The actual content of the announcement
954 pub contents: UnsignedNodeAnnouncement,
957 /// The unsigned part of a [`channel_announcement`] message.
959 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
960 #[derive(Clone, Debug, PartialEq, Eq)]
961 pub struct UnsignedChannelAnnouncement {
962 /// The advertised channel features
963 pub features: ChannelFeatures,
964 /// The genesis hash of the blockchain where the channel is to be opened
965 pub chain_hash: BlockHash,
966 /// The short channel ID
967 pub short_channel_id: u64,
968 /// One of the two `node_id`s which are endpoints of this channel
969 pub node_id_1: NodeId,
970 /// The other of the two `node_id`s which are endpoints of this channel
971 pub node_id_2: NodeId,
972 /// The funding key for the first node
973 pub bitcoin_key_1: NodeId,
974 /// The funding key for the second node
975 pub bitcoin_key_2: NodeId,
976 pub(crate) excess_data: Vec<u8>,
978 /// A [`channel_announcement`] message to be sent to or received from a peer.
980 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
981 #[derive(Clone, Debug, PartialEq, Eq)]
982 pub struct ChannelAnnouncement {
983 /// Authentication of the announcement by the first public node
984 pub node_signature_1: Signature,
985 /// Authentication of the announcement by the second public node
986 pub node_signature_2: Signature,
987 /// Proof of funding UTXO ownership by the first public node
988 pub bitcoin_signature_1: Signature,
989 /// Proof of funding UTXO ownership by the second public node
990 pub bitcoin_signature_2: Signature,
991 /// The actual announcement
992 pub contents: UnsignedChannelAnnouncement,
995 /// The unsigned part of a [`channel_update`] message.
997 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
998 #[derive(Clone, Debug, PartialEq, Eq)]
999 pub struct UnsignedChannelUpdate {
1000 /// The genesis hash of the blockchain where the channel is to be opened
1001 pub chain_hash: BlockHash,
1002 /// The short channel ID
1003 pub short_channel_id: u64,
1004 /// A strictly monotonic announcement counter, with gaps allowed, specific to this channel
1008 /// The number of blocks such that if:
1009 /// `incoming_htlc.cltv_expiry < outgoing_htlc.cltv_expiry + cltv_expiry_delta`
1010 /// then we need to fail the HTLC backwards. When forwarding an HTLC, `cltv_expiry_delta` determines
1011 /// the outgoing HTLC's minimum `cltv_expiry` value -- so, if an incoming HTLC comes in with a
1012 /// `cltv_expiry` of 100000, and the node we're forwarding to has a `cltv_expiry_delta` value of 10,
1013 /// then we'll check that the outgoing HTLC's `cltv_expiry` value is at least 100010 before
1014 /// forwarding. Note that the HTLC sender is the one who originally sets this value when
1015 /// constructing the route.
1016 pub cltv_expiry_delta: u16,
1017 /// The minimum HTLC size incoming to sender, in milli-satoshi
1018 pub htlc_minimum_msat: u64,
1019 /// The maximum HTLC value incoming to sender, in milli-satoshi.
1021 /// This used to be optional.
1022 pub htlc_maximum_msat: u64,
1023 /// The base HTLC fee charged by sender, in milli-satoshi
1024 pub fee_base_msat: u32,
1025 /// The amount to fee multiplier, in micro-satoshi
1026 pub fee_proportional_millionths: u32,
1027 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1030 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1031 pub excess_data: Vec<u8>,
1033 /// A [`channel_update`] message to be sent to or received from a peer.
1035 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1036 #[derive(Clone, Debug, PartialEq, Eq)]
1037 pub struct ChannelUpdate {
1038 /// A signature of the channel update
1039 pub signature: Signature,
1040 /// The actual channel update
1041 pub contents: UnsignedChannelUpdate,
1044 /// A [`query_channel_range`] message is used to query a peer for channel
1045 /// UTXOs in a range of blocks. The recipient of a query makes a best
1046 /// effort to reply to the query using one or more [`ReplyChannelRange`]
1049 /// [`query_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1050 #[derive(Clone, Debug, PartialEq, Eq)]
1051 pub struct QueryChannelRange {
1052 /// The genesis hash of the blockchain being queried
1053 pub chain_hash: BlockHash,
1054 /// The height of the first block for the channel UTXOs being queried
1055 pub first_blocknum: u32,
1056 /// The number of blocks to include in the query results
1057 pub number_of_blocks: u32,
1060 /// A [`reply_channel_range`] message is a reply to a [`QueryChannelRange`]
1063 /// Multiple `reply_channel_range` messages can be sent in reply
1064 /// to a single [`QueryChannelRange`] message. The query recipient makes a
1065 /// best effort to respond based on their local network view which may
1066 /// not be a perfect view of the network. The `short_channel_id`s in the
1067 /// reply are encoded. We only support `encoding_type=0` uncompressed
1068 /// serialization and do not support `encoding_type=1` zlib serialization.
1070 /// [`reply_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1071 #[derive(Clone, Debug, PartialEq, Eq)]
1072 pub struct ReplyChannelRange {
1073 /// The genesis hash of the blockchain being queried
1074 pub chain_hash: BlockHash,
1075 /// The height of the first block in the range of the reply
1076 pub first_blocknum: u32,
1077 /// The number of blocks included in the range of the reply
1078 pub number_of_blocks: u32,
1079 /// True when this is the final reply for a query
1080 pub sync_complete: bool,
1081 /// The `short_channel_id`s in the channel range
1082 pub short_channel_ids: Vec<u64>,
1085 /// A [`query_short_channel_ids`] message is used to query a peer for
1086 /// routing gossip messages related to one or more `short_channel_id`s.
1088 /// The query recipient will reply with the latest, if available,
1089 /// [`ChannelAnnouncement`], [`ChannelUpdate`] and [`NodeAnnouncement`] messages
1090 /// it maintains for the requested `short_channel_id`s followed by a
1091 /// [`ReplyShortChannelIdsEnd`] message. The `short_channel_id`s sent in
1092 /// this query are encoded. We only support `encoding_type=0` uncompressed
1093 /// serialization and do not support `encoding_type=1` zlib serialization.
1095 /// [`query_short_channel_ids`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_short_channel_idsreply_short_channel_ids_end-messages
1096 #[derive(Clone, Debug, PartialEq, Eq)]
1097 pub struct QueryShortChannelIds {
1098 /// The genesis hash of the blockchain being queried
1099 pub chain_hash: BlockHash,
1100 /// The short_channel_ids that are being queried
1101 pub short_channel_ids: Vec<u64>,
1104 /// A [`reply_short_channel_ids_end`] message is sent as a reply to a
1105 /// message. The query recipient makes a best
1106 /// effort to respond based on their local network view which may not be
1107 /// a perfect view of the network.
1109 /// [`reply_short_channel_ids_end`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_short_channel_idsreply_short_channel_ids_end-messages
1110 #[derive(Clone, Debug, PartialEq, Eq)]
1111 pub struct ReplyShortChannelIdsEnd {
1112 /// The genesis hash of the blockchain that was queried
1113 pub chain_hash: BlockHash,
1114 /// Indicates if the query recipient maintains up-to-date channel
1115 /// information for the `chain_hash`
1116 pub full_information: bool,
1119 /// A [`gossip_timestamp_filter`] message is used by a node to request
1120 /// gossip relay for messages in the requested time range when the
1121 /// `gossip_queries` feature has been negotiated.
1123 /// [`gossip_timestamp_filter`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-gossip_timestamp_filter-message
1124 #[derive(Clone, Debug, PartialEq, Eq)]
1125 pub struct GossipTimestampFilter {
1126 /// The genesis hash of the blockchain for channel and node information
1127 pub chain_hash: BlockHash,
1128 /// The starting unix timestamp
1129 pub first_timestamp: u32,
1130 /// The range of information in seconds
1131 pub timestamp_range: u32,
1134 /// Encoding type for data compression of collections in gossip queries.
1136 /// We do not support `encoding_type=1` zlib serialization [defined in BOLT
1137 /// #7](https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#query-messages).
1139 Uncompressed = 0x00,
1142 /// Used to put an error message in a [`LightningError`].
1143 #[derive(Clone, Debug)]
1144 pub enum ErrorAction {
1145 /// The peer took some action which made us think they were useless. Disconnect them.
1147 /// An error message which we should make an effort to send before we disconnect.
1148 msg: Option<ErrorMessage>
1150 /// The peer did something incorrect. Tell them without closing any channels and disconnect them.
1151 DisconnectPeerWithWarning {
1152 /// A warning message which we should make an effort to send before we disconnect.
1153 msg: WarningMessage,
1155 /// The peer did something harmless that we weren't able to process, just log and ignore
1156 // New code should *not* use this. New code must use IgnoreAndLog, below!
1158 /// The peer did something harmless that we weren't able to meaningfully process.
1159 /// If the error is logged, log it at the given level.
1160 IgnoreAndLog(logger::Level),
1161 /// The peer provided us with a gossip message which we'd already seen. In most cases this
1162 /// should be ignored, but it may result in the message being forwarded if it is a duplicate of
1163 /// our own channel announcements.
1164 IgnoreDuplicateGossip,
1165 /// The peer did something incorrect. Tell them.
1167 /// The message to send.
1170 /// The peer did something incorrect. Tell them without closing any channels.
1171 SendWarningMessage {
1172 /// The message to send.
1173 msg: WarningMessage,
1174 /// The peer may have done something harmless that we weren't able to meaningfully process,
1175 /// though we should still tell them about it.
1176 /// If this event is logged, log it at the given level.
1177 log_level: logger::Level,
1181 /// An Err type for failure to process messages.
1182 #[derive(Clone, Debug)]
1183 pub struct LightningError {
1184 /// A human-readable message describing the error
1186 /// The action which should be taken against the offending peer.
1187 pub action: ErrorAction,
1190 /// Struct used to return values from [`RevokeAndACK`] messages, containing a bunch of commitment
1191 /// transaction updates if they were pending.
1192 #[derive(Clone, Debug, PartialEq, Eq)]
1193 pub struct CommitmentUpdate {
1194 /// `update_add_htlc` messages which should be sent
1195 pub update_add_htlcs: Vec<UpdateAddHTLC>,
1196 /// `update_fulfill_htlc` messages which should be sent
1197 pub update_fulfill_htlcs: Vec<UpdateFulfillHTLC>,
1198 /// `update_fail_htlc` messages which should be sent
1199 pub update_fail_htlcs: Vec<UpdateFailHTLC>,
1200 /// `update_fail_malformed_htlc` messages which should be sent
1201 pub update_fail_malformed_htlcs: Vec<UpdateFailMalformedHTLC>,
1202 /// An `update_fee` message which should be sent
1203 pub update_fee: Option<UpdateFee>,
1204 /// A `commitment_signed` message which should be sent
1205 pub commitment_signed: CommitmentSigned,
1208 /// A trait to describe an object which can receive channel messages.
1210 /// Messages MAY be called in parallel when they originate from different `their_node_ids`, however
1211 /// they MUST NOT be called in parallel when the two calls have the same `their_node_id`.
1212 pub trait ChannelMessageHandler : MessageSendEventsProvider {
1214 /// Handle an incoming `open_channel` message from the given peer.
1215 fn handle_open_channel(&self, their_node_id: &PublicKey, msg: &OpenChannel);
1216 /// Handle an incoming `open_channel2` message from the given peer.
1217 fn handle_open_channel_v2(&self, their_node_id: &PublicKey, msg: &OpenChannelV2);
1218 /// Handle an incoming `accept_channel` message from the given peer.
1219 fn handle_accept_channel(&self, their_node_id: &PublicKey, msg: &AcceptChannel);
1220 /// Handle an incoming `accept_channel2` message from the given peer.
1221 fn handle_accept_channel_v2(&self, their_node_id: &PublicKey, msg: &AcceptChannelV2);
1222 /// Handle an incoming `funding_created` message from the given peer.
1223 fn handle_funding_created(&self, their_node_id: &PublicKey, msg: &FundingCreated);
1224 /// Handle an incoming `funding_signed` message from the given peer.
1225 fn handle_funding_signed(&self, their_node_id: &PublicKey, msg: &FundingSigned);
1226 /// Handle an incoming `channel_ready` message from the given peer.
1227 fn handle_channel_ready(&self, their_node_id: &PublicKey, msg: &ChannelReady);
1230 /// Handle an incoming `shutdown` message from the given peer.
1231 fn handle_shutdown(&self, their_node_id: &PublicKey, msg: &Shutdown);
1232 /// Handle an incoming `closing_signed` message from the given peer.
1233 fn handle_closing_signed(&self, their_node_id: &PublicKey, msg: &ClosingSigned);
1235 // Interactive channel construction
1236 /// Handle an incoming `tx_add_input message` from the given peer.
1237 fn handle_tx_add_input(&self, their_node_id: &PublicKey, msg: &TxAddInput);
1238 /// Handle an incoming `tx_add_output` message from the given peer.
1239 fn handle_tx_add_output(&self, their_node_id: &PublicKey, msg: &TxAddOutput);
1240 /// Handle an incoming `tx_remove_input` message from the given peer.
1241 fn handle_tx_remove_input(&self, their_node_id: &PublicKey, msg: &TxRemoveInput);
1242 /// Handle an incoming `tx_remove_output` message from the given peer.
1243 fn handle_tx_remove_output(&self, their_node_id: &PublicKey, msg: &TxRemoveOutput);
1244 /// Handle an incoming `tx_complete message` from the given peer.
1245 fn handle_tx_complete(&self, their_node_id: &PublicKey, msg: &TxComplete);
1246 /// Handle an incoming `tx_signatures` message from the given peer.
1247 fn handle_tx_signatures(&self, their_node_id: &PublicKey, msg: &TxSignatures);
1248 /// Handle an incoming `tx_init_rbf` message from the given peer.
1249 fn handle_tx_init_rbf(&self, their_node_id: &PublicKey, msg: &TxInitRbf);
1250 /// Handle an incoming `tx_ack_rbf` message from the given peer.
1251 fn handle_tx_ack_rbf(&self, their_node_id: &PublicKey, msg: &TxAckRbf);
1252 /// Handle an incoming `tx_abort message` from the given peer.
1253 fn handle_tx_abort(&self, their_node_id: &PublicKey, msg: &TxAbort);
1256 /// Handle an incoming `update_add_htlc` message from the given peer.
1257 fn handle_update_add_htlc(&self, their_node_id: &PublicKey, msg: &UpdateAddHTLC);
1258 /// Handle an incoming `update_fulfill_htlc` message from the given peer.
1259 fn handle_update_fulfill_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFulfillHTLC);
1260 /// Handle an incoming `update_fail_htlc` message from the given peer.
1261 fn handle_update_fail_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailHTLC);
1262 /// Handle an incoming `update_fail_malformed_htlc` message from the given peer.
1263 fn handle_update_fail_malformed_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailMalformedHTLC);
1264 /// Handle an incoming `commitment_signed` message from the given peer.
1265 fn handle_commitment_signed(&self, their_node_id: &PublicKey, msg: &CommitmentSigned);
1266 /// Handle an incoming `revoke_and_ack` message from the given peer.
1267 fn handle_revoke_and_ack(&self, their_node_id: &PublicKey, msg: &RevokeAndACK);
1269 /// Handle an incoming `update_fee` message from the given peer.
1270 fn handle_update_fee(&self, their_node_id: &PublicKey, msg: &UpdateFee);
1272 // Channel-to-announce:
1273 /// Handle an incoming `announcement_signatures` message from the given peer.
1274 fn handle_announcement_signatures(&self, their_node_id: &PublicKey, msg: &AnnouncementSignatures);
1276 // Connection loss/reestablish:
1277 /// Indicates a connection to the peer failed/an existing connection was lost.
1278 fn peer_disconnected(&self, their_node_id: &PublicKey);
1280 /// Handle a peer reconnecting, possibly generating `channel_reestablish` message(s).
1282 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1283 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1284 /// message handlers may still wish to communicate with this peer.
1285 fn peer_connected(&self, their_node_id: &PublicKey, msg: &Init, inbound: bool) -> Result<(), ()>;
1286 /// Handle an incoming `channel_reestablish` message from the given peer.
1287 fn handle_channel_reestablish(&self, their_node_id: &PublicKey, msg: &ChannelReestablish);
1289 /// Handle an incoming `channel_update` message from the given peer.
1290 fn handle_channel_update(&self, their_node_id: &PublicKey, msg: &ChannelUpdate);
1293 /// Handle an incoming `error` message from the given peer.
1294 fn handle_error(&self, their_node_id: &PublicKey, msg: &ErrorMessage);
1296 // Handler information:
1297 /// Gets the node feature flags which this handler itself supports. All available handlers are
1298 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1299 /// which are broadcasted in our [`NodeAnnouncement`] message.
1300 fn provided_node_features(&self) -> NodeFeatures;
1302 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1303 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1304 /// which are sent in our [`Init`] message.
1306 /// Note that this method is called before [`Self::peer_connected`].
1307 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1309 /// Gets the genesis hashes for this `ChannelMessageHandler` indicating which chains it supports.
1311 /// If it's `None`, then no particular network chain hash compatibility will be enforced when
1312 /// connecting to peers.
1313 fn get_genesis_hashes(&self) -> Option<Vec<ChainHash>>;
1316 /// A trait to describe an object which can receive routing messages.
1318 /// # Implementor DoS Warnings
1320 /// For messages enabled with the `gossip_queries` feature there are potential DoS vectors when
1321 /// handling inbound queries. Implementors using an on-disk network graph should be aware of
1322 /// repeated disk I/O for queries accessing different parts of the network graph.
1323 pub trait RoutingMessageHandler : MessageSendEventsProvider {
1324 /// Handle an incoming `node_announcement` message, returning `true` if it should be forwarded on,
1325 /// `false` or returning an `Err` otherwise.
1326 fn handle_node_announcement(&self, msg: &NodeAnnouncement) -> Result<bool, LightningError>;
1327 /// Handle a `channel_announcement` message, returning `true` if it should be forwarded on, `false`
1328 /// or returning an `Err` otherwise.
1329 fn handle_channel_announcement(&self, msg: &ChannelAnnouncement) -> Result<bool, LightningError>;
1330 /// Handle an incoming `channel_update` message, returning true if it should be forwarded on,
1331 /// `false` or returning an `Err` otherwise.
1332 fn handle_channel_update(&self, msg: &ChannelUpdate) -> Result<bool, LightningError>;
1333 /// Gets channel announcements and updates required to dump our routing table to a remote node,
1334 /// starting at the `short_channel_id` indicated by `starting_point` and including announcements
1335 /// for a single channel.
1336 fn get_next_channel_announcement(&self, starting_point: u64) -> Option<(ChannelAnnouncement, Option<ChannelUpdate>, Option<ChannelUpdate>)>;
1337 /// Gets a node announcement required to dump our routing table to a remote node, starting at
1338 /// the node *after* the provided pubkey and including up to one announcement immediately
1339 /// higher (as defined by `<PublicKey as Ord>::cmp`) than `starting_point`.
1340 /// If `None` is provided for `starting_point`, we start at the first node.
1341 fn get_next_node_announcement(&self, starting_point: Option<&NodeId>) -> Option<NodeAnnouncement>;
1342 /// Called when a connection is established with a peer. This can be used to
1343 /// perform routing table synchronization using a strategy defined by the
1346 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1347 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1348 /// message handlers may still wish to communicate with this peer.
1349 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1350 /// Handles the reply of a query we initiated to learn about channels
1351 /// for a given range of blocks. We can expect to receive one or more
1352 /// replies to a single query.
1353 fn handle_reply_channel_range(&self, their_node_id: &PublicKey, msg: ReplyChannelRange) -> Result<(), LightningError>;
1354 /// Handles the reply of a query we initiated asking for routing gossip
1355 /// messages for a list of channels. We should receive this message when
1356 /// a node has completed its best effort to send us the pertaining routing
1357 /// gossip messages.
1358 fn handle_reply_short_channel_ids_end(&self, their_node_id: &PublicKey, msg: ReplyShortChannelIdsEnd) -> Result<(), LightningError>;
1359 /// Handles when a peer asks us to send a list of `short_channel_id`s
1360 /// for the requested range of blocks.
1361 fn handle_query_channel_range(&self, their_node_id: &PublicKey, msg: QueryChannelRange) -> Result<(), LightningError>;
1362 /// Handles when a peer asks us to send routing gossip messages for a
1363 /// list of `short_channel_id`s.
1364 fn handle_query_short_channel_ids(&self, their_node_id: &PublicKey, msg: QueryShortChannelIds) -> Result<(), LightningError>;
1366 // Handler queueing status:
1367 /// Indicates that there are a large number of [`ChannelAnnouncement`] (or other) messages
1368 /// pending some async action. While there is no guarantee of the rate of future messages, the
1369 /// caller should seek to reduce the rate of new gossip messages handled, especially
1370 /// [`ChannelAnnouncement`]s.
1371 fn processing_queue_high(&self) -> bool;
1373 // Handler information:
1374 /// Gets the node feature flags which this handler itself supports. All available handlers are
1375 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1376 /// which are broadcasted in our [`NodeAnnouncement`] message.
1377 fn provided_node_features(&self) -> NodeFeatures;
1378 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1379 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1380 /// which are sent in our [`Init`] message.
1382 /// Note that this method is called before [`Self::peer_connected`].
1383 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1386 /// A trait to describe an object that can receive onion messages.
1387 pub trait OnionMessageHandler : OnionMessageProvider {
1388 /// Handle an incoming `onion_message` message from the given peer.
1389 fn handle_onion_message(&self, peer_node_id: &PublicKey, msg: &OnionMessage);
1390 /// Called when a connection is established with a peer. Can be used to track which peers
1391 /// advertise onion message support and are online.
1393 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1394 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1395 /// message handlers may still wish to communicate with this peer.
1396 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1397 /// Indicates a connection to the peer failed/an existing connection was lost. Allows handlers to
1398 /// drop and refuse to forward onion messages to this peer.
1399 fn peer_disconnected(&self, their_node_id: &PublicKey);
1401 // Handler information:
1402 /// Gets the node feature flags which this handler itself supports. All available handlers are
1403 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1404 /// which are broadcasted in our [`NodeAnnouncement`] message.
1405 fn provided_node_features(&self) -> NodeFeatures;
1407 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1408 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1409 /// which are sent in our [`Init`] message.
1411 /// Note that this method is called before [`Self::peer_connected`].
1412 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1415 mod fuzzy_internal_msgs {
1416 use crate::prelude::*;
1417 use crate::ln::{PaymentPreimage, PaymentSecret};
1419 // These types aren't intended to be pub, but are exposed for direct fuzzing (as we deserialize
1420 // them from untrusted input):
1422 pub struct FinalOnionHopData {
1423 pub payment_secret: PaymentSecret,
1424 /// The total value, in msat, of the payment as received by the ultimate recipient.
1425 /// Message serialization may panic if this value is more than 21 million Bitcoin.
1426 pub total_msat: u64,
1429 pub enum InboundOnionPayload {
1431 short_channel_id: u64,
1432 /// The value, in msat, of the payment after this hop's fee is deducted.
1433 amt_to_forward: u64,
1434 outgoing_cltv_value: u32,
1437 payment_data: Option<FinalOnionHopData>,
1438 payment_metadata: Option<Vec<u8>>,
1439 keysend_preimage: Option<PaymentPreimage>,
1441 outgoing_cltv_value: u32,
1445 pub(crate) enum OutboundOnionPayload {
1447 short_channel_id: u64,
1448 /// The value, in msat, of the payment after this hop's fee is deducted.
1449 amt_to_forward: u64,
1450 outgoing_cltv_value: u32,
1453 payment_data: Option<FinalOnionHopData>,
1454 payment_metadata: Option<Vec<u8>>,
1455 keysend_preimage: Option<PaymentPreimage>,
1457 outgoing_cltv_value: u32,
1461 pub struct DecodedOnionErrorPacket {
1462 pub(crate) hmac: [u8; 32],
1463 pub(crate) failuremsg: Vec<u8>,
1464 pub(crate) pad: Vec<u8>,
1468 pub use self::fuzzy_internal_msgs::*;
1469 #[cfg(not(fuzzing))]
1470 pub(crate) use self::fuzzy_internal_msgs::*;
1473 pub(crate) struct OnionPacket {
1474 pub(crate) version: u8,
1475 /// In order to ensure we always return an error on onion decode in compliance with [BOLT
1476 /// #4](https://github.com/lightning/bolts/blob/master/04-onion-routing.md), we have to
1477 /// deserialize `OnionPacket`s contained in [`UpdateAddHTLC`] messages even if the ephemeral
1478 /// public key (here) is bogus, so we hold a [`Result`] instead of a [`PublicKey`] as we'd
1480 pub(crate) public_key: Result<PublicKey, secp256k1::Error>,
1481 pub(crate) hop_data: [u8; 20*65],
1482 pub(crate) hmac: [u8; 32],
1485 impl onion_utils::Packet for OnionPacket {
1486 type Data = onion_utils::FixedSizeOnionPacket;
1487 fn new(pubkey: PublicKey, hop_data: onion_utils::FixedSizeOnionPacket, hmac: [u8; 32]) -> Self {
1490 public_key: Ok(pubkey),
1491 hop_data: hop_data.0,
1497 impl Eq for OnionPacket { }
1498 impl PartialEq for OnionPacket {
1499 fn eq(&self, other: &OnionPacket) -> bool {
1500 for (i, j) in self.hop_data.iter().zip(other.hop_data.iter()) {
1501 if i != j { return false; }
1503 self.version == other.version &&
1504 self.public_key == other.public_key &&
1505 self.hmac == other.hmac
1509 impl fmt::Debug for OnionPacket {
1510 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1511 f.write_fmt(format_args!("OnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
1515 #[derive(Clone, Debug, PartialEq, Eq)]
1516 pub(crate) struct OnionErrorPacket {
1517 // This really should be a constant size slice, but the spec lets these things be up to 128KB?
1518 // (TODO) We limit it in decode to much lower...
1519 pub(crate) data: Vec<u8>,
1522 impl fmt::Display for DecodeError {
1523 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1525 DecodeError::UnknownVersion => f.write_str("Unknown realm byte in Onion packet"),
1526 DecodeError::UnknownRequiredFeature => f.write_str("Unknown required feature preventing decode"),
1527 DecodeError::InvalidValue => f.write_str("Nonsense bytes didn't map to the type they were interpreted as"),
1528 DecodeError::ShortRead => f.write_str("Packet extended beyond the provided bytes"),
1529 DecodeError::BadLengthDescriptor => f.write_str("A length descriptor in the packet didn't describe the later data correctly"),
1530 DecodeError::Io(ref e) => fmt::Debug::fmt(e, f),
1531 DecodeError::UnsupportedCompression => f.write_str("We don't support receiving messages with zlib-compressed fields"),
1536 impl From<io::Error> for DecodeError {
1537 fn from(e: io::Error) -> Self {
1538 if e.kind() == io::ErrorKind::UnexpectedEof {
1539 DecodeError::ShortRead
1541 DecodeError::Io(e.kind())
1546 #[cfg(not(taproot))]
1547 impl_writeable_msg!(AcceptChannel, {
1548 temporary_channel_id,
1549 dust_limit_satoshis,
1550 max_htlc_value_in_flight_msat,
1551 channel_reserve_satoshis,
1557 revocation_basepoint,
1559 delayed_payment_basepoint,
1561 first_per_commitment_point,
1563 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1564 (1, channel_type, option),
1568 impl_writeable_msg!(AcceptChannel, {
1569 temporary_channel_id,
1570 dust_limit_satoshis,
1571 max_htlc_value_in_flight_msat,
1572 channel_reserve_satoshis,
1578 revocation_basepoint,
1580 delayed_payment_basepoint,
1582 first_per_commitment_point,
1584 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1585 (1, channel_type, option),
1586 (4, next_local_nonce, option),
1589 impl_writeable_msg!(AcceptChannelV2, {
1590 temporary_channel_id,
1592 dust_limit_satoshis,
1593 max_htlc_value_in_flight_msat,
1599 revocation_basepoint,
1601 delayed_payment_basepoint,
1603 first_per_commitment_point,
1604 second_per_commitment_point,
1606 (0, shutdown_scriptpubkey, option),
1607 (1, channel_type, option),
1608 (2, require_confirmed_inputs, option),
1611 impl_writeable_msg!(TxAddInput, {
1619 impl_writeable_msg!(TxAddOutput, {
1626 impl_writeable_msg!(TxRemoveInput, {
1631 impl_writeable_msg!(TxRemoveOutput, {
1636 impl_writeable_msg!(TxComplete, {
1640 impl_writeable_msg!(TxSignatures, {
1646 impl_writeable_msg!(TxInitRbf, {
1649 feerate_sat_per_1000_weight,
1651 (0, funding_output_contribution, option),
1654 impl_writeable_msg!(TxAckRbf, {
1657 (0, funding_output_contribution, option),
1660 impl_writeable_msg!(TxAbort, {
1665 impl_writeable_msg!(AnnouncementSignatures, {
1672 impl_writeable_msg!(ChannelReestablish, {
1674 next_local_commitment_number,
1675 next_remote_commitment_number,
1676 your_last_per_commitment_secret,
1677 my_current_per_commitment_point,
1679 (0, next_funding_txid, option),
1682 impl_writeable_msg!(ClosingSigned,
1683 { channel_id, fee_satoshis, signature },
1684 { (1, fee_range, option) }
1687 impl_writeable!(ClosingSignedFeeRange, {
1692 #[cfg(not(taproot))]
1693 impl_writeable_msg!(CommitmentSigned, {
1700 impl_writeable_msg!(CommitmentSigned, {
1705 (2, partial_signature_with_nonce, option)
1708 impl_writeable!(DecodedOnionErrorPacket, {
1714 #[cfg(not(taproot))]
1715 impl_writeable_msg!(FundingCreated, {
1716 temporary_channel_id,
1718 funding_output_index,
1722 impl_writeable_msg!(FundingCreated, {
1723 temporary_channel_id,
1725 funding_output_index,
1728 (2, partial_signature_with_nonce, option),
1729 (4, next_local_nonce, option)
1732 #[cfg(not(taproot))]
1733 impl_writeable_msg!(FundingSigned, {
1739 impl_writeable_msg!(FundingSigned, {
1743 (2, partial_signature_with_nonce, option)
1746 impl_writeable_msg!(ChannelReady, {
1748 next_per_commitment_point,
1750 (1, short_channel_id_alias, option),
1753 impl Writeable for Init {
1754 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1755 // global_features gets the bottom 13 bits of our features, and local_features gets all of
1756 // our relevant feature bits. This keeps us compatible with old nodes.
1757 self.features.write_up_to_13(w)?;
1758 self.features.write(w)?;
1759 encode_tlv_stream!(w, {
1760 (1, self.networks.as_ref().map(|n| WithoutLength(n)), option),
1761 (3, self.remote_network_address, option),
1767 impl Readable for Init {
1768 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1769 let global_features: InitFeatures = Readable::read(r)?;
1770 let features: InitFeatures = Readable::read(r)?;
1771 let mut remote_network_address: Option<NetAddress> = None;
1772 let mut networks: Option<WithoutLength<Vec<ChainHash>>> = None;
1773 decode_tlv_stream!(r, {
1774 (1, networks, option),
1775 (3, remote_network_address, option)
1778 features: features | global_features,
1779 networks: networks.map(|n| n.0),
1780 remote_network_address,
1785 impl_writeable_msg!(OpenChannel, {
1787 temporary_channel_id,
1790 dust_limit_satoshis,
1791 max_htlc_value_in_flight_msat,
1792 channel_reserve_satoshis,
1798 revocation_basepoint,
1800 delayed_payment_basepoint,
1802 first_per_commitment_point,
1805 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1806 (1, channel_type, option),
1809 impl_writeable_msg!(OpenChannelV2, {
1811 temporary_channel_id,
1812 funding_feerate_sat_per_1000_weight,
1813 commitment_feerate_sat_per_1000_weight,
1815 dust_limit_satoshis,
1816 max_htlc_value_in_flight_msat,
1822 revocation_basepoint,
1824 delayed_payment_basepoint,
1826 first_per_commitment_point,
1827 second_per_commitment_point,
1830 (0, shutdown_scriptpubkey, option),
1831 (1, channel_type, option),
1832 (2, require_confirmed_inputs, option),
1835 #[cfg(not(taproot))]
1836 impl_writeable_msg!(RevokeAndACK, {
1838 per_commitment_secret,
1839 next_per_commitment_point
1843 impl_writeable_msg!(RevokeAndACK, {
1845 per_commitment_secret,
1846 next_per_commitment_point
1848 (4, next_local_nonce, option)
1851 impl_writeable_msg!(Shutdown, {
1856 impl_writeable_msg!(UpdateFailHTLC, {
1862 impl_writeable_msg!(UpdateFailMalformedHTLC, {
1869 impl_writeable_msg!(UpdateFee, {
1874 impl_writeable_msg!(UpdateFulfillHTLC, {
1880 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
1881 // serialization format in a way which assumes we know the total serialized length/message end
1883 impl_writeable!(OnionErrorPacket, {
1887 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
1888 // serialization format in a way which assumes we know the total serialized length/message end
1890 impl Writeable for OnionPacket {
1891 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1892 self.version.write(w)?;
1893 match self.public_key {
1894 Ok(pubkey) => pubkey.write(w)?,
1895 Err(_) => [0u8;33].write(w)?,
1897 w.write_all(&self.hop_data)?;
1898 self.hmac.write(w)?;
1903 impl Readable for OnionPacket {
1904 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1906 version: Readable::read(r)?,
1908 let mut buf = [0u8;33];
1909 r.read_exact(&mut buf)?;
1910 PublicKey::from_slice(&buf)
1912 hop_data: Readable::read(r)?,
1913 hmac: Readable::read(r)?,
1918 impl_writeable_msg!(UpdateAddHTLC, {
1924 onion_routing_packet,
1926 (65537, skimmed_fee_msat, option)
1929 impl Readable for OnionMessage {
1930 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1931 let blinding_point: PublicKey = Readable::read(r)?;
1932 let len: u16 = Readable::read(r)?;
1933 let mut packet_reader = FixedLengthReader::new(r, len as u64);
1934 let onion_routing_packet: onion_message::Packet = <onion_message::Packet as LengthReadable>::read(&mut packet_reader)?;
1937 onion_routing_packet,
1942 impl Writeable for OnionMessage {
1943 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1944 self.blinding_point.write(w)?;
1945 let onion_packet_len = self.onion_routing_packet.serialized_length();
1946 (onion_packet_len as u16).write(w)?;
1947 self.onion_routing_packet.write(w)?;
1952 impl Writeable for FinalOnionHopData {
1953 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1954 self.payment_secret.0.write(w)?;
1955 HighZeroBytesDroppedBigSize(self.total_msat).write(w)
1959 impl Readable for FinalOnionHopData {
1960 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1961 let secret: [u8; 32] = Readable::read(r)?;
1962 let amt: HighZeroBytesDroppedBigSize<u64> = Readable::read(r)?;
1963 Ok(Self { payment_secret: PaymentSecret(secret), total_msat: amt.0 })
1967 impl Writeable for OutboundOnionPayload {
1968 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1970 Self::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } => {
1971 _encode_varint_length_prefixed_tlv!(w, {
1972 (2, HighZeroBytesDroppedBigSize(*amt_to_forward), required),
1973 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
1974 (6, short_channel_id, required)
1978 ref payment_data, ref payment_metadata, ref keysend_preimage, amt_msat, outgoing_cltv_value
1980 _encode_varint_length_prefixed_tlv!(w, {
1981 (2, HighZeroBytesDroppedBigSize(*amt_msat), required),
1982 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
1983 (8, payment_data, option),
1984 (16, payment_metadata.as_ref().map(|m| WithoutLength(m)), option),
1985 (5482373484, keysend_preimage, option)
1993 impl Readable for InboundOnionPayload {
1994 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1995 let mut amt = HighZeroBytesDroppedBigSize(0u64);
1996 let mut cltv_value = HighZeroBytesDroppedBigSize(0u32);
1997 let mut short_id: Option<u64> = None;
1998 let mut payment_data: Option<FinalOnionHopData> = None;
1999 let mut payment_metadata: Option<WithoutLength<Vec<u8>>> = None;
2000 let mut keysend_preimage: Option<PaymentPreimage> = None;
2001 read_tlv_fields!(r, {
2003 (4, cltv_value, required),
2004 (6, short_id, option),
2005 (8, payment_data, option),
2006 (16, payment_metadata, option),
2007 // See https://github.com/lightning/blips/blob/master/blip-0003.md
2008 (5482373484, keysend_preimage, option)
2011 if amt.0 > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2012 if let Some(short_channel_id) = short_id {
2013 if payment_data.is_some() { return Err(DecodeError::InvalidValue) }
2014 if payment_metadata.is_some() { return Err(DecodeError::InvalidValue); }
2017 amt_to_forward: amt.0,
2018 outgoing_cltv_value: cltv_value.0,
2021 if let Some(data) = &payment_data {
2022 if data.total_msat > MAX_VALUE_MSAT {
2023 return Err(DecodeError::InvalidValue);
2028 payment_metadata: payment_metadata.map(|w| w.0),
2031 outgoing_cltv_value: cltv_value.0,
2037 // ReadableArgs because we need onion_utils::decode_next_hop to accommodate payment packets and
2038 // onion message packets.
2039 impl ReadableArgs<()> for InboundOnionPayload {
2040 fn read<R: Read>(r: &mut R, _arg: ()) -> Result<Self, DecodeError> {
2041 <Self as Readable>::read(r)
2045 impl Writeable for Ping {
2046 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2047 self.ponglen.write(w)?;
2048 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2053 impl Readable for Ping {
2054 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2056 ponglen: Readable::read(r)?,
2058 let byteslen = Readable::read(r)?;
2059 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2066 impl Writeable for Pong {
2067 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2068 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2073 impl Readable for Pong {
2074 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2077 let byteslen = Readable::read(r)?;
2078 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2085 impl Writeable for UnsignedChannelAnnouncement {
2086 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2087 self.features.write(w)?;
2088 self.chain_hash.write(w)?;
2089 self.short_channel_id.write(w)?;
2090 self.node_id_1.write(w)?;
2091 self.node_id_2.write(w)?;
2092 self.bitcoin_key_1.write(w)?;
2093 self.bitcoin_key_2.write(w)?;
2094 w.write_all(&self.excess_data[..])?;
2099 impl Readable for UnsignedChannelAnnouncement {
2100 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2102 features: Readable::read(r)?,
2103 chain_hash: Readable::read(r)?,
2104 short_channel_id: Readable::read(r)?,
2105 node_id_1: Readable::read(r)?,
2106 node_id_2: Readable::read(r)?,
2107 bitcoin_key_1: Readable::read(r)?,
2108 bitcoin_key_2: Readable::read(r)?,
2109 excess_data: read_to_end(r)?,
2114 impl_writeable!(ChannelAnnouncement, {
2117 bitcoin_signature_1,
2118 bitcoin_signature_2,
2122 impl Writeable for UnsignedChannelUpdate {
2123 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2124 // `message_flags` used to indicate presence of `htlc_maximum_msat`, but was deprecated in the spec.
2125 const MESSAGE_FLAGS: u8 = 1;
2126 self.chain_hash.write(w)?;
2127 self.short_channel_id.write(w)?;
2128 self.timestamp.write(w)?;
2129 let all_flags = self.flags as u16 | ((MESSAGE_FLAGS as u16) << 8);
2130 all_flags.write(w)?;
2131 self.cltv_expiry_delta.write(w)?;
2132 self.htlc_minimum_msat.write(w)?;
2133 self.fee_base_msat.write(w)?;
2134 self.fee_proportional_millionths.write(w)?;
2135 self.htlc_maximum_msat.write(w)?;
2136 w.write_all(&self.excess_data[..])?;
2141 impl Readable for UnsignedChannelUpdate {
2142 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2144 chain_hash: Readable::read(r)?,
2145 short_channel_id: Readable::read(r)?,
2146 timestamp: Readable::read(r)?,
2148 let flags: u16 = Readable::read(r)?;
2149 // Note: we ignore the `message_flags` for now, since it was deprecated by the spec.
2152 cltv_expiry_delta: Readable::read(r)?,
2153 htlc_minimum_msat: Readable::read(r)?,
2154 fee_base_msat: Readable::read(r)?,
2155 fee_proportional_millionths: Readable::read(r)?,
2156 htlc_maximum_msat: Readable::read(r)?,
2157 excess_data: read_to_end(r)?,
2162 impl_writeable!(ChannelUpdate, {
2167 impl Writeable for ErrorMessage {
2168 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2169 self.channel_id.write(w)?;
2170 (self.data.len() as u16).write(w)?;
2171 w.write_all(self.data.as_bytes())?;
2176 impl Readable for ErrorMessage {
2177 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2179 channel_id: Readable::read(r)?,
2181 let sz: usize = <u16 as Readable>::read(r)? as usize;
2182 let mut data = Vec::with_capacity(sz);
2184 r.read_exact(&mut data)?;
2185 match String::from_utf8(data) {
2187 Err(_) => return Err(DecodeError::InvalidValue),
2194 impl Writeable for WarningMessage {
2195 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2196 self.channel_id.write(w)?;
2197 (self.data.len() as u16).write(w)?;
2198 w.write_all(self.data.as_bytes())?;
2203 impl Readable for WarningMessage {
2204 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2206 channel_id: Readable::read(r)?,
2208 let sz: usize = <u16 as Readable>::read(r)? as usize;
2209 let mut data = Vec::with_capacity(sz);
2211 r.read_exact(&mut data)?;
2212 match String::from_utf8(data) {
2214 Err(_) => return Err(DecodeError::InvalidValue),
2221 impl Writeable for UnsignedNodeAnnouncement {
2222 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2223 self.features.write(w)?;
2224 self.timestamp.write(w)?;
2225 self.node_id.write(w)?;
2226 w.write_all(&self.rgb)?;
2227 self.alias.write(w)?;
2229 let mut addr_len = 0;
2230 for addr in self.addresses.iter() {
2231 addr_len += 1 + addr.len();
2233 (addr_len + self.excess_address_data.len() as u16).write(w)?;
2234 for addr in self.addresses.iter() {
2237 w.write_all(&self.excess_address_data[..])?;
2238 w.write_all(&self.excess_data[..])?;
2243 impl Readable for UnsignedNodeAnnouncement {
2244 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2245 let features: NodeFeatures = Readable::read(r)?;
2246 let timestamp: u32 = Readable::read(r)?;
2247 let node_id: NodeId = Readable::read(r)?;
2248 let mut rgb = [0; 3];
2249 r.read_exact(&mut rgb)?;
2250 let alias: NodeAlias = Readable::read(r)?;
2252 let addr_len: u16 = Readable::read(r)?;
2253 let mut addresses: Vec<NetAddress> = Vec::new();
2254 let mut addr_readpos = 0;
2255 let mut excess = false;
2256 let mut excess_byte = 0;
2258 if addr_len <= addr_readpos { break; }
2259 match Readable::read(r) {
2261 if addr_len < addr_readpos + 1 + addr.len() {
2262 return Err(DecodeError::BadLengthDescriptor);
2264 addr_readpos += (1 + addr.len()) as u16;
2265 addresses.push(addr);
2267 Ok(Err(unknown_descriptor)) => {
2269 excess_byte = unknown_descriptor;
2272 Err(DecodeError::ShortRead) => return Err(DecodeError::BadLengthDescriptor),
2273 Err(e) => return Err(e),
2277 let mut excess_data = vec![];
2278 let excess_address_data = if addr_readpos < addr_len {
2279 let mut excess_address_data = vec![0; (addr_len - addr_readpos) as usize];
2280 r.read_exact(&mut excess_address_data[if excess { 1 } else { 0 }..])?;
2282 excess_address_data[0] = excess_byte;
2287 excess_data.push(excess_byte);
2291 excess_data.extend(read_to_end(r)?.iter());
2292 Ok(UnsignedNodeAnnouncement {
2299 excess_address_data,
2305 impl_writeable!(NodeAnnouncement, {
2310 impl Readable for QueryShortChannelIds {
2311 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2312 let chain_hash: BlockHash = Readable::read(r)?;
2314 let encoding_len: u16 = Readable::read(r)?;
2315 let encoding_type: u8 = Readable::read(r)?;
2317 // Must be encoding_type=0 uncompressed serialization. We do not
2318 // support encoding_type=1 zlib serialization.
2319 if encoding_type != EncodingType::Uncompressed as u8 {
2320 return Err(DecodeError::UnsupportedCompression);
2323 // We expect the encoding_len to always includes the 1-byte
2324 // encoding_type and that short_channel_ids are 8-bytes each
2325 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2326 return Err(DecodeError::InvalidValue);
2329 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2330 // less the 1-byte encoding_type
2331 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2332 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2333 for _ in 0..short_channel_id_count {
2334 short_channel_ids.push(Readable::read(r)?);
2337 Ok(QueryShortChannelIds {
2344 impl Writeable for QueryShortChannelIds {
2345 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2346 // Calculated from 1-byte encoding_type plus 8-bytes per short_channel_id
2347 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2349 self.chain_hash.write(w)?;
2350 encoding_len.write(w)?;
2352 // We only support type=0 uncompressed serialization
2353 (EncodingType::Uncompressed as u8).write(w)?;
2355 for scid in self.short_channel_ids.iter() {
2363 impl_writeable_msg!(ReplyShortChannelIdsEnd, {
2368 impl QueryChannelRange {
2369 /// Calculates the overflow safe ending block height for the query.
2371 /// Overflow returns `0xffffffff`, otherwise returns `first_blocknum + number_of_blocks`.
2372 pub fn end_blocknum(&self) -> u32 {
2373 match self.first_blocknum.checked_add(self.number_of_blocks) {
2374 Some(block) => block,
2375 None => u32::max_value(),
2380 impl_writeable_msg!(QueryChannelRange, {
2386 impl Readable for ReplyChannelRange {
2387 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2388 let chain_hash: BlockHash = Readable::read(r)?;
2389 let first_blocknum: u32 = Readable::read(r)?;
2390 let number_of_blocks: u32 = Readable::read(r)?;
2391 let sync_complete: bool = Readable::read(r)?;
2393 let encoding_len: u16 = Readable::read(r)?;
2394 let encoding_type: u8 = Readable::read(r)?;
2396 // Must be encoding_type=0 uncompressed serialization. We do not
2397 // support encoding_type=1 zlib serialization.
2398 if encoding_type != EncodingType::Uncompressed as u8 {
2399 return Err(DecodeError::UnsupportedCompression);
2402 // We expect the encoding_len to always includes the 1-byte
2403 // encoding_type and that short_channel_ids are 8-bytes each
2404 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2405 return Err(DecodeError::InvalidValue);
2408 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2409 // less the 1-byte encoding_type
2410 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2411 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2412 for _ in 0..short_channel_id_count {
2413 short_channel_ids.push(Readable::read(r)?);
2416 Ok(ReplyChannelRange {
2426 impl Writeable for ReplyChannelRange {
2427 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2428 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2429 self.chain_hash.write(w)?;
2430 self.first_blocknum.write(w)?;
2431 self.number_of_blocks.write(w)?;
2432 self.sync_complete.write(w)?;
2434 encoding_len.write(w)?;
2435 (EncodingType::Uncompressed as u8).write(w)?;
2436 for scid in self.short_channel_ids.iter() {
2444 impl_writeable_msg!(GossipTimestampFilter, {
2452 use bitcoin::blockdata::constants::ChainHash;
2453 use bitcoin::{Transaction, PackedLockTime, TxIn, Script, Sequence, Witness, TxOut};
2455 use crate::ln::{PaymentPreimage, PaymentHash, PaymentSecret};
2456 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
2457 use crate::ln::msgs::{self, FinalOnionHopData, OnionErrorPacket};
2458 use crate::routing::gossip::{NodeAlias, NodeId};
2459 use crate::util::ser::{Writeable, Readable, Hostname, TransactionU16LenLimited};
2461 use bitcoin::hashes::hex::FromHex;
2462 use bitcoin::util::address::Address;
2463 use bitcoin::network::constants::Network;
2464 use bitcoin::blockdata::script::Builder;
2465 use bitcoin::blockdata::opcodes;
2466 use bitcoin::hash_types::{Txid, BlockHash};
2468 use bitcoin::secp256k1::{PublicKey,SecretKey};
2469 use bitcoin::secp256k1::{Secp256k1, Message};
2471 use crate::io::{self, Cursor};
2472 use crate::prelude::*;
2473 use core::convert::TryFrom;
2474 use core::str::FromStr;
2476 use crate::chain::transaction::OutPoint;
2479 fn encoding_channel_reestablish() {
2481 let secp_ctx = Secp256k1::new();
2482 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2485 let cr = msgs::ChannelReestablish {
2486 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],
2487 next_local_commitment_number: 3,
2488 next_remote_commitment_number: 4,
2489 your_last_per_commitment_secret: [9;32],
2490 my_current_per_commitment_point: public_key,
2491 next_funding_txid: None,
2494 let encoded_value = cr.encode();
2498 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
2499 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2500 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2501 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
2502 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
2508 fn encoding_channel_reestablish_with_next_funding_txid() {
2510 let secp_ctx = Secp256k1::new();
2511 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2514 let cr = msgs::ChannelReestablish {
2515 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],
2516 next_local_commitment_number: 3,
2517 next_remote_commitment_number: 4,
2518 your_last_per_commitment_secret: [9;32],
2519 my_current_per_commitment_point: public_key,
2520 next_funding_txid: Some(Txid::from_hash(bitcoin::hashes::Hash::from_slice(&[
2521 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,
2525 let encoded_value = cr.encode();
2529 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
2530 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2531 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2532 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
2533 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
2534 0, // Type (next_funding_txid)
2536 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
2541 macro_rules! get_keys_from {
2542 ($slice: expr, $secp_ctx: expr) => {
2544 let privkey = SecretKey::from_slice(&hex::decode($slice).unwrap()[..]).unwrap();
2545 let pubkey = PublicKey::from_secret_key(&$secp_ctx, &privkey);
2551 macro_rules! get_sig_on {
2552 ($privkey: expr, $ctx: expr, $string: expr) => {
2554 let sighash = Message::from_slice(&$string.into_bytes()[..]).unwrap();
2555 $ctx.sign_ecdsa(&sighash, &$privkey)
2561 fn encoding_announcement_signatures() {
2562 let secp_ctx = Secp256k1::new();
2563 let (privkey, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2564 let sig_1 = get_sig_on!(privkey, secp_ctx, String::from("01010101010101010101010101010101"));
2565 let sig_2 = get_sig_on!(privkey, secp_ctx, String::from("02020202020202020202020202020202"));
2566 let announcement_signatures = msgs::AnnouncementSignatures {
2567 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],
2568 short_channel_id: 2316138423780173,
2569 node_signature: sig_1,
2570 bitcoin_signature: sig_2,
2573 let encoded_value = announcement_signatures.encode();
2574 assert_eq!(encoded_value, hex::decode("040000000000000005000000000000000600000000000000070000000000000000083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073acf9953cef4700860f5967838eba2bae89288ad188ebf8b20bf995c3ea53a26df1876d0a3a0e13172ba286a673140190c02ba9da60a2e43a745188c8a83c7f3ef").unwrap());
2577 fn do_encoding_channel_announcement(unknown_features_bits: bool, excess_data: bool) {
2578 let secp_ctx = Secp256k1::new();
2579 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2580 let (privkey_2, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2581 let (privkey_3, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2582 let (privkey_4, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2583 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2584 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
2585 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
2586 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
2587 let mut features = ChannelFeatures::empty();
2588 if unknown_features_bits {
2589 features = ChannelFeatures::from_le_bytes(vec![0xFF, 0xFF]);
2591 let unsigned_channel_announcement = msgs::UnsignedChannelAnnouncement {
2593 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2594 short_channel_id: 2316138423780173,
2595 node_id_1: NodeId::from_pubkey(&pubkey_1),
2596 node_id_2: NodeId::from_pubkey(&pubkey_2),
2597 bitcoin_key_1: NodeId::from_pubkey(&pubkey_3),
2598 bitcoin_key_2: NodeId::from_pubkey(&pubkey_4),
2599 excess_data: if excess_data { vec![10, 0, 0, 20, 0, 0, 30, 0, 0, 40] } else { Vec::new() },
2601 let channel_announcement = msgs::ChannelAnnouncement {
2602 node_signature_1: sig_1,
2603 node_signature_2: sig_2,
2604 bitcoin_signature_1: sig_3,
2605 bitcoin_signature_2: sig_4,
2606 contents: unsigned_channel_announcement,
2608 let encoded_value = channel_announcement.encode();
2609 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a1735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap();
2610 if unknown_features_bits {
2611 target_value.append(&mut hex::decode("0002ffff").unwrap());
2613 target_value.append(&mut hex::decode("0000").unwrap());
2615 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2616 target_value.append(&mut hex::decode("00083a840000034d031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
2618 target_value.append(&mut hex::decode("0a00001400001e000028").unwrap());
2620 assert_eq!(encoded_value, target_value);
2624 fn encoding_channel_announcement() {
2625 do_encoding_channel_announcement(true, false);
2626 do_encoding_channel_announcement(false, true);
2627 do_encoding_channel_announcement(false, false);
2628 do_encoding_channel_announcement(true, true);
2631 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) {
2632 let secp_ctx = Secp256k1::new();
2633 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2634 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2635 let features = if unknown_features_bits {
2636 NodeFeatures::from_le_bytes(vec![0xFF, 0xFF])
2638 // Set to some features we may support
2639 NodeFeatures::from_le_bytes(vec![2 | 1 << 5])
2641 let mut addresses = Vec::new();
2643 addresses.push(msgs::NetAddress::IPv4 {
2644 addr: [255, 254, 253, 252],
2649 addresses.push(msgs::NetAddress::IPv6 {
2650 addr: [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240],
2655 addresses.push(msgs::NetAddress::OnionV2(
2656 [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 38, 7]
2660 addresses.push(msgs::NetAddress::OnionV3 {
2661 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],
2668 addresses.push(msgs::NetAddress::Hostname {
2669 hostname: Hostname::try_from(String::from("host")).unwrap(),
2673 let mut addr_len = 0;
2674 for addr in &addresses {
2675 addr_len += addr.len() + 1;
2677 let unsigned_node_announcement = msgs::UnsignedNodeAnnouncement {
2679 timestamp: 20190119,
2680 node_id: NodeId::from_pubkey(&pubkey_1),
2682 alias: NodeAlias([16;32]),
2684 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() },
2685 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() },
2687 addr_len += unsigned_node_announcement.excess_address_data.len() as u16;
2688 let node_announcement = msgs::NodeAnnouncement {
2690 contents: unsigned_node_announcement,
2692 let encoded_value = node_announcement.encode();
2693 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
2694 if unknown_features_bits {
2695 target_value.append(&mut hex::decode("0002ffff").unwrap());
2697 target_value.append(&mut hex::decode("000122").unwrap());
2699 target_value.append(&mut hex::decode("013413a7031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f2020201010101010101010101010101010101010101010101010101010101010101010").unwrap());
2700 target_value.append(&mut vec![(addr_len >> 8) as u8, addr_len as u8]);
2702 target_value.append(&mut hex::decode("01fffefdfc2607").unwrap());
2705 target_value.append(&mut hex::decode("02fffefdfcfbfaf9f8f7f6f5f4f3f2f1f02607").unwrap());
2708 target_value.append(&mut hex::decode("03fffefdfcfbfaf9f8f7f62607").unwrap());
2711 target_value.append(&mut hex::decode("04fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0efeeedecebeae9e8e7e6e5e4e3e2e1e00020102607").unwrap());
2714 target_value.append(&mut hex::decode("0504686f73742607").unwrap());
2716 if excess_address_data {
2717 target_value.append(&mut hex::decode("216c280b5395a2546e7e4b2663e04f811622f15a4f92e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d269").unwrap());
2720 target_value.append(&mut hex::decode("3b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
2722 assert_eq!(encoded_value, target_value);
2726 fn encoding_node_announcement() {
2727 do_encoding_node_announcement(true, true, true, true, true, true, true, true);
2728 do_encoding_node_announcement(false, false, false, false, false, false, false, false);
2729 do_encoding_node_announcement(false, true, false, false, false, false, false, false);
2730 do_encoding_node_announcement(false, false, true, false, false, false, false, false);
2731 do_encoding_node_announcement(false, false, false, true, false, false, false, false);
2732 do_encoding_node_announcement(false, false, false, false, true, false, false, false);
2733 do_encoding_node_announcement(false, false, false, false, false, true, false, false);
2734 do_encoding_node_announcement(false, false, false, false, false, false, true, false);
2735 do_encoding_node_announcement(false, true, false, true, false, false, true, false);
2736 do_encoding_node_announcement(false, false, true, false, true, false, false, false);
2739 fn do_encoding_channel_update(direction: bool, disable: bool, excess_data: bool) {
2740 let secp_ctx = Secp256k1::new();
2741 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2742 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2743 let unsigned_channel_update = msgs::UnsignedChannelUpdate {
2744 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2745 short_channel_id: 2316138423780173,
2746 timestamp: 20190119,
2747 flags: if direction { 1 } else { 0 } | if disable { 1 << 1 } else { 0 },
2748 cltv_expiry_delta: 144,
2749 htlc_minimum_msat: 1000000,
2750 htlc_maximum_msat: 131355275467161,
2751 fee_base_msat: 10000,
2752 fee_proportional_millionths: 20,
2753 excess_data: if excess_data { vec![0, 0, 0, 0, 59, 154, 202, 0] } else { Vec::new() }
2755 let channel_update = msgs::ChannelUpdate {
2757 contents: unsigned_channel_update
2759 let encoded_value = channel_update.encode();
2760 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
2761 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2762 target_value.append(&mut hex::decode("00083a840000034d013413a7").unwrap());
2763 target_value.append(&mut hex::decode("01").unwrap());
2764 target_value.append(&mut hex::decode("00").unwrap());
2766 let flag = target_value.last_mut().unwrap();
2770 let flag = target_value.last_mut().unwrap();
2771 *flag = *flag | 1 << 1;
2773 target_value.append(&mut hex::decode("009000000000000f42400000271000000014").unwrap());
2774 target_value.append(&mut hex::decode("0000777788889999").unwrap());
2776 target_value.append(&mut hex::decode("000000003b9aca00").unwrap());
2778 assert_eq!(encoded_value, target_value);
2782 fn encoding_channel_update() {
2783 do_encoding_channel_update(false, false, false);
2784 do_encoding_channel_update(false, false, true);
2785 do_encoding_channel_update(true, false, false);
2786 do_encoding_channel_update(true, false, true);
2787 do_encoding_channel_update(false, true, false);
2788 do_encoding_channel_update(false, true, true);
2789 do_encoding_channel_update(true, true, false);
2790 do_encoding_channel_update(true, true, true);
2793 fn do_encoding_open_channel(random_bit: bool, shutdown: bool, incl_chan_type: bool) {
2794 let secp_ctx = Secp256k1::new();
2795 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2796 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2797 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2798 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2799 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
2800 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
2801 let open_channel = msgs::OpenChannel {
2802 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2803 temporary_channel_id: [2; 32],
2804 funding_satoshis: 1311768467284833366,
2805 push_msat: 2536655962884945560,
2806 dust_limit_satoshis: 3608586615801332854,
2807 max_htlc_value_in_flight_msat: 8517154655701053848,
2808 channel_reserve_satoshis: 8665828695742877976,
2809 htlc_minimum_msat: 2316138423780173,
2810 feerate_per_kw: 821716,
2811 to_self_delay: 49340,
2812 max_accepted_htlcs: 49340,
2813 funding_pubkey: pubkey_1,
2814 revocation_basepoint: pubkey_2,
2815 payment_point: pubkey_3,
2816 delayed_payment_basepoint: pubkey_4,
2817 htlc_basepoint: pubkey_5,
2818 first_per_commitment_point: pubkey_6,
2819 channel_flags: if random_bit { 1 << 5 } else { 0 },
2820 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
2821 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
2823 let encoded_value = open_channel.encode();
2824 let mut target_value = Vec::new();
2825 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2826 target_value.append(&mut hex::decode("02020202020202020202020202020202020202020202020202020202020202021234567890123456233403289122369832144668701144767633030896203198784335490624111800083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
2828 target_value.append(&mut hex::decode("20").unwrap());
2830 target_value.append(&mut hex::decode("00").unwrap());
2833 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
2836 target_value.append(&mut hex::decode("0100").unwrap());
2838 assert_eq!(encoded_value, target_value);
2842 fn encoding_open_channel() {
2843 do_encoding_open_channel(false, false, false);
2844 do_encoding_open_channel(false, false, true);
2845 do_encoding_open_channel(false, true, false);
2846 do_encoding_open_channel(false, true, true);
2847 do_encoding_open_channel(true, false, false);
2848 do_encoding_open_channel(true, false, true);
2849 do_encoding_open_channel(true, true, false);
2850 do_encoding_open_channel(true, true, true);
2853 fn do_encoding_open_channelv2(random_bit: bool, shutdown: bool, incl_chan_type: bool, require_confirmed_inputs: bool) {
2854 let secp_ctx = Secp256k1::new();
2855 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2856 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2857 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2858 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2859 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
2860 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
2861 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
2862 let open_channelv2 = msgs::OpenChannelV2 {
2863 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2864 temporary_channel_id: [2; 32],
2865 funding_feerate_sat_per_1000_weight: 821716,
2866 commitment_feerate_sat_per_1000_weight: 821716,
2867 funding_satoshis: 1311768467284833366,
2868 dust_limit_satoshis: 3608586615801332854,
2869 max_htlc_value_in_flight_msat: 8517154655701053848,
2870 htlc_minimum_msat: 2316138423780173,
2871 to_self_delay: 49340,
2872 max_accepted_htlcs: 49340,
2873 locktime: 305419896,
2874 funding_pubkey: pubkey_1,
2875 revocation_basepoint: pubkey_2,
2876 payment_basepoint: pubkey_3,
2877 delayed_payment_basepoint: pubkey_4,
2878 htlc_basepoint: pubkey_5,
2879 first_per_commitment_point: pubkey_6,
2880 second_per_commitment_point: pubkey_7,
2881 channel_flags: if random_bit { 1 << 5 } else { 0 },
2882 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
2883 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
2884 require_confirmed_inputs: if require_confirmed_inputs { Some(()) } else { None },
2886 let encoded_value = open_channelv2.encode();
2887 let mut target_value = Vec::new();
2888 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2889 target_value.append(&mut hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap());
2890 target_value.append(&mut hex::decode("000c89d4").unwrap());
2891 target_value.append(&mut hex::decode("000c89d4").unwrap());
2892 target_value.append(&mut hex::decode("1234567890123456").unwrap());
2893 target_value.append(&mut hex::decode("3214466870114476").unwrap());
2894 target_value.append(&mut hex::decode("7633030896203198").unwrap());
2895 target_value.append(&mut hex::decode("00083a840000034d").unwrap());
2896 target_value.append(&mut hex::decode("c0bc").unwrap());
2897 target_value.append(&mut hex::decode("c0bc").unwrap());
2898 target_value.append(&mut hex::decode("12345678").unwrap());
2899 target_value.append(&mut hex::decode("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap());
2900 target_value.append(&mut hex::decode("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap());
2901 target_value.append(&mut hex::decode("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap());
2902 target_value.append(&mut hex::decode("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
2903 target_value.append(&mut hex::decode("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap());
2904 target_value.append(&mut hex::decode("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
2905 target_value.append(&mut hex::decode("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap());
2908 target_value.append(&mut hex::decode("20").unwrap());
2910 target_value.append(&mut hex::decode("00").unwrap());
2913 target_value.append(&mut hex::decode("001b").unwrap()); // Type 0 + Length 27
2914 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
2917 target_value.append(&mut hex::decode("0100").unwrap());
2919 if require_confirmed_inputs {
2920 target_value.append(&mut hex::decode("0200").unwrap());
2922 assert_eq!(encoded_value, target_value);
2926 fn encoding_open_channelv2() {
2927 do_encoding_open_channelv2(false, false, false, false);
2928 do_encoding_open_channelv2(false, false, false, true);
2929 do_encoding_open_channelv2(false, false, true, false);
2930 do_encoding_open_channelv2(false, false, true, true);
2931 do_encoding_open_channelv2(false, true, false, false);
2932 do_encoding_open_channelv2(false, true, false, true);
2933 do_encoding_open_channelv2(false, true, true, false);
2934 do_encoding_open_channelv2(false, true, true, true);
2935 do_encoding_open_channelv2(true, false, false, false);
2936 do_encoding_open_channelv2(true, false, false, true);
2937 do_encoding_open_channelv2(true, false, true, false);
2938 do_encoding_open_channelv2(true, false, true, true);
2939 do_encoding_open_channelv2(true, true, false, false);
2940 do_encoding_open_channelv2(true, true, false, true);
2941 do_encoding_open_channelv2(true, true, true, false);
2942 do_encoding_open_channelv2(true, true, true, true);
2945 fn do_encoding_accept_channel(shutdown: bool) {
2946 let secp_ctx = Secp256k1::new();
2947 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2948 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2949 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2950 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2951 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
2952 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
2953 let accept_channel = msgs::AcceptChannel {
2954 temporary_channel_id: [2; 32],
2955 dust_limit_satoshis: 1311768467284833366,
2956 max_htlc_value_in_flight_msat: 2536655962884945560,
2957 channel_reserve_satoshis: 3608586615801332854,
2958 htlc_minimum_msat: 2316138423780173,
2959 minimum_depth: 821716,
2960 to_self_delay: 49340,
2961 max_accepted_htlcs: 49340,
2962 funding_pubkey: pubkey_1,
2963 revocation_basepoint: pubkey_2,
2964 payment_point: pubkey_3,
2965 delayed_payment_basepoint: pubkey_4,
2966 htlc_basepoint: pubkey_5,
2967 first_per_commitment_point: pubkey_6,
2968 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
2971 next_local_nonce: None,
2973 let encoded_value = accept_channel.encode();
2974 let mut target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020212345678901234562334032891223698321446687011447600083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap();
2976 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
2978 assert_eq!(encoded_value, target_value);
2982 fn encoding_accept_channel() {
2983 do_encoding_accept_channel(false);
2984 do_encoding_accept_channel(true);
2987 fn do_encoding_accept_channelv2(shutdown: bool) {
2988 let secp_ctx = Secp256k1::new();
2989 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2990 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2991 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2992 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2993 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
2994 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
2995 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
2996 let accept_channelv2 = msgs::AcceptChannelV2 {
2997 temporary_channel_id: [2; 32],
2998 funding_satoshis: 1311768467284833366,
2999 dust_limit_satoshis: 1311768467284833366,
3000 max_htlc_value_in_flight_msat: 2536655962884945560,
3001 htlc_minimum_msat: 2316138423780173,
3002 minimum_depth: 821716,
3003 to_self_delay: 49340,
3004 max_accepted_htlcs: 49340,
3005 funding_pubkey: pubkey_1,
3006 revocation_basepoint: pubkey_2,
3007 payment_basepoint: pubkey_3,
3008 delayed_payment_basepoint: pubkey_4,
3009 htlc_basepoint: pubkey_5,
3010 first_per_commitment_point: pubkey_6,
3011 second_per_commitment_point: pubkey_7,
3012 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3014 require_confirmed_inputs: None,
3016 let encoded_value = accept_channelv2.encode();
3017 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // temporary_channel_id
3018 target_value.append(&mut hex::decode("1234567890123456").unwrap()); // funding_satoshis
3019 target_value.append(&mut hex::decode("1234567890123456").unwrap()); // dust_limit_satoshis
3020 target_value.append(&mut hex::decode("2334032891223698").unwrap()); // max_htlc_value_in_flight_msat
3021 target_value.append(&mut hex::decode("00083a840000034d").unwrap()); // htlc_minimum_msat
3022 target_value.append(&mut hex::decode("000c89d4").unwrap()); // minimum_depth
3023 target_value.append(&mut hex::decode("c0bc").unwrap()); // to_self_delay
3024 target_value.append(&mut hex::decode("c0bc").unwrap()); // max_accepted_htlcs
3025 target_value.append(&mut hex::decode("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap()); // funding_pubkey
3026 target_value.append(&mut hex::decode("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap()); // revocation_basepoint
3027 target_value.append(&mut hex::decode("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap()); // payment_basepoint
3028 target_value.append(&mut hex::decode("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap()); // delayed_payment_basepoint
3029 target_value.append(&mut hex::decode("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap()); // htlc_basepoint
3030 target_value.append(&mut hex::decode("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap()); // first_per_commitment_point
3031 target_value.append(&mut hex::decode("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap()); // second_per_commitment_point
3033 target_value.append(&mut hex::decode("001b").unwrap()); // Type 0 + Length 27
3034 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3036 assert_eq!(encoded_value, target_value);
3040 fn encoding_accept_channelv2() {
3041 do_encoding_accept_channelv2(false);
3042 do_encoding_accept_channelv2(true);
3046 fn encoding_funding_created() {
3047 let secp_ctx = Secp256k1::new();
3048 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3049 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3050 let funding_created = msgs::FundingCreated {
3051 temporary_channel_id: [2; 32],
3052 funding_txid: Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3053 funding_output_index: 255,
3056 partial_signature_with_nonce: None,
3058 next_local_nonce: None,
3060 let encoded_value = funding_created.encode();
3061 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202026e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c200ffd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3062 assert_eq!(encoded_value, target_value);
3066 fn encoding_funding_signed() {
3067 let secp_ctx = Secp256k1::new();
3068 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3069 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3070 let funding_signed = msgs::FundingSigned {
3071 channel_id: [2; 32],
3074 partial_signature_with_nonce: None,
3076 let encoded_value = funding_signed.encode();
3077 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3078 assert_eq!(encoded_value, target_value);
3082 fn encoding_channel_ready() {
3083 let secp_ctx = Secp256k1::new();
3084 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3085 let channel_ready = msgs::ChannelReady {
3086 channel_id: [2; 32],
3087 next_per_commitment_point: pubkey_1,
3088 short_channel_id_alias: None,
3090 let encoded_value = channel_ready.encode();
3091 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3092 assert_eq!(encoded_value, target_value);
3096 fn encoding_tx_add_input() {
3097 let tx_add_input = msgs::TxAddInput {
3098 channel_id: [2; 32],
3099 serial_id: 4886718345,
3100 prevtx: TransactionU16LenLimited::new(Transaction {
3102 lock_time: PackedLockTime(0),
3104 previous_output: OutPoint { txid: Txid::from_hex("305bab643ee297b8b6b76b320792c8223d55082122cb606bf89382146ced9c77").unwrap(), index: 2 }.into_bitcoin_outpoint(),
3105 script_sig: Script::new(),
3106 sequence: Sequence(0xfffffffd),
3107 witness: Witness::from_vec(vec![
3108 hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3109 hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3114 script_pubkey: Address::from_str("bc1qzlffunw52jav8vwdu5x3jfk6sr8u22rmq3xzw2").unwrap().script_pubkey(),
3118 script_pubkey: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().script_pubkey(),
3122 prevtx_out: 305419896,
3123 sequence: 305419896,
3125 let encoded_value = tx_add_input.encode();
3126 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000000012345678900de02000000000101779ced6c148293f86b60cb222108553d22c89207326bb7b6b897e23e64ab5b300200000000fdffffff0236dbc1000000000016001417d29e4dd454bac3b1cde50d1926da80cfc5287b9cbd03000000000016001436ec78d514df462da95e6a00c24daa8915362d420247304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701210301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944000000001234567812345678").unwrap();
3127 assert_eq!(encoded_value, target_value);
3131 fn encoding_tx_add_output() {
3132 let tx_add_output = msgs::TxAddOutput {
3133 channel_id: [2; 32],
3134 serial_id: 4886718345,
3136 script: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().script_pubkey(),
3138 let encoded_value = tx_add_output.encode();
3139 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000000012345678900000001234567890016001436ec78d514df462da95e6a00c24daa8915362d42").unwrap();
3140 assert_eq!(encoded_value, target_value);
3144 fn encoding_tx_remove_input() {
3145 let tx_remove_input = msgs::TxRemoveInput {
3146 channel_id: [2; 32],
3147 serial_id: 4886718345,
3149 let encoded_value = tx_remove_input.encode();
3150 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3151 assert_eq!(encoded_value, target_value);
3155 fn encoding_tx_remove_output() {
3156 let tx_remove_output = msgs::TxRemoveOutput {
3157 channel_id: [2; 32],
3158 serial_id: 4886718345,
3160 let encoded_value = tx_remove_output.encode();
3161 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3162 assert_eq!(encoded_value, target_value);
3166 fn encoding_tx_complete() {
3167 let tx_complete = msgs::TxComplete {
3168 channel_id: [2; 32],
3170 let encoded_value = tx_complete.encode();
3171 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3172 assert_eq!(encoded_value, target_value);
3176 fn encoding_tx_signatures() {
3177 let tx_signatures = msgs::TxSignatures {
3178 channel_id: [2; 32],
3179 tx_hash: Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3181 Witness::from_vec(vec![
3182 hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3183 hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3184 Witness::from_vec(vec![
3185 hex::decode("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap(),
3186 hex::decode("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap()]),
3189 let encoded_value = tx_signatures.encode();
3190 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3191 target_value.append(&mut hex::decode("6e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c2").unwrap()); // tx_hash (sha256) (big endian byte order)
3192 target_value.append(&mut hex::decode("0002").unwrap()); // num_witnesses (u16)
3194 target_value.append(&mut hex::decode("006b").unwrap()); // len of witness_data
3195 target_value.append(&mut hex::decode("02").unwrap()); // num_witness_elements (VarInt)
3196 target_value.append(&mut hex::decode("47").unwrap()); // len of witness element data (VarInt)
3197 target_value.append(&mut hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap());
3198 target_value.append(&mut hex::decode("21").unwrap()); // len of witness element data (VarInt)
3199 target_value.append(&mut hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap());
3201 target_value.append(&mut hex::decode("006c").unwrap()); // len of witness_data
3202 target_value.append(&mut hex::decode("02").unwrap()); // num_witness_elements (VarInt)
3203 target_value.append(&mut hex::decode("48").unwrap()); // len of witness element data (VarInt)
3204 target_value.append(&mut hex::decode("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap());
3205 target_value.append(&mut hex::decode("21").unwrap()); // len of witness element data (VarInt)
3206 target_value.append(&mut hex::decode("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap());
3207 assert_eq!(encoded_value, target_value);
3210 fn do_encoding_tx_init_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3211 let tx_init_rbf = msgs::TxInitRbf {
3212 channel_id: [2; 32],
3213 locktime: 305419896,
3214 feerate_sat_per_1000_weight: 20190119,
3215 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3217 let encoded_value = tx_init_rbf.encode();
3218 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3219 target_value.append(&mut hex::decode("12345678").unwrap()); // locktime
3220 target_value.append(&mut hex::decode("013413a7").unwrap()); // feerate_sat_per_1000_weight
3221 if let Some((_, target)) = funding_value_with_hex_target {
3222 target_value.push(0x00); // Type
3223 target_value.push(target.len() as u8 / 2); // Length
3224 target_value.append(&mut hex::decode(target).unwrap()); // Value (i64)
3226 assert_eq!(encoded_value, target_value);
3230 fn encoding_tx_init_rbf() {
3231 do_encoding_tx_init_rbf(Some((1311768467284833366, "1234567890123456")));
3232 do_encoding_tx_init_rbf(Some((13117684672, "000000030DDFFBC0")));
3233 do_encoding_tx_init_rbf(None);
3236 fn do_encoding_tx_ack_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3237 let tx_ack_rbf = msgs::TxAckRbf {
3238 channel_id: [2; 32],
3239 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3241 let encoded_value = tx_ack_rbf.encode();
3242 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3243 if let Some((_, target)) = funding_value_with_hex_target {
3244 target_value.push(0x00); // Type
3245 target_value.push(target.len() as u8 / 2); // Length
3246 target_value.append(&mut hex::decode(target).unwrap()); // Value (i64)
3248 assert_eq!(encoded_value, target_value);
3252 fn encoding_tx_ack_rbf() {
3253 do_encoding_tx_ack_rbf(Some((1311768467284833366, "1234567890123456")));
3254 do_encoding_tx_ack_rbf(Some((13117684672, "000000030DDFFBC0")));
3255 do_encoding_tx_ack_rbf(None);
3259 fn encoding_tx_abort() {
3260 let tx_abort = msgs::TxAbort {
3261 channel_id: [2; 32],
3262 data: hex::decode("54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap(),
3264 let encoded_value = tx_abort.encode();
3265 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202002C54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap();
3266 assert_eq!(encoded_value, target_value);
3269 fn do_encoding_shutdown(script_type: u8) {
3270 let secp_ctx = Secp256k1::new();
3271 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3272 let script = Builder::new().push_opcode(opcodes::OP_TRUE).into_script();
3273 let shutdown = msgs::Shutdown {
3274 channel_id: [2; 32],
3276 if script_type == 1 { Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey() }
3277 else if script_type == 2 { Address::p2sh(&script, Network::Testnet).unwrap().script_pubkey() }
3278 else if script_type == 3 { Address::p2wpkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).unwrap().script_pubkey() }
3279 else { Address::p2wsh(&script, Network::Testnet).script_pubkey() },
3281 let encoded_value = shutdown.encode();
3282 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3283 if script_type == 1 {
3284 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3285 } else if script_type == 2 {
3286 target_value.append(&mut hex::decode("0017a914da1745e9b549bd0bfa1a569971c77eba30cd5a4b87").unwrap());
3287 } else if script_type == 3 {
3288 target_value.append(&mut hex::decode("0016001479b000887626b294a914501a4cd226b58b235983").unwrap());
3289 } else if script_type == 4 {
3290 target_value.append(&mut hex::decode("002200204ae81572f06e1b88fd5ced7a1a000945432e83e1551e6f721ee9c00b8cc33260").unwrap());
3292 assert_eq!(encoded_value, target_value);
3296 fn encoding_shutdown() {
3297 do_encoding_shutdown(1);
3298 do_encoding_shutdown(2);
3299 do_encoding_shutdown(3);
3300 do_encoding_shutdown(4);
3304 fn encoding_closing_signed() {
3305 let secp_ctx = Secp256k1::new();
3306 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3307 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3308 let closing_signed = msgs::ClosingSigned {
3309 channel_id: [2; 32],
3310 fee_satoshis: 2316138423780173,
3314 let encoded_value = closing_signed.encode();
3315 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3316 assert_eq!(encoded_value, target_value);
3317 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value)).unwrap(), closing_signed);
3319 let closing_signed_with_range = msgs::ClosingSigned {
3320 channel_id: [2; 32],
3321 fee_satoshis: 2316138423780173,
3323 fee_range: Some(msgs::ClosingSignedFeeRange {
3324 min_fee_satoshis: 0xdeadbeef,
3325 max_fee_satoshis: 0x1badcafe01234567,
3328 let encoded_value_with_range = closing_signed_with_range.encode();
3329 let target_value_with_range = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a011000000000deadbeef1badcafe01234567").unwrap();
3330 assert_eq!(encoded_value_with_range, target_value_with_range);
3331 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value_with_range)).unwrap(),
3332 closing_signed_with_range);
3336 fn encoding_update_add_htlc() {
3337 let secp_ctx = Secp256k1::new();
3338 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3339 let onion_routing_packet = msgs::OnionPacket {
3341 public_key: Ok(pubkey_1),
3342 hop_data: [1; 20*65],
3345 let update_add_htlc = msgs::UpdateAddHTLC {
3346 channel_id: [2; 32],
3347 htlc_id: 2316138423780173,
3348 amount_msat: 3608586615801332854,
3349 payment_hash: PaymentHash([1; 32]),
3350 cltv_expiry: 821716,
3351 onion_routing_packet,
3352 skimmed_fee_msat: None,
3354 let encoded_value = update_add_htlc.encode();
3355 let target_value = hex::decode("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").unwrap();
3356 assert_eq!(encoded_value, target_value);
3360 fn encoding_update_fulfill_htlc() {
3361 let update_fulfill_htlc = msgs::UpdateFulfillHTLC {
3362 channel_id: [2; 32],
3363 htlc_id: 2316138423780173,
3364 payment_preimage: PaymentPreimage([1; 32]),
3366 let encoded_value = update_fulfill_htlc.encode();
3367 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d0101010101010101010101010101010101010101010101010101010101010101").unwrap();
3368 assert_eq!(encoded_value, target_value);
3372 fn encoding_update_fail_htlc() {
3373 let reason = OnionErrorPacket {
3374 data: [1; 32].to_vec(),
3376 let update_fail_htlc = msgs::UpdateFailHTLC {
3377 channel_id: [2; 32],
3378 htlc_id: 2316138423780173,
3381 let encoded_value = update_fail_htlc.encode();
3382 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d00200101010101010101010101010101010101010101010101010101010101010101").unwrap();
3383 assert_eq!(encoded_value, target_value);
3387 fn encoding_update_fail_malformed_htlc() {
3388 let update_fail_malformed_htlc = msgs::UpdateFailMalformedHTLC {
3389 channel_id: [2; 32],
3390 htlc_id: 2316138423780173,
3391 sha256_of_onion: [1; 32],
3394 let encoded_value = update_fail_malformed_htlc.encode();
3395 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d010101010101010101010101010101010101010101010101010101010101010100ff").unwrap();
3396 assert_eq!(encoded_value, target_value);
3399 fn do_encoding_commitment_signed(htlcs: bool) {
3400 let secp_ctx = Secp256k1::new();
3401 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3402 let (privkey_2, _) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3403 let (privkey_3, _) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3404 let (privkey_4, _) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3405 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3406 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
3407 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
3408 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
3409 let commitment_signed = msgs::CommitmentSigned {
3410 channel_id: [2; 32],
3412 htlc_signatures: if htlcs { vec![sig_2, sig_3, sig_4] } else { Vec::new() },
3414 partial_signature_with_nonce: None,
3416 let encoded_value = commitment_signed.encode();
3417 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3419 target_value.append(&mut hex::decode("00031735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
3421 target_value.append(&mut hex::decode("0000").unwrap());
3423 assert_eq!(encoded_value, target_value);
3427 fn encoding_commitment_signed() {
3428 do_encoding_commitment_signed(true);
3429 do_encoding_commitment_signed(false);
3433 fn encoding_revoke_and_ack() {
3434 let secp_ctx = Secp256k1::new();
3435 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3436 let raa = msgs::RevokeAndACK {
3437 channel_id: [2; 32],
3438 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],
3439 next_per_commitment_point: pubkey_1,
3441 next_local_nonce: None,
3443 let encoded_value = raa.encode();
3444 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020101010101010101010101010101010101010101010101010101010101010101031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3445 assert_eq!(encoded_value, target_value);
3449 fn encoding_update_fee() {
3450 let update_fee = msgs::UpdateFee {
3451 channel_id: [2; 32],
3452 feerate_per_kw: 20190119,
3454 let encoded_value = update_fee.encode();
3455 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202013413a7").unwrap();
3456 assert_eq!(encoded_value, target_value);
3460 fn encoding_init() {
3461 let mainnet_hash = ChainHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap();
3462 assert_eq!(msgs::Init {
3463 features: InitFeatures::from_le_bytes(vec![0xFF, 0xFF, 0xFF]),
3464 networks: Some(vec![mainnet_hash]),
3465 remote_network_address: None,
3466 }.encode(), hex::decode("00023fff0003ffffff01206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3467 assert_eq!(msgs::Init {
3468 features: InitFeatures::from_le_bytes(vec![0xFF]),
3470 remote_network_address: None,
3471 }.encode(), hex::decode("0001ff0001ff").unwrap());
3472 assert_eq!(msgs::Init {
3473 features: InitFeatures::from_le_bytes(vec![]),
3474 networks: Some(vec![mainnet_hash]),
3475 remote_network_address: None,
3476 }.encode(), hex::decode("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3477 assert_eq!(msgs::Init {
3478 features: InitFeatures::from_le_bytes(vec![]),
3479 networks: Some(vec![ChainHash::from(&[1; 32][..]), ChainHash::from(&[2; 32][..])]),
3480 remote_network_address: None,
3481 }.encode(), hex::decode("00000000014001010101010101010101010101010101010101010101010101010101010101010202020202020202020202020202020202020202020202020202020202020202").unwrap());
3482 let init_msg = msgs::Init { features: InitFeatures::from_le_bytes(vec![]),
3483 networks: Some(vec![mainnet_hash]),
3484 remote_network_address: Some(msgs::NetAddress::IPv4 {
3485 addr: [127, 0, 0, 1],
3489 let encoded_value = init_msg.encode();
3490 let target_value = hex::decode("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d61900000000000307017f00000103e8").unwrap();
3491 assert_eq!(encoded_value, target_value);
3492 assert_eq!(msgs::Init::read(&mut Cursor::new(&target_value)).unwrap(), init_msg);
3496 fn encoding_error() {
3497 let error = msgs::ErrorMessage {
3498 channel_id: [2; 32],
3499 data: String::from("rust-lightning"),
3501 let encoded_value = error.encode();
3502 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3503 assert_eq!(encoded_value, target_value);
3507 fn encoding_warning() {
3508 let error = msgs::WarningMessage {
3509 channel_id: [2; 32],
3510 data: String::from("rust-lightning"),
3512 let encoded_value = error.encode();
3513 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3514 assert_eq!(encoded_value, target_value);
3518 fn encoding_ping() {
3519 let ping = msgs::Ping {
3523 let encoded_value = ping.encode();
3524 let target_value = hex::decode("0040004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3525 assert_eq!(encoded_value, target_value);
3529 fn encoding_pong() {
3530 let pong = msgs::Pong {
3533 let encoded_value = pong.encode();
3534 let target_value = hex::decode("004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3535 assert_eq!(encoded_value, target_value);
3539 fn encoding_nonfinal_onion_hop_data() {
3540 let outbound_msg = msgs::OutboundOnionPayload::Forward {
3541 short_channel_id: 0xdeadbeef1bad1dea,
3542 amt_to_forward: 0x0badf00d01020304,
3543 outgoing_cltv_value: 0xffffffff,
3545 let encoded_value = outbound_msg.encode();
3546 let target_value = hex::decode("1a02080badf00d010203040404ffffffff0608deadbeef1bad1dea").unwrap();
3547 assert_eq!(encoded_value, target_value);
3549 let inbound_msg = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3550 if let msgs::InboundOnionPayload::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } = inbound_msg {
3551 assert_eq!(short_channel_id, 0xdeadbeef1bad1dea);
3552 assert_eq!(amt_to_forward, 0x0badf00d01020304);
3553 assert_eq!(outgoing_cltv_value, 0xffffffff);
3554 } else { panic!(); }
3558 fn encoding_final_onion_hop_data() {
3559 let outbound_msg = msgs::OutboundOnionPayload::Receive {
3561 payment_metadata: None,
3562 keysend_preimage: None,
3563 amt_msat: 0x0badf00d01020304,
3564 outgoing_cltv_value: 0xffffffff,
3566 let encoded_value = outbound_msg.encode();
3567 let target_value = hex::decode("1002080badf00d010203040404ffffffff").unwrap();
3568 assert_eq!(encoded_value, target_value);
3570 let inbound_msg = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3571 if let msgs::InboundOnionPayload::Receive { payment_data: None, amt_msat, outgoing_cltv_value, .. } = inbound_msg {
3572 assert_eq!(amt_msat, 0x0badf00d01020304);
3573 assert_eq!(outgoing_cltv_value, 0xffffffff);
3574 } else { panic!(); }
3578 fn encoding_final_onion_hop_data_with_secret() {
3579 let expected_payment_secret = PaymentSecret([0x42u8; 32]);
3580 let outbound_msg = msgs::OutboundOnionPayload::Receive {
3581 payment_data: Some(FinalOnionHopData {
3582 payment_secret: expected_payment_secret,
3583 total_msat: 0x1badca1f
3585 payment_metadata: None,
3586 keysend_preimage: None,
3587 amt_msat: 0x0badf00d01020304,
3588 outgoing_cltv_value: 0xffffffff,
3590 let encoded_value = outbound_msg.encode();
3591 let target_value = hex::decode("3602080badf00d010203040404ffffffff082442424242424242424242424242424242424242424242424242424242424242421badca1f").unwrap();
3592 assert_eq!(encoded_value, target_value);
3594 let inbound_msg = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3595 if let msgs::InboundOnionPayload::Receive {
3596 payment_data: Some(FinalOnionHopData {
3598 total_msat: 0x1badca1f
3600 amt_msat, outgoing_cltv_value,
3601 payment_metadata: None,
3602 keysend_preimage: None,
3604 assert_eq!(payment_secret, expected_payment_secret);
3605 assert_eq!(amt_msat, 0x0badf00d01020304);
3606 assert_eq!(outgoing_cltv_value, 0xffffffff);
3607 } else { panic!(); }
3611 fn query_channel_range_end_blocknum() {
3612 let tests: Vec<(u32, u32, u32)> = vec![
3613 (10000, 1500, 11500),
3614 (0, 0xffffffff, 0xffffffff),
3615 (1, 0xffffffff, 0xffffffff),
3618 for (first_blocknum, number_of_blocks, expected) in tests.into_iter() {
3619 let sut = msgs::QueryChannelRange {
3620 chain_hash: BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap(),
3624 assert_eq!(sut.end_blocknum(), expected);
3629 fn encoding_query_channel_range() {
3630 let mut query_channel_range = msgs::QueryChannelRange {
3631 chain_hash: BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap(),
3632 first_blocknum: 100000,
3633 number_of_blocks: 1500,
3635 let encoded_value = query_channel_range.encode();
3636 let target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206000186a0000005dc").unwrap();
3637 assert_eq!(encoded_value, target_value);
3639 query_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3640 assert_eq!(query_channel_range.first_blocknum, 100000);
3641 assert_eq!(query_channel_range.number_of_blocks, 1500);
3645 fn encoding_reply_channel_range() {
3646 do_encoding_reply_channel_range(0);
3647 do_encoding_reply_channel_range(1);
3650 fn do_encoding_reply_channel_range(encoding_type: u8) {
3651 let mut target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206000b8a06000005dc01").unwrap();
3652 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3653 let mut reply_channel_range = msgs::ReplyChannelRange {
3654 chain_hash: expected_chain_hash,
3655 first_blocknum: 756230,
3656 number_of_blocks: 1500,
3657 sync_complete: true,
3658 short_channel_ids: vec![0x000000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
3661 if encoding_type == 0 {
3662 target_value.append(&mut hex::decode("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
3663 let encoded_value = reply_channel_range.encode();
3664 assert_eq!(encoded_value, target_value);
3666 reply_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3667 assert_eq!(reply_channel_range.chain_hash, expected_chain_hash);
3668 assert_eq!(reply_channel_range.first_blocknum, 756230);
3669 assert_eq!(reply_channel_range.number_of_blocks, 1500);
3670 assert_eq!(reply_channel_range.sync_complete, true);
3671 assert_eq!(reply_channel_range.short_channel_ids[0], 0x000000000000008e);
3672 assert_eq!(reply_channel_range.short_channel_ids[1], 0x0000000000003c69);
3673 assert_eq!(reply_channel_range.short_channel_ids[2], 0x000000000045a6c4);
3675 target_value.append(&mut hex::decode("001601789c636000833e08659309a65878be010010a9023a").unwrap());
3676 let result: Result<msgs::ReplyChannelRange, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
3677 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
3682 fn encoding_query_short_channel_ids() {
3683 do_encoding_query_short_channel_ids(0);
3684 do_encoding_query_short_channel_ids(1);
3687 fn do_encoding_query_short_channel_ids(encoding_type: u8) {
3688 let mut target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206").unwrap();
3689 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3690 let mut query_short_channel_ids = msgs::QueryShortChannelIds {
3691 chain_hash: expected_chain_hash,
3692 short_channel_ids: vec![0x0000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
3695 if encoding_type == 0 {
3696 target_value.append(&mut hex::decode("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
3697 let encoded_value = query_short_channel_ids.encode();
3698 assert_eq!(encoded_value, target_value);
3700 query_short_channel_ids = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3701 assert_eq!(query_short_channel_ids.chain_hash, expected_chain_hash);
3702 assert_eq!(query_short_channel_ids.short_channel_ids[0], 0x000000000000008e);
3703 assert_eq!(query_short_channel_ids.short_channel_ids[1], 0x0000000000003c69);
3704 assert_eq!(query_short_channel_ids.short_channel_ids[2], 0x000000000045a6c4);
3706 target_value.append(&mut hex::decode("001601789c636000833e08659309a65878be010010a9023a").unwrap());
3707 let result: Result<msgs::QueryShortChannelIds, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
3708 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
3713 fn encoding_reply_short_channel_ids_end() {
3714 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3715 let mut reply_short_channel_ids_end = msgs::ReplyShortChannelIdsEnd {
3716 chain_hash: expected_chain_hash,
3717 full_information: true,
3719 let encoded_value = reply_short_channel_ids_end.encode();
3720 let target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e220601").unwrap();
3721 assert_eq!(encoded_value, target_value);
3723 reply_short_channel_ids_end = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3724 assert_eq!(reply_short_channel_ids_end.chain_hash, expected_chain_hash);
3725 assert_eq!(reply_short_channel_ids_end.full_information, true);
3729 fn encoding_gossip_timestamp_filter(){
3730 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3731 let mut gossip_timestamp_filter = msgs::GossipTimestampFilter {
3732 chain_hash: expected_chain_hash,
3733 first_timestamp: 1590000000,
3734 timestamp_range: 0xffff_ffff,
3736 let encoded_value = gossip_timestamp_filter.encode();
3737 let target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e22065ec57980ffffffff").unwrap();
3738 assert_eq!(encoded_value, target_value);
3740 gossip_timestamp_filter = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3741 assert_eq!(gossip_timestamp_filter.chain_hash, expected_chain_hash);
3742 assert_eq!(gossip_timestamp_filter.first_timestamp, 1590000000);
3743 assert_eq!(gossip_timestamp_filter.timestamp_range, 0xffff_ffff);
3747 fn decode_onion_hop_data_len_as_bigsize() {
3748 // Tests that we can decode an onion payload that is >253 bytes.
3749 // Previously, receiving a payload of this size could've caused us to fail to decode a valid
3750 // payload, because we were decoding the length (a BigSize, big-endian) as a VarInt
3753 // Encode a test onion payload with a big custom TLV such that it's >253 bytes, forcing the
3754 // payload length to be encoded over multiple bytes rather than a single u8.
3755 let big_payload = encode_big_payload().unwrap();
3756 let mut rd = Cursor::new(&big_payload[..]);
3757 <msgs::InboundOnionPayload as Readable>::read(&mut rd).unwrap();
3759 // see above test, needs to be a separate method for use of the serialization macros.
3760 fn encode_big_payload() -> Result<Vec<u8>, io::Error> {
3761 use crate::util::ser::HighZeroBytesDroppedBigSize;
3762 let payload = msgs::OutboundOnionPayload::Forward {
3763 short_channel_id: 0xdeadbeef1bad1dea,
3764 amt_to_forward: 1000,
3765 outgoing_cltv_value: 0xffffffff,
3767 let mut encoded_payload = Vec::new();
3768 let test_bytes = vec![42u8; 1000];
3769 if let msgs::OutboundOnionPayload::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } = payload {
3770 _encode_varint_length_prefixed_tlv!(&mut encoded_payload, {
3771 (1, test_bytes, required_vec),
3772 (2, HighZeroBytesDroppedBigSize(amt_to_forward), required),
3773 (4, HighZeroBytesDroppedBigSize(outgoing_cltv_value), required),
3774 (6, short_channel_id, required)