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