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;
1305 /// A trait to describe an object which can receive routing messages.
1307 /// # Implementor DoS Warnings
1309 /// For messages enabled with the `gossip_queries` feature there are potential DoS vectors when
1310 /// handling inbound queries. Implementors using an on-disk network graph should be aware of
1311 /// repeated disk I/O for queries accessing different parts of the network graph.
1312 pub trait RoutingMessageHandler : MessageSendEventsProvider {
1313 /// Handle an incoming `node_announcement` message, returning `true` if it should be forwarded on,
1314 /// `false` or returning an `Err` otherwise.
1315 fn handle_node_announcement(&self, msg: &NodeAnnouncement) -> Result<bool, LightningError>;
1316 /// Handle a `channel_announcement` message, returning `true` if it should be forwarded on, `false`
1317 /// or returning an `Err` otherwise.
1318 fn handle_channel_announcement(&self, msg: &ChannelAnnouncement) -> Result<bool, LightningError>;
1319 /// Handle an incoming `channel_update` message, returning true if it should be forwarded on,
1320 /// `false` or returning an `Err` otherwise.
1321 fn handle_channel_update(&self, msg: &ChannelUpdate) -> Result<bool, LightningError>;
1322 /// Gets channel announcements and updates required to dump our routing table to a remote node,
1323 /// starting at the `short_channel_id` indicated by `starting_point` and including announcements
1324 /// for a single channel.
1325 fn get_next_channel_announcement(&self, starting_point: u64) -> Option<(ChannelAnnouncement, Option<ChannelUpdate>, Option<ChannelUpdate>)>;
1326 /// Gets a node announcement required to dump our routing table to a remote node, starting at
1327 /// the node *after* the provided pubkey and including up to one announcement immediately
1328 /// higher (as defined by `<PublicKey as Ord>::cmp`) than `starting_point`.
1329 /// If `None` is provided for `starting_point`, we start at the first node.
1330 fn get_next_node_announcement(&self, starting_point: Option<&NodeId>) -> Option<NodeAnnouncement>;
1331 /// Called when a connection is established with a peer. This can be used to
1332 /// perform routing table synchronization using a strategy defined by the
1335 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1336 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1337 /// message handlers may still wish to communicate with this peer.
1338 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1339 /// Handles the reply of a query we initiated to learn about channels
1340 /// for a given range of blocks. We can expect to receive one or more
1341 /// replies to a single query.
1342 fn handle_reply_channel_range(&self, their_node_id: &PublicKey, msg: ReplyChannelRange) -> Result<(), LightningError>;
1343 /// Handles the reply of a query we initiated asking for routing gossip
1344 /// messages for a list of channels. We should receive this message when
1345 /// a node has completed its best effort to send us the pertaining routing
1346 /// gossip messages.
1347 fn handle_reply_short_channel_ids_end(&self, their_node_id: &PublicKey, msg: ReplyShortChannelIdsEnd) -> Result<(), LightningError>;
1348 /// Handles when a peer asks us to send a list of `short_channel_id`s
1349 /// for the requested range of blocks.
1350 fn handle_query_channel_range(&self, their_node_id: &PublicKey, msg: QueryChannelRange) -> Result<(), LightningError>;
1351 /// Handles when a peer asks us to send routing gossip messages for a
1352 /// list of `short_channel_id`s.
1353 fn handle_query_short_channel_ids(&self, their_node_id: &PublicKey, msg: QueryShortChannelIds) -> Result<(), LightningError>;
1355 // Handler queueing status:
1356 /// Indicates that there are a large number of [`ChannelAnnouncement`] (or other) messages
1357 /// pending some async action. While there is no guarantee of the rate of future messages, the
1358 /// caller should seek to reduce the rate of new gossip messages handled, especially
1359 /// [`ChannelAnnouncement`]s.
1360 fn processing_queue_high(&self) -> bool;
1362 // Handler information:
1363 /// Gets the node feature flags which this handler itself supports. All available handlers are
1364 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1365 /// which are broadcasted in our [`NodeAnnouncement`] message.
1366 fn provided_node_features(&self) -> NodeFeatures;
1367 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1368 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1369 /// which are sent in our [`Init`] message.
1371 /// Note that this method is called before [`Self::peer_connected`].
1372 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1375 /// A trait to describe an object that can receive onion messages.
1376 pub trait OnionMessageHandler : OnionMessageProvider {
1377 /// Handle an incoming `onion_message` message from the given peer.
1378 fn handle_onion_message(&self, peer_node_id: &PublicKey, msg: &OnionMessage);
1379 /// Called when a connection is established with a peer. Can be used to track which peers
1380 /// advertise onion message support and are online.
1382 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1383 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1384 /// message handlers may still wish to communicate with this peer.
1385 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1386 /// Indicates a connection to the peer failed/an existing connection was lost. Allows handlers to
1387 /// drop and refuse to forward onion messages to this peer.
1388 fn peer_disconnected(&self, their_node_id: &PublicKey);
1390 // Handler information:
1391 /// Gets the node feature flags which this handler itself supports. All available handlers are
1392 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1393 /// which are broadcasted in our [`NodeAnnouncement`] message.
1394 fn provided_node_features(&self) -> NodeFeatures;
1396 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1397 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1398 /// which are sent in our [`Init`] message.
1400 /// Note that this method is called before [`Self::peer_connected`].
1401 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1404 mod fuzzy_internal_msgs {
1405 use crate::prelude::*;
1406 use crate::ln::{PaymentPreimage, PaymentSecret};
1408 // These types aren't intended to be pub, but are exposed for direct fuzzing (as we deserialize
1409 // them from untrusted input):
1411 pub(crate) struct FinalOnionHopData {
1412 pub(crate) payment_secret: PaymentSecret,
1413 /// The total value, in msat, of the payment as received by the ultimate recipient.
1414 /// Message serialization may panic if this value is more than 21 million Bitcoin.
1415 pub(crate) total_msat: u64,
1418 pub(crate) enum OnionHopDataFormat {
1420 short_channel_id: u64,
1423 payment_data: Option<FinalOnionHopData>,
1424 payment_metadata: Option<Vec<u8>>,
1425 keysend_preimage: Option<PaymentPreimage>,
1429 pub struct OnionHopData {
1430 pub(crate) format: OnionHopDataFormat,
1431 /// The value, in msat, of the payment after this hop's fee is deducted.
1432 /// Message serialization may panic if this value is more than 21 million Bitcoin.
1433 pub(crate) amt_to_forward: u64,
1434 pub(crate) outgoing_cltv_value: u32,
1437 pub struct DecodedOnionErrorPacket {
1438 pub(crate) hmac: [u8; 32],
1439 pub(crate) failuremsg: Vec<u8>,
1440 pub(crate) pad: Vec<u8>,
1444 pub use self::fuzzy_internal_msgs::*;
1445 #[cfg(not(fuzzing))]
1446 pub(crate) use self::fuzzy_internal_msgs::*;
1449 pub(crate) struct OnionPacket {
1450 pub(crate) version: u8,
1451 /// In order to ensure we always return an error on onion decode in compliance with [BOLT
1452 /// #4](https://github.com/lightning/bolts/blob/master/04-onion-routing.md), we have to
1453 /// deserialize `OnionPacket`s contained in [`UpdateAddHTLC`] messages even if the ephemeral
1454 /// public key (here) is bogus, so we hold a [`Result`] instead of a [`PublicKey`] as we'd
1456 pub(crate) public_key: Result<PublicKey, secp256k1::Error>,
1457 pub(crate) hop_data: [u8; 20*65],
1458 pub(crate) hmac: [u8; 32],
1461 impl onion_utils::Packet for OnionPacket {
1462 type Data = onion_utils::FixedSizeOnionPacket;
1463 fn new(pubkey: PublicKey, hop_data: onion_utils::FixedSizeOnionPacket, hmac: [u8; 32]) -> Self {
1466 public_key: Ok(pubkey),
1467 hop_data: hop_data.0,
1473 impl Eq for OnionPacket { }
1474 impl PartialEq for OnionPacket {
1475 fn eq(&self, other: &OnionPacket) -> bool {
1476 for (i, j) in self.hop_data.iter().zip(other.hop_data.iter()) {
1477 if i != j { return false; }
1479 self.version == other.version &&
1480 self.public_key == other.public_key &&
1481 self.hmac == other.hmac
1485 impl fmt::Debug for OnionPacket {
1486 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1487 f.write_fmt(format_args!("OnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
1491 #[derive(Clone, Debug, PartialEq, Eq)]
1492 pub(crate) struct OnionErrorPacket {
1493 // This really should be a constant size slice, but the spec lets these things be up to 128KB?
1494 // (TODO) We limit it in decode to much lower...
1495 pub(crate) data: Vec<u8>,
1498 impl fmt::Display for DecodeError {
1499 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1501 DecodeError::UnknownVersion => f.write_str("Unknown realm byte in Onion packet"),
1502 DecodeError::UnknownRequiredFeature => f.write_str("Unknown required feature preventing decode"),
1503 DecodeError::InvalidValue => f.write_str("Nonsense bytes didn't map to the type they were interpreted as"),
1504 DecodeError::ShortRead => f.write_str("Packet extended beyond the provided bytes"),
1505 DecodeError::BadLengthDescriptor => f.write_str("A length descriptor in the packet didn't describe the later data correctly"),
1506 DecodeError::Io(ref e) => fmt::Debug::fmt(e, f),
1507 DecodeError::UnsupportedCompression => f.write_str("We don't support receiving messages with zlib-compressed fields"),
1512 impl From<io::Error> for DecodeError {
1513 fn from(e: io::Error) -> Self {
1514 if e.kind() == io::ErrorKind::UnexpectedEof {
1515 DecodeError::ShortRead
1517 DecodeError::Io(e.kind())
1522 #[cfg(not(taproot))]
1523 impl_writeable_msg!(AcceptChannel, {
1524 temporary_channel_id,
1525 dust_limit_satoshis,
1526 max_htlc_value_in_flight_msat,
1527 channel_reserve_satoshis,
1533 revocation_basepoint,
1535 delayed_payment_basepoint,
1537 first_per_commitment_point,
1539 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1540 (1, channel_type, option),
1544 impl_writeable_msg!(AcceptChannel, {
1545 temporary_channel_id,
1546 dust_limit_satoshis,
1547 max_htlc_value_in_flight_msat,
1548 channel_reserve_satoshis,
1554 revocation_basepoint,
1556 delayed_payment_basepoint,
1558 first_per_commitment_point,
1560 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1561 (1, channel_type, option),
1562 (4, next_local_nonce, option),
1565 impl_writeable_msg!(AcceptChannelV2, {
1566 temporary_channel_id,
1568 dust_limit_satoshis,
1569 max_htlc_value_in_flight_msat,
1575 revocation_basepoint,
1577 delayed_payment_basepoint,
1579 first_per_commitment_point,
1580 second_per_commitment_point,
1582 (0, shutdown_scriptpubkey, option),
1583 (1, channel_type, option),
1584 (2, require_confirmed_inputs, option),
1587 impl_writeable_msg!(TxAddInput, {
1595 impl_writeable_msg!(TxAddOutput, {
1602 impl_writeable_msg!(TxRemoveInput, {
1607 impl_writeable_msg!(TxRemoveOutput, {
1612 impl_writeable_msg!(TxComplete, {
1616 impl_writeable_msg!(TxSignatures, {
1622 impl_writeable_msg!(TxInitRbf, {
1625 feerate_sat_per_1000_weight,
1627 (0, funding_output_contribution, option),
1630 impl_writeable_msg!(TxAckRbf, {
1633 (0, funding_output_contribution, option),
1636 impl_writeable_msg!(TxAbort, {
1641 impl_writeable_msg!(AnnouncementSignatures, {
1648 impl_writeable_msg!(ChannelReestablish, {
1650 next_local_commitment_number,
1651 next_remote_commitment_number,
1652 your_last_per_commitment_secret,
1653 my_current_per_commitment_point,
1655 (0, next_funding_txid, option),
1658 impl_writeable_msg!(ClosingSigned,
1659 { channel_id, fee_satoshis, signature },
1660 { (1, fee_range, option) }
1663 impl_writeable!(ClosingSignedFeeRange, {
1668 #[cfg(not(taproot))]
1669 impl_writeable_msg!(CommitmentSigned, {
1676 impl_writeable_msg!(CommitmentSigned, {
1681 (2, partial_signature_with_nonce, option)
1684 impl_writeable!(DecodedOnionErrorPacket, {
1690 #[cfg(not(taproot))]
1691 impl_writeable_msg!(FundingCreated, {
1692 temporary_channel_id,
1694 funding_output_index,
1698 impl_writeable_msg!(FundingCreated, {
1699 temporary_channel_id,
1701 funding_output_index,
1704 (2, partial_signature_with_nonce, option),
1705 (4, next_local_nonce, option)
1708 #[cfg(not(taproot))]
1709 impl_writeable_msg!(FundingSigned, {
1715 impl_writeable_msg!(FundingSigned, {
1719 (2, partial_signature_with_nonce, option)
1722 impl_writeable_msg!(ChannelReady, {
1724 next_per_commitment_point,
1726 (1, short_channel_id_alias, option),
1729 impl Writeable for Init {
1730 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1731 // global_features gets the bottom 13 bits of our features, and local_features gets all of
1732 // our relevant feature bits. This keeps us compatible with old nodes.
1733 self.features.write_up_to_13(w)?;
1734 self.features.write(w)?;
1735 encode_tlv_stream!(w, {
1736 (1, self.networks.as_ref().map(|n| WithoutLength(n)), option),
1737 (3, self.remote_network_address, option),
1743 impl Readable for Init {
1744 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1745 let global_features: InitFeatures = Readable::read(r)?;
1746 let features: InitFeatures = Readable::read(r)?;
1747 let mut remote_network_address: Option<NetAddress> = None;
1748 let mut networks: Option<WithoutLength<Vec<ChainHash>>> = None;
1749 decode_tlv_stream!(r, {
1750 (1, networks, option),
1751 (3, remote_network_address, option)
1754 features: features | global_features,
1755 networks: networks.map(|n| n.0),
1756 remote_network_address,
1761 impl_writeable_msg!(OpenChannel, {
1763 temporary_channel_id,
1766 dust_limit_satoshis,
1767 max_htlc_value_in_flight_msat,
1768 channel_reserve_satoshis,
1774 revocation_basepoint,
1776 delayed_payment_basepoint,
1778 first_per_commitment_point,
1781 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1782 (1, channel_type, option),
1785 impl_writeable_msg!(OpenChannelV2, {
1787 temporary_channel_id,
1788 funding_feerate_sat_per_1000_weight,
1789 commitment_feerate_sat_per_1000_weight,
1791 dust_limit_satoshis,
1792 max_htlc_value_in_flight_msat,
1798 revocation_basepoint,
1800 delayed_payment_basepoint,
1802 first_per_commitment_point,
1803 second_per_commitment_point,
1806 (0, shutdown_scriptpubkey, option),
1807 (1, channel_type, option),
1808 (2, require_confirmed_inputs, option),
1811 #[cfg(not(taproot))]
1812 impl_writeable_msg!(RevokeAndACK, {
1814 per_commitment_secret,
1815 next_per_commitment_point
1819 impl_writeable_msg!(RevokeAndACK, {
1821 per_commitment_secret,
1822 next_per_commitment_point
1824 (4, next_local_nonce, option)
1827 impl_writeable_msg!(Shutdown, {
1832 impl_writeable_msg!(UpdateFailHTLC, {
1838 impl_writeable_msg!(UpdateFailMalformedHTLC, {
1845 impl_writeable_msg!(UpdateFee, {
1850 impl_writeable_msg!(UpdateFulfillHTLC, {
1856 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
1857 // serialization format in a way which assumes we know the total serialized length/message end
1859 impl_writeable!(OnionErrorPacket, {
1863 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
1864 // serialization format in a way which assumes we know the total serialized length/message end
1866 impl Writeable for OnionPacket {
1867 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1868 self.version.write(w)?;
1869 match self.public_key {
1870 Ok(pubkey) => pubkey.write(w)?,
1871 Err(_) => [0u8;33].write(w)?,
1873 w.write_all(&self.hop_data)?;
1874 self.hmac.write(w)?;
1879 impl Readable for OnionPacket {
1880 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1882 version: Readable::read(r)?,
1884 let mut buf = [0u8;33];
1885 r.read_exact(&mut buf)?;
1886 PublicKey::from_slice(&buf)
1888 hop_data: Readable::read(r)?,
1889 hmac: Readable::read(r)?,
1894 impl_writeable_msg!(UpdateAddHTLC, {
1900 onion_routing_packet
1903 impl Readable for OnionMessage {
1904 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1905 let blinding_point: PublicKey = Readable::read(r)?;
1906 let len: u16 = Readable::read(r)?;
1907 let mut packet_reader = FixedLengthReader::new(r, len as u64);
1908 let onion_routing_packet: onion_message::Packet = <onion_message::Packet as LengthReadable>::read(&mut packet_reader)?;
1911 onion_routing_packet,
1916 impl Writeable for OnionMessage {
1917 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1918 self.blinding_point.write(w)?;
1919 let onion_packet_len = self.onion_routing_packet.serialized_length();
1920 (onion_packet_len as u16).write(w)?;
1921 self.onion_routing_packet.write(w)?;
1926 impl Writeable for FinalOnionHopData {
1927 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1928 self.payment_secret.0.write(w)?;
1929 HighZeroBytesDroppedBigSize(self.total_msat).write(w)
1933 impl Readable for FinalOnionHopData {
1934 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1935 let secret: [u8; 32] = Readable::read(r)?;
1936 let amt: HighZeroBytesDroppedBigSize<u64> = Readable::read(r)?;
1937 Ok(Self { payment_secret: PaymentSecret(secret), total_msat: amt.0 })
1941 impl Writeable for OnionHopData {
1942 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1944 OnionHopDataFormat::NonFinalNode { short_channel_id } => {
1945 _encode_varint_length_prefixed_tlv!(w, {
1946 (2, HighZeroBytesDroppedBigSize(self.amt_to_forward), required),
1947 (4, HighZeroBytesDroppedBigSize(self.outgoing_cltv_value), required),
1948 (6, short_channel_id, required)
1951 OnionHopDataFormat::FinalNode { ref payment_data, ref payment_metadata, ref keysend_preimage } => {
1952 _encode_varint_length_prefixed_tlv!(w, {
1953 (2, HighZeroBytesDroppedBigSize(self.amt_to_forward), required),
1954 (4, HighZeroBytesDroppedBigSize(self.outgoing_cltv_value), required),
1955 (8, payment_data, option),
1956 (16, payment_metadata.as_ref().map(|m| WithoutLength(m)), option),
1957 (5482373484, keysend_preimage, option)
1965 impl Readable for OnionHopData {
1966 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1967 let mut amt = HighZeroBytesDroppedBigSize(0u64);
1968 let mut cltv_value = HighZeroBytesDroppedBigSize(0u32);
1969 let mut short_id: Option<u64> = None;
1970 let mut payment_data: Option<FinalOnionHopData> = None;
1971 let mut payment_metadata: Option<WithoutLength<Vec<u8>>> = None;
1972 let mut keysend_preimage: Option<PaymentPreimage> = None;
1973 read_tlv_fields!(r, {
1975 (4, cltv_value, required),
1976 (6, short_id, option),
1977 (8, payment_data, option),
1978 (16, payment_metadata, option),
1979 // See https://github.com/lightning/blips/blob/master/blip-0003.md
1980 (5482373484, keysend_preimage, option)
1983 let format = if let Some(short_channel_id) = short_id {
1984 if payment_data.is_some() { return Err(DecodeError::InvalidValue); }
1985 if payment_metadata.is_some() { return Err(DecodeError::InvalidValue); }
1986 OnionHopDataFormat::NonFinalNode {
1990 if let Some(data) = &payment_data {
1991 if data.total_msat > MAX_VALUE_MSAT {
1992 return Err(DecodeError::InvalidValue);
1995 OnionHopDataFormat::FinalNode {
1997 payment_metadata: payment_metadata.map(|w| w.0),
2002 if amt.0 > MAX_VALUE_MSAT {
2003 return Err(DecodeError::InvalidValue);
2007 amt_to_forward: amt.0,
2008 outgoing_cltv_value: cltv_value.0,
2013 // ReadableArgs because we need onion_utils::decode_next_hop to accommodate payment packets and
2014 // onion message packets.
2015 impl ReadableArgs<()> for OnionHopData {
2016 fn read<R: Read>(r: &mut R, _arg: ()) -> Result<Self, DecodeError> {
2017 <Self as Readable>::read(r)
2021 impl Writeable for Ping {
2022 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2023 self.ponglen.write(w)?;
2024 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2029 impl Readable for Ping {
2030 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2032 ponglen: Readable::read(r)?,
2034 let byteslen = Readable::read(r)?;
2035 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2042 impl Writeable for Pong {
2043 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2044 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2049 impl Readable for Pong {
2050 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2053 let byteslen = Readable::read(r)?;
2054 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2061 impl Writeable for UnsignedChannelAnnouncement {
2062 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2063 self.features.write(w)?;
2064 self.chain_hash.write(w)?;
2065 self.short_channel_id.write(w)?;
2066 self.node_id_1.write(w)?;
2067 self.node_id_2.write(w)?;
2068 self.bitcoin_key_1.write(w)?;
2069 self.bitcoin_key_2.write(w)?;
2070 w.write_all(&self.excess_data[..])?;
2075 impl Readable for UnsignedChannelAnnouncement {
2076 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2078 features: Readable::read(r)?,
2079 chain_hash: Readable::read(r)?,
2080 short_channel_id: Readable::read(r)?,
2081 node_id_1: Readable::read(r)?,
2082 node_id_2: Readable::read(r)?,
2083 bitcoin_key_1: Readable::read(r)?,
2084 bitcoin_key_2: Readable::read(r)?,
2085 excess_data: read_to_end(r)?,
2090 impl_writeable!(ChannelAnnouncement, {
2093 bitcoin_signature_1,
2094 bitcoin_signature_2,
2098 impl Writeable for UnsignedChannelUpdate {
2099 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2100 // `message_flags` used to indicate presence of `htlc_maximum_msat`, but was deprecated in the spec.
2101 const MESSAGE_FLAGS: u8 = 1;
2102 self.chain_hash.write(w)?;
2103 self.short_channel_id.write(w)?;
2104 self.timestamp.write(w)?;
2105 let all_flags = self.flags as u16 | ((MESSAGE_FLAGS as u16) << 8);
2106 all_flags.write(w)?;
2107 self.cltv_expiry_delta.write(w)?;
2108 self.htlc_minimum_msat.write(w)?;
2109 self.fee_base_msat.write(w)?;
2110 self.fee_proportional_millionths.write(w)?;
2111 self.htlc_maximum_msat.write(w)?;
2112 w.write_all(&self.excess_data[..])?;
2117 impl Readable for UnsignedChannelUpdate {
2118 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2120 chain_hash: Readable::read(r)?,
2121 short_channel_id: Readable::read(r)?,
2122 timestamp: Readable::read(r)?,
2124 let flags: u16 = Readable::read(r)?;
2125 // Note: we ignore the `message_flags` for now, since it was deprecated by the spec.
2128 cltv_expiry_delta: Readable::read(r)?,
2129 htlc_minimum_msat: Readable::read(r)?,
2130 fee_base_msat: Readable::read(r)?,
2131 fee_proportional_millionths: Readable::read(r)?,
2132 htlc_maximum_msat: Readable::read(r)?,
2133 excess_data: read_to_end(r)?,
2138 impl_writeable!(ChannelUpdate, {
2143 impl Writeable for ErrorMessage {
2144 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2145 self.channel_id.write(w)?;
2146 (self.data.len() as u16).write(w)?;
2147 w.write_all(self.data.as_bytes())?;
2152 impl Readable for ErrorMessage {
2153 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2155 channel_id: Readable::read(r)?,
2157 let sz: usize = <u16 as Readable>::read(r)? as usize;
2158 let mut data = Vec::with_capacity(sz);
2160 r.read_exact(&mut data)?;
2161 match String::from_utf8(data) {
2163 Err(_) => return Err(DecodeError::InvalidValue),
2170 impl Writeable for WarningMessage {
2171 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2172 self.channel_id.write(w)?;
2173 (self.data.len() as u16).write(w)?;
2174 w.write_all(self.data.as_bytes())?;
2179 impl Readable for WarningMessage {
2180 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2182 channel_id: Readable::read(r)?,
2184 let sz: usize = <u16 as Readable>::read(r)? as usize;
2185 let mut data = Vec::with_capacity(sz);
2187 r.read_exact(&mut data)?;
2188 match String::from_utf8(data) {
2190 Err(_) => return Err(DecodeError::InvalidValue),
2197 impl Writeable for UnsignedNodeAnnouncement {
2198 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2199 self.features.write(w)?;
2200 self.timestamp.write(w)?;
2201 self.node_id.write(w)?;
2202 w.write_all(&self.rgb)?;
2203 self.alias.write(w)?;
2205 let mut addr_len = 0;
2206 for addr in self.addresses.iter() {
2207 addr_len += 1 + addr.len();
2209 (addr_len + self.excess_address_data.len() as u16).write(w)?;
2210 for addr in self.addresses.iter() {
2213 w.write_all(&self.excess_address_data[..])?;
2214 w.write_all(&self.excess_data[..])?;
2219 impl Readable for UnsignedNodeAnnouncement {
2220 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2221 let features: NodeFeatures = Readable::read(r)?;
2222 let timestamp: u32 = Readable::read(r)?;
2223 let node_id: NodeId = Readable::read(r)?;
2224 let mut rgb = [0; 3];
2225 r.read_exact(&mut rgb)?;
2226 let alias: NodeAlias = Readable::read(r)?;
2228 let addr_len: u16 = Readable::read(r)?;
2229 let mut addresses: Vec<NetAddress> = Vec::new();
2230 let mut addr_readpos = 0;
2231 let mut excess = false;
2232 let mut excess_byte = 0;
2234 if addr_len <= addr_readpos { break; }
2235 match Readable::read(r) {
2237 if addr_len < addr_readpos + 1 + addr.len() {
2238 return Err(DecodeError::BadLengthDescriptor);
2240 addr_readpos += (1 + addr.len()) as u16;
2241 addresses.push(addr);
2243 Ok(Err(unknown_descriptor)) => {
2245 excess_byte = unknown_descriptor;
2248 Err(DecodeError::ShortRead) => return Err(DecodeError::BadLengthDescriptor),
2249 Err(e) => return Err(e),
2253 let mut excess_data = vec![];
2254 let excess_address_data = if addr_readpos < addr_len {
2255 let mut excess_address_data = vec![0; (addr_len - addr_readpos) as usize];
2256 r.read_exact(&mut excess_address_data[if excess { 1 } else { 0 }..])?;
2258 excess_address_data[0] = excess_byte;
2263 excess_data.push(excess_byte);
2267 excess_data.extend(read_to_end(r)?.iter());
2268 Ok(UnsignedNodeAnnouncement {
2275 excess_address_data,
2281 impl_writeable!(NodeAnnouncement, {
2286 impl Readable for QueryShortChannelIds {
2287 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2288 let chain_hash: BlockHash = Readable::read(r)?;
2290 let encoding_len: u16 = Readable::read(r)?;
2291 let encoding_type: u8 = Readable::read(r)?;
2293 // Must be encoding_type=0 uncompressed serialization. We do not
2294 // support encoding_type=1 zlib serialization.
2295 if encoding_type != EncodingType::Uncompressed as u8 {
2296 return Err(DecodeError::UnsupportedCompression);
2299 // We expect the encoding_len to always includes the 1-byte
2300 // encoding_type and that short_channel_ids are 8-bytes each
2301 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2302 return Err(DecodeError::InvalidValue);
2305 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2306 // less the 1-byte encoding_type
2307 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2308 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2309 for _ in 0..short_channel_id_count {
2310 short_channel_ids.push(Readable::read(r)?);
2313 Ok(QueryShortChannelIds {
2320 impl Writeable for QueryShortChannelIds {
2321 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2322 // Calculated from 1-byte encoding_type plus 8-bytes per short_channel_id
2323 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2325 self.chain_hash.write(w)?;
2326 encoding_len.write(w)?;
2328 // We only support type=0 uncompressed serialization
2329 (EncodingType::Uncompressed as u8).write(w)?;
2331 for scid in self.short_channel_ids.iter() {
2339 impl_writeable_msg!(ReplyShortChannelIdsEnd, {
2344 impl QueryChannelRange {
2345 /// Calculates the overflow safe ending block height for the query.
2347 /// Overflow returns `0xffffffff`, otherwise returns `first_blocknum + number_of_blocks`.
2348 pub fn end_blocknum(&self) -> u32 {
2349 match self.first_blocknum.checked_add(self.number_of_blocks) {
2350 Some(block) => block,
2351 None => u32::max_value(),
2356 impl_writeable_msg!(QueryChannelRange, {
2362 impl Readable for ReplyChannelRange {
2363 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2364 let chain_hash: BlockHash = Readable::read(r)?;
2365 let first_blocknum: u32 = Readable::read(r)?;
2366 let number_of_blocks: u32 = Readable::read(r)?;
2367 let sync_complete: bool = Readable::read(r)?;
2369 let encoding_len: u16 = Readable::read(r)?;
2370 let encoding_type: u8 = Readable::read(r)?;
2372 // Must be encoding_type=0 uncompressed serialization. We do not
2373 // support encoding_type=1 zlib serialization.
2374 if encoding_type != EncodingType::Uncompressed as u8 {
2375 return Err(DecodeError::UnsupportedCompression);
2378 // We expect the encoding_len to always includes the 1-byte
2379 // encoding_type and that short_channel_ids are 8-bytes each
2380 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2381 return Err(DecodeError::InvalidValue);
2384 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2385 // less the 1-byte encoding_type
2386 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2387 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2388 for _ in 0..short_channel_id_count {
2389 short_channel_ids.push(Readable::read(r)?);
2392 Ok(ReplyChannelRange {
2402 impl Writeable for ReplyChannelRange {
2403 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2404 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2405 self.chain_hash.write(w)?;
2406 self.first_blocknum.write(w)?;
2407 self.number_of_blocks.write(w)?;
2408 self.sync_complete.write(w)?;
2410 encoding_len.write(w)?;
2411 (EncodingType::Uncompressed as u8).write(w)?;
2412 for scid in self.short_channel_ids.iter() {
2420 impl_writeable_msg!(GossipTimestampFilter, {
2428 use bitcoin::blockdata::constants::ChainHash;
2429 use bitcoin::{Transaction, PackedLockTime, TxIn, Script, Sequence, Witness, TxOut};
2431 use crate::ln::{PaymentPreimage, PaymentHash, PaymentSecret};
2432 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
2433 use crate::ln::msgs::{self, FinalOnionHopData, OnionErrorPacket, OnionHopDataFormat};
2434 use crate::routing::gossip::{NodeAlias, NodeId};
2435 use crate::util::ser::{Writeable, Readable, Hostname, TransactionU16LenLimited};
2437 use bitcoin::hashes::hex::FromHex;
2438 use bitcoin::util::address::Address;
2439 use bitcoin::network::constants::Network;
2440 use bitcoin::blockdata::script::Builder;
2441 use bitcoin::blockdata::opcodes;
2442 use bitcoin::hash_types::{Txid, BlockHash};
2444 use bitcoin::secp256k1::{PublicKey,SecretKey};
2445 use bitcoin::secp256k1::{Secp256k1, Message};
2447 use crate::io::{self, Cursor};
2448 use crate::prelude::*;
2449 use core::convert::TryFrom;
2450 use core::str::FromStr;
2452 use crate::chain::transaction::OutPoint;
2455 fn encoding_channel_reestablish() {
2457 let secp_ctx = Secp256k1::new();
2458 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2461 let cr = msgs::ChannelReestablish {
2462 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],
2463 next_local_commitment_number: 3,
2464 next_remote_commitment_number: 4,
2465 your_last_per_commitment_secret: [9;32],
2466 my_current_per_commitment_point: public_key,
2467 next_funding_txid: None,
2470 let encoded_value = cr.encode();
2474 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
2475 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2476 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2477 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
2478 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
2484 fn encoding_channel_reestablish_with_next_funding_txid() {
2486 let secp_ctx = Secp256k1::new();
2487 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2490 let cr = msgs::ChannelReestablish {
2491 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],
2492 next_local_commitment_number: 3,
2493 next_remote_commitment_number: 4,
2494 your_last_per_commitment_secret: [9;32],
2495 my_current_per_commitment_point: public_key,
2496 next_funding_txid: Some(Txid::from_hash(bitcoin::hashes::Hash::from_slice(&[
2497 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,
2501 let encoded_value = cr.encode();
2505 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
2506 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2507 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2508 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
2509 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
2510 0, // Type (next_funding_txid)
2512 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
2517 macro_rules! get_keys_from {
2518 ($slice: expr, $secp_ctx: expr) => {
2520 let privkey = SecretKey::from_slice(&hex::decode($slice).unwrap()[..]).unwrap();
2521 let pubkey = PublicKey::from_secret_key(&$secp_ctx, &privkey);
2527 macro_rules! get_sig_on {
2528 ($privkey: expr, $ctx: expr, $string: expr) => {
2530 let sighash = Message::from_slice(&$string.into_bytes()[..]).unwrap();
2531 $ctx.sign_ecdsa(&sighash, &$privkey)
2537 fn encoding_announcement_signatures() {
2538 let secp_ctx = Secp256k1::new();
2539 let (privkey, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2540 let sig_1 = get_sig_on!(privkey, secp_ctx, String::from("01010101010101010101010101010101"));
2541 let sig_2 = get_sig_on!(privkey, secp_ctx, String::from("02020202020202020202020202020202"));
2542 let announcement_signatures = msgs::AnnouncementSignatures {
2543 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],
2544 short_channel_id: 2316138423780173,
2545 node_signature: sig_1,
2546 bitcoin_signature: sig_2,
2549 let encoded_value = announcement_signatures.encode();
2550 assert_eq!(encoded_value, hex::decode("040000000000000005000000000000000600000000000000070000000000000000083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073acf9953cef4700860f5967838eba2bae89288ad188ebf8b20bf995c3ea53a26df1876d0a3a0e13172ba286a673140190c02ba9da60a2e43a745188c8a83c7f3ef").unwrap());
2553 fn do_encoding_channel_announcement(unknown_features_bits: bool, excess_data: bool) {
2554 let secp_ctx = Secp256k1::new();
2555 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2556 let (privkey_2, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2557 let (privkey_3, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2558 let (privkey_4, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2559 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2560 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
2561 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
2562 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
2563 let mut features = ChannelFeatures::empty();
2564 if unknown_features_bits {
2565 features = ChannelFeatures::from_le_bytes(vec![0xFF, 0xFF]);
2567 let unsigned_channel_announcement = msgs::UnsignedChannelAnnouncement {
2569 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2570 short_channel_id: 2316138423780173,
2571 node_id_1: NodeId::from_pubkey(&pubkey_1),
2572 node_id_2: NodeId::from_pubkey(&pubkey_2),
2573 bitcoin_key_1: NodeId::from_pubkey(&pubkey_3),
2574 bitcoin_key_2: NodeId::from_pubkey(&pubkey_4),
2575 excess_data: if excess_data { vec![10, 0, 0, 20, 0, 0, 30, 0, 0, 40] } else { Vec::new() },
2577 let channel_announcement = msgs::ChannelAnnouncement {
2578 node_signature_1: sig_1,
2579 node_signature_2: sig_2,
2580 bitcoin_signature_1: sig_3,
2581 bitcoin_signature_2: sig_4,
2582 contents: unsigned_channel_announcement,
2584 let encoded_value = channel_announcement.encode();
2585 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a1735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap();
2586 if unknown_features_bits {
2587 target_value.append(&mut hex::decode("0002ffff").unwrap());
2589 target_value.append(&mut hex::decode("0000").unwrap());
2591 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2592 target_value.append(&mut hex::decode("00083a840000034d031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
2594 target_value.append(&mut hex::decode("0a00001400001e000028").unwrap());
2596 assert_eq!(encoded_value, target_value);
2600 fn encoding_channel_announcement() {
2601 do_encoding_channel_announcement(true, false);
2602 do_encoding_channel_announcement(false, true);
2603 do_encoding_channel_announcement(false, false);
2604 do_encoding_channel_announcement(true, true);
2607 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) {
2608 let secp_ctx = Secp256k1::new();
2609 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2610 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2611 let features = if unknown_features_bits {
2612 NodeFeatures::from_le_bytes(vec![0xFF, 0xFF])
2614 // Set to some features we may support
2615 NodeFeatures::from_le_bytes(vec![2 | 1 << 5])
2617 let mut addresses = Vec::new();
2619 addresses.push(msgs::NetAddress::IPv4 {
2620 addr: [255, 254, 253, 252],
2625 addresses.push(msgs::NetAddress::IPv6 {
2626 addr: [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240],
2631 addresses.push(msgs::NetAddress::OnionV2(
2632 [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 38, 7]
2636 addresses.push(msgs::NetAddress::OnionV3 {
2637 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],
2644 addresses.push(msgs::NetAddress::Hostname {
2645 hostname: Hostname::try_from(String::from("host")).unwrap(),
2649 let mut addr_len = 0;
2650 for addr in &addresses {
2651 addr_len += addr.len() + 1;
2653 let unsigned_node_announcement = msgs::UnsignedNodeAnnouncement {
2655 timestamp: 20190119,
2656 node_id: NodeId::from_pubkey(&pubkey_1),
2658 alias: NodeAlias([16;32]),
2660 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() },
2661 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() },
2663 addr_len += unsigned_node_announcement.excess_address_data.len() as u16;
2664 let node_announcement = msgs::NodeAnnouncement {
2666 contents: unsigned_node_announcement,
2668 let encoded_value = node_announcement.encode();
2669 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
2670 if unknown_features_bits {
2671 target_value.append(&mut hex::decode("0002ffff").unwrap());
2673 target_value.append(&mut hex::decode("000122").unwrap());
2675 target_value.append(&mut hex::decode("013413a7031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f2020201010101010101010101010101010101010101010101010101010101010101010").unwrap());
2676 target_value.append(&mut vec![(addr_len >> 8) as u8, addr_len as u8]);
2678 target_value.append(&mut hex::decode("01fffefdfc2607").unwrap());
2681 target_value.append(&mut hex::decode("02fffefdfcfbfaf9f8f7f6f5f4f3f2f1f02607").unwrap());
2684 target_value.append(&mut hex::decode("03fffefdfcfbfaf9f8f7f62607").unwrap());
2687 target_value.append(&mut hex::decode("04fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0efeeedecebeae9e8e7e6e5e4e3e2e1e00020102607").unwrap());
2690 target_value.append(&mut hex::decode("0504686f73742607").unwrap());
2692 if excess_address_data {
2693 target_value.append(&mut hex::decode("216c280b5395a2546e7e4b2663e04f811622f15a4f92e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d269").unwrap());
2696 target_value.append(&mut hex::decode("3b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
2698 assert_eq!(encoded_value, target_value);
2702 fn encoding_node_announcement() {
2703 do_encoding_node_announcement(true, true, true, true, true, true, true, true);
2704 do_encoding_node_announcement(false, false, false, false, false, false, false, false);
2705 do_encoding_node_announcement(false, true, false, false, false, false, false, false);
2706 do_encoding_node_announcement(false, false, true, false, false, false, false, false);
2707 do_encoding_node_announcement(false, false, false, true, false, false, false, false);
2708 do_encoding_node_announcement(false, false, false, false, true, false, false, false);
2709 do_encoding_node_announcement(false, false, false, false, false, true, false, false);
2710 do_encoding_node_announcement(false, false, false, false, false, false, true, false);
2711 do_encoding_node_announcement(false, true, false, true, false, false, true, false);
2712 do_encoding_node_announcement(false, false, true, false, true, false, false, false);
2715 fn do_encoding_channel_update(direction: bool, disable: bool, excess_data: bool) {
2716 let secp_ctx = Secp256k1::new();
2717 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2718 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2719 let unsigned_channel_update = msgs::UnsignedChannelUpdate {
2720 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2721 short_channel_id: 2316138423780173,
2722 timestamp: 20190119,
2723 flags: if direction { 1 } else { 0 } | if disable { 1 << 1 } else { 0 },
2724 cltv_expiry_delta: 144,
2725 htlc_minimum_msat: 1000000,
2726 htlc_maximum_msat: 131355275467161,
2727 fee_base_msat: 10000,
2728 fee_proportional_millionths: 20,
2729 excess_data: if excess_data { vec![0, 0, 0, 0, 59, 154, 202, 0] } else { Vec::new() }
2731 let channel_update = msgs::ChannelUpdate {
2733 contents: unsigned_channel_update
2735 let encoded_value = channel_update.encode();
2736 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
2737 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2738 target_value.append(&mut hex::decode("00083a840000034d013413a7").unwrap());
2739 target_value.append(&mut hex::decode("01").unwrap());
2740 target_value.append(&mut hex::decode("00").unwrap());
2742 let flag = target_value.last_mut().unwrap();
2746 let flag = target_value.last_mut().unwrap();
2747 *flag = *flag | 1 << 1;
2749 target_value.append(&mut hex::decode("009000000000000f42400000271000000014").unwrap());
2750 target_value.append(&mut hex::decode("0000777788889999").unwrap());
2752 target_value.append(&mut hex::decode("000000003b9aca00").unwrap());
2754 assert_eq!(encoded_value, target_value);
2758 fn encoding_channel_update() {
2759 do_encoding_channel_update(false, false, false);
2760 do_encoding_channel_update(false, false, true);
2761 do_encoding_channel_update(true, false, false);
2762 do_encoding_channel_update(true, false, true);
2763 do_encoding_channel_update(false, true, false);
2764 do_encoding_channel_update(false, true, true);
2765 do_encoding_channel_update(true, true, false);
2766 do_encoding_channel_update(true, true, true);
2769 fn do_encoding_open_channel(random_bit: bool, shutdown: bool, incl_chan_type: bool) {
2770 let secp_ctx = Secp256k1::new();
2771 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2772 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2773 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2774 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2775 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
2776 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
2777 let open_channel = msgs::OpenChannel {
2778 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2779 temporary_channel_id: [2; 32],
2780 funding_satoshis: 1311768467284833366,
2781 push_msat: 2536655962884945560,
2782 dust_limit_satoshis: 3608586615801332854,
2783 max_htlc_value_in_flight_msat: 8517154655701053848,
2784 channel_reserve_satoshis: 8665828695742877976,
2785 htlc_minimum_msat: 2316138423780173,
2786 feerate_per_kw: 821716,
2787 to_self_delay: 49340,
2788 max_accepted_htlcs: 49340,
2789 funding_pubkey: pubkey_1,
2790 revocation_basepoint: pubkey_2,
2791 payment_point: pubkey_3,
2792 delayed_payment_basepoint: pubkey_4,
2793 htlc_basepoint: pubkey_5,
2794 first_per_commitment_point: pubkey_6,
2795 channel_flags: if random_bit { 1 << 5 } else { 0 },
2796 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
2797 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
2799 let encoded_value = open_channel.encode();
2800 let mut target_value = Vec::new();
2801 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2802 target_value.append(&mut hex::decode("02020202020202020202020202020202020202020202020202020202020202021234567890123456233403289122369832144668701144767633030896203198784335490624111800083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
2804 target_value.append(&mut hex::decode("20").unwrap());
2806 target_value.append(&mut hex::decode("00").unwrap());
2809 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
2812 target_value.append(&mut hex::decode("0100").unwrap());
2814 assert_eq!(encoded_value, target_value);
2818 fn encoding_open_channel() {
2819 do_encoding_open_channel(false, false, false);
2820 do_encoding_open_channel(false, false, true);
2821 do_encoding_open_channel(false, true, false);
2822 do_encoding_open_channel(false, true, true);
2823 do_encoding_open_channel(true, false, false);
2824 do_encoding_open_channel(true, false, true);
2825 do_encoding_open_channel(true, true, false);
2826 do_encoding_open_channel(true, true, true);
2829 fn do_encoding_open_channelv2(random_bit: bool, shutdown: bool, incl_chan_type: bool, require_confirmed_inputs: bool) {
2830 let secp_ctx = Secp256k1::new();
2831 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2832 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2833 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2834 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2835 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
2836 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
2837 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
2838 let open_channelv2 = msgs::OpenChannelV2 {
2839 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2840 temporary_channel_id: [2; 32],
2841 funding_feerate_sat_per_1000_weight: 821716,
2842 commitment_feerate_sat_per_1000_weight: 821716,
2843 funding_satoshis: 1311768467284833366,
2844 dust_limit_satoshis: 3608586615801332854,
2845 max_htlc_value_in_flight_msat: 8517154655701053848,
2846 htlc_minimum_msat: 2316138423780173,
2847 to_self_delay: 49340,
2848 max_accepted_htlcs: 49340,
2849 locktime: 305419896,
2850 funding_pubkey: pubkey_1,
2851 revocation_basepoint: pubkey_2,
2852 payment_basepoint: pubkey_3,
2853 delayed_payment_basepoint: pubkey_4,
2854 htlc_basepoint: pubkey_5,
2855 first_per_commitment_point: pubkey_6,
2856 second_per_commitment_point: pubkey_7,
2857 channel_flags: if random_bit { 1 << 5 } else { 0 },
2858 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
2859 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
2860 require_confirmed_inputs: if require_confirmed_inputs { Some(()) } else { None },
2862 let encoded_value = open_channelv2.encode();
2863 let mut target_value = Vec::new();
2864 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2865 target_value.append(&mut hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap());
2866 target_value.append(&mut hex::decode("000c89d4").unwrap());
2867 target_value.append(&mut hex::decode("000c89d4").unwrap());
2868 target_value.append(&mut hex::decode("1234567890123456").unwrap());
2869 target_value.append(&mut hex::decode("3214466870114476").unwrap());
2870 target_value.append(&mut hex::decode("7633030896203198").unwrap());
2871 target_value.append(&mut hex::decode("00083a840000034d").unwrap());
2872 target_value.append(&mut hex::decode("c0bc").unwrap());
2873 target_value.append(&mut hex::decode("c0bc").unwrap());
2874 target_value.append(&mut hex::decode("12345678").unwrap());
2875 target_value.append(&mut hex::decode("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap());
2876 target_value.append(&mut hex::decode("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap());
2877 target_value.append(&mut hex::decode("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap());
2878 target_value.append(&mut hex::decode("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
2879 target_value.append(&mut hex::decode("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap());
2880 target_value.append(&mut hex::decode("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
2881 target_value.append(&mut hex::decode("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap());
2884 target_value.append(&mut hex::decode("20").unwrap());
2886 target_value.append(&mut hex::decode("00").unwrap());
2889 target_value.append(&mut hex::decode("001b").unwrap()); // Type 0 + Length 27
2890 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
2893 target_value.append(&mut hex::decode("0100").unwrap());
2895 if require_confirmed_inputs {
2896 target_value.append(&mut hex::decode("0200").unwrap());
2898 assert_eq!(encoded_value, target_value);
2902 fn encoding_open_channelv2() {
2903 do_encoding_open_channelv2(false, false, false, false);
2904 do_encoding_open_channelv2(false, false, false, true);
2905 do_encoding_open_channelv2(false, false, true, false);
2906 do_encoding_open_channelv2(false, false, true, true);
2907 do_encoding_open_channelv2(false, true, false, false);
2908 do_encoding_open_channelv2(false, true, false, true);
2909 do_encoding_open_channelv2(false, true, true, false);
2910 do_encoding_open_channelv2(false, true, true, true);
2911 do_encoding_open_channelv2(true, false, false, false);
2912 do_encoding_open_channelv2(true, false, false, true);
2913 do_encoding_open_channelv2(true, false, true, false);
2914 do_encoding_open_channelv2(true, false, true, true);
2915 do_encoding_open_channelv2(true, true, false, false);
2916 do_encoding_open_channelv2(true, true, false, true);
2917 do_encoding_open_channelv2(true, true, true, false);
2918 do_encoding_open_channelv2(true, true, true, true);
2921 fn do_encoding_accept_channel(shutdown: bool) {
2922 let secp_ctx = Secp256k1::new();
2923 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2924 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2925 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2926 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2927 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
2928 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
2929 let accept_channel = msgs::AcceptChannel {
2930 temporary_channel_id: [2; 32],
2931 dust_limit_satoshis: 1311768467284833366,
2932 max_htlc_value_in_flight_msat: 2536655962884945560,
2933 channel_reserve_satoshis: 3608586615801332854,
2934 htlc_minimum_msat: 2316138423780173,
2935 minimum_depth: 821716,
2936 to_self_delay: 49340,
2937 max_accepted_htlcs: 49340,
2938 funding_pubkey: pubkey_1,
2939 revocation_basepoint: pubkey_2,
2940 payment_point: pubkey_3,
2941 delayed_payment_basepoint: pubkey_4,
2942 htlc_basepoint: pubkey_5,
2943 first_per_commitment_point: pubkey_6,
2944 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
2947 next_local_nonce: None,
2949 let encoded_value = accept_channel.encode();
2950 let mut target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020212345678901234562334032891223698321446687011447600083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap();
2952 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
2954 assert_eq!(encoded_value, target_value);
2958 fn encoding_accept_channel() {
2959 do_encoding_accept_channel(false);
2960 do_encoding_accept_channel(true);
2963 fn do_encoding_accept_channelv2(shutdown: bool) {
2964 let secp_ctx = Secp256k1::new();
2965 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2966 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2967 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2968 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2969 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
2970 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
2971 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
2972 let accept_channelv2 = msgs::AcceptChannelV2 {
2973 temporary_channel_id: [2; 32],
2974 funding_satoshis: 1311768467284833366,
2975 dust_limit_satoshis: 1311768467284833366,
2976 max_htlc_value_in_flight_msat: 2536655962884945560,
2977 htlc_minimum_msat: 2316138423780173,
2978 minimum_depth: 821716,
2979 to_self_delay: 49340,
2980 max_accepted_htlcs: 49340,
2981 funding_pubkey: pubkey_1,
2982 revocation_basepoint: pubkey_2,
2983 payment_basepoint: pubkey_3,
2984 delayed_payment_basepoint: pubkey_4,
2985 htlc_basepoint: pubkey_5,
2986 first_per_commitment_point: pubkey_6,
2987 second_per_commitment_point: pubkey_7,
2988 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
2990 require_confirmed_inputs: None,
2992 let encoded_value = accept_channelv2.encode();
2993 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // temporary_channel_id
2994 target_value.append(&mut hex::decode("1234567890123456").unwrap()); // funding_satoshis
2995 target_value.append(&mut hex::decode("1234567890123456").unwrap()); // dust_limit_satoshis
2996 target_value.append(&mut hex::decode("2334032891223698").unwrap()); // max_htlc_value_in_flight_msat
2997 target_value.append(&mut hex::decode("00083a840000034d").unwrap()); // htlc_minimum_msat
2998 target_value.append(&mut hex::decode("000c89d4").unwrap()); // minimum_depth
2999 target_value.append(&mut hex::decode("c0bc").unwrap()); // to_self_delay
3000 target_value.append(&mut hex::decode("c0bc").unwrap()); // max_accepted_htlcs
3001 target_value.append(&mut hex::decode("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap()); // funding_pubkey
3002 target_value.append(&mut hex::decode("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap()); // revocation_basepoint
3003 target_value.append(&mut hex::decode("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap()); // payment_basepoint
3004 target_value.append(&mut hex::decode("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap()); // delayed_payment_basepoint
3005 target_value.append(&mut hex::decode("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap()); // htlc_basepoint
3006 target_value.append(&mut hex::decode("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap()); // first_per_commitment_point
3007 target_value.append(&mut hex::decode("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap()); // second_per_commitment_point
3009 target_value.append(&mut hex::decode("001b").unwrap()); // Type 0 + Length 27
3010 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3012 assert_eq!(encoded_value, target_value);
3016 fn encoding_accept_channelv2() {
3017 do_encoding_accept_channelv2(false);
3018 do_encoding_accept_channelv2(true);
3022 fn encoding_funding_created() {
3023 let secp_ctx = Secp256k1::new();
3024 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3025 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3026 let funding_created = msgs::FundingCreated {
3027 temporary_channel_id: [2; 32],
3028 funding_txid: Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3029 funding_output_index: 255,
3032 partial_signature_with_nonce: None,
3034 next_local_nonce: None,
3036 let encoded_value = funding_created.encode();
3037 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202026e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c200ffd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3038 assert_eq!(encoded_value, target_value);
3042 fn encoding_funding_signed() {
3043 let secp_ctx = Secp256k1::new();
3044 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3045 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3046 let funding_signed = msgs::FundingSigned {
3047 channel_id: [2; 32],
3050 partial_signature_with_nonce: None,
3052 let encoded_value = funding_signed.encode();
3053 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3054 assert_eq!(encoded_value, target_value);
3058 fn encoding_channel_ready() {
3059 let secp_ctx = Secp256k1::new();
3060 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3061 let channel_ready = msgs::ChannelReady {
3062 channel_id: [2; 32],
3063 next_per_commitment_point: pubkey_1,
3064 short_channel_id_alias: None,
3066 let encoded_value = channel_ready.encode();
3067 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3068 assert_eq!(encoded_value, target_value);
3072 fn encoding_tx_add_input() {
3073 let tx_add_input = msgs::TxAddInput {
3074 channel_id: [2; 32],
3075 serial_id: 4886718345,
3076 prevtx: TransactionU16LenLimited::new(Transaction {
3078 lock_time: PackedLockTime(0),
3080 previous_output: OutPoint { txid: Txid::from_hex("305bab643ee297b8b6b76b320792c8223d55082122cb606bf89382146ced9c77").unwrap(), index: 2 }.into_bitcoin_outpoint(),
3081 script_sig: Script::new(),
3082 sequence: Sequence(0xfffffffd),
3083 witness: Witness::from_vec(vec![
3084 hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3085 hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3090 script_pubkey: Address::from_str("bc1qzlffunw52jav8vwdu5x3jfk6sr8u22rmq3xzw2").unwrap().script_pubkey(),
3094 script_pubkey: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().script_pubkey(),
3098 prevtx_out: 305419896,
3099 sequence: 305419896,
3101 let encoded_value = tx_add_input.encode();
3102 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000000012345678900de02000000000101779ced6c148293f86b60cb222108553d22c89207326bb7b6b897e23e64ab5b300200000000fdffffff0236dbc1000000000016001417d29e4dd454bac3b1cde50d1926da80cfc5287b9cbd03000000000016001436ec78d514df462da95e6a00c24daa8915362d420247304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701210301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944000000001234567812345678").unwrap();
3103 assert_eq!(encoded_value, target_value);
3107 fn encoding_tx_add_output() {
3108 let tx_add_output = msgs::TxAddOutput {
3109 channel_id: [2; 32],
3110 serial_id: 4886718345,
3112 script: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().script_pubkey(),
3114 let encoded_value = tx_add_output.encode();
3115 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000000012345678900000001234567890016001436ec78d514df462da95e6a00c24daa8915362d42").unwrap();
3116 assert_eq!(encoded_value, target_value);
3120 fn encoding_tx_remove_input() {
3121 let tx_remove_input = msgs::TxRemoveInput {
3122 channel_id: [2; 32],
3123 serial_id: 4886718345,
3125 let encoded_value = tx_remove_input.encode();
3126 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3127 assert_eq!(encoded_value, target_value);
3131 fn encoding_tx_remove_output() {
3132 let tx_remove_output = msgs::TxRemoveOutput {
3133 channel_id: [2; 32],
3134 serial_id: 4886718345,
3136 let encoded_value = tx_remove_output.encode();
3137 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3138 assert_eq!(encoded_value, target_value);
3142 fn encoding_tx_complete() {
3143 let tx_complete = msgs::TxComplete {
3144 channel_id: [2; 32],
3146 let encoded_value = tx_complete.encode();
3147 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3148 assert_eq!(encoded_value, target_value);
3152 fn encoding_tx_signatures() {
3153 let tx_signatures = msgs::TxSignatures {
3154 channel_id: [2; 32],
3155 tx_hash: Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3157 Witness::from_vec(vec![
3158 hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3159 hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3160 Witness::from_vec(vec![
3161 hex::decode("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap(),
3162 hex::decode("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap()]),
3165 let encoded_value = tx_signatures.encode();
3166 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3167 target_value.append(&mut hex::decode("6e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c2").unwrap()); // tx_hash (sha256) (big endian byte order)
3168 target_value.append(&mut hex::decode("0002").unwrap()); // num_witnesses (u16)
3170 target_value.append(&mut hex::decode("006b").unwrap()); // len of witness_data
3171 target_value.append(&mut hex::decode("02").unwrap()); // num_witness_elements (VarInt)
3172 target_value.append(&mut hex::decode("47").unwrap()); // len of witness element data (VarInt)
3173 target_value.append(&mut hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap());
3174 target_value.append(&mut hex::decode("21").unwrap()); // len of witness element data (VarInt)
3175 target_value.append(&mut hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap());
3177 target_value.append(&mut hex::decode("006c").unwrap()); // len of witness_data
3178 target_value.append(&mut hex::decode("02").unwrap()); // num_witness_elements (VarInt)
3179 target_value.append(&mut hex::decode("48").unwrap()); // len of witness element data (VarInt)
3180 target_value.append(&mut hex::decode("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap());
3181 target_value.append(&mut hex::decode("21").unwrap()); // len of witness element data (VarInt)
3182 target_value.append(&mut hex::decode("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap());
3183 assert_eq!(encoded_value, target_value);
3186 fn do_encoding_tx_init_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3187 let tx_init_rbf = msgs::TxInitRbf {
3188 channel_id: [2; 32],
3189 locktime: 305419896,
3190 feerate_sat_per_1000_weight: 20190119,
3191 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3193 let encoded_value = tx_init_rbf.encode();
3194 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3195 target_value.append(&mut hex::decode("12345678").unwrap()); // locktime
3196 target_value.append(&mut hex::decode("013413a7").unwrap()); // feerate_sat_per_1000_weight
3197 if let Some((_, target)) = funding_value_with_hex_target {
3198 target_value.push(0x00); // Type
3199 target_value.push(target.len() as u8 / 2); // Length
3200 target_value.append(&mut hex::decode(target).unwrap()); // Value (i64)
3202 assert_eq!(encoded_value, target_value);
3206 fn encoding_tx_init_rbf() {
3207 do_encoding_tx_init_rbf(Some((1311768467284833366, "1234567890123456")));
3208 do_encoding_tx_init_rbf(Some((13117684672, "000000030DDFFBC0")));
3209 do_encoding_tx_init_rbf(None);
3212 fn do_encoding_tx_ack_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3213 let tx_ack_rbf = msgs::TxAckRbf {
3214 channel_id: [2; 32],
3215 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3217 let encoded_value = tx_ack_rbf.encode();
3218 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3219 if let Some((_, target)) = funding_value_with_hex_target {
3220 target_value.push(0x00); // Type
3221 target_value.push(target.len() as u8 / 2); // Length
3222 target_value.append(&mut hex::decode(target).unwrap()); // Value (i64)
3224 assert_eq!(encoded_value, target_value);
3228 fn encoding_tx_ack_rbf() {
3229 do_encoding_tx_ack_rbf(Some((1311768467284833366, "1234567890123456")));
3230 do_encoding_tx_ack_rbf(Some((13117684672, "000000030DDFFBC0")));
3231 do_encoding_tx_ack_rbf(None);
3235 fn encoding_tx_abort() {
3236 let tx_abort = msgs::TxAbort {
3237 channel_id: [2; 32],
3238 data: hex::decode("54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap(),
3240 let encoded_value = tx_abort.encode();
3241 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202002C54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap();
3242 assert_eq!(encoded_value, target_value);
3245 fn do_encoding_shutdown(script_type: u8) {
3246 let secp_ctx = Secp256k1::new();
3247 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3248 let script = Builder::new().push_opcode(opcodes::OP_TRUE).into_script();
3249 let shutdown = msgs::Shutdown {
3250 channel_id: [2; 32],
3252 if script_type == 1 { Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey() }
3253 else if script_type == 2 { Address::p2sh(&script, Network::Testnet).unwrap().script_pubkey() }
3254 else if script_type == 3 { Address::p2wpkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).unwrap().script_pubkey() }
3255 else { Address::p2wsh(&script, Network::Testnet).script_pubkey() },
3257 let encoded_value = shutdown.encode();
3258 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3259 if script_type == 1 {
3260 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3261 } else if script_type == 2 {
3262 target_value.append(&mut hex::decode("0017a914da1745e9b549bd0bfa1a569971c77eba30cd5a4b87").unwrap());
3263 } else if script_type == 3 {
3264 target_value.append(&mut hex::decode("0016001479b000887626b294a914501a4cd226b58b235983").unwrap());
3265 } else if script_type == 4 {
3266 target_value.append(&mut hex::decode("002200204ae81572f06e1b88fd5ced7a1a000945432e83e1551e6f721ee9c00b8cc33260").unwrap());
3268 assert_eq!(encoded_value, target_value);
3272 fn encoding_shutdown() {
3273 do_encoding_shutdown(1);
3274 do_encoding_shutdown(2);
3275 do_encoding_shutdown(3);
3276 do_encoding_shutdown(4);
3280 fn encoding_closing_signed() {
3281 let secp_ctx = Secp256k1::new();
3282 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3283 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3284 let closing_signed = msgs::ClosingSigned {
3285 channel_id: [2; 32],
3286 fee_satoshis: 2316138423780173,
3290 let encoded_value = closing_signed.encode();
3291 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3292 assert_eq!(encoded_value, target_value);
3293 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value)).unwrap(), closing_signed);
3295 let closing_signed_with_range = msgs::ClosingSigned {
3296 channel_id: [2; 32],
3297 fee_satoshis: 2316138423780173,
3299 fee_range: Some(msgs::ClosingSignedFeeRange {
3300 min_fee_satoshis: 0xdeadbeef,
3301 max_fee_satoshis: 0x1badcafe01234567,
3304 let encoded_value_with_range = closing_signed_with_range.encode();
3305 let target_value_with_range = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a011000000000deadbeef1badcafe01234567").unwrap();
3306 assert_eq!(encoded_value_with_range, target_value_with_range);
3307 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value_with_range)).unwrap(),
3308 closing_signed_with_range);
3312 fn encoding_update_add_htlc() {
3313 let secp_ctx = Secp256k1::new();
3314 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3315 let onion_routing_packet = msgs::OnionPacket {
3317 public_key: Ok(pubkey_1),
3318 hop_data: [1; 20*65],
3321 let update_add_htlc = msgs::UpdateAddHTLC {
3322 channel_id: [2; 32],
3323 htlc_id: 2316138423780173,
3324 amount_msat: 3608586615801332854,
3325 payment_hash: PaymentHash([1; 32]),
3326 cltv_expiry: 821716,
3327 onion_routing_packet
3329 let encoded_value = update_add_htlc.encode();
3330 let target_value = hex::decode("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").unwrap();
3331 assert_eq!(encoded_value, target_value);
3335 fn encoding_update_fulfill_htlc() {
3336 let update_fulfill_htlc = msgs::UpdateFulfillHTLC {
3337 channel_id: [2; 32],
3338 htlc_id: 2316138423780173,
3339 payment_preimage: PaymentPreimage([1; 32]),
3341 let encoded_value = update_fulfill_htlc.encode();
3342 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d0101010101010101010101010101010101010101010101010101010101010101").unwrap();
3343 assert_eq!(encoded_value, target_value);
3347 fn encoding_update_fail_htlc() {
3348 let reason = OnionErrorPacket {
3349 data: [1; 32].to_vec(),
3351 let update_fail_htlc = msgs::UpdateFailHTLC {
3352 channel_id: [2; 32],
3353 htlc_id: 2316138423780173,
3356 let encoded_value = update_fail_htlc.encode();
3357 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d00200101010101010101010101010101010101010101010101010101010101010101").unwrap();
3358 assert_eq!(encoded_value, target_value);
3362 fn encoding_update_fail_malformed_htlc() {
3363 let update_fail_malformed_htlc = msgs::UpdateFailMalformedHTLC {
3364 channel_id: [2; 32],
3365 htlc_id: 2316138423780173,
3366 sha256_of_onion: [1; 32],
3369 let encoded_value = update_fail_malformed_htlc.encode();
3370 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d010101010101010101010101010101010101010101010101010101010101010100ff").unwrap();
3371 assert_eq!(encoded_value, target_value);
3374 fn do_encoding_commitment_signed(htlcs: bool) {
3375 let secp_ctx = Secp256k1::new();
3376 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3377 let (privkey_2, _) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3378 let (privkey_3, _) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3379 let (privkey_4, _) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3380 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3381 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
3382 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
3383 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
3384 let commitment_signed = msgs::CommitmentSigned {
3385 channel_id: [2; 32],
3387 htlc_signatures: if htlcs { vec![sig_2, sig_3, sig_4] } else { Vec::new() },
3389 partial_signature_with_nonce: None,
3391 let encoded_value = commitment_signed.encode();
3392 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3394 target_value.append(&mut hex::decode("00031735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
3396 target_value.append(&mut hex::decode("0000").unwrap());
3398 assert_eq!(encoded_value, target_value);
3402 fn encoding_commitment_signed() {
3403 do_encoding_commitment_signed(true);
3404 do_encoding_commitment_signed(false);
3408 fn encoding_revoke_and_ack() {
3409 let secp_ctx = Secp256k1::new();
3410 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3411 let raa = msgs::RevokeAndACK {
3412 channel_id: [2; 32],
3413 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],
3414 next_per_commitment_point: pubkey_1,
3416 next_local_nonce: None,
3418 let encoded_value = raa.encode();
3419 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020101010101010101010101010101010101010101010101010101010101010101031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3420 assert_eq!(encoded_value, target_value);
3424 fn encoding_update_fee() {
3425 let update_fee = msgs::UpdateFee {
3426 channel_id: [2; 32],
3427 feerate_per_kw: 20190119,
3429 let encoded_value = update_fee.encode();
3430 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202013413a7").unwrap();
3431 assert_eq!(encoded_value, target_value);
3435 fn encoding_init() {
3436 let mainnet_hash = ChainHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap();
3437 assert_eq!(msgs::Init {
3438 features: InitFeatures::from_le_bytes(vec![0xFF, 0xFF, 0xFF]),
3439 networks: Some(vec![mainnet_hash]),
3440 remote_network_address: None,
3441 }.encode(), hex::decode("00023fff0003ffffff01206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3442 assert_eq!(msgs::Init {
3443 features: InitFeatures::from_le_bytes(vec![0xFF]),
3445 remote_network_address: None,
3446 }.encode(), hex::decode("0001ff0001ff").unwrap());
3447 assert_eq!(msgs::Init {
3448 features: InitFeatures::from_le_bytes(vec![]),
3449 networks: Some(vec![mainnet_hash]),
3450 remote_network_address: None,
3451 }.encode(), hex::decode("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3452 assert_eq!(msgs::Init {
3453 features: InitFeatures::from_le_bytes(vec![]),
3454 networks: Some(vec![ChainHash::from(&[1; 32][..]), ChainHash::from(&[2; 32][..])]),
3455 remote_network_address: None,
3456 }.encode(), hex::decode("00000000014001010101010101010101010101010101010101010101010101010101010101010202020202020202020202020202020202020202020202020202020202020202").unwrap());
3457 let init_msg = msgs::Init { features: InitFeatures::from_le_bytes(vec![]),
3458 networks: Some(vec![mainnet_hash]),
3459 remote_network_address: Some(msgs::NetAddress::IPv4 {
3460 addr: [127, 0, 0, 1],
3464 let encoded_value = init_msg.encode();
3465 let target_value = hex::decode("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d61900000000000307017f00000103e8").unwrap();
3466 assert_eq!(encoded_value, target_value);
3467 assert_eq!(msgs::Init::read(&mut Cursor::new(&target_value)).unwrap(), init_msg);
3471 fn encoding_error() {
3472 let error = msgs::ErrorMessage {
3473 channel_id: [2; 32],
3474 data: String::from("rust-lightning"),
3476 let encoded_value = error.encode();
3477 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3478 assert_eq!(encoded_value, target_value);
3482 fn encoding_warning() {
3483 let error = msgs::WarningMessage {
3484 channel_id: [2; 32],
3485 data: String::from("rust-lightning"),
3487 let encoded_value = error.encode();
3488 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3489 assert_eq!(encoded_value, target_value);
3493 fn encoding_ping() {
3494 let ping = msgs::Ping {
3498 let encoded_value = ping.encode();
3499 let target_value = hex::decode("0040004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3500 assert_eq!(encoded_value, target_value);
3504 fn encoding_pong() {
3505 let pong = msgs::Pong {
3508 let encoded_value = pong.encode();
3509 let target_value = hex::decode("004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3510 assert_eq!(encoded_value, target_value);
3514 fn encoding_nonfinal_onion_hop_data() {
3515 let mut msg = msgs::OnionHopData {
3516 format: OnionHopDataFormat::NonFinalNode {
3517 short_channel_id: 0xdeadbeef1bad1dea,
3519 amt_to_forward: 0x0badf00d01020304,
3520 outgoing_cltv_value: 0xffffffff,
3522 let encoded_value = msg.encode();
3523 let target_value = hex::decode("1a02080badf00d010203040404ffffffff0608deadbeef1bad1dea").unwrap();
3524 assert_eq!(encoded_value, target_value);
3525 msg = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3526 if let OnionHopDataFormat::NonFinalNode { short_channel_id } = msg.format {
3527 assert_eq!(short_channel_id, 0xdeadbeef1bad1dea);
3528 } else { panic!(); }
3529 assert_eq!(msg.amt_to_forward, 0x0badf00d01020304);
3530 assert_eq!(msg.outgoing_cltv_value, 0xffffffff);
3534 fn encoding_final_onion_hop_data() {
3535 let mut msg = msgs::OnionHopData {
3536 format: OnionHopDataFormat::FinalNode {
3538 payment_metadata: None,
3539 keysend_preimage: None,
3541 amt_to_forward: 0x0badf00d01020304,
3542 outgoing_cltv_value: 0xffffffff,
3544 let encoded_value = msg.encode();
3545 let target_value = hex::decode("1002080badf00d010203040404ffffffff").unwrap();
3546 assert_eq!(encoded_value, target_value);
3547 msg = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3548 if let OnionHopDataFormat::FinalNode { payment_data: None, .. } = msg.format { } else { panic!(); }
3549 assert_eq!(msg.amt_to_forward, 0x0badf00d01020304);
3550 assert_eq!(msg.outgoing_cltv_value, 0xffffffff);
3554 fn encoding_final_onion_hop_data_with_secret() {
3555 let expected_payment_secret = PaymentSecret([0x42u8; 32]);
3556 let mut msg = msgs::OnionHopData {
3557 format: OnionHopDataFormat::FinalNode {
3558 payment_data: Some(FinalOnionHopData {
3559 payment_secret: expected_payment_secret,
3560 total_msat: 0x1badca1f
3562 payment_metadata: None,
3563 keysend_preimage: None,
3565 amt_to_forward: 0x0badf00d01020304,
3566 outgoing_cltv_value: 0xffffffff,
3568 let encoded_value = msg.encode();
3569 let target_value = hex::decode("3602080badf00d010203040404ffffffff082442424242424242424242424242424242424242424242424242424242424242421badca1f").unwrap();
3570 assert_eq!(encoded_value, target_value);
3571 msg = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3572 if let OnionHopDataFormat::FinalNode {
3573 payment_data: Some(FinalOnionHopData {
3575 total_msat: 0x1badca1f
3577 payment_metadata: None,
3578 keysend_preimage: None,
3580 assert_eq!(payment_secret, expected_payment_secret);
3581 } else { panic!(); }
3582 assert_eq!(msg.amt_to_forward, 0x0badf00d01020304);
3583 assert_eq!(msg.outgoing_cltv_value, 0xffffffff);
3587 fn query_channel_range_end_blocknum() {
3588 let tests: Vec<(u32, u32, u32)> = vec![
3589 (10000, 1500, 11500),
3590 (0, 0xffffffff, 0xffffffff),
3591 (1, 0xffffffff, 0xffffffff),
3594 for (first_blocknum, number_of_blocks, expected) in tests.into_iter() {
3595 let sut = msgs::QueryChannelRange {
3596 chain_hash: BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap(),
3600 assert_eq!(sut.end_blocknum(), expected);
3605 fn encoding_query_channel_range() {
3606 let mut query_channel_range = msgs::QueryChannelRange {
3607 chain_hash: BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap(),
3608 first_blocknum: 100000,
3609 number_of_blocks: 1500,
3611 let encoded_value = query_channel_range.encode();
3612 let target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206000186a0000005dc").unwrap();
3613 assert_eq!(encoded_value, target_value);
3615 query_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3616 assert_eq!(query_channel_range.first_blocknum, 100000);
3617 assert_eq!(query_channel_range.number_of_blocks, 1500);
3621 fn encoding_reply_channel_range() {
3622 do_encoding_reply_channel_range(0);
3623 do_encoding_reply_channel_range(1);
3626 fn do_encoding_reply_channel_range(encoding_type: u8) {
3627 let mut target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206000b8a06000005dc01").unwrap();
3628 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3629 let mut reply_channel_range = msgs::ReplyChannelRange {
3630 chain_hash: expected_chain_hash,
3631 first_blocknum: 756230,
3632 number_of_blocks: 1500,
3633 sync_complete: true,
3634 short_channel_ids: vec![0x000000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
3637 if encoding_type == 0 {
3638 target_value.append(&mut hex::decode("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
3639 let encoded_value = reply_channel_range.encode();
3640 assert_eq!(encoded_value, target_value);
3642 reply_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3643 assert_eq!(reply_channel_range.chain_hash, expected_chain_hash);
3644 assert_eq!(reply_channel_range.first_blocknum, 756230);
3645 assert_eq!(reply_channel_range.number_of_blocks, 1500);
3646 assert_eq!(reply_channel_range.sync_complete, true);
3647 assert_eq!(reply_channel_range.short_channel_ids[0], 0x000000000000008e);
3648 assert_eq!(reply_channel_range.short_channel_ids[1], 0x0000000000003c69);
3649 assert_eq!(reply_channel_range.short_channel_ids[2], 0x000000000045a6c4);
3651 target_value.append(&mut hex::decode("001601789c636000833e08659309a65878be010010a9023a").unwrap());
3652 let result: Result<msgs::ReplyChannelRange, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
3653 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
3658 fn encoding_query_short_channel_ids() {
3659 do_encoding_query_short_channel_ids(0);
3660 do_encoding_query_short_channel_ids(1);
3663 fn do_encoding_query_short_channel_ids(encoding_type: u8) {
3664 let mut target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206").unwrap();
3665 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3666 let mut query_short_channel_ids = msgs::QueryShortChannelIds {
3667 chain_hash: expected_chain_hash,
3668 short_channel_ids: vec![0x0000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
3671 if encoding_type == 0 {
3672 target_value.append(&mut hex::decode("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
3673 let encoded_value = query_short_channel_ids.encode();
3674 assert_eq!(encoded_value, target_value);
3676 query_short_channel_ids = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3677 assert_eq!(query_short_channel_ids.chain_hash, expected_chain_hash);
3678 assert_eq!(query_short_channel_ids.short_channel_ids[0], 0x000000000000008e);
3679 assert_eq!(query_short_channel_ids.short_channel_ids[1], 0x0000000000003c69);
3680 assert_eq!(query_short_channel_ids.short_channel_ids[2], 0x000000000045a6c4);
3682 target_value.append(&mut hex::decode("001601789c636000833e08659309a65878be010010a9023a").unwrap());
3683 let result: Result<msgs::QueryShortChannelIds, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
3684 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
3689 fn encoding_reply_short_channel_ids_end() {
3690 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3691 let mut reply_short_channel_ids_end = msgs::ReplyShortChannelIdsEnd {
3692 chain_hash: expected_chain_hash,
3693 full_information: true,
3695 let encoded_value = reply_short_channel_ids_end.encode();
3696 let target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e220601").unwrap();
3697 assert_eq!(encoded_value, target_value);
3699 reply_short_channel_ids_end = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3700 assert_eq!(reply_short_channel_ids_end.chain_hash, expected_chain_hash);
3701 assert_eq!(reply_short_channel_ids_end.full_information, true);
3705 fn encoding_gossip_timestamp_filter(){
3706 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3707 let mut gossip_timestamp_filter = msgs::GossipTimestampFilter {
3708 chain_hash: expected_chain_hash,
3709 first_timestamp: 1590000000,
3710 timestamp_range: 0xffff_ffff,
3712 let encoded_value = gossip_timestamp_filter.encode();
3713 let target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e22065ec57980ffffffff").unwrap();
3714 assert_eq!(encoded_value, target_value);
3716 gossip_timestamp_filter = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3717 assert_eq!(gossip_timestamp_filter.chain_hash, expected_chain_hash);
3718 assert_eq!(gossip_timestamp_filter.first_timestamp, 1590000000);
3719 assert_eq!(gossip_timestamp_filter.timestamp_range, 0xffff_ffff);
3723 fn decode_onion_hop_data_len_as_bigsize() {
3724 // Tests that we can decode an onion payload that is >253 bytes.
3725 // Previously, receiving a payload of this size could've caused us to fail to decode a valid
3726 // payload, because we were decoding the length (a BigSize, big-endian) as a VarInt
3729 // Encode a test onion payload with a big custom TLV such that it's >253 bytes, forcing the
3730 // payload length to be encoded over multiple bytes rather than a single u8.
3731 let big_payload = encode_big_payload().unwrap();
3732 let mut rd = Cursor::new(&big_payload[..]);
3733 <msgs::OnionHopData as Readable>::read(&mut rd).unwrap();
3735 // see above test, needs to be a separate method for use of the serialization macros.
3736 fn encode_big_payload() -> Result<Vec<u8>, io::Error> {
3737 use crate::util::ser::HighZeroBytesDroppedBigSize;
3738 let payload = msgs::OnionHopData {
3739 format: OnionHopDataFormat::NonFinalNode {
3740 short_channel_id: 0xdeadbeef1bad1dea,
3742 amt_to_forward: 1000,
3743 outgoing_cltv_value: 0xffffffff,
3745 let mut encoded_payload = Vec::new();
3746 let test_bytes = vec![42u8; 1000];
3747 if let OnionHopDataFormat::NonFinalNode { short_channel_id } = payload.format {
3748 _encode_varint_length_prefixed_tlv!(&mut encoded_payload, {
3749 (1, test_bytes, vec_type),
3750 (2, HighZeroBytesDroppedBigSize(payload.amt_to_forward), required),
3751 (4, HighZeroBytesDroppedBigSize(payload.outgoing_cltv_value), required),
3752 (6, short_channel_id, required)