_ Git - rust-lightning/blob - lightning/src/ln/msgs.rs

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