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