1 // This file is Copyright its original authors, visible in version control
4 // This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
5 // or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
6 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
7 // You may not use this file except in accordance with one or both of these
10 //! Wire messages, traits representing wire message handlers, and a few error types live here.
12 //! For a normal node you probably don't need to use anything here, however, if you wish to split a
13 //! node into an internet-facing route/message socket handling daemon and a separate daemon (or
14 //! server entirely) which handles only channel-related messages you may wish to implement
15 //! [`ChannelMessageHandler`] yourself and use it to re-serialize messages and pass them across
18 //! Note that if you go with such an architecture (instead of passing raw socket events to a
19 //! non-internet-facing system) you trust the frontend internet-facing system to not lie about the
20 //! source `node_id` of the message, however this does allow you to significantly reduce bandwidth
21 //! between the systems as routing messages can represent a significant chunk of bandwidth usage
22 //! (especially for non-channel-publicly-announcing nodes). As an alternate design which avoids
23 //! this issue, if you have sufficient bidirectional bandwidth between your systems, you may send
24 //! raw socket events into your non-internet-facing system and then send routing events back to
25 //! track the network on the less-secure system.
27 use bitcoin::blockdata::constants::ChainHash;
28 use bitcoin::secp256k1::PublicKey;
29 use bitcoin::secp256k1::ecdsa::Signature;
30 use bitcoin::{secp256k1, Witness};
31 use bitcoin::blockdata::script::Script;
32 use bitcoin::hash_types::{Txid, BlockHash};
34 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
35 use crate::ln::onion_utils;
36 use crate::onion_message;
38 use crate::prelude::*;
41 use crate::io::{self, Read};
42 use crate::io_extras::read_to_end;
44 use crate::events::{MessageSendEventsProvider, OnionMessageProvider};
45 use crate::util::logger;
46 use crate::util::ser::{LengthReadable, Readable, ReadableArgs, Writeable, Writer, WithoutLength, FixedLengthReader, HighZeroBytesDroppedBigSize, Hostname, TransactionU16LenLimited};
48 use crate::ln::{PaymentPreimage, PaymentHash, PaymentSecret};
50 use crate::routing::gossip::{NodeAlias, NodeId};
52 /// 21 million * 10^8 * 1000
53 pub(crate) const MAX_VALUE_MSAT: u64 = 21_000_000_0000_0000_000;
56 /// A partial signature that also contains the Musig2 nonce its signer used
57 #[derive(Clone, Debug, PartialEq, Eq)]
58 pub struct PartialSignatureWithNonce(pub musig2::types::PartialSignature, pub musig2::types::PublicNonce);
60 /// An error in decoding a message or struct.
61 #[derive(Clone, Debug, PartialEq, Eq)]
62 pub enum DecodeError {
63 /// A version byte specified something we don't know how to handle.
65 /// Includes unknown realm byte in an onion hop data packet.
67 /// Unknown feature mandating we fail to parse message (e.g., TLV with an even, unknown type)
68 UnknownRequiredFeature,
69 /// Value was invalid.
71 /// For example, a byte which was supposed to be a bool was something other than a 0
72 /// or 1, a public key/private key/signature was invalid, text wasn't UTF-8, TLV was
73 /// syntactically incorrect, etc.
75 /// The buffer to be read was too short.
77 /// A length descriptor in the packet didn't describe the later data correctly.
79 /// Error from [`std::io`].
81 /// The message included zlib-compressed values, which we don't support.
82 UnsupportedCompression,
85 /// An [`init`] message to be sent to or received from a peer.
87 /// [`init`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-init-message
88 #[derive(Clone, Debug, PartialEq, Eq)]
90 /// The relevant features which the sender supports.
91 pub features: InitFeatures,
92 /// Indicates chains the sender is interested in.
94 /// If there are no common chains, the connection will be closed.
95 pub networks: Option<Vec<ChainHash>>,
96 /// The receipient's network address.
98 /// This adds the option to report a remote IP address back to a connecting peer using the init
99 /// message. A node can decide to use that information to discover a potential update to its
100 /// public IPv4 address (NAT) and use that for a [`NodeAnnouncement`] update message containing
102 pub remote_network_address: Option<NetAddress>,
105 /// An [`error`] message to be sent to or received from a peer.
107 /// [`error`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-error-and-warning-messages
108 #[derive(Clone, Debug, PartialEq, Eq)]
109 pub struct ErrorMessage {
110 /// The channel ID involved in the error.
112 /// All-0s indicates a general error unrelated to a specific channel, after which all channels
113 /// with the sending peer should be closed.
114 pub channel_id: [u8; 32],
115 /// A possibly human-readable error description.
117 /// The string should be sanitized before it is used (e.g., emitted to logs or printed to
118 /// `stdout`). Otherwise, a well crafted error message may trigger a security vulnerability in
119 /// the terminal emulator or the logging subsystem.
123 /// A [`warning`] message to be sent to or received from a peer.
125 /// [`warning`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-error-and-warning-messages
126 #[derive(Clone, Debug, PartialEq, Eq)]
127 pub struct WarningMessage {
128 /// The channel ID involved in the warning.
130 /// All-0s indicates a warning unrelated to a specific channel.
131 pub channel_id: [u8; 32],
132 /// A possibly human-readable warning description.
134 /// The string should be sanitized before it is used (e.g. emitted to logs or printed to
135 /// stdout). Otherwise, a well crafted error message may trigger a security vulnerability in
136 /// the terminal emulator or the logging subsystem.
140 /// A [`ping`] message to be sent to or received from a peer.
142 /// [`ping`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-ping-and-pong-messages
143 #[derive(Clone, Debug, PartialEq, Eq)]
145 /// The desired response length.
147 /// The ping packet size.
149 /// This field is not sent on the wire. byteslen zeros are sent.
153 /// A [`pong`] message to be sent to or received from a peer.
155 /// [`pong`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-ping-and-pong-messages
156 #[derive(Clone, Debug, PartialEq, Eq)]
158 /// The pong packet size.
160 /// This field is not sent on the wire. byteslen zeros are sent.
164 /// An [`open_channel`] message to be sent to or received from a peer.
166 /// Used in V1 channel establishment
168 /// [`open_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-open_channel-message
169 #[derive(Clone, Debug, PartialEq, Eq)]
170 pub struct OpenChannel {
171 /// The genesis hash of the blockchain where the channel is to be opened
172 pub chain_hash: BlockHash,
173 /// A temporary channel ID, until the funding outpoint is announced
174 pub temporary_channel_id: [u8; 32],
175 /// The channel value
176 pub funding_satoshis: u64,
177 /// The amount to push to the counterparty as part of the open, in milli-satoshi
179 /// The threshold below which outputs on transactions broadcast by sender will be omitted
180 pub dust_limit_satoshis: u64,
181 /// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
182 pub max_htlc_value_in_flight_msat: u64,
183 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
184 pub channel_reserve_satoshis: u64,
185 /// The minimum HTLC size incoming to sender, in milli-satoshi
186 pub htlc_minimum_msat: u64,
187 /// The feerate per 1000-weight of sender generated transactions, until updated by
189 pub feerate_per_kw: u32,
190 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if
191 /// they broadcast a commitment transaction
192 pub to_self_delay: u16,
193 /// The maximum number of inbound HTLCs towards sender
194 pub max_accepted_htlcs: u16,
195 /// The sender's key controlling the funding transaction
196 pub funding_pubkey: PublicKey,
197 /// Used to derive a revocation key for transactions broadcast by counterparty
198 pub revocation_basepoint: PublicKey,
199 /// A payment key to sender for transactions broadcast by counterparty
200 pub payment_point: PublicKey,
201 /// Used to derive a payment key to sender for transactions broadcast by sender
202 pub delayed_payment_basepoint: PublicKey,
203 /// Used to derive an HTLC payment key to sender
204 pub htlc_basepoint: PublicKey,
205 /// The first to-be-broadcast-by-sender transaction's per commitment point
206 pub first_per_commitment_point: PublicKey,
207 /// The channel flags to be used
208 pub channel_flags: u8,
209 /// A request to pre-set the to-sender output's `scriptPubkey` for when we collaboratively close
210 pub shutdown_scriptpubkey: Option<Script>,
211 /// The channel type that this channel will represent
213 /// If this is `None`, we derive the channel type from the intersection of our
214 /// feature bits with our counterparty's feature bits from the [`Init`] message.
215 pub channel_type: Option<ChannelTypeFeatures>,
218 /// An open_channel2 message to be sent by or received from the channel initiator.
220 /// Used in V2 channel establishment
222 // TODO(dual_funding): Add spec link for `open_channel2`.
223 #[derive(Clone, Debug, PartialEq, Eq)]
224 pub struct OpenChannelV2 {
225 /// The genesis hash of the blockchain where the channel is to be opened
226 pub chain_hash: BlockHash,
227 /// A temporary channel ID derived using a zeroed out value for the channel acceptor's revocation basepoint
228 pub temporary_channel_id: [u8; 32],
229 /// The feerate for the funding transaction set by the channel initiator
230 pub funding_feerate_sat_per_1000_weight: u32,
231 /// The feerate for the commitment transaction set by the channel initiator
232 pub commitment_feerate_sat_per_1000_weight: u32,
233 /// Part of the channel value contributed by the channel initiator
234 pub funding_satoshis: u64,
235 /// The threshold below which outputs on transactions broadcast by the channel initiator will be
237 pub dust_limit_satoshis: u64,
238 /// The maximum inbound HTLC value in flight towards channel initiator, in milli-satoshi
239 pub max_htlc_value_in_flight_msat: u64,
240 /// The minimum HTLC size incoming to channel initiator, in milli-satoshi
241 pub htlc_minimum_msat: u64,
242 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
243 /// broadcast a commitment transaction
244 pub to_self_delay: u16,
245 /// The maximum number of inbound HTLCs towards channel initiator
246 pub max_accepted_htlcs: u16,
247 /// The locktime for the funding transaction
249 /// The channel initiator's key controlling the funding transaction
250 pub funding_pubkey: PublicKey,
251 /// Used to derive a revocation key for transactions broadcast by counterparty
252 pub revocation_basepoint: PublicKey,
253 /// A payment key to channel initiator for transactions broadcast by counterparty
254 pub payment_basepoint: PublicKey,
255 /// Used to derive a payment key to channel initiator for transactions broadcast by channel
257 pub delayed_payment_basepoint: PublicKey,
258 /// Used to derive an HTLC payment key to channel initiator
259 pub htlc_basepoint: PublicKey,
260 /// The first to-be-broadcast-by-channel-initiator transaction's per commitment point
261 pub first_per_commitment_point: PublicKey,
262 /// The second to-be-broadcast-by-channel-initiator transaction's per commitment point
263 pub second_per_commitment_point: PublicKey,
265 pub channel_flags: u8,
266 /// Optionally, a request to pre-set the to-channel-initiator output's scriptPubkey for when we
267 /// collaboratively close
268 pub shutdown_scriptpubkey: Option<Script>,
269 /// The channel type that this channel will represent. If none is set, we derive the channel
270 /// type from the intersection of our feature bits with our counterparty's feature bits from
271 /// the Init message.
272 pub channel_type: Option<ChannelTypeFeatures>,
273 /// Optionally, a requirement that only confirmed inputs can be added
274 pub require_confirmed_inputs: Option<()>,
277 /// An [`accept_channel`] message to be sent to or received from a peer.
279 /// Used in V1 channel establishment
281 /// [`accept_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-accept_channel-message
282 #[derive(Clone, Debug, PartialEq, Eq)]
283 pub struct AcceptChannel {
284 /// A temporary channel ID, until the funding outpoint is announced
285 pub temporary_channel_id: [u8; 32],
286 /// The threshold below which outputs on transactions broadcast by sender will be omitted
287 pub dust_limit_satoshis: u64,
288 /// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
289 pub max_htlc_value_in_flight_msat: u64,
290 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
291 pub channel_reserve_satoshis: u64,
292 /// The minimum HTLC size incoming to sender, in milli-satoshi
293 pub htlc_minimum_msat: u64,
294 /// Minimum depth of the funding transaction before the channel is considered open
295 pub minimum_depth: u32,
296 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they broadcast a commitment transaction
297 pub to_self_delay: u16,
298 /// The maximum number of inbound HTLCs towards sender
299 pub max_accepted_htlcs: u16,
300 /// The sender's key controlling the funding transaction
301 pub funding_pubkey: PublicKey,
302 /// Used to derive a revocation key for transactions broadcast by counterparty
303 pub revocation_basepoint: PublicKey,
304 /// A payment key to sender for transactions broadcast by counterparty
305 pub payment_point: PublicKey,
306 /// Used to derive a payment key to sender for transactions broadcast by sender
307 pub delayed_payment_basepoint: PublicKey,
308 /// Used to derive an HTLC payment key to sender for transactions broadcast by counterparty
309 pub htlc_basepoint: PublicKey,
310 /// The first to-be-broadcast-by-sender transaction's per commitment point
311 pub first_per_commitment_point: PublicKey,
312 /// A request to pre-set the to-sender output's scriptPubkey for when we collaboratively close
313 pub shutdown_scriptpubkey: Option<Script>,
314 /// The channel type that this channel will represent.
316 /// If this is `None`, we derive the channel type from the intersection of
317 /// our feature bits with our counterparty's feature bits from the [`Init`] message.
318 /// This is required to match the equivalent field in [`OpenChannel::channel_type`].
319 pub channel_type: Option<ChannelTypeFeatures>,
321 /// Next nonce the channel initiator should use to create a funding output signature against
322 pub next_local_nonce: Option<musig2::types::PublicNonce>,
325 /// An accept_channel2 message to be sent by or received from the channel accepter.
327 /// Used in V2 channel establishment
329 // TODO(dual_funding): Add spec link for `accept_channel2`.
330 #[derive(Clone, Debug, PartialEq, Eq)]
331 pub struct AcceptChannelV2 {
332 /// The same `temporary_channel_id` received from the initiator's `open_channel2` message.
333 pub temporary_channel_id: [u8; 32],
334 /// Part of the channel value contributed by the channel acceptor
335 pub funding_satoshis: u64,
336 /// The threshold below which outputs on transactions broadcast by the channel acceptor will be
338 pub dust_limit_satoshis: u64,
339 /// The maximum inbound HTLC value in flight towards channel acceptor, in milli-satoshi
340 pub max_htlc_value_in_flight_msat: u64,
341 /// The minimum HTLC size incoming to channel acceptor, in milli-satoshi
342 pub htlc_minimum_msat: u64,
343 /// Minimum depth of the funding transaction before the channel is considered open
344 pub minimum_depth: u32,
345 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
346 /// broadcast a commitment transaction
347 pub to_self_delay: u16,
348 /// The maximum number of inbound HTLCs towards channel acceptor
349 pub max_accepted_htlcs: u16,
350 /// The channel acceptor's key controlling the funding transaction
351 pub funding_pubkey: PublicKey,
352 /// Used to derive a revocation key for transactions broadcast by counterparty
353 pub revocation_basepoint: PublicKey,
354 /// A payment key to channel acceptor for transactions broadcast by counterparty
355 pub payment_basepoint: PublicKey,
356 /// Used to derive a payment key to channel acceptor for transactions broadcast by channel
358 pub delayed_payment_basepoint: PublicKey,
359 /// Used to derive an HTLC payment key to channel acceptor for transactions broadcast by counterparty
360 pub htlc_basepoint: PublicKey,
361 /// The first to-be-broadcast-by-channel-acceptor transaction's per commitment point
362 pub first_per_commitment_point: PublicKey,
363 /// The second to-be-broadcast-by-channel-acceptor transaction's per commitment point
364 pub second_per_commitment_point: PublicKey,
365 /// Optionally, a request to pre-set the to-channel-acceptor output's scriptPubkey for when we
366 /// collaboratively close
367 pub shutdown_scriptpubkey: Option<Script>,
368 /// The channel type that this channel will represent. If none is set, we derive the channel
369 /// type from the intersection of our feature bits with our counterparty's feature bits from
370 /// the Init message.
372 /// This is required to match the equivalent field in [`OpenChannelV2::channel_type`].
373 pub channel_type: Option<ChannelTypeFeatures>,
374 /// Optionally, a requirement that only confirmed inputs can be added
375 pub require_confirmed_inputs: Option<()>,
378 /// A [`funding_created`] message to be sent to or received from a peer.
380 /// Used in V1 channel establishment
382 /// [`funding_created`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-funding_created-message
383 #[derive(Clone, Debug, PartialEq, Eq)]
384 pub struct FundingCreated {
385 /// A temporary channel ID, until the funding is established
386 pub temporary_channel_id: [u8; 32],
387 /// The funding transaction ID
388 pub funding_txid: Txid,
389 /// The specific output index funding this channel
390 pub funding_output_index: u16,
391 /// The signature of the channel initiator (funder) on the initial commitment transaction
392 pub signature: Signature,
394 /// The partial signature of the channel initiator (funder)
395 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
397 /// Next nonce the channel acceptor should use to finalize the funding output signature
398 pub next_local_nonce: Option<musig2::types::PublicNonce>
401 /// A [`funding_signed`] message to be sent to or received from a peer.
403 /// Used in V1 channel establishment
405 /// [`funding_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-funding_signed-message
406 #[derive(Clone, Debug, PartialEq, Eq)]
407 pub struct FundingSigned {
409 pub channel_id: [u8; 32],
410 /// The signature of the channel acceptor (fundee) on the initial commitment transaction
411 pub signature: Signature,
413 /// The partial signature of the channel acceptor (fundee)
414 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
417 /// A [`channel_ready`] message to be sent to or received from a peer.
419 /// [`channel_ready`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-channel_ready-message
420 #[derive(Clone, Debug, PartialEq, Eq)]
421 pub struct ChannelReady {
423 pub channel_id: [u8; 32],
424 /// The per-commitment point of the second commitment transaction
425 pub next_per_commitment_point: PublicKey,
426 /// If set, provides a `short_channel_id` alias for this channel.
428 /// The sender will accept payments to be forwarded over this SCID and forward them to this
429 /// messages' recipient.
430 pub short_channel_id_alias: Option<u64>,
433 /// A tx_add_input message for adding an input during interactive transaction construction
435 // TODO(dual_funding): Add spec link for `tx_add_input`.
436 #[derive(Clone, Debug, PartialEq, Eq)]
437 pub struct TxAddInput {
439 pub channel_id: [u8; 32],
440 /// A randomly chosen unique identifier for this input, which is even for initiators and odd for
443 /// Serialized transaction that contains the output this input spends to verify that it is non
445 pub prevtx: TransactionU16LenLimited,
446 /// The index of the output being spent
448 /// The sequence number of this input
452 /// A tx_add_output message for adding an output during interactive transaction construction.
454 // TODO(dual_funding): Add spec link for `tx_add_output`.
455 #[derive(Clone, Debug, PartialEq, Eq)]
456 pub struct TxAddOutput {
458 pub channel_id: [u8; 32],
459 /// A randomly chosen unique identifier for this output, which is even for initiators and odd for
462 /// The satoshi value of the output
464 /// The scriptPubKey for the output
468 /// A tx_remove_input message for removing an input during interactive transaction construction.
470 // TODO(dual_funding): Add spec link for `tx_remove_input`.
471 #[derive(Clone, Debug, PartialEq, Eq)]
472 pub struct TxRemoveInput {
474 pub channel_id: [u8; 32],
475 /// The serial ID of the input to be removed
479 /// A tx_remove_output message for removing an output during interactive transaction construction.
481 // TODO(dual_funding): Add spec link for `tx_remove_output`.
482 #[derive(Clone, Debug, PartialEq, Eq)]
483 pub struct TxRemoveOutput {
485 pub channel_id: [u8; 32],
486 /// The serial ID of the output to be removed
490 /// A tx_complete message signalling the conclusion of a peer's transaction contributions during
491 /// interactive transaction construction.
493 // TODO(dual_funding): Add spec link for `tx_complete`.
494 #[derive(Clone, Debug, PartialEq, Eq)]
495 pub struct TxComplete {
497 pub channel_id: [u8; 32],
500 /// A tx_signatures message containing the sender's signatures for a transaction constructed with
501 /// interactive transaction construction.
503 // TODO(dual_funding): Add spec link for `tx_signatures`.
504 #[derive(Clone, Debug, PartialEq, Eq)]
505 pub struct TxSignatures {
507 pub channel_id: [u8; 32],
510 /// The list of witnesses
511 pub witnesses: Vec<Witness>,
514 /// A tx_init_rbf message which initiates a replacement of the transaction after it's been
517 // TODO(dual_funding): Add spec link for `tx_init_rbf`.
518 #[derive(Clone, Debug, PartialEq, Eq)]
519 pub struct TxInitRbf {
521 pub channel_id: [u8; 32],
522 /// The locktime of the transaction
524 /// The feerate of the transaction
525 pub feerate_sat_per_1000_weight: u32,
526 /// The number of satoshis the sender will contribute to or, if negative, remove from
527 /// (e.g. splice-out) the funding output of the transaction
528 pub funding_output_contribution: Option<i64>,
531 /// A tx_ack_rbf message which acknowledges replacement of the transaction after it's been
534 // TODO(dual_funding): Add spec link for `tx_ack_rbf`.
535 #[derive(Clone, Debug, PartialEq, Eq)]
536 pub struct TxAckRbf {
538 pub channel_id: [u8; 32],
539 /// The number of satoshis the sender will contribute to or, if negative, remove from
540 /// (e.g. splice-out) the funding output of the transaction
541 pub funding_output_contribution: Option<i64>,
544 /// A tx_abort message which signals the cancellation of an in-progress transaction negotiation.
546 // TODO(dual_funding): Add spec link for `tx_abort`.
547 #[derive(Clone, Debug, PartialEq, Eq)]
550 pub channel_id: [u8; 32],
555 /// A [`shutdown`] message to be sent to or received from a peer.
557 /// [`shutdown`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-initiation-shutdown
558 #[derive(Clone, Debug, PartialEq, Eq)]
559 pub struct Shutdown {
561 pub channel_id: [u8; 32],
562 /// The destination of this peer's funds on closing.
564 /// Must be in one of these forms: P2PKH, P2SH, P2WPKH, P2WSH, P2TR.
565 pub scriptpubkey: Script,
568 /// The minimum and maximum fees which the sender is willing to place on the closing transaction.
570 /// This is provided in [`ClosingSigned`] by both sides to indicate the fee range they are willing
572 #[derive(Clone, Debug, PartialEq, Eq)]
573 pub struct ClosingSignedFeeRange {
574 /// The minimum absolute fee, in satoshis, which the sender is willing to place on the closing
576 pub min_fee_satoshis: u64,
577 /// The maximum absolute fee, in satoshis, which the sender is willing to place on the closing
579 pub max_fee_satoshis: u64,
582 /// A [`closing_signed`] message to be sent to or received from a peer.
584 /// [`closing_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-negotiation-closing_signed
585 #[derive(Clone, Debug, PartialEq, Eq)]
586 pub struct ClosingSigned {
588 pub channel_id: [u8; 32],
589 /// The proposed total fee for the closing transaction
590 pub fee_satoshis: u64,
591 /// A signature on the closing transaction
592 pub signature: Signature,
593 /// The minimum and maximum fees which the sender is willing to accept, provided only by new
595 pub fee_range: Option<ClosingSignedFeeRange>,
598 /// An [`update_add_htlc`] message to be sent to or received from a peer.
600 /// [`update_add_htlc`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#adding-an-htlc-update_add_htlc
601 #[derive(Clone, Debug, PartialEq, Eq)]
602 pub struct UpdateAddHTLC {
604 pub channel_id: [u8; 32],
607 /// The HTLC value in milli-satoshi
608 pub amount_msat: u64,
609 /// The payment hash, the pre-image of which controls HTLC redemption
610 pub payment_hash: PaymentHash,
611 /// The expiry height of the HTLC
612 pub cltv_expiry: u32,
613 pub(crate) onion_routing_packet: OnionPacket,
616 /// An onion message to be sent to or received from a peer.
618 // TODO: update with link to OM when they are merged into the BOLTs
619 #[derive(Clone, Debug, PartialEq, Eq)]
620 pub struct OnionMessage {
621 /// Used in decrypting the onion packet's payload.
622 pub blinding_point: PublicKey,
623 pub(crate) onion_routing_packet: onion_message::Packet,
626 /// An [`update_fulfill_htlc`] message to be sent to or received from a peer.
628 /// [`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
629 #[derive(Clone, Debug, PartialEq, Eq)]
630 pub struct UpdateFulfillHTLC {
632 pub channel_id: [u8; 32],
635 /// The pre-image of the payment hash, allowing HTLC redemption
636 pub payment_preimage: PaymentPreimage,
639 /// An [`update_fail_htlc`] message to be sent to or received from a peer.
641 /// [`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
642 #[derive(Clone, Debug, PartialEq, Eq)]
643 pub struct UpdateFailHTLC {
645 pub channel_id: [u8; 32],
648 pub(crate) reason: OnionErrorPacket,
651 /// An [`update_fail_malformed_htlc`] message to be sent to or received from a peer.
653 /// [`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
654 #[derive(Clone, Debug, PartialEq, Eq)]
655 pub struct UpdateFailMalformedHTLC {
657 pub channel_id: [u8; 32],
660 pub(crate) sha256_of_onion: [u8; 32],
662 pub failure_code: u16,
665 /// A [`commitment_signed`] message to be sent to or received from a peer.
667 /// [`commitment_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#committing-updates-so-far-commitment_signed
668 #[derive(Clone, Debug, PartialEq, Eq)]
669 pub struct CommitmentSigned {
671 pub channel_id: [u8; 32],
672 /// A signature on the commitment transaction
673 pub signature: Signature,
674 /// Signatures on the HTLC transactions
675 pub htlc_signatures: Vec<Signature>,
677 /// The partial Taproot signature on the commitment transaction
678 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
681 /// A [`revoke_and_ack`] message to be sent to or received from a peer.
683 /// [`revoke_and_ack`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#completing-the-transition-to-the-updated-state-revoke_and_ack
684 #[derive(Clone, Debug, PartialEq, Eq)]
685 pub struct RevokeAndACK {
687 pub channel_id: [u8; 32],
688 /// The secret corresponding to the per-commitment point
689 pub per_commitment_secret: [u8; 32],
690 /// The next sender-broadcast commitment transaction's per-commitment point
691 pub next_per_commitment_point: PublicKey,
693 /// Musig nonce the recipient should use in their next commitment signature message
694 pub next_local_nonce: Option<musig2::types::PublicNonce>
697 /// An [`update_fee`] message to be sent to or received from a peer
699 /// [`update_fee`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#updating-fees-update_fee
700 #[derive(Clone, Debug, PartialEq, Eq)]
701 pub struct UpdateFee {
703 pub channel_id: [u8; 32],
704 /// Fee rate per 1000-weight of the transaction
705 pub feerate_per_kw: u32,
708 /// A [`channel_reestablish`] message to be sent to or received from a peer.
710 /// [`channel_reestablish`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#message-retransmission
711 #[derive(Clone, Debug, PartialEq, Eq)]
712 pub struct ChannelReestablish {
714 pub channel_id: [u8; 32],
715 /// The next commitment number for the sender
716 pub next_local_commitment_number: u64,
717 /// The next commitment number for the recipient
718 pub next_remote_commitment_number: u64,
719 /// Proof that the sender knows the per-commitment secret of a specific commitment transaction
720 /// belonging to the recipient
721 pub your_last_per_commitment_secret: [u8; 32],
722 /// The sender's per-commitment point for their current commitment transaction
723 pub my_current_per_commitment_point: PublicKey,
724 /// The next funding transaction ID
725 pub next_funding_txid: Option<Txid>,
728 /// An [`announcement_signatures`] message to be sent to or received from a peer.
730 /// [`announcement_signatures`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-announcement_signatures-message
731 #[derive(Clone, Debug, PartialEq, Eq)]
732 pub struct AnnouncementSignatures {
734 pub channel_id: [u8; 32],
735 /// The short channel ID
736 pub short_channel_id: u64,
737 /// A signature by the node key
738 pub node_signature: Signature,
739 /// A signature by the funding key
740 pub bitcoin_signature: Signature,
743 /// An address which can be used to connect to a remote peer.
744 #[derive(Clone, Debug, PartialEq, Eq)]
745 pub enum NetAddress {
746 /// An IPv4 address/port on which the peer is listening.
748 /// The 4-byte IPv4 address
750 /// The port on which the node is listening
753 /// An IPv6 address/port on which the peer is listening.
755 /// The 16-byte IPv6 address
757 /// The port on which the node is listening
760 /// An old-style Tor onion address/port on which the peer is listening.
762 /// This field is deprecated and the Tor network generally no longer supports V2 Onion
763 /// addresses. Thus, the details are not parsed here.
765 /// A new-style Tor onion address/port on which the peer is listening.
767 /// To create the human-readable "hostname", concatenate the ED25519 pubkey, checksum, and version,
768 /// wrap as base32 and append ".onion".
770 /// The ed25519 long-term public key of the peer
771 ed25519_pubkey: [u8; 32],
772 /// The checksum of the pubkey and version, as included in the onion address
774 /// The version byte, as defined by the Tor Onion v3 spec.
776 /// The port on which the node is listening
779 /// A hostname/port on which the peer is listening.
781 /// The hostname on which the node is listening.
783 /// The port on which the node is listening.
788 /// Gets the ID of this address type. Addresses in [`NodeAnnouncement`] messages should be sorted
790 pub(crate) fn get_id(&self) -> u8 {
792 &NetAddress::IPv4 {..} => { 1 },
793 &NetAddress::IPv6 {..} => { 2 },
794 &NetAddress::OnionV2(_) => { 3 },
795 &NetAddress::OnionV3 {..} => { 4 },
796 &NetAddress::Hostname {..} => { 5 },
800 /// Strict byte-length of address descriptor, 1-byte type not recorded
801 fn len(&self) -> u16 {
803 &NetAddress::IPv4 { .. } => { 6 },
804 &NetAddress::IPv6 { .. } => { 18 },
805 &NetAddress::OnionV2(_) => { 12 },
806 &NetAddress::OnionV3 { .. } => { 37 },
807 // Consists of 1-byte hostname length, hostname bytes, and 2-byte port.
808 &NetAddress::Hostname { ref hostname, .. } => { u16::from(hostname.len()) + 3 },
812 /// The maximum length of any address descriptor, not including the 1-byte type.
813 /// This maximum length is reached by a hostname address descriptor:
814 /// a hostname with a maximum length of 255, its 1-byte length and a 2-byte port.
815 pub(crate) const MAX_LEN: u16 = 258;
818 impl Writeable for NetAddress {
819 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
821 &NetAddress::IPv4 { ref addr, ref port } => {
826 &NetAddress::IPv6 { ref addr, ref port } => {
831 &NetAddress::OnionV2(bytes) => {
833 bytes.write(writer)?;
835 &NetAddress::OnionV3 { ref ed25519_pubkey, ref checksum, ref version, ref port } => {
837 ed25519_pubkey.write(writer)?;
838 checksum.write(writer)?;
839 version.write(writer)?;
842 &NetAddress::Hostname { ref hostname, ref port } => {
844 hostname.write(writer)?;
852 impl Readable for Result<NetAddress, u8> {
853 fn read<R: Read>(reader: &mut R) -> Result<Result<NetAddress, u8>, DecodeError> {
854 let byte = <u8 as Readable>::read(reader)?;
857 Ok(Ok(NetAddress::IPv4 {
858 addr: Readable::read(reader)?,
859 port: Readable::read(reader)?,
863 Ok(Ok(NetAddress::IPv6 {
864 addr: Readable::read(reader)?,
865 port: Readable::read(reader)?,
868 3 => Ok(Ok(NetAddress::OnionV2(Readable::read(reader)?))),
870 Ok(Ok(NetAddress::OnionV3 {
871 ed25519_pubkey: Readable::read(reader)?,
872 checksum: Readable::read(reader)?,
873 version: Readable::read(reader)?,
874 port: Readable::read(reader)?,
878 Ok(Ok(NetAddress::Hostname {
879 hostname: Readable::read(reader)?,
880 port: Readable::read(reader)?,
883 _ => return Ok(Err(byte)),
888 impl Readable for NetAddress {
889 fn read<R: Read>(reader: &mut R) -> Result<NetAddress, DecodeError> {
890 match Readable::read(reader) {
891 Ok(Ok(res)) => Ok(res),
892 Ok(Err(_)) => Err(DecodeError::UnknownVersion),
898 /// Represents the set of gossip messages that require a signature from a node's identity key.
899 pub enum UnsignedGossipMessage<'a> {
900 /// An unsigned channel announcement.
901 ChannelAnnouncement(&'a UnsignedChannelAnnouncement),
902 /// An unsigned channel update.
903 ChannelUpdate(&'a UnsignedChannelUpdate),
904 /// An unsigned node announcement.
905 NodeAnnouncement(&'a UnsignedNodeAnnouncement)
908 impl<'a> Writeable for UnsignedGossipMessage<'a> {
909 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
911 UnsignedGossipMessage::ChannelAnnouncement(ref msg) => msg.write(writer),
912 UnsignedGossipMessage::ChannelUpdate(ref msg) => msg.write(writer),
913 UnsignedGossipMessage::NodeAnnouncement(ref msg) => msg.write(writer),
918 /// The unsigned part of a [`node_announcement`] message.
920 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
921 #[derive(Clone, Debug, PartialEq, Eq)]
922 pub struct UnsignedNodeAnnouncement {
923 /// The advertised features
924 pub features: NodeFeatures,
925 /// A strictly monotonic announcement counter, with gaps allowed
927 /// The `node_id` this announcement originated from (don't rebroadcast the `node_announcement` back
930 /// An RGB color for UI purposes
932 /// An alias, for UI purposes.
934 /// This should be sanitized before use. There is no guarantee of uniqueness.
935 pub alias: NodeAlias,
936 /// List of addresses on which this node is reachable
937 pub addresses: Vec<NetAddress>,
938 pub(crate) excess_address_data: Vec<u8>,
939 pub(crate) excess_data: Vec<u8>,
941 #[derive(Clone, Debug, PartialEq, Eq)]
942 /// A [`node_announcement`] message to be sent to or received from a peer.
944 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
945 pub struct NodeAnnouncement {
946 /// The signature by the node key
947 pub signature: Signature,
948 /// The actual content of the announcement
949 pub contents: UnsignedNodeAnnouncement,
952 /// The unsigned part of a [`channel_announcement`] message.
954 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
955 #[derive(Clone, Debug, PartialEq, Eq)]
956 pub struct UnsignedChannelAnnouncement {
957 /// The advertised channel features
958 pub features: ChannelFeatures,
959 /// The genesis hash of the blockchain where the channel is to be opened
960 pub chain_hash: BlockHash,
961 /// The short channel ID
962 pub short_channel_id: u64,
963 /// One of the two `node_id`s which are endpoints of this channel
964 pub node_id_1: NodeId,
965 /// The other of the two `node_id`s which are endpoints of this channel
966 pub node_id_2: NodeId,
967 /// The funding key for the first node
968 pub bitcoin_key_1: NodeId,
969 /// The funding key for the second node
970 pub bitcoin_key_2: NodeId,
971 pub(crate) excess_data: Vec<u8>,
973 /// A [`channel_announcement`] message to be sent to or received from a peer.
975 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
976 #[derive(Clone, Debug, PartialEq, Eq)]
977 pub struct ChannelAnnouncement {
978 /// Authentication of the announcement by the first public node
979 pub node_signature_1: Signature,
980 /// Authentication of the announcement by the second public node
981 pub node_signature_2: Signature,
982 /// Proof of funding UTXO ownership by the first public node
983 pub bitcoin_signature_1: Signature,
984 /// Proof of funding UTXO ownership by the second public node
985 pub bitcoin_signature_2: Signature,
986 /// The actual announcement
987 pub contents: UnsignedChannelAnnouncement,
990 /// The unsigned part of a [`channel_update`] message.
992 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
993 #[derive(Clone, Debug, PartialEq, Eq)]
994 pub struct UnsignedChannelUpdate {
995 /// The genesis hash of the blockchain where the channel is to be opened
996 pub chain_hash: BlockHash,
997 /// The short channel ID
998 pub short_channel_id: u64,
999 /// A strictly monotonic announcement counter, with gaps allowed, specific to this channel
1003 /// The number of blocks such that if:
1004 /// `incoming_htlc.cltv_expiry < outgoing_htlc.cltv_expiry + cltv_expiry_delta`
1005 /// then we need to fail the HTLC backwards. When forwarding an HTLC, `cltv_expiry_delta` determines
1006 /// the outgoing HTLC's minimum `cltv_expiry` value -- so, if an incoming HTLC comes in with a
1007 /// `cltv_expiry` of 100000, and the node we're forwarding to has a `cltv_expiry_delta` value of 10,
1008 /// then we'll check that the outgoing HTLC's `cltv_expiry` value is at least 100010 before
1009 /// forwarding. Note that the HTLC sender is the one who originally sets this value when
1010 /// constructing the route.
1011 pub cltv_expiry_delta: u16,
1012 /// The minimum HTLC size incoming to sender, in milli-satoshi
1013 pub htlc_minimum_msat: u64,
1014 /// The maximum HTLC value incoming to sender, in milli-satoshi.
1016 /// This used to be optional.
1017 pub htlc_maximum_msat: u64,
1018 /// The base HTLC fee charged by sender, in milli-satoshi
1019 pub fee_base_msat: u32,
1020 /// The amount to fee multiplier, in micro-satoshi
1021 pub fee_proportional_millionths: u32,
1022 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1025 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1026 pub excess_data: Vec<u8>,
1028 /// A [`channel_update`] message to be sent to or received from a peer.
1030 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1031 #[derive(Clone, Debug, PartialEq, Eq)]
1032 pub struct ChannelUpdate {
1033 /// A signature of the channel update
1034 pub signature: Signature,
1035 /// The actual channel update
1036 pub contents: UnsignedChannelUpdate,
1039 /// A [`query_channel_range`] message is used to query a peer for channel
1040 /// UTXOs in a range of blocks. The recipient of a query makes a best
1041 /// effort to reply to the query using one or more [`ReplyChannelRange`]
1044 /// [`query_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1045 #[derive(Clone, Debug, PartialEq, Eq)]
1046 pub struct QueryChannelRange {
1047 /// The genesis hash of the blockchain being queried
1048 pub chain_hash: BlockHash,
1049 /// The height of the first block for the channel UTXOs being queried
1050 pub first_blocknum: u32,
1051 /// The number of blocks to include in the query results
1052 pub number_of_blocks: u32,
1055 /// A [`reply_channel_range`] message is a reply to a [`QueryChannelRange`]
1058 /// Multiple `reply_channel_range` messages can be sent in reply
1059 /// to a single [`QueryChannelRange`] message. The query recipient makes a
1060 /// best effort to respond based on their local network view which may
1061 /// not be a perfect view of the network. The `short_channel_id`s in the
1062 /// reply are encoded. We only support `encoding_type=0` uncompressed
1063 /// serialization and do not support `encoding_type=1` zlib serialization.
1065 /// [`reply_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1066 #[derive(Clone, Debug, PartialEq, Eq)]
1067 pub struct ReplyChannelRange {
1068 /// The genesis hash of the blockchain being queried
1069 pub chain_hash: BlockHash,
1070 /// The height of the first block in the range of the reply
1071 pub first_blocknum: u32,
1072 /// The number of blocks included in the range of the reply
1073 pub number_of_blocks: u32,
1074 /// True when this is the final reply for a query
1075 pub sync_complete: bool,
1076 /// The `short_channel_id`s in the channel range
1077 pub short_channel_ids: Vec<u64>,
1080 /// A [`query_short_channel_ids`] message is used to query a peer for
1081 /// routing gossip messages related to one or more `short_channel_id`s.
1083 /// The query recipient will reply with the latest, if available,
1084 /// [`ChannelAnnouncement`], [`ChannelUpdate`] and [`NodeAnnouncement`] messages
1085 /// it maintains for the requested `short_channel_id`s followed by a
1086 /// [`ReplyShortChannelIdsEnd`] message. The `short_channel_id`s sent in
1087 /// this query are encoded. We only support `encoding_type=0` uncompressed
1088 /// serialization and do not support `encoding_type=1` zlib serialization.
1090 /// [`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
1091 #[derive(Clone, Debug, PartialEq, Eq)]
1092 pub struct QueryShortChannelIds {
1093 /// The genesis hash of the blockchain being queried
1094 pub chain_hash: BlockHash,
1095 /// The short_channel_ids that are being queried
1096 pub short_channel_ids: Vec<u64>,
1099 /// A [`reply_short_channel_ids_end`] message is sent as a reply to a
1100 /// message. The query recipient makes a best
1101 /// effort to respond based on their local network view which may not be
1102 /// a perfect view of the network.
1104 /// [`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
1105 #[derive(Clone, Debug, PartialEq, Eq)]
1106 pub struct ReplyShortChannelIdsEnd {
1107 /// The genesis hash of the blockchain that was queried
1108 pub chain_hash: BlockHash,
1109 /// Indicates if the query recipient maintains up-to-date channel
1110 /// information for the `chain_hash`
1111 pub full_information: bool,
1114 /// A [`gossip_timestamp_filter`] message is used by a node to request
1115 /// gossip relay for messages in the requested time range when the
1116 /// `gossip_queries` feature has been negotiated.
1118 /// [`gossip_timestamp_filter`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-gossip_timestamp_filter-message
1119 #[derive(Clone, Debug, PartialEq, Eq)]
1120 pub struct GossipTimestampFilter {
1121 /// The genesis hash of the blockchain for channel and node information
1122 pub chain_hash: BlockHash,
1123 /// The starting unix timestamp
1124 pub first_timestamp: u32,
1125 /// The range of information in seconds
1126 pub timestamp_range: u32,
1129 /// Encoding type for data compression of collections in gossip queries.
1131 /// We do not support `encoding_type=1` zlib serialization [defined in BOLT
1132 /// #7](https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#query-messages).
1134 Uncompressed = 0x00,
1137 /// Used to put an error message in a [`LightningError`].
1138 #[derive(Clone, Debug)]
1139 pub enum ErrorAction {
1140 /// The peer took some action which made us think they were useless. Disconnect them.
1142 /// An error message which we should make an effort to send before we disconnect.
1143 msg: Option<ErrorMessage>
1145 /// The peer did something incorrect. Tell them without closing any channels and disconnect them.
1146 DisconnectPeerWithWarning {
1147 /// A warning message which we should make an effort to send before we disconnect.
1148 msg: WarningMessage,
1150 /// The peer did something harmless that we weren't able to process, just log and ignore
1151 // New code should *not* use this. New code must use IgnoreAndLog, below!
1153 /// The peer did something harmless that we weren't able to meaningfully process.
1154 /// If the error is logged, log it at the given level.
1155 IgnoreAndLog(logger::Level),
1156 /// The peer provided us with a gossip message which we'd already seen. In most cases this
1157 /// should be ignored, but it may result in the message being forwarded if it is a duplicate of
1158 /// our own channel announcements.
1159 IgnoreDuplicateGossip,
1160 /// The peer did something incorrect. Tell them.
1162 /// The message to send.
1165 /// The peer did something incorrect. Tell them without closing any channels.
1166 SendWarningMessage {
1167 /// The message to send.
1168 msg: WarningMessage,
1169 /// The peer may have done something harmless that we weren't able to meaningfully process,
1170 /// though we should still tell them about it.
1171 /// If this event is logged, log it at the given level.
1172 log_level: logger::Level,
1176 /// An Err type for failure to process messages.
1177 #[derive(Clone, Debug)]
1178 pub struct LightningError {
1179 /// A human-readable message describing the error
1181 /// The action which should be taken against the offending peer.
1182 pub action: ErrorAction,
1185 /// Struct used to return values from [`RevokeAndACK`] messages, containing a bunch of commitment
1186 /// transaction updates if they were pending.
1187 #[derive(Clone, Debug, PartialEq, Eq)]
1188 pub struct CommitmentUpdate {
1189 /// `update_add_htlc` messages which should be sent
1190 pub update_add_htlcs: Vec<UpdateAddHTLC>,
1191 /// `update_fulfill_htlc` messages which should be sent
1192 pub update_fulfill_htlcs: Vec<UpdateFulfillHTLC>,
1193 /// `update_fail_htlc` messages which should be sent
1194 pub update_fail_htlcs: Vec<UpdateFailHTLC>,
1195 /// `update_fail_malformed_htlc` messages which should be sent
1196 pub update_fail_malformed_htlcs: Vec<UpdateFailMalformedHTLC>,
1197 /// An `update_fee` message which should be sent
1198 pub update_fee: Option<UpdateFee>,
1199 /// A `commitment_signed` message which should be sent
1200 pub commitment_signed: CommitmentSigned,
1203 /// A trait to describe an object which can receive channel messages.
1205 /// Messages MAY be called in parallel when they originate from different `their_node_ids`, however
1206 /// they MUST NOT be called in parallel when the two calls have the same `their_node_id`.
1207 pub trait ChannelMessageHandler : MessageSendEventsProvider {
1209 /// Handle an incoming `open_channel` message from the given peer.
1210 fn handle_open_channel(&self, their_node_id: &PublicKey, msg: &OpenChannel);
1211 /// Handle an incoming `open_channel2` message from the given peer.
1212 fn handle_open_channel_v2(&self, their_node_id: &PublicKey, msg: &OpenChannelV2);
1213 /// Handle an incoming `accept_channel` message from the given peer.
1214 fn handle_accept_channel(&self, their_node_id: &PublicKey, msg: &AcceptChannel);
1215 /// Handle an incoming `accept_channel2` message from the given peer.
1216 fn handle_accept_channel_v2(&self, their_node_id: &PublicKey, msg: &AcceptChannelV2);
1217 /// Handle an incoming `funding_created` message from the given peer.
1218 fn handle_funding_created(&self, their_node_id: &PublicKey, msg: &FundingCreated);
1219 /// Handle an incoming `funding_signed` message from the given peer.
1220 fn handle_funding_signed(&self, their_node_id: &PublicKey, msg: &FundingSigned);
1221 /// Handle an incoming `channel_ready` message from the given peer.
1222 fn handle_channel_ready(&self, their_node_id: &PublicKey, msg: &ChannelReady);
1225 /// Handle an incoming `shutdown` message from the given peer.
1226 fn handle_shutdown(&self, their_node_id: &PublicKey, msg: &Shutdown);
1227 /// Handle an incoming `closing_signed` message from the given peer.
1228 fn handle_closing_signed(&self, their_node_id: &PublicKey, msg: &ClosingSigned);
1230 // Interactive channel construction
1231 /// Handle an incoming `tx_add_input message` from the given peer.
1232 fn handle_tx_add_input(&self, their_node_id: &PublicKey, msg: &TxAddInput);
1233 /// Handle an incoming `tx_add_output` message from the given peer.
1234 fn handle_tx_add_output(&self, their_node_id: &PublicKey, msg: &TxAddOutput);
1235 /// Handle an incoming `tx_remove_input` message from the given peer.
1236 fn handle_tx_remove_input(&self, their_node_id: &PublicKey, msg: &TxRemoveInput);
1237 /// Handle an incoming `tx_remove_output` message from the given peer.
1238 fn handle_tx_remove_output(&self, their_node_id: &PublicKey, msg: &TxRemoveOutput);
1239 /// Handle an incoming `tx_complete message` from the given peer.
1240 fn handle_tx_complete(&self, their_node_id: &PublicKey, msg: &TxComplete);
1241 /// Handle an incoming `tx_signatures` message from the given peer.
1242 fn handle_tx_signatures(&self, their_node_id: &PublicKey, msg: &TxSignatures);
1243 /// Handle an incoming `tx_init_rbf` message from the given peer.
1244 fn handle_tx_init_rbf(&self, their_node_id: &PublicKey, msg: &TxInitRbf);
1245 /// Handle an incoming `tx_ack_rbf` message from the given peer.
1246 fn handle_tx_ack_rbf(&self, their_node_id: &PublicKey, msg: &TxAckRbf);
1247 /// Handle an incoming `tx_abort message` from the given peer.
1248 fn handle_tx_abort(&self, their_node_id: &PublicKey, msg: &TxAbort);
1251 /// Handle an incoming `update_add_htlc` message from the given peer.
1252 fn handle_update_add_htlc(&self, their_node_id: &PublicKey, msg: &UpdateAddHTLC);
1253 /// Handle an incoming `update_fulfill_htlc` message from the given peer.
1254 fn handle_update_fulfill_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFulfillHTLC);
1255 /// Handle an incoming `update_fail_htlc` message from the given peer.
1256 fn handle_update_fail_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailHTLC);
1257 /// Handle an incoming `update_fail_malformed_htlc` message from the given peer.
1258 fn handle_update_fail_malformed_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailMalformedHTLC);
1259 /// Handle an incoming `commitment_signed` message from the given peer.
1260 fn handle_commitment_signed(&self, their_node_id: &PublicKey, msg: &CommitmentSigned);
1261 /// Handle an incoming `revoke_and_ack` message from the given peer.
1262 fn handle_revoke_and_ack(&self, their_node_id: &PublicKey, msg: &RevokeAndACK);
1264 /// Handle an incoming `update_fee` message from the given peer.
1265 fn handle_update_fee(&self, their_node_id: &PublicKey, msg: &UpdateFee);
1267 // Channel-to-announce:
1268 /// Handle an incoming `announcement_signatures` message from the given peer.
1269 fn handle_announcement_signatures(&self, their_node_id: &PublicKey, msg: &AnnouncementSignatures);
1271 // Connection loss/reestablish:
1272 /// Indicates a connection to the peer failed/an existing connection was lost.
1273 fn peer_disconnected(&self, their_node_id: &PublicKey);
1275 /// Handle a peer reconnecting, possibly generating `channel_reestablish` message(s).
1277 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1278 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1279 /// message handlers may still wish to communicate with this peer.
1280 fn peer_connected(&self, their_node_id: &PublicKey, msg: &Init, inbound: bool) -> Result<(), ()>;
1281 /// Handle an incoming `channel_reestablish` message from the given peer.
1282 fn handle_channel_reestablish(&self, their_node_id: &PublicKey, msg: &ChannelReestablish);
1284 /// Handle an incoming `channel_update` message from the given peer.
1285 fn handle_channel_update(&self, their_node_id: &PublicKey, msg: &ChannelUpdate);
1288 /// Handle an incoming `error` message from the given peer.
1289 fn handle_error(&self, their_node_id: &PublicKey, msg: &ErrorMessage);
1291 // Handler information:
1292 /// Gets the node feature flags which this handler itself supports. All available handlers are
1293 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1294 /// which are broadcasted in our [`NodeAnnouncement`] message.
1295 fn provided_node_features(&self) -> NodeFeatures;
1297 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1298 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1299 /// which are sent in our [`Init`] message.
1301 /// Note that this method is called before [`Self::peer_connected`].
1302 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1304 /// Gets the genesis hashes for this `ChannelMessageHandler` indicating which chains it supports.
1306 /// If it's `None`, then no particular network chain hash compatibility will be enforced when
1307 /// connecting to peers.
1308 fn get_genesis_hashes(&self) -> Option<Vec<ChainHash>>;
1311 /// A trait to describe an object which can receive routing messages.
1313 /// # Implementor DoS Warnings
1315 /// For messages enabled with the `gossip_queries` feature there are potential DoS vectors when
1316 /// handling inbound queries. Implementors using an on-disk network graph should be aware of
1317 /// repeated disk I/O for queries accessing different parts of the network graph.
1318 pub trait RoutingMessageHandler : MessageSendEventsProvider {
1319 /// Handle an incoming `node_announcement` message, returning `true` if it should be forwarded on,
1320 /// `false` or returning an `Err` otherwise.
1321 fn handle_node_announcement(&self, msg: &NodeAnnouncement) -> Result<bool, LightningError>;
1322 /// Handle a `channel_announcement` message, returning `true` if it should be forwarded on, `false`
1323 /// or returning an `Err` otherwise.
1324 fn handle_channel_announcement(&self, msg: &ChannelAnnouncement) -> Result<bool, LightningError>;
1325 /// Handle an incoming `channel_update` message, returning true if it should be forwarded on,
1326 /// `false` or returning an `Err` otherwise.
1327 fn handle_channel_update(&self, msg: &ChannelUpdate) -> Result<bool, LightningError>;
1328 /// Gets channel announcements and updates required to dump our routing table to a remote node,
1329 /// starting at the `short_channel_id` indicated by `starting_point` and including announcements
1330 /// for a single channel.
1331 fn get_next_channel_announcement(&self, starting_point: u64) -> Option<(ChannelAnnouncement, Option<ChannelUpdate>, Option<ChannelUpdate>)>;
1332 /// Gets a node announcement required to dump our routing table to a remote node, starting at
1333 /// the node *after* the provided pubkey and including up to one announcement immediately
1334 /// higher (as defined by `<PublicKey as Ord>::cmp`) than `starting_point`.
1335 /// If `None` is provided for `starting_point`, we start at the first node.
1336 fn get_next_node_announcement(&self, starting_point: Option<&NodeId>) -> Option<NodeAnnouncement>;
1337 /// Called when a connection is established with a peer. This can be used to
1338 /// perform routing table synchronization using a strategy defined by the
1341 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1342 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1343 /// message handlers may still wish to communicate with this peer.
1344 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1345 /// Handles the reply of a query we initiated to learn about channels
1346 /// for a given range of blocks. We can expect to receive one or more
1347 /// replies to a single query.
1348 fn handle_reply_channel_range(&self, their_node_id: &PublicKey, msg: ReplyChannelRange) -> Result<(), LightningError>;
1349 /// Handles the reply of a query we initiated asking for routing gossip
1350 /// messages for a list of channels. We should receive this message when
1351 /// a node has completed its best effort to send us the pertaining routing
1352 /// gossip messages.
1353 fn handle_reply_short_channel_ids_end(&self, their_node_id: &PublicKey, msg: ReplyShortChannelIdsEnd) -> Result<(), LightningError>;
1354 /// Handles when a peer asks us to send a list of `short_channel_id`s
1355 /// for the requested range of blocks.
1356 fn handle_query_channel_range(&self, their_node_id: &PublicKey, msg: QueryChannelRange) -> Result<(), LightningError>;
1357 /// Handles when a peer asks us to send routing gossip messages for a
1358 /// list of `short_channel_id`s.
1359 fn handle_query_short_channel_ids(&self, their_node_id: &PublicKey, msg: QueryShortChannelIds) -> Result<(), LightningError>;
1361 // Handler queueing status:
1362 /// Indicates that there are a large number of [`ChannelAnnouncement`] (or other) messages
1363 /// pending some async action. While there is no guarantee of the rate of future messages, the
1364 /// caller should seek to reduce the rate of new gossip messages handled, especially
1365 /// [`ChannelAnnouncement`]s.
1366 fn processing_queue_high(&self) -> bool;
1368 // Handler information:
1369 /// Gets the node feature flags which this handler itself supports. All available handlers are
1370 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1371 /// which are broadcasted in our [`NodeAnnouncement`] message.
1372 fn provided_node_features(&self) -> NodeFeatures;
1373 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1374 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1375 /// which are sent in our [`Init`] message.
1377 /// Note that this method is called before [`Self::peer_connected`].
1378 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1381 /// A trait to describe an object that can receive onion messages.
1382 pub trait OnionMessageHandler : OnionMessageProvider {
1383 /// Handle an incoming `onion_message` message from the given peer.
1384 fn handle_onion_message(&self, peer_node_id: &PublicKey, msg: &OnionMessage);
1385 /// Called when a connection is established with a peer. Can be used to track which peers
1386 /// advertise onion message support and are online.
1388 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1389 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1390 /// message handlers may still wish to communicate with this peer.
1391 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1392 /// Indicates a connection to the peer failed/an existing connection was lost. Allows handlers to
1393 /// drop and refuse to forward onion messages to this peer.
1394 fn peer_disconnected(&self, their_node_id: &PublicKey);
1396 // Handler information:
1397 /// Gets the node feature flags which this handler itself supports. All available handlers are
1398 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1399 /// which are broadcasted in our [`NodeAnnouncement`] message.
1400 fn provided_node_features(&self) -> NodeFeatures;
1402 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1403 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1404 /// which are sent in our [`Init`] message.
1406 /// Note that this method is called before [`Self::peer_connected`].
1407 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1410 mod fuzzy_internal_msgs {
1411 use crate::prelude::*;
1412 use crate::ln::{PaymentPreimage, PaymentSecret};
1414 // These types aren't intended to be pub, but are exposed for direct fuzzing (as we deserialize
1415 // them from untrusted input):
1417 pub(crate) struct FinalOnionHopData {
1418 pub(crate) payment_secret: PaymentSecret,
1419 /// The total value, in msat, of the payment as received by the ultimate recipient.
1420 /// Message serialization may panic if this value is more than 21 million Bitcoin.
1421 pub(crate) total_msat: u64,
1424 pub(crate) enum OnionHopDataFormat {
1426 short_channel_id: u64,
1429 payment_data: Option<FinalOnionHopData>,
1430 payment_metadata: Option<Vec<u8>>,
1431 keysend_preimage: Option<PaymentPreimage>,
1435 pub struct OnionHopData {
1436 pub(crate) format: OnionHopDataFormat,
1437 /// The value, in msat, of the payment after this hop's fee is deducted.
1438 /// Message serialization may panic if this value is more than 21 million Bitcoin.
1439 pub(crate) amt_to_forward: u64,
1440 pub(crate) outgoing_cltv_value: u32,
1443 pub struct DecodedOnionErrorPacket {
1444 pub(crate) hmac: [u8; 32],
1445 pub(crate) failuremsg: Vec<u8>,
1446 pub(crate) pad: Vec<u8>,
1450 pub use self::fuzzy_internal_msgs::*;
1451 #[cfg(not(fuzzing))]
1452 pub(crate) use self::fuzzy_internal_msgs::*;
1455 pub(crate) struct OnionPacket {
1456 pub(crate) version: u8,
1457 /// In order to ensure we always return an error on onion decode in compliance with [BOLT
1458 /// #4](https://github.com/lightning/bolts/blob/master/04-onion-routing.md), we have to
1459 /// deserialize `OnionPacket`s contained in [`UpdateAddHTLC`] messages even if the ephemeral
1460 /// public key (here) is bogus, so we hold a [`Result`] instead of a [`PublicKey`] as we'd
1462 pub(crate) public_key: Result<PublicKey, secp256k1::Error>,
1463 pub(crate) hop_data: [u8; 20*65],
1464 pub(crate) hmac: [u8; 32],
1467 impl onion_utils::Packet for OnionPacket {
1468 type Data = onion_utils::FixedSizeOnionPacket;
1469 fn new(pubkey: PublicKey, hop_data: onion_utils::FixedSizeOnionPacket, hmac: [u8; 32]) -> Self {
1472 public_key: Ok(pubkey),
1473 hop_data: hop_data.0,
1479 impl Eq for OnionPacket { }
1480 impl PartialEq for OnionPacket {
1481 fn eq(&self, other: &OnionPacket) -> bool {
1482 for (i, j) in self.hop_data.iter().zip(other.hop_data.iter()) {
1483 if i != j { return false; }
1485 self.version == other.version &&
1486 self.public_key == other.public_key &&
1487 self.hmac == other.hmac
1491 impl fmt::Debug for OnionPacket {
1492 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1493 f.write_fmt(format_args!("OnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
1497 #[derive(Clone, Debug, PartialEq, Eq)]
1498 pub(crate) struct OnionErrorPacket {
1499 // This really should be a constant size slice, but the spec lets these things be up to 128KB?
1500 // (TODO) We limit it in decode to much lower...
1501 pub(crate) data: Vec<u8>,
1504 impl fmt::Display for DecodeError {
1505 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1507 DecodeError::UnknownVersion => f.write_str("Unknown realm byte in Onion packet"),
1508 DecodeError::UnknownRequiredFeature => f.write_str("Unknown required feature preventing decode"),
1509 DecodeError::InvalidValue => f.write_str("Nonsense bytes didn't map to the type they were interpreted as"),
1510 DecodeError::ShortRead => f.write_str("Packet extended beyond the provided bytes"),
1511 DecodeError::BadLengthDescriptor => f.write_str("A length descriptor in the packet didn't describe the later data correctly"),
1512 DecodeError::Io(ref e) => fmt::Debug::fmt(e, f),
1513 DecodeError::UnsupportedCompression => f.write_str("We don't support receiving messages with zlib-compressed fields"),
1518 impl From<io::Error> for DecodeError {
1519 fn from(e: io::Error) -> Self {
1520 if e.kind() == io::ErrorKind::UnexpectedEof {
1521 DecodeError::ShortRead
1523 DecodeError::Io(e.kind())
1528 #[cfg(not(taproot))]
1529 impl_writeable_msg!(AcceptChannel, {
1530 temporary_channel_id,
1531 dust_limit_satoshis,
1532 max_htlc_value_in_flight_msat,
1533 channel_reserve_satoshis,
1539 revocation_basepoint,
1541 delayed_payment_basepoint,
1543 first_per_commitment_point,
1545 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1546 (1, channel_type, option),
1550 impl_writeable_msg!(AcceptChannel, {
1551 temporary_channel_id,
1552 dust_limit_satoshis,
1553 max_htlc_value_in_flight_msat,
1554 channel_reserve_satoshis,
1560 revocation_basepoint,
1562 delayed_payment_basepoint,
1564 first_per_commitment_point,
1566 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1567 (1, channel_type, option),
1568 (4, next_local_nonce, option),
1571 impl_writeable_msg!(AcceptChannelV2, {
1572 temporary_channel_id,
1574 dust_limit_satoshis,
1575 max_htlc_value_in_flight_msat,
1581 revocation_basepoint,
1583 delayed_payment_basepoint,
1585 first_per_commitment_point,
1586 second_per_commitment_point,
1588 (0, shutdown_scriptpubkey, option),
1589 (1, channel_type, option),
1590 (2, require_confirmed_inputs, option),
1593 impl_writeable_msg!(TxAddInput, {
1601 impl_writeable_msg!(TxAddOutput, {
1608 impl_writeable_msg!(TxRemoveInput, {
1613 impl_writeable_msg!(TxRemoveOutput, {
1618 impl_writeable_msg!(TxComplete, {
1622 impl_writeable_msg!(TxSignatures, {
1628 impl_writeable_msg!(TxInitRbf, {
1631 feerate_sat_per_1000_weight,
1633 (0, funding_output_contribution, option),
1636 impl_writeable_msg!(TxAckRbf, {
1639 (0, funding_output_contribution, option),
1642 impl_writeable_msg!(TxAbort, {
1647 impl_writeable_msg!(AnnouncementSignatures, {
1654 impl_writeable_msg!(ChannelReestablish, {
1656 next_local_commitment_number,
1657 next_remote_commitment_number,
1658 your_last_per_commitment_secret,
1659 my_current_per_commitment_point,
1661 (0, next_funding_txid, option),
1664 impl_writeable_msg!(ClosingSigned,
1665 { channel_id, fee_satoshis, signature },
1666 { (1, fee_range, option) }
1669 impl_writeable!(ClosingSignedFeeRange, {
1674 #[cfg(not(taproot))]
1675 impl_writeable_msg!(CommitmentSigned, {
1682 impl_writeable_msg!(CommitmentSigned, {
1687 (2, partial_signature_with_nonce, option)
1690 impl_writeable!(DecodedOnionErrorPacket, {
1696 #[cfg(not(taproot))]
1697 impl_writeable_msg!(FundingCreated, {
1698 temporary_channel_id,
1700 funding_output_index,
1704 impl_writeable_msg!(FundingCreated, {
1705 temporary_channel_id,
1707 funding_output_index,
1710 (2, partial_signature_with_nonce, option),
1711 (4, next_local_nonce, option)
1714 #[cfg(not(taproot))]
1715 impl_writeable_msg!(FundingSigned, {
1721 impl_writeable_msg!(FundingSigned, {
1725 (2, partial_signature_with_nonce, option)
1728 impl_writeable_msg!(ChannelReady, {
1730 next_per_commitment_point,
1732 (1, short_channel_id_alias, option),
1735 impl Writeable for Init {
1736 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1737 // global_features gets the bottom 13 bits of our features, and local_features gets all of
1738 // our relevant feature bits. This keeps us compatible with old nodes.
1739 self.features.write_up_to_13(w)?;
1740 self.features.write(w)?;
1741 encode_tlv_stream!(w, {
1742 (1, self.networks.as_ref().map(|n| WithoutLength(n)), option),
1743 (3, self.remote_network_address, option),
1749 impl Readable for Init {
1750 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1751 let global_features: InitFeatures = Readable::read(r)?;
1752 let features: InitFeatures = Readable::read(r)?;
1753 let mut remote_network_address: Option<NetAddress> = None;
1754 let mut networks: Option<WithoutLength<Vec<ChainHash>>> = None;
1755 decode_tlv_stream!(r, {
1756 (1, networks, option),
1757 (3, remote_network_address, option)
1760 features: features | global_features,
1761 networks: networks.map(|n| n.0),
1762 remote_network_address,
1767 impl_writeable_msg!(OpenChannel, {
1769 temporary_channel_id,
1772 dust_limit_satoshis,
1773 max_htlc_value_in_flight_msat,
1774 channel_reserve_satoshis,
1780 revocation_basepoint,
1782 delayed_payment_basepoint,
1784 first_per_commitment_point,
1787 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1788 (1, channel_type, option),
1791 impl_writeable_msg!(OpenChannelV2, {
1793 temporary_channel_id,
1794 funding_feerate_sat_per_1000_weight,
1795 commitment_feerate_sat_per_1000_weight,
1797 dust_limit_satoshis,
1798 max_htlc_value_in_flight_msat,
1804 revocation_basepoint,
1806 delayed_payment_basepoint,
1808 first_per_commitment_point,
1809 second_per_commitment_point,
1812 (0, shutdown_scriptpubkey, option),
1813 (1, channel_type, option),
1814 (2, require_confirmed_inputs, option),
1817 #[cfg(not(taproot))]
1818 impl_writeable_msg!(RevokeAndACK, {
1820 per_commitment_secret,
1821 next_per_commitment_point
1825 impl_writeable_msg!(RevokeAndACK, {
1827 per_commitment_secret,
1828 next_per_commitment_point
1830 (4, next_local_nonce, option)
1833 impl_writeable_msg!(Shutdown, {
1838 impl_writeable_msg!(UpdateFailHTLC, {
1844 impl_writeable_msg!(UpdateFailMalformedHTLC, {
1851 impl_writeable_msg!(UpdateFee, {
1856 impl_writeable_msg!(UpdateFulfillHTLC, {
1862 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
1863 // serialization format in a way which assumes we know the total serialized length/message end
1865 impl_writeable!(OnionErrorPacket, {
1869 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
1870 // serialization format in a way which assumes we know the total serialized length/message end
1872 impl Writeable for OnionPacket {
1873 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1874 self.version.write(w)?;
1875 match self.public_key {
1876 Ok(pubkey) => pubkey.write(w)?,
1877 Err(_) => [0u8;33].write(w)?,
1879 w.write_all(&self.hop_data)?;
1880 self.hmac.write(w)?;
1885 impl Readable for OnionPacket {
1886 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1888 version: Readable::read(r)?,
1890 let mut buf = [0u8;33];
1891 r.read_exact(&mut buf)?;
1892 PublicKey::from_slice(&buf)
1894 hop_data: Readable::read(r)?,
1895 hmac: Readable::read(r)?,
1900 impl_writeable_msg!(UpdateAddHTLC, {
1906 onion_routing_packet
1909 impl Readable for OnionMessage {
1910 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1911 let blinding_point: PublicKey = Readable::read(r)?;
1912 let len: u16 = Readable::read(r)?;
1913 let mut packet_reader = FixedLengthReader::new(r, len as u64);
1914 let onion_routing_packet: onion_message::Packet = <onion_message::Packet as LengthReadable>::read(&mut packet_reader)?;
1917 onion_routing_packet,
1922 impl Writeable for OnionMessage {
1923 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1924 self.blinding_point.write(w)?;
1925 let onion_packet_len = self.onion_routing_packet.serialized_length();
1926 (onion_packet_len as u16).write(w)?;
1927 self.onion_routing_packet.write(w)?;
1932 impl Writeable for FinalOnionHopData {
1933 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1934 self.payment_secret.0.write(w)?;
1935 HighZeroBytesDroppedBigSize(self.total_msat).write(w)
1939 impl Readable for FinalOnionHopData {
1940 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1941 let secret: [u8; 32] = Readable::read(r)?;
1942 let amt: HighZeroBytesDroppedBigSize<u64> = Readable::read(r)?;
1943 Ok(Self { payment_secret: PaymentSecret(secret), total_msat: amt.0 })
1947 impl Writeable for OnionHopData {
1948 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1950 OnionHopDataFormat::NonFinalNode { short_channel_id } => {
1951 _encode_varint_length_prefixed_tlv!(w, {
1952 (2, HighZeroBytesDroppedBigSize(self.amt_to_forward), required),
1953 (4, HighZeroBytesDroppedBigSize(self.outgoing_cltv_value), required),
1954 (6, short_channel_id, required)
1957 OnionHopDataFormat::FinalNode { ref payment_data, ref payment_metadata, ref keysend_preimage } => {
1958 _encode_varint_length_prefixed_tlv!(w, {
1959 (2, HighZeroBytesDroppedBigSize(self.amt_to_forward), required),
1960 (4, HighZeroBytesDroppedBigSize(self.outgoing_cltv_value), required),
1961 (8, payment_data, option),
1962 (16, payment_metadata.as_ref().map(|m| WithoutLength(m)), option),
1963 (5482373484, keysend_preimage, option)
1971 impl Readable for OnionHopData {
1972 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1973 let mut amt = HighZeroBytesDroppedBigSize(0u64);
1974 let mut cltv_value = HighZeroBytesDroppedBigSize(0u32);
1975 let mut short_id: Option<u64> = None;
1976 let mut payment_data: Option<FinalOnionHopData> = None;
1977 let mut payment_metadata: Option<WithoutLength<Vec<u8>>> = None;
1978 let mut keysend_preimage: Option<PaymentPreimage> = None;
1979 read_tlv_fields!(r, {
1981 (4, cltv_value, required),
1982 (6, short_id, option),
1983 (8, payment_data, option),
1984 (16, payment_metadata, option),
1985 // See https://github.com/lightning/blips/blob/master/blip-0003.md
1986 (5482373484, keysend_preimage, option)
1989 let format = if let Some(short_channel_id) = short_id {
1990 if payment_data.is_some() { return Err(DecodeError::InvalidValue); }
1991 if payment_metadata.is_some() { return Err(DecodeError::InvalidValue); }
1992 OnionHopDataFormat::NonFinalNode {
1996 if let Some(data) = &payment_data {
1997 if data.total_msat > MAX_VALUE_MSAT {
1998 return Err(DecodeError::InvalidValue);
2001 OnionHopDataFormat::FinalNode {
2003 payment_metadata: payment_metadata.map(|w| w.0),
2008 if amt.0 > MAX_VALUE_MSAT {
2009 return Err(DecodeError::InvalidValue);
2013 amt_to_forward: amt.0,
2014 outgoing_cltv_value: cltv_value.0,
2019 // ReadableArgs because we need onion_utils::decode_next_hop to accommodate payment packets and
2020 // onion message packets.
2021 impl ReadableArgs<()> for OnionHopData {
2022 fn read<R: Read>(r: &mut R, _arg: ()) -> Result<Self, DecodeError> {
2023 <Self as Readable>::read(r)
2027 impl Writeable for Ping {
2028 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2029 self.ponglen.write(w)?;
2030 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2035 impl Readable for Ping {
2036 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2038 ponglen: Readable::read(r)?,
2040 let byteslen = Readable::read(r)?;
2041 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2048 impl Writeable for Pong {
2049 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2050 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2055 impl Readable for Pong {
2056 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2059 let byteslen = Readable::read(r)?;
2060 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2067 impl Writeable for UnsignedChannelAnnouncement {
2068 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2069 self.features.write(w)?;
2070 self.chain_hash.write(w)?;
2071 self.short_channel_id.write(w)?;
2072 self.node_id_1.write(w)?;
2073 self.node_id_2.write(w)?;
2074 self.bitcoin_key_1.write(w)?;
2075 self.bitcoin_key_2.write(w)?;
2076 w.write_all(&self.excess_data[..])?;
2081 impl Readable for UnsignedChannelAnnouncement {
2082 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2084 features: Readable::read(r)?,
2085 chain_hash: Readable::read(r)?,
2086 short_channel_id: Readable::read(r)?,
2087 node_id_1: Readable::read(r)?,
2088 node_id_2: Readable::read(r)?,
2089 bitcoin_key_1: Readable::read(r)?,
2090 bitcoin_key_2: Readable::read(r)?,
2091 excess_data: read_to_end(r)?,
2096 impl_writeable!(ChannelAnnouncement, {
2099 bitcoin_signature_1,
2100 bitcoin_signature_2,
2104 impl Writeable for UnsignedChannelUpdate {
2105 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2106 // `message_flags` used to indicate presence of `htlc_maximum_msat`, but was deprecated in the spec.
2107 const MESSAGE_FLAGS: u8 = 1;
2108 self.chain_hash.write(w)?;
2109 self.short_channel_id.write(w)?;
2110 self.timestamp.write(w)?;
2111 let all_flags = self.flags as u16 | ((MESSAGE_FLAGS as u16) << 8);
2112 all_flags.write(w)?;
2113 self.cltv_expiry_delta.write(w)?;
2114 self.htlc_minimum_msat.write(w)?;
2115 self.fee_base_msat.write(w)?;
2116 self.fee_proportional_millionths.write(w)?;
2117 self.htlc_maximum_msat.write(w)?;
2118 w.write_all(&self.excess_data[..])?;
2123 impl Readable for UnsignedChannelUpdate {
2124 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2126 chain_hash: Readable::read(r)?,
2127 short_channel_id: Readable::read(r)?,
2128 timestamp: Readable::read(r)?,
2130 let flags: u16 = Readable::read(r)?;
2131 // Note: we ignore the `message_flags` for now, since it was deprecated by the spec.
2134 cltv_expiry_delta: Readable::read(r)?,
2135 htlc_minimum_msat: Readable::read(r)?,
2136 fee_base_msat: Readable::read(r)?,
2137 fee_proportional_millionths: Readable::read(r)?,
2138 htlc_maximum_msat: Readable::read(r)?,
2139 excess_data: read_to_end(r)?,
2144 impl_writeable!(ChannelUpdate, {
2149 impl Writeable for ErrorMessage {
2150 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2151 self.channel_id.write(w)?;
2152 (self.data.len() as u16).write(w)?;
2153 w.write_all(self.data.as_bytes())?;
2158 impl Readable for ErrorMessage {
2159 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2161 channel_id: Readable::read(r)?,
2163 let sz: usize = <u16 as Readable>::read(r)? as usize;
2164 let mut data = Vec::with_capacity(sz);
2166 r.read_exact(&mut data)?;
2167 match String::from_utf8(data) {
2169 Err(_) => return Err(DecodeError::InvalidValue),
2176 impl Writeable for WarningMessage {
2177 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2178 self.channel_id.write(w)?;
2179 (self.data.len() as u16).write(w)?;
2180 w.write_all(self.data.as_bytes())?;
2185 impl Readable for WarningMessage {
2186 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2188 channel_id: Readable::read(r)?,
2190 let sz: usize = <u16 as Readable>::read(r)? as usize;
2191 let mut data = Vec::with_capacity(sz);
2193 r.read_exact(&mut data)?;
2194 match String::from_utf8(data) {
2196 Err(_) => return Err(DecodeError::InvalidValue),
2203 impl Writeable for UnsignedNodeAnnouncement {
2204 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2205 self.features.write(w)?;
2206 self.timestamp.write(w)?;
2207 self.node_id.write(w)?;
2208 w.write_all(&self.rgb)?;
2209 self.alias.write(w)?;
2211 let mut addr_len = 0;
2212 for addr in self.addresses.iter() {
2213 addr_len += 1 + addr.len();
2215 (addr_len + self.excess_address_data.len() as u16).write(w)?;
2216 for addr in self.addresses.iter() {
2219 w.write_all(&self.excess_address_data[..])?;
2220 w.write_all(&self.excess_data[..])?;
2225 impl Readable for UnsignedNodeAnnouncement {
2226 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2227 let features: NodeFeatures = Readable::read(r)?;
2228 let timestamp: u32 = Readable::read(r)?;
2229 let node_id: NodeId = Readable::read(r)?;
2230 let mut rgb = [0; 3];
2231 r.read_exact(&mut rgb)?;
2232 let alias: NodeAlias = Readable::read(r)?;
2234 let addr_len: u16 = Readable::read(r)?;
2235 let mut addresses: Vec<NetAddress> = Vec::new();
2236 let mut addr_readpos = 0;
2237 let mut excess = false;
2238 let mut excess_byte = 0;
2240 if addr_len <= addr_readpos { break; }
2241 match Readable::read(r) {
2243 if addr_len < addr_readpos + 1 + addr.len() {
2244 return Err(DecodeError::BadLengthDescriptor);
2246 addr_readpos += (1 + addr.len()) as u16;
2247 addresses.push(addr);
2249 Ok(Err(unknown_descriptor)) => {
2251 excess_byte = unknown_descriptor;
2254 Err(DecodeError::ShortRead) => return Err(DecodeError::BadLengthDescriptor),
2255 Err(e) => return Err(e),
2259 let mut excess_data = vec![];
2260 let excess_address_data = if addr_readpos < addr_len {
2261 let mut excess_address_data = vec![0; (addr_len - addr_readpos) as usize];
2262 r.read_exact(&mut excess_address_data[if excess { 1 } else { 0 }..])?;
2264 excess_address_data[0] = excess_byte;
2269 excess_data.push(excess_byte);
2273 excess_data.extend(read_to_end(r)?.iter());
2274 Ok(UnsignedNodeAnnouncement {
2281 excess_address_data,
2287 impl_writeable!(NodeAnnouncement, {
2292 impl Readable for QueryShortChannelIds {
2293 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2294 let chain_hash: BlockHash = Readable::read(r)?;
2296 let encoding_len: u16 = Readable::read(r)?;
2297 let encoding_type: u8 = Readable::read(r)?;
2299 // Must be encoding_type=0 uncompressed serialization. We do not
2300 // support encoding_type=1 zlib serialization.
2301 if encoding_type != EncodingType::Uncompressed as u8 {
2302 return Err(DecodeError::UnsupportedCompression);
2305 // We expect the encoding_len to always includes the 1-byte
2306 // encoding_type and that short_channel_ids are 8-bytes each
2307 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2308 return Err(DecodeError::InvalidValue);
2311 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2312 // less the 1-byte encoding_type
2313 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2314 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2315 for _ in 0..short_channel_id_count {
2316 short_channel_ids.push(Readable::read(r)?);
2319 Ok(QueryShortChannelIds {
2326 impl Writeable for QueryShortChannelIds {
2327 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2328 // Calculated from 1-byte encoding_type plus 8-bytes per short_channel_id
2329 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2331 self.chain_hash.write(w)?;
2332 encoding_len.write(w)?;
2334 // We only support type=0 uncompressed serialization
2335 (EncodingType::Uncompressed as u8).write(w)?;
2337 for scid in self.short_channel_ids.iter() {
2345 impl_writeable_msg!(ReplyShortChannelIdsEnd, {
2350 impl QueryChannelRange {
2351 /// Calculates the overflow safe ending block height for the query.
2353 /// Overflow returns `0xffffffff`, otherwise returns `first_blocknum + number_of_blocks`.
2354 pub fn end_blocknum(&self) -> u32 {
2355 match self.first_blocknum.checked_add(self.number_of_blocks) {
2356 Some(block) => block,
2357 None => u32::max_value(),
2362 impl_writeable_msg!(QueryChannelRange, {
2368 impl Readable for ReplyChannelRange {
2369 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2370 let chain_hash: BlockHash = Readable::read(r)?;
2371 let first_blocknum: u32 = Readable::read(r)?;
2372 let number_of_blocks: u32 = Readable::read(r)?;
2373 let sync_complete: bool = Readable::read(r)?;
2375 let encoding_len: u16 = Readable::read(r)?;
2376 let encoding_type: u8 = Readable::read(r)?;
2378 // Must be encoding_type=0 uncompressed serialization. We do not
2379 // support encoding_type=1 zlib serialization.
2380 if encoding_type != EncodingType::Uncompressed as u8 {
2381 return Err(DecodeError::UnsupportedCompression);
2384 // We expect the encoding_len to always includes the 1-byte
2385 // encoding_type and that short_channel_ids are 8-bytes each
2386 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2387 return Err(DecodeError::InvalidValue);
2390 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2391 // less the 1-byte encoding_type
2392 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2393 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2394 for _ in 0..short_channel_id_count {
2395 short_channel_ids.push(Readable::read(r)?);
2398 Ok(ReplyChannelRange {
2408 impl Writeable for ReplyChannelRange {
2409 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2410 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2411 self.chain_hash.write(w)?;
2412 self.first_blocknum.write(w)?;
2413 self.number_of_blocks.write(w)?;
2414 self.sync_complete.write(w)?;
2416 encoding_len.write(w)?;
2417 (EncodingType::Uncompressed as u8).write(w)?;
2418 for scid in self.short_channel_ids.iter() {
2426 impl_writeable_msg!(GossipTimestampFilter, {
2434 use bitcoin::blockdata::constants::ChainHash;
2435 use bitcoin::{Transaction, PackedLockTime, TxIn, Script, Sequence, Witness, TxOut};
2437 use crate::ln::{PaymentPreimage, PaymentHash, PaymentSecret};
2438 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
2439 use crate::ln::msgs::{self, FinalOnionHopData, OnionErrorPacket, OnionHopDataFormat};
2440 use crate::routing::gossip::{NodeAlias, NodeId};
2441 use crate::util::ser::{Writeable, Readable, Hostname, TransactionU16LenLimited};
2443 use bitcoin::hashes::hex::FromHex;
2444 use bitcoin::util::address::Address;
2445 use bitcoin::network::constants::Network;
2446 use bitcoin::blockdata::script::Builder;
2447 use bitcoin::blockdata::opcodes;
2448 use bitcoin::hash_types::{Txid, BlockHash};
2450 use bitcoin::secp256k1::{PublicKey,SecretKey};
2451 use bitcoin::secp256k1::{Secp256k1, Message};
2453 use crate::io::{self, Cursor};
2454 use crate::prelude::*;
2455 use core::convert::TryFrom;
2456 use core::str::FromStr;
2458 use crate::chain::transaction::OutPoint;
2461 fn encoding_channel_reestablish() {
2463 let secp_ctx = Secp256k1::new();
2464 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2467 let cr = msgs::ChannelReestablish {
2468 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],
2469 next_local_commitment_number: 3,
2470 next_remote_commitment_number: 4,
2471 your_last_per_commitment_secret: [9;32],
2472 my_current_per_commitment_point: public_key,
2473 next_funding_txid: None,
2476 let encoded_value = cr.encode();
2480 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
2481 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2482 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2483 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
2484 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
2490 fn encoding_channel_reestablish_with_next_funding_txid() {
2492 let secp_ctx = Secp256k1::new();
2493 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2496 let cr = msgs::ChannelReestablish {
2497 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],
2498 next_local_commitment_number: 3,
2499 next_remote_commitment_number: 4,
2500 your_last_per_commitment_secret: [9;32],
2501 my_current_per_commitment_point: public_key,
2502 next_funding_txid: Some(Txid::from_hash(bitcoin::hashes::Hash::from_slice(&[
2503 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,
2507 let encoded_value = cr.encode();
2511 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
2512 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2513 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2514 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
2515 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
2516 0, // Type (next_funding_txid)
2518 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
2523 macro_rules! get_keys_from {
2524 ($slice: expr, $secp_ctx: expr) => {
2526 let privkey = SecretKey::from_slice(&hex::decode($slice).unwrap()[..]).unwrap();
2527 let pubkey = PublicKey::from_secret_key(&$secp_ctx, &privkey);
2533 macro_rules! get_sig_on {
2534 ($privkey: expr, $ctx: expr, $string: expr) => {
2536 let sighash = Message::from_slice(&$string.into_bytes()[..]).unwrap();
2537 $ctx.sign_ecdsa(&sighash, &$privkey)
2543 fn encoding_announcement_signatures() {
2544 let secp_ctx = Secp256k1::new();
2545 let (privkey, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2546 let sig_1 = get_sig_on!(privkey, secp_ctx, String::from("01010101010101010101010101010101"));
2547 let sig_2 = get_sig_on!(privkey, secp_ctx, String::from("02020202020202020202020202020202"));
2548 let announcement_signatures = msgs::AnnouncementSignatures {
2549 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],
2550 short_channel_id: 2316138423780173,
2551 node_signature: sig_1,
2552 bitcoin_signature: sig_2,
2555 let encoded_value = announcement_signatures.encode();
2556 assert_eq!(encoded_value, hex::decode("040000000000000005000000000000000600000000000000070000000000000000083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073acf9953cef4700860f5967838eba2bae89288ad188ebf8b20bf995c3ea53a26df1876d0a3a0e13172ba286a673140190c02ba9da60a2e43a745188c8a83c7f3ef").unwrap());
2559 fn do_encoding_channel_announcement(unknown_features_bits: bool, excess_data: bool) {
2560 let secp_ctx = Secp256k1::new();
2561 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2562 let (privkey_2, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2563 let (privkey_3, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2564 let (privkey_4, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2565 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2566 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
2567 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
2568 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
2569 let mut features = ChannelFeatures::empty();
2570 if unknown_features_bits {
2571 features = ChannelFeatures::from_le_bytes(vec![0xFF, 0xFF]);
2573 let unsigned_channel_announcement = msgs::UnsignedChannelAnnouncement {
2575 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2576 short_channel_id: 2316138423780173,
2577 node_id_1: NodeId::from_pubkey(&pubkey_1),
2578 node_id_2: NodeId::from_pubkey(&pubkey_2),
2579 bitcoin_key_1: NodeId::from_pubkey(&pubkey_3),
2580 bitcoin_key_2: NodeId::from_pubkey(&pubkey_4),
2581 excess_data: if excess_data { vec![10, 0, 0, 20, 0, 0, 30, 0, 0, 40] } else { Vec::new() },
2583 let channel_announcement = msgs::ChannelAnnouncement {
2584 node_signature_1: sig_1,
2585 node_signature_2: sig_2,
2586 bitcoin_signature_1: sig_3,
2587 bitcoin_signature_2: sig_4,
2588 contents: unsigned_channel_announcement,
2590 let encoded_value = channel_announcement.encode();
2591 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a1735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap();
2592 if unknown_features_bits {
2593 target_value.append(&mut hex::decode("0002ffff").unwrap());
2595 target_value.append(&mut hex::decode("0000").unwrap());
2597 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2598 target_value.append(&mut hex::decode("00083a840000034d031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
2600 target_value.append(&mut hex::decode("0a00001400001e000028").unwrap());
2602 assert_eq!(encoded_value, target_value);
2606 fn encoding_channel_announcement() {
2607 do_encoding_channel_announcement(true, false);
2608 do_encoding_channel_announcement(false, true);
2609 do_encoding_channel_announcement(false, false);
2610 do_encoding_channel_announcement(true, true);
2613 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) {
2614 let secp_ctx = Secp256k1::new();
2615 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2616 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2617 let features = if unknown_features_bits {
2618 NodeFeatures::from_le_bytes(vec![0xFF, 0xFF])
2620 // Set to some features we may support
2621 NodeFeatures::from_le_bytes(vec![2 | 1 << 5])
2623 let mut addresses = Vec::new();
2625 addresses.push(msgs::NetAddress::IPv4 {
2626 addr: [255, 254, 253, 252],
2631 addresses.push(msgs::NetAddress::IPv6 {
2632 addr: [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240],
2637 addresses.push(msgs::NetAddress::OnionV2(
2638 [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 38, 7]
2642 addresses.push(msgs::NetAddress::OnionV3 {
2643 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],
2650 addresses.push(msgs::NetAddress::Hostname {
2651 hostname: Hostname::try_from(String::from("host")).unwrap(),
2655 let mut addr_len = 0;
2656 for addr in &addresses {
2657 addr_len += addr.len() + 1;
2659 let unsigned_node_announcement = msgs::UnsignedNodeAnnouncement {
2661 timestamp: 20190119,
2662 node_id: NodeId::from_pubkey(&pubkey_1),
2664 alias: NodeAlias([16;32]),
2666 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() },
2667 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() },
2669 addr_len += unsigned_node_announcement.excess_address_data.len() as u16;
2670 let node_announcement = msgs::NodeAnnouncement {
2672 contents: unsigned_node_announcement,
2674 let encoded_value = node_announcement.encode();
2675 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
2676 if unknown_features_bits {
2677 target_value.append(&mut hex::decode("0002ffff").unwrap());
2679 target_value.append(&mut hex::decode("000122").unwrap());
2681 target_value.append(&mut hex::decode("013413a7031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f2020201010101010101010101010101010101010101010101010101010101010101010").unwrap());
2682 target_value.append(&mut vec![(addr_len >> 8) as u8, addr_len as u8]);
2684 target_value.append(&mut hex::decode("01fffefdfc2607").unwrap());
2687 target_value.append(&mut hex::decode("02fffefdfcfbfaf9f8f7f6f5f4f3f2f1f02607").unwrap());
2690 target_value.append(&mut hex::decode("03fffefdfcfbfaf9f8f7f62607").unwrap());
2693 target_value.append(&mut hex::decode("04fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0efeeedecebeae9e8e7e6e5e4e3e2e1e00020102607").unwrap());
2696 target_value.append(&mut hex::decode("0504686f73742607").unwrap());
2698 if excess_address_data {
2699 target_value.append(&mut hex::decode("216c280b5395a2546e7e4b2663e04f811622f15a4f92e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d269").unwrap());
2702 target_value.append(&mut hex::decode("3b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
2704 assert_eq!(encoded_value, target_value);
2708 fn encoding_node_announcement() {
2709 do_encoding_node_announcement(true, true, true, true, true, true, true, true);
2710 do_encoding_node_announcement(false, false, false, false, false, false, false, false);
2711 do_encoding_node_announcement(false, true, false, false, false, false, false, false);
2712 do_encoding_node_announcement(false, false, true, false, false, false, false, false);
2713 do_encoding_node_announcement(false, false, false, true, false, false, false, false);
2714 do_encoding_node_announcement(false, false, false, false, true, false, false, false);
2715 do_encoding_node_announcement(false, false, false, false, false, true, false, false);
2716 do_encoding_node_announcement(false, false, false, false, false, false, true, false);
2717 do_encoding_node_announcement(false, true, false, true, false, false, true, false);
2718 do_encoding_node_announcement(false, false, true, false, true, false, false, false);
2721 fn do_encoding_channel_update(direction: bool, disable: bool, excess_data: bool) {
2722 let secp_ctx = Secp256k1::new();
2723 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2724 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2725 let unsigned_channel_update = msgs::UnsignedChannelUpdate {
2726 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2727 short_channel_id: 2316138423780173,
2728 timestamp: 20190119,
2729 flags: if direction { 1 } else { 0 } | if disable { 1 << 1 } else { 0 },
2730 cltv_expiry_delta: 144,
2731 htlc_minimum_msat: 1000000,
2732 htlc_maximum_msat: 131355275467161,
2733 fee_base_msat: 10000,
2734 fee_proportional_millionths: 20,
2735 excess_data: if excess_data { vec![0, 0, 0, 0, 59, 154, 202, 0] } else { Vec::new() }
2737 let channel_update = msgs::ChannelUpdate {
2739 contents: unsigned_channel_update
2741 let encoded_value = channel_update.encode();
2742 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
2743 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2744 target_value.append(&mut hex::decode("00083a840000034d013413a7").unwrap());
2745 target_value.append(&mut hex::decode("01").unwrap());
2746 target_value.append(&mut hex::decode("00").unwrap());
2748 let flag = target_value.last_mut().unwrap();
2752 let flag = target_value.last_mut().unwrap();
2753 *flag = *flag | 1 << 1;
2755 target_value.append(&mut hex::decode("009000000000000f42400000271000000014").unwrap());
2756 target_value.append(&mut hex::decode("0000777788889999").unwrap());
2758 target_value.append(&mut hex::decode("000000003b9aca00").unwrap());
2760 assert_eq!(encoded_value, target_value);
2764 fn encoding_channel_update() {
2765 do_encoding_channel_update(false, false, false);
2766 do_encoding_channel_update(false, false, true);
2767 do_encoding_channel_update(true, false, false);
2768 do_encoding_channel_update(true, false, true);
2769 do_encoding_channel_update(false, true, false);
2770 do_encoding_channel_update(false, true, true);
2771 do_encoding_channel_update(true, true, false);
2772 do_encoding_channel_update(true, true, true);
2775 fn do_encoding_open_channel(random_bit: bool, shutdown: bool, incl_chan_type: bool) {
2776 let secp_ctx = Secp256k1::new();
2777 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2778 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2779 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2780 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2781 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
2782 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
2783 let open_channel = msgs::OpenChannel {
2784 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2785 temporary_channel_id: [2; 32],
2786 funding_satoshis: 1311768467284833366,
2787 push_msat: 2536655962884945560,
2788 dust_limit_satoshis: 3608586615801332854,
2789 max_htlc_value_in_flight_msat: 8517154655701053848,
2790 channel_reserve_satoshis: 8665828695742877976,
2791 htlc_minimum_msat: 2316138423780173,
2792 feerate_per_kw: 821716,
2793 to_self_delay: 49340,
2794 max_accepted_htlcs: 49340,
2795 funding_pubkey: pubkey_1,
2796 revocation_basepoint: pubkey_2,
2797 payment_point: pubkey_3,
2798 delayed_payment_basepoint: pubkey_4,
2799 htlc_basepoint: pubkey_5,
2800 first_per_commitment_point: pubkey_6,
2801 channel_flags: if random_bit { 1 << 5 } else { 0 },
2802 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
2803 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
2805 let encoded_value = open_channel.encode();
2806 let mut target_value = Vec::new();
2807 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2808 target_value.append(&mut hex::decode("02020202020202020202020202020202020202020202020202020202020202021234567890123456233403289122369832144668701144767633030896203198784335490624111800083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
2810 target_value.append(&mut hex::decode("20").unwrap());
2812 target_value.append(&mut hex::decode("00").unwrap());
2815 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
2818 target_value.append(&mut hex::decode("0100").unwrap());
2820 assert_eq!(encoded_value, target_value);
2824 fn encoding_open_channel() {
2825 do_encoding_open_channel(false, false, false);
2826 do_encoding_open_channel(false, false, true);
2827 do_encoding_open_channel(false, true, false);
2828 do_encoding_open_channel(false, true, true);
2829 do_encoding_open_channel(true, false, false);
2830 do_encoding_open_channel(true, false, true);
2831 do_encoding_open_channel(true, true, false);
2832 do_encoding_open_channel(true, true, true);
2835 fn do_encoding_open_channelv2(random_bit: bool, shutdown: bool, incl_chan_type: bool, require_confirmed_inputs: bool) {
2836 let secp_ctx = Secp256k1::new();
2837 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2838 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2839 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2840 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2841 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
2842 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
2843 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
2844 let open_channelv2 = msgs::OpenChannelV2 {
2845 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2846 temporary_channel_id: [2; 32],
2847 funding_feerate_sat_per_1000_weight: 821716,
2848 commitment_feerate_sat_per_1000_weight: 821716,
2849 funding_satoshis: 1311768467284833366,
2850 dust_limit_satoshis: 3608586615801332854,
2851 max_htlc_value_in_flight_msat: 8517154655701053848,
2852 htlc_minimum_msat: 2316138423780173,
2853 to_self_delay: 49340,
2854 max_accepted_htlcs: 49340,
2855 locktime: 305419896,
2856 funding_pubkey: pubkey_1,
2857 revocation_basepoint: pubkey_2,
2858 payment_basepoint: pubkey_3,
2859 delayed_payment_basepoint: pubkey_4,
2860 htlc_basepoint: pubkey_5,
2861 first_per_commitment_point: pubkey_6,
2862 second_per_commitment_point: pubkey_7,
2863 channel_flags: if random_bit { 1 << 5 } else { 0 },
2864 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
2865 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
2866 require_confirmed_inputs: if require_confirmed_inputs { Some(()) } else { None },
2868 let encoded_value = open_channelv2.encode();
2869 let mut target_value = Vec::new();
2870 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2871 target_value.append(&mut hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap());
2872 target_value.append(&mut hex::decode("000c89d4").unwrap());
2873 target_value.append(&mut hex::decode("000c89d4").unwrap());
2874 target_value.append(&mut hex::decode("1234567890123456").unwrap());
2875 target_value.append(&mut hex::decode("3214466870114476").unwrap());
2876 target_value.append(&mut hex::decode("7633030896203198").unwrap());
2877 target_value.append(&mut hex::decode("00083a840000034d").unwrap());
2878 target_value.append(&mut hex::decode("c0bc").unwrap());
2879 target_value.append(&mut hex::decode("c0bc").unwrap());
2880 target_value.append(&mut hex::decode("12345678").unwrap());
2881 target_value.append(&mut hex::decode("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap());
2882 target_value.append(&mut hex::decode("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap());
2883 target_value.append(&mut hex::decode("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap());
2884 target_value.append(&mut hex::decode("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
2885 target_value.append(&mut hex::decode("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap());
2886 target_value.append(&mut hex::decode("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
2887 target_value.append(&mut hex::decode("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap());
2890 target_value.append(&mut hex::decode("20").unwrap());
2892 target_value.append(&mut hex::decode("00").unwrap());
2895 target_value.append(&mut hex::decode("001b").unwrap()); // Type 0 + Length 27
2896 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
2899 target_value.append(&mut hex::decode("0100").unwrap());
2901 if require_confirmed_inputs {
2902 target_value.append(&mut hex::decode("0200").unwrap());
2904 assert_eq!(encoded_value, target_value);
2908 fn encoding_open_channelv2() {
2909 do_encoding_open_channelv2(false, false, false, false);
2910 do_encoding_open_channelv2(false, false, false, true);
2911 do_encoding_open_channelv2(false, false, true, false);
2912 do_encoding_open_channelv2(false, false, true, true);
2913 do_encoding_open_channelv2(false, true, false, false);
2914 do_encoding_open_channelv2(false, true, false, true);
2915 do_encoding_open_channelv2(false, true, true, false);
2916 do_encoding_open_channelv2(false, true, true, true);
2917 do_encoding_open_channelv2(true, false, false, false);
2918 do_encoding_open_channelv2(true, false, false, true);
2919 do_encoding_open_channelv2(true, false, true, false);
2920 do_encoding_open_channelv2(true, false, true, true);
2921 do_encoding_open_channelv2(true, true, false, false);
2922 do_encoding_open_channelv2(true, true, false, true);
2923 do_encoding_open_channelv2(true, true, true, false);
2924 do_encoding_open_channelv2(true, true, true, true);
2927 fn do_encoding_accept_channel(shutdown: bool) {
2928 let secp_ctx = Secp256k1::new();
2929 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2930 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2931 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2932 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2933 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
2934 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
2935 let accept_channel = msgs::AcceptChannel {
2936 temporary_channel_id: [2; 32],
2937 dust_limit_satoshis: 1311768467284833366,
2938 max_htlc_value_in_flight_msat: 2536655962884945560,
2939 channel_reserve_satoshis: 3608586615801332854,
2940 htlc_minimum_msat: 2316138423780173,
2941 minimum_depth: 821716,
2942 to_self_delay: 49340,
2943 max_accepted_htlcs: 49340,
2944 funding_pubkey: pubkey_1,
2945 revocation_basepoint: pubkey_2,
2946 payment_point: pubkey_3,
2947 delayed_payment_basepoint: pubkey_4,
2948 htlc_basepoint: pubkey_5,
2949 first_per_commitment_point: pubkey_6,
2950 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
2953 next_local_nonce: None,
2955 let encoded_value = accept_channel.encode();
2956 let mut target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020212345678901234562334032891223698321446687011447600083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap();
2958 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
2960 assert_eq!(encoded_value, target_value);
2964 fn encoding_accept_channel() {
2965 do_encoding_accept_channel(false);
2966 do_encoding_accept_channel(true);
2969 fn do_encoding_accept_channelv2(shutdown: bool) {
2970 let secp_ctx = Secp256k1::new();
2971 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2972 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2973 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2974 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2975 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
2976 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
2977 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
2978 let accept_channelv2 = msgs::AcceptChannelV2 {
2979 temporary_channel_id: [2; 32],
2980 funding_satoshis: 1311768467284833366,
2981 dust_limit_satoshis: 1311768467284833366,
2982 max_htlc_value_in_flight_msat: 2536655962884945560,
2983 htlc_minimum_msat: 2316138423780173,
2984 minimum_depth: 821716,
2985 to_self_delay: 49340,
2986 max_accepted_htlcs: 49340,
2987 funding_pubkey: pubkey_1,
2988 revocation_basepoint: pubkey_2,
2989 payment_basepoint: pubkey_3,
2990 delayed_payment_basepoint: pubkey_4,
2991 htlc_basepoint: pubkey_5,
2992 first_per_commitment_point: pubkey_6,
2993 second_per_commitment_point: pubkey_7,
2994 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
2996 require_confirmed_inputs: None,
2998 let encoded_value = accept_channelv2.encode();
2999 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // temporary_channel_id
3000 target_value.append(&mut hex::decode("1234567890123456").unwrap()); // funding_satoshis
3001 target_value.append(&mut hex::decode("1234567890123456").unwrap()); // dust_limit_satoshis
3002 target_value.append(&mut hex::decode("2334032891223698").unwrap()); // max_htlc_value_in_flight_msat
3003 target_value.append(&mut hex::decode("00083a840000034d").unwrap()); // htlc_minimum_msat
3004 target_value.append(&mut hex::decode("000c89d4").unwrap()); // minimum_depth
3005 target_value.append(&mut hex::decode("c0bc").unwrap()); // to_self_delay
3006 target_value.append(&mut hex::decode("c0bc").unwrap()); // max_accepted_htlcs
3007 target_value.append(&mut hex::decode("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap()); // funding_pubkey
3008 target_value.append(&mut hex::decode("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap()); // revocation_basepoint
3009 target_value.append(&mut hex::decode("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap()); // payment_basepoint
3010 target_value.append(&mut hex::decode("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap()); // delayed_payment_basepoint
3011 target_value.append(&mut hex::decode("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap()); // htlc_basepoint
3012 target_value.append(&mut hex::decode("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap()); // first_per_commitment_point
3013 target_value.append(&mut hex::decode("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap()); // second_per_commitment_point
3015 target_value.append(&mut hex::decode("001b").unwrap()); // Type 0 + Length 27
3016 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3018 assert_eq!(encoded_value, target_value);
3022 fn encoding_accept_channelv2() {
3023 do_encoding_accept_channelv2(false);
3024 do_encoding_accept_channelv2(true);
3028 fn encoding_funding_created() {
3029 let secp_ctx = Secp256k1::new();
3030 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3031 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3032 let funding_created = msgs::FundingCreated {
3033 temporary_channel_id: [2; 32],
3034 funding_txid: Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3035 funding_output_index: 255,
3038 partial_signature_with_nonce: None,
3040 next_local_nonce: None,
3042 let encoded_value = funding_created.encode();
3043 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202026e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c200ffd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3044 assert_eq!(encoded_value, target_value);
3048 fn encoding_funding_signed() {
3049 let secp_ctx = Secp256k1::new();
3050 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3051 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3052 let funding_signed = msgs::FundingSigned {
3053 channel_id: [2; 32],
3056 partial_signature_with_nonce: None,
3058 let encoded_value = funding_signed.encode();
3059 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3060 assert_eq!(encoded_value, target_value);
3064 fn encoding_channel_ready() {
3065 let secp_ctx = Secp256k1::new();
3066 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3067 let channel_ready = msgs::ChannelReady {
3068 channel_id: [2; 32],
3069 next_per_commitment_point: pubkey_1,
3070 short_channel_id_alias: None,
3072 let encoded_value = channel_ready.encode();
3073 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3074 assert_eq!(encoded_value, target_value);
3078 fn encoding_tx_add_input() {
3079 let tx_add_input = msgs::TxAddInput {
3080 channel_id: [2; 32],
3081 serial_id: 4886718345,
3082 prevtx: TransactionU16LenLimited::new(Transaction {
3084 lock_time: PackedLockTime(0),
3086 previous_output: OutPoint { txid: Txid::from_hex("305bab643ee297b8b6b76b320792c8223d55082122cb606bf89382146ced9c77").unwrap(), index: 2 }.into_bitcoin_outpoint(),
3087 script_sig: Script::new(),
3088 sequence: Sequence(0xfffffffd),
3089 witness: Witness::from_vec(vec![
3090 hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3091 hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3096 script_pubkey: Address::from_str("bc1qzlffunw52jav8vwdu5x3jfk6sr8u22rmq3xzw2").unwrap().script_pubkey(),
3100 script_pubkey: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().script_pubkey(),
3104 prevtx_out: 305419896,
3105 sequence: 305419896,
3107 let encoded_value = tx_add_input.encode();
3108 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000000012345678900de02000000000101779ced6c148293f86b60cb222108553d22c89207326bb7b6b897e23e64ab5b300200000000fdffffff0236dbc1000000000016001417d29e4dd454bac3b1cde50d1926da80cfc5287b9cbd03000000000016001436ec78d514df462da95e6a00c24daa8915362d420247304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701210301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944000000001234567812345678").unwrap();
3109 assert_eq!(encoded_value, target_value);
3113 fn encoding_tx_add_output() {
3114 let tx_add_output = msgs::TxAddOutput {
3115 channel_id: [2; 32],
3116 serial_id: 4886718345,
3118 script: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().script_pubkey(),
3120 let encoded_value = tx_add_output.encode();
3121 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000000012345678900000001234567890016001436ec78d514df462da95e6a00c24daa8915362d42").unwrap();
3122 assert_eq!(encoded_value, target_value);
3126 fn encoding_tx_remove_input() {
3127 let tx_remove_input = msgs::TxRemoveInput {
3128 channel_id: [2; 32],
3129 serial_id: 4886718345,
3131 let encoded_value = tx_remove_input.encode();
3132 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3133 assert_eq!(encoded_value, target_value);
3137 fn encoding_tx_remove_output() {
3138 let tx_remove_output = msgs::TxRemoveOutput {
3139 channel_id: [2; 32],
3140 serial_id: 4886718345,
3142 let encoded_value = tx_remove_output.encode();
3143 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3144 assert_eq!(encoded_value, target_value);
3148 fn encoding_tx_complete() {
3149 let tx_complete = msgs::TxComplete {
3150 channel_id: [2; 32],
3152 let encoded_value = tx_complete.encode();
3153 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3154 assert_eq!(encoded_value, target_value);
3158 fn encoding_tx_signatures() {
3159 let tx_signatures = msgs::TxSignatures {
3160 channel_id: [2; 32],
3161 tx_hash: Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3163 Witness::from_vec(vec![
3164 hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3165 hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3166 Witness::from_vec(vec![
3167 hex::decode("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap(),
3168 hex::decode("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap()]),
3171 let encoded_value = tx_signatures.encode();
3172 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3173 target_value.append(&mut hex::decode("6e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c2").unwrap()); // tx_hash (sha256) (big endian byte order)
3174 target_value.append(&mut hex::decode("0002").unwrap()); // num_witnesses (u16)
3176 target_value.append(&mut hex::decode("006b").unwrap()); // len of witness_data
3177 target_value.append(&mut hex::decode("02").unwrap()); // num_witness_elements (VarInt)
3178 target_value.append(&mut hex::decode("47").unwrap()); // len of witness element data (VarInt)
3179 target_value.append(&mut hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap());
3180 target_value.append(&mut hex::decode("21").unwrap()); // len of witness element data (VarInt)
3181 target_value.append(&mut hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap());
3183 target_value.append(&mut hex::decode("006c").unwrap()); // len of witness_data
3184 target_value.append(&mut hex::decode("02").unwrap()); // num_witness_elements (VarInt)
3185 target_value.append(&mut hex::decode("48").unwrap()); // len of witness element data (VarInt)
3186 target_value.append(&mut hex::decode("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap());
3187 target_value.append(&mut hex::decode("21").unwrap()); // len of witness element data (VarInt)
3188 target_value.append(&mut hex::decode("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap());
3189 assert_eq!(encoded_value, target_value);
3192 fn do_encoding_tx_init_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3193 let tx_init_rbf = msgs::TxInitRbf {
3194 channel_id: [2; 32],
3195 locktime: 305419896,
3196 feerate_sat_per_1000_weight: 20190119,
3197 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3199 let encoded_value = tx_init_rbf.encode();
3200 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3201 target_value.append(&mut hex::decode("12345678").unwrap()); // locktime
3202 target_value.append(&mut hex::decode("013413a7").unwrap()); // feerate_sat_per_1000_weight
3203 if let Some((_, target)) = funding_value_with_hex_target {
3204 target_value.push(0x00); // Type
3205 target_value.push(target.len() as u8 / 2); // Length
3206 target_value.append(&mut hex::decode(target).unwrap()); // Value (i64)
3208 assert_eq!(encoded_value, target_value);
3212 fn encoding_tx_init_rbf() {
3213 do_encoding_tx_init_rbf(Some((1311768467284833366, "1234567890123456")));
3214 do_encoding_tx_init_rbf(Some((13117684672, "000000030DDFFBC0")));
3215 do_encoding_tx_init_rbf(None);
3218 fn do_encoding_tx_ack_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3219 let tx_ack_rbf = msgs::TxAckRbf {
3220 channel_id: [2; 32],
3221 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3223 let encoded_value = tx_ack_rbf.encode();
3224 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3225 if let Some((_, target)) = funding_value_with_hex_target {
3226 target_value.push(0x00); // Type
3227 target_value.push(target.len() as u8 / 2); // Length
3228 target_value.append(&mut hex::decode(target).unwrap()); // Value (i64)
3230 assert_eq!(encoded_value, target_value);
3234 fn encoding_tx_ack_rbf() {
3235 do_encoding_tx_ack_rbf(Some((1311768467284833366, "1234567890123456")));
3236 do_encoding_tx_ack_rbf(Some((13117684672, "000000030DDFFBC0")));
3237 do_encoding_tx_ack_rbf(None);
3241 fn encoding_tx_abort() {
3242 let tx_abort = msgs::TxAbort {
3243 channel_id: [2; 32],
3244 data: hex::decode("54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap(),
3246 let encoded_value = tx_abort.encode();
3247 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202002C54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap();
3248 assert_eq!(encoded_value, target_value);
3251 fn do_encoding_shutdown(script_type: u8) {
3252 let secp_ctx = Secp256k1::new();
3253 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3254 let script = Builder::new().push_opcode(opcodes::OP_TRUE).into_script();
3255 let shutdown = msgs::Shutdown {
3256 channel_id: [2; 32],
3258 if script_type == 1 { Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey() }
3259 else if script_type == 2 { Address::p2sh(&script, Network::Testnet).unwrap().script_pubkey() }
3260 else if script_type == 3 { Address::p2wpkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).unwrap().script_pubkey() }
3261 else { Address::p2wsh(&script, Network::Testnet).script_pubkey() },
3263 let encoded_value = shutdown.encode();
3264 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3265 if script_type == 1 {
3266 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3267 } else if script_type == 2 {
3268 target_value.append(&mut hex::decode("0017a914da1745e9b549bd0bfa1a569971c77eba30cd5a4b87").unwrap());
3269 } else if script_type == 3 {
3270 target_value.append(&mut hex::decode("0016001479b000887626b294a914501a4cd226b58b235983").unwrap());
3271 } else if script_type == 4 {
3272 target_value.append(&mut hex::decode("002200204ae81572f06e1b88fd5ced7a1a000945432e83e1551e6f721ee9c00b8cc33260").unwrap());
3274 assert_eq!(encoded_value, target_value);
3278 fn encoding_shutdown() {
3279 do_encoding_shutdown(1);
3280 do_encoding_shutdown(2);
3281 do_encoding_shutdown(3);
3282 do_encoding_shutdown(4);
3286 fn encoding_closing_signed() {
3287 let secp_ctx = Secp256k1::new();
3288 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3289 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3290 let closing_signed = msgs::ClosingSigned {
3291 channel_id: [2; 32],
3292 fee_satoshis: 2316138423780173,
3296 let encoded_value = closing_signed.encode();
3297 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3298 assert_eq!(encoded_value, target_value);
3299 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value)).unwrap(), closing_signed);
3301 let closing_signed_with_range = msgs::ClosingSigned {
3302 channel_id: [2; 32],
3303 fee_satoshis: 2316138423780173,
3305 fee_range: Some(msgs::ClosingSignedFeeRange {
3306 min_fee_satoshis: 0xdeadbeef,
3307 max_fee_satoshis: 0x1badcafe01234567,
3310 let encoded_value_with_range = closing_signed_with_range.encode();
3311 let target_value_with_range = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a011000000000deadbeef1badcafe01234567").unwrap();
3312 assert_eq!(encoded_value_with_range, target_value_with_range);
3313 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value_with_range)).unwrap(),
3314 closing_signed_with_range);
3318 fn encoding_update_add_htlc() {
3319 let secp_ctx = Secp256k1::new();
3320 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3321 let onion_routing_packet = msgs::OnionPacket {
3323 public_key: Ok(pubkey_1),
3324 hop_data: [1; 20*65],
3327 let update_add_htlc = msgs::UpdateAddHTLC {
3328 channel_id: [2; 32],
3329 htlc_id: 2316138423780173,
3330 amount_msat: 3608586615801332854,
3331 payment_hash: PaymentHash([1; 32]),
3332 cltv_expiry: 821716,
3333 onion_routing_packet
3335 let encoded_value = update_add_htlc.encode();
3336 let target_value = hex::decode("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").unwrap();
3337 assert_eq!(encoded_value, target_value);
3341 fn encoding_update_fulfill_htlc() {
3342 let update_fulfill_htlc = msgs::UpdateFulfillHTLC {
3343 channel_id: [2; 32],
3344 htlc_id: 2316138423780173,
3345 payment_preimage: PaymentPreimage([1; 32]),
3347 let encoded_value = update_fulfill_htlc.encode();
3348 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d0101010101010101010101010101010101010101010101010101010101010101").unwrap();
3349 assert_eq!(encoded_value, target_value);
3353 fn encoding_update_fail_htlc() {
3354 let reason = OnionErrorPacket {
3355 data: [1; 32].to_vec(),
3357 let update_fail_htlc = msgs::UpdateFailHTLC {
3358 channel_id: [2; 32],
3359 htlc_id: 2316138423780173,
3362 let encoded_value = update_fail_htlc.encode();
3363 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d00200101010101010101010101010101010101010101010101010101010101010101").unwrap();
3364 assert_eq!(encoded_value, target_value);
3368 fn encoding_update_fail_malformed_htlc() {
3369 let update_fail_malformed_htlc = msgs::UpdateFailMalformedHTLC {
3370 channel_id: [2; 32],
3371 htlc_id: 2316138423780173,
3372 sha256_of_onion: [1; 32],
3375 let encoded_value = update_fail_malformed_htlc.encode();
3376 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d010101010101010101010101010101010101010101010101010101010101010100ff").unwrap();
3377 assert_eq!(encoded_value, target_value);
3380 fn do_encoding_commitment_signed(htlcs: bool) {
3381 let secp_ctx = Secp256k1::new();
3382 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3383 let (privkey_2, _) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3384 let (privkey_3, _) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3385 let (privkey_4, _) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3386 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3387 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
3388 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
3389 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
3390 let commitment_signed = msgs::CommitmentSigned {
3391 channel_id: [2; 32],
3393 htlc_signatures: if htlcs { vec![sig_2, sig_3, sig_4] } else { Vec::new() },
3395 partial_signature_with_nonce: None,
3397 let encoded_value = commitment_signed.encode();
3398 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3400 target_value.append(&mut hex::decode("00031735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
3402 target_value.append(&mut hex::decode("0000").unwrap());
3404 assert_eq!(encoded_value, target_value);
3408 fn encoding_commitment_signed() {
3409 do_encoding_commitment_signed(true);
3410 do_encoding_commitment_signed(false);
3414 fn encoding_revoke_and_ack() {
3415 let secp_ctx = Secp256k1::new();
3416 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3417 let raa = msgs::RevokeAndACK {
3418 channel_id: [2; 32],
3419 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],
3420 next_per_commitment_point: pubkey_1,
3422 next_local_nonce: None,
3424 let encoded_value = raa.encode();
3425 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020101010101010101010101010101010101010101010101010101010101010101031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3426 assert_eq!(encoded_value, target_value);
3430 fn encoding_update_fee() {
3431 let update_fee = msgs::UpdateFee {
3432 channel_id: [2; 32],
3433 feerate_per_kw: 20190119,
3435 let encoded_value = update_fee.encode();
3436 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202013413a7").unwrap();
3437 assert_eq!(encoded_value, target_value);
3441 fn encoding_init() {
3442 let mainnet_hash = ChainHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap();
3443 assert_eq!(msgs::Init {
3444 features: InitFeatures::from_le_bytes(vec![0xFF, 0xFF, 0xFF]),
3445 networks: Some(vec![mainnet_hash]),
3446 remote_network_address: None,
3447 }.encode(), hex::decode("00023fff0003ffffff01206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3448 assert_eq!(msgs::Init {
3449 features: InitFeatures::from_le_bytes(vec![0xFF]),
3451 remote_network_address: None,
3452 }.encode(), hex::decode("0001ff0001ff").unwrap());
3453 assert_eq!(msgs::Init {
3454 features: InitFeatures::from_le_bytes(vec![]),
3455 networks: Some(vec![mainnet_hash]),
3456 remote_network_address: None,
3457 }.encode(), hex::decode("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3458 assert_eq!(msgs::Init {
3459 features: InitFeatures::from_le_bytes(vec![]),
3460 networks: Some(vec![ChainHash::from(&[1; 32][..]), ChainHash::from(&[2; 32][..])]),
3461 remote_network_address: None,
3462 }.encode(), hex::decode("00000000014001010101010101010101010101010101010101010101010101010101010101010202020202020202020202020202020202020202020202020202020202020202").unwrap());
3463 let init_msg = msgs::Init { features: InitFeatures::from_le_bytes(vec![]),
3464 networks: Some(vec![mainnet_hash]),
3465 remote_network_address: Some(msgs::NetAddress::IPv4 {
3466 addr: [127, 0, 0, 1],
3470 let encoded_value = init_msg.encode();
3471 let target_value = hex::decode("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d61900000000000307017f00000103e8").unwrap();
3472 assert_eq!(encoded_value, target_value);
3473 assert_eq!(msgs::Init::read(&mut Cursor::new(&target_value)).unwrap(), init_msg);
3477 fn encoding_error() {
3478 let error = msgs::ErrorMessage {
3479 channel_id: [2; 32],
3480 data: String::from("rust-lightning"),
3482 let encoded_value = error.encode();
3483 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3484 assert_eq!(encoded_value, target_value);
3488 fn encoding_warning() {
3489 let error = msgs::WarningMessage {
3490 channel_id: [2; 32],
3491 data: String::from("rust-lightning"),
3493 let encoded_value = error.encode();
3494 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3495 assert_eq!(encoded_value, target_value);
3499 fn encoding_ping() {
3500 let ping = msgs::Ping {
3504 let encoded_value = ping.encode();
3505 let target_value = hex::decode("0040004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3506 assert_eq!(encoded_value, target_value);
3510 fn encoding_pong() {
3511 let pong = msgs::Pong {
3514 let encoded_value = pong.encode();
3515 let target_value = hex::decode("004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3516 assert_eq!(encoded_value, target_value);
3520 fn encoding_nonfinal_onion_hop_data() {
3521 let mut msg = msgs::OnionHopData {
3522 format: OnionHopDataFormat::NonFinalNode {
3523 short_channel_id: 0xdeadbeef1bad1dea,
3525 amt_to_forward: 0x0badf00d01020304,
3526 outgoing_cltv_value: 0xffffffff,
3528 let encoded_value = msg.encode();
3529 let target_value = hex::decode("1a02080badf00d010203040404ffffffff0608deadbeef1bad1dea").unwrap();
3530 assert_eq!(encoded_value, target_value);
3531 msg = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3532 if let OnionHopDataFormat::NonFinalNode { short_channel_id } = msg.format {
3533 assert_eq!(short_channel_id, 0xdeadbeef1bad1dea);
3534 } else { panic!(); }
3535 assert_eq!(msg.amt_to_forward, 0x0badf00d01020304);
3536 assert_eq!(msg.outgoing_cltv_value, 0xffffffff);
3540 fn encoding_final_onion_hop_data() {
3541 let mut msg = msgs::OnionHopData {
3542 format: OnionHopDataFormat::FinalNode {
3544 payment_metadata: None,
3545 keysend_preimage: None,
3547 amt_to_forward: 0x0badf00d01020304,
3548 outgoing_cltv_value: 0xffffffff,
3550 let encoded_value = msg.encode();
3551 let target_value = hex::decode("1002080badf00d010203040404ffffffff").unwrap();
3552 assert_eq!(encoded_value, target_value);
3553 msg = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3554 if let OnionHopDataFormat::FinalNode { payment_data: None, .. } = msg.format { } else { panic!(); }
3555 assert_eq!(msg.amt_to_forward, 0x0badf00d01020304);
3556 assert_eq!(msg.outgoing_cltv_value, 0xffffffff);
3560 fn encoding_final_onion_hop_data_with_secret() {
3561 let expected_payment_secret = PaymentSecret([0x42u8; 32]);
3562 let mut msg = msgs::OnionHopData {
3563 format: OnionHopDataFormat::FinalNode {
3564 payment_data: Some(FinalOnionHopData {
3565 payment_secret: expected_payment_secret,
3566 total_msat: 0x1badca1f
3568 payment_metadata: None,
3569 keysend_preimage: None,
3571 amt_to_forward: 0x0badf00d01020304,
3572 outgoing_cltv_value: 0xffffffff,
3574 let encoded_value = msg.encode();
3575 let target_value = hex::decode("3602080badf00d010203040404ffffffff082442424242424242424242424242424242424242424242424242424242424242421badca1f").unwrap();
3576 assert_eq!(encoded_value, target_value);
3577 msg = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3578 if let OnionHopDataFormat::FinalNode {
3579 payment_data: Some(FinalOnionHopData {
3581 total_msat: 0x1badca1f
3583 payment_metadata: None,
3584 keysend_preimage: None,
3586 assert_eq!(payment_secret, expected_payment_secret);
3587 } else { panic!(); }
3588 assert_eq!(msg.amt_to_forward, 0x0badf00d01020304);
3589 assert_eq!(msg.outgoing_cltv_value, 0xffffffff);
3593 fn query_channel_range_end_blocknum() {
3594 let tests: Vec<(u32, u32, u32)> = vec![
3595 (10000, 1500, 11500),
3596 (0, 0xffffffff, 0xffffffff),
3597 (1, 0xffffffff, 0xffffffff),
3600 for (first_blocknum, number_of_blocks, expected) in tests.into_iter() {
3601 let sut = msgs::QueryChannelRange {
3602 chain_hash: BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap(),
3606 assert_eq!(sut.end_blocknum(), expected);
3611 fn encoding_query_channel_range() {
3612 let mut query_channel_range = msgs::QueryChannelRange {
3613 chain_hash: BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap(),
3614 first_blocknum: 100000,
3615 number_of_blocks: 1500,
3617 let encoded_value = query_channel_range.encode();
3618 let target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206000186a0000005dc").unwrap();
3619 assert_eq!(encoded_value, target_value);
3621 query_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3622 assert_eq!(query_channel_range.first_blocknum, 100000);
3623 assert_eq!(query_channel_range.number_of_blocks, 1500);
3627 fn encoding_reply_channel_range() {
3628 do_encoding_reply_channel_range(0);
3629 do_encoding_reply_channel_range(1);
3632 fn do_encoding_reply_channel_range(encoding_type: u8) {
3633 let mut target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206000b8a06000005dc01").unwrap();
3634 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3635 let mut reply_channel_range = msgs::ReplyChannelRange {
3636 chain_hash: expected_chain_hash,
3637 first_blocknum: 756230,
3638 number_of_blocks: 1500,
3639 sync_complete: true,
3640 short_channel_ids: vec![0x000000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
3643 if encoding_type == 0 {
3644 target_value.append(&mut hex::decode("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
3645 let encoded_value = reply_channel_range.encode();
3646 assert_eq!(encoded_value, target_value);
3648 reply_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3649 assert_eq!(reply_channel_range.chain_hash, expected_chain_hash);
3650 assert_eq!(reply_channel_range.first_blocknum, 756230);
3651 assert_eq!(reply_channel_range.number_of_blocks, 1500);
3652 assert_eq!(reply_channel_range.sync_complete, true);
3653 assert_eq!(reply_channel_range.short_channel_ids[0], 0x000000000000008e);
3654 assert_eq!(reply_channel_range.short_channel_ids[1], 0x0000000000003c69);
3655 assert_eq!(reply_channel_range.short_channel_ids[2], 0x000000000045a6c4);
3657 target_value.append(&mut hex::decode("001601789c636000833e08659309a65878be010010a9023a").unwrap());
3658 let result: Result<msgs::ReplyChannelRange, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
3659 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
3664 fn encoding_query_short_channel_ids() {
3665 do_encoding_query_short_channel_ids(0);
3666 do_encoding_query_short_channel_ids(1);
3669 fn do_encoding_query_short_channel_ids(encoding_type: u8) {
3670 let mut target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206").unwrap();
3671 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3672 let mut query_short_channel_ids = msgs::QueryShortChannelIds {
3673 chain_hash: expected_chain_hash,
3674 short_channel_ids: vec![0x0000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
3677 if encoding_type == 0 {
3678 target_value.append(&mut hex::decode("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
3679 let encoded_value = query_short_channel_ids.encode();
3680 assert_eq!(encoded_value, target_value);
3682 query_short_channel_ids = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3683 assert_eq!(query_short_channel_ids.chain_hash, expected_chain_hash);
3684 assert_eq!(query_short_channel_ids.short_channel_ids[0], 0x000000000000008e);
3685 assert_eq!(query_short_channel_ids.short_channel_ids[1], 0x0000000000003c69);
3686 assert_eq!(query_short_channel_ids.short_channel_ids[2], 0x000000000045a6c4);
3688 target_value.append(&mut hex::decode("001601789c636000833e08659309a65878be010010a9023a").unwrap());
3689 let result: Result<msgs::QueryShortChannelIds, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
3690 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
3695 fn encoding_reply_short_channel_ids_end() {
3696 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3697 let mut reply_short_channel_ids_end = msgs::ReplyShortChannelIdsEnd {
3698 chain_hash: expected_chain_hash,
3699 full_information: true,
3701 let encoded_value = reply_short_channel_ids_end.encode();
3702 let target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e220601").unwrap();
3703 assert_eq!(encoded_value, target_value);
3705 reply_short_channel_ids_end = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3706 assert_eq!(reply_short_channel_ids_end.chain_hash, expected_chain_hash);
3707 assert_eq!(reply_short_channel_ids_end.full_information, true);
3711 fn encoding_gossip_timestamp_filter(){
3712 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3713 let mut gossip_timestamp_filter = msgs::GossipTimestampFilter {
3714 chain_hash: expected_chain_hash,
3715 first_timestamp: 1590000000,
3716 timestamp_range: 0xffff_ffff,
3718 let encoded_value = gossip_timestamp_filter.encode();
3719 let target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e22065ec57980ffffffff").unwrap();
3720 assert_eq!(encoded_value, target_value);
3722 gossip_timestamp_filter = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3723 assert_eq!(gossip_timestamp_filter.chain_hash, expected_chain_hash);
3724 assert_eq!(gossip_timestamp_filter.first_timestamp, 1590000000);
3725 assert_eq!(gossip_timestamp_filter.timestamp_range, 0xffff_ffff);
3729 fn decode_onion_hop_data_len_as_bigsize() {
3730 // Tests that we can decode an onion payload that is >253 bytes.
3731 // Previously, receiving a payload of this size could've caused us to fail to decode a valid
3732 // payload, because we were decoding the length (a BigSize, big-endian) as a VarInt
3735 // Encode a test onion payload with a big custom TLV such that it's >253 bytes, forcing the
3736 // payload length to be encoded over multiple bytes rather than a single u8.
3737 let big_payload = encode_big_payload().unwrap();
3738 let mut rd = Cursor::new(&big_payload[..]);
3739 <msgs::OnionHopData as Readable>::read(&mut rd).unwrap();
3741 // see above test, needs to be a separate method for use of the serialization macros.
3742 fn encode_big_payload() -> Result<Vec<u8>, io::Error> {
3743 use crate::util::ser::HighZeroBytesDroppedBigSize;
3744 let payload = msgs::OnionHopData {
3745 format: OnionHopDataFormat::NonFinalNode {
3746 short_channel_id: 0xdeadbeef1bad1dea,
3748 amt_to_forward: 1000,
3749 outgoing_cltv_value: 0xffffffff,
3751 let mut encoded_payload = Vec::new();
3752 let test_bytes = vec![42u8; 1000];
3753 if let OnionHopDataFormat::NonFinalNode { short_channel_id } = payload.format {
3754 _encode_varint_length_prefixed_tlv!(&mut encoded_payload, {
3755 (1, test_bytes, vec_type),
3756 (2, HighZeroBytesDroppedBigSize(payload.amt_to_forward), required),
3757 (4, HighZeroBytesDroppedBigSize(payload.outgoing_cltv_value), required),
3758 (6, short_channel_id, required)