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