]> git.bitcoin.ninja Git - rust-lightning/blob - lightning/src/ln/msgs.rs
37bb47ed477ff1329847cc0bc33ec8b374a886d9
[rust-lightning] / lightning / src / ln / msgs.rs
1 // This file is Copyright its original authors, visible in version control
2 // history.
3 //
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
8 // licenses.
9
10 //! Wire messages, traits representing wire message handlers, and a few error types live here.
11 //!
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
16 //! daemons/servers.
17 //!
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.
26
27 use bitcoin::blockdata::constants::ChainHash;
28 use bitcoin::secp256k1::PublicKey;
29 use bitcoin::secp256k1::ecdsa::Signature;
30 use bitcoin::{secp256k1, Witness};
31 use bitcoin::blockdata::script::Script;
32 use bitcoin::hash_types::Txid;
33
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};
40
41 use crate::prelude::*;
42 #[cfg(feature = "std")]
43 use core::convert::TryFrom;
44 use core::fmt;
45 use core::fmt::Debug;
46 use core::ops::Deref;
47 #[cfg(feature = "std")]
48 use core::str::FromStr;
49 #[cfg(feature = "std")]
50 use std::net::SocketAddr;
51 use crate::io::{self, Cursor, Read};
52 use crate::io_extras::read_to_end;
53
54 use crate::events::MessageSendEventsProvider;
55 use crate::util::chacha20poly1305rfc::ChaChaPolyReadAdapter;
56 use crate::util::logger;
57 use crate::util::ser::{LengthReadable, LengthReadableArgs, Readable, ReadableArgs, Writeable, Writer, WithoutLength, FixedLengthReader, HighZeroBytesDroppedBigSize, Hostname, TransactionU16LenLimited, BigSize};
58 use crate::util::base32;
59
60 use crate::routing::gossip::{NodeAlias, NodeId};
61
62 /// 21 million * 10^8 * 1000
63 pub(crate) const MAX_VALUE_MSAT: u64 = 21_000_000_0000_0000_000;
64
65 #[cfg(taproot)]
66 /// A partial signature that also contains the Musig2 nonce its signer used
67 #[derive(Clone, Debug, PartialEq, Eq)]
68 pub struct PartialSignatureWithNonce(pub musig2::types::PartialSignature, pub musig2::types::PublicNonce);
69
70 /// An error in decoding a message or struct.
71 #[derive(Clone, Debug, PartialEq, Eq)]
72 pub enum DecodeError {
73         /// A version byte specified something we don't know how to handle.
74         ///
75         /// Includes unknown realm byte in an onion hop data packet.
76         UnknownVersion,
77         /// Unknown feature mandating we fail to parse message (e.g., TLV with an even, unknown type)
78         UnknownRequiredFeature,
79         /// Value was invalid.
80         ///
81         /// For example, a byte which was supposed to be a bool was something other than a 0
82         /// or 1, a public key/private key/signature was invalid, text wasn't UTF-8, TLV was
83         /// syntactically incorrect, etc.
84         InvalidValue,
85         /// The buffer to be read was too short.
86         ShortRead,
87         /// A length descriptor in the packet didn't describe the later data correctly.
88         BadLengthDescriptor,
89         /// Error from [`std::io`].
90         Io(io::ErrorKind),
91         /// The message included zlib-compressed values, which we don't support.
92         UnsupportedCompression,
93 }
94
95 /// An [`init`] message to be sent to or received from a peer.
96 ///
97 /// [`init`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-init-message
98 #[derive(Clone, Debug, PartialEq, Eq)]
99 pub struct Init {
100         /// The relevant features which the sender supports.
101         pub features: InitFeatures,
102         /// Indicates chains the sender is interested in.
103         ///
104         /// If there are no common chains, the connection will be closed.
105         pub networks: Option<Vec<ChainHash>>,
106         /// The receipient's network address.
107         ///
108         /// This adds the option to report a remote IP address back to a connecting peer using the init
109         /// message. A node can decide to use that information to discover a potential update to its
110         /// public IPv4 address (NAT) and use that for a [`NodeAnnouncement`] update message containing
111         /// the new address.
112         pub remote_network_address: Option<SocketAddress>,
113 }
114
115 /// An [`error`] message to be sent to or received from a peer.
116 ///
117 /// [`error`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-error-and-warning-messages
118 #[derive(Clone, Debug, PartialEq, Eq)]
119 pub struct ErrorMessage {
120         /// The channel ID involved in the error.
121         ///
122         /// All-0s indicates a general error unrelated to a specific channel, after which all channels
123         /// with the sending peer should be closed.
124         pub channel_id: ChannelId,
125         /// A possibly human-readable error description.
126         ///
127         /// The string should be sanitized before it is used (e.g., emitted to logs or printed to
128         /// `stdout`). Otherwise, a well crafted error message may trigger a security vulnerability in
129         /// the terminal emulator or the logging subsystem.
130         pub data: String,
131 }
132
133 /// A [`warning`] message to be sent to or received from a peer.
134 ///
135 /// [`warning`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-error-and-warning-messages
136 #[derive(Clone, Debug, PartialEq, Eq)]
137 pub struct WarningMessage {
138         /// The channel ID involved in the warning.
139         ///
140         /// All-0s indicates a warning unrelated to a specific channel.
141         pub channel_id: ChannelId,
142         /// A possibly human-readable warning description.
143         ///
144         /// The string should be sanitized before it is used (e.g. emitted to logs or printed to
145         /// stdout). Otherwise, a well crafted error message may trigger a security vulnerability in
146         /// the terminal emulator or the logging subsystem.
147         pub data: String,
148 }
149
150 /// A [`ping`] message to be sent to or received from a peer.
151 ///
152 /// [`ping`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-ping-and-pong-messages
153 #[derive(Clone, Debug, PartialEq, Eq)]
154 pub struct Ping {
155         /// The desired response length.
156         pub ponglen: u16,
157         /// The ping packet size.
158         ///
159         /// This field is not sent on the wire. byteslen zeros are sent.
160         pub byteslen: u16,
161 }
162
163 /// A [`pong`] message to be sent to or received from a peer.
164 ///
165 /// [`pong`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-ping-and-pong-messages
166 #[derive(Clone, Debug, PartialEq, Eq)]
167 pub struct Pong {
168         /// The pong packet size.
169         ///
170         /// This field is not sent on the wire. byteslen zeros are sent.
171         pub byteslen: u16,
172 }
173
174 /// An [`open_channel`] message to be sent to or received from a peer.
175 ///
176 /// Used in V1 channel establishment
177 ///
178 /// [`open_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-open_channel-message
179 #[derive(Clone, Debug, PartialEq, Eq)]
180 pub struct OpenChannel {
181         /// The genesis hash of the blockchain where the channel is to be opened
182         pub chain_hash: ChainHash,
183         /// A temporary channel ID, until the funding outpoint is announced
184         pub temporary_channel_id: ChannelId,
185         /// The channel value
186         pub funding_satoshis: u64,
187         /// The amount to push to the counterparty as part of the open, in milli-satoshi
188         pub push_msat: u64,
189         /// The threshold below which outputs on transactions broadcast by sender will be omitted
190         pub dust_limit_satoshis: u64,
191         /// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
192         pub max_htlc_value_in_flight_msat: u64,
193         /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
194         pub channel_reserve_satoshis: u64,
195         /// The minimum HTLC size incoming to sender, in milli-satoshi
196         pub htlc_minimum_msat: u64,
197         /// The feerate per 1000-weight of sender generated transactions, until updated by
198         /// [`UpdateFee`]
199         pub feerate_per_kw: u32,
200         /// The number of blocks which the counterparty will have to wait to claim on-chain funds if
201         /// they broadcast a commitment transaction
202         pub to_self_delay: u16,
203         /// The maximum number of inbound HTLCs towards sender
204         pub max_accepted_htlcs: u16,
205         /// The sender's key controlling the funding transaction
206         pub funding_pubkey: PublicKey,
207         /// Used to derive a revocation key for transactions broadcast by counterparty
208         pub revocation_basepoint: PublicKey,
209         /// A payment key to sender for transactions broadcast by counterparty
210         pub payment_point: PublicKey,
211         /// Used to derive a payment key to sender for transactions broadcast by sender
212         pub delayed_payment_basepoint: PublicKey,
213         /// Used to derive an HTLC payment key to sender
214         pub htlc_basepoint: PublicKey,
215         /// The first to-be-broadcast-by-sender transaction's per commitment point
216         pub first_per_commitment_point: PublicKey,
217         /// The channel flags to be used
218         pub channel_flags: u8,
219         /// A request to pre-set the to-sender output's `scriptPubkey` for when we collaboratively close
220         pub shutdown_scriptpubkey: Option<Script>,
221         /// The channel type that this channel will represent
222         ///
223         /// If this is `None`, we derive the channel type from the intersection of our
224         /// feature bits with our counterparty's feature bits from the [`Init`] message.
225         pub channel_type: Option<ChannelTypeFeatures>,
226 }
227
228 /// An open_channel2 message to be sent by or received from the channel initiator.
229 ///
230 /// Used in V2 channel establishment
231 ///
232 // TODO(dual_funding): Add spec link for `open_channel2`.
233 #[derive(Clone, Debug, PartialEq, Eq)]
234 pub struct OpenChannelV2 {
235         /// The genesis hash of the blockchain where the channel is to be opened
236         pub chain_hash: ChainHash,
237         /// A temporary channel ID derived using a zeroed out value for the channel acceptor's revocation basepoint
238         pub temporary_channel_id: ChannelId,
239         /// The feerate for the funding transaction set by the channel initiator
240         pub funding_feerate_sat_per_1000_weight: u32,
241         /// The feerate for the commitment transaction set by the channel initiator
242         pub commitment_feerate_sat_per_1000_weight: u32,
243         /// Part of the channel value contributed by the channel initiator
244         pub funding_satoshis: u64,
245         /// The threshold below which outputs on transactions broadcast by the channel initiator will be
246         /// omitted
247         pub dust_limit_satoshis: u64,
248         /// The maximum inbound HTLC value in flight towards channel initiator, in milli-satoshi
249         pub max_htlc_value_in_flight_msat: u64,
250         /// The minimum HTLC size incoming to channel initiator, in milli-satoshi
251         pub htlc_minimum_msat: u64,
252         /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
253         /// broadcast a commitment transaction
254         pub to_self_delay: u16,
255         /// The maximum number of inbound HTLCs towards channel initiator
256         pub max_accepted_htlcs: u16,
257         /// The locktime for the funding transaction
258         pub locktime: u32,
259         /// The channel initiator's key controlling the funding transaction
260         pub funding_pubkey: PublicKey,
261         /// Used to derive a revocation key for transactions broadcast by counterparty
262         pub revocation_basepoint: PublicKey,
263         /// A payment key to channel initiator for transactions broadcast by counterparty
264         pub payment_basepoint: PublicKey,
265         /// Used to derive a payment key to channel initiator for transactions broadcast by channel
266         /// initiator
267         pub delayed_payment_basepoint: PublicKey,
268         /// Used to derive an HTLC payment key to channel initiator
269         pub htlc_basepoint: PublicKey,
270         /// The first to-be-broadcast-by-channel-initiator transaction's per commitment point
271         pub first_per_commitment_point: PublicKey,
272         /// The second to-be-broadcast-by-channel-initiator transaction's per commitment point
273         pub second_per_commitment_point: PublicKey,
274         /// Channel flags
275         pub channel_flags: u8,
276         /// Optionally, a request to pre-set the to-channel-initiator output's scriptPubkey for when we
277         /// collaboratively close
278         pub shutdown_scriptpubkey: Option<Script>,
279         /// The channel type that this channel will represent. If none is set, we derive the channel
280         /// type from the intersection of our feature bits with our counterparty's feature bits from
281         /// the Init message.
282         pub channel_type: Option<ChannelTypeFeatures>,
283         /// Optionally, a requirement that only confirmed inputs can be added
284         pub require_confirmed_inputs: Option<()>,
285 }
286
287 /// An [`accept_channel`] message to be sent to or received from a peer.
288 ///
289 /// Used in V1 channel establishment
290 ///
291 /// [`accept_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-accept_channel-message
292 #[derive(Clone, Debug, PartialEq, Eq)]
293 pub struct AcceptChannel {
294         /// A temporary channel ID, until the funding outpoint is announced
295         pub temporary_channel_id: ChannelId,
296         /// The threshold below which outputs on transactions broadcast by sender will be omitted
297         pub dust_limit_satoshis: u64,
298         /// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
299         pub max_htlc_value_in_flight_msat: u64,
300         /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
301         pub channel_reserve_satoshis: u64,
302         /// The minimum HTLC size incoming to sender, in milli-satoshi
303         pub htlc_minimum_msat: u64,
304         /// Minimum depth of the funding transaction before the channel is considered open
305         pub minimum_depth: u32,
306         /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they broadcast a commitment transaction
307         pub to_self_delay: u16,
308         /// The maximum number of inbound HTLCs towards sender
309         pub max_accepted_htlcs: u16,
310         /// The sender's key controlling the funding transaction
311         pub funding_pubkey: PublicKey,
312         /// Used to derive a revocation key for transactions broadcast by counterparty
313         pub revocation_basepoint: PublicKey,
314         /// A payment key to sender for transactions broadcast by counterparty
315         pub payment_point: PublicKey,
316         /// Used to derive a payment key to sender for transactions broadcast by sender
317         pub delayed_payment_basepoint: PublicKey,
318         /// Used to derive an HTLC payment key to sender for transactions broadcast by counterparty
319         pub htlc_basepoint: PublicKey,
320         /// The first to-be-broadcast-by-sender transaction's per commitment point
321         pub first_per_commitment_point: PublicKey,
322         /// A request to pre-set the to-sender output's scriptPubkey for when we collaboratively close
323         pub shutdown_scriptpubkey: Option<Script>,
324         /// The channel type that this channel will represent.
325         ///
326         /// If this is `None`, we derive the channel type from the intersection of
327         /// our feature bits with our counterparty's feature bits from the [`Init`] message.
328         /// This is required to match the equivalent field in [`OpenChannel::channel_type`].
329         pub channel_type: Option<ChannelTypeFeatures>,
330         #[cfg(taproot)]
331         /// Next nonce the channel initiator should use to create a funding output signature against
332         pub next_local_nonce: Option<musig2::types::PublicNonce>,
333 }
334
335 /// An accept_channel2 message to be sent by or received from the channel accepter.
336 ///
337 /// Used in V2 channel establishment
338 ///
339 // TODO(dual_funding): Add spec link for `accept_channel2`.
340 #[derive(Clone, Debug, PartialEq, Eq)]
341 pub struct AcceptChannelV2 {
342         /// The same `temporary_channel_id` received from the initiator's `open_channel2` message.
343         pub temporary_channel_id: ChannelId,
344         /// Part of the channel value contributed by the channel acceptor
345         pub funding_satoshis: u64,
346         /// The threshold below which outputs on transactions broadcast by the channel acceptor will be
347         /// omitted
348         pub dust_limit_satoshis: u64,
349         /// The maximum inbound HTLC value in flight towards channel acceptor, in milli-satoshi
350         pub max_htlc_value_in_flight_msat: u64,
351         /// The minimum HTLC size incoming to channel acceptor, in milli-satoshi
352         pub htlc_minimum_msat: u64,
353         /// Minimum depth of the funding transaction before the channel is considered open
354         pub minimum_depth: u32,
355         /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
356         /// broadcast a commitment transaction
357         pub to_self_delay: u16,
358         /// The maximum number of inbound HTLCs towards channel acceptor
359         pub max_accepted_htlcs: u16,
360         /// The channel acceptor's key controlling the funding transaction
361         pub funding_pubkey: PublicKey,
362         /// Used to derive a revocation key for transactions broadcast by counterparty
363         pub revocation_basepoint: PublicKey,
364         /// A payment key to channel acceptor for transactions broadcast by counterparty
365         pub payment_basepoint: PublicKey,
366         /// Used to derive a payment key to channel acceptor for transactions broadcast by channel
367         /// acceptor
368         pub delayed_payment_basepoint: PublicKey,
369         /// Used to derive an HTLC payment key to channel acceptor for transactions broadcast by counterparty
370         pub htlc_basepoint: PublicKey,
371         /// The first to-be-broadcast-by-channel-acceptor transaction's per commitment point
372         pub first_per_commitment_point: PublicKey,
373         /// The second to-be-broadcast-by-channel-acceptor transaction's per commitment point
374         pub second_per_commitment_point: PublicKey,
375         /// Optionally, a request to pre-set the to-channel-acceptor output's scriptPubkey for when we
376         /// collaboratively close
377         pub shutdown_scriptpubkey: Option<Script>,
378         /// The channel type that this channel will represent. If none is set, we derive the channel
379         /// type from the intersection of our feature bits with our counterparty's feature bits from
380         /// the Init message.
381         ///
382         /// This is required to match the equivalent field in [`OpenChannelV2::channel_type`].
383         pub channel_type: Option<ChannelTypeFeatures>,
384         /// Optionally, a requirement that only confirmed inputs can be added
385         pub require_confirmed_inputs: Option<()>,
386 }
387
388 /// A [`funding_created`] message to be sent to or received from a peer.
389 ///
390 /// Used in V1 channel establishment
391 ///
392 /// [`funding_created`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-funding_created-message
393 #[derive(Clone, Debug, PartialEq, Eq)]
394 pub struct FundingCreated {
395         /// A temporary channel ID, until the funding is established
396         pub temporary_channel_id: ChannelId,
397         /// The funding transaction ID
398         pub funding_txid: Txid,
399         /// The specific output index funding this channel
400         pub funding_output_index: u16,
401         /// The signature of the channel initiator (funder) on the initial commitment transaction
402         pub signature: Signature,
403         #[cfg(taproot)]
404         /// The partial signature of the channel initiator (funder)
405         pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
406         #[cfg(taproot)]
407         /// Next nonce the channel acceptor should use to finalize the funding output signature
408         pub next_local_nonce: Option<musig2::types::PublicNonce>
409 }
410
411 /// A [`funding_signed`] message to be sent to or received from a peer.
412 ///
413 /// Used in V1 channel establishment
414 ///
415 /// [`funding_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-funding_signed-message
416 #[derive(Clone, Debug, PartialEq, Eq)]
417 pub struct FundingSigned {
418         /// The channel ID
419         pub channel_id: ChannelId,
420         /// The signature of the channel acceptor (fundee) on the initial commitment transaction
421         pub signature: Signature,
422         #[cfg(taproot)]
423         /// The partial signature of the channel acceptor (fundee)
424         pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
425 }
426
427 /// A [`channel_ready`] message to be sent to or received from a peer.
428 ///
429 /// [`channel_ready`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-channel_ready-message
430 #[derive(Clone, Debug, PartialEq, Eq)]
431 pub struct ChannelReady {
432         /// The channel ID
433         pub channel_id: ChannelId,
434         /// The per-commitment point of the second commitment transaction
435         pub next_per_commitment_point: PublicKey,
436         /// If set, provides a `short_channel_id` alias for this channel.
437         ///
438         /// The sender will accept payments to be forwarded over this SCID and forward them to this
439         /// messages' recipient.
440         pub short_channel_id_alias: Option<u64>,
441 }
442
443 /// A tx_add_input message for adding an input during interactive transaction construction
444 ///
445 // TODO(dual_funding): Add spec link for `tx_add_input`.
446 #[derive(Clone, Debug, PartialEq, Eq)]
447 pub struct TxAddInput {
448         /// The channel ID
449         pub channel_id: ChannelId,
450         /// A randomly chosen unique identifier for this input, which is even for initiators and odd for
451         /// non-initiators.
452         pub serial_id: u64,
453         /// Serialized transaction that contains the output this input spends to verify that it is non
454         /// malleable.
455         pub prevtx: TransactionU16LenLimited,
456         /// The index of the output being spent
457         pub prevtx_out: u32,
458         /// The sequence number of this input
459         pub sequence: u32,
460 }
461
462 /// A tx_add_output message for adding an output during interactive transaction construction.
463 ///
464 // TODO(dual_funding): Add spec link for `tx_add_output`.
465 #[derive(Clone, Debug, PartialEq, Eq)]
466 pub struct TxAddOutput {
467         /// The channel ID
468         pub channel_id: ChannelId,
469         /// A randomly chosen unique identifier for this output, which is even for initiators and odd for
470         /// non-initiators.
471         pub serial_id: u64,
472         /// The satoshi value of the output
473         pub sats: u64,
474         /// The scriptPubKey for the output
475         pub script: Script,
476 }
477
478 /// A tx_remove_input message for removing an input during interactive transaction construction.
479 ///
480 // TODO(dual_funding): Add spec link for `tx_remove_input`.
481 #[derive(Clone, Debug, PartialEq, Eq)]
482 pub struct TxRemoveInput {
483         /// The channel ID
484         pub channel_id: ChannelId,
485         /// The serial ID of the input to be removed
486         pub serial_id: u64,
487 }
488
489 /// A tx_remove_output message for removing an output during interactive transaction construction.
490 ///
491 // TODO(dual_funding): Add spec link for `tx_remove_output`.
492 #[derive(Clone, Debug, PartialEq, Eq)]
493 pub struct TxRemoveOutput {
494         /// The channel ID
495         pub channel_id: ChannelId,
496         /// The serial ID of the output to be removed
497         pub serial_id: u64,
498 }
499
500 /// A tx_complete message signalling the conclusion of a peer's transaction contributions during
501 /// interactive transaction construction.
502 ///
503 // TODO(dual_funding): Add spec link for `tx_complete`.
504 #[derive(Clone, Debug, PartialEq, Eq)]
505 pub struct TxComplete {
506         /// The channel ID
507         pub channel_id: ChannelId,
508 }
509
510 /// A tx_signatures message containing the sender's signatures for a transaction constructed with
511 /// interactive transaction construction.
512 ///
513 // TODO(dual_funding): Add spec link for `tx_signatures`.
514 #[derive(Clone, Debug, PartialEq, Eq)]
515 pub struct TxSignatures {
516         /// The channel ID
517         pub channel_id: ChannelId,
518         /// The TXID
519         pub tx_hash: Txid,
520         /// The list of witnesses
521         pub witnesses: Vec<Witness>,
522 }
523
524 /// A tx_init_rbf message which initiates a replacement of the transaction after it's been
525 /// completed.
526 ///
527 // TODO(dual_funding): Add spec link for `tx_init_rbf`.
528 #[derive(Clone, Debug, PartialEq, Eq)]
529 pub struct TxInitRbf {
530         /// The channel ID
531         pub channel_id: ChannelId,
532         /// The locktime of the transaction
533         pub locktime: u32,
534         /// The feerate of the transaction
535         pub feerate_sat_per_1000_weight: u32,
536         /// The number of satoshis the sender will contribute to or, if negative, remove from
537         /// (e.g. splice-out) the funding output of the transaction
538         pub funding_output_contribution: Option<i64>,
539 }
540
541 /// A tx_ack_rbf message which acknowledges replacement of the transaction after it's been
542 /// completed.
543 ///
544 // TODO(dual_funding): Add spec link for `tx_ack_rbf`.
545 #[derive(Clone, Debug, PartialEq, Eq)]
546 pub struct TxAckRbf {
547         /// The channel ID
548         pub channel_id: ChannelId,
549         /// The number of satoshis the sender will contribute to or, if negative, remove from
550         /// (e.g. splice-out) the funding output of the transaction
551         pub funding_output_contribution: Option<i64>,
552 }
553
554 /// A tx_abort message which signals the cancellation of an in-progress transaction negotiation.
555 ///
556 // TODO(dual_funding): Add spec link for `tx_abort`.
557 #[derive(Clone, Debug, PartialEq, Eq)]
558 pub struct TxAbort {
559         /// The channel ID
560         pub channel_id: ChannelId,
561         /// Message data
562         pub data: Vec<u8>,
563 }
564
565 /// A [`shutdown`] message to be sent to or received from a peer.
566 ///
567 /// [`shutdown`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-initiation-shutdown
568 #[derive(Clone, Debug, PartialEq, Eq)]
569 pub struct Shutdown {
570         /// The channel ID
571         pub channel_id: ChannelId,
572         /// The destination of this peer's funds on closing.
573         ///
574         /// Must be in one of these forms: P2PKH, P2SH, P2WPKH, P2WSH, P2TR.
575         pub scriptpubkey: Script,
576 }
577
578 /// The minimum and maximum fees which the sender is willing to place on the closing transaction.
579 ///
580 /// This is provided in [`ClosingSigned`] by both sides to indicate the fee range they are willing
581 /// to use.
582 #[derive(Clone, Debug, PartialEq, Eq)]
583 pub struct ClosingSignedFeeRange {
584         /// The minimum absolute fee, in satoshis, which the sender is willing to place on the closing
585         /// transaction.
586         pub min_fee_satoshis: u64,
587         /// The maximum absolute fee, in satoshis, which the sender is willing to place on the closing
588         /// transaction.
589         pub max_fee_satoshis: u64,
590 }
591
592 /// A [`closing_signed`] message to be sent to or received from a peer.
593 ///
594 /// [`closing_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-negotiation-closing_signed
595 #[derive(Clone, Debug, PartialEq, Eq)]
596 pub struct ClosingSigned {
597         /// The channel ID
598         pub channel_id: ChannelId,
599         /// The proposed total fee for the closing transaction
600         pub fee_satoshis: u64,
601         /// A signature on the closing transaction
602         pub signature: Signature,
603         /// The minimum and maximum fees which the sender is willing to accept, provided only by new
604         /// nodes.
605         pub fee_range: Option<ClosingSignedFeeRange>,
606 }
607
608 /// An [`update_add_htlc`] message to be sent to or received from a peer.
609 ///
610 /// [`update_add_htlc`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#adding-an-htlc-update_add_htlc
611 #[derive(Clone, Debug, PartialEq, Eq)]
612 pub struct UpdateAddHTLC {
613         /// The channel ID
614         pub channel_id: ChannelId,
615         /// The HTLC ID
616         pub htlc_id: u64,
617         /// The HTLC value in milli-satoshi
618         pub amount_msat: u64,
619         /// The payment hash, the pre-image of which controls HTLC redemption
620         pub payment_hash: PaymentHash,
621         /// The expiry height of the HTLC
622         pub cltv_expiry: u32,
623         /// The extra fee skimmed by the sender of this message. See
624         /// [`ChannelConfig::accept_underpaying_htlcs`].
625         ///
626         /// [`ChannelConfig::accept_underpaying_htlcs`]: crate::util::config::ChannelConfig::accept_underpaying_htlcs
627         pub skimmed_fee_msat: Option<u64>,
628         pub(crate) onion_routing_packet: OnionPacket,
629 }
630
631  /// An onion message to be sent to or received from a peer.
632  ///
633  // TODO: update with link to OM when they are merged into the BOLTs
634 #[derive(Clone, Debug, PartialEq, Eq)]
635 pub struct OnionMessage {
636         /// Used in decrypting the onion packet's payload.
637         pub blinding_point: PublicKey,
638         /// The full onion packet including hop data, pubkey, and hmac
639         pub onion_routing_packet: onion_message::Packet,
640 }
641
642 /// An [`update_fulfill_htlc`] message to be sent to or received from a peer.
643 ///
644 /// [`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
645 #[derive(Clone, Debug, PartialEq, Eq)]
646 pub struct UpdateFulfillHTLC {
647         /// The channel ID
648         pub channel_id: ChannelId,
649         /// The HTLC ID
650         pub htlc_id: u64,
651         /// The pre-image of the payment hash, allowing HTLC redemption
652         pub payment_preimage: PaymentPreimage,
653 }
654
655 /// An [`update_fail_htlc`] message to be sent to or received from a peer.
656 ///
657 /// [`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
658 #[derive(Clone, Debug, PartialEq, Eq)]
659 pub struct UpdateFailHTLC {
660         /// The channel ID
661         pub channel_id: ChannelId,
662         /// The HTLC ID
663         pub htlc_id: u64,
664         pub(crate) reason: OnionErrorPacket,
665 }
666
667 /// An [`update_fail_malformed_htlc`] message to be sent to or received from a peer.
668 ///
669 /// [`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
670 #[derive(Clone, Debug, PartialEq, Eq)]
671 pub struct UpdateFailMalformedHTLC {
672         /// The channel ID
673         pub channel_id: ChannelId,
674         /// The HTLC ID
675         pub htlc_id: u64,
676         pub(crate) sha256_of_onion: [u8; 32],
677         /// The failure code
678         pub failure_code: u16,
679 }
680
681 /// A [`commitment_signed`] message to be sent to or received from a peer.
682 ///
683 /// [`commitment_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#committing-updates-so-far-commitment_signed
684 #[derive(Clone, Debug, PartialEq, Eq)]
685 pub struct CommitmentSigned {
686         /// The channel ID
687         pub channel_id: ChannelId,
688         /// A signature on the commitment transaction
689         pub signature: Signature,
690         /// Signatures on the HTLC transactions
691         pub htlc_signatures: Vec<Signature>,
692         #[cfg(taproot)]
693         /// The partial Taproot signature on the commitment transaction
694         pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
695 }
696
697 /// A [`revoke_and_ack`] message to be sent to or received from a peer.
698 ///
699 /// [`revoke_and_ack`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#completing-the-transition-to-the-updated-state-revoke_and_ack
700 #[derive(Clone, Debug, PartialEq, Eq)]
701 pub struct RevokeAndACK {
702         /// The channel ID
703         pub channel_id: ChannelId,
704         /// The secret corresponding to the per-commitment point
705         pub per_commitment_secret: [u8; 32],
706         /// The next sender-broadcast commitment transaction's per-commitment point
707         pub next_per_commitment_point: PublicKey,
708         #[cfg(taproot)]
709         /// Musig nonce the recipient should use in their next commitment signature message
710         pub next_local_nonce: Option<musig2::types::PublicNonce>
711 }
712
713 /// An [`update_fee`] message to be sent to or received from a peer
714 ///
715 /// [`update_fee`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#updating-fees-update_fee
716 #[derive(Clone, Debug, PartialEq, Eq)]
717 pub struct UpdateFee {
718         /// The channel ID
719         pub channel_id: ChannelId,
720         /// Fee rate per 1000-weight of the transaction
721         pub feerate_per_kw: u32,
722 }
723
724 /// A [`channel_reestablish`] message to be sent to or received from a peer.
725 ///
726 /// [`channel_reestablish`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#message-retransmission
727 #[derive(Clone, Debug, PartialEq, Eq)]
728 pub struct ChannelReestablish {
729         /// The channel ID
730         pub channel_id: ChannelId,
731         /// The next commitment number for the sender
732         pub next_local_commitment_number: u64,
733         /// The next commitment number for the recipient
734         pub next_remote_commitment_number: u64,
735         /// Proof that the sender knows the per-commitment secret of a specific commitment transaction
736         /// belonging to the recipient
737         pub your_last_per_commitment_secret: [u8; 32],
738         /// The sender's per-commitment point for their current commitment transaction
739         pub my_current_per_commitment_point: PublicKey,
740         /// The next funding transaction ID
741         pub next_funding_txid: Option<Txid>,
742 }
743
744 /// An [`announcement_signatures`] message to be sent to or received from a peer.
745 ///
746 /// [`announcement_signatures`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-announcement_signatures-message
747 #[derive(Clone, Debug, PartialEq, Eq)]
748 pub struct AnnouncementSignatures {
749         /// The channel ID
750         pub channel_id: ChannelId,
751         /// The short channel ID
752         pub short_channel_id: u64,
753         /// A signature by the node key
754         pub node_signature: Signature,
755         /// A signature by the funding key
756         pub bitcoin_signature: Signature,
757 }
758
759 /// An address which can be used to connect to a remote peer.
760 #[derive(Clone, Debug, PartialEq, Eq)]
761 pub enum SocketAddress {
762         /// An IPv4 address and port on which the peer is listening.
763         TcpIpV4 {
764                 /// The 4-byte IPv4 address
765                 addr: [u8; 4],
766                 /// The port on which the node is listening
767                 port: u16,
768         },
769         /// An IPv6 address and port on which the peer is listening.
770         TcpIpV6 {
771                 /// The 16-byte IPv6 address
772                 addr: [u8; 16],
773                 /// The port on which the node is listening
774                 port: u16,
775         },
776         /// An old-style Tor onion address/port on which the peer is listening.
777         ///
778         /// This field is deprecated and the Tor network generally no longer supports V2 Onion
779         /// addresses. Thus, the details are not parsed here.
780         OnionV2([u8; 12]),
781         /// A new-style Tor onion address/port on which the peer is listening.
782         ///
783         /// To create the human-readable "hostname", concatenate the ED25519 pubkey, checksum, and version,
784         /// wrap as base32 and append ".onion".
785         OnionV3 {
786                 /// The ed25519 long-term public key of the peer
787                 ed25519_pubkey: [u8; 32],
788                 /// The checksum of the pubkey and version, as included in the onion address
789                 checksum: u16,
790                 /// The version byte, as defined by the Tor Onion v3 spec.
791                 version: u8,
792                 /// The port on which the node is listening
793                 port: u16,
794         },
795         /// A hostname/port on which the peer is listening.
796         Hostname {
797                 /// The hostname on which the node is listening.
798                 hostname: Hostname,
799                 /// The port on which the node is listening.
800                 port: u16,
801         },
802 }
803 impl SocketAddress {
804         /// Gets the ID of this address type. Addresses in [`NodeAnnouncement`] messages should be sorted
805         /// by this.
806         pub(crate) fn get_id(&self) -> u8 {
807                 match self {
808                         &SocketAddress::TcpIpV4 {..} => { 1 },
809                         &SocketAddress::TcpIpV6 {..} => { 2 },
810                         &SocketAddress::OnionV2(_) => { 3 },
811                         &SocketAddress::OnionV3 {..} => { 4 },
812                         &SocketAddress::Hostname {..} => { 5 },
813                 }
814         }
815
816         /// Strict byte-length of address descriptor, 1-byte type not recorded
817         fn len(&self) -> u16 {
818                 match self {
819                         &SocketAddress::TcpIpV4 { .. } => { 6 },
820                         &SocketAddress::TcpIpV6 { .. } => { 18 },
821                         &SocketAddress::OnionV2(_) => { 12 },
822                         &SocketAddress::OnionV3 { .. } => { 37 },
823                         // Consists of 1-byte hostname length, hostname bytes, and 2-byte port.
824                         &SocketAddress::Hostname { ref hostname, .. } => { u16::from(hostname.len()) + 3 },
825                 }
826         }
827
828         /// The maximum length of any address descriptor, not including the 1-byte type.
829         /// This maximum length is reached by a hostname address descriptor:
830         /// a hostname with a maximum length of 255, its 1-byte length and a 2-byte port.
831         pub(crate) const MAX_LEN: u16 = 258;
832 }
833
834 impl Writeable for SocketAddress {
835         fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
836                 match self {
837                         &SocketAddress::TcpIpV4 { ref addr, ref port } => {
838                                 1u8.write(writer)?;
839                                 addr.write(writer)?;
840                                 port.write(writer)?;
841                         },
842                         &SocketAddress::TcpIpV6 { ref addr, ref port } => {
843                                 2u8.write(writer)?;
844                                 addr.write(writer)?;
845                                 port.write(writer)?;
846                         },
847                         &SocketAddress::OnionV2(bytes) => {
848                                 3u8.write(writer)?;
849                                 bytes.write(writer)?;
850                         },
851                         &SocketAddress::OnionV3 { ref ed25519_pubkey, ref checksum, ref version, ref port } => {
852                                 4u8.write(writer)?;
853                                 ed25519_pubkey.write(writer)?;
854                                 checksum.write(writer)?;
855                                 version.write(writer)?;
856                                 port.write(writer)?;
857                         },
858                         &SocketAddress::Hostname { ref hostname, ref port } => {
859                                 5u8.write(writer)?;
860                                 hostname.write(writer)?;
861                                 port.write(writer)?;
862                         },
863                 }
864                 Ok(())
865         }
866 }
867
868 impl Readable for Result<SocketAddress, u8> {
869         fn read<R: Read>(reader: &mut R) -> Result<Result<SocketAddress, u8>, DecodeError> {
870                 let byte = <u8 as Readable>::read(reader)?;
871                 match byte {
872                         1 => {
873                                 Ok(Ok(SocketAddress::TcpIpV4 {
874                                         addr: Readable::read(reader)?,
875                                         port: Readable::read(reader)?,
876                                 }))
877                         },
878                         2 => {
879                                 Ok(Ok(SocketAddress::TcpIpV6 {
880                                         addr: Readable::read(reader)?,
881                                         port: Readable::read(reader)?,
882                                 }))
883                         },
884                         3 => Ok(Ok(SocketAddress::OnionV2(Readable::read(reader)?))),
885                         4 => {
886                                 Ok(Ok(SocketAddress::OnionV3 {
887                                         ed25519_pubkey: Readable::read(reader)?,
888                                         checksum: Readable::read(reader)?,
889                                         version: Readable::read(reader)?,
890                                         port: Readable::read(reader)?,
891                                 }))
892                         },
893                         5 => {
894                                 Ok(Ok(SocketAddress::Hostname {
895                                         hostname: Readable::read(reader)?,
896                                         port: Readable::read(reader)?,
897                                 }))
898                         },
899                         _ => return Ok(Err(byte)),
900                 }
901         }
902 }
903
904 impl Readable for SocketAddress {
905         fn read<R: Read>(reader: &mut R) -> Result<SocketAddress, DecodeError> {
906                 match Readable::read(reader) {
907                         Ok(Ok(res)) => Ok(res),
908                         Ok(Err(_)) => Err(DecodeError::UnknownVersion),
909                         Err(e) => Err(e),
910                 }
911         }
912 }
913
914 /// [`SocketAddress`] error variants
915 #[derive(Debug, Eq, PartialEq, Clone)]
916 pub enum SocketAddressParseError {
917         /// Socket address (IPv4/IPv6) parsing error
918         SocketAddrParse,
919         /// Invalid input format
920         InvalidInput,
921         /// Invalid port
922         InvalidPort,
923         /// Invalid onion v3 address
924         InvalidOnionV3,
925 }
926
927 impl fmt::Display for SocketAddressParseError {
928         fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
929                 match self {
930                         SocketAddressParseError::SocketAddrParse => write!(f, "Socket address (IPv4/IPv6) parsing error"),
931                         SocketAddressParseError::InvalidInput => write!(f, "Invalid input format. \
932                                 Expected: \"<ipv4>:<port>\", \"[<ipv6>]:<port>\", \"<onion address>.onion:<port>\" or \"<hostname>:<port>\""),
933                         SocketAddressParseError::InvalidPort => write!(f, "Invalid port"),
934                         SocketAddressParseError::InvalidOnionV3 => write!(f, "Invalid onion v3 address"),
935                 }
936         }
937 }
938
939 #[cfg(feature = "std")]
940 impl From<std::net::SocketAddrV4> for SocketAddress {
941                 fn from(addr: std::net::SocketAddrV4) -> Self {
942                         SocketAddress::TcpIpV4 { addr: addr.ip().octets(), port: addr.port() }
943                 }
944 }
945
946 #[cfg(feature = "std")]
947 impl From<std::net::SocketAddrV6> for SocketAddress {
948                 fn from(addr: std::net::SocketAddrV6) -> Self {
949                         SocketAddress::TcpIpV6 { addr: addr.ip().octets(), port: addr.port() }
950                 }
951 }
952
953 #[cfg(feature = "std")]
954 impl From<std::net::SocketAddr> for SocketAddress {
955                 fn from(addr: std::net::SocketAddr) -> Self {
956                         match addr {
957                                 std::net::SocketAddr::V4(addr) => addr.into(),
958                                 std::net::SocketAddr::V6(addr) => addr.into(),
959                         }
960                 }
961 }
962
963 #[cfg(feature = "std")]
964 impl std::net::ToSocketAddrs for SocketAddress {
965         type Iter = std::vec::IntoIter<std::net::SocketAddr>;
966
967         fn to_socket_addrs(&self) -> std::io::Result<Self::Iter> {
968                 match self {
969                         SocketAddress::TcpIpV4 { addr, port } => {
970                                 let ip_addr = std::net::Ipv4Addr::from(*addr);
971                                 let socket_addr = SocketAddr::new(ip_addr.into(), *port);
972                                 Ok(vec![socket_addr].into_iter())
973                         }
974                         SocketAddress::TcpIpV6 { addr, port } => {
975                                 let ip_addr = std::net::Ipv6Addr::from(*addr);
976                                 let socket_addr = SocketAddr::new(ip_addr.into(), *port);
977                                 Ok(vec![socket_addr].into_iter())
978                         }
979                         SocketAddress::Hostname { ref hostname, port } => {
980                                 (hostname.as_str(), *port).to_socket_addrs()
981                         }
982                         SocketAddress::OnionV2(..) => {
983                                 Err(std::io::Error::new(std::io::ErrorKind::Other, "Resolution of OnionV2 \
984                                 addresses is currently unsupported."))
985                         }
986                         SocketAddress::OnionV3 { .. } => {
987                                 Err(std::io::Error::new(std::io::ErrorKind::Other, "Resolution of OnionV3 \
988                                 addresses is currently unsupported."))
989                         }
990                 }
991         }
992 }
993
994 /// Parses an OnionV3 host and port into a [`SocketAddress::OnionV3`].
995 ///
996 /// The host part must end with ".onion".
997 pub fn parse_onion_address(host: &str, port: u16) -> Result<SocketAddress, SocketAddressParseError> {
998         if host.ends_with(".onion") {
999                 let domain = &host[..host.len() - ".onion".len()];
1000                 if domain.len() != 56 {
1001                         return Err(SocketAddressParseError::InvalidOnionV3);
1002                 }
1003                 let onion =  base32::Alphabet::RFC4648 { padding: false }.decode(&domain).map_err(|_| SocketAddressParseError::InvalidOnionV3)?;
1004                 if onion.len() != 35 {
1005                         return Err(SocketAddressParseError::InvalidOnionV3);
1006                 }
1007                 let version = onion[0];
1008                 let first_checksum_flag = onion[1];
1009                 let second_checksum_flag = onion[2];
1010                 let mut ed25519_pubkey = [0; 32];
1011                 ed25519_pubkey.copy_from_slice(&onion[3..35]);
1012                 let checksum = u16::from_be_bytes([first_checksum_flag, second_checksum_flag]);
1013                 return Ok(SocketAddress::OnionV3 { ed25519_pubkey, checksum, version, port });
1014
1015         } else {
1016                 return Err(SocketAddressParseError::InvalidInput);
1017         }
1018 }
1019
1020 #[cfg(feature = "std")]
1021 impl FromStr for SocketAddress {
1022         type Err = SocketAddressParseError;
1023
1024         fn from_str(s: &str) -> Result<Self, Self::Err> {
1025                 match std::net::SocketAddr::from_str(s) {
1026                         Ok(addr) => Ok(addr.into()),
1027                         Err(_) => {
1028                                 let trimmed_input = match s.rfind(":") {
1029                                         Some(pos) => pos,
1030                                         None => return Err(SocketAddressParseError::InvalidInput),
1031                                 };
1032                                 let host = &s[..trimmed_input];
1033                                 let port: u16 = s[trimmed_input + 1..].parse().map_err(|_| SocketAddressParseError::InvalidPort)?;
1034                                 if host.ends_with(".onion") {
1035                                         return parse_onion_address(host, port);
1036                                 };
1037                                 if let Ok(hostname) = Hostname::try_from(s[..trimmed_input].to_string()) {
1038                                         return Ok(SocketAddress::Hostname { hostname, port });
1039                                 };
1040                                 return Err(SocketAddressParseError::SocketAddrParse)
1041                         },
1042                 }
1043         }
1044 }
1045
1046 /// Represents the set of gossip messages that require a signature from a node's identity key.
1047 pub enum UnsignedGossipMessage<'a> {
1048         /// An unsigned channel announcement.
1049         ChannelAnnouncement(&'a UnsignedChannelAnnouncement),
1050         /// An unsigned channel update.
1051         ChannelUpdate(&'a UnsignedChannelUpdate),
1052         /// An unsigned node announcement.
1053         NodeAnnouncement(&'a UnsignedNodeAnnouncement)
1054 }
1055
1056 impl<'a> Writeable for UnsignedGossipMessage<'a> {
1057         fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
1058                 match self {
1059                         UnsignedGossipMessage::ChannelAnnouncement(ref msg) => msg.write(writer),
1060                         UnsignedGossipMessage::ChannelUpdate(ref msg) => msg.write(writer),
1061                         UnsignedGossipMessage::NodeAnnouncement(ref msg) => msg.write(writer),
1062                 }
1063         }
1064 }
1065
1066 /// The unsigned part of a [`node_announcement`] message.
1067 ///
1068 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
1069 #[derive(Clone, Debug, PartialEq, Eq)]
1070 pub struct UnsignedNodeAnnouncement {
1071         /// The advertised features
1072         pub features: NodeFeatures,
1073         /// A strictly monotonic announcement counter, with gaps allowed
1074         pub timestamp: u32,
1075         /// The `node_id` this announcement originated from (don't rebroadcast the `node_announcement` back
1076         /// to this node).
1077         pub node_id: NodeId,
1078         /// An RGB color for UI purposes
1079         pub rgb: [u8; 3],
1080         /// An alias, for UI purposes.
1081         ///
1082         /// This should be sanitized before use. There is no guarantee of uniqueness.
1083         pub alias: NodeAlias,
1084         /// List of addresses on which this node is reachable
1085         pub addresses: Vec<SocketAddress>,
1086         pub(crate) excess_address_data: Vec<u8>,
1087         pub(crate) excess_data: Vec<u8>,
1088 }
1089 #[derive(Clone, Debug, PartialEq, Eq)]
1090 /// A [`node_announcement`] message to be sent to or received from a peer.
1091 ///
1092 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
1093 pub struct NodeAnnouncement {
1094         /// The signature by the node key
1095         pub signature: Signature,
1096         /// The actual content of the announcement
1097         pub contents: UnsignedNodeAnnouncement,
1098 }
1099
1100 /// The unsigned part of a [`channel_announcement`] message.
1101 ///
1102 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
1103 #[derive(Clone, Debug, PartialEq, Eq)]
1104 pub struct UnsignedChannelAnnouncement {
1105         /// The advertised channel features
1106         pub features: ChannelFeatures,
1107         /// The genesis hash of the blockchain where the channel is to be opened
1108         pub chain_hash: ChainHash,
1109         /// The short channel ID
1110         pub short_channel_id: u64,
1111         /// One of the two `node_id`s which are endpoints of this channel
1112         pub node_id_1: NodeId,
1113         /// The other of the two `node_id`s which are endpoints of this channel
1114         pub node_id_2: NodeId,
1115         /// The funding key for the first node
1116         pub bitcoin_key_1: NodeId,
1117         /// The funding key for the second node
1118         pub bitcoin_key_2: NodeId,
1119         /// Excess data which was signed as a part of the message which we do not (yet) understand how
1120         /// to decode.
1121         ///
1122         /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1123         pub excess_data: Vec<u8>,
1124 }
1125 /// A [`channel_announcement`] message to be sent to or received from a peer.
1126 ///
1127 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
1128 #[derive(Clone, Debug, PartialEq, Eq)]
1129 pub struct ChannelAnnouncement {
1130         /// Authentication of the announcement by the first public node
1131         pub node_signature_1: Signature,
1132         /// Authentication of the announcement by the second public node
1133         pub node_signature_2: Signature,
1134         /// Proof of funding UTXO ownership by the first public node
1135         pub bitcoin_signature_1: Signature,
1136         /// Proof of funding UTXO ownership by the second public node
1137         pub bitcoin_signature_2: Signature,
1138         /// The actual announcement
1139         pub contents: UnsignedChannelAnnouncement,
1140 }
1141
1142 /// The unsigned part of a [`channel_update`] message.
1143 ///
1144 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1145 #[derive(Clone, Debug, PartialEq, Eq)]
1146 pub struct UnsignedChannelUpdate {
1147         /// The genesis hash of the blockchain where the channel is to be opened
1148         pub chain_hash: ChainHash,
1149         /// The short channel ID
1150         pub short_channel_id: u64,
1151         /// A strictly monotonic announcement counter, with gaps allowed, specific to this channel
1152         pub timestamp: u32,
1153         /// Channel flags
1154         pub flags: u8,
1155         /// The number of blocks such that if:
1156         /// `incoming_htlc.cltv_expiry < outgoing_htlc.cltv_expiry + cltv_expiry_delta`
1157         /// then we need to fail the HTLC backwards. When forwarding an HTLC, `cltv_expiry_delta` determines
1158         /// the outgoing HTLC's minimum `cltv_expiry` value -- so, if an incoming HTLC comes in with a
1159         /// `cltv_expiry` of 100000, and the node we're forwarding to has a `cltv_expiry_delta` value of 10,
1160         /// then we'll check that the outgoing HTLC's `cltv_expiry` value is at least 100010 before
1161         /// forwarding. Note that the HTLC sender is the one who originally sets this value when
1162         /// constructing the route.
1163         pub cltv_expiry_delta: u16,
1164         /// The minimum HTLC size incoming to sender, in milli-satoshi
1165         pub htlc_minimum_msat: u64,
1166         /// The maximum HTLC value incoming to sender, in milli-satoshi.
1167         ///
1168         /// This used to be optional.
1169         pub htlc_maximum_msat: u64,
1170         /// The base HTLC fee charged by sender, in milli-satoshi
1171         pub fee_base_msat: u32,
1172         /// The amount to fee multiplier, in micro-satoshi
1173         pub fee_proportional_millionths: u32,
1174         /// Excess data which was signed as a part of the message which we do not (yet) understand how
1175         /// to decode.
1176         ///
1177         /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1178         pub excess_data: Vec<u8>,
1179 }
1180 /// A [`channel_update`] message to be sent to or received from a peer.
1181 ///
1182 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1183 #[derive(Clone, Debug, PartialEq, Eq)]
1184 pub struct ChannelUpdate {
1185         /// A signature of the channel update
1186         pub signature: Signature,
1187         /// The actual channel update
1188         pub contents: UnsignedChannelUpdate,
1189 }
1190
1191 /// A [`query_channel_range`] message is used to query a peer for channel
1192 /// UTXOs in a range of blocks. The recipient of a query makes a best
1193 /// effort to reply to the query using one or more [`ReplyChannelRange`]
1194 /// messages.
1195 ///
1196 /// [`query_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1197 #[derive(Clone, Debug, PartialEq, Eq)]
1198 pub struct QueryChannelRange {
1199         /// The genesis hash of the blockchain being queried
1200         pub chain_hash: ChainHash,
1201         /// The height of the first block for the channel UTXOs being queried
1202         pub first_blocknum: u32,
1203         /// The number of blocks to include in the query results
1204         pub number_of_blocks: u32,
1205 }
1206
1207 /// A [`reply_channel_range`] message is a reply to a [`QueryChannelRange`]
1208 /// message.
1209 ///
1210 /// Multiple `reply_channel_range` messages can be sent in reply
1211 /// to a single [`QueryChannelRange`] message. The query recipient makes a
1212 /// best effort to respond based on their local network view which may
1213 /// not be a perfect view of the network. The `short_channel_id`s in the
1214 /// reply are encoded. We only support `encoding_type=0` uncompressed
1215 /// serialization and do not support `encoding_type=1` zlib serialization.
1216 ///
1217 /// [`reply_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1218 #[derive(Clone, Debug, PartialEq, Eq)]
1219 pub struct ReplyChannelRange {
1220         /// The genesis hash of the blockchain being queried
1221         pub chain_hash: ChainHash,
1222         /// The height of the first block in the range of the reply
1223         pub first_blocknum: u32,
1224         /// The number of blocks included in the range of the reply
1225         pub number_of_blocks: u32,
1226         /// True when this is the final reply for a query
1227         pub sync_complete: bool,
1228         /// The `short_channel_id`s in the channel range
1229         pub short_channel_ids: Vec<u64>,
1230 }
1231
1232 /// A [`query_short_channel_ids`] message is used to query a peer for
1233 /// routing gossip messages related to one or more `short_channel_id`s.
1234 ///
1235 /// The query recipient will reply with the latest, if available,
1236 /// [`ChannelAnnouncement`], [`ChannelUpdate`] and [`NodeAnnouncement`] messages
1237 /// it maintains for the requested `short_channel_id`s followed by a
1238 /// [`ReplyShortChannelIdsEnd`] message. The `short_channel_id`s sent in
1239 /// this query are encoded. We only support `encoding_type=0` uncompressed
1240 /// serialization and do not support `encoding_type=1` zlib serialization.
1241 ///
1242 /// [`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
1243 #[derive(Clone, Debug, PartialEq, Eq)]
1244 pub struct QueryShortChannelIds {
1245         /// The genesis hash of the blockchain being queried
1246         pub chain_hash: ChainHash,
1247         /// The short_channel_ids that are being queried
1248         pub short_channel_ids: Vec<u64>,
1249 }
1250
1251 /// A [`reply_short_channel_ids_end`] message is sent as a reply to a
1252 /// message. The query recipient makes a best
1253 /// effort to respond based on their local network view which may not be
1254 /// a perfect view of the network.
1255 ///
1256 /// [`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
1257 #[derive(Clone, Debug, PartialEq, Eq)]
1258 pub struct ReplyShortChannelIdsEnd {
1259         /// The genesis hash of the blockchain that was queried
1260         pub chain_hash: ChainHash,
1261         /// Indicates if the query recipient maintains up-to-date channel
1262         /// information for the `chain_hash`
1263         pub full_information: bool,
1264 }
1265
1266 /// A [`gossip_timestamp_filter`] message is used by a node to request
1267 /// gossip relay for messages in the requested time range when the
1268 /// `gossip_queries` feature has been negotiated.
1269 ///
1270 /// [`gossip_timestamp_filter`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-gossip_timestamp_filter-message
1271 #[derive(Clone, Debug, PartialEq, Eq)]
1272 pub struct GossipTimestampFilter {
1273         /// The genesis hash of the blockchain for channel and node information
1274         pub chain_hash: ChainHash,
1275         /// The starting unix timestamp
1276         pub first_timestamp: u32,
1277         /// The range of information in seconds
1278         pub timestamp_range: u32,
1279 }
1280
1281 /// Encoding type for data compression of collections in gossip queries.
1282 ///
1283 /// We do not support `encoding_type=1` zlib serialization [defined in BOLT
1284 /// #7](https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#query-messages).
1285 enum EncodingType {
1286         Uncompressed = 0x00,
1287 }
1288
1289 /// Used to put an error message in a [`LightningError`].
1290 #[derive(Clone, Debug, PartialEq)]
1291 pub enum ErrorAction {
1292         /// The peer took some action which made us think they were useless. Disconnect them.
1293         DisconnectPeer {
1294                 /// An error message which we should make an effort to send before we disconnect.
1295                 msg: Option<ErrorMessage>
1296         },
1297         /// The peer did something incorrect. Tell them without closing any channels and disconnect them.
1298         DisconnectPeerWithWarning {
1299                 /// A warning message which we should make an effort to send before we disconnect.
1300                 msg: WarningMessage,
1301         },
1302         /// The peer did something harmless that we weren't able to process, just log and ignore
1303         // New code should *not* use this. New code must use IgnoreAndLog, below!
1304         IgnoreError,
1305         /// The peer did something harmless that we weren't able to meaningfully process.
1306         /// If the error is logged, log it at the given level.
1307         IgnoreAndLog(logger::Level),
1308         /// The peer provided us with a gossip message which we'd already seen. In most cases this
1309         /// should be ignored, but it may result in the message being forwarded if it is a duplicate of
1310         /// our own channel announcements.
1311         IgnoreDuplicateGossip,
1312         /// The peer did something incorrect. Tell them.
1313         SendErrorMessage {
1314                 /// The message to send.
1315                 msg: ErrorMessage,
1316         },
1317         /// The peer did something incorrect. Tell them without closing any channels.
1318         SendWarningMessage {
1319                 /// The message to send.
1320                 msg: WarningMessage,
1321                 /// The peer may have done something harmless that we weren't able to meaningfully process,
1322                 /// though we should still tell them about it.
1323                 /// If this event is logged, log it at the given level.
1324                 log_level: logger::Level,
1325         },
1326 }
1327
1328 /// An Err type for failure to process messages.
1329 #[derive(Clone, Debug)]
1330 pub struct LightningError {
1331         /// A human-readable message describing the error
1332         pub err: String,
1333         /// The action which should be taken against the offending peer.
1334         pub action: ErrorAction,
1335 }
1336
1337 /// Struct used to return values from [`RevokeAndACK`] messages, containing a bunch of commitment
1338 /// transaction updates if they were pending.
1339 #[derive(Clone, Debug, PartialEq, Eq)]
1340 pub struct CommitmentUpdate {
1341         /// `update_add_htlc` messages which should be sent
1342         pub update_add_htlcs: Vec<UpdateAddHTLC>,
1343         /// `update_fulfill_htlc` messages which should be sent
1344         pub update_fulfill_htlcs: Vec<UpdateFulfillHTLC>,
1345         /// `update_fail_htlc` messages which should be sent
1346         pub update_fail_htlcs: Vec<UpdateFailHTLC>,
1347         /// `update_fail_malformed_htlc` messages which should be sent
1348         pub update_fail_malformed_htlcs: Vec<UpdateFailMalformedHTLC>,
1349         /// An `update_fee` message which should be sent
1350         pub update_fee: Option<UpdateFee>,
1351         /// A `commitment_signed` message which should be sent
1352         pub commitment_signed: CommitmentSigned,
1353 }
1354
1355 /// A trait to describe an object which can receive channel messages.
1356 ///
1357 /// Messages MAY be called in parallel when they originate from different `their_node_ids`, however
1358 /// they MUST NOT be called in parallel when the two calls have the same `their_node_id`.
1359 pub trait ChannelMessageHandler : MessageSendEventsProvider {
1360         // Channel init:
1361         /// Handle an incoming `open_channel` message from the given peer.
1362         fn handle_open_channel(&self, their_node_id: &PublicKey, msg: &OpenChannel);
1363         /// Handle an incoming `open_channel2` message from the given peer.
1364         fn handle_open_channel_v2(&self, their_node_id: &PublicKey, msg: &OpenChannelV2);
1365         /// Handle an incoming `accept_channel` message from the given peer.
1366         fn handle_accept_channel(&self, their_node_id: &PublicKey, msg: &AcceptChannel);
1367         /// Handle an incoming `accept_channel2` message from the given peer.
1368         fn handle_accept_channel_v2(&self, their_node_id: &PublicKey, msg: &AcceptChannelV2);
1369         /// Handle an incoming `funding_created` message from the given peer.
1370         fn handle_funding_created(&self, their_node_id: &PublicKey, msg: &FundingCreated);
1371         /// Handle an incoming `funding_signed` message from the given peer.
1372         fn handle_funding_signed(&self, their_node_id: &PublicKey, msg: &FundingSigned);
1373         /// Handle an incoming `channel_ready` message from the given peer.
1374         fn handle_channel_ready(&self, their_node_id: &PublicKey, msg: &ChannelReady);
1375
1376         // Channel close:
1377         /// Handle an incoming `shutdown` message from the given peer.
1378         fn handle_shutdown(&self, their_node_id: &PublicKey, msg: &Shutdown);
1379         /// Handle an incoming `closing_signed` message from the given peer.
1380         fn handle_closing_signed(&self, their_node_id: &PublicKey, msg: &ClosingSigned);
1381
1382         // Interactive channel construction
1383         /// Handle an incoming `tx_add_input message` from the given peer.
1384         fn handle_tx_add_input(&self, their_node_id: &PublicKey, msg: &TxAddInput);
1385         /// Handle an incoming `tx_add_output` message from the given peer.
1386         fn handle_tx_add_output(&self, their_node_id: &PublicKey, msg: &TxAddOutput);
1387         /// Handle an incoming `tx_remove_input` message from the given peer.
1388         fn handle_tx_remove_input(&self, their_node_id: &PublicKey, msg: &TxRemoveInput);
1389         /// Handle an incoming `tx_remove_output` message from the given peer.
1390         fn handle_tx_remove_output(&self, their_node_id: &PublicKey, msg: &TxRemoveOutput);
1391         /// Handle an incoming `tx_complete message` from the given peer.
1392         fn handle_tx_complete(&self, their_node_id: &PublicKey, msg: &TxComplete);
1393         /// Handle an incoming `tx_signatures` message from the given peer.
1394         fn handle_tx_signatures(&self, their_node_id: &PublicKey, msg: &TxSignatures);
1395         /// Handle an incoming `tx_init_rbf` message from the given peer.
1396         fn handle_tx_init_rbf(&self, their_node_id: &PublicKey, msg: &TxInitRbf);
1397         /// Handle an incoming `tx_ack_rbf` message from the given peer.
1398         fn handle_tx_ack_rbf(&self, their_node_id: &PublicKey, msg: &TxAckRbf);
1399         /// Handle an incoming `tx_abort message` from the given peer.
1400         fn handle_tx_abort(&self, their_node_id: &PublicKey, msg: &TxAbort);
1401
1402         // HTLC handling:
1403         /// Handle an incoming `update_add_htlc` message from the given peer.
1404         fn handle_update_add_htlc(&self, their_node_id: &PublicKey, msg: &UpdateAddHTLC);
1405         /// Handle an incoming `update_fulfill_htlc` message from the given peer.
1406         fn handle_update_fulfill_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFulfillHTLC);
1407         /// Handle an incoming `update_fail_htlc` message from the given peer.
1408         fn handle_update_fail_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailHTLC);
1409         /// Handle an incoming `update_fail_malformed_htlc` message from the given peer.
1410         fn handle_update_fail_malformed_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailMalformedHTLC);
1411         /// Handle an incoming `commitment_signed` message from the given peer.
1412         fn handle_commitment_signed(&self, their_node_id: &PublicKey, msg: &CommitmentSigned);
1413         /// Handle an incoming `revoke_and_ack` message from the given peer.
1414         fn handle_revoke_and_ack(&self, their_node_id: &PublicKey, msg: &RevokeAndACK);
1415
1416         /// Handle an incoming `update_fee` message from the given peer.
1417         fn handle_update_fee(&self, their_node_id: &PublicKey, msg: &UpdateFee);
1418
1419         // Channel-to-announce:
1420         /// Handle an incoming `announcement_signatures` message from the given peer.
1421         fn handle_announcement_signatures(&self, their_node_id: &PublicKey, msg: &AnnouncementSignatures);
1422
1423         // Connection loss/reestablish:
1424         /// Indicates a connection to the peer failed/an existing connection was lost.
1425         fn peer_disconnected(&self, their_node_id: &PublicKey);
1426
1427         /// Handle a peer reconnecting, possibly generating `channel_reestablish` message(s).
1428         ///
1429         /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1430         /// with us. Implementors should be somewhat conservative about doing so, however, as other
1431         /// message handlers may still wish to communicate with this peer.
1432         fn peer_connected(&self, their_node_id: &PublicKey, msg: &Init, inbound: bool) -> Result<(), ()>;
1433         /// Handle an incoming `channel_reestablish` message from the given peer.
1434         fn handle_channel_reestablish(&self, their_node_id: &PublicKey, msg: &ChannelReestablish);
1435
1436         /// Handle an incoming `channel_update` message from the given peer.
1437         fn handle_channel_update(&self, their_node_id: &PublicKey, msg: &ChannelUpdate);
1438
1439         // Error:
1440         /// Handle an incoming `error` message from the given peer.
1441         fn handle_error(&self, their_node_id: &PublicKey, msg: &ErrorMessage);
1442
1443         // Handler information:
1444         /// Gets the node feature flags which this handler itself supports. All available handlers are
1445         /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1446         /// which are broadcasted in our [`NodeAnnouncement`] message.
1447         fn provided_node_features(&self) -> NodeFeatures;
1448
1449         /// Gets the init feature flags which should be sent to the given peer. All available handlers
1450         /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1451         /// which are sent in our [`Init`] message.
1452         ///
1453         /// Note that this method is called before [`Self::peer_connected`].
1454         fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1455
1456         /// Gets the chain hashes for this `ChannelMessageHandler` indicating which chains it supports.
1457         ///
1458         /// If it's `None`, then no particular network chain hash compatibility will be enforced when
1459         /// connecting to peers.
1460         fn get_chain_hashes(&self) -> Option<Vec<ChainHash>>;
1461 }
1462
1463 /// A trait to describe an object which can receive routing messages.
1464 ///
1465 /// # Implementor DoS Warnings
1466 ///
1467 /// For messages enabled with the `gossip_queries` feature there are potential DoS vectors when
1468 /// handling inbound queries. Implementors using an on-disk network graph should be aware of
1469 /// repeated disk I/O for queries accessing different parts of the network graph.
1470 pub trait RoutingMessageHandler : MessageSendEventsProvider {
1471         /// Handle an incoming `node_announcement` message, returning `true` if it should be forwarded on,
1472         /// `false` or returning an `Err` otherwise.
1473         fn handle_node_announcement(&self, msg: &NodeAnnouncement) -> Result<bool, LightningError>;
1474         /// Handle a `channel_announcement` message, returning `true` if it should be forwarded on, `false`
1475         /// or returning an `Err` otherwise.
1476         fn handle_channel_announcement(&self, msg: &ChannelAnnouncement) -> Result<bool, LightningError>;
1477         /// Handle an incoming `channel_update` message, returning true if it should be forwarded on,
1478         /// `false` or returning an `Err` otherwise.
1479         fn handle_channel_update(&self, msg: &ChannelUpdate) -> Result<bool, LightningError>;
1480         /// Gets channel announcements and updates required to dump our routing table to a remote node,
1481         /// starting at the `short_channel_id` indicated by `starting_point` and including announcements
1482         /// for a single channel.
1483         fn get_next_channel_announcement(&self, starting_point: u64) -> Option<(ChannelAnnouncement, Option<ChannelUpdate>, Option<ChannelUpdate>)>;
1484         /// Gets a node announcement required to dump our routing table to a remote node, starting at
1485         /// the node *after* the provided pubkey and including up to one announcement immediately
1486         /// higher (as defined by `<PublicKey as Ord>::cmp`) than `starting_point`.
1487         /// If `None` is provided for `starting_point`, we start at the first node.
1488         fn get_next_node_announcement(&self, starting_point: Option<&NodeId>) -> Option<NodeAnnouncement>;
1489         /// Called when a connection is established with a peer. This can be used to
1490         /// perform routing table synchronization using a strategy defined by the
1491         /// implementor.
1492         ///
1493         /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1494         /// with us. Implementors should be somewhat conservative about doing so, however, as other
1495         /// message handlers may still wish to communicate with this peer.
1496         fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1497         /// Handles the reply of a query we initiated to learn about channels
1498         /// for a given range of blocks. We can expect to receive one or more
1499         /// replies to a single query.
1500         fn handle_reply_channel_range(&self, their_node_id: &PublicKey, msg: ReplyChannelRange) -> Result<(), LightningError>;
1501         /// Handles the reply of a query we initiated asking for routing gossip
1502         /// messages for a list of channels. We should receive this message when
1503         /// a node has completed its best effort to send us the pertaining routing
1504         /// gossip messages.
1505         fn handle_reply_short_channel_ids_end(&self, their_node_id: &PublicKey, msg: ReplyShortChannelIdsEnd) -> Result<(), LightningError>;
1506         /// Handles when a peer asks us to send a list of `short_channel_id`s
1507         /// for the requested range of blocks.
1508         fn handle_query_channel_range(&self, their_node_id: &PublicKey, msg: QueryChannelRange) -> Result<(), LightningError>;
1509         /// Handles when a peer asks us to send routing gossip messages for a
1510         /// list of `short_channel_id`s.
1511         fn handle_query_short_channel_ids(&self, their_node_id: &PublicKey, msg: QueryShortChannelIds) -> Result<(), LightningError>;
1512
1513         // Handler queueing status:
1514         /// Indicates that there are a large number of [`ChannelAnnouncement`] (or other) messages
1515         /// pending some async action. While there is no guarantee of the rate of future messages, the
1516         /// caller should seek to reduce the rate of new gossip messages handled, especially
1517         /// [`ChannelAnnouncement`]s.
1518         fn processing_queue_high(&self) -> bool;
1519
1520         // Handler information:
1521         /// Gets the node feature flags which this handler itself supports. All available handlers are
1522         /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1523         /// which are broadcasted in our [`NodeAnnouncement`] message.
1524         fn provided_node_features(&self) -> NodeFeatures;
1525         /// Gets the init feature flags which should be sent to the given peer. All available handlers
1526         /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1527         /// which are sent in our [`Init`] message.
1528         ///
1529         /// Note that this method is called before [`Self::peer_connected`].
1530         fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1531 }
1532
1533 /// A handler for received [`OnionMessage`]s and for providing generated ones to send.
1534 pub trait OnionMessageHandler {
1535         /// Handle an incoming `onion_message` message from the given peer.
1536         fn handle_onion_message(&self, peer_node_id: &PublicKey, msg: &OnionMessage);
1537
1538         /// Returns the next pending onion message for the peer with the given node id.
1539         fn next_onion_message_for_peer(&self, peer_node_id: PublicKey) -> Option<OnionMessage>;
1540
1541         /// Called when a connection is established with a peer. Can be used to track which peers
1542         /// advertise onion message support and are online.
1543         ///
1544         /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1545         /// with us. Implementors should be somewhat conservative about doing so, however, as other
1546         /// message handlers may still wish to communicate with this peer.
1547         fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1548
1549         /// Indicates a connection to the peer failed/an existing connection was lost. Allows handlers to
1550         /// drop and refuse to forward onion messages to this peer.
1551         fn peer_disconnected(&self, their_node_id: &PublicKey);
1552
1553         // Handler information:
1554         /// Gets the node feature flags which this handler itself supports. All available handlers are
1555         /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1556         /// which are broadcasted in our [`NodeAnnouncement`] message.
1557         fn provided_node_features(&self) -> NodeFeatures;
1558
1559         /// Gets the init feature flags which should be sent to the given peer. All available handlers
1560         /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1561         /// which are sent in our [`Init`] message.
1562         ///
1563         /// Note that this method is called before [`Self::peer_connected`].
1564         fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1565 }
1566
1567 mod fuzzy_internal_msgs {
1568         use bitcoin::secp256k1::PublicKey;
1569         use crate::blinded_path::payment::PaymentConstraints;
1570         use crate::prelude::*;
1571         use crate::ln::{PaymentPreimage, PaymentSecret};
1572
1573         // These types aren't intended to be pub, but are exposed for direct fuzzing (as we deserialize
1574         // them from untrusted input):
1575         #[derive(Clone)]
1576         pub struct FinalOnionHopData {
1577                 pub payment_secret: PaymentSecret,
1578                 /// The total value, in msat, of the payment as received by the ultimate recipient.
1579                 /// Message serialization may panic if this value is more than 21 million Bitcoin.
1580                 pub total_msat: u64,
1581         }
1582
1583         pub enum InboundOnionPayload {
1584                 Forward {
1585                         short_channel_id: u64,
1586                         /// The value, in msat, of the payment after this hop's fee is deducted.
1587                         amt_to_forward: u64,
1588                         outgoing_cltv_value: u32,
1589                 },
1590                 Receive {
1591                         payment_data: Option<FinalOnionHopData>,
1592                         payment_metadata: Option<Vec<u8>>,
1593                         keysend_preimage: Option<PaymentPreimage>,
1594                         custom_tlvs: Vec<(u64, Vec<u8>)>,
1595                         amt_msat: u64,
1596                         outgoing_cltv_value: u32,
1597                 },
1598                 BlindedReceive {
1599                         amt_msat: u64,
1600                         total_msat: u64,
1601                         outgoing_cltv_value: u32,
1602                         payment_secret: PaymentSecret,
1603                         payment_constraints: PaymentConstraints,
1604                         intro_node_blinding_point: PublicKey,
1605                 }
1606         }
1607
1608         pub(crate) enum OutboundOnionPayload {
1609                 Forward {
1610                         short_channel_id: u64,
1611                         /// The value, in msat, of the payment after this hop's fee is deducted.
1612                         amt_to_forward: u64,
1613                         outgoing_cltv_value: u32,
1614                 },
1615                 Receive {
1616                         payment_data: Option<FinalOnionHopData>,
1617                         payment_metadata: Option<Vec<u8>>,
1618                         keysend_preimage: Option<PaymentPreimage>,
1619                         custom_tlvs: Vec<(u64, Vec<u8>)>,
1620                         amt_msat: u64,
1621                         outgoing_cltv_value: u32,
1622                 },
1623                 BlindedForward {
1624                         encrypted_tlvs: Vec<u8>,
1625                         intro_node_blinding_point: Option<PublicKey>,
1626                 },
1627                 BlindedReceive {
1628                         amt_msat: u64,
1629                         total_msat: u64,
1630                         outgoing_cltv_value: u32,
1631                         encrypted_tlvs: Vec<u8>,
1632                         intro_node_blinding_point: Option<PublicKey>, // Set if the introduction node of the blinded path is the final node
1633                 }
1634         }
1635
1636         pub struct DecodedOnionErrorPacket {
1637                 pub(crate) hmac: [u8; 32],
1638                 pub(crate) failuremsg: Vec<u8>,
1639                 pub(crate) pad: Vec<u8>,
1640         }
1641 }
1642 #[cfg(fuzzing)]
1643 pub use self::fuzzy_internal_msgs::*;
1644 #[cfg(not(fuzzing))]
1645 pub(crate) use self::fuzzy_internal_msgs::*;
1646
1647 #[derive(Clone)]
1648 pub(crate) struct OnionPacket {
1649         pub(crate) version: u8,
1650         /// In order to ensure we always return an error on onion decode in compliance with [BOLT
1651         /// #4](https://github.com/lightning/bolts/blob/master/04-onion-routing.md), we have to
1652         /// deserialize `OnionPacket`s contained in [`UpdateAddHTLC`] messages even if the ephemeral
1653         /// public key (here) is bogus, so we hold a [`Result`] instead of a [`PublicKey`] as we'd
1654         /// like.
1655         pub(crate) public_key: Result<PublicKey, secp256k1::Error>,
1656         pub(crate) hop_data: [u8; 20*65],
1657         pub(crate) hmac: [u8; 32],
1658 }
1659
1660 impl onion_utils::Packet for OnionPacket {
1661         type Data = onion_utils::FixedSizeOnionPacket;
1662         fn new(pubkey: PublicKey, hop_data: onion_utils::FixedSizeOnionPacket, hmac: [u8; 32]) -> Self {
1663                 Self {
1664                         version: 0,
1665                         public_key: Ok(pubkey),
1666                         hop_data: hop_data.0,
1667                         hmac,
1668                 }
1669         }
1670 }
1671
1672 impl Eq for OnionPacket { }
1673 impl PartialEq for OnionPacket {
1674         fn eq(&self, other: &OnionPacket) -> bool {
1675                 for (i, j) in self.hop_data.iter().zip(other.hop_data.iter()) {
1676                         if i != j { return false; }
1677                 }
1678                 self.version == other.version &&
1679                         self.public_key == other.public_key &&
1680                         self.hmac == other.hmac
1681         }
1682 }
1683
1684 impl fmt::Debug for OnionPacket {
1685         fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1686                 f.write_fmt(format_args!("OnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
1687         }
1688 }
1689
1690 #[derive(Clone, Debug, PartialEq, Eq)]
1691 pub(crate) struct OnionErrorPacket {
1692         // This really should be a constant size slice, but the spec lets these things be up to 128KB?
1693         // (TODO) We limit it in decode to much lower...
1694         pub(crate) data: Vec<u8>,
1695 }
1696
1697 impl fmt::Display for DecodeError {
1698         fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1699                 match *self {
1700                         DecodeError::UnknownVersion => f.write_str("Unknown realm byte in Onion packet"),
1701                         DecodeError::UnknownRequiredFeature => f.write_str("Unknown required feature preventing decode"),
1702                         DecodeError::InvalidValue => f.write_str("Nonsense bytes didn't map to the type they were interpreted as"),
1703                         DecodeError::ShortRead => f.write_str("Packet extended beyond the provided bytes"),
1704                         DecodeError::BadLengthDescriptor => f.write_str("A length descriptor in the packet didn't describe the later data correctly"),
1705                         DecodeError::Io(ref e) => fmt::Debug::fmt(e, f),
1706                         DecodeError::UnsupportedCompression => f.write_str("We don't support receiving messages with zlib-compressed fields"),
1707                 }
1708         }
1709 }
1710
1711 impl From<io::Error> for DecodeError {
1712         fn from(e: io::Error) -> Self {
1713                 if e.kind() == io::ErrorKind::UnexpectedEof {
1714                         DecodeError::ShortRead
1715                 } else {
1716                         DecodeError::Io(e.kind())
1717                 }
1718         }
1719 }
1720
1721 #[cfg(not(taproot))]
1722 impl_writeable_msg!(AcceptChannel, {
1723         temporary_channel_id,
1724         dust_limit_satoshis,
1725         max_htlc_value_in_flight_msat,
1726         channel_reserve_satoshis,
1727         htlc_minimum_msat,
1728         minimum_depth,
1729         to_self_delay,
1730         max_accepted_htlcs,
1731         funding_pubkey,
1732         revocation_basepoint,
1733         payment_point,
1734         delayed_payment_basepoint,
1735         htlc_basepoint,
1736         first_per_commitment_point,
1737 }, {
1738         (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1739         (1, channel_type, option),
1740 });
1741
1742 #[cfg(taproot)]
1743 impl_writeable_msg!(AcceptChannel, {
1744         temporary_channel_id,
1745         dust_limit_satoshis,
1746         max_htlc_value_in_flight_msat,
1747         channel_reserve_satoshis,
1748         htlc_minimum_msat,
1749         minimum_depth,
1750         to_self_delay,
1751         max_accepted_htlcs,
1752         funding_pubkey,
1753         revocation_basepoint,
1754         payment_point,
1755         delayed_payment_basepoint,
1756         htlc_basepoint,
1757         first_per_commitment_point,
1758 }, {
1759         (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1760         (1, channel_type, option),
1761         (4, next_local_nonce, option),
1762 });
1763
1764 impl_writeable_msg!(AcceptChannelV2, {
1765         temporary_channel_id,
1766         funding_satoshis,
1767         dust_limit_satoshis,
1768         max_htlc_value_in_flight_msat,
1769         htlc_minimum_msat,
1770         minimum_depth,
1771         to_self_delay,
1772         max_accepted_htlcs,
1773         funding_pubkey,
1774         revocation_basepoint,
1775         payment_basepoint,
1776         delayed_payment_basepoint,
1777         htlc_basepoint,
1778         first_per_commitment_point,
1779         second_per_commitment_point,
1780 }, {
1781         (0, shutdown_scriptpubkey, option),
1782         (1, channel_type, option),
1783         (2, require_confirmed_inputs, option),
1784 });
1785
1786 impl_writeable_msg!(TxAddInput, {
1787         channel_id,
1788         serial_id,
1789         prevtx,
1790         prevtx_out,
1791         sequence,
1792 }, {});
1793
1794 impl_writeable_msg!(TxAddOutput, {
1795         channel_id,
1796         serial_id,
1797         sats,
1798         script,
1799 }, {});
1800
1801 impl_writeable_msg!(TxRemoveInput, {
1802         channel_id,
1803         serial_id,
1804 }, {});
1805
1806 impl_writeable_msg!(TxRemoveOutput, {
1807         channel_id,
1808         serial_id,
1809 }, {});
1810
1811 impl_writeable_msg!(TxComplete, {
1812         channel_id,
1813 }, {});
1814
1815 impl_writeable_msg!(TxSignatures, {
1816         channel_id,
1817         tx_hash,
1818         witnesses,
1819 }, {});
1820
1821 impl_writeable_msg!(TxInitRbf, {
1822         channel_id,
1823         locktime,
1824         feerate_sat_per_1000_weight,
1825 }, {
1826         (0, funding_output_contribution, option),
1827 });
1828
1829 impl_writeable_msg!(TxAckRbf, {
1830         channel_id,
1831 }, {
1832         (0, funding_output_contribution, option),
1833 });
1834
1835 impl_writeable_msg!(TxAbort, {
1836         channel_id,
1837         data,
1838 }, {});
1839
1840 impl_writeable_msg!(AnnouncementSignatures, {
1841         channel_id,
1842         short_channel_id,
1843         node_signature,
1844         bitcoin_signature
1845 }, {});
1846
1847 impl_writeable_msg!(ChannelReestablish, {
1848         channel_id,
1849         next_local_commitment_number,
1850         next_remote_commitment_number,
1851         your_last_per_commitment_secret,
1852         my_current_per_commitment_point,
1853 }, {
1854         (0, next_funding_txid, option),
1855 });
1856
1857 impl_writeable_msg!(ClosingSigned,
1858         { channel_id, fee_satoshis, signature },
1859         { (1, fee_range, option) }
1860 );
1861
1862 impl_writeable!(ClosingSignedFeeRange, {
1863         min_fee_satoshis,
1864         max_fee_satoshis
1865 });
1866
1867 #[cfg(not(taproot))]
1868 impl_writeable_msg!(CommitmentSigned, {
1869         channel_id,
1870         signature,
1871         htlc_signatures
1872 }, {});
1873
1874 #[cfg(taproot)]
1875 impl_writeable_msg!(CommitmentSigned, {
1876         channel_id,
1877         signature,
1878         htlc_signatures
1879 }, {
1880         (2, partial_signature_with_nonce, option)
1881 });
1882
1883 impl_writeable!(DecodedOnionErrorPacket, {
1884         hmac,
1885         failuremsg,
1886         pad
1887 });
1888
1889 #[cfg(not(taproot))]
1890 impl_writeable_msg!(FundingCreated, {
1891         temporary_channel_id,
1892         funding_txid,
1893         funding_output_index,
1894         signature
1895 }, {});
1896 #[cfg(taproot)]
1897 impl_writeable_msg!(FundingCreated, {
1898         temporary_channel_id,
1899         funding_txid,
1900         funding_output_index,
1901         signature
1902 }, {
1903         (2, partial_signature_with_nonce, option),
1904         (4, next_local_nonce, option)
1905 });
1906
1907 #[cfg(not(taproot))]
1908 impl_writeable_msg!(FundingSigned, {
1909         channel_id,
1910         signature
1911 }, {});
1912
1913 #[cfg(taproot)]
1914 impl_writeable_msg!(FundingSigned, {
1915         channel_id,
1916         signature
1917 }, {
1918         (2, partial_signature_with_nonce, option)
1919 });
1920
1921 impl_writeable_msg!(ChannelReady, {
1922         channel_id,
1923         next_per_commitment_point,
1924 }, {
1925         (1, short_channel_id_alias, option),
1926 });
1927
1928 impl Writeable for Init {
1929         fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1930                 // global_features gets the bottom 13 bits of our features, and local_features gets all of
1931                 // our relevant feature bits. This keeps us compatible with old nodes.
1932                 self.features.write_up_to_13(w)?;
1933                 self.features.write(w)?;
1934                 encode_tlv_stream!(w, {
1935                         (1, self.networks.as_ref().map(|n| WithoutLength(n)), option),
1936                         (3, self.remote_network_address, option),
1937                 });
1938                 Ok(())
1939         }
1940 }
1941
1942 impl Readable for Init {
1943         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1944                 let global_features: InitFeatures = Readable::read(r)?;
1945                 let features: InitFeatures = Readable::read(r)?;
1946                 let mut remote_network_address: Option<SocketAddress> = None;
1947                 let mut networks: Option<WithoutLength<Vec<ChainHash>>> = None;
1948                 decode_tlv_stream!(r, {
1949                         (1, networks, option),
1950                         (3, remote_network_address, option)
1951                 });
1952                 Ok(Init {
1953                         features: features | global_features,
1954                         networks: networks.map(|n| n.0),
1955                         remote_network_address,
1956                 })
1957         }
1958 }
1959
1960 impl_writeable_msg!(OpenChannel, {
1961         chain_hash,
1962         temporary_channel_id,
1963         funding_satoshis,
1964         push_msat,
1965         dust_limit_satoshis,
1966         max_htlc_value_in_flight_msat,
1967         channel_reserve_satoshis,
1968         htlc_minimum_msat,
1969         feerate_per_kw,
1970         to_self_delay,
1971         max_accepted_htlcs,
1972         funding_pubkey,
1973         revocation_basepoint,
1974         payment_point,
1975         delayed_payment_basepoint,
1976         htlc_basepoint,
1977         first_per_commitment_point,
1978         channel_flags,
1979 }, {
1980         (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1981         (1, channel_type, option),
1982 });
1983
1984 impl_writeable_msg!(OpenChannelV2, {
1985         chain_hash,
1986         temporary_channel_id,
1987         funding_feerate_sat_per_1000_weight,
1988         commitment_feerate_sat_per_1000_weight,
1989         funding_satoshis,
1990         dust_limit_satoshis,
1991         max_htlc_value_in_flight_msat,
1992         htlc_minimum_msat,
1993         to_self_delay,
1994         max_accepted_htlcs,
1995         locktime,
1996         funding_pubkey,
1997         revocation_basepoint,
1998         payment_basepoint,
1999         delayed_payment_basepoint,
2000         htlc_basepoint,
2001         first_per_commitment_point,
2002         second_per_commitment_point,
2003         channel_flags,
2004 }, {
2005         (0, shutdown_scriptpubkey, option),
2006         (1, channel_type, option),
2007         (2, require_confirmed_inputs, option),
2008 });
2009
2010 #[cfg(not(taproot))]
2011 impl_writeable_msg!(RevokeAndACK, {
2012         channel_id,
2013         per_commitment_secret,
2014         next_per_commitment_point
2015 }, {});
2016
2017 #[cfg(taproot)]
2018 impl_writeable_msg!(RevokeAndACK, {
2019         channel_id,
2020         per_commitment_secret,
2021         next_per_commitment_point
2022 }, {
2023         (4, next_local_nonce, option)
2024 });
2025
2026 impl_writeable_msg!(Shutdown, {
2027         channel_id,
2028         scriptpubkey
2029 }, {});
2030
2031 impl_writeable_msg!(UpdateFailHTLC, {
2032         channel_id,
2033         htlc_id,
2034         reason
2035 }, {});
2036
2037 impl_writeable_msg!(UpdateFailMalformedHTLC, {
2038         channel_id,
2039         htlc_id,
2040         sha256_of_onion,
2041         failure_code
2042 }, {});
2043
2044 impl_writeable_msg!(UpdateFee, {
2045         channel_id,
2046         feerate_per_kw
2047 }, {});
2048
2049 impl_writeable_msg!(UpdateFulfillHTLC, {
2050         channel_id,
2051         htlc_id,
2052         payment_preimage
2053 }, {});
2054
2055 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2056 // serialization format in a way which assumes we know the total serialized length/message end
2057 // position.
2058 impl_writeable!(OnionErrorPacket, {
2059         data
2060 });
2061
2062 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2063 // serialization format in a way which assumes we know the total serialized length/message end
2064 // position.
2065 impl Writeable for OnionPacket {
2066         fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2067                 self.version.write(w)?;
2068                 match self.public_key {
2069                         Ok(pubkey) => pubkey.write(w)?,
2070                         Err(_) => [0u8;33].write(w)?,
2071                 }
2072                 w.write_all(&self.hop_data)?;
2073                 self.hmac.write(w)?;
2074                 Ok(())
2075         }
2076 }
2077
2078 impl Readable for OnionPacket {
2079         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2080                 Ok(OnionPacket {
2081                         version: Readable::read(r)?,
2082                         public_key: {
2083                                 let mut buf = [0u8;33];
2084                                 r.read_exact(&mut buf)?;
2085                                 PublicKey::from_slice(&buf)
2086                         },
2087                         hop_data: Readable::read(r)?,
2088                         hmac: Readable::read(r)?,
2089                 })
2090         }
2091 }
2092
2093 impl_writeable_msg!(UpdateAddHTLC, {
2094         channel_id,
2095         htlc_id,
2096         amount_msat,
2097         payment_hash,
2098         cltv_expiry,
2099         onion_routing_packet,
2100 }, {
2101         (65537, skimmed_fee_msat, option)
2102 });
2103
2104 impl Readable for OnionMessage {
2105         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2106                 let blinding_point: PublicKey = Readable::read(r)?;
2107                 let len: u16 = Readable::read(r)?;
2108                 let mut packet_reader = FixedLengthReader::new(r, len as u64);
2109                 let onion_routing_packet: onion_message::Packet = <onion_message::Packet as LengthReadable>::read(&mut packet_reader)?;
2110                 Ok(Self {
2111                         blinding_point,
2112                         onion_routing_packet,
2113                 })
2114         }
2115 }
2116
2117 impl Writeable for OnionMessage {
2118         fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2119                 self.blinding_point.write(w)?;
2120                 let onion_packet_len = self.onion_routing_packet.serialized_length();
2121                 (onion_packet_len as u16).write(w)?;
2122                 self.onion_routing_packet.write(w)?;
2123                 Ok(())
2124         }
2125 }
2126
2127 impl Writeable for FinalOnionHopData {
2128         fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2129                 self.payment_secret.0.write(w)?;
2130                 HighZeroBytesDroppedBigSize(self.total_msat).write(w)
2131         }
2132 }
2133
2134 impl Readable for FinalOnionHopData {
2135         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2136                 let secret: [u8; 32] = Readable::read(r)?;
2137                 let amt: HighZeroBytesDroppedBigSize<u64> = Readable::read(r)?;
2138                 Ok(Self { payment_secret: PaymentSecret(secret), total_msat: amt.0 })
2139         }
2140 }
2141
2142 impl Writeable for OutboundOnionPayload {
2143         fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2144                 match self {
2145                         Self::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } => {
2146                                 _encode_varint_length_prefixed_tlv!(w, {
2147                                         (2, HighZeroBytesDroppedBigSize(*amt_to_forward), required),
2148                                         (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2149                                         (6, short_channel_id, required)
2150                                 });
2151                         },
2152                         Self::Receive {
2153                                 ref payment_data, ref payment_metadata, ref keysend_preimage, amt_msat,
2154                                 outgoing_cltv_value, ref custom_tlvs,
2155                         } => {
2156                                 // We need to update [`ln::outbound_payment::RecipientOnionFields::with_custom_tlvs`]
2157                                 // to reject any reserved types in the experimental range if new ones are ever
2158                                 // standardized.
2159                                 let keysend_tlv = keysend_preimage.map(|preimage| (5482373484, preimage.encode()));
2160                                 let mut custom_tlvs: Vec<&(u64, Vec<u8>)> = custom_tlvs.iter().chain(keysend_tlv.iter()).collect();
2161                                 custom_tlvs.sort_unstable_by_key(|(typ, _)| *typ);
2162                                 _encode_varint_length_prefixed_tlv!(w, {
2163                                         (2, HighZeroBytesDroppedBigSize(*amt_msat), required),
2164                                         (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2165                                         (8, payment_data, option),
2166                                         (16, payment_metadata.as_ref().map(|m| WithoutLength(m)), option)
2167                                 }, custom_tlvs.iter());
2168                         },
2169                         Self::BlindedForward { encrypted_tlvs, intro_node_blinding_point } => {
2170                                 _encode_varint_length_prefixed_tlv!(w, {
2171                                         (10, *encrypted_tlvs, required_vec),
2172                                         (12, intro_node_blinding_point, option)
2173                                 });
2174                         },
2175                         Self::BlindedReceive {
2176                                 amt_msat, total_msat, outgoing_cltv_value, encrypted_tlvs,
2177                                 intro_node_blinding_point,
2178                         } => {
2179                                 _encode_varint_length_prefixed_tlv!(w, {
2180                                         (2, HighZeroBytesDroppedBigSize(*amt_msat), required),
2181                                         (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2182                                         (10, *encrypted_tlvs, required_vec),
2183                                         (12, intro_node_blinding_point, option),
2184                                         (18, HighZeroBytesDroppedBigSize(*total_msat), required)
2185                                 });
2186                         },
2187                 }
2188                 Ok(())
2189         }
2190 }
2191
2192 impl<NS: Deref> ReadableArgs<&NS> for InboundOnionPayload where NS::Target: NodeSigner {
2193         fn read<R: Read>(r: &mut R, node_signer: &NS) -> Result<Self, DecodeError> {
2194                 let mut amt = None;
2195                 let mut cltv_value = None;
2196                 let mut short_id: Option<u64> = None;
2197                 let mut payment_data: Option<FinalOnionHopData> = None;
2198                 let mut encrypted_tlvs_opt: Option<WithoutLength<Vec<u8>>> = None;
2199                 let mut intro_node_blinding_point = None;
2200                 let mut payment_metadata: Option<WithoutLength<Vec<u8>>> = None;
2201                 let mut total_msat = None;
2202                 let mut keysend_preimage: Option<PaymentPreimage> = None;
2203                 let mut custom_tlvs = Vec::new();
2204
2205                 let tlv_len = BigSize::read(r)?;
2206                 let rd = FixedLengthReader::new(r, tlv_len.0);
2207                 decode_tlv_stream_with_custom_tlv_decode!(rd, {
2208                         (2, amt, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2209                         (4, cltv_value, (option, encoding: (u32, HighZeroBytesDroppedBigSize))),
2210                         (6, short_id, option),
2211                         (8, payment_data, option),
2212                         (10, encrypted_tlvs_opt, option),
2213                         (12, intro_node_blinding_point, option),
2214                         (16, payment_metadata, option),
2215                         (18, total_msat, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2216                         // See https://github.com/lightning/blips/blob/master/blip-0003.md
2217                         (5482373484, keysend_preimage, option)
2218                 }, |msg_type: u64, msg_reader: &mut FixedLengthReader<_>| -> Result<bool, DecodeError> {
2219                         if msg_type < 1 << 16 { return Ok(false) }
2220                         let mut value = Vec::new();
2221                         msg_reader.read_to_end(&mut value)?;
2222                         custom_tlvs.push((msg_type, value));
2223                         Ok(true)
2224                 });
2225
2226                 if amt.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2227
2228                 if let Some(blinding_point) = intro_node_blinding_point {
2229                         if short_id.is_some() || payment_data.is_some() || payment_metadata.is_some() {
2230                                 return Err(DecodeError::InvalidValue)
2231                         }
2232                         let enc_tlvs = encrypted_tlvs_opt.ok_or(DecodeError::InvalidValue)?.0;
2233                         let enc_tlvs_ss = node_signer.ecdh(Recipient::Node, &blinding_point, None)
2234                                 .map_err(|_| DecodeError::InvalidValue)?;
2235                         let rho = onion_utils::gen_rho_from_shared_secret(&enc_tlvs_ss.secret_bytes());
2236                         let mut s = Cursor::new(&enc_tlvs);
2237                         let mut reader = FixedLengthReader::new(&mut s, enc_tlvs.len() as u64);
2238                         match ChaChaPolyReadAdapter::read(&mut reader, rho)? {
2239                                 ChaChaPolyReadAdapter { readable: ReceiveTlvs { payment_secret, payment_constraints }} => {
2240                                         if total_msat.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2241                                         Ok(Self::BlindedReceive {
2242                                                 amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2243                                                 total_msat: total_msat.ok_or(DecodeError::InvalidValue)?,
2244                                                 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2245                                                 payment_secret,
2246                                                 payment_constraints,
2247                                                 intro_node_blinding_point: blinding_point,
2248                                         })
2249                                 },
2250                         }
2251                 } else if let Some(short_channel_id) = short_id {
2252                         if payment_data.is_some() || payment_metadata.is_some() || encrypted_tlvs_opt.is_some() ||
2253                                 total_msat.is_some()
2254                         { return Err(DecodeError::InvalidValue) }
2255                         Ok(Self::Forward {
2256                                 short_channel_id,
2257                                 amt_to_forward: amt.ok_or(DecodeError::InvalidValue)?,
2258                                 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2259                         })
2260                 } else {
2261                         if encrypted_tlvs_opt.is_some() || total_msat.is_some() {
2262                                 return Err(DecodeError::InvalidValue)
2263                         }
2264                         if let Some(data) = &payment_data {
2265                                 if data.total_msat > MAX_VALUE_MSAT {
2266                                         return Err(DecodeError::InvalidValue);
2267                                 }
2268                         }
2269                         Ok(Self::Receive {
2270                                 payment_data,
2271                                 payment_metadata: payment_metadata.map(|w| w.0),
2272                                 keysend_preimage,
2273                                 amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2274                                 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2275                                 custom_tlvs,
2276                         })
2277                 }
2278         }
2279 }
2280
2281 impl Writeable for Ping {
2282         fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2283                 self.ponglen.write(w)?;
2284                 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2285                 Ok(())
2286         }
2287 }
2288
2289 impl Readable for Ping {
2290         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2291                 Ok(Ping {
2292                         ponglen: Readable::read(r)?,
2293                         byteslen: {
2294                                 let byteslen = Readable::read(r)?;
2295                                 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2296                                 byteslen
2297                         }
2298                 })
2299         }
2300 }
2301
2302 impl Writeable for Pong {
2303         fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2304                 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2305                 Ok(())
2306         }
2307 }
2308
2309 impl Readable for Pong {
2310         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2311                 Ok(Pong {
2312                         byteslen: {
2313                                 let byteslen = Readable::read(r)?;
2314                                 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2315                                 byteslen
2316                         }
2317                 })
2318         }
2319 }
2320
2321 impl Writeable for UnsignedChannelAnnouncement {
2322         fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2323                 self.features.write(w)?;
2324                 self.chain_hash.write(w)?;
2325                 self.short_channel_id.write(w)?;
2326                 self.node_id_1.write(w)?;
2327                 self.node_id_2.write(w)?;
2328                 self.bitcoin_key_1.write(w)?;
2329                 self.bitcoin_key_2.write(w)?;
2330                 w.write_all(&self.excess_data[..])?;
2331                 Ok(())
2332         }
2333 }
2334
2335 impl Readable for UnsignedChannelAnnouncement {
2336         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2337                 Ok(Self {
2338                         features: Readable::read(r)?,
2339                         chain_hash: Readable::read(r)?,
2340                         short_channel_id: Readable::read(r)?,
2341                         node_id_1: Readable::read(r)?,
2342                         node_id_2: Readable::read(r)?,
2343                         bitcoin_key_1: Readable::read(r)?,
2344                         bitcoin_key_2: Readable::read(r)?,
2345                         excess_data: read_to_end(r)?,
2346                 })
2347         }
2348 }
2349
2350 impl_writeable!(ChannelAnnouncement, {
2351         node_signature_1,
2352         node_signature_2,
2353         bitcoin_signature_1,
2354         bitcoin_signature_2,
2355         contents
2356 });
2357
2358 impl Writeable for UnsignedChannelUpdate {
2359         fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2360                 // `message_flags` used to indicate presence of `htlc_maximum_msat`, but was deprecated in the spec.
2361                 const MESSAGE_FLAGS: u8 = 1;
2362                 self.chain_hash.write(w)?;
2363                 self.short_channel_id.write(w)?;
2364                 self.timestamp.write(w)?;
2365                 let all_flags = self.flags as u16 | ((MESSAGE_FLAGS as u16) << 8);
2366                 all_flags.write(w)?;
2367                 self.cltv_expiry_delta.write(w)?;
2368                 self.htlc_minimum_msat.write(w)?;
2369                 self.fee_base_msat.write(w)?;
2370                 self.fee_proportional_millionths.write(w)?;
2371                 self.htlc_maximum_msat.write(w)?;
2372                 w.write_all(&self.excess_data[..])?;
2373                 Ok(())
2374         }
2375 }
2376
2377 impl Readable for UnsignedChannelUpdate {
2378         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2379                 Ok(Self {
2380                         chain_hash: Readable::read(r)?,
2381                         short_channel_id: Readable::read(r)?,
2382                         timestamp: Readable::read(r)?,
2383                         flags: {
2384                                 let flags: u16 = Readable::read(r)?;
2385                                 // Note: we ignore the `message_flags` for now, since it was deprecated by the spec.
2386                                 flags as u8
2387                         },
2388                         cltv_expiry_delta: Readable::read(r)?,
2389                         htlc_minimum_msat: Readable::read(r)?,
2390                         fee_base_msat: Readable::read(r)?,
2391                         fee_proportional_millionths: Readable::read(r)?,
2392                         htlc_maximum_msat: Readable::read(r)?,
2393                         excess_data: read_to_end(r)?,
2394                 })
2395         }
2396 }
2397
2398 impl_writeable!(ChannelUpdate, {
2399         signature,
2400         contents
2401 });
2402
2403 impl Writeable for ErrorMessage {
2404         fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2405                 self.channel_id.write(w)?;
2406                 (self.data.len() as u16).write(w)?;
2407                 w.write_all(self.data.as_bytes())?;
2408                 Ok(())
2409         }
2410 }
2411
2412 impl Readable for ErrorMessage {
2413         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2414                 Ok(Self {
2415                         channel_id: Readable::read(r)?,
2416                         data: {
2417                                 let sz: usize = <u16 as Readable>::read(r)? as usize;
2418                                 let mut data = Vec::with_capacity(sz);
2419                                 data.resize(sz, 0);
2420                                 r.read_exact(&mut data)?;
2421                                 match String::from_utf8(data) {
2422                                         Ok(s) => s,
2423                                         Err(_) => return Err(DecodeError::InvalidValue),
2424                                 }
2425                         }
2426                 })
2427         }
2428 }
2429
2430 impl Writeable for WarningMessage {
2431         fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2432                 self.channel_id.write(w)?;
2433                 (self.data.len() as u16).write(w)?;
2434                 w.write_all(self.data.as_bytes())?;
2435                 Ok(())
2436         }
2437 }
2438
2439 impl Readable for WarningMessage {
2440         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2441                 Ok(Self {
2442                         channel_id: Readable::read(r)?,
2443                         data: {
2444                                 let sz: usize = <u16 as Readable>::read(r)? as usize;
2445                                 let mut data = Vec::with_capacity(sz);
2446                                 data.resize(sz, 0);
2447                                 r.read_exact(&mut data)?;
2448                                 match String::from_utf8(data) {
2449                                         Ok(s) => s,
2450                                         Err(_) => return Err(DecodeError::InvalidValue),
2451                                 }
2452                         }
2453                 })
2454         }
2455 }
2456
2457 impl Writeable for UnsignedNodeAnnouncement {
2458         fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2459                 self.features.write(w)?;
2460                 self.timestamp.write(w)?;
2461                 self.node_id.write(w)?;
2462                 w.write_all(&self.rgb)?;
2463                 self.alias.write(w)?;
2464
2465                 let mut addr_len = 0;
2466                 for addr in self.addresses.iter() {
2467                         addr_len += 1 + addr.len();
2468                 }
2469                 (addr_len + self.excess_address_data.len() as u16).write(w)?;
2470                 for addr in self.addresses.iter() {
2471                         addr.write(w)?;
2472                 }
2473                 w.write_all(&self.excess_address_data[..])?;
2474                 w.write_all(&self.excess_data[..])?;
2475                 Ok(())
2476         }
2477 }
2478
2479 impl Readable for UnsignedNodeAnnouncement {
2480         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2481                 let features: NodeFeatures = Readable::read(r)?;
2482                 let timestamp: u32 = Readable::read(r)?;
2483                 let node_id: NodeId = Readable::read(r)?;
2484                 let mut rgb = [0; 3];
2485                 r.read_exact(&mut rgb)?;
2486                 let alias: NodeAlias = Readable::read(r)?;
2487
2488                 let addr_len: u16 = Readable::read(r)?;
2489                 let mut addresses: Vec<SocketAddress> = Vec::new();
2490                 let mut addr_readpos = 0;
2491                 let mut excess = false;
2492                 let mut excess_byte = 0;
2493                 loop {
2494                         if addr_len <= addr_readpos { break; }
2495                         match Readable::read(r) {
2496                                 Ok(Ok(addr)) => {
2497                                         if addr_len < addr_readpos + 1 + addr.len() {
2498                                                 return Err(DecodeError::BadLengthDescriptor);
2499                                         }
2500                                         addr_readpos += (1 + addr.len()) as u16;
2501                                         addresses.push(addr);
2502                                 },
2503                                 Ok(Err(unknown_descriptor)) => {
2504                                         excess = true;
2505                                         excess_byte = unknown_descriptor;
2506                                         break;
2507                                 },
2508                                 Err(DecodeError::ShortRead) => return Err(DecodeError::BadLengthDescriptor),
2509                                 Err(e) => return Err(e),
2510                         }
2511                 }
2512
2513                 let mut excess_data = vec![];
2514                 let excess_address_data = if addr_readpos < addr_len {
2515                         let mut excess_address_data = vec![0; (addr_len - addr_readpos) as usize];
2516                         r.read_exact(&mut excess_address_data[if excess { 1 } else { 0 }..])?;
2517                         if excess {
2518                                 excess_address_data[0] = excess_byte;
2519                         }
2520                         excess_address_data
2521                 } else {
2522                         if excess {
2523                                 excess_data.push(excess_byte);
2524                         }
2525                         Vec::new()
2526                 };
2527                 excess_data.extend(read_to_end(r)?.iter());
2528                 Ok(UnsignedNodeAnnouncement {
2529                         features,
2530                         timestamp,
2531                         node_id,
2532                         rgb,
2533                         alias,
2534                         addresses,
2535                         excess_address_data,
2536                         excess_data,
2537                 })
2538         }
2539 }
2540
2541 impl_writeable!(NodeAnnouncement, {
2542         signature,
2543         contents
2544 });
2545
2546 impl Readable for QueryShortChannelIds {
2547         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2548                 let chain_hash: ChainHash = Readable::read(r)?;
2549
2550                 let encoding_len: u16 = Readable::read(r)?;
2551                 let encoding_type: u8 = Readable::read(r)?;
2552
2553                 // Must be encoding_type=0 uncompressed serialization. We do not
2554                 // support encoding_type=1 zlib serialization.
2555                 if encoding_type != EncodingType::Uncompressed as u8 {
2556                         return Err(DecodeError::UnsupportedCompression);
2557                 }
2558
2559                 // We expect the encoding_len to always includes the 1-byte
2560                 // encoding_type and that short_channel_ids are 8-bytes each
2561                 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2562                         return Err(DecodeError::InvalidValue);
2563                 }
2564
2565                 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2566                 // less the 1-byte encoding_type
2567                 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2568                 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2569                 for _ in 0..short_channel_id_count {
2570                         short_channel_ids.push(Readable::read(r)?);
2571                 }
2572
2573                 Ok(QueryShortChannelIds {
2574                         chain_hash,
2575                         short_channel_ids,
2576                 })
2577         }
2578 }
2579
2580 impl Writeable for QueryShortChannelIds {
2581         fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2582                 // Calculated from 1-byte encoding_type plus 8-bytes per short_channel_id
2583                 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2584
2585                 self.chain_hash.write(w)?;
2586                 encoding_len.write(w)?;
2587
2588                 // We only support type=0 uncompressed serialization
2589                 (EncodingType::Uncompressed as u8).write(w)?;
2590
2591                 for scid in self.short_channel_ids.iter() {
2592                         scid.write(w)?;
2593                 }
2594
2595                 Ok(())
2596         }
2597 }
2598
2599 impl_writeable_msg!(ReplyShortChannelIdsEnd, {
2600         chain_hash,
2601         full_information,
2602 }, {});
2603
2604 impl QueryChannelRange {
2605         /// Calculates the overflow safe ending block height for the query.
2606         ///
2607         /// Overflow returns `0xffffffff`, otherwise returns `first_blocknum + number_of_blocks`.
2608         pub fn end_blocknum(&self) -> u32 {
2609                 match self.first_blocknum.checked_add(self.number_of_blocks) {
2610                         Some(block) => block,
2611                         None => u32::max_value(),
2612                 }
2613         }
2614 }
2615
2616 impl_writeable_msg!(QueryChannelRange, {
2617         chain_hash,
2618         first_blocknum,
2619         number_of_blocks
2620 }, {});
2621
2622 impl Readable for ReplyChannelRange {
2623         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2624                 let chain_hash: ChainHash = Readable::read(r)?;
2625                 let first_blocknum: u32 = Readable::read(r)?;
2626                 let number_of_blocks: u32 = Readable::read(r)?;
2627                 let sync_complete: bool = Readable::read(r)?;
2628
2629                 let encoding_len: u16 = Readable::read(r)?;
2630                 let encoding_type: u8 = Readable::read(r)?;
2631
2632                 // Must be encoding_type=0 uncompressed serialization. We do not
2633                 // support encoding_type=1 zlib serialization.
2634                 if encoding_type != EncodingType::Uncompressed as u8 {
2635                         return Err(DecodeError::UnsupportedCompression);
2636                 }
2637
2638                 // We expect the encoding_len to always includes the 1-byte
2639                 // encoding_type and that short_channel_ids are 8-bytes each
2640                 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2641                         return Err(DecodeError::InvalidValue);
2642                 }
2643
2644                 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2645                 // less the 1-byte encoding_type
2646                 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2647                 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2648                 for _ in 0..short_channel_id_count {
2649                         short_channel_ids.push(Readable::read(r)?);
2650                 }
2651
2652                 Ok(ReplyChannelRange {
2653                         chain_hash,
2654                         first_blocknum,
2655                         number_of_blocks,
2656                         sync_complete,
2657                         short_channel_ids
2658                 })
2659         }
2660 }
2661
2662 impl Writeable for ReplyChannelRange {
2663         fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2664                 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2665                 self.chain_hash.write(w)?;
2666                 self.first_blocknum.write(w)?;
2667                 self.number_of_blocks.write(w)?;
2668                 self.sync_complete.write(w)?;
2669
2670                 encoding_len.write(w)?;
2671                 (EncodingType::Uncompressed as u8).write(w)?;
2672                 for scid in self.short_channel_ids.iter() {
2673                         scid.write(w)?;
2674                 }
2675
2676                 Ok(())
2677         }
2678 }
2679
2680 impl_writeable_msg!(GossipTimestampFilter, {
2681         chain_hash,
2682         first_timestamp,
2683         timestamp_range,
2684 }, {});
2685
2686 #[cfg(test)]
2687 mod tests {
2688         use std::convert::TryFrom;
2689         use bitcoin::{Transaction, PackedLockTime, TxIn, Script, Sequence, Witness, TxOut};
2690         use hex;
2691         use crate::ln::{PaymentPreimage, PaymentHash, PaymentSecret};
2692         use crate::ln::ChannelId;
2693         use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
2694         use crate::ln::msgs::{self, FinalOnionHopData, OnionErrorPacket};
2695         use crate::ln::msgs::SocketAddress;
2696         use crate::routing::gossip::{NodeAlias, NodeId};
2697         use crate::util::ser::{Writeable, Readable, ReadableArgs, Hostname, TransactionU16LenLimited};
2698         use crate::util::test_utils;
2699
2700         use bitcoin::hashes::hex::FromHex;
2701         use bitcoin::util::address::Address;
2702         use bitcoin::network::constants::Network;
2703         use bitcoin::blockdata::constants::ChainHash;
2704         use bitcoin::blockdata::script::Builder;
2705         use bitcoin::blockdata::opcodes;
2706         use bitcoin::hash_types::Txid;
2707
2708         use bitcoin::secp256k1::{PublicKey,SecretKey};
2709         use bitcoin::secp256k1::{Secp256k1, Message};
2710
2711         use crate::io::{self, Cursor};
2712         use crate::prelude::*;
2713         use core::str::FromStr;
2714         use crate::chain::transaction::OutPoint;
2715
2716         #[cfg(feature = "std")]
2717         use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6, ToSocketAddrs};
2718         use crate::ln::msgs::SocketAddressParseError;
2719
2720         #[test]
2721         fn encoding_channel_reestablish() {
2722                 let public_key = {
2723                         let secp_ctx = Secp256k1::new();
2724                         PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2725                 };
2726
2727                 let cr = msgs::ChannelReestablish {
2728                         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]),
2729                         next_local_commitment_number: 3,
2730                         next_remote_commitment_number: 4,
2731                         your_last_per_commitment_secret: [9;32],
2732                         my_current_per_commitment_point: public_key,
2733                         next_funding_txid: None,
2734                 };
2735
2736                 let encoded_value = cr.encode();
2737                 assert_eq!(
2738                         encoded_value,
2739                         vec![
2740                                 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
2741                                 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2742                                 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2743                                 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
2744                                 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
2745                         ]
2746                 );
2747         }
2748
2749         #[test]
2750         fn encoding_channel_reestablish_with_next_funding_txid() {
2751                 let public_key = {
2752                         let secp_ctx = Secp256k1::new();
2753                         PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2754                 };
2755
2756                 let cr = msgs::ChannelReestablish {
2757                         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]),
2758                         next_local_commitment_number: 3,
2759                         next_remote_commitment_number: 4,
2760                         your_last_per_commitment_secret: [9;32],
2761                         my_current_per_commitment_point: public_key,
2762                         next_funding_txid: Some(Txid::from_hash(bitcoin::hashes::Hash::from_slice(&[
2763                                 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,
2764                         ]).unwrap())),
2765                 };
2766
2767                 let encoded_value = cr.encode();
2768                 assert_eq!(
2769                         encoded_value,
2770                         vec![
2771                                 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
2772                                 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2773                                 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2774                                 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
2775                                 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
2776                                 0, // Type (next_funding_txid)
2777                                 32, // Length
2778                                 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
2779                         ]
2780                 );
2781         }
2782
2783         macro_rules! get_keys_from {
2784                 ($slice: expr, $secp_ctx: expr) => {
2785                         {
2786                                 let privkey = SecretKey::from_slice(&hex::decode($slice).unwrap()[..]).unwrap();
2787                                 let pubkey = PublicKey::from_secret_key(&$secp_ctx, &privkey);
2788                                 (privkey, pubkey)
2789                         }
2790                 }
2791         }
2792
2793         macro_rules! get_sig_on {
2794                 ($privkey: expr, $ctx: expr, $string: expr) => {
2795                         {
2796                                 let sighash = Message::from_slice(&$string.into_bytes()[..]).unwrap();
2797                                 $ctx.sign_ecdsa(&sighash, &$privkey)
2798                         }
2799                 }
2800         }
2801
2802         #[test]
2803         fn encoding_announcement_signatures() {
2804                 let secp_ctx = Secp256k1::new();
2805                 let (privkey, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2806                 let sig_1 = get_sig_on!(privkey, secp_ctx, String::from("01010101010101010101010101010101"));
2807                 let sig_2 = get_sig_on!(privkey, secp_ctx, String::from("02020202020202020202020202020202"));
2808                 let announcement_signatures = msgs::AnnouncementSignatures {
2809                         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]),
2810                         short_channel_id: 2316138423780173,
2811                         node_signature: sig_1,
2812                         bitcoin_signature: sig_2,
2813                 };
2814
2815                 let encoded_value = announcement_signatures.encode();
2816                 assert_eq!(encoded_value, hex::decode("040000000000000005000000000000000600000000000000070000000000000000083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073acf9953cef4700860f5967838eba2bae89288ad188ebf8b20bf995c3ea53a26df1876d0a3a0e13172ba286a673140190c02ba9da60a2e43a745188c8a83c7f3ef").unwrap());
2817         }
2818
2819         fn do_encoding_channel_announcement(unknown_features_bits: bool, excess_data: bool) {
2820                 let secp_ctx = Secp256k1::new();
2821                 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2822                 let (privkey_2, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2823                 let (privkey_3, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2824                 let (privkey_4, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2825                 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2826                 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
2827                 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
2828                 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
2829                 let mut features = ChannelFeatures::empty();
2830                 if unknown_features_bits {
2831                         features = ChannelFeatures::from_le_bytes(vec![0xFF, 0xFF]);
2832                 }
2833                 let unsigned_channel_announcement = msgs::UnsignedChannelAnnouncement {
2834                         features,
2835                         chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
2836                         short_channel_id: 2316138423780173,
2837                         node_id_1: NodeId::from_pubkey(&pubkey_1),
2838                         node_id_2: NodeId::from_pubkey(&pubkey_2),
2839                         bitcoin_key_1: NodeId::from_pubkey(&pubkey_3),
2840                         bitcoin_key_2: NodeId::from_pubkey(&pubkey_4),
2841                         excess_data: if excess_data { vec![10, 0, 0, 20, 0, 0, 30, 0, 0, 40] } else { Vec::new() },
2842                 };
2843                 let channel_announcement = msgs::ChannelAnnouncement {
2844                         node_signature_1: sig_1,
2845                         node_signature_2: sig_2,
2846                         bitcoin_signature_1: sig_3,
2847                         bitcoin_signature_2: sig_4,
2848                         contents: unsigned_channel_announcement,
2849                 };
2850                 let encoded_value = channel_announcement.encode();
2851                 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a1735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap();
2852                 if unknown_features_bits {
2853                         target_value.append(&mut hex::decode("0002ffff").unwrap());
2854                 } else {
2855                         target_value.append(&mut hex::decode("0000").unwrap());
2856                 }
2857                 target_value.append(&mut hex::decode("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
2858                 target_value.append(&mut hex::decode("00083a840000034d031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
2859                 if excess_data {
2860                         target_value.append(&mut hex::decode("0a00001400001e000028").unwrap());
2861                 }
2862                 assert_eq!(encoded_value, target_value);
2863         }
2864
2865         #[test]
2866         fn encoding_channel_announcement() {
2867                 do_encoding_channel_announcement(true, false);
2868                 do_encoding_channel_announcement(false, true);
2869                 do_encoding_channel_announcement(false, false);
2870                 do_encoding_channel_announcement(true, true);
2871         }
2872
2873         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) {
2874                 let secp_ctx = Secp256k1::new();
2875                 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2876                 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2877                 let features = if unknown_features_bits {
2878                         NodeFeatures::from_le_bytes(vec![0xFF, 0xFF])
2879                 } else {
2880                         // Set to some features we may support
2881                         NodeFeatures::from_le_bytes(vec![2 | 1 << 5])
2882                 };
2883                 let mut addresses = Vec::new();
2884                 if ipv4 {
2885                         addresses.push(SocketAddress::TcpIpV4 {
2886                                 addr: [255, 254, 253, 252],
2887                                 port: 9735
2888                         });
2889                 }
2890                 if ipv6 {
2891                         addresses.push(SocketAddress::TcpIpV6 {
2892                                 addr: [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240],
2893                                 port: 9735
2894                         });
2895                 }
2896                 if onionv2 {
2897                         addresses.push(msgs::SocketAddress::OnionV2(
2898                                 [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 38, 7]
2899                         ));
2900                 }
2901                 if onionv3 {
2902                         addresses.push(msgs::SocketAddress::OnionV3 {
2903                                 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],
2904                                 checksum: 32,
2905                                 version: 16,
2906                                 port: 9735
2907                         });
2908                 }
2909                 if hostname {
2910                         addresses.push(SocketAddress::Hostname {
2911                                 hostname: Hostname::try_from(String::from("host")).unwrap(),
2912                                 port: 9735,
2913                         });
2914                 }
2915                 let mut addr_len = 0;
2916                 for addr in &addresses {
2917                         addr_len += addr.len() + 1;
2918                 }
2919                 let unsigned_node_announcement = msgs::UnsignedNodeAnnouncement {
2920                         features,
2921                         timestamp: 20190119,
2922                         node_id: NodeId::from_pubkey(&pubkey_1),
2923                         rgb: [32; 3],
2924                         alias: NodeAlias([16;32]),
2925                         addresses,
2926                         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() },
2927                         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() },
2928                 };
2929                 addr_len += unsigned_node_announcement.excess_address_data.len() as u16;
2930                 let node_announcement = msgs::NodeAnnouncement {
2931                         signature: sig_1,
2932                         contents: unsigned_node_announcement,
2933                 };
2934                 let encoded_value = node_announcement.encode();
2935                 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
2936                 if unknown_features_bits {
2937                         target_value.append(&mut hex::decode("0002ffff").unwrap());
2938                 } else {
2939                         target_value.append(&mut hex::decode("000122").unwrap());
2940                 }
2941                 target_value.append(&mut hex::decode("013413a7031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f2020201010101010101010101010101010101010101010101010101010101010101010").unwrap());
2942                 target_value.append(&mut vec![(addr_len >> 8) as u8, addr_len as u8]);
2943                 if ipv4 {
2944                         target_value.append(&mut hex::decode("01fffefdfc2607").unwrap());
2945                 }
2946                 if ipv6 {
2947                         target_value.append(&mut hex::decode("02fffefdfcfbfaf9f8f7f6f5f4f3f2f1f02607").unwrap());
2948                 }
2949                 if onionv2 {
2950                         target_value.append(&mut hex::decode("03fffefdfcfbfaf9f8f7f62607").unwrap());
2951                 }
2952                 if onionv3 {
2953                         target_value.append(&mut hex::decode("04fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0efeeedecebeae9e8e7e6e5e4e3e2e1e00020102607").unwrap());
2954                 }
2955                 if hostname {
2956                         target_value.append(&mut hex::decode("0504686f73742607").unwrap());
2957                 }
2958                 if excess_address_data {
2959                         target_value.append(&mut hex::decode("216c280b5395a2546e7e4b2663e04f811622f15a4f92e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d269").unwrap());
2960                 }
2961                 if excess_data {
2962                         target_value.append(&mut hex::decode("3b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
2963                 }
2964                 assert_eq!(encoded_value, target_value);
2965         }
2966
2967         #[test]
2968         fn encoding_node_announcement() {
2969                 do_encoding_node_announcement(true, true, true, true, true, true, true, true);
2970                 do_encoding_node_announcement(false, false, false, false, false, false, false, false);
2971                 do_encoding_node_announcement(false, true, false, false, false, false, false, false);
2972                 do_encoding_node_announcement(false, false, true, false, false, false, false, false);
2973                 do_encoding_node_announcement(false, false, false, true, false, false, false, false);
2974                 do_encoding_node_announcement(false, false, false, false, true, false, false, false);
2975                 do_encoding_node_announcement(false, false, false, false, false, true, false, false);
2976                 do_encoding_node_announcement(false, false, false, false, false, false, true, false);
2977                 do_encoding_node_announcement(false, true, false, true, false, false, true, false);
2978                 do_encoding_node_announcement(false, false, true, false, true, false, false, false);
2979         }
2980
2981         fn do_encoding_channel_update(direction: bool, disable: bool, excess_data: bool) {
2982                 let secp_ctx = Secp256k1::new();
2983                 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2984                 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2985                 let unsigned_channel_update = msgs::UnsignedChannelUpdate {
2986                         chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
2987                         short_channel_id: 2316138423780173,
2988                         timestamp: 20190119,
2989                         flags: if direction { 1 } else { 0 } | if disable { 1 << 1 } else { 0 },
2990                         cltv_expiry_delta: 144,
2991                         htlc_minimum_msat: 1000000,
2992                         htlc_maximum_msat: 131355275467161,
2993                         fee_base_msat: 10000,
2994                         fee_proportional_millionths: 20,
2995                         excess_data: if excess_data { vec![0, 0, 0, 0, 59, 154, 202, 0] } else { Vec::new() }
2996                 };
2997                 let channel_update = msgs::ChannelUpdate {
2998                         signature: sig_1,
2999                         contents: unsigned_channel_update
3000                 };
3001                 let encoded_value = channel_update.encode();
3002                 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3003                 target_value.append(&mut hex::decode("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3004                 target_value.append(&mut hex::decode("00083a840000034d013413a7").unwrap());
3005                 target_value.append(&mut hex::decode("01").unwrap());
3006                 target_value.append(&mut hex::decode("00").unwrap());
3007                 if direction {
3008                         let flag = target_value.last_mut().unwrap();
3009                         *flag = 1;
3010                 }
3011                 if disable {
3012                         let flag = target_value.last_mut().unwrap();
3013                         *flag = *flag | 1 << 1;
3014                 }
3015                 target_value.append(&mut hex::decode("009000000000000f42400000271000000014").unwrap());
3016                 target_value.append(&mut hex::decode("0000777788889999").unwrap());
3017                 if excess_data {
3018                         target_value.append(&mut hex::decode("000000003b9aca00").unwrap());
3019                 }
3020                 assert_eq!(encoded_value, target_value);
3021         }
3022
3023         #[test]
3024         fn encoding_channel_update() {
3025                 do_encoding_channel_update(false, false, false);
3026                 do_encoding_channel_update(false, false, true);
3027                 do_encoding_channel_update(true, false, false);
3028                 do_encoding_channel_update(true, false, true);
3029                 do_encoding_channel_update(false, true, false);
3030                 do_encoding_channel_update(false, true, true);
3031                 do_encoding_channel_update(true, true, false);
3032                 do_encoding_channel_update(true, true, true);
3033         }
3034
3035         fn do_encoding_open_channel(random_bit: bool, shutdown: bool, incl_chan_type: bool) {
3036                 let secp_ctx = Secp256k1::new();
3037                 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3038                 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3039                 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3040                 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3041                 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3042                 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3043                 let open_channel = msgs::OpenChannel {
3044                         chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3045                         temporary_channel_id: ChannelId::from_bytes([2; 32]),
3046                         funding_satoshis: 1311768467284833366,
3047                         push_msat: 2536655962884945560,
3048                         dust_limit_satoshis: 3608586615801332854,
3049                         max_htlc_value_in_flight_msat: 8517154655701053848,
3050                         channel_reserve_satoshis: 8665828695742877976,
3051                         htlc_minimum_msat: 2316138423780173,
3052                         feerate_per_kw: 821716,
3053                         to_self_delay: 49340,
3054                         max_accepted_htlcs: 49340,
3055                         funding_pubkey: pubkey_1,
3056                         revocation_basepoint: pubkey_2,
3057                         payment_point: pubkey_3,
3058                         delayed_payment_basepoint: pubkey_4,
3059                         htlc_basepoint: pubkey_5,
3060                         first_per_commitment_point: pubkey_6,
3061                         channel_flags: if random_bit { 1 << 5 } else { 0 },
3062                         shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3063                         channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3064                 };
3065                 let encoded_value = open_channel.encode();
3066                 let mut target_value = Vec::new();
3067                 target_value.append(&mut hex::decode("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3068                 target_value.append(&mut hex::decode("02020202020202020202020202020202020202020202020202020202020202021234567890123456233403289122369832144668701144767633030896203198784335490624111800083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3069                 if random_bit {
3070                         target_value.append(&mut hex::decode("20").unwrap());
3071                 } else {
3072                         target_value.append(&mut hex::decode("00").unwrap());
3073                 }
3074                 if shutdown {
3075                         target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3076                 }
3077                 if incl_chan_type {
3078                         target_value.append(&mut hex::decode("0100").unwrap());
3079                 }
3080                 assert_eq!(encoded_value, target_value);
3081         }
3082
3083         #[test]
3084         fn encoding_open_channel() {
3085                 do_encoding_open_channel(false, false, false);
3086                 do_encoding_open_channel(false, false, true);
3087                 do_encoding_open_channel(false, true, false);
3088                 do_encoding_open_channel(false, true, true);
3089                 do_encoding_open_channel(true, false, false);
3090                 do_encoding_open_channel(true, false, true);
3091                 do_encoding_open_channel(true, true, false);
3092                 do_encoding_open_channel(true, true, true);
3093         }
3094
3095         fn do_encoding_open_channelv2(random_bit: bool, shutdown: bool, incl_chan_type: bool, require_confirmed_inputs: bool) {
3096                 let secp_ctx = Secp256k1::new();
3097                 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3098                 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3099                 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3100                 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3101                 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3102                 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3103                 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3104                 let open_channelv2 = msgs::OpenChannelV2 {
3105                         chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3106                         temporary_channel_id: ChannelId::from_bytes([2; 32]),
3107                         funding_feerate_sat_per_1000_weight: 821716,
3108                         commitment_feerate_sat_per_1000_weight: 821716,
3109                         funding_satoshis: 1311768467284833366,
3110                         dust_limit_satoshis: 3608586615801332854,
3111                         max_htlc_value_in_flight_msat: 8517154655701053848,
3112                         htlc_minimum_msat: 2316138423780173,
3113                         to_self_delay: 49340,
3114                         max_accepted_htlcs: 49340,
3115                         locktime: 305419896,
3116                         funding_pubkey: pubkey_1,
3117                         revocation_basepoint: pubkey_2,
3118                         payment_basepoint: pubkey_3,
3119                         delayed_payment_basepoint: pubkey_4,
3120                         htlc_basepoint: pubkey_5,
3121                         first_per_commitment_point: pubkey_6,
3122                         second_per_commitment_point: pubkey_7,
3123                         channel_flags: if random_bit { 1 << 5 } else { 0 },
3124                         shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3125                         channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3126                         require_confirmed_inputs: if require_confirmed_inputs { Some(()) } else { None },
3127                 };
3128                 let encoded_value = open_channelv2.encode();
3129                 let mut target_value = Vec::new();
3130                 target_value.append(&mut hex::decode("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3131                 target_value.append(&mut hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap());
3132                 target_value.append(&mut hex::decode("000c89d4").unwrap());
3133                 target_value.append(&mut hex::decode("000c89d4").unwrap());
3134                 target_value.append(&mut hex::decode("1234567890123456").unwrap());
3135                 target_value.append(&mut hex::decode("3214466870114476").unwrap());
3136                 target_value.append(&mut hex::decode("7633030896203198").unwrap());
3137                 target_value.append(&mut hex::decode("00083a840000034d").unwrap());
3138                 target_value.append(&mut hex::decode("c0bc").unwrap());
3139                 target_value.append(&mut hex::decode("c0bc").unwrap());
3140                 target_value.append(&mut hex::decode("12345678").unwrap());
3141                 target_value.append(&mut hex::decode("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap());
3142                 target_value.append(&mut hex::decode("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap());
3143                 target_value.append(&mut hex::decode("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap());
3144                 target_value.append(&mut hex::decode("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
3145                 target_value.append(&mut hex::decode("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap());
3146                 target_value.append(&mut hex::decode("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3147                 target_value.append(&mut hex::decode("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap());
3148
3149                 if random_bit {
3150                         target_value.append(&mut hex::decode("20").unwrap());
3151                 } else {
3152                         target_value.append(&mut hex::decode("00").unwrap());
3153                 }
3154                 if shutdown {
3155                         target_value.append(&mut hex::decode("001b").unwrap()); // Type 0 + Length 27
3156                         target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3157                 }
3158                 if incl_chan_type {
3159                         target_value.append(&mut hex::decode("0100").unwrap());
3160                 }
3161                 if require_confirmed_inputs {
3162                         target_value.append(&mut hex::decode("0200").unwrap());
3163                 }
3164                 assert_eq!(encoded_value, target_value);
3165         }
3166
3167         #[test]
3168         fn encoding_open_channelv2() {
3169                 do_encoding_open_channelv2(false, false, false, false);
3170                 do_encoding_open_channelv2(false, false, false, true);
3171                 do_encoding_open_channelv2(false, false, true, false);
3172                 do_encoding_open_channelv2(false, false, true, true);
3173                 do_encoding_open_channelv2(false, true, false, false);
3174                 do_encoding_open_channelv2(false, true, false, true);
3175                 do_encoding_open_channelv2(false, true, true, false);
3176                 do_encoding_open_channelv2(false, true, true, true);
3177                 do_encoding_open_channelv2(true, false, false, false);
3178                 do_encoding_open_channelv2(true, false, false, true);
3179                 do_encoding_open_channelv2(true, false, true, false);
3180                 do_encoding_open_channelv2(true, false, true, true);
3181                 do_encoding_open_channelv2(true, true, false, false);
3182                 do_encoding_open_channelv2(true, true, false, true);
3183                 do_encoding_open_channelv2(true, true, true, false);
3184                 do_encoding_open_channelv2(true, true, true, true);
3185         }
3186
3187         fn do_encoding_accept_channel(shutdown: bool) {
3188                 let secp_ctx = Secp256k1::new();
3189                 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3190                 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3191                 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3192                 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3193                 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3194                 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3195                 let accept_channel = msgs::AcceptChannel {
3196                         temporary_channel_id: ChannelId::from_bytes([2; 32]),
3197                         dust_limit_satoshis: 1311768467284833366,
3198                         max_htlc_value_in_flight_msat: 2536655962884945560,
3199                         channel_reserve_satoshis: 3608586615801332854,
3200                         htlc_minimum_msat: 2316138423780173,
3201                         minimum_depth: 821716,
3202                         to_self_delay: 49340,
3203                         max_accepted_htlcs: 49340,
3204                         funding_pubkey: pubkey_1,
3205                         revocation_basepoint: pubkey_2,
3206                         payment_point: pubkey_3,
3207                         delayed_payment_basepoint: pubkey_4,
3208                         htlc_basepoint: pubkey_5,
3209                         first_per_commitment_point: pubkey_6,
3210                         shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3211                         channel_type: None,
3212                         #[cfg(taproot)]
3213                         next_local_nonce: None,
3214                 };
3215                 let encoded_value = accept_channel.encode();
3216                 let mut target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020212345678901234562334032891223698321446687011447600083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap();
3217                 if shutdown {
3218                         target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3219                 }
3220                 assert_eq!(encoded_value, target_value);
3221         }
3222
3223         #[test]
3224         fn encoding_accept_channel() {
3225                 do_encoding_accept_channel(false);
3226                 do_encoding_accept_channel(true);
3227         }
3228
3229         fn do_encoding_accept_channelv2(shutdown: bool) {
3230                 let secp_ctx = Secp256k1::new();
3231                 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3232                 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3233                 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3234                 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3235                 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3236                 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3237                 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3238                 let accept_channelv2 = msgs::AcceptChannelV2 {
3239                         temporary_channel_id: ChannelId::from_bytes([2; 32]),
3240                         funding_satoshis: 1311768467284833366,
3241                         dust_limit_satoshis: 1311768467284833366,
3242                         max_htlc_value_in_flight_msat: 2536655962884945560,
3243                         htlc_minimum_msat: 2316138423780173,
3244                         minimum_depth: 821716,
3245                         to_self_delay: 49340,
3246                         max_accepted_htlcs: 49340,
3247                         funding_pubkey: pubkey_1,
3248                         revocation_basepoint: pubkey_2,
3249                         payment_basepoint: pubkey_3,
3250                         delayed_payment_basepoint: pubkey_4,
3251                         htlc_basepoint: pubkey_5,
3252                         first_per_commitment_point: pubkey_6,
3253                         second_per_commitment_point: pubkey_7,
3254                         shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3255                         channel_type: None,
3256                         require_confirmed_inputs: None,
3257                 };
3258                 let encoded_value = accept_channelv2.encode();
3259                 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // temporary_channel_id
3260                 target_value.append(&mut hex::decode("1234567890123456").unwrap()); // funding_satoshis
3261                 target_value.append(&mut hex::decode("1234567890123456").unwrap()); // dust_limit_satoshis
3262                 target_value.append(&mut hex::decode("2334032891223698").unwrap()); // max_htlc_value_in_flight_msat
3263                 target_value.append(&mut hex::decode("00083a840000034d").unwrap()); // htlc_minimum_msat
3264                 target_value.append(&mut hex::decode("000c89d4").unwrap()); //  minimum_depth
3265                 target_value.append(&mut hex::decode("c0bc").unwrap()); // to_self_delay
3266                 target_value.append(&mut hex::decode("c0bc").unwrap()); // max_accepted_htlcs
3267                 target_value.append(&mut hex::decode("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap()); // funding_pubkey
3268                 target_value.append(&mut hex::decode("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap()); // revocation_basepoint
3269                 target_value.append(&mut hex::decode("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap()); // payment_basepoint
3270                 target_value.append(&mut hex::decode("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap()); // delayed_payment_basepoint
3271                 target_value.append(&mut hex::decode("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap()); // htlc_basepoint
3272                 target_value.append(&mut hex::decode("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap()); // first_per_commitment_point
3273                 target_value.append(&mut hex::decode("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap()); // second_per_commitment_point
3274                 if shutdown {
3275                         target_value.append(&mut hex::decode("001b").unwrap()); // Type 0 + Length 27
3276                         target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3277                 }
3278                 assert_eq!(encoded_value, target_value);
3279         }
3280
3281         #[test]
3282         fn encoding_accept_channelv2() {
3283                 do_encoding_accept_channelv2(false);
3284                 do_encoding_accept_channelv2(true);
3285         }
3286
3287         #[test]
3288         fn encoding_funding_created() {
3289                 let secp_ctx = Secp256k1::new();
3290                 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3291                 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3292                 let funding_created = msgs::FundingCreated {
3293                         temporary_channel_id: ChannelId::from_bytes([2; 32]),
3294                         funding_txid: Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3295                         funding_output_index: 255,
3296                         signature: sig_1,
3297                         #[cfg(taproot)]
3298                         partial_signature_with_nonce: None,
3299                         #[cfg(taproot)]
3300                         next_local_nonce: None,
3301                 };
3302                 let encoded_value = funding_created.encode();
3303                 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202026e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c200ffd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3304                 assert_eq!(encoded_value, target_value);
3305         }
3306
3307         #[test]
3308         fn encoding_funding_signed() {
3309                 let secp_ctx = Secp256k1::new();
3310                 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3311                 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3312                 let funding_signed = msgs::FundingSigned {
3313                         channel_id: ChannelId::from_bytes([2; 32]),
3314                         signature: sig_1,
3315                         #[cfg(taproot)]
3316                         partial_signature_with_nonce: None,
3317                 };
3318                 let encoded_value = funding_signed.encode();
3319                 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3320                 assert_eq!(encoded_value, target_value);
3321         }
3322
3323         #[test]
3324         fn encoding_channel_ready() {
3325                 let secp_ctx = Secp256k1::new();
3326                 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3327                 let channel_ready = msgs::ChannelReady {
3328                         channel_id: ChannelId::from_bytes([2; 32]),
3329                         next_per_commitment_point: pubkey_1,
3330                         short_channel_id_alias: None,
3331                 };
3332                 let encoded_value = channel_ready.encode();
3333                 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3334                 assert_eq!(encoded_value, target_value);
3335         }
3336
3337         #[test]
3338         fn encoding_tx_add_input() {
3339                 let tx_add_input = msgs::TxAddInput {
3340                         channel_id: ChannelId::from_bytes([2; 32]),
3341                         serial_id: 4886718345,
3342                         prevtx: TransactionU16LenLimited::new(Transaction {
3343                                 version: 2,
3344                                 lock_time: PackedLockTime(0),
3345                                 input: vec![TxIn {
3346                                         previous_output: OutPoint { txid: Txid::from_hex("305bab643ee297b8b6b76b320792c8223d55082122cb606bf89382146ced9c77").unwrap(), index: 2 }.into_bitcoin_outpoint(),
3347                                         script_sig: Script::new(),
3348                                         sequence: Sequence(0xfffffffd),
3349                                         witness: Witness::from_vec(vec![
3350                                                 hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3351                                                 hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3352                                 }],
3353                                 output: vec![
3354                                         TxOut {
3355                                                 value: 12704566,
3356                                                 script_pubkey: Address::from_str("bc1qzlffunw52jav8vwdu5x3jfk6sr8u22rmq3xzw2").unwrap().script_pubkey(),
3357                                         },
3358                                         TxOut {
3359                                                 value: 245148,
3360                                                 script_pubkey: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().script_pubkey(),
3361                                         },
3362                                 ],
3363                         }).unwrap(),
3364                         prevtx_out: 305419896,
3365                         sequence: 305419896,
3366                 };
3367                 let encoded_value = tx_add_input.encode();
3368                 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000000012345678900de02000000000101779ced6c148293f86b60cb222108553d22c89207326bb7b6b897e23e64ab5b300200000000fdffffff0236dbc1000000000016001417d29e4dd454bac3b1cde50d1926da80cfc5287b9cbd03000000000016001436ec78d514df462da95e6a00c24daa8915362d420247304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701210301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944000000001234567812345678").unwrap();
3369                 assert_eq!(encoded_value, target_value);
3370         }
3371
3372         #[test]
3373         fn encoding_tx_add_output() {
3374                 let tx_add_output = msgs::TxAddOutput {
3375                         channel_id: ChannelId::from_bytes([2; 32]),
3376                         serial_id: 4886718345,
3377                         sats: 4886718345,
3378                         script: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().script_pubkey(),
3379                 };
3380                 let encoded_value = tx_add_output.encode();
3381                 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000000012345678900000001234567890016001436ec78d514df462da95e6a00c24daa8915362d42").unwrap();
3382                 assert_eq!(encoded_value, target_value);
3383         }
3384
3385         #[test]
3386         fn encoding_tx_remove_input() {
3387                 let tx_remove_input = msgs::TxRemoveInput {
3388                         channel_id: ChannelId::from_bytes([2; 32]),
3389                         serial_id: 4886718345,
3390                 };
3391                 let encoded_value = tx_remove_input.encode();
3392                 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3393                 assert_eq!(encoded_value, target_value);
3394         }
3395
3396         #[test]
3397         fn encoding_tx_remove_output() {
3398                 let tx_remove_output = msgs::TxRemoveOutput {
3399                         channel_id: ChannelId::from_bytes([2; 32]),
3400                         serial_id: 4886718345,
3401                 };
3402                 let encoded_value = tx_remove_output.encode();
3403                 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3404                 assert_eq!(encoded_value, target_value);
3405         }
3406
3407         #[test]
3408         fn encoding_tx_complete() {
3409                 let tx_complete = msgs::TxComplete {
3410                         channel_id: ChannelId::from_bytes([2; 32]),
3411                 };
3412                 let encoded_value = tx_complete.encode();
3413                 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3414                 assert_eq!(encoded_value, target_value);
3415         }
3416
3417         #[test]
3418         fn encoding_tx_signatures() {
3419                 let tx_signatures = msgs::TxSignatures {
3420                         channel_id: ChannelId::from_bytes([2; 32]),
3421                         tx_hash: Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3422                         witnesses: vec![
3423                                 Witness::from_vec(vec![
3424                                         hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3425                                         hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3426                                 Witness::from_vec(vec![
3427                                         hex::decode("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap(),
3428                                         hex::decode("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap()]),
3429                         ],
3430                 };
3431                 let encoded_value = tx_signatures.encode();
3432                 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3433                 target_value.append(&mut hex::decode("6e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c2").unwrap()); // tx_hash (sha256) (big endian byte order)
3434                 target_value.append(&mut hex::decode("0002").unwrap()); // num_witnesses (u16)
3435                 // Witness 1
3436                 target_value.append(&mut hex::decode("006b").unwrap()); // len of witness_data
3437                 target_value.append(&mut hex::decode("02").unwrap()); // num_witness_elements (VarInt)
3438                 target_value.append(&mut hex::decode("47").unwrap()); // len of witness element data (VarInt)
3439                 target_value.append(&mut hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap());
3440                 target_value.append(&mut hex::decode("21").unwrap()); // len of witness element data (VarInt)
3441                 target_value.append(&mut hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap());
3442                 // Witness 2
3443                 target_value.append(&mut hex::decode("006c").unwrap()); // len of witness_data
3444                 target_value.append(&mut hex::decode("02").unwrap()); // num_witness_elements (VarInt)
3445                 target_value.append(&mut hex::decode("48").unwrap()); // len of witness element data (VarInt)
3446                 target_value.append(&mut hex::decode("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap());
3447                 target_value.append(&mut hex::decode("21").unwrap()); // len of witness element data (VarInt)
3448                 target_value.append(&mut hex::decode("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap());
3449                 assert_eq!(encoded_value, target_value);
3450         }
3451
3452         fn do_encoding_tx_init_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3453                 let tx_init_rbf = msgs::TxInitRbf {
3454                         channel_id: ChannelId::from_bytes([2; 32]),
3455                         locktime: 305419896,
3456                         feerate_sat_per_1000_weight: 20190119,
3457                         funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3458                 };
3459                 let encoded_value = tx_init_rbf.encode();
3460                 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3461                 target_value.append(&mut hex::decode("12345678").unwrap()); // locktime
3462                 target_value.append(&mut hex::decode("013413a7").unwrap()); // feerate_sat_per_1000_weight
3463                 if let Some((_, target)) = funding_value_with_hex_target {
3464                         target_value.push(0x00); // Type
3465                         target_value.push(target.len() as u8 / 2); // Length
3466                         target_value.append(&mut hex::decode(target).unwrap()); // Value (i64)
3467                 }
3468                 assert_eq!(encoded_value, target_value);
3469         }
3470
3471         #[test]
3472         fn encoding_tx_init_rbf() {
3473                 do_encoding_tx_init_rbf(Some((1311768467284833366, "1234567890123456")));
3474                 do_encoding_tx_init_rbf(Some((13117684672, "000000030DDFFBC0")));
3475                 do_encoding_tx_init_rbf(None);
3476         }
3477
3478         fn do_encoding_tx_ack_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3479                 let tx_ack_rbf = msgs::TxAckRbf {
3480                         channel_id: ChannelId::from_bytes([2; 32]),
3481                         funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3482                 };
3483                 let encoded_value = tx_ack_rbf.encode();
3484                 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3485                 if let Some((_, target)) = funding_value_with_hex_target {
3486                         target_value.push(0x00); // Type
3487                         target_value.push(target.len() as u8 / 2); // Length
3488                         target_value.append(&mut hex::decode(target).unwrap()); // Value (i64)
3489                 }
3490                 assert_eq!(encoded_value, target_value);
3491         }
3492
3493         #[test]
3494         fn encoding_tx_ack_rbf() {
3495                 do_encoding_tx_ack_rbf(Some((1311768467284833366, "1234567890123456")));
3496                 do_encoding_tx_ack_rbf(Some((13117684672, "000000030DDFFBC0")));
3497                 do_encoding_tx_ack_rbf(None);
3498         }
3499
3500         #[test]
3501         fn encoding_tx_abort() {
3502                 let tx_abort = msgs::TxAbort {
3503                         channel_id: ChannelId::from_bytes([2; 32]),
3504                         data: hex::decode("54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap(),
3505                 };
3506                 let encoded_value = tx_abort.encode();
3507                 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202002C54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap();
3508                 assert_eq!(encoded_value, target_value);
3509         }
3510
3511         fn do_encoding_shutdown(script_type: u8) {
3512                 let secp_ctx = Secp256k1::new();
3513                 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3514                 let script = Builder::new().push_opcode(opcodes::OP_TRUE).into_script();
3515                 let shutdown = msgs::Shutdown {
3516                         channel_id: ChannelId::from_bytes([2; 32]),
3517                         scriptpubkey:
3518                                 if script_type == 1 { Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey() }
3519                                 else if script_type == 2 { Address::p2sh(&script, Network::Testnet).unwrap().script_pubkey() }
3520                                 else if script_type == 3 { Address::p2wpkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).unwrap().script_pubkey() }
3521                                 else { Address::p2wsh(&script, Network::Testnet).script_pubkey() },
3522                 };
3523                 let encoded_value = shutdown.encode();
3524                 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3525                 if script_type == 1 {
3526                         target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3527                 } else if script_type == 2 {
3528                         target_value.append(&mut hex::decode("0017a914da1745e9b549bd0bfa1a569971c77eba30cd5a4b87").unwrap());
3529                 } else if script_type == 3 {
3530                         target_value.append(&mut hex::decode("0016001479b000887626b294a914501a4cd226b58b235983").unwrap());
3531                 } else if script_type == 4 {
3532                         target_value.append(&mut hex::decode("002200204ae81572f06e1b88fd5ced7a1a000945432e83e1551e6f721ee9c00b8cc33260").unwrap());
3533                 }
3534                 assert_eq!(encoded_value, target_value);
3535         }
3536
3537         #[test]
3538         fn encoding_shutdown() {
3539                 do_encoding_shutdown(1);
3540                 do_encoding_shutdown(2);
3541                 do_encoding_shutdown(3);
3542                 do_encoding_shutdown(4);
3543         }
3544
3545         #[test]
3546         fn encoding_closing_signed() {
3547                 let secp_ctx = Secp256k1::new();
3548                 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3549                 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3550                 let closing_signed = msgs::ClosingSigned {
3551                         channel_id: ChannelId::from_bytes([2; 32]),
3552                         fee_satoshis: 2316138423780173,
3553                         signature: sig_1,
3554                         fee_range: None,
3555                 };
3556                 let encoded_value = closing_signed.encode();
3557                 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3558                 assert_eq!(encoded_value, target_value);
3559                 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value)).unwrap(), closing_signed);
3560
3561                 let closing_signed_with_range = msgs::ClosingSigned {
3562                         channel_id: ChannelId::from_bytes([2; 32]),
3563                         fee_satoshis: 2316138423780173,
3564                         signature: sig_1,
3565                         fee_range: Some(msgs::ClosingSignedFeeRange {
3566                                 min_fee_satoshis: 0xdeadbeef,
3567                                 max_fee_satoshis: 0x1badcafe01234567,
3568                         }),
3569                 };
3570                 let encoded_value_with_range = closing_signed_with_range.encode();
3571                 let target_value_with_range = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a011000000000deadbeef1badcafe01234567").unwrap();
3572                 assert_eq!(encoded_value_with_range, target_value_with_range);
3573                 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value_with_range)).unwrap(),
3574                         closing_signed_with_range);
3575         }
3576
3577         #[test]
3578         fn encoding_update_add_htlc() {
3579                 let secp_ctx = Secp256k1::new();
3580                 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3581                 let onion_routing_packet = msgs::OnionPacket {
3582                         version: 255,
3583                         public_key: Ok(pubkey_1),
3584                         hop_data: [1; 20*65],
3585                         hmac: [2; 32]
3586                 };
3587                 let update_add_htlc = msgs::UpdateAddHTLC {
3588                         channel_id: ChannelId::from_bytes([2; 32]),
3589                         htlc_id: 2316138423780173,
3590                         amount_msat: 3608586615801332854,
3591                         payment_hash: PaymentHash([1; 32]),
3592                         cltv_expiry: 821716,
3593                         onion_routing_packet,
3594                         skimmed_fee_msat: None,
3595                 };
3596                 let encoded_value = update_add_htlc.encode();
3597                 let target_value = hex::decode("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").unwrap();
3598                 assert_eq!(encoded_value, target_value);
3599         }
3600
3601         #[test]
3602         fn encoding_update_fulfill_htlc() {
3603                 let update_fulfill_htlc = msgs::UpdateFulfillHTLC {
3604                         channel_id: ChannelId::from_bytes([2; 32]),
3605                         htlc_id: 2316138423780173,
3606                         payment_preimage: PaymentPreimage([1; 32]),
3607                 };
3608                 let encoded_value = update_fulfill_htlc.encode();
3609                 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d0101010101010101010101010101010101010101010101010101010101010101").unwrap();
3610                 assert_eq!(encoded_value, target_value);
3611         }
3612
3613         #[test]
3614         fn encoding_update_fail_htlc() {
3615                 let reason = OnionErrorPacket {
3616                         data: [1; 32].to_vec(),
3617                 };
3618                 let update_fail_htlc = msgs::UpdateFailHTLC {
3619                         channel_id: ChannelId::from_bytes([2; 32]),
3620                         htlc_id: 2316138423780173,
3621                         reason
3622                 };
3623                 let encoded_value = update_fail_htlc.encode();
3624                 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d00200101010101010101010101010101010101010101010101010101010101010101").unwrap();
3625                 assert_eq!(encoded_value, target_value);
3626         }
3627
3628         #[test]
3629         fn encoding_update_fail_malformed_htlc() {
3630                 let update_fail_malformed_htlc = msgs::UpdateFailMalformedHTLC {
3631                         channel_id: ChannelId::from_bytes([2; 32]),
3632                         htlc_id: 2316138423780173,
3633                         sha256_of_onion: [1; 32],
3634                         failure_code: 255
3635                 };
3636                 let encoded_value = update_fail_malformed_htlc.encode();
3637                 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d010101010101010101010101010101010101010101010101010101010101010100ff").unwrap();
3638                 assert_eq!(encoded_value, target_value);
3639         }
3640
3641         fn do_encoding_commitment_signed(htlcs: bool) {
3642                 let secp_ctx = Secp256k1::new();
3643                 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3644                 let (privkey_2, _) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3645                 let (privkey_3, _) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3646                 let (privkey_4, _) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3647                 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3648                 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
3649                 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
3650                 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
3651                 let commitment_signed = msgs::CommitmentSigned {
3652                         channel_id: ChannelId::from_bytes([2; 32]),
3653                         signature: sig_1,
3654                         htlc_signatures: if htlcs { vec![sig_2, sig_3, sig_4] } else { Vec::new() },
3655                         #[cfg(taproot)]
3656                         partial_signature_with_nonce: None,
3657                 };
3658                 let encoded_value = commitment_signed.encode();
3659                 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3660                 if htlcs {
3661                         target_value.append(&mut hex::decode("00031735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
3662                 } else {
3663                         target_value.append(&mut hex::decode("0000").unwrap());
3664                 }
3665                 assert_eq!(encoded_value, target_value);
3666         }
3667
3668         #[test]
3669         fn encoding_commitment_signed() {
3670                 do_encoding_commitment_signed(true);
3671                 do_encoding_commitment_signed(false);
3672         }
3673
3674         #[test]
3675         fn encoding_revoke_and_ack() {
3676                 let secp_ctx = Secp256k1::new();
3677                 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3678                 let raa = msgs::RevokeAndACK {
3679                         channel_id: ChannelId::from_bytes([2; 32]),
3680                         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],
3681                         next_per_commitment_point: pubkey_1,
3682                         #[cfg(taproot)]
3683                         next_local_nonce: None,
3684                 };
3685                 let encoded_value = raa.encode();
3686                 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020101010101010101010101010101010101010101010101010101010101010101031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3687                 assert_eq!(encoded_value, target_value);
3688         }
3689
3690         #[test]
3691         fn encoding_update_fee() {
3692                 let update_fee = msgs::UpdateFee {
3693                         channel_id: ChannelId::from_bytes([2; 32]),
3694                         feerate_per_kw: 20190119,
3695                 };
3696                 let encoded_value = update_fee.encode();
3697                 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202013413a7").unwrap();
3698                 assert_eq!(encoded_value, target_value);
3699         }
3700
3701         #[test]
3702         fn encoding_init() {
3703                 let mainnet_hash = ChainHash::using_genesis_block(Network::Bitcoin);
3704                 assert_eq!(msgs::Init {
3705                         features: InitFeatures::from_le_bytes(vec![0xFF, 0xFF, 0xFF]),
3706                         networks: Some(vec![mainnet_hash]),
3707                         remote_network_address: None,
3708                 }.encode(), hex::decode("00023fff0003ffffff01206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3709                 assert_eq!(msgs::Init {
3710                         features: InitFeatures::from_le_bytes(vec![0xFF]),
3711                         networks: None,
3712                         remote_network_address: None,
3713                 }.encode(), hex::decode("0001ff0001ff").unwrap());
3714                 assert_eq!(msgs::Init {
3715                         features: InitFeatures::from_le_bytes(vec![]),
3716                         networks: Some(vec![mainnet_hash]),
3717                         remote_network_address: None,
3718                 }.encode(), hex::decode("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3719                 assert_eq!(msgs::Init {
3720                         features: InitFeatures::from_le_bytes(vec![]),
3721                         networks: Some(vec![ChainHash::from(&[1; 32][..]), ChainHash::from(&[2; 32][..])]),
3722                         remote_network_address: None,
3723                 }.encode(), hex::decode("00000000014001010101010101010101010101010101010101010101010101010101010101010202020202020202020202020202020202020202020202020202020202020202").unwrap());
3724                 let init_msg = msgs::Init { features: InitFeatures::from_le_bytes(vec![]),
3725                         networks: Some(vec![mainnet_hash]),
3726                         remote_network_address: Some(SocketAddress::TcpIpV4 {
3727                                 addr: [127, 0, 0, 1],
3728                                 port: 1000,
3729                         }),
3730                 };
3731                 let encoded_value = init_msg.encode();
3732                 let target_value = hex::decode("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d61900000000000307017f00000103e8").unwrap();
3733                 assert_eq!(encoded_value, target_value);
3734                 assert_eq!(msgs::Init::read(&mut Cursor::new(&target_value)).unwrap(), init_msg);
3735         }
3736
3737         #[test]
3738         fn encoding_error() {
3739                 let error = msgs::ErrorMessage {
3740                         channel_id: ChannelId::from_bytes([2; 32]),
3741                         data: String::from("rust-lightning"),
3742                 };
3743                 let encoded_value = error.encode();
3744                 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3745                 assert_eq!(encoded_value, target_value);
3746         }
3747
3748         #[test]
3749         fn encoding_warning() {
3750                 let error = msgs::WarningMessage {
3751                         channel_id: ChannelId::from_bytes([2; 32]),
3752                         data: String::from("rust-lightning"),
3753                 };
3754                 let encoded_value = error.encode();
3755                 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3756                 assert_eq!(encoded_value, target_value);
3757         }
3758
3759         #[test]
3760         fn encoding_ping() {
3761                 let ping = msgs::Ping {
3762                         ponglen: 64,
3763                         byteslen: 64
3764                 };
3765                 let encoded_value = ping.encode();
3766                 let target_value = hex::decode("0040004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3767                 assert_eq!(encoded_value, target_value);
3768         }
3769
3770         #[test]
3771         fn encoding_pong() {
3772                 let pong = msgs::Pong {
3773                         byteslen: 64
3774                 };
3775                 let encoded_value = pong.encode();
3776                 let target_value = hex::decode("004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3777                 assert_eq!(encoded_value, target_value);
3778         }
3779
3780         #[test]
3781         fn encoding_nonfinal_onion_hop_data() {
3782                 let outbound_msg = msgs::OutboundOnionPayload::Forward {
3783                         short_channel_id: 0xdeadbeef1bad1dea,
3784                         amt_to_forward: 0x0badf00d01020304,
3785                         outgoing_cltv_value: 0xffffffff,
3786                 };
3787                 let encoded_value = outbound_msg.encode();
3788                 let target_value = hex::decode("1a02080badf00d010203040404ffffffff0608deadbeef1bad1dea").unwrap();
3789                 assert_eq!(encoded_value, target_value);
3790
3791                 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3792                 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
3793                 if let msgs::InboundOnionPayload::Forward {
3794                         short_channel_id, amt_to_forward, outgoing_cltv_value
3795                 } = inbound_msg {
3796                         assert_eq!(short_channel_id, 0xdeadbeef1bad1dea);
3797                         assert_eq!(amt_to_forward, 0x0badf00d01020304);
3798                         assert_eq!(outgoing_cltv_value, 0xffffffff);
3799                 } else { panic!(); }
3800         }
3801
3802         #[test]
3803         fn encoding_final_onion_hop_data() {
3804                 let outbound_msg = msgs::OutboundOnionPayload::Receive {
3805                         payment_data: None,
3806                         payment_metadata: None,
3807                         keysend_preimage: None,
3808                         amt_msat: 0x0badf00d01020304,
3809                         outgoing_cltv_value: 0xffffffff,
3810                         custom_tlvs: vec![],
3811                 };
3812                 let encoded_value = outbound_msg.encode();
3813                 let target_value = hex::decode("1002080badf00d010203040404ffffffff").unwrap();
3814                 assert_eq!(encoded_value, target_value);
3815
3816                 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3817                 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
3818                 if let msgs::InboundOnionPayload::Receive {
3819                         payment_data: None, amt_msat, outgoing_cltv_value, ..
3820                 } = inbound_msg {
3821                         assert_eq!(amt_msat, 0x0badf00d01020304);
3822                         assert_eq!(outgoing_cltv_value, 0xffffffff);
3823                 } else { panic!(); }
3824         }
3825
3826         #[test]
3827         fn encoding_final_onion_hop_data_with_secret() {
3828                 let expected_payment_secret = PaymentSecret([0x42u8; 32]);
3829                 let outbound_msg = msgs::OutboundOnionPayload::Receive {
3830                         payment_data: Some(FinalOnionHopData {
3831                                 payment_secret: expected_payment_secret,
3832                                 total_msat: 0x1badca1f
3833                         }),
3834                         payment_metadata: None,
3835                         keysend_preimage: None,
3836                         amt_msat: 0x0badf00d01020304,
3837                         outgoing_cltv_value: 0xffffffff,
3838                         custom_tlvs: vec![],
3839                 };
3840                 let encoded_value = outbound_msg.encode();
3841                 let target_value = hex::decode("3602080badf00d010203040404ffffffff082442424242424242424242424242424242424242424242424242424242424242421badca1f").unwrap();
3842                 assert_eq!(encoded_value, target_value);
3843
3844                 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3845                 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
3846                 if let msgs::InboundOnionPayload::Receive {
3847                         payment_data: Some(FinalOnionHopData {
3848                                 payment_secret,
3849                                 total_msat: 0x1badca1f
3850                         }),
3851                         amt_msat, outgoing_cltv_value,
3852                         payment_metadata: None,
3853                         keysend_preimage: None,
3854                         custom_tlvs,
3855                 } = inbound_msg  {
3856                         assert_eq!(payment_secret, expected_payment_secret);
3857                         assert_eq!(amt_msat, 0x0badf00d01020304);
3858                         assert_eq!(outgoing_cltv_value, 0xffffffff);
3859                         assert_eq!(custom_tlvs, vec![]);
3860                 } else { panic!(); }
3861         }
3862
3863         #[test]
3864         fn encoding_final_onion_hop_data_with_bad_custom_tlvs() {
3865                 // If custom TLVs have type number within the range reserved for protocol, treat them as if
3866                 // they're unknown
3867                 let bad_type_range_tlvs = vec![
3868                         ((1 << 16) - 4, vec![42]),
3869                         ((1 << 16) - 2, vec![42; 32]),
3870                 ];
3871                 let mut msg = msgs::OutboundOnionPayload::Receive {
3872                         payment_data: None,
3873                         payment_metadata: None,
3874                         keysend_preimage: None,
3875                         custom_tlvs: bad_type_range_tlvs,
3876                         amt_msat: 0x0badf00d01020304,
3877                         outgoing_cltv_value: 0xffffffff,
3878                 };
3879                 let encoded_value = msg.encode();
3880                 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3881                 assert!(msgs::InboundOnionPayload::read(&mut Cursor::new(&encoded_value[..]), &&node_signer).is_err());
3882                 let good_type_range_tlvs = vec![
3883                         ((1 << 16) - 3, vec![42]),
3884                         ((1 << 16) - 1, vec![42; 32]),
3885                 ];
3886                 if let msgs::OutboundOnionPayload::Receive { ref mut custom_tlvs, .. } = msg {
3887                         *custom_tlvs = good_type_range_tlvs.clone();
3888                 }
3889                 let encoded_value = msg.encode();
3890                 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&encoded_value[..]), &&node_signer).unwrap();
3891                 match inbound_msg {
3892                         msgs::InboundOnionPayload::Receive { custom_tlvs, .. } => assert!(custom_tlvs.is_empty()),
3893                         _ => panic!(),
3894                 }
3895         }
3896
3897         #[test]
3898         fn encoding_final_onion_hop_data_with_custom_tlvs() {
3899                 let expected_custom_tlvs = vec![
3900                         (5482373483, vec![0x12, 0x34]),
3901                         (5482373487, vec![0x42u8; 8]),
3902                 ];
3903                 let msg = msgs::OutboundOnionPayload::Receive {
3904                         payment_data: None,
3905                         payment_metadata: None,
3906                         keysend_preimage: None,
3907                         custom_tlvs: expected_custom_tlvs.clone(),
3908                         amt_msat: 0x0badf00d01020304,
3909                         outgoing_cltv_value: 0xffffffff,
3910                 };
3911                 let encoded_value = msg.encode();
3912                 let target_value = hex::decode("2e02080badf00d010203040404ffffffffff0000000146c6616b021234ff0000000146c6616f084242424242424242").unwrap();
3913                 assert_eq!(encoded_value, target_value);
3914                 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3915                 let inbound_msg: msgs::InboundOnionPayload = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
3916                 if let msgs::InboundOnionPayload::Receive {
3917                         payment_data: None,
3918                         payment_metadata: None,
3919                         keysend_preimage: None,
3920                         custom_tlvs,
3921                         amt_msat,
3922                         outgoing_cltv_value,
3923                         ..
3924                 } = inbound_msg {
3925                         assert_eq!(custom_tlvs, expected_custom_tlvs);
3926                         assert_eq!(amt_msat, 0x0badf00d01020304);
3927                         assert_eq!(outgoing_cltv_value, 0xffffffff);
3928                 } else { panic!(); }
3929         }
3930
3931         #[test]
3932         fn query_channel_range_end_blocknum() {
3933                 let tests: Vec<(u32, u32, u32)> = vec![
3934                         (10000, 1500, 11500),
3935                         (0, 0xffffffff, 0xffffffff),
3936                         (1, 0xffffffff, 0xffffffff),
3937                 ];
3938
3939                 for (first_blocknum, number_of_blocks, expected) in tests.into_iter() {
3940                         let sut = msgs::QueryChannelRange {
3941                                 chain_hash: ChainHash::using_genesis_block(Network::Regtest),
3942                                 first_blocknum,
3943                                 number_of_blocks,
3944                         };
3945                         assert_eq!(sut.end_blocknum(), expected);
3946                 }
3947         }
3948
3949         #[test]
3950         fn encoding_query_channel_range() {
3951                 let mut query_channel_range = msgs::QueryChannelRange {
3952                         chain_hash: ChainHash::using_genesis_block(Network::Regtest),
3953                         first_blocknum: 100000,
3954                         number_of_blocks: 1500,
3955                 };
3956                 let encoded_value = query_channel_range.encode();
3957                 let target_value = hex::decode("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000186a0000005dc").unwrap();
3958                 assert_eq!(encoded_value, target_value);
3959
3960                 query_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3961                 assert_eq!(query_channel_range.first_blocknum, 100000);
3962                 assert_eq!(query_channel_range.number_of_blocks, 1500);
3963         }
3964
3965         #[test]
3966         fn encoding_reply_channel_range() {
3967                 do_encoding_reply_channel_range(0);
3968                 do_encoding_reply_channel_range(1);
3969         }
3970
3971         fn do_encoding_reply_channel_range(encoding_type: u8) {
3972                 let mut target_value = hex::decode("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000b8a06000005dc01").unwrap();
3973                 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
3974                 let mut reply_channel_range = msgs::ReplyChannelRange {
3975                         chain_hash: expected_chain_hash,
3976                         first_blocknum: 756230,
3977                         number_of_blocks: 1500,
3978                         sync_complete: true,
3979                         short_channel_ids: vec![0x000000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
3980                 };
3981
3982                 if encoding_type == 0 {
3983                         target_value.append(&mut hex::decode("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
3984                         let encoded_value = reply_channel_range.encode();
3985                         assert_eq!(encoded_value, target_value);
3986
3987                         reply_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3988                         assert_eq!(reply_channel_range.chain_hash, expected_chain_hash);
3989                         assert_eq!(reply_channel_range.first_blocknum, 756230);
3990                         assert_eq!(reply_channel_range.number_of_blocks, 1500);
3991                         assert_eq!(reply_channel_range.sync_complete, true);
3992                         assert_eq!(reply_channel_range.short_channel_ids[0], 0x000000000000008e);
3993                         assert_eq!(reply_channel_range.short_channel_ids[1], 0x0000000000003c69);
3994                         assert_eq!(reply_channel_range.short_channel_ids[2], 0x000000000045a6c4);
3995                 } else {
3996                         target_value.append(&mut hex::decode("001601789c636000833e08659309a65878be010010a9023a").unwrap());
3997                         let result: Result<msgs::ReplyChannelRange, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
3998                         assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
3999                 }
4000         }
4001
4002         #[test]
4003         fn encoding_query_short_channel_ids() {
4004                 do_encoding_query_short_channel_ids(0);
4005                 do_encoding_query_short_channel_ids(1);
4006         }
4007
4008         fn do_encoding_query_short_channel_ids(encoding_type: u8) {
4009                 let mut target_value = hex::decode("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
4010                 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4011                 let mut query_short_channel_ids = msgs::QueryShortChannelIds {
4012                         chain_hash: expected_chain_hash,
4013                         short_channel_ids: vec![0x0000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
4014                 };
4015
4016                 if encoding_type == 0 {
4017                         target_value.append(&mut hex::decode("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
4018                         let encoded_value = query_short_channel_ids.encode();
4019                         assert_eq!(encoded_value, target_value);
4020
4021                         query_short_channel_ids = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4022                         assert_eq!(query_short_channel_ids.chain_hash, expected_chain_hash);
4023                         assert_eq!(query_short_channel_ids.short_channel_ids[0], 0x000000000000008e);
4024                         assert_eq!(query_short_channel_ids.short_channel_ids[1], 0x0000000000003c69);
4025                         assert_eq!(query_short_channel_ids.short_channel_ids[2], 0x000000000045a6c4);
4026                 } else {
4027                         target_value.append(&mut hex::decode("001601789c636000833e08659309a65878be010010a9023a").unwrap());
4028                         let result: Result<msgs::QueryShortChannelIds, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
4029                         assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
4030                 }
4031         }
4032
4033         #[test]
4034         fn encoding_reply_short_channel_ids_end() {
4035                 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4036                 let mut reply_short_channel_ids_end = msgs::ReplyShortChannelIdsEnd {
4037                         chain_hash: expected_chain_hash,
4038                         full_information: true,
4039                 };
4040                 let encoded_value = reply_short_channel_ids_end.encode();
4041                 let target_value = hex::decode("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f01").unwrap();
4042                 assert_eq!(encoded_value, target_value);
4043
4044                 reply_short_channel_ids_end = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4045                 assert_eq!(reply_short_channel_ids_end.chain_hash, expected_chain_hash);
4046                 assert_eq!(reply_short_channel_ids_end.full_information, true);
4047         }
4048
4049         #[test]
4050         fn encoding_gossip_timestamp_filter(){
4051                 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4052                 let mut gossip_timestamp_filter = msgs::GossipTimestampFilter {
4053                         chain_hash: expected_chain_hash,
4054                         first_timestamp: 1590000000,
4055                         timestamp_range: 0xffff_ffff,
4056                 };
4057                 let encoded_value = gossip_timestamp_filter.encode();
4058                 let target_value = hex::decode("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f5ec57980ffffffff").unwrap();
4059                 assert_eq!(encoded_value, target_value);
4060
4061                 gossip_timestamp_filter = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4062                 assert_eq!(gossip_timestamp_filter.chain_hash, expected_chain_hash);
4063                 assert_eq!(gossip_timestamp_filter.first_timestamp, 1590000000);
4064                 assert_eq!(gossip_timestamp_filter.timestamp_range, 0xffff_ffff);
4065         }
4066
4067         #[test]
4068         fn decode_onion_hop_data_len_as_bigsize() {
4069                 // Tests that we can decode an onion payload that is >253 bytes.
4070                 // Previously, receiving a payload of this size could've caused us to fail to decode a valid
4071                 // payload, because we were decoding the length (a BigSize, big-endian) as a VarInt
4072                 // (little-endian).
4073
4074                 // Encode a test onion payload with a big custom TLV such that it's >253 bytes, forcing the
4075                 // payload length to be encoded over multiple bytes rather than a single u8.
4076                 let big_payload = encode_big_payload().unwrap();
4077                 let mut rd = Cursor::new(&big_payload[..]);
4078
4079                 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4080                 <msgs::InboundOnionPayload as ReadableArgs<&&test_utils::TestKeysInterface>>
4081                         ::read(&mut rd, &&node_signer).unwrap();
4082         }
4083         // see above test, needs to be a separate method for use of the serialization macros.
4084         fn encode_big_payload() -> Result<Vec<u8>, io::Error> {
4085                 use crate::util::ser::HighZeroBytesDroppedBigSize;
4086                 let payload = msgs::OutboundOnionPayload::Forward {
4087                         short_channel_id: 0xdeadbeef1bad1dea,
4088                         amt_to_forward: 1000,
4089                         outgoing_cltv_value: 0xffffffff,
4090                 };
4091                 let mut encoded_payload = Vec::new();
4092                 let test_bytes = vec![42u8; 1000];
4093                 if let msgs::OutboundOnionPayload::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } = payload {
4094                         _encode_varint_length_prefixed_tlv!(&mut encoded_payload, {
4095                                 (1, test_bytes, required_vec),
4096                                 (2, HighZeroBytesDroppedBigSize(amt_to_forward), required),
4097                                 (4, HighZeroBytesDroppedBigSize(outgoing_cltv_value), required),
4098                                 (6, short_channel_id, required)
4099                         });
4100                 }
4101                 Ok(encoded_payload)
4102         }
4103
4104         #[test]
4105         #[cfg(feature = "std")]
4106         fn test_socket_address_from_str() {
4107                 assert_eq!(SocketAddress::TcpIpV4 {
4108                         addr: Ipv4Addr::new(127, 0, 0, 1).octets(),
4109                         port: 1234,
4110                 }, SocketAddress::from_str("127.0.0.1:1234").unwrap());
4111
4112                 assert_eq!(SocketAddress::TcpIpV6 {
4113                         addr: Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1).octets(),
4114                         port: 1234,
4115                 }, SocketAddress::from_str("[0:0:0:0:0:0:0:1]:1234").unwrap());
4116                 assert_eq!(
4117                         SocketAddress::Hostname {
4118                                 hostname: Hostname::try_from("lightning-node.mydomain.com".to_string()).unwrap(),
4119                                 port: 1234,
4120                         }, SocketAddress::from_str("lightning-node.mydomain.com:1234").unwrap());
4121                 assert_eq!(
4122                         SocketAddress::Hostname {
4123                                 hostname: Hostname::try_from("example.com".to_string()).unwrap(),
4124                                 port: 1234,
4125                         }, SocketAddress::from_str("example.com:1234").unwrap());
4126                 assert_eq!(SocketAddress::OnionV3 {
4127                         ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102, 182, 107, 4, 105, 247, 246, 85,
4128                         111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31, 33, 71, 3],
4129                         checksum: 48326,
4130                         version: 121,
4131                         port: 1234
4132                 }, SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion:1234").unwrap());
4133                 assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6.onion:1234"));
4134                 assert_eq!(Err(SocketAddressParseError::InvalidInput), SocketAddress::from_str("127.0.0.1@1234"));
4135                 assert_eq!(Err(SocketAddressParseError::InvalidInput), "".parse::<SocketAddress>());
4136                 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:9735:94").is_err());
4137                 assert!(SocketAddress::from_str("wrong$%#.com:1234").is_err());
4138                 assert_eq!(Err(SocketAddressParseError::InvalidPort), SocketAddress::from_str("example.com:wrong"));
4139                 assert!("localhost".parse::<SocketAddress>().is_err());
4140                 assert!("localhost:invalid-port".parse::<SocketAddress>().is_err());
4141                 assert!( "invalid-onion-v3-hostname.onion:8080".parse::<SocketAddress>().is_err());
4142                 assert!("b32.example.onion:invalid-port".parse::<SocketAddress>().is_err());
4143                 assert!("invalid-address".parse::<SocketAddress>().is_err());
4144                 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:1234").is_err());
4145         }
4146
4147         #[test]
4148         #[cfg(feature = "std")]
4149         fn test_socket_address_to_socket_addrs() {
4150                 assert_eq!(SocketAddress::TcpIpV4 {addr:[0u8; 4], port: 1337,}.to_socket_addrs().unwrap().next().unwrap(),
4151                                    SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(0,0,0,0), 1337)));
4152                 assert_eq!(SocketAddress::TcpIpV6 {addr:[0u8; 16], port: 1337,}.to_socket_addrs().unwrap().next().unwrap(),
4153                                    SocketAddr::V6(SocketAddrV6::new(Ipv6Addr::from([0u8; 16]), 1337, 0, 0)));
4154                 assert_eq!(SocketAddress::Hostname { hostname: Hostname::try_from("0.0.0.0".to_string()).unwrap(), port: 0 }
4155                                            .to_socket_addrs().unwrap().next().unwrap(), SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::from([0u8; 4]),0)));
4156                 assert!(SocketAddress::OnionV2([0u8; 12]).to_socket_addrs().is_err());
4157                 assert!(SocketAddress::OnionV3{ ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102,
4158                         182, 107, 4, 105, 247, 246, 85, 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31,
4159                         33, 71, 3],
4160                         checksum: 48326,
4161                         version: 121,
4162                         port: 1234 }.to_socket_addrs().is_err());
4163         }
4164 }