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