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