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