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

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