1 // This file is Copyright its original authors, visible in version control
4 // This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
5 // or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
6 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
7 // You may not use this file except in accordance with one or both of these
10 //! Wire messages, traits representing wire message handlers, and a few error types live here.
12 //! For a normal node you probably don't need to use anything here, however, if you wish to split a
13 //! node into an internet-facing route/message socket handling daemon and a separate daemon (or
14 //! server entirely) which handles only channel-related messages you may wish to implement
15 //! [`ChannelMessageHandler`] yourself and use it to re-serialize messages and pass them across
18 //! Note that if you go with such an architecture (instead of passing raw socket events to a
19 //! non-internet-facing system) you trust the frontend internet-facing system to not lie about the
20 //! source `node_id` of the message, however this does allow you to significantly reduce bandwidth
21 //! between the systems as routing messages can represent a significant chunk of bandwidth usage
22 //! (especially for non-channel-publicly-announcing nodes). As an alternate design which avoids
23 //! this issue, if you have sufficient bidirectional bandwidth between your systems, you may send
24 //! raw socket events into your non-internet-facing system and then send routing events back to
25 //! track the network on the less-secure system.
27 use bitcoin::blockdata::constants::ChainHash;
28 use bitcoin::secp256k1::PublicKey;
29 use bitcoin::secp256k1::ecdsa::Signature;
30 use bitcoin::{secp256k1, Witness};
31 use bitcoin::blockdata::script::ScriptBuf;
32 use bitcoin::hash_types::Txid;
34 use crate::blinded_path::payment::ReceiveTlvs;
35 use crate::ln::{ChannelId, PaymentPreimage, PaymentHash, PaymentSecret};
36 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
37 use crate::ln::onion_utils;
38 use crate::onion_message;
39 use crate::sign::{NodeSigner, Recipient};
41 use crate::prelude::*;
42 #[cfg(feature = "std")]
43 use core::convert::TryFrom;
47 #[cfg(feature = "std")]
48 use core::str::FromStr;
49 #[cfg(feature = "std")]
50 use std::net::SocketAddr;
51 use core::fmt::Display;
52 use crate::io::{self, Cursor, Read};
53 use crate::io_extras::read_to_end;
55 use crate::events::MessageSendEventsProvider;
56 use crate::util::chacha20poly1305rfc::ChaChaPolyReadAdapter;
57 use crate::util::logger;
58 use crate::util::ser::{LengthReadable, LengthReadableArgs, Readable, ReadableArgs, Writeable, Writer, WithoutLength, FixedLengthReader, HighZeroBytesDroppedBigSize, Hostname, TransactionU16LenLimited, BigSize};
59 use crate::util::base32;
61 use crate::routing::gossip::{NodeAlias, NodeId};
63 /// 21 million * 10^8 * 1000
64 pub(crate) const MAX_VALUE_MSAT: u64 = 21_000_000_0000_0000_000;
67 /// A partial signature that also contains the Musig2 nonce its signer used
68 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
69 pub struct PartialSignatureWithNonce(pub musig2::types::PartialSignature, pub musig2::types::PublicNonce);
71 /// An error in decoding a message or struct.
72 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
73 pub enum DecodeError {
74 /// A version byte specified something we don't know how to handle.
76 /// Includes unknown realm byte in an onion hop data packet.
78 /// Unknown feature mandating we fail to parse message (e.g., TLV with an even, unknown type)
79 UnknownRequiredFeature,
80 /// Value was invalid.
82 /// For example, a byte which was supposed to be a bool was something other than a 0
83 /// or 1, a public key/private key/signature was invalid, text wasn't UTF-8, TLV was
84 /// syntactically incorrect, etc.
86 /// The buffer to be read was too short.
88 /// A length descriptor in the packet didn't describe the later data correctly.
90 /// Error from [`std::io`].
92 /// The message included zlib-compressed values, which we don't support.
93 UnsupportedCompression,
96 /// An [`init`] message to be sent to or received from a peer.
98 /// [`init`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-init-message
99 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
101 /// The relevant features which the sender supports.
102 pub features: InitFeatures,
103 /// Indicates chains the sender is interested in.
105 /// If there are no common chains, the connection will be closed.
106 pub networks: Option<Vec<ChainHash>>,
107 /// The receipient's network address.
109 /// This adds the option to report a remote IP address back to a connecting peer using the init
110 /// message. A node can decide to use that information to discover a potential update to its
111 /// public IPv4 address (NAT) and use that for a [`NodeAnnouncement`] update message containing
113 pub remote_network_address: Option<SocketAddress>,
116 /// An [`error`] message to be sent to or received from a peer.
118 /// [`error`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-error-and-warning-messages
119 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
120 pub struct ErrorMessage {
121 /// The channel ID involved in the error.
123 /// All-0s indicates a general error unrelated to a specific channel, after which all channels
124 /// with the sending peer should be closed.
125 pub channel_id: ChannelId,
126 /// A possibly human-readable error description.
128 /// The string should be sanitized before it is used (e.g., emitted to logs or printed to
129 /// `stdout`). Otherwise, a well crafted error message may trigger a security vulnerability in
130 /// the terminal emulator or the logging subsystem.
134 /// A [`warning`] message to be sent to or received from a peer.
136 /// [`warning`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-error-and-warning-messages
137 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
138 pub struct WarningMessage {
139 /// The channel ID involved in the warning.
141 /// All-0s indicates a warning unrelated to a specific channel.
142 pub channel_id: ChannelId,
143 /// A possibly human-readable warning description.
145 /// The string should be sanitized before it is used (e.g. emitted to logs or printed to
146 /// stdout). Otherwise, a well crafted error message may trigger a security vulnerability in
147 /// the terminal emulator or the logging subsystem.
151 /// A [`ping`] message to be sent to or received from a peer.
153 /// [`ping`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-ping-and-pong-messages
154 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
156 /// The desired response length.
158 /// The ping packet size.
160 /// This field is not sent on the wire. byteslen zeros are sent.
164 /// A [`pong`] message to be sent to or received from a peer.
166 /// [`pong`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-ping-and-pong-messages
167 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
169 /// The pong packet size.
171 /// This field is not sent on the wire. byteslen zeros are sent.
175 /// An [`open_channel`] message to be sent to or received from a peer.
177 /// Used in V1 channel establishment
179 /// [`open_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-open_channel-message
180 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
181 pub struct OpenChannel {
182 /// The genesis hash of the blockchain where the channel is to be opened
183 pub chain_hash: ChainHash,
184 /// A temporary channel ID, until the funding outpoint is announced
185 pub temporary_channel_id: ChannelId,
186 /// The channel value
187 pub funding_satoshis: u64,
188 /// The amount to push to the counterparty as part of the open, in milli-satoshi
190 /// The threshold below which outputs on transactions broadcast by sender will be omitted
191 pub dust_limit_satoshis: u64,
192 /// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
193 pub max_htlc_value_in_flight_msat: u64,
194 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
195 pub channel_reserve_satoshis: u64,
196 /// The minimum HTLC size incoming to sender, in milli-satoshi
197 pub htlc_minimum_msat: u64,
198 /// The feerate per 1000-weight of sender generated transactions, until updated by
200 pub feerate_per_kw: u32,
201 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if
202 /// they broadcast a commitment transaction
203 pub to_self_delay: u16,
204 /// The maximum number of inbound HTLCs towards sender
205 pub max_accepted_htlcs: u16,
206 /// The sender's key controlling the funding transaction
207 pub funding_pubkey: PublicKey,
208 /// Used to derive a revocation key for transactions broadcast by counterparty
209 pub revocation_basepoint: PublicKey,
210 /// A payment key to sender for transactions broadcast by counterparty
211 pub payment_point: PublicKey,
212 /// Used to derive a payment key to sender for transactions broadcast by sender
213 pub delayed_payment_basepoint: PublicKey,
214 /// Used to derive an HTLC payment key to sender
215 pub htlc_basepoint: PublicKey,
216 /// The first to-be-broadcast-by-sender transaction's per commitment point
217 pub first_per_commitment_point: PublicKey,
218 /// The channel flags to be used
219 pub channel_flags: u8,
220 /// A request to pre-set the to-sender output's `scriptPubkey` for when we collaboratively close
221 pub shutdown_scriptpubkey: Option<ScriptBuf>,
222 /// The channel type that this channel will represent
224 /// If this is `None`, we derive the channel type from the intersection of our
225 /// feature bits with our counterparty's feature bits from the [`Init`] message.
226 pub channel_type: Option<ChannelTypeFeatures>,
229 /// An open_channel2 message to be sent by or received from the channel initiator.
231 /// Used in V2 channel establishment
233 // TODO(dual_funding): Add spec link for `open_channel2`.
234 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
235 pub struct OpenChannelV2 {
236 /// The genesis hash of the blockchain where the channel is to be opened
237 pub chain_hash: ChainHash,
238 /// A temporary channel ID derived using a zeroed out value for the channel acceptor's revocation basepoint
239 pub temporary_channel_id: ChannelId,
240 /// The feerate for the funding transaction set by the channel initiator
241 pub funding_feerate_sat_per_1000_weight: u32,
242 /// The feerate for the commitment transaction set by the channel initiator
243 pub commitment_feerate_sat_per_1000_weight: u32,
244 /// Part of the channel value contributed by the channel initiator
245 pub funding_satoshis: u64,
246 /// The threshold below which outputs on transactions broadcast by the channel initiator will be
248 pub dust_limit_satoshis: u64,
249 /// The maximum inbound HTLC value in flight towards channel initiator, in milli-satoshi
250 pub max_htlc_value_in_flight_msat: u64,
251 /// The minimum HTLC size incoming to channel initiator, in milli-satoshi
252 pub htlc_minimum_msat: u64,
253 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
254 /// broadcast a commitment transaction
255 pub to_self_delay: u16,
256 /// The maximum number of inbound HTLCs towards channel initiator
257 pub max_accepted_htlcs: u16,
258 /// The locktime for the funding transaction
260 /// The channel initiator's key controlling the funding transaction
261 pub funding_pubkey: PublicKey,
262 /// Used to derive a revocation key for transactions broadcast by counterparty
263 pub revocation_basepoint: PublicKey,
264 /// A payment key to channel initiator for transactions broadcast by counterparty
265 pub payment_basepoint: PublicKey,
266 /// Used to derive a payment key to channel initiator for transactions broadcast by channel
268 pub delayed_payment_basepoint: PublicKey,
269 /// Used to derive an HTLC payment key to channel initiator
270 pub htlc_basepoint: PublicKey,
271 /// The first to-be-broadcast-by-channel-initiator transaction's per commitment point
272 pub first_per_commitment_point: PublicKey,
273 /// The second to-be-broadcast-by-channel-initiator transaction's per commitment point
274 pub second_per_commitment_point: PublicKey,
276 pub channel_flags: u8,
277 /// Optionally, a request to pre-set the to-channel-initiator output's scriptPubkey for when we
278 /// collaboratively close
279 pub shutdown_scriptpubkey: Option<ScriptBuf>,
280 /// The channel type that this channel will represent. If none is set, we derive the channel
281 /// type from the intersection of our feature bits with our counterparty's feature bits from
282 /// the Init message.
283 pub channel_type: Option<ChannelTypeFeatures>,
284 /// Optionally, a requirement that only confirmed inputs can be added
285 pub require_confirmed_inputs: Option<()>,
288 /// An [`accept_channel`] message to be sent to or received from a peer.
290 /// Used in V1 channel establishment
292 /// [`accept_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-accept_channel-message
293 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
294 pub struct AcceptChannel {
295 /// A temporary channel ID, until the funding outpoint is announced
296 pub temporary_channel_id: ChannelId,
297 /// The threshold below which outputs on transactions broadcast by sender will be omitted
298 pub dust_limit_satoshis: u64,
299 /// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
300 pub max_htlc_value_in_flight_msat: u64,
301 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
302 pub channel_reserve_satoshis: u64,
303 /// The minimum HTLC size incoming to sender, in milli-satoshi
304 pub htlc_minimum_msat: u64,
305 /// Minimum depth of the funding transaction before the channel is considered open
306 pub minimum_depth: u32,
307 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they broadcast a commitment transaction
308 pub to_self_delay: u16,
309 /// The maximum number of inbound HTLCs towards sender
310 pub max_accepted_htlcs: u16,
311 /// The sender's key controlling the funding transaction
312 pub funding_pubkey: PublicKey,
313 /// Used to derive a revocation key for transactions broadcast by counterparty
314 pub revocation_basepoint: PublicKey,
315 /// A payment key to sender for transactions broadcast by counterparty
316 pub payment_point: PublicKey,
317 /// Used to derive a payment key to sender for transactions broadcast by sender
318 pub delayed_payment_basepoint: PublicKey,
319 /// Used to derive an HTLC payment key to sender for transactions broadcast by counterparty
320 pub htlc_basepoint: PublicKey,
321 /// The first to-be-broadcast-by-sender transaction's per commitment point
322 pub first_per_commitment_point: PublicKey,
323 /// A request to pre-set the to-sender output's scriptPubkey for when we collaboratively close
324 pub shutdown_scriptpubkey: Option<ScriptBuf>,
325 /// The channel type that this channel will represent.
327 /// If this is `None`, we derive the channel type from the intersection of
328 /// our feature bits with our counterparty's feature bits from the [`Init`] message.
329 /// This is required to match the equivalent field in [`OpenChannel::channel_type`].
330 pub channel_type: Option<ChannelTypeFeatures>,
332 /// Next nonce the channel initiator should use to create a funding output signature against
333 pub next_local_nonce: Option<musig2::types::PublicNonce>,
336 /// An accept_channel2 message to be sent by or received from the channel accepter.
338 /// Used in V2 channel establishment
340 // TODO(dual_funding): Add spec link for `accept_channel2`.
341 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
342 pub struct AcceptChannelV2 {
343 /// The same `temporary_channel_id` received from the initiator's `open_channel2` message.
344 pub temporary_channel_id: ChannelId,
345 /// Part of the channel value contributed by the channel acceptor
346 pub funding_satoshis: u64,
347 /// The threshold below which outputs on transactions broadcast by the channel acceptor will be
349 pub dust_limit_satoshis: u64,
350 /// The maximum inbound HTLC value in flight towards channel acceptor, in milli-satoshi
351 pub max_htlc_value_in_flight_msat: u64,
352 /// The minimum HTLC size incoming to channel acceptor, in milli-satoshi
353 pub htlc_minimum_msat: u64,
354 /// Minimum depth of the funding transaction before the channel is considered open
355 pub minimum_depth: u32,
356 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
357 /// broadcast a commitment transaction
358 pub to_self_delay: u16,
359 /// The maximum number of inbound HTLCs towards channel acceptor
360 pub max_accepted_htlcs: u16,
361 /// The channel acceptor's key controlling the funding transaction
362 pub funding_pubkey: PublicKey,
363 /// Used to derive a revocation key for transactions broadcast by counterparty
364 pub revocation_basepoint: PublicKey,
365 /// A payment key to channel acceptor for transactions broadcast by counterparty
366 pub payment_basepoint: PublicKey,
367 /// Used to derive a payment key to channel acceptor for transactions broadcast by channel
369 pub delayed_payment_basepoint: PublicKey,
370 /// Used to derive an HTLC payment key to channel acceptor for transactions broadcast by counterparty
371 pub htlc_basepoint: PublicKey,
372 /// The first to-be-broadcast-by-channel-acceptor transaction's per commitment point
373 pub first_per_commitment_point: PublicKey,
374 /// The second to-be-broadcast-by-channel-acceptor transaction's per commitment point
375 pub second_per_commitment_point: PublicKey,
376 /// Optionally, a request to pre-set the to-channel-acceptor output's scriptPubkey for when we
377 /// collaboratively close
378 pub shutdown_scriptpubkey: Option<ScriptBuf>,
379 /// The channel type that this channel will represent. If none is set, we derive the channel
380 /// type from the intersection of our feature bits with our counterparty's feature bits from
381 /// the Init message.
383 /// This is required to match the equivalent field in [`OpenChannelV2::channel_type`].
384 pub channel_type: Option<ChannelTypeFeatures>,
385 /// Optionally, a requirement that only confirmed inputs can be added
386 pub require_confirmed_inputs: Option<()>,
389 /// A [`funding_created`] message to be sent to or received from a peer.
391 /// Used in V1 channel establishment
393 /// [`funding_created`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-funding_created-message
394 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
395 pub struct FundingCreated {
396 /// A temporary channel ID, until the funding is established
397 pub temporary_channel_id: ChannelId,
398 /// The funding transaction ID
399 pub funding_txid: Txid,
400 /// The specific output index funding this channel
401 pub funding_output_index: u16,
402 /// The signature of the channel initiator (funder) on the initial commitment transaction
403 pub signature: Signature,
405 /// The partial signature of the channel initiator (funder)
406 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
408 /// Next nonce the channel acceptor should use to finalize the funding output signature
409 pub next_local_nonce: Option<musig2::types::PublicNonce>
412 /// A [`funding_signed`] message to be sent to or received from a peer.
414 /// Used in V1 channel establishment
416 /// [`funding_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-funding_signed-message
417 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
418 pub struct FundingSigned {
420 pub channel_id: ChannelId,
421 /// The signature of the channel acceptor (fundee) on the initial commitment transaction
422 pub signature: Signature,
424 /// The partial signature of the channel acceptor (fundee)
425 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
428 /// A [`channel_ready`] message to be sent to or received from a peer.
430 /// [`channel_ready`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-channel_ready-message
431 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
432 pub struct ChannelReady {
434 pub channel_id: ChannelId,
435 /// The per-commitment point of the second commitment transaction
436 pub next_per_commitment_point: PublicKey,
437 /// If set, provides a `short_channel_id` alias for this channel.
439 /// The sender will accept payments to be forwarded over this SCID and forward them to this
440 /// messages' recipient.
441 pub short_channel_id_alias: Option<u64>,
444 /// An stfu (quiescence) message to be sent by or received from the stfu initiator.
445 // TODO(splicing): Add spec link for `stfu`; still in draft, using from https://github.com/lightning/bolts/pull/863
446 #[derive(Clone, Debug, PartialEq, Eq)]
448 /// The channel ID where quiescence is intended
449 pub channel_id: ChannelId,
450 /// Initiator flag, 1 if initiating, 0 if replying to an stfu.
454 /// A splice message to be sent by or received from the stfu initiator (splice initiator).
455 // TODO(splicing): Add spec link for `splice`; still in draft, using from https://github.com/lightning/bolts/pull/863
456 #[derive(Clone, Debug, PartialEq, Eq)]
458 /// The channel ID where splicing is intended
459 pub channel_id: ChannelId,
460 /// The genesis hash of the blockchain where the channel is intended to be spliced
461 pub chain_hash: ChainHash,
462 /// The intended change in channel capacity: the amount to be added (positive value)
463 /// or removed (negative value) by the sender (splice initiator) by splicing into/from the channel.
464 pub relative_satoshis: i64,
465 /// The feerate for the new funding transaction, set by the splice initiator
466 pub funding_feerate_perkw: u32,
467 /// The locktime for the new funding transaction
469 /// The key of the sender (splice initiator) controlling the new funding transaction
470 pub funding_pubkey: PublicKey,
473 /// A splice_ack message to be received by or sent to the splice initiator.
475 // TODO(splicing): Add spec link for `splice_ack`; still in draft, using from https://github.com/lightning/bolts/pull/863
476 #[derive(Clone, Debug, PartialEq, Eq)]
477 pub struct SpliceAck {
478 /// The channel ID where splicing is intended
479 pub channel_id: ChannelId,
480 /// The genesis hash of the blockchain where the channel is intended to be spliced
481 pub chain_hash: ChainHash,
482 /// The intended change in channel capacity: the amount to be added (positive value)
483 /// or removed (negative value) by the sender (splice acceptor) by splicing into/from the channel.
484 pub relative_satoshis: i64,
485 /// The key of the sender (splice acceptor) controlling the new funding transaction
486 pub funding_pubkey: PublicKey,
489 /// A splice_locked message to be sent to or received from a peer.
491 // TODO(splicing): Add spec link for `splice_locked`; still in draft, using from https://github.com/lightning/bolts/pull/863
492 #[derive(Clone, Debug, PartialEq, Eq)]
493 pub struct SpliceLocked {
495 pub channel_id: ChannelId,
498 /// A tx_add_input message for adding an input during interactive transaction construction
500 // TODO(dual_funding): Add spec link for `tx_add_input`.
501 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
502 pub struct TxAddInput {
504 pub channel_id: ChannelId,
505 /// A randomly chosen unique identifier for this input, which is even for initiators and odd for
508 /// Serialized transaction that contains the output this input spends to verify that it is non
510 pub prevtx: TransactionU16LenLimited,
511 /// The index of the output being spent
513 /// The sequence number of this input
517 /// A tx_add_output message for adding an output during interactive transaction construction.
519 // TODO(dual_funding): Add spec link for `tx_add_output`.
520 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
521 pub struct TxAddOutput {
523 pub channel_id: ChannelId,
524 /// A randomly chosen unique identifier for this output, which is even for initiators and odd for
527 /// The satoshi value of the output
529 /// The scriptPubKey for the output
530 pub script: ScriptBuf,
533 /// A tx_remove_input message for removing an input during interactive transaction construction.
535 // TODO(dual_funding): Add spec link for `tx_remove_input`.
536 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
537 pub struct TxRemoveInput {
539 pub channel_id: ChannelId,
540 /// The serial ID of the input to be removed
544 /// A tx_remove_output message for removing an output during interactive transaction construction.
546 // TODO(dual_funding): Add spec link for `tx_remove_output`.
547 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
548 pub struct TxRemoveOutput {
550 pub channel_id: ChannelId,
551 /// The serial ID of the output to be removed
555 /// A tx_complete message signalling the conclusion of a peer's transaction contributions during
556 /// interactive transaction construction.
558 // TODO(dual_funding): Add spec link for `tx_complete`.
559 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
560 pub struct TxComplete {
562 pub channel_id: ChannelId,
565 /// A tx_signatures message containing the sender's signatures for a transaction constructed with
566 /// interactive transaction construction.
568 // TODO(dual_funding): Add spec link for `tx_signatures`.
569 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
570 pub struct TxSignatures {
572 pub channel_id: ChannelId,
575 /// The list of witnesses
576 pub witnesses: Vec<Witness>,
579 /// A tx_init_rbf message which initiates a replacement of the transaction after it's been
582 // TODO(dual_funding): Add spec link for `tx_init_rbf`.
583 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
584 pub struct TxInitRbf {
586 pub channel_id: ChannelId,
587 /// The locktime of the transaction
589 /// The feerate of the transaction
590 pub feerate_sat_per_1000_weight: u32,
591 /// The number of satoshis the sender will contribute to or, if negative, remove from
592 /// (e.g. splice-out) the funding output of the transaction
593 pub funding_output_contribution: Option<i64>,
596 /// A tx_ack_rbf message which acknowledges replacement of the transaction after it's been
599 // TODO(dual_funding): Add spec link for `tx_ack_rbf`.
600 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
601 pub struct TxAckRbf {
603 pub channel_id: ChannelId,
604 /// The number of satoshis the sender will contribute to or, if negative, remove from
605 /// (e.g. splice-out) the funding output of the transaction
606 pub funding_output_contribution: Option<i64>,
609 /// A tx_abort message which signals the cancellation of an in-progress transaction negotiation.
611 // TODO(dual_funding): Add spec link for `tx_abort`.
612 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
615 pub channel_id: ChannelId,
620 /// A [`shutdown`] message to be sent to or received from a peer.
622 /// [`shutdown`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-initiation-shutdown
623 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
624 pub struct Shutdown {
626 pub channel_id: ChannelId,
627 /// The destination of this peer's funds on closing.
629 /// Must be in one of these forms: P2PKH, P2SH, P2WPKH, P2WSH, P2TR.
630 pub scriptpubkey: ScriptBuf,
633 /// The minimum and maximum fees which the sender is willing to place on the closing transaction.
635 /// This is provided in [`ClosingSigned`] by both sides to indicate the fee range they are willing
637 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
638 pub struct ClosingSignedFeeRange {
639 /// The minimum absolute fee, in satoshis, which the sender is willing to place on the closing
641 pub min_fee_satoshis: u64,
642 /// The maximum absolute fee, in satoshis, which the sender is willing to place on the closing
644 pub max_fee_satoshis: u64,
647 /// A [`closing_signed`] message to be sent to or received from a peer.
649 /// [`closing_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-negotiation-closing_signed
650 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
651 pub struct ClosingSigned {
653 pub channel_id: ChannelId,
654 /// The proposed total fee for the closing transaction
655 pub fee_satoshis: u64,
656 /// A signature on the closing transaction
657 pub signature: Signature,
658 /// The minimum and maximum fees which the sender is willing to accept, provided only by new
660 pub fee_range: Option<ClosingSignedFeeRange>,
663 /// An [`update_add_htlc`] message to be sent to or received from a peer.
665 /// [`update_add_htlc`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#adding-an-htlc-update_add_htlc
666 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
667 pub struct UpdateAddHTLC {
669 pub channel_id: ChannelId,
672 /// The HTLC value in milli-satoshi
673 pub amount_msat: u64,
674 /// The payment hash, the pre-image of which controls HTLC redemption
675 pub payment_hash: PaymentHash,
676 /// The expiry height of the HTLC
677 pub cltv_expiry: u32,
678 /// The extra fee skimmed by the sender of this message. See
679 /// [`ChannelConfig::accept_underpaying_htlcs`].
681 /// [`ChannelConfig::accept_underpaying_htlcs`]: crate::util::config::ChannelConfig::accept_underpaying_htlcs
682 pub skimmed_fee_msat: Option<u64>,
683 pub(crate) onion_routing_packet: OnionPacket,
686 /// An onion message to be sent to or received from a peer.
688 // TODO: update with link to OM when they are merged into the BOLTs
689 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
690 pub struct OnionMessage {
691 /// Used in decrypting the onion packet's payload.
692 pub blinding_point: PublicKey,
693 /// The full onion packet including hop data, pubkey, and hmac
694 pub onion_routing_packet: onion_message::Packet,
697 /// An [`update_fulfill_htlc`] message to be sent to or received from a peer.
699 /// [`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
700 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
701 pub struct UpdateFulfillHTLC {
703 pub channel_id: ChannelId,
706 /// The pre-image of the payment hash, allowing HTLC redemption
707 pub payment_preimage: PaymentPreimage,
710 /// An [`update_fail_htlc`] message to be sent to or received from a peer.
712 /// [`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
713 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
714 pub struct UpdateFailHTLC {
716 pub channel_id: ChannelId,
719 pub(crate) reason: OnionErrorPacket,
722 /// An [`update_fail_malformed_htlc`] message to be sent to or received from a peer.
724 /// [`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
725 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
726 pub struct UpdateFailMalformedHTLC {
728 pub channel_id: ChannelId,
731 pub(crate) sha256_of_onion: [u8; 32],
733 pub failure_code: u16,
736 /// A [`commitment_signed`] message to be sent to or received from a peer.
738 /// [`commitment_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#committing-updates-so-far-commitment_signed
739 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
740 pub struct CommitmentSigned {
742 pub channel_id: ChannelId,
743 /// A signature on the commitment transaction
744 pub signature: Signature,
745 /// Signatures on the HTLC transactions
746 pub htlc_signatures: Vec<Signature>,
748 /// The partial Taproot signature on the commitment transaction
749 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
752 /// A [`revoke_and_ack`] message to be sent to or received from a peer.
754 /// [`revoke_and_ack`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#completing-the-transition-to-the-updated-state-revoke_and_ack
755 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
756 pub struct RevokeAndACK {
758 pub channel_id: ChannelId,
759 /// The secret corresponding to the per-commitment point
760 pub per_commitment_secret: [u8; 32],
761 /// The next sender-broadcast commitment transaction's per-commitment point
762 pub next_per_commitment_point: PublicKey,
764 /// Musig nonce the recipient should use in their next commitment signature message
765 pub next_local_nonce: Option<musig2::types::PublicNonce>
768 /// An [`update_fee`] message to be sent to or received from a peer
770 /// [`update_fee`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#updating-fees-update_fee
771 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
772 pub struct UpdateFee {
774 pub channel_id: ChannelId,
775 /// Fee rate per 1000-weight of the transaction
776 pub feerate_per_kw: u32,
779 /// A [`channel_reestablish`] message to be sent to or received from a peer.
781 /// [`channel_reestablish`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#message-retransmission
782 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
783 pub struct ChannelReestablish {
785 pub channel_id: ChannelId,
786 /// The next commitment number for the sender
787 pub next_local_commitment_number: u64,
788 /// The next commitment number for the recipient
789 pub next_remote_commitment_number: u64,
790 /// Proof that the sender knows the per-commitment secret of a specific commitment transaction
791 /// belonging to the recipient
792 pub your_last_per_commitment_secret: [u8; 32],
793 /// The sender's per-commitment point for their current commitment transaction
794 pub my_current_per_commitment_point: PublicKey,
795 /// The next funding transaction ID
796 pub next_funding_txid: Option<Txid>,
799 /// An [`announcement_signatures`] message to be sent to or received from a peer.
801 /// [`announcement_signatures`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-announcement_signatures-message
802 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
803 pub struct AnnouncementSignatures {
805 pub channel_id: ChannelId,
806 /// The short channel ID
807 pub short_channel_id: u64,
808 /// A signature by the node key
809 pub node_signature: Signature,
810 /// A signature by the funding key
811 pub bitcoin_signature: Signature,
814 /// An address which can be used to connect to a remote peer.
815 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
816 pub enum SocketAddress {
817 /// An IPv4 address and port on which the peer is listening.
819 /// The 4-byte IPv4 address
821 /// The port on which the node is listening
824 /// An IPv6 address and port on which the peer is listening.
826 /// The 16-byte IPv6 address
828 /// The port on which the node is listening
831 /// An old-style Tor onion address/port on which the peer is listening.
833 /// This field is deprecated and the Tor network generally no longer supports V2 Onion
834 /// addresses. Thus, the details are not parsed here.
836 /// A new-style Tor onion address/port on which the peer is listening.
838 /// To create the human-readable "hostname", concatenate the ED25519 pubkey, checksum, and version,
839 /// wrap as base32 and append ".onion".
841 /// The ed25519 long-term public key of the peer
842 ed25519_pubkey: [u8; 32],
843 /// The checksum of the pubkey and version, as included in the onion address
845 /// The version byte, as defined by the Tor Onion v3 spec.
847 /// The port on which the node is listening
850 /// A hostname/port on which the peer is listening.
852 /// The hostname on which the node is listening.
854 /// The port on which the node is listening.
859 /// Gets the ID of this address type. Addresses in [`NodeAnnouncement`] messages should be sorted
861 pub(crate) fn get_id(&self) -> u8 {
863 &SocketAddress::TcpIpV4 {..} => { 1 },
864 &SocketAddress::TcpIpV6 {..} => { 2 },
865 &SocketAddress::OnionV2(_) => { 3 },
866 &SocketAddress::OnionV3 {..} => { 4 },
867 &SocketAddress::Hostname {..} => { 5 },
871 /// Strict byte-length of address descriptor, 1-byte type not recorded
872 fn len(&self) -> u16 {
874 &SocketAddress::TcpIpV4 { .. } => { 6 },
875 &SocketAddress::TcpIpV6 { .. } => { 18 },
876 &SocketAddress::OnionV2(_) => { 12 },
877 &SocketAddress::OnionV3 { .. } => { 37 },
878 // Consists of 1-byte hostname length, hostname bytes, and 2-byte port.
879 &SocketAddress::Hostname { ref hostname, .. } => { u16::from(hostname.len()) + 3 },
883 /// The maximum length of any address descriptor, not including the 1-byte type.
884 /// This maximum length is reached by a hostname address descriptor:
885 /// a hostname with a maximum length of 255, its 1-byte length and a 2-byte port.
886 pub(crate) const MAX_LEN: u16 = 258;
889 impl Writeable for SocketAddress {
890 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
892 &SocketAddress::TcpIpV4 { ref addr, ref port } => {
897 &SocketAddress::TcpIpV6 { ref addr, ref port } => {
902 &SocketAddress::OnionV2(bytes) => {
904 bytes.write(writer)?;
906 &SocketAddress::OnionV3 { ref ed25519_pubkey, ref checksum, ref version, ref port } => {
908 ed25519_pubkey.write(writer)?;
909 checksum.write(writer)?;
910 version.write(writer)?;
913 &SocketAddress::Hostname { ref hostname, ref port } => {
915 hostname.write(writer)?;
923 impl Readable for Result<SocketAddress, u8> {
924 fn read<R: Read>(reader: &mut R) -> Result<Result<SocketAddress, u8>, DecodeError> {
925 let byte = <u8 as Readable>::read(reader)?;
928 Ok(Ok(SocketAddress::TcpIpV4 {
929 addr: Readable::read(reader)?,
930 port: Readable::read(reader)?,
934 Ok(Ok(SocketAddress::TcpIpV6 {
935 addr: Readable::read(reader)?,
936 port: Readable::read(reader)?,
939 3 => Ok(Ok(SocketAddress::OnionV2(Readable::read(reader)?))),
941 Ok(Ok(SocketAddress::OnionV3 {
942 ed25519_pubkey: Readable::read(reader)?,
943 checksum: Readable::read(reader)?,
944 version: Readable::read(reader)?,
945 port: Readable::read(reader)?,
949 Ok(Ok(SocketAddress::Hostname {
950 hostname: Readable::read(reader)?,
951 port: Readable::read(reader)?,
954 _ => return Ok(Err(byte)),
959 impl Readable for SocketAddress {
960 fn read<R: Read>(reader: &mut R) -> Result<SocketAddress, DecodeError> {
961 match Readable::read(reader) {
962 Ok(Ok(res)) => Ok(res),
963 Ok(Err(_)) => Err(DecodeError::UnknownVersion),
969 /// [`SocketAddress`] error variants
970 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
971 pub enum SocketAddressParseError {
972 /// Socket address (IPv4/IPv6) parsing error
974 /// Invalid input format
978 /// Invalid onion v3 address
982 impl fmt::Display for SocketAddressParseError {
983 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
985 SocketAddressParseError::SocketAddrParse => write!(f, "Socket address (IPv4/IPv6) parsing error"),
986 SocketAddressParseError::InvalidInput => write!(f, "Invalid input format. \
987 Expected: \"<ipv4>:<port>\", \"[<ipv6>]:<port>\", \"<onion address>.onion:<port>\" or \"<hostname>:<port>\""),
988 SocketAddressParseError::InvalidPort => write!(f, "Invalid port"),
989 SocketAddressParseError::InvalidOnionV3 => write!(f, "Invalid onion v3 address"),
994 #[cfg(feature = "std")]
995 impl From<std::net::SocketAddrV4> for SocketAddress {
996 fn from(addr: std::net::SocketAddrV4) -> Self {
997 SocketAddress::TcpIpV4 { addr: addr.ip().octets(), port: addr.port() }
1001 #[cfg(feature = "std")]
1002 impl From<std::net::SocketAddrV6> for SocketAddress {
1003 fn from(addr: std::net::SocketAddrV6) -> Self {
1004 SocketAddress::TcpIpV6 { addr: addr.ip().octets(), port: addr.port() }
1008 #[cfg(feature = "std")]
1009 impl From<std::net::SocketAddr> for SocketAddress {
1010 fn from(addr: std::net::SocketAddr) -> Self {
1012 std::net::SocketAddr::V4(addr) => addr.into(),
1013 std::net::SocketAddr::V6(addr) => addr.into(),
1018 #[cfg(feature = "std")]
1019 impl std::net::ToSocketAddrs for SocketAddress {
1020 type Iter = std::vec::IntoIter<std::net::SocketAddr>;
1022 fn to_socket_addrs(&self) -> std::io::Result<Self::Iter> {
1024 SocketAddress::TcpIpV4 { addr, port } => {
1025 let ip_addr = std::net::Ipv4Addr::from(*addr);
1026 let socket_addr = SocketAddr::new(ip_addr.into(), *port);
1027 Ok(vec![socket_addr].into_iter())
1029 SocketAddress::TcpIpV6 { addr, port } => {
1030 let ip_addr = std::net::Ipv6Addr::from(*addr);
1031 let socket_addr = SocketAddr::new(ip_addr.into(), *port);
1032 Ok(vec![socket_addr].into_iter())
1034 SocketAddress::Hostname { ref hostname, port } => {
1035 (hostname.as_str(), *port).to_socket_addrs()
1037 SocketAddress::OnionV2(..) => {
1038 Err(std::io::Error::new(std::io::ErrorKind::Other, "Resolution of OnionV2 \
1039 addresses is currently unsupported."))
1041 SocketAddress::OnionV3 { .. } => {
1042 Err(std::io::Error::new(std::io::ErrorKind::Other, "Resolution of OnionV3 \
1043 addresses is currently unsupported."))
1049 /// Parses an OnionV3 host and port into a [`SocketAddress::OnionV3`].
1051 /// The host part must end with ".onion".
1052 pub fn parse_onion_address(host: &str, port: u16) -> Result<SocketAddress, SocketAddressParseError> {
1053 if host.ends_with(".onion") {
1054 let domain = &host[..host.len() - ".onion".len()];
1055 if domain.len() != 56 {
1056 return Err(SocketAddressParseError::InvalidOnionV3);
1058 let onion = base32::Alphabet::RFC4648 { padding: false }.decode(&domain).map_err(|_| SocketAddressParseError::InvalidOnionV3)?;
1059 if onion.len() != 35 {
1060 return Err(SocketAddressParseError::InvalidOnionV3);
1062 let version = onion[0];
1063 let first_checksum_flag = onion[1];
1064 let second_checksum_flag = onion[2];
1065 let mut ed25519_pubkey = [0; 32];
1066 ed25519_pubkey.copy_from_slice(&onion[3..35]);
1067 let checksum = u16::from_be_bytes([first_checksum_flag, second_checksum_flag]);
1068 return Ok(SocketAddress::OnionV3 { ed25519_pubkey, checksum, version, port });
1071 return Err(SocketAddressParseError::InvalidInput);
1075 impl Display for SocketAddress {
1076 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1078 SocketAddress::TcpIpV4{addr, port} => write!(
1079 f, "{}.{}.{}.{}:{}", addr[0], addr[1], addr[2], addr[3], port)?,
1080 SocketAddress::TcpIpV6{addr, port} => write!(
1082 "[{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}]:{}",
1083 addr[0], addr[1], addr[2], addr[3], addr[4], addr[5], addr[6], addr[7], addr[8], addr[9], addr[10], addr[11], addr[12], addr[13], addr[14], addr[15], port
1085 SocketAddress::OnionV2(bytes) => write!(f, "OnionV2({:?})", bytes)?,
1086 SocketAddress::OnionV3 {
1092 let [first_checksum_flag, second_checksum_flag] = checksum.to_be_bytes();
1093 let mut addr = vec![*version, first_checksum_flag, second_checksum_flag];
1094 addr.extend_from_slice(ed25519_pubkey);
1095 let onion = base32::Alphabet::RFC4648 { padding: false }.encode(&addr);
1096 write!(f, "{}.onion:{}", onion, port)?
1098 SocketAddress::Hostname { hostname, port } => write!(f, "{}:{}", hostname, port)?,
1104 #[cfg(feature = "std")]
1105 impl FromStr for SocketAddress {
1106 type Err = SocketAddressParseError;
1108 fn from_str(s: &str) -> Result<Self, Self::Err> {
1109 match std::net::SocketAddr::from_str(s) {
1110 Ok(addr) => Ok(addr.into()),
1112 let trimmed_input = match s.rfind(":") {
1114 None => return Err(SocketAddressParseError::InvalidInput),
1116 let host = &s[..trimmed_input];
1117 let port: u16 = s[trimmed_input + 1..].parse().map_err(|_| SocketAddressParseError::InvalidPort)?;
1118 if host.ends_with(".onion") {
1119 return parse_onion_address(host, port);
1121 if let Ok(hostname) = Hostname::try_from(s[..trimmed_input].to_string()) {
1122 return Ok(SocketAddress::Hostname { hostname, port });
1124 return Err(SocketAddressParseError::SocketAddrParse)
1130 /// Represents the set of gossip messages that require a signature from a node's identity key.
1131 pub enum UnsignedGossipMessage<'a> {
1132 /// An unsigned channel announcement.
1133 ChannelAnnouncement(&'a UnsignedChannelAnnouncement),
1134 /// An unsigned channel update.
1135 ChannelUpdate(&'a UnsignedChannelUpdate),
1136 /// An unsigned node announcement.
1137 NodeAnnouncement(&'a UnsignedNodeAnnouncement)
1140 impl<'a> Writeable for UnsignedGossipMessage<'a> {
1141 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
1143 UnsignedGossipMessage::ChannelAnnouncement(ref msg) => msg.write(writer),
1144 UnsignedGossipMessage::ChannelUpdate(ref msg) => msg.write(writer),
1145 UnsignedGossipMessage::NodeAnnouncement(ref msg) => msg.write(writer),
1150 /// The unsigned part of a [`node_announcement`] message.
1152 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
1153 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1154 pub struct UnsignedNodeAnnouncement {
1155 /// The advertised features
1156 pub features: NodeFeatures,
1157 /// A strictly monotonic announcement counter, with gaps allowed
1159 /// The `node_id` this announcement originated from (don't rebroadcast the `node_announcement` back
1161 pub node_id: NodeId,
1162 /// An RGB color for UI purposes
1164 /// An alias, for UI purposes.
1166 /// This should be sanitized before use. There is no guarantee of uniqueness.
1167 pub alias: NodeAlias,
1168 /// List of addresses on which this node is reachable
1169 pub addresses: Vec<SocketAddress>,
1170 pub(crate) excess_address_data: Vec<u8>,
1171 pub(crate) excess_data: Vec<u8>,
1173 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1174 /// A [`node_announcement`] message to be sent to or received from a peer.
1176 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
1177 pub struct NodeAnnouncement {
1178 /// The signature by the node key
1179 pub signature: Signature,
1180 /// The actual content of the announcement
1181 pub contents: UnsignedNodeAnnouncement,
1184 /// The unsigned part of a [`channel_announcement`] message.
1186 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
1187 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1188 pub struct UnsignedChannelAnnouncement {
1189 /// The advertised channel features
1190 pub features: ChannelFeatures,
1191 /// The genesis hash of the blockchain where the channel is to be opened
1192 pub chain_hash: ChainHash,
1193 /// The short channel ID
1194 pub short_channel_id: u64,
1195 /// One of the two `node_id`s which are endpoints of this channel
1196 pub node_id_1: NodeId,
1197 /// The other of the two `node_id`s which are endpoints of this channel
1198 pub node_id_2: NodeId,
1199 /// The funding key for the first node
1200 pub bitcoin_key_1: NodeId,
1201 /// The funding key for the second node
1202 pub bitcoin_key_2: NodeId,
1203 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1206 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1207 pub excess_data: Vec<u8>,
1209 /// A [`channel_announcement`] message to be sent to or received from a peer.
1211 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
1212 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1213 pub struct ChannelAnnouncement {
1214 /// Authentication of the announcement by the first public node
1215 pub node_signature_1: Signature,
1216 /// Authentication of the announcement by the second public node
1217 pub node_signature_2: Signature,
1218 /// Proof of funding UTXO ownership by the first public node
1219 pub bitcoin_signature_1: Signature,
1220 /// Proof of funding UTXO ownership by the second public node
1221 pub bitcoin_signature_2: Signature,
1222 /// The actual announcement
1223 pub contents: UnsignedChannelAnnouncement,
1226 /// The unsigned part of a [`channel_update`] message.
1228 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1229 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1230 pub struct UnsignedChannelUpdate {
1231 /// The genesis hash of the blockchain where the channel is to be opened
1232 pub chain_hash: ChainHash,
1233 /// The short channel ID
1234 pub short_channel_id: u64,
1235 /// A strictly monotonic announcement counter, with gaps allowed, specific to this channel
1239 /// The number of blocks such that if:
1240 /// `incoming_htlc.cltv_expiry < outgoing_htlc.cltv_expiry + cltv_expiry_delta`
1241 /// then we need to fail the HTLC backwards. When forwarding an HTLC, `cltv_expiry_delta` determines
1242 /// the outgoing HTLC's minimum `cltv_expiry` value -- so, if an incoming HTLC comes in with a
1243 /// `cltv_expiry` of 100000, and the node we're forwarding to has a `cltv_expiry_delta` value of 10,
1244 /// then we'll check that the outgoing HTLC's `cltv_expiry` value is at least 100010 before
1245 /// forwarding. Note that the HTLC sender is the one who originally sets this value when
1246 /// constructing the route.
1247 pub cltv_expiry_delta: u16,
1248 /// The minimum HTLC size incoming to sender, in milli-satoshi
1249 pub htlc_minimum_msat: u64,
1250 /// The maximum HTLC value incoming to sender, in milli-satoshi.
1252 /// This used to be optional.
1253 pub htlc_maximum_msat: u64,
1254 /// The base HTLC fee charged by sender, in milli-satoshi
1255 pub fee_base_msat: u32,
1256 /// The amount to fee multiplier, in micro-satoshi
1257 pub fee_proportional_millionths: u32,
1258 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1261 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1262 pub excess_data: Vec<u8>,
1264 /// A [`channel_update`] message to be sent to or received from a peer.
1266 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1267 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1268 pub struct ChannelUpdate {
1269 /// A signature of the channel update
1270 pub signature: Signature,
1271 /// The actual channel update
1272 pub contents: UnsignedChannelUpdate,
1275 /// A [`query_channel_range`] message is used to query a peer for channel
1276 /// UTXOs in a range of blocks. The recipient of a query makes a best
1277 /// effort to reply to the query using one or more [`ReplyChannelRange`]
1280 /// [`query_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1281 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1282 pub struct QueryChannelRange {
1283 /// The genesis hash of the blockchain being queried
1284 pub chain_hash: ChainHash,
1285 /// The height of the first block for the channel UTXOs being queried
1286 pub first_blocknum: u32,
1287 /// The number of blocks to include in the query results
1288 pub number_of_blocks: u32,
1291 /// A [`reply_channel_range`] message is a reply to a [`QueryChannelRange`]
1294 /// Multiple `reply_channel_range` messages can be sent in reply
1295 /// to a single [`QueryChannelRange`] message. The query recipient makes a
1296 /// best effort to respond based on their local network view which may
1297 /// not be a perfect view of the network. The `short_channel_id`s in the
1298 /// reply are encoded. We only support `encoding_type=0` uncompressed
1299 /// serialization and do not support `encoding_type=1` zlib serialization.
1301 /// [`reply_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1302 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1303 pub struct ReplyChannelRange {
1304 /// The genesis hash of the blockchain being queried
1305 pub chain_hash: ChainHash,
1306 /// The height of the first block in the range of the reply
1307 pub first_blocknum: u32,
1308 /// The number of blocks included in the range of the reply
1309 pub number_of_blocks: u32,
1310 /// True when this is the final reply for a query
1311 pub sync_complete: bool,
1312 /// The `short_channel_id`s in the channel range
1313 pub short_channel_ids: Vec<u64>,
1316 /// A [`query_short_channel_ids`] message is used to query a peer for
1317 /// routing gossip messages related to one or more `short_channel_id`s.
1319 /// The query recipient will reply with the latest, if available,
1320 /// [`ChannelAnnouncement`], [`ChannelUpdate`] and [`NodeAnnouncement`] messages
1321 /// it maintains for the requested `short_channel_id`s followed by a
1322 /// [`ReplyShortChannelIdsEnd`] message. The `short_channel_id`s sent in
1323 /// this query are encoded. We only support `encoding_type=0` uncompressed
1324 /// serialization and do not support `encoding_type=1` zlib serialization.
1326 /// [`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
1327 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1328 pub struct QueryShortChannelIds {
1329 /// The genesis hash of the blockchain being queried
1330 pub chain_hash: ChainHash,
1331 /// The short_channel_ids that are being queried
1332 pub short_channel_ids: Vec<u64>,
1335 /// A [`reply_short_channel_ids_end`] message is sent as a reply to a
1336 /// message. The query recipient makes a best
1337 /// effort to respond based on their local network view which may not be
1338 /// a perfect view of the network.
1340 /// [`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
1341 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1342 pub struct ReplyShortChannelIdsEnd {
1343 /// The genesis hash of the blockchain that was queried
1344 pub chain_hash: ChainHash,
1345 /// Indicates if the query recipient maintains up-to-date channel
1346 /// information for the `chain_hash`
1347 pub full_information: bool,
1350 /// A [`gossip_timestamp_filter`] message is used by a node to request
1351 /// gossip relay for messages in the requested time range when the
1352 /// `gossip_queries` feature has been negotiated.
1354 /// [`gossip_timestamp_filter`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-gossip_timestamp_filter-message
1355 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1356 pub struct GossipTimestampFilter {
1357 /// The genesis hash of the blockchain for channel and node information
1358 pub chain_hash: ChainHash,
1359 /// The starting unix timestamp
1360 pub first_timestamp: u32,
1361 /// The range of information in seconds
1362 pub timestamp_range: u32,
1365 /// Encoding type for data compression of collections in gossip queries.
1367 /// We do not support `encoding_type=1` zlib serialization [defined in BOLT
1368 /// #7](https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#query-messages).
1370 Uncompressed = 0x00,
1373 /// Used to put an error message in a [`LightningError`].
1374 #[derive(Clone, Debug, Hash, PartialEq)]
1375 pub enum ErrorAction {
1376 /// The peer took some action which made us think they were useless. Disconnect them.
1378 /// An error message which we should make an effort to send before we disconnect.
1379 msg: Option<ErrorMessage>
1381 /// The peer did something incorrect. Tell them without closing any channels and disconnect them.
1382 DisconnectPeerWithWarning {
1383 /// A warning message which we should make an effort to send before we disconnect.
1384 msg: WarningMessage,
1386 /// The peer did something harmless that we weren't able to process, just log and ignore
1387 // New code should *not* use this. New code must use IgnoreAndLog, below!
1389 /// The peer did something harmless that we weren't able to meaningfully process.
1390 /// If the error is logged, log it at the given level.
1391 IgnoreAndLog(logger::Level),
1392 /// The peer provided us with a gossip message which we'd already seen. In most cases this
1393 /// should be ignored, but it may result in the message being forwarded if it is a duplicate of
1394 /// our own channel announcements.
1395 IgnoreDuplicateGossip,
1396 /// The peer did something incorrect. Tell them.
1398 /// The message to send.
1401 /// The peer did something incorrect. Tell them without closing any channels.
1402 SendWarningMessage {
1403 /// The message to send.
1404 msg: WarningMessage,
1405 /// The peer may have done something harmless that we weren't able to meaningfully process,
1406 /// though we should still tell them about it.
1407 /// If this event is logged, log it at the given level.
1408 log_level: logger::Level,
1412 /// An Err type for failure to process messages.
1413 #[derive(Clone, Debug)]
1414 pub struct LightningError {
1415 /// A human-readable message describing the error
1417 /// The action which should be taken against the offending peer.
1418 pub action: ErrorAction,
1421 /// Struct used to return values from [`RevokeAndACK`] messages, containing a bunch of commitment
1422 /// transaction updates if they were pending.
1423 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1424 pub struct CommitmentUpdate {
1425 /// `update_add_htlc` messages which should be sent
1426 pub update_add_htlcs: Vec<UpdateAddHTLC>,
1427 /// `update_fulfill_htlc` messages which should be sent
1428 pub update_fulfill_htlcs: Vec<UpdateFulfillHTLC>,
1429 /// `update_fail_htlc` messages which should be sent
1430 pub update_fail_htlcs: Vec<UpdateFailHTLC>,
1431 /// `update_fail_malformed_htlc` messages which should be sent
1432 pub update_fail_malformed_htlcs: Vec<UpdateFailMalformedHTLC>,
1433 /// An `update_fee` message which should be sent
1434 pub update_fee: Option<UpdateFee>,
1435 /// A `commitment_signed` message which should be sent
1436 pub commitment_signed: CommitmentSigned,
1439 /// A trait to describe an object which can receive channel messages.
1441 /// Messages MAY be called in parallel when they originate from different `their_node_ids`, however
1442 /// they MUST NOT be called in parallel when the two calls have the same `their_node_id`.
1443 pub trait ChannelMessageHandler : MessageSendEventsProvider {
1445 /// Handle an incoming `open_channel` message from the given peer.
1446 fn handle_open_channel(&self, their_node_id: &PublicKey, msg: &OpenChannel);
1447 /// Handle an incoming `open_channel2` message from the given peer.
1448 fn handle_open_channel_v2(&self, their_node_id: &PublicKey, msg: &OpenChannelV2);
1449 /// Handle an incoming `accept_channel` message from the given peer.
1450 fn handle_accept_channel(&self, their_node_id: &PublicKey, msg: &AcceptChannel);
1451 /// Handle an incoming `accept_channel2` message from the given peer.
1452 fn handle_accept_channel_v2(&self, their_node_id: &PublicKey, msg: &AcceptChannelV2);
1453 /// Handle an incoming `funding_created` message from the given peer.
1454 fn handle_funding_created(&self, their_node_id: &PublicKey, msg: &FundingCreated);
1455 /// Handle an incoming `funding_signed` message from the given peer.
1456 fn handle_funding_signed(&self, their_node_id: &PublicKey, msg: &FundingSigned);
1457 /// Handle an incoming `channel_ready` message from the given peer.
1458 fn handle_channel_ready(&self, their_node_id: &PublicKey, msg: &ChannelReady);
1461 /// Handle an incoming `shutdown` message from the given peer.
1462 fn handle_shutdown(&self, their_node_id: &PublicKey, msg: &Shutdown);
1463 /// Handle an incoming `closing_signed` message from the given peer.
1464 fn handle_closing_signed(&self, their_node_id: &PublicKey, msg: &ClosingSigned);
1467 /// Handle an incoming `stfu` message from the given peer.
1468 fn handle_stfu(&self, their_node_id: &PublicKey, msg: &Stfu);
1471 /// Handle an incoming `splice` message from the given peer.
1472 fn handle_splice(&self, their_node_id: &PublicKey, msg: &Splice);
1473 /// Handle an incoming `splice_ack` message from the given peer.
1474 fn handle_splice_ack(&self, their_node_id: &PublicKey, msg: &SpliceAck);
1475 /// Handle an incoming `splice_locked` message from the given peer.
1476 fn handle_splice_locked(&self, their_node_id: &PublicKey, msg: &SpliceLocked);
1478 // Interactive channel construction
1479 /// Handle an incoming `tx_add_input message` from the given peer.
1480 fn handle_tx_add_input(&self, their_node_id: &PublicKey, msg: &TxAddInput);
1481 /// Handle an incoming `tx_add_output` message from the given peer.
1482 fn handle_tx_add_output(&self, their_node_id: &PublicKey, msg: &TxAddOutput);
1483 /// Handle an incoming `tx_remove_input` message from the given peer.
1484 fn handle_tx_remove_input(&self, their_node_id: &PublicKey, msg: &TxRemoveInput);
1485 /// Handle an incoming `tx_remove_output` message from the given peer.
1486 fn handle_tx_remove_output(&self, their_node_id: &PublicKey, msg: &TxRemoveOutput);
1487 /// Handle an incoming `tx_complete message` from the given peer.
1488 fn handle_tx_complete(&self, their_node_id: &PublicKey, msg: &TxComplete);
1489 /// Handle an incoming `tx_signatures` message from the given peer.
1490 fn handle_tx_signatures(&self, their_node_id: &PublicKey, msg: &TxSignatures);
1491 /// Handle an incoming `tx_init_rbf` message from the given peer.
1492 fn handle_tx_init_rbf(&self, their_node_id: &PublicKey, msg: &TxInitRbf);
1493 /// Handle an incoming `tx_ack_rbf` message from the given peer.
1494 fn handle_tx_ack_rbf(&self, their_node_id: &PublicKey, msg: &TxAckRbf);
1495 /// Handle an incoming `tx_abort message` from the given peer.
1496 fn handle_tx_abort(&self, their_node_id: &PublicKey, msg: &TxAbort);
1499 /// Handle an incoming `update_add_htlc` message from the given peer.
1500 fn handle_update_add_htlc(&self, their_node_id: &PublicKey, msg: &UpdateAddHTLC);
1501 /// Handle an incoming `update_fulfill_htlc` message from the given peer.
1502 fn handle_update_fulfill_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFulfillHTLC);
1503 /// Handle an incoming `update_fail_htlc` message from the given peer.
1504 fn handle_update_fail_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailHTLC);
1505 /// Handle an incoming `update_fail_malformed_htlc` message from the given peer.
1506 fn handle_update_fail_malformed_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailMalformedHTLC);
1507 /// Handle an incoming `commitment_signed` message from the given peer.
1508 fn handle_commitment_signed(&self, their_node_id: &PublicKey, msg: &CommitmentSigned);
1509 /// Handle an incoming `revoke_and_ack` message from the given peer.
1510 fn handle_revoke_and_ack(&self, their_node_id: &PublicKey, msg: &RevokeAndACK);
1512 /// Handle an incoming `update_fee` message from the given peer.
1513 fn handle_update_fee(&self, their_node_id: &PublicKey, msg: &UpdateFee);
1515 // Channel-to-announce:
1516 /// Handle an incoming `announcement_signatures` message from the given peer.
1517 fn handle_announcement_signatures(&self, their_node_id: &PublicKey, msg: &AnnouncementSignatures);
1519 // Connection loss/reestablish:
1520 /// Indicates a connection to the peer failed/an existing connection was lost.
1521 fn peer_disconnected(&self, their_node_id: &PublicKey);
1523 /// Handle a peer reconnecting, possibly generating `channel_reestablish` message(s).
1525 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1526 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1527 /// message handlers may still wish to communicate with this peer.
1528 fn peer_connected(&self, their_node_id: &PublicKey, msg: &Init, inbound: bool) -> Result<(), ()>;
1529 /// Handle an incoming `channel_reestablish` message from the given peer.
1530 fn handle_channel_reestablish(&self, their_node_id: &PublicKey, msg: &ChannelReestablish);
1532 /// Handle an incoming `channel_update` message from the given peer.
1533 fn handle_channel_update(&self, their_node_id: &PublicKey, msg: &ChannelUpdate);
1536 /// Handle an incoming `error` message from the given peer.
1537 fn handle_error(&self, their_node_id: &PublicKey, msg: &ErrorMessage);
1539 // Handler information:
1540 /// Gets the node feature flags which this handler itself supports. All available handlers are
1541 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1542 /// which are broadcasted in our [`NodeAnnouncement`] message.
1543 fn provided_node_features(&self) -> NodeFeatures;
1545 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1546 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1547 /// which are sent in our [`Init`] message.
1549 /// Note that this method is called before [`Self::peer_connected`].
1550 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1552 /// Gets the chain hashes for this `ChannelMessageHandler` indicating which chains it supports.
1554 /// If it's `None`, then no particular network chain hash compatibility will be enforced when
1555 /// connecting to peers.
1556 fn get_chain_hashes(&self) -> Option<Vec<ChainHash>>;
1559 /// A trait to describe an object which can receive routing messages.
1561 /// # Implementor DoS Warnings
1563 /// For messages enabled with the `gossip_queries` feature there are potential DoS vectors when
1564 /// handling inbound queries. Implementors using an on-disk network graph should be aware of
1565 /// repeated disk I/O for queries accessing different parts of the network graph.
1566 pub trait RoutingMessageHandler : MessageSendEventsProvider {
1567 /// Handle an incoming `node_announcement` message, returning `true` if it should be forwarded on,
1568 /// `false` or returning an `Err` otherwise.
1569 fn handle_node_announcement(&self, msg: &NodeAnnouncement) -> Result<bool, LightningError>;
1570 /// Handle a `channel_announcement` message, returning `true` if it should be forwarded on, `false`
1571 /// or returning an `Err` otherwise.
1572 fn handle_channel_announcement(&self, msg: &ChannelAnnouncement) -> Result<bool, LightningError>;
1573 /// Handle an incoming `channel_update` message, returning true if it should be forwarded on,
1574 /// `false` or returning an `Err` otherwise.
1575 fn handle_channel_update(&self, msg: &ChannelUpdate) -> Result<bool, LightningError>;
1576 /// Gets channel announcements and updates required to dump our routing table to a remote node,
1577 /// starting at the `short_channel_id` indicated by `starting_point` and including announcements
1578 /// for a single channel.
1579 fn get_next_channel_announcement(&self, starting_point: u64) -> Option<(ChannelAnnouncement, Option<ChannelUpdate>, Option<ChannelUpdate>)>;
1580 /// Gets a node announcement required to dump our routing table to a remote node, starting at
1581 /// the node *after* the provided pubkey and including up to one announcement immediately
1582 /// higher (as defined by `<PublicKey as Ord>::cmp`) than `starting_point`.
1583 /// If `None` is provided for `starting_point`, we start at the first node.
1584 fn get_next_node_announcement(&self, starting_point: Option<&NodeId>) -> Option<NodeAnnouncement>;
1585 /// Called when a connection is established with a peer. This can be used to
1586 /// perform routing table synchronization using a strategy defined by the
1589 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1590 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1591 /// message handlers may still wish to communicate with this peer.
1592 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1593 /// Handles the reply of a query we initiated to learn about channels
1594 /// for a given range of blocks. We can expect to receive one or more
1595 /// replies to a single query.
1596 fn handle_reply_channel_range(&self, their_node_id: &PublicKey, msg: ReplyChannelRange) -> Result<(), LightningError>;
1597 /// Handles the reply of a query we initiated asking for routing gossip
1598 /// messages for a list of channels. We should receive this message when
1599 /// a node has completed its best effort to send us the pertaining routing
1600 /// gossip messages.
1601 fn handle_reply_short_channel_ids_end(&self, their_node_id: &PublicKey, msg: ReplyShortChannelIdsEnd) -> Result<(), LightningError>;
1602 /// Handles when a peer asks us to send a list of `short_channel_id`s
1603 /// for the requested range of blocks.
1604 fn handle_query_channel_range(&self, their_node_id: &PublicKey, msg: QueryChannelRange) -> Result<(), LightningError>;
1605 /// Handles when a peer asks us to send routing gossip messages for a
1606 /// list of `short_channel_id`s.
1607 fn handle_query_short_channel_ids(&self, their_node_id: &PublicKey, msg: QueryShortChannelIds) -> Result<(), LightningError>;
1609 // Handler queueing status:
1610 /// Indicates that there are a large number of [`ChannelAnnouncement`] (or other) messages
1611 /// pending some async action. While there is no guarantee of the rate of future messages, the
1612 /// caller should seek to reduce the rate of new gossip messages handled, especially
1613 /// [`ChannelAnnouncement`]s.
1614 fn processing_queue_high(&self) -> bool;
1616 // Handler information:
1617 /// Gets the node feature flags which this handler itself supports. All available handlers are
1618 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1619 /// which are broadcasted in our [`NodeAnnouncement`] message.
1620 fn provided_node_features(&self) -> NodeFeatures;
1621 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1622 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1623 /// which are sent in our [`Init`] message.
1625 /// Note that this method is called before [`Self::peer_connected`].
1626 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1629 /// A handler for received [`OnionMessage`]s and for providing generated ones to send.
1630 pub trait OnionMessageHandler {
1631 /// Handle an incoming `onion_message` message from the given peer.
1632 fn handle_onion_message(&self, peer_node_id: &PublicKey, msg: &OnionMessage);
1634 /// Returns the next pending onion message for the peer with the given node id.
1635 fn next_onion_message_for_peer(&self, peer_node_id: PublicKey) -> Option<OnionMessage>;
1637 /// Called when a connection is established with a peer. Can be used to track which peers
1638 /// advertise onion message support and are online.
1640 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1641 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1642 /// message handlers may still wish to communicate with this peer.
1643 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1645 /// Indicates a connection to the peer failed/an existing connection was lost. Allows handlers to
1646 /// drop and refuse to forward onion messages to this peer.
1647 fn peer_disconnected(&self, their_node_id: &PublicKey);
1649 // Handler information:
1650 /// Gets the node feature flags which this handler itself supports. All available handlers are
1651 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1652 /// which are broadcasted in our [`NodeAnnouncement`] message.
1653 fn provided_node_features(&self) -> NodeFeatures;
1655 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1656 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1657 /// which are sent in our [`Init`] message.
1659 /// Note that this method is called before [`Self::peer_connected`].
1660 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1663 mod fuzzy_internal_msgs {
1664 use bitcoin::secp256k1::PublicKey;
1665 use crate::blinded_path::payment::PaymentConstraints;
1666 use crate::prelude::*;
1667 use crate::ln::{PaymentPreimage, PaymentSecret};
1669 // These types aren't intended to be pub, but are exposed for direct fuzzing (as we deserialize
1670 // them from untrusted input):
1672 pub struct FinalOnionHopData {
1673 pub payment_secret: PaymentSecret,
1674 /// The total value, in msat, of the payment as received by the ultimate recipient.
1675 /// Message serialization may panic if this value is more than 21 million Bitcoin.
1676 pub total_msat: u64,
1679 pub enum InboundOnionPayload {
1681 short_channel_id: u64,
1682 /// The value, in msat, of the payment after this hop's fee is deducted.
1683 amt_to_forward: u64,
1684 outgoing_cltv_value: u32,
1687 payment_data: Option<FinalOnionHopData>,
1688 payment_metadata: Option<Vec<u8>>,
1689 keysend_preimage: Option<PaymentPreimage>,
1690 custom_tlvs: Vec<(u64, Vec<u8>)>,
1692 outgoing_cltv_value: u32,
1697 outgoing_cltv_value: u32,
1698 payment_secret: PaymentSecret,
1699 payment_constraints: PaymentConstraints,
1700 intro_node_blinding_point: PublicKey,
1704 pub(crate) enum OutboundOnionPayload {
1706 short_channel_id: u64,
1707 /// The value, in msat, of the payment after this hop's fee is deducted.
1708 amt_to_forward: u64,
1709 outgoing_cltv_value: u32,
1712 payment_data: Option<FinalOnionHopData>,
1713 payment_metadata: Option<Vec<u8>>,
1714 keysend_preimage: Option<PaymentPreimage>,
1715 custom_tlvs: Vec<(u64, Vec<u8>)>,
1717 outgoing_cltv_value: u32,
1720 encrypted_tlvs: Vec<u8>,
1721 intro_node_blinding_point: Option<PublicKey>,
1726 outgoing_cltv_value: u32,
1727 encrypted_tlvs: Vec<u8>,
1728 intro_node_blinding_point: Option<PublicKey>, // Set if the introduction node of the blinded path is the final node
1732 pub struct DecodedOnionErrorPacket {
1733 pub(crate) hmac: [u8; 32],
1734 pub(crate) failuremsg: Vec<u8>,
1735 pub(crate) pad: Vec<u8>,
1739 pub use self::fuzzy_internal_msgs::*;
1740 #[cfg(not(fuzzing))]
1741 pub(crate) use self::fuzzy_internal_msgs::*;
1743 /// BOLT 4 onion packet including hop data for the next peer.
1744 #[derive(Clone, Hash, PartialEq, Eq)]
1745 pub struct OnionPacket {
1746 /// BOLT 4 version number.
1748 /// In order to ensure we always return an error on onion decode in compliance with [BOLT
1749 /// #4](https://github.com/lightning/bolts/blob/master/04-onion-routing.md), we have to
1750 /// deserialize `OnionPacket`s contained in [`UpdateAddHTLC`] messages even if the ephemeral
1751 /// public key (here) is bogus, so we hold a [`Result`] instead of a [`PublicKey`] as we'd
1753 pub public_key: Result<PublicKey, secp256k1::Error>,
1754 /// 1300 bytes encrypted payload for the next hop.
1755 pub hop_data: [u8; 20*65],
1756 /// HMAC to verify the integrity of hop_data.
1760 impl onion_utils::Packet for OnionPacket {
1761 type Data = onion_utils::FixedSizeOnionPacket;
1762 fn new(pubkey: PublicKey, hop_data: onion_utils::FixedSizeOnionPacket, hmac: [u8; 32]) -> Self {
1765 public_key: Ok(pubkey),
1766 hop_data: hop_data.0,
1772 impl fmt::Debug for OnionPacket {
1773 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1774 f.write_fmt(format_args!("OnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
1778 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1779 pub(crate) struct OnionErrorPacket {
1780 // This really should be a constant size slice, but the spec lets these things be up to 128KB?
1781 // (TODO) We limit it in decode to much lower...
1782 pub(crate) data: Vec<u8>,
1785 impl fmt::Display for DecodeError {
1786 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1788 DecodeError::UnknownVersion => f.write_str("Unknown realm byte in Onion packet"),
1789 DecodeError::UnknownRequiredFeature => f.write_str("Unknown required feature preventing decode"),
1790 DecodeError::InvalidValue => f.write_str("Nonsense bytes didn't map to the type they were interpreted as"),
1791 DecodeError::ShortRead => f.write_str("Packet extended beyond the provided bytes"),
1792 DecodeError::BadLengthDescriptor => f.write_str("A length descriptor in the packet didn't describe the later data correctly"),
1793 DecodeError::Io(ref e) => fmt::Debug::fmt(e, f),
1794 DecodeError::UnsupportedCompression => f.write_str("We don't support receiving messages with zlib-compressed fields"),
1799 impl From<io::Error> for DecodeError {
1800 fn from(e: io::Error) -> Self {
1801 if e.kind() == io::ErrorKind::UnexpectedEof {
1802 DecodeError::ShortRead
1804 DecodeError::Io(e.kind())
1809 #[cfg(not(taproot))]
1810 impl_writeable_msg!(AcceptChannel, {
1811 temporary_channel_id,
1812 dust_limit_satoshis,
1813 max_htlc_value_in_flight_msat,
1814 channel_reserve_satoshis,
1820 revocation_basepoint,
1822 delayed_payment_basepoint,
1824 first_per_commitment_point,
1826 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))), // Don't encode length twice.
1827 (1, channel_type, option),
1831 impl_writeable_msg!(AcceptChannel, {
1832 temporary_channel_id,
1833 dust_limit_satoshis,
1834 max_htlc_value_in_flight_msat,
1835 channel_reserve_satoshis,
1841 revocation_basepoint,
1843 delayed_payment_basepoint,
1845 first_per_commitment_point,
1847 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))), // Don't encode length twice.
1848 (1, channel_type, option),
1849 (4, next_local_nonce, option),
1852 impl_writeable_msg!(AcceptChannelV2, {
1853 temporary_channel_id,
1855 dust_limit_satoshis,
1856 max_htlc_value_in_flight_msat,
1862 revocation_basepoint,
1864 delayed_payment_basepoint,
1866 first_per_commitment_point,
1867 second_per_commitment_point,
1869 (0, shutdown_scriptpubkey, option),
1870 (1, channel_type, option),
1871 (2, require_confirmed_inputs, option),
1874 impl_writeable_msg!(Stfu, {
1879 impl_writeable_msg!(Splice, {
1883 funding_feerate_perkw,
1888 impl_writeable_msg!(SpliceAck, {
1895 impl_writeable_msg!(SpliceLocked, {
1899 impl_writeable_msg!(TxAddInput, {
1907 impl_writeable_msg!(TxAddOutput, {
1914 impl_writeable_msg!(TxRemoveInput, {
1919 impl_writeable_msg!(TxRemoveOutput, {
1924 impl_writeable_msg!(TxComplete, {
1928 impl_writeable_msg!(TxSignatures, {
1934 impl_writeable_msg!(TxInitRbf, {
1937 feerate_sat_per_1000_weight,
1939 (0, funding_output_contribution, option),
1942 impl_writeable_msg!(TxAckRbf, {
1945 (0, funding_output_contribution, option),
1948 impl_writeable_msg!(TxAbort, {
1953 impl_writeable_msg!(AnnouncementSignatures, {
1960 impl_writeable_msg!(ChannelReestablish, {
1962 next_local_commitment_number,
1963 next_remote_commitment_number,
1964 your_last_per_commitment_secret,
1965 my_current_per_commitment_point,
1967 (0, next_funding_txid, option),
1970 impl_writeable_msg!(ClosingSigned,
1971 { channel_id, fee_satoshis, signature },
1972 { (1, fee_range, option) }
1975 impl_writeable!(ClosingSignedFeeRange, {
1980 #[cfg(not(taproot))]
1981 impl_writeable_msg!(CommitmentSigned, {
1988 impl_writeable_msg!(CommitmentSigned, {
1993 (2, partial_signature_with_nonce, option)
1996 impl_writeable!(DecodedOnionErrorPacket, {
2002 #[cfg(not(taproot))]
2003 impl_writeable_msg!(FundingCreated, {
2004 temporary_channel_id,
2006 funding_output_index,
2010 impl_writeable_msg!(FundingCreated, {
2011 temporary_channel_id,
2013 funding_output_index,
2016 (2, partial_signature_with_nonce, option),
2017 (4, next_local_nonce, option)
2020 #[cfg(not(taproot))]
2021 impl_writeable_msg!(FundingSigned, {
2027 impl_writeable_msg!(FundingSigned, {
2031 (2, partial_signature_with_nonce, option)
2034 impl_writeable_msg!(ChannelReady, {
2036 next_per_commitment_point,
2038 (1, short_channel_id_alias, option),
2041 impl Writeable for Init {
2042 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2043 // global_features gets the bottom 13 bits of our features, and local_features gets all of
2044 // our relevant feature bits. This keeps us compatible with old nodes.
2045 self.features.write_up_to_13(w)?;
2046 self.features.write(w)?;
2047 encode_tlv_stream!(w, {
2048 (1, self.networks.as_ref().map(|n| WithoutLength(n)), option),
2049 (3, self.remote_network_address, option),
2055 impl Readable for Init {
2056 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2057 let global_features: InitFeatures = Readable::read(r)?;
2058 let features: InitFeatures = Readable::read(r)?;
2059 let mut remote_network_address: Option<SocketAddress> = None;
2060 let mut networks: Option<WithoutLength<Vec<ChainHash>>> = None;
2061 decode_tlv_stream!(r, {
2062 (1, networks, option),
2063 (3, remote_network_address, option)
2066 features: features | global_features,
2067 networks: networks.map(|n| n.0),
2068 remote_network_address,
2073 impl_writeable_msg!(OpenChannel, {
2075 temporary_channel_id,
2078 dust_limit_satoshis,
2079 max_htlc_value_in_flight_msat,
2080 channel_reserve_satoshis,
2086 revocation_basepoint,
2088 delayed_payment_basepoint,
2090 first_per_commitment_point,
2093 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))), // Don't encode length twice.
2094 (1, channel_type, option),
2097 impl_writeable_msg!(OpenChannelV2, {
2099 temporary_channel_id,
2100 funding_feerate_sat_per_1000_weight,
2101 commitment_feerate_sat_per_1000_weight,
2103 dust_limit_satoshis,
2104 max_htlc_value_in_flight_msat,
2110 revocation_basepoint,
2112 delayed_payment_basepoint,
2114 first_per_commitment_point,
2115 second_per_commitment_point,
2118 (0, shutdown_scriptpubkey, option),
2119 (1, channel_type, option),
2120 (2, require_confirmed_inputs, option),
2123 #[cfg(not(taproot))]
2124 impl_writeable_msg!(RevokeAndACK, {
2126 per_commitment_secret,
2127 next_per_commitment_point
2131 impl_writeable_msg!(RevokeAndACK, {
2133 per_commitment_secret,
2134 next_per_commitment_point
2136 (4, next_local_nonce, option)
2139 impl_writeable_msg!(Shutdown, {
2144 impl_writeable_msg!(UpdateFailHTLC, {
2150 impl_writeable_msg!(UpdateFailMalformedHTLC, {
2157 impl_writeable_msg!(UpdateFee, {
2162 impl_writeable_msg!(UpdateFulfillHTLC, {
2168 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2169 // serialization format in a way which assumes we know the total serialized length/message end
2171 impl_writeable!(OnionErrorPacket, {
2175 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2176 // serialization format in a way which assumes we know the total serialized length/message end
2178 impl Writeable for OnionPacket {
2179 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2180 self.version.write(w)?;
2181 match self.public_key {
2182 Ok(pubkey) => pubkey.write(w)?,
2183 Err(_) => [0u8;33].write(w)?,
2185 w.write_all(&self.hop_data)?;
2186 self.hmac.write(w)?;
2191 impl Readable for OnionPacket {
2192 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2194 version: Readable::read(r)?,
2196 let mut buf = [0u8;33];
2197 r.read_exact(&mut buf)?;
2198 PublicKey::from_slice(&buf)
2200 hop_data: Readable::read(r)?,
2201 hmac: Readable::read(r)?,
2206 impl_writeable_msg!(UpdateAddHTLC, {
2212 onion_routing_packet,
2214 (65537, skimmed_fee_msat, option)
2217 impl Readable for OnionMessage {
2218 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2219 let blinding_point: PublicKey = Readable::read(r)?;
2220 let len: u16 = Readable::read(r)?;
2221 let mut packet_reader = FixedLengthReader::new(r, len as u64);
2222 let onion_routing_packet: onion_message::Packet = <onion_message::Packet as LengthReadable>::read(&mut packet_reader)?;
2225 onion_routing_packet,
2230 impl Writeable for OnionMessage {
2231 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2232 self.blinding_point.write(w)?;
2233 let onion_packet_len = self.onion_routing_packet.serialized_length();
2234 (onion_packet_len as u16).write(w)?;
2235 self.onion_routing_packet.write(w)?;
2240 impl Writeable for FinalOnionHopData {
2241 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2242 self.payment_secret.0.write(w)?;
2243 HighZeroBytesDroppedBigSize(self.total_msat).write(w)
2247 impl Readable for FinalOnionHopData {
2248 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2249 let secret: [u8; 32] = Readable::read(r)?;
2250 let amt: HighZeroBytesDroppedBigSize<u64> = Readable::read(r)?;
2251 Ok(Self { payment_secret: PaymentSecret(secret), total_msat: amt.0 })
2255 impl Writeable for OutboundOnionPayload {
2256 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2258 Self::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } => {
2259 _encode_varint_length_prefixed_tlv!(w, {
2260 (2, HighZeroBytesDroppedBigSize(*amt_to_forward), required),
2261 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2262 (6, short_channel_id, required)
2266 ref payment_data, ref payment_metadata, ref keysend_preimage, amt_msat,
2267 outgoing_cltv_value, ref custom_tlvs,
2269 // We need to update [`ln::outbound_payment::RecipientOnionFields::with_custom_tlvs`]
2270 // to reject any reserved types in the experimental range if new ones are ever
2272 let keysend_tlv = keysend_preimage.map(|preimage| (5482373484, preimage.encode()));
2273 let mut custom_tlvs: Vec<&(u64, Vec<u8>)> = custom_tlvs.iter().chain(keysend_tlv.iter()).collect();
2274 custom_tlvs.sort_unstable_by_key(|(typ, _)| *typ);
2275 _encode_varint_length_prefixed_tlv!(w, {
2276 (2, HighZeroBytesDroppedBigSize(*amt_msat), required),
2277 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2278 (8, payment_data, option),
2279 (16, payment_metadata.as_ref().map(|m| WithoutLength(m)), option)
2280 }, custom_tlvs.iter());
2282 Self::BlindedForward { encrypted_tlvs, intro_node_blinding_point } => {
2283 _encode_varint_length_prefixed_tlv!(w, {
2284 (10, *encrypted_tlvs, required_vec),
2285 (12, intro_node_blinding_point, option)
2288 Self::BlindedReceive {
2289 amt_msat, total_msat, outgoing_cltv_value, encrypted_tlvs,
2290 intro_node_blinding_point,
2292 _encode_varint_length_prefixed_tlv!(w, {
2293 (2, HighZeroBytesDroppedBigSize(*amt_msat), required),
2294 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2295 (10, *encrypted_tlvs, required_vec),
2296 (12, intro_node_blinding_point, option),
2297 (18, HighZeroBytesDroppedBigSize(*total_msat), required)
2305 impl<NS: Deref> ReadableArgs<&NS> for InboundOnionPayload where NS::Target: NodeSigner {
2306 fn read<R: Read>(r: &mut R, node_signer: &NS) -> Result<Self, DecodeError> {
2308 let mut cltv_value = None;
2309 let mut short_id: Option<u64> = None;
2310 let mut payment_data: Option<FinalOnionHopData> = None;
2311 let mut encrypted_tlvs_opt: Option<WithoutLength<Vec<u8>>> = None;
2312 let mut intro_node_blinding_point = None;
2313 let mut payment_metadata: Option<WithoutLength<Vec<u8>>> = None;
2314 let mut total_msat = None;
2315 let mut keysend_preimage: Option<PaymentPreimage> = None;
2316 let mut custom_tlvs = Vec::new();
2318 let tlv_len = BigSize::read(r)?;
2319 let rd = FixedLengthReader::new(r, tlv_len.0);
2320 decode_tlv_stream_with_custom_tlv_decode!(rd, {
2321 (2, amt, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2322 (4, cltv_value, (option, encoding: (u32, HighZeroBytesDroppedBigSize))),
2323 (6, short_id, option),
2324 (8, payment_data, option),
2325 (10, encrypted_tlvs_opt, option),
2326 (12, intro_node_blinding_point, option),
2327 (16, payment_metadata, option),
2328 (18, total_msat, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2329 // See https://github.com/lightning/blips/blob/master/blip-0003.md
2330 (5482373484, keysend_preimage, option)
2331 }, |msg_type: u64, msg_reader: &mut FixedLengthReader<_>| -> Result<bool, DecodeError> {
2332 if msg_type < 1 << 16 { return Ok(false) }
2333 let mut value = Vec::new();
2334 msg_reader.read_to_end(&mut value)?;
2335 custom_tlvs.push((msg_type, value));
2339 if amt.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2341 if let Some(blinding_point) = intro_node_blinding_point {
2342 if short_id.is_some() || payment_data.is_some() || payment_metadata.is_some() {
2343 return Err(DecodeError::InvalidValue)
2345 let enc_tlvs = encrypted_tlvs_opt.ok_or(DecodeError::InvalidValue)?.0;
2346 let enc_tlvs_ss = node_signer.ecdh(Recipient::Node, &blinding_point, None)
2347 .map_err(|_| DecodeError::InvalidValue)?;
2348 let rho = onion_utils::gen_rho_from_shared_secret(&enc_tlvs_ss.secret_bytes());
2349 let mut s = Cursor::new(&enc_tlvs);
2350 let mut reader = FixedLengthReader::new(&mut s, enc_tlvs.len() as u64);
2351 match ChaChaPolyReadAdapter::read(&mut reader, rho)? {
2352 ChaChaPolyReadAdapter { readable: ReceiveTlvs { payment_secret, payment_constraints }} => {
2353 if total_msat.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2354 Ok(Self::BlindedReceive {
2355 amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2356 total_msat: total_msat.ok_or(DecodeError::InvalidValue)?,
2357 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2359 payment_constraints,
2360 intro_node_blinding_point: blinding_point,
2364 } else if let Some(short_channel_id) = short_id {
2365 if payment_data.is_some() || payment_metadata.is_some() || encrypted_tlvs_opt.is_some() ||
2366 total_msat.is_some()
2367 { return Err(DecodeError::InvalidValue) }
2370 amt_to_forward: amt.ok_or(DecodeError::InvalidValue)?,
2371 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2374 if encrypted_tlvs_opt.is_some() || total_msat.is_some() {
2375 return Err(DecodeError::InvalidValue)
2377 if let Some(data) = &payment_data {
2378 if data.total_msat > MAX_VALUE_MSAT {
2379 return Err(DecodeError::InvalidValue);
2384 payment_metadata: payment_metadata.map(|w| w.0),
2386 amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2387 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2394 impl Writeable for Ping {
2395 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2396 self.ponglen.write(w)?;
2397 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2402 impl Readable for Ping {
2403 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2405 ponglen: Readable::read(r)?,
2407 let byteslen = Readable::read(r)?;
2408 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2415 impl Writeable for Pong {
2416 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2417 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2422 impl Readable for Pong {
2423 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2426 let byteslen = Readable::read(r)?;
2427 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2434 impl Writeable for UnsignedChannelAnnouncement {
2435 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2436 self.features.write(w)?;
2437 self.chain_hash.write(w)?;
2438 self.short_channel_id.write(w)?;
2439 self.node_id_1.write(w)?;
2440 self.node_id_2.write(w)?;
2441 self.bitcoin_key_1.write(w)?;
2442 self.bitcoin_key_2.write(w)?;
2443 w.write_all(&self.excess_data[..])?;
2448 impl Readable for UnsignedChannelAnnouncement {
2449 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2451 features: Readable::read(r)?,
2452 chain_hash: Readable::read(r)?,
2453 short_channel_id: Readable::read(r)?,
2454 node_id_1: Readable::read(r)?,
2455 node_id_2: Readable::read(r)?,
2456 bitcoin_key_1: Readable::read(r)?,
2457 bitcoin_key_2: Readable::read(r)?,
2458 excess_data: read_to_end(r)?,
2463 impl_writeable!(ChannelAnnouncement, {
2466 bitcoin_signature_1,
2467 bitcoin_signature_2,
2471 impl Writeable for UnsignedChannelUpdate {
2472 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2473 // `message_flags` used to indicate presence of `htlc_maximum_msat`, but was deprecated in the spec.
2474 const MESSAGE_FLAGS: u8 = 1;
2475 self.chain_hash.write(w)?;
2476 self.short_channel_id.write(w)?;
2477 self.timestamp.write(w)?;
2478 let all_flags = self.flags as u16 | ((MESSAGE_FLAGS as u16) << 8);
2479 all_flags.write(w)?;
2480 self.cltv_expiry_delta.write(w)?;
2481 self.htlc_minimum_msat.write(w)?;
2482 self.fee_base_msat.write(w)?;
2483 self.fee_proportional_millionths.write(w)?;
2484 self.htlc_maximum_msat.write(w)?;
2485 w.write_all(&self.excess_data[..])?;
2490 impl Readable for UnsignedChannelUpdate {
2491 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2493 chain_hash: Readable::read(r)?,
2494 short_channel_id: Readable::read(r)?,
2495 timestamp: Readable::read(r)?,
2497 let flags: u16 = Readable::read(r)?;
2498 // Note: we ignore the `message_flags` for now, since it was deprecated by the spec.
2501 cltv_expiry_delta: Readable::read(r)?,
2502 htlc_minimum_msat: Readable::read(r)?,
2503 fee_base_msat: Readable::read(r)?,
2504 fee_proportional_millionths: Readable::read(r)?,
2505 htlc_maximum_msat: Readable::read(r)?,
2506 excess_data: read_to_end(r)?,
2511 impl_writeable!(ChannelUpdate, {
2516 impl Writeable for ErrorMessage {
2517 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2518 self.channel_id.write(w)?;
2519 (self.data.len() as u16).write(w)?;
2520 w.write_all(self.data.as_bytes())?;
2525 impl Readable for ErrorMessage {
2526 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2528 channel_id: Readable::read(r)?,
2530 let sz: usize = <u16 as Readable>::read(r)? as usize;
2531 let mut data = Vec::with_capacity(sz);
2533 r.read_exact(&mut data)?;
2534 match String::from_utf8(data) {
2536 Err(_) => return Err(DecodeError::InvalidValue),
2543 impl Writeable for WarningMessage {
2544 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2545 self.channel_id.write(w)?;
2546 (self.data.len() as u16).write(w)?;
2547 w.write_all(self.data.as_bytes())?;
2552 impl Readable for WarningMessage {
2553 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2555 channel_id: Readable::read(r)?,
2557 let sz: usize = <u16 as Readable>::read(r)? as usize;
2558 let mut data = Vec::with_capacity(sz);
2560 r.read_exact(&mut data)?;
2561 match String::from_utf8(data) {
2563 Err(_) => return Err(DecodeError::InvalidValue),
2570 impl Writeable for UnsignedNodeAnnouncement {
2571 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2572 self.features.write(w)?;
2573 self.timestamp.write(w)?;
2574 self.node_id.write(w)?;
2575 w.write_all(&self.rgb)?;
2576 self.alias.write(w)?;
2578 let mut addr_len = 0;
2579 for addr in self.addresses.iter() {
2580 addr_len += 1 + addr.len();
2582 (addr_len + self.excess_address_data.len() as u16).write(w)?;
2583 for addr in self.addresses.iter() {
2586 w.write_all(&self.excess_address_data[..])?;
2587 w.write_all(&self.excess_data[..])?;
2592 impl Readable for UnsignedNodeAnnouncement {
2593 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2594 let features: NodeFeatures = Readable::read(r)?;
2595 let timestamp: u32 = Readable::read(r)?;
2596 let node_id: NodeId = Readable::read(r)?;
2597 let mut rgb = [0; 3];
2598 r.read_exact(&mut rgb)?;
2599 let alias: NodeAlias = Readable::read(r)?;
2601 let addr_len: u16 = Readable::read(r)?;
2602 let mut addresses: Vec<SocketAddress> = Vec::new();
2603 let mut addr_readpos = 0;
2604 let mut excess = false;
2605 let mut excess_byte = 0;
2607 if addr_len <= addr_readpos { break; }
2608 match Readable::read(r) {
2610 if addr_len < addr_readpos + 1 + addr.len() {
2611 return Err(DecodeError::BadLengthDescriptor);
2613 addr_readpos += (1 + addr.len()) as u16;
2614 addresses.push(addr);
2616 Ok(Err(unknown_descriptor)) => {
2618 excess_byte = unknown_descriptor;
2621 Err(DecodeError::ShortRead) => return Err(DecodeError::BadLengthDescriptor),
2622 Err(e) => return Err(e),
2626 let mut excess_data = vec![];
2627 let excess_address_data = if addr_readpos < addr_len {
2628 let mut excess_address_data = vec![0; (addr_len - addr_readpos) as usize];
2629 r.read_exact(&mut excess_address_data[if excess { 1 } else { 0 }..])?;
2631 excess_address_data[0] = excess_byte;
2636 excess_data.push(excess_byte);
2640 excess_data.extend(read_to_end(r)?.iter());
2641 Ok(UnsignedNodeAnnouncement {
2648 excess_address_data,
2654 impl_writeable!(NodeAnnouncement, {
2659 impl Readable for QueryShortChannelIds {
2660 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2661 let chain_hash: ChainHash = Readable::read(r)?;
2663 let encoding_len: u16 = Readable::read(r)?;
2664 let encoding_type: u8 = Readable::read(r)?;
2666 // Must be encoding_type=0 uncompressed serialization. We do not
2667 // support encoding_type=1 zlib serialization.
2668 if encoding_type != EncodingType::Uncompressed as u8 {
2669 return Err(DecodeError::UnsupportedCompression);
2672 // We expect the encoding_len to always includes the 1-byte
2673 // encoding_type and that short_channel_ids are 8-bytes each
2674 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2675 return Err(DecodeError::InvalidValue);
2678 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2679 // less the 1-byte encoding_type
2680 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2681 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2682 for _ in 0..short_channel_id_count {
2683 short_channel_ids.push(Readable::read(r)?);
2686 Ok(QueryShortChannelIds {
2693 impl Writeable for QueryShortChannelIds {
2694 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2695 // Calculated from 1-byte encoding_type plus 8-bytes per short_channel_id
2696 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2698 self.chain_hash.write(w)?;
2699 encoding_len.write(w)?;
2701 // We only support type=0 uncompressed serialization
2702 (EncodingType::Uncompressed as u8).write(w)?;
2704 for scid in self.short_channel_ids.iter() {
2712 impl_writeable_msg!(ReplyShortChannelIdsEnd, {
2717 impl QueryChannelRange {
2718 /// Calculates the overflow safe ending block height for the query.
2720 /// Overflow returns `0xffffffff`, otherwise returns `first_blocknum + number_of_blocks`.
2721 pub fn end_blocknum(&self) -> u32 {
2722 match self.first_blocknum.checked_add(self.number_of_blocks) {
2723 Some(block) => block,
2724 None => u32::max_value(),
2729 impl_writeable_msg!(QueryChannelRange, {
2735 impl Readable for ReplyChannelRange {
2736 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2737 let chain_hash: ChainHash = Readable::read(r)?;
2738 let first_blocknum: u32 = Readable::read(r)?;
2739 let number_of_blocks: u32 = Readable::read(r)?;
2740 let sync_complete: bool = Readable::read(r)?;
2742 let encoding_len: u16 = Readable::read(r)?;
2743 let encoding_type: u8 = Readable::read(r)?;
2745 // Must be encoding_type=0 uncompressed serialization. We do not
2746 // support encoding_type=1 zlib serialization.
2747 if encoding_type != EncodingType::Uncompressed as u8 {
2748 return Err(DecodeError::UnsupportedCompression);
2751 // We expect the encoding_len to always includes the 1-byte
2752 // encoding_type and that short_channel_ids are 8-bytes each
2753 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2754 return Err(DecodeError::InvalidValue);
2757 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2758 // less the 1-byte encoding_type
2759 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2760 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2761 for _ in 0..short_channel_id_count {
2762 short_channel_ids.push(Readable::read(r)?);
2765 Ok(ReplyChannelRange {
2775 impl Writeable for ReplyChannelRange {
2776 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2777 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2778 self.chain_hash.write(w)?;
2779 self.first_blocknum.write(w)?;
2780 self.number_of_blocks.write(w)?;
2781 self.sync_complete.write(w)?;
2783 encoding_len.write(w)?;
2784 (EncodingType::Uncompressed as u8).write(w)?;
2785 for scid in self.short_channel_ids.iter() {
2793 impl_writeable_msg!(GossipTimestampFilter, {
2801 use std::convert::TryFrom;
2802 use bitcoin::{Transaction, TxIn, ScriptBuf, Sequence, Witness, TxOut};
2803 use hex::DisplayHex;
2804 use crate::ln::{PaymentPreimage, PaymentHash, PaymentSecret};
2805 use crate::ln::ChannelId;
2806 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
2807 use crate::ln::msgs::{self, FinalOnionHopData, OnionErrorPacket};
2808 use crate::ln::msgs::SocketAddress;
2809 use crate::routing::gossip::{NodeAlias, NodeId};
2810 use crate::util::ser::{Writeable, Readable, ReadableArgs, Hostname, TransactionU16LenLimited};
2811 use crate::util::test_utils;
2813 use bitcoin::hashes::hex::FromHex;
2814 use bitcoin::address::Address;
2815 use bitcoin::network::constants::Network;
2816 use bitcoin::blockdata::constants::ChainHash;
2817 use bitcoin::blockdata::script::Builder;
2818 use bitcoin::blockdata::opcodes;
2819 use bitcoin::hash_types::Txid;
2820 use bitcoin::locktime::absolute::LockTime;
2822 use bitcoin::secp256k1::{PublicKey,SecretKey};
2823 use bitcoin::secp256k1::{Secp256k1, Message};
2825 use crate::io::{self, Cursor};
2826 use crate::prelude::*;
2827 use core::str::FromStr;
2828 use crate::chain::transaction::OutPoint;
2830 #[cfg(feature = "std")]
2831 use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6, ToSocketAddrs};
2832 #[cfg(feature = "std")]
2833 use crate::ln::msgs::SocketAddressParseError;
2836 fn encoding_channel_reestablish() {
2838 let secp_ctx = Secp256k1::new();
2839 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&<Vec<u8>>::from_hex("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2842 let cr = msgs::ChannelReestablish {
2843 channel_id: ChannelId::from_bytes([4, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0]),
2844 next_local_commitment_number: 3,
2845 next_remote_commitment_number: 4,
2846 your_last_per_commitment_secret: [9;32],
2847 my_current_per_commitment_point: public_key,
2848 next_funding_txid: None,
2851 let encoded_value = cr.encode();
2855 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
2856 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2857 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2858 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
2859 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
2865 fn encoding_channel_reestablish_with_next_funding_txid() {
2867 let secp_ctx = Secp256k1::new();
2868 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&<Vec<u8>>::from_hex("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2871 let cr = msgs::ChannelReestablish {
2872 channel_id: ChannelId::from_bytes([4, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0]),
2873 next_local_commitment_number: 3,
2874 next_remote_commitment_number: 4,
2875 your_last_per_commitment_secret: [9;32],
2876 my_current_per_commitment_point: public_key,
2877 next_funding_txid: Some(Txid::from_raw_hash(bitcoin::hashes::Hash::from_slice(&[
2878 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,
2882 let encoded_value = cr.encode();
2886 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
2887 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2888 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2889 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
2890 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
2891 0, // Type (next_funding_txid)
2893 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
2898 macro_rules! get_keys_from {
2899 ($slice: expr, $secp_ctx: expr) => {
2901 let privkey = SecretKey::from_slice(&<Vec<u8>>::from_hex($slice).unwrap()[..]).unwrap();
2902 let pubkey = PublicKey::from_secret_key(&$secp_ctx, &privkey);
2908 macro_rules! get_sig_on {
2909 ($privkey: expr, $ctx: expr, $string: expr) => {
2911 let sighash = Message::from_slice(&$string.into_bytes()[..]).unwrap();
2912 $ctx.sign_ecdsa(&sighash, &$privkey)
2918 fn encoding_announcement_signatures() {
2919 let secp_ctx = Secp256k1::new();
2920 let (privkey, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2921 let sig_1 = get_sig_on!(privkey, secp_ctx, String::from("01010101010101010101010101010101"));
2922 let sig_2 = get_sig_on!(privkey, secp_ctx, String::from("02020202020202020202020202020202"));
2923 let announcement_signatures = msgs::AnnouncementSignatures {
2924 channel_id: ChannelId::from_bytes([4, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0]),
2925 short_channel_id: 2316138423780173,
2926 node_signature: sig_1,
2927 bitcoin_signature: sig_2,
2930 let encoded_value = announcement_signatures.encode();
2931 assert_eq!(encoded_value, <Vec<u8>>::from_hex("040000000000000005000000000000000600000000000000070000000000000000083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073acf9953cef4700860f5967838eba2bae89288ad188ebf8b20bf995c3ea53a26df1876d0a3a0e13172ba286a673140190c02ba9da60a2e43a745188c8a83c7f3ef").unwrap());
2934 fn do_encoding_channel_announcement(unknown_features_bits: bool, excess_data: bool) {
2935 let secp_ctx = Secp256k1::new();
2936 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2937 let (privkey_2, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2938 let (privkey_3, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2939 let (privkey_4, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2940 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2941 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
2942 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
2943 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
2944 let mut features = ChannelFeatures::empty();
2945 if unknown_features_bits {
2946 features = ChannelFeatures::from_le_bytes(vec![0xFF, 0xFF]);
2948 let unsigned_channel_announcement = msgs::UnsignedChannelAnnouncement {
2950 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
2951 short_channel_id: 2316138423780173,
2952 node_id_1: NodeId::from_pubkey(&pubkey_1),
2953 node_id_2: NodeId::from_pubkey(&pubkey_2),
2954 bitcoin_key_1: NodeId::from_pubkey(&pubkey_3),
2955 bitcoin_key_2: NodeId::from_pubkey(&pubkey_4),
2956 excess_data: if excess_data { vec![10, 0, 0, 20, 0, 0, 30, 0, 0, 40] } else { Vec::new() },
2958 let channel_announcement = msgs::ChannelAnnouncement {
2959 node_signature_1: sig_1,
2960 node_signature_2: sig_2,
2961 bitcoin_signature_1: sig_3,
2962 bitcoin_signature_2: sig_4,
2963 contents: unsigned_channel_announcement,
2965 let encoded_value = channel_announcement.encode();
2966 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a1735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap();
2967 if unknown_features_bits {
2968 target_value.append(&mut <Vec<u8>>::from_hex("0002ffff").unwrap());
2970 target_value.append(&mut <Vec<u8>>::from_hex("0000").unwrap());
2972 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
2973 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
2975 target_value.append(&mut <Vec<u8>>::from_hex("0a00001400001e000028").unwrap());
2977 assert_eq!(encoded_value, target_value);
2981 fn encoding_channel_announcement() {
2982 do_encoding_channel_announcement(true, false);
2983 do_encoding_channel_announcement(false, true);
2984 do_encoding_channel_announcement(false, false);
2985 do_encoding_channel_announcement(true, true);
2988 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) {
2989 let secp_ctx = Secp256k1::new();
2990 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2991 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2992 let features = if unknown_features_bits {
2993 NodeFeatures::from_le_bytes(vec![0xFF, 0xFF])
2995 // Set to some features we may support
2996 NodeFeatures::from_le_bytes(vec![2 | 1 << 5])
2998 let mut addresses = Vec::new();
3000 addresses.push(SocketAddress::TcpIpV4 {
3001 addr: [255, 254, 253, 252],
3006 addresses.push(SocketAddress::TcpIpV6 {
3007 addr: [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240],
3012 addresses.push(msgs::SocketAddress::OnionV2(
3013 [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 38, 7]
3017 addresses.push(msgs::SocketAddress::OnionV3 {
3018 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],
3025 addresses.push(SocketAddress::Hostname {
3026 hostname: Hostname::try_from(String::from("host")).unwrap(),
3030 let mut addr_len = 0;
3031 for addr in &addresses {
3032 addr_len += addr.len() + 1;
3034 let unsigned_node_announcement = msgs::UnsignedNodeAnnouncement {
3036 timestamp: 20190119,
3037 node_id: NodeId::from_pubkey(&pubkey_1),
3039 alias: NodeAlias([16;32]),
3041 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() },
3042 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() },
3044 addr_len += unsigned_node_announcement.excess_address_data.len() as u16;
3045 let node_announcement = msgs::NodeAnnouncement {
3047 contents: unsigned_node_announcement,
3049 let encoded_value = node_announcement.encode();
3050 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3051 if unknown_features_bits {
3052 target_value.append(&mut <Vec<u8>>::from_hex("0002ffff").unwrap());
3054 target_value.append(&mut <Vec<u8>>::from_hex("000122").unwrap());
3056 target_value.append(&mut <Vec<u8>>::from_hex("013413a7031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f2020201010101010101010101010101010101010101010101010101010101010101010").unwrap());
3057 target_value.append(&mut vec![(addr_len >> 8) as u8, addr_len as u8]);
3059 target_value.append(&mut <Vec<u8>>::from_hex("01fffefdfc2607").unwrap());
3062 target_value.append(&mut <Vec<u8>>::from_hex("02fffefdfcfbfaf9f8f7f6f5f4f3f2f1f02607").unwrap());
3065 target_value.append(&mut <Vec<u8>>::from_hex("03fffefdfcfbfaf9f8f7f62607").unwrap());
3068 target_value.append(&mut <Vec<u8>>::from_hex("04fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0efeeedecebeae9e8e7e6e5e4e3e2e1e00020102607").unwrap());
3071 target_value.append(&mut <Vec<u8>>::from_hex("0504686f73742607").unwrap());
3073 if excess_address_data {
3074 target_value.append(&mut <Vec<u8>>::from_hex("216c280b5395a2546e7e4b2663e04f811622f15a4f92e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d269").unwrap());
3077 target_value.append(&mut <Vec<u8>>::from_hex("3b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
3079 assert_eq!(encoded_value, target_value);
3083 fn encoding_node_announcement() {
3084 do_encoding_node_announcement(true, true, true, true, true, true, true, true);
3085 do_encoding_node_announcement(false, false, false, false, false, false, false, false);
3086 do_encoding_node_announcement(false, true, false, false, false, false, false, false);
3087 do_encoding_node_announcement(false, false, true, false, false, false, false, false);
3088 do_encoding_node_announcement(false, false, false, true, false, false, false, false);
3089 do_encoding_node_announcement(false, false, false, false, true, false, false, false);
3090 do_encoding_node_announcement(false, false, false, false, false, true, false, false);
3091 do_encoding_node_announcement(false, false, false, false, false, false, true, false);
3092 do_encoding_node_announcement(false, true, false, true, false, false, true, false);
3093 do_encoding_node_announcement(false, false, true, false, true, false, false, false);
3096 fn do_encoding_channel_update(direction: bool, disable: bool, excess_data: bool) {
3097 let secp_ctx = Secp256k1::new();
3098 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3099 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3100 let unsigned_channel_update = msgs::UnsignedChannelUpdate {
3101 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3102 short_channel_id: 2316138423780173,
3103 timestamp: 20190119,
3104 flags: if direction { 1 } else { 0 } | if disable { 1 << 1 } else { 0 },
3105 cltv_expiry_delta: 144,
3106 htlc_minimum_msat: 1000000,
3107 htlc_maximum_msat: 131355275467161,
3108 fee_base_msat: 10000,
3109 fee_proportional_millionths: 20,
3110 excess_data: if excess_data { vec![0, 0, 0, 0, 59, 154, 202, 0] } else { Vec::new() }
3112 let channel_update = msgs::ChannelUpdate {
3114 contents: unsigned_channel_update
3116 let encoded_value = channel_update.encode();
3117 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3118 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3119 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d013413a7").unwrap());
3120 target_value.append(&mut <Vec<u8>>::from_hex("01").unwrap());
3121 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3123 let flag = target_value.last_mut().unwrap();
3127 let flag = target_value.last_mut().unwrap();
3128 *flag = *flag | 1 << 1;
3130 target_value.append(&mut <Vec<u8>>::from_hex("009000000000000f42400000271000000014").unwrap());
3131 target_value.append(&mut <Vec<u8>>::from_hex("0000777788889999").unwrap());
3133 target_value.append(&mut <Vec<u8>>::from_hex("000000003b9aca00").unwrap());
3135 assert_eq!(encoded_value, target_value);
3139 fn encoding_channel_update() {
3140 do_encoding_channel_update(false, false, false);
3141 do_encoding_channel_update(false, false, true);
3142 do_encoding_channel_update(true, false, false);
3143 do_encoding_channel_update(true, false, true);
3144 do_encoding_channel_update(false, true, false);
3145 do_encoding_channel_update(false, true, true);
3146 do_encoding_channel_update(true, true, false);
3147 do_encoding_channel_update(true, true, true);
3150 fn do_encoding_open_channel(random_bit: bool, shutdown: bool, incl_chan_type: bool) {
3151 let secp_ctx = Secp256k1::new();
3152 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3153 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3154 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3155 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3156 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3157 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3158 let open_channel = msgs::OpenChannel {
3159 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3160 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3161 funding_satoshis: 1311768467284833366,
3162 push_msat: 2536655962884945560,
3163 dust_limit_satoshis: 3608586615801332854,
3164 max_htlc_value_in_flight_msat: 8517154655701053848,
3165 channel_reserve_satoshis: 8665828695742877976,
3166 htlc_minimum_msat: 2316138423780173,
3167 feerate_per_kw: 821716,
3168 to_self_delay: 49340,
3169 max_accepted_htlcs: 49340,
3170 funding_pubkey: pubkey_1,
3171 revocation_basepoint: pubkey_2,
3172 payment_point: pubkey_3,
3173 delayed_payment_basepoint: pubkey_4,
3174 htlc_basepoint: pubkey_5,
3175 first_per_commitment_point: pubkey_6,
3176 channel_flags: if random_bit { 1 << 5 } else { 0 },
3177 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3178 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3180 let encoded_value = open_channel.encode();
3181 let mut target_value = Vec::new();
3182 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3183 target_value.append(&mut <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202021234567890123456233403289122369832144668701144767633030896203198784335490624111800083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3185 target_value.append(&mut <Vec<u8>>::from_hex("20").unwrap());
3187 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3190 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3193 target_value.append(&mut <Vec<u8>>::from_hex("0100").unwrap());
3195 assert_eq!(encoded_value, target_value);
3199 fn encoding_open_channel() {
3200 do_encoding_open_channel(false, false, false);
3201 do_encoding_open_channel(false, false, true);
3202 do_encoding_open_channel(false, true, false);
3203 do_encoding_open_channel(false, true, true);
3204 do_encoding_open_channel(true, false, false);
3205 do_encoding_open_channel(true, false, true);
3206 do_encoding_open_channel(true, true, false);
3207 do_encoding_open_channel(true, true, true);
3210 fn do_encoding_open_channelv2(random_bit: bool, shutdown: bool, incl_chan_type: bool, require_confirmed_inputs: bool) {
3211 let secp_ctx = Secp256k1::new();
3212 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3213 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3214 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3215 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3216 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3217 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3218 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3219 let open_channelv2 = msgs::OpenChannelV2 {
3220 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3221 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3222 funding_feerate_sat_per_1000_weight: 821716,
3223 commitment_feerate_sat_per_1000_weight: 821716,
3224 funding_satoshis: 1311768467284833366,
3225 dust_limit_satoshis: 3608586615801332854,
3226 max_htlc_value_in_flight_msat: 8517154655701053848,
3227 htlc_minimum_msat: 2316138423780173,
3228 to_self_delay: 49340,
3229 max_accepted_htlcs: 49340,
3230 locktime: 305419896,
3231 funding_pubkey: pubkey_1,
3232 revocation_basepoint: pubkey_2,
3233 payment_basepoint: pubkey_3,
3234 delayed_payment_basepoint: pubkey_4,
3235 htlc_basepoint: pubkey_5,
3236 first_per_commitment_point: pubkey_6,
3237 second_per_commitment_point: pubkey_7,
3238 channel_flags: if random_bit { 1 << 5 } else { 0 },
3239 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3240 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3241 require_confirmed_inputs: if require_confirmed_inputs { Some(()) } else { None },
3243 let encoded_value = open_channelv2.encode();
3244 let mut target_value = Vec::new();
3245 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3246 target_value.append(&mut <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap());
3247 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap());
3248 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap());
3249 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap());
3250 target_value.append(&mut <Vec<u8>>::from_hex("3214466870114476").unwrap());
3251 target_value.append(&mut <Vec<u8>>::from_hex("7633030896203198").unwrap());
3252 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d").unwrap());
3253 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap());
3254 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap());
3255 target_value.append(&mut <Vec<u8>>::from_hex("12345678").unwrap());
3256 target_value.append(&mut <Vec<u8>>::from_hex("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap());
3257 target_value.append(&mut <Vec<u8>>::from_hex("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap());
3258 target_value.append(&mut <Vec<u8>>::from_hex("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap());
3259 target_value.append(&mut <Vec<u8>>::from_hex("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
3260 target_value.append(&mut <Vec<u8>>::from_hex("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap());
3261 target_value.append(&mut <Vec<u8>>::from_hex("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3262 target_value.append(&mut <Vec<u8>>::from_hex("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap());
3265 target_value.append(&mut <Vec<u8>>::from_hex("20").unwrap());
3267 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3270 target_value.append(&mut <Vec<u8>>::from_hex("001b").unwrap()); // Type 0 + Length 27
3271 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3274 target_value.append(&mut <Vec<u8>>::from_hex("0100").unwrap());
3276 if require_confirmed_inputs {
3277 target_value.append(&mut <Vec<u8>>::from_hex("0200").unwrap());
3279 assert_eq!(encoded_value, target_value);
3283 fn encoding_open_channelv2() {
3284 do_encoding_open_channelv2(false, false, false, false);
3285 do_encoding_open_channelv2(false, false, false, true);
3286 do_encoding_open_channelv2(false, false, true, false);
3287 do_encoding_open_channelv2(false, false, true, true);
3288 do_encoding_open_channelv2(false, true, false, false);
3289 do_encoding_open_channelv2(false, true, false, true);
3290 do_encoding_open_channelv2(false, true, true, false);
3291 do_encoding_open_channelv2(false, true, true, true);
3292 do_encoding_open_channelv2(true, false, false, false);
3293 do_encoding_open_channelv2(true, false, false, true);
3294 do_encoding_open_channelv2(true, false, true, false);
3295 do_encoding_open_channelv2(true, false, true, true);
3296 do_encoding_open_channelv2(true, true, false, false);
3297 do_encoding_open_channelv2(true, true, false, true);
3298 do_encoding_open_channelv2(true, true, true, false);
3299 do_encoding_open_channelv2(true, true, true, true);
3302 fn do_encoding_accept_channel(shutdown: bool) {
3303 let secp_ctx = Secp256k1::new();
3304 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3305 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3306 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3307 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3308 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3309 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3310 let accept_channel = msgs::AcceptChannel {
3311 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3312 dust_limit_satoshis: 1311768467284833366,
3313 max_htlc_value_in_flight_msat: 2536655962884945560,
3314 channel_reserve_satoshis: 3608586615801332854,
3315 htlc_minimum_msat: 2316138423780173,
3316 minimum_depth: 821716,
3317 to_self_delay: 49340,
3318 max_accepted_htlcs: 49340,
3319 funding_pubkey: pubkey_1,
3320 revocation_basepoint: pubkey_2,
3321 payment_point: pubkey_3,
3322 delayed_payment_basepoint: pubkey_4,
3323 htlc_basepoint: pubkey_5,
3324 first_per_commitment_point: pubkey_6,
3325 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3328 next_local_nonce: None,
3330 let encoded_value = accept_channel.encode();
3331 let mut target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020212345678901234562334032891223698321446687011447600083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap();
3333 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3335 assert_eq!(encoded_value, target_value);
3339 fn encoding_accept_channel() {
3340 do_encoding_accept_channel(false);
3341 do_encoding_accept_channel(true);
3344 fn do_encoding_accept_channelv2(shutdown: bool) {
3345 let secp_ctx = Secp256k1::new();
3346 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3347 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3348 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3349 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3350 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3351 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3352 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3353 let accept_channelv2 = msgs::AcceptChannelV2 {
3354 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3355 funding_satoshis: 1311768467284833366,
3356 dust_limit_satoshis: 1311768467284833366,
3357 max_htlc_value_in_flight_msat: 2536655962884945560,
3358 htlc_minimum_msat: 2316138423780173,
3359 minimum_depth: 821716,
3360 to_self_delay: 49340,
3361 max_accepted_htlcs: 49340,
3362 funding_pubkey: pubkey_1,
3363 revocation_basepoint: pubkey_2,
3364 payment_basepoint: pubkey_3,
3365 delayed_payment_basepoint: pubkey_4,
3366 htlc_basepoint: pubkey_5,
3367 first_per_commitment_point: pubkey_6,
3368 second_per_commitment_point: pubkey_7,
3369 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3371 require_confirmed_inputs: None,
3373 let encoded_value = accept_channelv2.encode();
3374 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // temporary_channel_id
3375 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap()); // funding_satoshis
3376 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap()); // dust_limit_satoshis
3377 target_value.append(&mut <Vec<u8>>::from_hex("2334032891223698").unwrap()); // max_htlc_value_in_flight_msat
3378 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d").unwrap()); // htlc_minimum_msat
3379 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap()); // minimum_depth
3380 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap()); // to_self_delay
3381 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap()); // max_accepted_htlcs
3382 target_value.append(&mut <Vec<u8>>::from_hex("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap()); // funding_pubkey
3383 target_value.append(&mut <Vec<u8>>::from_hex("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap()); // revocation_basepoint
3384 target_value.append(&mut <Vec<u8>>::from_hex("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap()); // payment_basepoint
3385 target_value.append(&mut <Vec<u8>>::from_hex("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap()); // delayed_payment_basepoint
3386 target_value.append(&mut <Vec<u8>>::from_hex("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap()); // htlc_basepoint
3387 target_value.append(&mut <Vec<u8>>::from_hex("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap()); // first_per_commitment_point
3388 target_value.append(&mut <Vec<u8>>::from_hex("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap()); // second_per_commitment_point
3390 target_value.append(&mut <Vec<u8>>::from_hex("001b").unwrap()); // Type 0 + Length 27
3391 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3393 assert_eq!(encoded_value, target_value);
3397 fn encoding_accept_channelv2() {
3398 do_encoding_accept_channelv2(false);
3399 do_encoding_accept_channelv2(true);
3403 fn encoding_funding_created() {
3404 let secp_ctx = Secp256k1::new();
3405 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3406 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3407 let funding_created = msgs::FundingCreated {
3408 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3409 funding_txid: Txid::from_str("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3410 funding_output_index: 255,
3413 partial_signature_with_nonce: None,
3415 next_local_nonce: None,
3417 let encoded_value = funding_created.encode();
3418 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202026e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c200ffd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3419 assert_eq!(encoded_value, target_value);
3423 fn encoding_funding_signed() {
3424 let secp_ctx = Secp256k1::new();
3425 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3426 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3427 let funding_signed = msgs::FundingSigned {
3428 channel_id: ChannelId::from_bytes([2; 32]),
3431 partial_signature_with_nonce: None,
3433 let encoded_value = funding_signed.encode();
3434 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3435 assert_eq!(encoded_value, target_value);
3439 fn encoding_channel_ready() {
3440 let secp_ctx = Secp256k1::new();
3441 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3442 let channel_ready = msgs::ChannelReady {
3443 channel_id: ChannelId::from_bytes([2; 32]),
3444 next_per_commitment_point: pubkey_1,
3445 short_channel_id_alias: None,
3447 let encoded_value = channel_ready.encode();
3448 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3449 assert_eq!(encoded_value, target_value);
3453 fn encoding_splice() {
3454 let secp_ctx = Secp256k1::new();
3455 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3456 let splice = msgs::Splice {
3457 chain_hash: ChainHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
3458 channel_id: ChannelId::from_bytes([2; 32]),
3459 relative_satoshis: 123456,
3460 funding_feerate_perkw: 2000,
3462 funding_pubkey: pubkey_1,
3464 let encoded_value = splice.encode();
3465 assert_eq!(encoded_value.as_hex().to_string(), "02020202020202020202020202020202020202020202020202020202020202026fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000000000000001e240000007d000000000031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f");
3469 fn encoding_stfu() {
3470 let stfu = msgs::Stfu {
3471 channel_id: ChannelId::from_bytes([2; 32]),
3474 let encoded_value = stfu.encode();
3475 assert_eq!(encoded_value.as_hex().to_string(), "020202020202020202020202020202020202020202020202020202020202020201");
3479 fn encoding_splice_ack() {
3480 let secp_ctx = Secp256k1::new();
3481 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3482 let splice = msgs::SpliceAck {
3483 chain_hash: ChainHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
3484 channel_id: ChannelId::from_bytes([2; 32]),
3485 relative_satoshis: 123456,
3486 funding_pubkey: pubkey_1,
3488 let encoded_value = splice.encode();
3489 assert_eq!(encoded_value.as_hex().to_string(), "02020202020202020202020202020202020202020202020202020202020202026fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000000000000001e240031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f");
3493 fn encoding_splice_locked() {
3494 let splice = msgs::SpliceLocked {
3495 channel_id: ChannelId::from_bytes([2; 32]),
3497 let encoded_value = splice.encode();
3498 assert_eq!(encoded_value.as_hex().to_string(), "0202020202020202020202020202020202020202020202020202020202020202");
3502 fn encoding_tx_add_input() {
3503 let tx_add_input = msgs::TxAddInput {
3504 channel_id: ChannelId::from_bytes([2; 32]),
3505 serial_id: 4886718345,
3506 prevtx: TransactionU16LenLimited::new(Transaction {
3508 lock_time: LockTime::ZERO,
3510 previous_output: OutPoint { txid: Txid::from_str("305bab643ee297b8b6b76b320792c8223d55082122cb606bf89382146ced9c77").unwrap(), index: 2 }.into_bitcoin_outpoint(),
3511 script_sig: ScriptBuf::new(),
3512 sequence: Sequence(0xfffffffd),
3513 witness: Witness::from_slice(&vec![
3514 <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3515 <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3520 script_pubkey: Address::from_str("bc1qzlffunw52jav8vwdu5x3jfk6sr8u22rmq3xzw2").unwrap().payload.script_pubkey(),
3524 script_pubkey: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().payload.script_pubkey(),
3528 prevtx_out: 305419896,
3529 sequence: 305419896,
3531 let encoded_value = tx_add_input.encode();
3532 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000000012345678900de02000000000101779ced6c148293f86b60cb222108553d22c89207326bb7b6b897e23e64ab5b300200000000fdffffff0236dbc1000000000016001417d29e4dd454bac3b1cde50d1926da80cfc5287b9cbd03000000000016001436ec78d514df462da95e6a00c24daa8915362d420247304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701210301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944000000001234567812345678").unwrap();
3533 assert_eq!(encoded_value, target_value);
3537 fn encoding_tx_add_output() {
3538 let tx_add_output = msgs::TxAddOutput {
3539 channel_id: ChannelId::from_bytes([2; 32]),
3540 serial_id: 4886718345,
3542 script: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().payload.script_pubkey(),
3544 let encoded_value = tx_add_output.encode();
3545 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000000012345678900000001234567890016001436ec78d514df462da95e6a00c24daa8915362d42").unwrap();
3546 assert_eq!(encoded_value, target_value);
3550 fn encoding_tx_remove_input() {
3551 let tx_remove_input = msgs::TxRemoveInput {
3552 channel_id: ChannelId::from_bytes([2; 32]),
3553 serial_id: 4886718345,
3555 let encoded_value = tx_remove_input.encode();
3556 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3557 assert_eq!(encoded_value, target_value);
3561 fn encoding_tx_remove_output() {
3562 let tx_remove_output = msgs::TxRemoveOutput {
3563 channel_id: ChannelId::from_bytes([2; 32]),
3564 serial_id: 4886718345,
3566 let encoded_value = tx_remove_output.encode();
3567 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3568 assert_eq!(encoded_value, target_value);
3572 fn encoding_tx_complete() {
3573 let tx_complete = msgs::TxComplete {
3574 channel_id: ChannelId::from_bytes([2; 32]),
3576 let encoded_value = tx_complete.encode();
3577 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3578 assert_eq!(encoded_value, target_value);
3582 fn encoding_tx_signatures() {
3583 let tx_signatures = msgs::TxSignatures {
3584 channel_id: ChannelId::from_bytes([2; 32]),
3585 tx_hash: Txid::from_str("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3587 Witness::from_slice(&vec![
3588 <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3589 <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3590 Witness::from_slice(&vec![
3591 <Vec<u8>>::from_hex("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap(),
3592 <Vec<u8>>::from_hex("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap()]),
3595 let encoded_value = tx_signatures.encode();
3596 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3597 target_value.append(&mut <Vec<u8>>::from_hex("6e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c2").unwrap()); // tx_hash (sha256) (big endian byte order)
3598 target_value.append(&mut <Vec<u8>>::from_hex("0002").unwrap()); // num_witnesses (u16)
3600 target_value.append(&mut <Vec<u8>>::from_hex("006b").unwrap()); // len of witness_data
3601 target_value.append(&mut <Vec<u8>>::from_hex("02").unwrap()); // num_witness_elements (VarInt)
3602 target_value.append(&mut <Vec<u8>>::from_hex("47").unwrap()); // len of witness element data (VarInt)
3603 target_value.append(&mut <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap());
3604 target_value.append(&mut <Vec<u8>>::from_hex("21").unwrap()); // len of witness element data (VarInt)
3605 target_value.append(&mut <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap());
3607 target_value.append(&mut <Vec<u8>>::from_hex("006c").unwrap()); // len of witness_data
3608 target_value.append(&mut <Vec<u8>>::from_hex("02").unwrap()); // num_witness_elements (VarInt)
3609 target_value.append(&mut <Vec<u8>>::from_hex("48").unwrap()); // len of witness element data (VarInt)
3610 target_value.append(&mut <Vec<u8>>::from_hex("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap());
3611 target_value.append(&mut <Vec<u8>>::from_hex("21").unwrap()); // len of witness element data (VarInt)
3612 target_value.append(&mut <Vec<u8>>::from_hex("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap());
3613 assert_eq!(encoded_value, target_value);
3616 fn do_encoding_tx_init_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3617 let tx_init_rbf = msgs::TxInitRbf {
3618 channel_id: ChannelId::from_bytes([2; 32]),
3619 locktime: 305419896,
3620 feerate_sat_per_1000_weight: 20190119,
3621 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3623 let encoded_value = tx_init_rbf.encode();
3624 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3625 target_value.append(&mut <Vec<u8>>::from_hex("12345678").unwrap()); // locktime
3626 target_value.append(&mut <Vec<u8>>::from_hex("013413a7").unwrap()); // feerate_sat_per_1000_weight
3627 if let Some((_, target)) = funding_value_with_hex_target {
3628 target_value.push(0x00); // Type
3629 target_value.push(target.len() as u8 / 2); // Length
3630 target_value.append(&mut <Vec<u8>>::from_hex(target).unwrap()); // Value (i64)
3632 assert_eq!(encoded_value, target_value);
3636 fn encoding_tx_init_rbf() {
3637 do_encoding_tx_init_rbf(Some((1311768467284833366, "1234567890123456")));
3638 do_encoding_tx_init_rbf(Some((13117684672, "000000030DDFFBC0")));
3639 do_encoding_tx_init_rbf(None);
3642 fn do_encoding_tx_ack_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3643 let tx_ack_rbf = msgs::TxAckRbf {
3644 channel_id: ChannelId::from_bytes([2; 32]),
3645 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3647 let encoded_value = tx_ack_rbf.encode();
3648 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3649 if let Some((_, target)) = funding_value_with_hex_target {
3650 target_value.push(0x00); // Type
3651 target_value.push(target.len() as u8 / 2); // Length
3652 target_value.append(&mut <Vec<u8>>::from_hex(target).unwrap()); // Value (i64)
3654 assert_eq!(encoded_value, target_value);
3658 fn encoding_tx_ack_rbf() {
3659 do_encoding_tx_ack_rbf(Some((1311768467284833366, "1234567890123456")));
3660 do_encoding_tx_ack_rbf(Some((13117684672, "000000030DDFFBC0")));
3661 do_encoding_tx_ack_rbf(None);
3665 fn encoding_tx_abort() {
3666 let tx_abort = msgs::TxAbort {
3667 channel_id: ChannelId::from_bytes([2; 32]),
3668 data: <Vec<u8>>::from_hex("54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap(),
3670 let encoded_value = tx_abort.encode();
3671 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202002C54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap();
3672 assert_eq!(encoded_value, target_value);
3675 fn do_encoding_shutdown(script_type: u8) {
3676 let secp_ctx = Secp256k1::new();
3677 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3678 let script = Builder::new().push_opcode(opcodes::OP_TRUE).into_script();
3679 let shutdown = msgs::Shutdown {
3680 channel_id: ChannelId::from_bytes([2; 32]),
3682 if script_type == 1 { Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey() }
3683 else if script_type == 2 { Address::p2sh(&script, Network::Testnet).unwrap().script_pubkey() }
3684 else if script_type == 3 { Address::p2wpkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).unwrap().script_pubkey() }
3685 else { Address::p2wsh(&script, Network::Testnet).script_pubkey() },
3687 let encoded_value = shutdown.encode();
3688 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3689 if script_type == 1 {
3690 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3691 } else if script_type == 2 {
3692 target_value.append(&mut <Vec<u8>>::from_hex("0017a914da1745e9b549bd0bfa1a569971c77eba30cd5a4b87").unwrap());
3693 } else if script_type == 3 {
3694 target_value.append(&mut <Vec<u8>>::from_hex("0016001479b000887626b294a914501a4cd226b58b235983").unwrap());
3695 } else if script_type == 4 {
3696 target_value.append(&mut <Vec<u8>>::from_hex("002200204ae81572f06e1b88fd5ced7a1a000945432e83e1551e6f721ee9c00b8cc33260").unwrap());
3698 assert_eq!(encoded_value, target_value);
3702 fn encoding_shutdown() {
3703 do_encoding_shutdown(1);
3704 do_encoding_shutdown(2);
3705 do_encoding_shutdown(3);
3706 do_encoding_shutdown(4);
3710 fn encoding_closing_signed() {
3711 let secp_ctx = Secp256k1::new();
3712 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3713 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3714 let closing_signed = msgs::ClosingSigned {
3715 channel_id: ChannelId::from_bytes([2; 32]),
3716 fee_satoshis: 2316138423780173,
3720 let encoded_value = closing_signed.encode();
3721 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3722 assert_eq!(encoded_value, target_value);
3723 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value)).unwrap(), closing_signed);
3725 let closing_signed_with_range = msgs::ClosingSigned {
3726 channel_id: ChannelId::from_bytes([2; 32]),
3727 fee_satoshis: 2316138423780173,
3729 fee_range: Some(msgs::ClosingSignedFeeRange {
3730 min_fee_satoshis: 0xdeadbeef,
3731 max_fee_satoshis: 0x1badcafe01234567,
3734 let encoded_value_with_range = closing_signed_with_range.encode();
3735 let target_value_with_range = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a011000000000deadbeef1badcafe01234567").unwrap();
3736 assert_eq!(encoded_value_with_range, target_value_with_range);
3737 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value_with_range)).unwrap(),
3738 closing_signed_with_range);
3742 fn encoding_update_add_htlc() {
3743 let secp_ctx = Secp256k1::new();
3744 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3745 let onion_routing_packet = msgs::OnionPacket {
3747 public_key: Ok(pubkey_1),
3748 hop_data: [1; 20*65],
3751 let update_add_htlc = msgs::UpdateAddHTLC {
3752 channel_id: ChannelId::from_bytes([2; 32]),
3753 htlc_id: 2316138423780173,
3754 amount_msat: 3608586615801332854,
3755 payment_hash: PaymentHash([1; 32]),
3756 cltv_expiry: 821716,
3757 onion_routing_packet,
3758 skimmed_fee_msat: None,
3760 let encoded_value = update_add_htlc.encode();
3761 let target_value = <Vec<u8>>::from_hex("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").unwrap();
3762 assert_eq!(encoded_value, target_value);
3766 fn encoding_update_fulfill_htlc() {
3767 let update_fulfill_htlc = msgs::UpdateFulfillHTLC {
3768 channel_id: ChannelId::from_bytes([2; 32]),
3769 htlc_id: 2316138423780173,
3770 payment_preimage: PaymentPreimage([1; 32]),
3772 let encoded_value = update_fulfill_htlc.encode();
3773 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d0101010101010101010101010101010101010101010101010101010101010101").unwrap();
3774 assert_eq!(encoded_value, target_value);
3778 fn encoding_update_fail_htlc() {
3779 let reason = OnionErrorPacket {
3780 data: [1; 32].to_vec(),
3782 let update_fail_htlc = msgs::UpdateFailHTLC {
3783 channel_id: ChannelId::from_bytes([2; 32]),
3784 htlc_id: 2316138423780173,
3787 let encoded_value = update_fail_htlc.encode();
3788 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d00200101010101010101010101010101010101010101010101010101010101010101").unwrap();
3789 assert_eq!(encoded_value, target_value);
3793 fn encoding_update_fail_malformed_htlc() {
3794 let update_fail_malformed_htlc = msgs::UpdateFailMalformedHTLC {
3795 channel_id: ChannelId::from_bytes([2; 32]),
3796 htlc_id: 2316138423780173,
3797 sha256_of_onion: [1; 32],
3800 let encoded_value = update_fail_malformed_htlc.encode();
3801 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d010101010101010101010101010101010101010101010101010101010101010100ff").unwrap();
3802 assert_eq!(encoded_value, target_value);
3805 fn do_encoding_commitment_signed(htlcs: bool) {
3806 let secp_ctx = Secp256k1::new();
3807 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3808 let (privkey_2, _) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3809 let (privkey_3, _) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3810 let (privkey_4, _) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3811 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3812 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
3813 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
3814 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
3815 let commitment_signed = msgs::CommitmentSigned {
3816 channel_id: ChannelId::from_bytes([2; 32]),
3818 htlc_signatures: if htlcs { vec![sig_2, sig_3, sig_4] } else { Vec::new() },
3820 partial_signature_with_nonce: None,
3822 let encoded_value = commitment_signed.encode();
3823 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3825 target_value.append(&mut <Vec<u8>>::from_hex("00031735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
3827 target_value.append(&mut <Vec<u8>>::from_hex("0000").unwrap());
3829 assert_eq!(encoded_value, target_value);
3833 fn encoding_commitment_signed() {
3834 do_encoding_commitment_signed(true);
3835 do_encoding_commitment_signed(false);
3839 fn encoding_revoke_and_ack() {
3840 let secp_ctx = Secp256k1::new();
3841 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3842 let raa = msgs::RevokeAndACK {
3843 channel_id: ChannelId::from_bytes([2; 32]),
3844 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],
3845 next_per_commitment_point: pubkey_1,
3847 next_local_nonce: None,
3849 let encoded_value = raa.encode();
3850 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020101010101010101010101010101010101010101010101010101010101010101031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3851 assert_eq!(encoded_value, target_value);
3855 fn encoding_update_fee() {
3856 let update_fee = msgs::UpdateFee {
3857 channel_id: ChannelId::from_bytes([2; 32]),
3858 feerate_per_kw: 20190119,
3860 let encoded_value = update_fee.encode();
3861 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202013413a7").unwrap();
3862 assert_eq!(encoded_value, target_value);
3866 fn encoding_init() {
3867 let mainnet_hash = ChainHash::using_genesis_block(Network::Bitcoin);
3868 assert_eq!(msgs::Init {
3869 features: InitFeatures::from_le_bytes(vec![0xFF, 0xFF, 0xFF]),
3870 networks: Some(vec![mainnet_hash]),
3871 remote_network_address: None,
3872 }.encode(), <Vec<u8>>::from_hex("00023fff0003ffffff01206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3873 assert_eq!(msgs::Init {
3874 features: InitFeatures::from_le_bytes(vec![0xFF]),
3876 remote_network_address: None,
3877 }.encode(), <Vec<u8>>::from_hex("0001ff0001ff").unwrap());
3878 assert_eq!(msgs::Init {
3879 features: InitFeatures::from_le_bytes(vec![]),
3880 networks: Some(vec![mainnet_hash]),
3881 remote_network_address: None,
3882 }.encode(), <Vec<u8>>::from_hex("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3883 assert_eq!(msgs::Init {
3884 features: InitFeatures::from_le_bytes(vec![]),
3885 networks: Some(vec![ChainHash::from(&[1; 32]), ChainHash::from(&[2; 32])]),
3886 remote_network_address: None,
3887 }.encode(), <Vec<u8>>::from_hex("00000000014001010101010101010101010101010101010101010101010101010101010101010202020202020202020202020202020202020202020202020202020202020202").unwrap());
3888 let init_msg = msgs::Init { features: InitFeatures::from_le_bytes(vec![]),
3889 networks: Some(vec![mainnet_hash]),
3890 remote_network_address: Some(SocketAddress::TcpIpV4 {
3891 addr: [127, 0, 0, 1],
3895 let encoded_value = init_msg.encode();
3896 let target_value = <Vec<u8>>::from_hex("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d61900000000000307017f00000103e8").unwrap();
3897 assert_eq!(encoded_value, target_value);
3898 assert_eq!(msgs::Init::read(&mut Cursor::new(&target_value)).unwrap(), init_msg);
3902 fn encoding_error() {
3903 let error = msgs::ErrorMessage {
3904 channel_id: ChannelId::from_bytes([2; 32]),
3905 data: String::from("rust-lightning"),
3907 let encoded_value = error.encode();
3908 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3909 assert_eq!(encoded_value, target_value);
3913 fn encoding_warning() {
3914 let error = msgs::WarningMessage {
3915 channel_id: ChannelId::from_bytes([2; 32]),
3916 data: String::from("rust-lightning"),
3918 let encoded_value = error.encode();
3919 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3920 assert_eq!(encoded_value, target_value);
3924 fn encoding_ping() {
3925 let ping = msgs::Ping {
3929 let encoded_value = ping.encode();
3930 let target_value = <Vec<u8>>::from_hex("0040004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3931 assert_eq!(encoded_value, target_value);
3935 fn encoding_pong() {
3936 let pong = msgs::Pong {
3939 let encoded_value = pong.encode();
3940 let target_value = <Vec<u8>>::from_hex("004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3941 assert_eq!(encoded_value, target_value);
3945 fn encoding_nonfinal_onion_hop_data() {
3946 let outbound_msg = msgs::OutboundOnionPayload::Forward {
3947 short_channel_id: 0xdeadbeef1bad1dea,
3948 amt_to_forward: 0x0badf00d01020304,
3949 outgoing_cltv_value: 0xffffffff,
3951 let encoded_value = outbound_msg.encode();
3952 let target_value = <Vec<u8>>::from_hex("1a02080badf00d010203040404ffffffff0608deadbeef1bad1dea").unwrap();
3953 assert_eq!(encoded_value, target_value);
3955 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3956 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
3957 if let msgs::InboundOnionPayload::Forward {
3958 short_channel_id, amt_to_forward, outgoing_cltv_value
3960 assert_eq!(short_channel_id, 0xdeadbeef1bad1dea);
3961 assert_eq!(amt_to_forward, 0x0badf00d01020304);
3962 assert_eq!(outgoing_cltv_value, 0xffffffff);
3963 } else { panic!(); }
3967 fn encoding_final_onion_hop_data() {
3968 let outbound_msg = msgs::OutboundOnionPayload::Receive {
3970 payment_metadata: None,
3971 keysend_preimage: None,
3972 amt_msat: 0x0badf00d01020304,
3973 outgoing_cltv_value: 0xffffffff,
3974 custom_tlvs: vec![],
3976 let encoded_value = outbound_msg.encode();
3977 let target_value = <Vec<u8>>::from_hex("1002080badf00d010203040404ffffffff").unwrap();
3978 assert_eq!(encoded_value, target_value);
3980 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3981 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
3982 if let msgs::InboundOnionPayload::Receive {
3983 payment_data: None, amt_msat, outgoing_cltv_value, ..
3985 assert_eq!(amt_msat, 0x0badf00d01020304);
3986 assert_eq!(outgoing_cltv_value, 0xffffffff);
3987 } else { panic!(); }
3991 fn encoding_final_onion_hop_data_with_secret() {
3992 let expected_payment_secret = PaymentSecret([0x42u8; 32]);
3993 let outbound_msg = msgs::OutboundOnionPayload::Receive {
3994 payment_data: Some(FinalOnionHopData {
3995 payment_secret: expected_payment_secret,
3996 total_msat: 0x1badca1f
3998 payment_metadata: None,
3999 keysend_preimage: None,
4000 amt_msat: 0x0badf00d01020304,
4001 outgoing_cltv_value: 0xffffffff,
4002 custom_tlvs: vec![],
4004 let encoded_value = outbound_msg.encode();
4005 let target_value = <Vec<u8>>::from_hex("3602080badf00d010203040404ffffffff082442424242424242424242424242424242424242424242424242424242424242421badca1f").unwrap();
4006 assert_eq!(encoded_value, target_value);
4008 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4009 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
4010 if let msgs::InboundOnionPayload::Receive {
4011 payment_data: Some(FinalOnionHopData {
4013 total_msat: 0x1badca1f
4015 amt_msat, outgoing_cltv_value,
4016 payment_metadata: None,
4017 keysend_preimage: None,
4020 assert_eq!(payment_secret, expected_payment_secret);
4021 assert_eq!(amt_msat, 0x0badf00d01020304);
4022 assert_eq!(outgoing_cltv_value, 0xffffffff);
4023 assert_eq!(custom_tlvs, vec![]);
4024 } else { panic!(); }
4028 fn encoding_final_onion_hop_data_with_bad_custom_tlvs() {
4029 // If custom TLVs have type number within the range reserved for protocol, treat them as if
4031 let bad_type_range_tlvs = vec![
4032 ((1 << 16) - 4, vec![42]),
4033 ((1 << 16) - 2, vec![42; 32]),
4035 let mut msg = msgs::OutboundOnionPayload::Receive {
4037 payment_metadata: None,
4038 keysend_preimage: None,
4039 custom_tlvs: bad_type_range_tlvs,
4040 amt_msat: 0x0badf00d01020304,
4041 outgoing_cltv_value: 0xffffffff,
4043 let encoded_value = msg.encode();
4044 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4045 assert!(msgs::InboundOnionPayload::read(&mut Cursor::new(&encoded_value[..]), &&node_signer).is_err());
4046 let good_type_range_tlvs = vec![
4047 ((1 << 16) - 3, vec![42]),
4048 ((1 << 16) - 1, vec![42; 32]),
4050 if let msgs::OutboundOnionPayload::Receive { ref mut custom_tlvs, .. } = msg {
4051 *custom_tlvs = good_type_range_tlvs.clone();
4053 let encoded_value = msg.encode();
4054 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&encoded_value[..]), &&node_signer).unwrap();
4056 msgs::InboundOnionPayload::Receive { custom_tlvs, .. } => assert!(custom_tlvs.is_empty()),
4062 fn encoding_final_onion_hop_data_with_custom_tlvs() {
4063 let expected_custom_tlvs = vec![
4064 (5482373483, vec![0x12, 0x34]),
4065 (5482373487, vec![0x42u8; 8]),
4067 let msg = msgs::OutboundOnionPayload::Receive {
4069 payment_metadata: None,
4070 keysend_preimage: None,
4071 custom_tlvs: expected_custom_tlvs.clone(),
4072 amt_msat: 0x0badf00d01020304,
4073 outgoing_cltv_value: 0xffffffff,
4075 let encoded_value = msg.encode();
4076 let target_value = <Vec<u8>>::from_hex("2e02080badf00d010203040404ffffffffff0000000146c6616b021234ff0000000146c6616f084242424242424242").unwrap();
4077 assert_eq!(encoded_value, target_value);
4078 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4079 let inbound_msg: msgs::InboundOnionPayload = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
4080 if let msgs::InboundOnionPayload::Receive {
4082 payment_metadata: None,
4083 keysend_preimage: None,
4086 outgoing_cltv_value,
4089 assert_eq!(custom_tlvs, expected_custom_tlvs);
4090 assert_eq!(amt_msat, 0x0badf00d01020304);
4091 assert_eq!(outgoing_cltv_value, 0xffffffff);
4092 } else { panic!(); }
4096 fn query_channel_range_end_blocknum() {
4097 let tests: Vec<(u32, u32, u32)> = vec![
4098 (10000, 1500, 11500),
4099 (0, 0xffffffff, 0xffffffff),
4100 (1, 0xffffffff, 0xffffffff),
4103 for (first_blocknum, number_of_blocks, expected) in tests.into_iter() {
4104 let sut = msgs::QueryChannelRange {
4105 chain_hash: ChainHash::using_genesis_block(Network::Regtest),
4109 assert_eq!(sut.end_blocknum(), expected);
4114 fn encoding_query_channel_range() {
4115 let mut query_channel_range = msgs::QueryChannelRange {
4116 chain_hash: ChainHash::using_genesis_block(Network::Regtest),
4117 first_blocknum: 100000,
4118 number_of_blocks: 1500,
4120 let encoded_value = query_channel_range.encode();
4121 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000186a0000005dc").unwrap();
4122 assert_eq!(encoded_value, target_value);
4124 query_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4125 assert_eq!(query_channel_range.first_blocknum, 100000);
4126 assert_eq!(query_channel_range.number_of_blocks, 1500);
4130 fn encoding_reply_channel_range() {
4131 do_encoding_reply_channel_range(0);
4132 do_encoding_reply_channel_range(1);
4135 fn do_encoding_reply_channel_range(encoding_type: u8) {
4136 let mut target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000b8a06000005dc01").unwrap();
4137 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4138 let mut reply_channel_range = msgs::ReplyChannelRange {
4139 chain_hash: expected_chain_hash,
4140 first_blocknum: 756230,
4141 number_of_blocks: 1500,
4142 sync_complete: true,
4143 short_channel_ids: vec![0x000000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
4146 if encoding_type == 0 {
4147 target_value.append(&mut <Vec<u8>>::from_hex("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
4148 let encoded_value = reply_channel_range.encode();
4149 assert_eq!(encoded_value, target_value);
4151 reply_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4152 assert_eq!(reply_channel_range.chain_hash, expected_chain_hash);
4153 assert_eq!(reply_channel_range.first_blocknum, 756230);
4154 assert_eq!(reply_channel_range.number_of_blocks, 1500);
4155 assert_eq!(reply_channel_range.sync_complete, true);
4156 assert_eq!(reply_channel_range.short_channel_ids[0], 0x000000000000008e);
4157 assert_eq!(reply_channel_range.short_channel_ids[1], 0x0000000000003c69);
4158 assert_eq!(reply_channel_range.short_channel_ids[2], 0x000000000045a6c4);
4160 target_value.append(&mut <Vec<u8>>::from_hex("001601789c636000833e08659309a65878be010010a9023a").unwrap());
4161 let result: Result<msgs::ReplyChannelRange, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
4162 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
4167 fn encoding_query_short_channel_ids() {
4168 do_encoding_query_short_channel_ids(0);
4169 do_encoding_query_short_channel_ids(1);
4172 fn do_encoding_query_short_channel_ids(encoding_type: u8) {
4173 let mut target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
4174 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4175 let mut query_short_channel_ids = msgs::QueryShortChannelIds {
4176 chain_hash: expected_chain_hash,
4177 short_channel_ids: vec![0x0000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
4180 if encoding_type == 0 {
4181 target_value.append(&mut <Vec<u8>>::from_hex("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
4182 let encoded_value = query_short_channel_ids.encode();
4183 assert_eq!(encoded_value, target_value);
4185 query_short_channel_ids = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4186 assert_eq!(query_short_channel_ids.chain_hash, expected_chain_hash);
4187 assert_eq!(query_short_channel_ids.short_channel_ids[0], 0x000000000000008e);
4188 assert_eq!(query_short_channel_ids.short_channel_ids[1], 0x0000000000003c69);
4189 assert_eq!(query_short_channel_ids.short_channel_ids[2], 0x000000000045a6c4);
4191 target_value.append(&mut <Vec<u8>>::from_hex("001601789c636000833e08659309a65878be010010a9023a").unwrap());
4192 let result: Result<msgs::QueryShortChannelIds, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
4193 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
4198 fn encoding_reply_short_channel_ids_end() {
4199 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4200 let mut reply_short_channel_ids_end = msgs::ReplyShortChannelIdsEnd {
4201 chain_hash: expected_chain_hash,
4202 full_information: true,
4204 let encoded_value = reply_short_channel_ids_end.encode();
4205 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f01").unwrap();
4206 assert_eq!(encoded_value, target_value);
4208 reply_short_channel_ids_end = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4209 assert_eq!(reply_short_channel_ids_end.chain_hash, expected_chain_hash);
4210 assert_eq!(reply_short_channel_ids_end.full_information, true);
4214 fn encoding_gossip_timestamp_filter(){
4215 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4216 let mut gossip_timestamp_filter = msgs::GossipTimestampFilter {
4217 chain_hash: expected_chain_hash,
4218 first_timestamp: 1590000000,
4219 timestamp_range: 0xffff_ffff,
4221 let encoded_value = gossip_timestamp_filter.encode();
4222 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f5ec57980ffffffff").unwrap();
4223 assert_eq!(encoded_value, target_value);
4225 gossip_timestamp_filter = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4226 assert_eq!(gossip_timestamp_filter.chain_hash, expected_chain_hash);
4227 assert_eq!(gossip_timestamp_filter.first_timestamp, 1590000000);
4228 assert_eq!(gossip_timestamp_filter.timestamp_range, 0xffff_ffff);
4232 fn decode_onion_hop_data_len_as_bigsize() {
4233 // Tests that we can decode an onion payload that is >253 bytes.
4234 // Previously, receiving a payload of this size could've caused us to fail to decode a valid
4235 // payload, because we were decoding the length (a BigSize, big-endian) as a VarInt
4238 // Encode a test onion payload with a big custom TLV such that it's >253 bytes, forcing the
4239 // payload length to be encoded over multiple bytes rather than a single u8.
4240 let big_payload = encode_big_payload().unwrap();
4241 let mut rd = Cursor::new(&big_payload[..]);
4243 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4244 <msgs::InboundOnionPayload as ReadableArgs<&&test_utils::TestKeysInterface>>
4245 ::read(&mut rd, &&node_signer).unwrap();
4247 // see above test, needs to be a separate method for use of the serialization macros.
4248 fn encode_big_payload() -> Result<Vec<u8>, io::Error> {
4249 use crate::util::ser::HighZeroBytesDroppedBigSize;
4250 let payload = msgs::OutboundOnionPayload::Forward {
4251 short_channel_id: 0xdeadbeef1bad1dea,
4252 amt_to_forward: 1000,
4253 outgoing_cltv_value: 0xffffffff,
4255 let mut encoded_payload = Vec::new();
4256 let test_bytes = vec![42u8; 1000];
4257 if let msgs::OutboundOnionPayload::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } = payload {
4258 _encode_varint_length_prefixed_tlv!(&mut encoded_payload, {
4259 (1, test_bytes, required_vec),
4260 (2, HighZeroBytesDroppedBigSize(amt_to_forward), required),
4261 (4, HighZeroBytesDroppedBigSize(outgoing_cltv_value), required),
4262 (6, short_channel_id, required)
4269 #[cfg(feature = "std")]
4270 fn test_socket_address_from_str() {
4271 let tcpip_v4 = SocketAddress::TcpIpV4 {
4272 addr: Ipv4Addr::new(127, 0, 0, 1).octets(),
4275 assert_eq!(tcpip_v4, SocketAddress::from_str("127.0.0.1:1234").unwrap());
4276 assert_eq!(tcpip_v4, SocketAddress::from_str(&tcpip_v4.to_string()).unwrap());
4278 let tcpip_v6 = SocketAddress::TcpIpV6 {
4279 addr: Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1).octets(),
4282 assert_eq!(tcpip_v6, SocketAddress::from_str("[0:0:0:0:0:0:0:1]:1234").unwrap());
4283 assert_eq!(tcpip_v6, SocketAddress::from_str(&tcpip_v6.to_string()).unwrap());
4285 let hostname = SocketAddress::Hostname {
4286 hostname: Hostname::try_from("lightning-node.mydomain.com".to_string()).unwrap(),
4289 assert_eq!(hostname, SocketAddress::from_str("lightning-node.mydomain.com:1234").unwrap());
4290 assert_eq!(hostname, SocketAddress::from_str(&hostname.to_string()).unwrap());
4292 let onion_v2 = SocketAddress::OnionV2 ([40, 4, 64, 185, 202, 19, 162, 75, 90, 200, 38, 7],);
4293 assert_eq!("OnionV2([40, 4, 64, 185, 202, 19, 162, 75, 90, 200, 38, 7])", &onion_v2.to_string());
4294 assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("FACEBOOKCOREWWWI.onion:9735"));
4296 let onion_v3 = SocketAddress::OnionV3 {
4297 ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102, 182, 107, 4, 105, 247, 246, 85,
4298 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31, 33, 71, 3],
4303 assert_eq!(onion_v3, SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion:1234").unwrap());
4304 assert_eq!(onion_v3, SocketAddress::from_str(&onion_v3.to_string()).unwrap());
4306 assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6.onion:1234"));
4307 assert_eq!(Err(SocketAddressParseError::InvalidInput), SocketAddress::from_str("127.0.0.1@1234"));
4308 assert_eq!(Err(SocketAddressParseError::InvalidInput), "".parse::<SocketAddress>());
4309 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:9735:94").is_err());
4310 assert!(SocketAddress::from_str("wrong$%#.com:1234").is_err());
4311 assert_eq!(Err(SocketAddressParseError::InvalidPort), SocketAddress::from_str("example.com:wrong"));
4312 assert!("localhost".parse::<SocketAddress>().is_err());
4313 assert!("localhost:invalid-port".parse::<SocketAddress>().is_err());
4314 assert!( "invalid-onion-v3-hostname.onion:8080".parse::<SocketAddress>().is_err());
4315 assert!("b32.example.onion:invalid-port".parse::<SocketAddress>().is_err());
4316 assert!("invalid-address".parse::<SocketAddress>().is_err());
4317 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:1234").is_err());
4321 #[cfg(feature = "std")]
4322 fn test_socket_address_to_socket_addrs() {
4323 assert_eq!(SocketAddress::TcpIpV4 {addr:[0u8; 4], port: 1337,}.to_socket_addrs().unwrap().next().unwrap(),
4324 SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(0,0,0,0), 1337)));
4325 assert_eq!(SocketAddress::TcpIpV6 {addr:[0u8; 16], port: 1337,}.to_socket_addrs().unwrap().next().unwrap(),
4326 SocketAddr::V6(SocketAddrV6::new(Ipv6Addr::from([0u8; 16]), 1337, 0, 0)));
4327 assert_eq!(SocketAddress::Hostname { hostname: Hostname::try_from("0.0.0.0".to_string()).unwrap(), port: 0 }
4328 .to_socket_addrs().unwrap().next().unwrap(), SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::from([0u8; 4]),0)));
4329 assert!(SocketAddress::OnionV2([0u8; 12]).to_socket_addrs().is_err());
4330 assert!(SocketAddress::OnionV3{ ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102,
4331 182, 107, 4, 105, 247, 246, 85, 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31,
4335 port: 1234 }.to_socket_addrs().is_err());