git.bitcoin.ninja Git - rust-lightning/blob - lightning/src/ln/msgs.rs

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