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, BigSize};
48 use crate::ln::{PaymentPreimage, PaymentHash, PaymentSecret};
50 use crate::routing::gossip::{NodeAlias, NodeId};
52 /// 21 million * 10^8 * 1000
53 pub(crate) const MAX_VALUE_MSAT: u64 = 21_000_000_0000_0000_000;
56 /// A partial signature that also contains the Musig2 nonce its signer used
57 #[derive(Clone, Debug, PartialEq, Eq)]
58 pub struct PartialSignatureWithNonce(pub musig2::types::PartialSignature, pub musig2::types::PublicNonce);
60 /// An error in decoding a message or struct.
61 #[derive(Clone, Debug, PartialEq, Eq)]
62 pub enum DecodeError {
63 /// A version byte specified something we don't know how to handle.
65 /// Includes unknown realm byte in an onion hop data packet.
67 /// Unknown feature mandating we fail to parse message (e.g., TLV with an even, unknown type)
68 UnknownRequiredFeature,
69 /// Value was invalid.
71 /// For example, a byte which was supposed to be a bool was something other than a 0
72 /// or 1, a public key/private key/signature was invalid, text wasn't UTF-8, TLV was
73 /// syntactically incorrect, etc.
75 /// The buffer to be read was too short.
77 /// A length descriptor in the packet didn't describe the later data correctly.
79 /// Error from [`std::io`].
81 /// The message included zlib-compressed values, which we don't support.
82 UnsupportedCompression,
85 /// An [`init`] message to be sent to or received from a peer.
87 /// [`init`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-init-message
88 #[derive(Clone, Debug, PartialEq, Eq)]
90 /// The relevant features which the sender supports.
91 pub features: InitFeatures,
92 /// Indicates chains the sender is interested in.
94 /// If there are no common chains, the connection will be closed.
95 pub networks: Option<Vec<ChainHash>>,
96 /// The receipient's network address.
98 /// This adds the option to report a remote IP address back to a connecting peer using the init
99 /// message. A node can decide to use that information to discover a potential update to its
100 /// public IPv4 address (NAT) and use that for a [`NodeAnnouncement`] update message containing
102 pub remote_network_address: Option<NetAddress>,
105 /// An [`error`] message to be sent to or received from a peer.
107 /// [`error`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-error-and-warning-messages
108 #[derive(Clone, Debug, PartialEq, Eq)]
109 pub struct ErrorMessage {
110 /// The channel ID involved in the error.
112 /// All-0s indicates a general error unrelated to a specific channel, after which all channels
113 /// with the sending peer should be closed.
114 pub channel_id: [u8; 32],
115 /// A possibly human-readable error description.
117 /// The string should be sanitized before it is used (e.g., emitted to logs or printed to
118 /// `stdout`). Otherwise, a well crafted error message may trigger a security vulnerability in
119 /// the terminal emulator or the logging subsystem.
123 /// A [`warning`] message to be sent to or received from a peer.
125 /// [`warning`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-error-and-warning-messages
126 #[derive(Clone, Debug, PartialEq, Eq)]
127 pub struct WarningMessage {
128 /// The channel ID involved in the warning.
130 /// All-0s indicates a warning unrelated to a specific channel.
131 pub channel_id: [u8; 32],
132 /// A possibly human-readable warning description.
134 /// The string should be sanitized before it is used (e.g. emitted to logs or printed to
135 /// stdout). Otherwise, a well crafted error message may trigger a security vulnerability in
136 /// the terminal emulator or the logging subsystem.
140 /// A [`ping`] message to be sent to or received from a peer.
142 /// [`ping`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-ping-and-pong-messages
143 #[derive(Clone, Debug, PartialEq, Eq)]
145 /// The desired response length.
147 /// The ping packet size.
149 /// This field is not sent on the wire. byteslen zeros are sent.
153 /// A [`pong`] message to be sent to or received from a peer.
155 /// [`pong`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-ping-and-pong-messages
156 #[derive(Clone, Debug, PartialEq, Eq)]
158 /// The pong packet size.
160 /// This field is not sent on the wire. byteslen zeros are sent.
164 /// An [`open_channel`] message to be sent to or received from a peer.
166 /// Used in V1 channel establishment
168 /// [`open_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-open_channel-message
169 #[derive(Clone, Debug, PartialEq, Eq)]
170 pub struct OpenChannel {
171 /// The genesis hash of the blockchain where the channel is to be opened
172 pub chain_hash: BlockHash,
173 /// A temporary channel ID, until the funding outpoint is announced
174 pub temporary_channel_id: [u8; 32],
175 /// The channel value
176 pub funding_satoshis: u64,
177 /// The amount to push to the counterparty as part of the open, in milli-satoshi
179 /// The threshold below which outputs on transactions broadcast by sender will be omitted
180 pub dust_limit_satoshis: u64,
181 /// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
182 pub max_htlc_value_in_flight_msat: u64,
183 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
184 pub channel_reserve_satoshis: u64,
185 /// The minimum HTLC size incoming to sender, in milli-satoshi
186 pub htlc_minimum_msat: u64,
187 /// The feerate per 1000-weight of sender generated transactions, until updated by
189 pub feerate_per_kw: u32,
190 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if
191 /// they broadcast a commitment transaction
192 pub to_self_delay: u16,
193 /// The maximum number of inbound HTLCs towards sender
194 pub max_accepted_htlcs: u16,
195 /// The sender's key controlling the funding transaction
196 pub funding_pubkey: PublicKey,
197 /// Used to derive a revocation key for transactions broadcast by counterparty
198 pub revocation_basepoint: PublicKey,
199 /// A payment key to sender for transactions broadcast by counterparty
200 pub payment_point: PublicKey,
201 /// Used to derive a payment key to sender for transactions broadcast by sender
202 pub delayed_payment_basepoint: PublicKey,
203 /// Used to derive an HTLC payment key to sender
204 pub htlc_basepoint: PublicKey,
205 /// The first to-be-broadcast-by-sender transaction's per commitment point
206 pub first_per_commitment_point: PublicKey,
207 /// The channel flags to be used
208 pub channel_flags: u8,
209 /// A request to pre-set the to-sender output's `scriptPubkey` for when we collaboratively close
210 pub shutdown_scriptpubkey: Option<Script>,
211 /// The channel type that this channel will represent
213 /// If this is `None`, we derive the channel type from the intersection of our
214 /// feature bits with our counterparty's feature bits from the [`Init`] message.
215 pub channel_type: Option<ChannelTypeFeatures>,
218 /// An open_channel2 message to be sent by or received from the channel initiator.
220 /// Used in V2 channel establishment
222 // TODO(dual_funding): Add spec link for `open_channel2`.
223 #[derive(Clone, Debug, PartialEq, Eq)]
224 pub struct OpenChannelV2 {
225 /// The genesis hash of the blockchain where the channel is to be opened
226 pub chain_hash: BlockHash,
227 /// A temporary channel ID derived using a zeroed out value for the channel acceptor's revocation basepoint
228 pub temporary_channel_id: [u8; 32],
229 /// The feerate for the funding transaction set by the channel initiator
230 pub funding_feerate_sat_per_1000_weight: u32,
231 /// The feerate for the commitment transaction set by the channel initiator
232 pub commitment_feerate_sat_per_1000_weight: u32,
233 /// Part of the channel value contributed by the channel initiator
234 pub funding_satoshis: u64,
235 /// The threshold below which outputs on transactions broadcast by the channel initiator will be
237 pub dust_limit_satoshis: u64,
238 /// The maximum inbound HTLC value in flight towards channel initiator, in milli-satoshi
239 pub max_htlc_value_in_flight_msat: u64,
240 /// The minimum HTLC size incoming to channel initiator, in milli-satoshi
241 pub htlc_minimum_msat: u64,
242 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
243 /// broadcast a commitment transaction
244 pub to_self_delay: u16,
245 /// The maximum number of inbound HTLCs towards channel initiator
246 pub max_accepted_htlcs: u16,
247 /// The locktime for the funding transaction
249 /// The channel initiator's key controlling the funding transaction
250 pub funding_pubkey: PublicKey,
251 /// Used to derive a revocation key for transactions broadcast by counterparty
252 pub revocation_basepoint: PublicKey,
253 /// A payment key to channel initiator for transactions broadcast by counterparty
254 pub payment_basepoint: PublicKey,
255 /// Used to derive a payment key to channel initiator for transactions broadcast by channel
257 pub delayed_payment_basepoint: PublicKey,
258 /// Used to derive an HTLC payment key to channel initiator
259 pub htlc_basepoint: PublicKey,
260 /// The first to-be-broadcast-by-channel-initiator transaction's per commitment point
261 pub first_per_commitment_point: PublicKey,
262 /// The second to-be-broadcast-by-channel-initiator transaction's per commitment point
263 pub second_per_commitment_point: PublicKey,
265 pub channel_flags: u8,
266 /// Optionally, a request to pre-set the to-channel-initiator output's scriptPubkey for when we
267 /// collaboratively close
268 pub shutdown_scriptpubkey: Option<Script>,
269 /// The channel type that this channel will represent. If none is set, we derive the channel
270 /// type from the intersection of our feature bits with our counterparty's feature bits from
271 /// the Init message.
272 pub channel_type: Option<ChannelTypeFeatures>,
273 /// Optionally, a requirement that only confirmed inputs can be added
274 pub require_confirmed_inputs: Option<()>,
277 /// An [`accept_channel`] message to be sent to or received from a peer.
279 /// Used in V1 channel establishment
281 /// [`accept_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-accept_channel-message
282 #[derive(Clone, Debug, PartialEq, Eq)]
283 pub struct AcceptChannel {
284 /// A temporary channel ID, until the funding outpoint is announced
285 pub temporary_channel_id: [u8; 32],
286 /// The threshold below which outputs on transactions broadcast by sender will be omitted
287 pub dust_limit_satoshis: u64,
288 /// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
289 pub max_htlc_value_in_flight_msat: u64,
290 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
291 pub channel_reserve_satoshis: u64,
292 /// The minimum HTLC size incoming to sender, in milli-satoshi
293 pub htlc_minimum_msat: u64,
294 /// Minimum depth of the funding transaction before the channel is considered open
295 pub minimum_depth: u32,
296 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they broadcast a commitment transaction
297 pub to_self_delay: u16,
298 /// The maximum number of inbound HTLCs towards sender
299 pub max_accepted_htlcs: u16,
300 /// The sender's key controlling the funding transaction
301 pub funding_pubkey: PublicKey,
302 /// Used to derive a revocation key for transactions broadcast by counterparty
303 pub revocation_basepoint: PublicKey,
304 /// A payment key to sender for transactions broadcast by counterparty
305 pub payment_point: PublicKey,
306 /// Used to derive a payment key to sender for transactions broadcast by sender
307 pub delayed_payment_basepoint: PublicKey,
308 /// Used to derive an HTLC payment key to sender for transactions broadcast by counterparty
309 pub htlc_basepoint: PublicKey,
310 /// The first to-be-broadcast-by-sender transaction's per commitment point
311 pub first_per_commitment_point: PublicKey,
312 /// A request to pre-set the to-sender output's scriptPubkey for when we collaboratively close
313 pub shutdown_scriptpubkey: Option<Script>,
314 /// The channel type that this channel will represent.
316 /// If this is `None`, we derive the channel type from the intersection of
317 /// our feature bits with our counterparty's feature bits from the [`Init`] message.
318 /// This is required to match the equivalent field in [`OpenChannel::channel_type`].
319 pub channel_type: Option<ChannelTypeFeatures>,
321 /// Next nonce the channel initiator should use to create a funding output signature against
322 pub next_local_nonce: Option<musig2::types::PublicNonce>,
325 /// An accept_channel2 message to be sent by or received from the channel accepter.
327 /// Used in V2 channel establishment
329 // TODO(dual_funding): Add spec link for `accept_channel2`.
330 #[derive(Clone, Debug, PartialEq, Eq)]
331 pub struct AcceptChannelV2 {
332 /// The same `temporary_channel_id` received from the initiator's `open_channel2` message.
333 pub temporary_channel_id: [u8; 32],
334 /// Part of the channel value contributed by the channel acceptor
335 pub funding_satoshis: u64,
336 /// The threshold below which outputs on transactions broadcast by the channel acceptor will be
338 pub dust_limit_satoshis: u64,
339 /// The maximum inbound HTLC value in flight towards channel acceptor, in milli-satoshi
340 pub max_htlc_value_in_flight_msat: u64,
341 /// The minimum HTLC size incoming to channel acceptor, in milli-satoshi
342 pub htlc_minimum_msat: u64,
343 /// Minimum depth of the funding transaction before the channel is considered open
344 pub minimum_depth: u32,
345 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
346 /// broadcast a commitment transaction
347 pub to_self_delay: u16,
348 /// The maximum number of inbound HTLCs towards channel acceptor
349 pub max_accepted_htlcs: u16,
350 /// The channel acceptor's key controlling the funding transaction
351 pub funding_pubkey: PublicKey,
352 /// Used to derive a revocation key for transactions broadcast by counterparty
353 pub revocation_basepoint: PublicKey,
354 /// A payment key to channel acceptor for transactions broadcast by counterparty
355 pub payment_basepoint: PublicKey,
356 /// Used to derive a payment key to channel acceptor for transactions broadcast by channel
358 pub delayed_payment_basepoint: PublicKey,
359 /// Used to derive an HTLC payment key to channel acceptor for transactions broadcast by counterparty
360 pub htlc_basepoint: PublicKey,
361 /// The first to-be-broadcast-by-channel-acceptor transaction's per commitment point
362 pub first_per_commitment_point: PublicKey,
363 /// The second to-be-broadcast-by-channel-acceptor transaction's per commitment point
364 pub second_per_commitment_point: PublicKey,
365 /// Optionally, a request to pre-set the to-channel-acceptor output's scriptPubkey for when we
366 /// collaboratively close
367 pub shutdown_scriptpubkey: Option<Script>,
368 /// The channel type that this channel will represent. If none is set, we derive the channel
369 /// type from the intersection of our feature bits with our counterparty's feature bits from
370 /// the Init message.
372 /// This is required to match the equivalent field in [`OpenChannelV2::channel_type`].
373 pub channel_type: Option<ChannelTypeFeatures>,
374 /// Optionally, a requirement that only confirmed inputs can be added
375 pub require_confirmed_inputs: Option<()>,
378 /// A [`funding_created`] message to be sent to or received from a peer.
380 /// Used in V1 channel establishment
382 /// [`funding_created`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-funding_created-message
383 #[derive(Clone, Debug, PartialEq, Eq)]
384 pub struct FundingCreated {
385 /// A temporary channel ID, until the funding is established
386 pub temporary_channel_id: [u8; 32],
387 /// The funding transaction ID
388 pub funding_txid: Txid,
389 /// The specific output index funding this channel
390 pub funding_output_index: u16,
391 /// The signature of the channel initiator (funder) on the initial commitment transaction
392 pub signature: Signature,
394 /// The partial signature of the channel initiator (funder)
395 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
397 /// Next nonce the channel acceptor should use to finalize the funding output signature
398 pub next_local_nonce: Option<musig2::types::PublicNonce>
401 /// A [`funding_signed`] message to be sent to or received from a peer.
403 /// Used in V1 channel establishment
405 /// [`funding_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-funding_signed-message
406 #[derive(Clone, Debug, PartialEq, Eq)]
407 pub struct FundingSigned {
409 pub channel_id: [u8; 32],
410 /// The signature of the channel acceptor (fundee) on the initial commitment transaction
411 pub signature: Signature,
413 /// The partial signature of the channel acceptor (fundee)
414 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
417 /// A [`channel_ready`] message to be sent to or received from a peer.
419 /// [`channel_ready`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-channel_ready-message
420 #[derive(Clone, Debug, PartialEq, Eq)]
421 pub struct ChannelReady {
423 pub channel_id: [u8; 32],
424 /// The per-commitment point of the second commitment transaction
425 pub next_per_commitment_point: PublicKey,
426 /// If set, provides a `short_channel_id` alias for this channel.
428 /// The sender will accept payments to be forwarded over this SCID and forward them to this
429 /// messages' recipient.
430 pub short_channel_id_alias: Option<u64>,
433 /// A tx_add_input message for adding an input during interactive transaction construction
435 // TODO(dual_funding): Add spec link for `tx_add_input`.
436 #[derive(Clone, Debug, PartialEq, Eq)]
437 pub struct TxAddInput {
439 pub channel_id: [u8; 32],
440 /// A randomly chosen unique identifier for this input, which is even for initiators and odd for
443 /// Serialized transaction that contains the output this input spends to verify that it is non
445 pub prevtx: TransactionU16LenLimited,
446 /// The index of the output being spent
448 /// The sequence number of this input
452 /// A tx_add_output message for adding an output during interactive transaction construction.
454 // TODO(dual_funding): Add spec link for `tx_add_output`.
455 #[derive(Clone, Debug, PartialEq, Eq)]
456 pub struct TxAddOutput {
458 pub channel_id: [u8; 32],
459 /// A randomly chosen unique identifier for this output, which is even for initiators and odd for
462 /// The satoshi value of the output
464 /// The scriptPubKey for the output
468 /// A tx_remove_input message for removing an input during interactive transaction construction.
470 // TODO(dual_funding): Add spec link for `tx_remove_input`.
471 #[derive(Clone, Debug, PartialEq, Eq)]
472 pub struct TxRemoveInput {
474 pub channel_id: [u8; 32],
475 /// The serial ID of the input to be removed
479 /// A tx_remove_output message for removing an output during interactive transaction construction.
481 // TODO(dual_funding): Add spec link for `tx_remove_output`.
482 #[derive(Clone, Debug, PartialEq, Eq)]
483 pub struct TxRemoveOutput {
485 pub channel_id: [u8; 32],
486 /// The serial ID of the output to be removed
490 /// A tx_complete message signalling the conclusion of a peer's transaction contributions during
491 /// interactive transaction construction.
493 // TODO(dual_funding): Add spec link for `tx_complete`.
494 #[derive(Clone, Debug, PartialEq, Eq)]
495 pub struct TxComplete {
497 pub channel_id: [u8; 32],
500 /// A tx_signatures message containing the sender's signatures for a transaction constructed with
501 /// interactive transaction construction.
503 // TODO(dual_funding): Add spec link for `tx_signatures`.
504 #[derive(Clone, Debug, PartialEq, Eq)]
505 pub struct TxSignatures {
507 pub channel_id: [u8; 32],
510 /// The list of witnesses
511 pub witnesses: Vec<Witness>,
514 /// A tx_init_rbf message which initiates a replacement of the transaction after it's been
517 // TODO(dual_funding): Add spec link for `tx_init_rbf`.
518 #[derive(Clone, Debug, PartialEq, Eq)]
519 pub struct TxInitRbf {
521 pub channel_id: [u8; 32],
522 /// The locktime of the transaction
524 /// The feerate of the transaction
525 pub feerate_sat_per_1000_weight: u32,
526 /// The number of satoshis the sender will contribute to or, if negative, remove from
527 /// (e.g. splice-out) the funding output of the transaction
528 pub funding_output_contribution: Option<i64>,
531 /// A tx_ack_rbf message which acknowledges replacement of the transaction after it's been
534 // TODO(dual_funding): Add spec link for `tx_ack_rbf`.
535 #[derive(Clone, Debug, PartialEq, Eq)]
536 pub struct TxAckRbf {
538 pub channel_id: [u8; 32],
539 /// The number of satoshis the sender will contribute to or, if negative, remove from
540 /// (e.g. splice-out) the funding output of the transaction
541 pub funding_output_contribution: Option<i64>,
544 /// A tx_abort message which signals the cancellation of an in-progress transaction negotiation.
546 // TODO(dual_funding): Add spec link for `tx_abort`.
547 #[derive(Clone, Debug, PartialEq, Eq)]
550 pub channel_id: [u8; 32],
555 /// A [`shutdown`] message to be sent to or received from a peer.
557 /// [`shutdown`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-initiation-shutdown
558 #[derive(Clone, Debug, PartialEq, Eq)]
559 pub struct Shutdown {
561 pub channel_id: [u8; 32],
562 /// The destination of this peer's funds on closing.
564 /// Must be in one of these forms: P2PKH, P2SH, P2WPKH, P2WSH, P2TR.
565 pub scriptpubkey: Script,
568 /// The minimum and maximum fees which the sender is willing to place on the closing transaction.
570 /// This is provided in [`ClosingSigned`] by both sides to indicate the fee range they are willing
572 #[derive(Clone, Debug, PartialEq, Eq)]
573 pub struct ClosingSignedFeeRange {
574 /// The minimum absolute fee, in satoshis, which the sender is willing to place on the closing
576 pub min_fee_satoshis: u64,
577 /// The maximum absolute fee, in satoshis, which the sender is willing to place on the closing
579 pub max_fee_satoshis: u64,
582 /// A [`closing_signed`] message to be sent to or received from a peer.
584 /// [`closing_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-negotiation-closing_signed
585 #[derive(Clone, Debug, PartialEq, Eq)]
586 pub struct ClosingSigned {
588 pub channel_id: [u8; 32],
589 /// The proposed total fee for the closing transaction
590 pub fee_satoshis: u64,
591 /// A signature on the closing transaction
592 pub signature: Signature,
593 /// The minimum and maximum fees which the sender is willing to accept, provided only by new
595 pub fee_range: Option<ClosingSignedFeeRange>,
598 /// An [`update_add_htlc`] message to be sent to or received from a peer.
600 /// [`update_add_htlc`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#adding-an-htlc-update_add_htlc
601 #[derive(Clone, Debug, PartialEq, Eq)]
602 pub struct UpdateAddHTLC {
604 pub channel_id: [u8; 32],
607 /// The HTLC value in milli-satoshi
608 pub amount_msat: u64,
609 /// The payment hash, the pre-image of which controls HTLC redemption
610 pub payment_hash: PaymentHash,
611 /// The expiry height of the HTLC
612 pub cltv_expiry: u32,
613 /// The extra fee skimmed by the sender of this message. See
614 /// [`ChannelConfig::accept_underpaying_htlcs`].
616 /// [`ChannelConfig::accept_underpaying_htlcs`]: crate::util::config::ChannelConfig::accept_underpaying_htlcs
617 pub skimmed_fee_msat: Option<u64>,
618 pub(crate) onion_routing_packet: OnionPacket,
621 /// An onion message to be sent to or received from a peer.
623 // TODO: update with link to OM when they are merged into the BOLTs
624 #[derive(Clone, Debug, PartialEq, Eq)]
625 pub struct OnionMessage {
626 /// Used in decrypting the onion packet's payload.
627 pub blinding_point: PublicKey,
628 pub(crate) onion_routing_packet: onion_message::Packet,
631 /// An [`update_fulfill_htlc`] message to be sent to or received from a peer.
633 /// [`update_fulfill_htlc`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#removing-an-htlc-update_fulfill_htlc-update_fail_htlc-and-update_fail_malformed_htlc
634 #[derive(Clone, Debug, PartialEq, Eq)]
635 pub struct UpdateFulfillHTLC {
637 pub channel_id: [u8; 32],
640 /// The pre-image of the payment hash, allowing HTLC redemption
641 pub payment_preimage: PaymentPreimage,
644 /// An [`update_fail_htlc`] message to be sent to or received from a peer.
646 /// [`update_fail_htlc`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#removing-an-htlc-update_fulfill_htlc-update_fail_htlc-and-update_fail_malformed_htlc
647 #[derive(Clone, Debug, PartialEq, Eq)]
648 pub struct UpdateFailHTLC {
650 pub channel_id: [u8; 32],
653 pub(crate) reason: OnionErrorPacket,
656 /// An [`update_fail_malformed_htlc`] message to be sent to or received from a peer.
658 /// [`update_fail_malformed_htlc`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#removing-an-htlc-update_fulfill_htlc-update_fail_htlc-and-update_fail_malformed_htlc
659 #[derive(Clone, Debug, PartialEq, Eq)]
660 pub struct UpdateFailMalformedHTLC {
662 pub channel_id: [u8; 32],
665 pub(crate) sha256_of_onion: [u8; 32],
667 pub failure_code: u16,
670 /// A [`commitment_signed`] message to be sent to or received from a peer.
672 /// [`commitment_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#committing-updates-so-far-commitment_signed
673 #[derive(Clone, Debug, PartialEq, Eq)]
674 pub struct CommitmentSigned {
676 pub channel_id: [u8; 32],
677 /// A signature on the commitment transaction
678 pub signature: Signature,
679 /// Signatures on the HTLC transactions
680 pub htlc_signatures: Vec<Signature>,
682 /// The partial Taproot signature on the commitment transaction
683 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
686 /// A [`revoke_and_ack`] message to be sent to or received from a peer.
688 /// [`revoke_and_ack`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#completing-the-transition-to-the-updated-state-revoke_and_ack
689 #[derive(Clone, Debug, PartialEq, Eq)]
690 pub struct RevokeAndACK {
692 pub channel_id: [u8; 32],
693 /// The secret corresponding to the per-commitment point
694 pub per_commitment_secret: [u8; 32],
695 /// The next sender-broadcast commitment transaction's per-commitment point
696 pub next_per_commitment_point: PublicKey,
698 /// Musig nonce the recipient should use in their next commitment signature message
699 pub next_local_nonce: Option<musig2::types::PublicNonce>
702 /// An [`update_fee`] message to be sent to or received from a peer
704 /// [`update_fee`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#updating-fees-update_fee
705 #[derive(Clone, Debug, PartialEq, Eq)]
706 pub struct UpdateFee {
708 pub channel_id: [u8; 32],
709 /// Fee rate per 1000-weight of the transaction
710 pub feerate_per_kw: u32,
713 /// A [`channel_reestablish`] message to be sent to or received from a peer.
715 /// [`channel_reestablish`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#message-retransmission
716 #[derive(Clone, Debug, PartialEq, Eq)]
717 pub struct ChannelReestablish {
719 pub channel_id: [u8; 32],
720 /// The next commitment number for the sender
721 pub next_local_commitment_number: u64,
722 /// The next commitment number for the recipient
723 pub next_remote_commitment_number: u64,
724 /// Proof that the sender knows the per-commitment secret of a specific commitment transaction
725 /// belonging to the recipient
726 pub your_last_per_commitment_secret: [u8; 32],
727 /// The sender's per-commitment point for their current commitment transaction
728 pub my_current_per_commitment_point: PublicKey,
729 /// The next funding transaction ID
730 pub next_funding_txid: Option<Txid>,
733 /// An [`announcement_signatures`] message to be sent to or received from a peer.
735 /// [`announcement_signatures`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-announcement_signatures-message
736 #[derive(Clone, Debug, PartialEq, Eq)]
737 pub struct AnnouncementSignatures {
739 pub channel_id: [u8; 32],
740 /// The short channel ID
741 pub short_channel_id: u64,
742 /// A signature by the node key
743 pub node_signature: Signature,
744 /// A signature by the funding key
745 pub bitcoin_signature: Signature,
748 /// An address which can be used to connect to a remote peer.
749 #[derive(Clone, Debug, PartialEq, Eq)]
750 pub enum NetAddress {
751 /// An IPv4 address/port on which the peer is listening.
753 /// The 4-byte IPv4 address
755 /// The port on which the node is listening
758 /// An IPv6 address/port on which the peer is listening.
760 /// The 16-byte IPv6 address
762 /// The port on which the node is listening
765 /// An old-style Tor onion address/port on which the peer is listening.
767 /// This field is deprecated and the Tor network generally no longer supports V2 Onion
768 /// addresses. Thus, the details are not parsed here.
770 /// A new-style Tor onion address/port on which the peer is listening.
772 /// To create the human-readable "hostname", concatenate the ED25519 pubkey, checksum, and version,
773 /// wrap as base32 and append ".onion".
775 /// The ed25519 long-term public key of the peer
776 ed25519_pubkey: [u8; 32],
777 /// The checksum of the pubkey and version, as included in the onion address
779 /// The version byte, as defined by the Tor Onion v3 spec.
781 /// The port on which the node is listening
784 /// A hostname/port on which the peer is listening.
786 /// The hostname on which the node is listening.
788 /// The port on which the node is listening.
793 /// Gets the ID of this address type. Addresses in [`NodeAnnouncement`] messages should be sorted
795 pub(crate) fn get_id(&self) -> u8 {
797 &NetAddress::IPv4 {..} => { 1 },
798 &NetAddress::IPv6 {..} => { 2 },
799 &NetAddress::OnionV2(_) => { 3 },
800 &NetAddress::OnionV3 {..} => { 4 },
801 &NetAddress::Hostname {..} => { 5 },
805 /// Strict byte-length of address descriptor, 1-byte type not recorded
806 fn len(&self) -> u16 {
808 &NetAddress::IPv4 { .. } => { 6 },
809 &NetAddress::IPv6 { .. } => { 18 },
810 &NetAddress::OnionV2(_) => { 12 },
811 &NetAddress::OnionV3 { .. } => { 37 },
812 // Consists of 1-byte hostname length, hostname bytes, and 2-byte port.
813 &NetAddress::Hostname { ref hostname, .. } => { u16::from(hostname.len()) + 3 },
817 /// The maximum length of any address descriptor, not including the 1-byte type.
818 /// This maximum length is reached by a hostname address descriptor:
819 /// a hostname with a maximum length of 255, its 1-byte length and a 2-byte port.
820 pub(crate) const MAX_LEN: u16 = 258;
823 impl Writeable for NetAddress {
824 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
826 &NetAddress::IPv4 { ref addr, ref port } => {
831 &NetAddress::IPv6 { ref addr, ref port } => {
836 &NetAddress::OnionV2(bytes) => {
838 bytes.write(writer)?;
840 &NetAddress::OnionV3 { ref ed25519_pubkey, ref checksum, ref version, ref port } => {
842 ed25519_pubkey.write(writer)?;
843 checksum.write(writer)?;
844 version.write(writer)?;
847 &NetAddress::Hostname { ref hostname, ref port } => {
849 hostname.write(writer)?;
857 impl Readable for Result<NetAddress, u8> {
858 fn read<R: Read>(reader: &mut R) -> Result<Result<NetAddress, u8>, DecodeError> {
859 let byte = <u8 as Readable>::read(reader)?;
862 Ok(Ok(NetAddress::IPv4 {
863 addr: Readable::read(reader)?,
864 port: Readable::read(reader)?,
868 Ok(Ok(NetAddress::IPv6 {
869 addr: Readable::read(reader)?,
870 port: Readable::read(reader)?,
873 3 => Ok(Ok(NetAddress::OnionV2(Readable::read(reader)?))),
875 Ok(Ok(NetAddress::OnionV3 {
876 ed25519_pubkey: Readable::read(reader)?,
877 checksum: Readable::read(reader)?,
878 version: Readable::read(reader)?,
879 port: Readable::read(reader)?,
883 Ok(Ok(NetAddress::Hostname {
884 hostname: Readable::read(reader)?,
885 port: Readable::read(reader)?,
888 _ => return Ok(Err(byte)),
893 impl Readable for NetAddress {
894 fn read<R: Read>(reader: &mut R) -> Result<NetAddress, DecodeError> {
895 match Readable::read(reader) {
896 Ok(Ok(res)) => Ok(res),
897 Ok(Err(_)) => Err(DecodeError::UnknownVersion),
903 /// Represents the set of gossip messages that require a signature from a node's identity key.
904 pub enum UnsignedGossipMessage<'a> {
905 /// An unsigned channel announcement.
906 ChannelAnnouncement(&'a UnsignedChannelAnnouncement),
907 /// An unsigned channel update.
908 ChannelUpdate(&'a UnsignedChannelUpdate),
909 /// An unsigned node announcement.
910 NodeAnnouncement(&'a UnsignedNodeAnnouncement)
913 impl<'a> Writeable for UnsignedGossipMessage<'a> {
914 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
916 UnsignedGossipMessage::ChannelAnnouncement(ref msg) => msg.write(writer),
917 UnsignedGossipMessage::ChannelUpdate(ref msg) => msg.write(writer),
918 UnsignedGossipMessage::NodeAnnouncement(ref msg) => msg.write(writer),
923 /// The unsigned part of a [`node_announcement`] message.
925 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
926 #[derive(Clone, Debug, PartialEq, Eq)]
927 pub struct UnsignedNodeAnnouncement {
928 /// The advertised features
929 pub features: NodeFeatures,
930 /// A strictly monotonic announcement counter, with gaps allowed
932 /// The `node_id` this announcement originated from (don't rebroadcast the `node_announcement` back
935 /// An RGB color for UI purposes
937 /// An alias, for UI purposes.
939 /// This should be sanitized before use. There is no guarantee of uniqueness.
940 pub alias: NodeAlias,
941 /// List of addresses on which this node is reachable
942 pub addresses: Vec<NetAddress>,
943 pub(crate) excess_address_data: Vec<u8>,
944 pub(crate) excess_data: Vec<u8>,
946 #[derive(Clone, Debug, PartialEq, Eq)]
947 /// A [`node_announcement`] message to be sent to or received from a peer.
949 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
950 pub struct NodeAnnouncement {
951 /// The signature by the node key
952 pub signature: Signature,
953 /// The actual content of the announcement
954 pub contents: UnsignedNodeAnnouncement,
957 /// The unsigned part of a [`channel_announcement`] message.
959 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
960 #[derive(Clone, Debug, PartialEq, Eq)]
961 pub struct UnsignedChannelAnnouncement {
962 /// The advertised channel features
963 pub features: ChannelFeatures,
964 /// The genesis hash of the blockchain where the channel is to be opened
965 pub chain_hash: BlockHash,
966 /// The short channel ID
967 pub short_channel_id: u64,
968 /// One of the two `node_id`s which are endpoints of this channel
969 pub node_id_1: NodeId,
970 /// The other of the two `node_id`s which are endpoints of this channel
971 pub node_id_2: NodeId,
972 /// The funding key for the first node
973 pub bitcoin_key_1: NodeId,
974 /// The funding key for the second node
975 pub bitcoin_key_2: NodeId,
976 /// Excess data which was signed as a part of the message which we do not (yet) understand how
979 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
980 pub excess_data: Vec<u8>,
982 /// A [`channel_announcement`] message to be sent to or received from a peer.
984 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
985 #[derive(Clone, Debug, PartialEq, Eq)]
986 pub struct ChannelAnnouncement {
987 /// Authentication of the announcement by the first public node
988 pub node_signature_1: Signature,
989 /// Authentication of the announcement by the second public node
990 pub node_signature_2: Signature,
991 /// Proof of funding UTXO ownership by the first public node
992 pub bitcoin_signature_1: Signature,
993 /// Proof of funding UTXO ownership by the second public node
994 pub bitcoin_signature_2: Signature,
995 /// The actual announcement
996 pub contents: UnsignedChannelAnnouncement,
999 /// The unsigned part of a [`channel_update`] message.
1001 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1002 #[derive(Clone, Debug, PartialEq, Eq)]
1003 pub struct UnsignedChannelUpdate {
1004 /// The genesis hash of the blockchain where the channel is to be opened
1005 pub chain_hash: BlockHash,
1006 /// The short channel ID
1007 pub short_channel_id: u64,
1008 /// A strictly monotonic announcement counter, with gaps allowed, specific to this channel
1012 /// The number of blocks such that if:
1013 /// `incoming_htlc.cltv_expiry < outgoing_htlc.cltv_expiry + cltv_expiry_delta`
1014 /// then we need to fail the HTLC backwards. When forwarding an HTLC, `cltv_expiry_delta` determines
1015 /// the outgoing HTLC's minimum `cltv_expiry` value -- so, if an incoming HTLC comes in with a
1016 /// `cltv_expiry` of 100000, and the node we're forwarding to has a `cltv_expiry_delta` value of 10,
1017 /// then we'll check that the outgoing HTLC's `cltv_expiry` value is at least 100010 before
1018 /// forwarding. Note that the HTLC sender is the one who originally sets this value when
1019 /// constructing the route.
1020 pub cltv_expiry_delta: u16,
1021 /// The minimum HTLC size incoming to sender, in milli-satoshi
1022 pub htlc_minimum_msat: u64,
1023 /// The maximum HTLC value incoming to sender, in milli-satoshi.
1025 /// This used to be optional.
1026 pub htlc_maximum_msat: u64,
1027 /// The base HTLC fee charged by sender, in milli-satoshi
1028 pub fee_base_msat: u32,
1029 /// The amount to fee multiplier, in micro-satoshi
1030 pub fee_proportional_millionths: u32,
1031 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1034 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1035 pub excess_data: Vec<u8>,
1037 /// A [`channel_update`] message to be sent to or received from a peer.
1039 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1040 #[derive(Clone, Debug, PartialEq, Eq)]
1041 pub struct ChannelUpdate {
1042 /// A signature of the channel update
1043 pub signature: Signature,
1044 /// The actual channel update
1045 pub contents: UnsignedChannelUpdate,
1048 /// A [`query_channel_range`] message is used to query a peer for channel
1049 /// UTXOs in a range of blocks. The recipient of a query makes a best
1050 /// effort to reply to the query using one or more [`ReplyChannelRange`]
1053 /// [`query_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1054 #[derive(Clone, Debug, PartialEq, Eq)]
1055 pub struct QueryChannelRange {
1056 /// The genesis hash of the blockchain being queried
1057 pub chain_hash: BlockHash,
1058 /// The height of the first block for the channel UTXOs being queried
1059 pub first_blocknum: u32,
1060 /// The number of blocks to include in the query results
1061 pub number_of_blocks: u32,
1064 /// A [`reply_channel_range`] message is a reply to a [`QueryChannelRange`]
1067 /// Multiple `reply_channel_range` messages can be sent in reply
1068 /// to a single [`QueryChannelRange`] message. The query recipient makes a
1069 /// best effort to respond based on their local network view which may
1070 /// not be a perfect view of the network. The `short_channel_id`s in the
1071 /// reply are encoded. We only support `encoding_type=0` uncompressed
1072 /// serialization and do not support `encoding_type=1` zlib serialization.
1074 /// [`reply_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1075 #[derive(Clone, Debug, PartialEq, Eq)]
1076 pub struct ReplyChannelRange {
1077 /// The genesis hash of the blockchain being queried
1078 pub chain_hash: BlockHash,
1079 /// The height of the first block in the range of the reply
1080 pub first_blocknum: u32,
1081 /// The number of blocks included in the range of the reply
1082 pub number_of_blocks: u32,
1083 /// True when this is the final reply for a query
1084 pub sync_complete: bool,
1085 /// The `short_channel_id`s in the channel range
1086 pub short_channel_ids: Vec<u64>,
1089 /// A [`query_short_channel_ids`] message is used to query a peer for
1090 /// routing gossip messages related to one or more `short_channel_id`s.
1092 /// The query recipient will reply with the latest, if available,
1093 /// [`ChannelAnnouncement`], [`ChannelUpdate`] and [`NodeAnnouncement`] messages
1094 /// it maintains for the requested `short_channel_id`s followed by a
1095 /// [`ReplyShortChannelIdsEnd`] message. The `short_channel_id`s sent in
1096 /// this query are encoded. We only support `encoding_type=0` uncompressed
1097 /// serialization and do not support `encoding_type=1` zlib serialization.
1099 /// [`query_short_channel_ids`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_short_channel_idsreply_short_channel_ids_end-messages
1100 #[derive(Clone, Debug, PartialEq, Eq)]
1101 pub struct QueryShortChannelIds {
1102 /// The genesis hash of the blockchain being queried
1103 pub chain_hash: BlockHash,
1104 /// The short_channel_ids that are being queried
1105 pub short_channel_ids: Vec<u64>,
1108 /// A [`reply_short_channel_ids_end`] message is sent as a reply to a
1109 /// message. The query recipient makes a best
1110 /// effort to respond based on their local network view which may not be
1111 /// a perfect view of the network.
1113 /// [`reply_short_channel_ids_end`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_short_channel_idsreply_short_channel_ids_end-messages
1114 #[derive(Clone, Debug, PartialEq, Eq)]
1115 pub struct ReplyShortChannelIdsEnd {
1116 /// The genesis hash of the blockchain that was queried
1117 pub chain_hash: BlockHash,
1118 /// Indicates if the query recipient maintains up-to-date channel
1119 /// information for the `chain_hash`
1120 pub full_information: bool,
1123 /// A [`gossip_timestamp_filter`] message is used by a node to request
1124 /// gossip relay for messages in the requested time range when the
1125 /// `gossip_queries` feature has been negotiated.
1127 /// [`gossip_timestamp_filter`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-gossip_timestamp_filter-message
1128 #[derive(Clone, Debug, PartialEq, Eq)]
1129 pub struct GossipTimestampFilter {
1130 /// The genesis hash of the blockchain for channel and node information
1131 pub chain_hash: BlockHash,
1132 /// The starting unix timestamp
1133 pub first_timestamp: u32,
1134 /// The range of information in seconds
1135 pub timestamp_range: u32,
1138 /// Encoding type for data compression of collections in gossip queries.
1140 /// We do not support `encoding_type=1` zlib serialization [defined in BOLT
1141 /// #7](https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#query-messages).
1143 Uncompressed = 0x00,
1146 /// Used to put an error message in a [`LightningError`].
1147 #[derive(Clone, Debug)]
1148 pub enum ErrorAction {
1149 /// The peer took some action which made us think they were useless. Disconnect them.
1151 /// An error message which we should make an effort to send before we disconnect.
1152 msg: Option<ErrorMessage>
1154 /// The peer did something incorrect. Tell them without closing any channels and disconnect them.
1155 DisconnectPeerWithWarning {
1156 /// A warning message which we should make an effort to send before we disconnect.
1157 msg: WarningMessage,
1159 /// The peer did something harmless that we weren't able to process, just log and ignore
1160 // New code should *not* use this. New code must use IgnoreAndLog, below!
1162 /// The peer did something harmless that we weren't able to meaningfully process.
1163 /// If the error is logged, log it at the given level.
1164 IgnoreAndLog(logger::Level),
1165 /// The peer provided us with a gossip message which we'd already seen. In most cases this
1166 /// should be ignored, but it may result in the message being forwarded if it is a duplicate of
1167 /// our own channel announcements.
1168 IgnoreDuplicateGossip,
1169 /// The peer did something incorrect. Tell them.
1171 /// The message to send.
1174 /// The peer did something incorrect. Tell them without closing any channels.
1175 SendWarningMessage {
1176 /// The message to send.
1177 msg: WarningMessage,
1178 /// The peer may have done something harmless that we weren't able to meaningfully process,
1179 /// though we should still tell them about it.
1180 /// If this event is logged, log it at the given level.
1181 log_level: logger::Level,
1185 /// An Err type for failure to process messages.
1186 #[derive(Clone, Debug)]
1187 pub struct LightningError {
1188 /// A human-readable message describing the error
1190 /// The action which should be taken against the offending peer.
1191 pub action: ErrorAction,
1194 /// Struct used to return values from [`RevokeAndACK`] messages, containing a bunch of commitment
1195 /// transaction updates if they were pending.
1196 #[derive(Clone, Debug, PartialEq, Eq)]
1197 pub struct CommitmentUpdate {
1198 /// `update_add_htlc` messages which should be sent
1199 pub update_add_htlcs: Vec<UpdateAddHTLC>,
1200 /// `update_fulfill_htlc` messages which should be sent
1201 pub update_fulfill_htlcs: Vec<UpdateFulfillHTLC>,
1202 /// `update_fail_htlc` messages which should be sent
1203 pub update_fail_htlcs: Vec<UpdateFailHTLC>,
1204 /// `update_fail_malformed_htlc` messages which should be sent
1205 pub update_fail_malformed_htlcs: Vec<UpdateFailMalformedHTLC>,
1206 /// An `update_fee` message which should be sent
1207 pub update_fee: Option<UpdateFee>,
1208 /// A `commitment_signed` message which should be sent
1209 pub commitment_signed: CommitmentSigned,
1212 /// A trait to describe an object which can receive channel messages.
1214 /// Messages MAY be called in parallel when they originate from different `their_node_ids`, however
1215 /// they MUST NOT be called in parallel when the two calls have the same `their_node_id`.
1216 pub trait ChannelMessageHandler : MessageSendEventsProvider {
1218 /// Handle an incoming `open_channel` message from the given peer.
1219 fn handle_open_channel(&self, their_node_id: &PublicKey, msg: &OpenChannel);
1220 /// Handle an incoming `open_channel2` message from the given peer.
1221 fn handle_open_channel_v2(&self, their_node_id: &PublicKey, msg: &OpenChannelV2);
1222 /// Handle an incoming `accept_channel` message from the given peer.
1223 fn handle_accept_channel(&self, their_node_id: &PublicKey, msg: &AcceptChannel);
1224 /// Handle an incoming `accept_channel2` message from the given peer.
1225 fn handle_accept_channel_v2(&self, their_node_id: &PublicKey, msg: &AcceptChannelV2);
1226 /// Handle an incoming `funding_created` message from the given peer.
1227 fn handle_funding_created(&self, their_node_id: &PublicKey, msg: &FundingCreated);
1228 /// Handle an incoming `funding_signed` message from the given peer.
1229 fn handle_funding_signed(&self, their_node_id: &PublicKey, msg: &FundingSigned);
1230 /// Handle an incoming `channel_ready` message from the given peer.
1231 fn handle_channel_ready(&self, their_node_id: &PublicKey, msg: &ChannelReady);
1234 /// Handle an incoming `shutdown` message from the given peer.
1235 fn handle_shutdown(&self, their_node_id: &PublicKey, msg: &Shutdown);
1236 /// Handle an incoming `closing_signed` message from the given peer.
1237 fn handle_closing_signed(&self, their_node_id: &PublicKey, msg: &ClosingSigned);
1239 // Interactive channel construction
1240 /// Handle an incoming `tx_add_input message` from the given peer.
1241 fn handle_tx_add_input(&self, their_node_id: &PublicKey, msg: &TxAddInput);
1242 /// Handle an incoming `tx_add_output` message from the given peer.
1243 fn handle_tx_add_output(&self, their_node_id: &PublicKey, msg: &TxAddOutput);
1244 /// Handle an incoming `tx_remove_input` message from the given peer.
1245 fn handle_tx_remove_input(&self, their_node_id: &PublicKey, msg: &TxRemoveInput);
1246 /// Handle an incoming `tx_remove_output` message from the given peer.
1247 fn handle_tx_remove_output(&self, their_node_id: &PublicKey, msg: &TxRemoveOutput);
1248 /// Handle an incoming `tx_complete message` from the given peer.
1249 fn handle_tx_complete(&self, their_node_id: &PublicKey, msg: &TxComplete);
1250 /// Handle an incoming `tx_signatures` message from the given peer.
1251 fn handle_tx_signatures(&self, their_node_id: &PublicKey, msg: &TxSignatures);
1252 /// Handle an incoming `tx_init_rbf` message from the given peer.
1253 fn handle_tx_init_rbf(&self, their_node_id: &PublicKey, msg: &TxInitRbf);
1254 /// Handle an incoming `tx_ack_rbf` message from the given peer.
1255 fn handle_tx_ack_rbf(&self, their_node_id: &PublicKey, msg: &TxAckRbf);
1256 /// Handle an incoming `tx_abort message` from the given peer.
1257 fn handle_tx_abort(&self, their_node_id: &PublicKey, msg: &TxAbort);
1260 /// Handle an incoming `update_add_htlc` message from the given peer.
1261 fn handle_update_add_htlc(&self, their_node_id: &PublicKey, msg: &UpdateAddHTLC);
1262 /// Handle an incoming `update_fulfill_htlc` message from the given peer.
1263 fn handle_update_fulfill_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFulfillHTLC);
1264 /// Handle an incoming `update_fail_htlc` message from the given peer.
1265 fn handle_update_fail_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailHTLC);
1266 /// Handle an incoming `update_fail_malformed_htlc` message from the given peer.
1267 fn handle_update_fail_malformed_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailMalformedHTLC);
1268 /// Handle an incoming `commitment_signed` message from the given peer.
1269 fn handle_commitment_signed(&self, their_node_id: &PublicKey, msg: &CommitmentSigned);
1270 /// Handle an incoming `revoke_and_ack` message from the given peer.
1271 fn handle_revoke_and_ack(&self, their_node_id: &PublicKey, msg: &RevokeAndACK);
1273 /// Handle an incoming `update_fee` message from the given peer.
1274 fn handle_update_fee(&self, their_node_id: &PublicKey, msg: &UpdateFee);
1276 // Channel-to-announce:
1277 /// Handle an incoming `announcement_signatures` message from the given peer.
1278 fn handle_announcement_signatures(&self, their_node_id: &PublicKey, msg: &AnnouncementSignatures);
1280 // Connection loss/reestablish:
1281 /// Indicates a connection to the peer failed/an existing connection was lost.
1282 fn peer_disconnected(&self, their_node_id: &PublicKey);
1284 /// Handle a peer reconnecting, possibly generating `channel_reestablish` message(s).
1286 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1287 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1288 /// message handlers may still wish to communicate with this peer.
1289 fn peer_connected(&self, their_node_id: &PublicKey, msg: &Init, inbound: bool) -> Result<(), ()>;
1290 /// Handle an incoming `channel_reestablish` message from the given peer.
1291 fn handle_channel_reestablish(&self, their_node_id: &PublicKey, msg: &ChannelReestablish);
1293 /// Handle an incoming `channel_update` message from the given peer.
1294 fn handle_channel_update(&self, their_node_id: &PublicKey, msg: &ChannelUpdate);
1297 /// Handle an incoming `error` message from the given peer.
1298 fn handle_error(&self, their_node_id: &PublicKey, msg: &ErrorMessage);
1300 // Handler information:
1301 /// Gets the node feature flags which this handler itself supports. All available handlers are
1302 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1303 /// which are broadcasted in our [`NodeAnnouncement`] message.
1304 fn provided_node_features(&self) -> NodeFeatures;
1306 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1307 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1308 /// which are sent in our [`Init`] message.
1310 /// Note that this method is called before [`Self::peer_connected`].
1311 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1313 /// Gets the genesis hashes for this `ChannelMessageHandler` indicating which chains it supports.
1315 /// If it's `None`, then no particular network chain hash compatibility will be enforced when
1316 /// connecting to peers.
1317 fn get_genesis_hashes(&self) -> Option<Vec<ChainHash>>;
1320 /// A trait to describe an object which can receive routing messages.
1322 /// # Implementor DoS Warnings
1324 /// For messages enabled with the `gossip_queries` feature there are potential DoS vectors when
1325 /// handling inbound queries. Implementors using an on-disk network graph should be aware of
1326 /// repeated disk I/O for queries accessing different parts of the network graph.
1327 pub trait RoutingMessageHandler : MessageSendEventsProvider {
1328 /// Handle an incoming `node_announcement` message, returning `true` if it should be forwarded on,
1329 /// `false` or returning an `Err` otherwise.
1330 fn handle_node_announcement(&self, msg: &NodeAnnouncement) -> Result<bool, LightningError>;
1331 /// Handle a `channel_announcement` message, returning `true` if it should be forwarded on, `false`
1332 /// or returning an `Err` otherwise.
1333 fn handle_channel_announcement(&self, msg: &ChannelAnnouncement) -> Result<bool, LightningError>;
1334 /// Handle an incoming `channel_update` message, returning true if it should be forwarded on,
1335 /// `false` or returning an `Err` otherwise.
1336 fn handle_channel_update(&self, msg: &ChannelUpdate) -> Result<bool, LightningError>;
1337 /// Gets channel announcements and updates required to dump our routing table to a remote node,
1338 /// starting at the `short_channel_id` indicated by `starting_point` and including announcements
1339 /// for a single channel.
1340 fn get_next_channel_announcement(&self, starting_point: u64) -> Option<(ChannelAnnouncement, Option<ChannelUpdate>, Option<ChannelUpdate>)>;
1341 /// Gets a node announcement required to dump our routing table to a remote node, starting at
1342 /// the node *after* the provided pubkey and including up to one announcement immediately
1343 /// higher (as defined by `<PublicKey as Ord>::cmp`) than `starting_point`.
1344 /// If `None` is provided for `starting_point`, we start at the first node.
1345 fn get_next_node_announcement(&self, starting_point: Option<&NodeId>) -> Option<NodeAnnouncement>;
1346 /// Called when a connection is established with a peer. This can be used to
1347 /// perform routing table synchronization using a strategy defined by the
1350 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1351 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1352 /// message handlers may still wish to communicate with this peer.
1353 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1354 /// Handles the reply of a query we initiated to learn about channels
1355 /// for a given range of blocks. We can expect to receive one or more
1356 /// replies to a single query.
1357 fn handle_reply_channel_range(&self, their_node_id: &PublicKey, msg: ReplyChannelRange) -> Result<(), LightningError>;
1358 /// Handles the reply of a query we initiated asking for routing gossip
1359 /// messages for a list of channels. We should receive this message when
1360 /// a node has completed its best effort to send us the pertaining routing
1361 /// gossip messages.
1362 fn handle_reply_short_channel_ids_end(&self, their_node_id: &PublicKey, msg: ReplyShortChannelIdsEnd) -> Result<(), LightningError>;
1363 /// Handles when a peer asks us to send a list of `short_channel_id`s
1364 /// for the requested range of blocks.
1365 fn handle_query_channel_range(&self, their_node_id: &PublicKey, msg: QueryChannelRange) -> Result<(), LightningError>;
1366 /// Handles when a peer asks us to send routing gossip messages for a
1367 /// list of `short_channel_id`s.
1368 fn handle_query_short_channel_ids(&self, their_node_id: &PublicKey, msg: QueryShortChannelIds) -> Result<(), LightningError>;
1370 // Handler queueing status:
1371 /// Indicates that there are a large number of [`ChannelAnnouncement`] (or other) messages
1372 /// pending some async action. While there is no guarantee of the rate of future messages, the
1373 /// caller should seek to reduce the rate of new gossip messages handled, especially
1374 /// [`ChannelAnnouncement`]s.
1375 fn processing_queue_high(&self) -> bool;
1377 // Handler information:
1378 /// Gets the node feature flags which this handler itself supports. All available handlers are
1379 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1380 /// which are broadcasted in our [`NodeAnnouncement`] message.
1381 fn provided_node_features(&self) -> NodeFeatures;
1382 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1383 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1384 /// which are sent in our [`Init`] message.
1386 /// Note that this method is called before [`Self::peer_connected`].
1387 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1390 /// A trait to describe an object that can receive onion messages.
1391 pub trait OnionMessageHandler : OnionMessageProvider {
1392 /// Handle an incoming `onion_message` message from the given peer.
1393 fn handle_onion_message(&self, peer_node_id: &PublicKey, msg: &OnionMessage);
1394 /// Called when a connection is established with a peer. Can be used to track which peers
1395 /// advertise onion message support and are online.
1397 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1398 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1399 /// message handlers may still wish to communicate with this peer.
1400 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1401 /// Indicates a connection to the peer failed/an existing connection was lost. Allows handlers to
1402 /// drop and refuse to forward onion messages to this peer.
1403 fn peer_disconnected(&self, their_node_id: &PublicKey);
1405 // Handler information:
1406 /// Gets the node feature flags which this handler itself supports. All available handlers are
1407 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1408 /// which are broadcasted in our [`NodeAnnouncement`] message.
1409 fn provided_node_features(&self) -> NodeFeatures;
1411 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1412 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1413 /// which are sent in our [`Init`] message.
1415 /// Note that this method is called before [`Self::peer_connected`].
1416 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1419 mod fuzzy_internal_msgs {
1420 use crate::prelude::*;
1421 use crate::ln::{PaymentPreimage, PaymentSecret};
1423 // These types aren't intended to be pub, but are exposed for direct fuzzing (as we deserialize
1424 // them from untrusted input):
1426 pub struct FinalOnionHopData {
1427 pub payment_secret: PaymentSecret,
1428 /// The total value, in msat, of the payment as received by the ultimate recipient.
1429 /// Message serialization may panic if this value is more than 21 million Bitcoin.
1430 pub total_msat: u64,
1433 pub enum InboundOnionPayload {
1435 short_channel_id: u64,
1436 /// The value, in msat, of the payment after this hop's fee is deducted.
1437 amt_to_forward: u64,
1438 outgoing_cltv_value: u32,
1441 payment_data: Option<FinalOnionHopData>,
1442 payment_metadata: Option<Vec<u8>>,
1443 keysend_preimage: Option<PaymentPreimage>,
1444 custom_tlvs: Vec<(u64, Vec<u8>)>,
1446 outgoing_cltv_value: u32,
1450 pub(crate) enum OutboundOnionPayload {
1452 short_channel_id: u64,
1453 /// The value, in msat, of the payment after this hop's fee is deducted.
1454 amt_to_forward: u64,
1455 outgoing_cltv_value: u32,
1458 payment_data: Option<FinalOnionHopData>,
1459 payment_metadata: Option<Vec<u8>>,
1460 keysend_preimage: Option<PaymentPreimage>,
1461 custom_tlvs: Vec<(u64, Vec<u8>)>,
1463 outgoing_cltv_value: u32,
1467 pub struct DecodedOnionErrorPacket {
1468 pub(crate) hmac: [u8; 32],
1469 pub(crate) failuremsg: Vec<u8>,
1470 pub(crate) pad: Vec<u8>,
1474 pub use self::fuzzy_internal_msgs::*;
1475 #[cfg(not(fuzzing))]
1476 pub(crate) use self::fuzzy_internal_msgs::*;
1479 pub(crate) struct OnionPacket {
1480 pub(crate) version: u8,
1481 /// In order to ensure we always return an error on onion decode in compliance with [BOLT
1482 /// #4](https://github.com/lightning/bolts/blob/master/04-onion-routing.md), we have to
1483 /// deserialize `OnionPacket`s contained in [`UpdateAddHTLC`] messages even if the ephemeral
1484 /// public key (here) is bogus, so we hold a [`Result`] instead of a [`PublicKey`] as we'd
1486 pub(crate) public_key: Result<PublicKey, secp256k1::Error>,
1487 pub(crate) hop_data: [u8; 20*65],
1488 pub(crate) hmac: [u8; 32],
1491 impl onion_utils::Packet for OnionPacket {
1492 type Data = onion_utils::FixedSizeOnionPacket;
1493 fn new(pubkey: PublicKey, hop_data: onion_utils::FixedSizeOnionPacket, hmac: [u8; 32]) -> Self {
1496 public_key: Ok(pubkey),
1497 hop_data: hop_data.0,
1503 impl Eq for OnionPacket { }
1504 impl PartialEq for OnionPacket {
1505 fn eq(&self, other: &OnionPacket) -> bool {
1506 for (i, j) in self.hop_data.iter().zip(other.hop_data.iter()) {
1507 if i != j { return false; }
1509 self.version == other.version &&
1510 self.public_key == other.public_key &&
1511 self.hmac == other.hmac
1515 impl fmt::Debug for OnionPacket {
1516 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1517 f.write_fmt(format_args!("OnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
1521 #[derive(Clone, Debug, PartialEq, Eq)]
1522 pub(crate) struct OnionErrorPacket {
1523 // This really should be a constant size slice, but the spec lets these things be up to 128KB?
1524 // (TODO) We limit it in decode to much lower...
1525 pub(crate) data: Vec<u8>,
1528 impl fmt::Display for DecodeError {
1529 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1531 DecodeError::UnknownVersion => f.write_str("Unknown realm byte in Onion packet"),
1532 DecodeError::UnknownRequiredFeature => f.write_str("Unknown required feature preventing decode"),
1533 DecodeError::InvalidValue => f.write_str("Nonsense bytes didn't map to the type they were interpreted as"),
1534 DecodeError::ShortRead => f.write_str("Packet extended beyond the provided bytes"),
1535 DecodeError::BadLengthDescriptor => f.write_str("A length descriptor in the packet didn't describe the later data correctly"),
1536 DecodeError::Io(ref e) => fmt::Debug::fmt(e, f),
1537 DecodeError::UnsupportedCompression => f.write_str("We don't support receiving messages with zlib-compressed fields"),
1542 impl From<io::Error> for DecodeError {
1543 fn from(e: io::Error) -> Self {
1544 if e.kind() == io::ErrorKind::UnexpectedEof {
1545 DecodeError::ShortRead
1547 DecodeError::Io(e.kind())
1552 #[cfg(not(taproot))]
1553 impl_writeable_msg!(AcceptChannel, {
1554 temporary_channel_id,
1555 dust_limit_satoshis,
1556 max_htlc_value_in_flight_msat,
1557 channel_reserve_satoshis,
1563 revocation_basepoint,
1565 delayed_payment_basepoint,
1567 first_per_commitment_point,
1569 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1570 (1, channel_type, option),
1574 impl_writeable_msg!(AcceptChannel, {
1575 temporary_channel_id,
1576 dust_limit_satoshis,
1577 max_htlc_value_in_flight_msat,
1578 channel_reserve_satoshis,
1584 revocation_basepoint,
1586 delayed_payment_basepoint,
1588 first_per_commitment_point,
1590 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1591 (1, channel_type, option),
1592 (4, next_local_nonce, option),
1595 impl_writeable_msg!(AcceptChannelV2, {
1596 temporary_channel_id,
1598 dust_limit_satoshis,
1599 max_htlc_value_in_flight_msat,
1605 revocation_basepoint,
1607 delayed_payment_basepoint,
1609 first_per_commitment_point,
1610 second_per_commitment_point,
1612 (0, shutdown_scriptpubkey, option),
1613 (1, channel_type, option),
1614 (2, require_confirmed_inputs, option),
1617 impl_writeable_msg!(TxAddInput, {
1625 impl_writeable_msg!(TxAddOutput, {
1632 impl_writeable_msg!(TxRemoveInput, {
1637 impl_writeable_msg!(TxRemoveOutput, {
1642 impl_writeable_msg!(TxComplete, {
1646 impl_writeable_msg!(TxSignatures, {
1652 impl_writeable_msg!(TxInitRbf, {
1655 feerate_sat_per_1000_weight,
1657 (0, funding_output_contribution, option),
1660 impl_writeable_msg!(TxAckRbf, {
1663 (0, funding_output_contribution, option),
1666 impl_writeable_msg!(TxAbort, {
1671 impl_writeable_msg!(AnnouncementSignatures, {
1678 impl_writeable_msg!(ChannelReestablish, {
1680 next_local_commitment_number,
1681 next_remote_commitment_number,
1682 your_last_per_commitment_secret,
1683 my_current_per_commitment_point,
1685 (0, next_funding_txid, option),
1688 impl_writeable_msg!(ClosingSigned,
1689 { channel_id, fee_satoshis, signature },
1690 { (1, fee_range, option) }
1693 impl_writeable!(ClosingSignedFeeRange, {
1698 #[cfg(not(taproot))]
1699 impl_writeable_msg!(CommitmentSigned, {
1706 impl_writeable_msg!(CommitmentSigned, {
1711 (2, partial_signature_with_nonce, option)
1714 impl_writeable!(DecodedOnionErrorPacket, {
1720 #[cfg(not(taproot))]
1721 impl_writeable_msg!(FundingCreated, {
1722 temporary_channel_id,
1724 funding_output_index,
1728 impl_writeable_msg!(FundingCreated, {
1729 temporary_channel_id,
1731 funding_output_index,
1734 (2, partial_signature_with_nonce, option),
1735 (4, next_local_nonce, option)
1738 #[cfg(not(taproot))]
1739 impl_writeable_msg!(FundingSigned, {
1745 impl_writeable_msg!(FundingSigned, {
1749 (2, partial_signature_with_nonce, option)
1752 impl_writeable_msg!(ChannelReady, {
1754 next_per_commitment_point,
1756 (1, short_channel_id_alias, option),
1759 impl Writeable for Init {
1760 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1761 // global_features gets the bottom 13 bits of our features, and local_features gets all of
1762 // our relevant feature bits. This keeps us compatible with old nodes.
1763 self.features.write_up_to_13(w)?;
1764 self.features.write(w)?;
1765 encode_tlv_stream!(w, {
1766 (1, self.networks.as_ref().map(|n| WithoutLength(n)), option),
1767 (3, self.remote_network_address, option),
1773 impl Readable for Init {
1774 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1775 let global_features: InitFeatures = Readable::read(r)?;
1776 let features: InitFeatures = Readable::read(r)?;
1777 let mut remote_network_address: Option<NetAddress> = None;
1778 let mut networks: Option<WithoutLength<Vec<ChainHash>>> = None;
1779 decode_tlv_stream!(r, {
1780 (1, networks, option),
1781 (3, remote_network_address, option)
1784 features: features | global_features,
1785 networks: networks.map(|n| n.0),
1786 remote_network_address,
1791 impl_writeable_msg!(OpenChannel, {
1793 temporary_channel_id,
1796 dust_limit_satoshis,
1797 max_htlc_value_in_flight_msat,
1798 channel_reserve_satoshis,
1804 revocation_basepoint,
1806 delayed_payment_basepoint,
1808 first_per_commitment_point,
1811 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1812 (1, channel_type, option),
1815 impl_writeable_msg!(OpenChannelV2, {
1817 temporary_channel_id,
1818 funding_feerate_sat_per_1000_weight,
1819 commitment_feerate_sat_per_1000_weight,
1821 dust_limit_satoshis,
1822 max_htlc_value_in_flight_msat,
1828 revocation_basepoint,
1830 delayed_payment_basepoint,
1832 first_per_commitment_point,
1833 second_per_commitment_point,
1836 (0, shutdown_scriptpubkey, option),
1837 (1, channel_type, option),
1838 (2, require_confirmed_inputs, option),
1841 #[cfg(not(taproot))]
1842 impl_writeable_msg!(RevokeAndACK, {
1844 per_commitment_secret,
1845 next_per_commitment_point
1849 impl_writeable_msg!(RevokeAndACK, {
1851 per_commitment_secret,
1852 next_per_commitment_point
1854 (4, next_local_nonce, option)
1857 impl_writeable_msg!(Shutdown, {
1862 impl_writeable_msg!(UpdateFailHTLC, {
1868 impl_writeable_msg!(UpdateFailMalformedHTLC, {
1875 impl_writeable_msg!(UpdateFee, {
1880 impl_writeable_msg!(UpdateFulfillHTLC, {
1886 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
1887 // serialization format in a way which assumes we know the total serialized length/message end
1889 impl_writeable!(OnionErrorPacket, {
1893 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
1894 // serialization format in a way which assumes we know the total serialized length/message end
1896 impl Writeable for OnionPacket {
1897 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1898 self.version.write(w)?;
1899 match self.public_key {
1900 Ok(pubkey) => pubkey.write(w)?,
1901 Err(_) => [0u8;33].write(w)?,
1903 w.write_all(&self.hop_data)?;
1904 self.hmac.write(w)?;
1909 impl Readable for OnionPacket {
1910 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1912 version: Readable::read(r)?,
1914 let mut buf = [0u8;33];
1915 r.read_exact(&mut buf)?;
1916 PublicKey::from_slice(&buf)
1918 hop_data: Readable::read(r)?,
1919 hmac: Readable::read(r)?,
1924 impl_writeable_msg!(UpdateAddHTLC, {
1930 onion_routing_packet,
1932 (65537, skimmed_fee_msat, option)
1935 impl Readable for OnionMessage {
1936 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1937 let blinding_point: PublicKey = Readable::read(r)?;
1938 let len: u16 = Readable::read(r)?;
1939 let mut packet_reader = FixedLengthReader::new(r, len as u64);
1940 let onion_routing_packet: onion_message::Packet = <onion_message::Packet as LengthReadable>::read(&mut packet_reader)?;
1943 onion_routing_packet,
1948 impl Writeable for OnionMessage {
1949 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1950 self.blinding_point.write(w)?;
1951 let onion_packet_len = self.onion_routing_packet.serialized_length();
1952 (onion_packet_len as u16).write(w)?;
1953 self.onion_routing_packet.write(w)?;
1958 impl Writeable for FinalOnionHopData {
1959 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1960 self.payment_secret.0.write(w)?;
1961 HighZeroBytesDroppedBigSize(self.total_msat).write(w)
1965 impl Readable for FinalOnionHopData {
1966 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1967 let secret: [u8; 32] = Readable::read(r)?;
1968 let amt: HighZeroBytesDroppedBigSize<u64> = Readable::read(r)?;
1969 Ok(Self { payment_secret: PaymentSecret(secret), total_msat: amt.0 })
1973 impl Writeable for OutboundOnionPayload {
1974 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1976 Self::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } => {
1977 _encode_varint_length_prefixed_tlv!(w, {
1978 (2, HighZeroBytesDroppedBigSize(*amt_to_forward), required),
1979 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
1980 (6, short_channel_id, required)
1984 ref payment_data, ref payment_metadata, ref keysend_preimage, amt_msat,
1985 outgoing_cltv_value, ref custom_tlvs,
1987 // We need to update [`ln::outbound_payment::RecipientOnionFields::with_custom_tlvs`]
1988 // to reject any reserved types in the experimental range if new ones are ever
1990 let preimage = if let Some(ref preimage) = keysend_preimage {
1991 Some((5482373484, preimage.encode()))
1993 let mut custom_tlvs: Vec<&(u64, Vec<u8>)> = custom_tlvs.iter().chain(preimage.iter()).collect();
1994 custom_tlvs.sort_unstable_by_key(|(typ, _)| *typ);
1995 _encode_varint_length_prefixed_tlv!(w, {
1996 (2, HighZeroBytesDroppedBigSize(*amt_msat), required),
1997 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
1998 (8, payment_data, option),
1999 (16, payment_metadata.as_ref().map(|m| WithoutLength(m)), option)
2000 }, custom_tlvs.iter());
2007 impl Readable for InboundOnionPayload {
2008 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2009 let mut amt = HighZeroBytesDroppedBigSize(0u64);
2010 let mut cltv_value = HighZeroBytesDroppedBigSize(0u32);
2011 let mut short_id: Option<u64> = None;
2012 let mut payment_data: Option<FinalOnionHopData> = None;
2013 let mut payment_metadata: Option<WithoutLength<Vec<u8>>> = None;
2014 let mut keysend_preimage: Option<PaymentPreimage> = None;
2015 let mut custom_tlvs = Vec::new();
2017 let tlv_len = BigSize::read(r)?;
2018 let rd = FixedLengthReader::new(r, tlv_len.0);
2019 decode_tlv_stream_with_custom_tlv_decode!(rd, {
2021 (4, cltv_value, required),
2022 (6, short_id, option),
2023 (8, payment_data, option),
2024 (16, payment_metadata, option),
2025 // See https://github.com/lightning/blips/blob/master/blip-0003.md
2026 (5482373484, keysend_preimage, option)
2027 }, |msg_type: u64, msg_reader: &mut FixedLengthReader<_>| -> Result<bool, DecodeError> {
2028 if msg_type < 1 << 16 { return Ok(false) }
2029 let mut value = Vec::new();
2030 msg_reader.read_to_end(&mut value)?;
2031 custom_tlvs.push((msg_type, value));
2035 if amt.0 > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2036 if let Some(short_channel_id) = short_id {
2037 if payment_data.is_some() { return Err(DecodeError::InvalidValue) }
2038 if payment_metadata.is_some() { return Err(DecodeError::InvalidValue); }
2041 amt_to_forward: amt.0,
2042 outgoing_cltv_value: cltv_value.0,
2045 if let Some(data) = &payment_data {
2046 if data.total_msat > MAX_VALUE_MSAT {
2047 return Err(DecodeError::InvalidValue);
2052 payment_metadata: payment_metadata.map(|w| w.0),
2055 outgoing_cltv_value: cltv_value.0,
2062 // ReadableArgs because we need onion_utils::decode_next_hop to accommodate payment packets and
2063 // onion message packets.
2064 impl ReadableArgs<()> for InboundOnionPayload {
2065 fn read<R: Read>(r: &mut R, _arg: ()) -> Result<Self, DecodeError> {
2066 <Self as Readable>::read(r)
2070 impl Writeable for Ping {
2071 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2072 self.ponglen.write(w)?;
2073 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2078 impl Readable for Ping {
2079 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2081 ponglen: Readable::read(r)?,
2083 let byteslen = Readable::read(r)?;
2084 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2091 impl Writeable for Pong {
2092 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2093 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2098 impl Readable for Pong {
2099 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2102 let byteslen = Readable::read(r)?;
2103 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2110 impl Writeable for UnsignedChannelAnnouncement {
2111 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2112 self.features.write(w)?;
2113 self.chain_hash.write(w)?;
2114 self.short_channel_id.write(w)?;
2115 self.node_id_1.write(w)?;
2116 self.node_id_2.write(w)?;
2117 self.bitcoin_key_1.write(w)?;
2118 self.bitcoin_key_2.write(w)?;
2119 w.write_all(&self.excess_data[..])?;
2124 impl Readable for UnsignedChannelAnnouncement {
2125 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2127 features: Readable::read(r)?,
2128 chain_hash: Readable::read(r)?,
2129 short_channel_id: Readable::read(r)?,
2130 node_id_1: Readable::read(r)?,
2131 node_id_2: Readable::read(r)?,
2132 bitcoin_key_1: Readable::read(r)?,
2133 bitcoin_key_2: Readable::read(r)?,
2134 excess_data: read_to_end(r)?,
2139 impl_writeable!(ChannelAnnouncement, {
2142 bitcoin_signature_1,
2143 bitcoin_signature_2,
2147 impl Writeable for UnsignedChannelUpdate {
2148 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2149 // `message_flags` used to indicate presence of `htlc_maximum_msat`, but was deprecated in the spec.
2150 const MESSAGE_FLAGS: u8 = 1;
2151 self.chain_hash.write(w)?;
2152 self.short_channel_id.write(w)?;
2153 self.timestamp.write(w)?;
2154 let all_flags = self.flags as u16 | ((MESSAGE_FLAGS as u16) << 8);
2155 all_flags.write(w)?;
2156 self.cltv_expiry_delta.write(w)?;
2157 self.htlc_minimum_msat.write(w)?;
2158 self.fee_base_msat.write(w)?;
2159 self.fee_proportional_millionths.write(w)?;
2160 self.htlc_maximum_msat.write(w)?;
2161 w.write_all(&self.excess_data[..])?;
2166 impl Readable for UnsignedChannelUpdate {
2167 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2169 chain_hash: Readable::read(r)?,
2170 short_channel_id: Readable::read(r)?,
2171 timestamp: Readable::read(r)?,
2173 let flags: u16 = Readable::read(r)?;
2174 // Note: we ignore the `message_flags` for now, since it was deprecated by the spec.
2177 cltv_expiry_delta: Readable::read(r)?,
2178 htlc_minimum_msat: Readable::read(r)?,
2179 fee_base_msat: Readable::read(r)?,
2180 fee_proportional_millionths: Readable::read(r)?,
2181 htlc_maximum_msat: Readable::read(r)?,
2182 excess_data: read_to_end(r)?,
2187 impl_writeable!(ChannelUpdate, {
2192 impl Writeable for ErrorMessage {
2193 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2194 self.channel_id.write(w)?;
2195 (self.data.len() as u16).write(w)?;
2196 w.write_all(self.data.as_bytes())?;
2201 impl Readable for ErrorMessage {
2202 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2204 channel_id: Readable::read(r)?,
2206 let sz: usize = <u16 as Readable>::read(r)? as usize;
2207 let mut data = Vec::with_capacity(sz);
2209 r.read_exact(&mut data)?;
2210 match String::from_utf8(data) {
2212 Err(_) => return Err(DecodeError::InvalidValue),
2219 impl Writeable for WarningMessage {
2220 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2221 self.channel_id.write(w)?;
2222 (self.data.len() as u16).write(w)?;
2223 w.write_all(self.data.as_bytes())?;
2228 impl Readable for WarningMessage {
2229 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2231 channel_id: Readable::read(r)?,
2233 let sz: usize = <u16 as Readable>::read(r)? as usize;
2234 let mut data = Vec::with_capacity(sz);
2236 r.read_exact(&mut data)?;
2237 match String::from_utf8(data) {
2239 Err(_) => return Err(DecodeError::InvalidValue),
2246 impl Writeable for UnsignedNodeAnnouncement {
2247 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2248 self.features.write(w)?;
2249 self.timestamp.write(w)?;
2250 self.node_id.write(w)?;
2251 w.write_all(&self.rgb)?;
2252 self.alias.write(w)?;
2254 let mut addr_len = 0;
2255 for addr in self.addresses.iter() {
2256 addr_len += 1 + addr.len();
2258 (addr_len + self.excess_address_data.len() as u16).write(w)?;
2259 for addr in self.addresses.iter() {
2262 w.write_all(&self.excess_address_data[..])?;
2263 w.write_all(&self.excess_data[..])?;
2268 impl Readable for UnsignedNodeAnnouncement {
2269 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2270 let features: NodeFeatures = Readable::read(r)?;
2271 let timestamp: u32 = Readable::read(r)?;
2272 let node_id: NodeId = Readable::read(r)?;
2273 let mut rgb = [0; 3];
2274 r.read_exact(&mut rgb)?;
2275 let alias: NodeAlias = Readable::read(r)?;
2277 let addr_len: u16 = Readable::read(r)?;
2278 let mut addresses: Vec<NetAddress> = Vec::new();
2279 let mut addr_readpos = 0;
2280 let mut excess = false;
2281 let mut excess_byte = 0;
2283 if addr_len <= addr_readpos { break; }
2284 match Readable::read(r) {
2286 if addr_len < addr_readpos + 1 + addr.len() {
2287 return Err(DecodeError::BadLengthDescriptor);
2289 addr_readpos += (1 + addr.len()) as u16;
2290 addresses.push(addr);
2292 Ok(Err(unknown_descriptor)) => {
2294 excess_byte = unknown_descriptor;
2297 Err(DecodeError::ShortRead) => return Err(DecodeError::BadLengthDescriptor),
2298 Err(e) => return Err(e),
2302 let mut excess_data = vec![];
2303 let excess_address_data = if addr_readpos < addr_len {
2304 let mut excess_address_data = vec![0; (addr_len - addr_readpos) as usize];
2305 r.read_exact(&mut excess_address_data[if excess { 1 } else { 0 }..])?;
2307 excess_address_data[0] = excess_byte;
2312 excess_data.push(excess_byte);
2316 excess_data.extend(read_to_end(r)?.iter());
2317 Ok(UnsignedNodeAnnouncement {
2324 excess_address_data,
2330 impl_writeable!(NodeAnnouncement, {
2335 impl Readable for QueryShortChannelIds {
2336 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2337 let chain_hash: BlockHash = Readable::read(r)?;
2339 let encoding_len: u16 = Readable::read(r)?;
2340 let encoding_type: u8 = Readable::read(r)?;
2342 // Must be encoding_type=0 uncompressed serialization. We do not
2343 // support encoding_type=1 zlib serialization.
2344 if encoding_type != EncodingType::Uncompressed as u8 {
2345 return Err(DecodeError::UnsupportedCompression);
2348 // We expect the encoding_len to always includes the 1-byte
2349 // encoding_type and that short_channel_ids are 8-bytes each
2350 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2351 return Err(DecodeError::InvalidValue);
2354 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2355 // less the 1-byte encoding_type
2356 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2357 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2358 for _ in 0..short_channel_id_count {
2359 short_channel_ids.push(Readable::read(r)?);
2362 Ok(QueryShortChannelIds {
2369 impl Writeable for QueryShortChannelIds {
2370 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2371 // Calculated from 1-byte encoding_type plus 8-bytes per short_channel_id
2372 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2374 self.chain_hash.write(w)?;
2375 encoding_len.write(w)?;
2377 // We only support type=0 uncompressed serialization
2378 (EncodingType::Uncompressed as u8).write(w)?;
2380 for scid in self.short_channel_ids.iter() {
2388 impl_writeable_msg!(ReplyShortChannelIdsEnd, {
2393 impl QueryChannelRange {
2394 /// Calculates the overflow safe ending block height for the query.
2396 /// Overflow returns `0xffffffff`, otherwise returns `first_blocknum + number_of_blocks`.
2397 pub fn end_blocknum(&self) -> u32 {
2398 match self.first_blocknum.checked_add(self.number_of_blocks) {
2399 Some(block) => block,
2400 None => u32::max_value(),
2405 impl_writeable_msg!(QueryChannelRange, {
2411 impl Readable for ReplyChannelRange {
2412 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2413 let chain_hash: BlockHash = Readable::read(r)?;
2414 let first_blocknum: u32 = Readable::read(r)?;
2415 let number_of_blocks: u32 = Readable::read(r)?;
2416 let sync_complete: bool = Readable::read(r)?;
2418 let encoding_len: u16 = Readable::read(r)?;
2419 let encoding_type: u8 = Readable::read(r)?;
2421 // Must be encoding_type=0 uncompressed serialization. We do not
2422 // support encoding_type=1 zlib serialization.
2423 if encoding_type != EncodingType::Uncompressed as u8 {
2424 return Err(DecodeError::UnsupportedCompression);
2427 // We expect the encoding_len to always includes the 1-byte
2428 // encoding_type and that short_channel_ids are 8-bytes each
2429 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2430 return Err(DecodeError::InvalidValue);
2433 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2434 // less the 1-byte encoding_type
2435 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2436 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2437 for _ in 0..short_channel_id_count {
2438 short_channel_ids.push(Readable::read(r)?);
2441 Ok(ReplyChannelRange {
2451 impl Writeable for ReplyChannelRange {
2452 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2453 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2454 self.chain_hash.write(w)?;
2455 self.first_blocknum.write(w)?;
2456 self.number_of_blocks.write(w)?;
2457 self.sync_complete.write(w)?;
2459 encoding_len.write(w)?;
2460 (EncodingType::Uncompressed as u8).write(w)?;
2461 for scid in self.short_channel_ids.iter() {
2469 impl_writeable_msg!(GossipTimestampFilter, {
2477 use bitcoin::blockdata::constants::ChainHash;
2478 use bitcoin::{Transaction, PackedLockTime, TxIn, Script, Sequence, Witness, TxOut};
2480 use crate::ln::{PaymentPreimage, PaymentHash, PaymentSecret};
2481 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
2482 use crate::ln::msgs::{self, FinalOnionHopData, OnionErrorPacket};
2483 use crate::routing::gossip::{NodeAlias, NodeId};
2484 use crate::util::ser::{Writeable, Readable, Hostname, TransactionU16LenLimited};
2486 use bitcoin::hashes::hex::FromHex;
2487 use bitcoin::util::address::Address;
2488 use bitcoin::network::constants::Network;
2489 use bitcoin::blockdata::script::Builder;
2490 use bitcoin::blockdata::opcodes;
2491 use bitcoin::hash_types::{Txid, BlockHash};
2493 use bitcoin::secp256k1::{PublicKey,SecretKey};
2494 use bitcoin::secp256k1::{Secp256k1, Message};
2496 use crate::io::{self, Cursor};
2497 use crate::prelude::*;
2498 use core::convert::TryFrom;
2499 use core::str::FromStr;
2501 use crate::chain::transaction::OutPoint;
2504 fn encoding_channel_reestablish() {
2506 let secp_ctx = Secp256k1::new();
2507 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2510 let cr = msgs::ChannelReestablish {
2511 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],
2512 next_local_commitment_number: 3,
2513 next_remote_commitment_number: 4,
2514 your_last_per_commitment_secret: [9;32],
2515 my_current_per_commitment_point: public_key,
2516 next_funding_txid: None,
2519 let encoded_value = cr.encode();
2523 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
2524 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2525 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2526 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
2527 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
2533 fn encoding_channel_reestablish_with_next_funding_txid() {
2535 let secp_ctx = Secp256k1::new();
2536 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2539 let cr = msgs::ChannelReestablish {
2540 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],
2541 next_local_commitment_number: 3,
2542 next_remote_commitment_number: 4,
2543 your_last_per_commitment_secret: [9;32],
2544 my_current_per_commitment_point: public_key,
2545 next_funding_txid: Some(Txid::from_hash(bitcoin::hashes::Hash::from_slice(&[
2546 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,
2550 let encoded_value = cr.encode();
2554 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
2555 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2556 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2557 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
2558 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
2559 0, // Type (next_funding_txid)
2561 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
2566 macro_rules! get_keys_from {
2567 ($slice: expr, $secp_ctx: expr) => {
2569 let privkey = SecretKey::from_slice(&hex::decode($slice).unwrap()[..]).unwrap();
2570 let pubkey = PublicKey::from_secret_key(&$secp_ctx, &privkey);
2576 macro_rules! get_sig_on {
2577 ($privkey: expr, $ctx: expr, $string: expr) => {
2579 let sighash = Message::from_slice(&$string.into_bytes()[..]).unwrap();
2580 $ctx.sign_ecdsa(&sighash, &$privkey)
2586 fn encoding_announcement_signatures() {
2587 let secp_ctx = Secp256k1::new();
2588 let (privkey, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2589 let sig_1 = get_sig_on!(privkey, secp_ctx, String::from("01010101010101010101010101010101"));
2590 let sig_2 = get_sig_on!(privkey, secp_ctx, String::from("02020202020202020202020202020202"));
2591 let announcement_signatures = msgs::AnnouncementSignatures {
2592 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],
2593 short_channel_id: 2316138423780173,
2594 node_signature: sig_1,
2595 bitcoin_signature: sig_2,
2598 let encoded_value = announcement_signatures.encode();
2599 assert_eq!(encoded_value, hex::decode("040000000000000005000000000000000600000000000000070000000000000000083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073acf9953cef4700860f5967838eba2bae89288ad188ebf8b20bf995c3ea53a26df1876d0a3a0e13172ba286a673140190c02ba9da60a2e43a745188c8a83c7f3ef").unwrap());
2602 fn do_encoding_channel_announcement(unknown_features_bits: bool, excess_data: bool) {
2603 let secp_ctx = Secp256k1::new();
2604 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2605 let (privkey_2, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2606 let (privkey_3, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2607 let (privkey_4, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2608 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2609 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
2610 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
2611 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
2612 let mut features = ChannelFeatures::empty();
2613 if unknown_features_bits {
2614 features = ChannelFeatures::from_le_bytes(vec![0xFF, 0xFF]);
2616 let unsigned_channel_announcement = msgs::UnsignedChannelAnnouncement {
2618 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2619 short_channel_id: 2316138423780173,
2620 node_id_1: NodeId::from_pubkey(&pubkey_1),
2621 node_id_2: NodeId::from_pubkey(&pubkey_2),
2622 bitcoin_key_1: NodeId::from_pubkey(&pubkey_3),
2623 bitcoin_key_2: NodeId::from_pubkey(&pubkey_4),
2624 excess_data: if excess_data { vec![10, 0, 0, 20, 0, 0, 30, 0, 0, 40] } else { Vec::new() },
2626 let channel_announcement = msgs::ChannelAnnouncement {
2627 node_signature_1: sig_1,
2628 node_signature_2: sig_2,
2629 bitcoin_signature_1: sig_3,
2630 bitcoin_signature_2: sig_4,
2631 contents: unsigned_channel_announcement,
2633 let encoded_value = channel_announcement.encode();
2634 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a1735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap();
2635 if unknown_features_bits {
2636 target_value.append(&mut hex::decode("0002ffff").unwrap());
2638 target_value.append(&mut hex::decode("0000").unwrap());
2640 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2641 target_value.append(&mut hex::decode("00083a840000034d031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
2643 target_value.append(&mut hex::decode("0a00001400001e000028").unwrap());
2645 assert_eq!(encoded_value, target_value);
2649 fn encoding_channel_announcement() {
2650 do_encoding_channel_announcement(true, false);
2651 do_encoding_channel_announcement(false, true);
2652 do_encoding_channel_announcement(false, false);
2653 do_encoding_channel_announcement(true, true);
2656 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) {
2657 let secp_ctx = Secp256k1::new();
2658 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2659 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2660 let features = if unknown_features_bits {
2661 NodeFeatures::from_le_bytes(vec![0xFF, 0xFF])
2663 // Set to some features we may support
2664 NodeFeatures::from_le_bytes(vec![2 | 1 << 5])
2666 let mut addresses = Vec::new();
2668 addresses.push(msgs::NetAddress::IPv4 {
2669 addr: [255, 254, 253, 252],
2674 addresses.push(msgs::NetAddress::IPv6 {
2675 addr: [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240],
2680 addresses.push(msgs::NetAddress::OnionV2(
2681 [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 38, 7]
2685 addresses.push(msgs::NetAddress::OnionV3 {
2686 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],
2693 addresses.push(msgs::NetAddress::Hostname {
2694 hostname: Hostname::try_from(String::from("host")).unwrap(),
2698 let mut addr_len = 0;
2699 for addr in &addresses {
2700 addr_len += addr.len() + 1;
2702 let unsigned_node_announcement = msgs::UnsignedNodeAnnouncement {
2704 timestamp: 20190119,
2705 node_id: NodeId::from_pubkey(&pubkey_1),
2707 alias: NodeAlias([16;32]),
2709 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() },
2710 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() },
2712 addr_len += unsigned_node_announcement.excess_address_data.len() as u16;
2713 let node_announcement = msgs::NodeAnnouncement {
2715 contents: unsigned_node_announcement,
2717 let encoded_value = node_announcement.encode();
2718 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
2719 if unknown_features_bits {
2720 target_value.append(&mut hex::decode("0002ffff").unwrap());
2722 target_value.append(&mut hex::decode("000122").unwrap());
2724 target_value.append(&mut hex::decode("013413a7031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f2020201010101010101010101010101010101010101010101010101010101010101010").unwrap());
2725 target_value.append(&mut vec![(addr_len >> 8) as u8, addr_len as u8]);
2727 target_value.append(&mut hex::decode("01fffefdfc2607").unwrap());
2730 target_value.append(&mut hex::decode("02fffefdfcfbfaf9f8f7f6f5f4f3f2f1f02607").unwrap());
2733 target_value.append(&mut hex::decode("03fffefdfcfbfaf9f8f7f62607").unwrap());
2736 target_value.append(&mut hex::decode("04fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0efeeedecebeae9e8e7e6e5e4e3e2e1e00020102607").unwrap());
2739 target_value.append(&mut hex::decode("0504686f73742607").unwrap());
2741 if excess_address_data {
2742 target_value.append(&mut hex::decode("216c280b5395a2546e7e4b2663e04f811622f15a4f92e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d269").unwrap());
2745 target_value.append(&mut hex::decode("3b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
2747 assert_eq!(encoded_value, target_value);
2751 fn encoding_node_announcement() {
2752 do_encoding_node_announcement(true, true, true, true, true, true, true, true);
2753 do_encoding_node_announcement(false, false, false, false, false, false, false, false);
2754 do_encoding_node_announcement(false, true, false, false, false, false, false, false);
2755 do_encoding_node_announcement(false, false, true, false, false, false, false, false);
2756 do_encoding_node_announcement(false, false, false, true, false, false, false, false);
2757 do_encoding_node_announcement(false, false, false, false, true, false, false, false);
2758 do_encoding_node_announcement(false, false, false, false, false, true, false, false);
2759 do_encoding_node_announcement(false, false, false, false, false, false, true, false);
2760 do_encoding_node_announcement(false, true, false, true, false, false, true, false);
2761 do_encoding_node_announcement(false, false, true, false, true, false, false, false);
2764 fn do_encoding_channel_update(direction: bool, disable: bool, excess_data: bool) {
2765 let secp_ctx = Secp256k1::new();
2766 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2767 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2768 let unsigned_channel_update = msgs::UnsignedChannelUpdate {
2769 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2770 short_channel_id: 2316138423780173,
2771 timestamp: 20190119,
2772 flags: if direction { 1 } else { 0 } | if disable { 1 << 1 } else { 0 },
2773 cltv_expiry_delta: 144,
2774 htlc_minimum_msat: 1000000,
2775 htlc_maximum_msat: 131355275467161,
2776 fee_base_msat: 10000,
2777 fee_proportional_millionths: 20,
2778 excess_data: if excess_data { vec![0, 0, 0, 0, 59, 154, 202, 0] } else { Vec::new() }
2780 let channel_update = msgs::ChannelUpdate {
2782 contents: unsigned_channel_update
2784 let encoded_value = channel_update.encode();
2785 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
2786 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2787 target_value.append(&mut hex::decode("00083a840000034d013413a7").unwrap());
2788 target_value.append(&mut hex::decode("01").unwrap());
2789 target_value.append(&mut hex::decode("00").unwrap());
2791 let flag = target_value.last_mut().unwrap();
2795 let flag = target_value.last_mut().unwrap();
2796 *flag = *flag | 1 << 1;
2798 target_value.append(&mut hex::decode("009000000000000f42400000271000000014").unwrap());
2799 target_value.append(&mut hex::decode("0000777788889999").unwrap());
2801 target_value.append(&mut hex::decode("000000003b9aca00").unwrap());
2803 assert_eq!(encoded_value, target_value);
2807 fn encoding_channel_update() {
2808 do_encoding_channel_update(false, false, false);
2809 do_encoding_channel_update(false, false, true);
2810 do_encoding_channel_update(true, false, false);
2811 do_encoding_channel_update(true, false, true);
2812 do_encoding_channel_update(false, true, false);
2813 do_encoding_channel_update(false, true, true);
2814 do_encoding_channel_update(true, true, false);
2815 do_encoding_channel_update(true, true, true);
2818 fn do_encoding_open_channel(random_bit: bool, shutdown: bool, incl_chan_type: bool) {
2819 let secp_ctx = Secp256k1::new();
2820 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2821 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2822 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2823 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2824 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
2825 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
2826 let open_channel = msgs::OpenChannel {
2827 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2828 temporary_channel_id: [2; 32],
2829 funding_satoshis: 1311768467284833366,
2830 push_msat: 2536655962884945560,
2831 dust_limit_satoshis: 3608586615801332854,
2832 max_htlc_value_in_flight_msat: 8517154655701053848,
2833 channel_reserve_satoshis: 8665828695742877976,
2834 htlc_minimum_msat: 2316138423780173,
2835 feerate_per_kw: 821716,
2836 to_self_delay: 49340,
2837 max_accepted_htlcs: 49340,
2838 funding_pubkey: pubkey_1,
2839 revocation_basepoint: pubkey_2,
2840 payment_point: pubkey_3,
2841 delayed_payment_basepoint: pubkey_4,
2842 htlc_basepoint: pubkey_5,
2843 first_per_commitment_point: pubkey_6,
2844 channel_flags: if random_bit { 1 << 5 } else { 0 },
2845 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
2846 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
2848 let encoded_value = open_channel.encode();
2849 let mut target_value = Vec::new();
2850 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2851 target_value.append(&mut hex::decode("02020202020202020202020202020202020202020202020202020202020202021234567890123456233403289122369832144668701144767633030896203198784335490624111800083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
2853 target_value.append(&mut hex::decode("20").unwrap());
2855 target_value.append(&mut hex::decode("00").unwrap());
2858 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
2861 target_value.append(&mut hex::decode("0100").unwrap());
2863 assert_eq!(encoded_value, target_value);
2867 fn encoding_open_channel() {
2868 do_encoding_open_channel(false, false, false);
2869 do_encoding_open_channel(false, false, true);
2870 do_encoding_open_channel(false, true, false);
2871 do_encoding_open_channel(false, true, true);
2872 do_encoding_open_channel(true, false, false);
2873 do_encoding_open_channel(true, false, true);
2874 do_encoding_open_channel(true, true, false);
2875 do_encoding_open_channel(true, true, true);
2878 fn do_encoding_open_channelv2(random_bit: bool, shutdown: bool, incl_chan_type: bool, require_confirmed_inputs: bool) {
2879 let secp_ctx = Secp256k1::new();
2880 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2881 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2882 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2883 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2884 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
2885 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
2886 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
2887 let open_channelv2 = msgs::OpenChannelV2 {
2888 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2889 temporary_channel_id: [2; 32],
2890 funding_feerate_sat_per_1000_weight: 821716,
2891 commitment_feerate_sat_per_1000_weight: 821716,
2892 funding_satoshis: 1311768467284833366,
2893 dust_limit_satoshis: 3608586615801332854,
2894 max_htlc_value_in_flight_msat: 8517154655701053848,
2895 htlc_minimum_msat: 2316138423780173,
2896 to_self_delay: 49340,
2897 max_accepted_htlcs: 49340,
2898 locktime: 305419896,
2899 funding_pubkey: pubkey_1,
2900 revocation_basepoint: pubkey_2,
2901 payment_basepoint: pubkey_3,
2902 delayed_payment_basepoint: pubkey_4,
2903 htlc_basepoint: pubkey_5,
2904 first_per_commitment_point: pubkey_6,
2905 second_per_commitment_point: pubkey_7,
2906 channel_flags: if random_bit { 1 << 5 } else { 0 },
2907 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
2908 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
2909 require_confirmed_inputs: if require_confirmed_inputs { Some(()) } else { None },
2911 let encoded_value = open_channelv2.encode();
2912 let mut target_value = Vec::new();
2913 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2914 target_value.append(&mut hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap());
2915 target_value.append(&mut hex::decode("000c89d4").unwrap());
2916 target_value.append(&mut hex::decode("000c89d4").unwrap());
2917 target_value.append(&mut hex::decode("1234567890123456").unwrap());
2918 target_value.append(&mut hex::decode("3214466870114476").unwrap());
2919 target_value.append(&mut hex::decode("7633030896203198").unwrap());
2920 target_value.append(&mut hex::decode("00083a840000034d").unwrap());
2921 target_value.append(&mut hex::decode("c0bc").unwrap());
2922 target_value.append(&mut hex::decode("c0bc").unwrap());
2923 target_value.append(&mut hex::decode("12345678").unwrap());
2924 target_value.append(&mut hex::decode("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap());
2925 target_value.append(&mut hex::decode("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap());
2926 target_value.append(&mut hex::decode("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap());
2927 target_value.append(&mut hex::decode("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
2928 target_value.append(&mut hex::decode("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap());
2929 target_value.append(&mut hex::decode("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
2930 target_value.append(&mut hex::decode("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap());
2933 target_value.append(&mut hex::decode("20").unwrap());
2935 target_value.append(&mut hex::decode("00").unwrap());
2938 target_value.append(&mut hex::decode("001b").unwrap()); // Type 0 + Length 27
2939 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
2942 target_value.append(&mut hex::decode("0100").unwrap());
2944 if require_confirmed_inputs {
2945 target_value.append(&mut hex::decode("0200").unwrap());
2947 assert_eq!(encoded_value, target_value);
2951 fn encoding_open_channelv2() {
2952 do_encoding_open_channelv2(false, false, false, false);
2953 do_encoding_open_channelv2(false, false, false, true);
2954 do_encoding_open_channelv2(false, false, true, false);
2955 do_encoding_open_channelv2(false, false, true, true);
2956 do_encoding_open_channelv2(false, true, false, false);
2957 do_encoding_open_channelv2(false, true, false, true);
2958 do_encoding_open_channelv2(false, true, true, false);
2959 do_encoding_open_channelv2(false, true, true, true);
2960 do_encoding_open_channelv2(true, false, false, false);
2961 do_encoding_open_channelv2(true, false, false, true);
2962 do_encoding_open_channelv2(true, false, true, false);
2963 do_encoding_open_channelv2(true, false, true, true);
2964 do_encoding_open_channelv2(true, true, false, false);
2965 do_encoding_open_channelv2(true, true, false, true);
2966 do_encoding_open_channelv2(true, true, true, false);
2967 do_encoding_open_channelv2(true, true, true, true);
2970 fn do_encoding_accept_channel(shutdown: bool) {
2971 let secp_ctx = Secp256k1::new();
2972 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2973 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2974 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2975 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2976 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
2977 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
2978 let accept_channel = msgs::AcceptChannel {
2979 temporary_channel_id: [2; 32],
2980 dust_limit_satoshis: 1311768467284833366,
2981 max_htlc_value_in_flight_msat: 2536655962884945560,
2982 channel_reserve_satoshis: 3608586615801332854,
2983 htlc_minimum_msat: 2316138423780173,
2984 minimum_depth: 821716,
2985 to_self_delay: 49340,
2986 max_accepted_htlcs: 49340,
2987 funding_pubkey: pubkey_1,
2988 revocation_basepoint: pubkey_2,
2989 payment_point: pubkey_3,
2990 delayed_payment_basepoint: pubkey_4,
2991 htlc_basepoint: pubkey_5,
2992 first_per_commitment_point: pubkey_6,
2993 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
2996 next_local_nonce: None,
2998 let encoded_value = accept_channel.encode();
2999 let mut target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020212345678901234562334032891223698321446687011447600083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap();
3001 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3003 assert_eq!(encoded_value, target_value);
3007 fn encoding_accept_channel() {
3008 do_encoding_accept_channel(false);
3009 do_encoding_accept_channel(true);
3012 fn do_encoding_accept_channelv2(shutdown: bool) {
3013 let secp_ctx = Secp256k1::new();
3014 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3015 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3016 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3017 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3018 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3019 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3020 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3021 let accept_channelv2 = msgs::AcceptChannelV2 {
3022 temporary_channel_id: [2; 32],
3023 funding_satoshis: 1311768467284833366,
3024 dust_limit_satoshis: 1311768467284833366,
3025 max_htlc_value_in_flight_msat: 2536655962884945560,
3026 htlc_minimum_msat: 2316138423780173,
3027 minimum_depth: 821716,
3028 to_self_delay: 49340,
3029 max_accepted_htlcs: 49340,
3030 funding_pubkey: pubkey_1,
3031 revocation_basepoint: pubkey_2,
3032 payment_basepoint: pubkey_3,
3033 delayed_payment_basepoint: pubkey_4,
3034 htlc_basepoint: pubkey_5,
3035 first_per_commitment_point: pubkey_6,
3036 second_per_commitment_point: pubkey_7,
3037 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3039 require_confirmed_inputs: None,
3041 let encoded_value = accept_channelv2.encode();
3042 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // temporary_channel_id
3043 target_value.append(&mut hex::decode("1234567890123456").unwrap()); // funding_satoshis
3044 target_value.append(&mut hex::decode("1234567890123456").unwrap()); // dust_limit_satoshis
3045 target_value.append(&mut hex::decode("2334032891223698").unwrap()); // max_htlc_value_in_flight_msat
3046 target_value.append(&mut hex::decode("00083a840000034d").unwrap()); // htlc_minimum_msat
3047 target_value.append(&mut hex::decode("000c89d4").unwrap()); // minimum_depth
3048 target_value.append(&mut hex::decode("c0bc").unwrap()); // to_self_delay
3049 target_value.append(&mut hex::decode("c0bc").unwrap()); // max_accepted_htlcs
3050 target_value.append(&mut hex::decode("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap()); // funding_pubkey
3051 target_value.append(&mut hex::decode("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap()); // revocation_basepoint
3052 target_value.append(&mut hex::decode("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap()); // payment_basepoint
3053 target_value.append(&mut hex::decode("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap()); // delayed_payment_basepoint
3054 target_value.append(&mut hex::decode("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap()); // htlc_basepoint
3055 target_value.append(&mut hex::decode("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap()); // first_per_commitment_point
3056 target_value.append(&mut hex::decode("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap()); // second_per_commitment_point
3058 target_value.append(&mut hex::decode("001b").unwrap()); // Type 0 + Length 27
3059 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3061 assert_eq!(encoded_value, target_value);
3065 fn encoding_accept_channelv2() {
3066 do_encoding_accept_channelv2(false);
3067 do_encoding_accept_channelv2(true);
3071 fn encoding_funding_created() {
3072 let secp_ctx = Secp256k1::new();
3073 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3074 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3075 let funding_created = msgs::FundingCreated {
3076 temporary_channel_id: [2; 32],
3077 funding_txid: Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3078 funding_output_index: 255,
3081 partial_signature_with_nonce: None,
3083 next_local_nonce: None,
3085 let encoded_value = funding_created.encode();
3086 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202026e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c200ffd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3087 assert_eq!(encoded_value, target_value);
3091 fn encoding_funding_signed() {
3092 let secp_ctx = Secp256k1::new();
3093 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3094 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3095 let funding_signed = msgs::FundingSigned {
3096 channel_id: [2; 32],
3099 partial_signature_with_nonce: None,
3101 let encoded_value = funding_signed.encode();
3102 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3103 assert_eq!(encoded_value, target_value);
3107 fn encoding_channel_ready() {
3108 let secp_ctx = Secp256k1::new();
3109 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3110 let channel_ready = msgs::ChannelReady {
3111 channel_id: [2; 32],
3112 next_per_commitment_point: pubkey_1,
3113 short_channel_id_alias: None,
3115 let encoded_value = channel_ready.encode();
3116 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3117 assert_eq!(encoded_value, target_value);
3121 fn encoding_tx_add_input() {
3122 let tx_add_input = msgs::TxAddInput {
3123 channel_id: [2; 32],
3124 serial_id: 4886718345,
3125 prevtx: TransactionU16LenLimited::new(Transaction {
3127 lock_time: PackedLockTime(0),
3129 previous_output: OutPoint { txid: Txid::from_hex("305bab643ee297b8b6b76b320792c8223d55082122cb606bf89382146ced9c77").unwrap(), index: 2 }.into_bitcoin_outpoint(),
3130 script_sig: Script::new(),
3131 sequence: Sequence(0xfffffffd),
3132 witness: Witness::from_vec(vec![
3133 hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3134 hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3139 script_pubkey: Address::from_str("bc1qzlffunw52jav8vwdu5x3jfk6sr8u22rmq3xzw2").unwrap().script_pubkey(),
3143 script_pubkey: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().script_pubkey(),
3147 prevtx_out: 305419896,
3148 sequence: 305419896,
3150 let encoded_value = tx_add_input.encode();
3151 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000000012345678900de02000000000101779ced6c148293f86b60cb222108553d22c89207326bb7b6b897e23e64ab5b300200000000fdffffff0236dbc1000000000016001417d29e4dd454bac3b1cde50d1926da80cfc5287b9cbd03000000000016001436ec78d514df462da95e6a00c24daa8915362d420247304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701210301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944000000001234567812345678").unwrap();
3152 assert_eq!(encoded_value, target_value);
3156 fn encoding_tx_add_output() {
3157 let tx_add_output = msgs::TxAddOutput {
3158 channel_id: [2; 32],
3159 serial_id: 4886718345,
3161 script: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().script_pubkey(),
3163 let encoded_value = tx_add_output.encode();
3164 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000000012345678900000001234567890016001436ec78d514df462da95e6a00c24daa8915362d42").unwrap();
3165 assert_eq!(encoded_value, target_value);
3169 fn encoding_tx_remove_input() {
3170 let tx_remove_input = msgs::TxRemoveInput {
3171 channel_id: [2; 32],
3172 serial_id: 4886718345,
3174 let encoded_value = tx_remove_input.encode();
3175 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3176 assert_eq!(encoded_value, target_value);
3180 fn encoding_tx_remove_output() {
3181 let tx_remove_output = msgs::TxRemoveOutput {
3182 channel_id: [2; 32],
3183 serial_id: 4886718345,
3185 let encoded_value = tx_remove_output.encode();
3186 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3187 assert_eq!(encoded_value, target_value);
3191 fn encoding_tx_complete() {
3192 let tx_complete = msgs::TxComplete {
3193 channel_id: [2; 32],
3195 let encoded_value = tx_complete.encode();
3196 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3197 assert_eq!(encoded_value, target_value);
3201 fn encoding_tx_signatures() {
3202 let tx_signatures = msgs::TxSignatures {
3203 channel_id: [2; 32],
3204 tx_hash: Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3206 Witness::from_vec(vec![
3207 hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3208 hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3209 Witness::from_vec(vec![
3210 hex::decode("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap(),
3211 hex::decode("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap()]),
3214 let encoded_value = tx_signatures.encode();
3215 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3216 target_value.append(&mut hex::decode("6e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c2").unwrap()); // tx_hash (sha256) (big endian byte order)
3217 target_value.append(&mut hex::decode("0002").unwrap()); // num_witnesses (u16)
3219 target_value.append(&mut hex::decode("006b").unwrap()); // len of witness_data
3220 target_value.append(&mut hex::decode("02").unwrap()); // num_witness_elements (VarInt)
3221 target_value.append(&mut hex::decode("47").unwrap()); // len of witness element data (VarInt)
3222 target_value.append(&mut hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap());
3223 target_value.append(&mut hex::decode("21").unwrap()); // len of witness element data (VarInt)
3224 target_value.append(&mut hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap());
3226 target_value.append(&mut hex::decode("006c").unwrap()); // len of witness_data
3227 target_value.append(&mut hex::decode("02").unwrap()); // num_witness_elements (VarInt)
3228 target_value.append(&mut hex::decode("48").unwrap()); // len of witness element data (VarInt)
3229 target_value.append(&mut hex::decode("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap());
3230 target_value.append(&mut hex::decode("21").unwrap()); // len of witness element data (VarInt)
3231 target_value.append(&mut hex::decode("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap());
3232 assert_eq!(encoded_value, target_value);
3235 fn do_encoding_tx_init_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3236 let tx_init_rbf = msgs::TxInitRbf {
3237 channel_id: [2; 32],
3238 locktime: 305419896,
3239 feerate_sat_per_1000_weight: 20190119,
3240 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3242 let encoded_value = tx_init_rbf.encode();
3243 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3244 target_value.append(&mut hex::decode("12345678").unwrap()); // locktime
3245 target_value.append(&mut hex::decode("013413a7").unwrap()); // feerate_sat_per_1000_weight
3246 if let Some((_, target)) = funding_value_with_hex_target {
3247 target_value.push(0x00); // Type
3248 target_value.push(target.len() as u8 / 2); // Length
3249 target_value.append(&mut hex::decode(target).unwrap()); // Value (i64)
3251 assert_eq!(encoded_value, target_value);
3255 fn encoding_tx_init_rbf() {
3256 do_encoding_tx_init_rbf(Some((1311768467284833366, "1234567890123456")));
3257 do_encoding_tx_init_rbf(Some((13117684672, "000000030DDFFBC0")));
3258 do_encoding_tx_init_rbf(None);
3261 fn do_encoding_tx_ack_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3262 let tx_ack_rbf = msgs::TxAckRbf {
3263 channel_id: [2; 32],
3264 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3266 let encoded_value = tx_ack_rbf.encode();
3267 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3268 if let Some((_, target)) = funding_value_with_hex_target {
3269 target_value.push(0x00); // Type
3270 target_value.push(target.len() as u8 / 2); // Length
3271 target_value.append(&mut hex::decode(target).unwrap()); // Value (i64)
3273 assert_eq!(encoded_value, target_value);
3277 fn encoding_tx_ack_rbf() {
3278 do_encoding_tx_ack_rbf(Some((1311768467284833366, "1234567890123456")));
3279 do_encoding_tx_ack_rbf(Some((13117684672, "000000030DDFFBC0")));
3280 do_encoding_tx_ack_rbf(None);
3284 fn encoding_tx_abort() {
3285 let tx_abort = msgs::TxAbort {
3286 channel_id: [2; 32],
3287 data: hex::decode("54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap(),
3289 let encoded_value = tx_abort.encode();
3290 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202002C54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap();
3291 assert_eq!(encoded_value, target_value);
3294 fn do_encoding_shutdown(script_type: u8) {
3295 let secp_ctx = Secp256k1::new();
3296 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3297 let script = Builder::new().push_opcode(opcodes::OP_TRUE).into_script();
3298 let shutdown = msgs::Shutdown {
3299 channel_id: [2; 32],
3301 if script_type == 1 { Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey() }
3302 else if script_type == 2 { Address::p2sh(&script, Network::Testnet).unwrap().script_pubkey() }
3303 else if script_type == 3 { Address::p2wpkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).unwrap().script_pubkey() }
3304 else { Address::p2wsh(&script, Network::Testnet).script_pubkey() },
3306 let encoded_value = shutdown.encode();
3307 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3308 if script_type == 1 {
3309 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3310 } else if script_type == 2 {
3311 target_value.append(&mut hex::decode("0017a914da1745e9b549bd0bfa1a569971c77eba30cd5a4b87").unwrap());
3312 } else if script_type == 3 {
3313 target_value.append(&mut hex::decode("0016001479b000887626b294a914501a4cd226b58b235983").unwrap());
3314 } else if script_type == 4 {
3315 target_value.append(&mut hex::decode("002200204ae81572f06e1b88fd5ced7a1a000945432e83e1551e6f721ee9c00b8cc33260").unwrap());
3317 assert_eq!(encoded_value, target_value);
3321 fn encoding_shutdown() {
3322 do_encoding_shutdown(1);
3323 do_encoding_shutdown(2);
3324 do_encoding_shutdown(3);
3325 do_encoding_shutdown(4);
3329 fn encoding_closing_signed() {
3330 let secp_ctx = Secp256k1::new();
3331 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3332 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3333 let closing_signed = msgs::ClosingSigned {
3334 channel_id: [2; 32],
3335 fee_satoshis: 2316138423780173,
3339 let encoded_value = closing_signed.encode();
3340 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3341 assert_eq!(encoded_value, target_value);
3342 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value)).unwrap(), closing_signed);
3344 let closing_signed_with_range = msgs::ClosingSigned {
3345 channel_id: [2; 32],
3346 fee_satoshis: 2316138423780173,
3348 fee_range: Some(msgs::ClosingSignedFeeRange {
3349 min_fee_satoshis: 0xdeadbeef,
3350 max_fee_satoshis: 0x1badcafe01234567,
3353 let encoded_value_with_range = closing_signed_with_range.encode();
3354 let target_value_with_range = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a011000000000deadbeef1badcafe01234567").unwrap();
3355 assert_eq!(encoded_value_with_range, target_value_with_range);
3356 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value_with_range)).unwrap(),
3357 closing_signed_with_range);
3361 fn encoding_update_add_htlc() {
3362 let secp_ctx = Secp256k1::new();
3363 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3364 let onion_routing_packet = msgs::OnionPacket {
3366 public_key: Ok(pubkey_1),
3367 hop_data: [1; 20*65],
3370 let update_add_htlc = msgs::UpdateAddHTLC {
3371 channel_id: [2; 32],
3372 htlc_id: 2316138423780173,
3373 amount_msat: 3608586615801332854,
3374 payment_hash: PaymentHash([1; 32]),
3375 cltv_expiry: 821716,
3376 onion_routing_packet,
3377 skimmed_fee_msat: None,
3379 let encoded_value = update_add_htlc.encode();
3380 let target_value = hex::decode("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").unwrap();
3381 assert_eq!(encoded_value, target_value);
3385 fn encoding_update_fulfill_htlc() {
3386 let update_fulfill_htlc = msgs::UpdateFulfillHTLC {
3387 channel_id: [2; 32],
3388 htlc_id: 2316138423780173,
3389 payment_preimage: PaymentPreimage([1; 32]),
3391 let encoded_value = update_fulfill_htlc.encode();
3392 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d0101010101010101010101010101010101010101010101010101010101010101").unwrap();
3393 assert_eq!(encoded_value, target_value);
3397 fn encoding_update_fail_htlc() {
3398 let reason = OnionErrorPacket {
3399 data: [1; 32].to_vec(),
3401 let update_fail_htlc = msgs::UpdateFailHTLC {
3402 channel_id: [2; 32],
3403 htlc_id: 2316138423780173,
3406 let encoded_value = update_fail_htlc.encode();
3407 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d00200101010101010101010101010101010101010101010101010101010101010101").unwrap();
3408 assert_eq!(encoded_value, target_value);
3412 fn encoding_update_fail_malformed_htlc() {
3413 let update_fail_malformed_htlc = msgs::UpdateFailMalformedHTLC {
3414 channel_id: [2; 32],
3415 htlc_id: 2316138423780173,
3416 sha256_of_onion: [1; 32],
3419 let encoded_value = update_fail_malformed_htlc.encode();
3420 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d010101010101010101010101010101010101010101010101010101010101010100ff").unwrap();
3421 assert_eq!(encoded_value, target_value);
3424 fn do_encoding_commitment_signed(htlcs: bool) {
3425 let secp_ctx = Secp256k1::new();
3426 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3427 let (privkey_2, _) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3428 let (privkey_3, _) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3429 let (privkey_4, _) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3430 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3431 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
3432 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
3433 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
3434 let commitment_signed = msgs::CommitmentSigned {
3435 channel_id: [2; 32],
3437 htlc_signatures: if htlcs { vec![sig_2, sig_3, sig_4] } else { Vec::new() },
3439 partial_signature_with_nonce: None,
3441 let encoded_value = commitment_signed.encode();
3442 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3444 target_value.append(&mut hex::decode("00031735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
3446 target_value.append(&mut hex::decode("0000").unwrap());
3448 assert_eq!(encoded_value, target_value);
3452 fn encoding_commitment_signed() {
3453 do_encoding_commitment_signed(true);
3454 do_encoding_commitment_signed(false);
3458 fn encoding_revoke_and_ack() {
3459 let secp_ctx = Secp256k1::new();
3460 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3461 let raa = msgs::RevokeAndACK {
3462 channel_id: [2; 32],
3463 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],
3464 next_per_commitment_point: pubkey_1,
3466 next_local_nonce: None,
3468 let encoded_value = raa.encode();
3469 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020101010101010101010101010101010101010101010101010101010101010101031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3470 assert_eq!(encoded_value, target_value);
3474 fn encoding_update_fee() {
3475 let update_fee = msgs::UpdateFee {
3476 channel_id: [2; 32],
3477 feerate_per_kw: 20190119,
3479 let encoded_value = update_fee.encode();
3480 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202013413a7").unwrap();
3481 assert_eq!(encoded_value, target_value);
3485 fn encoding_init() {
3486 let mainnet_hash = ChainHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap();
3487 assert_eq!(msgs::Init {
3488 features: InitFeatures::from_le_bytes(vec![0xFF, 0xFF, 0xFF]),
3489 networks: Some(vec![mainnet_hash]),
3490 remote_network_address: None,
3491 }.encode(), hex::decode("00023fff0003ffffff01206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3492 assert_eq!(msgs::Init {
3493 features: InitFeatures::from_le_bytes(vec![0xFF]),
3495 remote_network_address: None,
3496 }.encode(), hex::decode("0001ff0001ff").unwrap());
3497 assert_eq!(msgs::Init {
3498 features: InitFeatures::from_le_bytes(vec![]),
3499 networks: Some(vec![mainnet_hash]),
3500 remote_network_address: None,
3501 }.encode(), hex::decode("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3502 assert_eq!(msgs::Init {
3503 features: InitFeatures::from_le_bytes(vec![]),
3504 networks: Some(vec![ChainHash::from(&[1; 32][..]), ChainHash::from(&[2; 32][..])]),
3505 remote_network_address: None,
3506 }.encode(), hex::decode("00000000014001010101010101010101010101010101010101010101010101010101010101010202020202020202020202020202020202020202020202020202020202020202").unwrap());
3507 let init_msg = msgs::Init { features: InitFeatures::from_le_bytes(vec![]),
3508 networks: Some(vec![mainnet_hash]),
3509 remote_network_address: Some(msgs::NetAddress::IPv4 {
3510 addr: [127, 0, 0, 1],
3514 let encoded_value = init_msg.encode();
3515 let target_value = hex::decode("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d61900000000000307017f00000103e8").unwrap();
3516 assert_eq!(encoded_value, target_value);
3517 assert_eq!(msgs::Init::read(&mut Cursor::new(&target_value)).unwrap(), init_msg);
3521 fn encoding_error() {
3522 let error = msgs::ErrorMessage {
3523 channel_id: [2; 32],
3524 data: String::from("rust-lightning"),
3526 let encoded_value = error.encode();
3527 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3528 assert_eq!(encoded_value, target_value);
3532 fn encoding_warning() {
3533 let error = msgs::WarningMessage {
3534 channel_id: [2; 32],
3535 data: String::from("rust-lightning"),
3537 let encoded_value = error.encode();
3538 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3539 assert_eq!(encoded_value, target_value);
3543 fn encoding_ping() {
3544 let ping = msgs::Ping {
3548 let encoded_value = ping.encode();
3549 let target_value = hex::decode("0040004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3550 assert_eq!(encoded_value, target_value);
3554 fn encoding_pong() {
3555 let pong = msgs::Pong {
3558 let encoded_value = pong.encode();
3559 let target_value = hex::decode("004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3560 assert_eq!(encoded_value, target_value);
3564 fn encoding_nonfinal_onion_hop_data() {
3565 let outbound_msg = msgs::OutboundOnionPayload::Forward {
3566 short_channel_id: 0xdeadbeef1bad1dea,
3567 amt_to_forward: 0x0badf00d01020304,
3568 outgoing_cltv_value: 0xffffffff,
3570 let encoded_value = outbound_msg.encode();
3571 let target_value = hex::decode("1a02080badf00d010203040404ffffffff0608deadbeef1bad1dea").unwrap();
3572 assert_eq!(encoded_value, target_value);
3574 let inbound_msg = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3575 if let msgs::InboundOnionPayload::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } = inbound_msg {
3576 assert_eq!(short_channel_id, 0xdeadbeef1bad1dea);
3577 assert_eq!(amt_to_forward, 0x0badf00d01020304);
3578 assert_eq!(outgoing_cltv_value, 0xffffffff);
3579 } else { panic!(); }
3583 fn encoding_final_onion_hop_data() {
3584 let outbound_msg = msgs::OutboundOnionPayload::Receive {
3586 payment_metadata: None,
3587 keysend_preimage: None,
3588 amt_msat: 0x0badf00d01020304,
3589 outgoing_cltv_value: 0xffffffff,
3590 custom_tlvs: vec![],
3592 let encoded_value = outbound_msg.encode();
3593 let target_value = hex::decode("1002080badf00d010203040404ffffffff").unwrap();
3594 assert_eq!(encoded_value, target_value);
3596 let inbound_msg = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3597 if let msgs::InboundOnionPayload::Receive { payment_data: None, amt_msat, outgoing_cltv_value, .. } = inbound_msg {
3598 assert_eq!(amt_msat, 0x0badf00d01020304);
3599 assert_eq!(outgoing_cltv_value, 0xffffffff);
3600 } else { panic!(); }
3604 fn encoding_final_onion_hop_data_with_secret() {
3605 let expected_payment_secret = PaymentSecret([0x42u8; 32]);
3606 let outbound_msg = msgs::OutboundOnionPayload::Receive {
3607 payment_data: Some(FinalOnionHopData {
3608 payment_secret: expected_payment_secret,
3609 total_msat: 0x1badca1f
3611 payment_metadata: None,
3612 keysend_preimage: None,
3613 amt_msat: 0x0badf00d01020304,
3614 outgoing_cltv_value: 0xffffffff,
3615 custom_tlvs: vec![],
3617 let encoded_value = outbound_msg.encode();
3618 let target_value = hex::decode("3602080badf00d010203040404ffffffff082442424242424242424242424242424242424242424242424242424242424242421badca1f").unwrap();
3619 assert_eq!(encoded_value, target_value);
3621 let inbound_msg = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3622 if let msgs::InboundOnionPayload::Receive {
3623 payment_data: Some(FinalOnionHopData {
3625 total_msat: 0x1badca1f
3627 amt_msat, outgoing_cltv_value,
3628 payment_metadata: None,
3629 keysend_preimage: None,
3632 assert_eq!(payment_secret, expected_payment_secret);
3633 assert_eq!(amt_msat, 0x0badf00d01020304);
3634 assert_eq!(outgoing_cltv_value, 0xffffffff);
3635 assert_eq!(custom_tlvs, vec![]);
3636 } else { panic!(); }
3640 fn encoding_final_onion_hop_data_with_bad_custom_tlvs() {
3641 // If custom TLVs have type number within the range reserved for protocol, treat them as if
3643 let bad_type_range_tlvs = vec![
3644 ((1 << 16) - 4, vec![42]),
3645 ((1 << 16) - 2, vec![42; 32]),
3647 let mut msg = msgs::OutboundOnionPayload::Receive {
3649 payment_metadata: None,
3650 keysend_preimage: None,
3651 custom_tlvs: bad_type_range_tlvs,
3652 amt_msat: 0x0badf00d01020304,
3653 outgoing_cltv_value: 0xffffffff,
3655 let encoded_value = msg.encode();
3656 assert!(msgs::InboundOnionPayload::read(&mut Cursor::new(&encoded_value[..])).is_err());
3657 let good_type_range_tlvs = vec![
3658 ((1 << 16) - 3, vec![42]),
3659 ((1 << 16) - 1, vec![42; 32]),
3661 if let msgs::OutboundOnionPayload::Receive { ref mut custom_tlvs, .. } = msg {
3662 *custom_tlvs = good_type_range_tlvs.clone();
3664 let encoded_value = msg.encode();
3665 let inbound_msg = Readable::read(&mut Cursor::new(&encoded_value[..])).unwrap();
3667 msgs::InboundOnionPayload::Receive { custom_tlvs, .. } => assert!(custom_tlvs.is_empty()),
3673 fn encoding_final_onion_hop_data_with_custom_tlvs() {
3674 let expected_custom_tlvs = vec![
3675 (5482373483, vec![0x12, 0x34]),
3676 (5482373487, vec![0x42u8; 8]),
3678 let msg = msgs::OutboundOnionPayload::Receive {
3680 payment_metadata: None,
3681 keysend_preimage: None,
3682 custom_tlvs: expected_custom_tlvs.clone(),
3683 amt_msat: 0x0badf00d01020304,
3684 outgoing_cltv_value: 0xffffffff,
3686 let encoded_value = msg.encode();
3687 let target_value = hex::decode("2e02080badf00d010203040404ffffffffff0000000146c6616b021234ff0000000146c6616f084242424242424242").unwrap();
3688 assert_eq!(encoded_value, target_value);
3689 let inbound_msg: msgs::InboundOnionPayload = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3690 if let msgs::InboundOnionPayload::Receive {
3692 payment_metadata: None,
3693 keysend_preimage: None,
3696 outgoing_cltv_value,
3699 assert_eq!(custom_tlvs, expected_custom_tlvs);
3700 assert_eq!(amt_msat, 0x0badf00d01020304);
3701 assert_eq!(outgoing_cltv_value, 0xffffffff);
3702 } else { panic!(); }
3706 fn query_channel_range_end_blocknum() {
3707 let tests: Vec<(u32, u32, u32)> = vec![
3708 (10000, 1500, 11500),
3709 (0, 0xffffffff, 0xffffffff),
3710 (1, 0xffffffff, 0xffffffff),
3713 for (first_blocknum, number_of_blocks, expected) in tests.into_iter() {
3714 let sut = msgs::QueryChannelRange {
3715 chain_hash: BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap(),
3719 assert_eq!(sut.end_blocknum(), expected);
3724 fn encoding_query_channel_range() {
3725 let mut query_channel_range = msgs::QueryChannelRange {
3726 chain_hash: BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap(),
3727 first_blocknum: 100000,
3728 number_of_blocks: 1500,
3730 let encoded_value = query_channel_range.encode();
3731 let target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206000186a0000005dc").unwrap();
3732 assert_eq!(encoded_value, target_value);
3734 query_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3735 assert_eq!(query_channel_range.first_blocknum, 100000);
3736 assert_eq!(query_channel_range.number_of_blocks, 1500);
3740 fn encoding_reply_channel_range() {
3741 do_encoding_reply_channel_range(0);
3742 do_encoding_reply_channel_range(1);
3745 fn do_encoding_reply_channel_range(encoding_type: u8) {
3746 let mut target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206000b8a06000005dc01").unwrap();
3747 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3748 let mut reply_channel_range = msgs::ReplyChannelRange {
3749 chain_hash: expected_chain_hash,
3750 first_blocknum: 756230,
3751 number_of_blocks: 1500,
3752 sync_complete: true,
3753 short_channel_ids: vec![0x000000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
3756 if encoding_type == 0 {
3757 target_value.append(&mut hex::decode("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
3758 let encoded_value = reply_channel_range.encode();
3759 assert_eq!(encoded_value, target_value);
3761 reply_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3762 assert_eq!(reply_channel_range.chain_hash, expected_chain_hash);
3763 assert_eq!(reply_channel_range.first_blocknum, 756230);
3764 assert_eq!(reply_channel_range.number_of_blocks, 1500);
3765 assert_eq!(reply_channel_range.sync_complete, true);
3766 assert_eq!(reply_channel_range.short_channel_ids[0], 0x000000000000008e);
3767 assert_eq!(reply_channel_range.short_channel_ids[1], 0x0000000000003c69);
3768 assert_eq!(reply_channel_range.short_channel_ids[2], 0x000000000045a6c4);
3770 target_value.append(&mut hex::decode("001601789c636000833e08659309a65878be010010a9023a").unwrap());
3771 let result: Result<msgs::ReplyChannelRange, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
3772 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
3777 fn encoding_query_short_channel_ids() {
3778 do_encoding_query_short_channel_ids(0);
3779 do_encoding_query_short_channel_ids(1);
3782 fn do_encoding_query_short_channel_ids(encoding_type: u8) {
3783 let mut target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206").unwrap();
3784 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3785 let mut query_short_channel_ids = msgs::QueryShortChannelIds {
3786 chain_hash: expected_chain_hash,
3787 short_channel_ids: vec![0x0000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
3790 if encoding_type == 0 {
3791 target_value.append(&mut hex::decode("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
3792 let encoded_value = query_short_channel_ids.encode();
3793 assert_eq!(encoded_value, target_value);
3795 query_short_channel_ids = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3796 assert_eq!(query_short_channel_ids.chain_hash, expected_chain_hash);
3797 assert_eq!(query_short_channel_ids.short_channel_ids[0], 0x000000000000008e);
3798 assert_eq!(query_short_channel_ids.short_channel_ids[1], 0x0000000000003c69);
3799 assert_eq!(query_short_channel_ids.short_channel_ids[2], 0x000000000045a6c4);
3801 target_value.append(&mut hex::decode("001601789c636000833e08659309a65878be010010a9023a").unwrap());
3802 let result: Result<msgs::QueryShortChannelIds, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
3803 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
3808 fn encoding_reply_short_channel_ids_end() {
3809 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3810 let mut reply_short_channel_ids_end = msgs::ReplyShortChannelIdsEnd {
3811 chain_hash: expected_chain_hash,
3812 full_information: true,
3814 let encoded_value = reply_short_channel_ids_end.encode();
3815 let target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e220601").unwrap();
3816 assert_eq!(encoded_value, target_value);
3818 reply_short_channel_ids_end = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3819 assert_eq!(reply_short_channel_ids_end.chain_hash, expected_chain_hash);
3820 assert_eq!(reply_short_channel_ids_end.full_information, true);
3824 fn encoding_gossip_timestamp_filter(){
3825 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3826 let mut gossip_timestamp_filter = msgs::GossipTimestampFilter {
3827 chain_hash: expected_chain_hash,
3828 first_timestamp: 1590000000,
3829 timestamp_range: 0xffff_ffff,
3831 let encoded_value = gossip_timestamp_filter.encode();
3832 let target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e22065ec57980ffffffff").unwrap();
3833 assert_eq!(encoded_value, target_value);
3835 gossip_timestamp_filter = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3836 assert_eq!(gossip_timestamp_filter.chain_hash, expected_chain_hash);
3837 assert_eq!(gossip_timestamp_filter.first_timestamp, 1590000000);
3838 assert_eq!(gossip_timestamp_filter.timestamp_range, 0xffff_ffff);
3842 fn decode_onion_hop_data_len_as_bigsize() {
3843 // Tests that we can decode an onion payload that is >253 bytes.
3844 // Previously, receiving a payload of this size could've caused us to fail to decode a valid
3845 // payload, because we were decoding the length (a BigSize, big-endian) as a VarInt
3848 // Encode a test onion payload with a big custom TLV such that it's >253 bytes, forcing the
3849 // payload length to be encoded over multiple bytes rather than a single u8.
3850 let big_payload = encode_big_payload().unwrap();
3851 let mut rd = Cursor::new(&big_payload[..]);
3852 <msgs::InboundOnionPayload as Readable>::read(&mut rd).unwrap();
3854 // see above test, needs to be a separate method for use of the serialization macros.
3855 fn encode_big_payload() -> Result<Vec<u8>, io::Error> {
3856 use crate::util::ser::HighZeroBytesDroppedBigSize;
3857 let payload = msgs::OutboundOnionPayload::Forward {
3858 short_channel_id: 0xdeadbeef1bad1dea,
3859 amt_to_forward: 1000,
3860 outgoing_cltv_value: 0xffffffff,
3862 let mut encoded_payload = Vec::new();
3863 let test_bytes = vec![42u8; 1000];
3864 if let msgs::OutboundOnionPayload::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } = payload {
3865 _encode_varint_length_prefixed_tlv!(&mut encoded_payload, {
3866 (1, test_bytes, required_vec),
3867 (2, HighZeroBytesDroppedBigSize(amt_to_forward), required),
3868 (4, HighZeroBytesDroppedBigSize(outgoing_cltv_value), required),
3869 (6, short_channel_id, required)