_ 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::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 #[derive(Clone)]
1672 #[cfg_attr(test, derive(Debug, PartialEq))]
1673 /// Information communicated in the onion to the recipient for multi-part tracking and proof that
1674 /// the payment is associated with an invoice.
1675 pub struct FinalOnionHopData {
1676         /// When sending a multi-part payment, this secret is used to identify a payment across HTLCs.
1677         /// Because it is generated by the recipient and included in the invoice, it also provides
1678         /// proof to the recipient that the payment was sent by someone with the generated invoice.
1679         pub payment_secret: PaymentSecret,
1680         /// The intended total amount that this payment is for.
1681         ///
1682         /// Message serialization may panic if this value is more than 21 million Bitcoin.
1683         pub total_msat: u64,
1684 }
1685
1686 mod fuzzy_internal_msgs {
1687         use bitcoin::secp256k1::PublicKey;
1688         use crate::blinded_path::payment::{PaymentConstraints, PaymentRelay};
1689         use crate::prelude::*;
1690         use crate::ln::{PaymentPreimage, PaymentSecret};
1691         use crate::ln::features::BlindedHopFeatures;
1692         use super::FinalOnionHopData;
1693
1694         // These types aren't intended to be pub, but are exposed for direct fuzzing (as we deserialize
1695         // them from untrusted input):
1696
1697         pub enum InboundOnionPayload {
1698                 Forward {
1699                         short_channel_id: u64,
1700                         /// The value, in msat, of the payment after this hop's fee is deducted.
1701                         amt_to_forward: u64,
1702                         outgoing_cltv_value: u32,
1703                 },
1704                 Receive {
1705                         payment_data: Option<FinalOnionHopData>,
1706                         payment_metadata: Option<Vec<u8>>,
1707                         keysend_preimage: Option<PaymentPreimage>,
1708                         custom_tlvs: Vec<(u64, Vec<u8>)>,
1709                         sender_intended_htlc_amt_msat: u64,
1710                         cltv_expiry_height: u32,
1711                 },
1712                 BlindedForward {
1713                         short_channel_id: u64,
1714                         payment_relay: PaymentRelay,
1715                         payment_constraints: PaymentConstraints,
1716                         features: BlindedHopFeatures,
1717                         intro_node_blinding_point: PublicKey,
1718                 },
1719                 BlindedReceive {
1720                         sender_intended_htlc_amt_msat: u64,
1721                         total_msat: u64,
1722                         cltv_expiry_height: u32,
1723                         payment_secret: PaymentSecret,
1724                         payment_constraints: PaymentConstraints,
1725                         intro_node_blinding_point: Option<PublicKey>,
1726                 }
1727         }
1728
1729         pub(crate) enum OutboundOnionPayload {
1730                 Forward {
1731                         short_channel_id: u64,
1732                         /// The value, in msat, of the payment after this hop's fee is deducted.
1733                         amt_to_forward: u64,
1734                         outgoing_cltv_value: u32,
1735                 },
1736                 Receive {
1737                         payment_data: Option<FinalOnionHopData>,
1738                         payment_metadata: Option<Vec<u8>>,
1739                         keysend_preimage: Option<PaymentPreimage>,
1740                         custom_tlvs: Vec<(u64, Vec<u8>)>,
1741                         sender_intended_htlc_amt_msat: u64,
1742                         cltv_expiry_height: u32,
1743                 },
1744                 BlindedForward {
1745                         encrypted_tlvs: Vec<u8>,
1746                         intro_node_blinding_point: Option<PublicKey>,
1747                 },
1748                 BlindedReceive {
1749                         sender_intended_htlc_amt_msat: u64,
1750                         total_msat: u64,
1751                         cltv_expiry_height: u32,
1752                         encrypted_tlvs: Vec<u8>,
1753                         intro_node_blinding_point: Option<PublicKey>, // Set if the introduction node of the blinded path is the final node
1754                 }
1755         }
1756
1757         pub struct DecodedOnionErrorPacket {
1758                 pub(crate) hmac: [u8; 32],
1759                 pub(crate) failuremsg: Vec<u8>,
1760                 pub(crate) pad: Vec<u8>,
1761         }
1762 }
1763 #[cfg(fuzzing)]
1764 pub use self::fuzzy_internal_msgs::*;
1765 #[cfg(not(fuzzing))]
1766 pub(crate) use self::fuzzy_internal_msgs::*;
1767
1768 /// BOLT 4 onion packet including hop data for the next peer.
1769 #[derive(Clone, Hash, PartialEq, Eq)]
1770 pub struct OnionPacket {
1771         /// BOLT 4 version number.
1772         pub version: u8,
1773         /// In order to ensure we always return an error on onion decode in compliance with [BOLT
1774         /// #4](https://github.com/lightning/bolts/blob/master/04-onion-routing.md), we have to
1775         /// deserialize `OnionPacket`s contained in [`UpdateAddHTLC`] messages even if the ephemeral
1776         /// public key (here) is bogus, so we hold a [`Result`] instead of a [`PublicKey`] as we'd
1777         /// like.
1778         pub public_key: Result<PublicKey, secp256k1::Error>,
1779         /// 1300 bytes encrypted payload for the next hop.
1780         pub hop_data: [u8; 20*65],
1781         /// HMAC to verify the integrity of hop_data.
1782         pub hmac: [u8; 32],
1783 }
1784
1785 impl onion_utils::Packet for OnionPacket {
1786         type Data = onion_utils::FixedSizeOnionPacket;
1787         fn new(pubkey: PublicKey, hop_data: onion_utils::FixedSizeOnionPacket, hmac: [u8; 32]) -> Self {
1788                 Self {
1789                         version: 0,
1790                         public_key: Ok(pubkey),
1791                         hop_data: hop_data.0,
1792                         hmac,
1793                 }
1794         }
1795 }
1796
1797 impl fmt::Debug for OnionPacket {
1798         fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1799                 f.write_fmt(format_args!("OnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
1800         }
1801 }
1802
1803 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1804 pub(crate) struct OnionErrorPacket {
1805         // This really should be a constant size slice, but the spec lets these things be up to 128KB?
1806         // (TODO) We limit it in decode to much lower...
1807         pub(crate) data: Vec<u8>,
1808 }
1809
1810 impl fmt::Display for DecodeError {
1811         fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1812                 match *self {
1813                         DecodeError::UnknownVersion => f.write_str("Unknown realm byte in Onion packet"),
1814                         DecodeError::UnknownRequiredFeature => f.write_str("Unknown required feature preventing decode"),
1815                         DecodeError::InvalidValue => f.write_str("Nonsense bytes didn't map to the type they were interpreted as"),
1816                         DecodeError::ShortRead => f.write_str("Packet extended beyond the provided bytes"),
1817                         DecodeError::BadLengthDescriptor => f.write_str("A length descriptor in the packet didn't describe the later data correctly"),
1818                         DecodeError::Io(ref e) => fmt::Debug::fmt(e, f),
1819                         DecodeError::UnsupportedCompression => f.write_str("We don't support receiving messages with zlib-compressed fields"),
1820                 }
1821         }
1822 }
1823
1824 impl From<io::Error> for DecodeError {
1825         fn from(e: io::Error) -> Self {
1826                 if e.kind() == io::ErrorKind::UnexpectedEof {
1827                         DecodeError::ShortRead
1828                 } else {
1829                         DecodeError::Io(e.kind())
1830                 }
1831         }
1832 }
1833
1834 #[cfg(not(taproot))]
1835 impl_writeable_msg!(AcceptChannel, {
1836         temporary_channel_id,
1837         dust_limit_satoshis,
1838         max_htlc_value_in_flight_msat,
1839         channel_reserve_satoshis,
1840         htlc_minimum_msat,
1841         minimum_depth,
1842         to_self_delay,
1843         max_accepted_htlcs,
1844         funding_pubkey,
1845         revocation_basepoint,
1846         payment_point,
1847         delayed_payment_basepoint,
1848         htlc_basepoint,
1849         first_per_commitment_point,
1850 }, {
1851         (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))), // Don't encode length twice.
1852         (1, channel_type, option),
1853 });
1854
1855 #[cfg(taproot)]
1856 impl_writeable_msg!(AcceptChannel, {
1857         temporary_channel_id,
1858         dust_limit_satoshis,
1859         max_htlc_value_in_flight_msat,
1860         channel_reserve_satoshis,
1861         htlc_minimum_msat,
1862         minimum_depth,
1863         to_self_delay,
1864         max_accepted_htlcs,
1865         funding_pubkey,
1866         revocation_basepoint,
1867         payment_point,
1868         delayed_payment_basepoint,
1869         htlc_basepoint,
1870         first_per_commitment_point,
1871 }, {
1872         (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))), // Don't encode length twice.
1873         (1, channel_type, option),
1874         (4, next_local_nonce, option),
1875 });
1876
1877 impl_writeable_msg!(AcceptChannelV2, {
1878         temporary_channel_id,
1879         funding_satoshis,
1880         dust_limit_satoshis,
1881         max_htlc_value_in_flight_msat,
1882         htlc_minimum_msat,
1883         minimum_depth,
1884         to_self_delay,
1885         max_accepted_htlcs,
1886         funding_pubkey,
1887         revocation_basepoint,
1888         payment_basepoint,
1889         delayed_payment_basepoint,
1890         htlc_basepoint,
1891         first_per_commitment_point,
1892         second_per_commitment_point,
1893 }, {
1894         (0, shutdown_scriptpubkey, option),
1895         (1, channel_type, option),
1896         (2, require_confirmed_inputs, option),
1897 });
1898
1899 impl_writeable_msg!(Stfu, {
1900         channel_id,
1901         initiator,
1902 }, {});
1903
1904 impl_writeable_msg!(Splice, {
1905         channel_id,
1906         chain_hash,
1907         relative_satoshis,
1908         funding_feerate_perkw,
1909         locktime,
1910         funding_pubkey,
1911 }, {});
1912
1913 impl_writeable_msg!(SpliceAck, {
1914         channel_id,
1915         chain_hash,
1916         relative_satoshis,
1917         funding_pubkey,
1918 }, {});
1919
1920 impl_writeable_msg!(SpliceLocked, {
1921         channel_id,
1922 }, {});
1923
1924 impl_writeable_msg!(TxAddInput, {
1925         channel_id,
1926         serial_id,
1927         prevtx,
1928         prevtx_out,
1929         sequence,
1930 }, {});
1931
1932 impl_writeable_msg!(TxAddOutput, {
1933         channel_id,
1934         serial_id,
1935         sats,
1936         script,
1937 }, {});
1938
1939 impl_writeable_msg!(TxRemoveInput, {
1940         channel_id,
1941         serial_id,
1942 }, {});
1943
1944 impl_writeable_msg!(TxRemoveOutput, {
1945         channel_id,
1946         serial_id,
1947 }, {});
1948
1949 impl_writeable_msg!(TxComplete, {
1950         channel_id,
1951 }, {});
1952
1953 impl_writeable_msg!(TxSignatures, {
1954         channel_id,
1955         tx_hash,
1956         witnesses,
1957 }, {});
1958
1959 impl_writeable_msg!(TxInitRbf, {
1960         channel_id,
1961         locktime,
1962         feerate_sat_per_1000_weight,
1963 }, {
1964         (0, funding_output_contribution, option),
1965 });
1966
1967 impl_writeable_msg!(TxAckRbf, {
1968         channel_id,
1969 }, {
1970         (0, funding_output_contribution, option),
1971 });
1972
1973 impl_writeable_msg!(TxAbort, {
1974         channel_id,
1975         data,
1976 }, {});
1977
1978 impl_writeable_msg!(AnnouncementSignatures, {
1979         channel_id,
1980         short_channel_id,
1981         node_signature,
1982         bitcoin_signature
1983 }, {});
1984
1985 impl_writeable_msg!(ChannelReestablish, {
1986         channel_id,
1987         next_local_commitment_number,
1988         next_remote_commitment_number,
1989         your_last_per_commitment_secret,
1990         my_current_per_commitment_point,
1991 }, {
1992         (0, next_funding_txid, option),
1993 });
1994
1995 impl_writeable_msg!(ClosingSigned,
1996         { channel_id, fee_satoshis, signature },
1997         { (1, fee_range, option) }
1998 );
1999
2000 impl_writeable!(ClosingSignedFeeRange, {
2001         min_fee_satoshis,
2002         max_fee_satoshis
2003 });
2004
2005 #[cfg(not(taproot))]
2006 impl_writeable_msg!(CommitmentSigned, {
2007         channel_id,
2008         signature,
2009         htlc_signatures
2010 }, {});
2011
2012 #[cfg(taproot)]
2013 impl_writeable_msg!(CommitmentSigned, {
2014         channel_id,
2015         signature,
2016         htlc_signatures
2017 }, {
2018         (2, partial_signature_with_nonce, option)
2019 });
2020
2021 impl_writeable!(DecodedOnionErrorPacket, {
2022         hmac,
2023         failuremsg,
2024         pad
2025 });
2026
2027 #[cfg(not(taproot))]
2028 impl_writeable_msg!(FundingCreated, {
2029         temporary_channel_id,
2030         funding_txid,
2031         funding_output_index,
2032         signature
2033 }, {});
2034 #[cfg(taproot)]
2035 impl_writeable_msg!(FundingCreated, {
2036         temporary_channel_id,
2037         funding_txid,
2038         funding_output_index,
2039         signature
2040 }, {
2041         (2, partial_signature_with_nonce, option),
2042         (4, next_local_nonce, option)
2043 });
2044
2045 #[cfg(not(taproot))]
2046 impl_writeable_msg!(FundingSigned, {
2047         channel_id,
2048         signature
2049 }, {});
2050
2051 #[cfg(taproot)]
2052 impl_writeable_msg!(FundingSigned, {
2053         channel_id,
2054         signature
2055 }, {
2056         (2, partial_signature_with_nonce, option)
2057 });
2058
2059 impl_writeable_msg!(ChannelReady, {
2060         channel_id,
2061         next_per_commitment_point,
2062 }, {
2063         (1, short_channel_id_alias, option),
2064 });
2065
2066 impl Writeable for Init {
2067         fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2068                 // global_features gets the bottom 13 bits of our features, and local_features gets all of
2069                 // our relevant feature bits. This keeps us compatible with old nodes.
2070                 self.features.write_up_to_13(w)?;
2071                 self.features.write(w)?;
2072                 encode_tlv_stream!(w, {
2073                         (1, self.networks.as_ref().map(|n| WithoutLength(n)), option),
2074                         (3, self.remote_network_address, option),
2075                 });
2076                 Ok(())
2077         }
2078 }
2079
2080 impl Readable for Init {
2081         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2082                 let global_features: InitFeatures = Readable::read(r)?;
2083                 let features: InitFeatures = Readable::read(r)?;
2084                 let mut remote_network_address: Option<SocketAddress> = None;
2085                 let mut networks: Option<WithoutLength<Vec<ChainHash>>> = None;
2086                 decode_tlv_stream!(r, {
2087                         (1, networks, option),
2088                         (3, remote_network_address, option)
2089                 });
2090                 Ok(Init {
2091                         features: features | global_features,
2092                         networks: networks.map(|n| n.0),
2093                         remote_network_address,
2094                 })
2095         }
2096 }
2097
2098 impl_writeable_msg!(OpenChannel, {
2099         chain_hash,
2100         temporary_channel_id,
2101         funding_satoshis,
2102         push_msat,
2103         dust_limit_satoshis,
2104         max_htlc_value_in_flight_msat,
2105         channel_reserve_satoshis,
2106         htlc_minimum_msat,
2107         feerate_per_kw,
2108         to_self_delay,
2109         max_accepted_htlcs,
2110         funding_pubkey,
2111         revocation_basepoint,
2112         payment_point,
2113         delayed_payment_basepoint,
2114         htlc_basepoint,
2115         first_per_commitment_point,
2116         channel_flags,
2117 }, {
2118         (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))), // Don't encode length twice.
2119         (1, channel_type, option),
2120 });
2121
2122 impl_writeable_msg!(OpenChannelV2, {
2123         chain_hash,
2124         temporary_channel_id,
2125         funding_feerate_sat_per_1000_weight,
2126         commitment_feerate_sat_per_1000_weight,
2127         funding_satoshis,
2128         dust_limit_satoshis,
2129         max_htlc_value_in_flight_msat,
2130         htlc_minimum_msat,
2131         to_self_delay,
2132         max_accepted_htlcs,
2133         locktime,
2134         funding_pubkey,
2135         revocation_basepoint,
2136         payment_basepoint,
2137         delayed_payment_basepoint,
2138         htlc_basepoint,
2139         first_per_commitment_point,
2140         second_per_commitment_point,
2141         channel_flags,
2142 }, {
2143         (0, shutdown_scriptpubkey, option),
2144         (1, channel_type, option),
2145         (2, require_confirmed_inputs, option),
2146 });
2147
2148 #[cfg(not(taproot))]
2149 impl_writeable_msg!(RevokeAndACK, {
2150         channel_id,
2151         per_commitment_secret,
2152         next_per_commitment_point
2153 }, {});
2154
2155 #[cfg(taproot)]
2156 impl_writeable_msg!(RevokeAndACK, {
2157         channel_id,
2158         per_commitment_secret,
2159         next_per_commitment_point
2160 }, {
2161         (4, next_local_nonce, option)
2162 });
2163
2164 impl_writeable_msg!(Shutdown, {
2165         channel_id,
2166         scriptpubkey
2167 }, {});
2168
2169 impl_writeable_msg!(UpdateFailHTLC, {
2170         channel_id,
2171         htlc_id,
2172         reason
2173 }, {});
2174
2175 impl_writeable_msg!(UpdateFailMalformedHTLC, {
2176         channel_id,
2177         htlc_id,
2178         sha256_of_onion,
2179         failure_code
2180 }, {});
2181
2182 impl_writeable_msg!(UpdateFee, {
2183         channel_id,
2184         feerate_per_kw
2185 }, {});
2186
2187 impl_writeable_msg!(UpdateFulfillHTLC, {
2188         channel_id,
2189         htlc_id,
2190         payment_preimage
2191 }, {});
2192
2193 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2194 // serialization format in a way which assumes we know the total serialized length/message end
2195 // position.
2196 impl_writeable!(OnionErrorPacket, {
2197         data
2198 });
2199
2200 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2201 // serialization format in a way which assumes we know the total serialized length/message end
2202 // position.
2203 impl Writeable for OnionPacket {
2204         fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2205                 self.version.write(w)?;
2206                 match self.public_key {
2207                         Ok(pubkey) => pubkey.write(w)?,
2208                         Err(_) => [0u8;33].write(w)?,
2209                 }
2210                 w.write_all(&self.hop_data)?;
2211                 self.hmac.write(w)?;
2212                 Ok(())
2213         }
2214 }
2215
2216 impl Readable for OnionPacket {
2217         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2218                 Ok(OnionPacket {
2219                         version: Readable::read(r)?,
2220                         public_key: {
2221                                 let mut buf = [0u8;33];
2222                                 r.read_exact(&mut buf)?;
2223                                 PublicKey::from_slice(&buf)
2224                         },
2225                         hop_data: Readable::read(r)?,
2226                         hmac: Readable::read(r)?,
2227                 })
2228         }
2229 }
2230
2231 impl_writeable_msg!(UpdateAddHTLC, {
2232         channel_id,
2233         htlc_id,
2234         amount_msat,
2235         payment_hash,
2236         cltv_expiry,
2237         onion_routing_packet,
2238 }, {
2239         (0, blinding_point, option),
2240         (65537, skimmed_fee_msat, option)
2241 });
2242
2243 impl Readable for OnionMessage {
2244         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2245                 let blinding_point: PublicKey = Readable::read(r)?;
2246                 let len: u16 = Readable::read(r)?;
2247                 let mut packet_reader = FixedLengthReader::new(r, len as u64);
2248                 let onion_routing_packet: onion_message::packet::Packet =
2249                         <onion_message::packet::Packet as LengthReadable>::read(&mut packet_reader)?;
2250                 Ok(Self {
2251                         blinding_point,
2252                         onion_routing_packet,
2253                 })
2254         }
2255 }
2256
2257 impl Writeable for OnionMessage {
2258         fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2259                 self.blinding_point.write(w)?;
2260                 let onion_packet_len = self.onion_routing_packet.serialized_length();
2261                 (onion_packet_len as u16).write(w)?;
2262                 self.onion_routing_packet.write(w)?;
2263                 Ok(())
2264         }
2265 }
2266
2267 impl Writeable for FinalOnionHopData {
2268         fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2269                 self.payment_secret.0.write(w)?;
2270                 HighZeroBytesDroppedBigSize(self.total_msat).write(w)
2271         }
2272 }
2273
2274 impl Readable for FinalOnionHopData {
2275         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2276                 let secret: [u8; 32] = Readable::read(r)?;
2277                 let amt: HighZeroBytesDroppedBigSize<u64> = Readable::read(r)?;
2278                 Ok(Self { payment_secret: PaymentSecret(secret), total_msat: amt.0 })
2279         }
2280 }
2281
2282 impl Writeable for OutboundOnionPayload {
2283         fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2284                 match self {
2285                         Self::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } => {
2286                                 _encode_varint_length_prefixed_tlv!(w, {
2287                                         (2, HighZeroBytesDroppedBigSize(*amt_to_forward), required),
2288                                         (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2289                                         (6, short_channel_id, required)
2290                                 });
2291                         },
2292                         Self::Receive {
2293                                 ref payment_data, ref payment_metadata, ref keysend_preimage, sender_intended_htlc_amt_msat,
2294                                 cltv_expiry_height, ref custom_tlvs,
2295                         } => {
2296                                 // We need to update [`ln::outbound_payment::RecipientOnionFields::with_custom_tlvs`]
2297                                 // to reject any reserved types in the experimental range if new ones are ever
2298                                 // standardized.
2299                                 let keysend_tlv = keysend_preimage.map(|preimage| (5482373484, preimage.encode()));
2300                                 let mut custom_tlvs: Vec<&(u64, Vec<u8>)> = custom_tlvs.iter().chain(keysend_tlv.iter()).collect();
2301                                 custom_tlvs.sort_unstable_by_key(|(typ, _)| *typ);
2302                                 _encode_varint_length_prefixed_tlv!(w, {
2303                                         (2, HighZeroBytesDroppedBigSize(*sender_intended_htlc_amt_msat), required),
2304                                         (4, HighZeroBytesDroppedBigSize(*cltv_expiry_height), required),
2305                                         (8, payment_data, option),
2306                                         (16, payment_metadata.as_ref().map(|m| WithoutLength(m)), option)
2307                                 }, custom_tlvs.iter());
2308                         },
2309                         Self::BlindedForward { encrypted_tlvs, intro_node_blinding_point } => {
2310                                 _encode_varint_length_prefixed_tlv!(w, {
2311                                         (10, *encrypted_tlvs, required_vec),
2312                                         (12, intro_node_blinding_point, option)
2313                                 });
2314                         },
2315                         Self::BlindedReceive {
2316                                 sender_intended_htlc_amt_msat, total_msat, cltv_expiry_height, encrypted_tlvs,
2317                                 intro_node_blinding_point,
2318                         } => {
2319                                 _encode_varint_length_prefixed_tlv!(w, {
2320                                         (2, HighZeroBytesDroppedBigSize(*sender_intended_htlc_amt_msat), required),
2321                                         (4, HighZeroBytesDroppedBigSize(*cltv_expiry_height), required),
2322                                         (10, *encrypted_tlvs, required_vec),
2323                                         (12, intro_node_blinding_point, option),
2324                                         (18, HighZeroBytesDroppedBigSize(*total_msat), required)
2325                                 });
2326                         },
2327                 }
2328                 Ok(())
2329         }
2330 }
2331
2332 impl<NS: Deref> ReadableArgs<(Option<PublicKey>, &NS)> for InboundOnionPayload where NS::Target: NodeSigner {
2333         fn read<R: Read>(r: &mut R, args: (Option<PublicKey>, &NS)) -> Result<Self, DecodeError> {
2334                 let (update_add_blinding_point, node_signer) = args;
2335
2336                 let mut amt = None;
2337                 let mut cltv_value = None;
2338                 let mut short_id: Option<u64> = None;
2339                 let mut payment_data: Option<FinalOnionHopData> = None;
2340                 let mut encrypted_tlvs_opt: Option<WithoutLength<Vec<u8>>> = None;
2341                 let mut intro_node_blinding_point = None;
2342                 let mut payment_metadata: Option<WithoutLength<Vec<u8>>> = None;
2343                 let mut total_msat = None;
2344                 let mut keysend_preimage: Option<PaymentPreimage> = None;
2345                 let mut custom_tlvs = Vec::new();
2346
2347                 let tlv_len = BigSize::read(r)?;
2348                 let rd = FixedLengthReader::new(r, tlv_len.0);
2349                 decode_tlv_stream_with_custom_tlv_decode!(rd, {
2350                         (2, amt, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2351                         (4, cltv_value, (option, encoding: (u32, HighZeroBytesDroppedBigSize))),
2352                         (6, short_id, option),
2353                         (8, payment_data, option),
2354                         (10, encrypted_tlvs_opt, option),
2355                         (12, intro_node_blinding_point, option),
2356                         (16, payment_metadata, option),
2357                         (18, total_msat, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2358                         // See https://github.com/lightning/blips/blob/master/blip-0003.md
2359                         (5482373484, keysend_preimage, option)
2360                 }, |msg_type: u64, msg_reader: &mut FixedLengthReader<_>| -> Result<bool, DecodeError> {
2361                         if msg_type < 1 << 16 { return Ok(false) }
2362                         let mut value = Vec::new();
2363                         msg_reader.read_to_end(&mut value)?;
2364                         custom_tlvs.push((msg_type, value));
2365                         Ok(true)
2366                 });
2367
2368                 if amt.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2369                 if intro_node_blinding_point.is_some() && update_add_blinding_point.is_some() {
2370                         return Err(DecodeError::InvalidValue)
2371                 }
2372
2373                 if let Some(blinding_point) = intro_node_blinding_point.or(update_add_blinding_point) {
2374                         if short_id.is_some() || payment_data.is_some() || payment_metadata.is_some() ||
2375                                 keysend_preimage.is_some()
2376                         {
2377                                 return Err(DecodeError::InvalidValue)
2378                         }
2379                         let enc_tlvs = encrypted_tlvs_opt.ok_or(DecodeError::InvalidValue)?.0;
2380                         let enc_tlvs_ss = node_signer.ecdh(Recipient::Node, &blinding_point, None)
2381                                 .map_err(|_| DecodeError::InvalidValue)?;
2382                         let rho = onion_utils::gen_rho_from_shared_secret(&enc_tlvs_ss.secret_bytes());
2383                         let mut s = Cursor::new(&enc_tlvs);
2384                         let mut reader = FixedLengthReader::new(&mut s, enc_tlvs.len() as u64);
2385                         match ChaChaPolyReadAdapter::read(&mut reader, rho)? {
2386                                 ChaChaPolyReadAdapter { readable: BlindedPaymentTlvs::Forward(ForwardTlvs {
2387                                         short_channel_id, payment_relay, payment_constraints, features
2388                                 })} => {
2389                                         if amt.is_some() || cltv_value.is_some() || total_msat.is_some() {
2390                                                 return Err(DecodeError::InvalidValue)
2391                                         }
2392                                         Ok(Self::BlindedForward {
2393                                                 short_channel_id,
2394                                                 payment_relay,
2395                                                 payment_constraints,
2396                                                 features,
2397                                                 intro_node_blinding_point: intro_node_blinding_point.ok_or(DecodeError::InvalidValue)?,
2398                                         })
2399                                 },
2400                                 ChaChaPolyReadAdapter { readable: BlindedPaymentTlvs::Receive(ReceiveTlvs {
2401                                         payment_secret, payment_constraints
2402                                 })} => {
2403                                         if total_msat.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2404                                         Ok(Self::BlindedReceive {
2405                                                 sender_intended_htlc_amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2406                                                 total_msat: total_msat.ok_or(DecodeError::InvalidValue)?,
2407                                                 cltv_expiry_height: cltv_value.ok_or(DecodeError::InvalidValue)?,
2408                                                 payment_secret,
2409                                                 payment_constraints,
2410                                                 intro_node_blinding_point,
2411                                         })
2412                                 },
2413                         }
2414                 } else if let Some(short_channel_id) = short_id {
2415                         if payment_data.is_some() || payment_metadata.is_some() || encrypted_tlvs_opt.is_some() ||
2416                                 total_msat.is_some()
2417                         { return Err(DecodeError::InvalidValue) }
2418                         Ok(Self::Forward {
2419                                 short_channel_id,
2420                                 amt_to_forward: amt.ok_or(DecodeError::InvalidValue)?,
2421                                 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2422                         })
2423                 } else {
2424                         if encrypted_tlvs_opt.is_some() || total_msat.is_some() {
2425                                 return Err(DecodeError::InvalidValue)
2426                         }
2427                         if let Some(data) = &payment_data {
2428                                 if data.total_msat > MAX_VALUE_MSAT {
2429                                         return Err(DecodeError::InvalidValue);
2430                                 }
2431                         }
2432                         Ok(Self::Receive {
2433                                 payment_data,
2434                                 payment_metadata: payment_metadata.map(|w| w.0),
2435                                 keysend_preimage,
2436                                 sender_intended_htlc_amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2437                                 cltv_expiry_height: cltv_value.ok_or(DecodeError::InvalidValue)?,
2438                                 custom_tlvs,
2439                         })
2440                 }
2441         }
2442 }
2443
2444 impl Writeable for Ping {
2445         fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2446                 self.ponglen.write(w)?;
2447                 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2448                 Ok(())
2449         }
2450 }
2451
2452 impl Readable for Ping {
2453         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2454                 Ok(Ping {
2455                         ponglen: Readable::read(r)?,
2456                         byteslen: {
2457                                 let byteslen = Readable::read(r)?;
2458                                 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2459                                 byteslen
2460                         }
2461                 })
2462         }
2463 }
2464
2465 impl Writeable for Pong {
2466         fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2467                 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2468                 Ok(())
2469         }
2470 }
2471
2472 impl Readable for Pong {
2473         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2474                 Ok(Pong {
2475                         byteslen: {
2476                                 let byteslen = Readable::read(r)?;
2477                                 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2478                                 byteslen
2479                         }
2480                 })
2481         }
2482 }
2483
2484 impl Writeable for UnsignedChannelAnnouncement {
2485         fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2486                 self.features.write(w)?;
2487                 self.chain_hash.write(w)?;
2488                 self.short_channel_id.write(w)?;
2489                 self.node_id_1.write(w)?;
2490                 self.node_id_2.write(w)?;
2491                 self.bitcoin_key_1.write(w)?;
2492                 self.bitcoin_key_2.write(w)?;
2493                 w.write_all(&self.excess_data[..])?;
2494                 Ok(())
2495         }
2496 }
2497
2498 impl Readable for UnsignedChannelAnnouncement {
2499         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2500                 Ok(Self {
2501                         features: Readable::read(r)?,
2502                         chain_hash: Readable::read(r)?,
2503                         short_channel_id: Readable::read(r)?,
2504                         node_id_1: Readable::read(r)?,
2505                         node_id_2: Readable::read(r)?,
2506                         bitcoin_key_1: Readable::read(r)?,
2507                         bitcoin_key_2: Readable::read(r)?,
2508                         excess_data: read_to_end(r)?,
2509                 })
2510         }
2511 }
2512
2513 impl_writeable!(ChannelAnnouncement, {
2514         node_signature_1,
2515         node_signature_2,
2516         bitcoin_signature_1,
2517         bitcoin_signature_2,
2518         contents
2519 });
2520
2521 impl Writeable for UnsignedChannelUpdate {
2522         fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2523                 // `message_flags` used to indicate presence of `htlc_maximum_msat`, but was deprecated in the spec.
2524                 const MESSAGE_FLAGS: u8 = 1;
2525                 self.chain_hash.write(w)?;
2526                 self.short_channel_id.write(w)?;
2527                 self.timestamp.write(w)?;
2528                 let all_flags = self.flags as u16 | ((MESSAGE_FLAGS as u16) << 8);
2529                 all_flags.write(w)?;
2530                 self.cltv_expiry_delta.write(w)?;
2531                 self.htlc_minimum_msat.write(w)?;
2532                 self.fee_base_msat.write(w)?;
2533                 self.fee_proportional_millionths.write(w)?;
2534                 self.htlc_maximum_msat.write(w)?;
2535                 w.write_all(&self.excess_data[..])?;
2536                 Ok(())
2537         }
2538 }
2539
2540 impl Readable for UnsignedChannelUpdate {
2541         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2542                 Ok(Self {
2543                         chain_hash: Readable::read(r)?,
2544                         short_channel_id: Readable::read(r)?,
2545                         timestamp: Readable::read(r)?,
2546                         flags: {
2547                                 let flags: u16 = Readable::read(r)?;
2548                                 // Note: we ignore the `message_flags` for now, since it was deprecated by the spec.
2549                                 flags as u8
2550                         },
2551                         cltv_expiry_delta: Readable::read(r)?,
2552                         htlc_minimum_msat: Readable::read(r)?,
2553                         fee_base_msat: Readable::read(r)?,
2554                         fee_proportional_millionths: Readable::read(r)?,
2555                         htlc_maximum_msat: Readable::read(r)?,
2556                         excess_data: read_to_end(r)?,
2557                 })
2558         }
2559 }
2560
2561 impl_writeable!(ChannelUpdate, {
2562         signature,
2563         contents
2564 });
2565
2566 impl Writeable for ErrorMessage {
2567         fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2568                 self.channel_id.write(w)?;
2569                 (self.data.len() as u16).write(w)?;
2570                 w.write_all(self.data.as_bytes())?;
2571                 Ok(())
2572         }
2573 }
2574
2575 impl Readable for ErrorMessage {
2576         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2577                 Ok(Self {
2578                         channel_id: Readable::read(r)?,
2579                         data: {
2580                                 let sz: usize = <u16 as Readable>::read(r)? as usize;
2581                                 let mut data = Vec::with_capacity(sz);
2582                                 data.resize(sz, 0);
2583                                 r.read_exact(&mut data)?;
2584                                 match String::from_utf8(data) {
2585                                         Ok(s) => s,
2586                                         Err(_) => return Err(DecodeError::InvalidValue),
2587                                 }
2588                         }
2589                 })
2590         }
2591 }
2592
2593 impl Writeable for WarningMessage {
2594         fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2595                 self.channel_id.write(w)?;
2596                 (self.data.len() as u16).write(w)?;
2597                 w.write_all(self.data.as_bytes())?;
2598                 Ok(())
2599         }
2600 }
2601
2602 impl Readable for WarningMessage {
2603         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2604                 Ok(Self {
2605                         channel_id: Readable::read(r)?,
2606                         data: {
2607                                 let sz: usize = <u16 as Readable>::read(r)? as usize;
2608                                 let mut data = Vec::with_capacity(sz);
2609                                 data.resize(sz, 0);
2610                                 r.read_exact(&mut data)?;
2611                                 match String::from_utf8(data) {
2612                                         Ok(s) => s,
2613                                         Err(_) => return Err(DecodeError::InvalidValue),
2614                                 }
2615                         }
2616                 })
2617         }
2618 }
2619
2620 impl Writeable for UnsignedNodeAnnouncement {
2621         fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2622                 self.features.write(w)?;
2623                 self.timestamp.write(w)?;
2624                 self.node_id.write(w)?;
2625                 w.write_all(&self.rgb)?;
2626                 self.alias.write(w)?;
2627
2628                 let mut addr_len = 0;
2629                 for addr in self.addresses.iter() {
2630                         addr_len += 1 + addr.len();
2631                 }
2632                 (addr_len + self.excess_address_data.len() as u16).write(w)?;
2633                 for addr in self.addresses.iter() {
2634                         addr.write(w)?;
2635                 }
2636                 w.write_all(&self.excess_address_data[..])?;
2637                 w.write_all(&self.excess_data[..])?;
2638                 Ok(())
2639         }
2640 }
2641
2642 impl Readable for UnsignedNodeAnnouncement {
2643         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2644                 let features: NodeFeatures = Readable::read(r)?;
2645                 let timestamp: u32 = Readable::read(r)?;
2646                 let node_id: NodeId = Readable::read(r)?;
2647                 let mut rgb = [0; 3];
2648                 r.read_exact(&mut rgb)?;
2649                 let alias: NodeAlias = Readable::read(r)?;
2650
2651                 let addr_len: u16 = Readable::read(r)?;
2652                 let mut addresses: Vec<SocketAddress> = Vec::new();
2653                 let mut addr_readpos = 0;
2654                 let mut excess = false;
2655                 let mut excess_byte = 0;
2656                 loop {
2657                         if addr_len <= addr_readpos { break; }
2658                         match Readable::read(r) {
2659                                 Ok(Ok(addr)) => {
2660                                         if addr_len < addr_readpos + 1 + addr.len() {
2661                                                 return Err(DecodeError::BadLengthDescriptor);
2662                                         }
2663                                         addr_readpos += (1 + addr.len()) as u16;
2664                                         addresses.push(addr);
2665                                 },
2666                                 Ok(Err(unknown_descriptor)) => {
2667                                         excess = true;
2668                                         excess_byte = unknown_descriptor;
2669                                         break;
2670                                 },
2671                                 Err(DecodeError::ShortRead) => return Err(DecodeError::BadLengthDescriptor),
2672                                 Err(e) => return Err(e),
2673                         }
2674                 }
2675
2676                 let mut excess_data = vec![];
2677                 let excess_address_data = if addr_readpos < addr_len {
2678                         let mut excess_address_data = vec![0; (addr_len - addr_readpos) as usize];
2679                         r.read_exact(&mut excess_address_data[if excess { 1 } else { 0 }..])?;
2680                         if excess {
2681                                 excess_address_data[0] = excess_byte;
2682                         }
2683                         excess_address_data
2684                 } else {
2685                         if excess {
2686                                 excess_data.push(excess_byte);
2687                         }
2688                         Vec::new()
2689                 };
2690                 excess_data.extend(read_to_end(r)?.iter());
2691                 Ok(UnsignedNodeAnnouncement {
2692                         features,
2693                         timestamp,
2694                         node_id,
2695                         rgb,
2696                         alias,
2697                         addresses,
2698                         excess_address_data,
2699                         excess_data,
2700                 })
2701         }
2702 }
2703
2704 impl_writeable!(NodeAnnouncement, {
2705         signature,
2706         contents
2707 });
2708
2709 impl Readable for QueryShortChannelIds {
2710         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2711                 let chain_hash: ChainHash = Readable::read(r)?;
2712
2713                 let encoding_len: u16 = Readable::read(r)?;
2714                 let encoding_type: u8 = Readable::read(r)?;
2715
2716                 // Must be encoding_type=0 uncompressed serialization. We do not
2717                 // support encoding_type=1 zlib serialization.
2718                 if encoding_type != EncodingType::Uncompressed as u8 {
2719                         return Err(DecodeError::UnsupportedCompression);
2720                 }
2721
2722                 // We expect the encoding_len to always includes the 1-byte
2723                 // encoding_type and that short_channel_ids are 8-bytes each
2724                 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2725                         return Err(DecodeError::InvalidValue);
2726                 }
2727
2728                 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2729                 // less the 1-byte encoding_type
2730                 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2731                 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2732                 for _ in 0..short_channel_id_count {
2733                         short_channel_ids.push(Readable::read(r)?);
2734                 }
2735
2736                 Ok(QueryShortChannelIds {
2737                         chain_hash,
2738                         short_channel_ids,
2739                 })
2740         }
2741 }
2742
2743 impl Writeable for QueryShortChannelIds {
2744         fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2745                 // Calculated from 1-byte encoding_type plus 8-bytes per short_channel_id
2746                 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2747
2748                 self.chain_hash.write(w)?;
2749                 encoding_len.write(w)?;
2750
2751                 // We only support type=0 uncompressed serialization
2752                 (EncodingType::Uncompressed as u8).write(w)?;
2753
2754                 for scid in self.short_channel_ids.iter() {
2755                         scid.write(w)?;
2756                 }
2757
2758                 Ok(())
2759         }
2760 }
2761
2762 impl_writeable_msg!(ReplyShortChannelIdsEnd, {
2763         chain_hash,
2764         full_information,
2765 }, {});
2766
2767 impl QueryChannelRange {
2768         /// Calculates the overflow safe ending block height for the query.
2769         ///
2770         /// Overflow returns `0xffffffff`, otherwise returns `first_blocknum + number_of_blocks`.
2771         pub fn end_blocknum(&self) -> u32 {
2772                 match self.first_blocknum.checked_add(self.number_of_blocks) {
2773                         Some(block) => block,
2774                         None => u32::max_value(),
2775                 }
2776         }
2777 }
2778
2779 impl_writeable_msg!(QueryChannelRange, {
2780         chain_hash,
2781         first_blocknum,
2782         number_of_blocks
2783 }, {});
2784
2785 impl Readable for ReplyChannelRange {
2786         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2787                 let chain_hash: ChainHash = Readable::read(r)?;
2788                 let first_blocknum: u32 = Readable::read(r)?;
2789                 let number_of_blocks: u32 = Readable::read(r)?;
2790                 let sync_complete: bool = Readable::read(r)?;
2791
2792                 let encoding_len: u16 = Readable::read(r)?;
2793                 let encoding_type: u8 = Readable::read(r)?;
2794
2795                 // Must be encoding_type=0 uncompressed serialization. We do not
2796                 // support encoding_type=1 zlib serialization.
2797                 if encoding_type != EncodingType::Uncompressed as u8 {
2798                         return Err(DecodeError::UnsupportedCompression);
2799                 }
2800
2801                 // We expect the encoding_len to always includes the 1-byte
2802                 // encoding_type and that short_channel_ids are 8-bytes each
2803                 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2804                         return Err(DecodeError::InvalidValue);
2805                 }
2806
2807                 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2808                 // less the 1-byte encoding_type
2809                 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2810                 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2811                 for _ in 0..short_channel_id_count {
2812                         short_channel_ids.push(Readable::read(r)?);
2813                 }
2814
2815                 Ok(ReplyChannelRange {
2816                         chain_hash,
2817                         first_blocknum,
2818                         number_of_blocks,
2819                         sync_complete,
2820                         short_channel_ids
2821                 })
2822         }
2823 }
2824
2825 impl Writeable for ReplyChannelRange {
2826         fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2827                 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2828                 self.chain_hash.write(w)?;
2829                 self.first_blocknum.write(w)?;
2830                 self.number_of_blocks.write(w)?;
2831                 self.sync_complete.write(w)?;
2832
2833                 encoding_len.write(w)?;
2834                 (EncodingType::Uncompressed as u8).write(w)?;
2835                 for scid in self.short_channel_ids.iter() {
2836                         scid.write(w)?;
2837                 }
2838
2839                 Ok(())
2840         }
2841 }
2842
2843 impl_writeable_msg!(GossipTimestampFilter, {
2844         chain_hash,
2845         first_timestamp,
2846         timestamp_range,
2847 }, {});
2848
2849 #[cfg(test)]
2850 mod tests {
2851         use std::convert::TryFrom;
2852         use bitcoin::{Transaction, TxIn, ScriptBuf, Sequence, Witness, TxOut};
2853         use hex::DisplayHex;
2854         use crate::ln::{PaymentPreimage, PaymentHash, PaymentSecret};
2855         use crate::ln::ChannelId;
2856         use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
2857         use crate::ln::msgs::{self, FinalOnionHopData, OnionErrorPacket};
2858         use crate::ln::msgs::SocketAddress;
2859         use crate::routing::gossip::{NodeAlias, NodeId};
2860         use crate::util::ser::{Writeable, Readable, ReadableArgs, Hostname, TransactionU16LenLimited};
2861         use crate::util::test_utils;
2862
2863         use bitcoin::hashes::hex::FromHex;
2864         use bitcoin::address::Address;
2865         use bitcoin::network::constants::Network;
2866         use bitcoin::blockdata::constants::ChainHash;
2867         use bitcoin::blockdata::script::Builder;
2868         use bitcoin::blockdata::opcodes;
2869         use bitcoin::hash_types::Txid;
2870         use bitcoin::locktime::absolute::LockTime;
2871
2872         use bitcoin::secp256k1::{PublicKey,SecretKey};
2873         use bitcoin::secp256k1::{Secp256k1, Message};
2874
2875         use crate::io::{self, Cursor};
2876         use crate::prelude::*;
2877         use core::str::FromStr;
2878         use crate::chain::transaction::OutPoint;
2879
2880         #[cfg(feature = "std")]
2881         use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6, ToSocketAddrs};
2882         #[cfg(feature = "std")]
2883         use crate::ln::msgs::SocketAddressParseError;
2884
2885         #[test]
2886         fn encoding_channel_reestablish() {
2887                 let public_key = {
2888                         let secp_ctx = Secp256k1::new();
2889                         PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&<Vec<u8>>::from_hex("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2890                 };
2891
2892                 let cr = msgs::ChannelReestablish {
2893                         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]),
2894                         next_local_commitment_number: 3,
2895                         next_remote_commitment_number: 4,
2896                         your_last_per_commitment_secret: [9;32],
2897                         my_current_per_commitment_point: public_key,
2898                         next_funding_txid: None,
2899                 };
2900
2901                 let encoded_value = cr.encode();
2902                 assert_eq!(
2903                         encoded_value,
2904                         vec![
2905                                 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
2906                                 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2907                                 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2908                                 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
2909                                 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
2910                         ]
2911                 );
2912         }
2913
2914         #[test]
2915         fn encoding_channel_reestablish_with_next_funding_txid() {
2916                 let public_key = {
2917                         let secp_ctx = Secp256k1::new();
2918                         PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&<Vec<u8>>::from_hex("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2919                 };
2920
2921                 let cr = msgs::ChannelReestablish {
2922                         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]),
2923                         next_local_commitment_number: 3,
2924                         next_remote_commitment_number: 4,
2925                         your_last_per_commitment_secret: [9;32],
2926                         my_current_per_commitment_point: public_key,
2927                         next_funding_txid: Some(Txid::from_raw_hash(bitcoin::hashes::Hash::from_slice(&[
2928                                 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,
2929                         ]).unwrap())),
2930                 };
2931
2932                 let encoded_value = cr.encode();
2933                 assert_eq!(
2934                         encoded_value,
2935                         vec![
2936                                 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
2937                                 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2938                                 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2939                                 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
2940                                 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
2941                                 0, // Type (next_funding_txid)
2942                                 32, // Length
2943                                 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
2944                         ]
2945                 );
2946         }
2947
2948         macro_rules! get_keys_from {
2949                 ($slice: expr, $secp_ctx: expr) => {
2950                         {
2951                                 let privkey = SecretKey::from_slice(&<Vec<u8>>::from_hex($slice).unwrap()[..]).unwrap();
2952                                 let pubkey = PublicKey::from_secret_key(&$secp_ctx, &privkey);
2953                                 (privkey, pubkey)
2954                         }
2955                 }
2956         }
2957
2958         macro_rules! get_sig_on {
2959                 ($privkey: expr, $ctx: expr, $string: expr) => {
2960                         {
2961                                 let sighash = Message::from_slice(&$string.into_bytes()[..]).unwrap();
2962                                 $ctx.sign_ecdsa(&sighash, &$privkey)
2963                         }
2964                 }
2965         }
2966
2967         #[test]
2968         fn encoding_announcement_signatures() {
2969                 let secp_ctx = Secp256k1::new();
2970                 let (privkey, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2971                 let sig_1 = get_sig_on!(privkey, secp_ctx, String::from("01010101010101010101010101010101"));
2972                 let sig_2 = get_sig_on!(privkey, secp_ctx, String::from("02020202020202020202020202020202"));
2973                 let announcement_signatures = msgs::AnnouncementSignatures {
2974                         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]),
2975                         short_channel_id: 2316138423780173,
2976                         node_signature: sig_1,
2977                         bitcoin_signature: sig_2,
2978                 };
2979
2980                 let encoded_value = announcement_signatures.encode();
2981                 assert_eq!(encoded_value, <Vec<u8>>::from_hex("040000000000000005000000000000000600000000000000070000000000000000083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073acf9953cef4700860f5967838eba2bae89288ad188ebf8b20bf995c3ea53a26df1876d0a3a0e13172ba286a673140190c02ba9da60a2e43a745188c8a83c7f3ef").unwrap());
2982         }
2983
2984         fn do_encoding_channel_announcement(unknown_features_bits: bool, excess_data: bool) {
2985                 let secp_ctx = Secp256k1::new();
2986                 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2987                 let (privkey_2, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2988                 let (privkey_3, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2989                 let (privkey_4, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2990                 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2991                 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
2992                 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
2993                 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
2994                 let mut features = ChannelFeatures::empty();
2995                 if unknown_features_bits {
2996                         features = ChannelFeatures::from_le_bytes(vec![0xFF, 0xFF]);
2997                 }
2998                 let unsigned_channel_announcement = msgs::UnsignedChannelAnnouncement {
2999                         features,
3000                         chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3001                         short_channel_id: 2316138423780173,
3002                         node_id_1: NodeId::from_pubkey(&pubkey_1),
3003                         node_id_2: NodeId::from_pubkey(&pubkey_2),
3004                         bitcoin_key_1: NodeId::from_pubkey(&pubkey_3),
3005                         bitcoin_key_2: NodeId::from_pubkey(&pubkey_4),
3006                         excess_data: if excess_data { vec![10, 0, 0, 20, 0, 0, 30, 0, 0, 40] } else { Vec::new() },
3007                 };
3008                 let channel_announcement = msgs::ChannelAnnouncement {
3009                         node_signature_1: sig_1,
3010                         node_signature_2: sig_2,
3011                         bitcoin_signature_1: sig_3,
3012                         bitcoin_signature_2: sig_4,
3013                         contents: unsigned_channel_announcement,
3014                 };
3015                 let encoded_value = channel_announcement.encode();
3016                 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a1735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap();
3017                 if unknown_features_bits {
3018                         target_value.append(&mut <Vec<u8>>::from_hex("0002ffff").unwrap());
3019                 } else {
3020                         target_value.append(&mut <Vec<u8>>::from_hex("0000").unwrap());
3021                 }
3022                 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3023                 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
3024                 if excess_data {
3025                         target_value.append(&mut <Vec<u8>>::from_hex("0a00001400001e000028").unwrap());
3026                 }
3027                 assert_eq!(encoded_value, target_value);
3028         }
3029
3030         #[test]
3031         fn encoding_channel_announcement() {
3032                 do_encoding_channel_announcement(true, false);
3033                 do_encoding_channel_announcement(false, true);
3034                 do_encoding_channel_announcement(false, false);
3035                 do_encoding_channel_announcement(true, true);
3036         }
3037
3038         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) {
3039                 let secp_ctx = Secp256k1::new();
3040                 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3041                 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3042                 let features = if unknown_features_bits {
3043                         NodeFeatures::from_le_bytes(vec![0xFF, 0xFF])
3044                 } else {
3045                         // Set to some features we may support
3046                         NodeFeatures::from_le_bytes(vec![2 | 1 << 5])
3047                 };
3048                 let mut addresses = Vec::new();
3049                 if ipv4 {
3050                         addresses.push(SocketAddress::TcpIpV4 {
3051                                 addr: [255, 254, 253, 252],
3052                                 port: 9735
3053                         });
3054                 }
3055                 if ipv6 {
3056                         addresses.push(SocketAddress::TcpIpV6 {
3057                                 addr: [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240],
3058                                 port: 9735
3059                         });
3060                 }
3061                 if onionv2 {
3062                         addresses.push(msgs::SocketAddress::OnionV2(
3063                                 [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 38, 7]
3064                         ));
3065                 }
3066                 if onionv3 {
3067                         addresses.push(msgs::SocketAddress::OnionV3 {
3068                                 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],
3069                                 checksum: 32,
3070                                 version: 16,
3071                                 port: 9735
3072                         });
3073                 }
3074                 if hostname {
3075                         addresses.push(SocketAddress::Hostname {
3076                                 hostname: Hostname::try_from(String::from("host")).unwrap(),
3077                                 port: 9735,
3078                         });
3079                 }
3080                 let mut addr_len = 0;
3081                 for addr in &addresses {
3082                         addr_len += addr.len() + 1;
3083                 }
3084                 let unsigned_node_announcement = msgs::UnsignedNodeAnnouncement {
3085                         features,
3086                         timestamp: 20190119,
3087                         node_id: NodeId::from_pubkey(&pubkey_1),
3088                         rgb: [32; 3],
3089                         alias: NodeAlias([16;32]),
3090                         addresses,
3091                         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() },
3092                         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() },
3093                 };
3094                 addr_len += unsigned_node_announcement.excess_address_data.len() as u16;
3095                 let node_announcement = msgs::NodeAnnouncement {
3096                         signature: sig_1,
3097                         contents: unsigned_node_announcement,
3098                 };
3099                 let encoded_value = node_announcement.encode();
3100                 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3101                 if unknown_features_bits {
3102                         target_value.append(&mut <Vec<u8>>::from_hex("0002ffff").unwrap());
3103                 } else {
3104                         target_value.append(&mut <Vec<u8>>::from_hex("000122").unwrap());
3105                 }
3106                 target_value.append(&mut <Vec<u8>>::from_hex("013413a7031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f2020201010101010101010101010101010101010101010101010101010101010101010").unwrap());
3107                 target_value.append(&mut vec![(addr_len >> 8) as u8, addr_len as u8]);
3108                 if ipv4 {
3109                         target_value.append(&mut <Vec<u8>>::from_hex("01fffefdfc2607").unwrap());
3110                 }
3111                 if ipv6 {
3112                         target_value.append(&mut <Vec<u8>>::from_hex("02fffefdfcfbfaf9f8f7f6f5f4f3f2f1f02607").unwrap());
3113                 }
3114                 if onionv2 {
3115                         target_value.append(&mut <Vec<u8>>::from_hex("03fffefdfcfbfaf9f8f7f62607").unwrap());
3116                 }
3117                 if onionv3 {
3118                         target_value.append(&mut <Vec<u8>>::from_hex("04fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0efeeedecebeae9e8e7e6e5e4e3e2e1e00020102607").unwrap());
3119                 }
3120                 if hostname {
3121                         target_value.append(&mut <Vec<u8>>::from_hex("0504686f73742607").unwrap());
3122                 }
3123                 if excess_address_data {
3124                         target_value.append(&mut <Vec<u8>>::from_hex("216c280b5395a2546e7e4b2663e04f811622f15a4f92e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d269").unwrap());
3125                 }
3126                 if excess_data {
3127                         target_value.append(&mut <Vec<u8>>::from_hex("3b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
3128                 }
3129                 assert_eq!(encoded_value, target_value);
3130         }
3131
3132         #[test]
3133         fn encoding_node_announcement() {
3134                 do_encoding_node_announcement(true, true, true, true, true, true, true, true);
3135                 do_encoding_node_announcement(false, false, false, false, false, false, false, false);
3136                 do_encoding_node_announcement(false, true, false, false, false, false, false, false);
3137                 do_encoding_node_announcement(false, false, true, false, false, false, false, false);
3138                 do_encoding_node_announcement(false, false, false, true, false, false, false, false);
3139                 do_encoding_node_announcement(false, false, false, false, true, false, false, false);
3140                 do_encoding_node_announcement(false, false, false, false, false, true, false, false);
3141                 do_encoding_node_announcement(false, false, false, false, false, false, true, false);
3142                 do_encoding_node_announcement(false, true, false, true, false, false, true, false);
3143                 do_encoding_node_announcement(false, false, true, false, true, false, false, false);
3144         }
3145
3146         fn do_encoding_channel_update(direction: bool, disable: bool, excess_data: bool) {
3147                 let secp_ctx = Secp256k1::new();
3148                 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3149                 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3150                 let unsigned_channel_update = msgs::UnsignedChannelUpdate {
3151                         chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3152                         short_channel_id: 2316138423780173,
3153                         timestamp: 20190119,
3154                         flags: if direction { 1 } else { 0 } | if disable { 1 << 1 } else { 0 },
3155                         cltv_expiry_delta: 144,
3156                         htlc_minimum_msat: 1000000,
3157                         htlc_maximum_msat: 131355275467161,
3158                         fee_base_msat: 10000,
3159                         fee_proportional_millionths: 20,
3160                         excess_data: if excess_data { vec![0, 0, 0, 0, 59, 154, 202, 0] } else { Vec::new() }
3161                 };
3162                 let channel_update = msgs::ChannelUpdate {
3163                         signature: sig_1,
3164                         contents: unsigned_channel_update
3165                 };
3166                 let encoded_value = channel_update.encode();
3167                 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3168                 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3169                 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d013413a7").unwrap());
3170                 target_value.append(&mut <Vec<u8>>::from_hex("01").unwrap());
3171                 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3172                 if direction {
3173                         let flag = target_value.last_mut().unwrap();
3174                         *flag = 1;
3175                 }
3176                 if disable {
3177                         let flag = target_value.last_mut().unwrap();
3178                         *flag = *flag | 1 << 1;
3179                 }
3180                 target_value.append(&mut <Vec<u8>>::from_hex("009000000000000f42400000271000000014").unwrap());
3181                 target_value.append(&mut <Vec<u8>>::from_hex("0000777788889999").unwrap());
3182                 if excess_data {
3183                         target_value.append(&mut <Vec<u8>>::from_hex("000000003b9aca00").unwrap());
3184                 }
3185                 assert_eq!(encoded_value, target_value);
3186         }
3187
3188         #[test]
3189         fn encoding_channel_update() {
3190                 do_encoding_channel_update(false, false, false);
3191                 do_encoding_channel_update(false, false, true);
3192                 do_encoding_channel_update(true, false, false);
3193                 do_encoding_channel_update(true, false, true);
3194                 do_encoding_channel_update(false, true, false);
3195                 do_encoding_channel_update(false, true, true);
3196                 do_encoding_channel_update(true, true, false);
3197                 do_encoding_channel_update(true, true, true);
3198         }
3199
3200         fn do_encoding_open_channel(random_bit: bool, shutdown: bool, incl_chan_type: bool) {
3201                 let secp_ctx = Secp256k1::new();
3202                 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3203                 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3204                 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3205                 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3206                 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3207                 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3208                 let open_channel = msgs::OpenChannel {
3209                         chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3210                         temporary_channel_id: ChannelId::from_bytes([2; 32]),
3211                         funding_satoshis: 1311768467284833366,
3212                         push_msat: 2536655962884945560,
3213                         dust_limit_satoshis: 3608586615801332854,
3214                         max_htlc_value_in_flight_msat: 8517154655701053848,
3215                         channel_reserve_satoshis: 8665828695742877976,
3216                         htlc_minimum_msat: 2316138423780173,
3217                         feerate_per_kw: 821716,
3218                         to_self_delay: 49340,
3219                         max_accepted_htlcs: 49340,
3220                         funding_pubkey: pubkey_1,
3221                         revocation_basepoint: pubkey_2,
3222                         payment_point: pubkey_3,
3223                         delayed_payment_basepoint: pubkey_4,
3224                         htlc_basepoint: pubkey_5,
3225                         first_per_commitment_point: pubkey_6,
3226                         channel_flags: if random_bit { 1 << 5 } else { 0 },
3227                         shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3228                         channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3229                 };
3230                 let encoded_value = open_channel.encode();
3231                 let mut target_value = Vec::new();
3232                 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3233                 target_value.append(&mut <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202021234567890123456233403289122369832144668701144767633030896203198784335490624111800083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3234                 if random_bit {
3235                         target_value.append(&mut <Vec<u8>>::from_hex("20").unwrap());
3236                 } else {
3237                         target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3238                 }
3239                 if shutdown {
3240                         target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3241                 }
3242                 if incl_chan_type {
3243                         target_value.append(&mut <Vec<u8>>::from_hex("0100").unwrap());
3244                 }
3245                 assert_eq!(encoded_value, target_value);
3246         }
3247
3248         #[test]
3249         fn encoding_open_channel() {
3250                 do_encoding_open_channel(false, false, false);
3251                 do_encoding_open_channel(false, false, true);
3252                 do_encoding_open_channel(false, true, false);
3253                 do_encoding_open_channel(false, true, true);
3254                 do_encoding_open_channel(true, false, false);
3255                 do_encoding_open_channel(true, false, true);
3256                 do_encoding_open_channel(true, true, false);
3257                 do_encoding_open_channel(true, true, true);
3258         }
3259
3260         fn do_encoding_open_channelv2(random_bit: bool, shutdown: bool, incl_chan_type: bool, require_confirmed_inputs: bool) {
3261                 let secp_ctx = Secp256k1::new();
3262                 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3263                 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3264                 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3265                 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3266                 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3267                 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3268                 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3269                 let open_channelv2 = msgs::OpenChannelV2 {
3270                         chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3271                         temporary_channel_id: ChannelId::from_bytes([2; 32]),
3272                         funding_feerate_sat_per_1000_weight: 821716,
3273                         commitment_feerate_sat_per_1000_weight: 821716,
3274                         funding_satoshis: 1311768467284833366,
3275                         dust_limit_satoshis: 3608586615801332854,
3276                         max_htlc_value_in_flight_msat: 8517154655701053848,
3277                         htlc_minimum_msat: 2316138423780173,
3278                         to_self_delay: 49340,
3279                         max_accepted_htlcs: 49340,
3280                         locktime: 305419896,
3281                         funding_pubkey: pubkey_1,
3282                         revocation_basepoint: pubkey_2,
3283                         payment_basepoint: pubkey_3,
3284                         delayed_payment_basepoint: pubkey_4,
3285                         htlc_basepoint: pubkey_5,
3286                         first_per_commitment_point: pubkey_6,
3287                         second_per_commitment_point: pubkey_7,
3288                         channel_flags: if random_bit { 1 << 5 } else { 0 },
3289                         shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3290                         channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3291                         require_confirmed_inputs: if require_confirmed_inputs { Some(()) } else { None },
3292                 };
3293                 let encoded_value = open_channelv2.encode();
3294                 let mut target_value = Vec::new();
3295                 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3296                 target_value.append(&mut <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap());
3297                 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap());
3298                 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap());
3299                 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap());
3300                 target_value.append(&mut <Vec<u8>>::from_hex("3214466870114476").unwrap());
3301                 target_value.append(&mut <Vec<u8>>::from_hex("7633030896203198").unwrap());
3302                 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d").unwrap());
3303                 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap());
3304                 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap());
3305                 target_value.append(&mut <Vec<u8>>::from_hex("12345678").unwrap());
3306                 target_value.append(&mut <Vec<u8>>::from_hex("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap());
3307                 target_value.append(&mut <Vec<u8>>::from_hex("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap());
3308                 target_value.append(&mut <Vec<u8>>::from_hex("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap());
3309                 target_value.append(&mut <Vec<u8>>::from_hex("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
3310                 target_value.append(&mut <Vec<u8>>::from_hex("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap());
3311                 target_value.append(&mut <Vec<u8>>::from_hex("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3312                 target_value.append(&mut <Vec<u8>>::from_hex("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap());
3313
3314                 if random_bit {
3315                         target_value.append(&mut <Vec<u8>>::from_hex("20").unwrap());
3316                 } else {
3317                         target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3318                 }
3319                 if shutdown {
3320                         target_value.append(&mut <Vec<u8>>::from_hex("001b").unwrap()); // Type 0 + Length 27
3321                         target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3322                 }
3323                 if incl_chan_type {
3324                         target_value.append(&mut <Vec<u8>>::from_hex("0100").unwrap());
3325                 }
3326                 if require_confirmed_inputs {
3327                         target_value.append(&mut <Vec<u8>>::from_hex("0200").unwrap());
3328                 }
3329                 assert_eq!(encoded_value, target_value);
3330         }
3331
3332         #[test]
3333         fn encoding_open_channelv2() {
3334                 do_encoding_open_channelv2(false, false, false, false);
3335                 do_encoding_open_channelv2(false, false, false, true);
3336                 do_encoding_open_channelv2(false, false, true, false);
3337                 do_encoding_open_channelv2(false, false, true, true);
3338                 do_encoding_open_channelv2(false, true, false, false);
3339                 do_encoding_open_channelv2(false, true, false, true);
3340                 do_encoding_open_channelv2(false, true, true, false);
3341                 do_encoding_open_channelv2(false, true, true, true);
3342                 do_encoding_open_channelv2(true, false, false, false);
3343                 do_encoding_open_channelv2(true, false, false, true);
3344                 do_encoding_open_channelv2(true, false, true, false);
3345                 do_encoding_open_channelv2(true, false, true, true);
3346                 do_encoding_open_channelv2(true, true, false, false);
3347                 do_encoding_open_channelv2(true, true, false, true);
3348                 do_encoding_open_channelv2(true, true, true, false);
3349                 do_encoding_open_channelv2(true, true, true, true);
3350         }
3351
3352         fn do_encoding_accept_channel(shutdown: bool) {
3353                 let secp_ctx = Secp256k1::new();
3354                 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3355                 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3356                 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3357                 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3358                 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3359                 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3360                 let accept_channel = msgs::AcceptChannel {
3361                         temporary_channel_id: ChannelId::from_bytes([2; 32]),
3362                         dust_limit_satoshis: 1311768467284833366,
3363                         max_htlc_value_in_flight_msat: 2536655962884945560,
3364                         channel_reserve_satoshis: 3608586615801332854,
3365                         htlc_minimum_msat: 2316138423780173,
3366                         minimum_depth: 821716,
3367                         to_self_delay: 49340,
3368                         max_accepted_htlcs: 49340,
3369                         funding_pubkey: pubkey_1,
3370                         revocation_basepoint: pubkey_2,
3371                         payment_point: pubkey_3,
3372                         delayed_payment_basepoint: pubkey_4,
3373                         htlc_basepoint: pubkey_5,
3374                         first_per_commitment_point: pubkey_6,
3375                         shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3376                         channel_type: None,
3377                         #[cfg(taproot)]
3378                         next_local_nonce: None,
3379                 };
3380                 let encoded_value = accept_channel.encode();
3381                 let mut target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020212345678901234562334032891223698321446687011447600083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap();
3382                 if shutdown {
3383                         target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3384                 }
3385                 assert_eq!(encoded_value, target_value);
3386         }
3387
3388         #[test]
3389         fn encoding_accept_channel() {
3390                 do_encoding_accept_channel(false);
3391                 do_encoding_accept_channel(true);
3392         }
3393
3394         fn do_encoding_accept_channelv2(shutdown: bool) {
3395                 let secp_ctx = Secp256k1::new();
3396                 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3397                 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3398                 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3399                 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3400                 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3401                 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3402                 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3403                 let accept_channelv2 = msgs::AcceptChannelV2 {
3404                         temporary_channel_id: ChannelId::from_bytes([2; 32]),
3405                         funding_satoshis: 1311768467284833366,
3406                         dust_limit_satoshis: 1311768467284833366,
3407                         max_htlc_value_in_flight_msat: 2536655962884945560,
3408                         htlc_minimum_msat: 2316138423780173,
3409                         minimum_depth: 821716,
3410                         to_self_delay: 49340,
3411                         max_accepted_htlcs: 49340,
3412                         funding_pubkey: pubkey_1,
3413                         revocation_basepoint: pubkey_2,
3414                         payment_basepoint: pubkey_3,
3415                         delayed_payment_basepoint: pubkey_4,
3416                         htlc_basepoint: pubkey_5,
3417                         first_per_commitment_point: pubkey_6,
3418                         second_per_commitment_point: pubkey_7,
3419                         shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3420                         channel_type: None,
3421                         require_confirmed_inputs: None,
3422                 };
3423                 let encoded_value = accept_channelv2.encode();
3424                 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // temporary_channel_id
3425                 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap()); // funding_satoshis
3426                 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap()); // dust_limit_satoshis
3427                 target_value.append(&mut <Vec<u8>>::from_hex("2334032891223698").unwrap()); // max_htlc_value_in_flight_msat
3428                 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d").unwrap()); // htlc_minimum_msat
3429                 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap()); //  minimum_depth
3430                 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap()); // to_self_delay
3431                 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap()); // max_accepted_htlcs
3432                 target_value.append(&mut <Vec<u8>>::from_hex("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap()); // funding_pubkey
3433                 target_value.append(&mut <Vec<u8>>::from_hex("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap()); // revocation_basepoint
3434                 target_value.append(&mut <Vec<u8>>::from_hex("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap()); // payment_basepoint
3435                 target_value.append(&mut <Vec<u8>>::from_hex("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap()); // delayed_payment_basepoint
3436                 target_value.append(&mut <Vec<u8>>::from_hex("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap()); // htlc_basepoint
3437                 target_value.append(&mut <Vec<u8>>::from_hex("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap()); // first_per_commitment_point
3438                 target_value.append(&mut <Vec<u8>>::from_hex("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap()); // second_per_commitment_point
3439                 if shutdown {
3440                         target_value.append(&mut <Vec<u8>>::from_hex("001b").unwrap()); // Type 0 + Length 27
3441                         target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3442                 }
3443                 assert_eq!(encoded_value, target_value);
3444         }
3445
3446         #[test]
3447         fn encoding_accept_channelv2() {
3448                 do_encoding_accept_channelv2(false);
3449                 do_encoding_accept_channelv2(true);
3450         }
3451
3452         #[test]
3453         fn encoding_funding_created() {
3454                 let secp_ctx = Secp256k1::new();
3455                 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3456                 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3457                 let funding_created = msgs::FundingCreated {
3458                         temporary_channel_id: ChannelId::from_bytes([2; 32]),
3459                         funding_txid: Txid::from_str("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3460                         funding_output_index: 255,
3461                         signature: sig_1,
3462                         #[cfg(taproot)]
3463                         partial_signature_with_nonce: None,
3464                         #[cfg(taproot)]
3465                         next_local_nonce: None,
3466                 };
3467                 let encoded_value = funding_created.encode();
3468                 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202026e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c200ffd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3469                 assert_eq!(encoded_value, target_value);
3470         }
3471
3472         #[test]
3473         fn encoding_funding_signed() {
3474                 let secp_ctx = Secp256k1::new();
3475                 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3476                 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3477                 let funding_signed = msgs::FundingSigned {
3478                         channel_id: ChannelId::from_bytes([2; 32]),
3479                         signature: sig_1,
3480                         #[cfg(taproot)]
3481                         partial_signature_with_nonce: None,
3482                 };
3483                 let encoded_value = funding_signed.encode();
3484                 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3485                 assert_eq!(encoded_value, target_value);
3486         }
3487
3488         #[test]
3489         fn encoding_channel_ready() {
3490                 let secp_ctx = Secp256k1::new();
3491                 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3492                 let channel_ready = msgs::ChannelReady {
3493                         channel_id: ChannelId::from_bytes([2; 32]),
3494                         next_per_commitment_point: pubkey_1,
3495                         short_channel_id_alias: None,
3496                 };
3497                 let encoded_value = channel_ready.encode();
3498                 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3499                 assert_eq!(encoded_value, target_value);
3500         }
3501
3502         #[test]
3503         fn encoding_splice() {
3504                 let secp_ctx = Secp256k1::new();
3505                 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3506                 let splice = msgs::Splice {
3507                         chain_hash: ChainHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
3508                         channel_id: ChannelId::from_bytes([2; 32]),
3509                         relative_satoshis: 123456,
3510                         funding_feerate_perkw: 2000,
3511                         locktime: 0,
3512                         funding_pubkey: pubkey_1,
3513                 };
3514                 let encoded_value = splice.encode();
3515                 assert_eq!(encoded_value.as_hex().to_string(), "02020202020202020202020202020202020202020202020202020202020202026fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000000000000001e240000007d000000000031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f");
3516         }
3517
3518         #[test]
3519         fn encoding_stfu() {
3520                 let stfu = msgs::Stfu {
3521                         channel_id: ChannelId::from_bytes([2; 32]),
3522                         initiator: 1,
3523                 };
3524                 let encoded_value = stfu.encode();
3525                 assert_eq!(encoded_value.as_hex().to_string(), "020202020202020202020202020202020202020202020202020202020202020201");
3526         }
3527
3528         #[test]
3529         fn encoding_splice_ack() {
3530                 let secp_ctx = Secp256k1::new();
3531                 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3532                 let splice = msgs::SpliceAck {
3533                         chain_hash: ChainHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
3534                         channel_id: ChannelId::from_bytes([2; 32]),
3535                         relative_satoshis: 123456,
3536                         funding_pubkey: pubkey_1,
3537                 };
3538                 let encoded_value = splice.encode();
3539                 assert_eq!(encoded_value.as_hex().to_string(), "02020202020202020202020202020202020202020202020202020202020202026fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000000000000001e240031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f");
3540         }
3541
3542         #[test]
3543         fn encoding_splice_locked() {
3544                 let splice = msgs::SpliceLocked {
3545                         channel_id: ChannelId::from_bytes([2; 32]),
3546                 };
3547                 let encoded_value = splice.encode();
3548                 assert_eq!(encoded_value.as_hex().to_string(), "0202020202020202020202020202020202020202020202020202020202020202");
3549         }
3550
3551         #[test]
3552         fn encoding_tx_add_input() {
3553                 let tx_add_input = msgs::TxAddInput {
3554                         channel_id: ChannelId::from_bytes([2; 32]),
3555                         serial_id: 4886718345,
3556                         prevtx: TransactionU16LenLimited::new(Transaction {
3557                                 version: 2,
3558                                 lock_time: LockTime::ZERO,
3559                                 input: vec![TxIn {
3560                                         previous_output: OutPoint { txid: Txid::from_str("305bab643ee297b8b6b76b320792c8223d55082122cb606bf89382146ced9c77").unwrap(), index: 2 }.into_bitcoin_outpoint(),
3561                                         script_sig: ScriptBuf::new(),
3562                                         sequence: Sequence(0xfffffffd),
3563                                         witness: Witness::from_slice(&vec![
3564                                                 <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3565                                                 <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3566                                 }],
3567                                 output: vec![
3568                                         TxOut {
3569                                                 value: 12704566,
3570                                                 script_pubkey: Address::from_str("bc1qzlffunw52jav8vwdu5x3jfk6sr8u22rmq3xzw2").unwrap().payload.script_pubkey(),
3571                                         },
3572                                         TxOut {
3573                                                 value: 245148,
3574                                                 script_pubkey: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().payload.script_pubkey(),
3575                                         },
3576                                 ],
3577                         }).unwrap(),
3578                         prevtx_out: 305419896,
3579                         sequence: 305419896,
3580                 };
3581                 let encoded_value = tx_add_input.encode();
3582                 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000000012345678900de02000000000101779ced6c148293f86b60cb222108553d22c89207326bb7b6b897e23e64ab5b300200000000fdffffff0236dbc1000000000016001417d29e4dd454bac3b1cde50d1926da80cfc5287b9cbd03000000000016001436ec78d514df462da95e6a00c24daa8915362d420247304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701210301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944000000001234567812345678").unwrap();
3583                 assert_eq!(encoded_value, target_value);
3584         }
3585
3586         #[test]
3587         fn encoding_tx_add_output() {
3588                 let tx_add_output = msgs::TxAddOutput {
3589                         channel_id: ChannelId::from_bytes([2; 32]),
3590                         serial_id: 4886718345,
3591                         sats: 4886718345,
3592                         script: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().payload.script_pubkey(),
3593                 };
3594                 let encoded_value = tx_add_output.encode();
3595                 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000000012345678900000001234567890016001436ec78d514df462da95e6a00c24daa8915362d42").unwrap();
3596                 assert_eq!(encoded_value, target_value);
3597         }
3598
3599         #[test]
3600         fn encoding_tx_remove_input() {
3601                 let tx_remove_input = msgs::TxRemoveInput {
3602                         channel_id: ChannelId::from_bytes([2; 32]),
3603                         serial_id: 4886718345,
3604                 };
3605                 let encoded_value = tx_remove_input.encode();
3606                 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3607                 assert_eq!(encoded_value, target_value);
3608         }
3609
3610         #[test]
3611         fn encoding_tx_remove_output() {
3612                 let tx_remove_output = msgs::TxRemoveOutput {
3613                         channel_id: ChannelId::from_bytes([2; 32]),
3614                         serial_id: 4886718345,
3615                 };
3616                 let encoded_value = tx_remove_output.encode();
3617                 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3618                 assert_eq!(encoded_value, target_value);
3619         }
3620
3621         #[test]
3622         fn encoding_tx_complete() {
3623                 let tx_complete = msgs::TxComplete {
3624                         channel_id: ChannelId::from_bytes([2; 32]),
3625                 };
3626                 let encoded_value = tx_complete.encode();
3627                 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3628                 assert_eq!(encoded_value, target_value);
3629         }
3630
3631         #[test]
3632         fn encoding_tx_signatures() {
3633                 let tx_signatures = msgs::TxSignatures {
3634                         channel_id: ChannelId::from_bytes([2; 32]),
3635                         tx_hash: Txid::from_str("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3636                         witnesses: vec![
3637                                 Witness::from_slice(&vec![
3638                                         <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3639                                         <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3640                                 Witness::from_slice(&vec![
3641                                         <Vec<u8>>::from_hex("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap(),
3642                                         <Vec<u8>>::from_hex("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap()]),
3643                         ],
3644                 };
3645                 let encoded_value = tx_signatures.encode();
3646                 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3647                 target_value.append(&mut <Vec<u8>>::from_hex("6e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c2").unwrap()); // tx_hash (sha256) (big endian byte order)
3648                 target_value.append(&mut <Vec<u8>>::from_hex("0002").unwrap()); // num_witnesses (u16)
3649                 // Witness 1
3650                 target_value.append(&mut <Vec<u8>>::from_hex("006b").unwrap()); // len of witness_data
3651                 target_value.append(&mut <Vec<u8>>::from_hex("02").unwrap()); // num_witness_elements (VarInt)
3652                 target_value.append(&mut <Vec<u8>>::from_hex("47").unwrap()); // len of witness element data (VarInt)
3653                 target_value.append(&mut <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap());
3654                 target_value.append(&mut <Vec<u8>>::from_hex("21").unwrap()); // len of witness element data (VarInt)
3655                 target_value.append(&mut <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap());
3656                 // Witness 2
3657                 target_value.append(&mut <Vec<u8>>::from_hex("006c").unwrap()); // len of witness_data
3658                 target_value.append(&mut <Vec<u8>>::from_hex("02").unwrap()); // num_witness_elements (VarInt)
3659                 target_value.append(&mut <Vec<u8>>::from_hex("48").unwrap()); // len of witness element data (VarInt)
3660                 target_value.append(&mut <Vec<u8>>::from_hex("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap());
3661                 target_value.append(&mut <Vec<u8>>::from_hex("21").unwrap()); // len of witness element data (VarInt)
3662                 target_value.append(&mut <Vec<u8>>::from_hex("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap());
3663                 assert_eq!(encoded_value, target_value);
3664         }
3665
3666         fn do_encoding_tx_init_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3667                 let tx_init_rbf = msgs::TxInitRbf {
3668                         channel_id: ChannelId::from_bytes([2; 32]),
3669                         locktime: 305419896,
3670                         feerate_sat_per_1000_weight: 20190119,
3671                         funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3672                 };
3673                 let encoded_value = tx_init_rbf.encode();
3674                 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3675                 target_value.append(&mut <Vec<u8>>::from_hex("12345678").unwrap()); // locktime
3676                 target_value.append(&mut <Vec<u8>>::from_hex("013413a7").unwrap()); // feerate_sat_per_1000_weight
3677                 if let Some((_, target)) = funding_value_with_hex_target {
3678                         target_value.push(0x00); // Type
3679                         target_value.push(target.len() as u8 / 2); // Length
3680                         target_value.append(&mut <Vec<u8>>::from_hex(target).unwrap()); // Value (i64)
3681                 }
3682                 assert_eq!(encoded_value, target_value);
3683         }
3684
3685         #[test]
3686         fn encoding_tx_init_rbf() {
3687                 do_encoding_tx_init_rbf(Some((1311768467284833366, "1234567890123456")));
3688                 do_encoding_tx_init_rbf(Some((13117684672, "000000030DDFFBC0")));
3689                 do_encoding_tx_init_rbf(None);
3690         }
3691
3692         fn do_encoding_tx_ack_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3693                 let tx_ack_rbf = msgs::TxAckRbf {
3694                         channel_id: ChannelId::from_bytes([2; 32]),
3695                         funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3696                 };
3697                 let encoded_value = tx_ack_rbf.encode();
3698                 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3699                 if let Some((_, target)) = funding_value_with_hex_target {
3700                         target_value.push(0x00); // Type
3701                         target_value.push(target.len() as u8 / 2); // Length
3702                         target_value.append(&mut <Vec<u8>>::from_hex(target).unwrap()); // Value (i64)
3703                 }
3704                 assert_eq!(encoded_value, target_value);
3705         }
3706
3707         #[test]
3708         fn encoding_tx_ack_rbf() {
3709                 do_encoding_tx_ack_rbf(Some((1311768467284833366, "1234567890123456")));
3710                 do_encoding_tx_ack_rbf(Some((13117684672, "000000030DDFFBC0")));
3711                 do_encoding_tx_ack_rbf(None);
3712         }
3713
3714         #[test]
3715         fn encoding_tx_abort() {
3716                 let tx_abort = msgs::TxAbort {
3717                         channel_id: ChannelId::from_bytes([2; 32]),
3718                         data: <Vec<u8>>::from_hex("54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap(),
3719                 };
3720                 let encoded_value = tx_abort.encode();
3721                 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202002C54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap();
3722                 assert_eq!(encoded_value, target_value);
3723         }
3724
3725         fn do_encoding_shutdown(script_type: u8) {
3726                 let secp_ctx = Secp256k1::new();
3727                 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3728                 let script = Builder::new().push_opcode(opcodes::OP_TRUE).into_script();
3729                 let shutdown = msgs::Shutdown {
3730                         channel_id: ChannelId::from_bytes([2; 32]),
3731                         scriptpubkey:
3732                                 if script_type == 1 { Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey() }
3733                                 else if script_type == 2 { Address::p2sh(&script, Network::Testnet).unwrap().script_pubkey() }
3734                                 else if script_type == 3 { Address::p2wpkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).unwrap().script_pubkey() }
3735                                 else { Address::p2wsh(&script, Network::Testnet).script_pubkey() },
3736                 };
3737                 let encoded_value = shutdown.encode();
3738                 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3739                 if script_type == 1 {
3740                         target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3741                 } else if script_type == 2 {
3742                         target_value.append(&mut <Vec<u8>>::from_hex("0017a914da1745e9b549bd0bfa1a569971c77eba30cd5a4b87").unwrap());
3743                 } else if script_type == 3 {
3744                         target_value.append(&mut <Vec<u8>>::from_hex("0016001479b000887626b294a914501a4cd226b58b235983").unwrap());
3745                 } else if script_type == 4 {
3746                         target_value.append(&mut <Vec<u8>>::from_hex("002200204ae81572f06e1b88fd5ced7a1a000945432e83e1551e6f721ee9c00b8cc33260").unwrap());
3747                 }
3748                 assert_eq!(encoded_value, target_value);
3749         }
3750
3751         #[test]
3752         fn encoding_shutdown() {
3753                 do_encoding_shutdown(1);
3754                 do_encoding_shutdown(2);
3755                 do_encoding_shutdown(3);
3756                 do_encoding_shutdown(4);
3757         }
3758
3759         #[test]
3760         fn encoding_closing_signed() {
3761                 let secp_ctx = Secp256k1::new();
3762                 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3763                 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3764                 let closing_signed = msgs::ClosingSigned {
3765                         channel_id: ChannelId::from_bytes([2; 32]),
3766                         fee_satoshis: 2316138423780173,
3767                         signature: sig_1,
3768                         fee_range: None,
3769                 };
3770                 let encoded_value = closing_signed.encode();
3771                 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3772                 assert_eq!(encoded_value, target_value);
3773                 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value)).unwrap(), closing_signed);
3774
3775                 let closing_signed_with_range = msgs::ClosingSigned {
3776                         channel_id: ChannelId::from_bytes([2; 32]),
3777                         fee_satoshis: 2316138423780173,
3778                         signature: sig_1,
3779                         fee_range: Some(msgs::ClosingSignedFeeRange {
3780                                 min_fee_satoshis: 0xdeadbeef,
3781                                 max_fee_satoshis: 0x1badcafe01234567,
3782                         }),
3783                 };
3784                 let encoded_value_with_range = closing_signed_with_range.encode();
3785                 let target_value_with_range = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a011000000000deadbeef1badcafe01234567").unwrap();
3786                 assert_eq!(encoded_value_with_range, target_value_with_range);
3787                 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value_with_range)).unwrap(),
3788                         closing_signed_with_range);
3789         }
3790
3791         #[test]
3792         fn encoding_update_add_htlc() {
3793                 let secp_ctx = Secp256k1::new();
3794                 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3795                 let onion_routing_packet = msgs::OnionPacket {
3796                         version: 255,
3797                         public_key: Ok(pubkey_1),
3798                         hop_data: [1; 20*65],
3799                         hmac: [2; 32]
3800                 };
3801                 let update_add_htlc = msgs::UpdateAddHTLC {
3802                         channel_id: ChannelId::from_bytes([2; 32]),
3803                         htlc_id: 2316138423780173,
3804                         amount_msat: 3608586615801332854,
3805                         payment_hash: PaymentHash([1; 32]),
3806                         cltv_expiry: 821716,
3807                         onion_routing_packet,
3808                         skimmed_fee_msat: None,
3809                         blinding_point: None,
3810                 };
3811                 let encoded_value = update_add_htlc.encode();
3812                 let target_value = <Vec<u8>>::from_hex("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").unwrap();
3813                 assert_eq!(encoded_value, target_value);
3814         }
3815
3816         #[test]
3817         fn encoding_update_fulfill_htlc() {
3818                 let update_fulfill_htlc = msgs::UpdateFulfillHTLC {
3819                         channel_id: ChannelId::from_bytes([2; 32]),
3820                         htlc_id: 2316138423780173,
3821                         payment_preimage: PaymentPreimage([1; 32]),
3822                 };
3823                 let encoded_value = update_fulfill_htlc.encode();
3824                 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d0101010101010101010101010101010101010101010101010101010101010101").unwrap();
3825                 assert_eq!(encoded_value, target_value);
3826         }
3827
3828         #[test]
3829         fn encoding_update_fail_htlc() {
3830                 let reason = OnionErrorPacket {
3831                         data: [1; 32].to_vec(),
3832                 };
3833                 let update_fail_htlc = msgs::UpdateFailHTLC {
3834                         channel_id: ChannelId::from_bytes([2; 32]),
3835                         htlc_id: 2316138423780173,
3836                         reason
3837                 };
3838                 let encoded_value = update_fail_htlc.encode();
3839                 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d00200101010101010101010101010101010101010101010101010101010101010101").unwrap();
3840                 assert_eq!(encoded_value, target_value);
3841         }
3842
3843         #[test]
3844         fn encoding_update_fail_malformed_htlc() {
3845                 let update_fail_malformed_htlc = msgs::UpdateFailMalformedHTLC {
3846                         channel_id: ChannelId::from_bytes([2; 32]),
3847                         htlc_id: 2316138423780173,
3848                         sha256_of_onion: [1; 32],
3849                         failure_code: 255
3850                 };
3851                 let encoded_value = update_fail_malformed_htlc.encode();
3852                 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d010101010101010101010101010101010101010101010101010101010101010100ff").unwrap();
3853                 assert_eq!(encoded_value, target_value);
3854         }
3855
3856         fn do_encoding_commitment_signed(htlcs: bool) {
3857                 let secp_ctx = Secp256k1::new();
3858                 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3859                 let (privkey_2, _) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3860                 let (privkey_3, _) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3861                 let (privkey_4, _) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3862                 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3863                 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
3864                 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
3865                 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
3866                 let commitment_signed = msgs::CommitmentSigned {
3867                         channel_id: ChannelId::from_bytes([2; 32]),
3868                         signature: sig_1,
3869                         htlc_signatures: if htlcs { vec![sig_2, sig_3, sig_4] } else { Vec::new() },
3870                         #[cfg(taproot)]
3871                         partial_signature_with_nonce: None,
3872                 };
3873                 let encoded_value = commitment_signed.encode();
3874                 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3875                 if htlcs {
3876                         target_value.append(&mut <Vec<u8>>::from_hex("00031735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
3877                 } else {
3878                         target_value.append(&mut <Vec<u8>>::from_hex("0000").unwrap());
3879                 }
3880                 assert_eq!(encoded_value, target_value);
3881         }
3882
3883         #[test]
3884         fn encoding_commitment_signed() {
3885                 do_encoding_commitment_signed(true);
3886                 do_encoding_commitment_signed(false);
3887         }
3888
3889         #[test]
3890         fn encoding_revoke_and_ack() {
3891                 let secp_ctx = Secp256k1::new();
3892                 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3893                 let raa = msgs::RevokeAndACK {
3894                         channel_id: ChannelId::from_bytes([2; 32]),
3895                         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],
3896                         next_per_commitment_point: pubkey_1,
3897                         #[cfg(taproot)]
3898                         next_local_nonce: None,
3899                 };
3900                 let encoded_value = raa.encode();
3901                 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020101010101010101010101010101010101010101010101010101010101010101031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3902                 assert_eq!(encoded_value, target_value);
3903         }
3904
3905         #[test]
3906         fn encoding_update_fee() {
3907                 let update_fee = msgs::UpdateFee {
3908                         channel_id: ChannelId::from_bytes([2; 32]),
3909                         feerate_per_kw: 20190119,
3910                 };
3911                 let encoded_value = update_fee.encode();
3912                 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202013413a7").unwrap();
3913                 assert_eq!(encoded_value, target_value);
3914         }
3915
3916         #[test]
3917         fn encoding_init() {
3918                 let mainnet_hash = ChainHash::using_genesis_block(Network::Bitcoin);
3919                 assert_eq!(msgs::Init {
3920                         features: InitFeatures::from_le_bytes(vec![0xFF, 0xFF, 0xFF]),
3921                         networks: Some(vec![mainnet_hash]),
3922                         remote_network_address: None,
3923                 }.encode(), <Vec<u8>>::from_hex("00023fff0003ffffff01206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3924                 assert_eq!(msgs::Init {
3925                         features: InitFeatures::from_le_bytes(vec![0xFF]),
3926                         networks: None,
3927                         remote_network_address: None,
3928                 }.encode(), <Vec<u8>>::from_hex("0001ff0001ff").unwrap());
3929                 assert_eq!(msgs::Init {
3930                         features: InitFeatures::from_le_bytes(vec![]),
3931                         networks: Some(vec![mainnet_hash]),
3932                         remote_network_address: None,
3933                 }.encode(), <Vec<u8>>::from_hex("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3934                 assert_eq!(msgs::Init {
3935                         features: InitFeatures::from_le_bytes(vec![]),
3936                         networks: Some(vec![ChainHash::from(&[1; 32]), ChainHash::from(&[2; 32])]),
3937                         remote_network_address: None,
3938                 }.encode(), <Vec<u8>>::from_hex("00000000014001010101010101010101010101010101010101010101010101010101010101010202020202020202020202020202020202020202020202020202020202020202").unwrap());
3939                 let init_msg = msgs::Init { features: InitFeatures::from_le_bytes(vec![]),
3940                         networks: Some(vec![mainnet_hash]),
3941                         remote_network_address: Some(SocketAddress::TcpIpV4 {
3942                                 addr: [127, 0, 0, 1],
3943                                 port: 1000,
3944                         }),
3945                 };
3946                 let encoded_value = init_msg.encode();
3947                 let target_value = <Vec<u8>>::from_hex("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d61900000000000307017f00000103e8").unwrap();
3948                 assert_eq!(encoded_value, target_value);
3949                 assert_eq!(msgs::Init::read(&mut Cursor::new(&target_value)).unwrap(), init_msg);
3950         }
3951
3952         #[test]
3953         fn encoding_error() {
3954                 let error = msgs::ErrorMessage {
3955                         channel_id: ChannelId::from_bytes([2; 32]),
3956                         data: String::from("rust-lightning"),
3957                 };
3958                 let encoded_value = error.encode();
3959                 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3960                 assert_eq!(encoded_value, target_value);
3961         }
3962
3963         #[test]
3964         fn encoding_warning() {
3965                 let error = msgs::WarningMessage {
3966                         channel_id: ChannelId::from_bytes([2; 32]),
3967                         data: String::from("rust-lightning"),
3968                 };
3969                 let encoded_value = error.encode();
3970                 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3971                 assert_eq!(encoded_value, target_value);
3972         }
3973
3974         #[test]
3975         fn encoding_ping() {
3976                 let ping = msgs::Ping {
3977                         ponglen: 64,
3978                         byteslen: 64
3979                 };
3980                 let encoded_value = ping.encode();
3981                 let target_value = <Vec<u8>>::from_hex("0040004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3982                 assert_eq!(encoded_value, target_value);
3983         }
3984
3985         #[test]
3986         fn encoding_pong() {
3987                 let pong = msgs::Pong {
3988                         byteslen: 64
3989                 };
3990                 let encoded_value = pong.encode();
3991                 let target_value = <Vec<u8>>::from_hex("004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3992                 assert_eq!(encoded_value, target_value);
3993         }
3994
3995         #[test]
3996         fn encoding_nonfinal_onion_hop_data() {
3997                 let outbound_msg = msgs::OutboundOnionPayload::Forward {
3998                         short_channel_id: 0xdeadbeef1bad1dea,
3999                         amt_to_forward: 0x0badf00d01020304,
4000                         outgoing_cltv_value: 0xffffffff,
4001                 };
4002                 let encoded_value = outbound_msg.encode();
4003                 let target_value = <Vec<u8>>::from_hex("1a02080badf00d010203040404ffffffff0608deadbeef1bad1dea").unwrap();
4004                 assert_eq!(encoded_value, target_value);
4005
4006                 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4007                 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4008                 if let msgs::InboundOnionPayload::Forward {
4009                         short_channel_id, amt_to_forward, outgoing_cltv_value
4010                 } = inbound_msg {
4011                         assert_eq!(short_channel_id, 0xdeadbeef1bad1dea);
4012                         assert_eq!(amt_to_forward, 0x0badf00d01020304);
4013                         assert_eq!(outgoing_cltv_value, 0xffffffff);
4014                 } else { panic!(); }
4015         }
4016
4017         #[test]
4018         fn encoding_final_onion_hop_data() {
4019                 let outbound_msg = msgs::OutboundOnionPayload::Receive {
4020                         payment_data: None,
4021                         payment_metadata: None,
4022                         keysend_preimage: None,
4023                         sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4024                         cltv_expiry_height: 0xffffffff,
4025                         custom_tlvs: vec![],
4026                 };
4027                 let encoded_value = outbound_msg.encode();
4028                 let target_value = <Vec<u8>>::from_hex("1002080badf00d010203040404ffffffff").unwrap();
4029                 assert_eq!(encoded_value, target_value);
4030
4031                 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4032                 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4033                 if let msgs::InboundOnionPayload::Receive {
4034                         payment_data: None, sender_intended_htlc_amt_msat, cltv_expiry_height, ..
4035                 } = inbound_msg {
4036                         assert_eq!(sender_intended_htlc_amt_msat, 0x0badf00d01020304);
4037                         assert_eq!(cltv_expiry_height, 0xffffffff);
4038                 } else { panic!(); }
4039         }
4040
4041         #[test]
4042         fn encoding_final_onion_hop_data_with_secret() {
4043                 let expected_payment_secret = PaymentSecret([0x42u8; 32]);
4044                 let outbound_msg = msgs::OutboundOnionPayload::Receive {
4045                         payment_data: Some(FinalOnionHopData {
4046                                 payment_secret: expected_payment_secret,
4047                                 total_msat: 0x1badca1f
4048                         }),
4049                         payment_metadata: None,
4050                         keysend_preimage: None,
4051                         sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4052                         cltv_expiry_height: 0xffffffff,
4053                         custom_tlvs: vec![],
4054                 };
4055                 let encoded_value = outbound_msg.encode();
4056                 let target_value = <Vec<u8>>::from_hex("3602080badf00d010203040404ffffffff082442424242424242424242424242424242424242424242424242424242424242421badca1f").unwrap();
4057                 assert_eq!(encoded_value, target_value);
4058
4059                 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4060                 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4061                 if let msgs::InboundOnionPayload::Receive {
4062                         payment_data: Some(FinalOnionHopData {
4063                                 payment_secret,
4064                                 total_msat: 0x1badca1f
4065                         }),
4066                         sender_intended_htlc_amt_msat, cltv_expiry_height,
4067                         payment_metadata: None,
4068                         keysend_preimage: None,
4069                         custom_tlvs,
4070                 } = inbound_msg  {
4071                         assert_eq!(payment_secret, expected_payment_secret);
4072                         assert_eq!(sender_intended_htlc_amt_msat, 0x0badf00d01020304);
4073                         assert_eq!(cltv_expiry_height, 0xffffffff);
4074                         assert_eq!(custom_tlvs, vec![]);
4075                 } else { panic!(); }
4076         }
4077
4078         #[test]
4079         fn encoding_final_onion_hop_data_with_bad_custom_tlvs() {
4080                 // If custom TLVs have type number within the range reserved for protocol, treat them as if
4081                 // they're unknown
4082                 let bad_type_range_tlvs = vec![
4083                         ((1 << 16) - 4, vec![42]),
4084                         ((1 << 16) - 2, vec![42; 32]),
4085                 ];
4086                 let mut msg = msgs::OutboundOnionPayload::Receive {
4087                         payment_data: None,
4088                         payment_metadata: None,
4089                         keysend_preimage: None,
4090                         custom_tlvs: bad_type_range_tlvs,
4091                         sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4092                         cltv_expiry_height: 0xffffffff,
4093                 };
4094                 let encoded_value = msg.encode();
4095                 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4096                 assert!(msgs::InboundOnionPayload::read(&mut Cursor::new(&encoded_value[..]), (None, &&node_signer)).is_err());
4097                 let good_type_range_tlvs = vec![
4098                         ((1 << 16) - 3, vec![42]),
4099                         ((1 << 16) - 1, vec![42; 32]),
4100                 ];
4101                 if let msgs::OutboundOnionPayload::Receive { ref mut custom_tlvs, .. } = msg {
4102                         *custom_tlvs = good_type_range_tlvs.clone();
4103                 }
4104                 let encoded_value = msg.encode();
4105                 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&encoded_value[..]), (None, &&node_signer)).unwrap();
4106                 match inbound_msg {
4107                         msgs::InboundOnionPayload::Receive { custom_tlvs, .. } => assert!(custom_tlvs.is_empty()),
4108                         _ => panic!(),
4109                 }
4110         }
4111
4112         #[test]
4113         fn encoding_final_onion_hop_data_with_custom_tlvs() {
4114                 let expected_custom_tlvs = vec![
4115                         (5482373483, vec![0x12, 0x34]),
4116                         (5482373487, vec![0x42u8; 8]),
4117                 ];
4118                 let msg = msgs::OutboundOnionPayload::Receive {
4119                         payment_data: None,
4120                         payment_metadata: None,
4121                         keysend_preimage: None,
4122                         custom_tlvs: expected_custom_tlvs.clone(),
4123                         sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4124                         cltv_expiry_height: 0xffffffff,
4125                 };
4126                 let encoded_value = msg.encode();
4127                 let target_value = <Vec<u8>>::from_hex("2e02080badf00d010203040404ffffffffff0000000146c6616b021234ff0000000146c6616f084242424242424242").unwrap();
4128                 assert_eq!(encoded_value, target_value);
4129                 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4130                 let inbound_msg: msgs::InboundOnionPayload = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4131                 if let msgs::InboundOnionPayload::Receive {
4132                         payment_data: None,
4133                         payment_metadata: None,
4134                         keysend_preimage: None,
4135                         custom_tlvs,
4136                         sender_intended_htlc_amt_msat,
4137                         cltv_expiry_height: outgoing_cltv_value,
4138                         ..
4139                 } = inbound_msg {
4140                         assert_eq!(custom_tlvs, expected_custom_tlvs);
4141                         assert_eq!(sender_intended_htlc_amt_msat, 0x0badf00d01020304);
4142                         assert_eq!(outgoing_cltv_value, 0xffffffff);
4143                 } else { panic!(); }
4144         }
4145
4146         #[test]
4147         fn query_channel_range_end_blocknum() {
4148                 let tests: Vec<(u32, u32, u32)> = vec![
4149                         (10000, 1500, 11500),
4150                         (0, 0xffffffff, 0xffffffff),
4151                         (1, 0xffffffff, 0xffffffff),
4152                 ];
4153
4154                 for (first_blocknum, number_of_blocks, expected) in tests.into_iter() {
4155                         let sut = msgs::QueryChannelRange {
4156                                 chain_hash: ChainHash::using_genesis_block(Network::Regtest),
4157                                 first_blocknum,
4158                                 number_of_blocks,
4159                         };
4160                         assert_eq!(sut.end_blocknum(), expected);
4161                 }
4162         }
4163
4164         #[test]
4165         fn encoding_query_channel_range() {
4166                 let mut query_channel_range = msgs::QueryChannelRange {
4167                         chain_hash: ChainHash::using_genesis_block(Network::Regtest),
4168                         first_blocknum: 100000,
4169                         number_of_blocks: 1500,
4170                 };
4171                 let encoded_value = query_channel_range.encode();
4172                 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000186a0000005dc").unwrap();
4173                 assert_eq!(encoded_value, target_value);
4174
4175                 query_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4176                 assert_eq!(query_channel_range.first_blocknum, 100000);
4177                 assert_eq!(query_channel_range.number_of_blocks, 1500);
4178         }
4179
4180         #[test]
4181         fn encoding_reply_channel_range() {
4182                 do_encoding_reply_channel_range(0);
4183                 do_encoding_reply_channel_range(1);
4184         }
4185
4186         fn do_encoding_reply_channel_range(encoding_type: u8) {
4187                 let mut target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000b8a06000005dc01").unwrap();
4188                 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4189                 let mut reply_channel_range = msgs::ReplyChannelRange {
4190                         chain_hash: expected_chain_hash,
4191                         first_blocknum: 756230,
4192                         number_of_blocks: 1500,
4193                         sync_complete: true,
4194                         short_channel_ids: vec![0x000000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
4195                 };
4196
4197                 if encoding_type == 0 {
4198                         target_value.append(&mut <Vec<u8>>::from_hex("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
4199                         let encoded_value = reply_channel_range.encode();
4200                         assert_eq!(encoded_value, target_value);
4201
4202                         reply_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4203                         assert_eq!(reply_channel_range.chain_hash, expected_chain_hash);
4204                         assert_eq!(reply_channel_range.first_blocknum, 756230);
4205                         assert_eq!(reply_channel_range.number_of_blocks, 1500);
4206                         assert_eq!(reply_channel_range.sync_complete, true);
4207                         assert_eq!(reply_channel_range.short_channel_ids[0], 0x000000000000008e);
4208                         assert_eq!(reply_channel_range.short_channel_ids[1], 0x0000000000003c69);
4209                         assert_eq!(reply_channel_range.short_channel_ids[2], 0x000000000045a6c4);
4210                 } else {
4211                         target_value.append(&mut <Vec<u8>>::from_hex("001601789c636000833e08659309a65878be010010a9023a").unwrap());
4212                         let result: Result<msgs::ReplyChannelRange, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
4213                         assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
4214                 }
4215         }
4216
4217         #[test]
4218         fn encoding_query_short_channel_ids() {
4219                 do_encoding_query_short_channel_ids(0);
4220                 do_encoding_query_short_channel_ids(1);
4221         }
4222
4223         fn do_encoding_query_short_channel_ids(encoding_type: u8) {
4224                 let mut target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
4225                 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4226                 let mut query_short_channel_ids = msgs::QueryShortChannelIds {
4227                         chain_hash: expected_chain_hash,
4228                         short_channel_ids: vec![0x0000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
4229                 };
4230
4231                 if encoding_type == 0 {
4232                         target_value.append(&mut <Vec<u8>>::from_hex("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
4233                         let encoded_value = query_short_channel_ids.encode();
4234                         assert_eq!(encoded_value, target_value);
4235
4236                         query_short_channel_ids = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4237                         assert_eq!(query_short_channel_ids.chain_hash, expected_chain_hash);
4238                         assert_eq!(query_short_channel_ids.short_channel_ids[0], 0x000000000000008e);
4239                         assert_eq!(query_short_channel_ids.short_channel_ids[1], 0x0000000000003c69);
4240                         assert_eq!(query_short_channel_ids.short_channel_ids[2], 0x000000000045a6c4);
4241                 } else {
4242                         target_value.append(&mut <Vec<u8>>::from_hex("001601789c636000833e08659309a65878be010010a9023a").unwrap());
4243                         let result: Result<msgs::QueryShortChannelIds, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
4244                         assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
4245                 }
4246         }
4247
4248         #[test]
4249         fn encoding_reply_short_channel_ids_end() {
4250                 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4251                 let mut reply_short_channel_ids_end = msgs::ReplyShortChannelIdsEnd {
4252                         chain_hash: expected_chain_hash,
4253                         full_information: true,
4254                 };
4255                 let encoded_value = reply_short_channel_ids_end.encode();
4256                 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f01").unwrap();
4257                 assert_eq!(encoded_value, target_value);
4258
4259                 reply_short_channel_ids_end = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4260                 assert_eq!(reply_short_channel_ids_end.chain_hash, expected_chain_hash);
4261                 assert_eq!(reply_short_channel_ids_end.full_information, true);
4262         }
4263
4264         #[test]
4265         fn encoding_gossip_timestamp_filter(){
4266                 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4267                 let mut gossip_timestamp_filter = msgs::GossipTimestampFilter {
4268                         chain_hash: expected_chain_hash,
4269                         first_timestamp: 1590000000,
4270                         timestamp_range: 0xffff_ffff,
4271                 };
4272                 let encoded_value = gossip_timestamp_filter.encode();
4273                 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f5ec57980ffffffff").unwrap();
4274                 assert_eq!(encoded_value, target_value);
4275
4276                 gossip_timestamp_filter = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4277                 assert_eq!(gossip_timestamp_filter.chain_hash, expected_chain_hash);
4278                 assert_eq!(gossip_timestamp_filter.first_timestamp, 1590000000);
4279                 assert_eq!(gossip_timestamp_filter.timestamp_range, 0xffff_ffff);
4280         }
4281
4282         #[test]
4283         fn decode_onion_hop_data_len_as_bigsize() {
4284                 // Tests that we can decode an onion payload that is >253 bytes.
4285                 // Previously, receiving a payload of this size could've caused us to fail to decode a valid
4286                 // payload, because we were decoding the length (a BigSize, big-endian) as a VarInt
4287                 // (little-endian).
4288
4289                 // Encode a test onion payload with a big custom TLV such that it's >253 bytes, forcing the
4290                 // payload length to be encoded over multiple bytes rather than a single u8.
4291                 let big_payload = encode_big_payload().unwrap();
4292                 let mut rd = Cursor::new(&big_payload[..]);
4293
4294                 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4295                 <msgs::InboundOnionPayload as ReadableArgs<(Option<PublicKey>, &&test_utils::TestKeysInterface)>>
4296                         ::read(&mut rd, (None, &&node_signer)).unwrap();
4297         }
4298         // see above test, needs to be a separate method for use of the serialization macros.
4299         fn encode_big_payload() -> Result<Vec<u8>, io::Error> {
4300                 use crate::util::ser::HighZeroBytesDroppedBigSize;
4301                 let payload = msgs::OutboundOnionPayload::Forward {
4302                         short_channel_id: 0xdeadbeef1bad1dea,
4303                         amt_to_forward: 1000,
4304                         outgoing_cltv_value: 0xffffffff,
4305                 };
4306                 let mut encoded_payload = Vec::new();
4307                 let test_bytes = vec![42u8; 1000];
4308                 if let msgs::OutboundOnionPayload::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } = payload {
4309                         _encode_varint_length_prefixed_tlv!(&mut encoded_payload, {
4310                                 (1, test_bytes, required_vec),
4311                                 (2, HighZeroBytesDroppedBigSize(amt_to_forward), required),
4312                                 (4, HighZeroBytesDroppedBigSize(outgoing_cltv_value), required),
4313                                 (6, short_channel_id, required)
4314                         });
4315                 }
4316                 Ok(encoded_payload)
4317         }
4318
4319         #[test]
4320         #[cfg(feature = "std")]
4321         fn test_socket_address_from_str() {
4322                 let tcpip_v4 = SocketAddress::TcpIpV4 {
4323                         addr: Ipv4Addr::new(127, 0, 0, 1).octets(),
4324                         port: 1234,
4325                 };
4326                 assert_eq!(tcpip_v4, SocketAddress::from_str("127.0.0.1:1234").unwrap());
4327                 assert_eq!(tcpip_v4, SocketAddress::from_str(&tcpip_v4.to_string()).unwrap());
4328
4329                 let tcpip_v6 = SocketAddress::TcpIpV6 {
4330                         addr: Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1).octets(),
4331                         port: 1234,
4332                 };
4333                 assert_eq!(tcpip_v6, SocketAddress::from_str("[0:0:0:0:0:0:0:1]:1234").unwrap());
4334                 assert_eq!(tcpip_v6, SocketAddress::from_str(&tcpip_v6.to_string()).unwrap());
4335
4336                 let hostname = SocketAddress::Hostname {
4337                                 hostname: Hostname::try_from("lightning-node.mydomain.com".to_string()).unwrap(),
4338                                 port: 1234,
4339                 };
4340                 assert_eq!(hostname, SocketAddress::from_str("lightning-node.mydomain.com:1234").unwrap());
4341                 assert_eq!(hostname, SocketAddress::from_str(&hostname.to_string()).unwrap());
4342
4343                 let onion_v2 = SocketAddress::OnionV2 ([40, 4, 64, 185, 202, 19, 162, 75, 90, 200, 38, 7],);
4344                 assert_eq!("OnionV2([40, 4, 64, 185, 202, 19, 162, 75, 90, 200, 38, 7])", &onion_v2.to_string());
4345                 assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("FACEBOOKCOREWWWI.onion:9735"));
4346
4347                 let onion_v3 = SocketAddress::OnionV3 {
4348                         ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102, 182, 107, 4, 105, 247, 246, 85,
4349                         111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31, 33, 71, 3],
4350                         checksum: 48326,
4351                         version: 121,
4352                         port: 1234
4353                 };
4354                 assert_eq!(onion_v3, SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion:1234").unwrap());
4355                 assert_eq!(onion_v3, SocketAddress::from_str(&onion_v3.to_string()).unwrap());
4356
4357                 assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6.onion:1234"));
4358                 assert_eq!(Err(SocketAddressParseError::InvalidInput), SocketAddress::from_str("127.0.0.1@1234"));
4359                 assert_eq!(Err(SocketAddressParseError::InvalidInput), "".parse::<SocketAddress>());
4360                 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:9735:94").is_err());
4361                 assert!(SocketAddress::from_str("wrong$%#.com:1234").is_err());
4362                 assert_eq!(Err(SocketAddressParseError::InvalidPort), SocketAddress::from_str("example.com:wrong"));
4363                 assert!("localhost".parse::<SocketAddress>().is_err());
4364                 assert!("localhost:invalid-port".parse::<SocketAddress>().is_err());
4365                 assert!( "invalid-onion-v3-hostname.onion:8080".parse::<SocketAddress>().is_err());
4366                 assert!("b32.example.onion:invalid-port".parse::<SocketAddress>().is_err());
4367                 assert!("invalid-address".parse::<SocketAddress>().is_err());
4368                 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:1234").is_err());
4369         }
4370
4371         #[test]
4372         #[cfg(feature = "std")]
4373         fn test_socket_address_to_socket_addrs() {
4374                 assert_eq!(SocketAddress::TcpIpV4 {addr:[0u8; 4], port: 1337,}.to_socket_addrs().unwrap().next().unwrap(),
4375                                    SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(0,0,0,0), 1337)));
4376                 assert_eq!(SocketAddress::TcpIpV6 {addr:[0u8; 16], port: 1337,}.to_socket_addrs().unwrap().next().unwrap(),
4377                                    SocketAddr::V6(SocketAddrV6::new(Ipv6Addr::from([0u8; 16]), 1337, 0, 0)));
4378                 assert_eq!(SocketAddress::Hostname { hostname: Hostname::try_from("0.0.0.0".to_string()).unwrap(), port: 0 }
4379                                            .to_socket_addrs().unwrap().next().unwrap(), SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::from([0u8; 4]),0)));
4380                 assert!(SocketAddress::OnionV2([0u8; 12]).to_socket_addrs().is_err());
4381                 assert!(SocketAddress::OnionV3{ ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102,
4382                         182, 107, 4, 105, 247, 246, 85, 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31,
4383                         33, 71, 3],
4384                         checksum: 48326,
4385                         version: 121,
4386                         port: 1234 }.to_socket_addrs().is_err());
4387         }
4388 }