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