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