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, PartialEq)]
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 keysend_tlv = keysend_preimage.map(|preimage| (5482373484, preimage.encode()));
1991 let mut custom_tlvs: Vec<&(u64, Vec<u8>)> = custom_tlvs.iter().chain(keysend_tlv.iter()).collect();
1992 custom_tlvs.sort_unstable_by_key(|(typ, _)| *typ);
1993 _encode_varint_length_prefixed_tlv!(w, {
1994 (2, HighZeroBytesDroppedBigSize(*amt_msat), required),
1995 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
1996 (8, payment_data, option),
1997 (16, payment_metadata.as_ref().map(|m| WithoutLength(m)), option)
1998 }, custom_tlvs.iter());
2005 impl Readable for InboundOnionPayload {
2006 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2007 let mut amt = HighZeroBytesDroppedBigSize(0u64);
2008 let mut cltv_value = HighZeroBytesDroppedBigSize(0u32);
2009 let mut short_id: Option<u64> = None;
2010 let mut payment_data: Option<FinalOnionHopData> = None;
2011 let mut payment_metadata: Option<WithoutLength<Vec<u8>>> = None;
2012 let mut keysend_preimage: Option<PaymentPreimage> = None;
2013 let mut custom_tlvs = Vec::new();
2015 let tlv_len = BigSize::read(r)?;
2016 let rd = FixedLengthReader::new(r, tlv_len.0);
2017 decode_tlv_stream_with_custom_tlv_decode!(rd, {
2019 (4, cltv_value, required),
2020 (6, short_id, option),
2021 (8, payment_data, option),
2022 (16, payment_metadata, option),
2023 // See https://github.com/lightning/blips/blob/master/blip-0003.md
2024 (5482373484, keysend_preimage, option)
2025 }, |msg_type: u64, msg_reader: &mut FixedLengthReader<_>| -> Result<bool, DecodeError> {
2026 if msg_type < 1 << 16 { return Ok(false) }
2027 let mut value = Vec::new();
2028 msg_reader.read_to_end(&mut value)?;
2029 custom_tlvs.push((msg_type, value));
2033 if amt.0 > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2034 if let Some(short_channel_id) = short_id {
2035 if payment_data.is_some() { return Err(DecodeError::InvalidValue) }
2036 if payment_metadata.is_some() { return Err(DecodeError::InvalidValue); }
2039 amt_to_forward: amt.0,
2040 outgoing_cltv_value: cltv_value.0,
2043 if let Some(data) = &payment_data {
2044 if data.total_msat > MAX_VALUE_MSAT {
2045 return Err(DecodeError::InvalidValue);
2050 payment_metadata: payment_metadata.map(|w| w.0),
2053 outgoing_cltv_value: cltv_value.0,
2060 // ReadableArgs because we need onion_utils::decode_next_hop to accommodate payment packets and
2061 // onion message packets.
2062 impl ReadableArgs<()> for InboundOnionPayload {
2063 fn read<R: Read>(r: &mut R, _arg: ()) -> Result<Self, DecodeError> {
2064 <Self as Readable>::read(r)
2068 impl Writeable for Ping {
2069 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2070 self.ponglen.write(w)?;
2071 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2076 impl Readable for Ping {
2077 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2079 ponglen: Readable::read(r)?,
2081 let byteslen = Readable::read(r)?;
2082 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2089 impl Writeable for Pong {
2090 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2091 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2096 impl Readable for Pong {
2097 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2100 let byteslen = Readable::read(r)?;
2101 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2108 impl Writeable for UnsignedChannelAnnouncement {
2109 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2110 self.features.write(w)?;
2111 self.chain_hash.write(w)?;
2112 self.short_channel_id.write(w)?;
2113 self.node_id_1.write(w)?;
2114 self.node_id_2.write(w)?;
2115 self.bitcoin_key_1.write(w)?;
2116 self.bitcoin_key_2.write(w)?;
2117 w.write_all(&self.excess_data[..])?;
2122 impl Readable for UnsignedChannelAnnouncement {
2123 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2125 features: Readable::read(r)?,
2126 chain_hash: Readable::read(r)?,
2127 short_channel_id: Readable::read(r)?,
2128 node_id_1: Readable::read(r)?,
2129 node_id_2: Readable::read(r)?,
2130 bitcoin_key_1: Readable::read(r)?,
2131 bitcoin_key_2: Readable::read(r)?,
2132 excess_data: read_to_end(r)?,
2137 impl_writeable!(ChannelAnnouncement, {
2140 bitcoin_signature_1,
2141 bitcoin_signature_2,
2145 impl Writeable for UnsignedChannelUpdate {
2146 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2147 // `message_flags` used to indicate presence of `htlc_maximum_msat`, but was deprecated in the spec.
2148 const MESSAGE_FLAGS: u8 = 1;
2149 self.chain_hash.write(w)?;
2150 self.short_channel_id.write(w)?;
2151 self.timestamp.write(w)?;
2152 let all_flags = self.flags as u16 | ((MESSAGE_FLAGS as u16) << 8);
2153 all_flags.write(w)?;
2154 self.cltv_expiry_delta.write(w)?;
2155 self.htlc_minimum_msat.write(w)?;
2156 self.fee_base_msat.write(w)?;
2157 self.fee_proportional_millionths.write(w)?;
2158 self.htlc_maximum_msat.write(w)?;
2159 w.write_all(&self.excess_data[..])?;
2164 impl Readable for UnsignedChannelUpdate {
2165 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2167 chain_hash: Readable::read(r)?,
2168 short_channel_id: Readable::read(r)?,
2169 timestamp: Readable::read(r)?,
2171 let flags: u16 = Readable::read(r)?;
2172 // Note: we ignore the `message_flags` for now, since it was deprecated by the spec.
2175 cltv_expiry_delta: Readable::read(r)?,
2176 htlc_minimum_msat: Readable::read(r)?,
2177 fee_base_msat: Readable::read(r)?,
2178 fee_proportional_millionths: Readable::read(r)?,
2179 htlc_maximum_msat: Readable::read(r)?,
2180 excess_data: read_to_end(r)?,
2185 impl_writeable!(ChannelUpdate, {
2190 impl Writeable for ErrorMessage {
2191 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2192 self.channel_id.write(w)?;
2193 (self.data.len() as u16).write(w)?;
2194 w.write_all(self.data.as_bytes())?;
2199 impl Readable for ErrorMessage {
2200 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2202 channel_id: Readable::read(r)?,
2204 let sz: usize = <u16 as Readable>::read(r)? as usize;
2205 let mut data = Vec::with_capacity(sz);
2207 r.read_exact(&mut data)?;
2208 match String::from_utf8(data) {
2210 Err(_) => return Err(DecodeError::InvalidValue),
2217 impl Writeable for WarningMessage {
2218 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2219 self.channel_id.write(w)?;
2220 (self.data.len() as u16).write(w)?;
2221 w.write_all(self.data.as_bytes())?;
2226 impl Readable for WarningMessage {
2227 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2229 channel_id: Readable::read(r)?,
2231 let sz: usize = <u16 as Readable>::read(r)? as usize;
2232 let mut data = Vec::with_capacity(sz);
2234 r.read_exact(&mut data)?;
2235 match String::from_utf8(data) {
2237 Err(_) => return Err(DecodeError::InvalidValue),
2244 impl Writeable for UnsignedNodeAnnouncement {
2245 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2246 self.features.write(w)?;
2247 self.timestamp.write(w)?;
2248 self.node_id.write(w)?;
2249 w.write_all(&self.rgb)?;
2250 self.alias.write(w)?;
2252 let mut addr_len = 0;
2253 for addr in self.addresses.iter() {
2254 addr_len += 1 + addr.len();
2256 (addr_len + self.excess_address_data.len() as u16).write(w)?;
2257 for addr in self.addresses.iter() {
2260 w.write_all(&self.excess_address_data[..])?;
2261 w.write_all(&self.excess_data[..])?;
2266 impl Readable for UnsignedNodeAnnouncement {
2267 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2268 let features: NodeFeatures = Readable::read(r)?;
2269 let timestamp: u32 = Readable::read(r)?;
2270 let node_id: NodeId = Readable::read(r)?;
2271 let mut rgb = [0; 3];
2272 r.read_exact(&mut rgb)?;
2273 let alias: NodeAlias = Readable::read(r)?;
2275 let addr_len: u16 = Readable::read(r)?;
2276 let mut addresses: Vec<NetAddress> = Vec::new();
2277 let mut addr_readpos = 0;
2278 let mut excess = false;
2279 let mut excess_byte = 0;
2281 if addr_len <= addr_readpos { break; }
2282 match Readable::read(r) {
2284 if addr_len < addr_readpos + 1 + addr.len() {
2285 return Err(DecodeError::BadLengthDescriptor);
2287 addr_readpos += (1 + addr.len()) as u16;
2288 addresses.push(addr);
2290 Ok(Err(unknown_descriptor)) => {
2292 excess_byte = unknown_descriptor;
2295 Err(DecodeError::ShortRead) => return Err(DecodeError::BadLengthDescriptor),
2296 Err(e) => return Err(e),
2300 let mut excess_data = vec![];
2301 let excess_address_data = if addr_readpos < addr_len {
2302 let mut excess_address_data = vec![0; (addr_len - addr_readpos) as usize];
2303 r.read_exact(&mut excess_address_data[if excess { 1 } else { 0 }..])?;
2305 excess_address_data[0] = excess_byte;
2310 excess_data.push(excess_byte);
2314 excess_data.extend(read_to_end(r)?.iter());
2315 Ok(UnsignedNodeAnnouncement {
2322 excess_address_data,
2328 impl_writeable!(NodeAnnouncement, {
2333 impl Readable for QueryShortChannelIds {
2334 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2335 let chain_hash: BlockHash = Readable::read(r)?;
2337 let encoding_len: u16 = Readable::read(r)?;
2338 let encoding_type: u8 = Readable::read(r)?;
2340 // Must be encoding_type=0 uncompressed serialization. We do not
2341 // support encoding_type=1 zlib serialization.
2342 if encoding_type != EncodingType::Uncompressed as u8 {
2343 return Err(DecodeError::UnsupportedCompression);
2346 // We expect the encoding_len to always includes the 1-byte
2347 // encoding_type and that short_channel_ids are 8-bytes each
2348 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2349 return Err(DecodeError::InvalidValue);
2352 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2353 // less the 1-byte encoding_type
2354 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2355 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2356 for _ in 0..short_channel_id_count {
2357 short_channel_ids.push(Readable::read(r)?);
2360 Ok(QueryShortChannelIds {
2367 impl Writeable for QueryShortChannelIds {
2368 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2369 // Calculated from 1-byte encoding_type plus 8-bytes per short_channel_id
2370 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2372 self.chain_hash.write(w)?;
2373 encoding_len.write(w)?;
2375 // We only support type=0 uncompressed serialization
2376 (EncodingType::Uncompressed as u8).write(w)?;
2378 for scid in self.short_channel_ids.iter() {
2386 impl_writeable_msg!(ReplyShortChannelIdsEnd, {
2391 impl QueryChannelRange {
2392 /// Calculates the overflow safe ending block height for the query.
2394 /// Overflow returns `0xffffffff`, otherwise returns `first_blocknum + number_of_blocks`.
2395 pub fn end_blocknum(&self) -> u32 {
2396 match self.first_blocknum.checked_add(self.number_of_blocks) {
2397 Some(block) => block,
2398 None => u32::max_value(),
2403 impl_writeable_msg!(QueryChannelRange, {
2409 impl Readable for ReplyChannelRange {
2410 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2411 let chain_hash: BlockHash = Readable::read(r)?;
2412 let first_blocknum: u32 = Readable::read(r)?;
2413 let number_of_blocks: u32 = Readable::read(r)?;
2414 let sync_complete: bool = Readable::read(r)?;
2416 let encoding_len: u16 = Readable::read(r)?;
2417 let encoding_type: u8 = Readable::read(r)?;
2419 // Must be encoding_type=0 uncompressed serialization. We do not
2420 // support encoding_type=1 zlib serialization.
2421 if encoding_type != EncodingType::Uncompressed as u8 {
2422 return Err(DecodeError::UnsupportedCompression);
2425 // We expect the encoding_len to always includes the 1-byte
2426 // encoding_type and that short_channel_ids are 8-bytes each
2427 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2428 return Err(DecodeError::InvalidValue);
2431 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2432 // less the 1-byte encoding_type
2433 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2434 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2435 for _ in 0..short_channel_id_count {
2436 short_channel_ids.push(Readable::read(r)?);
2439 Ok(ReplyChannelRange {
2449 impl Writeable for ReplyChannelRange {
2450 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2451 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2452 self.chain_hash.write(w)?;
2453 self.first_blocknum.write(w)?;
2454 self.number_of_blocks.write(w)?;
2455 self.sync_complete.write(w)?;
2457 encoding_len.write(w)?;
2458 (EncodingType::Uncompressed as u8).write(w)?;
2459 for scid in self.short_channel_ids.iter() {
2467 impl_writeable_msg!(GossipTimestampFilter, {
2475 use bitcoin::blockdata::constants::ChainHash;
2476 use bitcoin::{Transaction, PackedLockTime, TxIn, Script, Sequence, Witness, TxOut};
2478 use crate::ln::{PaymentPreimage, PaymentHash, PaymentSecret};
2479 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
2480 use crate::ln::msgs::{self, FinalOnionHopData, OnionErrorPacket};
2481 use crate::routing::gossip::{NodeAlias, NodeId};
2482 use crate::util::ser::{Writeable, Readable, Hostname, TransactionU16LenLimited};
2484 use bitcoin::hashes::hex::FromHex;
2485 use bitcoin::util::address::Address;
2486 use bitcoin::network::constants::Network;
2487 use bitcoin::blockdata::script::Builder;
2488 use bitcoin::blockdata::opcodes;
2489 use bitcoin::hash_types::{Txid, BlockHash};
2491 use bitcoin::secp256k1::{PublicKey,SecretKey};
2492 use bitcoin::secp256k1::{Secp256k1, Message};
2494 use crate::io::{self, Cursor};
2495 use crate::prelude::*;
2496 use core::convert::TryFrom;
2497 use core::str::FromStr;
2499 use crate::chain::transaction::OutPoint;
2502 fn encoding_channel_reestablish() {
2504 let secp_ctx = Secp256k1::new();
2505 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2508 let cr = msgs::ChannelReestablish {
2509 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],
2510 next_local_commitment_number: 3,
2511 next_remote_commitment_number: 4,
2512 your_last_per_commitment_secret: [9;32],
2513 my_current_per_commitment_point: public_key,
2514 next_funding_txid: None,
2517 let encoded_value = cr.encode();
2521 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
2522 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2523 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2524 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
2525 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
2531 fn encoding_channel_reestablish_with_next_funding_txid() {
2533 let secp_ctx = Secp256k1::new();
2534 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2537 let cr = msgs::ChannelReestablish {
2538 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],
2539 next_local_commitment_number: 3,
2540 next_remote_commitment_number: 4,
2541 your_last_per_commitment_secret: [9;32],
2542 my_current_per_commitment_point: public_key,
2543 next_funding_txid: Some(Txid::from_hash(bitcoin::hashes::Hash::from_slice(&[
2544 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,
2548 let encoded_value = cr.encode();
2552 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
2553 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2554 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2555 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
2556 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
2557 0, // Type (next_funding_txid)
2559 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
2564 macro_rules! get_keys_from {
2565 ($slice: expr, $secp_ctx: expr) => {
2567 let privkey = SecretKey::from_slice(&hex::decode($slice).unwrap()[..]).unwrap();
2568 let pubkey = PublicKey::from_secret_key(&$secp_ctx, &privkey);
2574 macro_rules! get_sig_on {
2575 ($privkey: expr, $ctx: expr, $string: expr) => {
2577 let sighash = Message::from_slice(&$string.into_bytes()[..]).unwrap();
2578 $ctx.sign_ecdsa(&sighash, &$privkey)
2584 fn encoding_announcement_signatures() {
2585 let secp_ctx = Secp256k1::new();
2586 let (privkey, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2587 let sig_1 = get_sig_on!(privkey, secp_ctx, String::from("01010101010101010101010101010101"));
2588 let sig_2 = get_sig_on!(privkey, secp_ctx, String::from("02020202020202020202020202020202"));
2589 let announcement_signatures = msgs::AnnouncementSignatures {
2590 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],
2591 short_channel_id: 2316138423780173,
2592 node_signature: sig_1,
2593 bitcoin_signature: sig_2,
2596 let encoded_value = announcement_signatures.encode();
2597 assert_eq!(encoded_value, hex::decode("040000000000000005000000000000000600000000000000070000000000000000083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073acf9953cef4700860f5967838eba2bae89288ad188ebf8b20bf995c3ea53a26df1876d0a3a0e13172ba286a673140190c02ba9da60a2e43a745188c8a83c7f3ef").unwrap());
2600 fn do_encoding_channel_announcement(unknown_features_bits: bool, excess_data: bool) {
2601 let secp_ctx = Secp256k1::new();
2602 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2603 let (privkey_2, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2604 let (privkey_3, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2605 let (privkey_4, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2606 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2607 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
2608 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
2609 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
2610 let mut features = ChannelFeatures::empty();
2611 if unknown_features_bits {
2612 features = ChannelFeatures::from_le_bytes(vec![0xFF, 0xFF]);
2614 let unsigned_channel_announcement = msgs::UnsignedChannelAnnouncement {
2616 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2617 short_channel_id: 2316138423780173,
2618 node_id_1: NodeId::from_pubkey(&pubkey_1),
2619 node_id_2: NodeId::from_pubkey(&pubkey_2),
2620 bitcoin_key_1: NodeId::from_pubkey(&pubkey_3),
2621 bitcoin_key_2: NodeId::from_pubkey(&pubkey_4),
2622 excess_data: if excess_data { vec![10, 0, 0, 20, 0, 0, 30, 0, 0, 40] } else { Vec::new() },
2624 let channel_announcement = msgs::ChannelAnnouncement {
2625 node_signature_1: sig_1,
2626 node_signature_2: sig_2,
2627 bitcoin_signature_1: sig_3,
2628 bitcoin_signature_2: sig_4,
2629 contents: unsigned_channel_announcement,
2631 let encoded_value = channel_announcement.encode();
2632 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a1735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap();
2633 if unknown_features_bits {
2634 target_value.append(&mut hex::decode("0002ffff").unwrap());
2636 target_value.append(&mut hex::decode("0000").unwrap());
2638 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2639 target_value.append(&mut hex::decode("00083a840000034d031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
2641 target_value.append(&mut hex::decode("0a00001400001e000028").unwrap());
2643 assert_eq!(encoded_value, target_value);
2647 fn encoding_channel_announcement() {
2648 do_encoding_channel_announcement(true, false);
2649 do_encoding_channel_announcement(false, true);
2650 do_encoding_channel_announcement(false, false);
2651 do_encoding_channel_announcement(true, true);
2654 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) {
2655 let secp_ctx = Secp256k1::new();
2656 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2657 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2658 let features = if unknown_features_bits {
2659 NodeFeatures::from_le_bytes(vec![0xFF, 0xFF])
2661 // Set to some features we may support
2662 NodeFeatures::from_le_bytes(vec![2 | 1 << 5])
2664 let mut addresses = Vec::new();
2666 addresses.push(msgs::NetAddress::IPv4 {
2667 addr: [255, 254, 253, 252],
2672 addresses.push(msgs::NetAddress::IPv6 {
2673 addr: [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240],
2678 addresses.push(msgs::NetAddress::OnionV2(
2679 [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 38, 7]
2683 addresses.push(msgs::NetAddress::OnionV3 {
2684 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],
2691 addresses.push(msgs::NetAddress::Hostname {
2692 hostname: Hostname::try_from(String::from("host")).unwrap(),
2696 let mut addr_len = 0;
2697 for addr in &addresses {
2698 addr_len += addr.len() + 1;
2700 let unsigned_node_announcement = msgs::UnsignedNodeAnnouncement {
2702 timestamp: 20190119,
2703 node_id: NodeId::from_pubkey(&pubkey_1),
2705 alias: NodeAlias([16;32]),
2707 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() },
2708 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() },
2710 addr_len += unsigned_node_announcement.excess_address_data.len() as u16;
2711 let node_announcement = msgs::NodeAnnouncement {
2713 contents: unsigned_node_announcement,
2715 let encoded_value = node_announcement.encode();
2716 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
2717 if unknown_features_bits {
2718 target_value.append(&mut hex::decode("0002ffff").unwrap());
2720 target_value.append(&mut hex::decode("000122").unwrap());
2722 target_value.append(&mut hex::decode("013413a7031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f2020201010101010101010101010101010101010101010101010101010101010101010").unwrap());
2723 target_value.append(&mut vec![(addr_len >> 8) as u8, addr_len as u8]);
2725 target_value.append(&mut hex::decode("01fffefdfc2607").unwrap());
2728 target_value.append(&mut hex::decode("02fffefdfcfbfaf9f8f7f6f5f4f3f2f1f02607").unwrap());
2731 target_value.append(&mut hex::decode("03fffefdfcfbfaf9f8f7f62607").unwrap());
2734 target_value.append(&mut hex::decode("04fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0efeeedecebeae9e8e7e6e5e4e3e2e1e00020102607").unwrap());
2737 target_value.append(&mut hex::decode("0504686f73742607").unwrap());
2739 if excess_address_data {
2740 target_value.append(&mut hex::decode("216c280b5395a2546e7e4b2663e04f811622f15a4f92e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d269").unwrap());
2743 target_value.append(&mut hex::decode("3b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
2745 assert_eq!(encoded_value, target_value);
2749 fn encoding_node_announcement() {
2750 do_encoding_node_announcement(true, true, true, true, true, true, true, true);
2751 do_encoding_node_announcement(false, false, false, false, false, false, false, false);
2752 do_encoding_node_announcement(false, true, false, false, false, false, false, false);
2753 do_encoding_node_announcement(false, false, true, false, false, false, false, false);
2754 do_encoding_node_announcement(false, false, false, true, false, false, false, false);
2755 do_encoding_node_announcement(false, false, false, false, true, false, false, false);
2756 do_encoding_node_announcement(false, false, false, false, false, true, false, false);
2757 do_encoding_node_announcement(false, false, false, false, false, false, true, false);
2758 do_encoding_node_announcement(false, true, false, true, false, false, true, false);
2759 do_encoding_node_announcement(false, false, true, false, true, false, false, false);
2762 fn do_encoding_channel_update(direction: bool, disable: bool, excess_data: bool) {
2763 let secp_ctx = Secp256k1::new();
2764 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2765 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2766 let unsigned_channel_update = msgs::UnsignedChannelUpdate {
2767 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2768 short_channel_id: 2316138423780173,
2769 timestamp: 20190119,
2770 flags: if direction { 1 } else { 0 } | if disable { 1 << 1 } else { 0 },
2771 cltv_expiry_delta: 144,
2772 htlc_minimum_msat: 1000000,
2773 htlc_maximum_msat: 131355275467161,
2774 fee_base_msat: 10000,
2775 fee_proportional_millionths: 20,
2776 excess_data: if excess_data { vec![0, 0, 0, 0, 59, 154, 202, 0] } else { Vec::new() }
2778 let channel_update = msgs::ChannelUpdate {
2780 contents: unsigned_channel_update
2782 let encoded_value = channel_update.encode();
2783 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
2784 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2785 target_value.append(&mut hex::decode("00083a840000034d013413a7").unwrap());
2786 target_value.append(&mut hex::decode("01").unwrap());
2787 target_value.append(&mut hex::decode("00").unwrap());
2789 let flag = target_value.last_mut().unwrap();
2793 let flag = target_value.last_mut().unwrap();
2794 *flag = *flag | 1 << 1;
2796 target_value.append(&mut hex::decode("009000000000000f42400000271000000014").unwrap());
2797 target_value.append(&mut hex::decode("0000777788889999").unwrap());
2799 target_value.append(&mut hex::decode("000000003b9aca00").unwrap());
2801 assert_eq!(encoded_value, target_value);
2805 fn encoding_channel_update() {
2806 do_encoding_channel_update(false, false, false);
2807 do_encoding_channel_update(false, false, true);
2808 do_encoding_channel_update(true, false, false);
2809 do_encoding_channel_update(true, false, true);
2810 do_encoding_channel_update(false, true, false);
2811 do_encoding_channel_update(false, true, true);
2812 do_encoding_channel_update(true, true, false);
2813 do_encoding_channel_update(true, true, true);
2816 fn do_encoding_open_channel(random_bit: bool, shutdown: bool, incl_chan_type: bool) {
2817 let secp_ctx = Secp256k1::new();
2818 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2819 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2820 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2821 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2822 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
2823 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
2824 let open_channel = msgs::OpenChannel {
2825 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2826 temporary_channel_id: [2; 32],
2827 funding_satoshis: 1311768467284833366,
2828 push_msat: 2536655962884945560,
2829 dust_limit_satoshis: 3608586615801332854,
2830 max_htlc_value_in_flight_msat: 8517154655701053848,
2831 channel_reserve_satoshis: 8665828695742877976,
2832 htlc_minimum_msat: 2316138423780173,
2833 feerate_per_kw: 821716,
2834 to_self_delay: 49340,
2835 max_accepted_htlcs: 49340,
2836 funding_pubkey: pubkey_1,
2837 revocation_basepoint: pubkey_2,
2838 payment_point: pubkey_3,
2839 delayed_payment_basepoint: pubkey_4,
2840 htlc_basepoint: pubkey_5,
2841 first_per_commitment_point: pubkey_6,
2842 channel_flags: if random_bit { 1 << 5 } else { 0 },
2843 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
2844 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
2846 let encoded_value = open_channel.encode();
2847 let mut target_value = Vec::new();
2848 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2849 target_value.append(&mut hex::decode("02020202020202020202020202020202020202020202020202020202020202021234567890123456233403289122369832144668701144767633030896203198784335490624111800083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
2851 target_value.append(&mut hex::decode("20").unwrap());
2853 target_value.append(&mut hex::decode("00").unwrap());
2856 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
2859 target_value.append(&mut hex::decode("0100").unwrap());
2861 assert_eq!(encoded_value, target_value);
2865 fn encoding_open_channel() {
2866 do_encoding_open_channel(false, false, false);
2867 do_encoding_open_channel(false, false, true);
2868 do_encoding_open_channel(false, true, false);
2869 do_encoding_open_channel(false, true, true);
2870 do_encoding_open_channel(true, false, false);
2871 do_encoding_open_channel(true, false, true);
2872 do_encoding_open_channel(true, true, false);
2873 do_encoding_open_channel(true, true, true);
2876 fn do_encoding_open_channelv2(random_bit: bool, shutdown: bool, incl_chan_type: bool, require_confirmed_inputs: bool) {
2877 let secp_ctx = Secp256k1::new();
2878 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2879 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2880 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2881 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2882 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
2883 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
2884 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
2885 let open_channelv2 = msgs::OpenChannelV2 {
2886 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2887 temporary_channel_id: [2; 32],
2888 funding_feerate_sat_per_1000_weight: 821716,
2889 commitment_feerate_sat_per_1000_weight: 821716,
2890 funding_satoshis: 1311768467284833366,
2891 dust_limit_satoshis: 3608586615801332854,
2892 max_htlc_value_in_flight_msat: 8517154655701053848,
2893 htlc_minimum_msat: 2316138423780173,
2894 to_self_delay: 49340,
2895 max_accepted_htlcs: 49340,
2896 locktime: 305419896,
2897 funding_pubkey: pubkey_1,
2898 revocation_basepoint: pubkey_2,
2899 payment_basepoint: pubkey_3,
2900 delayed_payment_basepoint: pubkey_4,
2901 htlc_basepoint: pubkey_5,
2902 first_per_commitment_point: pubkey_6,
2903 second_per_commitment_point: pubkey_7,
2904 channel_flags: if random_bit { 1 << 5 } else { 0 },
2905 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
2906 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
2907 require_confirmed_inputs: if require_confirmed_inputs { Some(()) } else { None },
2909 let encoded_value = open_channelv2.encode();
2910 let mut target_value = Vec::new();
2911 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2912 target_value.append(&mut hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap());
2913 target_value.append(&mut hex::decode("000c89d4").unwrap());
2914 target_value.append(&mut hex::decode("000c89d4").unwrap());
2915 target_value.append(&mut hex::decode("1234567890123456").unwrap());
2916 target_value.append(&mut hex::decode("3214466870114476").unwrap());
2917 target_value.append(&mut hex::decode("7633030896203198").unwrap());
2918 target_value.append(&mut hex::decode("00083a840000034d").unwrap());
2919 target_value.append(&mut hex::decode("c0bc").unwrap());
2920 target_value.append(&mut hex::decode("c0bc").unwrap());
2921 target_value.append(&mut hex::decode("12345678").unwrap());
2922 target_value.append(&mut hex::decode("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap());
2923 target_value.append(&mut hex::decode("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap());
2924 target_value.append(&mut hex::decode("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap());
2925 target_value.append(&mut hex::decode("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
2926 target_value.append(&mut hex::decode("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap());
2927 target_value.append(&mut hex::decode("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
2928 target_value.append(&mut hex::decode("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap());
2931 target_value.append(&mut hex::decode("20").unwrap());
2933 target_value.append(&mut hex::decode("00").unwrap());
2936 target_value.append(&mut hex::decode("001b").unwrap()); // Type 0 + Length 27
2937 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
2940 target_value.append(&mut hex::decode("0100").unwrap());
2942 if require_confirmed_inputs {
2943 target_value.append(&mut hex::decode("0200").unwrap());
2945 assert_eq!(encoded_value, target_value);
2949 fn encoding_open_channelv2() {
2950 do_encoding_open_channelv2(false, false, false, false);
2951 do_encoding_open_channelv2(false, false, false, true);
2952 do_encoding_open_channelv2(false, false, true, false);
2953 do_encoding_open_channelv2(false, false, true, true);
2954 do_encoding_open_channelv2(false, true, false, false);
2955 do_encoding_open_channelv2(false, true, false, true);
2956 do_encoding_open_channelv2(false, true, true, false);
2957 do_encoding_open_channelv2(false, true, true, true);
2958 do_encoding_open_channelv2(true, false, false, false);
2959 do_encoding_open_channelv2(true, false, false, true);
2960 do_encoding_open_channelv2(true, false, true, false);
2961 do_encoding_open_channelv2(true, false, true, true);
2962 do_encoding_open_channelv2(true, true, false, false);
2963 do_encoding_open_channelv2(true, true, false, true);
2964 do_encoding_open_channelv2(true, true, true, false);
2965 do_encoding_open_channelv2(true, true, true, true);
2968 fn do_encoding_accept_channel(shutdown: bool) {
2969 let secp_ctx = Secp256k1::new();
2970 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2971 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2972 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2973 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2974 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
2975 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
2976 let accept_channel = msgs::AcceptChannel {
2977 temporary_channel_id: [2; 32],
2978 dust_limit_satoshis: 1311768467284833366,
2979 max_htlc_value_in_flight_msat: 2536655962884945560,
2980 channel_reserve_satoshis: 3608586615801332854,
2981 htlc_minimum_msat: 2316138423780173,
2982 minimum_depth: 821716,
2983 to_self_delay: 49340,
2984 max_accepted_htlcs: 49340,
2985 funding_pubkey: pubkey_1,
2986 revocation_basepoint: pubkey_2,
2987 payment_point: pubkey_3,
2988 delayed_payment_basepoint: pubkey_4,
2989 htlc_basepoint: pubkey_5,
2990 first_per_commitment_point: pubkey_6,
2991 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
2994 next_local_nonce: None,
2996 let encoded_value = accept_channel.encode();
2997 let mut target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020212345678901234562334032891223698321446687011447600083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap();
2999 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3001 assert_eq!(encoded_value, target_value);
3005 fn encoding_accept_channel() {
3006 do_encoding_accept_channel(false);
3007 do_encoding_accept_channel(true);
3010 fn do_encoding_accept_channelv2(shutdown: bool) {
3011 let secp_ctx = Secp256k1::new();
3012 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3013 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3014 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3015 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3016 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3017 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3018 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3019 let accept_channelv2 = msgs::AcceptChannelV2 {
3020 temporary_channel_id: [2; 32],
3021 funding_satoshis: 1311768467284833366,
3022 dust_limit_satoshis: 1311768467284833366,
3023 max_htlc_value_in_flight_msat: 2536655962884945560,
3024 htlc_minimum_msat: 2316138423780173,
3025 minimum_depth: 821716,
3026 to_self_delay: 49340,
3027 max_accepted_htlcs: 49340,
3028 funding_pubkey: pubkey_1,
3029 revocation_basepoint: pubkey_2,
3030 payment_basepoint: pubkey_3,
3031 delayed_payment_basepoint: pubkey_4,
3032 htlc_basepoint: pubkey_5,
3033 first_per_commitment_point: pubkey_6,
3034 second_per_commitment_point: pubkey_7,
3035 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3037 require_confirmed_inputs: None,
3039 let encoded_value = accept_channelv2.encode();
3040 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // temporary_channel_id
3041 target_value.append(&mut hex::decode("1234567890123456").unwrap()); // funding_satoshis
3042 target_value.append(&mut hex::decode("1234567890123456").unwrap()); // dust_limit_satoshis
3043 target_value.append(&mut hex::decode("2334032891223698").unwrap()); // max_htlc_value_in_flight_msat
3044 target_value.append(&mut hex::decode("00083a840000034d").unwrap()); // htlc_minimum_msat
3045 target_value.append(&mut hex::decode("000c89d4").unwrap()); // minimum_depth
3046 target_value.append(&mut hex::decode("c0bc").unwrap()); // to_self_delay
3047 target_value.append(&mut hex::decode("c0bc").unwrap()); // max_accepted_htlcs
3048 target_value.append(&mut hex::decode("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap()); // funding_pubkey
3049 target_value.append(&mut hex::decode("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap()); // revocation_basepoint
3050 target_value.append(&mut hex::decode("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap()); // payment_basepoint
3051 target_value.append(&mut hex::decode("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap()); // delayed_payment_basepoint
3052 target_value.append(&mut hex::decode("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap()); // htlc_basepoint
3053 target_value.append(&mut hex::decode("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap()); // first_per_commitment_point
3054 target_value.append(&mut hex::decode("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap()); // second_per_commitment_point
3056 target_value.append(&mut hex::decode("001b").unwrap()); // Type 0 + Length 27
3057 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3059 assert_eq!(encoded_value, target_value);
3063 fn encoding_accept_channelv2() {
3064 do_encoding_accept_channelv2(false);
3065 do_encoding_accept_channelv2(true);
3069 fn encoding_funding_created() {
3070 let secp_ctx = Secp256k1::new();
3071 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3072 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3073 let funding_created = msgs::FundingCreated {
3074 temporary_channel_id: [2; 32],
3075 funding_txid: Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3076 funding_output_index: 255,
3079 partial_signature_with_nonce: None,
3081 next_local_nonce: None,
3083 let encoded_value = funding_created.encode();
3084 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202026e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c200ffd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3085 assert_eq!(encoded_value, target_value);
3089 fn encoding_funding_signed() {
3090 let secp_ctx = Secp256k1::new();
3091 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3092 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3093 let funding_signed = msgs::FundingSigned {
3094 channel_id: [2; 32],
3097 partial_signature_with_nonce: None,
3099 let encoded_value = funding_signed.encode();
3100 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3101 assert_eq!(encoded_value, target_value);
3105 fn encoding_channel_ready() {
3106 let secp_ctx = Secp256k1::new();
3107 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3108 let channel_ready = msgs::ChannelReady {
3109 channel_id: [2; 32],
3110 next_per_commitment_point: pubkey_1,
3111 short_channel_id_alias: None,
3113 let encoded_value = channel_ready.encode();
3114 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3115 assert_eq!(encoded_value, target_value);
3119 fn encoding_tx_add_input() {
3120 let tx_add_input = msgs::TxAddInput {
3121 channel_id: [2; 32],
3122 serial_id: 4886718345,
3123 prevtx: TransactionU16LenLimited::new(Transaction {
3125 lock_time: PackedLockTime(0),
3127 previous_output: OutPoint { txid: Txid::from_hex("305bab643ee297b8b6b76b320792c8223d55082122cb606bf89382146ced9c77").unwrap(), index: 2 }.into_bitcoin_outpoint(),
3128 script_sig: Script::new(),
3129 sequence: Sequence(0xfffffffd),
3130 witness: Witness::from_vec(vec![
3131 hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3132 hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3137 script_pubkey: Address::from_str("bc1qzlffunw52jav8vwdu5x3jfk6sr8u22rmq3xzw2").unwrap().script_pubkey(),
3141 script_pubkey: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().script_pubkey(),
3145 prevtx_out: 305419896,
3146 sequence: 305419896,
3148 let encoded_value = tx_add_input.encode();
3149 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000000012345678900de02000000000101779ced6c148293f86b60cb222108553d22c89207326bb7b6b897e23e64ab5b300200000000fdffffff0236dbc1000000000016001417d29e4dd454bac3b1cde50d1926da80cfc5287b9cbd03000000000016001436ec78d514df462da95e6a00c24daa8915362d420247304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701210301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944000000001234567812345678").unwrap();
3150 assert_eq!(encoded_value, target_value);
3154 fn encoding_tx_add_output() {
3155 let tx_add_output = msgs::TxAddOutput {
3156 channel_id: [2; 32],
3157 serial_id: 4886718345,
3159 script: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().script_pubkey(),
3161 let encoded_value = tx_add_output.encode();
3162 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000000012345678900000001234567890016001436ec78d514df462da95e6a00c24daa8915362d42").unwrap();
3163 assert_eq!(encoded_value, target_value);
3167 fn encoding_tx_remove_input() {
3168 let tx_remove_input = msgs::TxRemoveInput {
3169 channel_id: [2; 32],
3170 serial_id: 4886718345,
3172 let encoded_value = tx_remove_input.encode();
3173 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3174 assert_eq!(encoded_value, target_value);
3178 fn encoding_tx_remove_output() {
3179 let tx_remove_output = msgs::TxRemoveOutput {
3180 channel_id: [2; 32],
3181 serial_id: 4886718345,
3183 let encoded_value = tx_remove_output.encode();
3184 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3185 assert_eq!(encoded_value, target_value);
3189 fn encoding_tx_complete() {
3190 let tx_complete = msgs::TxComplete {
3191 channel_id: [2; 32],
3193 let encoded_value = tx_complete.encode();
3194 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3195 assert_eq!(encoded_value, target_value);
3199 fn encoding_tx_signatures() {
3200 let tx_signatures = msgs::TxSignatures {
3201 channel_id: [2; 32],
3202 tx_hash: Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3204 Witness::from_vec(vec![
3205 hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3206 hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3207 Witness::from_vec(vec![
3208 hex::decode("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap(),
3209 hex::decode("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap()]),
3212 let encoded_value = tx_signatures.encode();
3213 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3214 target_value.append(&mut hex::decode("6e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c2").unwrap()); // tx_hash (sha256) (big endian byte order)
3215 target_value.append(&mut hex::decode("0002").unwrap()); // num_witnesses (u16)
3217 target_value.append(&mut hex::decode("006b").unwrap()); // len of witness_data
3218 target_value.append(&mut hex::decode("02").unwrap()); // num_witness_elements (VarInt)
3219 target_value.append(&mut hex::decode("47").unwrap()); // len of witness element data (VarInt)
3220 target_value.append(&mut hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap());
3221 target_value.append(&mut hex::decode("21").unwrap()); // len of witness element data (VarInt)
3222 target_value.append(&mut hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap());
3224 target_value.append(&mut hex::decode("006c").unwrap()); // len of witness_data
3225 target_value.append(&mut hex::decode("02").unwrap()); // num_witness_elements (VarInt)
3226 target_value.append(&mut hex::decode("48").unwrap()); // len of witness element data (VarInt)
3227 target_value.append(&mut hex::decode("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap());
3228 target_value.append(&mut hex::decode("21").unwrap()); // len of witness element data (VarInt)
3229 target_value.append(&mut hex::decode("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap());
3230 assert_eq!(encoded_value, target_value);
3233 fn do_encoding_tx_init_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3234 let tx_init_rbf = msgs::TxInitRbf {
3235 channel_id: [2; 32],
3236 locktime: 305419896,
3237 feerate_sat_per_1000_weight: 20190119,
3238 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3240 let encoded_value = tx_init_rbf.encode();
3241 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3242 target_value.append(&mut hex::decode("12345678").unwrap()); // locktime
3243 target_value.append(&mut hex::decode("013413a7").unwrap()); // feerate_sat_per_1000_weight
3244 if let Some((_, target)) = funding_value_with_hex_target {
3245 target_value.push(0x00); // Type
3246 target_value.push(target.len() as u8 / 2); // Length
3247 target_value.append(&mut hex::decode(target).unwrap()); // Value (i64)
3249 assert_eq!(encoded_value, target_value);
3253 fn encoding_tx_init_rbf() {
3254 do_encoding_tx_init_rbf(Some((1311768467284833366, "1234567890123456")));
3255 do_encoding_tx_init_rbf(Some((13117684672, "000000030DDFFBC0")));
3256 do_encoding_tx_init_rbf(None);
3259 fn do_encoding_tx_ack_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3260 let tx_ack_rbf = msgs::TxAckRbf {
3261 channel_id: [2; 32],
3262 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3264 let encoded_value = tx_ack_rbf.encode();
3265 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3266 if let Some((_, target)) = funding_value_with_hex_target {
3267 target_value.push(0x00); // Type
3268 target_value.push(target.len() as u8 / 2); // Length
3269 target_value.append(&mut hex::decode(target).unwrap()); // Value (i64)
3271 assert_eq!(encoded_value, target_value);
3275 fn encoding_tx_ack_rbf() {
3276 do_encoding_tx_ack_rbf(Some((1311768467284833366, "1234567890123456")));
3277 do_encoding_tx_ack_rbf(Some((13117684672, "000000030DDFFBC0")));
3278 do_encoding_tx_ack_rbf(None);
3282 fn encoding_tx_abort() {
3283 let tx_abort = msgs::TxAbort {
3284 channel_id: [2; 32],
3285 data: hex::decode("54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap(),
3287 let encoded_value = tx_abort.encode();
3288 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202002C54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap();
3289 assert_eq!(encoded_value, target_value);
3292 fn do_encoding_shutdown(script_type: u8) {
3293 let secp_ctx = Secp256k1::new();
3294 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3295 let script = Builder::new().push_opcode(opcodes::OP_TRUE).into_script();
3296 let shutdown = msgs::Shutdown {
3297 channel_id: [2; 32],
3299 if script_type == 1 { Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey() }
3300 else if script_type == 2 { Address::p2sh(&script, Network::Testnet).unwrap().script_pubkey() }
3301 else if script_type == 3 { Address::p2wpkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).unwrap().script_pubkey() }
3302 else { Address::p2wsh(&script, Network::Testnet).script_pubkey() },
3304 let encoded_value = shutdown.encode();
3305 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3306 if script_type == 1 {
3307 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3308 } else if script_type == 2 {
3309 target_value.append(&mut hex::decode("0017a914da1745e9b549bd0bfa1a569971c77eba30cd5a4b87").unwrap());
3310 } else if script_type == 3 {
3311 target_value.append(&mut hex::decode("0016001479b000887626b294a914501a4cd226b58b235983").unwrap());
3312 } else if script_type == 4 {
3313 target_value.append(&mut hex::decode("002200204ae81572f06e1b88fd5ced7a1a000945432e83e1551e6f721ee9c00b8cc33260").unwrap());
3315 assert_eq!(encoded_value, target_value);
3319 fn encoding_shutdown() {
3320 do_encoding_shutdown(1);
3321 do_encoding_shutdown(2);
3322 do_encoding_shutdown(3);
3323 do_encoding_shutdown(4);
3327 fn encoding_closing_signed() {
3328 let secp_ctx = Secp256k1::new();
3329 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3330 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3331 let closing_signed = msgs::ClosingSigned {
3332 channel_id: [2; 32],
3333 fee_satoshis: 2316138423780173,
3337 let encoded_value = closing_signed.encode();
3338 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3339 assert_eq!(encoded_value, target_value);
3340 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value)).unwrap(), closing_signed);
3342 let closing_signed_with_range = msgs::ClosingSigned {
3343 channel_id: [2; 32],
3344 fee_satoshis: 2316138423780173,
3346 fee_range: Some(msgs::ClosingSignedFeeRange {
3347 min_fee_satoshis: 0xdeadbeef,
3348 max_fee_satoshis: 0x1badcafe01234567,
3351 let encoded_value_with_range = closing_signed_with_range.encode();
3352 let target_value_with_range = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a011000000000deadbeef1badcafe01234567").unwrap();
3353 assert_eq!(encoded_value_with_range, target_value_with_range);
3354 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value_with_range)).unwrap(),
3355 closing_signed_with_range);
3359 fn encoding_update_add_htlc() {
3360 let secp_ctx = Secp256k1::new();
3361 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3362 let onion_routing_packet = msgs::OnionPacket {
3364 public_key: Ok(pubkey_1),
3365 hop_data: [1; 20*65],
3368 let update_add_htlc = msgs::UpdateAddHTLC {
3369 channel_id: [2; 32],
3370 htlc_id: 2316138423780173,
3371 amount_msat: 3608586615801332854,
3372 payment_hash: PaymentHash([1; 32]),
3373 cltv_expiry: 821716,
3374 onion_routing_packet,
3375 skimmed_fee_msat: None,
3377 let encoded_value = update_add_htlc.encode();
3378 let target_value = hex::decode("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").unwrap();
3379 assert_eq!(encoded_value, target_value);
3383 fn encoding_update_fulfill_htlc() {
3384 let update_fulfill_htlc = msgs::UpdateFulfillHTLC {
3385 channel_id: [2; 32],
3386 htlc_id: 2316138423780173,
3387 payment_preimage: PaymentPreimage([1; 32]),
3389 let encoded_value = update_fulfill_htlc.encode();
3390 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d0101010101010101010101010101010101010101010101010101010101010101").unwrap();
3391 assert_eq!(encoded_value, target_value);
3395 fn encoding_update_fail_htlc() {
3396 let reason = OnionErrorPacket {
3397 data: [1; 32].to_vec(),
3399 let update_fail_htlc = msgs::UpdateFailHTLC {
3400 channel_id: [2; 32],
3401 htlc_id: 2316138423780173,
3404 let encoded_value = update_fail_htlc.encode();
3405 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d00200101010101010101010101010101010101010101010101010101010101010101").unwrap();
3406 assert_eq!(encoded_value, target_value);
3410 fn encoding_update_fail_malformed_htlc() {
3411 let update_fail_malformed_htlc = msgs::UpdateFailMalformedHTLC {
3412 channel_id: [2; 32],
3413 htlc_id: 2316138423780173,
3414 sha256_of_onion: [1; 32],
3417 let encoded_value = update_fail_malformed_htlc.encode();
3418 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d010101010101010101010101010101010101010101010101010101010101010100ff").unwrap();
3419 assert_eq!(encoded_value, target_value);
3422 fn do_encoding_commitment_signed(htlcs: bool) {
3423 let secp_ctx = Secp256k1::new();
3424 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3425 let (privkey_2, _) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3426 let (privkey_3, _) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3427 let (privkey_4, _) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3428 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3429 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
3430 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
3431 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
3432 let commitment_signed = msgs::CommitmentSigned {
3433 channel_id: [2; 32],
3435 htlc_signatures: if htlcs { vec![sig_2, sig_3, sig_4] } else { Vec::new() },
3437 partial_signature_with_nonce: None,
3439 let encoded_value = commitment_signed.encode();
3440 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3442 target_value.append(&mut hex::decode("00031735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
3444 target_value.append(&mut hex::decode("0000").unwrap());
3446 assert_eq!(encoded_value, target_value);
3450 fn encoding_commitment_signed() {
3451 do_encoding_commitment_signed(true);
3452 do_encoding_commitment_signed(false);
3456 fn encoding_revoke_and_ack() {
3457 let secp_ctx = Secp256k1::new();
3458 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3459 let raa = msgs::RevokeAndACK {
3460 channel_id: [2; 32],
3461 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],
3462 next_per_commitment_point: pubkey_1,
3464 next_local_nonce: None,
3466 let encoded_value = raa.encode();
3467 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020101010101010101010101010101010101010101010101010101010101010101031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3468 assert_eq!(encoded_value, target_value);
3472 fn encoding_update_fee() {
3473 let update_fee = msgs::UpdateFee {
3474 channel_id: [2; 32],
3475 feerate_per_kw: 20190119,
3477 let encoded_value = update_fee.encode();
3478 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202013413a7").unwrap();
3479 assert_eq!(encoded_value, target_value);
3483 fn encoding_init() {
3484 let mainnet_hash = ChainHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap();
3485 assert_eq!(msgs::Init {
3486 features: InitFeatures::from_le_bytes(vec![0xFF, 0xFF, 0xFF]),
3487 networks: Some(vec![mainnet_hash]),
3488 remote_network_address: None,
3489 }.encode(), hex::decode("00023fff0003ffffff01206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3490 assert_eq!(msgs::Init {
3491 features: InitFeatures::from_le_bytes(vec![0xFF]),
3493 remote_network_address: None,
3494 }.encode(), hex::decode("0001ff0001ff").unwrap());
3495 assert_eq!(msgs::Init {
3496 features: InitFeatures::from_le_bytes(vec![]),
3497 networks: Some(vec![mainnet_hash]),
3498 remote_network_address: None,
3499 }.encode(), hex::decode("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3500 assert_eq!(msgs::Init {
3501 features: InitFeatures::from_le_bytes(vec![]),
3502 networks: Some(vec![ChainHash::from(&[1; 32][..]), ChainHash::from(&[2; 32][..])]),
3503 remote_network_address: None,
3504 }.encode(), hex::decode("00000000014001010101010101010101010101010101010101010101010101010101010101010202020202020202020202020202020202020202020202020202020202020202").unwrap());
3505 let init_msg = msgs::Init { features: InitFeatures::from_le_bytes(vec![]),
3506 networks: Some(vec![mainnet_hash]),
3507 remote_network_address: Some(msgs::NetAddress::IPv4 {
3508 addr: [127, 0, 0, 1],
3512 let encoded_value = init_msg.encode();
3513 let target_value = hex::decode("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d61900000000000307017f00000103e8").unwrap();
3514 assert_eq!(encoded_value, target_value);
3515 assert_eq!(msgs::Init::read(&mut Cursor::new(&target_value)).unwrap(), init_msg);
3519 fn encoding_error() {
3520 let error = msgs::ErrorMessage {
3521 channel_id: [2; 32],
3522 data: String::from("rust-lightning"),
3524 let encoded_value = error.encode();
3525 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3526 assert_eq!(encoded_value, target_value);
3530 fn encoding_warning() {
3531 let error = msgs::WarningMessage {
3532 channel_id: [2; 32],
3533 data: String::from("rust-lightning"),
3535 let encoded_value = error.encode();
3536 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3537 assert_eq!(encoded_value, target_value);
3541 fn encoding_ping() {
3542 let ping = msgs::Ping {
3546 let encoded_value = ping.encode();
3547 let target_value = hex::decode("0040004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3548 assert_eq!(encoded_value, target_value);
3552 fn encoding_pong() {
3553 let pong = msgs::Pong {
3556 let encoded_value = pong.encode();
3557 let target_value = hex::decode("004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3558 assert_eq!(encoded_value, target_value);
3562 fn encoding_nonfinal_onion_hop_data() {
3563 let outbound_msg = msgs::OutboundOnionPayload::Forward {
3564 short_channel_id: 0xdeadbeef1bad1dea,
3565 amt_to_forward: 0x0badf00d01020304,
3566 outgoing_cltv_value: 0xffffffff,
3568 let encoded_value = outbound_msg.encode();
3569 let target_value = hex::decode("1a02080badf00d010203040404ffffffff0608deadbeef1bad1dea").unwrap();
3570 assert_eq!(encoded_value, target_value);
3572 let inbound_msg = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3573 if let msgs::InboundOnionPayload::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } = inbound_msg {
3574 assert_eq!(short_channel_id, 0xdeadbeef1bad1dea);
3575 assert_eq!(amt_to_forward, 0x0badf00d01020304);
3576 assert_eq!(outgoing_cltv_value, 0xffffffff);
3577 } else { panic!(); }
3581 fn encoding_final_onion_hop_data() {
3582 let outbound_msg = msgs::OutboundOnionPayload::Receive {
3584 payment_metadata: None,
3585 keysend_preimage: None,
3586 amt_msat: 0x0badf00d01020304,
3587 outgoing_cltv_value: 0xffffffff,
3588 custom_tlvs: vec![],
3590 let encoded_value = outbound_msg.encode();
3591 let target_value = hex::decode("1002080badf00d010203040404ffffffff").unwrap();
3592 assert_eq!(encoded_value, target_value);
3594 let inbound_msg = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3595 if let msgs::InboundOnionPayload::Receive { payment_data: None, amt_msat, outgoing_cltv_value, .. } = inbound_msg {
3596 assert_eq!(amt_msat, 0x0badf00d01020304);
3597 assert_eq!(outgoing_cltv_value, 0xffffffff);
3598 } else { panic!(); }
3602 fn encoding_final_onion_hop_data_with_secret() {
3603 let expected_payment_secret = PaymentSecret([0x42u8; 32]);
3604 let outbound_msg = msgs::OutboundOnionPayload::Receive {
3605 payment_data: Some(FinalOnionHopData {
3606 payment_secret: expected_payment_secret,
3607 total_msat: 0x1badca1f
3609 payment_metadata: None,
3610 keysend_preimage: None,
3611 amt_msat: 0x0badf00d01020304,
3612 outgoing_cltv_value: 0xffffffff,
3613 custom_tlvs: vec![],
3615 let encoded_value = outbound_msg.encode();
3616 let target_value = hex::decode("3602080badf00d010203040404ffffffff082442424242424242424242424242424242424242424242424242424242424242421badca1f").unwrap();
3617 assert_eq!(encoded_value, target_value);
3619 let inbound_msg = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3620 if let msgs::InboundOnionPayload::Receive {
3621 payment_data: Some(FinalOnionHopData {
3623 total_msat: 0x1badca1f
3625 amt_msat, outgoing_cltv_value,
3626 payment_metadata: None,
3627 keysend_preimage: None,
3630 assert_eq!(payment_secret, expected_payment_secret);
3631 assert_eq!(amt_msat, 0x0badf00d01020304);
3632 assert_eq!(outgoing_cltv_value, 0xffffffff);
3633 assert_eq!(custom_tlvs, vec![]);
3634 } else { panic!(); }
3638 fn encoding_final_onion_hop_data_with_bad_custom_tlvs() {
3639 // If custom TLVs have type number within the range reserved for protocol, treat them as if
3641 let bad_type_range_tlvs = vec![
3642 ((1 << 16) - 4, vec![42]),
3643 ((1 << 16) - 2, vec![42; 32]),
3645 let mut msg = msgs::OutboundOnionPayload::Receive {
3647 payment_metadata: None,
3648 keysend_preimage: None,
3649 custom_tlvs: bad_type_range_tlvs,
3650 amt_msat: 0x0badf00d01020304,
3651 outgoing_cltv_value: 0xffffffff,
3653 let encoded_value = msg.encode();
3654 assert!(msgs::InboundOnionPayload::read(&mut Cursor::new(&encoded_value[..])).is_err());
3655 let good_type_range_tlvs = vec![
3656 ((1 << 16) - 3, vec![42]),
3657 ((1 << 16) - 1, vec![42; 32]),
3659 if let msgs::OutboundOnionPayload::Receive { ref mut custom_tlvs, .. } = msg {
3660 *custom_tlvs = good_type_range_tlvs.clone();
3662 let encoded_value = msg.encode();
3663 let inbound_msg = Readable::read(&mut Cursor::new(&encoded_value[..])).unwrap();
3665 msgs::InboundOnionPayload::Receive { custom_tlvs, .. } => assert!(custom_tlvs.is_empty()),
3671 fn encoding_final_onion_hop_data_with_custom_tlvs() {
3672 let expected_custom_tlvs = vec![
3673 (5482373483, vec![0x12, 0x34]),
3674 (5482373487, vec![0x42u8; 8]),
3676 let msg = msgs::OutboundOnionPayload::Receive {
3678 payment_metadata: None,
3679 keysend_preimage: None,
3680 custom_tlvs: expected_custom_tlvs.clone(),
3681 amt_msat: 0x0badf00d01020304,
3682 outgoing_cltv_value: 0xffffffff,
3684 let encoded_value = msg.encode();
3685 let target_value = hex::decode("2e02080badf00d010203040404ffffffffff0000000146c6616b021234ff0000000146c6616f084242424242424242").unwrap();
3686 assert_eq!(encoded_value, target_value);
3687 let inbound_msg: msgs::InboundOnionPayload = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3688 if let msgs::InboundOnionPayload::Receive {
3690 payment_metadata: None,
3691 keysend_preimage: None,
3694 outgoing_cltv_value,
3697 assert_eq!(custom_tlvs, expected_custom_tlvs);
3698 assert_eq!(amt_msat, 0x0badf00d01020304);
3699 assert_eq!(outgoing_cltv_value, 0xffffffff);
3700 } else { panic!(); }
3704 fn query_channel_range_end_blocknum() {
3705 let tests: Vec<(u32, u32, u32)> = vec![
3706 (10000, 1500, 11500),
3707 (0, 0xffffffff, 0xffffffff),
3708 (1, 0xffffffff, 0xffffffff),
3711 for (first_blocknum, number_of_blocks, expected) in tests.into_iter() {
3712 let sut = msgs::QueryChannelRange {
3713 chain_hash: BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap(),
3717 assert_eq!(sut.end_blocknum(), expected);
3722 fn encoding_query_channel_range() {
3723 let mut query_channel_range = msgs::QueryChannelRange {
3724 chain_hash: BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap(),
3725 first_blocknum: 100000,
3726 number_of_blocks: 1500,
3728 let encoded_value = query_channel_range.encode();
3729 let target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206000186a0000005dc").unwrap();
3730 assert_eq!(encoded_value, target_value);
3732 query_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3733 assert_eq!(query_channel_range.first_blocknum, 100000);
3734 assert_eq!(query_channel_range.number_of_blocks, 1500);
3738 fn encoding_reply_channel_range() {
3739 do_encoding_reply_channel_range(0);
3740 do_encoding_reply_channel_range(1);
3743 fn do_encoding_reply_channel_range(encoding_type: u8) {
3744 let mut target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206000b8a06000005dc01").unwrap();
3745 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3746 let mut reply_channel_range = msgs::ReplyChannelRange {
3747 chain_hash: expected_chain_hash,
3748 first_blocknum: 756230,
3749 number_of_blocks: 1500,
3750 sync_complete: true,
3751 short_channel_ids: vec![0x000000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
3754 if encoding_type == 0 {
3755 target_value.append(&mut hex::decode("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
3756 let encoded_value = reply_channel_range.encode();
3757 assert_eq!(encoded_value, target_value);
3759 reply_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3760 assert_eq!(reply_channel_range.chain_hash, expected_chain_hash);
3761 assert_eq!(reply_channel_range.first_blocknum, 756230);
3762 assert_eq!(reply_channel_range.number_of_blocks, 1500);
3763 assert_eq!(reply_channel_range.sync_complete, true);
3764 assert_eq!(reply_channel_range.short_channel_ids[0], 0x000000000000008e);
3765 assert_eq!(reply_channel_range.short_channel_ids[1], 0x0000000000003c69);
3766 assert_eq!(reply_channel_range.short_channel_ids[2], 0x000000000045a6c4);
3768 target_value.append(&mut hex::decode("001601789c636000833e08659309a65878be010010a9023a").unwrap());
3769 let result: Result<msgs::ReplyChannelRange, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
3770 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
3775 fn encoding_query_short_channel_ids() {
3776 do_encoding_query_short_channel_ids(0);
3777 do_encoding_query_short_channel_ids(1);
3780 fn do_encoding_query_short_channel_ids(encoding_type: u8) {
3781 let mut target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206").unwrap();
3782 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3783 let mut query_short_channel_ids = msgs::QueryShortChannelIds {
3784 chain_hash: expected_chain_hash,
3785 short_channel_ids: vec![0x0000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
3788 if encoding_type == 0 {
3789 target_value.append(&mut hex::decode("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
3790 let encoded_value = query_short_channel_ids.encode();
3791 assert_eq!(encoded_value, target_value);
3793 query_short_channel_ids = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3794 assert_eq!(query_short_channel_ids.chain_hash, expected_chain_hash);
3795 assert_eq!(query_short_channel_ids.short_channel_ids[0], 0x000000000000008e);
3796 assert_eq!(query_short_channel_ids.short_channel_ids[1], 0x0000000000003c69);
3797 assert_eq!(query_short_channel_ids.short_channel_ids[2], 0x000000000045a6c4);
3799 target_value.append(&mut hex::decode("001601789c636000833e08659309a65878be010010a9023a").unwrap());
3800 let result: Result<msgs::QueryShortChannelIds, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
3801 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
3806 fn encoding_reply_short_channel_ids_end() {
3807 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3808 let mut reply_short_channel_ids_end = msgs::ReplyShortChannelIdsEnd {
3809 chain_hash: expected_chain_hash,
3810 full_information: true,
3812 let encoded_value = reply_short_channel_ids_end.encode();
3813 let target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e220601").unwrap();
3814 assert_eq!(encoded_value, target_value);
3816 reply_short_channel_ids_end = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3817 assert_eq!(reply_short_channel_ids_end.chain_hash, expected_chain_hash);
3818 assert_eq!(reply_short_channel_ids_end.full_information, true);
3822 fn encoding_gossip_timestamp_filter(){
3823 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3824 let mut gossip_timestamp_filter = msgs::GossipTimestampFilter {
3825 chain_hash: expected_chain_hash,
3826 first_timestamp: 1590000000,
3827 timestamp_range: 0xffff_ffff,
3829 let encoded_value = gossip_timestamp_filter.encode();
3830 let target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e22065ec57980ffffffff").unwrap();
3831 assert_eq!(encoded_value, target_value);
3833 gossip_timestamp_filter = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3834 assert_eq!(gossip_timestamp_filter.chain_hash, expected_chain_hash);
3835 assert_eq!(gossip_timestamp_filter.first_timestamp, 1590000000);
3836 assert_eq!(gossip_timestamp_filter.timestamp_range, 0xffff_ffff);
3840 fn decode_onion_hop_data_len_as_bigsize() {
3841 // Tests that we can decode an onion payload that is >253 bytes.
3842 // Previously, receiving a payload of this size could've caused us to fail to decode a valid
3843 // payload, because we were decoding the length (a BigSize, big-endian) as a VarInt
3846 // Encode a test onion payload with a big custom TLV such that it's >253 bytes, forcing the
3847 // payload length to be encoded over multiple bytes rather than a single u8.
3848 let big_payload = encode_big_payload().unwrap();
3849 let mut rd = Cursor::new(&big_payload[..]);
3850 <msgs::InboundOnionPayload as Readable>::read(&mut rd).unwrap();
3852 // see above test, needs to be a separate method for use of the serialization macros.
3853 fn encode_big_payload() -> Result<Vec<u8>, io::Error> {
3854 use crate::util::ser::HighZeroBytesDroppedBigSize;
3855 let payload = msgs::OutboundOnionPayload::Forward {
3856 short_channel_id: 0xdeadbeef1bad1dea,
3857 amt_to_forward: 1000,
3858 outgoing_cltv_value: 0xffffffff,
3860 let mut encoded_payload = Vec::new();
3861 let test_bytes = vec![42u8; 1000];
3862 if let msgs::OutboundOnionPayload::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } = payload {
3863 _encode_varint_length_prefixed_tlv!(&mut encoded_payload, {
3864 (1, test_bytes, required_vec),
3865 (2, HighZeroBytesDroppedBigSize(amt_to_forward), required),
3866 (4, HighZeroBytesDroppedBigSize(outgoing_cltv_value), required),
3867 (6, short_channel_id, required)