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 /// The onion routing packet with encrypted data for the next hop.
684 pub onion_routing_packet: OnionPacket,
685 /// Provided if we are relaying or receiving a payment within a blinded path, to decrypt the onion
686 /// routing packet and the recipient-provided encrypted payload within.
687 pub blinding_point: Option<PublicKey>,
690 /// An onion message to be sent to or received from a peer.
692 // TODO: update with link to OM when they are merged into the BOLTs
693 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
694 pub struct OnionMessage {
695 /// Used in decrypting the onion packet's payload.
696 pub blinding_point: PublicKey,
697 /// The full onion packet including hop data, pubkey, and hmac
698 pub onion_routing_packet: onion_message::Packet,
701 /// An [`update_fulfill_htlc`] message to be sent to or received from a peer.
703 /// [`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
704 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
705 pub struct UpdateFulfillHTLC {
707 pub channel_id: ChannelId,
710 /// The pre-image of the payment hash, allowing HTLC redemption
711 pub payment_preimage: PaymentPreimage,
714 /// An [`update_fail_htlc`] message to be sent to or received from a peer.
716 /// [`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
717 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
718 pub struct UpdateFailHTLC {
720 pub channel_id: ChannelId,
723 pub(crate) reason: OnionErrorPacket,
726 /// An [`update_fail_malformed_htlc`] message to be sent to or received from a peer.
728 /// [`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
729 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
730 pub struct UpdateFailMalformedHTLC {
732 pub channel_id: ChannelId,
735 pub(crate) sha256_of_onion: [u8; 32],
737 pub failure_code: u16,
740 /// A [`commitment_signed`] message to be sent to or received from a peer.
742 /// [`commitment_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#committing-updates-so-far-commitment_signed
743 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
744 pub struct CommitmentSigned {
746 pub channel_id: ChannelId,
747 /// A signature on the commitment transaction
748 pub signature: Signature,
749 /// Signatures on the HTLC transactions
750 pub htlc_signatures: Vec<Signature>,
752 /// The partial Taproot signature on the commitment transaction
753 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
756 /// A [`revoke_and_ack`] message to be sent to or received from a peer.
758 /// [`revoke_and_ack`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#completing-the-transition-to-the-updated-state-revoke_and_ack
759 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
760 pub struct RevokeAndACK {
762 pub channel_id: ChannelId,
763 /// The secret corresponding to the per-commitment point
764 pub per_commitment_secret: [u8; 32],
765 /// The next sender-broadcast commitment transaction's per-commitment point
766 pub next_per_commitment_point: PublicKey,
768 /// Musig nonce the recipient should use in their next commitment signature message
769 pub next_local_nonce: Option<musig2::types::PublicNonce>
772 /// An [`update_fee`] message to be sent to or received from a peer
774 /// [`update_fee`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#updating-fees-update_fee
775 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
776 pub struct UpdateFee {
778 pub channel_id: ChannelId,
779 /// Fee rate per 1000-weight of the transaction
780 pub feerate_per_kw: u32,
783 /// A [`channel_reestablish`] message to be sent to or received from a peer.
785 /// [`channel_reestablish`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#message-retransmission
786 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
787 pub struct ChannelReestablish {
789 pub channel_id: ChannelId,
790 /// The next commitment number for the sender
791 pub next_local_commitment_number: u64,
792 /// The next commitment number for the recipient
793 pub next_remote_commitment_number: u64,
794 /// Proof that the sender knows the per-commitment secret of a specific commitment transaction
795 /// belonging to the recipient
796 pub your_last_per_commitment_secret: [u8; 32],
797 /// The sender's per-commitment point for their current commitment transaction
798 pub my_current_per_commitment_point: PublicKey,
799 /// The next funding transaction ID
800 pub next_funding_txid: Option<Txid>,
803 /// An [`announcement_signatures`] message to be sent to or received from a peer.
805 /// [`announcement_signatures`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-announcement_signatures-message
806 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
807 pub struct AnnouncementSignatures {
809 pub channel_id: ChannelId,
810 /// The short channel ID
811 pub short_channel_id: u64,
812 /// A signature by the node key
813 pub node_signature: Signature,
814 /// A signature by the funding key
815 pub bitcoin_signature: Signature,
818 /// An address which can be used to connect to a remote peer.
819 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
820 pub enum SocketAddress {
821 /// An IPv4 address and port on which the peer is listening.
823 /// The 4-byte IPv4 address
825 /// The port on which the node is listening
828 /// An IPv6 address and port on which the peer is listening.
830 /// The 16-byte IPv6 address
832 /// The port on which the node is listening
835 /// An old-style Tor onion address/port on which the peer is listening.
837 /// This field is deprecated and the Tor network generally no longer supports V2 Onion
838 /// addresses. Thus, the details are not parsed here.
840 /// A new-style Tor onion address/port on which the peer is listening.
842 /// To create the human-readable "hostname", concatenate the ED25519 pubkey, checksum, and version,
843 /// wrap as base32 and append ".onion".
845 /// The ed25519 long-term public key of the peer
846 ed25519_pubkey: [u8; 32],
847 /// The checksum of the pubkey and version, as included in the onion address
849 /// The version byte, as defined by the Tor Onion v3 spec.
851 /// The port on which the node is listening
854 /// A hostname/port on which the peer is listening.
856 /// The hostname on which the node is listening.
858 /// The port on which the node is listening.
863 /// Gets the ID of this address type. Addresses in [`NodeAnnouncement`] messages should be sorted
865 pub(crate) fn get_id(&self) -> u8 {
867 &SocketAddress::TcpIpV4 {..} => { 1 },
868 &SocketAddress::TcpIpV6 {..} => { 2 },
869 &SocketAddress::OnionV2(_) => { 3 },
870 &SocketAddress::OnionV3 {..} => { 4 },
871 &SocketAddress::Hostname {..} => { 5 },
875 /// Strict byte-length of address descriptor, 1-byte type not recorded
876 fn len(&self) -> u16 {
878 &SocketAddress::TcpIpV4 { .. } => { 6 },
879 &SocketAddress::TcpIpV6 { .. } => { 18 },
880 &SocketAddress::OnionV2(_) => { 12 },
881 &SocketAddress::OnionV3 { .. } => { 37 },
882 // Consists of 1-byte hostname length, hostname bytes, and 2-byte port.
883 &SocketAddress::Hostname { ref hostname, .. } => { u16::from(hostname.len()) + 3 },
887 /// The maximum length of any address descriptor, not including the 1-byte type.
888 /// This maximum length is reached by a hostname address descriptor:
889 /// a hostname with a maximum length of 255, its 1-byte length and a 2-byte port.
890 pub(crate) const MAX_LEN: u16 = 258;
893 impl Writeable for SocketAddress {
894 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
896 &SocketAddress::TcpIpV4 { ref addr, ref port } => {
901 &SocketAddress::TcpIpV6 { ref addr, ref port } => {
906 &SocketAddress::OnionV2(bytes) => {
908 bytes.write(writer)?;
910 &SocketAddress::OnionV3 { ref ed25519_pubkey, ref checksum, ref version, ref port } => {
912 ed25519_pubkey.write(writer)?;
913 checksum.write(writer)?;
914 version.write(writer)?;
917 &SocketAddress::Hostname { ref hostname, ref port } => {
919 hostname.write(writer)?;
927 impl Readable for Result<SocketAddress, u8> {
928 fn read<R: Read>(reader: &mut R) -> Result<Result<SocketAddress, u8>, DecodeError> {
929 let byte = <u8 as Readable>::read(reader)?;
932 Ok(Ok(SocketAddress::TcpIpV4 {
933 addr: Readable::read(reader)?,
934 port: Readable::read(reader)?,
938 Ok(Ok(SocketAddress::TcpIpV6 {
939 addr: Readable::read(reader)?,
940 port: Readable::read(reader)?,
943 3 => Ok(Ok(SocketAddress::OnionV2(Readable::read(reader)?))),
945 Ok(Ok(SocketAddress::OnionV3 {
946 ed25519_pubkey: Readable::read(reader)?,
947 checksum: Readable::read(reader)?,
948 version: Readable::read(reader)?,
949 port: Readable::read(reader)?,
953 Ok(Ok(SocketAddress::Hostname {
954 hostname: Readable::read(reader)?,
955 port: Readable::read(reader)?,
958 _ => return Ok(Err(byte)),
963 impl Readable for SocketAddress {
964 fn read<R: Read>(reader: &mut R) -> Result<SocketAddress, DecodeError> {
965 match Readable::read(reader) {
966 Ok(Ok(res)) => Ok(res),
967 Ok(Err(_)) => Err(DecodeError::UnknownVersion),
973 /// [`SocketAddress`] error variants
974 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
975 pub enum SocketAddressParseError {
976 /// Socket address (IPv4/IPv6) parsing error
978 /// Invalid input format
982 /// Invalid onion v3 address
986 impl fmt::Display for SocketAddressParseError {
987 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
989 SocketAddressParseError::SocketAddrParse => write!(f, "Socket address (IPv4/IPv6) parsing error"),
990 SocketAddressParseError::InvalidInput => write!(f, "Invalid input format. \
991 Expected: \"<ipv4>:<port>\", \"[<ipv6>]:<port>\", \"<onion address>.onion:<port>\" or \"<hostname>:<port>\""),
992 SocketAddressParseError::InvalidPort => write!(f, "Invalid port"),
993 SocketAddressParseError::InvalidOnionV3 => write!(f, "Invalid onion v3 address"),
998 #[cfg(feature = "std")]
999 impl From<std::net::SocketAddrV4> for SocketAddress {
1000 fn from(addr: std::net::SocketAddrV4) -> Self {
1001 SocketAddress::TcpIpV4 { addr: addr.ip().octets(), port: addr.port() }
1005 #[cfg(feature = "std")]
1006 impl From<std::net::SocketAddrV6> for SocketAddress {
1007 fn from(addr: std::net::SocketAddrV6) -> Self {
1008 SocketAddress::TcpIpV6 { addr: addr.ip().octets(), port: addr.port() }
1012 #[cfg(feature = "std")]
1013 impl From<std::net::SocketAddr> for SocketAddress {
1014 fn from(addr: std::net::SocketAddr) -> Self {
1016 std::net::SocketAddr::V4(addr) => addr.into(),
1017 std::net::SocketAddr::V6(addr) => addr.into(),
1022 #[cfg(feature = "std")]
1023 impl std::net::ToSocketAddrs for SocketAddress {
1024 type Iter = std::vec::IntoIter<std::net::SocketAddr>;
1026 fn to_socket_addrs(&self) -> std::io::Result<Self::Iter> {
1028 SocketAddress::TcpIpV4 { addr, port } => {
1029 let ip_addr = std::net::Ipv4Addr::from(*addr);
1030 let socket_addr = SocketAddr::new(ip_addr.into(), *port);
1031 Ok(vec![socket_addr].into_iter())
1033 SocketAddress::TcpIpV6 { addr, port } => {
1034 let ip_addr = std::net::Ipv6Addr::from(*addr);
1035 let socket_addr = SocketAddr::new(ip_addr.into(), *port);
1036 Ok(vec![socket_addr].into_iter())
1038 SocketAddress::Hostname { ref hostname, port } => {
1039 (hostname.as_str(), *port).to_socket_addrs()
1041 SocketAddress::OnionV2(..) => {
1042 Err(std::io::Error::new(std::io::ErrorKind::Other, "Resolution of OnionV2 \
1043 addresses is currently unsupported."))
1045 SocketAddress::OnionV3 { .. } => {
1046 Err(std::io::Error::new(std::io::ErrorKind::Other, "Resolution of OnionV3 \
1047 addresses is currently unsupported."))
1053 /// Parses an OnionV3 host and port into a [`SocketAddress::OnionV3`].
1055 /// The host part must end with ".onion".
1056 pub fn parse_onion_address(host: &str, port: u16) -> Result<SocketAddress, SocketAddressParseError> {
1057 if host.ends_with(".onion") {
1058 let domain = &host[..host.len() - ".onion".len()];
1059 if domain.len() != 56 {
1060 return Err(SocketAddressParseError::InvalidOnionV3);
1062 let onion = base32::Alphabet::RFC4648 { padding: false }.decode(&domain).map_err(|_| SocketAddressParseError::InvalidOnionV3)?;
1063 if onion.len() != 35 {
1064 return Err(SocketAddressParseError::InvalidOnionV3);
1066 let version = onion[0];
1067 let first_checksum_flag = onion[1];
1068 let second_checksum_flag = onion[2];
1069 let mut ed25519_pubkey = [0; 32];
1070 ed25519_pubkey.copy_from_slice(&onion[3..35]);
1071 let checksum = u16::from_be_bytes([first_checksum_flag, second_checksum_flag]);
1072 return Ok(SocketAddress::OnionV3 { ed25519_pubkey, checksum, version, port });
1075 return Err(SocketAddressParseError::InvalidInput);
1079 impl Display for SocketAddress {
1080 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1082 SocketAddress::TcpIpV4{addr, port} => write!(
1083 f, "{}.{}.{}.{}:{}", addr[0], addr[1], addr[2], addr[3], port)?,
1084 SocketAddress::TcpIpV6{addr, port} => write!(
1086 "[{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}]:{}",
1087 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
1089 SocketAddress::OnionV2(bytes) => write!(f, "OnionV2({:?})", bytes)?,
1090 SocketAddress::OnionV3 {
1096 let [first_checksum_flag, second_checksum_flag] = checksum.to_be_bytes();
1097 let mut addr = vec![*version, first_checksum_flag, second_checksum_flag];
1098 addr.extend_from_slice(ed25519_pubkey);
1099 let onion = base32::Alphabet::RFC4648 { padding: false }.encode(&addr);
1100 write!(f, "{}.onion:{}", onion, port)?
1102 SocketAddress::Hostname { hostname, port } => write!(f, "{}:{}", hostname, port)?,
1108 #[cfg(feature = "std")]
1109 impl FromStr for SocketAddress {
1110 type Err = SocketAddressParseError;
1112 fn from_str(s: &str) -> Result<Self, Self::Err> {
1113 match std::net::SocketAddr::from_str(s) {
1114 Ok(addr) => Ok(addr.into()),
1116 let trimmed_input = match s.rfind(":") {
1118 None => return Err(SocketAddressParseError::InvalidInput),
1120 let host = &s[..trimmed_input];
1121 let port: u16 = s[trimmed_input + 1..].parse().map_err(|_| SocketAddressParseError::InvalidPort)?;
1122 if host.ends_with(".onion") {
1123 return parse_onion_address(host, port);
1125 if let Ok(hostname) = Hostname::try_from(s[..trimmed_input].to_string()) {
1126 return Ok(SocketAddress::Hostname { hostname, port });
1128 return Err(SocketAddressParseError::SocketAddrParse)
1134 /// Represents the set of gossip messages that require a signature from a node's identity key.
1135 pub enum UnsignedGossipMessage<'a> {
1136 /// An unsigned channel announcement.
1137 ChannelAnnouncement(&'a UnsignedChannelAnnouncement),
1138 /// An unsigned channel update.
1139 ChannelUpdate(&'a UnsignedChannelUpdate),
1140 /// An unsigned node announcement.
1141 NodeAnnouncement(&'a UnsignedNodeAnnouncement)
1144 impl<'a> Writeable for UnsignedGossipMessage<'a> {
1145 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
1147 UnsignedGossipMessage::ChannelAnnouncement(ref msg) => msg.write(writer),
1148 UnsignedGossipMessage::ChannelUpdate(ref msg) => msg.write(writer),
1149 UnsignedGossipMessage::NodeAnnouncement(ref msg) => msg.write(writer),
1154 /// The unsigned part of a [`node_announcement`] message.
1156 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
1157 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1158 pub struct UnsignedNodeAnnouncement {
1159 /// The advertised features
1160 pub features: NodeFeatures,
1161 /// A strictly monotonic announcement counter, with gaps allowed
1163 /// The `node_id` this announcement originated from (don't rebroadcast the `node_announcement` back
1165 pub node_id: NodeId,
1166 /// An RGB color for UI purposes
1168 /// An alias, for UI purposes.
1170 /// This should be sanitized before use. There is no guarantee of uniqueness.
1171 pub alias: NodeAlias,
1172 /// List of addresses on which this node is reachable
1173 pub addresses: Vec<SocketAddress>,
1174 pub(crate) excess_address_data: Vec<u8>,
1175 pub(crate) excess_data: Vec<u8>,
1177 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1178 /// A [`node_announcement`] message to be sent to or received from a peer.
1180 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
1181 pub struct NodeAnnouncement {
1182 /// The signature by the node key
1183 pub signature: Signature,
1184 /// The actual content of the announcement
1185 pub contents: UnsignedNodeAnnouncement,
1188 /// The unsigned part of a [`channel_announcement`] message.
1190 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
1191 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1192 pub struct UnsignedChannelAnnouncement {
1193 /// The advertised channel features
1194 pub features: ChannelFeatures,
1195 /// The genesis hash of the blockchain where the channel is to be opened
1196 pub chain_hash: ChainHash,
1197 /// The short channel ID
1198 pub short_channel_id: u64,
1199 /// One of the two `node_id`s which are endpoints of this channel
1200 pub node_id_1: NodeId,
1201 /// The other of the two `node_id`s which are endpoints of this channel
1202 pub node_id_2: NodeId,
1203 /// The funding key for the first node
1204 pub bitcoin_key_1: NodeId,
1205 /// The funding key for the second node
1206 pub bitcoin_key_2: NodeId,
1207 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1210 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1211 pub excess_data: Vec<u8>,
1213 /// A [`channel_announcement`] message to be sent to or received from a peer.
1215 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
1216 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1217 pub struct ChannelAnnouncement {
1218 /// Authentication of the announcement by the first public node
1219 pub node_signature_1: Signature,
1220 /// Authentication of the announcement by the second public node
1221 pub node_signature_2: Signature,
1222 /// Proof of funding UTXO ownership by the first public node
1223 pub bitcoin_signature_1: Signature,
1224 /// Proof of funding UTXO ownership by the second public node
1225 pub bitcoin_signature_2: Signature,
1226 /// The actual announcement
1227 pub contents: UnsignedChannelAnnouncement,
1230 /// The unsigned part of a [`channel_update`] message.
1232 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1233 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1234 pub struct UnsignedChannelUpdate {
1235 /// The genesis hash of the blockchain where the channel is to be opened
1236 pub chain_hash: ChainHash,
1237 /// The short channel ID
1238 pub short_channel_id: u64,
1239 /// A strictly monotonic announcement counter, with gaps allowed, specific to this channel
1243 /// The number of blocks such that if:
1244 /// `incoming_htlc.cltv_expiry < outgoing_htlc.cltv_expiry + cltv_expiry_delta`
1245 /// then we need to fail the HTLC backwards. When forwarding an HTLC, `cltv_expiry_delta` determines
1246 /// the outgoing HTLC's minimum `cltv_expiry` value -- so, if an incoming HTLC comes in with a
1247 /// `cltv_expiry` of 100000, and the node we're forwarding to has a `cltv_expiry_delta` value of 10,
1248 /// then we'll check that the outgoing HTLC's `cltv_expiry` value is at least 100010 before
1249 /// forwarding. Note that the HTLC sender is the one who originally sets this value when
1250 /// constructing the route.
1251 pub cltv_expiry_delta: u16,
1252 /// The minimum HTLC size incoming to sender, in milli-satoshi
1253 pub htlc_minimum_msat: u64,
1254 /// The maximum HTLC value incoming to sender, in milli-satoshi.
1256 /// This used to be optional.
1257 pub htlc_maximum_msat: u64,
1258 /// The base HTLC fee charged by sender, in milli-satoshi
1259 pub fee_base_msat: u32,
1260 /// The amount to fee multiplier, in micro-satoshi
1261 pub fee_proportional_millionths: u32,
1262 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1265 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1266 pub excess_data: Vec<u8>,
1268 /// A [`channel_update`] message to be sent to or received from a peer.
1270 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1271 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1272 pub struct ChannelUpdate {
1273 /// A signature of the channel update
1274 pub signature: Signature,
1275 /// The actual channel update
1276 pub contents: UnsignedChannelUpdate,
1279 /// A [`query_channel_range`] message is used to query a peer for channel
1280 /// UTXOs in a range of blocks. The recipient of a query makes a best
1281 /// effort to reply to the query using one or more [`ReplyChannelRange`]
1284 /// [`query_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1285 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1286 pub struct QueryChannelRange {
1287 /// The genesis hash of the blockchain being queried
1288 pub chain_hash: ChainHash,
1289 /// The height of the first block for the channel UTXOs being queried
1290 pub first_blocknum: u32,
1291 /// The number of blocks to include in the query results
1292 pub number_of_blocks: u32,
1295 /// A [`reply_channel_range`] message is a reply to a [`QueryChannelRange`]
1298 /// Multiple `reply_channel_range` messages can be sent in reply
1299 /// to a single [`QueryChannelRange`] message. The query recipient makes a
1300 /// best effort to respond based on their local network view which may
1301 /// not be a perfect view of the network. The `short_channel_id`s in the
1302 /// reply are encoded. We only support `encoding_type=0` uncompressed
1303 /// serialization and do not support `encoding_type=1` zlib serialization.
1305 /// [`reply_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1306 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1307 pub struct ReplyChannelRange {
1308 /// The genesis hash of the blockchain being queried
1309 pub chain_hash: ChainHash,
1310 /// The height of the first block in the range of the reply
1311 pub first_blocknum: u32,
1312 /// The number of blocks included in the range of the reply
1313 pub number_of_blocks: u32,
1314 /// True when this is the final reply for a query
1315 pub sync_complete: bool,
1316 /// The `short_channel_id`s in the channel range
1317 pub short_channel_ids: Vec<u64>,
1320 /// A [`query_short_channel_ids`] message is used to query a peer for
1321 /// routing gossip messages related to one or more `short_channel_id`s.
1323 /// The query recipient will reply with the latest, if available,
1324 /// [`ChannelAnnouncement`], [`ChannelUpdate`] and [`NodeAnnouncement`] messages
1325 /// it maintains for the requested `short_channel_id`s followed by a
1326 /// [`ReplyShortChannelIdsEnd`] message. The `short_channel_id`s sent in
1327 /// this query are encoded. We only support `encoding_type=0` uncompressed
1328 /// serialization and do not support `encoding_type=1` zlib serialization.
1330 /// [`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
1331 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1332 pub struct QueryShortChannelIds {
1333 /// The genesis hash of the blockchain being queried
1334 pub chain_hash: ChainHash,
1335 /// The short_channel_ids that are being queried
1336 pub short_channel_ids: Vec<u64>,
1339 /// A [`reply_short_channel_ids_end`] message is sent as a reply to a
1340 /// message. The query recipient makes a best
1341 /// effort to respond based on their local network view which may not be
1342 /// a perfect view of the network.
1344 /// [`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
1345 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1346 pub struct ReplyShortChannelIdsEnd {
1347 /// The genesis hash of the blockchain that was queried
1348 pub chain_hash: ChainHash,
1349 /// Indicates if the query recipient maintains up-to-date channel
1350 /// information for the `chain_hash`
1351 pub full_information: bool,
1354 /// A [`gossip_timestamp_filter`] message is used by a node to request
1355 /// gossip relay for messages in the requested time range when the
1356 /// `gossip_queries` feature has been negotiated.
1358 /// [`gossip_timestamp_filter`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-gossip_timestamp_filter-message
1359 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1360 pub struct GossipTimestampFilter {
1361 /// The genesis hash of the blockchain for channel and node information
1362 pub chain_hash: ChainHash,
1363 /// The starting unix timestamp
1364 pub first_timestamp: u32,
1365 /// The range of information in seconds
1366 pub timestamp_range: u32,
1369 /// Encoding type for data compression of collections in gossip queries.
1371 /// We do not support `encoding_type=1` zlib serialization [defined in BOLT
1372 /// #7](https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#query-messages).
1374 Uncompressed = 0x00,
1377 /// Used to put an error message in a [`LightningError`].
1378 #[derive(Clone, Debug, Hash, PartialEq)]
1379 pub enum ErrorAction {
1380 /// The peer took some action which made us think they were useless. Disconnect them.
1382 /// An error message which we should make an effort to send before we disconnect.
1383 msg: Option<ErrorMessage>
1385 /// The peer did something incorrect. Tell them without closing any channels and disconnect them.
1386 DisconnectPeerWithWarning {
1387 /// A warning message which we should make an effort to send before we disconnect.
1388 msg: WarningMessage,
1390 /// The peer did something harmless that we weren't able to process, just log and ignore
1391 // New code should *not* use this. New code must use IgnoreAndLog, below!
1393 /// The peer did something harmless that we weren't able to meaningfully process.
1394 /// If the error is logged, log it at the given level.
1395 IgnoreAndLog(logger::Level),
1396 /// The peer provided us with a gossip message which we'd already seen. In most cases this
1397 /// should be ignored, but it may result in the message being forwarded if it is a duplicate of
1398 /// our own channel announcements.
1399 IgnoreDuplicateGossip,
1400 /// The peer did something incorrect. Tell them.
1402 /// The message to send.
1405 /// The peer did something incorrect. Tell them without closing any channels.
1406 SendWarningMessage {
1407 /// The message to send.
1408 msg: WarningMessage,
1409 /// The peer may have done something harmless that we weren't able to meaningfully process,
1410 /// though we should still tell them about it.
1411 /// If this event is logged, log it at the given level.
1412 log_level: logger::Level,
1416 /// An Err type for failure to process messages.
1417 #[derive(Clone, Debug)]
1418 pub struct LightningError {
1419 /// A human-readable message describing the error
1421 /// The action which should be taken against the offending peer.
1422 pub action: ErrorAction,
1425 /// Struct used to return values from [`RevokeAndACK`] messages, containing a bunch of commitment
1426 /// transaction updates if they were pending.
1427 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1428 pub struct CommitmentUpdate {
1429 /// `update_add_htlc` messages which should be sent
1430 pub update_add_htlcs: Vec<UpdateAddHTLC>,
1431 /// `update_fulfill_htlc` messages which should be sent
1432 pub update_fulfill_htlcs: Vec<UpdateFulfillHTLC>,
1433 /// `update_fail_htlc` messages which should be sent
1434 pub update_fail_htlcs: Vec<UpdateFailHTLC>,
1435 /// `update_fail_malformed_htlc` messages which should be sent
1436 pub update_fail_malformed_htlcs: Vec<UpdateFailMalformedHTLC>,
1437 /// An `update_fee` message which should be sent
1438 pub update_fee: Option<UpdateFee>,
1439 /// A `commitment_signed` message which should be sent
1440 pub commitment_signed: CommitmentSigned,
1443 /// A trait to describe an object which can receive channel messages.
1445 /// Messages MAY be called in parallel when they originate from different `their_node_ids`, however
1446 /// they MUST NOT be called in parallel when the two calls have the same `their_node_id`.
1447 pub trait ChannelMessageHandler : MessageSendEventsProvider {
1449 /// Handle an incoming `open_channel` message from the given peer.
1450 fn handle_open_channel(&self, their_node_id: &PublicKey, msg: &OpenChannel);
1451 /// Handle an incoming `open_channel2` message from the given peer.
1452 fn handle_open_channel_v2(&self, their_node_id: &PublicKey, msg: &OpenChannelV2);
1453 /// Handle an incoming `accept_channel` message from the given peer.
1454 fn handle_accept_channel(&self, their_node_id: &PublicKey, msg: &AcceptChannel);
1455 /// Handle an incoming `accept_channel2` message from the given peer.
1456 fn handle_accept_channel_v2(&self, their_node_id: &PublicKey, msg: &AcceptChannelV2);
1457 /// Handle an incoming `funding_created` message from the given peer.
1458 fn handle_funding_created(&self, their_node_id: &PublicKey, msg: &FundingCreated);
1459 /// Handle an incoming `funding_signed` message from the given peer.
1460 fn handle_funding_signed(&self, their_node_id: &PublicKey, msg: &FundingSigned);
1461 /// Handle an incoming `channel_ready` message from the given peer.
1462 fn handle_channel_ready(&self, their_node_id: &PublicKey, msg: &ChannelReady);
1465 /// Handle an incoming `shutdown` message from the given peer.
1466 fn handle_shutdown(&self, their_node_id: &PublicKey, msg: &Shutdown);
1467 /// Handle an incoming `closing_signed` message from the given peer.
1468 fn handle_closing_signed(&self, their_node_id: &PublicKey, msg: &ClosingSigned);
1471 /// Handle an incoming `stfu` message from the given peer.
1472 fn handle_stfu(&self, their_node_id: &PublicKey, msg: &Stfu);
1475 /// Handle an incoming `splice` message from the given peer.
1476 fn handle_splice(&self, their_node_id: &PublicKey, msg: &Splice);
1477 /// Handle an incoming `splice_ack` message from the given peer.
1478 fn handle_splice_ack(&self, their_node_id: &PublicKey, msg: &SpliceAck);
1479 /// Handle an incoming `splice_locked` message from the given peer.
1480 fn handle_splice_locked(&self, their_node_id: &PublicKey, msg: &SpliceLocked);
1482 // Interactive channel construction
1483 /// Handle an incoming `tx_add_input message` from the given peer.
1484 fn handle_tx_add_input(&self, their_node_id: &PublicKey, msg: &TxAddInput);
1485 /// Handle an incoming `tx_add_output` message from the given peer.
1486 fn handle_tx_add_output(&self, their_node_id: &PublicKey, msg: &TxAddOutput);
1487 /// Handle an incoming `tx_remove_input` message from the given peer.
1488 fn handle_tx_remove_input(&self, their_node_id: &PublicKey, msg: &TxRemoveInput);
1489 /// Handle an incoming `tx_remove_output` message from the given peer.
1490 fn handle_tx_remove_output(&self, their_node_id: &PublicKey, msg: &TxRemoveOutput);
1491 /// Handle an incoming `tx_complete message` from the given peer.
1492 fn handle_tx_complete(&self, their_node_id: &PublicKey, msg: &TxComplete);
1493 /// Handle an incoming `tx_signatures` message from the given peer.
1494 fn handle_tx_signatures(&self, their_node_id: &PublicKey, msg: &TxSignatures);
1495 /// Handle an incoming `tx_init_rbf` message from the given peer.
1496 fn handle_tx_init_rbf(&self, their_node_id: &PublicKey, msg: &TxInitRbf);
1497 /// Handle an incoming `tx_ack_rbf` message from the given peer.
1498 fn handle_tx_ack_rbf(&self, their_node_id: &PublicKey, msg: &TxAckRbf);
1499 /// Handle an incoming `tx_abort message` from the given peer.
1500 fn handle_tx_abort(&self, their_node_id: &PublicKey, msg: &TxAbort);
1503 /// Handle an incoming `update_add_htlc` message from the given peer.
1504 fn handle_update_add_htlc(&self, their_node_id: &PublicKey, msg: &UpdateAddHTLC);
1505 /// Handle an incoming `update_fulfill_htlc` message from the given peer.
1506 fn handle_update_fulfill_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFulfillHTLC);
1507 /// Handle an incoming `update_fail_htlc` message from the given peer.
1508 fn handle_update_fail_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailHTLC);
1509 /// Handle an incoming `update_fail_malformed_htlc` message from the given peer.
1510 fn handle_update_fail_malformed_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailMalformedHTLC);
1511 /// Handle an incoming `commitment_signed` message from the given peer.
1512 fn handle_commitment_signed(&self, their_node_id: &PublicKey, msg: &CommitmentSigned);
1513 /// Handle an incoming `revoke_and_ack` message from the given peer.
1514 fn handle_revoke_and_ack(&self, their_node_id: &PublicKey, msg: &RevokeAndACK);
1516 /// Handle an incoming `update_fee` message from the given peer.
1517 fn handle_update_fee(&self, their_node_id: &PublicKey, msg: &UpdateFee);
1519 // Channel-to-announce:
1520 /// Handle an incoming `announcement_signatures` message from the given peer.
1521 fn handle_announcement_signatures(&self, their_node_id: &PublicKey, msg: &AnnouncementSignatures);
1523 // Connection loss/reestablish:
1524 /// Indicates a connection to the peer failed/an existing connection was lost.
1525 fn peer_disconnected(&self, their_node_id: &PublicKey);
1527 /// Handle a peer reconnecting, possibly generating `channel_reestablish` message(s).
1529 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1530 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1531 /// message handlers may still wish to communicate with this peer.
1532 fn peer_connected(&self, their_node_id: &PublicKey, msg: &Init, inbound: bool) -> Result<(), ()>;
1533 /// Handle an incoming `channel_reestablish` message from the given peer.
1534 fn handle_channel_reestablish(&self, their_node_id: &PublicKey, msg: &ChannelReestablish);
1536 /// Handle an incoming `channel_update` message from the given peer.
1537 fn handle_channel_update(&self, their_node_id: &PublicKey, msg: &ChannelUpdate);
1540 /// Handle an incoming `error` message from the given peer.
1541 fn handle_error(&self, their_node_id: &PublicKey, msg: &ErrorMessage);
1543 // Handler information:
1544 /// Gets the node feature flags which this handler itself supports. All available handlers are
1545 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1546 /// which are broadcasted in our [`NodeAnnouncement`] message.
1547 fn provided_node_features(&self) -> NodeFeatures;
1549 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1550 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1551 /// which are sent in our [`Init`] message.
1553 /// Note that this method is called before [`Self::peer_connected`].
1554 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1556 /// Gets the chain hashes for this `ChannelMessageHandler` indicating which chains it supports.
1558 /// If it's `None`, then no particular network chain hash compatibility will be enforced when
1559 /// connecting to peers.
1560 fn get_chain_hashes(&self) -> Option<Vec<ChainHash>>;
1563 /// A trait to describe an object which can receive routing messages.
1565 /// # Implementor DoS Warnings
1567 /// For messages enabled with the `gossip_queries` feature there are potential DoS vectors when
1568 /// handling inbound queries. Implementors using an on-disk network graph should be aware of
1569 /// repeated disk I/O for queries accessing different parts of the network graph.
1570 pub trait RoutingMessageHandler : MessageSendEventsProvider {
1571 /// Handle an incoming `node_announcement` message, returning `true` if it should be forwarded on,
1572 /// `false` or returning an `Err` otherwise.
1573 fn handle_node_announcement(&self, msg: &NodeAnnouncement) -> Result<bool, LightningError>;
1574 /// Handle a `channel_announcement` message, returning `true` if it should be forwarded on, `false`
1575 /// or returning an `Err` otherwise.
1576 fn handle_channel_announcement(&self, msg: &ChannelAnnouncement) -> Result<bool, LightningError>;
1577 /// Handle an incoming `channel_update` message, returning true if it should be forwarded on,
1578 /// `false` or returning an `Err` otherwise.
1579 fn handle_channel_update(&self, msg: &ChannelUpdate) -> Result<bool, LightningError>;
1580 /// Gets channel announcements and updates required to dump our routing table to a remote node,
1581 /// starting at the `short_channel_id` indicated by `starting_point` and including announcements
1582 /// for a single channel.
1583 fn get_next_channel_announcement(&self, starting_point: u64) -> Option<(ChannelAnnouncement, Option<ChannelUpdate>, Option<ChannelUpdate>)>;
1584 /// Gets a node announcement required to dump our routing table to a remote node, starting at
1585 /// the node *after* the provided pubkey and including up to one announcement immediately
1586 /// higher (as defined by `<PublicKey as Ord>::cmp`) than `starting_point`.
1587 /// If `None` is provided for `starting_point`, we start at the first node.
1588 fn get_next_node_announcement(&self, starting_point: Option<&NodeId>) -> Option<NodeAnnouncement>;
1589 /// Called when a connection is established with a peer. This can be used to
1590 /// perform routing table synchronization using a strategy defined by the
1593 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1594 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1595 /// message handlers may still wish to communicate with this peer.
1596 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1597 /// Handles the reply of a query we initiated to learn about channels
1598 /// for a given range of blocks. We can expect to receive one or more
1599 /// replies to a single query.
1600 fn handle_reply_channel_range(&self, their_node_id: &PublicKey, msg: ReplyChannelRange) -> Result<(), LightningError>;
1601 /// Handles the reply of a query we initiated asking for routing gossip
1602 /// messages for a list of channels. We should receive this message when
1603 /// a node has completed its best effort to send us the pertaining routing
1604 /// gossip messages.
1605 fn handle_reply_short_channel_ids_end(&self, their_node_id: &PublicKey, msg: ReplyShortChannelIdsEnd) -> Result<(), LightningError>;
1606 /// Handles when a peer asks us to send a list of `short_channel_id`s
1607 /// for the requested range of blocks.
1608 fn handle_query_channel_range(&self, their_node_id: &PublicKey, msg: QueryChannelRange) -> Result<(), LightningError>;
1609 /// Handles when a peer asks us to send routing gossip messages for a
1610 /// list of `short_channel_id`s.
1611 fn handle_query_short_channel_ids(&self, their_node_id: &PublicKey, msg: QueryShortChannelIds) -> Result<(), LightningError>;
1613 // Handler queueing status:
1614 /// Indicates that there are a large number of [`ChannelAnnouncement`] (or other) messages
1615 /// pending some async action. While there is no guarantee of the rate of future messages, the
1616 /// caller should seek to reduce the rate of new gossip messages handled, especially
1617 /// [`ChannelAnnouncement`]s.
1618 fn processing_queue_high(&self) -> bool;
1620 // Handler information:
1621 /// Gets the node feature flags which this handler itself supports. All available handlers are
1622 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1623 /// which are broadcasted in our [`NodeAnnouncement`] message.
1624 fn provided_node_features(&self) -> NodeFeatures;
1625 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1626 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1627 /// which are sent in our [`Init`] message.
1629 /// Note that this method is called before [`Self::peer_connected`].
1630 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1633 /// A handler for received [`OnionMessage`]s and for providing generated ones to send.
1634 pub trait OnionMessageHandler {
1635 /// Handle an incoming `onion_message` message from the given peer.
1636 fn handle_onion_message(&self, peer_node_id: &PublicKey, msg: &OnionMessage);
1638 /// Returns the next pending onion message for the peer with the given node id.
1639 fn next_onion_message_for_peer(&self, peer_node_id: PublicKey) -> Option<OnionMessage>;
1641 /// Called when a connection is established with a peer. Can be used to track which peers
1642 /// advertise onion message support and are online.
1644 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1645 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1646 /// message handlers may still wish to communicate with this peer.
1647 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1649 /// Indicates a connection to the peer failed/an existing connection was lost. Allows handlers to
1650 /// drop and refuse to forward onion messages to this peer.
1651 fn peer_disconnected(&self, their_node_id: &PublicKey);
1653 // Handler information:
1654 /// Gets the node feature flags which this handler itself supports. All available handlers are
1655 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1656 /// which are broadcasted in our [`NodeAnnouncement`] message.
1657 fn provided_node_features(&self) -> NodeFeatures;
1659 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1660 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1661 /// which are sent in our [`Init`] message.
1663 /// Note that this method is called before [`Self::peer_connected`].
1664 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1667 mod fuzzy_internal_msgs {
1668 use bitcoin::secp256k1::PublicKey;
1669 use crate::blinded_path::payment::PaymentConstraints;
1670 use crate::prelude::*;
1671 use crate::ln::{PaymentPreimage, PaymentSecret};
1673 // These types aren't intended to be pub, but are exposed for direct fuzzing (as we deserialize
1674 // them from untrusted input):
1676 pub struct FinalOnionHopData {
1677 pub payment_secret: PaymentSecret,
1678 /// The total value, in msat, of the payment as received by the ultimate recipient.
1679 /// Message serialization may panic if this value is more than 21 million Bitcoin.
1680 pub total_msat: u64,
1683 pub enum InboundOnionPayload {
1685 short_channel_id: u64,
1686 /// The value, in msat, of the payment after this hop's fee is deducted.
1687 amt_to_forward: u64,
1688 outgoing_cltv_value: u32,
1691 payment_data: Option<FinalOnionHopData>,
1692 payment_metadata: Option<Vec<u8>>,
1693 keysend_preimage: Option<PaymentPreimage>,
1694 custom_tlvs: Vec<(u64, Vec<u8>)>,
1696 outgoing_cltv_value: u32,
1701 outgoing_cltv_value: u32,
1702 payment_secret: PaymentSecret,
1703 payment_constraints: PaymentConstraints,
1704 intro_node_blinding_point: PublicKey,
1708 pub(crate) enum OutboundOnionPayload {
1710 short_channel_id: u64,
1711 /// The value, in msat, of the payment after this hop's fee is deducted.
1712 amt_to_forward: u64,
1713 outgoing_cltv_value: u32,
1716 payment_data: Option<FinalOnionHopData>,
1717 payment_metadata: Option<Vec<u8>>,
1718 keysend_preimage: Option<PaymentPreimage>,
1719 custom_tlvs: Vec<(u64, Vec<u8>)>,
1721 outgoing_cltv_value: u32,
1724 encrypted_tlvs: Vec<u8>,
1725 intro_node_blinding_point: Option<PublicKey>,
1730 outgoing_cltv_value: u32,
1731 encrypted_tlvs: Vec<u8>,
1732 intro_node_blinding_point: Option<PublicKey>, // Set if the introduction node of the blinded path is the final node
1736 pub struct DecodedOnionErrorPacket {
1737 pub(crate) hmac: [u8; 32],
1738 pub(crate) failuremsg: Vec<u8>,
1739 pub(crate) pad: Vec<u8>,
1743 pub use self::fuzzy_internal_msgs::*;
1744 #[cfg(not(fuzzing))]
1745 pub(crate) use self::fuzzy_internal_msgs::*;
1747 /// BOLT 4 onion packet including hop data for the next peer.
1748 #[derive(Clone, Hash, PartialEq, Eq)]
1749 pub struct OnionPacket {
1750 /// BOLT 4 version number.
1752 /// In order to ensure we always return an error on onion decode in compliance with [BOLT
1753 /// #4](https://github.com/lightning/bolts/blob/master/04-onion-routing.md), we have to
1754 /// deserialize `OnionPacket`s contained in [`UpdateAddHTLC`] messages even if the ephemeral
1755 /// public key (here) is bogus, so we hold a [`Result`] instead of a [`PublicKey`] as we'd
1757 pub public_key: Result<PublicKey, secp256k1::Error>,
1758 /// 1300 bytes encrypted payload for the next hop.
1759 pub hop_data: [u8; 20*65],
1760 /// HMAC to verify the integrity of hop_data.
1764 impl onion_utils::Packet for OnionPacket {
1765 type Data = onion_utils::FixedSizeOnionPacket;
1766 fn new(pubkey: PublicKey, hop_data: onion_utils::FixedSizeOnionPacket, hmac: [u8; 32]) -> Self {
1769 public_key: Ok(pubkey),
1770 hop_data: hop_data.0,
1776 impl fmt::Debug for OnionPacket {
1777 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1778 f.write_fmt(format_args!("OnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
1782 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1783 pub(crate) struct OnionErrorPacket {
1784 // This really should be a constant size slice, but the spec lets these things be up to 128KB?
1785 // (TODO) We limit it in decode to much lower...
1786 pub(crate) data: Vec<u8>,
1789 impl fmt::Display for DecodeError {
1790 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1792 DecodeError::UnknownVersion => f.write_str("Unknown realm byte in Onion packet"),
1793 DecodeError::UnknownRequiredFeature => f.write_str("Unknown required feature preventing decode"),
1794 DecodeError::InvalidValue => f.write_str("Nonsense bytes didn't map to the type they were interpreted as"),
1795 DecodeError::ShortRead => f.write_str("Packet extended beyond the provided bytes"),
1796 DecodeError::BadLengthDescriptor => f.write_str("A length descriptor in the packet didn't describe the later data correctly"),
1797 DecodeError::Io(ref e) => fmt::Debug::fmt(e, f),
1798 DecodeError::UnsupportedCompression => f.write_str("We don't support receiving messages with zlib-compressed fields"),
1803 impl From<io::Error> for DecodeError {
1804 fn from(e: io::Error) -> Self {
1805 if e.kind() == io::ErrorKind::UnexpectedEof {
1806 DecodeError::ShortRead
1808 DecodeError::Io(e.kind())
1813 #[cfg(not(taproot))]
1814 impl_writeable_msg!(AcceptChannel, {
1815 temporary_channel_id,
1816 dust_limit_satoshis,
1817 max_htlc_value_in_flight_msat,
1818 channel_reserve_satoshis,
1824 revocation_basepoint,
1826 delayed_payment_basepoint,
1828 first_per_commitment_point,
1830 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))), // Don't encode length twice.
1831 (1, channel_type, option),
1835 impl_writeable_msg!(AcceptChannel, {
1836 temporary_channel_id,
1837 dust_limit_satoshis,
1838 max_htlc_value_in_flight_msat,
1839 channel_reserve_satoshis,
1845 revocation_basepoint,
1847 delayed_payment_basepoint,
1849 first_per_commitment_point,
1851 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))), // Don't encode length twice.
1852 (1, channel_type, option),
1853 (4, next_local_nonce, option),
1856 impl_writeable_msg!(AcceptChannelV2, {
1857 temporary_channel_id,
1859 dust_limit_satoshis,
1860 max_htlc_value_in_flight_msat,
1866 revocation_basepoint,
1868 delayed_payment_basepoint,
1870 first_per_commitment_point,
1871 second_per_commitment_point,
1873 (0, shutdown_scriptpubkey, option),
1874 (1, channel_type, option),
1875 (2, require_confirmed_inputs, option),
1878 impl_writeable_msg!(Stfu, {
1883 impl_writeable_msg!(Splice, {
1887 funding_feerate_perkw,
1892 impl_writeable_msg!(SpliceAck, {
1899 impl_writeable_msg!(SpliceLocked, {
1903 impl_writeable_msg!(TxAddInput, {
1911 impl_writeable_msg!(TxAddOutput, {
1918 impl_writeable_msg!(TxRemoveInput, {
1923 impl_writeable_msg!(TxRemoveOutput, {
1928 impl_writeable_msg!(TxComplete, {
1932 impl_writeable_msg!(TxSignatures, {
1938 impl_writeable_msg!(TxInitRbf, {
1941 feerate_sat_per_1000_weight,
1943 (0, funding_output_contribution, option),
1946 impl_writeable_msg!(TxAckRbf, {
1949 (0, funding_output_contribution, option),
1952 impl_writeable_msg!(TxAbort, {
1957 impl_writeable_msg!(AnnouncementSignatures, {
1964 impl_writeable_msg!(ChannelReestablish, {
1966 next_local_commitment_number,
1967 next_remote_commitment_number,
1968 your_last_per_commitment_secret,
1969 my_current_per_commitment_point,
1971 (0, next_funding_txid, option),
1974 impl_writeable_msg!(ClosingSigned,
1975 { channel_id, fee_satoshis, signature },
1976 { (1, fee_range, option) }
1979 impl_writeable!(ClosingSignedFeeRange, {
1984 #[cfg(not(taproot))]
1985 impl_writeable_msg!(CommitmentSigned, {
1992 impl_writeable_msg!(CommitmentSigned, {
1997 (2, partial_signature_with_nonce, option)
2000 impl_writeable!(DecodedOnionErrorPacket, {
2006 #[cfg(not(taproot))]
2007 impl_writeable_msg!(FundingCreated, {
2008 temporary_channel_id,
2010 funding_output_index,
2014 impl_writeable_msg!(FundingCreated, {
2015 temporary_channel_id,
2017 funding_output_index,
2020 (2, partial_signature_with_nonce, option),
2021 (4, next_local_nonce, option)
2024 #[cfg(not(taproot))]
2025 impl_writeable_msg!(FundingSigned, {
2031 impl_writeable_msg!(FundingSigned, {
2035 (2, partial_signature_with_nonce, option)
2038 impl_writeable_msg!(ChannelReady, {
2040 next_per_commitment_point,
2042 (1, short_channel_id_alias, option),
2045 impl Writeable for Init {
2046 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2047 // global_features gets the bottom 13 bits of our features, and local_features gets all of
2048 // our relevant feature bits. This keeps us compatible with old nodes.
2049 self.features.write_up_to_13(w)?;
2050 self.features.write(w)?;
2051 encode_tlv_stream!(w, {
2052 (1, self.networks.as_ref().map(|n| WithoutLength(n)), option),
2053 (3, self.remote_network_address, option),
2059 impl Readable for Init {
2060 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2061 let global_features: InitFeatures = Readable::read(r)?;
2062 let features: InitFeatures = Readable::read(r)?;
2063 let mut remote_network_address: Option<SocketAddress> = None;
2064 let mut networks: Option<WithoutLength<Vec<ChainHash>>> = None;
2065 decode_tlv_stream!(r, {
2066 (1, networks, option),
2067 (3, remote_network_address, option)
2070 features: features | global_features,
2071 networks: networks.map(|n| n.0),
2072 remote_network_address,
2077 impl_writeable_msg!(OpenChannel, {
2079 temporary_channel_id,
2082 dust_limit_satoshis,
2083 max_htlc_value_in_flight_msat,
2084 channel_reserve_satoshis,
2090 revocation_basepoint,
2092 delayed_payment_basepoint,
2094 first_per_commitment_point,
2097 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))), // Don't encode length twice.
2098 (1, channel_type, option),
2101 impl_writeable_msg!(OpenChannelV2, {
2103 temporary_channel_id,
2104 funding_feerate_sat_per_1000_weight,
2105 commitment_feerate_sat_per_1000_weight,
2107 dust_limit_satoshis,
2108 max_htlc_value_in_flight_msat,
2114 revocation_basepoint,
2116 delayed_payment_basepoint,
2118 first_per_commitment_point,
2119 second_per_commitment_point,
2122 (0, shutdown_scriptpubkey, option),
2123 (1, channel_type, option),
2124 (2, require_confirmed_inputs, option),
2127 #[cfg(not(taproot))]
2128 impl_writeable_msg!(RevokeAndACK, {
2130 per_commitment_secret,
2131 next_per_commitment_point
2135 impl_writeable_msg!(RevokeAndACK, {
2137 per_commitment_secret,
2138 next_per_commitment_point
2140 (4, next_local_nonce, option)
2143 impl_writeable_msg!(Shutdown, {
2148 impl_writeable_msg!(UpdateFailHTLC, {
2154 impl_writeable_msg!(UpdateFailMalformedHTLC, {
2161 impl_writeable_msg!(UpdateFee, {
2166 impl_writeable_msg!(UpdateFulfillHTLC, {
2172 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2173 // serialization format in a way which assumes we know the total serialized length/message end
2175 impl_writeable!(OnionErrorPacket, {
2179 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2180 // serialization format in a way which assumes we know the total serialized length/message end
2182 impl Writeable for OnionPacket {
2183 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2184 self.version.write(w)?;
2185 match self.public_key {
2186 Ok(pubkey) => pubkey.write(w)?,
2187 Err(_) => [0u8;33].write(w)?,
2189 w.write_all(&self.hop_data)?;
2190 self.hmac.write(w)?;
2195 impl Readable for OnionPacket {
2196 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2198 version: Readable::read(r)?,
2200 let mut buf = [0u8;33];
2201 r.read_exact(&mut buf)?;
2202 PublicKey::from_slice(&buf)
2204 hop_data: Readable::read(r)?,
2205 hmac: Readable::read(r)?,
2210 impl_writeable_msg!(UpdateAddHTLC, {
2216 onion_routing_packet,
2218 (0, blinding_point, option),
2219 (65537, skimmed_fee_msat, option)
2222 impl Readable for OnionMessage {
2223 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2224 let blinding_point: PublicKey = Readable::read(r)?;
2225 let len: u16 = Readable::read(r)?;
2226 let mut packet_reader = FixedLengthReader::new(r, len as u64);
2227 let onion_routing_packet: onion_message::Packet = <onion_message::Packet as LengthReadable>::read(&mut packet_reader)?;
2230 onion_routing_packet,
2235 impl Writeable for OnionMessage {
2236 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2237 self.blinding_point.write(w)?;
2238 let onion_packet_len = self.onion_routing_packet.serialized_length();
2239 (onion_packet_len as u16).write(w)?;
2240 self.onion_routing_packet.write(w)?;
2245 impl Writeable for FinalOnionHopData {
2246 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2247 self.payment_secret.0.write(w)?;
2248 HighZeroBytesDroppedBigSize(self.total_msat).write(w)
2252 impl Readable for FinalOnionHopData {
2253 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2254 let secret: [u8; 32] = Readable::read(r)?;
2255 let amt: HighZeroBytesDroppedBigSize<u64> = Readable::read(r)?;
2256 Ok(Self { payment_secret: PaymentSecret(secret), total_msat: amt.0 })
2260 impl Writeable for OutboundOnionPayload {
2261 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2263 Self::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } => {
2264 _encode_varint_length_prefixed_tlv!(w, {
2265 (2, HighZeroBytesDroppedBigSize(*amt_to_forward), required),
2266 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2267 (6, short_channel_id, required)
2271 ref payment_data, ref payment_metadata, ref keysend_preimage, amt_msat,
2272 outgoing_cltv_value, ref custom_tlvs,
2274 // We need to update [`ln::outbound_payment::RecipientOnionFields::with_custom_tlvs`]
2275 // to reject any reserved types in the experimental range if new ones are ever
2277 let keysend_tlv = keysend_preimage.map(|preimage| (5482373484, preimage.encode()));
2278 let mut custom_tlvs: Vec<&(u64, Vec<u8>)> = custom_tlvs.iter().chain(keysend_tlv.iter()).collect();
2279 custom_tlvs.sort_unstable_by_key(|(typ, _)| *typ);
2280 _encode_varint_length_prefixed_tlv!(w, {
2281 (2, HighZeroBytesDroppedBigSize(*amt_msat), required),
2282 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2283 (8, payment_data, option),
2284 (16, payment_metadata.as_ref().map(|m| WithoutLength(m)), option)
2285 }, custom_tlvs.iter());
2287 Self::BlindedForward { encrypted_tlvs, intro_node_blinding_point } => {
2288 _encode_varint_length_prefixed_tlv!(w, {
2289 (10, *encrypted_tlvs, required_vec),
2290 (12, intro_node_blinding_point, option)
2293 Self::BlindedReceive {
2294 amt_msat, total_msat, outgoing_cltv_value, encrypted_tlvs,
2295 intro_node_blinding_point,
2297 _encode_varint_length_prefixed_tlv!(w, {
2298 (2, HighZeroBytesDroppedBigSize(*amt_msat), required),
2299 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2300 (10, *encrypted_tlvs, required_vec),
2301 (12, intro_node_blinding_point, option),
2302 (18, HighZeroBytesDroppedBigSize(*total_msat), required)
2310 impl<NS: Deref> ReadableArgs<&NS> for InboundOnionPayload where NS::Target: NodeSigner {
2311 fn read<R: Read>(r: &mut R, node_signer: &NS) -> Result<Self, DecodeError> {
2313 let mut cltv_value = None;
2314 let mut short_id: Option<u64> = None;
2315 let mut payment_data: Option<FinalOnionHopData> = None;
2316 let mut encrypted_tlvs_opt: Option<WithoutLength<Vec<u8>>> = None;
2317 let mut intro_node_blinding_point = None;
2318 let mut payment_metadata: Option<WithoutLength<Vec<u8>>> = None;
2319 let mut total_msat = None;
2320 let mut keysend_preimage: Option<PaymentPreimage> = None;
2321 let mut custom_tlvs = Vec::new();
2323 let tlv_len = BigSize::read(r)?;
2324 let rd = FixedLengthReader::new(r, tlv_len.0);
2325 decode_tlv_stream_with_custom_tlv_decode!(rd, {
2326 (2, amt, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2327 (4, cltv_value, (option, encoding: (u32, HighZeroBytesDroppedBigSize))),
2328 (6, short_id, option),
2329 (8, payment_data, option),
2330 (10, encrypted_tlvs_opt, option),
2331 (12, intro_node_blinding_point, option),
2332 (16, payment_metadata, option),
2333 (18, total_msat, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2334 // See https://github.com/lightning/blips/blob/master/blip-0003.md
2335 (5482373484, keysend_preimage, option)
2336 }, |msg_type: u64, msg_reader: &mut FixedLengthReader<_>| -> Result<bool, DecodeError> {
2337 if msg_type < 1 << 16 { return Ok(false) }
2338 let mut value = Vec::new();
2339 msg_reader.read_to_end(&mut value)?;
2340 custom_tlvs.push((msg_type, value));
2344 if amt.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2346 if let Some(blinding_point) = intro_node_blinding_point {
2347 if short_id.is_some() || payment_data.is_some() || payment_metadata.is_some() {
2348 return Err(DecodeError::InvalidValue)
2350 let enc_tlvs = encrypted_tlvs_opt.ok_or(DecodeError::InvalidValue)?.0;
2351 let enc_tlvs_ss = node_signer.ecdh(Recipient::Node, &blinding_point, None)
2352 .map_err(|_| DecodeError::InvalidValue)?;
2353 let rho = onion_utils::gen_rho_from_shared_secret(&enc_tlvs_ss.secret_bytes());
2354 let mut s = Cursor::new(&enc_tlvs);
2355 let mut reader = FixedLengthReader::new(&mut s, enc_tlvs.len() as u64);
2356 match ChaChaPolyReadAdapter::read(&mut reader, rho)? {
2357 ChaChaPolyReadAdapter { readable: ReceiveTlvs { payment_secret, payment_constraints }} => {
2358 if total_msat.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2359 Ok(Self::BlindedReceive {
2360 amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2361 total_msat: total_msat.ok_or(DecodeError::InvalidValue)?,
2362 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2364 payment_constraints,
2365 intro_node_blinding_point: blinding_point,
2369 } else if let Some(short_channel_id) = short_id {
2370 if payment_data.is_some() || payment_metadata.is_some() || encrypted_tlvs_opt.is_some() ||
2371 total_msat.is_some()
2372 { return Err(DecodeError::InvalidValue) }
2375 amt_to_forward: amt.ok_or(DecodeError::InvalidValue)?,
2376 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2379 if encrypted_tlvs_opt.is_some() || total_msat.is_some() {
2380 return Err(DecodeError::InvalidValue)
2382 if let Some(data) = &payment_data {
2383 if data.total_msat > MAX_VALUE_MSAT {
2384 return Err(DecodeError::InvalidValue);
2389 payment_metadata: payment_metadata.map(|w| w.0),
2391 amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2392 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2399 impl Writeable for Ping {
2400 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2401 self.ponglen.write(w)?;
2402 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2407 impl Readable for Ping {
2408 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2410 ponglen: Readable::read(r)?,
2412 let byteslen = Readable::read(r)?;
2413 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2420 impl Writeable for Pong {
2421 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2422 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2427 impl Readable for Pong {
2428 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2431 let byteslen = Readable::read(r)?;
2432 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2439 impl Writeable for UnsignedChannelAnnouncement {
2440 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2441 self.features.write(w)?;
2442 self.chain_hash.write(w)?;
2443 self.short_channel_id.write(w)?;
2444 self.node_id_1.write(w)?;
2445 self.node_id_2.write(w)?;
2446 self.bitcoin_key_1.write(w)?;
2447 self.bitcoin_key_2.write(w)?;
2448 w.write_all(&self.excess_data[..])?;
2453 impl Readable for UnsignedChannelAnnouncement {
2454 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2456 features: Readable::read(r)?,
2457 chain_hash: Readable::read(r)?,
2458 short_channel_id: Readable::read(r)?,
2459 node_id_1: Readable::read(r)?,
2460 node_id_2: Readable::read(r)?,
2461 bitcoin_key_1: Readable::read(r)?,
2462 bitcoin_key_2: Readable::read(r)?,
2463 excess_data: read_to_end(r)?,
2468 impl_writeable!(ChannelAnnouncement, {
2471 bitcoin_signature_1,
2472 bitcoin_signature_2,
2476 impl Writeable for UnsignedChannelUpdate {
2477 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2478 // `message_flags` used to indicate presence of `htlc_maximum_msat`, but was deprecated in the spec.
2479 const MESSAGE_FLAGS: u8 = 1;
2480 self.chain_hash.write(w)?;
2481 self.short_channel_id.write(w)?;
2482 self.timestamp.write(w)?;
2483 let all_flags = self.flags as u16 | ((MESSAGE_FLAGS as u16) << 8);
2484 all_flags.write(w)?;
2485 self.cltv_expiry_delta.write(w)?;
2486 self.htlc_minimum_msat.write(w)?;
2487 self.fee_base_msat.write(w)?;
2488 self.fee_proportional_millionths.write(w)?;
2489 self.htlc_maximum_msat.write(w)?;
2490 w.write_all(&self.excess_data[..])?;
2495 impl Readable for UnsignedChannelUpdate {
2496 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2498 chain_hash: Readable::read(r)?,
2499 short_channel_id: Readable::read(r)?,
2500 timestamp: Readable::read(r)?,
2502 let flags: u16 = Readable::read(r)?;
2503 // Note: we ignore the `message_flags` for now, since it was deprecated by the spec.
2506 cltv_expiry_delta: Readable::read(r)?,
2507 htlc_minimum_msat: Readable::read(r)?,
2508 fee_base_msat: Readable::read(r)?,
2509 fee_proportional_millionths: Readable::read(r)?,
2510 htlc_maximum_msat: Readable::read(r)?,
2511 excess_data: read_to_end(r)?,
2516 impl_writeable!(ChannelUpdate, {
2521 impl Writeable for ErrorMessage {
2522 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2523 self.channel_id.write(w)?;
2524 (self.data.len() as u16).write(w)?;
2525 w.write_all(self.data.as_bytes())?;
2530 impl Readable for ErrorMessage {
2531 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2533 channel_id: Readable::read(r)?,
2535 let sz: usize = <u16 as Readable>::read(r)? as usize;
2536 let mut data = Vec::with_capacity(sz);
2538 r.read_exact(&mut data)?;
2539 match String::from_utf8(data) {
2541 Err(_) => return Err(DecodeError::InvalidValue),
2548 impl Writeable for WarningMessage {
2549 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2550 self.channel_id.write(w)?;
2551 (self.data.len() as u16).write(w)?;
2552 w.write_all(self.data.as_bytes())?;
2557 impl Readable for WarningMessage {
2558 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2560 channel_id: Readable::read(r)?,
2562 let sz: usize = <u16 as Readable>::read(r)? as usize;
2563 let mut data = Vec::with_capacity(sz);
2565 r.read_exact(&mut data)?;
2566 match String::from_utf8(data) {
2568 Err(_) => return Err(DecodeError::InvalidValue),
2575 impl Writeable for UnsignedNodeAnnouncement {
2576 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2577 self.features.write(w)?;
2578 self.timestamp.write(w)?;
2579 self.node_id.write(w)?;
2580 w.write_all(&self.rgb)?;
2581 self.alias.write(w)?;
2583 let mut addr_len = 0;
2584 for addr in self.addresses.iter() {
2585 addr_len += 1 + addr.len();
2587 (addr_len + self.excess_address_data.len() as u16).write(w)?;
2588 for addr in self.addresses.iter() {
2591 w.write_all(&self.excess_address_data[..])?;
2592 w.write_all(&self.excess_data[..])?;
2597 impl Readable for UnsignedNodeAnnouncement {
2598 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2599 let features: NodeFeatures = Readable::read(r)?;
2600 let timestamp: u32 = Readable::read(r)?;
2601 let node_id: NodeId = Readable::read(r)?;
2602 let mut rgb = [0; 3];
2603 r.read_exact(&mut rgb)?;
2604 let alias: NodeAlias = Readable::read(r)?;
2606 let addr_len: u16 = Readable::read(r)?;
2607 let mut addresses: Vec<SocketAddress> = Vec::new();
2608 let mut addr_readpos = 0;
2609 let mut excess = false;
2610 let mut excess_byte = 0;
2612 if addr_len <= addr_readpos { break; }
2613 match Readable::read(r) {
2615 if addr_len < addr_readpos + 1 + addr.len() {
2616 return Err(DecodeError::BadLengthDescriptor);
2618 addr_readpos += (1 + addr.len()) as u16;
2619 addresses.push(addr);
2621 Ok(Err(unknown_descriptor)) => {
2623 excess_byte = unknown_descriptor;
2626 Err(DecodeError::ShortRead) => return Err(DecodeError::BadLengthDescriptor),
2627 Err(e) => return Err(e),
2631 let mut excess_data = vec![];
2632 let excess_address_data = if addr_readpos < addr_len {
2633 let mut excess_address_data = vec![0; (addr_len - addr_readpos) as usize];
2634 r.read_exact(&mut excess_address_data[if excess { 1 } else { 0 }..])?;
2636 excess_address_data[0] = excess_byte;
2641 excess_data.push(excess_byte);
2645 excess_data.extend(read_to_end(r)?.iter());
2646 Ok(UnsignedNodeAnnouncement {
2653 excess_address_data,
2659 impl_writeable!(NodeAnnouncement, {
2664 impl Readable for QueryShortChannelIds {
2665 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2666 let chain_hash: ChainHash = Readable::read(r)?;
2668 let encoding_len: u16 = Readable::read(r)?;
2669 let encoding_type: u8 = Readable::read(r)?;
2671 // Must be encoding_type=0 uncompressed serialization. We do not
2672 // support encoding_type=1 zlib serialization.
2673 if encoding_type != EncodingType::Uncompressed as u8 {
2674 return Err(DecodeError::UnsupportedCompression);
2677 // We expect the encoding_len to always includes the 1-byte
2678 // encoding_type and that short_channel_ids are 8-bytes each
2679 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2680 return Err(DecodeError::InvalidValue);
2683 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2684 // less the 1-byte encoding_type
2685 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2686 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2687 for _ in 0..short_channel_id_count {
2688 short_channel_ids.push(Readable::read(r)?);
2691 Ok(QueryShortChannelIds {
2698 impl Writeable for QueryShortChannelIds {
2699 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2700 // Calculated from 1-byte encoding_type plus 8-bytes per short_channel_id
2701 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2703 self.chain_hash.write(w)?;
2704 encoding_len.write(w)?;
2706 // We only support type=0 uncompressed serialization
2707 (EncodingType::Uncompressed as u8).write(w)?;
2709 for scid in self.short_channel_ids.iter() {
2717 impl_writeable_msg!(ReplyShortChannelIdsEnd, {
2722 impl QueryChannelRange {
2723 /// Calculates the overflow safe ending block height for the query.
2725 /// Overflow returns `0xffffffff`, otherwise returns `first_blocknum + number_of_blocks`.
2726 pub fn end_blocknum(&self) -> u32 {
2727 match self.first_blocknum.checked_add(self.number_of_blocks) {
2728 Some(block) => block,
2729 None => u32::max_value(),
2734 impl_writeable_msg!(QueryChannelRange, {
2740 impl Readable for ReplyChannelRange {
2741 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2742 let chain_hash: ChainHash = Readable::read(r)?;
2743 let first_blocknum: u32 = Readable::read(r)?;
2744 let number_of_blocks: u32 = Readable::read(r)?;
2745 let sync_complete: bool = Readable::read(r)?;
2747 let encoding_len: u16 = Readable::read(r)?;
2748 let encoding_type: u8 = Readable::read(r)?;
2750 // Must be encoding_type=0 uncompressed serialization. We do not
2751 // support encoding_type=1 zlib serialization.
2752 if encoding_type != EncodingType::Uncompressed as u8 {
2753 return Err(DecodeError::UnsupportedCompression);
2756 // We expect the encoding_len to always includes the 1-byte
2757 // encoding_type and that short_channel_ids are 8-bytes each
2758 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2759 return Err(DecodeError::InvalidValue);
2762 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2763 // less the 1-byte encoding_type
2764 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2765 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2766 for _ in 0..short_channel_id_count {
2767 short_channel_ids.push(Readable::read(r)?);
2770 Ok(ReplyChannelRange {
2780 impl Writeable for ReplyChannelRange {
2781 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2782 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2783 self.chain_hash.write(w)?;
2784 self.first_blocknum.write(w)?;
2785 self.number_of_blocks.write(w)?;
2786 self.sync_complete.write(w)?;
2788 encoding_len.write(w)?;
2789 (EncodingType::Uncompressed as u8).write(w)?;
2790 for scid in self.short_channel_ids.iter() {
2798 impl_writeable_msg!(GossipTimestampFilter, {
2806 use std::convert::TryFrom;
2807 use bitcoin::{Transaction, TxIn, ScriptBuf, Sequence, Witness, TxOut};
2808 use hex::DisplayHex;
2809 use crate::ln::{PaymentPreimage, PaymentHash, PaymentSecret};
2810 use crate::ln::ChannelId;
2811 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
2812 use crate::ln::msgs::{self, FinalOnionHopData, OnionErrorPacket};
2813 use crate::ln::msgs::SocketAddress;
2814 use crate::routing::gossip::{NodeAlias, NodeId};
2815 use crate::util::ser::{Writeable, Readable, ReadableArgs, Hostname, TransactionU16LenLimited};
2816 use crate::util::test_utils;
2818 use bitcoin::hashes::hex::FromHex;
2819 use bitcoin::address::Address;
2820 use bitcoin::network::constants::Network;
2821 use bitcoin::blockdata::constants::ChainHash;
2822 use bitcoin::blockdata::script::Builder;
2823 use bitcoin::blockdata::opcodes;
2824 use bitcoin::hash_types::Txid;
2825 use bitcoin::locktime::absolute::LockTime;
2827 use bitcoin::secp256k1::{PublicKey,SecretKey};
2828 use bitcoin::secp256k1::{Secp256k1, Message};
2830 use crate::io::{self, Cursor};
2831 use crate::prelude::*;
2832 use core::str::FromStr;
2833 use crate::chain::transaction::OutPoint;
2835 #[cfg(feature = "std")]
2836 use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6, ToSocketAddrs};
2837 #[cfg(feature = "std")]
2838 use crate::ln::msgs::SocketAddressParseError;
2841 fn encoding_channel_reestablish() {
2843 let secp_ctx = Secp256k1::new();
2844 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&<Vec<u8>>::from_hex("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2847 let cr = msgs::ChannelReestablish {
2848 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]),
2849 next_local_commitment_number: 3,
2850 next_remote_commitment_number: 4,
2851 your_last_per_commitment_secret: [9;32],
2852 my_current_per_commitment_point: public_key,
2853 next_funding_txid: None,
2856 let encoded_value = cr.encode();
2860 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
2861 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2862 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2863 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
2864 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
2870 fn encoding_channel_reestablish_with_next_funding_txid() {
2872 let secp_ctx = Secp256k1::new();
2873 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&<Vec<u8>>::from_hex("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2876 let cr = msgs::ChannelReestablish {
2877 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]),
2878 next_local_commitment_number: 3,
2879 next_remote_commitment_number: 4,
2880 your_last_per_commitment_secret: [9;32],
2881 my_current_per_commitment_point: public_key,
2882 next_funding_txid: Some(Txid::from_raw_hash(bitcoin::hashes::Hash::from_slice(&[
2883 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,
2887 let encoded_value = cr.encode();
2891 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
2892 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2893 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2894 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
2895 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
2896 0, // Type (next_funding_txid)
2898 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
2903 macro_rules! get_keys_from {
2904 ($slice: expr, $secp_ctx: expr) => {
2906 let privkey = SecretKey::from_slice(&<Vec<u8>>::from_hex($slice).unwrap()[..]).unwrap();
2907 let pubkey = PublicKey::from_secret_key(&$secp_ctx, &privkey);
2913 macro_rules! get_sig_on {
2914 ($privkey: expr, $ctx: expr, $string: expr) => {
2916 let sighash = Message::from_slice(&$string.into_bytes()[..]).unwrap();
2917 $ctx.sign_ecdsa(&sighash, &$privkey)
2923 fn encoding_announcement_signatures() {
2924 let secp_ctx = Secp256k1::new();
2925 let (privkey, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2926 let sig_1 = get_sig_on!(privkey, secp_ctx, String::from("01010101010101010101010101010101"));
2927 let sig_2 = get_sig_on!(privkey, secp_ctx, String::from("02020202020202020202020202020202"));
2928 let announcement_signatures = msgs::AnnouncementSignatures {
2929 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]),
2930 short_channel_id: 2316138423780173,
2931 node_signature: sig_1,
2932 bitcoin_signature: sig_2,
2935 let encoded_value = announcement_signatures.encode();
2936 assert_eq!(encoded_value, <Vec<u8>>::from_hex("040000000000000005000000000000000600000000000000070000000000000000083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073acf9953cef4700860f5967838eba2bae89288ad188ebf8b20bf995c3ea53a26df1876d0a3a0e13172ba286a673140190c02ba9da60a2e43a745188c8a83c7f3ef").unwrap());
2939 fn do_encoding_channel_announcement(unknown_features_bits: bool, excess_data: bool) {
2940 let secp_ctx = Secp256k1::new();
2941 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2942 let (privkey_2, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2943 let (privkey_3, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2944 let (privkey_4, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2945 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2946 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
2947 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
2948 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
2949 let mut features = ChannelFeatures::empty();
2950 if unknown_features_bits {
2951 features = ChannelFeatures::from_le_bytes(vec![0xFF, 0xFF]);
2953 let unsigned_channel_announcement = msgs::UnsignedChannelAnnouncement {
2955 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
2956 short_channel_id: 2316138423780173,
2957 node_id_1: NodeId::from_pubkey(&pubkey_1),
2958 node_id_2: NodeId::from_pubkey(&pubkey_2),
2959 bitcoin_key_1: NodeId::from_pubkey(&pubkey_3),
2960 bitcoin_key_2: NodeId::from_pubkey(&pubkey_4),
2961 excess_data: if excess_data { vec![10, 0, 0, 20, 0, 0, 30, 0, 0, 40] } else { Vec::new() },
2963 let channel_announcement = msgs::ChannelAnnouncement {
2964 node_signature_1: sig_1,
2965 node_signature_2: sig_2,
2966 bitcoin_signature_1: sig_3,
2967 bitcoin_signature_2: sig_4,
2968 contents: unsigned_channel_announcement,
2970 let encoded_value = channel_announcement.encode();
2971 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a1735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap();
2972 if unknown_features_bits {
2973 target_value.append(&mut <Vec<u8>>::from_hex("0002ffff").unwrap());
2975 target_value.append(&mut <Vec<u8>>::from_hex("0000").unwrap());
2977 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
2978 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
2980 target_value.append(&mut <Vec<u8>>::from_hex("0a00001400001e000028").unwrap());
2982 assert_eq!(encoded_value, target_value);
2986 fn encoding_channel_announcement() {
2987 do_encoding_channel_announcement(true, false);
2988 do_encoding_channel_announcement(false, true);
2989 do_encoding_channel_announcement(false, false);
2990 do_encoding_channel_announcement(true, true);
2993 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) {
2994 let secp_ctx = Secp256k1::new();
2995 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2996 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2997 let features = if unknown_features_bits {
2998 NodeFeatures::from_le_bytes(vec![0xFF, 0xFF])
3000 // Set to some features we may support
3001 NodeFeatures::from_le_bytes(vec![2 | 1 << 5])
3003 let mut addresses = Vec::new();
3005 addresses.push(SocketAddress::TcpIpV4 {
3006 addr: [255, 254, 253, 252],
3011 addresses.push(SocketAddress::TcpIpV6 {
3012 addr: [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240],
3017 addresses.push(msgs::SocketAddress::OnionV2(
3018 [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 38, 7]
3022 addresses.push(msgs::SocketAddress::OnionV3 {
3023 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],
3030 addresses.push(SocketAddress::Hostname {
3031 hostname: Hostname::try_from(String::from("host")).unwrap(),
3035 let mut addr_len = 0;
3036 for addr in &addresses {
3037 addr_len += addr.len() + 1;
3039 let unsigned_node_announcement = msgs::UnsignedNodeAnnouncement {
3041 timestamp: 20190119,
3042 node_id: NodeId::from_pubkey(&pubkey_1),
3044 alias: NodeAlias([16;32]),
3046 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() },
3047 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() },
3049 addr_len += unsigned_node_announcement.excess_address_data.len() as u16;
3050 let node_announcement = msgs::NodeAnnouncement {
3052 contents: unsigned_node_announcement,
3054 let encoded_value = node_announcement.encode();
3055 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3056 if unknown_features_bits {
3057 target_value.append(&mut <Vec<u8>>::from_hex("0002ffff").unwrap());
3059 target_value.append(&mut <Vec<u8>>::from_hex("000122").unwrap());
3061 target_value.append(&mut <Vec<u8>>::from_hex("013413a7031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f2020201010101010101010101010101010101010101010101010101010101010101010").unwrap());
3062 target_value.append(&mut vec![(addr_len >> 8) as u8, addr_len as u8]);
3064 target_value.append(&mut <Vec<u8>>::from_hex("01fffefdfc2607").unwrap());
3067 target_value.append(&mut <Vec<u8>>::from_hex("02fffefdfcfbfaf9f8f7f6f5f4f3f2f1f02607").unwrap());
3070 target_value.append(&mut <Vec<u8>>::from_hex("03fffefdfcfbfaf9f8f7f62607").unwrap());
3073 target_value.append(&mut <Vec<u8>>::from_hex("04fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0efeeedecebeae9e8e7e6e5e4e3e2e1e00020102607").unwrap());
3076 target_value.append(&mut <Vec<u8>>::from_hex("0504686f73742607").unwrap());
3078 if excess_address_data {
3079 target_value.append(&mut <Vec<u8>>::from_hex("216c280b5395a2546e7e4b2663e04f811622f15a4f92e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d269").unwrap());
3082 target_value.append(&mut <Vec<u8>>::from_hex("3b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
3084 assert_eq!(encoded_value, target_value);
3088 fn encoding_node_announcement() {
3089 do_encoding_node_announcement(true, true, true, true, true, true, true, true);
3090 do_encoding_node_announcement(false, false, false, false, false, false, false, false);
3091 do_encoding_node_announcement(false, true, false, false, false, false, false, false);
3092 do_encoding_node_announcement(false, false, true, false, false, false, false, false);
3093 do_encoding_node_announcement(false, false, false, true, false, false, false, false);
3094 do_encoding_node_announcement(false, false, false, false, true, false, false, false);
3095 do_encoding_node_announcement(false, false, false, false, false, true, false, false);
3096 do_encoding_node_announcement(false, false, false, false, false, false, true, false);
3097 do_encoding_node_announcement(false, true, false, true, false, false, true, false);
3098 do_encoding_node_announcement(false, false, true, false, true, false, false, false);
3101 fn do_encoding_channel_update(direction: bool, disable: bool, excess_data: bool) {
3102 let secp_ctx = Secp256k1::new();
3103 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3104 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3105 let unsigned_channel_update = msgs::UnsignedChannelUpdate {
3106 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3107 short_channel_id: 2316138423780173,
3108 timestamp: 20190119,
3109 flags: if direction { 1 } else { 0 } | if disable { 1 << 1 } else { 0 },
3110 cltv_expiry_delta: 144,
3111 htlc_minimum_msat: 1000000,
3112 htlc_maximum_msat: 131355275467161,
3113 fee_base_msat: 10000,
3114 fee_proportional_millionths: 20,
3115 excess_data: if excess_data { vec![0, 0, 0, 0, 59, 154, 202, 0] } else { Vec::new() }
3117 let channel_update = msgs::ChannelUpdate {
3119 contents: unsigned_channel_update
3121 let encoded_value = channel_update.encode();
3122 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3123 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3124 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d013413a7").unwrap());
3125 target_value.append(&mut <Vec<u8>>::from_hex("01").unwrap());
3126 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3128 let flag = target_value.last_mut().unwrap();
3132 let flag = target_value.last_mut().unwrap();
3133 *flag = *flag | 1 << 1;
3135 target_value.append(&mut <Vec<u8>>::from_hex("009000000000000f42400000271000000014").unwrap());
3136 target_value.append(&mut <Vec<u8>>::from_hex("0000777788889999").unwrap());
3138 target_value.append(&mut <Vec<u8>>::from_hex("000000003b9aca00").unwrap());
3140 assert_eq!(encoded_value, target_value);
3144 fn encoding_channel_update() {
3145 do_encoding_channel_update(false, false, false);
3146 do_encoding_channel_update(false, false, true);
3147 do_encoding_channel_update(true, false, false);
3148 do_encoding_channel_update(true, false, true);
3149 do_encoding_channel_update(false, true, false);
3150 do_encoding_channel_update(false, true, true);
3151 do_encoding_channel_update(true, true, false);
3152 do_encoding_channel_update(true, true, true);
3155 fn do_encoding_open_channel(random_bit: bool, shutdown: bool, incl_chan_type: bool) {
3156 let secp_ctx = Secp256k1::new();
3157 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3158 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3159 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3160 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3161 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3162 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3163 let open_channel = msgs::OpenChannel {
3164 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3165 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3166 funding_satoshis: 1311768467284833366,
3167 push_msat: 2536655962884945560,
3168 dust_limit_satoshis: 3608586615801332854,
3169 max_htlc_value_in_flight_msat: 8517154655701053848,
3170 channel_reserve_satoshis: 8665828695742877976,
3171 htlc_minimum_msat: 2316138423780173,
3172 feerate_per_kw: 821716,
3173 to_self_delay: 49340,
3174 max_accepted_htlcs: 49340,
3175 funding_pubkey: pubkey_1,
3176 revocation_basepoint: pubkey_2,
3177 payment_point: pubkey_3,
3178 delayed_payment_basepoint: pubkey_4,
3179 htlc_basepoint: pubkey_5,
3180 first_per_commitment_point: pubkey_6,
3181 channel_flags: if random_bit { 1 << 5 } else { 0 },
3182 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3183 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3185 let encoded_value = open_channel.encode();
3186 let mut target_value = Vec::new();
3187 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3188 target_value.append(&mut <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202021234567890123456233403289122369832144668701144767633030896203198784335490624111800083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3190 target_value.append(&mut <Vec<u8>>::from_hex("20").unwrap());
3192 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3195 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3198 target_value.append(&mut <Vec<u8>>::from_hex("0100").unwrap());
3200 assert_eq!(encoded_value, target_value);
3204 fn encoding_open_channel() {
3205 do_encoding_open_channel(false, false, false);
3206 do_encoding_open_channel(false, false, true);
3207 do_encoding_open_channel(false, true, false);
3208 do_encoding_open_channel(false, true, true);
3209 do_encoding_open_channel(true, false, false);
3210 do_encoding_open_channel(true, false, true);
3211 do_encoding_open_channel(true, true, false);
3212 do_encoding_open_channel(true, true, true);
3215 fn do_encoding_open_channelv2(random_bit: bool, shutdown: bool, incl_chan_type: bool, require_confirmed_inputs: bool) {
3216 let secp_ctx = Secp256k1::new();
3217 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3218 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3219 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3220 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3221 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3222 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3223 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3224 let open_channelv2 = msgs::OpenChannelV2 {
3225 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3226 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3227 funding_feerate_sat_per_1000_weight: 821716,
3228 commitment_feerate_sat_per_1000_weight: 821716,
3229 funding_satoshis: 1311768467284833366,
3230 dust_limit_satoshis: 3608586615801332854,
3231 max_htlc_value_in_flight_msat: 8517154655701053848,
3232 htlc_minimum_msat: 2316138423780173,
3233 to_self_delay: 49340,
3234 max_accepted_htlcs: 49340,
3235 locktime: 305419896,
3236 funding_pubkey: pubkey_1,
3237 revocation_basepoint: pubkey_2,
3238 payment_basepoint: pubkey_3,
3239 delayed_payment_basepoint: pubkey_4,
3240 htlc_basepoint: pubkey_5,
3241 first_per_commitment_point: pubkey_6,
3242 second_per_commitment_point: pubkey_7,
3243 channel_flags: if random_bit { 1 << 5 } else { 0 },
3244 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3245 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3246 require_confirmed_inputs: if require_confirmed_inputs { Some(()) } else { None },
3248 let encoded_value = open_channelv2.encode();
3249 let mut target_value = Vec::new();
3250 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3251 target_value.append(&mut <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap());
3252 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap());
3253 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap());
3254 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap());
3255 target_value.append(&mut <Vec<u8>>::from_hex("3214466870114476").unwrap());
3256 target_value.append(&mut <Vec<u8>>::from_hex("7633030896203198").unwrap());
3257 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d").unwrap());
3258 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap());
3259 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap());
3260 target_value.append(&mut <Vec<u8>>::from_hex("12345678").unwrap());
3261 target_value.append(&mut <Vec<u8>>::from_hex("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap());
3262 target_value.append(&mut <Vec<u8>>::from_hex("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap());
3263 target_value.append(&mut <Vec<u8>>::from_hex("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap());
3264 target_value.append(&mut <Vec<u8>>::from_hex("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
3265 target_value.append(&mut <Vec<u8>>::from_hex("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap());
3266 target_value.append(&mut <Vec<u8>>::from_hex("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3267 target_value.append(&mut <Vec<u8>>::from_hex("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap());
3270 target_value.append(&mut <Vec<u8>>::from_hex("20").unwrap());
3272 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3275 target_value.append(&mut <Vec<u8>>::from_hex("001b").unwrap()); // Type 0 + Length 27
3276 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3279 target_value.append(&mut <Vec<u8>>::from_hex("0100").unwrap());
3281 if require_confirmed_inputs {
3282 target_value.append(&mut <Vec<u8>>::from_hex("0200").unwrap());
3284 assert_eq!(encoded_value, target_value);
3288 fn encoding_open_channelv2() {
3289 do_encoding_open_channelv2(false, false, false, false);
3290 do_encoding_open_channelv2(false, false, false, true);
3291 do_encoding_open_channelv2(false, false, true, false);
3292 do_encoding_open_channelv2(false, false, true, true);
3293 do_encoding_open_channelv2(false, true, false, false);
3294 do_encoding_open_channelv2(false, true, false, true);
3295 do_encoding_open_channelv2(false, true, true, false);
3296 do_encoding_open_channelv2(false, true, true, true);
3297 do_encoding_open_channelv2(true, false, false, false);
3298 do_encoding_open_channelv2(true, false, false, true);
3299 do_encoding_open_channelv2(true, false, true, false);
3300 do_encoding_open_channelv2(true, false, true, true);
3301 do_encoding_open_channelv2(true, true, false, false);
3302 do_encoding_open_channelv2(true, true, false, true);
3303 do_encoding_open_channelv2(true, true, true, false);
3304 do_encoding_open_channelv2(true, true, true, true);
3307 fn do_encoding_accept_channel(shutdown: bool) {
3308 let secp_ctx = Secp256k1::new();
3309 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3310 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3311 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3312 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3313 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3314 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3315 let accept_channel = msgs::AcceptChannel {
3316 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3317 dust_limit_satoshis: 1311768467284833366,
3318 max_htlc_value_in_flight_msat: 2536655962884945560,
3319 channel_reserve_satoshis: 3608586615801332854,
3320 htlc_minimum_msat: 2316138423780173,
3321 minimum_depth: 821716,
3322 to_self_delay: 49340,
3323 max_accepted_htlcs: 49340,
3324 funding_pubkey: pubkey_1,
3325 revocation_basepoint: pubkey_2,
3326 payment_point: pubkey_3,
3327 delayed_payment_basepoint: pubkey_4,
3328 htlc_basepoint: pubkey_5,
3329 first_per_commitment_point: pubkey_6,
3330 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3333 next_local_nonce: None,
3335 let encoded_value = accept_channel.encode();
3336 let mut target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020212345678901234562334032891223698321446687011447600083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap();
3338 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3340 assert_eq!(encoded_value, target_value);
3344 fn encoding_accept_channel() {
3345 do_encoding_accept_channel(false);
3346 do_encoding_accept_channel(true);
3349 fn do_encoding_accept_channelv2(shutdown: bool) {
3350 let secp_ctx = Secp256k1::new();
3351 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3352 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3353 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3354 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3355 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3356 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3357 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3358 let accept_channelv2 = msgs::AcceptChannelV2 {
3359 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3360 funding_satoshis: 1311768467284833366,
3361 dust_limit_satoshis: 1311768467284833366,
3362 max_htlc_value_in_flight_msat: 2536655962884945560,
3363 htlc_minimum_msat: 2316138423780173,
3364 minimum_depth: 821716,
3365 to_self_delay: 49340,
3366 max_accepted_htlcs: 49340,
3367 funding_pubkey: pubkey_1,
3368 revocation_basepoint: pubkey_2,
3369 payment_basepoint: pubkey_3,
3370 delayed_payment_basepoint: pubkey_4,
3371 htlc_basepoint: pubkey_5,
3372 first_per_commitment_point: pubkey_6,
3373 second_per_commitment_point: pubkey_7,
3374 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3376 require_confirmed_inputs: None,
3378 let encoded_value = accept_channelv2.encode();
3379 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // temporary_channel_id
3380 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap()); // funding_satoshis
3381 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap()); // dust_limit_satoshis
3382 target_value.append(&mut <Vec<u8>>::from_hex("2334032891223698").unwrap()); // max_htlc_value_in_flight_msat
3383 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d").unwrap()); // htlc_minimum_msat
3384 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap()); // minimum_depth
3385 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap()); // to_self_delay
3386 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap()); // max_accepted_htlcs
3387 target_value.append(&mut <Vec<u8>>::from_hex("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap()); // funding_pubkey
3388 target_value.append(&mut <Vec<u8>>::from_hex("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap()); // revocation_basepoint
3389 target_value.append(&mut <Vec<u8>>::from_hex("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap()); // payment_basepoint
3390 target_value.append(&mut <Vec<u8>>::from_hex("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap()); // delayed_payment_basepoint
3391 target_value.append(&mut <Vec<u8>>::from_hex("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap()); // htlc_basepoint
3392 target_value.append(&mut <Vec<u8>>::from_hex("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap()); // first_per_commitment_point
3393 target_value.append(&mut <Vec<u8>>::from_hex("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap()); // second_per_commitment_point
3395 target_value.append(&mut <Vec<u8>>::from_hex("001b").unwrap()); // Type 0 + Length 27
3396 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3398 assert_eq!(encoded_value, target_value);
3402 fn encoding_accept_channelv2() {
3403 do_encoding_accept_channelv2(false);
3404 do_encoding_accept_channelv2(true);
3408 fn encoding_funding_created() {
3409 let secp_ctx = Secp256k1::new();
3410 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3411 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3412 let funding_created = msgs::FundingCreated {
3413 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3414 funding_txid: Txid::from_str("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3415 funding_output_index: 255,
3418 partial_signature_with_nonce: None,
3420 next_local_nonce: None,
3422 let encoded_value = funding_created.encode();
3423 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202026e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c200ffd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3424 assert_eq!(encoded_value, target_value);
3428 fn encoding_funding_signed() {
3429 let secp_ctx = Secp256k1::new();
3430 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3431 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3432 let funding_signed = msgs::FundingSigned {
3433 channel_id: ChannelId::from_bytes([2; 32]),
3436 partial_signature_with_nonce: None,
3438 let encoded_value = funding_signed.encode();
3439 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3440 assert_eq!(encoded_value, target_value);
3444 fn encoding_channel_ready() {
3445 let secp_ctx = Secp256k1::new();
3446 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3447 let channel_ready = msgs::ChannelReady {
3448 channel_id: ChannelId::from_bytes([2; 32]),
3449 next_per_commitment_point: pubkey_1,
3450 short_channel_id_alias: None,
3452 let encoded_value = channel_ready.encode();
3453 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3454 assert_eq!(encoded_value, target_value);
3458 fn encoding_splice() {
3459 let secp_ctx = Secp256k1::new();
3460 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3461 let splice = msgs::Splice {
3462 chain_hash: ChainHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
3463 channel_id: ChannelId::from_bytes([2; 32]),
3464 relative_satoshis: 123456,
3465 funding_feerate_perkw: 2000,
3467 funding_pubkey: pubkey_1,
3469 let encoded_value = splice.encode();
3470 assert_eq!(encoded_value.as_hex().to_string(), "02020202020202020202020202020202020202020202020202020202020202026fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000000000000001e240000007d000000000031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f");
3474 fn encoding_stfu() {
3475 let stfu = msgs::Stfu {
3476 channel_id: ChannelId::from_bytes([2; 32]),
3479 let encoded_value = stfu.encode();
3480 assert_eq!(encoded_value.as_hex().to_string(), "020202020202020202020202020202020202020202020202020202020202020201");
3484 fn encoding_splice_ack() {
3485 let secp_ctx = Secp256k1::new();
3486 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3487 let splice = msgs::SpliceAck {
3488 chain_hash: ChainHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
3489 channel_id: ChannelId::from_bytes([2; 32]),
3490 relative_satoshis: 123456,
3491 funding_pubkey: pubkey_1,
3493 let encoded_value = splice.encode();
3494 assert_eq!(encoded_value.as_hex().to_string(), "02020202020202020202020202020202020202020202020202020202020202026fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000000000000001e240031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f");
3498 fn encoding_splice_locked() {
3499 let splice = msgs::SpliceLocked {
3500 channel_id: ChannelId::from_bytes([2; 32]),
3502 let encoded_value = splice.encode();
3503 assert_eq!(encoded_value.as_hex().to_string(), "0202020202020202020202020202020202020202020202020202020202020202");
3507 fn encoding_tx_add_input() {
3508 let tx_add_input = msgs::TxAddInput {
3509 channel_id: ChannelId::from_bytes([2; 32]),
3510 serial_id: 4886718345,
3511 prevtx: TransactionU16LenLimited::new(Transaction {
3513 lock_time: LockTime::ZERO,
3515 previous_output: OutPoint { txid: Txid::from_str("305bab643ee297b8b6b76b320792c8223d55082122cb606bf89382146ced9c77").unwrap(), index: 2 }.into_bitcoin_outpoint(),
3516 script_sig: ScriptBuf::new(),
3517 sequence: Sequence(0xfffffffd),
3518 witness: Witness::from_slice(&vec![
3519 <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3520 <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3525 script_pubkey: Address::from_str("bc1qzlffunw52jav8vwdu5x3jfk6sr8u22rmq3xzw2").unwrap().payload.script_pubkey(),
3529 script_pubkey: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().payload.script_pubkey(),
3533 prevtx_out: 305419896,
3534 sequence: 305419896,
3536 let encoded_value = tx_add_input.encode();
3537 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000000012345678900de02000000000101779ced6c148293f86b60cb222108553d22c89207326bb7b6b897e23e64ab5b300200000000fdffffff0236dbc1000000000016001417d29e4dd454bac3b1cde50d1926da80cfc5287b9cbd03000000000016001436ec78d514df462da95e6a00c24daa8915362d420247304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701210301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944000000001234567812345678").unwrap();
3538 assert_eq!(encoded_value, target_value);
3542 fn encoding_tx_add_output() {
3543 let tx_add_output = msgs::TxAddOutput {
3544 channel_id: ChannelId::from_bytes([2; 32]),
3545 serial_id: 4886718345,
3547 script: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().payload.script_pubkey(),
3549 let encoded_value = tx_add_output.encode();
3550 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000000012345678900000001234567890016001436ec78d514df462da95e6a00c24daa8915362d42").unwrap();
3551 assert_eq!(encoded_value, target_value);
3555 fn encoding_tx_remove_input() {
3556 let tx_remove_input = msgs::TxRemoveInput {
3557 channel_id: ChannelId::from_bytes([2; 32]),
3558 serial_id: 4886718345,
3560 let encoded_value = tx_remove_input.encode();
3561 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3562 assert_eq!(encoded_value, target_value);
3566 fn encoding_tx_remove_output() {
3567 let tx_remove_output = msgs::TxRemoveOutput {
3568 channel_id: ChannelId::from_bytes([2; 32]),
3569 serial_id: 4886718345,
3571 let encoded_value = tx_remove_output.encode();
3572 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3573 assert_eq!(encoded_value, target_value);
3577 fn encoding_tx_complete() {
3578 let tx_complete = msgs::TxComplete {
3579 channel_id: ChannelId::from_bytes([2; 32]),
3581 let encoded_value = tx_complete.encode();
3582 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3583 assert_eq!(encoded_value, target_value);
3587 fn encoding_tx_signatures() {
3588 let tx_signatures = msgs::TxSignatures {
3589 channel_id: ChannelId::from_bytes([2; 32]),
3590 tx_hash: Txid::from_str("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3592 Witness::from_slice(&vec![
3593 <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3594 <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3595 Witness::from_slice(&vec![
3596 <Vec<u8>>::from_hex("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap(),
3597 <Vec<u8>>::from_hex("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap()]),
3600 let encoded_value = tx_signatures.encode();
3601 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3602 target_value.append(&mut <Vec<u8>>::from_hex("6e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c2").unwrap()); // tx_hash (sha256) (big endian byte order)
3603 target_value.append(&mut <Vec<u8>>::from_hex("0002").unwrap()); // num_witnesses (u16)
3605 target_value.append(&mut <Vec<u8>>::from_hex("006b").unwrap()); // len of witness_data
3606 target_value.append(&mut <Vec<u8>>::from_hex("02").unwrap()); // num_witness_elements (VarInt)
3607 target_value.append(&mut <Vec<u8>>::from_hex("47").unwrap()); // len of witness element data (VarInt)
3608 target_value.append(&mut <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap());
3609 target_value.append(&mut <Vec<u8>>::from_hex("21").unwrap()); // len of witness element data (VarInt)
3610 target_value.append(&mut <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap());
3612 target_value.append(&mut <Vec<u8>>::from_hex("006c").unwrap()); // len of witness_data
3613 target_value.append(&mut <Vec<u8>>::from_hex("02").unwrap()); // num_witness_elements (VarInt)
3614 target_value.append(&mut <Vec<u8>>::from_hex("48").unwrap()); // len of witness element data (VarInt)
3615 target_value.append(&mut <Vec<u8>>::from_hex("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap());
3616 target_value.append(&mut <Vec<u8>>::from_hex("21").unwrap()); // len of witness element data (VarInt)
3617 target_value.append(&mut <Vec<u8>>::from_hex("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap());
3618 assert_eq!(encoded_value, target_value);
3621 fn do_encoding_tx_init_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3622 let tx_init_rbf = msgs::TxInitRbf {
3623 channel_id: ChannelId::from_bytes([2; 32]),
3624 locktime: 305419896,
3625 feerate_sat_per_1000_weight: 20190119,
3626 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3628 let encoded_value = tx_init_rbf.encode();
3629 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3630 target_value.append(&mut <Vec<u8>>::from_hex("12345678").unwrap()); // locktime
3631 target_value.append(&mut <Vec<u8>>::from_hex("013413a7").unwrap()); // feerate_sat_per_1000_weight
3632 if let Some((_, target)) = funding_value_with_hex_target {
3633 target_value.push(0x00); // Type
3634 target_value.push(target.len() as u8 / 2); // Length
3635 target_value.append(&mut <Vec<u8>>::from_hex(target).unwrap()); // Value (i64)
3637 assert_eq!(encoded_value, target_value);
3641 fn encoding_tx_init_rbf() {
3642 do_encoding_tx_init_rbf(Some((1311768467284833366, "1234567890123456")));
3643 do_encoding_tx_init_rbf(Some((13117684672, "000000030DDFFBC0")));
3644 do_encoding_tx_init_rbf(None);
3647 fn do_encoding_tx_ack_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3648 let tx_ack_rbf = msgs::TxAckRbf {
3649 channel_id: ChannelId::from_bytes([2; 32]),
3650 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3652 let encoded_value = tx_ack_rbf.encode();
3653 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3654 if let Some((_, target)) = funding_value_with_hex_target {
3655 target_value.push(0x00); // Type
3656 target_value.push(target.len() as u8 / 2); // Length
3657 target_value.append(&mut <Vec<u8>>::from_hex(target).unwrap()); // Value (i64)
3659 assert_eq!(encoded_value, target_value);
3663 fn encoding_tx_ack_rbf() {
3664 do_encoding_tx_ack_rbf(Some((1311768467284833366, "1234567890123456")));
3665 do_encoding_tx_ack_rbf(Some((13117684672, "000000030DDFFBC0")));
3666 do_encoding_tx_ack_rbf(None);
3670 fn encoding_tx_abort() {
3671 let tx_abort = msgs::TxAbort {
3672 channel_id: ChannelId::from_bytes([2; 32]),
3673 data: <Vec<u8>>::from_hex("54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap(),
3675 let encoded_value = tx_abort.encode();
3676 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202002C54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap();
3677 assert_eq!(encoded_value, target_value);
3680 fn do_encoding_shutdown(script_type: u8) {
3681 let secp_ctx = Secp256k1::new();
3682 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3683 let script = Builder::new().push_opcode(opcodes::OP_TRUE).into_script();
3684 let shutdown = msgs::Shutdown {
3685 channel_id: ChannelId::from_bytes([2; 32]),
3687 if script_type == 1 { Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey() }
3688 else if script_type == 2 { Address::p2sh(&script, Network::Testnet).unwrap().script_pubkey() }
3689 else if script_type == 3 { Address::p2wpkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).unwrap().script_pubkey() }
3690 else { Address::p2wsh(&script, Network::Testnet).script_pubkey() },
3692 let encoded_value = shutdown.encode();
3693 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3694 if script_type == 1 {
3695 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3696 } else if script_type == 2 {
3697 target_value.append(&mut <Vec<u8>>::from_hex("0017a914da1745e9b549bd0bfa1a569971c77eba30cd5a4b87").unwrap());
3698 } else if script_type == 3 {
3699 target_value.append(&mut <Vec<u8>>::from_hex("0016001479b000887626b294a914501a4cd226b58b235983").unwrap());
3700 } else if script_type == 4 {
3701 target_value.append(&mut <Vec<u8>>::from_hex("002200204ae81572f06e1b88fd5ced7a1a000945432e83e1551e6f721ee9c00b8cc33260").unwrap());
3703 assert_eq!(encoded_value, target_value);
3707 fn encoding_shutdown() {
3708 do_encoding_shutdown(1);
3709 do_encoding_shutdown(2);
3710 do_encoding_shutdown(3);
3711 do_encoding_shutdown(4);
3715 fn encoding_closing_signed() {
3716 let secp_ctx = Secp256k1::new();
3717 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3718 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3719 let closing_signed = msgs::ClosingSigned {
3720 channel_id: ChannelId::from_bytes([2; 32]),
3721 fee_satoshis: 2316138423780173,
3725 let encoded_value = closing_signed.encode();
3726 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3727 assert_eq!(encoded_value, target_value);
3728 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value)).unwrap(), closing_signed);
3730 let closing_signed_with_range = msgs::ClosingSigned {
3731 channel_id: ChannelId::from_bytes([2; 32]),
3732 fee_satoshis: 2316138423780173,
3734 fee_range: Some(msgs::ClosingSignedFeeRange {
3735 min_fee_satoshis: 0xdeadbeef,
3736 max_fee_satoshis: 0x1badcafe01234567,
3739 let encoded_value_with_range = closing_signed_with_range.encode();
3740 let target_value_with_range = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a011000000000deadbeef1badcafe01234567").unwrap();
3741 assert_eq!(encoded_value_with_range, target_value_with_range);
3742 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value_with_range)).unwrap(),
3743 closing_signed_with_range);
3747 fn encoding_update_add_htlc() {
3748 let secp_ctx = Secp256k1::new();
3749 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3750 let onion_routing_packet = msgs::OnionPacket {
3752 public_key: Ok(pubkey_1),
3753 hop_data: [1; 20*65],
3756 let update_add_htlc = msgs::UpdateAddHTLC {
3757 channel_id: ChannelId::from_bytes([2; 32]),
3758 htlc_id: 2316138423780173,
3759 amount_msat: 3608586615801332854,
3760 payment_hash: PaymentHash([1; 32]),
3761 cltv_expiry: 821716,
3762 onion_routing_packet,
3763 skimmed_fee_msat: None,
3764 blinding_point: None,
3766 let encoded_value = update_add_htlc.encode();
3767 let target_value = <Vec<u8>>::from_hex("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").unwrap();
3768 assert_eq!(encoded_value, target_value);
3772 fn encoding_update_fulfill_htlc() {
3773 let update_fulfill_htlc = msgs::UpdateFulfillHTLC {
3774 channel_id: ChannelId::from_bytes([2; 32]),
3775 htlc_id: 2316138423780173,
3776 payment_preimage: PaymentPreimage([1; 32]),
3778 let encoded_value = update_fulfill_htlc.encode();
3779 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d0101010101010101010101010101010101010101010101010101010101010101").unwrap();
3780 assert_eq!(encoded_value, target_value);
3784 fn encoding_update_fail_htlc() {
3785 let reason = OnionErrorPacket {
3786 data: [1; 32].to_vec(),
3788 let update_fail_htlc = msgs::UpdateFailHTLC {
3789 channel_id: ChannelId::from_bytes([2; 32]),
3790 htlc_id: 2316138423780173,
3793 let encoded_value = update_fail_htlc.encode();
3794 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d00200101010101010101010101010101010101010101010101010101010101010101").unwrap();
3795 assert_eq!(encoded_value, target_value);
3799 fn encoding_update_fail_malformed_htlc() {
3800 let update_fail_malformed_htlc = msgs::UpdateFailMalformedHTLC {
3801 channel_id: ChannelId::from_bytes([2; 32]),
3802 htlc_id: 2316138423780173,
3803 sha256_of_onion: [1; 32],
3806 let encoded_value = update_fail_malformed_htlc.encode();
3807 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d010101010101010101010101010101010101010101010101010101010101010100ff").unwrap();
3808 assert_eq!(encoded_value, target_value);
3811 fn do_encoding_commitment_signed(htlcs: bool) {
3812 let secp_ctx = Secp256k1::new();
3813 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3814 let (privkey_2, _) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3815 let (privkey_3, _) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3816 let (privkey_4, _) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3817 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3818 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
3819 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
3820 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
3821 let commitment_signed = msgs::CommitmentSigned {
3822 channel_id: ChannelId::from_bytes([2; 32]),
3824 htlc_signatures: if htlcs { vec![sig_2, sig_3, sig_4] } else { Vec::new() },
3826 partial_signature_with_nonce: None,
3828 let encoded_value = commitment_signed.encode();
3829 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3831 target_value.append(&mut <Vec<u8>>::from_hex("00031735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
3833 target_value.append(&mut <Vec<u8>>::from_hex("0000").unwrap());
3835 assert_eq!(encoded_value, target_value);
3839 fn encoding_commitment_signed() {
3840 do_encoding_commitment_signed(true);
3841 do_encoding_commitment_signed(false);
3845 fn encoding_revoke_and_ack() {
3846 let secp_ctx = Secp256k1::new();
3847 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3848 let raa = msgs::RevokeAndACK {
3849 channel_id: ChannelId::from_bytes([2; 32]),
3850 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],
3851 next_per_commitment_point: pubkey_1,
3853 next_local_nonce: None,
3855 let encoded_value = raa.encode();
3856 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020101010101010101010101010101010101010101010101010101010101010101031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3857 assert_eq!(encoded_value, target_value);
3861 fn encoding_update_fee() {
3862 let update_fee = msgs::UpdateFee {
3863 channel_id: ChannelId::from_bytes([2; 32]),
3864 feerate_per_kw: 20190119,
3866 let encoded_value = update_fee.encode();
3867 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202013413a7").unwrap();
3868 assert_eq!(encoded_value, target_value);
3872 fn encoding_init() {
3873 let mainnet_hash = ChainHash::using_genesis_block(Network::Bitcoin);
3874 assert_eq!(msgs::Init {
3875 features: InitFeatures::from_le_bytes(vec![0xFF, 0xFF, 0xFF]),
3876 networks: Some(vec![mainnet_hash]),
3877 remote_network_address: None,
3878 }.encode(), <Vec<u8>>::from_hex("00023fff0003ffffff01206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3879 assert_eq!(msgs::Init {
3880 features: InitFeatures::from_le_bytes(vec![0xFF]),
3882 remote_network_address: None,
3883 }.encode(), <Vec<u8>>::from_hex("0001ff0001ff").unwrap());
3884 assert_eq!(msgs::Init {
3885 features: InitFeatures::from_le_bytes(vec![]),
3886 networks: Some(vec![mainnet_hash]),
3887 remote_network_address: None,
3888 }.encode(), <Vec<u8>>::from_hex("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3889 assert_eq!(msgs::Init {
3890 features: InitFeatures::from_le_bytes(vec![]),
3891 networks: Some(vec![ChainHash::from(&[1; 32]), ChainHash::from(&[2; 32])]),
3892 remote_network_address: None,
3893 }.encode(), <Vec<u8>>::from_hex("00000000014001010101010101010101010101010101010101010101010101010101010101010202020202020202020202020202020202020202020202020202020202020202").unwrap());
3894 let init_msg = msgs::Init { features: InitFeatures::from_le_bytes(vec![]),
3895 networks: Some(vec![mainnet_hash]),
3896 remote_network_address: Some(SocketAddress::TcpIpV4 {
3897 addr: [127, 0, 0, 1],
3901 let encoded_value = init_msg.encode();
3902 let target_value = <Vec<u8>>::from_hex("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d61900000000000307017f00000103e8").unwrap();
3903 assert_eq!(encoded_value, target_value);
3904 assert_eq!(msgs::Init::read(&mut Cursor::new(&target_value)).unwrap(), init_msg);
3908 fn encoding_error() {
3909 let error = msgs::ErrorMessage {
3910 channel_id: ChannelId::from_bytes([2; 32]),
3911 data: String::from("rust-lightning"),
3913 let encoded_value = error.encode();
3914 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3915 assert_eq!(encoded_value, target_value);
3919 fn encoding_warning() {
3920 let error = msgs::WarningMessage {
3921 channel_id: ChannelId::from_bytes([2; 32]),
3922 data: String::from("rust-lightning"),
3924 let encoded_value = error.encode();
3925 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3926 assert_eq!(encoded_value, target_value);
3930 fn encoding_ping() {
3931 let ping = msgs::Ping {
3935 let encoded_value = ping.encode();
3936 let target_value = <Vec<u8>>::from_hex("0040004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3937 assert_eq!(encoded_value, target_value);
3941 fn encoding_pong() {
3942 let pong = msgs::Pong {
3945 let encoded_value = pong.encode();
3946 let target_value = <Vec<u8>>::from_hex("004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3947 assert_eq!(encoded_value, target_value);
3951 fn encoding_nonfinal_onion_hop_data() {
3952 let outbound_msg = msgs::OutboundOnionPayload::Forward {
3953 short_channel_id: 0xdeadbeef1bad1dea,
3954 amt_to_forward: 0x0badf00d01020304,
3955 outgoing_cltv_value: 0xffffffff,
3957 let encoded_value = outbound_msg.encode();
3958 let target_value = <Vec<u8>>::from_hex("1a02080badf00d010203040404ffffffff0608deadbeef1bad1dea").unwrap();
3959 assert_eq!(encoded_value, target_value);
3961 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3962 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
3963 if let msgs::InboundOnionPayload::Forward {
3964 short_channel_id, amt_to_forward, outgoing_cltv_value
3966 assert_eq!(short_channel_id, 0xdeadbeef1bad1dea);
3967 assert_eq!(amt_to_forward, 0x0badf00d01020304);
3968 assert_eq!(outgoing_cltv_value, 0xffffffff);
3969 } else { panic!(); }
3973 fn encoding_final_onion_hop_data() {
3974 let outbound_msg = msgs::OutboundOnionPayload::Receive {
3976 payment_metadata: None,
3977 keysend_preimage: None,
3978 amt_msat: 0x0badf00d01020304,
3979 outgoing_cltv_value: 0xffffffff,
3980 custom_tlvs: vec![],
3982 let encoded_value = outbound_msg.encode();
3983 let target_value = <Vec<u8>>::from_hex("1002080badf00d010203040404ffffffff").unwrap();
3984 assert_eq!(encoded_value, target_value);
3986 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3987 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
3988 if let msgs::InboundOnionPayload::Receive {
3989 payment_data: None, amt_msat, outgoing_cltv_value, ..
3991 assert_eq!(amt_msat, 0x0badf00d01020304);
3992 assert_eq!(outgoing_cltv_value, 0xffffffff);
3993 } else { panic!(); }
3997 fn encoding_final_onion_hop_data_with_secret() {
3998 let expected_payment_secret = PaymentSecret([0x42u8; 32]);
3999 let outbound_msg = msgs::OutboundOnionPayload::Receive {
4000 payment_data: Some(FinalOnionHopData {
4001 payment_secret: expected_payment_secret,
4002 total_msat: 0x1badca1f
4004 payment_metadata: None,
4005 keysend_preimage: None,
4006 amt_msat: 0x0badf00d01020304,
4007 outgoing_cltv_value: 0xffffffff,
4008 custom_tlvs: vec![],
4010 let encoded_value = outbound_msg.encode();
4011 let target_value = <Vec<u8>>::from_hex("3602080badf00d010203040404ffffffff082442424242424242424242424242424242424242424242424242424242424242421badca1f").unwrap();
4012 assert_eq!(encoded_value, target_value);
4014 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4015 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
4016 if let msgs::InboundOnionPayload::Receive {
4017 payment_data: Some(FinalOnionHopData {
4019 total_msat: 0x1badca1f
4021 amt_msat, outgoing_cltv_value,
4022 payment_metadata: None,
4023 keysend_preimage: None,
4026 assert_eq!(payment_secret, expected_payment_secret);
4027 assert_eq!(amt_msat, 0x0badf00d01020304);
4028 assert_eq!(outgoing_cltv_value, 0xffffffff);
4029 assert_eq!(custom_tlvs, vec![]);
4030 } else { panic!(); }
4034 fn encoding_final_onion_hop_data_with_bad_custom_tlvs() {
4035 // If custom TLVs have type number within the range reserved for protocol, treat them as if
4037 let bad_type_range_tlvs = vec![
4038 ((1 << 16) - 4, vec![42]),
4039 ((1 << 16) - 2, vec![42; 32]),
4041 let mut msg = msgs::OutboundOnionPayload::Receive {
4043 payment_metadata: None,
4044 keysend_preimage: None,
4045 custom_tlvs: bad_type_range_tlvs,
4046 amt_msat: 0x0badf00d01020304,
4047 outgoing_cltv_value: 0xffffffff,
4049 let encoded_value = msg.encode();
4050 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4051 assert!(msgs::InboundOnionPayload::read(&mut Cursor::new(&encoded_value[..]), &&node_signer).is_err());
4052 let good_type_range_tlvs = vec![
4053 ((1 << 16) - 3, vec![42]),
4054 ((1 << 16) - 1, vec![42; 32]),
4056 if let msgs::OutboundOnionPayload::Receive { ref mut custom_tlvs, .. } = msg {
4057 *custom_tlvs = good_type_range_tlvs.clone();
4059 let encoded_value = msg.encode();
4060 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&encoded_value[..]), &&node_signer).unwrap();
4062 msgs::InboundOnionPayload::Receive { custom_tlvs, .. } => assert!(custom_tlvs.is_empty()),
4068 fn encoding_final_onion_hop_data_with_custom_tlvs() {
4069 let expected_custom_tlvs = vec![
4070 (5482373483, vec![0x12, 0x34]),
4071 (5482373487, vec![0x42u8; 8]),
4073 let msg = msgs::OutboundOnionPayload::Receive {
4075 payment_metadata: None,
4076 keysend_preimage: None,
4077 custom_tlvs: expected_custom_tlvs.clone(),
4078 amt_msat: 0x0badf00d01020304,
4079 outgoing_cltv_value: 0xffffffff,
4081 let encoded_value = msg.encode();
4082 let target_value = <Vec<u8>>::from_hex("2e02080badf00d010203040404ffffffffff0000000146c6616b021234ff0000000146c6616f084242424242424242").unwrap();
4083 assert_eq!(encoded_value, target_value);
4084 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4085 let inbound_msg: msgs::InboundOnionPayload = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
4086 if let msgs::InboundOnionPayload::Receive {
4088 payment_metadata: None,
4089 keysend_preimage: None,
4092 outgoing_cltv_value,
4095 assert_eq!(custom_tlvs, expected_custom_tlvs);
4096 assert_eq!(amt_msat, 0x0badf00d01020304);
4097 assert_eq!(outgoing_cltv_value, 0xffffffff);
4098 } else { panic!(); }
4102 fn query_channel_range_end_blocknum() {
4103 let tests: Vec<(u32, u32, u32)> = vec![
4104 (10000, 1500, 11500),
4105 (0, 0xffffffff, 0xffffffff),
4106 (1, 0xffffffff, 0xffffffff),
4109 for (first_blocknum, number_of_blocks, expected) in tests.into_iter() {
4110 let sut = msgs::QueryChannelRange {
4111 chain_hash: ChainHash::using_genesis_block(Network::Regtest),
4115 assert_eq!(sut.end_blocknum(), expected);
4120 fn encoding_query_channel_range() {
4121 let mut query_channel_range = msgs::QueryChannelRange {
4122 chain_hash: ChainHash::using_genesis_block(Network::Regtest),
4123 first_blocknum: 100000,
4124 number_of_blocks: 1500,
4126 let encoded_value = query_channel_range.encode();
4127 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000186a0000005dc").unwrap();
4128 assert_eq!(encoded_value, target_value);
4130 query_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4131 assert_eq!(query_channel_range.first_blocknum, 100000);
4132 assert_eq!(query_channel_range.number_of_blocks, 1500);
4136 fn encoding_reply_channel_range() {
4137 do_encoding_reply_channel_range(0);
4138 do_encoding_reply_channel_range(1);
4141 fn do_encoding_reply_channel_range(encoding_type: u8) {
4142 let mut target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000b8a06000005dc01").unwrap();
4143 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4144 let mut reply_channel_range = msgs::ReplyChannelRange {
4145 chain_hash: expected_chain_hash,
4146 first_blocknum: 756230,
4147 number_of_blocks: 1500,
4148 sync_complete: true,
4149 short_channel_ids: vec![0x000000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
4152 if encoding_type == 0 {
4153 target_value.append(&mut <Vec<u8>>::from_hex("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
4154 let encoded_value = reply_channel_range.encode();
4155 assert_eq!(encoded_value, target_value);
4157 reply_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4158 assert_eq!(reply_channel_range.chain_hash, expected_chain_hash);
4159 assert_eq!(reply_channel_range.first_blocknum, 756230);
4160 assert_eq!(reply_channel_range.number_of_blocks, 1500);
4161 assert_eq!(reply_channel_range.sync_complete, true);
4162 assert_eq!(reply_channel_range.short_channel_ids[0], 0x000000000000008e);
4163 assert_eq!(reply_channel_range.short_channel_ids[1], 0x0000000000003c69);
4164 assert_eq!(reply_channel_range.short_channel_ids[2], 0x000000000045a6c4);
4166 target_value.append(&mut <Vec<u8>>::from_hex("001601789c636000833e08659309a65878be010010a9023a").unwrap());
4167 let result: Result<msgs::ReplyChannelRange, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
4168 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
4173 fn encoding_query_short_channel_ids() {
4174 do_encoding_query_short_channel_ids(0);
4175 do_encoding_query_short_channel_ids(1);
4178 fn do_encoding_query_short_channel_ids(encoding_type: u8) {
4179 let mut target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
4180 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4181 let mut query_short_channel_ids = msgs::QueryShortChannelIds {
4182 chain_hash: expected_chain_hash,
4183 short_channel_ids: vec![0x0000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
4186 if encoding_type == 0 {
4187 target_value.append(&mut <Vec<u8>>::from_hex("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
4188 let encoded_value = query_short_channel_ids.encode();
4189 assert_eq!(encoded_value, target_value);
4191 query_short_channel_ids = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4192 assert_eq!(query_short_channel_ids.chain_hash, expected_chain_hash);
4193 assert_eq!(query_short_channel_ids.short_channel_ids[0], 0x000000000000008e);
4194 assert_eq!(query_short_channel_ids.short_channel_ids[1], 0x0000000000003c69);
4195 assert_eq!(query_short_channel_ids.short_channel_ids[2], 0x000000000045a6c4);
4197 target_value.append(&mut <Vec<u8>>::from_hex("001601789c636000833e08659309a65878be010010a9023a").unwrap());
4198 let result: Result<msgs::QueryShortChannelIds, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
4199 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
4204 fn encoding_reply_short_channel_ids_end() {
4205 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4206 let mut reply_short_channel_ids_end = msgs::ReplyShortChannelIdsEnd {
4207 chain_hash: expected_chain_hash,
4208 full_information: true,
4210 let encoded_value = reply_short_channel_ids_end.encode();
4211 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f01").unwrap();
4212 assert_eq!(encoded_value, target_value);
4214 reply_short_channel_ids_end = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4215 assert_eq!(reply_short_channel_ids_end.chain_hash, expected_chain_hash);
4216 assert_eq!(reply_short_channel_ids_end.full_information, true);
4220 fn encoding_gossip_timestamp_filter(){
4221 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4222 let mut gossip_timestamp_filter = msgs::GossipTimestampFilter {
4223 chain_hash: expected_chain_hash,
4224 first_timestamp: 1590000000,
4225 timestamp_range: 0xffff_ffff,
4227 let encoded_value = gossip_timestamp_filter.encode();
4228 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f5ec57980ffffffff").unwrap();
4229 assert_eq!(encoded_value, target_value);
4231 gossip_timestamp_filter = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4232 assert_eq!(gossip_timestamp_filter.chain_hash, expected_chain_hash);
4233 assert_eq!(gossip_timestamp_filter.first_timestamp, 1590000000);
4234 assert_eq!(gossip_timestamp_filter.timestamp_range, 0xffff_ffff);
4238 fn decode_onion_hop_data_len_as_bigsize() {
4239 // Tests that we can decode an onion payload that is >253 bytes.
4240 // Previously, receiving a payload of this size could've caused us to fail to decode a valid
4241 // payload, because we were decoding the length (a BigSize, big-endian) as a VarInt
4244 // Encode a test onion payload with a big custom TLV such that it's >253 bytes, forcing the
4245 // payload length to be encoded over multiple bytes rather than a single u8.
4246 let big_payload = encode_big_payload().unwrap();
4247 let mut rd = Cursor::new(&big_payload[..]);
4249 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4250 <msgs::InboundOnionPayload as ReadableArgs<&&test_utils::TestKeysInterface>>
4251 ::read(&mut rd, &&node_signer).unwrap();
4253 // see above test, needs to be a separate method for use of the serialization macros.
4254 fn encode_big_payload() -> Result<Vec<u8>, io::Error> {
4255 use crate::util::ser::HighZeroBytesDroppedBigSize;
4256 let payload = msgs::OutboundOnionPayload::Forward {
4257 short_channel_id: 0xdeadbeef1bad1dea,
4258 amt_to_forward: 1000,
4259 outgoing_cltv_value: 0xffffffff,
4261 let mut encoded_payload = Vec::new();
4262 let test_bytes = vec![42u8; 1000];
4263 if let msgs::OutboundOnionPayload::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } = payload {
4264 _encode_varint_length_prefixed_tlv!(&mut encoded_payload, {
4265 (1, test_bytes, required_vec),
4266 (2, HighZeroBytesDroppedBigSize(amt_to_forward), required),
4267 (4, HighZeroBytesDroppedBigSize(outgoing_cltv_value), required),
4268 (6, short_channel_id, required)
4275 #[cfg(feature = "std")]
4276 fn test_socket_address_from_str() {
4277 let tcpip_v4 = SocketAddress::TcpIpV4 {
4278 addr: Ipv4Addr::new(127, 0, 0, 1).octets(),
4281 assert_eq!(tcpip_v4, SocketAddress::from_str("127.0.0.1:1234").unwrap());
4282 assert_eq!(tcpip_v4, SocketAddress::from_str(&tcpip_v4.to_string()).unwrap());
4284 let tcpip_v6 = SocketAddress::TcpIpV6 {
4285 addr: Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1).octets(),
4288 assert_eq!(tcpip_v6, SocketAddress::from_str("[0:0:0:0:0:0:0:1]:1234").unwrap());
4289 assert_eq!(tcpip_v6, SocketAddress::from_str(&tcpip_v6.to_string()).unwrap());
4291 let hostname = SocketAddress::Hostname {
4292 hostname: Hostname::try_from("lightning-node.mydomain.com".to_string()).unwrap(),
4295 assert_eq!(hostname, SocketAddress::from_str("lightning-node.mydomain.com:1234").unwrap());
4296 assert_eq!(hostname, SocketAddress::from_str(&hostname.to_string()).unwrap());
4298 let onion_v2 = SocketAddress::OnionV2 ([40, 4, 64, 185, 202, 19, 162, 75, 90, 200, 38, 7],);
4299 assert_eq!("OnionV2([40, 4, 64, 185, 202, 19, 162, 75, 90, 200, 38, 7])", &onion_v2.to_string());
4300 assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("FACEBOOKCOREWWWI.onion:9735"));
4302 let onion_v3 = SocketAddress::OnionV3 {
4303 ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102, 182, 107, 4, 105, 247, 246, 85,
4304 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31, 33, 71, 3],
4309 assert_eq!(onion_v3, SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion:1234").unwrap());
4310 assert_eq!(onion_v3, SocketAddress::from_str(&onion_v3.to_string()).unwrap());
4312 assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6.onion:1234"));
4313 assert_eq!(Err(SocketAddressParseError::InvalidInput), SocketAddress::from_str("127.0.0.1@1234"));
4314 assert_eq!(Err(SocketAddressParseError::InvalidInput), "".parse::<SocketAddress>());
4315 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:9735:94").is_err());
4316 assert!(SocketAddress::from_str("wrong$%#.com:1234").is_err());
4317 assert_eq!(Err(SocketAddressParseError::InvalidPort), SocketAddress::from_str("example.com:wrong"));
4318 assert!("localhost".parse::<SocketAddress>().is_err());
4319 assert!("localhost:invalid-port".parse::<SocketAddress>().is_err());
4320 assert!( "invalid-onion-v3-hostname.onion:8080".parse::<SocketAddress>().is_err());
4321 assert!("b32.example.onion:invalid-port".parse::<SocketAddress>().is_err());
4322 assert!("invalid-address".parse::<SocketAddress>().is_err());
4323 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:1234").is_err());
4327 #[cfg(feature = "std")]
4328 fn test_socket_address_to_socket_addrs() {
4329 assert_eq!(SocketAddress::TcpIpV4 {addr:[0u8; 4], port: 1337,}.to_socket_addrs().unwrap().next().unwrap(),
4330 SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(0,0,0,0), 1337)));
4331 assert_eq!(SocketAddress::TcpIpV6 {addr:[0u8; 16], port: 1337,}.to_socket_addrs().unwrap().next().unwrap(),
4332 SocketAddr::V6(SocketAddrV6::new(Ipv6Addr::from([0u8; 16]), 1337, 0, 0)));
4333 assert_eq!(SocketAddress::Hostname { hostname: Hostname::try_from("0.0.0.0".to_string()).unwrap(), port: 0 }
4334 .to_socket_addrs().unwrap().next().unwrap(), SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::from([0u8; 4]),0)));
4335 assert!(SocketAddress::OnionV2([0u8; 12]).to_socket_addrs().is_err());
4336 assert!(SocketAddress::OnionV3{ ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102,
4337 182, 107, 4, 105, 247, 246, 85, 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31,
4341 port: 1234 }.to_socket_addrs().is_err());