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