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

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