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