_ Git - rust-lightning/blob - lightning/src/ln/msgs.rs

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