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