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

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