_ 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 /// BOLT 4 onion packet including hop data for the next peer.
1678 #[derive(Clone, Hash, PartialEq, Eq)]
1679 pub struct OnionPacket {
1680         /// BOLT 4 version number.
1681         pub version: u8,
1682         /// In order to ensure we always return an error on onion decode in compliance with [BOLT
1683         /// #4](https://github.com/lightning/bolts/blob/master/04-onion-routing.md), we have to
1684         /// deserialize `OnionPacket`s contained in [`UpdateAddHTLC`] messages even if the ephemeral
1685         /// public key (here) is bogus, so we hold a [`Result`] instead of a [`PublicKey`] as we'd
1686         /// like.
1687         pub public_key: Result<PublicKey, secp256k1::Error>,
1688         /// 1300 bytes encrypted payload for the next hop.
1689         pub hop_data: [u8; 20*65],
1690         /// HMAC to verify the integrity of hop_data.
1691         pub hmac: [u8; 32],
1692 }
1693
1694 impl onion_utils::Packet for OnionPacket {
1695         type Data = onion_utils::FixedSizeOnionPacket;
1696         fn new(pubkey: PublicKey, hop_data: onion_utils::FixedSizeOnionPacket, hmac: [u8; 32]) -> Self {
1697                 Self {
1698                         version: 0,
1699                         public_key: Ok(pubkey),
1700                         hop_data: hop_data.0,
1701                         hmac,
1702                 }
1703         }
1704 }
1705
1706 impl fmt::Debug for OnionPacket {
1707         fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1708                 f.write_fmt(format_args!("OnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
1709         }
1710 }
1711
1712 #[derive(Clone, Debug, PartialEq, Eq)]
1713 pub(crate) struct OnionErrorPacket {
1714         // This really should be a constant size slice, but the spec lets these things be up to 128KB?
1715         // (TODO) We limit it in decode to much lower...
1716         pub(crate) data: Vec<u8>,
1717 }
1718
1719 impl fmt::Display for DecodeError {
1720         fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1721                 match *self {
1722                         DecodeError::UnknownVersion => f.write_str("Unknown realm byte in Onion packet"),
1723                         DecodeError::UnknownRequiredFeature => f.write_str("Unknown required feature preventing decode"),
1724                         DecodeError::InvalidValue => f.write_str("Nonsense bytes didn't map to the type they were interpreted as"),
1725                         DecodeError::ShortRead => f.write_str("Packet extended beyond the provided bytes"),
1726                         DecodeError::BadLengthDescriptor => f.write_str("A length descriptor in the packet didn't describe the later data correctly"),
1727                         DecodeError::Io(ref e) => fmt::Debug::fmt(e, f),
1728                         DecodeError::UnsupportedCompression => f.write_str("We don't support receiving messages with zlib-compressed fields"),
1729                 }
1730         }
1731 }
1732
1733 impl From<io::Error> for DecodeError {
1734         fn from(e: io::Error) -> Self {
1735                 if e.kind() == io::ErrorKind::UnexpectedEof {
1736                         DecodeError::ShortRead
1737                 } else {
1738                         DecodeError::Io(e.kind())
1739                 }
1740         }
1741 }
1742
1743 #[cfg(not(taproot))]
1744 impl_writeable_msg!(AcceptChannel, {
1745         temporary_channel_id,
1746         dust_limit_satoshis,
1747         max_htlc_value_in_flight_msat,
1748         channel_reserve_satoshis,
1749         htlc_minimum_msat,
1750         minimum_depth,
1751         to_self_delay,
1752         max_accepted_htlcs,
1753         funding_pubkey,
1754         revocation_basepoint,
1755         payment_point,
1756         delayed_payment_basepoint,
1757         htlc_basepoint,
1758         first_per_commitment_point,
1759 }, {
1760         (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1761         (1, channel_type, option),
1762 });
1763
1764 #[cfg(taproot)]
1765 impl_writeable_msg!(AcceptChannel, {
1766         temporary_channel_id,
1767         dust_limit_satoshis,
1768         max_htlc_value_in_flight_msat,
1769         channel_reserve_satoshis,
1770         htlc_minimum_msat,
1771         minimum_depth,
1772         to_self_delay,
1773         max_accepted_htlcs,
1774         funding_pubkey,
1775         revocation_basepoint,
1776         payment_point,
1777         delayed_payment_basepoint,
1778         htlc_basepoint,
1779         first_per_commitment_point,
1780 }, {
1781         (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1782         (1, channel_type, option),
1783         (4, next_local_nonce, option),
1784 });
1785
1786 impl_writeable_msg!(AcceptChannelV2, {
1787         temporary_channel_id,
1788         funding_satoshis,
1789         dust_limit_satoshis,
1790         max_htlc_value_in_flight_msat,
1791         htlc_minimum_msat,
1792         minimum_depth,
1793         to_self_delay,
1794         max_accepted_htlcs,
1795         funding_pubkey,
1796         revocation_basepoint,
1797         payment_basepoint,
1798         delayed_payment_basepoint,
1799         htlc_basepoint,
1800         first_per_commitment_point,
1801         second_per_commitment_point,
1802 }, {
1803         (0, shutdown_scriptpubkey, option),
1804         (1, channel_type, option),
1805         (2, require_confirmed_inputs, option),
1806 });
1807
1808 impl_writeable_msg!(TxAddInput, {
1809         channel_id,
1810         serial_id,
1811         prevtx,
1812         prevtx_out,
1813         sequence,
1814 }, {});
1815
1816 impl_writeable_msg!(TxAddOutput, {
1817         channel_id,
1818         serial_id,
1819         sats,
1820         script,
1821 }, {});
1822
1823 impl_writeable_msg!(TxRemoveInput, {
1824         channel_id,
1825         serial_id,
1826 }, {});
1827
1828 impl_writeable_msg!(TxRemoveOutput, {
1829         channel_id,
1830         serial_id,
1831 }, {});
1832
1833 impl_writeable_msg!(TxComplete, {
1834         channel_id,
1835 }, {});
1836
1837 impl_writeable_msg!(TxSignatures, {
1838         channel_id,
1839         tx_hash,
1840         witnesses,
1841 }, {});
1842
1843 impl_writeable_msg!(TxInitRbf, {
1844         channel_id,
1845         locktime,
1846         feerate_sat_per_1000_weight,
1847 }, {
1848         (0, funding_output_contribution, option),
1849 });
1850
1851 impl_writeable_msg!(TxAckRbf, {
1852         channel_id,
1853 }, {
1854         (0, funding_output_contribution, option),
1855 });
1856
1857 impl_writeable_msg!(TxAbort, {
1858         channel_id,
1859         data,
1860 }, {});
1861
1862 impl_writeable_msg!(AnnouncementSignatures, {
1863         channel_id,
1864         short_channel_id,
1865         node_signature,
1866         bitcoin_signature
1867 }, {});
1868
1869 impl_writeable_msg!(ChannelReestablish, {
1870         channel_id,
1871         next_local_commitment_number,
1872         next_remote_commitment_number,
1873         your_last_per_commitment_secret,
1874         my_current_per_commitment_point,
1875 }, {
1876         (0, next_funding_txid, option),
1877 });
1878
1879 impl_writeable_msg!(ClosingSigned,
1880         { channel_id, fee_satoshis, signature },
1881         { (1, fee_range, option) }
1882 );
1883
1884 impl_writeable!(ClosingSignedFeeRange, {
1885         min_fee_satoshis,
1886         max_fee_satoshis
1887 });
1888
1889 #[cfg(not(taproot))]
1890 impl_writeable_msg!(CommitmentSigned, {
1891         channel_id,
1892         signature,
1893         htlc_signatures
1894 }, {});
1895
1896 #[cfg(taproot)]
1897 impl_writeable_msg!(CommitmentSigned, {
1898         channel_id,
1899         signature,
1900         htlc_signatures
1901 }, {
1902         (2, partial_signature_with_nonce, option)
1903 });
1904
1905 impl_writeable!(DecodedOnionErrorPacket, {
1906         hmac,
1907         failuremsg,
1908         pad
1909 });
1910
1911 #[cfg(not(taproot))]
1912 impl_writeable_msg!(FundingCreated, {
1913         temporary_channel_id,
1914         funding_txid,
1915         funding_output_index,
1916         signature
1917 }, {});
1918 #[cfg(taproot)]
1919 impl_writeable_msg!(FundingCreated, {
1920         temporary_channel_id,
1921         funding_txid,
1922         funding_output_index,
1923         signature
1924 }, {
1925         (2, partial_signature_with_nonce, option),
1926         (4, next_local_nonce, option)
1927 });
1928
1929 #[cfg(not(taproot))]
1930 impl_writeable_msg!(FundingSigned, {
1931         channel_id,
1932         signature
1933 }, {});
1934
1935 #[cfg(taproot)]
1936 impl_writeable_msg!(FundingSigned, {
1937         channel_id,
1938         signature
1939 }, {
1940         (2, partial_signature_with_nonce, option)
1941 });
1942
1943 impl_writeable_msg!(ChannelReady, {
1944         channel_id,
1945         next_per_commitment_point,
1946 }, {
1947         (1, short_channel_id_alias, option),
1948 });
1949
1950 impl Writeable for Init {
1951         fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1952                 // global_features gets the bottom 13 bits of our features, and local_features gets all of
1953                 // our relevant feature bits. This keeps us compatible with old nodes.
1954                 self.features.write_up_to_13(w)?;
1955                 self.features.write(w)?;
1956                 encode_tlv_stream!(w, {
1957                         (1, self.networks.as_ref().map(|n| WithoutLength(n)), option),
1958                         (3, self.remote_network_address, option),
1959                 });
1960                 Ok(())
1961         }
1962 }
1963
1964 impl Readable for Init {
1965         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1966                 let global_features: InitFeatures = Readable::read(r)?;
1967                 let features: InitFeatures = Readable::read(r)?;
1968                 let mut remote_network_address: Option<SocketAddress> = None;
1969                 let mut networks: Option<WithoutLength<Vec<ChainHash>>> = None;
1970                 decode_tlv_stream!(r, {
1971                         (1, networks, option),
1972                         (3, remote_network_address, option)
1973                 });
1974                 Ok(Init {
1975                         features: features | global_features,
1976                         networks: networks.map(|n| n.0),
1977                         remote_network_address,
1978                 })
1979         }
1980 }
1981
1982 impl_writeable_msg!(OpenChannel, {
1983         chain_hash,
1984         temporary_channel_id,
1985         funding_satoshis,
1986         push_msat,
1987         dust_limit_satoshis,
1988         max_htlc_value_in_flight_msat,
1989         channel_reserve_satoshis,
1990         htlc_minimum_msat,
1991         feerate_per_kw,
1992         to_self_delay,
1993         max_accepted_htlcs,
1994         funding_pubkey,
1995         revocation_basepoint,
1996         payment_point,
1997         delayed_payment_basepoint,
1998         htlc_basepoint,
1999         first_per_commitment_point,
2000         channel_flags,
2001 }, {
2002         (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
2003         (1, channel_type, option),
2004 });
2005
2006 impl_writeable_msg!(OpenChannelV2, {
2007         chain_hash,
2008         temporary_channel_id,
2009         funding_feerate_sat_per_1000_weight,
2010         commitment_feerate_sat_per_1000_weight,
2011         funding_satoshis,
2012         dust_limit_satoshis,
2013         max_htlc_value_in_flight_msat,
2014         htlc_minimum_msat,
2015         to_self_delay,
2016         max_accepted_htlcs,
2017         locktime,
2018         funding_pubkey,
2019         revocation_basepoint,
2020         payment_basepoint,
2021         delayed_payment_basepoint,
2022         htlc_basepoint,
2023         first_per_commitment_point,
2024         second_per_commitment_point,
2025         channel_flags,
2026 }, {
2027         (0, shutdown_scriptpubkey, option),
2028         (1, channel_type, option),
2029         (2, require_confirmed_inputs, option),
2030 });
2031
2032 #[cfg(not(taproot))]
2033 impl_writeable_msg!(RevokeAndACK, {
2034         channel_id,
2035         per_commitment_secret,
2036         next_per_commitment_point
2037 }, {});
2038
2039 #[cfg(taproot)]
2040 impl_writeable_msg!(RevokeAndACK, {
2041         channel_id,
2042         per_commitment_secret,
2043         next_per_commitment_point
2044 }, {
2045         (4, next_local_nonce, option)
2046 });
2047
2048 impl_writeable_msg!(Shutdown, {
2049         channel_id,
2050         scriptpubkey
2051 }, {});
2052
2053 impl_writeable_msg!(UpdateFailHTLC, {
2054         channel_id,
2055         htlc_id,
2056         reason
2057 }, {});
2058
2059 impl_writeable_msg!(UpdateFailMalformedHTLC, {
2060         channel_id,
2061         htlc_id,
2062         sha256_of_onion,
2063         failure_code
2064 }, {});
2065
2066 impl_writeable_msg!(UpdateFee, {
2067         channel_id,
2068         feerate_per_kw
2069 }, {});
2070
2071 impl_writeable_msg!(UpdateFulfillHTLC, {
2072         channel_id,
2073         htlc_id,
2074         payment_preimage
2075 }, {});
2076
2077 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2078 // serialization format in a way which assumes we know the total serialized length/message end
2079 // position.
2080 impl_writeable!(OnionErrorPacket, {
2081         data
2082 });
2083
2084 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2085 // serialization format in a way which assumes we know the total serialized length/message end
2086 // position.
2087 impl Writeable for OnionPacket {
2088         fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2089                 self.version.write(w)?;
2090                 match self.public_key {
2091                         Ok(pubkey) => pubkey.write(w)?,
2092                         Err(_) => [0u8;33].write(w)?,
2093                 }
2094                 w.write_all(&self.hop_data)?;
2095                 self.hmac.write(w)?;
2096                 Ok(())
2097         }
2098 }
2099
2100 impl Readable for OnionPacket {
2101         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2102                 Ok(OnionPacket {
2103                         version: Readable::read(r)?,
2104                         public_key: {
2105                                 let mut buf = [0u8;33];
2106                                 r.read_exact(&mut buf)?;
2107                                 PublicKey::from_slice(&buf)
2108                         },
2109                         hop_data: Readable::read(r)?,
2110                         hmac: Readable::read(r)?,
2111                 })
2112         }
2113 }
2114
2115 impl_writeable_msg!(UpdateAddHTLC, {
2116         channel_id,
2117         htlc_id,
2118         amount_msat,
2119         payment_hash,
2120         cltv_expiry,
2121         onion_routing_packet,
2122 }, {
2123         (65537, skimmed_fee_msat, option)
2124 });
2125
2126 impl Readable for OnionMessage {
2127         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2128                 let blinding_point: PublicKey = Readable::read(r)?;
2129                 let len: u16 = Readable::read(r)?;
2130                 let mut packet_reader = FixedLengthReader::new(r, len as u64);
2131                 let onion_routing_packet: onion_message::Packet = <onion_message::Packet as LengthReadable>::read(&mut packet_reader)?;
2132                 Ok(Self {
2133                         blinding_point,
2134                         onion_routing_packet,
2135                 })
2136         }
2137 }
2138
2139 impl Writeable for OnionMessage {
2140         fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2141                 self.blinding_point.write(w)?;
2142                 let onion_packet_len = self.onion_routing_packet.serialized_length();
2143                 (onion_packet_len as u16).write(w)?;
2144                 self.onion_routing_packet.write(w)?;
2145                 Ok(())
2146         }
2147 }
2148
2149 impl Writeable for FinalOnionHopData {
2150         fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2151                 self.payment_secret.0.write(w)?;
2152                 HighZeroBytesDroppedBigSize(self.total_msat).write(w)
2153         }
2154 }
2155
2156 impl Readable for FinalOnionHopData {
2157         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2158                 let secret: [u8; 32] = Readable::read(r)?;
2159                 let amt: HighZeroBytesDroppedBigSize<u64> = Readable::read(r)?;
2160                 Ok(Self { payment_secret: PaymentSecret(secret), total_msat: amt.0 })
2161         }
2162 }
2163
2164 impl Writeable for OutboundOnionPayload {
2165         fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2166                 match self {
2167                         Self::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } => {
2168                                 _encode_varint_length_prefixed_tlv!(w, {
2169                                         (2, HighZeroBytesDroppedBigSize(*amt_to_forward), required),
2170                                         (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2171                                         (6, short_channel_id, required)
2172                                 });
2173                         },
2174                         Self::Receive {
2175                                 ref payment_data, ref payment_metadata, ref keysend_preimage, amt_msat,
2176                                 outgoing_cltv_value, ref custom_tlvs,
2177                         } => {
2178                                 // We need to update [`ln::outbound_payment::RecipientOnionFields::with_custom_tlvs`]
2179                                 // to reject any reserved types in the experimental range if new ones are ever
2180                                 // standardized.
2181                                 let keysend_tlv = keysend_preimage.map(|preimage| (5482373484, preimage.encode()));
2182                                 let mut custom_tlvs: Vec<&(u64, Vec<u8>)> = custom_tlvs.iter().chain(keysend_tlv.iter()).collect();
2183                                 custom_tlvs.sort_unstable_by_key(|(typ, _)| *typ);
2184                                 _encode_varint_length_prefixed_tlv!(w, {
2185                                         (2, HighZeroBytesDroppedBigSize(*amt_msat), required),
2186                                         (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2187                                         (8, payment_data, option),
2188                                         (16, payment_metadata.as_ref().map(|m| WithoutLength(m)), option)
2189                                 }, custom_tlvs.iter());
2190                         },
2191                         Self::BlindedForward { encrypted_tlvs, intro_node_blinding_point } => {
2192                                 _encode_varint_length_prefixed_tlv!(w, {
2193                                         (10, *encrypted_tlvs, required_vec),
2194                                         (12, intro_node_blinding_point, option)
2195                                 });
2196                         },
2197                         Self::BlindedReceive {
2198                                 amt_msat, total_msat, outgoing_cltv_value, encrypted_tlvs,
2199                                 intro_node_blinding_point,
2200                         } => {
2201                                 _encode_varint_length_prefixed_tlv!(w, {
2202                                         (2, HighZeroBytesDroppedBigSize(*amt_msat), required),
2203                                         (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2204                                         (10, *encrypted_tlvs, required_vec),
2205                                         (12, intro_node_blinding_point, option),
2206                                         (18, HighZeroBytesDroppedBigSize(*total_msat), required)
2207                                 });
2208                         },
2209                 }
2210                 Ok(())
2211         }
2212 }
2213
2214 impl<NS: Deref> ReadableArgs<&NS> for InboundOnionPayload where NS::Target: NodeSigner {
2215         fn read<R: Read>(r: &mut R, node_signer: &NS) -> Result<Self, DecodeError> {
2216                 let mut amt = None;
2217                 let mut cltv_value = None;
2218                 let mut short_id: Option<u64> = None;
2219                 let mut payment_data: Option<FinalOnionHopData> = None;
2220                 let mut encrypted_tlvs_opt: Option<WithoutLength<Vec<u8>>> = None;
2221                 let mut intro_node_blinding_point = None;
2222                 let mut payment_metadata: Option<WithoutLength<Vec<u8>>> = None;
2223                 let mut total_msat = None;
2224                 let mut keysend_preimage: Option<PaymentPreimage> = None;
2225                 let mut custom_tlvs = Vec::new();
2226
2227                 let tlv_len = BigSize::read(r)?;
2228                 let rd = FixedLengthReader::new(r, tlv_len.0);
2229                 decode_tlv_stream_with_custom_tlv_decode!(rd, {
2230                         (2, amt, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2231                         (4, cltv_value, (option, encoding: (u32, HighZeroBytesDroppedBigSize))),
2232                         (6, short_id, option),
2233                         (8, payment_data, option),
2234                         (10, encrypted_tlvs_opt, option),
2235                         (12, intro_node_blinding_point, option),
2236                         (16, payment_metadata, option),
2237                         (18, total_msat, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2238                         // See https://github.com/lightning/blips/blob/master/blip-0003.md
2239                         (5482373484, keysend_preimage, option)
2240                 }, |msg_type: u64, msg_reader: &mut FixedLengthReader<_>| -> Result<bool, DecodeError> {
2241                         if msg_type < 1 << 16 { return Ok(false) }
2242                         let mut value = Vec::new();
2243                         msg_reader.read_to_end(&mut value)?;
2244                         custom_tlvs.push((msg_type, value));
2245                         Ok(true)
2246                 });
2247
2248                 if amt.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2249
2250                 if let Some(blinding_point) = intro_node_blinding_point {
2251                         if short_id.is_some() || payment_data.is_some() || payment_metadata.is_some() {
2252                                 return Err(DecodeError::InvalidValue)
2253                         }
2254                         let enc_tlvs = encrypted_tlvs_opt.ok_or(DecodeError::InvalidValue)?.0;
2255                         let enc_tlvs_ss = node_signer.ecdh(Recipient::Node, &blinding_point, None)
2256                                 .map_err(|_| DecodeError::InvalidValue)?;
2257                         let rho = onion_utils::gen_rho_from_shared_secret(&enc_tlvs_ss.secret_bytes());
2258                         let mut s = Cursor::new(&enc_tlvs);
2259                         let mut reader = FixedLengthReader::new(&mut s, enc_tlvs.len() as u64);
2260                         match ChaChaPolyReadAdapter::read(&mut reader, rho)? {
2261                                 ChaChaPolyReadAdapter { readable: ReceiveTlvs { payment_secret, payment_constraints }} => {
2262                                         if total_msat.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2263                                         Ok(Self::BlindedReceive {
2264                                                 amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2265                                                 total_msat: total_msat.ok_or(DecodeError::InvalidValue)?,
2266                                                 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2267                                                 payment_secret,
2268                                                 payment_constraints,
2269                                                 intro_node_blinding_point: blinding_point,
2270                                         })
2271                                 },
2272                         }
2273                 } else if let Some(short_channel_id) = short_id {
2274                         if payment_data.is_some() || payment_metadata.is_some() || encrypted_tlvs_opt.is_some() ||
2275                                 total_msat.is_some()
2276                         { return Err(DecodeError::InvalidValue) }
2277                         Ok(Self::Forward {
2278                                 short_channel_id,
2279                                 amt_to_forward: amt.ok_or(DecodeError::InvalidValue)?,
2280                                 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2281                         })
2282                 } else {
2283                         if encrypted_tlvs_opt.is_some() || total_msat.is_some() {
2284                                 return Err(DecodeError::InvalidValue)
2285                         }
2286                         if let Some(data) = &payment_data {
2287                                 if data.total_msat > MAX_VALUE_MSAT {
2288                                         return Err(DecodeError::InvalidValue);
2289                                 }
2290                         }
2291                         Ok(Self::Receive {
2292                                 payment_data,
2293                                 payment_metadata: payment_metadata.map(|w| w.0),
2294                                 keysend_preimage,
2295                                 amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2296                                 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2297                                 custom_tlvs,
2298                         })
2299                 }
2300         }
2301 }
2302
2303 impl Writeable for Ping {
2304         fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2305                 self.ponglen.write(w)?;
2306                 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2307                 Ok(())
2308         }
2309 }
2310
2311 impl Readable for Ping {
2312         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2313                 Ok(Ping {
2314                         ponglen: Readable::read(r)?,
2315                         byteslen: {
2316                                 let byteslen = Readable::read(r)?;
2317                                 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2318                                 byteslen
2319                         }
2320                 })
2321         }
2322 }
2323
2324 impl Writeable for Pong {
2325         fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2326                 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2327                 Ok(())
2328         }
2329 }
2330
2331 impl Readable for Pong {
2332         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2333                 Ok(Pong {
2334                         byteslen: {
2335                                 let byteslen = Readable::read(r)?;
2336                                 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2337                                 byteslen
2338                         }
2339                 })
2340         }
2341 }
2342
2343 impl Writeable for UnsignedChannelAnnouncement {
2344         fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2345                 self.features.write(w)?;
2346                 self.chain_hash.write(w)?;
2347                 self.short_channel_id.write(w)?;
2348                 self.node_id_1.write(w)?;
2349                 self.node_id_2.write(w)?;
2350                 self.bitcoin_key_1.write(w)?;
2351                 self.bitcoin_key_2.write(w)?;
2352                 w.write_all(&self.excess_data[..])?;
2353                 Ok(())
2354         }
2355 }
2356
2357 impl Readable for UnsignedChannelAnnouncement {
2358         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2359                 Ok(Self {
2360                         features: Readable::read(r)?,
2361                         chain_hash: Readable::read(r)?,
2362                         short_channel_id: Readable::read(r)?,
2363                         node_id_1: Readable::read(r)?,
2364                         node_id_2: Readable::read(r)?,
2365                         bitcoin_key_1: Readable::read(r)?,
2366                         bitcoin_key_2: Readable::read(r)?,
2367                         excess_data: read_to_end(r)?,
2368                 })
2369         }
2370 }
2371
2372 impl_writeable!(ChannelAnnouncement, {
2373         node_signature_1,
2374         node_signature_2,
2375         bitcoin_signature_1,
2376         bitcoin_signature_2,
2377         contents
2378 });
2379
2380 impl Writeable for UnsignedChannelUpdate {
2381         fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2382                 // `message_flags` used to indicate presence of `htlc_maximum_msat`, but was deprecated in the spec.
2383                 const MESSAGE_FLAGS: u8 = 1;
2384                 self.chain_hash.write(w)?;
2385                 self.short_channel_id.write(w)?;
2386                 self.timestamp.write(w)?;
2387                 let all_flags = self.flags as u16 | ((MESSAGE_FLAGS as u16) << 8);
2388                 all_flags.write(w)?;
2389                 self.cltv_expiry_delta.write(w)?;
2390                 self.htlc_minimum_msat.write(w)?;
2391                 self.fee_base_msat.write(w)?;
2392                 self.fee_proportional_millionths.write(w)?;
2393                 self.htlc_maximum_msat.write(w)?;
2394                 w.write_all(&self.excess_data[..])?;
2395                 Ok(())
2396         }
2397 }
2398
2399 impl Readable for UnsignedChannelUpdate {
2400         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2401                 Ok(Self {
2402                         chain_hash: Readable::read(r)?,
2403                         short_channel_id: Readable::read(r)?,
2404                         timestamp: Readable::read(r)?,
2405                         flags: {
2406                                 let flags: u16 = Readable::read(r)?;
2407                                 // Note: we ignore the `message_flags` for now, since it was deprecated by the spec.
2408                                 flags as u8
2409                         },
2410                         cltv_expiry_delta: Readable::read(r)?,
2411                         htlc_minimum_msat: Readable::read(r)?,
2412                         fee_base_msat: Readable::read(r)?,
2413                         fee_proportional_millionths: Readable::read(r)?,
2414                         htlc_maximum_msat: Readable::read(r)?,
2415                         excess_data: read_to_end(r)?,
2416                 })
2417         }
2418 }
2419
2420 impl_writeable!(ChannelUpdate, {
2421         signature,
2422         contents
2423 });
2424
2425 impl Writeable for ErrorMessage {
2426         fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2427                 self.channel_id.write(w)?;
2428                 (self.data.len() as u16).write(w)?;
2429                 w.write_all(self.data.as_bytes())?;
2430                 Ok(())
2431         }
2432 }
2433
2434 impl Readable for ErrorMessage {
2435         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2436                 Ok(Self {
2437                         channel_id: Readable::read(r)?,
2438                         data: {
2439                                 let sz: usize = <u16 as Readable>::read(r)? as usize;
2440                                 let mut data = Vec::with_capacity(sz);
2441                                 data.resize(sz, 0);
2442                                 r.read_exact(&mut data)?;
2443                                 match String::from_utf8(data) {
2444                                         Ok(s) => s,
2445                                         Err(_) => return Err(DecodeError::InvalidValue),
2446                                 }
2447                         }
2448                 })
2449         }
2450 }
2451
2452 impl Writeable for WarningMessage {
2453         fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2454                 self.channel_id.write(w)?;
2455                 (self.data.len() as u16).write(w)?;
2456                 w.write_all(self.data.as_bytes())?;
2457                 Ok(())
2458         }
2459 }
2460
2461 impl Readable for WarningMessage {
2462         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2463                 Ok(Self {
2464                         channel_id: Readable::read(r)?,
2465                         data: {
2466                                 let sz: usize = <u16 as Readable>::read(r)? as usize;
2467                                 let mut data = Vec::with_capacity(sz);
2468                                 data.resize(sz, 0);
2469                                 r.read_exact(&mut data)?;
2470                                 match String::from_utf8(data) {
2471                                         Ok(s) => s,
2472                                         Err(_) => return Err(DecodeError::InvalidValue),
2473                                 }
2474                         }
2475                 })
2476         }
2477 }
2478
2479 impl Writeable for UnsignedNodeAnnouncement {
2480         fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2481                 self.features.write(w)?;
2482                 self.timestamp.write(w)?;
2483                 self.node_id.write(w)?;
2484                 w.write_all(&self.rgb)?;
2485                 self.alias.write(w)?;
2486
2487                 let mut addr_len = 0;
2488                 for addr in self.addresses.iter() {
2489                         addr_len += 1 + addr.len();
2490                 }
2491                 (addr_len + self.excess_address_data.len() as u16).write(w)?;
2492                 for addr in self.addresses.iter() {
2493                         addr.write(w)?;
2494                 }
2495                 w.write_all(&self.excess_address_data[..])?;
2496                 w.write_all(&self.excess_data[..])?;
2497                 Ok(())
2498         }
2499 }
2500
2501 impl Readable for UnsignedNodeAnnouncement {
2502         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2503                 let features: NodeFeatures = Readable::read(r)?;
2504                 let timestamp: u32 = Readable::read(r)?;
2505                 let node_id: NodeId = Readable::read(r)?;
2506                 let mut rgb = [0; 3];
2507                 r.read_exact(&mut rgb)?;
2508                 let alias: NodeAlias = Readable::read(r)?;
2509
2510                 let addr_len: u16 = Readable::read(r)?;
2511                 let mut addresses: Vec<SocketAddress> = Vec::new();
2512                 let mut addr_readpos = 0;
2513                 let mut excess = false;
2514                 let mut excess_byte = 0;
2515                 loop {
2516                         if addr_len <= addr_readpos { break; }
2517                         match Readable::read(r) {
2518                                 Ok(Ok(addr)) => {
2519                                         if addr_len < addr_readpos + 1 + addr.len() {
2520                                                 return Err(DecodeError::BadLengthDescriptor);
2521                                         }
2522                                         addr_readpos += (1 + addr.len()) as u16;
2523                                         addresses.push(addr);
2524                                 },
2525                                 Ok(Err(unknown_descriptor)) => {
2526                                         excess = true;
2527                                         excess_byte = unknown_descriptor;
2528                                         break;
2529                                 },
2530                                 Err(DecodeError::ShortRead) => return Err(DecodeError::BadLengthDescriptor),
2531                                 Err(e) => return Err(e),
2532                         }
2533                 }
2534
2535                 let mut excess_data = vec![];
2536                 let excess_address_data = if addr_readpos < addr_len {
2537                         let mut excess_address_data = vec![0; (addr_len - addr_readpos) as usize];
2538                         r.read_exact(&mut excess_address_data[if excess { 1 } else { 0 }..])?;
2539                         if excess {
2540                                 excess_address_data[0] = excess_byte;
2541                         }
2542                         excess_address_data
2543                 } else {
2544                         if excess {
2545                                 excess_data.push(excess_byte);
2546                         }
2547                         Vec::new()
2548                 };
2549                 excess_data.extend(read_to_end(r)?.iter());
2550                 Ok(UnsignedNodeAnnouncement {
2551                         features,
2552                         timestamp,
2553                         node_id,
2554                         rgb,
2555                         alias,
2556                         addresses,
2557                         excess_address_data,
2558                         excess_data,
2559                 })
2560         }
2561 }
2562
2563 impl_writeable!(NodeAnnouncement, {
2564         signature,
2565         contents
2566 });
2567
2568 impl Readable for QueryShortChannelIds {
2569         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2570                 let chain_hash: ChainHash = Readable::read(r)?;
2571
2572                 let encoding_len: u16 = Readable::read(r)?;
2573                 let encoding_type: u8 = Readable::read(r)?;
2574
2575                 // Must be encoding_type=0 uncompressed serialization. We do not
2576                 // support encoding_type=1 zlib serialization.
2577                 if encoding_type != EncodingType::Uncompressed as u8 {
2578                         return Err(DecodeError::UnsupportedCompression);
2579                 }
2580
2581                 // We expect the encoding_len to always includes the 1-byte
2582                 // encoding_type and that short_channel_ids are 8-bytes each
2583                 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2584                         return Err(DecodeError::InvalidValue);
2585                 }
2586
2587                 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2588                 // less the 1-byte encoding_type
2589                 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2590                 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2591                 for _ in 0..short_channel_id_count {
2592                         short_channel_ids.push(Readable::read(r)?);
2593                 }
2594
2595                 Ok(QueryShortChannelIds {
2596                         chain_hash,
2597                         short_channel_ids,
2598                 })
2599         }
2600 }
2601
2602 impl Writeable for QueryShortChannelIds {
2603         fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2604                 // Calculated from 1-byte encoding_type plus 8-bytes per short_channel_id
2605                 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2606
2607                 self.chain_hash.write(w)?;
2608                 encoding_len.write(w)?;
2609
2610                 // We only support type=0 uncompressed serialization
2611                 (EncodingType::Uncompressed as u8).write(w)?;
2612
2613                 for scid in self.short_channel_ids.iter() {
2614                         scid.write(w)?;
2615                 }
2616
2617                 Ok(())
2618         }
2619 }
2620
2621 impl_writeable_msg!(ReplyShortChannelIdsEnd, {
2622         chain_hash,
2623         full_information,
2624 }, {});
2625
2626 impl QueryChannelRange {
2627         /// Calculates the overflow safe ending block height for the query.
2628         ///
2629         /// Overflow returns `0xffffffff`, otherwise returns `first_blocknum + number_of_blocks`.
2630         pub fn end_blocknum(&self) -> u32 {
2631                 match self.first_blocknum.checked_add(self.number_of_blocks) {
2632                         Some(block) => block,
2633                         None => u32::max_value(),
2634                 }
2635         }
2636 }
2637
2638 impl_writeable_msg!(QueryChannelRange, {
2639         chain_hash,
2640         first_blocknum,
2641         number_of_blocks
2642 }, {});
2643
2644 impl Readable for ReplyChannelRange {
2645         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2646                 let chain_hash: ChainHash = Readable::read(r)?;
2647                 let first_blocknum: u32 = Readable::read(r)?;
2648                 let number_of_blocks: u32 = Readable::read(r)?;
2649                 let sync_complete: bool = Readable::read(r)?;
2650
2651                 let encoding_len: u16 = Readable::read(r)?;
2652                 let encoding_type: u8 = Readable::read(r)?;
2653
2654                 // Must be encoding_type=0 uncompressed serialization. We do not
2655                 // support encoding_type=1 zlib serialization.
2656                 if encoding_type != EncodingType::Uncompressed as u8 {
2657                         return Err(DecodeError::UnsupportedCompression);
2658                 }
2659
2660                 // We expect the encoding_len to always includes the 1-byte
2661                 // encoding_type and that short_channel_ids are 8-bytes each
2662                 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2663                         return Err(DecodeError::InvalidValue);
2664                 }
2665
2666                 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2667                 // less the 1-byte encoding_type
2668                 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2669                 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2670                 for _ in 0..short_channel_id_count {
2671                         short_channel_ids.push(Readable::read(r)?);
2672                 }
2673
2674                 Ok(ReplyChannelRange {
2675                         chain_hash,
2676                         first_blocknum,
2677                         number_of_blocks,
2678                         sync_complete,
2679                         short_channel_ids
2680                 })
2681         }
2682 }
2683
2684 impl Writeable for ReplyChannelRange {
2685         fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2686                 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2687                 self.chain_hash.write(w)?;
2688                 self.first_blocknum.write(w)?;
2689                 self.number_of_blocks.write(w)?;
2690                 self.sync_complete.write(w)?;
2691
2692                 encoding_len.write(w)?;
2693                 (EncodingType::Uncompressed as u8).write(w)?;
2694                 for scid in self.short_channel_ids.iter() {
2695                         scid.write(w)?;
2696                 }
2697
2698                 Ok(())
2699         }
2700 }
2701
2702 impl_writeable_msg!(GossipTimestampFilter, {
2703         chain_hash,
2704         first_timestamp,
2705         timestamp_range,
2706 }, {});
2707
2708 #[cfg(test)]
2709 mod tests {
2710         use std::convert::TryFrom;
2711         use bitcoin::{Transaction, PackedLockTime, TxIn, Script, Sequence, Witness, TxOut};
2712         use hex;
2713         use crate::ln::{PaymentPreimage, PaymentHash, PaymentSecret};
2714         use crate::ln::ChannelId;
2715         use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
2716         use crate::ln::msgs::{self, FinalOnionHopData, OnionErrorPacket};
2717         use crate::ln::msgs::SocketAddress;
2718         use crate::routing::gossip::{NodeAlias, NodeId};
2719         use crate::util::ser::{Writeable, Readable, ReadableArgs, Hostname, TransactionU16LenLimited};
2720         use crate::util::test_utils;
2721
2722         use bitcoin::hashes::hex::FromHex;
2723         use bitcoin::util::address::Address;
2724         use bitcoin::network::constants::Network;
2725         use bitcoin::blockdata::constants::ChainHash;
2726         use bitcoin::blockdata::script::Builder;
2727         use bitcoin::blockdata::opcodes;
2728         use bitcoin::hash_types::Txid;
2729
2730         use bitcoin::secp256k1::{PublicKey,SecretKey};
2731         use bitcoin::secp256k1::{Secp256k1, Message};
2732
2733         use crate::io::{self, Cursor};
2734         use crate::prelude::*;
2735         use core::str::FromStr;
2736         use crate::chain::transaction::OutPoint;
2737
2738         #[cfg(feature = "std")]
2739         use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6, ToSocketAddrs};
2740         #[cfg(feature = "std")]
2741         use crate::ln::msgs::SocketAddressParseError;
2742
2743         #[test]
2744         fn encoding_channel_reestablish() {
2745                 let public_key = {
2746                         let secp_ctx = Secp256k1::new();
2747                         PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2748                 };
2749
2750                 let cr = msgs::ChannelReestablish {
2751                         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]),
2752                         next_local_commitment_number: 3,
2753                         next_remote_commitment_number: 4,
2754                         your_last_per_commitment_secret: [9;32],
2755                         my_current_per_commitment_point: public_key,
2756                         next_funding_txid: None,
2757                 };
2758
2759                 let encoded_value = cr.encode();
2760                 assert_eq!(
2761                         encoded_value,
2762                         vec![
2763                                 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
2764                                 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2765                                 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2766                                 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
2767                                 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
2768                         ]
2769                 );
2770         }
2771
2772         #[test]
2773         fn encoding_channel_reestablish_with_next_funding_txid() {
2774                 let public_key = {
2775                         let secp_ctx = Secp256k1::new();
2776                         PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2777                 };
2778
2779                 let cr = msgs::ChannelReestablish {
2780                         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]),
2781                         next_local_commitment_number: 3,
2782                         next_remote_commitment_number: 4,
2783                         your_last_per_commitment_secret: [9;32],
2784                         my_current_per_commitment_point: public_key,
2785                         next_funding_txid: Some(Txid::from_hash(bitcoin::hashes::Hash::from_slice(&[
2786                                 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,
2787                         ]).unwrap())),
2788                 };
2789
2790                 let encoded_value = cr.encode();
2791                 assert_eq!(
2792                         encoded_value,
2793                         vec![
2794                                 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
2795                                 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2796                                 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2797                                 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
2798                                 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
2799                                 0, // Type (next_funding_txid)
2800                                 32, // Length
2801                                 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
2802                         ]
2803                 );
2804         }
2805
2806         macro_rules! get_keys_from {
2807                 ($slice: expr, $secp_ctx: expr) => {
2808                         {
2809                                 let privkey = SecretKey::from_slice(&hex::decode($slice).unwrap()[..]).unwrap();
2810                                 let pubkey = PublicKey::from_secret_key(&$secp_ctx, &privkey);
2811                                 (privkey, pubkey)
2812                         }
2813                 }
2814         }
2815
2816         macro_rules! get_sig_on {
2817                 ($privkey: expr, $ctx: expr, $string: expr) => {
2818                         {
2819                                 let sighash = Message::from_slice(&$string.into_bytes()[..]).unwrap();
2820                                 $ctx.sign_ecdsa(&sighash, &$privkey)
2821                         }
2822                 }
2823         }
2824
2825         #[test]
2826         fn encoding_announcement_signatures() {
2827                 let secp_ctx = Secp256k1::new();
2828                 let (privkey, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2829                 let sig_1 = get_sig_on!(privkey, secp_ctx, String::from("01010101010101010101010101010101"));
2830                 let sig_2 = get_sig_on!(privkey, secp_ctx, String::from("02020202020202020202020202020202"));
2831                 let announcement_signatures = msgs::AnnouncementSignatures {
2832                         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]),
2833                         short_channel_id: 2316138423780173,
2834                         node_signature: sig_1,
2835                         bitcoin_signature: sig_2,
2836                 };
2837
2838                 let encoded_value = announcement_signatures.encode();
2839                 assert_eq!(encoded_value, hex::decode("040000000000000005000000000000000600000000000000070000000000000000083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073acf9953cef4700860f5967838eba2bae89288ad188ebf8b20bf995c3ea53a26df1876d0a3a0e13172ba286a673140190c02ba9da60a2e43a745188c8a83c7f3ef").unwrap());
2840         }
2841
2842         fn do_encoding_channel_announcement(unknown_features_bits: bool, excess_data: bool) {
2843                 let secp_ctx = Secp256k1::new();
2844                 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2845                 let (privkey_2, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2846                 let (privkey_3, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2847                 let (privkey_4, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2848                 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2849                 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
2850                 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
2851                 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
2852                 let mut features = ChannelFeatures::empty();
2853                 if unknown_features_bits {
2854                         features = ChannelFeatures::from_le_bytes(vec![0xFF, 0xFF]);
2855                 }
2856                 let unsigned_channel_announcement = msgs::UnsignedChannelAnnouncement {
2857                         features,
2858                         chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
2859                         short_channel_id: 2316138423780173,
2860                         node_id_1: NodeId::from_pubkey(&pubkey_1),
2861                         node_id_2: NodeId::from_pubkey(&pubkey_2),
2862                         bitcoin_key_1: NodeId::from_pubkey(&pubkey_3),
2863                         bitcoin_key_2: NodeId::from_pubkey(&pubkey_4),
2864                         excess_data: if excess_data { vec![10, 0, 0, 20, 0, 0, 30, 0, 0, 40] } else { Vec::new() },
2865                 };
2866                 let channel_announcement = msgs::ChannelAnnouncement {
2867                         node_signature_1: sig_1,
2868                         node_signature_2: sig_2,
2869                         bitcoin_signature_1: sig_3,
2870                         bitcoin_signature_2: sig_4,
2871                         contents: unsigned_channel_announcement,
2872                 };
2873                 let encoded_value = channel_announcement.encode();
2874                 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a1735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap();
2875                 if unknown_features_bits {
2876                         target_value.append(&mut hex::decode("0002ffff").unwrap());
2877                 } else {
2878                         target_value.append(&mut hex::decode("0000").unwrap());
2879                 }
2880                 target_value.append(&mut hex::decode("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
2881                 target_value.append(&mut hex::decode("00083a840000034d031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
2882                 if excess_data {
2883                         target_value.append(&mut hex::decode("0a00001400001e000028").unwrap());
2884                 }
2885                 assert_eq!(encoded_value, target_value);
2886         }
2887
2888         #[test]
2889         fn encoding_channel_announcement() {
2890                 do_encoding_channel_announcement(true, false);
2891                 do_encoding_channel_announcement(false, true);
2892                 do_encoding_channel_announcement(false, false);
2893                 do_encoding_channel_announcement(true, true);
2894         }
2895
2896         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) {
2897                 let secp_ctx = Secp256k1::new();
2898                 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2899                 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2900                 let features = if unknown_features_bits {
2901                         NodeFeatures::from_le_bytes(vec![0xFF, 0xFF])
2902                 } else {
2903                         // Set to some features we may support
2904                         NodeFeatures::from_le_bytes(vec![2 | 1 << 5])
2905                 };
2906                 let mut addresses = Vec::new();
2907                 if ipv4 {
2908                         addresses.push(SocketAddress::TcpIpV4 {
2909                                 addr: [255, 254, 253, 252],
2910                                 port: 9735
2911                         });
2912                 }
2913                 if ipv6 {
2914                         addresses.push(SocketAddress::TcpIpV6 {
2915                                 addr: [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240],
2916                                 port: 9735
2917                         });
2918                 }
2919                 if onionv2 {
2920                         addresses.push(msgs::SocketAddress::OnionV2(
2921                                 [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 38, 7]
2922                         ));
2923                 }
2924                 if onionv3 {
2925                         addresses.push(msgs::SocketAddress::OnionV3 {
2926                                 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],
2927                                 checksum: 32,
2928                                 version: 16,
2929                                 port: 9735
2930                         });
2931                 }
2932                 if hostname {
2933                         addresses.push(SocketAddress::Hostname {
2934                                 hostname: Hostname::try_from(String::from("host")).unwrap(),
2935                                 port: 9735,
2936                         });
2937                 }
2938                 let mut addr_len = 0;
2939                 for addr in &addresses {
2940                         addr_len += addr.len() + 1;
2941                 }
2942                 let unsigned_node_announcement = msgs::UnsignedNodeAnnouncement {
2943                         features,
2944                         timestamp: 20190119,
2945                         node_id: NodeId::from_pubkey(&pubkey_1),
2946                         rgb: [32; 3],
2947                         alias: NodeAlias([16;32]),
2948                         addresses,
2949                         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() },
2950                         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() },
2951                 };
2952                 addr_len += unsigned_node_announcement.excess_address_data.len() as u16;
2953                 let node_announcement = msgs::NodeAnnouncement {
2954                         signature: sig_1,
2955                         contents: unsigned_node_announcement,
2956                 };
2957                 let encoded_value = node_announcement.encode();
2958                 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
2959                 if unknown_features_bits {
2960                         target_value.append(&mut hex::decode("0002ffff").unwrap());
2961                 } else {
2962                         target_value.append(&mut hex::decode("000122").unwrap());
2963                 }
2964                 target_value.append(&mut hex::decode("013413a7031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f2020201010101010101010101010101010101010101010101010101010101010101010").unwrap());
2965                 target_value.append(&mut vec![(addr_len >> 8) as u8, addr_len as u8]);
2966                 if ipv4 {
2967                         target_value.append(&mut hex::decode("01fffefdfc2607").unwrap());
2968                 }
2969                 if ipv6 {
2970                         target_value.append(&mut hex::decode("02fffefdfcfbfaf9f8f7f6f5f4f3f2f1f02607").unwrap());
2971                 }
2972                 if onionv2 {
2973                         target_value.append(&mut hex::decode("03fffefdfcfbfaf9f8f7f62607").unwrap());
2974                 }
2975                 if onionv3 {
2976                         target_value.append(&mut hex::decode("04fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0efeeedecebeae9e8e7e6e5e4e3e2e1e00020102607").unwrap());
2977                 }
2978                 if hostname {
2979                         target_value.append(&mut hex::decode("0504686f73742607").unwrap());
2980                 }
2981                 if excess_address_data {
2982                         target_value.append(&mut hex::decode("216c280b5395a2546e7e4b2663e04f811622f15a4f92e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d269").unwrap());
2983                 }
2984                 if excess_data {
2985                         target_value.append(&mut hex::decode("3b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
2986                 }
2987                 assert_eq!(encoded_value, target_value);
2988         }
2989
2990         #[test]
2991         fn encoding_node_announcement() {
2992                 do_encoding_node_announcement(true, true, true, true, true, true, true, true);
2993                 do_encoding_node_announcement(false, false, false, false, false, false, false, false);
2994                 do_encoding_node_announcement(false, true, false, false, false, false, false, false);
2995                 do_encoding_node_announcement(false, false, true, false, false, false, false, false);
2996                 do_encoding_node_announcement(false, false, false, true, false, false, false, false);
2997                 do_encoding_node_announcement(false, false, false, false, true, false, false, false);
2998                 do_encoding_node_announcement(false, false, false, false, false, true, false, false);
2999                 do_encoding_node_announcement(false, false, false, false, false, false, true, false);
3000                 do_encoding_node_announcement(false, true, false, true, false, false, true, false);
3001                 do_encoding_node_announcement(false, false, true, false, true, false, false, false);
3002         }
3003
3004         fn do_encoding_channel_update(direction: bool, disable: bool, excess_data: bool) {
3005                 let secp_ctx = Secp256k1::new();
3006                 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3007                 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3008                 let unsigned_channel_update = msgs::UnsignedChannelUpdate {
3009                         chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3010                         short_channel_id: 2316138423780173,
3011                         timestamp: 20190119,
3012                         flags: if direction { 1 } else { 0 } | if disable { 1 << 1 } else { 0 },
3013                         cltv_expiry_delta: 144,
3014                         htlc_minimum_msat: 1000000,
3015                         htlc_maximum_msat: 131355275467161,
3016                         fee_base_msat: 10000,
3017                         fee_proportional_millionths: 20,
3018                         excess_data: if excess_data { vec![0, 0, 0, 0, 59, 154, 202, 0] } else { Vec::new() }
3019                 };
3020                 let channel_update = msgs::ChannelUpdate {
3021                         signature: sig_1,
3022                         contents: unsigned_channel_update
3023                 };
3024                 let encoded_value = channel_update.encode();
3025                 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3026                 target_value.append(&mut hex::decode("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3027                 target_value.append(&mut hex::decode("00083a840000034d013413a7").unwrap());
3028                 target_value.append(&mut hex::decode("01").unwrap());
3029                 target_value.append(&mut hex::decode("00").unwrap());
3030                 if direction {
3031                         let flag = target_value.last_mut().unwrap();
3032                         *flag = 1;
3033                 }
3034                 if disable {
3035                         let flag = target_value.last_mut().unwrap();
3036                         *flag = *flag | 1 << 1;
3037                 }
3038                 target_value.append(&mut hex::decode("009000000000000f42400000271000000014").unwrap());
3039                 target_value.append(&mut hex::decode("0000777788889999").unwrap());
3040                 if excess_data {
3041                         target_value.append(&mut hex::decode("000000003b9aca00").unwrap());
3042                 }
3043                 assert_eq!(encoded_value, target_value);
3044         }
3045
3046         #[test]
3047         fn encoding_channel_update() {
3048                 do_encoding_channel_update(false, false, false);
3049                 do_encoding_channel_update(false, false, true);
3050                 do_encoding_channel_update(true, false, false);
3051                 do_encoding_channel_update(true, false, true);
3052                 do_encoding_channel_update(false, true, false);
3053                 do_encoding_channel_update(false, true, true);
3054                 do_encoding_channel_update(true, true, false);
3055                 do_encoding_channel_update(true, true, true);
3056         }
3057
3058         fn do_encoding_open_channel(random_bit: bool, shutdown: bool, incl_chan_type: bool) {
3059                 let secp_ctx = Secp256k1::new();
3060                 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3061                 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3062                 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3063                 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3064                 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3065                 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3066                 let open_channel = msgs::OpenChannel {
3067                         chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3068                         temporary_channel_id: ChannelId::from_bytes([2; 32]),
3069                         funding_satoshis: 1311768467284833366,
3070                         push_msat: 2536655962884945560,
3071                         dust_limit_satoshis: 3608586615801332854,
3072                         max_htlc_value_in_flight_msat: 8517154655701053848,
3073                         channel_reserve_satoshis: 8665828695742877976,
3074                         htlc_minimum_msat: 2316138423780173,
3075                         feerate_per_kw: 821716,
3076                         to_self_delay: 49340,
3077                         max_accepted_htlcs: 49340,
3078                         funding_pubkey: pubkey_1,
3079                         revocation_basepoint: pubkey_2,
3080                         payment_point: pubkey_3,
3081                         delayed_payment_basepoint: pubkey_4,
3082                         htlc_basepoint: pubkey_5,
3083                         first_per_commitment_point: pubkey_6,
3084                         channel_flags: if random_bit { 1 << 5 } else { 0 },
3085                         shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3086                         channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3087                 };
3088                 let encoded_value = open_channel.encode();
3089                 let mut target_value = Vec::new();
3090                 target_value.append(&mut hex::decode("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3091                 target_value.append(&mut hex::decode("02020202020202020202020202020202020202020202020202020202020202021234567890123456233403289122369832144668701144767633030896203198784335490624111800083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3092                 if random_bit {
3093                         target_value.append(&mut hex::decode("20").unwrap());
3094                 } else {
3095                         target_value.append(&mut hex::decode("00").unwrap());
3096                 }
3097                 if shutdown {
3098                         target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3099                 }
3100                 if incl_chan_type {
3101                         target_value.append(&mut hex::decode("0100").unwrap());
3102                 }
3103                 assert_eq!(encoded_value, target_value);
3104         }
3105
3106         #[test]
3107         fn encoding_open_channel() {
3108                 do_encoding_open_channel(false, false, false);
3109                 do_encoding_open_channel(false, false, true);
3110                 do_encoding_open_channel(false, true, false);
3111                 do_encoding_open_channel(false, true, true);
3112                 do_encoding_open_channel(true, false, false);
3113                 do_encoding_open_channel(true, false, true);
3114                 do_encoding_open_channel(true, true, false);
3115                 do_encoding_open_channel(true, true, true);
3116         }
3117
3118         fn do_encoding_open_channelv2(random_bit: bool, shutdown: bool, incl_chan_type: bool, require_confirmed_inputs: bool) {
3119                 let secp_ctx = Secp256k1::new();
3120                 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3121                 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3122                 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3123                 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3124                 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3125                 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3126                 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3127                 let open_channelv2 = msgs::OpenChannelV2 {
3128                         chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3129                         temporary_channel_id: ChannelId::from_bytes([2; 32]),
3130                         funding_feerate_sat_per_1000_weight: 821716,
3131                         commitment_feerate_sat_per_1000_weight: 821716,
3132                         funding_satoshis: 1311768467284833366,
3133                         dust_limit_satoshis: 3608586615801332854,
3134                         max_htlc_value_in_flight_msat: 8517154655701053848,
3135                         htlc_minimum_msat: 2316138423780173,
3136                         to_self_delay: 49340,
3137                         max_accepted_htlcs: 49340,
3138                         locktime: 305419896,
3139                         funding_pubkey: pubkey_1,
3140                         revocation_basepoint: pubkey_2,
3141                         payment_basepoint: pubkey_3,
3142                         delayed_payment_basepoint: pubkey_4,
3143                         htlc_basepoint: pubkey_5,
3144                         first_per_commitment_point: pubkey_6,
3145                         second_per_commitment_point: pubkey_7,
3146                         channel_flags: if random_bit { 1 << 5 } else { 0 },
3147                         shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3148                         channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3149                         require_confirmed_inputs: if require_confirmed_inputs { Some(()) } else { None },
3150                 };
3151                 let encoded_value = open_channelv2.encode();
3152                 let mut target_value = Vec::new();
3153                 target_value.append(&mut hex::decode("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3154                 target_value.append(&mut hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap());
3155                 target_value.append(&mut hex::decode("000c89d4").unwrap());
3156                 target_value.append(&mut hex::decode("000c89d4").unwrap());
3157                 target_value.append(&mut hex::decode("1234567890123456").unwrap());
3158                 target_value.append(&mut hex::decode("3214466870114476").unwrap());
3159                 target_value.append(&mut hex::decode("7633030896203198").unwrap());
3160                 target_value.append(&mut hex::decode("00083a840000034d").unwrap());
3161                 target_value.append(&mut hex::decode("c0bc").unwrap());
3162                 target_value.append(&mut hex::decode("c0bc").unwrap());
3163                 target_value.append(&mut hex::decode("12345678").unwrap());
3164                 target_value.append(&mut hex::decode("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap());
3165                 target_value.append(&mut hex::decode("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap());
3166                 target_value.append(&mut hex::decode("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap());
3167                 target_value.append(&mut hex::decode("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
3168                 target_value.append(&mut hex::decode("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap());
3169                 target_value.append(&mut hex::decode("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3170                 target_value.append(&mut hex::decode("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap());
3171
3172                 if random_bit {
3173                         target_value.append(&mut hex::decode("20").unwrap());
3174                 } else {
3175                         target_value.append(&mut hex::decode("00").unwrap());
3176                 }
3177                 if shutdown {
3178                         target_value.append(&mut hex::decode("001b").unwrap()); // Type 0 + Length 27
3179                         target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3180                 }
3181                 if incl_chan_type {
3182                         target_value.append(&mut hex::decode("0100").unwrap());
3183                 }
3184                 if require_confirmed_inputs {
3185                         target_value.append(&mut hex::decode("0200").unwrap());
3186                 }
3187                 assert_eq!(encoded_value, target_value);
3188         }
3189
3190         #[test]
3191         fn encoding_open_channelv2() {
3192                 do_encoding_open_channelv2(false, false, false, false);
3193                 do_encoding_open_channelv2(false, false, false, true);
3194                 do_encoding_open_channelv2(false, false, true, false);
3195                 do_encoding_open_channelv2(false, false, true, true);
3196                 do_encoding_open_channelv2(false, true, false, false);
3197                 do_encoding_open_channelv2(false, true, false, true);
3198                 do_encoding_open_channelv2(false, true, true, false);
3199                 do_encoding_open_channelv2(false, true, true, true);
3200                 do_encoding_open_channelv2(true, false, false, false);
3201                 do_encoding_open_channelv2(true, false, false, true);
3202                 do_encoding_open_channelv2(true, false, true, false);
3203                 do_encoding_open_channelv2(true, false, true, true);
3204                 do_encoding_open_channelv2(true, true, false, false);
3205                 do_encoding_open_channelv2(true, true, false, true);
3206                 do_encoding_open_channelv2(true, true, true, false);
3207                 do_encoding_open_channelv2(true, true, true, true);
3208         }
3209
3210         fn do_encoding_accept_channel(shutdown: bool) {
3211                 let secp_ctx = Secp256k1::new();
3212                 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3213                 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3214                 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3215                 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3216                 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3217                 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3218                 let accept_channel = msgs::AcceptChannel {
3219                         temporary_channel_id: ChannelId::from_bytes([2; 32]),
3220                         dust_limit_satoshis: 1311768467284833366,
3221                         max_htlc_value_in_flight_msat: 2536655962884945560,
3222                         channel_reserve_satoshis: 3608586615801332854,
3223                         htlc_minimum_msat: 2316138423780173,
3224                         minimum_depth: 821716,
3225                         to_self_delay: 49340,
3226                         max_accepted_htlcs: 49340,
3227                         funding_pubkey: pubkey_1,
3228                         revocation_basepoint: pubkey_2,
3229                         payment_point: pubkey_3,
3230                         delayed_payment_basepoint: pubkey_4,
3231                         htlc_basepoint: pubkey_5,
3232                         first_per_commitment_point: pubkey_6,
3233                         shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3234                         channel_type: None,
3235                         #[cfg(taproot)]
3236                         next_local_nonce: None,
3237                 };
3238                 let encoded_value = accept_channel.encode();
3239                 let mut target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020212345678901234562334032891223698321446687011447600083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap();
3240                 if shutdown {
3241                         target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3242                 }
3243                 assert_eq!(encoded_value, target_value);
3244         }
3245
3246         #[test]
3247         fn encoding_accept_channel() {
3248                 do_encoding_accept_channel(false);
3249                 do_encoding_accept_channel(true);
3250         }
3251
3252         fn do_encoding_accept_channelv2(shutdown: bool) {
3253                 let secp_ctx = Secp256k1::new();
3254                 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3255                 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3256                 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3257                 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3258                 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3259                 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3260                 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3261                 let accept_channelv2 = msgs::AcceptChannelV2 {
3262                         temporary_channel_id: ChannelId::from_bytes([2; 32]),
3263                         funding_satoshis: 1311768467284833366,
3264                         dust_limit_satoshis: 1311768467284833366,
3265                         max_htlc_value_in_flight_msat: 2536655962884945560,
3266                         htlc_minimum_msat: 2316138423780173,
3267                         minimum_depth: 821716,
3268                         to_self_delay: 49340,
3269                         max_accepted_htlcs: 49340,
3270                         funding_pubkey: pubkey_1,
3271                         revocation_basepoint: pubkey_2,
3272                         payment_basepoint: pubkey_3,
3273                         delayed_payment_basepoint: pubkey_4,
3274                         htlc_basepoint: pubkey_5,
3275                         first_per_commitment_point: pubkey_6,
3276                         second_per_commitment_point: pubkey_7,
3277                         shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3278                         channel_type: None,
3279                         require_confirmed_inputs: None,
3280                 };
3281                 let encoded_value = accept_channelv2.encode();
3282                 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // temporary_channel_id
3283                 target_value.append(&mut hex::decode("1234567890123456").unwrap()); // funding_satoshis
3284                 target_value.append(&mut hex::decode("1234567890123456").unwrap()); // dust_limit_satoshis
3285                 target_value.append(&mut hex::decode("2334032891223698").unwrap()); // max_htlc_value_in_flight_msat
3286                 target_value.append(&mut hex::decode("00083a840000034d").unwrap()); // htlc_minimum_msat
3287                 target_value.append(&mut hex::decode("000c89d4").unwrap()); //  minimum_depth
3288                 target_value.append(&mut hex::decode("c0bc").unwrap()); // to_self_delay
3289                 target_value.append(&mut hex::decode("c0bc").unwrap()); // max_accepted_htlcs
3290                 target_value.append(&mut hex::decode("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap()); // funding_pubkey
3291                 target_value.append(&mut hex::decode("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap()); // revocation_basepoint
3292                 target_value.append(&mut hex::decode("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap()); // payment_basepoint
3293                 target_value.append(&mut hex::decode("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap()); // delayed_payment_basepoint
3294                 target_value.append(&mut hex::decode("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap()); // htlc_basepoint
3295                 target_value.append(&mut hex::decode("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap()); // first_per_commitment_point
3296                 target_value.append(&mut hex::decode("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap()); // second_per_commitment_point
3297                 if shutdown {
3298                         target_value.append(&mut hex::decode("001b").unwrap()); // Type 0 + Length 27
3299                         target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3300                 }
3301                 assert_eq!(encoded_value, target_value);
3302         }
3303
3304         #[test]
3305         fn encoding_accept_channelv2() {
3306                 do_encoding_accept_channelv2(false);
3307                 do_encoding_accept_channelv2(true);
3308         }
3309
3310         #[test]
3311         fn encoding_funding_created() {
3312                 let secp_ctx = Secp256k1::new();
3313                 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3314                 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3315                 let funding_created = msgs::FundingCreated {
3316                         temporary_channel_id: ChannelId::from_bytes([2; 32]),
3317                         funding_txid: Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3318                         funding_output_index: 255,
3319                         signature: sig_1,
3320                         #[cfg(taproot)]
3321                         partial_signature_with_nonce: None,
3322                         #[cfg(taproot)]
3323                         next_local_nonce: None,
3324                 };
3325                 let encoded_value = funding_created.encode();
3326                 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202026e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c200ffd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3327                 assert_eq!(encoded_value, target_value);
3328         }
3329
3330         #[test]
3331         fn encoding_funding_signed() {
3332                 let secp_ctx = Secp256k1::new();
3333                 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3334                 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3335                 let funding_signed = msgs::FundingSigned {
3336                         channel_id: ChannelId::from_bytes([2; 32]),
3337                         signature: sig_1,
3338                         #[cfg(taproot)]
3339                         partial_signature_with_nonce: None,
3340                 };
3341                 let encoded_value = funding_signed.encode();
3342                 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3343                 assert_eq!(encoded_value, target_value);
3344         }
3345
3346         #[test]
3347         fn encoding_channel_ready() {
3348                 let secp_ctx = Secp256k1::new();
3349                 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3350                 let channel_ready = msgs::ChannelReady {
3351                         channel_id: ChannelId::from_bytes([2; 32]),
3352                         next_per_commitment_point: pubkey_1,
3353                         short_channel_id_alias: None,
3354                 };
3355                 let encoded_value = channel_ready.encode();
3356                 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3357                 assert_eq!(encoded_value, target_value);
3358         }
3359
3360         #[test]
3361         fn encoding_tx_add_input() {
3362                 let tx_add_input = msgs::TxAddInput {
3363                         channel_id: ChannelId::from_bytes([2; 32]),
3364                         serial_id: 4886718345,
3365                         prevtx: TransactionU16LenLimited::new(Transaction {
3366                                 version: 2,
3367                                 lock_time: PackedLockTime(0),
3368                                 input: vec![TxIn {
3369                                         previous_output: OutPoint { txid: Txid::from_hex("305bab643ee297b8b6b76b320792c8223d55082122cb606bf89382146ced9c77").unwrap(), index: 2 }.into_bitcoin_outpoint(),
3370                                         script_sig: Script::new(),
3371                                         sequence: Sequence(0xfffffffd),
3372                                         witness: Witness::from_vec(vec![
3373                                                 hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3374                                                 hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3375                                 }],
3376                                 output: vec![
3377                                         TxOut {
3378                                                 value: 12704566,
3379                                                 script_pubkey: Address::from_str("bc1qzlffunw52jav8vwdu5x3jfk6sr8u22rmq3xzw2").unwrap().script_pubkey(),
3380                                         },
3381                                         TxOut {
3382                                                 value: 245148,
3383                                                 script_pubkey: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().script_pubkey(),
3384                                         },
3385                                 ],
3386                         }).unwrap(),
3387                         prevtx_out: 305419896,
3388                         sequence: 305419896,
3389                 };
3390                 let encoded_value = tx_add_input.encode();
3391                 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000000012345678900de02000000000101779ced6c148293f86b60cb222108553d22c89207326bb7b6b897e23e64ab5b300200000000fdffffff0236dbc1000000000016001417d29e4dd454bac3b1cde50d1926da80cfc5287b9cbd03000000000016001436ec78d514df462da95e6a00c24daa8915362d420247304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701210301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944000000001234567812345678").unwrap();
3392                 assert_eq!(encoded_value, target_value);
3393         }
3394
3395         #[test]
3396         fn encoding_tx_add_output() {
3397                 let tx_add_output = msgs::TxAddOutput {
3398                         channel_id: ChannelId::from_bytes([2; 32]),
3399                         serial_id: 4886718345,
3400                         sats: 4886718345,
3401                         script: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().script_pubkey(),
3402                 };
3403                 let encoded_value = tx_add_output.encode();
3404                 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000000012345678900000001234567890016001436ec78d514df462da95e6a00c24daa8915362d42").unwrap();
3405                 assert_eq!(encoded_value, target_value);
3406         }
3407
3408         #[test]
3409         fn encoding_tx_remove_input() {
3410                 let tx_remove_input = msgs::TxRemoveInput {
3411                         channel_id: ChannelId::from_bytes([2; 32]),
3412                         serial_id: 4886718345,
3413                 };
3414                 let encoded_value = tx_remove_input.encode();
3415                 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3416                 assert_eq!(encoded_value, target_value);
3417         }
3418
3419         #[test]
3420         fn encoding_tx_remove_output() {
3421                 let tx_remove_output = msgs::TxRemoveOutput {
3422                         channel_id: ChannelId::from_bytes([2; 32]),
3423                         serial_id: 4886718345,
3424                 };
3425                 let encoded_value = tx_remove_output.encode();
3426                 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3427                 assert_eq!(encoded_value, target_value);
3428         }
3429
3430         #[test]
3431         fn encoding_tx_complete() {
3432                 let tx_complete = msgs::TxComplete {
3433                         channel_id: ChannelId::from_bytes([2; 32]),
3434                 };
3435                 let encoded_value = tx_complete.encode();
3436                 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3437                 assert_eq!(encoded_value, target_value);
3438         }
3439
3440         #[test]
3441         fn encoding_tx_signatures() {
3442                 let tx_signatures = msgs::TxSignatures {
3443                         channel_id: ChannelId::from_bytes([2; 32]),
3444                         tx_hash: Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3445                         witnesses: vec![
3446                                 Witness::from_vec(vec![
3447                                         hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3448                                         hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3449                                 Witness::from_vec(vec![
3450                                         hex::decode("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap(),
3451                                         hex::decode("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap()]),
3452                         ],
3453                 };
3454                 let encoded_value = tx_signatures.encode();
3455                 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3456                 target_value.append(&mut hex::decode("6e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c2").unwrap()); // tx_hash (sha256) (big endian byte order)
3457                 target_value.append(&mut hex::decode("0002").unwrap()); // num_witnesses (u16)
3458                 // Witness 1
3459                 target_value.append(&mut hex::decode("006b").unwrap()); // len of witness_data
3460                 target_value.append(&mut hex::decode("02").unwrap()); // num_witness_elements (VarInt)
3461                 target_value.append(&mut hex::decode("47").unwrap()); // len of witness element data (VarInt)
3462                 target_value.append(&mut hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap());
3463                 target_value.append(&mut hex::decode("21").unwrap()); // len of witness element data (VarInt)
3464                 target_value.append(&mut hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap());
3465                 // Witness 2
3466                 target_value.append(&mut hex::decode("006c").unwrap()); // len of witness_data
3467                 target_value.append(&mut hex::decode("02").unwrap()); // num_witness_elements (VarInt)
3468                 target_value.append(&mut hex::decode("48").unwrap()); // len of witness element data (VarInt)
3469                 target_value.append(&mut hex::decode("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap());
3470                 target_value.append(&mut hex::decode("21").unwrap()); // len of witness element data (VarInt)
3471                 target_value.append(&mut hex::decode("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap());
3472                 assert_eq!(encoded_value, target_value);
3473         }
3474
3475         fn do_encoding_tx_init_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3476                 let tx_init_rbf = msgs::TxInitRbf {
3477                         channel_id: ChannelId::from_bytes([2; 32]),
3478                         locktime: 305419896,
3479                         feerate_sat_per_1000_weight: 20190119,
3480                         funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3481                 };
3482                 let encoded_value = tx_init_rbf.encode();
3483                 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3484                 target_value.append(&mut hex::decode("12345678").unwrap()); // locktime
3485                 target_value.append(&mut hex::decode("013413a7").unwrap()); // feerate_sat_per_1000_weight
3486                 if let Some((_, target)) = funding_value_with_hex_target {
3487                         target_value.push(0x00); // Type
3488                         target_value.push(target.len() as u8 / 2); // Length
3489                         target_value.append(&mut hex::decode(target).unwrap()); // Value (i64)
3490                 }
3491                 assert_eq!(encoded_value, target_value);
3492         }
3493
3494         #[test]
3495         fn encoding_tx_init_rbf() {
3496                 do_encoding_tx_init_rbf(Some((1311768467284833366, "1234567890123456")));
3497                 do_encoding_tx_init_rbf(Some((13117684672, "000000030DDFFBC0")));
3498                 do_encoding_tx_init_rbf(None);
3499         }
3500
3501         fn do_encoding_tx_ack_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3502                 let tx_ack_rbf = msgs::TxAckRbf {
3503                         channel_id: ChannelId::from_bytes([2; 32]),
3504                         funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3505                 };
3506                 let encoded_value = tx_ack_rbf.encode();
3507                 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3508                 if let Some((_, target)) = funding_value_with_hex_target {
3509                         target_value.push(0x00); // Type
3510                         target_value.push(target.len() as u8 / 2); // Length
3511                         target_value.append(&mut hex::decode(target).unwrap()); // Value (i64)
3512                 }
3513                 assert_eq!(encoded_value, target_value);
3514         }
3515
3516         #[test]
3517         fn encoding_tx_ack_rbf() {
3518                 do_encoding_tx_ack_rbf(Some((1311768467284833366, "1234567890123456")));
3519                 do_encoding_tx_ack_rbf(Some((13117684672, "000000030DDFFBC0")));
3520                 do_encoding_tx_ack_rbf(None);
3521         }
3522
3523         #[test]
3524         fn encoding_tx_abort() {
3525                 let tx_abort = msgs::TxAbort {
3526                         channel_id: ChannelId::from_bytes([2; 32]),
3527                         data: hex::decode("54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap(),
3528                 };
3529                 let encoded_value = tx_abort.encode();
3530                 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202002C54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap();
3531                 assert_eq!(encoded_value, target_value);
3532         }
3533
3534         fn do_encoding_shutdown(script_type: u8) {
3535                 let secp_ctx = Secp256k1::new();
3536                 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3537                 let script = Builder::new().push_opcode(opcodes::OP_TRUE).into_script();
3538                 let shutdown = msgs::Shutdown {
3539                         channel_id: ChannelId::from_bytes([2; 32]),
3540                         scriptpubkey:
3541                                 if script_type == 1 { Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey() }
3542                                 else if script_type == 2 { Address::p2sh(&script, Network::Testnet).unwrap().script_pubkey() }
3543                                 else if script_type == 3 { Address::p2wpkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).unwrap().script_pubkey() }
3544                                 else { Address::p2wsh(&script, Network::Testnet).script_pubkey() },
3545                 };
3546                 let encoded_value = shutdown.encode();
3547                 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3548                 if script_type == 1 {
3549                         target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3550                 } else if script_type == 2 {
3551                         target_value.append(&mut hex::decode("0017a914da1745e9b549bd0bfa1a569971c77eba30cd5a4b87").unwrap());
3552                 } else if script_type == 3 {
3553                         target_value.append(&mut hex::decode("0016001479b000887626b294a914501a4cd226b58b235983").unwrap());
3554                 } else if script_type == 4 {
3555                         target_value.append(&mut hex::decode("002200204ae81572f06e1b88fd5ced7a1a000945432e83e1551e6f721ee9c00b8cc33260").unwrap());
3556                 }
3557                 assert_eq!(encoded_value, target_value);
3558         }
3559
3560         #[test]
3561         fn encoding_shutdown() {
3562                 do_encoding_shutdown(1);
3563                 do_encoding_shutdown(2);
3564                 do_encoding_shutdown(3);
3565                 do_encoding_shutdown(4);
3566         }
3567
3568         #[test]
3569         fn encoding_closing_signed() {
3570                 let secp_ctx = Secp256k1::new();
3571                 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3572                 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3573                 let closing_signed = msgs::ClosingSigned {
3574                         channel_id: ChannelId::from_bytes([2; 32]),
3575                         fee_satoshis: 2316138423780173,
3576                         signature: sig_1,
3577                         fee_range: None,
3578                 };
3579                 let encoded_value = closing_signed.encode();
3580                 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3581                 assert_eq!(encoded_value, target_value);
3582                 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value)).unwrap(), closing_signed);
3583
3584                 let closing_signed_with_range = msgs::ClosingSigned {
3585                         channel_id: ChannelId::from_bytes([2; 32]),
3586                         fee_satoshis: 2316138423780173,
3587                         signature: sig_1,
3588                         fee_range: Some(msgs::ClosingSignedFeeRange {
3589                                 min_fee_satoshis: 0xdeadbeef,
3590                                 max_fee_satoshis: 0x1badcafe01234567,
3591                         }),
3592                 };
3593                 let encoded_value_with_range = closing_signed_with_range.encode();
3594                 let target_value_with_range = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a011000000000deadbeef1badcafe01234567").unwrap();
3595                 assert_eq!(encoded_value_with_range, target_value_with_range);
3596                 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value_with_range)).unwrap(),
3597                         closing_signed_with_range);
3598         }
3599
3600         #[test]
3601         fn encoding_update_add_htlc() {
3602                 let secp_ctx = Secp256k1::new();
3603                 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3604                 let onion_routing_packet = msgs::OnionPacket {
3605                         version: 255,
3606                         public_key: Ok(pubkey_1),
3607                         hop_data: [1; 20*65],
3608                         hmac: [2; 32]
3609                 };
3610                 let update_add_htlc = msgs::UpdateAddHTLC {
3611                         channel_id: ChannelId::from_bytes([2; 32]),
3612                         htlc_id: 2316138423780173,
3613                         amount_msat: 3608586615801332854,
3614                         payment_hash: PaymentHash([1; 32]),
3615                         cltv_expiry: 821716,
3616                         onion_routing_packet,
3617                         skimmed_fee_msat: None,
3618                 };
3619                 let encoded_value = update_add_htlc.encode();
3620                 let target_value = hex::decode("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").unwrap();
3621                 assert_eq!(encoded_value, target_value);
3622         }
3623
3624         #[test]
3625         fn encoding_update_fulfill_htlc() {
3626                 let update_fulfill_htlc = msgs::UpdateFulfillHTLC {
3627                         channel_id: ChannelId::from_bytes([2; 32]),
3628                         htlc_id: 2316138423780173,
3629                         payment_preimage: PaymentPreimage([1; 32]),
3630                 };
3631                 let encoded_value = update_fulfill_htlc.encode();
3632                 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d0101010101010101010101010101010101010101010101010101010101010101").unwrap();
3633                 assert_eq!(encoded_value, target_value);
3634         }
3635
3636         #[test]
3637         fn encoding_update_fail_htlc() {
3638                 let reason = OnionErrorPacket {
3639                         data: [1; 32].to_vec(),
3640                 };
3641                 let update_fail_htlc = msgs::UpdateFailHTLC {
3642                         channel_id: ChannelId::from_bytes([2; 32]),
3643                         htlc_id: 2316138423780173,
3644                         reason
3645                 };
3646                 let encoded_value = update_fail_htlc.encode();
3647                 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d00200101010101010101010101010101010101010101010101010101010101010101").unwrap();
3648                 assert_eq!(encoded_value, target_value);
3649         }
3650
3651         #[test]
3652         fn encoding_update_fail_malformed_htlc() {
3653                 let update_fail_malformed_htlc = msgs::UpdateFailMalformedHTLC {
3654                         channel_id: ChannelId::from_bytes([2; 32]),
3655                         htlc_id: 2316138423780173,
3656                         sha256_of_onion: [1; 32],
3657                         failure_code: 255
3658                 };
3659                 let encoded_value = update_fail_malformed_htlc.encode();
3660                 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d010101010101010101010101010101010101010101010101010101010101010100ff").unwrap();
3661                 assert_eq!(encoded_value, target_value);
3662         }
3663
3664         fn do_encoding_commitment_signed(htlcs: bool) {
3665                 let secp_ctx = Secp256k1::new();
3666                 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3667                 let (privkey_2, _) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3668                 let (privkey_3, _) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3669                 let (privkey_4, _) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3670                 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3671                 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
3672                 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
3673                 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
3674                 let commitment_signed = msgs::CommitmentSigned {
3675                         channel_id: ChannelId::from_bytes([2; 32]),
3676                         signature: sig_1,
3677                         htlc_signatures: if htlcs { vec![sig_2, sig_3, sig_4] } else { Vec::new() },
3678                         #[cfg(taproot)]
3679                         partial_signature_with_nonce: None,
3680                 };
3681                 let encoded_value = commitment_signed.encode();
3682                 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3683                 if htlcs {
3684                         target_value.append(&mut hex::decode("00031735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
3685                 } else {
3686                         target_value.append(&mut hex::decode("0000").unwrap());
3687                 }
3688                 assert_eq!(encoded_value, target_value);
3689         }
3690
3691         #[test]
3692         fn encoding_commitment_signed() {
3693                 do_encoding_commitment_signed(true);
3694                 do_encoding_commitment_signed(false);
3695         }
3696
3697         #[test]
3698         fn encoding_revoke_and_ack() {
3699                 let secp_ctx = Secp256k1::new();
3700                 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3701                 let raa = msgs::RevokeAndACK {
3702                         channel_id: ChannelId::from_bytes([2; 32]),
3703                         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],
3704                         next_per_commitment_point: pubkey_1,
3705                         #[cfg(taproot)]
3706                         next_local_nonce: None,
3707                 };
3708                 let encoded_value = raa.encode();
3709                 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020101010101010101010101010101010101010101010101010101010101010101031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3710                 assert_eq!(encoded_value, target_value);
3711         }
3712
3713         #[test]
3714         fn encoding_update_fee() {
3715                 let update_fee = msgs::UpdateFee {
3716                         channel_id: ChannelId::from_bytes([2; 32]),
3717                         feerate_per_kw: 20190119,
3718                 };
3719                 let encoded_value = update_fee.encode();
3720                 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202013413a7").unwrap();
3721                 assert_eq!(encoded_value, target_value);
3722         }
3723
3724         #[test]
3725         fn encoding_init() {
3726                 let mainnet_hash = ChainHash::using_genesis_block(Network::Bitcoin);
3727                 assert_eq!(msgs::Init {
3728                         features: InitFeatures::from_le_bytes(vec![0xFF, 0xFF, 0xFF]),
3729                         networks: Some(vec![mainnet_hash]),
3730                         remote_network_address: None,
3731                 }.encode(), hex::decode("00023fff0003ffffff01206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3732                 assert_eq!(msgs::Init {
3733                         features: InitFeatures::from_le_bytes(vec![0xFF]),
3734                         networks: None,
3735                         remote_network_address: None,
3736                 }.encode(), hex::decode("0001ff0001ff").unwrap());
3737                 assert_eq!(msgs::Init {
3738                         features: InitFeatures::from_le_bytes(vec![]),
3739                         networks: Some(vec![mainnet_hash]),
3740                         remote_network_address: None,
3741                 }.encode(), hex::decode("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3742                 assert_eq!(msgs::Init {
3743                         features: InitFeatures::from_le_bytes(vec![]),
3744                         networks: Some(vec![ChainHash::from(&[1; 32][..]), ChainHash::from(&[2; 32][..])]),
3745                         remote_network_address: None,
3746                 }.encode(), hex::decode("00000000014001010101010101010101010101010101010101010101010101010101010101010202020202020202020202020202020202020202020202020202020202020202").unwrap());
3747                 let init_msg = msgs::Init { features: InitFeatures::from_le_bytes(vec![]),
3748                         networks: Some(vec![mainnet_hash]),
3749                         remote_network_address: Some(SocketAddress::TcpIpV4 {
3750                                 addr: [127, 0, 0, 1],
3751                                 port: 1000,
3752                         }),
3753                 };
3754                 let encoded_value = init_msg.encode();
3755                 let target_value = hex::decode("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d61900000000000307017f00000103e8").unwrap();
3756                 assert_eq!(encoded_value, target_value);
3757                 assert_eq!(msgs::Init::read(&mut Cursor::new(&target_value)).unwrap(), init_msg);
3758         }
3759
3760         #[test]
3761         fn encoding_error() {
3762                 let error = msgs::ErrorMessage {
3763                         channel_id: ChannelId::from_bytes([2; 32]),
3764                         data: String::from("rust-lightning"),
3765                 };
3766                 let encoded_value = error.encode();
3767                 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3768                 assert_eq!(encoded_value, target_value);
3769         }
3770
3771         #[test]
3772         fn encoding_warning() {
3773                 let error = msgs::WarningMessage {
3774                         channel_id: ChannelId::from_bytes([2; 32]),
3775                         data: String::from("rust-lightning"),
3776                 };
3777                 let encoded_value = error.encode();
3778                 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3779                 assert_eq!(encoded_value, target_value);
3780         }
3781
3782         #[test]
3783         fn encoding_ping() {
3784                 let ping = msgs::Ping {
3785                         ponglen: 64,
3786                         byteslen: 64
3787                 };
3788                 let encoded_value = ping.encode();
3789                 let target_value = hex::decode("0040004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3790                 assert_eq!(encoded_value, target_value);
3791         }
3792
3793         #[test]
3794         fn encoding_pong() {
3795                 let pong = msgs::Pong {
3796                         byteslen: 64
3797                 };
3798                 let encoded_value = pong.encode();
3799                 let target_value = hex::decode("004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3800                 assert_eq!(encoded_value, target_value);
3801         }
3802
3803         #[test]
3804         fn encoding_nonfinal_onion_hop_data() {
3805                 let outbound_msg = msgs::OutboundOnionPayload::Forward {
3806                         short_channel_id: 0xdeadbeef1bad1dea,
3807                         amt_to_forward: 0x0badf00d01020304,
3808                         outgoing_cltv_value: 0xffffffff,
3809                 };
3810                 let encoded_value = outbound_msg.encode();
3811                 let target_value = hex::decode("1a02080badf00d010203040404ffffffff0608deadbeef1bad1dea").unwrap();
3812                 assert_eq!(encoded_value, target_value);
3813
3814                 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3815                 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
3816                 if let msgs::InboundOnionPayload::Forward {
3817                         short_channel_id, amt_to_forward, outgoing_cltv_value
3818                 } = inbound_msg {
3819                         assert_eq!(short_channel_id, 0xdeadbeef1bad1dea);
3820                         assert_eq!(amt_to_forward, 0x0badf00d01020304);
3821                         assert_eq!(outgoing_cltv_value, 0xffffffff);
3822                 } else { panic!(); }
3823         }
3824
3825         #[test]
3826         fn encoding_final_onion_hop_data() {
3827                 let outbound_msg = msgs::OutboundOnionPayload::Receive {
3828                         payment_data: None,
3829                         payment_metadata: None,
3830                         keysend_preimage: None,
3831                         amt_msat: 0x0badf00d01020304,
3832                         outgoing_cltv_value: 0xffffffff,
3833                         custom_tlvs: vec![],
3834                 };
3835                 let encoded_value = outbound_msg.encode();
3836                 let target_value = hex::decode("1002080badf00d010203040404ffffffff").unwrap();
3837                 assert_eq!(encoded_value, target_value);
3838
3839                 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3840                 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
3841                 if let msgs::InboundOnionPayload::Receive {
3842                         payment_data: None, amt_msat, outgoing_cltv_value, ..
3843                 } = inbound_msg {
3844                         assert_eq!(amt_msat, 0x0badf00d01020304);
3845                         assert_eq!(outgoing_cltv_value, 0xffffffff);
3846                 } else { panic!(); }
3847         }
3848
3849         #[test]
3850         fn encoding_final_onion_hop_data_with_secret() {
3851                 let expected_payment_secret = PaymentSecret([0x42u8; 32]);
3852                 let outbound_msg = msgs::OutboundOnionPayload::Receive {
3853                         payment_data: Some(FinalOnionHopData {
3854                                 payment_secret: expected_payment_secret,
3855                                 total_msat: 0x1badca1f
3856                         }),
3857                         payment_metadata: None,
3858                         keysend_preimage: None,
3859                         amt_msat: 0x0badf00d01020304,
3860                         outgoing_cltv_value: 0xffffffff,
3861                         custom_tlvs: vec![],
3862                 };
3863                 let encoded_value = outbound_msg.encode();
3864                 let target_value = hex::decode("3602080badf00d010203040404ffffffff082442424242424242424242424242424242424242424242424242424242424242421badca1f").unwrap();
3865                 assert_eq!(encoded_value, target_value);
3866
3867                 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3868                 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
3869                 if let msgs::InboundOnionPayload::Receive {
3870                         payment_data: Some(FinalOnionHopData {
3871                                 payment_secret,
3872                                 total_msat: 0x1badca1f
3873                         }),
3874                         amt_msat, outgoing_cltv_value,
3875                         payment_metadata: None,
3876                         keysend_preimage: None,
3877                         custom_tlvs,
3878                 } = inbound_msg  {
3879                         assert_eq!(payment_secret, expected_payment_secret);
3880                         assert_eq!(amt_msat, 0x0badf00d01020304);
3881                         assert_eq!(outgoing_cltv_value, 0xffffffff);
3882                         assert_eq!(custom_tlvs, vec![]);
3883                 } else { panic!(); }
3884         }
3885
3886         #[test]
3887         fn encoding_final_onion_hop_data_with_bad_custom_tlvs() {
3888                 // If custom TLVs have type number within the range reserved for protocol, treat them as if
3889                 // they're unknown
3890                 let bad_type_range_tlvs = vec![
3891                         ((1 << 16) - 4, vec![42]),
3892                         ((1 << 16) - 2, vec![42; 32]),
3893                 ];
3894                 let mut msg = msgs::OutboundOnionPayload::Receive {
3895                         payment_data: None,
3896                         payment_metadata: None,
3897                         keysend_preimage: None,
3898                         custom_tlvs: bad_type_range_tlvs,
3899                         amt_msat: 0x0badf00d01020304,
3900                         outgoing_cltv_value: 0xffffffff,
3901                 };
3902                 let encoded_value = msg.encode();
3903                 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3904                 assert!(msgs::InboundOnionPayload::read(&mut Cursor::new(&encoded_value[..]), &&node_signer).is_err());
3905                 let good_type_range_tlvs = vec![
3906                         ((1 << 16) - 3, vec![42]),
3907                         ((1 << 16) - 1, vec![42; 32]),
3908                 ];
3909                 if let msgs::OutboundOnionPayload::Receive { ref mut custom_tlvs, .. } = msg {
3910                         *custom_tlvs = good_type_range_tlvs.clone();
3911                 }
3912                 let encoded_value = msg.encode();
3913                 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&encoded_value[..]), &&node_signer).unwrap();
3914                 match inbound_msg {
3915                         msgs::InboundOnionPayload::Receive { custom_tlvs, .. } => assert!(custom_tlvs.is_empty()),
3916                         _ => panic!(),
3917                 }
3918         }
3919
3920         #[test]
3921         fn encoding_final_onion_hop_data_with_custom_tlvs() {
3922                 let expected_custom_tlvs = vec![
3923                         (5482373483, vec![0x12, 0x34]),
3924                         (5482373487, vec![0x42u8; 8]),
3925                 ];
3926                 let msg = msgs::OutboundOnionPayload::Receive {
3927                         payment_data: None,
3928                         payment_metadata: None,
3929                         keysend_preimage: None,
3930                         custom_tlvs: expected_custom_tlvs.clone(),
3931                         amt_msat: 0x0badf00d01020304,
3932                         outgoing_cltv_value: 0xffffffff,
3933                 };
3934                 let encoded_value = msg.encode();
3935                 let target_value = hex::decode("2e02080badf00d010203040404ffffffffff0000000146c6616b021234ff0000000146c6616f084242424242424242").unwrap();
3936                 assert_eq!(encoded_value, target_value);
3937                 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3938                 let inbound_msg: msgs::InboundOnionPayload = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
3939                 if let msgs::InboundOnionPayload::Receive {
3940                         payment_data: None,
3941                         payment_metadata: None,
3942                         keysend_preimage: None,
3943                         custom_tlvs,
3944                         amt_msat,
3945                         outgoing_cltv_value,
3946                         ..
3947                 } = inbound_msg {
3948                         assert_eq!(custom_tlvs, expected_custom_tlvs);
3949                         assert_eq!(amt_msat, 0x0badf00d01020304);
3950                         assert_eq!(outgoing_cltv_value, 0xffffffff);
3951                 } else { panic!(); }
3952         }
3953
3954         #[test]
3955         fn query_channel_range_end_blocknum() {
3956                 let tests: Vec<(u32, u32, u32)> = vec![
3957                         (10000, 1500, 11500),
3958                         (0, 0xffffffff, 0xffffffff),
3959                         (1, 0xffffffff, 0xffffffff),
3960                 ];
3961
3962                 for (first_blocknum, number_of_blocks, expected) in tests.into_iter() {
3963                         let sut = msgs::QueryChannelRange {
3964                                 chain_hash: ChainHash::using_genesis_block(Network::Regtest),
3965                                 first_blocknum,
3966                                 number_of_blocks,
3967                         };
3968                         assert_eq!(sut.end_blocknum(), expected);
3969                 }
3970         }
3971
3972         #[test]
3973         fn encoding_query_channel_range() {
3974                 let mut query_channel_range = msgs::QueryChannelRange {
3975                         chain_hash: ChainHash::using_genesis_block(Network::Regtest),
3976                         first_blocknum: 100000,
3977                         number_of_blocks: 1500,
3978                 };
3979                 let encoded_value = query_channel_range.encode();
3980                 let target_value = hex::decode("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000186a0000005dc").unwrap();
3981                 assert_eq!(encoded_value, target_value);
3982
3983                 query_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3984                 assert_eq!(query_channel_range.first_blocknum, 100000);
3985                 assert_eq!(query_channel_range.number_of_blocks, 1500);
3986         }
3987
3988         #[test]
3989         fn encoding_reply_channel_range() {
3990                 do_encoding_reply_channel_range(0);
3991                 do_encoding_reply_channel_range(1);
3992         }
3993
3994         fn do_encoding_reply_channel_range(encoding_type: u8) {
3995                 let mut target_value = hex::decode("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000b8a06000005dc01").unwrap();
3996                 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
3997                 let mut reply_channel_range = msgs::ReplyChannelRange {
3998                         chain_hash: expected_chain_hash,
3999                         first_blocknum: 756230,
4000                         number_of_blocks: 1500,
4001                         sync_complete: true,
4002                         short_channel_ids: vec![0x000000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
4003                 };
4004
4005                 if encoding_type == 0 {
4006                         target_value.append(&mut hex::decode("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
4007                         let encoded_value = reply_channel_range.encode();
4008                         assert_eq!(encoded_value, target_value);
4009
4010                         reply_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4011                         assert_eq!(reply_channel_range.chain_hash, expected_chain_hash);
4012                         assert_eq!(reply_channel_range.first_blocknum, 756230);
4013                         assert_eq!(reply_channel_range.number_of_blocks, 1500);
4014                         assert_eq!(reply_channel_range.sync_complete, true);
4015                         assert_eq!(reply_channel_range.short_channel_ids[0], 0x000000000000008e);
4016                         assert_eq!(reply_channel_range.short_channel_ids[1], 0x0000000000003c69);
4017                         assert_eq!(reply_channel_range.short_channel_ids[2], 0x000000000045a6c4);
4018                 } else {
4019                         target_value.append(&mut hex::decode("001601789c636000833e08659309a65878be010010a9023a").unwrap());
4020                         let result: Result<msgs::ReplyChannelRange, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
4021                         assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
4022                 }
4023         }
4024
4025         #[test]
4026         fn encoding_query_short_channel_ids() {
4027                 do_encoding_query_short_channel_ids(0);
4028                 do_encoding_query_short_channel_ids(1);
4029         }
4030
4031         fn do_encoding_query_short_channel_ids(encoding_type: u8) {
4032                 let mut target_value = hex::decode("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
4033                 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4034                 let mut query_short_channel_ids = msgs::QueryShortChannelIds {
4035                         chain_hash: expected_chain_hash,
4036                         short_channel_ids: vec![0x0000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
4037                 };
4038
4039                 if encoding_type == 0 {
4040                         target_value.append(&mut hex::decode("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
4041                         let encoded_value = query_short_channel_ids.encode();
4042                         assert_eq!(encoded_value, target_value);
4043
4044                         query_short_channel_ids = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4045                         assert_eq!(query_short_channel_ids.chain_hash, expected_chain_hash);
4046                         assert_eq!(query_short_channel_ids.short_channel_ids[0], 0x000000000000008e);
4047                         assert_eq!(query_short_channel_ids.short_channel_ids[1], 0x0000000000003c69);
4048                         assert_eq!(query_short_channel_ids.short_channel_ids[2], 0x000000000045a6c4);
4049                 } else {
4050                         target_value.append(&mut hex::decode("001601789c636000833e08659309a65878be010010a9023a").unwrap());
4051                         let result: Result<msgs::QueryShortChannelIds, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
4052                         assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
4053                 }
4054         }
4055
4056         #[test]
4057         fn encoding_reply_short_channel_ids_end() {
4058                 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4059                 let mut reply_short_channel_ids_end = msgs::ReplyShortChannelIdsEnd {
4060                         chain_hash: expected_chain_hash,
4061                         full_information: true,
4062                 };
4063                 let encoded_value = reply_short_channel_ids_end.encode();
4064                 let target_value = hex::decode("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f01").unwrap();
4065                 assert_eq!(encoded_value, target_value);
4066
4067                 reply_short_channel_ids_end = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4068                 assert_eq!(reply_short_channel_ids_end.chain_hash, expected_chain_hash);
4069                 assert_eq!(reply_short_channel_ids_end.full_information, true);
4070         }
4071
4072         #[test]
4073         fn encoding_gossip_timestamp_filter(){
4074                 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4075                 let mut gossip_timestamp_filter = msgs::GossipTimestampFilter {
4076                         chain_hash: expected_chain_hash,
4077                         first_timestamp: 1590000000,
4078                         timestamp_range: 0xffff_ffff,
4079                 };
4080                 let encoded_value = gossip_timestamp_filter.encode();
4081                 let target_value = hex::decode("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f5ec57980ffffffff").unwrap();
4082                 assert_eq!(encoded_value, target_value);
4083
4084                 gossip_timestamp_filter = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4085                 assert_eq!(gossip_timestamp_filter.chain_hash, expected_chain_hash);
4086                 assert_eq!(gossip_timestamp_filter.first_timestamp, 1590000000);
4087                 assert_eq!(gossip_timestamp_filter.timestamp_range, 0xffff_ffff);
4088         }
4089
4090         #[test]
4091         fn decode_onion_hop_data_len_as_bigsize() {
4092                 // Tests that we can decode an onion payload that is >253 bytes.
4093                 // Previously, receiving a payload of this size could've caused us to fail to decode a valid
4094                 // payload, because we were decoding the length (a BigSize, big-endian) as a VarInt
4095                 // (little-endian).
4096
4097                 // Encode a test onion payload with a big custom TLV such that it's >253 bytes, forcing the
4098                 // payload length to be encoded over multiple bytes rather than a single u8.
4099                 let big_payload = encode_big_payload().unwrap();
4100                 let mut rd = Cursor::new(&big_payload[..]);
4101
4102                 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4103                 <msgs::InboundOnionPayload as ReadableArgs<&&test_utils::TestKeysInterface>>
4104                         ::read(&mut rd, &&node_signer).unwrap();
4105         }
4106         // see above test, needs to be a separate method for use of the serialization macros.
4107         fn encode_big_payload() -> Result<Vec<u8>, io::Error> {
4108                 use crate::util::ser::HighZeroBytesDroppedBigSize;
4109                 let payload = msgs::OutboundOnionPayload::Forward {
4110                         short_channel_id: 0xdeadbeef1bad1dea,
4111                         amt_to_forward: 1000,
4112                         outgoing_cltv_value: 0xffffffff,
4113                 };
4114                 let mut encoded_payload = Vec::new();
4115                 let test_bytes = vec![42u8; 1000];
4116                 if let msgs::OutboundOnionPayload::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } = payload {
4117                         _encode_varint_length_prefixed_tlv!(&mut encoded_payload, {
4118                                 (1, test_bytes, required_vec),
4119                                 (2, HighZeroBytesDroppedBigSize(amt_to_forward), required),
4120                                 (4, HighZeroBytesDroppedBigSize(outgoing_cltv_value), required),
4121                                 (6, short_channel_id, required)
4122                         });
4123                 }
4124                 Ok(encoded_payload)
4125         }
4126
4127         #[test]
4128         #[cfg(feature = "std")]
4129         fn test_socket_address_from_str() {
4130                 let tcpip_v4 = SocketAddress::TcpIpV4 {
4131                         addr: Ipv4Addr::new(127, 0, 0, 1).octets(),
4132                         port: 1234,
4133                 };
4134                 assert_eq!(tcpip_v4, SocketAddress::from_str("127.0.0.1:1234").unwrap());
4135                 assert_eq!(tcpip_v4, SocketAddress::from_str(&tcpip_v4.to_string()).unwrap());
4136
4137                 let tcpip_v6 = SocketAddress::TcpIpV6 {
4138                         addr: Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1).octets(),
4139                         port: 1234,
4140                 };
4141                 assert_eq!(tcpip_v6, SocketAddress::from_str("[0:0:0:0:0:0:0:1]:1234").unwrap());
4142                 assert_eq!(tcpip_v6, SocketAddress::from_str(&tcpip_v6.to_string()).unwrap());
4143
4144                 let hostname = SocketAddress::Hostname {
4145                                 hostname: Hostname::try_from("lightning-node.mydomain.com".to_string()).unwrap(),
4146                                 port: 1234,
4147                 };
4148                 assert_eq!(hostname, SocketAddress::from_str("lightning-node.mydomain.com:1234").unwrap());
4149                 assert_eq!(hostname, SocketAddress::from_str(&hostname.to_string()).unwrap());
4150
4151                 let onion_v2 = SocketAddress::OnionV2 ([40, 4, 64, 185, 202, 19, 162, 75, 90, 200, 38, 7],);
4152                 assert_eq!("OnionV2([40, 4, 64, 185, 202, 19, 162, 75, 90, 200, 38, 7])", &onion_v2.to_string());
4153                 assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("FACEBOOKCOREWWWI.onion:9735"));
4154
4155                 let onion_v3 = SocketAddress::OnionV3 {
4156                         ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102, 182, 107, 4, 105, 247, 246, 85,
4157                         111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31, 33, 71, 3],
4158                         checksum: 48326,
4159                         version: 121,
4160                         port: 1234
4161                 };
4162                 assert_eq!(onion_v3, SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion:1234").unwrap());
4163                 assert_eq!(onion_v3, SocketAddress::from_str(&onion_v3.to_string()).unwrap());
4164
4165                 assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6.onion:1234"));
4166                 assert_eq!(Err(SocketAddressParseError::InvalidInput), SocketAddress::from_str("127.0.0.1@1234"));
4167                 assert_eq!(Err(SocketAddressParseError::InvalidInput), "".parse::<SocketAddress>());
4168                 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:9735:94").is_err());
4169                 assert!(SocketAddress::from_str("wrong$%#.com:1234").is_err());
4170                 assert_eq!(Err(SocketAddressParseError::InvalidPort), SocketAddress::from_str("example.com:wrong"));
4171                 assert!("localhost".parse::<SocketAddress>().is_err());
4172                 assert!("localhost:invalid-port".parse::<SocketAddress>().is_err());
4173                 assert!( "invalid-onion-v3-hostname.onion:8080".parse::<SocketAddress>().is_err());
4174                 assert!("b32.example.onion:invalid-port".parse::<SocketAddress>().is_err());
4175                 assert!("invalid-address".parse::<SocketAddress>().is_err());
4176                 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:1234").is_err());
4177         }
4178
4179         #[test]
4180         #[cfg(feature = "std")]
4181         fn test_socket_address_to_socket_addrs() {
4182                 assert_eq!(SocketAddress::TcpIpV4 {addr:[0u8; 4], port: 1337,}.to_socket_addrs().unwrap().next().unwrap(),
4183                                    SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(0,0,0,0), 1337)));
4184                 assert_eq!(SocketAddress::TcpIpV6 {addr:[0u8; 16], port: 1337,}.to_socket_addrs().unwrap().next().unwrap(),
4185                                    SocketAddr::V6(SocketAddrV6::new(Ipv6Addr::from([0u8; 16]), 1337, 0, 0)));
4186                 assert_eq!(SocketAddress::Hostname { hostname: Hostname::try_from("0.0.0.0".to_string()).unwrap(), port: 0 }
4187                                            .to_socket_addrs().unwrap().next().unwrap(), SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::from([0u8; 4]),0)));
4188                 assert!(SocketAddress::OnionV2([0u8; 12]).to_socket_addrs().is_err());
4189                 assert!(SocketAddress::OnionV3{ ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102,
4190                         182, 107, 4, 105, 247, 246, 85, 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31,
4191                         33, 71, 3],
4192                         checksum: 48326,
4193                         version: 121,
4194                         port: 1234 }.to_socket_addrs().is_err());
4195         }
4196 }