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