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