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