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::secp256k1::PublicKey;
28 use bitcoin::secp256k1::ecdsa::Signature;
29 use bitcoin::{secp256k1, Witness};
30 use bitcoin::blockdata::script::Script;
31 use bitcoin::hash_types::{Txid, BlockHash};
33 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
34 use crate::ln::onion_utils;
35 use crate::onion_message;
37 use crate::prelude::*;
40 use crate::io::{self, Read};
41 use crate::io_extras::read_to_end;
43 use crate::events::{MessageSendEventsProvider, OnionMessageProvider};
44 use crate::util::logger;
45 use crate::util::ser::{LengthReadable, Readable, ReadableArgs, Writeable, Writer, WithoutLength, FixedLengthReader, HighZeroBytesDroppedBigSize, Hostname, TransactionU16LenLimited};
47 use crate::ln::{PaymentPreimage, PaymentHash, PaymentSecret};
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 /// The receipient's network address.
93 /// This adds the option to report a remote IP address back to a connecting peer using the init
94 /// message. A node can decide to use that information to discover a potential update to its
95 /// public IPv4 address (NAT) and use that for a [`NodeAnnouncement`] update message containing
97 pub remote_network_address: Option<NetAddress>,
100 /// An [`error`] message to be sent to or received from a peer.
102 /// [`error`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-error-and-warning-messages
103 #[derive(Clone, Debug, PartialEq, Eq)]
104 pub struct ErrorMessage {
105 /// The channel ID involved in the error.
107 /// All-0s indicates a general error unrelated to a specific channel, after which all channels
108 /// with the sending peer should be closed.
109 pub channel_id: [u8; 32],
110 /// A possibly human-readable error description.
112 /// The string should be sanitized before it is used (e.g., emitted to logs or printed to
113 /// `stdout`). Otherwise, a well crafted error message may trigger a security vulnerability in
114 /// the terminal emulator or the logging subsystem.
118 /// A [`warning`] message to be sent to or received from a peer.
120 /// [`warning`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-error-and-warning-messages
121 #[derive(Clone, Debug, PartialEq, Eq)]
122 pub struct WarningMessage {
123 /// The channel ID involved in the warning.
125 /// All-0s indicates a warning unrelated to a specific channel.
126 pub channel_id: [u8; 32],
127 /// A possibly human-readable warning description.
129 /// The string should be sanitized before it is used (e.g. emitted to logs or printed to
130 /// stdout). Otherwise, a well crafted error message may trigger a security vulnerability in
131 /// the terminal emulator or the logging subsystem.
135 /// A [`ping`] message to be sent to or received from a peer.
137 /// [`ping`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-ping-and-pong-messages
138 #[derive(Clone, Debug, PartialEq, Eq)]
140 /// The desired response length.
142 /// The ping packet size.
144 /// This field is not sent on the wire. byteslen zeros are sent.
148 /// A [`pong`] message to be sent to or received from a peer.
150 /// [`pong`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-ping-and-pong-messages
151 #[derive(Clone, Debug, PartialEq, Eq)]
153 /// The pong packet size.
155 /// This field is not sent on the wire. byteslen zeros are sent.
159 /// An [`open_channel`] message to be sent to or received from a peer.
161 /// Used in V1 channel establishment
163 /// [`open_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-open_channel-message
164 #[derive(Clone, Debug, PartialEq, Eq)]
165 pub struct OpenChannel {
166 /// The genesis hash of the blockchain where the channel is to be opened
167 pub chain_hash: BlockHash,
168 /// A temporary channel ID, until the funding outpoint is announced
169 pub temporary_channel_id: [u8; 32],
170 /// The channel value
171 pub funding_satoshis: u64,
172 /// The amount to push to the counterparty as part of the open, in milli-satoshi
174 /// The threshold below which outputs on transactions broadcast by sender will be omitted
175 pub dust_limit_satoshis: u64,
176 /// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
177 pub max_htlc_value_in_flight_msat: u64,
178 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
179 pub channel_reserve_satoshis: u64,
180 /// The minimum HTLC size incoming to sender, in milli-satoshi
181 pub htlc_minimum_msat: u64,
182 /// The feerate per 1000-weight of sender generated transactions, until updated by
184 pub feerate_per_kw: u32,
185 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if
186 /// they broadcast a commitment transaction
187 pub to_self_delay: u16,
188 /// The maximum number of inbound HTLCs towards sender
189 pub max_accepted_htlcs: u16,
190 /// The sender's key controlling the funding transaction
191 pub funding_pubkey: PublicKey,
192 /// Used to derive a revocation key for transactions broadcast by counterparty
193 pub revocation_basepoint: PublicKey,
194 /// A payment key to sender for transactions broadcast by counterparty
195 pub payment_point: PublicKey,
196 /// Used to derive a payment key to sender for transactions broadcast by sender
197 pub delayed_payment_basepoint: PublicKey,
198 /// Used to derive an HTLC payment key to sender
199 pub htlc_basepoint: PublicKey,
200 /// The first to-be-broadcast-by-sender transaction's per commitment point
201 pub first_per_commitment_point: PublicKey,
202 /// The channel flags to be used
203 pub channel_flags: u8,
204 /// A request to pre-set the to-sender output's `scriptPubkey` for when we collaboratively close
205 pub shutdown_scriptpubkey: Option<Script>,
206 /// The channel type that this channel will represent
208 /// If this is `None`, we derive the channel type from the intersection of our
209 /// feature bits with our counterparty's feature bits from the [`Init`] message.
210 pub channel_type: Option<ChannelTypeFeatures>,
213 /// An open_channel2 message to be sent by or received from the channel initiator.
215 /// Used in V2 channel establishment
217 // TODO(dual_funding): Add spec link for `open_channel2`.
218 #[derive(Clone, Debug, PartialEq, Eq)]
219 pub struct OpenChannelV2 {
220 /// The genesis hash of the blockchain where the channel is to be opened
221 pub chain_hash: BlockHash,
222 /// A temporary channel ID derived using a zeroed out value for the channel acceptor's revocation basepoint
223 pub temporary_channel_id: [u8; 32],
224 /// The feerate for the funding transaction set by the channel initiator
225 pub funding_feerate_sat_per_1000_weight: u32,
226 /// The feerate for the commitment transaction set by the channel initiator
227 pub commitment_feerate_sat_per_1000_weight: u32,
228 /// Part of the channel value contributed by the channel initiator
229 pub funding_satoshis: u64,
230 /// The threshold below which outputs on transactions broadcast by the channel initiator will be
232 pub dust_limit_satoshis: u64,
233 /// The maximum inbound HTLC value in flight towards channel initiator, in milli-satoshi
234 pub max_htlc_value_in_flight_msat: u64,
235 /// The minimum HTLC size incoming to channel initiator, in milli-satoshi
236 pub htlc_minimum_msat: u64,
237 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
238 /// broadcast a commitment transaction
239 pub to_self_delay: u16,
240 /// The maximum number of inbound HTLCs towards channel initiator
241 pub max_accepted_htlcs: u16,
242 /// The locktime for the funding transaction
244 /// The channel initiator's key controlling the funding transaction
245 pub funding_pubkey: PublicKey,
246 /// Used to derive a revocation key for transactions broadcast by counterparty
247 pub revocation_basepoint: PublicKey,
248 /// A payment key to channel initiator for transactions broadcast by counterparty
249 pub payment_basepoint: PublicKey,
250 /// Used to derive a payment key to channel initiator for transactions broadcast by channel
252 pub delayed_payment_basepoint: PublicKey,
253 /// Used to derive an HTLC payment key to channel initiator
254 pub htlc_basepoint: PublicKey,
255 /// The first to-be-broadcast-by-channel-initiator transaction's per commitment point
256 pub first_per_commitment_point: PublicKey,
257 /// The second to-be-broadcast-by-channel-initiator transaction's per commitment point
258 pub second_per_commitment_point: PublicKey,
260 pub channel_flags: u8,
261 /// Optionally, a request to pre-set the to-channel-initiator output's scriptPubkey for when we
262 /// collaboratively close
263 pub shutdown_scriptpubkey: Option<Script>,
264 /// The channel type that this channel will represent. If none is set, we derive the channel
265 /// type from the intersection of our feature bits with our counterparty's feature bits from
266 /// the Init message.
267 pub channel_type: Option<ChannelTypeFeatures>,
268 /// Optionally, a requirement that only confirmed inputs can be added
269 pub require_confirmed_inputs: Option<()>,
272 /// An [`accept_channel`] message to be sent to or received from a peer.
274 /// Used in V1 channel establishment
276 /// [`accept_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-accept_channel-message
277 #[derive(Clone, Debug, PartialEq, Eq)]
278 pub struct AcceptChannel {
279 /// A temporary channel ID, until the funding outpoint is announced
280 pub temporary_channel_id: [u8; 32],
281 /// The threshold below which outputs on transactions broadcast by sender will be omitted
282 pub dust_limit_satoshis: u64,
283 /// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
284 pub max_htlc_value_in_flight_msat: u64,
285 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
286 pub channel_reserve_satoshis: u64,
287 /// The minimum HTLC size incoming to sender, in milli-satoshi
288 pub htlc_minimum_msat: u64,
289 /// Minimum depth of the funding transaction before the channel is considered open
290 pub minimum_depth: u32,
291 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they broadcast a commitment transaction
292 pub to_self_delay: u16,
293 /// The maximum number of inbound HTLCs towards sender
294 pub max_accepted_htlcs: u16,
295 /// The sender's key controlling the funding transaction
296 pub funding_pubkey: PublicKey,
297 /// Used to derive a revocation key for transactions broadcast by counterparty
298 pub revocation_basepoint: PublicKey,
299 /// A payment key to sender for transactions broadcast by counterparty
300 pub payment_point: PublicKey,
301 /// Used to derive a payment key to sender for transactions broadcast by sender
302 pub delayed_payment_basepoint: PublicKey,
303 /// Used to derive an HTLC payment key to sender for transactions broadcast by counterparty
304 pub htlc_basepoint: PublicKey,
305 /// The first to-be-broadcast-by-sender transaction's per commitment point
306 pub first_per_commitment_point: PublicKey,
307 /// A request to pre-set the to-sender output's scriptPubkey for when we collaboratively close
308 pub shutdown_scriptpubkey: Option<Script>,
309 /// The channel type that this channel will represent.
311 /// If this is `None`, we derive the channel type from the intersection of
312 /// our feature bits with our counterparty's feature bits from the [`Init`] message.
313 /// This is required to match the equivalent field in [`OpenChannel::channel_type`].
314 pub channel_type: Option<ChannelTypeFeatures>,
316 /// Next nonce the channel initiator should use to create a funding output signature against
317 pub next_local_nonce: Option<musig2::types::PublicNonce>,
320 /// An accept_channel2 message to be sent by or received from the channel accepter.
322 /// Used in V2 channel establishment
324 // TODO(dual_funding): Add spec link for `accept_channel2`.
325 #[derive(Clone, Debug, PartialEq, Eq)]
326 pub struct AcceptChannelV2 {
327 /// The same `temporary_channel_id` received from the initiator's `open_channel2` message.
328 pub temporary_channel_id: [u8; 32],
329 /// Part of the channel value contributed by the channel acceptor
330 pub funding_satoshis: u64,
331 /// The threshold below which outputs on transactions broadcast by the channel acceptor will be
333 pub dust_limit_satoshis: u64,
334 /// The maximum inbound HTLC value in flight towards channel acceptor, in milli-satoshi
335 pub max_htlc_value_in_flight_msat: u64,
336 /// The minimum HTLC size incoming to channel acceptor, in milli-satoshi
337 pub htlc_minimum_msat: u64,
338 /// Minimum depth of the funding transaction before the channel is considered open
339 pub minimum_depth: u32,
340 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
341 /// broadcast a commitment transaction
342 pub to_self_delay: u16,
343 /// The maximum number of inbound HTLCs towards channel acceptor
344 pub max_accepted_htlcs: u16,
345 /// The channel acceptor's key controlling the funding transaction
346 pub funding_pubkey: PublicKey,
347 /// Used to derive a revocation key for transactions broadcast by counterparty
348 pub revocation_basepoint: PublicKey,
349 /// A payment key to channel acceptor for transactions broadcast by counterparty
350 pub payment_basepoint: PublicKey,
351 /// Used to derive a payment key to channel acceptor for transactions broadcast by channel
353 pub delayed_payment_basepoint: PublicKey,
354 /// Used to derive an HTLC payment key to channel acceptor for transactions broadcast by counterparty
355 pub htlc_basepoint: PublicKey,
356 /// The first to-be-broadcast-by-channel-acceptor transaction's per commitment point
357 pub first_per_commitment_point: PublicKey,
358 /// The second to-be-broadcast-by-channel-acceptor transaction's per commitment point
359 pub second_per_commitment_point: PublicKey,
360 /// Optionally, a request to pre-set the to-channel-acceptor output's scriptPubkey for when we
361 /// collaboratively close
362 pub shutdown_scriptpubkey: Option<Script>,
363 /// The channel type that this channel will represent. If none is set, we derive the channel
364 /// type from the intersection of our feature bits with our counterparty's feature bits from
365 /// the Init message.
367 /// This is required to match the equivalent field in [`OpenChannelV2::channel_type`].
368 pub channel_type: Option<ChannelTypeFeatures>,
369 /// Optionally, a requirement that only confirmed inputs can be added
370 pub require_confirmed_inputs: Option<()>,
373 /// A [`funding_created`] message to be sent to or received from a peer.
375 /// Used in V1 channel establishment
377 /// [`funding_created`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-funding_created-message
378 #[derive(Clone, Debug, PartialEq, Eq)]
379 pub struct FundingCreated {
380 /// A temporary channel ID, until the funding is established
381 pub temporary_channel_id: [u8; 32],
382 /// The funding transaction ID
383 pub funding_txid: Txid,
384 /// The specific output index funding this channel
385 pub funding_output_index: u16,
386 /// The signature of the channel initiator (funder) on the initial commitment transaction
387 pub signature: Signature,
389 /// The partial signature of the channel initiator (funder)
390 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
392 /// Next nonce the channel acceptor should use to finalize the funding output signature
393 pub next_local_nonce: Option<musig2::types::PublicNonce>
396 /// A [`funding_signed`] message to be sent to or received from a peer.
398 /// Used in V1 channel establishment
400 /// [`funding_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-funding_signed-message
401 #[derive(Clone, Debug, PartialEq, Eq)]
402 pub struct FundingSigned {
404 pub channel_id: [u8; 32],
405 /// The signature of the channel acceptor (fundee) on the initial commitment transaction
406 pub signature: Signature,
408 /// The partial signature of the channel acceptor (fundee)
409 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
412 /// A [`channel_ready`] message to be sent to or received from a peer.
414 /// [`channel_ready`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-channel_ready-message
415 #[derive(Clone, Debug, PartialEq, Eq)]
416 pub struct ChannelReady {
418 pub channel_id: [u8; 32],
419 /// The per-commitment point of the second commitment transaction
420 pub next_per_commitment_point: PublicKey,
421 /// If set, provides a `short_channel_id` alias for this channel.
423 /// The sender will accept payments to be forwarded over this SCID and forward them to this
424 /// messages' recipient.
425 pub short_channel_id_alias: Option<u64>,
428 /// A tx_add_input message for adding an input during interactive transaction construction
430 // TODO(dual_funding): Add spec link for `tx_add_input`.
431 #[derive(Clone, Debug, PartialEq, Eq)]
432 pub struct TxAddInput {
434 pub channel_id: [u8; 32],
435 /// A randomly chosen unique identifier for this input, which is even for initiators and odd for
438 /// Serialized transaction that contains the output this input spends to verify that it is non
440 pub prevtx: TransactionU16LenLimited,
441 /// The index of the output being spent
443 /// The sequence number of this input
447 /// A tx_add_output message for adding an output during interactive transaction construction.
449 // TODO(dual_funding): Add spec link for `tx_add_output`.
450 #[derive(Clone, Debug, PartialEq, Eq)]
451 pub struct TxAddOutput {
453 pub channel_id: [u8; 32],
454 /// A randomly chosen unique identifier for this output, which is even for initiators and odd for
457 /// The satoshi value of the output
459 /// The scriptPubKey for the output
463 /// A tx_remove_input message for removing an input during interactive transaction construction.
465 // TODO(dual_funding): Add spec link for `tx_remove_input`.
466 #[derive(Clone, Debug, PartialEq, Eq)]
467 pub struct TxRemoveInput {
469 pub channel_id: [u8; 32],
470 /// The serial ID of the input to be removed
474 /// A tx_remove_output message for removing an output during interactive transaction construction.
476 // TODO(dual_funding): Add spec link for `tx_remove_output`.
477 #[derive(Clone, Debug, PartialEq, Eq)]
478 pub struct TxRemoveOutput {
480 pub channel_id: [u8; 32],
481 /// The serial ID of the output to be removed
485 /// A tx_complete message signalling the conclusion of a peer's transaction contributions during
486 /// interactive transaction construction.
488 // TODO(dual_funding): Add spec link for `tx_complete`.
489 #[derive(Clone, Debug, PartialEq, Eq)]
490 pub struct TxComplete {
492 pub channel_id: [u8; 32],
495 /// A tx_signatures message containing the sender's signatures for a transaction constructed with
496 /// interactive transaction construction.
498 // TODO(dual_funding): Add spec link for `tx_signatures`.
499 #[derive(Clone, Debug, PartialEq, Eq)]
500 pub struct TxSignatures {
502 pub channel_id: [u8; 32],
505 /// The list of witnesses
506 pub witnesses: Vec<Witness>,
509 /// A tx_init_rbf message which initiates a replacement of the transaction after it's been
512 // TODO(dual_funding): Add spec link for `tx_init_rbf`.
513 #[derive(Clone, Debug, PartialEq, Eq)]
514 pub struct TxInitRbf {
516 pub channel_id: [u8; 32],
517 /// The locktime of the transaction
519 /// The feerate of the transaction
520 pub feerate_sat_per_1000_weight: u32,
521 /// The number of satoshis the sender will contribute to or, if negative, remove from
522 /// (e.g. splice-out) the funding output of the transaction
523 pub funding_output_contribution: Option<i64>,
526 /// A tx_ack_rbf message which acknowledges replacement of the transaction after it's been
529 // TODO(dual_funding): Add spec link for `tx_ack_rbf`.
530 #[derive(Clone, Debug, PartialEq, Eq)]
531 pub struct TxAckRbf {
533 pub channel_id: [u8; 32],
534 /// The number of satoshis the sender will contribute to or, if negative, remove from
535 /// (e.g. splice-out) the funding output of the transaction
536 pub funding_output_contribution: Option<i64>,
539 /// A tx_abort message which signals the cancellation of an in-progress transaction negotiation.
541 // TODO(dual_funding): Add spec link for `tx_abort`.
542 #[derive(Clone, Debug, PartialEq, Eq)]
545 pub channel_id: [u8; 32],
550 /// A [`shutdown`] message to be sent to or received from a peer.
552 /// [`shutdown`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-initiation-shutdown
553 #[derive(Clone, Debug, PartialEq, Eq)]
554 pub struct Shutdown {
556 pub channel_id: [u8; 32],
557 /// The destination of this peer's funds on closing.
559 /// Must be in one of these forms: P2PKH, P2SH, P2WPKH, P2WSH, P2TR.
560 pub scriptpubkey: Script,
563 /// The minimum and maximum fees which the sender is willing to place on the closing transaction.
565 /// This is provided in [`ClosingSigned`] by both sides to indicate the fee range they are willing
567 #[derive(Clone, Debug, PartialEq, Eq)]
568 pub struct ClosingSignedFeeRange {
569 /// The minimum absolute fee, in satoshis, which the sender is willing to place on the closing
571 pub min_fee_satoshis: u64,
572 /// The maximum absolute fee, in satoshis, which the sender is willing to place on the closing
574 pub max_fee_satoshis: u64,
577 /// A [`closing_signed`] message to be sent to or received from a peer.
579 /// [`closing_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-negotiation-closing_signed
580 #[derive(Clone, Debug, PartialEq, Eq)]
581 pub struct ClosingSigned {
583 pub channel_id: [u8; 32],
584 /// The proposed total fee for the closing transaction
585 pub fee_satoshis: u64,
586 /// A signature on the closing transaction
587 pub signature: Signature,
588 /// The minimum and maximum fees which the sender is willing to accept, provided only by new
590 pub fee_range: Option<ClosingSignedFeeRange>,
593 /// An [`update_add_htlc`] message to be sent to or received from a peer.
595 /// [`update_add_htlc`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#adding-an-htlc-update_add_htlc
596 #[derive(Clone, Debug, PartialEq, Eq)]
597 pub struct UpdateAddHTLC {
599 pub channel_id: [u8; 32],
602 /// The HTLC value in milli-satoshi
603 pub amount_msat: u64,
604 /// The payment hash, the pre-image of which controls HTLC redemption
605 pub payment_hash: PaymentHash,
606 /// The expiry height of the HTLC
607 pub cltv_expiry: u32,
608 pub(crate) onion_routing_packet: OnionPacket,
611 /// An onion message to be sent to or received from a peer.
613 // TODO: update with link to OM when they are merged into the BOLTs
614 #[derive(Clone, Debug, PartialEq, Eq)]
615 pub struct OnionMessage {
616 /// Used in decrypting the onion packet's payload.
617 pub blinding_point: PublicKey,
618 pub(crate) onion_routing_packet: onion_message::Packet,
621 /// An [`update_fulfill_htlc`] message to be sent to or received from a peer.
623 /// [`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
624 #[derive(Clone, Debug, PartialEq, Eq)]
625 pub struct UpdateFulfillHTLC {
627 pub channel_id: [u8; 32],
630 /// The pre-image of the payment hash, allowing HTLC redemption
631 pub payment_preimage: PaymentPreimage,
634 /// An [`update_fail_htlc`] message to be sent to or received from a peer.
636 /// [`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
637 #[derive(Clone, Debug, PartialEq, Eq)]
638 pub struct UpdateFailHTLC {
640 pub channel_id: [u8; 32],
643 pub(crate) reason: OnionErrorPacket,
646 /// An [`update_fail_malformed_htlc`] message to be sent to or received from a peer.
648 /// [`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
649 #[derive(Clone, Debug, PartialEq, Eq)]
650 pub struct UpdateFailMalformedHTLC {
652 pub channel_id: [u8; 32],
655 pub(crate) sha256_of_onion: [u8; 32],
657 pub failure_code: u16,
660 /// A [`commitment_signed`] message to be sent to or received from a peer.
662 /// [`commitment_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#committing-updates-so-far-commitment_signed
663 #[derive(Clone, Debug, PartialEq, Eq)]
664 pub struct CommitmentSigned {
666 pub channel_id: [u8; 32],
667 /// A signature on the commitment transaction
668 pub signature: Signature,
669 /// Signatures on the HTLC transactions
670 pub htlc_signatures: Vec<Signature>,
672 /// The partial Taproot signature on the commitment transaction
673 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
676 /// A [`revoke_and_ack`] message to be sent to or received from a peer.
678 /// [`revoke_and_ack`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#completing-the-transition-to-the-updated-state-revoke_and_ack
679 #[derive(Clone, Debug, PartialEq, Eq)]
680 pub struct RevokeAndACK {
682 pub channel_id: [u8; 32],
683 /// The secret corresponding to the per-commitment point
684 pub per_commitment_secret: [u8; 32],
685 /// The next sender-broadcast commitment transaction's per-commitment point
686 pub next_per_commitment_point: PublicKey,
688 /// Musig nonce the recipient should use in their next commitment signature message
689 pub next_local_nonce: Option<musig2::types::PublicNonce>
692 /// An [`update_fee`] message to be sent to or received from a peer
694 /// [`update_fee`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#updating-fees-update_fee
695 #[derive(Clone, Debug, PartialEq, Eq)]
696 pub struct UpdateFee {
698 pub channel_id: [u8; 32],
699 /// Fee rate per 1000-weight of the transaction
700 pub feerate_per_kw: u32,
703 /// A [`channel_reestablish`] message to be sent to or received from a peer.
705 /// [`channel_reestablish`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#message-retransmission
706 #[derive(Clone, Debug, PartialEq, Eq)]
707 pub struct ChannelReestablish {
709 pub channel_id: [u8; 32],
710 /// The next commitment number for the sender
711 pub next_local_commitment_number: u64,
712 /// The next commitment number for the recipient
713 pub next_remote_commitment_number: u64,
714 /// Proof that the sender knows the per-commitment secret of a specific commitment transaction
715 /// belonging to the recipient
716 pub your_last_per_commitment_secret: [u8; 32],
717 /// The sender's per-commitment point for their current commitment transaction
718 pub my_current_per_commitment_point: PublicKey,
719 /// The next funding transaction ID
720 pub next_funding_txid: Option<Txid>,
723 /// An [`announcement_signatures`] message to be sent to or received from a peer.
725 /// [`announcement_signatures`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-announcement_signatures-message
726 #[derive(Clone, Debug, PartialEq, Eq)]
727 pub struct AnnouncementSignatures {
729 pub channel_id: [u8; 32],
730 /// The short channel ID
731 pub short_channel_id: u64,
732 /// A signature by the node key
733 pub node_signature: Signature,
734 /// A signature by the funding key
735 pub bitcoin_signature: Signature,
738 /// An address which can be used to connect to a remote peer.
739 #[derive(Clone, Debug, PartialEq, Eq)]
740 pub enum NetAddress {
741 /// An IPv4 address/port on which the peer is listening.
743 /// The 4-byte IPv4 address
745 /// The port on which the node is listening
748 /// An IPv6 address/port on which the peer is listening.
750 /// The 16-byte IPv6 address
752 /// The port on which the node is listening
755 /// An old-style Tor onion address/port on which the peer is listening.
757 /// This field is deprecated and the Tor network generally no longer supports V2 Onion
758 /// addresses. Thus, the details are not parsed here.
760 /// A new-style Tor onion address/port on which the peer is listening.
762 /// To create the human-readable "hostname", concatenate the ED25519 pubkey, checksum, and version,
763 /// wrap as base32 and append ".onion".
765 /// The ed25519 long-term public key of the peer
766 ed25519_pubkey: [u8; 32],
767 /// The checksum of the pubkey and version, as included in the onion address
769 /// The version byte, as defined by the Tor Onion v3 spec.
771 /// The port on which the node is listening
774 /// A hostname/port on which the peer is listening.
776 /// The hostname on which the node is listening.
778 /// The port on which the node is listening.
783 /// Gets the ID of this address type. Addresses in [`NodeAnnouncement`] messages should be sorted
785 pub(crate) fn get_id(&self) -> u8 {
787 &NetAddress::IPv4 {..} => { 1 },
788 &NetAddress::IPv6 {..} => { 2 },
789 &NetAddress::OnionV2(_) => { 3 },
790 &NetAddress::OnionV3 {..} => { 4 },
791 &NetAddress::Hostname {..} => { 5 },
795 /// Strict byte-length of address descriptor, 1-byte type not recorded
796 fn len(&self) -> u16 {
798 &NetAddress::IPv4 { .. } => { 6 },
799 &NetAddress::IPv6 { .. } => { 18 },
800 &NetAddress::OnionV2(_) => { 12 },
801 &NetAddress::OnionV3 { .. } => { 37 },
802 // Consists of 1-byte hostname length, hostname bytes, and 2-byte port.
803 &NetAddress::Hostname { ref hostname, .. } => { u16::from(hostname.len()) + 3 },
807 /// The maximum length of any address descriptor, not including the 1-byte type.
808 /// This maximum length is reached by a hostname address descriptor:
809 /// a hostname with a maximum length of 255, its 1-byte length and a 2-byte port.
810 pub(crate) const MAX_LEN: u16 = 258;
813 impl Writeable for NetAddress {
814 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
816 &NetAddress::IPv4 { ref addr, ref port } => {
821 &NetAddress::IPv6 { ref addr, ref port } => {
826 &NetAddress::OnionV2(bytes) => {
828 bytes.write(writer)?;
830 &NetAddress::OnionV3 { ref ed25519_pubkey, ref checksum, ref version, ref port } => {
832 ed25519_pubkey.write(writer)?;
833 checksum.write(writer)?;
834 version.write(writer)?;
837 &NetAddress::Hostname { ref hostname, ref port } => {
839 hostname.write(writer)?;
847 impl Readable for Result<NetAddress, u8> {
848 fn read<R: Read>(reader: &mut R) -> Result<Result<NetAddress, u8>, DecodeError> {
849 let byte = <u8 as Readable>::read(reader)?;
852 Ok(Ok(NetAddress::IPv4 {
853 addr: Readable::read(reader)?,
854 port: Readable::read(reader)?,
858 Ok(Ok(NetAddress::IPv6 {
859 addr: Readable::read(reader)?,
860 port: Readable::read(reader)?,
863 3 => Ok(Ok(NetAddress::OnionV2(Readable::read(reader)?))),
865 Ok(Ok(NetAddress::OnionV3 {
866 ed25519_pubkey: Readable::read(reader)?,
867 checksum: Readable::read(reader)?,
868 version: Readable::read(reader)?,
869 port: Readable::read(reader)?,
873 Ok(Ok(NetAddress::Hostname {
874 hostname: Readable::read(reader)?,
875 port: Readable::read(reader)?,
878 _ => return Ok(Err(byte)),
883 impl Readable for NetAddress {
884 fn read<R: Read>(reader: &mut R) -> Result<NetAddress, DecodeError> {
885 match Readable::read(reader) {
886 Ok(Ok(res)) => Ok(res),
887 Ok(Err(_)) => Err(DecodeError::UnknownVersion),
893 /// Represents the set of gossip messages that require a signature from a node's identity key.
894 pub enum UnsignedGossipMessage<'a> {
895 /// An unsigned channel announcement.
896 ChannelAnnouncement(&'a UnsignedChannelAnnouncement),
897 /// An unsigned channel update.
898 ChannelUpdate(&'a UnsignedChannelUpdate),
899 /// An unsigned node announcement.
900 NodeAnnouncement(&'a UnsignedNodeAnnouncement)
903 impl<'a> Writeable for UnsignedGossipMessage<'a> {
904 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
906 UnsignedGossipMessage::ChannelAnnouncement(ref msg) => msg.write(writer),
907 UnsignedGossipMessage::ChannelUpdate(ref msg) => msg.write(writer),
908 UnsignedGossipMessage::NodeAnnouncement(ref msg) => msg.write(writer),
913 /// The unsigned part of a [`node_announcement`] message.
915 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
916 #[derive(Clone, Debug, PartialEq, Eq)]
917 pub struct UnsignedNodeAnnouncement {
918 /// The advertised features
919 pub features: NodeFeatures,
920 /// A strictly monotonic announcement counter, with gaps allowed
922 /// The `node_id` this announcement originated from (don't rebroadcast the `node_announcement` back
925 /// An RGB color for UI purposes
927 /// An alias, for UI purposes.
929 /// This should be sanitized before use. There is no guarantee of uniqueness.
930 pub alias: NodeAlias,
931 /// List of addresses on which this node is reachable
932 pub addresses: Vec<NetAddress>,
933 pub(crate) excess_address_data: Vec<u8>,
934 pub(crate) excess_data: Vec<u8>,
936 #[derive(Clone, Debug, PartialEq, Eq)]
937 /// A [`node_announcement`] message to be sent to or received from a peer.
939 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
940 pub struct NodeAnnouncement {
941 /// The signature by the node key
942 pub signature: Signature,
943 /// The actual content of the announcement
944 pub contents: UnsignedNodeAnnouncement,
947 /// The unsigned part of a [`channel_announcement`] message.
949 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
950 #[derive(Clone, Debug, PartialEq, Eq)]
951 pub struct UnsignedChannelAnnouncement {
952 /// The advertised channel features
953 pub features: ChannelFeatures,
954 /// The genesis hash of the blockchain where the channel is to be opened
955 pub chain_hash: BlockHash,
956 /// The short channel ID
957 pub short_channel_id: u64,
958 /// One of the two `node_id`s which are endpoints of this channel
959 pub node_id_1: NodeId,
960 /// The other of the two `node_id`s which are endpoints of this channel
961 pub node_id_2: NodeId,
962 /// The funding key for the first node
963 pub bitcoin_key_1: NodeId,
964 /// The funding key for the second node
965 pub bitcoin_key_2: NodeId,
966 pub(crate) excess_data: Vec<u8>,
968 /// A [`channel_announcement`] message to be sent to or received from a peer.
970 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
971 #[derive(Clone, Debug, PartialEq, Eq)]
972 pub struct ChannelAnnouncement {
973 /// Authentication of the announcement by the first public node
974 pub node_signature_1: Signature,
975 /// Authentication of the announcement by the second public node
976 pub node_signature_2: Signature,
977 /// Proof of funding UTXO ownership by the first public node
978 pub bitcoin_signature_1: Signature,
979 /// Proof of funding UTXO ownership by the second public node
980 pub bitcoin_signature_2: Signature,
981 /// The actual announcement
982 pub contents: UnsignedChannelAnnouncement,
985 /// The unsigned part of a [`channel_update`] message.
987 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
988 #[derive(Clone, Debug, PartialEq, Eq)]
989 pub struct UnsignedChannelUpdate {
990 /// The genesis hash of the blockchain where the channel is to be opened
991 pub chain_hash: BlockHash,
992 /// The short channel ID
993 pub short_channel_id: u64,
994 /// A strictly monotonic announcement counter, with gaps allowed, specific to this channel
998 /// The number of blocks such that if:
999 /// `incoming_htlc.cltv_expiry < outgoing_htlc.cltv_expiry + cltv_expiry_delta`
1000 /// then we need to fail the HTLC backwards. When forwarding an HTLC, `cltv_expiry_delta` determines
1001 /// the outgoing HTLC's minimum `cltv_expiry` value -- so, if an incoming HTLC comes in with a
1002 /// `cltv_expiry` of 100000, and the node we're forwarding to has a `cltv_expiry_delta` value of 10,
1003 /// then we'll check that the outgoing HTLC's `cltv_expiry` value is at least 100010 before
1004 /// forwarding. Note that the HTLC sender is the one who originally sets this value when
1005 /// constructing the route.
1006 pub cltv_expiry_delta: u16,
1007 /// The minimum HTLC size incoming to sender, in milli-satoshi
1008 pub htlc_minimum_msat: u64,
1009 /// The maximum HTLC value incoming to sender, in milli-satoshi.
1011 /// This used to be optional.
1012 pub htlc_maximum_msat: u64,
1013 /// The base HTLC fee charged by sender, in milli-satoshi
1014 pub fee_base_msat: u32,
1015 /// The amount to fee multiplier, in micro-satoshi
1016 pub fee_proportional_millionths: u32,
1017 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1020 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1021 pub excess_data: Vec<u8>,
1023 /// A [`channel_update`] message to be sent to or received from a peer.
1025 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1026 #[derive(Clone, Debug, PartialEq, Eq)]
1027 pub struct ChannelUpdate {
1028 /// A signature of the channel update
1029 pub signature: Signature,
1030 /// The actual channel update
1031 pub contents: UnsignedChannelUpdate,
1034 /// A [`query_channel_range`] message is used to query a peer for channel
1035 /// UTXOs in a range of blocks. The recipient of a query makes a best
1036 /// effort to reply to the query using one or more [`ReplyChannelRange`]
1039 /// [`query_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1040 #[derive(Clone, Debug, PartialEq, Eq)]
1041 pub struct QueryChannelRange {
1042 /// The genesis hash of the blockchain being queried
1043 pub chain_hash: BlockHash,
1044 /// The height of the first block for the channel UTXOs being queried
1045 pub first_blocknum: u32,
1046 /// The number of blocks to include in the query results
1047 pub number_of_blocks: u32,
1050 /// A [`reply_channel_range`] message is a reply to a [`QueryChannelRange`]
1053 /// Multiple `reply_channel_range` messages can be sent in reply
1054 /// to a single [`QueryChannelRange`] message. The query recipient makes a
1055 /// best effort to respond based on their local network view which may
1056 /// not be a perfect view of the network. The `short_channel_id`s in the
1057 /// reply are encoded. We only support `encoding_type=0` uncompressed
1058 /// serialization and do not support `encoding_type=1` zlib serialization.
1060 /// [`reply_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1061 #[derive(Clone, Debug, PartialEq, Eq)]
1062 pub struct ReplyChannelRange {
1063 /// The genesis hash of the blockchain being queried
1064 pub chain_hash: BlockHash,
1065 /// The height of the first block in the range of the reply
1066 pub first_blocknum: u32,
1067 /// The number of blocks included in the range of the reply
1068 pub number_of_blocks: u32,
1069 /// True when this is the final reply for a query
1070 pub sync_complete: bool,
1071 /// The `short_channel_id`s in the channel range
1072 pub short_channel_ids: Vec<u64>,
1075 /// A [`query_short_channel_ids`] message is used to query a peer for
1076 /// routing gossip messages related to one or more `short_channel_id`s.
1078 /// The query recipient will reply with the latest, if available,
1079 /// [`ChannelAnnouncement`], [`ChannelUpdate`] and [`NodeAnnouncement`] messages
1080 /// it maintains for the requested `short_channel_id`s followed by a
1081 /// [`ReplyShortChannelIdsEnd`] message. The `short_channel_id`s sent in
1082 /// this query are encoded. We only support `encoding_type=0` uncompressed
1083 /// serialization and do not support `encoding_type=1` zlib serialization.
1085 /// [`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
1086 #[derive(Clone, Debug, PartialEq, Eq)]
1087 pub struct QueryShortChannelIds {
1088 /// The genesis hash of the blockchain being queried
1089 pub chain_hash: BlockHash,
1090 /// The short_channel_ids that are being queried
1091 pub short_channel_ids: Vec<u64>,
1094 /// A [`reply_short_channel_ids_end`] message is sent as a reply to a
1095 /// message. The query recipient makes a best
1096 /// effort to respond based on their local network view which may not be
1097 /// a perfect view of the network.
1099 /// [`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
1100 #[derive(Clone, Debug, PartialEq, Eq)]
1101 pub struct ReplyShortChannelIdsEnd {
1102 /// The genesis hash of the blockchain that was queried
1103 pub chain_hash: BlockHash,
1104 /// Indicates if the query recipient maintains up-to-date channel
1105 /// information for the `chain_hash`
1106 pub full_information: bool,
1109 /// A [`gossip_timestamp_filter`] message is used by a node to request
1110 /// gossip relay for messages in the requested time range when the
1111 /// `gossip_queries` feature has been negotiated.
1113 /// [`gossip_timestamp_filter`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-gossip_timestamp_filter-message
1114 #[derive(Clone, Debug, PartialEq, Eq)]
1115 pub struct GossipTimestampFilter {
1116 /// The genesis hash of the blockchain for channel and node information
1117 pub chain_hash: BlockHash,
1118 /// The starting unix timestamp
1119 pub first_timestamp: u32,
1120 /// The range of information in seconds
1121 pub timestamp_range: u32,
1124 /// Encoding type for data compression of collections in gossip queries.
1126 /// We do not support `encoding_type=1` zlib serialization [defined in BOLT
1127 /// #7](https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#query-messages).
1129 Uncompressed = 0x00,
1132 /// Used to put an error message in a [`LightningError`].
1133 #[derive(Clone, Debug)]
1134 pub enum ErrorAction {
1135 /// The peer took some action which made us think they were useless. Disconnect them.
1137 /// An error message which we should make an effort to send before we disconnect.
1138 msg: Option<ErrorMessage>
1140 /// The peer did something incorrect. Tell them without closing any channels and disconnect them.
1141 DisconnectPeerWithWarning {
1142 /// A warning message which we should make an effort to send before we disconnect.
1143 msg: WarningMessage,
1145 /// The peer did something harmless that we weren't able to process, just log and ignore
1146 // New code should *not* use this. New code must use IgnoreAndLog, below!
1148 /// The peer did something harmless that we weren't able to meaningfully process.
1149 /// If the error is logged, log it at the given level.
1150 IgnoreAndLog(logger::Level),
1151 /// The peer provided us with a gossip message which we'd already seen. In most cases this
1152 /// should be ignored, but it may result in the message being forwarded if it is a duplicate of
1153 /// our own channel announcements.
1154 IgnoreDuplicateGossip,
1155 /// The peer did something incorrect. Tell them.
1157 /// The message to send.
1160 /// The peer did something incorrect. Tell them without closing any channels.
1161 SendWarningMessage {
1162 /// The message to send.
1163 msg: WarningMessage,
1164 /// The peer may have done something harmless that we weren't able to meaningfully process,
1165 /// though we should still tell them about it.
1166 /// If this event is logged, log it at the given level.
1167 log_level: logger::Level,
1171 /// An Err type for failure to process messages.
1172 #[derive(Clone, Debug)]
1173 pub struct LightningError {
1174 /// A human-readable message describing the error
1176 /// The action which should be taken against the offending peer.
1177 pub action: ErrorAction,
1180 /// Struct used to return values from [`RevokeAndACK`] messages, containing a bunch of commitment
1181 /// transaction updates if they were pending.
1182 #[derive(Clone, Debug, PartialEq, Eq)]
1183 pub struct CommitmentUpdate {
1184 /// `update_add_htlc` messages which should be sent
1185 pub update_add_htlcs: Vec<UpdateAddHTLC>,
1186 /// `update_fulfill_htlc` messages which should be sent
1187 pub update_fulfill_htlcs: Vec<UpdateFulfillHTLC>,
1188 /// `update_fail_htlc` messages which should be sent
1189 pub update_fail_htlcs: Vec<UpdateFailHTLC>,
1190 /// `update_fail_malformed_htlc` messages which should be sent
1191 pub update_fail_malformed_htlcs: Vec<UpdateFailMalformedHTLC>,
1192 /// An `update_fee` message which should be sent
1193 pub update_fee: Option<UpdateFee>,
1194 /// A `commitment_signed` message which should be sent
1195 pub commitment_signed: CommitmentSigned,
1198 /// A trait to describe an object which can receive channel messages.
1200 /// Messages MAY be called in parallel when they originate from different `their_node_ids`, however
1201 /// they MUST NOT be called in parallel when the two calls have the same `their_node_id`.
1202 pub trait ChannelMessageHandler : MessageSendEventsProvider {
1204 /// Handle an incoming `open_channel` message from the given peer.
1205 fn handle_open_channel(&self, their_node_id: &PublicKey, msg: &OpenChannel);
1206 /// Handle an incoming `open_channel2` message from the given peer.
1207 fn handle_open_channel_v2(&self, their_node_id: &PublicKey, msg: &OpenChannelV2);
1208 /// Handle an incoming `accept_channel` message from the given peer.
1209 fn handle_accept_channel(&self, their_node_id: &PublicKey, msg: &AcceptChannel);
1210 /// Handle an incoming `accept_channel2` message from the given peer.
1211 fn handle_accept_channel_v2(&self, their_node_id: &PublicKey, msg: &AcceptChannelV2);
1212 /// Handle an incoming `funding_created` message from the given peer.
1213 fn handle_funding_created(&self, their_node_id: &PublicKey, msg: &FundingCreated);
1214 /// Handle an incoming `funding_signed` message from the given peer.
1215 fn handle_funding_signed(&self, their_node_id: &PublicKey, msg: &FundingSigned);
1216 /// Handle an incoming `channel_ready` message from the given peer.
1217 fn handle_channel_ready(&self, their_node_id: &PublicKey, msg: &ChannelReady);
1220 /// Handle an incoming `shutdown` message from the given peer.
1221 fn handle_shutdown(&self, their_node_id: &PublicKey, msg: &Shutdown);
1222 /// Handle an incoming `closing_signed` message from the given peer.
1223 fn handle_closing_signed(&self, their_node_id: &PublicKey, msg: &ClosingSigned);
1225 // Interactive channel construction
1226 /// Handle an incoming `tx_add_input message` from the given peer.
1227 fn handle_tx_add_input(&self, their_node_id: &PublicKey, msg: &TxAddInput);
1228 /// Handle an incoming `tx_add_output` message from the given peer.
1229 fn handle_tx_add_output(&self, their_node_id: &PublicKey, msg: &TxAddOutput);
1230 /// Handle an incoming `tx_remove_input` message from the given peer.
1231 fn handle_tx_remove_input(&self, their_node_id: &PublicKey, msg: &TxRemoveInput);
1232 /// Handle an incoming `tx_remove_output` message from the given peer.
1233 fn handle_tx_remove_output(&self, their_node_id: &PublicKey, msg: &TxRemoveOutput);
1234 /// Handle an incoming `tx_complete message` from the given peer.
1235 fn handle_tx_complete(&self, their_node_id: &PublicKey, msg: &TxComplete);
1236 /// Handle an incoming `tx_signatures` message from the given peer.
1237 fn handle_tx_signatures(&self, their_node_id: &PublicKey, msg: &TxSignatures);
1238 /// Handle an incoming `tx_init_rbf` message from the given peer.
1239 fn handle_tx_init_rbf(&self, their_node_id: &PublicKey, msg: &TxInitRbf);
1240 /// Handle an incoming `tx_ack_rbf` message from the given peer.
1241 fn handle_tx_ack_rbf(&self, their_node_id: &PublicKey, msg: &TxAckRbf);
1242 /// Handle an incoming `tx_abort message` from the given peer.
1243 fn handle_tx_abort(&self, their_node_id: &PublicKey, msg: &TxAbort);
1246 /// Handle an incoming `update_add_htlc` message from the given peer.
1247 fn handle_update_add_htlc(&self, their_node_id: &PublicKey, msg: &UpdateAddHTLC);
1248 /// Handle an incoming `update_fulfill_htlc` message from the given peer.
1249 fn handle_update_fulfill_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFulfillHTLC);
1250 /// Handle an incoming `update_fail_htlc` message from the given peer.
1251 fn handle_update_fail_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailHTLC);
1252 /// Handle an incoming `update_fail_malformed_htlc` message from the given peer.
1253 fn handle_update_fail_malformed_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailMalformedHTLC);
1254 /// Handle an incoming `commitment_signed` message from the given peer.
1255 fn handle_commitment_signed(&self, their_node_id: &PublicKey, msg: &CommitmentSigned);
1256 /// Handle an incoming `revoke_and_ack` message from the given peer.
1257 fn handle_revoke_and_ack(&self, their_node_id: &PublicKey, msg: &RevokeAndACK);
1259 /// Handle an incoming `update_fee` message from the given peer.
1260 fn handle_update_fee(&self, their_node_id: &PublicKey, msg: &UpdateFee);
1262 // Channel-to-announce:
1263 /// Handle an incoming `announcement_signatures` message from the given peer.
1264 fn handle_announcement_signatures(&self, their_node_id: &PublicKey, msg: &AnnouncementSignatures);
1266 // Connection loss/reestablish:
1267 /// Indicates a connection to the peer failed/an existing connection was lost.
1268 fn peer_disconnected(&self, their_node_id: &PublicKey);
1270 /// Handle a peer reconnecting, possibly generating `channel_reestablish` message(s).
1272 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1273 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1274 /// message handlers may still wish to communicate with this peer.
1275 fn peer_connected(&self, their_node_id: &PublicKey, msg: &Init, inbound: bool) -> Result<(), ()>;
1276 /// Handle an incoming `channel_reestablish` message from the given peer.
1277 fn handle_channel_reestablish(&self, their_node_id: &PublicKey, msg: &ChannelReestablish);
1279 /// Handle an incoming `channel_update` message from the given peer.
1280 fn handle_channel_update(&self, their_node_id: &PublicKey, msg: &ChannelUpdate);
1283 /// Handle an incoming `error` message from the given peer.
1284 fn handle_error(&self, their_node_id: &PublicKey, msg: &ErrorMessage);
1286 // Handler information:
1287 /// Gets the node feature flags which this handler itself supports. All available handlers are
1288 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1289 /// which are broadcasted in our [`NodeAnnouncement`] message.
1290 fn provided_node_features(&self) -> NodeFeatures;
1292 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1293 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1294 /// which are sent in our [`Init`] message.
1296 /// Note that this method is called before [`Self::peer_connected`].
1297 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1300 /// A trait to describe an object which can receive routing messages.
1302 /// # Implementor DoS Warnings
1304 /// For messages enabled with the `gossip_queries` feature there are potential DoS vectors when
1305 /// handling inbound queries. Implementors using an on-disk network graph should be aware of
1306 /// repeated disk I/O for queries accessing different parts of the network graph.
1307 pub trait RoutingMessageHandler : MessageSendEventsProvider {
1308 /// Handle an incoming `node_announcement` message, returning `true` if it should be forwarded on,
1309 /// `false` or returning an `Err` otherwise.
1310 fn handle_node_announcement(&self, msg: &NodeAnnouncement) -> Result<bool, LightningError>;
1311 /// Handle a `channel_announcement` message, returning `true` if it should be forwarded on, `false`
1312 /// or returning an `Err` otherwise.
1313 fn handle_channel_announcement(&self, msg: &ChannelAnnouncement) -> Result<bool, LightningError>;
1314 /// Handle an incoming `channel_update` message, returning true if it should be forwarded on,
1315 /// `false` or returning an `Err` otherwise.
1316 fn handle_channel_update(&self, msg: &ChannelUpdate) -> Result<bool, LightningError>;
1317 /// Gets channel announcements and updates required to dump our routing table to a remote node,
1318 /// starting at the `short_channel_id` indicated by `starting_point` and including announcements
1319 /// for a single channel.
1320 fn get_next_channel_announcement(&self, starting_point: u64) -> Option<(ChannelAnnouncement, Option<ChannelUpdate>, Option<ChannelUpdate>)>;
1321 /// Gets a node announcement required to dump our routing table to a remote node, starting at
1322 /// the node *after* the provided pubkey and including up to one announcement immediately
1323 /// higher (as defined by `<PublicKey as Ord>::cmp`) than `starting_point`.
1324 /// If `None` is provided for `starting_point`, we start at the first node.
1325 fn get_next_node_announcement(&self, starting_point: Option<&NodeId>) -> Option<NodeAnnouncement>;
1326 /// Called when a connection is established with a peer. This can be used to
1327 /// perform routing table synchronization using a strategy defined by the
1330 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1331 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1332 /// message handlers may still wish to communicate with this peer.
1333 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1334 /// Handles the reply of a query we initiated to learn about channels
1335 /// for a given range of blocks. We can expect to receive one or more
1336 /// replies to a single query.
1337 fn handle_reply_channel_range(&self, their_node_id: &PublicKey, msg: ReplyChannelRange) -> Result<(), LightningError>;
1338 /// Handles the reply of a query we initiated asking for routing gossip
1339 /// messages for a list of channels. We should receive this message when
1340 /// a node has completed its best effort to send us the pertaining routing
1341 /// gossip messages.
1342 fn handle_reply_short_channel_ids_end(&self, their_node_id: &PublicKey, msg: ReplyShortChannelIdsEnd) -> Result<(), LightningError>;
1343 /// Handles when a peer asks us to send a list of `short_channel_id`s
1344 /// for the requested range of blocks.
1345 fn handle_query_channel_range(&self, their_node_id: &PublicKey, msg: QueryChannelRange) -> Result<(), LightningError>;
1346 /// Handles when a peer asks us to send routing gossip messages for a
1347 /// list of `short_channel_id`s.
1348 fn handle_query_short_channel_ids(&self, their_node_id: &PublicKey, msg: QueryShortChannelIds) -> Result<(), LightningError>;
1350 // Handler queueing status:
1351 /// Indicates that there are a large number of [`ChannelAnnouncement`] (or other) messages
1352 /// pending some async action. While there is no guarantee of the rate of future messages, the
1353 /// caller should seek to reduce the rate of new gossip messages handled, especially
1354 /// [`ChannelAnnouncement`]s.
1355 fn processing_queue_high(&self) -> bool;
1357 // Handler information:
1358 /// Gets the node feature flags which this handler itself supports. All available handlers are
1359 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1360 /// which are broadcasted in our [`NodeAnnouncement`] message.
1361 fn provided_node_features(&self) -> NodeFeatures;
1362 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1363 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1364 /// which are sent in our [`Init`] message.
1366 /// Note that this method is called before [`Self::peer_connected`].
1367 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1370 /// A trait to describe an object that can receive onion messages.
1371 pub trait OnionMessageHandler : OnionMessageProvider {
1372 /// Handle an incoming `onion_message` message from the given peer.
1373 fn handle_onion_message(&self, peer_node_id: &PublicKey, msg: &OnionMessage);
1374 /// Called when a connection is established with a peer. Can be used to track which peers
1375 /// advertise onion message support and are online.
1377 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1378 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1379 /// message handlers may still wish to communicate with this peer.
1380 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1381 /// Indicates a connection to the peer failed/an existing connection was lost. Allows handlers to
1382 /// drop and refuse to forward onion messages to this peer.
1383 fn peer_disconnected(&self, their_node_id: &PublicKey);
1385 // Handler information:
1386 /// Gets the node feature flags which this handler itself supports. All available handlers are
1387 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1388 /// which are broadcasted in our [`NodeAnnouncement`] message.
1389 fn provided_node_features(&self) -> NodeFeatures;
1391 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1392 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1393 /// which are sent in our [`Init`] message.
1395 /// Note that this method is called before [`Self::peer_connected`].
1396 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1399 mod fuzzy_internal_msgs {
1400 use crate::prelude::*;
1401 use crate::ln::{PaymentPreimage, PaymentSecret};
1403 // These types aren't intended to be pub, but are exposed for direct fuzzing (as we deserialize
1404 // them from untrusted input):
1406 pub(crate) struct FinalOnionHopData {
1407 pub(crate) payment_secret: PaymentSecret,
1408 /// The total value, in msat, of the payment as received by the ultimate recipient.
1409 /// Message serialization may panic if this value is more than 21 million Bitcoin.
1410 pub(crate) total_msat: u64,
1413 pub(crate) enum OnionHopDataFormat {
1415 short_channel_id: u64,
1418 payment_data: Option<FinalOnionHopData>,
1419 payment_metadata: Option<Vec<u8>>,
1420 keysend_preimage: Option<PaymentPreimage>,
1424 pub struct OnionHopData {
1425 pub(crate) format: OnionHopDataFormat,
1426 /// The value, in msat, of the payment after this hop's fee is deducted.
1427 /// Message serialization may panic if this value is more than 21 million Bitcoin.
1428 pub(crate) amt_to_forward: u64,
1429 pub(crate) outgoing_cltv_value: u32,
1432 pub struct DecodedOnionErrorPacket {
1433 pub(crate) hmac: [u8; 32],
1434 pub(crate) failuremsg: Vec<u8>,
1435 pub(crate) pad: Vec<u8>,
1439 pub use self::fuzzy_internal_msgs::*;
1440 #[cfg(not(fuzzing))]
1441 pub(crate) use self::fuzzy_internal_msgs::*;
1444 pub(crate) struct OnionPacket {
1445 pub(crate) version: u8,
1446 /// In order to ensure we always return an error on onion decode in compliance with [BOLT
1447 /// #4](https://github.com/lightning/bolts/blob/master/04-onion-routing.md), we have to
1448 /// deserialize `OnionPacket`s contained in [`UpdateAddHTLC`] messages even if the ephemeral
1449 /// public key (here) is bogus, so we hold a [`Result`] instead of a [`PublicKey`] as we'd
1451 pub(crate) public_key: Result<PublicKey, secp256k1::Error>,
1452 pub(crate) hop_data: [u8; 20*65],
1453 pub(crate) hmac: [u8; 32],
1456 impl onion_utils::Packet for OnionPacket {
1457 type Data = onion_utils::FixedSizeOnionPacket;
1458 fn new(pubkey: PublicKey, hop_data: onion_utils::FixedSizeOnionPacket, hmac: [u8; 32]) -> Self {
1461 public_key: Ok(pubkey),
1462 hop_data: hop_data.0,
1468 impl Eq for OnionPacket { }
1469 impl PartialEq for OnionPacket {
1470 fn eq(&self, other: &OnionPacket) -> bool {
1471 for (i, j) in self.hop_data.iter().zip(other.hop_data.iter()) {
1472 if i != j { return false; }
1474 self.version == other.version &&
1475 self.public_key == other.public_key &&
1476 self.hmac == other.hmac
1480 impl fmt::Debug for OnionPacket {
1481 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1482 f.write_fmt(format_args!("OnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
1486 #[derive(Clone, Debug, PartialEq, Eq)]
1487 pub(crate) struct OnionErrorPacket {
1488 // This really should be a constant size slice, but the spec lets these things be up to 128KB?
1489 // (TODO) We limit it in decode to much lower...
1490 pub(crate) data: Vec<u8>,
1493 impl fmt::Display for DecodeError {
1494 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1496 DecodeError::UnknownVersion => f.write_str("Unknown realm byte in Onion packet"),
1497 DecodeError::UnknownRequiredFeature => f.write_str("Unknown required feature preventing decode"),
1498 DecodeError::InvalidValue => f.write_str("Nonsense bytes didn't map to the type they were interpreted as"),
1499 DecodeError::ShortRead => f.write_str("Packet extended beyond the provided bytes"),
1500 DecodeError::BadLengthDescriptor => f.write_str("A length descriptor in the packet didn't describe the later data correctly"),
1501 DecodeError::Io(ref e) => fmt::Debug::fmt(e, f),
1502 DecodeError::UnsupportedCompression => f.write_str("We don't support receiving messages with zlib-compressed fields"),
1507 impl From<io::Error> for DecodeError {
1508 fn from(e: io::Error) -> Self {
1509 if e.kind() == io::ErrorKind::UnexpectedEof {
1510 DecodeError::ShortRead
1512 DecodeError::Io(e.kind())
1517 #[cfg(not(taproot))]
1518 impl_writeable_msg!(AcceptChannel, {
1519 temporary_channel_id,
1520 dust_limit_satoshis,
1521 max_htlc_value_in_flight_msat,
1522 channel_reserve_satoshis,
1528 revocation_basepoint,
1530 delayed_payment_basepoint,
1532 first_per_commitment_point,
1534 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1535 (1, channel_type, option),
1539 impl_writeable_msg!(AcceptChannel, {
1540 temporary_channel_id,
1541 dust_limit_satoshis,
1542 max_htlc_value_in_flight_msat,
1543 channel_reserve_satoshis,
1549 revocation_basepoint,
1551 delayed_payment_basepoint,
1553 first_per_commitment_point,
1555 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1556 (1, channel_type, option),
1557 (4, next_local_nonce, option),
1560 impl_writeable_msg!(AcceptChannelV2, {
1561 temporary_channel_id,
1563 dust_limit_satoshis,
1564 max_htlc_value_in_flight_msat,
1570 revocation_basepoint,
1572 delayed_payment_basepoint,
1574 first_per_commitment_point,
1575 second_per_commitment_point,
1577 (0, shutdown_scriptpubkey, option),
1578 (1, channel_type, option),
1579 (2, require_confirmed_inputs, option),
1582 impl_writeable_msg!(TxAddInput, {
1590 impl_writeable_msg!(TxAddOutput, {
1597 impl_writeable_msg!(TxRemoveInput, {
1602 impl_writeable_msg!(TxRemoveOutput, {
1607 impl_writeable_msg!(TxComplete, {
1611 impl_writeable_msg!(TxSignatures, {
1617 impl_writeable_msg!(TxInitRbf, {
1620 feerate_sat_per_1000_weight,
1622 (0, funding_output_contribution, option),
1625 impl_writeable_msg!(TxAckRbf, {
1628 (0, funding_output_contribution, option),
1631 impl_writeable_msg!(TxAbort, {
1636 impl_writeable_msg!(AnnouncementSignatures, {
1643 impl_writeable_msg!(ChannelReestablish, {
1645 next_local_commitment_number,
1646 next_remote_commitment_number,
1647 your_last_per_commitment_secret,
1648 my_current_per_commitment_point,
1650 (0, next_funding_txid, option),
1653 impl_writeable_msg!(ClosingSigned,
1654 { channel_id, fee_satoshis, signature },
1655 { (1, fee_range, option) }
1658 impl_writeable!(ClosingSignedFeeRange, {
1663 #[cfg(not(taproot))]
1664 impl_writeable_msg!(CommitmentSigned, {
1671 impl_writeable_msg!(CommitmentSigned, {
1676 (2, partial_signature_with_nonce, option)
1679 impl_writeable!(DecodedOnionErrorPacket, {
1685 #[cfg(not(taproot))]
1686 impl_writeable_msg!(FundingCreated, {
1687 temporary_channel_id,
1689 funding_output_index,
1693 impl_writeable_msg!(FundingCreated, {
1694 temporary_channel_id,
1696 funding_output_index,
1699 (2, partial_signature_with_nonce, option),
1700 (4, next_local_nonce, option)
1703 #[cfg(not(taproot))]
1704 impl_writeable_msg!(FundingSigned, {
1710 impl_writeable_msg!(FundingSigned, {
1714 (2, partial_signature_with_nonce, option)
1717 impl_writeable_msg!(ChannelReady, {
1719 next_per_commitment_point,
1721 (1, short_channel_id_alias, option),
1724 impl Writeable for Init {
1725 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1726 // global_features gets the bottom 13 bits of our features, and local_features gets all of
1727 // our relevant feature bits. This keeps us compatible with old nodes.
1728 self.features.write_up_to_13(w)?;
1729 self.features.write(w)?;
1730 encode_tlv_stream!(w, {
1731 (3, self.remote_network_address, option)
1737 impl Readable for Init {
1738 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1739 let global_features: InitFeatures = Readable::read(r)?;
1740 let features: InitFeatures = Readable::read(r)?;
1741 let mut remote_network_address: Option<NetAddress> = None;
1742 decode_tlv_stream!(r, {
1743 (3, remote_network_address, option)
1746 features: features | global_features,
1747 remote_network_address,
1752 impl_writeable_msg!(OpenChannel, {
1754 temporary_channel_id,
1757 dust_limit_satoshis,
1758 max_htlc_value_in_flight_msat,
1759 channel_reserve_satoshis,
1765 revocation_basepoint,
1767 delayed_payment_basepoint,
1769 first_per_commitment_point,
1772 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1773 (1, channel_type, option),
1776 impl_writeable_msg!(OpenChannelV2, {
1778 temporary_channel_id,
1779 funding_feerate_sat_per_1000_weight,
1780 commitment_feerate_sat_per_1000_weight,
1782 dust_limit_satoshis,
1783 max_htlc_value_in_flight_msat,
1789 revocation_basepoint,
1791 delayed_payment_basepoint,
1793 first_per_commitment_point,
1794 second_per_commitment_point,
1797 (0, shutdown_scriptpubkey, option),
1798 (1, channel_type, option),
1799 (2, require_confirmed_inputs, option),
1802 #[cfg(not(taproot))]
1803 impl_writeable_msg!(RevokeAndACK, {
1805 per_commitment_secret,
1806 next_per_commitment_point
1810 impl_writeable_msg!(RevokeAndACK, {
1812 per_commitment_secret,
1813 next_per_commitment_point
1815 (4, next_local_nonce, option)
1818 impl_writeable_msg!(Shutdown, {
1823 impl_writeable_msg!(UpdateFailHTLC, {
1829 impl_writeable_msg!(UpdateFailMalformedHTLC, {
1836 impl_writeable_msg!(UpdateFee, {
1841 impl_writeable_msg!(UpdateFulfillHTLC, {
1847 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
1848 // serialization format in a way which assumes we know the total serialized length/message end
1850 impl_writeable!(OnionErrorPacket, {
1854 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
1855 // serialization format in a way which assumes we know the total serialized length/message end
1857 impl Writeable for OnionPacket {
1858 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1859 self.version.write(w)?;
1860 match self.public_key {
1861 Ok(pubkey) => pubkey.write(w)?,
1862 Err(_) => [0u8;33].write(w)?,
1864 w.write_all(&self.hop_data)?;
1865 self.hmac.write(w)?;
1870 impl Readable for OnionPacket {
1871 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1873 version: Readable::read(r)?,
1875 let mut buf = [0u8;33];
1876 r.read_exact(&mut buf)?;
1877 PublicKey::from_slice(&buf)
1879 hop_data: Readable::read(r)?,
1880 hmac: Readable::read(r)?,
1885 impl_writeable_msg!(UpdateAddHTLC, {
1891 onion_routing_packet
1894 impl Readable for OnionMessage {
1895 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1896 let blinding_point: PublicKey = Readable::read(r)?;
1897 let len: u16 = Readable::read(r)?;
1898 let mut packet_reader = FixedLengthReader::new(r, len as u64);
1899 let onion_routing_packet: onion_message::Packet = <onion_message::Packet as LengthReadable>::read(&mut packet_reader)?;
1902 onion_routing_packet,
1907 impl Writeable for OnionMessage {
1908 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1909 self.blinding_point.write(w)?;
1910 let onion_packet_len = self.onion_routing_packet.serialized_length();
1911 (onion_packet_len as u16).write(w)?;
1912 self.onion_routing_packet.write(w)?;
1917 impl Writeable for FinalOnionHopData {
1918 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1919 self.payment_secret.0.write(w)?;
1920 HighZeroBytesDroppedBigSize(self.total_msat).write(w)
1924 impl Readable for FinalOnionHopData {
1925 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1926 let secret: [u8; 32] = Readable::read(r)?;
1927 let amt: HighZeroBytesDroppedBigSize<u64> = Readable::read(r)?;
1928 Ok(Self { payment_secret: PaymentSecret(secret), total_msat: amt.0 })
1932 impl Writeable for OnionHopData {
1933 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1935 OnionHopDataFormat::NonFinalNode { short_channel_id } => {
1936 _encode_varint_length_prefixed_tlv!(w, {
1937 (2, HighZeroBytesDroppedBigSize(self.amt_to_forward), required),
1938 (4, HighZeroBytesDroppedBigSize(self.outgoing_cltv_value), required),
1939 (6, short_channel_id, required)
1942 OnionHopDataFormat::FinalNode { ref payment_data, ref payment_metadata, ref keysend_preimage } => {
1943 _encode_varint_length_prefixed_tlv!(w, {
1944 (2, HighZeroBytesDroppedBigSize(self.amt_to_forward), required),
1945 (4, HighZeroBytesDroppedBigSize(self.outgoing_cltv_value), required),
1946 (8, payment_data, option),
1947 (16, payment_metadata.as_ref().map(|m| WithoutLength(m)), option),
1948 (5482373484, keysend_preimage, option)
1956 impl Readable for OnionHopData {
1957 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1958 let mut amt = HighZeroBytesDroppedBigSize(0u64);
1959 let mut cltv_value = HighZeroBytesDroppedBigSize(0u32);
1960 let mut short_id: Option<u64> = None;
1961 let mut payment_data: Option<FinalOnionHopData> = None;
1962 let mut payment_metadata: Option<WithoutLength<Vec<u8>>> = None;
1963 let mut keysend_preimage: Option<PaymentPreimage> = None;
1964 read_tlv_fields!(r, {
1966 (4, cltv_value, required),
1967 (6, short_id, option),
1968 (8, payment_data, option),
1969 (16, payment_metadata, option),
1970 // See https://github.com/lightning/blips/blob/master/blip-0003.md
1971 (5482373484, keysend_preimage, option)
1974 let format = if let Some(short_channel_id) = short_id {
1975 if payment_data.is_some() { return Err(DecodeError::InvalidValue); }
1976 if payment_metadata.is_some() { return Err(DecodeError::InvalidValue); }
1977 OnionHopDataFormat::NonFinalNode {
1981 if let Some(data) = &payment_data {
1982 if data.total_msat > MAX_VALUE_MSAT {
1983 return Err(DecodeError::InvalidValue);
1986 OnionHopDataFormat::FinalNode {
1988 payment_metadata: payment_metadata.map(|w| w.0),
1993 if amt.0 > MAX_VALUE_MSAT {
1994 return Err(DecodeError::InvalidValue);
1998 amt_to_forward: amt.0,
1999 outgoing_cltv_value: cltv_value.0,
2004 // ReadableArgs because we need onion_utils::decode_next_hop to accommodate payment packets and
2005 // onion message packets.
2006 impl ReadableArgs<()> for OnionHopData {
2007 fn read<R: Read>(r: &mut R, _arg: ()) -> Result<Self, DecodeError> {
2008 <Self as Readable>::read(r)
2012 impl Writeable for Ping {
2013 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2014 self.ponglen.write(w)?;
2015 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2020 impl Readable for Ping {
2021 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2023 ponglen: Readable::read(r)?,
2025 let byteslen = Readable::read(r)?;
2026 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2033 impl Writeable for Pong {
2034 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2035 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2040 impl Readable for Pong {
2041 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2044 let byteslen = Readable::read(r)?;
2045 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2052 impl Writeable for UnsignedChannelAnnouncement {
2053 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2054 self.features.write(w)?;
2055 self.chain_hash.write(w)?;
2056 self.short_channel_id.write(w)?;
2057 self.node_id_1.write(w)?;
2058 self.node_id_2.write(w)?;
2059 self.bitcoin_key_1.write(w)?;
2060 self.bitcoin_key_2.write(w)?;
2061 w.write_all(&self.excess_data[..])?;
2066 impl Readable for UnsignedChannelAnnouncement {
2067 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2069 features: Readable::read(r)?,
2070 chain_hash: Readable::read(r)?,
2071 short_channel_id: Readable::read(r)?,
2072 node_id_1: Readable::read(r)?,
2073 node_id_2: Readable::read(r)?,
2074 bitcoin_key_1: Readable::read(r)?,
2075 bitcoin_key_2: Readable::read(r)?,
2076 excess_data: read_to_end(r)?,
2081 impl_writeable!(ChannelAnnouncement, {
2084 bitcoin_signature_1,
2085 bitcoin_signature_2,
2089 impl Writeable for UnsignedChannelUpdate {
2090 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2091 // `message_flags` used to indicate presence of `htlc_maximum_msat`, but was deprecated in the spec.
2092 const MESSAGE_FLAGS: u8 = 1;
2093 self.chain_hash.write(w)?;
2094 self.short_channel_id.write(w)?;
2095 self.timestamp.write(w)?;
2096 let all_flags = self.flags as u16 | ((MESSAGE_FLAGS as u16) << 8);
2097 all_flags.write(w)?;
2098 self.cltv_expiry_delta.write(w)?;
2099 self.htlc_minimum_msat.write(w)?;
2100 self.fee_base_msat.write(w)?;
2101 self.fee_proportional_millionths.write(w)?;
2102 self.htlc_maximum_msat.write(w)?;
2103 w.write_all(&self.excess_data[..])?;
2108 impl Readable for UnsignedChannelUpdate {
2109 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2111 chain_hash: Readable::read(r)?,
2112 short_channel_id: Readable::read(r)?,
2113 timestamp: Readable::read(r)?,
2115 let flags: u16 = Readable::read(r)?;
2116 // Note: we ignore the `message_flags` for now, since it was deprecated by the spec.
2119 cltv_expiry_delta: Readable::read(r)?,
2120 htlc_minimum_msat: Readable::read(r)?,
2121 fee_base_msat: Readable::read(r)?,
2122 fee_proportional_millionths: Readable::read(r)?,
2123 htlc_maximum_msat: Readable::read(r)?,
2124 excess_data: read_to_end(r)?,
2129 impl_writeable!(ChannelUpdate, {
2134 impl Writeable for ErrorMessage {
2135 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2136 self.channel_id.write(w)?;
2137 (self.data.len() as u16).write(w)?;
2138 w.write_all(self.data.as_bytes())?;
2143 impl Readable for ErrorMessage {
2144 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2146 channel_id: Readable::read(r)?,
2148 let sz: usize = <u16 as Readable>::read(r)? as usize;
2149 let mut data = Vec::with_capacity(sz);
2151 r.read_exact(&mut data)?;
2152 match String::from_utf8(data) {
2154 Err(_) => return Err(DecodeError::InvalidValue),
2161 impl Writeable for WarningMessage {
2162 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2163 self.channel_id.write(w)?;
2164 (self.data.len() as u16).write(w)?;
2165 w.write_all(self.data.as_bytes())?;
2170 impl Readable for WarningMessage {
2171 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2173 channel_id: Readable::read(r)?,
2175 let sz: usize = <u16 as Readable>::read(r)? as usize;
2176 let mut data = Vec::with_capacity(sz);
2178 r.read_exact(&mut data)?;
2179 match String::from_utf8(data) {
2181 Err(_) => return Err(DecodeError::InvalidValue),
2188 impl Writeable for UnsignedNodeAnnouncement {
2189 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2190 self.features.write(w)?;
2191 self.timestamp.write(w)?;
2192 self.node_id.write(w)?;
2193 w.write_all(&self.rgb)?;
2194 self.alias.write(w)?;
2196 let mut addr_len = 0;
2197 for addr in self.addresses.iter() {
2198 addr_len += 1 + addr.len();
2200 (addr_len + self.excess_address_data.len() as u16).write(w)?;
2201 for addr in self.addresses.iter() {
2204 w.write_all(&self.excess_address_data[..])?;
2205 w.write_all(&self.excess_data[..])?;
2210 impl Readable for UnsignedNodeAnnouncement {
2211 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2212 let features: NodeFeatures = Readable::read(r)?;
2213 let timestamp: u32 = Readable::read(r)?;
2214 let node_id: NodeId = Readable::read(r)?;
2215 let mut rgb = [0; 3];
2216 r.read_exact(&mut rgb)?;
2217 let alias: NodeAlias = Readable::read(r)?;
2219 let addr_len: u16 = Readable::read(r)?;
2220 let mut addresses: Vec<NetAddress> = Vec::new();
2221 let mut addr_readpos = 0;
2222 let mut excess = false;
2223 let mut excess_byte = 0;
2225 if addr_len <= addr_readpos { break; }
2226 match Readable::read(r) {
2228 if addr_len < addr_readpos + 1 + addr.len() {
2229 return Err(DecodeError::BadLengthDescriptor);
2231 addr_readpos += (1 + addr.len()) as u16;
2232 addresses.push(addr);
2234 Ok(Err(unknown_descriptor)) => {
2236 excess_byte = unknown_descriptor;
2239 Err(DecodeError::ShortRead) => return Err(DecodeError::BadLengthDescriptor),
2240 Err(e) => return Err(e),
2244 let mut excess_data = vec![];
2245 let excess_address_data = if addr_readpos < addr_len {
2246 let mut excess_address_data = vec![0; (addr_len - addr_readpos) as usize];
2247 r.read_exact(&mut excess_address_data[if excess { 1 } else { 0 }..])?;
2249 excess_address_data[0] = excess_byte;
2254 excess_data.push(excess_byte);
2258 excess_data.extend(read_to_end(r)?.iter());
2259 Ok(UnsignedNodeAnnouncement {
2266 excess_address_data,
2272 impl_writeable!(NodeAnnouncement, {
2277 impl Readable for QueryShortChannelIds {
2278 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2279 let chain_hash: BlockHash = Readable::read(r)?;
2281 let encoding_len: u16 = Readable::read(r)?;
2282 let encoding_type: u8 = Readable::read(r)?;
2284 // Must be encoding_type=0 uncompressed serialization. We do not
2285 // support encoding_type=1 zlib serialization.
2286 if encoding_type != EncodingType::Uncompressed as u8 {
2287 return Err(DecodeError::UnsupportedCompression);
2290 // We expect the encoding_len to always includes the 1-byte
2291 // encoding_type and that short_channel_ids are 8-bytes each
2292 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2293 return Err(DecodeError::InvalidValue);
2296 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2297 // less the 1-byte encoding_type
2298 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2299 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2300 for _ in 0..short_channel_id_count {
2301 short_channel_ids.push(Readable::read(r)?);
2304 Ok(QueryShortChannelIds {
2311 impl Writeable for QueryShortChannelIds {
2312 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2313 // Calculated from 1-byte encoding_type plus 8-bytes per short_channel_id
2314 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2316 self.chain_hash.write(w)?;
2317 encoding_len.write(w)?;
2319 // We only support type=0 uncompressed serialization
2320 (EncodingType::Uncompressed as u8).write(w)?;
2322 for scid in self.short_channel_ids.iter() {
2330 impl_writeable_msg!(ReplyShortChannelIdsEnd, {
2335 impl QueryChannelRange {
2336 /// Calculates the overflow safe ending block height for the query.
2338 /// Overflow returns `0xffffffff`, otherwise returns `first_blocknum + number_of_blocks`.
2339 pub fn end_blocknum(&self) -> u32 {
2340 match self.first_blocknum.checked_add(self.number_of_blocks) {
2341 Some(block) => block,
2342 None => u32::max_value(),
2347 impl_writeable_msg!(QueryChannelRange, {
2353 impl Readable for ReplyChannelRange {
2354 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2355 let chain_hash: BlockHash = Readable::read(r)?;
2356 let first_blocknum: u32 = Readable::read(r)?;
2357 let number_of_blocks: u32 = Readable::read(r)?;
2358 let sync_complete: bool = Readable::read(r)?;
2360 let encoding_len: u16 = Readable::read(r)?;
2361 let encoding_type: u8 = Readable::read(r)?;
2363 // Must be encoding_type=0 uncompressed serialization. We do not
2364 // support encoding_type=1 zlib serialization.
2365 if encoding_type != EncodingType::Uncompressed as u8 {
2366 return Err(DecodeError::UnsupportedCompression);
2369 // We expect the encoding_len to always includes the 1-byte
2370 // encoding_type and that short_channel_ids are 8-bytes each
2371 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2372 return Err(DecodeError::InvalidValue);
2375 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2376 // less the 1-byte encoding_type
2377 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2378 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2379 for _ in 0..short_channel_id_count {
2380 short_channel_ids.push(Readable::read(r)?);
2383 Ok(ReplyChannelRange {
2393 impl Writeable for ReplyChannelRange {
2394 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2395 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2396 self.chain_hash.write(w)?;
2397 self.first_blocknum.write(w)?;
2398 self.number_of_blocks.write(w)?;
2399 self.sync_complete.write(w)?;
2401 encoding_len.write(w)?;
2402 (EncodingType::Uncompressed as u8).write(w)?;
2403 for scid in self.short_channel_ids.iter() {
2411 impl_writeable_msg!(GossipTimestampFilter, {
2419 use bitcoin::{Transaction, PackedLockTime, TxIn, Script, Sequence, Witness, TxOut};
2421 use crate::ln::{PaymentPreimage, PaymentHash, PaymentSecret};
2422 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
2423 use crate::ln::msgs::{self, FinalOnionHopData, OnionErrorPacket, OnionHopDataFormat};
2424 use crate::routing::gossip::{NodeAlias, NodeId};
2425 use crate::util::ser::{Writeable, Readable, Hostname, TransactionU16LenLimited};
2427 use bitcoin::hashes::hex::FromHex;
2428 use bitcoin::util::address::Address;
2429 use bitcoin::network::constants::Network;
2430 use bitcoin::blockdata::script::Builder;
2431 use bitcoin::blockdata::opcodes;
2432 use bitcoin::hash_types::{Txid, BlockHash};
2434 use bitcoin::secp256k1::{PublicKey,SecretKey};
2435 use bitcoin::secp256k1::{Secp256k1, Message};
2437 use crate::io::{self, Cursor};
2438 use crate::prelude::*;
2439 use core::convert::TryFrom;
2440 use core::str::FromStr;
2442 use crate::chain::transaction::OutPoint;
2445 fn encoding_channel_reestablish() {
2447 let secp_ctx = Secp256k1::new();
2448 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2451 let cr = msgs::ChannelReestablish {
2452 channel_id: [4, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0],
2453 next_local_commitment_number: 3,
2454 next_remote_commitment_number: 4,
2455 your_last_per_commitment_secret: [9;32],
2456 my_current_per_commitment_point: public_key,
2457 next_funding_txid: None,
2460 let encoded_value = cr.encode();
2464 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
2465 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2466 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2467 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
2468 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
2474 fn encoding_channel_reestablish_with_next_funding_txid() {
2476 let secp_ctx = Secp256k1::new();
2477 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2480 let cr = msgs::ChannelReestablish {
2481 channel_id: [4, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0],
2482 next_local_commitment_number: 3,
2483 next_remote_commitment_number: 4,
2484 your_last_per_commitment_secret: [9;32],
2485 my_current_per_commitment_point: public_key,
2486 next_funding_txid: Some(Txid::from_hash(bitcoin::hashes::Hash::from_slice(&[
2487 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,
2491 let encoded_value = cr.encode();
2495 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
2496 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2497 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2498 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
2499 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
2500 0, // Type (next_funding_txid)
2502 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
2507 macro_rules! get_keys_from {
2508 ($slice: expr, $secp_ctx: expr) => {
2510 let privkey = SecretKey::from_slice(&hex::decode($slice).unwrap()[..]).unwrap();
2511 let pubkey = PublicKey::from_secret_key(&$secp_ctx, &privkey);
2517 macro_rules! get_sig_on {
2518 ($privkey: expr, $ctx: expr, $string: expr) => {
2520 let sighash = Message::from_slice(&$string.into_bytes()[..]).unwrap();
2521 $ctx.sign_ecdsa(&sighash, &$privkey)
2527 fn encoding_announcement_signatures() {
2528 let secp_ctx = Secp256k1::new();
2529 let (privkey, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2530 let sig_1 = get_sig_on!(privkey, secp_ctx, String::from("01010101010101010101010101010101"));
2531 let sig_2 = get_sig_on!(privkey, secp_ctx, String::from("02020202020202020202020202020202"));
2532 let announcement_signatures = msgs::AnnouncementSignatures {
2533 channel_id: [4, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0],
2534 short_channel_id: 2316138423780173,
2535 node_signature: sig_1,
2536 bitcoin_signature: sig_2,
2539 let encoded_value = announcement_signatures.encode();
2540 assert_eq!(encoded_value, hex::decode("040000000000000005000000000000000600000000000000070000000000000000083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073acf9953cef4700860f5967838eba2bae89288ad188ebf8b20bf995c3ea53a26df1876d0a3a0e13172ba286a673140190c02ba9da60a2e43a745188c8a83c7f3ef").unwrap());
2543 fn do_encoding_channel_announcement(unknown_features_bits: bool, excess_data: bool) {
2544 let secp_ctx = Secp256k1::new();
2545 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2546 let (privkey_2, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2547 let (privkey_3, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2548 let (privkey_4, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2549 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2550 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
2551 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
2552 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
2553 let mut features = ChannelFeatures::empty();
2554 if unknown_features_bits {
2555 features = ChannelFeatures::from_le_bytes(vec![0xFF, 0xFF]);
2557 let unsigned_channel_announcement = msgs::UnsignedChannelAnnouncement {
2559 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2560 short_channel_id: 2316138423780173,
2561 node_id_1: NodeId::from_pubkey(&pubkey_1),
2562 node_id_2: NodeId::from_pubkey(&pubkey_2),
2563 bitcoin_key_1: NodeId::from_pubkey(&pubkey_3),
2564 bitcoin_key_2: NodeId::from_pubkey(&pubkey_4),
2565 excess_data: if excess_data { vec![10, 0, 0, 20, 0, 0, 30, 0, 0, 40] } else { Vec::new() },
2567 let channel_announcement = msgs::ChannelAnnouncement {
2568 node_signature_1: sig_1,
2569 node_signature_2: sig_2,
2570 bitcoin_signature_1: sig_3,
2571 bitcoin_signature_2: sig_4,
2572 contents: unsigned_channel_announcement,
2574 let encoded_value = channel_announcement.encode();
2575 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a1735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap();
2576 if unknown_features_bits {
2577 target_value.append(&mut hex::decode("0002ffff").unwrap());
2579 target_value.append(&mut hex::decode("0000").unwrap());
2581 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2582 target_value.append(&mut hex::decode("00083a840000034d031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
2584 target_value.append(&mut hex::decode("0a00001400001e000028").unwrap());
2586 assert_eq!(encoded_value, target_value);
2590 fn encoding_channel_announcement() {
2591 do_encoding_channel_announcement(true, false);
2592 do_encoding_channel_announcement(false, true);
2593 do_encoding_channel_announcement(false, false);
2594 do_encoding_channel_announcement(true, true);
2597 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) {
2598 let secp_ctx = Secp256k1::new();
2599 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2600 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2601 let features = if unknown_features_bits {
2602 NodeFeatures::from_le_bytes(vec![0xFF, 0xFF])
2604 // Set to some features we may support
2605 NodeFeatures::from_le_bytes(vec![2 | 1 << 5])
2607 let mut addresses = Vec::new();
2609 addresses.push(msgs::NetAddress::IPv4 {
2610 addr: [255, 254, 253, 252],
2615 addresses.push(msgs::NetAddress::IPv6 {
2616 addr: [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240],
2621 addresses.push(msgs::NetAddress::OnionV2(
2622 [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 38, 7]
2626 addresses.push(msgs::NetAddress::OnionV3 {
2627 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],
2634 addresses.push(msgs::NetAddress::Hostname {
2635 hostname: Hostname::try_from(String::from("host")).unwrap(),
2639 let mut addr_len = 0;
2640 for addr in &addresses {
2641 addr_len += addr.len() + 1;
2643 let unsigned_node_announcement = msgs::UnsignedNodeAnnouncement {
2645 timestamp: 20190119,
2646 node_id: NodeId::from_pubkey(&pubkey_1),
2648 alias: NodeAlias([16;32]),
2650 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() },
2651 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() },
2653 addr_len += unsigned_node_announcement.excess_address_data.len() as u16;
2654 let node_announcement = msgs::NodeAnnouncement {
2656 contents: unsigned_node_announcement,
2658 let encoded_value = node_announcement.encode();
2659 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
2660 if unknown_features_bits {
2661 target_value.append(&mut hex::decode("0002ffff").unwrap());
2663 target_value.append(&mut hex::decode("000122").unwrap());
2665 target_value.append(&mut hex::decode("013413a7031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f2020201010101010101010101010101010101010101010101010101010101010101010").unwrap());
2666 target_value.append(&mut vec![(addr_len >> 8) as u8, addr_len as u8]);
2668 target_value.append(&mut hex::decode("01fffefdfc2607").unwrap());
2671 target_value.append(&mut hex::decode("02fffefdfcfbfaf9f8f7f6f5f4f3f2f1f02607").unwrap());
2674 target_value.append(&mut hex::decode("03fffefdfcfbfaf9f8f7f62607").unwrap());
2677 target_value.append(&mut hex::decode("04fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0efeeedecebeae9e8e7e6e5e4e3e2e1e00020102607").unwrap());
2680 target_value.append(&mut hex::decode("0504686f73742607").unwrap());
2682 if excess_address_data {
2683 target_value.append(&mut hex::decode("216c280b5395a2546e7e4b2663e04f811622f15a4f92e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d269").unwrap());
2686 target_value.append(&mut hex::decode("3b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
2688 assert_eq!(encoded_value, target_value);
2692 fn encoding_node_announcement() {
2693 do_encoding_node_announcement(true, true, true, true, true, true, true, true);
2694 do_encoding_node_announcement(false, false, false, false, false, false, false, false);
2695 do_encoding_node_announcement(false, true, false, false, false, false, false, false);
2696 do_encoding_node_announcement(false, false, true, false, false, false, false, false);
2697 do_encoding_node_announcement(false, false, false, true, false, false, false, false);
2698 do_encoding_node_announcement(false, false, false, false, true, false, false, false);
2699 do_encoding_node_announcement(false, false, false, false, false, true, false, false);
2700 do_encoding_node_announcement(false, false, false, false, false, false, true, false);
2701 do_encoding_node_announcement(false, true, false, true, false, false, true, false);
2702 do_encoding_node_announcement(false, false, true, false, true, false, false, false);
2705 fn do_encoding_channel_update(direction: bool, disable: bool, excess_data: bool) {
2706 let secp_ctx = Secp256k1::new();
2707 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2708 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2709 let unsigned_channel_update = msgs::UnsignedChannelUpdate {
2710 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2711 short_channel_id: 2316138423780173,
2712 timestamp: 20190119,
2713 flags: if direction { 1 } else { 0 } | if disable { 1 << 1 } else { 0 },
2714 cltv_expiry_delta: 144,
2715 htlc_minimum_msat: 1000000,
2716 htlc_maximum_msat: 131355275467161,
2717 fee_base_msat: 10000,
2718 fee_proportional_millionths: 20,
2719 excess_data: if excess_data { vec![0, 0, 0, 0, 59, 154, 202, 0] } else { Vec::new() }
2721 let channel_update = msgs::ChannelUpdate {
2723 contents: unsigned_channel_update
2725 let encoded_value = channel_update.encode();
2726 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
2727 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2728 target_value.append(&mut hex::decode("00083a840000034d013413a7").unwrap());
2729 target_value.append(&mut hex::decode("01").unwrap());
2730 target_value.append(&mut hex::decode("00").unwrap());
2732 let flag = target_value.last_mut().unwrap();
2736 let flag = target_value.last_mut().unwrap();
2737 *flag = *flag | 1 << 1;
2739 target_value.append(&mut hex::decode("009000000000000f42400000271000000014").unwrap());
2740 target_value.append(&mut hex::decode("0000777788889999").unwrap());
2742 target_value.append(&mut hex::decode("000000003b9aca00").unwrap());
2744 assert_eq!(encoded_value, target_value);
2748 fn encoding_channel_update() {
2749 do_encoding_channel_update(false, false, false);
2750 do_encoding_channel_update(false, false, true);
2751 do_encoding_channel_update(true, false, false);
2752 do_encoding_channel_update(true, false, true);
2753 do_encoding_channel_update(false, true, false);
2754 do_encoding_channel_update(false, true, true);
2755 do_encoding_channel_update(true, true, false);
2756 do_encoding_channel_update(true, true, true);
2759 fn do_encoding_open_channel(random_bit: bool, shutdown: bool, incl_chan_type: bool) {
2760 let secp_ctx = Secp256k1::new();
2761 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2762 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2763 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2764 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2765 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
2766 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
2767 let open_channel = msgs::OpenChannel {
2768 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2769 temporary_channel_id: [2; 32],
2770 funding_satoshis: 1311768467284833366,
2771 push_msat: 2536655962884945560,
2772 dust_limit_satoshis: 3608586615801332854,
2773 max_htlc_value_in_flight_msat: 8517154655701053848,
2774 channel_reserve_satoshis: 8665828695742877976,
2775 htlc_minimum_msat: 2316138423780173,
2776 feerate_per_kw: 821716,
2777 to_self_delay: 49340,
2778 max_accepted_htlcs: 49340,
2779 funding_pubkey: pubkey_1,
2780 revocation_basepoint: pubkey_2,
2781 payment_point: pubkey_3,
2782 delayed_payment_basepoint: pubkey_4,
2783 htlc_basepoint: pubkey_5,
2784 first_per_commitment_point: pubkey_6,
2785 channel_flags: if random_bit { 1 << 5 } else { 0 },
2786 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
2787 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
2789 let encoded_value = open_channel.encode();
2790 let mut target_value = Vec::new();
2791 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2792 target_value.append(&mut hex::decode("02020202020202020202020202020202020202020202020202020202020202021234567890123456233403289122369832144668701144767633030896203198784335490624111800083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
2794 target_value.append(&mut hex::decode("20").unwrap());
2796 target_value.append(&mut hex::decode("00").unwrap());
2799 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
2802 target_value.append(&mut hex::decode("0100").unwrap());
2804 assert_eq!(encoded_value, target_value);
2808 fn encoding_open_channel() {
2809 do_encoding_open_channel(false, false, false);
2810 do_encoding_open_channel(false, false, true);
2811 do_encoding_open_channel(false, true, false);
2812 do_encoding_open_channel(false, true, true);
2813 do_encoding_open_channel(true, false, false);
2814 do_encoding_open_channel(true, false, true);
2815 do_encoding_open_channel(true, true, false);
2816 do_encoding_open_channel(true, true, true);
2819 fn do_encoding_open_channelv2(random_bit: bool, shutdown: bool, incl_chan_type: bool, require_confirmed_inputs: bool) {
2820 let secp_ctx = Secp256k1::new();
2821 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2822 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2823 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2824 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2825 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
2826 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
2827 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
2828 let open_channelv2 = msgs::OpenChannelV2 {
2829 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2830 temporary_channel_id: [2; 32],
2831 funding_feerate_sat_per_1000_weight: 821716,
2832 commitment_feerate_sat_per_1000_weight: 821716,
2833 funding_satoshis: 1311768467284833366,
2834 dust_limit_satoshis: 3608586615801332854,
2835 max_htlc_value_in_flight_msat: 8517154655701053848,
2836 htlc_minimum_msat: 2316138423780173,
2837 to_self_delay: 49340,
2838 max_accepted_htlcs: 49340,
2839 locktime: 305419896,
2840 funding_pubkey: pubkey_1,
2841 revocation_basepoint: pubkey_2,
2842 payment_basepoint: pubkey_3,
2843 delayed_payment_basepoint: pubkey_4,
2844 htlc_basepoint: pubkey_5,
2845 first_per_commitment_point: pubkey_6,
2846 second_per_commitment_point: pubkey_7,
2847 channel_flags: if random_bit { 1 << 5 } else { 0 },
2848 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
2849 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
2850 require_confirmed_inputs: if require_confirmed_inputs { Some(()) } else { None },
2852 let encoded_value = open_channelv2.encode();
2853 let mut target_value = Vec::new();
2854 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2855 target_value.append(&mut hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap());
2856 target_value.append(&mut hex::decode("000c89d4").unwrap());
2857 target_value.append(&mut hex::decode("000c89d4").unwrap());
2858 target_value.append(&mut hex::decode("1234567890123456").unwrap());
2859 target_value.append(&mut hex::decode("3214466870114476").unwrap());
2860 target_value.append(&mut hex::decode("7633030896203198").unwrap());
2861 target_value.append(&mut hex::decode("00083a840000034d").unwrap());
2862 target_value.append(&mut hex::decode("c0bc").unwrap());
2863 target_value.append(&mut hex::decode("c0bc").unwrap());
2864 target_value.append(&mut hex::decode("12345678").unwrap());
2865 target_value.append(&mut hex::decode("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap());
2866 target_value.append(&mut hex::decode("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap());
2867 target_value.append(&mut hex::decode("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap());
2868 target_value.append(&mut hex::decode("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
2869 target_value.append(&mut hex::decode("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap());
2870 target_value.append(&mut hex::decode("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
2871 target_value.append(&mut hex::decode("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap());
2874 target_value.append(&mut hex::decode("20").unwrap());
2876 target_value.append(&mut hex::decode("00").unwrap());
2879 target_value.append(&mut hex::decode("001b").unwrap()); // Type 0 + Length 27
2880 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
2883 target_value.append(&mut hex::decode("0100").unwrap());
2885 if require_confirmed_inputs {
2886 target_value.append(&mut hex::decode("0200").unwrap());
2888 assert_eq!(encoded_value, target_value);
2892 fn encoding_open_channelv2() {
2893 do_encoding_open_channelv2(false, false, false, false);
2894 do_encoding_open_channelv2(false, false, false, true);
2895 do_encoding_open_channelv2(false, false, true, false);
2896 do_encoding_open_channelv2(false, false, true, true);
2897 do_encoding_open_channelv2(false, true, false, false);
2898 do_encoding_open_channelv2(false, true, false, true);
2899 do_encoding_open_channelv2(false, true, true, false);
2900 do_encoding_open_channelv2(false, true, true, true);
2901 do_encoding_open_channelv2(true, false, false, false);
2902 do_encoding_open_channelv2(true, false, false, true);
2903 do_encoding_open_channelv2(true, false, true, false);
2904 do_encoding_open_channelv2(true, false, true, true);
2905 do_encoding_open_channelv2(true, true, false, false);
2906 do_encoding_open_channelv2(true, true, false, true);
2907 do_encoding_open_channelv2(true, true, true, false);
2908 do_encoding_open_channelv2(true, true, true, true);
2911 fn do_encoding_accept_channel(shutdown: bool) {
2912 let secp_ctx = Secp256k1::new();
2913 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2914 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2915 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2916 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2917 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
2918 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
2919 let accept_channel = msgs::AcceptChannel {
2920 temporary_channel_id: [2; 32],
2921 dust_limit_satoshis: 1311768467284833366,
2922 max_htlc_value_in_flight_msat: 2536655962884945560,
2923 channel_reserve_satoshis: 3608586615801332854,
2924 htlc_minimum_msat: 2316138423780173,
2925 minimum_depth: 821716,
2926 to_self_delay: 49340,
2927 max_accepted_htlcs: 49340,
2928 funding_pubkey: pubkey_1,
2929 revocation_basepoint: pubkey_2,
2930 payment_point: pubkey_3,
2931 delayed_payment_basepoint: pubkey_4,
2932 htlc_basepoint: pubkey_5,
2933 first_per_commitment_point: pubkey_6,
2934 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
2937 next_local_nonce: None,
2939 let encoded_value = accept_channel.encode();
2940 let mut target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020212345678901234562334032891223698321446687011447600083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap();
2942 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
2944 assert_eq!(encoded_value, target_value);
2948 fn encoding_accept_channel() {
2949 do_encoding_accept_channel(false);
2950 do_encoding_accept_channel(true);
2953 fn do_encoding_accept_channelv2(shutdown: bool) {
2954 let secp_ctx = Secp256k1::new();
2955 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2956 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2957 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2958 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2959 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
2960 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
2961 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
2962 let accept_channelv2 = msgs::AcceptChannelV2 {
2963 temporary_channel_id: [2; 32],
2964 funding_satoshis: 1311768467284833366,
2965 dust_limit_satoshis: 1311768467284833366,
2966 max_htlc_value_in_flight_msat: 2536655962884945560,
2967 htlc_minimum_msat: 2316138423780173,
2968 minimum_depth: 821716,
2969 to_self_delay: 49340,
2970 max_accepted_htlcs: 49340,
2971 funding_pubkey: pubkey_1,
2972 revocation_basepoint: pubkey_2,
2973 payment_basepoint: pubkey_3,
2974 delayed_payment_basepoint: pubkey_4,
2975 htlc_basepoint: pubkey_5,
2976 first_per_commitment_point: pubkey_6,
2977 second_per_commitment_point: pubkey_7,
2978 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
2980 require_confirmed_inputs: None,
2982 let encoded_value = accept_channelv2.encode();
2983 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // temporary_channel_id
2984 target_value.append(&mut hex::decode("1234567890123456").unwrap()); // funding_satoshis
2985 target_value.append(&mut hex::decode("1234567890123456").unwrap()); // dust_limit_satoshis
2986 target_value.append(&mut hex::decode("2334032891223698").unwrap()); // max_htlc_value_in_flight_msat
2987 target_value.append(&mut hex::decode("00083a840000034d").unwrap()); // htlc_minimum_msat
2988 target_value.append(&mut hex::decode("000c89d4").unwrap()); // minimum_depth
2989 target_value.append(&mut hex::decode("c0bc").unwrap()); // to_self_delay
2990 target_value.append(&mut hex::decode("c0bc").unwrap()); // max_accepted_htlcs
2991 target_value.append(&mut hex::decode("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap()); // funding_pubkey
2992 target_value.append(&mut hex::decode("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap()); // revocation_basepoint
2993 target_value.append(&mut hex::decode("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap()); // payment_basepoint
2994 target_value.append(&mut hex::decode("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap()); // delayed_payment_basepoint
2995 target_value.append(&mut hex::decode("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap()); // htlc_basepoint
2996 target_value.append(&mut hex::decode("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap()); // first_per_commitment_point
2997 target_value.append(&mut hex::decode("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap()); // second_per_commitment_point
2999 target_value.append(&mut hex::decode("001b").unwrap()); // Type 0 + Length 27
3000 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3002 assert_eq!(encoded_value, target_value);
3006 fn encoding_accept_channelv2() {
3007 do_encoding_accept_channelv2(false);
3008 do_encoding_accept_channelv2(true);
3012 fn encoding_funding_created() {
3013 let secp_ctx = Secp256k1::new();
3014 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3015 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3016 let funding_created = msgs::FundingCreated {
3017 temporary_channel_id: [2; 32],
3018 funding_txid: Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3019 funding_output_index: 255,
3022 partial_signature_with_nonce: None,
3024 next_local_nonce: None,
3026 let encoded_value = funding_created.encode();
3027 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202026e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c200ffd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3028 assert_eq!(encoded_value, target_value);
3032 fn encoding_funding_signed() {
3033 let secp_ctx = Secp256k1::new();
3034 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3035 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3036 let funding_signed = msgs::FundingSigned {
3037 channel_id: [2; 32],
3040 partial_signature_with_nonce: None,
3042 let encoded_value = funding_signed.encode();
3043 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3044 assert_eq!(encoded_value, target_value);
3048 fn encoding_channel_ready() {
3049 let secp_ctx = Secp256k1::new();
3050 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3051 let channel_ready = msgs::ChannelReady {
3052 channel_id: [2; 32],
3053 next_per_commitment_point: pubkey_1,
3054 short_channel_id_alias: None,
3056 let encoded_value = channel_ready.encode();
3057 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3058 assert_eq!(encoded_value, target_value);
3062 fn encoding_tx_add_input() {
3063 let tx_add_input = msgs::TxAddInput {
3064 channel_id: [2; 32],
3065 serial_id: 4886718345,
3066 prevtx: TransactionU16LenLimited::new(Transaction {
3068 lock_time: PackedLockTime(0),
3070 previous_output: OutPoint { txid: Txid::from_hex("305bab643ee297b8b6b76b320792c8223d55082122cb606bf89382146ced9c77").unwrap(), index: 2 }.into_bitcoin_outpoint(),
3071 script_sig: Script::new(),
3072 sequence: Sequence(0xfffffffd),
3073 witness: Witness::from_vec(vec![
3074 hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3075 hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3080 script_pubkey: Address::from_str("bc1qzlffunw52jav8vwdu5x3jfk6sr8u22rmq3xzw2").unwrap().script_pubkey(),
3084 script_pubkey: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().script_pubkey(),
3088 prevtx_out: 305419896,
3089 sequence: 305419896,
3091 let encoded_value = tx_add_input.encode();
3092 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000000012345678900de02000000000101779ced6c148293f86b60cb222108553d22c89207326bb7b6b897e23e64ab5b300200000000fdffffff0236dbc1000000000016001417d29e4dd454bac3b1cde50d1926da80cfc5287b9cbd03000000000016001436ec78d514df462da95e6a00c24daa8915362d420247304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701210301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944000000001234567812345678").unwrap();
3093 assert_eq!(encoded_value, target_value);
3097 fn encoding_tx_add_output() {
3098 let tx_add_output = msgs::TxAddOutput {
3099 channel_id: [2; 32],
3100 serial_id: 4886718345,
3102 script: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().script_pubkey(),
3104 let encoded_value = tx_add_output.encode();
3105 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000000012345678900000001234567890016001436ec78d514df462da95e6a00c24daa8915362d42").unwrap();
3106 assert_eq!(encoded_value, target_value);
3110 fn encoding_tx_remove_input() {
3111 let tx_remove_input = msgs::TxRemoveInput {
3112 channel_id: [2; 32],
3113 serial_id: 4886718345,
3115 let encoded_value = tx_remove_input.encode();
3116 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3117 assert_eq!(encoded_value, target_value);
3121 fn encoding_tx_remove_output() {
3122 let tx_remove_output = msgs::TxRemoveOutput {
3123 channel_id: [2; 32],
3124 serial_id: 4886718345,
3126 let encoded_value = tx_remove_output.encode();
3127 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3128 assert_eq!(encoded_value, target_value);
3132 fn encoding_tx_complete() {
3133 let tx_complete = msgs::TxComplete {
3134 channel_id: [2; 32],
3136 let encoded_value = tx_complete.encode();
3137 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3138 assert_eq!(encoded_value, target_value);
3142 fn encoding_tx_signatures() {
3143 let tx_signatures = msgs::TxSignatures {
3144 channel_id: [2; 32],
3145 tx_hash: Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3147 Witness::from_vec(vec![
3148 hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3149 hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3150 Witness::from_vec(vec![
3151 hex::decode("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap(),
3152 hex::decode("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap()]),
3155 let encoded_value = tx_signatures.encode();
3156 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3157 target_value.append(&mut hex::decode("6e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c2").unwrap()); // tx_hash (sha256) (big endian byte order)
3158 target_value.append(&mut hex::decode("0002").unwrap()); // num_witnesses (u16)
3160 target_value.append(&mut hex::decode("006b").unwrap()); // len of witness_data
3161 target_value.append(&mut hex::decode("02").unwrap()); // num_witness_elements (VarInt)
3162 target_value.append(&mut hex::decode("47").unwrap()); // len of witness element data (VarInt)
3163 target_value.append(&mut hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap());
3164 target_value.append(&mut hex::decode("21").unwrap()); // len of witness element data (VarInt)
3165 target_value.append(&mut hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap());
3167 target_value.append(&mut hex::decode("006c").unwrap()); // len of witness_data
3168 target_value.append(&mut hex::decode("02").unwrap()); // num_witness_elements (VarInt)
3169 target_value.append(&mut hex::decode("48").unwrap()); // len of witness element data (VarInt)
3170 target_value.append(&mut hex::decode("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap());
3171 target_value.append(&mut hex::decode("21").unwrap()); // len of witness element data (VarInt)
3172 target_value.append(&mut hex::decode("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap());
3173 assert_eq!(encoded_value, target_value);
3176 fn do_encoding_tx_init_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3177 let tx_init_rbf = msgs::TxInitRbf {
3178 channel_id: [2; 32],
3179 locktime: 305419896,
3180 feerate_sat_per_1000_weight: 20190119,
3181 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3183 let encoded_value = tx_init_rbf.encode();
3184 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3185 target_value.append(&mut hex::decode("12345678").unwrap()); // locktime
3186 target_value.append(&mut hex::decode("013413a7").unwrap()); // feerate_sat_per_1000_weight
3187 if let Some((_, target)) = funding_value_with_hex_target {
3188 target_value.push(0x00); // Type
3189 target_value.push(target.len() as u8 / 2); // Length
3190 target_value.append(&mut hex::decode(target).unwrap()); // Value (i64)
3192 assert_eq!(encoded_value, target_value);
3196 fn encoding_tx_init_rbf() {
3197 do_encoding_tx_init_rbf(Some((1311768467284833366, "1234567890123456")));
3198 do_encoding_tx_init_rbf(Some((13117684672, "000000030DDFFBC0")));
3199 do_encoding_tx_init_rbf(None);
3202 fn do_encoding_tx_ack_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3203 let tx_ack_rbf = msgs::TxAckRbf {
3204 channel_id: [2; 32],
3205 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3207 let encoded_value = tx_ack_rbf.encode();
3208 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3209 if let Some((_, target)) = funding_value_with_hex_target {
3210 target_value.push(0x00); // Type
3211 target_value.push(target.len() as u8 / 2); // Length
3212 target_value.append(&mut hex::decode(target).unwrap()); // Value (i64)
3214 assert_eq!(encoded_value, target_value);
3218 fn encoding_tx_ack_rbf() {
3219 do_encoding_tx_ack_rbf(Some((1311768467284833366, "1234567890123456")));
3220 do_encoding_tx_ack_rbf(Some((13117684672, "000000030DDFFBC0")));
3221 do_encoding_tx_ack_rbf(None);
3225 fn encoding_tx_abort() {
3226 let tx_abort = msgs::TxAbort {
3227 channel_id: [2; 32],
3228 data: hex::decode("54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap(),
3230 let encoded_value = tx_abort.encode();
3231 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202002C54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap();
3232 assert_eq!(encoded_value, target_value);
3235 fn do_encoding_shutdown(script_type: u8) {
3236 let secp_ctx = Secp256k1::new();
3237 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3238 let script = Builder::new().push_opcode(opcodes::OP_TRUE).into_script();
3239 let shutdown = msgs::Shutdown {
3240 channel_id: [2; 32],
3242 if script_type == 1 { Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey() }
3243 else if script_type == 2 { Address::p2sh(&script, Network::Testnet).unwrap().script_pubkey() }
3244 else if script_type == 3 { Address::p2wpkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).unwrap().script_pubkey() }
3245 else { Address::p2wsh(&script, Network::Testnet).script_pubkey() },
3247 let encoded_value = shutdown.encode();
3248 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3249 if script_type == 1 {
3250 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3251 } else if script_type == 2 {
3252 target_value.append(&mut hex::decode("0017a914da1745e9b549bd0bfa1a569971c77eba30cd5a4b87").unwrap());
3253 } else if script_type == 3 {
3254 target_value.append(&mut hex::decode("0016001479b000887626b294a914501a4cd226b58b235983").unwrap());
3255 } else if script_type == 4 {
3256 target_value.append(&mut hex::decode("002200204ae81572f06e1b88fd5ced7a1a000945432e83e1551e6f721ee9c00b8cc33260").unwrap());
3258 assert_eq!(encoded_value, target_value);
3262 fn encoding_shutdown() {
3263 do_encoding_shutdown(1);
3264 do_encoding_shutdown(2);
3265 do_encoding_shutdown(3);
3266 do_encoding_shutdown(4);
3270 fn encoding_closing_signed() {
3271 let secp_ctx = Secp256k1::new();
3272 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3273 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3274 let closing_signed = msgs::ClosingSigned {
3275 channel_id: [2; 32],
3276 fee_satoshis: 2316138423780173,
3280 let encoded_value = closing_signed.encode();
3281 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3282 assert_eq!(encoded_value, target_value);
3283 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value)).unwrap(), closing_signed);
3285 let closing_signed_with_range = msgs::ClosingSigned {
3286 channel_id: [2; 32],
3287 fee_satoshis: 2316138423780173,
3289 fee_range: Some(msgs::ClosingSignedFeeRange {
3290 min_fee_satoshis: 0xdeadbeef,
3291 max_fee_satoshis: 0x1badcafe01234567,
3294 let encoded_value_with_range = closing_signed_with_range.encode();
3295 let target_value_with_range = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a011000000000deadbeef1badcafe01234567").unwrap();
3296 assert_eq!(encoded_value_with_range, target_value_with_range);
3297 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value_with_range)).unwrap(),
3298 closing_signed_with_range);
3302 fn encoding_update_add_htlc() {
3303 let secp_ctx = Secp256k1::new();
3304 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3305 let onion_routing_packet = msgs::OnionPacket {
3307 public_key: Ok(pubkey_1),
3308 hop_data: [1; 20*65],
3311 let update_add_htlc = msgs::UpdateAddHTLC {
3312 channel_id: [2; 32],
3313 htlc_id: 2316138423780173,
3314 amount_msat: 3608586615801332854,
3315 payment_hash: PaymentHash([1; 32]),
3316 cltv_expiry: 821716,
3317 onion_routing_packet
3319 let encoded_value = update_add_htlc.encode();
3320 let target_value = hex::decode("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").unwrap();
3321 assert_eq!(encoded_value, target_value);
3325 fn encoding_update_fulfill_htlc() {
3326 let update_fulfill_htlc = msgs::UpdateFulfillHTLC {
3327 channel_id: [2; 32],
3328 htlc_id: 2316138423780173,
3329 payment_preimage: PaymentPreimage([1; 32]),
3331 let encoded_value = update_fulfill_htlc.encode();
3332 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d0101010101010101010101010101010101010101010101010101010101010101").unwrap();
3333 assert_eq!(encoded_value, target_value);
3337 fn encoding_update_fail_htlc() {
3338 let reason = OnionErrorPacket {
3339 data: [1; 32].to_vec(),
3341 let update_fail_htlc = msgs::UpdateFailHTLC {
3342 channel_id: [2; 32],
3343 htlc_id: 2316138423780173,
3346 let encoded_value = update_fail_htlc.encode();
3347 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d00200101010101010101010101010101010101010101010101010101010101010101").unwrap();
3348 assert_eq!(encoded_value, target_value);
3352 fn encoding_update_fail_malformed_htlc() {
3353 let update_fail_malformed_htlc = msgs::UpdateFailMalformedHTLC {
3354 channel_id: [2; 32],
3355 htlc_id: 2316138423780173,
3356 sha256_of_onion: [1; 32],
3359 let encoded_value = update_fail_malformed_htlc.encode();
3360 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d010101010101010101010101010101010101010101010101010101010101010100ff").unwrap();
3361 assert_eq!(encoded_value, target_value);
3364 fn do_encoding_commitment_signed(htlcs: bool) {
3365 let secp_ctx = Secp256k1::new();
3366 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3367 let (privkey_2, _) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3368 let (privkey_3, _) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3369 let (privkey_4, _) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3370 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3371 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
3372 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
3373 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
3374 let commitment_signed = msgs::CommitmentSigned {
3375 channel_id: [2; 32],
3377 htlc_signatures: if htlcs { vec![sig_2, sig_3, sig_4] } else { Vec::new() },
3379 partial_signature_with_nonce: None,
3381 let encoded_value = commitment_signed.encode();
3382 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3384 target_value.append(&mut hex::decode("00031735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
3386 target_value.append(&mut hex::decode("0000").unwrap());
3388 assert_eq!(encoded_value, target_value);
3392 fn encoding_commitment_signed() {
3393 do_encoding_commitment_signed(true);
3394 do_encoding_commitment_signed(false);
3398 fn encoding_revoke_and_ack() {
3399 let secp_ctx = Secp256k1::new();
3400 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3401 let raa = msgs::RevokeAndACK {
3402 channel_id: [2; 32],
3403 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],
3404 next_per_commitment_point: pubkey_1,
3406 next_local_nonce: None,
3408 let encoded_value = raa.encode();
3409 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020101010101010101010101010101010101010101010101010101010101010101031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3410 assert_eq!(encoded_value, target_value);
3414 fn encoding_update_fee() {
3415 let update_fee = msgs::UpdateFee {
3416 channel_id: [2; 32],
3417 feerate_per_kw: 20190119,
3419 let encoded_value = update_fee.encode();
3420 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202013413a7").unwrap();
3421 assert_eq!(encoded_value, target_value);
3425 fn encoding_init() {
3426 assert_eq!(msgs::Init {
3427 features: InitFeatures::from_le_bytes(vec![0xFF, 0xFF, 0xFF]),
3428 remote_network_address: None,
3429 }.encode(), hex::decode("00023fff0003ffffff").unwrap());
3430 assert_eq!(msgs::Init {
3431 features: InitFeatures::from_le_bytes(vec![0xFF]),
3432 remote_network_address: None,
3433 }.encode(), hex::decode("0001ff0001ff").unwrap());
3434 assert_eq!(msgs::Init {
3435 features: InitFeatures::from_le_bytes(vec![]),
3436 remote_network_address: None,
3437 }.encode(), hex::decode("00000000").unwrap());
3439 let init_msg = msgs::Init { features: InitFeatures::from_le_bytes(vec![]),
3440 remote_network_address: Some(msgs::NetAddress::IPv4 {
3441 addr: [127, 0, 0, 1],
3445 let encoded_value = init_msg.encode();
3446 let target_value = hex::decode("000000000307017f00000103e8").unwrap();
3447 assert_eq!(encoded_value, target_value);
3448 assert_eq!(msgs::Init::read(&mut Cursor::new(&target_value)).unwrap(), init_msg);
3452 fn encoding_error() {
3453 let error = msgs::ErrorMessage {
3454 channel_id: [2; 32],
3455 data: String::from("rust-lightning"),
3457 let encoded_value = error.encode();
3458 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3459 assert_eq!(encoded_value, target_value);
3463 fn encoding_warning() {
3464 let error = msgs::WarningMessage {
3465 channel_id: [2; 32],
3466 data: String::from("rust-lightning"),
3468 let encoded_value = error.encode();
3469 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3470 assert_eq!(encoded_value, target_value);
3474 fn encoding_ping() {
3475 let ping = msgs::Ping {
3479 let encoded_value = ping.encode();
3480 let target_value = hex::decode("0040004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3481 assert_eq!(encoded_value, target_value);
3485 fn encoding_pong() {
3486 let pong = msgs::Pong {
3489 let encoded_value = pong.encode();
3490 let target_value = hex::decode("004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3491 assert_eq!(encoded_value, target_value);
3495 fn encoding_nonfinal_onion_hop_data() {
3496 let mut msg = msgs::OnionHopData {
3497 format: OnionHopDataFormat::NonFinalNode {
3498 short_channel_id: 0xdeadbeef1bad1dea,
3500 amt_to_forward: 0x0badf00d01020304,
3501 outgoing_cltv_value: 0xffffffff,
3503 let encoded_value = msg.encode();
3504 let target_value = hex::decode("1a02080badf00d010203040404ffffffff0608deadbeef1bad1dea").unwrap();
3505 assert_eq!(encoded_value, target_value);
3506 msg = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3507 if let OnionHopDataFormat::NonFinalNode { short_channel_id } = msg.format {
3508 assert_eq!(short_channel_id, 0xdeadbeef1bad1dea);
3509 } else { panic!(); }
3510 assert_eq!(msg.amt_to_forward, 0x0badf00d01020304);
3511 assert_eq!(msg.outgoing_cltv_value, 0xffffffff);
3515 fn encoding_final_onion_hop_data() {
3516 let mut msg = msgs::OnionHopData {
3517 format: OnionHopDataFormat::FinalNode {
3519 payment_metadata: None,
3520 keysend_preimage: None,
3522 amt_to_forward: 0x0badf00d01020304,
3523 outgoing_cltv_value: 0xffffffff,
3525 let encoded_value = msg.encode();
3526 let target_value = hex::decode("1002080badf00d010203040404ffffffff").unwrap();
3527 assert_eq!(encoded_value, target_value);
3528 msg = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3529 if let OnionHopDataFormat::FinalNode { payment_data: None, .. } = msg.format { } else { panic!(); }
3530 assert_eq!(msg.amt_to_forward, 0x0badf00d01020304);
3531 assert_eq!(msg.outgoing_cltv_value, 0xffffffff);
3535 fn encoding_final_onion_hop_data_with_secret() {
3536 let expected_payment_secret = PaymentSecret([0x42u8; 32]);
3537 let mut msg = msgs::OnionHopData {
3538 format: OnionHopDataFormat::FinalNode {
3539 payment_data: Some(FinalOnionHopData {
3540 payment_secret: expected_payment_secret,
3541 total_msat: 0x1badca1f
3543 payment_metadata: None,
3544 keysend_preimage: None,
3546 amt_to_forward: 0x0badf00d01020304,
3547 outgoing_cltv_value: 0xffffffff,
3549 let encoded_value = msg.encode();
3550 let target_value = hex::decode("3602080badf00d010203040404ffffffff082442424242424242424242424242424242424242424242424242424242424242421badca1f").unwrap();
3551 assert_eq!(encoded_value, target_value);
3552 msg = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3553 if let OnionHopDataFormat::FinalNode {
3554 payment_data: Some(FinalOnionHopData {
3556 total_msat: 0x1badca1f
3558 payment_metadata: None,
3559 keysend_preimage: None,
3561 assert_eq!(payment_secret, expected_payment_secret);
3562 } else { panic!(); }
3563 assert_eq!(msg.amt_to_forward, 0x0badf00d01020304);
3564 assert_eq!(msg.outgoing_cltv_value, 0xffffffff);
3568 fn query_channel_range_end_blocknum() {
3569 let tests: Vec<(u32, u32, u32)> = vec![
3570 (10000, 1500, 11500),
3571 (0, 0xffffffff, 0xffffffff),
3572 (1, 0xffffffff, 0xffffffff),
3575 for (first_blocknum, number_of_blocks, expected) in tests.into_iter() {
3576 let sut = msgs::QueryChannelRange {
3577 chain_hash: BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap(),
3581 assert_eq!(sut.end_blocknum(), expected);
3586 fn encoding_query_channel_range() {
3587 let mut query_channel_range = msgs::QueryChannelRange {
3588 chain_hash: BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap(),
3589 first_blocknum: 100000,
3590 number_of_blocks: 1500,
3592 let encoded_value = query_channel_range.encode();
3593 let target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206000186a0000005dc").unwrap();
3594 assert_eq!(encoded_value, target_value);
3596 query_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3597 assert_eq!(query_channel_range.first_blocknum, 100000);
3598 assert_eq!(query_channel_range.number_of_blocks, 1500);
3602 fn encoding_reply_channel_range() {
3603 do_encoding_reply_channel_range(0);
3604 do_encoding_reply_channel_range(1);
3607 fn do_encoding_reply_channel_range(encoding_type: u8) {
3608 let mut target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206000b8a06000005dc01").unwrap();
3609 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3610 let mut reply_channel_range = msgs::ReplyChannelRange {
3611 chain_hash: expected_chain_hash,
3612 first_blocknum: 756230,
3613 number_of_blocks: 1500,
3614 sync_complete: true,
3615 short_channel_ids: vec![0x000000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
3618 if encoding_type == 0 {
3619 target_value.append(&mut hex::decode("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
3620 let encoded_value = reply_channel_range.encode();
3621 assert_eq!(encoded_value, target_value);
3623 reply_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3624 assert_eq!(reply_channel_range.chain_hash, expected_chain_hash);
3625 assert_eq!(reply_channel_range.first_blocknum, 756230);
3626 assert_eq!(reply_channel_range.number_of_blocks, 1500);
3627 assert_eq!(reply_channel_range.sync_complete, true);
3628 assert_eq!(reply_channel_range.short_channel_ids[0], 0x000000000000008e);
3629 assert_eq!(reply_channel_range.short_channel_ids[1], 0x0000000000003c69);
3630 assert_eq!(reply_channel_range.short_channel_ids[2], 0x000000000045a6c4);
3632 target_value.append(&mut hex::decode("001601789c636000833e08659309a65878be010010a9023a").unwrap());
3633 let result: Result<msgs::ReplyChannelRange, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
3634 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
3639 fn encoding_query_short_channel_ids() {
3640 do_encoding_query_short_channel_ids(0);
3641 do_encoding_query_short_channel_ids(1);
3644 fn do_encoding_query_short_channel_ids(encoding_type: u8) {
3645 let mut target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206").unwrap();
3646 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3647 let mut query_short_channel_ids = msgs::QueryShortChannelIds {
3648 chain_hash: expected_chain_hash,
3649 short_channel_ids: vec![0x0000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
3652 if encoding_type == 0 {
3653 target_value.append(&mut hex::decode("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
3654 let encoded_value = query_short_channel_ids.encode();
3655 assert_eq!(encoded_value, target_value);
3657 query_short_channel_ids = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3658 assert_eq!(query_short_channel_ids.chain_hash, expected_chain_hash);
3659 assert_eq!(query_short_channel_ids.short_channel_ids[0], 0x000000000000008e);
3660 assert_eq!(query_short_channel_ids.short_channel_ids[1], 0x0000000000003c69);
3661 assert_eq!(query_short_channel_ids.short_channel_ids[2], 0x000000000045a6c4);
3663 target_value.append(&mut hex::decode("001601789c636000833e08659309a65878be010010a9023a").unwrap());
3664 let result: Result<msgs::QueryShortChannelIds, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
3665 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
3670 fn encoding_reply_short_channel_ids_end() {
3671 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3672 let mut reply_short_channel_ids_end = msgs::ReplyShortChannelIdsEnd {
3673 chain_hash: expected_chain_hash,
3674 full_information: true,
3676 let encoded_value = reply_short_channel_ids_end.encode();
3677 let target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e220601").unwrap();
3678 assert_eq!(encoded_value, target_value);
3680 reply_short_channel_ids_end = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3681 assert_eq!(reply_short_channel_ids_end.chain_hash, expected_chain_hash);
3682 assert_eq!(reply_short_channel_ids_end.full_information, true);
3686 fn encoding_gossip_timestamp_filter(){
3687 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3688 let mut gossip_timestamp_filter = msgs::GossipTimestampFilter {
3689 chain_hash: expected_chain_hash,
3690 first_timestamp: 1590000000,
3691 timestamp_range: 0xffff_ffff,
3693 let encoded_value = gossip_timestamp_filter.encode();
3694 let target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e22065ec57980ffffffff").unwrap();
3695 assert_eq!(encoded_value, target_value);
3697 gossip_timestamp_filter = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3698 assert_eq!(gossip_timestamp_filter.chain_hash, expected_chain_hash);
3699 assert_eq!(gossip_timestamp_filter.first_timestamp, 1590000000);
3700 assert_eq!(gossip_timestamp_filter.timestamp_range, 0xffff_ffff);
3704 fn decode_onion_hop_data_len_as_bigsize() {
3705 // Tests that we can decode an onion payload that is >253 bytes.
3706 // Previously, receiving a payload of this size could've caused us to fail to decode a valid
3707 // payload, because we were decoding the length (a BigSize, big-endian) as a VarInt
3710 // Encode a test onion payload with a big custom TLV such that it's >253 bytes, forcing the
3711 // payload length to be encoded over multiple bytes rather than a single u8.
3712 let big_payload = encode_big_payload().unwrap();
3713 let mut rd = Cursor::new(&big_payload[..]);
3714 <msgs::OnionHopData as Readable>::read(&mut rd).unwrap();
3716 // see above test, needs to be a separate method for use of the serialization macros.
3717 fn encode_big_payload() -> Result<Vec<u8>, io::Error> {
3718 use crate::util::ser::HighZeroBytesDroppedBigSize;
3719 let payload = msgs::OnionHopData {
3720 format: OnionHopDataFormat::NonFinalNode {
3721 short_channel_id: 0xdeadbeef1bad1dea,
3723 amt_to_forward: 1000,
3724 outgoing_cltv_value: 0xffffffff,
3726 let mut encoded_payload = Vec::new();
3727 let test_bytes = vec![42u8; 1000];
3728 if let OnionHopDataFormat::NonFinalNode { short_channel_id } = payload.format {
3729 _encode_varint_length_prefixed_tlv!(&mut encoded_payload, {
3730 (1, test_bytes, vec_type),
3731 (2, HighZeroBytesDroppedBigSize(payload.amt_to_forward), required),
3732 (4, HighZeroBytesDroppedBigSize(payload.outgoing_cltv_value), required),
3733 (6, short_channel_id, required)