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::{ChannelId, PaymentPreimage, PaymentHash, PaymentSecret};
35 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
36 use crate::ln::onion_utils;
37 use crate::onion_message;
39 use crate::prelude::*;
42 use crate::io::{self, Read};
43 use crate::io_extras::read_to_end;
45 use crate::events::{MessageSendEventsProvider, OnionMessageProvider};
46 use crate::util::logger;
47 use crate::util::ser::{LengthReadable, Readable, ReadableArgs, Writeable, Writer, WithoutLength, FixedLengthReader, HighZeroBytesDroppedBigSize, Hostname, TransactionU16LenLimited, BigSize};
49 use crate::routing::gossip::{NodeAlias, NodeId};
51 /// 21 million * 10^8 * 1000
52 pub(crate) const MAX_VALUE_MSAT: u64 = 21_000_000_0000_0000_000;
55 /// A partial signature that also contains the Musig2 nonce its signer used
56 #[derive(Clone, Debug, PartialEq, Eq)]
57 pub struct PartialSignatureWithNonce(pub musig2::types::PartialSignature, pub musig2::types::PublicNonce);
59 /// An error in decoding a message or struct.
60 #[derive(Clone, Debug, PartialEq, Eq)]
61 pub enum DecodeError {
62 /// A version byte specified something we don't know how to handle.
64 /// Includes unknown realm byte in an onion hop data packet.
66 /// Unknown feature mandating we fail to parse message (e.g., TLV with an even, unknown type)
67 UnknownRequiredFeature,
68 /// Value was invalid.
70 /// For example, a byte which was supposed to be a bool was something other than a 0
71 /// or 1, a public key/private key/signature was invalid, text wasn't UTF-8, TLV was
72 /// syntactically incorrect, etc.
74 /// The buffer to be read was too short.
76 /// A length descriptor in the packet didn't describe the later data correctly.
78 /// Error from [`std::io`].
80 /// The message included zlib-compressed values, which we don't support.
81 UnsupportedCompression,
84 /// An [`init`] message to be sent to or received from a peer.
86 /// [`init`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-init-message
87 #[derive(Clone, Debug, PartialEq, Eq)]
89 /// The relevant features which the sender supports.
90 pub features: InitFeatures,
91 /// Indicates chains the sender is interested in.
93 /// If there are no common chains, the connection will be closed.
94 pub networks: Option<Vec<ChainHash>>,
95 /// The receipient's network address.
97 /// This adds the option to report a remote IP address back to a connecting peer using the init
98 /// message. A node can decide to use that information to discover a potential update to its
99 /// public IPv4 address (NAT) and use that for a [`NodeAnnouncement`] update message containing
101 pub remote_network_address: Option<NetAddress>,
104 /// An [`error`] message to be sent to or received from a peer.
106 /// [`error`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-error-and-warning-messages
107 #[derive(Clone, Debug, PartialEq, Eq)]
108 pub struct ErrorMessage {
109 /// The channel ID involved in the error.
111 /// All-0s indicates a general error unrelated to a specific channel, after which all channels
112 /// with the sending peer should be closed.
113 pub channel_id: ChannelId,
114 /// A possibly human-readable error description.
116 /// The string should be sanitized before it is used (e.g., emitted to logs or printed to
117 /// `stdout`). Otherwise, a well crafted error message may trigger a security vulnerability in
118 /// the terminal emulator or the logging subsystem.
122 /// A [`warning`] message to be sent to or received from a peer.
124 /// [`warning`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-error-and-warning-messages
125 #[derive(Clone, Debug, PartialEq, Eq)]
126 pub struct WarningMessage {
127 /// The channel ID involved in the warning.
129 /// All-0s indicates a warning unrelated to a specific channel.
130 pub channel_id: ChannelId,
131 /// A possibly human-readable warning description.
133 /// The string should be sanitized before it is used (e.g. emitted to logs or printed to
134 /// stdout). Otherwise, a well crafted error message may trigger a security vulnerability in
135 /// the terminal emulator or the logging subsystem.
139 /// A [`ping`] message to be sent to or received from a peer.
141 /// [`ping`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-ping-and-pong-messages
142 #[derive(Clone, Debug, PartialEq, Eq)]
144 /// The desired response length.
146 /// The ping packet size.
148 /// This field is not sent on the wire. byteslen zeros are sent.
152 /// A [`pong`] message to be sent to or received from a peer.
154 /// [`pong`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-ping-and-pong-messages
155 #[derive(Clone, Debug, PartialEq, Eq)]
157 /// The pong packet size.
159 /// This field is not sent on the wire. byteslen zeros are sent.
163 /// An [`open_channel`] message to be sent to or received from a peer.
165 /// Used in V1 channel establishment
167 /// [`open_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-open_channel-message
168 #[derive(Clone, Debug, PartialEq, Eq)]
169 pub struct OpenChannel {
170 /// The genesis hash of the blockchain where the channel is to be opened
171 pub chain_hash: BlockHash,
172 /// A temporary channel ID, until the funding outpoint is announced
173 pub temporary_channel_id: ChannelId,
174 /// The channel value
175 pub funding_satoshis: u64,
176 /// The amount to push to the counterparty as part of the open, in milli-satoshi
178 /// The threshold below which outputs on transactions broadcast by sender will be omitted
179 pub dust_limit_satoshis: u64,
180 /// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
181 pub max_htlc_value_in_flight_msat: u64,
182 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
183 pub channel_reserve_satoshis: u64,
184 /// The minimum HTLC size incoming to sender, in milli-satoshi
185 pub htlc_minimum_msat: u64,
186 /// The feerate per 1000-weight of sender generated transactions, until updated by
188 pub feerate_per_kw: u32,
189 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if
190 /// they broadcast a commitment transaction
191 pub to_self_delay: u16,
192 /// The maximum number of inbound HTLCs towards sender
193 pub max_accepted_htlcs: u16,
194 /// The sender's key controlling the funding transaction
195 pub funding_pubkey: PublicKey,
196 /// Used to derive a revocation key for transactions broadcast by counterparty
197 pub revocation_basepoint: PublicKey,
198 /// A payment key to sender for transactions broadcast by counterparty
199 pub payment_point: PublicKey,
200 /// Used to derive a payment key to sender for transactions broadcast by sender
201 pub delayed_payment_basepoint: PublicKey,
202 /// Used to derive an HTLC payment key to sender
203 pub htlc_basepoint: PublicKey,
204 /// The first to-be-broadcast-by-sender transaction's per commitment point
205 pub first_per_commitment_point: PublicKey,
206 /// The channel flags to be used
207 pub channel_flags: u8,
208 /// A request to pre-set the to-sender output's `scriptPubkey` for when we collaboratively close
209 pub shutdown_scriptpubkey: Option<Script>,
210 /// The channel type that this channel will represent
212 /// If this is `None`, we derive the channel type from the intersection of our
213 /// feature bits with our counterparty's feature bits from the [`Init`] message.
214 pub channel_type: Option<ChannelTypeFeatures>,
217 /// An open_channel2 message to be sent by or received from the channel initiator.
219 /// Used in V2 channel establishment
221 // TODO(dual_funding): Add spec link for `open_channel2`.
222 #[derive(Clone, Debug, PartialEq, Eq)]
223 pub struct OpenChannelV2 {
224 /// The genesis hash of the blockchain where the channel is to be opened
225 pub chain_hash: BlockHash,
226 /// A temporary channel ID derived using a zeroed out value for the channel acceptor's revocation basepoint
227 pub temporary_channel_id: ChannelId,
228 /// The feerate for the funding transaction set by the channel initiator
229 pub funding_feerate_sat_per_1000_weight: u32,
230 /// The feerate for the commitment transaction set by the channel initiator
231 pub commitment_feerate_sat_per_1000_weight: u32,
232 /// Part of the channel value contributed by the channel initiator
233 pub funding_satoshis: u64,
234 /// The threshold below which outputs on transactions broadcast by the channel initiator will be
236 pub dust_limit_satoshis: u64,
237 /// The maximum inbound HTLC value in flight towards channel initiator, in milli-satoshi
238 pub max_htlc_value_in_flight_msat: u64,
239 /// The minimum HTLC size incoming to channel initiator, in milli-satoshi
240 pub htlc_minimum_msat: u64,
241 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
242 /// broadcast a commitment transaction
243 pub to_self_delay: u16,
244 /// The maximum number of inbound HTLCs towards channel initiator
245 pub max_accepted_htlcs: u16,
246 /// The locktime for the funding transaction
248 /// The channel initiator's key controlling the funding transaction
249 pub funding_pubkey: PublicKey,
250 /// Used to derive a revocation key for transactions broadcast by counterparty
251 pub revocation_basepoint: PublicKey,
252 /// A payment key to channel initiator for transactions broadcast by counterparty
253 pub payment_basepoint: PublicKey,
254 /// Used to derive a payment key to channel initiator for transactions broadcast by channel
256 pub delayed_payment_basepoint: PublicKey,
257 /// Used to derive an HTLC payment key to channel initiator
258 pub htlc_basepoint: PublicKey,
259 /// The first to-be-broadcast-by-channel-initiator transaction's per commitment point
260 pub first_per_commitment_point: PublicKey,
261 /// The second to-be-broadcast-by-channel-initiator transaction's per commitment point
262 pub second_per_commitment_point: PublicKey,
264 pub channel_flags: u8,
265 /// Optionally, a request to pre-set the to-channel-initiator output's scriptPubkey for when we
266 /// collaboratively close
267 pub shutdown_scriptpubkey: Option<Script>,
268 /// The channel type that this channel will represent. If none is set, we derive the channel
269 /// type from the intersection of our feature bits with our counterparty's feature bits from
270 /// the Init message.
271 pub channel_type: Option<ChannelTypeFeatures>,
272 /// Optionally, a requirement that only confirmed inputs can be added
273 pub require_confirmed_inputs: Option<()>,
276 /// An [`accept_channel`] message to be sent to or received from a peer.
278 /// Used in V1 channel establishment
280 /// [`accept_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-accept_channel-message
281 #[derive(Clone, Debug, PartialEq, Eq)]
282 pub struct AcceptChannel {
283 /// A temporary channel ID, until the funding outpoint is announced
284 pub temporary_channel_id: ChannelId,
285 /// The threshold below which outputs on transactions broadcast by sender will be omitted
286 pub dust_limit_satoshis: u64,
287 /// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
288 pub max_htlc_value_in_flight_msat: u64,
289 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
290 pub channel_reserve_satoshis: u64,
291 /// The minimum HTLC size incoming to sender, in milli-satoshi
292 pub htlc_minimum_msat: u64,
293 /// Minimum depth of the funding transaction before the channel is considered open
294 pub minimum_depth: u32,
295 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they broadcast a commitment transaction
296 pub to_self_delay: u16,
297 /// The maximum number of inbound HTLCs towards sender
298 pub max_accepted_htlcs: u16,
299 /// The sender's key controlling the funding transaction
300 pub funding_pubkey: PublicKey,
301 /// Used to derive a revocation key for transactions broadcast by counterparty
302 pub revocation_basepoint: PublicKey,
303 /// A payment key to sender for transactions broadcast by counterparty
304 pub payment_point: PublicKey,
305 /// Used to derive a payment key to sender for transactions broadcast by sender
306 pub delayed_payment_basepoint: PublicKey,
307 /// Used to derive an HTLC payment key to sender for transactions broadcast by counterparty
308 pub htlc_basepoint: PublicKey,
309 /// The first to-be-broadcast-by-sender transaction's per commitment point
310 pub first_per_commitment_point: PublicKey,
311 /// A request to pre-set the to-sender output's scriptPubkey for when we collaboratively close
312 pub shutdown_scriptpubkey: Option<Script>,
313 /// The channel type that this channel will represent.
315 /// If this is `None`, we derive the channel type from the intersection of
316 /// our feature bits with our counterparty's feature bits from the [`Init`] message.
317 /// This is required to match the equivalent field in [`OpenChannel::channel_type`].
318 pub channel_type: Option<ChannelTypeFeatures>,
320 /// Next nonce the channel initiator should use to create a funding output signature against
321 pub next_local_nonce: Option<musig2::types::PublicNonce>,
324 /// An accept_channel2 message to be sent by or received from the channel accepter.
326 /// Used in V2 channel establishment
328 // TODO(dual_funding): Add spec link for `accept_channel2`.
329 #[derive(Clone, Debug, PartialEq, Eq)]
330 pub struct AcceptChannelV2 {
331 /// The same `temporary_channel_id` received from the initiator's `open_channel2` message.
332 pub temporary_channel_id: ChannelId,
333 /// Part of the channel value contributed by the channel acceptor
334 pub funding_satoshis: u64,
335 /// The threshold below which outputs on transactions broadcast by the channel acceptor will be
337 pub dust_limit_satoshis: u64,
338 /// The maximum inbound HTLC value in flight towards channel acceptor, in milli-satoshi
339 pub max_htlc_value_in_flight_msat: u64,
340 /// The minimum HTLC size incoming to channel acceptor, in milli-satoshi
341 pub htlc_minimum_msat: u64,
342 /// Minimum depth of the funding transaction before the channel is considered open
343 pub minimum_depth: u32,
344 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
345 /// broadcast a commitment transaction
346 pub to_self_delay: u16,
347 /// The maximum number of inbound HTLCs towards channel acceptor
348 pub max_accepted_htlcs: u16,
349 /// The channel acceptor's key controlling the funding transaction
350 pub funding_pubkey: PublicKey,
351 /// Used to derive a revocation key for transactions broadcast by counterparty
352 pub revocation_basepoint: PublicKey,
353 /// A payment key to channel acceptor for transactions broadcast by counterparty
354 pub payment_basepoint: PublicKey,
355 /// Used to derive a payment key to channel acceptor for transactions broadcast by channel
357 pub delayed_payment_basepoint: PublicKey,
358 /// Used to derive an HTLC payment key to channel acceptor for transactions broadcast by counterparty
359 pub htlc_basepoint: PublicKey,
360 /// The first to-be-broadcast-by-channel-acceptor transaction's per commitment point
361 pub first_per_commitment_point: PublicKey,
362 /// The second to-be-broadcast-by-channel-acceptor transaction's per commitment point
363 pub second_per_commitment_point: PublicKey,
364 /// Optionally, a request to pre-set the to-channel-acceptor output's scriptPubkey for when we
365 /// collaboratively close
366 pub shutdown_scriptpubkey: Option<Script>,
367 /// The channel type that this channel will represent. If none is set, we derive the channel
368 /// type from the intersection of our feature bits with our counterparty's feature bits from
369 /// the Init message.
371 /// This is required to match the equivalent field in [`OpenChannelV2::channel_type`].
372 pub channel_type: Option<ChannelTypeFeatures>,
373 /// Optionally, a requirement that only confirmed inputs can be added
374 pub require_confirmed_inputs: Option<()>,
377 /// A [`funding_created`] message to be sent to or received from a peer.
379 /// Used in V1 channel establishment
381 /// [`funding_created`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-funding_created-message
382 #[derive(Clone, Debug, PartialEq, Eq)]
383 pub struct FundingCreated {
384 /// A temporary channel ID, until the funding is established
385 pub temporary_channel_id: ChannelId,
386 /// The funding transaction ID
387 pub funding_txid: Txid,
388 /// The specific output index funding this channel
389 pub funding_output_index: u16,
390 /// The signature of the channel initiator (funder) on the initial commitment transaction
391 pub signature: Signature,
393 /// The partial signature of the channel initiator (funder)
394 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
396 /// Next nonce the channel acceptor should use to finalize the funding output signature
397 pub next_local_nonce: Option<musig2::types::PublicNonce>
400 /// A [`funding_signed`] message to be sent to or received from a peer.
402 /// Used in V1 channel establishment
404 /// [`funding_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-funding_signed-message
405 #[derive(Clone, Debug, PartialEq, Eq)]
406 pub struct FundingSigned {
408 pub channel_id: ChannelId,
409 /// The signature of the channel acceptor (fundee) on the initial commitment transaction
410 pub signature: Signature,
412 /// The partial signature of the channel acceptor (fundee)
413 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
416 /// A [`channel_ready`] message to be sent to or received from a peer.
418 /// [`channel_ready`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-channel_ready-message
419 #[derive(Clone, Debug, PartialEq, Eq)]
420 pub struct ChannelReady {
422 pub channel_id: ChannelId,
423 /// The per-commitment point of the second commitment transaction
424 pub next_per_commitment_point: PublicKey,
425 /// If set, provides a `short_channel_id` alias for this channel.
427 /// The sender will accept payments to be forwarded over this SCID and forward them to this
428 /// messages' recipient.
429 pub short_channel_id_alias: Option<u64>,
432 /// A tx_add_input message for adding an input during interactive transaction construction
434 // TODO(dual_funding): Add spec link for `tx_add_input`.
435 #[derive(Clone, Debug, PartialEq, Eq)]
436 pub struct TxAddInput {
438 pub channel_id: ChannelId,
439 /// A randomly chosen unique identifier for this input, which is even for initiators and odd for
442 /// Serialized transaction that contains the output this input spends to verify that it is non
444 pub prevtx: TransactionU16LenLimited,
445 /// The index of the output being spent
447 /// The sequence number of this input
451 /// A tx_add_output message for adding an output during interactive transaction construction.
453 // TODO(dual_funding): Add spec link for `tx_add_output`.
454 #[derive(Clone, Debug, PartialEq, Eq)]
455 pub struct TxAddOutput {
457 pub channel_id: ChannelId,
458 /// A randomly chosen unique identifier for this output, which is even for initiators and odd for
461 /// The satoshi value of the output
463 /// The scriptPubKey for the output
467 /// A tx_remove_input message for removing an input during interactive transaction construction.
469 // TODO(dual_funding): Add spec link for `tx_remove_input`.
470 #[derive(Clone, Debug, PartialEq, Eq)]
471 pub struct TxRemoveInput {
473 pub channel_id: ChannelId,
474 /// The serial ID of the input to be removed
478 /// A tx_remove_output message for removing an output during interactive transaction construction.
480 // TODO(dual_funding): Add spec link for `tx_remove_output`.
481 #[derive(Clone, Debug, PartialEq, Eq)]
482 pub struct TxRemoveOutput {
484 pub channel_id: ChannelId,
485 /// The serial ID of the output to be removed
489 /// A tx_complete message signalling the conclusion of a peer's transaction contributions during
490 /// interactive transaction construction.
492 // TODO(dual_funding): Add spec link for `tx_complete`.
493 #[derive(Clone, Debug, PartialEq, Eq)]
494 pub struct TxComplete {
496 pub channel_id: ChannelId,
499 /// A tx_signatures message containing the sender's signatures for a transaction constructed with
500 /// interactive transaction construction.
502 // TODO(dual_funding): Add spec link for `tx_signatures`.
503 #[derive(Clone, Debug, PartialEq, Eq)]
504 pub struct TxSignatures {
506 pub channel_id: ChannelId,
509 /// The list of witnesses
510 pub witnesses: Vec<Witness>,
513 /// A tx_init_rbf message which initiates a replacement of the transaction after it's been
516 // TODO(dual_funding): Add spec link for `tx_init_rbf`.
517 #[derive(Clone, Debug, PartialEq, Eq)]
518 pub struct TxInitRbf {
520 pub channel_id: ChannelId,
521 /// The locktime of the transaction
523 /// The feerate of the transaction
524 pub feerate_sat_per_1000_weight: u32,
525 /// The number of satoshis the sender will contribute to or, if negative, remove from
526 /// (e.g. splice-out) the funding output of the transaction
527 pub funding_output_contribution: Option<i64>,
530 /// A tx_ack_rbf message which acknowledges replacement of the transaction after it's been
533 // TODO(dual_funding): Add spec link for `tx_ack_rbf`.
534 #[derive(Clone, Debug, PartialEq, Eq)]
535 pub struct TxAckRbf {
537 pub channel_id: ChannelId,
538 /// The number of satoshis the sender will contribute to or, if negative, remove from
539 /// (e.g. splice-out) the funding output of the transaction
540 pub funding_output_contribution: Option<i64>,
543 /// A tx_abort message which signals the cancellation of an in-progress transaction negotiation.
545 // TODO(dual_funding): Add spec link for `tx_abort`.
546 #[derive(Clone, Debug, PartialEq, Eq)]
549 pub channel_id: ChannelId,
554 /// A [`shutdown`] message to be sent to or received from a peer.
556 /// [`shutdown`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-initiation-shutdown
557 #[derive(Clone, Debug, PartialEq, Eq)]
558 pub struct Shutdown {
560 pub channel_id: ChannelId,
561 /// The destination of this peer's funds on closing.
563 /// Must be in one of these forms: P2PKH, P2SH, P2WPKH, P2WSH, P2TR.
564 pub scriptpubkey: Script,
567 /// The minimum and maximum fees which the sender is willing to place on the closing transaction.
569 /// This is provided in [`ClosingSigned`] by both sides to indicate the fee range they are willing
571 #[derive(Clone, Debug, PartialEq, Eq)]
572 pub struct ClosingSignedFeeRange {
573 /// The minimum absolute fee, in satoshis, which the sender is willing to place on the closing
575 pub min_fee_satoshis: u64,
576 /// The maximum absolute fee, in satoshis, which the sender is willing to place on the closing
578 pub max_fee_satoshis: u64,
581 /// A [`closing_signed`] message to be sent to or received from a peer.
583 /// [`closing_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-negotiation-closing_signed
584 #[derive(Clone, Debug, PartialEq, Eq)]
585 pub struct ClosingSigned {
587 pub channel_id: ChannelId,
588 /// The proposed total fee for the closing transaction
589 pub fee_satoshis: u64,
590 /// A signature on the closing transaction
591 pub signature: Signature,
592 /// The minimum and maximum fees which the sender is willing to accept, provided only by new
594 pub fee_range: Option<ClosingSignedFeeRange>,
597 /// An [`update_add_htlc`] message to be sent to or received from a peer.
599 /// [`update_add_htlc`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#adding-an-htlc-update_add_htlc
600 #[derive(Clone, Debug, PartialEq, Eq)]
601 pub struct UpdateAddHTLC {
603 pub channel_id: ChannelId,
606 /// The HTLC value in milli-satoshi
607 pub amount_msat: u64,
608 /// The payment hash, the pre-image of which controls HTLC redemption
609 pub payment_hash: PaymentHash,
610 /// The expiry height of the HTLC
611 pub cltv_expiry: u32,
612 /// The extra fee skimmed by the sender of this message. See
613 /// [`ChannelConfig::accept_underpaying_htlcs`].
615 /// [`ChannelConfig::accept_underpaying_htlcs`]: crate::util::config::ChannelConfig::accept_underpaying_htlcs
616 pub skimmed_fee_msat: Option<u64>,
617 pub(crate) onion_routing_packet: OnionPacket,
620 /// An onion message to be sent to or received from a peer.
622 // TODO: update with link to OM when they are merged into the BOLTs
623 #[derive(Clone, Debug, PartialEq, Eq)]
624 pub struct OnionMessage {
625 /// Used in decrypting the onion packet's payload.
626 pub blinding_point: PublicKey,
627 pub(crate) onion_routing_packet: onion_message::Packet,
630 /// An [`update_fulfill_htlc`] message to be sent to or received from a peer.
632 /// [`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
633 #[derive(Clone, Debug, PartialEq, Eq)]
634 pub struct UpdateFulfillHTLC {
636 pub channel_id: ChannelId,
639 /// The pre-image of the payment hash, allowing HTLC redemption
640 pub payment_preimage: PaymentPreimage,
643 /// An [`update_fail_htlc`] message to be sent to or received from a peer.
645 /// [`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
646 #[derive(Clone, Debug, PartialEq, Eq)]
647 pub struct UpdateFailHTLC {
649 pub channel_id: ChannelId,
652 pub(crate) reason: OnionErrorPacket,
655 /// An [`update_fail_malformed_htlc`] message to be sent to or received from a peer.
657 /// [`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
658 #[derive(Clone, Debug, PartialEq, Eq)]
659 pub struct UpdateFailMalformedHTLC {
661 pub channel_id: ChannelId,
664 pub(crate) sha256_of_onion: [u8; 32],
666 pub failure_code: u16,
669 /// A [`commitment_signed`] message to be sent to or received from a peer.
671 /// [`commitment_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#committing-updates-so-far-commitment_signed
672 #[derive(Clone, Debug, PartialEq, Eq)]
673 pub struct CommitmentSigned {
675 pub channel_id: ChannelId,
676 /// A signature on the commitment transaction
677 pub signature: Signature,
678 /// Signatures on the HTLC transactions
679 pub htlc_signatures: Vec<Signature>,
681 /// The partial Taproot signature on the commitment transaction
682 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
685 /// A [`revoke_and_ack`] message to be sent to or received from a peer.
687 /// [`revoke_and_ack`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#completing-the-transition-to-the-updated-state-revoke_and_ack
688 #[derive(Clone, Debug, PartialEq, Eq)]
689 pub struct RevokeAndACK {
691 pub channel_id: ChannelId,
692 /// The secret corresponding to the per-commitment point
693 pub per_commitment_secret: [u8; 32],
694 /// The next sender-broadcast commitment transaction's per-commitment point
695 pub next_per_commitment_point: PublicKey,
697 /// Musig nonce the recipient should use in their next commitment signature message
698 pub next_local_nonce: Option<musig2::types::PublicNonce>
701 /// An [`update_fee`] message to be sent to or received from a peer
703 /// [`update_fee`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#updating-fees-update_fee
704 #[derive(Clone, Debug, PartialEq, Eq)]
705 pub struct UpdateFee {
707 pub channel_id: ChannelId,
708 /// Fee rate per 1000-weight of the transaction
709 pub feerate_per_kw: u32,
712 /// A [`channel_reestablish`] message to be sent to or received from a peer.
714 /// [`channel_reestablish`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#message-retransmission
715 #[derive(Clone, Debug, PartialEq, Eq)]
716 pub struct ChannelReestablish {
718 pub channel_id: ChannelId,
719 /// The next commitment number for the sender
720 pub next_local_commitment_number: u64,
721 /// The next commitment number for the recipient
722 pub next_remote_commitment_number: u64,
723 /// Proof that the sender knows the per-commitment secret of a specific commitment transaction
724 /// belonging to the recipient
725 pub your_last_per_commitment_secret: [u8; 32],
726 /// The sender's per-commitment point for their current commitment transaction
727 pub my_current_per_commitment_point: PublicKey,
728 /// The next funding transaction ID
729 pub next_funding_txid: Option<Txid>,
732 /// An [`announcement_signatures`] message to be sent to or received from a peer.
734 /// [`announcement_signatures`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-announcement_signatures-message
735 #[derive(Clone, Debug, PartialEq, Eq)]
736 pub struct AnnouncementSignatures {
738 pub channel_id: ChannelId,
739 /// The short channel ID
740 pub short_channel_id: u64,
741 /// A signature by the node key
742 pub node_signature: Signature,
743 /// A signature by the funding key
744 pub bitcoin_signature: Signature,
747 /// An address which can be used to connect to a remote peer.
748 #[derive(Clone, Debug, PartialEq, Eq)]
749 pub enum NetAddress {
750 /// An IPv4 address/port on which the peer is listening.
752 /// The 4-byte IPv4 address
754 /// The port on which the node is listening
757 /// An IPv6 address/port on which the peer is listening.
759 /// The 16-byte IPv6 address
761 /// The port on which the node is listening
764 /// An old-style Tor onion address/port on which the peer is listening.
766 /// This field is deprecated and the Tor network generally no longer supports V2 Onion
767 /// addresses. Thus, the details are not parsed here.
769 /// A new-style Tor onion address/port on which the peer is listening.
771 /// To create the human-readable "hostname", concatenate the ED25519 pubkey, checksum, and version,
772 /// wrap as base32 and append ".onion".
774 /// The ed25519 long-term public key of the peer
775 ed25519_pubkey: [u8; 32],
776 /// The checksum of the pubkey and version, as included in the onion address
778 /// The version byte, as defined by the Tor Onion v3 spec.
780 /// The port on which the node is listening
783 /// A hostname/port on which the peer is listening.
785 /// The hostname on which the node is listening.
787 /// The port on which the node is listening.
792 /// Gets the ID of this address type. Addresses in [`NodeAnnouncement`] messages should be sorted
794 pub(crate) fn get_id(&self) -> u8 {
796 &NetAddress::IPv4 {..} => { 1 },
797 &NetAddress::IPv6 {..} => { 2 },
798 &NetAddress::OnionV2(_) => { 3 },
799 &NetAddress::OnionV3 {..} => { 4 },
800 &NetAddress::Hostname {..} => { 5 },
804 /// Strict byte-length of address descriptor, 1-byte type not recorded
805 fn len(&self) -> u16 {
807 &NetAddress::IPv4 { .. } => { 6 },
808 &NetAddress::IPv6 { .. } => { 18 },
809 &NetAddress::OnionV2(_) => { 12 },
810 &NetAddress::OnionV3 { .. } => { 37 },
811 // Consists of 1-byte hostname length, hostname bytes, and 2-byte port.
812 &NetAddress::Hostname { ref hostname, .. } => { u16::from(hostname.len()) + 3 },
816 /// The maximum length of any address descriptor, not including the 1-byte type.
817 /// This maximum length is reached by a hostname address descriptor:
818 /// a hostname with a maximum length of 255, its 1-byte length and a 2-byte port.
819 pub(crate) const MAX_LEN: u16 = 258;
822 impl Writeable for NetAddress {
823 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
825 &NetAddress::IPv4 { ref addr, ref port } => {
830 &NetAddress::IPv6 { ref addr, ref port } => {
835 &NetAddress::OnionV2(bytes) => {
837 bytes.write(writer)?;
839 &NetAddress::OnionV3 { ref ed25519_pubkey, ref checksum, ref version, ref port } => {
841 ed25519_pubkey.write(writer)?;
842 checksum.write(writer)?;
843 version.write(writer)?;
846 &NetAddress::Hostname { ref hostname, ref port } => {
848 hostname.write(writer)?;
856 impl Readable for Result<NetAddress, u8> {
857 fn read<R: Read>(reader: &mut R) -> Result<Result<NetAddress, u8>, DecodeError> {
858 let byte = <u8 as Readable>::read(reader)?;
861 Ok(Ok(NetAddress::IPv4 {
862 addr: Readable::read(reader)?,
863 port: Readable::read(reader)?,
867 Ok(Ok(NetAddress::IPv6 {
868 addr: Readable::read(reader)?,
869 port: Readable::read(reader)?,
872 3 => Ok(Ok(NetAddress::OnionV2(Readable::read(reader)?))),
874 Ok(Ok(NetAddress::OnionV3 {
875 ed25519_pubkey: Readable::read(reader)?,
876 checksum: Readable::read(reader)?,
877 version: Readable::read(reader)?,
878 port: Readable::read(reader)?,
882 Ok(Ok(NetAddress::Hostname {
883 hostname: Readable::read(reader)?,
884 port: Readable::read(reader)?,
887 _ => return Ok(Err(byte)),
892 impl Readable for NetAddress {
893 fn read<R: Read>(reader: &mut R) -> Result<NetAddress, DecodeError> {
894 match Readable::read(reader) {
895 Ok(Ok(res)) => Ok(res),
896 Ok(Err(_)) => Err(DecodeError::UnknownVersion),
902 /// Represents the set of gossip messages that require a signature from a node's identity key.
903 pub enum UnsignedGossipMessage<'a> {
904 /// An unsigned channel announcement.
905 ChannelAnnouncement(&'a UnsignedChannelAnnouncement),
906 /// An unsigned channel update.
907 ChannelUpdate(&'a UnsignedChannelUpdate),
908 /// An unsigned node announcement.
909 NodeAnnouncement(&'a UnsignedNodeAnnouncement)
912 impl<'a> Writeable for UnsignedGossipMessage<'a> {
913 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
915 UnsignedGossipMessage::ChannelAnnouncement(ref msg) => msg.write(writer),
916 UnsignedGossipMessage::ChannelUpdate(ref msg) => msg.write(writer),
917 UnsignedGossipMessage::NodeAnnouncement(ref msg) => msg.write(writer),
922 /// The unsigned part of a [`node_announcement`] message.
924 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
925 #[derive(Clone, Debug, PartialEq, Eq)]
926 pub struct UnsignedNodeAnnouncement {
927 /// The advertised features
928 pub features: NodeFeatures,
929 /// A strictly monotonic announcement counter, with gaps allowed
931 /// The `node_id` this announcement originated from (don't rebroadcast the `node_announcement` back
934 /// An RGB color for UI purposes
936 /// An alias, for UI purposes.
938 /// This should be sanitized before use. There is no guarantee of uniqueness.
939 pub alias: NodeAlias,
940 /// List of addresses on which this node is reachable
941 pub addresses: Vec<NetAddress>,
942 pub(crate) excess_address_data: Vec<u8>,
943 pub(crate) excess_data: Vec<u8>,
945 #[derive(Clone, Debug, PartialEq, Eq)]
946 /// A [`node_announcement`] message to be sent to or received from a peer.
948 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
949 pub struct NodeAnnouncement {
950 /// The signature by the node key
951 pub signature: Signature,
952 /// The actual content of the announcement
953 pub contents: UnsignedNodeAnnouncement,
956 /// The unsigned part of a [`channel_announcement`] message.
958 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
959 #[derive(Clone, Debug, PartialEq, Eq)]
960 pub struct UnsignedChannelAnnouncement {
961 /// The advertised channel features
962 pub features: ChannelFeatures,
963 /// The genesis hash of the blockchain where the channel is to be opened
964 pub chain_hash: BlockHash,
965 /// The short channel ID
966 pub short_channel_id: u64,
967 /// One of the two `node_id`s which are endpoints of this channel
968 pub node_id_1: NodeId,
969 /// The other of the two `node_id`s which are endpoints of this channel
970 pub node_id_2: NodeId,
971 /// The funding key for the first node
972 pub bitcoin_key_1: NodeId,
973 /// The funding key for the second node
974 pub bitcoin_key_2: NodeId,
975 /// Excess data which was signed as a part of the message which we do not (yet) understand how
978 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
979 pub excess_data: Vec<u8>,
981 /// A [`channel_announcement`] message to be sent to or received from a peer.
983 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
984 #[derive(Clone, Debug, PartialEq, Eq)]
985 pub struct ChannelAnnouncement {
986 /// Authentication of the announcement by the first public node
987 pub node_signature_1: Signature,
988 /// Authentication of the announcement by the second public node
989 pub node_signature_2: Signature,
990 /// Proof of funding UTXO ownership by the first public node
991 pub bitcoin_signature_1: Signature,
992 /// Proof of funding UTXO ownership by the second public node
993 pub bitcoin_signature_2: Signature,
994 /// The actual announcement
995 pub contents: UnsignedChannelAnnouncement,
998 /// The unsigned part of a [`channel_update`] message.
1000 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1001 #[derive(Clone, Debug, PartialEq, Eq)]
1002 pub struct UnsignedChannelUpdate {
1003 /// The genesis hash of the blockchain where the channel is to be opened
1004 pub chain_hash: BlockHash,
1005 /// The short channel ID
1006 pub short_channel_id: u64,
1007 /// A strictly monotonic announcement counter, with gaps allowed, specific to this channel
1011 /// The number of blocks such that if:
1012 /// `incoming_htlc.cltv_expiry < outgoing_htlc.cltv_expiry + cltv_expiry_delta`
1013 /// then we need to fail the HTLC backwards. When forwarding an HTLC, `cltv_expiry_delta` determines
1014 /// the outgoing HTLC's minimum `cltv_expiry` value -- so, if an incoming HTLC comes in with a
1015 /// `cltv_expiry` of 100000, and the node we're forwarding to has a `cltv_expiry_delta` value of 10,
1016 /// then we'll check that the outgoing HTLC's `cltv_expiry` value is at least 100010 before
1017 /// forwarding. Note that the HTLC sender is the one who originally sets this value when
1018 /// constructing the route.
1019 pub cltv_expiry_delta: u16,
1020 /// The minimum HTLC size incoming to sender, in milli-satoshi
1021 pub htlc_minimum_msat: u64,
1022 /// The maximum HTLC value incoming to sender, in milli-satoshi.
1024 /// This used to be optional.
1025 pub htlc_maximum_msat: u64,
1026 /// The base HTLC fee charged by sender, in milli-satoshi
1027 pub fee_base_msat: u32,
1028 /// The amount to fee multiplier, in micro-satoshi
1029 pub fee_proportional_millionths: u32,
1030 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1033 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1034 pub excess_data: Vec<u8>,
1036 /// A [`channel_update`] message to be sent to or received from a peer.
1038 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1039 #[derive(Clone, Debug, PartialEq, Eq)]
1040 pub struct ChannelUpdate {
1041 /// A signature of the channel update
1042 pub signature: Signature,
1043 /// The actual channel update
1044 pub contents: UnsignedChannelUpdate,
1047 /// A [`query_channel_range`] message is used to query a peer for channel
1048 /// UTXOs in a range of blocks. The recipient of a query makes a best
1049 /// effort to reply to the query using one or more [`ReplyChannelRange`]
1052 /// [`query_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1053 #[derive(Clone, Debug, PartialEq, Eq)]
1054 pub struct QueryChannelRange {
1055 /// The genesis hash of the blockchain being queried
1056 pub chain_hash: BlockHash,
1057 /// The height of the first block for the channel UTXOs being queried
1058 pub first_blocknum: u32,
1059 /// The number of blocks to include in the query results
1060 pub number_of_blocks: u32,
1063 /// A [`reply_channel_range`] message is a reply to a [`QueryChannelRange`]
1066 /// Multiple `reply_channel_range` messages can be sent in reply
1067 /// to a single [`QueryChannelRange`] message. The query recipient makes a
1068 /// best effort to respond based on their local network view which may
1069 /// not be a perfect view of the network. The `short_channel_id`s in the
1070 /// reply are encoded. We only support `encoding_type=0` uncompressed
1071 /// serialization and do not support `encoding_type=1` zlib serialization.
1073 /// [`reply_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1074 #[derive(Clone, Debug, PartialEq, Eq)]
1075 pub struct ReplyChannelRange {
1076 /// The genesis hash of the blockchain being queried
1077 pub chain_hash: BlockHash,
1078 /// The height of the first block in the range of the reply
1079 pub first_blocknum: u32,
1080 /// The number of blocks included in the range of the reply
1081 pub number_of_blocks: u32,
1082 /// True when this is the final reply for a query
1083 pub sync_complete: bool,
1084 /// The `short_channel_id`s in the channel range
1085 pub short_channel_ids: Vec<u64>,
1088 /// A [`query_short_channel_ids`] message is used to query a peer for
1089 /// routing gossip messages related to one or more `short_channel_id`s.
1091 /// The query recipient will reply with the latest, if available,
1092 /// [`ChannelAnnouncement`], [`ChannelUpdate`] and [`NodeAnnouncement`] messages
1093 /// it maintains for the requested `short_channel_id`s followed by a
1094 /// [`ReplyShortChannelIdsEnd`] message. The `short_channel_id`s sent in
1095 /// this query are encoded. We only support `encoding_type=0` uncompressed
1096 /// serialization and do not support `encoding_type=1` zlib serialization.
1098 /// [`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
1099 #[derive(Clone, Debug, PartialEq, Eq)]
1100 pub struct QueryShortChannelIds {
1101 /// The genesis hash of the blockchain being queried
1102 pub chain_hash: BlockHash,
1103 /// The short_channel_ids that are being queried
1104 pub short_channel_ids: Vec<u64>,
1107 /// A [`reply_short_channel_ids_end`] message is sent as a reply to a
1108 /// message. The query recipient makes a best
1109 /// effort to respond based on their local network view which may not be
1110 /// a perfect view of the network.
1112 /// [`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
1113 #[derive(Clone, Debug, PartialEq, Eq)]
1114 pub struct ReplyShortChannelIdsEnd {
1115 /// The genesis hash of the blockchain that was queried
1116 pub chain_hash: BlockHash,
1117 /// Indicates if the query recipient maintains up-to-date channel
1118 /// information for the `chain_hash`
1119 pub full_information: bool,
1122 /// A [`gossip_timestamp_filter`] message is used by a node to request
1123 /// gossip relay for messages in the requested time range when the
1124 /// `gossip_queries` feature has been negotiated.
1126 /// [`gossip_timestamp_filter`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-gossip_timestamp_filter-message
1127 #[derive(Clone, Debug, PartialEq, Eq)]
1128 pub struct GossipTimestampFilter {
1129 /// The genesis hash of the blockchain for channel and node information
1130 pub chain_hash: BlockHash,
1131 /// The starting unix timestamp
1132 pub first_timestamp: u32,
1133 /// The range of information in seconds
1134 pub timestamp_range: u32,
1137 /// Encoding type for data compression of collections in gossip queries.
1139 /// We do not support `encoding_type=1` zlib serialization [defined in BOLT
1140 /// #7](https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#query-messages).
1142 Uncompressed = 0x00,
1145 /// Used to put an error message in a [`LightningError`].
1146 #[derive(Clone, Debug, PartialEq)]
1147 pub enum ErrorAction {
1148 /// The peer took some action which made us think they were useless. Disconnect them.
1150 /// An error message which we should make an effort to send before we disconnect.
1151 msg: Option<ErrorMessage>
1153 /// The peer did something incorrect. Tell them without closing any channels and disconnect them.
1154 DisconnectPeerWithWarning {
1155 /// A warning message which we should make an effort to send before we disconnect.
1156 msg: WarningMessage,
1158 /// The peer did something harmless that we weren't able to process, just log and ignore
1159 // New code should *not* use this. New code must use IgnoreAndLog, below!
1161 /// The peer did something harmless that we weren't able to meaningfully process.
1162 /// If the error is logged, log it at the given level.
1163 IgnoreAndLog(logger::Level),
1164 /// The peer provided us with a gossip message which we'd already seen. In most cases this
1165 /// should be ignored, but it may result in the message being forwarded if it is a duplicate of
1166 /// our own channel announcements.
1167 IgnoreDuplicateGossip,
1168 /// The peer did something incorrect. Tell them.
1170 /// The message to send.
1173 /// The peer did something incorrect. Tell them without closing any channels.
1174 SendWarningMessage {
1175 /// The message to send.
1176 msg: WarningMessage,
1177 /// The peer may have done something harmless that we weren't able to meaningfully process,
1178 /// though we should still tell them about it.
1179 /// If this event is logged, log it at the given level.
1180 log_level: logger::Level,
1184 /// An Err type for failure to process messages.
1185 #[derive(Clone, Debug)]
1186 pub struct LightningError {
1187 /// A human-readable message describing the error
1189 /// The action which should be taken against the offending peer.
1190 pub action: ErrorAction,
1193 /// Struct used to return values from [`RevokeAndACK`] messages, containing a bunch of commitment
1194 /// transaction updates if they were pending.
1195 #[derive(Clone, Debug, PartialEq, Eq)]
1196 pub struct CommitmentUpdate {
1197 /// `update_add_htlc` messages which should be sent
1198 pub update_add_htlcs: Vec<UpdateAddHTLC>,
1199 /// `update_fulfill_htlc` messages which should be sent
1200 pub update_fulfill_htlcs: Vec<UpdateFulfillHTLC>,
1201 /// `update_fail_htlc` messages which should be sent
1202 pub update_fail_htlcs: Vec<UpdateFailHTLC>,
1203 /// `update_fail_malformed_htlc` messages which should be sent
1204 pub update_fail_malformed_htlcs: Vec<UpdateFailMalformedHTLC>,
1205 /// An `update_fee` message which should be sent
1206 pub update_fee: Option<UpdateFee>,
1207 /// A `commitment_signed` message which should be sent
1208 pub commitment_signed: CommitmentSigned,
1211 /// A trait to describe an object which can receive channel messages.
1213 /// Messages MAY be called in parallel when they originate from different `their_node_ids`, however
1214 /// they MUST NOT be called in parallel when the two calls have the same `their_node_id`.
1215 pub trait ChannelMessageHandler : MessageSendEventsProvider {
1217 /// Handle an incoming `open_channel` message from the given peer.
1218 fn handle_open_channel(&self, their_node_id: &PublicKey, msg: &OpenChannel);
1219 /// Handle an incoming `open_channel2` message from the given peer.
1220 fn handle_open_channel_v2(&self, their_node_id: &PublicKey, msg: &OpenChannelV2);
1221 /// Handle an incoming `accept_channel` message from the given peer.
1222 fn handle_accept_channel(&self, their_node_id: &PublicKey, msg: &AcceptChannel);
1223 /// Handle an incoming `accept_channel2` message from the given peer.
1224 fn handle_accept_channel_v2(&self, their_node_id: &PublicKey, msg: &AcceptChannelV2);
1225 /// Handle an incoming `funding_created` message from the given peer.
1226 fn handle_funding_created(&self, their_node_id: &PublicKey, msg: &FundingCreated);
1227 /// Handle an incoming `funding_signed` message from the given peer.
1228 fn handle_funding_signed(&self, their_node_id: &PublicKey, msg: &FundingSigned);
1229 /// Handle an incoming `channel_ready` message from the given peer.
1230 fn handle_channel_ready(&self, their_node_id: &PublicKey, msg: &ChannelReady);
1233 /// Handle an incoming `shutdown` message from the given peer.
1234 fn handle_shutdown(&self, their_node_id: &PublicKey, msg: &Shutdown);
1235 /// Handle an incoming `closing_signed` message from the given peer.
1236 fn handle_closing_signed(&self, their_node_id: &PublicKey, msg: &ClosingSigned);
1238 // Interactive channel construction
1239 /// Handle an incoming `tx_add_input message` from the given peer.
1240 fn handle_tx_add_input(&self, their_node_id: &PublicKey, msg: &TxAddInput);
1241 /// Handle an incoming `tx_add_output` message from the given peer.
1242 fn handle_tx_add_output(&self, their_node_id: &PublicKey, msg: &TxAddOutput);
1243 /// Handle an incoming `tx_remove_input` message from the given peer.
1244 fn handle_tx_remove_input(&self, their_node_id: &PublicKey, msg: &TxRemoveInput);
1245 /// Handle an incoming `tx_remove_output` message from the given peer.
1246 fn handle_tx_remove_output(&self, their_node_id: &PublicKey, msg: &TxRemoveOutput);
1247 /// Handle an incoming `tx_complete message` from the given peer.
1248 fn handle_tx_complete(&self, their_node_id: &PublicKey, msg: &TxComplete);
1249 /// Handle an incoming `tx_signatures` message from the given peer.
1250 fn handle_tx_signatures(&self, their_node_id: &PublicKey, msg: &TxSignatures);
1251 /// Handle an incoming `tx_init_rbf` message from the given peer.
1252 fn handle_tx_init_rbf(&self, their_node_id: &PublicKey, msg: &TxInitRbf);
1253 /// Handle an incoming `tx_ack_rbf` message from the given peer.
1254 fn handle_tx_ack_rbf(&self, their_node_id: &PublicKey, msg: &TxAckRbf);
1255 /// Handle an incoming `tx_abort message` from the given peer.
1256 fn handle_tx_abort(&self, their_node_id: &PublicKey, msg: &TxAbort);
1259 /// Handle an incoming `update_add_htlc` message from the given peer.
1260 fn handle_update_add_htlc(&self, their_node_id: &PublicKey, msg: &UpdateAddHTLC);
1261 /// Handle an incoming `update_fulfill_htlc` message from the given peer.
1262 fn handle_update_fulfill_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFulfillHTLC);
1263 /// Handle an incoming `update_fail_htlc` message from the given peer.
1264 fn handle_update_fail_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailHTLC);
1265 /// Handle an incoming `update_fail_malformed_htlc` message from the given peer.
1266 fn handle_update_fail_malformed_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailMalformedHTLC);
1267 /// Handle an incoming `commitment_signed` message from the given peer.
1268 fn handle_commitment_signed(&self, their_node_id: &PublicKey, msg: &CommitmentSigned);
1269 /// Handle an incoming `revoke_and_ack` message from the given peer.
1270 fn handle_revoke_and_ack(&self, their_node_id: &PublicKey, msg: &RevokeAndACK);
1272 /// Handle an incoming `update_fee` message from the given peer.
1273 fn handle_update_fee(&self, their_node_id: &PublicKey, msg: &UpdateFee);
1275 // Channel-to-announce:
1276 /// Handle an incoming `announcement_signatures` message from the given peer.
1277 fn handle_announcement_signatures(&self, their_node_id: &PublicKey, msg: &AnnouncementSignatures);
1279 // Connection loss/reestablish:
1280 /// Indicates a connection to the peer failed/an existing connection was lost.
1281 fn peer_disconnected(&self, their_node_id: &PublicKey);
1283 /// Handle a peer reconnecting, possibly generating `channel_reestablish` message(s).
1285 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1286 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1287 /// message handlers may still wish to communicate with this peer.
1288 fn peer_connected(&self, their_node_id: &PublicKey, msg: &Init, inbound: bool) -> Result<(), ()>;
1289 /// Handle an incoming `channel_reestablish` message from the given peer.
1290 fn handle_channel_reestablish(&self, their_node_id: &PublicKey, msg: &ChannelReestablish);
1292 /// Handle an incoming `channel_update` message from the given peer.
1293 fn handle_channel_update(&self, their_node_id: &PublicKey, msg: &ChannelUpdate);
1296 /// Handle an incoming `error` message from the given peer.
1297 fn handle_error(&self, their_node_id: &PublicKey, msg: &ErrorMessage);
1299 // Handler information:
1300 /// Gets the node feature flags which this handler itself supports. All available handlers are
1301 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1302 /// which are broadcasted in our [`NodeAnnouncement`] message.
1303 fn provided_node_features(&self) -> NodeFeatures;
1305 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1306 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1307 /// which are sent in our [`Init`] message.
1309 /// Note that this method is called before [`Self::peer_connected`].
1310 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1312 /// Gets the genesis hashes for this `ChannelMessageHandler` indicating which chains it supports.
1314 /// If it's `None`, then no particular network chain hash compatibility will be enforced when
1315 /// connecting to peers.
1316 fn get_genesis_hashes(&self) -> Option<Vec<ChainHash>>;
1319 /// A trait to describe an object which can receive routing messages.
1321 /// # Implementor DoS Warnings
1323 /// For messages enabled with the `gossip_queries` feature there are potential DoS vectors when
1324 /// handling inbound queries. Implementors using an on-disk network graph should be aware of
1325 /// repeated disk I/O for queries accessing different parts of the network graph.
1326 pub trait RoutingMessageHandler : MessageSendEventsProvider {
1327 /// Handle an incoming `node_announcement` message, returning `true` if it should be forwarded on,
1328 /// `false` or returning an `Err` otherwise.
1329 fn handle_node_announcement(&self, msg: &NodeAnnouncement) -> Result<bool, LightningError>;
1330 /// Handle a `channel_announcement` message, returning `true` if it should be forwarded on, `false`
1331 /// or returning an `Err` otherwise.
1332 fn handle_channel_announcement(&self, msg: &ChannelAnnouncement) -> Result<bool, LightningError>;
1333 /// Handle an incoming `channel_update` message, returning true if it should be forwarded on,
1334 /// `false` or returning an `Err` otherwise.
1335 fn handle_channel_update(&self, msg: &ChannelUpdate) -> Result<bool, LightningError>;
1336 /// Gets channel announcements and updates required to dump our routing table to a remote node,
1337 /// starting at the `short_channel_id` indicated by `starting_point` and including announcements
1338 /// for a single channel.
1339 fn get_next_channel_announcement(&self, starting_point: u64) -> Option<(ChannelAnnouncement, Option<ChannelUpdate>, Option<ChannelUpdate>)>;
1340 /// Gets a node announcement required to dump our routing table to a remote node, starting at
1341 /// the node *after* the provided pubkey and including up to one announcement immediately
1342 /// higher (as defined by `<PublicKey as Ord>::cmp`) than `starting_point`.
1343 /// If `None` is provided for `starting_point`, we start at the first node.
1344 fn get_next_node_announcement(&self, starting_point: Option<&NodeId>) -> Option<NodeAnnouncement>;
1345 /// Called when a connection is established with a peer. This can be used to
1346 /// perform routing table synchronization using a strategy defined by the
1349 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1350 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1351 /// message handlers may still wish to communicate with this peer.
1352 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1353 /// Handles the reply of a query we initiated to learn about channels
1354 /// for a given range of blocks. We can expect to receive one or more
1355 /// replies to a single query.
1356 fn handle_reply_channel_range(&self, their_node_id: &PublicKey, msg: ReplyChannelRange) -> Result<(), LightningError>;
1357 /// Handles the reply of a query we initiated asking for routing gossip
1358 /// messages for a list of channels. We should receive this message when
1359 /// a node has completed its best effort to send us the pertaining routing
1360 /// gossip messages.
1361 fn handle_reply_short_channel_ids_end(&self, their_node_id: &PublicKey, msg: ReplyShortChannelIdsEnd) -> Result<(), LightningError>;
1362 /// Handles when a peer asks us to send a list of `short_channel_id`s
1363 /// for the requested range of blocks.
1364 fn handle_query_channel_range(&self, their_node_id: &PublicKey, msg: QueryChannelRange) -> Result<(), LightningError>;
1365 /// Handles when a peer asks us to send routing gossip messages for a
1366 /// list of `short_channel_id`s.
1367 fn handle_query_short_channel_ids(&self, their_node_id: &PublicKey, msg: QueryShortChannelIds) -> Result<(), LightningError>;
1369 // Handler queueing status:
1370 /// Indicates that there are a large number of [`ChannelAnnouncement`] (or other) messages
1371 /// pending some async action. While there is no guarantee of the rate of future messages, the
1372 /// caller should seek to reduce the rate of new gossip messages handled, especially
1373 /// [`ChannelAnnouncement`]s.
1374 fn processing_queue_high(&self) -> bool;
1376 // Handler information:
1377 /// Gets the node feature flags which this handler itself supports. All available handlers are
1378 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1379 /// which are broadcasted in our [`NodeAnnouncement`] message.
1380 fn provided_node_features(&self) -> NodeFeatures;
1381 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1382 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1383 /// which are sent in our [`Init`] message.
1385 /// Note that this method is called before [`Self::peer_connected`].
1386 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1389 /// A trait to describe an object that can receive onion messages.
1390 pub trait OnionMessageHandler : OnionMessageProvider {
1391 /// Handle an incoming `onion_message` message from the given peer.
1392 fn handle_onion_message(&self, peer_node_id: &PublicKey, msg: &OnionMessage);
1393 /// Called when a connection is established with a peer. Can be used to track which peers
1394 /// advertise onion message support and are online.
1396 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1397 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1398 /// message handlers may still wish to communicate with this peer.
1399 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1400 /// Indicates a connection to the peer failed/an existing connection was lost. Allows handlers to
1401 /// drop and refuse to forward onion messages to this peer.
1402 fn peer_disconnected(&self, their_node_id: &PublicKey);
1404 // Handler information:
1405 /// Gets the node feature flags which this handler itself supports. All available handlers are
1406 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1407 /// which are broadcasted in our [`NodeAnnouncement`] message.
1408 fn provided_node_features(&self) -> NodeFeatures;
1410 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1411 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1412 /// which are sent in our [`Init`] message.
1414 /// Note that this method is called before [`Self::peer_connected`].
1415 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1418 mod fuzzy_internal_msgs {
1419 use crate::prelude::*;
1420 use crate::ln::{PaymentPreimage, PaymentSecret};
1422 // These types aren't intended to be pub, but are exposed for direct fuzzing (as we deserialize
1423 // them from untrusted input):
1425 pub struct FinalOnionHopData {
1426 pub payment_secret: PaymentSecret,
1427 /// The total value, in msat, of the payment as received by the ultimate recipient.
1428 /// Message serialization may panic if this value is more than 21 million Bitcoin.
1429 pub total_msat: u64,
1432 pub enum InboundOnionPayload {
1434 short_channel_id: u64,
1435 /// The value, in msat, of the payment after this hop's fee is deducted.
1436 amt_to_forward: u64,
1437 outgoing_cltv_value: u32,
1440 payment_data: Option<FinalOnionHopData>,
1441 payment_metadata: Option<Vec<u8>>,
1442 keysend_preimage: Option<PaymentPreimage>,
1443 custom_tlvs: Vec<(u64, Vec<u8>)>,
1445 outgoing_cltv_value: u32,
1449 pub(crate) enum OutboundOnionPayload {
1451 short_channel_id: u64,
1452 /// The value, in msat, of the payment after this hop's fee is deducted.
1453 amt_to_forward: u64,
1454 outgoing_cltv_value: u32,
1457 payment_data: Option<FinalOnionHopData>,
1458 payment_metadata: Option<Vec<u8>>,
1459 keysend_preimage: Option<PaymentPreimage>,
1460 custom_tlvs: Vec<(u64, Vec<u8>)>,
1462 outgoing_cltv_value: u32,
1466 pub struct DecodedOnionErrorPacket {
1467 pub(crate) hmac: [u8; 32],
1468 pub(crate) failuremsg: Vec<u8>,
1469 pub(crate) pad: Vec<u8>,
1473 pub use self::fuzzy_internal_msgs::*;
1474 #[cfg(not(fuzzing))]
1475 pub(crate) use self::fuzzy_internal_msgs::*;
1478 pub(crate) struct OnionPacket {
1479 pub(crate) version: u8,
1480 /// In order to ensure we always return an error on onion decode in compliance with [BOLT
1481 /// #4](https://github.com/lightning/bolts/blob/master/04-onion-routing.md), we have to
1482 /// deserialize `OnionPacket`s contained in [`UpdateAddHTLC`] messages even if the ephemeral
1483 /// public key (here) is bogus, so we hold a [`Result`] instead of a [`PublicKey`] as we'd
1485 pub(crate) public_key: Result<PublicKey, secp256k1::Error>,
1486 pub(crate) hop_data: [u8; 20*65],
1487 pub(crate) hmac: [u8; 32],
1490 impl onion_utils::Packet for OnionPacket {
1491 type Data = onion_utils::FixedSizeOnionPacket;
1492 fn new(pubkey: PublicKey, hop_data: onion_utils::FixedSizeOnionPacket, hmac: [u8; 32]) -> Self {
1495 public_key: Ok(pubkey),
1496 hop_data: hop_data.0,
1502 impl Eq for OnionPacket { }
1503 impl PartialEq for OnionPacket {
1504 fn eq(&self, other: &OnionPacket) -> bool {
1505 for (i, j) in self.hop_data.iter().zip(other.hop_data.iter()) {
1506 if i != j { return false; }
1508 self.version == other.version &&
1509 self.public_key == other.public_key &&
1510 self.hmac == other.hmac
1514 impl fmt::Debug for OnionPacket {
1515 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1516 f.write_fmt(format_args!("OnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
1520 #[derive(Clone, Debug, PartialEq, Eq)]
1521 pub(crate) struct OnionErrorPacket {
1522 // This really should be a constant size slice, but the spec lets these things be up to 128KB?
1523 // (TODO) We limit it in decode to much lower...
1524 pub(crate) data: Vec<u8>,
1527 impl fmt::Display for DecodeError {
1528 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1530 DecodeError::UnknownVersion => f.write_str("Unknown realm byte in Onion packet"),
1531 DecodeError::UnknownRequiredFeature => f.write_str("Unknown required feature preventing decode"),
1532 DecodeError::InvalidValue => f.write_str("Nonsense bytes didn't map to the type they were interpreted as"),
1533 DecodeError::ShortRead => f.write_str("Packet extended beyond the provided bytes"),
1534 DecodeError::BadLengthDescriptor => f.write_str("A length descriptor in the packet didn't describe the later data correctly"),
1535 DecodeError::Io(ref e) => fmt::Debug::fmt(e, f),
1536 DecodeError::UnsupportedCompression => f.write_str("We don't support receiving messages with zlib-compressed fields"),
1541 impl From<io::Error> for DecodeError {
1542 fn from(e: io::Error) -> Self {
1543 if e.kind() == io::ErrorKind::UnexpectedEof {
1544 DecodeError::ShortRead
1546 DecodeError::Io(e.kind())
1551 #[cfg(not(taproot))]
1552 impl_writeable_msg!(AcceptChannel, {
1553 temporary_channel_id,
1554 dust_limit_satoshis,
1555 max_htlc_value_in_flight_msat,
1556 channel_reserve_satoshis,
1562 revocation_basepoint,
1564 delayed_payment_basepoint,
1566 first_per_commitment_point,
1568 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1569 (1, channel_type, option),
1573 impl_writeable_msg!(AcceptChannel, {
1574 temporary_channel_id,
1575 dust_limit_satoshis,
1576 max_htlc_value_in_flight_msat,
1577 channel_reserve_satoshis,
1583 revocation_basepoint,
1585 delayed_payment_basepoint,
1587 first_per_commitment_point,
1589 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1590 (1, channel_type, option),
1591 (4, next_local_nonce, option),
1594 impl_writeable_msg!(AcceptChannelV2, {
1595 temporary_channel_id,
1597 dust_limit_satoshis,
1598 max_htlc_value_in_flight_msat,
1604 revocation_basepoint,
1606 delayed_payment_basepoint,
1608 first_per_commitment_point,
1609 second_per_commitment_point,
1611 (0, shutdown_scriptpubkey, option),
1612 (1, channel_type, option),
1613 (2, require_confirmed_inputs, option),
1616 impl_writeable_msg!(TxAddInput, {
1624 impl_writeable_msg!(TxAddOutput, {
1631 impl_writeable_msg!(TxRemoveInput, {
1636 impl_writeable_msg!(TxRemoveOutput, {
1641 impl_writeable_msg!(TxComplete, {
1645 impl_writeable_msg!(TxSignatures, {
1651 impl_writeable_msg!(TxInitRbf, {
1654 feerate_sat_per_1000_weight,
1656 (0, funding_output_contribution, option),
1659 impl_writeable_msg!(TxAckRbf, {
1662 (0, funding_output_contribution, option),
1665 impl_writeable_msg!(TxAbort, {
1670 impl_writeable_msg!(AnnouncementSignatures, {
1677 impl_writeable_msg!(ChannelReestablish, {
1679 next_local_commitment_number,
1680 next_remote_commitment_number,
1681 your_last_per_commitment_secret,
1682 my_current_per_commitment_point,
1684 (0, next_funding_txid, option),
1687 impl_writeable_msg!(ClosingSigned,
1688 { channel_id, fee_satoshis, signature },
1689 { (1, fee_range, option) }
1692 impl_writeable!(ClosingSignedFeeRange, {
1697 #[cfg(not(taproot))]
1698 impl_writeable_msg!(CommitmentSigned, {
1705 impl_writeable_msg!(CommitmentSigned, {
1710 (2, partial_signature_with_nonce, option)
1713 impl_writeable!(DecodedOnionErrorPacket, {
1719 #[cfg(not(taproot))]
1720 impl_writeable_msg!(FundingCreated, {
1721 temporary_channel_id,
1723 funding_output_index,
1727 impl_writeable_msg!(FundingCreated, {
1728 temporary_channel_id,
1730 funding_output_index,
1733 (2, partial_signature_with_nonce, option),
1734 (4, next_local_nonce, option)
1737 #[cfg(not(taproot))]
1738 impl_writeable_msg!(FundingSigned, {
1744 impl_writeable_msg!(FundingSigned, {
1748 (2, partial_signature_with_nonce, option)
1751 impl_writeable_msg!(ChannelReady, {
1753 next_per_commitment_point,
1755 (1, short_channel_id_alias, option),
1758 impl Writeable for Init {
1759 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1760 // global_features gets the bottom 13 bits of our features, and local_features gets all of
1761 // our relevant feature bits. This keeps us compatible with old nodes.
1762 self.features.write_up_to_13(w)?;
1763 self.features.write(w)?;
1764 encode_tlv_stream!(w, {
1765 (1, self.networks.as_ref().map(|n| WithoutLength(n)), option),
1766 (3, self.remote_network_address, option),
1772 impl Readable for Init {
1773 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1774 let global_features: InitFeatures = Readable::read(r)?;
1775 let features: InitFeatures = Readable::read(r)?;
1776 let mut remote_network_address: Option<NetAddress> = None;
1777 let mut networks: Option<WithoutLength<Vec<ChainHash>>> = None;
1778 decode_tlv_stream!(r, {
1779 (1, networks, option),
1780 (3, remote_network_address, option)
1783 features: features | global_features,
1784 networks: networks.map(|n| n.0),
1785 remote_network_address,
1790 impl_writeable_msg!(OpenChannel, {
1792 temporary_channel_id,
1795 dust_limit_satoshis,
1796 max_htlc_value_in_flight_msat,
1797 channel_reserve_satoshis,
1803 revocation_basepoint,
1805 delayed_payment_basepoint,
1807 first_per_commitment_point,
1810 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1811 (1, channel_type, option),
1814 impl_writeable_msg!(OpenChannelV2, {
1816 temporary_channel_id,
1817 funding_feerate_sat_per_1000_weight,
1818 commitment_feerate_sat_per_1000_weight,
1820 dust_limit_satoshis,
1821 max_htlc_value_in_flight_msat,
1827 revocation_basepoint,
1829 delayed_payment_basepoint,
1831 first_per_commitment_point,
1832 second_per_commitment_point,
1835 (0, shutdown_scriptpubkey, option),
1836 (1, channel_type, option),
1837 (2, require_confirmed_inputs, option),
1840 #[cfg(not(taproot))]
1841 impl_writeable_msg!(RevokeAndACK, {
1843 per_commitment_secret,
1844 next_per_commitment_point
1848 impl_writeable_msg!(RevokeAndACK, {
1850 per_commitment_secret,
1851 next_per_commitment_point
1853 (4, next_local_nonce, option)
1856 impl_writeable_msg!(Shutdown, {
1861 impl_writeable_msg!(UpdateFailHTLC, {
1867 impl_writeable_msg!(UpdateFailMalformedHTLC, {
1874 impl_writeable_msg!(UpdateFee, {
1879 impl_writeable_msg!(UpdateFulfillHTLC, {
1885 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
1886 // serialization format in a way which assumes we know the total serialized length/message end
1888 impl_writeable!(OnionErrorPacket, {
1892 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
1893 // serialization format in a way which assumes we know the total serialized length/message end
1895 impl Writeable for OnionPacket {
1896 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1897 self.version.write(w)?;
1898 match self.public_key {
1899 Ok(pubkey) => pubkey.write(w)?,
1900 Err(_) => [0u8;33].write(w)?,
1902 w.write_all(&self.hop_data)?;
1903 self.hmac.write(w)?;
1908 impl Readable for OnionPacket {
1909 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1911 version: Readable::read(r)?,
1913 let mut buf = [0u8;33];
1914 r.read_exact(&mut buf)?;
1915 PublicKey::from_slice(&buf)
1917 hop_data: Readable::read(r)?,
1918 hmac: Readable::read(r)?,
1923 impl_writeable_msg!(UpdateAddHTLC, {
1929 onion_routing_packet,
1931 (65537, skimmed_fee_msat, option)
1934 impl Readable for OnionMessage {
1935 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1936 let blinding_point: PublicKey = Readable::read(r)?;
1937 let len: u16 = Readable::read(r)?;
1938 let mut packet_reader = FixedLengthReader::new(r, len as u64);
1939 let onion_routing_packet: onion_message::Packet = <onion_message::Packet as LengthReadable>::read(&mut packet_reader)?;
1942 onion_routing_packet,
1947 impl Writeable for OnionMessage {
1948 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1949 self.blinding_point.write(w)?;
1950 let onion_packet_len = self.onion_routing_packet.serialized_length();
1951 (onion_packet_len as u16).write(w)?;
1952 self.onion_routing_packet.write(w)?;
1957 impl Writeable for FinalOnionHopData {
1958 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1959 self.payment_secret.0.write(w)?;
1960 HighZeroBytesDroppedBigSize(self.total_msat).write(w)
1964 impl Readable for FinalOnionHopData {
1965 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1966 let secret: [u8; 32] = Readable::read(r)?;
1967 let amt: HighZeroBytesDroppedBigSize<u64> = Readable::read(r)?;
1968 Ok(Self { payment_secret: PaymentSecret(secret), total_msat: amt.0 })
1972 impl Writeable for OutboundOnionPayload {
1973 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1975 Self::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } => {
1976 _encode_varint_length_prefixed_tlv!(w, {
1977 (2, HighZeroBytesDroppedBigSize(*amt_to_forward), required),
1978 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
1979 (6, short_channel_id, required)
1983 ref payment_data, ref payment_metadata, ref keysend_preimage, amt_msat,
1984 outgoing_cltv_value, ref custom_tlvs,
1986 // We need to update [`ln::outbound_payment::RecipientOnionFields::with_custom_tlvs`]
1987 // to reject any reserved types in the experimental range if new ones are ever
1989 let keysend_tlv = keysend_preimage.map(|preimage| (5482373484, preimage.encode()));
1990 let mut custom_tlvs: Vec<&(u64, Vec<u8>)> = custom_tlvs.iter().chain(keysend_tlv.iter()).collect();
1991 custom_tlvs.sort_unstable_by_key(|(typ, _)| *typ);
1992 _encode_varint_length_prefixed_tlv!(w, {
1993 (2, HighZeroBytesDroppedBigSize(*amt_msat), required),
1994 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
1995 (8, payment_data, option),
1996 (16, payment_metadata.as_ref().map(|m| WithoutLength(m)), option)
1997 }, custom_tlvs.iter());
2004 impl Readable for InboundOnionPayload {
2005 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2006 let mut amt = HighZeroBytesDroppedBigSize(0u64);
2007 let mut cltv_value = HighZeroBytesDroppedBigSize(0u32);
2008 let mut short_id: Option<u64> = None;
2009 let mut payment_data: Option<FinalOnionHopData> = None;
2010 let mut payment_metadata: Option<WithoutLength<Vec<u8>>> = None;
2011 let mut keysend_preimage: Option<PaymentPreimage> = None;
2012 let mut custom_tlvs = Vec::new();
2014 let tlv_len = BigSize::read(r)?;
2015 let rd = FixedLengthReader::new(r, tlv_len.0);
2016 decode_tlv_stream_with_custom_tlv_decode!(rd, {
2018 (4, cltv_value, required),
2019 (6, short_id, option),
2020 (8, payment_data, option),
2021 (16, payment_metadata, option),
2022 // See https://github.com/lightning/blips/blob/master/blip-0003.md
2023 (5482373484, keysend_preimage, option)
2024 }, |msg_type: u64, msg_reader: &mut FixedLengthReader<_>| -> Result<bool, DecodeError> {
2025 if msg_type < 1 << 16 { return Ok(false) }
2026 let mut value = Vec::new();
2027 msg_reader.read_to_end(&mut value)?;
2028 custom_tlvs.push((msg_type, value));
2032 if amt.0 > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2033 if let Some(short_channel_id) = short_id {
2034 if payment_data.is_some() { return Err(DecodeError::InvalidValue) }
2035 if payment_metadata.is_some() { return Err(DecodeError::InvalidValue); }
2038 amt_to_forward: amt.0,
2039 outgoing_cltv_value: cltv_value.0,
2042 if let Some(data) = &payment_data {
2043 if data.total_msat > MAX_VALUE_MSAT {
2044 return Err(DecodeError::InvalidValue);
2049 payment_metadata: payment_metadata.map(|w| w.0),
2052 outgoing_cltv_value: cltv_value.0,
2059 // ReadableArgs because we need onion_utils::decode_next_hop to accommodate payment packets and
2060 // onion message packets.
2061 impl ReadableArgs<()> for InboundOnionPayload {
2062 fn read<R: Read>(r: &mut R, _arg: ()) -> Result<Self, DecodeError> {
2063 <Self as Readable>::read(r)
2067 impl Writeable for Ping {
2068 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2069 self.ponglen.write(w)?;
2070 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2075 impl Readable for Ping {
2076 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2078 ponglen: Readable::read(r)?,
2080 let byteslen = Readable::read(r)?;
2081 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2088 impl Writeable for Pong {
2089 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2090 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2095 impl Readable for Pong {
2096 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2099 let byteslen = Readable::read(r)?;
2100 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2107 impl Writeable for UnsignedChannelAnnouncement {
2108 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2109 self.features.write(w)?;
2110 self.chain_hash.write(w)?;
2111 self.short_channel_id.write(w)?;
2112 self.node_id_1.write(w)?;
2113 self.node_id_2.write(w)?;
2114 self.bitcoin_key_1.write(w)?;
2115 self.bitcoin_key_2.write(w)?;
2116 w.write_all(&self.excess_data[..])?;
2121 impl Readable for UnsignedChannelAnnouncement {
2122 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2124 features: Readable::read(r)?,
2125 chain_hash: Readable::read(r)?,
2126 short_channel_id: Readable::read(r)?,
2127 node_id_1: Readable::read(r)?,
2128 node_id_2: Readable::read(r)?,
2129 bitcoin_key_1: Readable::read(r)?,
2130 bitcoin_key_2: Readable::read(r)?,
2131 excess_data: read_to_end(r)?,
2136 impl_writeable!(ChannelAnnouncement, {
2139 bitcoin_signature_1,
2140 bitcoin_signature_2,
2144 impl Writeable for UnsignedChannelUpdate {
2145 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2146 // `message_flags` used to indicate presence of `htlc_maximum_msat`, but was deprecated in the spec.
2147 const MESSAGE_FLAGS: u8 = 1;
2148 self.chain_hash.write(w)?;
2149 self.short_channel_id.write(w)?;
2150 self.timestamp.write(w)?;
2151 let all_flags = self.flags as u16 | ((MESSAGE_FLAGS as u16) << 8);
2152 all_flags.write(w)?;
2153 self.cltv_expiry_delta.write(w)?;
2154 self.htlc_minimum_msat.write(w)?;
2155 self.fee_base_msat.write(w)?;
2156 self.fee_proportional_millionths.write(w)?;
2157 self.htlc_maximum_msat.write(w)?;
2158 w.write_all(&self.excess_data[..])?;
2163 impl Readable for UnsignedChannelUpdate {
2164 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2166 chain_hash: Readable::read(r)?,
2167 short_channel_id: Readable::read(r)?,
2168 timestamp: Readable::read(r)?,
2170 let flags: u16 = Readable::read(r)?;
2171 // Note: we ignore the `message_flags` for now, since it was deprecated by the spec.
2174 cltv_expiry_delta: Readable::read(r)?,
2175 htlc_minimum_msat: Readable::read(r)?,
2176 fee_base_msat: Readable::read(r)?,
2177 fee_proportional_millionths: Readable::read(r)?,
2178 htlc_maximum_msat: Readable::read(r)?,
2179 excess_data: read_to_end(r)?,
2184 impl_writeable!(ChannelUpdate, {
2189 impl Writeable for ErrorMessage {
2190 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2191 self.channel_id.write(w)?;
2192 (self.data.len() as u16).write(w)?;
2193 w.write_all(self.data.as_bytes())?;
2198 impl Readable for ErrorMessage {
2199 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2201 channel_id: Readable::read(r)?,
2203 let sz: usize = <u16 as Readable>::read(r)? as usize;
2204 let mut data = Vec::with_capacity(sz);
2206 r.read_exact(&mut data)?;
2207 match String::from_utf8(data) {
2209 Err(_) => return Err(DecodeError::InvalidValue),
2216 impl Writeable for WarningMessage {
2217 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2218 self.channel_id.write(w)?;
2219 (self.data.len() as u16).write(w)?;
2220 w.write_all(self.data.as_bytes())?;
2225 impl Readable for WarningMessage {
2226 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2228 channel_id: Readable::read(r)?,
2230 let sz: usize = <u16 as Readable>::read(r)? as usize;
2231 let mut data = Vec::with_capacity(sz);
2233 r.read_exact(&mut data)?;
2234 match String::from_utf8(data) {
2236 Err(_) => return Err(DecodeError::InvalidValue),
2243 impl Writeable for UnsignedNodeAnnouncement {
2244 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2245 self.features.write(w)?;
2246 self.timestamp.write(w)?;
2247 self.node_id.write(w)?;
2248 w.write_all(&self.rgb)?;
2249 self.alias.write(w)?;
2251 let mut addr_len = 0;
2252 for addr in self.addresses.iter() {
2253 addr_len += 1 + addr.len();
2255 (addr_len + self.excess_address_data.len() as u16).write(w)?;
2256 for addr in self.addresses.iter() {
2259 w.write_all(&self.excess_address_data[..])?;
2260 w.write_all(&self.excess_data[..])?;
2265 impl Readable for UnsignedNodeAnnouncement {
2266 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2267 let features: NodeFeatures = Readable::read(r)?;
2268 let timestamp: u32 = Readable::read(r)?;
2269 let node_id: NodeId = Readable::read(r)?;
2270 let mut rgb = [0; 3];
2271 r.read_exact(&mut rgb)?;
2272 let alias: NodeAlias = Readable::read(r)?;
2274 let addr_len: u16 = Readable::read(r)?;
2275 let mut addresses: Vec<NetAddress> = Vec::new();
2276 let mut addr_readpos = 0;
2277 let mut excess = false;
2278 let mut excess_byte = 0;
2280 if addr_len <= addr_readpos { break; }
2281 match Readable::read(r) {
2283 if addr_len < addr_readpos + 1 + addr.len() {
2284 return Err(DecodeError::BadLengthDescriptor);
2286 addr_readpos += (1 + addr.len()) as u16;
2287 addresses.push(addr);
2289 Ok(Err(unknown_descriptor)) => {
2291 excess_byte = unknown_descriptor;
2294 Err(DecodeError::ShortRead) => return Err(DecodeError::BadLengthDescriptor),
2295 Err(e) => return Err(e),
2299 let mut excess_data = vec![];
2300 let excess_address_data = if addr_readpos < addr_len {
2301 let mut excess_address_data = vec![0; (addr_len - addr_readpos) as usize];
2302 r.read_exact(&mut excess_address_data[if excess { 1 } else { 0 }..])?;
2304 excess_address_data[0] = excess_byte;
2309 excess_data.push(excess_byte);
2313 excess_data.extend(read_to_end(r)?.iter());
2314 Ok(UnsignedNodeAnnouncement {
2321 excess_address_data,
2327 impl_writeable!(NodeAnnouncement, {
2332 impl Readable for QueryShortChannelIds {
2333 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2334 let chain_hash: BlockHash = Readable::read(r)?;
2336 let encoding_len: u16 = Readable::read(r)?;
2337 let encoding_type: u8 = Readable::read(r)?;
2339 // Must be encoding_type=0 uncompressed serialization. We do not
2340 // support encoding_type=1 zlib serialization.
2341 if encoding_type != EncodingType::Uncompressed as u8 {
2342 return Err(DecodeError::UnsupportedCompression);
2345 // We expect the encoding_len to always includes the 1-byte
2346 // encoding_type and that short_channel_ids are 8-bytes each
2347 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2348 return Err(DecodeError::InvalidValue);
2351 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2352 // less the 1-byte encoding_type
2353 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2354 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2355 for _ in 0..short_channel_id_count {
2356 short_channel_ids.push(Readable::read(r)?);
2359 Ok(QueryShortChannelIds {
2366 impl Writeable for QueryShortChannelIds {
2367 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2368 // Calculated from 1-byte encoding_type plus 8-bytes per short_channel_id
2369 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2371 self.chain_hash.write(w)?;
2372 encoding_len.write(w)?;
2374 // We only support type=0 uncompressed serialization
2375 (EncodingType::Uncompressed as u8).write(w)?;
2377 for scid in self.short_channel_ids.iter() {
2385 impl_writeable_msg!(ReplyShortChannelIdsEnd, {
2390 impl QueryChannelRange {
2391 /// Calculates the overflow safe ending block height for the query.
2393 /// Overflow returns `0xffffffff`, otherwise returns `first_blocknum + number_of_blocks`.
2394 pub fn end_blocknum(&self) -> u32 {
2395 match self.first_blocknum.checked_add(self.number_of_blocks) {
2396 Some(block) => block,
2397 None => u32::max_value(),
2402 impl_writeable_msg!(QueryChannelRange, {
2408 impl Readable for ReplyChannelRange {
2409 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2410 let chain_hash: BlockHash = Readable::read(r)?;
2411 let first_blocknum: u32 = Readable::read(r)?;
2412 let number_of_blocks: u32 = Readable::read(r)?;
2413 let sync_complete: bool = Readable::read(r)?;
2415 let encoding_len: u16 = Readable::read(r)?;
2416 let encoding_type: u8 = Readable::read(r)?;
2418 // Must be encoding_type=0 uncompressed serialization. We do not
2419 // support encoding_type=1 zlib serialization.
2420 if encoding_type != EncodingType::Uncompressed as u8 {
2421 return Err(DecodeError::UnsupportedCompression);
2424 // We expect the encoding_len to always includes the 1-byte
2425 // encoding_type and that short_channel_ids are 8-bytes each
2426 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2427 return Err(DecodeError::InvalidValue);
2430 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2431 // less the 1-byte encoding_type
2432 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2433 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2434 for _ in 0..short_channel_id_count {
2435 short_channel_ids.push(Readable::read(r)?);
2438 Ok(ReplyChannelRange {
2448 impl Writeable for ReplyChannelRange {
2449 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2450 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2451 self.chain_hash.write(w)?;
2452 self.first_blocknum.write(w)?;
2453 self.number_of_blocks.write(w)?;
2454 self.sync_complete.write(w)?;
2456 encoding_len.write(w)?;
2457 (EncodingType::Uncompressed as u8).write(w)?;
2458 for scid in self.short_channel_ids.iter() {
2466 impl_writeable_msg!(GossipTimestampFilter, {
2474 use bitcoin::blockdata::constants::ChainHash;
2475 use bitcoin::{Transaction, PackedLockTime, TxIn, Script, Sequence, Witness, TxOut};
2477 use crate::ln::{PaymentPreimage, PaymentHash, PaymentSecret};
2478 use crate::ln::ChannelId;
2479 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
2480 use crate::ln::msgs::{self, FinalOnionHopData, OnionErrorPacket};
2481 use crate::routing::gossip::{NodeAlias, NodeId};
2482 use crate::util::ser::{Writeable, Readable, Hostname, TransactionU16LenLimited};
2484 use bitcoin::hashes::hex::FromHex;
2485 use bitcoin::util::address::Address;
2486 use bitcoin::network::constants::Network;
2487 use bitcoin::blockdata::script::Builder;
2488 use bitcoin::blockdata::opcodes;
2489 use bitcoin::hash_types::{Txid, BlockHash};
2491 use bitcoin::secp256k1::{PublicKey,SecretKey};
2492 use bitcoin::secp256k1::{Secp256k1, Message};
2494 use crate::io::{self, Cursor};
2495 use crate::prelude::*;
2496 use core::convert::TryFrom;
2497 use core::str::FromStr;
2499 use crate::chain::transaction::OutPoint;
2502 fn encoding_channel_reestablish() {
2504 let secp_ctx = Secp256k1::new();
2505 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2508 let cr = msgs::ChannelReestablish {
2509 channel_id: ChannelId::from_bytes([4, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0]),
2510 next_local_commitment_number: 3,
2511 next_remote_commitment_number: 4,
2512 your_last_per_commitment_secret: [9;32],
2513 my_current_per_commitment_point: public_key,
2514 next_funding_txid: None,
2517 let encoded_value = cr.encode();
2521 4, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, // channel_id
2522 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2523 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2524 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, // your_last_per_commitment_secret
2525 3, 27, 132, 197, 86, 123, 18, 100, 64, 153, 93, 62, 213, 170, 186, 5, 101, 215, 30, 24, 52, 96, 72, 25, 255, 156, 23, 245, 233, 213, 221, 7, 143, // my_current_per_commitment_point
2531 fn encoding_channel_reestablish_with_next_funding_txid() {
2533 let secp_ctx = Secp256k1::new();
2534 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2537 let cr = msgs::ChannelReestablish {
2538 channel_id: ChannelId::from_bytes([4, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0]),
2539 next_local_commitment_number: 3,
2540 next_remote_commitment_number: 4,
2541 your_last_per_commitment_secret: [9;32],
2542 my_current_per_commitment_point: public_key,
2543 next_funding_txid: Some(Txid::from_hash(bitcoin::hashes::Hash::from_slice(&[
2544 48, 167, 250, 69, 152, 48, 103, 172, 164, 99, 59, 19, 23, 11, 92, 84, 15, 80, 4, 12, 98, 82, 75, 31, 201, 11, 91, 23, 98, 23, 53, 124,
2548 let encoded_value = cr.encode();
2552 4, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, // channel_id
2553 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2554 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2555 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, // your_last_per_commitment_secret
2556 3, 27, 132, 197, 86, 123, 18, 100, 64, 153, 93, 62, 213, 170, 186, 5, 101, 215, 30, 24, 52, 96, 72, 25, 255, 156, 23, 245, 233, 213, 221, 7, 143, // my_current_per_commitment_point
2557 0, // Type (next_funding_txid)
2559 48, 167, 250, 69, 152, 48, 103, 172, 164, 99, 59, 19, 23, 11, 92, 84, 15, 80, 4, 12, 98, 82, 75, 31, 201, 11, 91, 23, 98, 23, 53, 124, // Value
2564 macro_rules! get_keys_from {
2565 ($slice: expr, $secp_ctx: expr) => {
2567 let privkey = SecretKey::from_slice(&hex::decode($slice).unwrap()[..]).unwrap();
2568 let pubkey = PublicKey::from_secret_key(&$secp_ctx, &privkey);
2574 macro_rules! get_sig_on {
2575 ($privkey: expr, $ctx: expr, $string: expr) => {
2577 let sighash = Message::from_slice(&$string.into_bytes()[..]).unwrap();
2578 $ctx.sign_ecdsa(&sighash, &$privkey)
2584 fn encoding_announcement_signatures() {
2585 let secp_ctx = Secp256k1::new();
2586 let (privkey, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2587 let sig_1 = get_sig_on!(privkey, secp_ctx, String::from("01010101010101010101010101010101"));
2588 let sig_2 = get_sig_on!(privkey, secp_ctx, String::from("02020202020202020202020202020202"));
2589 let announcement_signatures = msgs::AnnouncementSignatures {
2590 channel_id: ChannelId::from_bytes([4, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0]),
2591 short_channel_id: 2316138423780173,
2592 node_signature: sig_1,
2593 bitcoin_signature: sig_2,
2596 let encoded_value = announcement_signatures.encode();
2597 assert_eq!(encoded_value, hex::decode("040000000000000005000000000000000600000000000000070000000000000000083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073acf9953cef4700860f5967838eba2bae89288ad188ebf8b20bf995c3ea53a26df1876d0a3a0e13172ba286a673140190c02ba9da60a2e43a745188c8a83c7f3ef").unwrap());
2600 fn do_encoding_channel_announcement(unknown_features_bits: bool, excess_data: bool) {
2601 let secp_ctx = Secp256k1::new();
2602 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2603 let (privkey_2, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2604 let (privkey_3, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2605 let (privkey_4, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2606 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2607 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
2608 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
2609 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
2610 let mut features = ChannelFeatures::empty();
2611 if unknown_features_bits {
2612 features = ChannelFeatures::from_le_bytes(vec![0xFF, 0xFF]);
2614 let unsigned_channel_announcement = msgs::UnsignedChannelAnnouncement {
2616 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2617 short_channel_id: 2316138423780173,
2618 node_id_1: NodeId::from_pubkey(&pubkey_1),
2619 node_id_2: NodeId::from_pubkey(&pubkey_2),
2620 bitcoin_key_1: NodeId::from_pubkey(&pubkey_3),
2621 bitcoin_key_2: NodeId::from_pubkey(&pubkey_4),
2622 excess_data: if excess_data { vec![10, 0, 0, 20, 0, 0, 30, 0, 0, 40] } else { Vec::new() },
2624 let channel_announcement = msgs::ChannelAnnouncement {
2625 node_signature_1: sig_1,
2626 node_signature_2: sig_2,
2627 bitcoin_signature_1: sig_3,
2628 bitcoin_signature_2: sig_4,
2629 contents: unsigned_channel_announcement,
2631 let encoded_value = channel_announcement.encode();
2632 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a1735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap();
2633 if unknown_features_bits {
2634 target_value.append(&mut hex::decode("0002ffff").unwrap());
2636 target_value.append(&mut hex::decode("0000").unwrap());
2638 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2639 target_value.append(&mut hex::decode("00083a840000034d031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
2641 target_value.append(&mut hex::decode("0a00001400001e000028").unwrap());
2643 assert_eq!(encoded_value, target_value);
2647 fn encoding_channel_announcement() {
2648 do_encoding_channel_announcement(true, false);
2649 do_encoding_channel_announcement(false, true);
2650 do_encoding_channel_announcement(false, false);
2651 do_encoding_channel_announcement(true, true);
2654 fn do_encoding_node_announcement(unknown_features_bits: bool, ipv4: bool, ipv6: bool, onionv2: bool, onionv3: bool, hostname: bool, excess_address_data: bool, excess_data: bool) {
2655 let secp_ctx = Secp256k1::new();
2656 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2657 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2658 let features = if unknown_features_bits {
2659 NodeFeatures::from_le_bytes(vec![0xFF, 0xFF])
2661 // Set to some features we may support
2662 NodeFeatures::from_le_bytes(vec![2 | 1 << 5])
2664 let mut addresses = Vec::new();
2666 addresses.push(msgs::NetAddress::IPv4 {
2667 addr: [255, 254, 253, 252],
2672 addresses.push(msgs::NetAddress::IPv6 {
2673 addr: [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240],
2678 addresses.push(msgs::NetAddress::OnionV2(
2679 [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 38, 7]
2683 addresses.push(msgs::NetAddress::OnionV3 {
2684 ed25519_pubkey: [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240, 239, 238, 237, 236, 235, 234, 233, 232, 231, 230, 229, 228, 227, 226, 225, 224],
2691 addresses.push(msgs::NetAddress::Hostname {
2692 hostname: Hostname::try_from(String::from("host")).unwrap(),
2696 let mut addr_len = 0;
2697 for addr in &addresses {
2698 addr_len += addr.len() + 1;
2700 let unsigned_node_announcement = msgs::UnsignedNodeAnnouncement {
2702 timestamp: 20190119,
2703 node_id: NodeId::from_pubkey(&pubkey_1),
2705 alias: NodeAlias([16;32]),
2707 excess_address_data: if excess_address_data { vec![33, 108, 40, 11, 83, 149, 162, 84, 110, 126, 75, 38, 99, 224, 79, 129, 22, 34, 241, 90, 79, 146, 232, 58, 162, 233, 43, 162, 165, 115, 193, 57, 20, 44, 84, 174, 99, 7, 42, 30, 193, 238, 125, 192, 192, 75, 222, 92, 132, 120, 6, 23, 42, 160, 92, 146, 194, 42, 232, 227, 8, 209, 210, 105] } else { Vec::new() },
2708 excess_data: if excess_data { vec![59, 18, 204, 25, 92, 224, 162, 209, 189, 166, 168, 139, 239, 161, 159, 160, 127, 81, 202, 167, 92, 232, 56, 55, 242, 137, 101, 96, 11, 138, 172, 171, 8, 85, 255, 176, 231, 65, 236, 95, 124, 65, 66, 30, 152, 41, 169, 212, 134, 17, 200, 200, 49, 247, 27, 229, 234, 115, 230, 101, 148, 151, 127, 253] } else { Vec::new() },
2710 addr_len += unsigned_node_announcement.excess_address_data.len() as u16;
2711 let node_announcement = msgs::NodeAnnouncement {
2713 contents: unsigned_node_announcement,
2715 let encoded_value = node_announcement.encode();
2716 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
2717 if unknown_features_bits {
2718 target_value.append(&mut hex::decode("0002ffff").unwrap());
2720 target_value.append(&mut hex::decode("000122").unwrap());
2722 target_value.append(&mut hex::decode("013413a7031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f2020201010101010101010101010101010101010101010101010101010101010101010").unwrap());
2723 target_value.append(&mut vec![(addr_len >> 8) as u8, addr_len as u8]);
2725 target_value.append(&mut hex::decode("01fffefdfc2607").unwrap());
2728 target_value.append(&mut hex::decode("02fffefdfcfbfaf9f8f7f6f5f4f3f2f1f02607").unwrap());
2731 target_value.append(&mut hex::decode("03fffefdfcfbfaf9f8f7f62607").unwrap());
2734 target_value.append(&mut hex::decode("04fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0efeeedecebeae9e8e7e6e5e4e3e2e1e00020102607").unwrap());
2737 target_value.append(&mut hex::decode("0504686f73742607").unwrap());
2739 if excess_address_data {
2740 target_value.append(&mut hex::decode("216c280b5395a2546e7e4b2663e04f811622f15a4f92e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d269").unwrap());
2743 target_value.append(&mut hex::decode("3b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
2745 assert_eq!(encoded_value, target_value);
2749 fn encoding_node_announcement() {
2750 do_encoding_node_announcement(true, true, true, true, true, true, true, true);
2751 do_encoding_node_announcement(false, false, false, false, false, false, false, false);
2752 do_encoding_node_announcement(false, true, false, false, false, false, false, false);
2753 do_encoding_node_announcement(false, false, true, false, false, false, false, false);
2754 do_encoding_node_announcement(false, false, false, true, false, false, false, false);
2755 do_encoding_node_announcement(false, false, false, false, true, false, false, false);
2756 do_encoding_node_announcement(false, false, false, false, false, true, false, false);
2757 do_encoding_node_announcement(false, false, false, false, false, false, true, false);
2758 do_encoding_node_announcement(false, true, false, true, false, false, true, false);
2759 do_encoding_node_announcement(false, false, true, false, true, false, false, false);
2762 fn do_encoding_channel_update(direction: bool, disable: bool, excess_data: bool) {
2763 let secp_ctx = Secp256k1::new();
2764 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2765 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2766 let unsigned_channel_update = msgs::UnsignedChannelUpdate {
2767 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2768 short_channel_id: 2316138423780173,
2769 timestamp: 20190119,
2770 flags: if direction { 1 } else { 0 } | if disable { 1 << 1 } else { 0 },
2771 cltv_expiry_delta: 144,
2772 htlc_minimum_msat: 1000000,
2773 htlc_maximum_msat: 131355275467161,
2774 fee_base_msat: 10000,
2775 fee_proportional_millionths: 20,
2776 excess_data: if excess_data { vec![0, 0, 0, 0, 59, 154, 202, 0] } else { Vec::new() }
2778 let channel_update = msgs::ChannelUpdate {
2780 contents: unsigned_channel_update
2782 let encoded_value = channel_update.encode();
2783 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
2784 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2785 target_value.append(&mut hex::decode("00083a840000034d013413a7").unwrap());
2786 target_value.append(&mut hex::decode("01").unwrap());
2787 target_value.append(&mut hex::decode("00").unwrap());
2789 let flag = target_value.last_mut().unwrap();
2793 let flag = target_value.last_mut().unwrap();
2794 *flag = *flag | 1 << 1;
2796 target_value.append(&mut hex::decode("009000000000000f42400000271000000014").unwrap());
2797 target_value.append(&mut hex::decode("0000777788889999").unwrap());
2799 target_value.append(&mut hex::decode("000000003b9aca00").unwrap());
2801 assert_eq!(encoded_value, target_value);
2805 fn encoding_channel_update() {
2806 do_encoding_channel_update(false, false, false);
2807 do_encoding_channel_update(false, false, true);
2808 do_encoding_channel_update(true, false, false);
2809 do_encoding_channel_update(true, false, true);
2810 do_encoding_channel_update(false, true, false);
2811 do_encoding_channel_update(false, true, true);
2812 do_encoding_channel_update(true, true, false);
2813 do_encoding_channel_update(true, true, true);
2816 fn do_encoding_open_channel(random_bit: bool, shutdown: bool, incl_chan_type: bool) {
2817 let secp_ctx = Secp256k1::new();
2818 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2819 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2820 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2821 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2822 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
2823 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
2824 let open_channel = msgs::OpenChannel {
2825 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2826 temporary_channel_id: ChannelId::from_bytes([2; 32]),
2827 funding_satoshis: 1311768467284833366,
2828 push_msat: 2536655962884945560,
2829 dust_limit_satoshis: 3608586615801332854,
2830 max_htlc_value_in_flight_msat: 8517154655701053848,
2831 channel_reserve_satoshis: 8665828695742877976,
2832 htlc_minimum_msat: 2316138423780173,
2833 feerate_per_kw: 821716,
2834 to_self_delay: 49340,
2835 max_accepted_htlcs: 49340,
2836 funding_pubkey: pubkey_1,
2837 revocation_basepoint: pubkey_2,
2838 payment_point: pubkey_3,
2839 delayed_payment_basepoint: pubkey_4,
2840 htlc_basepoint: pubkey_5,
2841 first_per_commitment_point: pubkey_6,
2842 channel_flags: if random_bit { 1 << 5 } else { 0 },
2843 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
2844 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
2846 let encoded_value = open_channel.encode();
2847 let mut target_value = Vec::new();
2848 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2849 target_value.append(&mut hex::decode("02020202020202020202020202020202020202020202020202020202020202021234567890123456233403289122369832144668701144767633030896203198784335490624111800083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
2851 target_value.append(&mut hex::decode("20").unwrap());
2853 target_value.append(&mut hex::decode("00").unwrap());
2856 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
2859 target_value.append(&mut hex::decode("0100").unwrap());
2861 assert_eq!(encoded_value, target_value);
2865 fn encoding_open_channel() {
2866 do_encoding_open_channel(false, false, false);
2867 do_encoding_open_channel(false, false, true);
2868 do_encoding_open_channel(false, true, false);
2869 do_encoding_open_channel(false, true, true);
2870 do_encoding_open_channel(true, false, false);
2871 do_encoding_open_channel(true, false, true);
2872 do_encoding_open_channel(true, true, false);
2873 do_encoding_open_channel(true, true, true);
2876 fn do_encoding_open_channelv2(random_bit: bool, shutdown: bool, incl_chan_type: bool, require_confirmed_inputs: bool) {
2877 let secp_ctx = Secp256k1::new();
2878 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2879 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2880 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2881 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2882 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
2883 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
2884 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
2885 let open_channelv2 = msgs::OpenChannelV2 {
2886 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2887 temporary_channel_id: ChannelId::from_bytes([2; 32]),
2888 funding_feerate_sat_per_1000_weight: 821716,
2889 commitment_feerate_sat_per_1000_weight: 821716,
2890 funding_satoshis: 1311768467284833366,
2891 dust_limit_satoshis: 3608586615801332854,
2892 max_htlc_value_in_flight_msat: 8517154655701053848,
2893 htlc_minimum_msat: 2316138423780173,
2894 to_self_delay: 49340,
2895 max_accepted_htlcs: 49340,
2896 locktime: 305419896,
2897 funding_pubkey: pubkey_1,
2898 revocation_basepoint: pubkey_2,
2899 payment_basepoint: pubkey_3,
2900 delayed_payment_basepoint: pubkey_4,
2901 htlc_basepoint: pubkey_5,
2902 first_per_commitment_point: pubkey_6,
2903 second_per_commitment_point: pubkey_7,
2904 channel_flags: if random_bit { 1 << 5 } else { 0 },
2905 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
2906 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
2907 require_confirmed_inputs: if require_confirmed_inputs { Some(()) } else { None },
2909 let encoded_value = open_channelv2.encode();
2910 let mut target_value = Vec::new();
2911 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2912 target_value.append(&mut hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap());
2913 target_value.append(&mut hex::decode("000c89d4").unwrap());
2914 target_value.append(&mut hex::decode("000c89d4").unwrap());
2915 target_value.append(&mut hex::decode("1234567890123456").unwrap());
2916 target_value.append(&mut hex::decode("3214466870114476").unwrap());
2917 target_value.append(&mut hex::decode("7633030896203198").unwrap());
2918 target_value.append(&mut hex::decode("00083a840000034d").unwrap());
2919 target_value.append(&mut hex::decode("c0bc").unwrap());
2920 target_value.append(&mut hex::decode("c0bc").unwrap());
2921 target_value.append(&mut hex::decode("12345678").unwrap());
2922 target_value.append(&mut hex::decode("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap());
2923 target_value.append(&mut hex::decode("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap());
2924 target_value.append(&mut hex::decode("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap());
2925 target_value.append(&mut hex::decode("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
2926 target_value.append(&mut hex::decode("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap());
2927 target_value.append(&mut hex::decode("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
2928 target_value.append(&mut hex::decode("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap());
2931 target_value.append(&mut hex::decode("20").unwrap());
2933 target_value.append(&mut hex::decode("00").unwrap());
2936 target_value.append(&mut hex::decode("001b").unwrap()); // Type 0 + Length 27
2937 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
2940 target_value.append(&mut hex::decode("0100").unwrap());
2942 if require_confirmed_inputs {
2943 target_value.append(&mut hex::decode("0200").unwrap());
2945 assert_eq!(encoded_value, target_value);
2949 fn encoding_open_channelv2() {
2950 do_encoding_open_channelv2(false, false, false, false);
2951 do_encoding_open_channelv2(false, false, false, true);
2952 do_encoding_open_channelv2(false, false, true, false);
2953 do_encoding_open_channelv2(false, false, true, true);
2954 do_encoding_open_channelv2(false, true, false, false);
2955 do_encoding_open_channelv2(false, true, false, true);
2956 do_encoding_open_channelv2(false, true, true, false);
2957 do_encoding_open_channelv2(false, true, true, true);
2958 do_encoding_open_channelv2(true, false, false, false);
2959 do_encoding_open_channelv2(true, false, false, true);
2960 do_encoding_open_channelv2(true, false, true, false);
2961 do_encoding_open_channelv2(true, false, true, true);
2962 do_encoding_open_channelv2(true, true, false, false);
2963 do_encoding_open_channelv2(true, true, false, true);
2964 do_encoding_open_channelv2(true, true, true, false);
2965 do_encoding_open_channelv2(true, true, true, true);
2968 fn do_encoding_accept_channel(shutdown: bool) {
2969 let secp_ctx = Secp256k1::new();
2970 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2971 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2972 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2973 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2974 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
2975 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
2976 let accept_channel = msgs::AcceptChannel {
2977 temporary_channel_id: ChannelId::from_bytes([2; 32]),
2978 dust_limit_satoshis: 1311768467284833366,
2979 max_htlc_value_in_flight_msat: 2536655962884945560,
2980 channel_reserve_satoshis: 3608586615801332854,
2981 htlc_minimum_msat: 2316138423780173,
2982 minimum_depth: 821716,
2983 to_self_delay: 49340,
2984 max_accepted_htlcs: 49340,
2985 funding_pubkey: pubkey_1,
2986 revocation_basepoint: pubkey_2,
2987 payment_point: pubkey_3,
2988 delayed_payment_basepoint: pubkey_4,
2989 htlc_basepoint: pubkey_5,
2990 first_per_commitment_point: pubkey_6,
2991 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
2994 next_local_nonce: None,
2996 let encoded_value = accept_channel.encode();
2997 let mut target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020212345678901234562334032891223698321446687011447600083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap();
2999 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3001 assert_eq!(encoded_value, target_value);
3005 fn encoding_accept_channel() {
3006 do_encoding_accept_channel(false);
3007 do_encoding_accept_channel(true);
3010 fn do_encoding_accept_channelv2(shutdown: bool) {
3011 let secp_ctx = Secp256k1::new();
3012 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3013 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3014 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3015 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3016 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3017 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3018 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3019 let accept_channelv2 = msgs::AcceptChannelV2 {
3020 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3021 funding_satoshis: 1311768467284833366,
3022 dust_limit_satoshis: 1311768467284833366,
3023 max_htlc_value_in_flight_msat: 2536655962884945560,
3024 htlc_minimum_msat: 2316138423780173,
3025 minimum_depth: 821716,
3026 to_self_delay: 49340,
3027 max_accepted_htlcs: 49340,
3028 funding_pubkey: pubkey_1,
3029 revocation_basepoint: pubkey_2,
3030 payment_basepoint: pubkey_3,
3031 delayed_payment_basepoint: pubkey_4,
3032 htlc_basepoint: pubkey_5,
3033 first_per_commitment_point: pubkey_6,
3034 second_per_commitment_point: pubkey_7,
3035 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3037 require_confirmed_inputs: None,
3039 let encoded_value = accept_channelv2.encode();
3040 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // temporary_channel_id
3041 target_value.append(&mut hex::decode("1234567890123456").unwrap()); // funding_satoshis
3042 target_value.append(&mut hex::decode("1234567890123456").unwrap()); // dust_limit_satoshis
3043 target_value.append(&mut hex::decode("2334032891223698").unwrap()); // max_htlc_value_in_flight_msat
3044 target_value.append(&mut hex::decode("00083a840000034d").unwrap()); // htlc_minimum_msat
3045 target_value.append(&mut hex::decode("000c89d4").unwrap()); // minimum_depth
3046 target_value.append(&mut hex::decode("c0bc").unwrap()); // to_self_delay
3047 target_value.append(&mut hex::decode("c0bc").unwrap()); // max_accepted_htlcs
3048 target_value.append(&mut hex::decode("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap()); // funding_pubkey
3049 target_value.append(&mut hex::decode("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap()); // revocation_basepoint
3050 target_value.append(&mut hex::decode("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap()); // payment_basepoint
3051 target_value.append(&mut hex::decode("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap()); // delayed_payment_basepoint
3052 target_value.append(&mut hex::decode("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap()); // htlc_basepoint
3053 target_value.append(&mut hex::decode("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap()); // first_per_commitment_point
3054 target_value.append(&mut hex::decode("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap()); // second_per_commitment_point
3056 target_value.append(&mut hex::decode("001b").unwrap()); // Type 0 + Length 27
3057 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3059 assert_eq!(encoded_value, target_value);
3063 fn encoding_accept_channelv2() {
3064 do_encoding_accept_channelv2(false);
3065 do_encoding_accept_channelv2(true);
3069 fn encoding_funding_created() {
3070 let secp_ctx = Secp256k1::new();
3071 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3072 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3073 let funding_created = msgs::FundingCreated {
3074 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3075 funding_txid: Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3076 funding_output_index: 255,
3079 partial_signature_with_nonce: None,
3081 next_local_nonce: None,
3083 let encoded_value = funding_created.encode();
3084 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202026e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c200ffd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3085 assert_eq!(encoded_value, target_value);
3089 fn encoding_funding_signed() {
3090 let secp_ctx = Secp256k1::new();
3091 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3092 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3093 let funding_signed = msgs::FundingSigned {
3094 channel_id: ChannelId::from_bytes([2; 32]),
3097 partial_signature_with_nonce: None,
3099 let encoded_value = funding_signed.encode();
3100 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3101 assert_eq!(encoded_value, target_value);
3105 fn encoding_channel_ready() {
3106 let secp_ctx = Secp256k1::new();
3107 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3108 let channel_ready = msgs::ChannelReady {
3109 channel_id: ChannelId::from_bytes([2; 32]),
3110 next_per_commitment_point: pubkey_1,
3111 short_channel_id_alias: None,
3113 let encoded_value = channel_ready.encode();
3114 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3115 assert_eq!(encoded_value, target_value);
3119 fn encoding_tx_add_input() {
3120 let tx_add_input = msgs::TxAddInput {
3121 channel_id: ChannelId::from_bytes([2; 32]),
3122 serial_id: 4886718345,
3123 prevtx: TransactionU16LenLimited::new(Transaction {
3125 lock_time: PackedLockTime(0),
3127 previous_output: OutPoint { txid: Txid::from_hex("305bab643ee297b8b6b76b320792c8223d55082122cb606bf89382146ced9c77").unwrap(), index: 2 }.into_bitcoin_outpoint(),
3128 script_sig: Script::new(),
3129 sequence: Sequence(0xfffffffd),
3130 witness: Witness::from_vec(vec![
3131 hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3132 hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3137 script_pubkey: Address::from_str("bc1qzlffunw52jav8vwdu5x3jfk6sr8u22rmq3xzw2").unwrap().script_pubkey(),
3141 script_pubkey: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().script_pubkey(),
3145 prevtx_out: 305419896,
3146 sequence: 305419896,
3148 let encoded_value = tx_add_input.encode();
3149 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000000012345678900de02000000000101779ced6c148293f86b60cb222108553d22c89207326bb7b6b897e23e64ab5b300200000000fdffffff0236dbc1000000000016001417d29e4dd454bac3b1cde50d1926da80cfc5287b9cbd03000000000016001436ec78d514df462da95e6a00c24daa8915362d420247304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701210301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944000000001234567812345678").unwrap();
3150 assert_eq!(encoded_value, target_value);
3154 fn encoding_tx_add_output() {
3155 let tx_add_output = msgs::TxAddOutput {
3156 channel_id: ChannelId::from_bytes([2; 32]),
3157 serial_id: 4886718345,
3159 script: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().script_pubkey(),
3161 let encoded_value = tx_add_output.encode();
3162 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000000012345678900000001234567890016001436ec78d514df462da95e6a00c24daa8915362d42").unwrap();
3163 assert_eq!(encoded_value, target_value);
3167 fn encoding_tx_remove_input() {
3168 let tx_remove_input = msgs::TxRemoveInput {
3169 channel_id: ChannelId::from_bytes([2; 32]),
3170 serial_id: 4886718345,
3172 let encoded_value = tx_remove_input.encode();
3173 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3174 assert_eq!(encoded_value, target_value);
3178 fn encoding_tx_remove_output() {
3179 let tx_remove_output = msgs::TxRemoveOutput {
3180 channel_id: ChannelId::from_bytes([2; 32]),
3181 serial_id: 4886718345,
3183 let encoded_value = tx_remove_output.encode();
3184 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3185 assert_eq!(encoded_value, target_value);
3189 fn encoding_tx_complete() {
3190 let tx_complete = msgs::TxComplete {
3191 channel_id: ChannelId::from_bytes([2; 32]),
3193 let encoded_value = tx_complete.encode();
3194 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3195 assert_eq!(encoded_value, target_value);
3199 fn encoding_tx_signatures() {
3200 let tx_signatures = msgs::TxSignatures {
3201 channel_id: ChannelId::from_bytes([2; 32]),
3202 tx_hash: Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3204 Witness::from_vec(vec![
3205 hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3206 hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3207 Witness::from_vec(vec![
3208 hex::decode("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap(),
3209 hex::decode("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap()]),
3212 let encoded_value = tx_signatures.encode();
3213 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3214 target_value.append(&mut hex::decode("6e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c2").unwrap()); // tx_hash (sha256) (big endian byte order)
3215 target_value.append(&mut hex::decode("0002").unwrap()); // num_witnesses (u16)
3217 target_value.append(&mut hex::decode("006b").unwrap()); // len of witness_data
3218 target_value.append(&mut hex::decode("02").unwrap()); // num_witness_elements (VarInt)
3219 target_value.append(&mut hex::decode("47").unwrap()); // len of witness element data (VarInt)
3220 target_value.append(&mut hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap());
3221 target_value.append(&mut hex::decode("21").unwrap()); // len of witness element data (VarInt)
3222 target_value.append(&mut hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap());
3224 target_value.append(&mut hex::decode("006c").unwrap()); // len of witness_data
3225 target_value.append(&mut hex::decode("02").unwrap()); // num_witness_elements (VarInt)
3226 target_value.append(&mut hex::decode("48").unwrap()); // len of witness element data (VarInt)
3227 target_value.append(&mut hex::decode("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap());
3228 target_value.append(&mut hex::decode("21").unwrap()); // len of witness element data (VarInt)
3229 target_value.append(&mut hex::decode("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap());
3230 assert_eq!(encoded_value, target_value);
3233 fn do_encoding_tx_init_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3234 let tx_init_rbf = msgs::TxInitRbf {
3235 channel_id: ChannelId::from_bytes([2; 32]),
3236 locktime: 305419896,
3237 feerate_sat_per_1000_weight: 20190119,
3238 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3240 let encoded_value = tx_init_rbf.encode();
3241 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3242 target_value.append(&mut hex::decode("12345678").unwrap()); // locktime
3243 target_value.append(&mut hex::decode("013413a7").unwrap()); // feerate_sat_per_1000_weight
3244 if let Some((_, target)) = funding_value_with_hex_target {
3245 target_value.push(0x00); // Type
3246 target_value.push(target.len() as u8 / 2); // Length
3247 target_value.append(&mut hex::decode(target).unwrap()); // Value (i64)
3249 assert_eq!(encoded_value, target_value);
3253 fn encoding_tx_init_rbf() {
3254 do_encoding_tx_init_rbf(Some((1311768467284833366, "1234567890123456")));
3255 do_encoding_tx_init_rbf(Some((13117684672, "000000030DDFFBC0")));
3256 do_encoding_tx_init_rbf(None);
3259 fn do_encoding_tx_ack_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3260 let tx_ack_rbf = msgs::TxAckRbf {
3261 channel_id: ChannelId::from_bytes([2; 32]),
3262 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3264 let encoded_value = tx_ack_rbf.encode();
3265 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3266 if let Some((_, target)) = funding_value_with_hex_target {
3267 target_value.push(0x00); // Type
3268 target_value.push(target.len() as u8 / 2); // Length
3269 target_value.append(&mut hex::decode(target).unwrap()); // Value (i64)
3271 assert_eq!(encoded_value, target_value);
3275 fn encoding_tx_ack_rbf() {
3276 do_encoding_tx_ack_rbf(Some((1311768467284833366, "1234567890123456")));
3277 do_encoding_tx_ack_rbf(Some((13117684672, "000000030DDFFBC0")));
3278 do_encoding_tx_ack_rbf(None);
3282 fn encoding_tx_abort() {
3283 let tx_abort = msgs::TxAbort {
3284 channel_id: ChannelId::from_bytes([2; 32]),
3285 data: hex::decode("54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap(),
3287 let encoded_value = tx_abort.encode();
3288 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202002C54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap();
3289 assert_eq!(encoded_value, target_value);
3292 fn do_encoding_shutdown(script_type: u8) {
3293 let secp_ctx = Secp256k1::new();
3294 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3295 let script = Builder::new().push_opcode(opcodes::OP_TRUE).into_script();
3296 let shutdown = msgs::Shutdown {
3297 channel_id: ChannelId::from_bytes([2; 32]),
3299 if script_type == 1 { Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey() }
3300 else if script_type == 2 { Address::p2sh(&script, Network::Testnet).unwrap().script_pubkey() }
3301 else if script_type == 3 { Address::p2wpkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).unwrap().script_pubkey() }
3302 else { Address::p2wsh(&script, Network::Testnet).script_pubkey() },
3304 let encoded_value = shutdown.encode();
3305 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3306 if script_type == 1 {
3307 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3308 } else if script_type == 2 {
3309 target_value.append(&mut hex::decode("0017a914da1745e9b549bd0bfa1a569971c77eba30cd5a4b87").unwrap());
3310 } else if script_type == 3 {
3311 target_value.append(&mut hex::decode("0016001479b000887626b294a914501a4cd226b58b235983").unwrap());
3312 } else if script_type == 4 {
3313 target_value.append(&mut hex::decode("002200204ae81572f06e1b88fd5ced7a1a000945432e83e1551e6f721ee9c00b8cc33260").unwrap());
3315 assert_eq!(encoded_value, target_value);
3319 fn encoding_shutdown() {
3320 do_encoding_shutdown(1);
3321 do_encoding_shutdown(2);
3322 do_encoding_shutdown(3);
3323 do_encoding_shutdown(4);
3327 fn encoding_closing_signed() {
3328 let secp_ctx = Secp256k1::new();
3329 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3330 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3331 let closing_signed = msgs::ClosingSigned {
3332 channel_id: ChannelId::from_bytes([2; 32]),
3333 fee_satoshis: 2316138423780173,
3337 let encoded_value = closing_signed.encode();
3338 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3339 assert_eq!(encoded_value, target_value);
3340 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value)).unwrap(), closing_signed);
3342 let closing_signed_with_range = msgs::ClosingSigned {
3343 channel_id: ChannelId::from_bytes([2; 32]),
3344 fee_satoshis: 2316138423780173,
3346 fee_range: Some(msgs::ClosingSignedFeeRange {
3347 min_fee_satoshis: 0xdeadbeef,
3348 max_fee_satoshis: 0x1badcafe01234567,
3351 let encoded_value_with_range = closing_signed_with_range.encode();
3352 let target_value_with_range = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a011000000000deadbeef1badcafe01234567").unwrap();
3353 assert_eq!(encoded_value_with_range, target_value_with_range);
3354 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value_with_range)).unwrap(),
3355 closing_signed_with_range);
3359 fn encoding_update_add_htlc() {
3360 let secp_ctx = Secp256k1::new();
3361 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3362 let onion_routing_packet = msgs::OnionPacket {
3364 public_key: Ok(pubkey_1),
3365 hop_data: [1; 20*65],
3368 let update_add_htlc = msgs::UpdateAddHTLC {
3369 channel_id: ChannelId::from_bytes([2; 32]),
3370 htlc_id: 2316138423780173,
3371 amount_msat: 3608586615801332854,
3372 payment_hash: PaymentHash([1; 32]),
3373 cltv_expiry: 821716,
3374 onion_routing_packet,
3375 skimmed_fee_msat: None,
3377 let encoded_value = update_add_htlc.encode();
3378 let target_value = hex::decode("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").unwrap();
3379 assert_eq!(encoded_value, target_value);
3383 fn encoding_update_fulfill_htlc() {
3384 let update_fulfill_htlc = msgs::UpdateFulfillHTLC {
3385 channel_id: ChannelId::from_bytes([2; 32]),
3386 htlc_id: 2316138423780173,
3387 payment_preimage: PaymentPreimage([1; 32]),
3389 let encoded_value = update_fulfill_htlc.encode();
3390 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d0101010101010101010101010101010101010101010101010101010101010101").unwrap();
3391 assert_eq!(encoded_value, target_value);
3395 fn encoding_update_fail_htlc() {
3396 let reason = OnionErrorPacket {
3397 data: [1; 32].to_vec(),
3399 let update_fail_htlc = msgs::UpdateFailHTLC {
3400 channel_id: ChannelId::from_bytes([2; 32]),
3401 htlc_id: 2316138423780173,
3404 let encoded_value = update_fail_htlc.encode();
3405 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d00200101010101010101010101010101010101010101010101010101010101010101").unwrap();
3406 assert_eq!(encoded_value, target_value);
3410 fn encoding_update_fail_malformed_htlc() {
3411 let update_fail_malformed_htlc = msgs::UpdateFailMalformedHTLC {
3412 channel_id: ChannelId::from_bytes([2; 32]),
3413 htlc_id: 2316138423780173,
3414 sha256_of_onion: [1; 32],
3417 let encoded_value = update_fail_malformed_htlc.encode();
3418 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d010101010101010101010101010101010101010101010101010101010101010100ff").unwrap();
3419 assert_eq!(encoded_value, target_value);
3422 fn do_encoding_commitment_signed(htlcs: bool) {
3423 let secp_ctx = Secp256k1::new();
3424 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3425 let (privkey_2, _) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3426 let (privkey_3, _) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3427 let (privkey_4, _) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3428 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3429 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
3430 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
3431 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
3432 let commitment_signed = msgs::CommitmentSigned {
3433 channel_id: ChannelId::from_bytes([2; 32]),
3435 htlc_signatures: if htlcs { vec![sig_2, sig_3, sig_4] } else { Vec::new() },
3437 partial_signature_with_nonce: None,
3439 let encoded_value = commitment_signed.encode();
3440 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3442 target_value.append(&mut hex::decode("00031735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
3444 target_value.append(&mut hex::decode("0000").unwrap());
3446 assert_eq!(encoded_value, target_value);
3450 fn encoding_commitment_signed() {
3451 do_encoding_commitment_signed(true);
3452 do_encoding_commitment_signed(false);
3456 fn encoding_revoke_and_ack() {
3457 let secp_ctx = Secp256k1::new();
3458 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3459 let raa = msgs::RevokeAndACK {
3460 channel_id: ChannelId::from_bytes([2; 32]),
3461 per_commitment_secret: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
3462 next_per_commitment_point: pubkey_1,
3464 next_local_nonce: None,
3466 let encoded_value = raa.encode();
3467 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020101010101010101010101010101010101010101010101010101010101010101031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3468 assert_eq!(encoded_value, target_value);
3472 fn encoding_update_fee() {
3473 let update_fee = msgs::UpdateFee {
3474 channel_id: ChannelId::from_bytes([2; 32]),
3475 feerate_per_kw: 20190119,
3477 let encoded_value = update_fee.encode();
3478 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202013413a7").unwrap();
3479 assert_eq!(encoded_value, target_value);
3483 fn encoding_init() {
3484 let mainnet_hash = ChainHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap();
3485 assert_eq!(msgs::Init {
3486 features: InitFeatures::from_le_bytes(vec![0xFF, 0xFF, 0xFF]),
3487 networks: Some(vec![mainnet_hash]),
3488 remote_network_address: None,
3489 }.encode(), hex::decode("00023fff0003ffffff01206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3490 assert_eq!(msgs::Init {
3491 features: InitFeatures::from_le_bytes(vec![0xFF]),
3493 remote_network_address: None,
3494 }.encode(), hex::decode("0001ff0001ff").unwrap());
3495 assert_eq!(msgs::Init {
3496 features: InitFeatures::from_le_bytes(vec![]),
3497 networks: Some(vec![mainnet_hash]),
3498 remote_network_address: None,
3499 }.encode(), hex::decode("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3500 assert_eq!(msgs::Init {
3501 features: InitFeatures::from_le_bytes(vec![]),
3502 networks: Some(vec![ChainHash::from(&[1; 32][..]), ChainHash::from(&[2; 32][..])]),
3503 remote_network_address: None,
3504 }.encode(), hex::decode("00000000014001010101010101010101010101010101010101010101010101010101010101010202020202020202020202020202020202020202020202020202020202020202").unwrap());
3505 let init_msg = msgs::Init { features: InitFeatures::from_le_bytes(vec![]),
3506 networks: Some(vec![mainnet_hash]),
3507 remote_network_address: Some(msgs::NetAddress::IPv4 {
3508 addr: [127, 0, 0, 1],
3512 let encoded_value = init_msg.encode();
3513 let target_value = hex::decode("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d61900000000000307017f00000103e8").unwrap();
3514 assert_eq!(encoded_value, target_value);
3515 assert_eq!(msgs::Init::read(&mut Cursor::new(&target_value)).unwrap(), init_msg);
3519 fn encoding_error() {
3520 let error = msgs::ErrorMessage {
3521 channel_id: ChannelId::from_bytes([2; 32]),
3522 data: String::from("rust-lightning"),
3524 let encoded_value = error.encode();
3525 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3526 assert_eq!(encoded_value, target_value);
3530 fn encoding_warning() {
3531 let error = msgs::WarningMessage {
3532 channel_id: ChannelId::from_bytes([2; 32]),
3533 data: String::from("rust-lightning"),
3535 let encoded_value = error.encode();
3536 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3537 assert_eq!(encoded_value, target_value);
3541 fn encoding_ping() {
3542 let ping = msgs::Ping {
3546 let encoded_value = ping.encode();
3547 let target_value = hex::decode("0040004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3548 assert_eq!(encoded_value, target_value);
3552 fn encoding_pong() {
3553 let pong = msgs::Pong {
3556 let encoded_value = pong.encode();
3557 let target_value = hex::decode("004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3558 assert_eq!(encoded_value, target_value);
3562 fn encoding_nonfinal_onion_hop_data() {
3563 let outbound_msg = msgs::OutboundOnionPayload::Forward {
3564 short_channel_id: 0xdeadbeef1bad1dea,
3565 amt_to_forward: 0x0badf00d01020304,
3566 outgoing_cltv_value: 0xffffffff,
3568 let encoded_value = outbound_msg.encode();
3569 let target_value = hex::decode("1a02080badf00d010203040404ffffffff0608deadbeef1bad1dea").unwrap();
3570 assert_eq!(encoded_value, target_value);
3572 let inbound_msg = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3573 if let msgs::InboundOnionPayload::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } = inbound_msg {
3574 assert_eq!(short_channel_id, 0xdeadbeef1bad1dea);
3575 assert_eq!(amt_to_forward, 0x0badf00d01020304);
3576 assert_eq!(outgoing_cltv_value, 0xffffffff);
3577 } else { panic!(); }
3581 fn encoding_final_onion_hop_data() {
3582 let outbound_msg = msgs::OutboundOnionPayload::Receive {
3584 payment_metadata: None,
3585 keysend_preimage: None,
3586 amt_msat: 0x0badf00d01020304,
3587 outgoing_cltv_value: 0xffffffff,
3588 custom_tlvs: vec![],
3590 let encoded_value = outbound_msg.encode();
3591 let target_value = hex::decode("1002080badf00d010203040404ffffffff").unwrap();
3592 assert_eq!(encoded_value, target_value);
3594 let inbound_msg = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3595 if let msgs::InboundOnionPayload::Receive { payment_data: None, amt_msat, outgoing_cltv_value, .. } = inbound_msg {
3596 assert_eq!(amt_msat, 0x0badf00d01020304);
3597 assert_eq!(outgoing_cltv_value, 0xffffffff);
3598 } else { panic!(); }
3602 fn encoding_final_onion_hop_data_with_secret() {
3603 let expected_payment_secret = PaymentSecret([0x42u8; 32]);
3604 let outbound_msg = msgs::OutboundOnionPayload::Receive {
3605 payment_data: Some(FinalOnionHopData {
3606 payment_secret: expected_payment_secret,
3607 total_msat: 0x1badca1f
3609 payment_metadata: None,
3610 keysend_preimage: None,
3611 amt_msat: 0x0badf00d01020304,
3612 outgoing_cltv_value: 0xffffffff,
3613 custom_tlvs: vec![],
3615 let encoded_value = outbound_msg.encode();
3616 let target_value = hex::decode("3602080badf00d010203040404ffffffff082442424242424242424242424242424242424242424242424242424242424242421badca1f").unwrap();
3617 assert_eq!(encoded_value, target_value);
3619 let inbound_msg = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3620 if let msgs::InboundOnionPayload::Receive {
3621 payment_data: Some(FinalOnionHopData {
3623 total_msat: 0x1badca1f
3625 amt_msat, outgoing_cltv_value,
3626 payment_metadata: None,
3627 keysend_preimage: None,
3630 assert_eq!(payment_secret, expected_payment_secret);
3631 assert_eq!(amt_msat, 0x0badf00d01020304);
3632 assert_eq!(outgoing_cltv_value, 0xffffffff);
3633 assert_eq!(custom_tlvs, vec![]);
3634 } else { panic!(); }
3638 fn encoding_final_onion_hop_data_with_bad_custom_tlvs() {
3639 // If custom TLVs have type number within the range reserved for protocol, treat them as if
3641 let bad_type_range_tlvs = vec![
3642 ((1 << 16) - 4, vec![42]),
3643 ((1 << 16) - 2, vec![42; 32]),
3645 let mut msg = msgs::OutboundOnionPayload::Receive {
3647 payment_metadata: None,
3648 keysend_preimage: None,
3649 custom_tlvs: bad_type_range_tlvs,
3650 amt_msat: 0x0badf00d01020304,
3651 outgoing_cltv_value: 0xffffffff,
3653 let encoded_value = msg.encode();
3654 assert!(msgs::InboundOnionPayload::read(&mut Cursor::new(&encoded_value[..])).is_err());
3655 let good_type_range_tlvs = vec![
3656 ((1 << 16) - 3, vec![42]),
3657 ((1 << 16) - 1, vec![42; 32]),
3659 if let msgs::OutboundOnionPayload::Receive { ref mut custom_tlvs, .. } = msg {
3660 *custom_tlvs = good_type_range_tlvs.clone();
3662 let encoded_value = msg.encode();
3663 let inbound_msg = Readable::read(&mut Cursor::new(&encoded_value[..])).unwrap();
3665 msgs::InboundOnionPayload::Receive { custom_tlvs, .. } => assert!(custom_tlvs.is_empty()),
3671 fn encoding_final_onion_hop_data_with_custom_tlvs() {
3672 let expected_custom_tlvs = vec![
3673 (5482373483, vec![0x12, 0x34]),
3674 (5482373487, vec![0x42u8; 8]),
3676 let msg = msgs::OutboundOnionPayload::Receive {
3678 payment_metadata: None,
3679 keysend_preimage: None,
3680 custom_tlvs: expected_custom_tlvs.clone(),
3681 amt_msat: 0x0badf00d01020304,
3682 outgoing_cltv_value: 0xffffffff,
3684 let encoded_value = msg.encode();
3685 let target_value = hex::decode("2e02080badf00d010203040404ffffffffff0000000146c6616b021234ff0000000146c6616f084242424242424242").unwrap();
3686 assert_eq!(encoded_value, target_value);
3687 let inbound_msg: msgs::InboundOnionPayload = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3688 if let msgs::InboundOnionPayload::Receive {
3690 payment_metadata: None,
3691 keysend_preimage: None,
3694 outgoing_cltv_value,
3697 assert_eq!(custom_tlvs, expected_custom_tlvs);
3698 assert_eq!(amt_msat, 0x0badf00d01020304);
3699 assert_eq!(outgoing_cltv_value, 0xffffffff);
3700 } else { panic!(); }
3704 fn query_channel_range_end_blocknum() {
3705 let tests: Vec<(u32, u32, u32)> = vec![
3706 (10000, 1500, 11500),
3707 (0, 0xffffffff, 0xffffffff),
3708 (1, 0xffffffff, 0xffffffff),
3711 for (first_blocknum, number_of_blocks, expected) in tests.into_iter() {
3712 let sut = msgs::QueryChannelRange {
3713 chain_hash: BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap(),
3717 assert_eq!(sut.end_blocknum(), expected);
3722 fn encoding_query_channel_range() {
3723 let mut query_channel_range = msgs::QueryChannelRange {
3724 chain_hash: BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap(),
3725 first_blocknum: 100000,
3726 number_of_blocks: 1500,
3728 let encoded_value = query_channel_range.encode();
3729 let target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206000186a0000005dc").unwrap();
3730 assert_eq!(encoded_value, target_value);
3732 query_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3733 assert_eq!(query_channel_range.first_blocknum, 100000);
3734 assert_eq!(query_channel_range.number_of_blocks, 1500);
3738 fn encoding_reply_channel_range() {
3739 do_encoding_reply_channel_range(0);
3740 do_encoding_reply_channel_range(1);
3743 fn do_encoding_reply_channel_range(encoding_type: u8) {
3744 let mut target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206000b8a06000005dc01").unwrap();
3745 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3746 let mut reply_channel_range = msgs::ReplyChannelRange {
3747 chain_hash: expected_chain_hash,
3748 first_blocknum: 756230,
3749 number_of_blocks: 1500,
3750 sync_complete: true,
3751 short_channel_ids: vec![0x000000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
3754 if encoding_type == 0 {
3755 target_value.append(&mut hex::decode("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
3756 let encoded_value = reply_channel_range.encode();
3757 assert_eq!(encoded_value, target_value);
3759 reply_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3760 assert_eq!(reply_channel_range.chain_hash, expected_chain_hash);
3761 assert_eq!(reply_channel_range.first_blocknum, 756230);
3762 assert_eq!(reply_channel_range.number_of_blocks, 1500);
3763 assert_eq!(reply_channel_range.sync_complete, true);
3764 assert_eq!(reply_channel_range.short_channel_ids[0], 0x000000000000008e);
3765 assert_eq!(reply_channel_range.short_channel_ids[1], 0x0000000000003c69);
3766 assert_eq!(reply_channel_range.short_channel_ids[2], 0x000000000045a6c4);
3768 target_value.append(&mut hex::decode("001601789c636000833e08659309a65878be010010a9023a").unwrap());
3769 let result: Result<msgs::ReplyChannelRange, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
3770 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
3775 fn encoding_query_short_channel_ids() {
3776 do_encoding_query_short_channel_ids(0);
3777 do_encoding_query_short_channel_ids(1);
3780 fn do_encoding_query_short_channel_ids(encoding_type: u8) {
3781 let mut target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206").unwrap();
3782 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3783 let mut query_short_channel_ids = msgs::QueryShortChannelIds {
3784 chain_hash: expected_chain_hash,
3785 short_channel_ids: vec![0x0000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
3788 if encoding_type == 0 {
3789 target_value.append(&mut hex::decode("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
3790 let encoded_value = query_short_channel_ids.encode();
3791 assert_eq!(encoded_value, target_value);
3793 query_short_channel_ids = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3794 assert_eq!(query_short_channel_ids.chain_hash, expected_chain_hash);
3795 assert_eq!(query_short_channel_ids.short_channel_ids[0], 0x000000000000008e);
3796 assert_eq!(query_short_channel_ids.short_channel_ids[1], 0x0000000000003c69);
3797 assert_eq!(query_short_channel_ids.short_channel_ids[2], 0x000000000045a6c4);
3799 target_value.append(&mut hex::decode("001601789c636000833e08659309a65878be010010a9023a").unwrap());
3800 let result: Result<msgs::QueryShortChannelIds, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
3801 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
3806 fn encoding_reply_short_channel_ids_end() {
3807 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3808 let mut reply_short_channel_ids_end = msgs::ReplyShortChannelIdsEnd {
3809 chain_hash: expected_chain_hash,
3810 full_information: true,
3812 let encoded_value = reply_short_channel_ids_end.encode();
3813 let target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e220601").unwrap();
3814 assert_eq!(encoded_value, target_value);
3816 reply_short_channel_ids_end = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3817 assert_eq!(reply_short_channel_ids_end.chain_hash, expected_chain_hash);
3818 assert_eq!(reply_short_channel_ids_end.full_information, true);
3822 fn encoding_gossip_timestamp_filter(){
3823 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3824 let mut gossip_timestamp_filter = msgs::GossipTimestampFilter {
3825 chain_hash: expected_chain_hash,
3826 first_timestamp: 1590000000,
3827 timestamp_range: 0xffff_ffff,
3829 let encoded_value = gossip_timestamp_filter.encode();
3830 let target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e22065ec57980ffffffff").unwrap();
3831 assert_eq!(encoded_value, target_value);
3833 gossip_timestamp_filter = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3834 assert_eq!(gossip_timestamp_filter.chain_hash, expected_chain_hash);
3835 assert_eq!(gossip_timestamp_filter.first_timestamp, 1590000000);
3836 assert_eq!(gossip_timestamp_filter.timestamp_range, 0xffff_ffff);
3840 fn decode_onion_hop_data_len_as_bigsize() {
3841 // Tests that we can decode an onion payload that is >253 bytes.
3842 // Previously, receiving a payload of this size could've caused us to fail to decode a valid
3843 // payload, because we were decoding the length (a BigSize, big-endian) as a VarInt
3846 // Encode a test onion payload with a big custom TLV such that it's >253 bytes, forcing the
3847 // payload length to be encoded over multiple bytes rather than a single u8.
3848 let big_payload = encode_big_payload().unwrap();
3849 let mut rd = Cursor::new(&big_payload[..]);
3850 <msgs::InboundOnionPayload as Readable>::read(&mut rd).unwrap();
3852 // see above test, needs to be a separate method for use of the serialization macros.
3853 fn encode_big_payload() -> Result<Vec<u8>, io::Error> {
3854 use crate::util::ser::HighZeroBytesDroppedBigSize;
3855 let payload = msgs::OutboundOnionPayload::Forward {
3856 short_channel_id: 0xdeadbeef1bad1dea,
3857 amt_to_forward: 1000,
3858 outgoing_cltv_value: 0xffffffff,
3860 let mut encoded_payload = Vec::new();
3861 let test_bytes = vec![42u8; 1000];
3862 if let msgs::OutboundOnionPayload::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } = payload {
3863 _encode_varint_length_prefixed_tlv!(&mut encoded_payload, {
3864 (1, test_bytes, required_vec),
3865 (2, HighZeroBytesDroppedBigSize(amt_to_forward), required),
3866 (4, HighZeroBytesDroppedBigSize(outgoing_cltv_value), required),
3867 (6, short_channel_id, required)