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