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

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