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

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