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

   1 use secp256k1::key::PublicKey;
   2 use secp256k1::{Secp256k1, Signature};
   3 use secp256k1;
   4 use bitcoin::util::hash::Sha256dHash;
   5 use bitcoin::network::serialize::{deserialize,serialize};
   6 use bitcoin::blockdata::script::Script;
   7
   8 use std::error::Error;
   9 use std::{cmp, fmt};
  10 use std::io::Read;
  11 use std::result::Result;
  12
  13 use util::{byte_utils, internal_traits, events};
  14 use util::ser::{Readable, Writeable, Writer};
  15
  16 pub trait MsgEncodable {
  17         fn encode(&self) -> Vec<u8>;
  18         #[inline]
  19         fn encoded_len(&self) -> usize { self.encode().len() }
  20         #[inline]
  21         fn encode_with_len(&self) -> Vec<u8> {
  22                 let enc = self.encode();
  23                 let mut res = Vec::with_capacity(enc.len() + 2);
  24                 res.extend_from_slice(&byte_utils::be16_to_array(enc.len() as u16));
  25                 res.extend_from_slice(&enc);
  26                 res
  27         }
  28 }
  29 #[derive(Debug)]
  30 pub enum DecodeError {
  31         /// Unknown realm byte in an OnionHopData packet
  32         UnknownRealmByte,
  33         /// Unknown feature mandating we fail to parse message
  34         UnknownRequiredFeature,
  35         /// Failed to decode a public key (ie it's invalid)
  36         BadPublicKey,
  37         /// Failed to decode a signature (ie it's invalid)
  38         BadSignature,
  39         /// Value expected to be text wasn't decodable as text
  40         BadText,
  41         /// Buffer too short
  42         ShortRead,
  43         /// node_announcement included more than one address of a given type!
  44         ExtraAddressesPerType,
  45         /// A length descriptor in the packet didn't describe the later data correctly
  46         /// (currently only generated in node_announcement)
  47         BadLengthDescriptor,
  48         /// Error from std::io
  49         Io(::std::io::Error),
  50         /// 1 or 0 is not found for boolean value
  51         InvalidValue,
  52 }
  53 pub trait MsgDecodable: Sized {
  54         fn decode(v: &[u8]) -> Result<Self, DecodeError>;
  55 }
  56
  57 /// Tracks localfeatures which are only in init messages
  58 #[derive(Clone, PartialEq)]
  59 pub struct LocalFeatures {
  60         flags: Vec<u8>,
  61 }
  62
  63 impl LocalFeatures {
  64         pub fn new() -> LocalFeatures {
  65                 LocalFeatures {
  66                         flags: Vec::new(),
  67                 }
  68         }
  69
  70         pub fn supports_data_loss_protect(&self) -> bool {
  71                 self.flags.len() > 0 && (self.flags[0] & 3) != 0
  72         }
  73         pub fn requires_data_loss_protect(&self) -> bool {
  74                 self.flags.len() > 0 && (self.flags[0] & 1) != 0
  75         }
  76
  77         pub fn initial_routing_sync(&self) -> bool {
  78                 self.flags.len() > 0 && (self.flags[0] & (1 << 3)) != 0
  79         }
  80         pub fn set_initial_routing_sync(&mut self) {
  81                 if self.flags.len() == 0 {
  82                         self.flags.resize(1, 1 << 3);
  83                 } else {
  84                         self.flags[0] |= 1 << 3;
  85                 }
  86         }
  87
  88         pub fn supports_upfront_shutdown_script(&self) -> bool {
  89                 self.flags.len() > 0 && (self.flags[0] & (3 << 4)) != 0
  90         }
  91         pub fn requires_upfront_shutdown_script(&self) -> bool {
  92                 self.flags.len() > 0 && (self.flags[0] & (1 << 4)) != 0
  93         }
  94
  95         pub fn requires_unknown_bits(&self) -> bool {
  96                 for (idx, &byte) in self.flags.iter().enumerate() {
  97                         if idx != 0 && (byte & 0x55) != 0 {
  98                                 return true;
  99                         } else if idx == 0 && (byte & 0x14) != 0 {
 100                                 return true;
 101                         }
 102                 }
 103                 return false;
 104         }
 105
 106         pub fn supports_unknown_bits(&self) -> bool {
 107                 for (idx, &byte) in self.flags.iter().enumerate() {
 108                         if idx != 0 && byte != 0 {
 109                                 return true;
 110                         } else if idx == 0 && (byte & 0xc4) != 0 {
 111                                 return true;
 112                         }
 113                 }
 114                 return false;
 115         }
 116 }
 117
 118 /// Tracks globalfeatures which are in init messages and routing announcements
 119 #[derive(Clone, PartialEq)]
 120 pub struct GlobalFeatures {
 121         flags: Vec<u8>,
 122 }
 123
 124 impl GlobalFeatures {
 125         pub fn new() -> GlobalFeatures {
 126                 GlobalFeatures {
 127                         flags: Vec::new(),
 128                 }
 129         }
 130
 131         pub fn requires_unknown_bits(&self) -> bool {
 132                 for &byte in self.flags.iter() {
 133                         if (byte & 0x55) != 0 {
 134                                 return true;
 135                         }
 136                 }
 137                 return false;
 138         }
 139
 140         pub fn supports_unknown_bits(&self) -> bool {
 141                 for &byte in self.flags.iter() {
 142                         if byte != 0 {
 143                                 return true;
 144                         }
 145                 }
 146                 return false;
 147         }
 148 }
 149
 150 pub struct Init {
 151         pub global_features: GlobalFeatures,
 152         pub local_features: LocalFeatures,
 153 }
 154
 155 pub struct ErrorMessage {
 156         pub channel_id: [u8; 32],
 157         pub data: String,
 158 }
 159
 160 pub struct Ping {
 161         pub ponglen: u16,
 162         pub byteslen: u16,
 163 }
 164
 165 pub struct Pong {
 166         pub byteslen: u16,
 167 }
 168
 169 pub struct OpenChannel {
 170         pub chain_hash: Sha256dHash,
 171         pub temporary_channel_id: [u8; 32],
 172         pub funding_satoshis: u64,
 173         pub push_msat: u64,
 174         pub dust_limit_satoshis: u64,
 175         pub max_htlc_value_in_flight_msat: u64,
 176         pub channel_reserve_satoshis: u64,
 177         pub htlc_minimum_msat: u64,
 178         pub feerate_per_kw: u32,
 179         pub to_self_delay: u16,
 180         pub max_accepted_htlcs: u16,
 181         pub funding_pubkey: PublicKey,
 182         pub revocation_basepoint: PublicKey,
 183         pub payment_basepoint: PublicKey,
 184         pub delayed_payment_basepoint: PublicKey,
 185         pub htlc_basepoint: PublicKey,
 186         pub first_per_commitment_point: PublicKey,
 187         pub channel_flags: u8,
 188         pub shutdown_scriptpubkey: Option<Script>,
 189 }
 190
 191 pub struct AcceptChannel {
 192         pub temporary_channel_id: [u8; 32],
 193         pub dust_limit_satoshis: u64,
 194         pub max_htlc_value_in_flight_msat: u64,
 195         pub channel_reserve_satoshis: u64,
 196         pub htlc_minimum_msat: u64,
 197         pub minimum_depth: u32,
 198         pub to_self_delay: u16,
 199         pub max_accepted_htlcs: u16,
 200         pub funding_pubkey: PublicKey,
 201         pub revocation_basepoint: PublicKey,
 202         pub payment_basepoint: PublicKey,
 203         pub delayed_payment_basepoint: PublicKey,
 204         pub htlc_basepoint: PublicKey,
 205         pub first_per_commitment_point: PublicKey,
 206         pub shutdown_scriptpubkey: Option<Script>,
 207 }
 208
 209 pub struct FundingCreated {
 210         pub temporary_channel_id: [u8; 32],
 211         pub funding_txid: Sha256dHash,
 212         pub funding_output_index: u16,
 213         pub signature: Signature,
 214 }
 215
 216 pub struct FundingSigned {
 217         pub channel_id: [u8; 32],
 218         pub signature: Signature,
 219 }
 220
 221 pub struct FundingLocked {
 222         pub channel_id: [u8; 32],
 223         pub next_per_commitment_point: PublicKey,
 224 }
 225
 226 pub struct Shutdown {
 227         pub channel_id: [u8; 32],
 228         pub scriptpubkey: Script,
 229 }
 230
 231 pub struct ClosingSigned {
 232         pub channel_id: [u8; 32],
 233         pub fee_satoshis: u64,
 234         pub signature: Signature,
 235 }
 236
 237 #[derive(Clone)]
 238 pub struct UpdateAddHTLC {
 239         pub channel_id: [u8; 32],
 240         pub htlc_id: u64,
 241         pub amount_msat: u64,
 242         pub payment_hash: [u8; 32],
 243         pub cltv_expiry: u32,
 244         pub onion_routing_packet: OnionPacket,
 245 }
 246
 247 #[derive(Clone)]
 248 pub struct UpdateFulfillHTLC {
 249         pub channel_id: [u8; 32],
 250         pub htlc_id: u64,
 251         pub payment_preimage: [u8; 32],
 252 }
 253
 254 #[derive(Clone)]
 255 pub struct UpdateFailHTLC {
 256         pub channel_id: [u8; 32],
 257         pub htlc_id: u64,
 258         pub reason: OnionErrorPacket,
 259 }
 260
 261 #[derive(Clone)]
 262 pub struct UpdateFailMalformedHTLC {
 263         pub channel_id: [u8; 32],
 264         pub htlc_id: u64,
 265         pub sha256_of_onion: [u8; 32],
 266         pub failure_code: u16,
 267 }
 268
 269 #[derive(Clone)]
 270 pub struct CommitmentSigned {
 271         pub channel_id: [u8; 32],
 272         pub signature: Signature,
 273         pub htlc_signatures: Vec<Signature>,
 274 }
 275
 276 pub struct RevokeAndACK {
 277         pub channel_id: [u8; 32],
 278         pub per_commitment_secret: [u8; 32],
 279         pub next_per_commitment_point: PublicKey,
 280 }
 281
 282 pub struct UpdateFee {
 283         pub channel_id: [u8; 32],
 284         pub feerate_per_kw: u32,
 285 }
 286
 287 pub struct DataLossProtect {
 288         pub your_last_per_commitment_secret: [u8; 32],
 289         pub my_current_per_commitment_point: PublicKey,
 290 }
 291
 292 pub struct ChannelReestablish {
 293         pub channel_id: [u8; 32],
 294         pub next_local_commitment_number: u64,
 295         pub next_remote_commitment_number: u64,
 296         pub data_loss_protect: Option<DataLossProtect>,
 297 }
 298
 299 #[derive(Clone)]
 300 pub struct AnnouncementSignatures {
 301         pub channel_id: [u8; 32],
 302         pub short_channel_id: u64,
 303         pub node_signature: Signature,
 304         pub bitcoin_signature: Signature,
 305 }
 306
 307 #[derive(Clone)]
 308 pub enum NetAddress {
 309         IPv4 {
 310                 addr: [u8; 4],
 311                 port: u16,
 312         },
 313         IPv6 {
 314                 addr: [u8; 16],
 315                 port: u16,
 316         },
 317         OnionV2 {
 318                 addr: [u8; 10],
 319                 port: u16,
 320         },
 321         OnionV3 {
 322                 ed25519_pubkey: [u8; 32],
 323                 checksum: u16,
 324                 version: u8,
 325                 port: u16,
 326         },
 327 }
 328 impl NetAddress {
 329         fn get_id(&self) -> u8 {
 330                 match self {
 331                         &NetAddress::IPv4 {..} => { 1 },
 332                         &NetAddress::IPv6 {..} => { 2 },
 333                         &NetAddress::OnionV2 {..} => { 3 },
 334                         &NetAddress::OnionV3 {..} => { 4 },
 335                 }
 336         }
 337 }
 338
 339 pub struct UnsignedNodeAnnouncement {
 340         pub features: GlobalFeatures,
 341         pub timestamp: u32,
 342         pub node_id: PublicKey,
 343         pub rgb: [u8; 3],
 344         pub alias: [u8; 32],
 345         /// List of addresses on which this node is reachable. Note that you may only have up to one
 346         /// address of each type, if you have more, they may be silently discarded or we may panic!
 347         pub addresses: Vec<NetAddress>,
 348         pub excess_address_data: Vec<u8>,
 349         pub excess_data: Vec<u8>,
 350 }
 351 pub struct NodeAnnouncement {
 352         pub signature: Signature,
 353         pub contents: UnsignedNodeAnnouncement,
 354 }
 355
 356 #[derive(PartialEq, Clone)]
 357 pub struct UnsignedChannelAnnouncement {
 358         pub features: GlobalFeatures,
 359         pub chain_hash: Sha256dHash,
 360         pub short_channel_id: u64,
 361         pub node_id_1: PublicKey,
 362         pub node_id_2: PublicKey,
 363         pub bitcoin_key_1: PublicKey,
 364         pub bitcoin_key_2: PublicKey,
 365         pub excess_data: Vec<u8>,
 366 }
 367 #[derive(PartialEq, Clone)]
 368 pub struct ChannelAnnouncement {
 369         pub node_signature_1: Signature,
 370         pub node_signature_2: Signature,
 371         pub bitcoin_signature_1: Signature,
 372         pub bitcoin_signature_2: Signature,
 373         pub contents: UnsignedChannelAnnouncement,
 374 }
 375
 376 #[derive(PartialEq, Clone)]
 377 pub struct UnsignedChannelUpdate {
 378         pub chain_hash: Sha256dHash,
 379         pub short_channel_id: u64,
 380         pub timestamp: u32,
 381         pub flags: u16,
 382         pub cltv_expiry_delta: u16,
 383         pub htlc_minimum_msat: u64,
 384         pub fee_base_msat: u32,
 385         pub fee_proportional_millionths: u32,
 386         pub excess_data: Vec<u8>,
 387 }
 388 #[derive(PartialEq, Clone)]
 389 pub struct ChannelUpdate {
 390         pub signature: Signature,
 391         pub contents: UnsignedChannelUpdate,
 392 }
 393
 394 /// Used to put an error message in a HandleError
 395 pub enum ErrorAction {
 396         /// The peer took some action which made us think they were useless. Disconnect them.
 397         DisconnectPeer {
 398                 msg: Option<ErrorMessage>
 399         },
 400         /// The peer did something harmless that we weren't able to process, just log and ignore
 401         IgnoreError,
 402         /// The peer did something incorrect. Tell them.
 403         SendErrorMessage {
 404                 msg: ErrorMessage
 405         },
 406 }
 407
 408 pub struct HandleError { //TODO: rename me
 409         pub err: &'static str,
 410         pub action: Option<ErrorAction>, //TODO: Make this required
 411 }
 412
 413 /// Struct used to return values from revoke_and_ack messages, containing a bunch of commitment
 414 /// transaction updates if they were pending.
 415 pub struct CommitmentUpdate {
 416         pub update_add_htlcs: Vec<UpdateAddHTLC>,
 417         pub update_fulfill_htlcs: Vec<UpdateFulfillHTLC>,
 418         pub update_fail_htlcs: Vec<UpdateFailHTLC>,
 419         pub update_fail_malformed_htlcs: Vec<UpdateFailMalformedHTLC>,
 420         pub commitment_signed: CommitmentSigned,
 421 }
 422
 423 pub enum HTLCFailChannelUpdate {
 424         ChannelUpdateMessage {
 425                 msg: ChannelUpdate,
 426         },
 427         ChannelClosed {
 428                 short_channel_id: u64,
 429         },
 430 }
 431
 432 /// A trait to describe an object which can receive channel messages. Messages MAY be called in
 433 /// paralell when they originate from different their_node_ids, however they MUST NOT be called in
 434 /// paralell when the two calls have the same their_node_id.
 435 pub trait ChannelMessageHandler : events::EventsProvider + Send + Sync {
 436         //Channel init:
 437         fn handle_open_channel(&self, their_node_id: &PublicKey, msg: &OpenChannel) -> Result<AcceptChannel, HandleError>;
 438         fn handle_accept_channel(&self, their_node_id: &PublicKey, msg: &AcceptChannel) -> Result<(), HandleError>;
 439         fn handle_funding_created(&self, their_node_id: &PublicKey, msg: &FundingCreated) -> Result<FundingSigned, HandleError>;
 440         fn handle_funding_signed(&self, their_node_id: &PublicKey, msg: &FundingSigned) -> Result<(), HandleError>;
 441         fn handle_funding_locked(&self, their_node_id: &PublicKey, msg: &FundingLocked) -> Result<Option<AnnouncementSignatures>, HandleError>;
 442
 443         // Channl close:
 444         fn handle_shutdown(&self, their_node_id: &PublicKey, msg: &Shutdown) -> Result<(Option<Shutdown>, Option<ClosingSigned>), HandleError>;
 445         fn handle_closing_signed(&self, their_node_id: &PublicKey, msg: &ClosingSigned) -> Result<Option<ClosingSigned>, HandleError>;
 446
 447         // HTLC handling:
 448         fn handle_update_add_htlc(&self, their_node_id: &PublicKey, msg: &UpdateAddHTLC) -> Result<(), HandleError>;
 449         fn handle_update_fulfill_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFulfillHTLC) -> Result<(), HandleError>;
 450         fn handle_update_fail_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailHTLC) -> Result<Option<HTLCFailChannelUpdate>, HandleError>;
 451         fn handle_update_fail_malformed_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailMalformedHTLC) -> Result<(), HandleError>;
 452         fn handle_commitment_signed(&self, their_node_id: &PublicKey, msg: &CommitmentSigned) -> Result<(RevokeAndACK, Option<CommitmentSigned>), HandleError>;
 453         fn handle_revoke_and_ack(&self, their_node_id: &PublicKey, msg: &RevokeAndACK) -> Result<Option<CommitmentUpdate>, HandleError>;
 454
 455         fn handle_update_fee(&self, their_node_id: &PublicKey, msg: &UpdateFee) -> Result<(), HandleError>;
 456
 457         // Channel-to-announce:
 458         fn handle_announcement_signatures(&self, their_node_id: &PublicKey, msg: &AnnouncementSignatures) -> Result<(), HandleError>;
 459
 460         // Connection loss/reestablish:
 461         /// Indicates a connection to the peer failed/an existing connection was lost. If no connection
 462         /// is believed to be possible in the future (eg they're sending us messages we don't
 463         /// understand or indicate they require unknown feature bits), no_connection_possible is set
 464         /// and any outstanding channels should be failed.
 465         fn peer_disconnected(&self, their_node_id: &PublicKey, no_connection_possible: bool);
 466
 467         fn peer_connected(&self, their_node_id: &PublicKey) -> Vec<ChannelReestablish>;
 468         fn handle_channel_reestablish(&self, their_node_id: &PublicKey, msg: &ChannelReestablish) -> Result<(Option<FundingLocked>, Option<RevokeAndACK>, Option<CommitmentUpdate>), HandleError>;
 469
 470         // Error:
 471         fn handle_error(&self, their_node_id: &PublicKey, msg: &ErrorMessage);
 472 }
 473
 474 pub trait RoutingMessageHandler : Send + Sync {
 475         fn handle_node_announcement(&self, msg: &NodeAnnouncement) -> Result<bool, HandleError>;
 476         /// Handle a channel_announcement message, returning true if it should be forwarded on, false
 477         /// or returning an Err otherwise.
 478         fn handle_channel_announcement(&self, msg: &ChannelAnnouncement) -> Result<bool, HandleError>;
 479         fn handle_channel_update(&self, msg: &ChannelUpdate) -> Result<bool, HandleError>;
 480         fn handle_htlc_fail_channel_update(&self, update: &HTLCFailChannelUpdate);
 481 }
 482
 483 pub struct OnionRealm0HopData {
 484         pub short_channel_id: u64,
 485         pub amt_to_forward: u64,
 486         pub outgoing_cltv_value: u32,
 487         // 12 bytes of 0-padding
 488 }
 489
 490 pub struct OnionHopData {
 491         pub realm: u8,
 492         pub data: OnionRealm0HopData,
 493         pub hmac: [u8; 32],
 494 }
 495 unsafe impl internal_traits::NoDealloc for OnionHopData{}
 496
 497 #[derive(Clone)]
 498 pub struct OnionPacket {
 499         pub version: u8,
 500         /// In order to ensure we always return an error on Onion decode in compliance with BOLT 4, we
 501         /// have to deserialize OnionPackets contained in UpdateAddHTLCs even if the ephemeral public
 502         /// key (here) is bogus, so we hold a Result instead of a PublicKey as we'd like.
 503         pub public_key: Result<PublicKey, secp256k1::Error>,
 504         pub hop_data: [u8; 20*65],
 505         pub hmac: [u8; 32],
 506 }
 507
 508 pub struct DecodedOnionErrorPacket {
 509         pub hmac: [u8; 32],
 510         pub failuremsg: Vec<u8>,
 511         pub pad: Vec<u8>,
 512 }
 513
 514 #[derive(Clone)]
 515 pub struct OnionErrorPacket {
 516         // This really should be a constant size slice, but the spec lets these things be up to 128KB?
 517         // (TODO) We limit it in decode to much lower...
 518         pub data: Vec<u8>,
 519 }
 520
 521 impl Error for DecodeError {
 522         fn description(&self) -> &str {
 523                 match *self {
 524                         DecodeError::UnknownRealmByte => "Unknown realm byte in Onion packet",
 525                         DecodeError::UnknownRequiredFeature => "Unknown required feature preventing decode",
 526                         DecodeError::BadPublicKey => "Invalid public key in packet",
 527                         DecodeError::BadSignature => "Invalid signature in packet",
 528                         DecodeError::BadText => "Invalid text in packet",
 529                         DecodeError::ShortRead => "Packet extended beyond the provided bytes",
 530                         DecodeError::ExtraAddressesPerType => "More than one address of a single type",
 531                         DecodeError::BadLengthDescriptor => "A length descriptor in the packet didn't describe the later data correctly",
 532                         DecodeError::Io(ref e) => e.description(),
 533                         DecodeError::InvalidValue => "0 or 1 is not found for boolean",
 534                 }
 535         }
 536 }
 537 impl fmt::Display for DecodeError {
 538         fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 539                 f.write_str(self.description())
 540         }
 541 }
 542
 543 impl fmt::Debug for HandleError {
 544         fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 545                 f.write_str(self.err)
 546         }
 547 }
 548
 549 impl From<::std::io::Error> for DecodeError {
 550         fn from(e: ::std::io::Error) -> Self {
 551                 if e.kind() == ::std::io::ErrorKind::UnexpectedEof {
 552                         DecodeError::ShortRead
 553                 } else {
 554                         DecodeError::Io(e)
 555                 }
 556         }
 557 }
 558
 559 macro_rules! secp_pubkey {
 560         ( $ctx: expr, $slice: expr ) => {
 561                 match PublicKey::from_slice($ctx, $slice) {
 562                         Ok(key) => key,
 563                         Err(_) => return Err(DecodeError::BadPublicKey)
 564                 }
 565         };
 566 }
 567
 568 macro_rules! secp_signature {
 569         ( $ctx: expr, $slice: expr ) => {
 570                 match Signature::from_compact($ctx, $slice) {
 571                         Ok(sig) => sig,
 572                         Err(_) => return Err(DecodeError::BadSignature)
 573                 }
 574         };
 575 }
 576
 577 impl MsgDecodable for LocalFeatures {
 578         fn decode(v: &[u8]) -> Result<Self, DecodeError> {
 579                 if v.len() < 2 { return Err(DecodeError::ShortRead); }
 580                 let len = byte_utils::slice_to_be16(&v[0..2]) as usize;
 581                 if v.len() < len + 2 { return Err(DecodeError::ShortRead); }
 582                 let mut flags = Vec::with_capacity(len);
 583                 flags.extend_from_slice(&v[2..2 + len]);
 584                 Ok(Self {
 585                         flags: flags
 586                 })
 587         }
 588 }
 589 impl MsgEncodable for LocalFeatures {
 590         fn encode(&self) -> Vec<u8> {
 591                 let mut res = Vec::with_capacity(self.flags.len() + 2);
 592                 res.extend_from_slice(&byte_utils::be16_to_array(self.flags.len() as u16));
 593                 res.extend_from_slice(&self.flags[..]);
 594                 res
 595         }
 596         fn encoded_len(&self) -> usize { self.flags.len() + 2 }
 597 }
 598
 599 impl MsgDecodable for GlobalFeatures {
 600         fn decode(v: &[u8]) -> Result<Self, DecodeError> {
 601                 if v.len() < 2 { return Err(DecodeError::ShortRead); }
 602                 let len = byte_utils::slice_to_be16(&v[0..2]) as usize;
 603                 if v.len() < len + 2 { return Err(DecodeError::ShortRead); }
 604                 let mut flags = Vec::with_capacity(len);
 605                 flags.extend_from_slice(&v[2..2 + len]);
 606                 Ok(Self {
 607                         flags: flags
 608                 })
 609         }
 610 }
 611 impl MsgEncodable for GlobalFeatures {
 612         fn encode(&self) -> Vec<u8> {
 613                 let mut res = Vec::with_capacity(self.flags.len() + 2);
 614                 res.extend_from_slice(&byte_utils::be16_to_array(self.flags.len() as u16));
 615                 res.extend_from_slice(&self.flags[..]);
 616                 res
 617         }
 618         fn encoded_len(&self) -> usize { self.flags.len() + 2 }
 619 }
 620
 621 impl MsgDecodable for Init {
 622         fn decode(v: &[u8]) -> Result<Self, DecodeError> {
 623                 let global_features = GlobalFeatures::decode(v)?;
 624                 if v.len() < global_features.flags.len() + 4 {
 625                         return Err(DecodeError::ShortRead);
 626                 }
 627                 let local_features = LocalFeatures::decode(&v[global_features.flags.len() + 2..])?;
 628                 Ok(Self {
 629                         global_features: global_features,
 630                         local_features: local_features,
 631                 })
 632         }
 633 }
 634 impl MsgEncodable for Init {
 635         fn encode(&self) -> Vec<u8> {
 636                 let mut res = Vec::with_capacity(self.global_features.flags.len() + self.local_features.flags.len());
 637                 res.extend_from_slice(&self.global_features.encode()[..]);
 638                 res.extend_from_slice(&self.local_features.encode()[..]);
 639                 res
 640         }
 641 }
 642
 643 impl MsgDecodable for Ping {
 644         fn decode(v: &[u8]) -> Result<Self, DecodeError> {
 645                 if v.len() < 4 {
 646                         return Err(DecodeError::ShortRead);
 647                 }
 648                 let ponglen = byte_utils::slice_to_be16(&v[0..2]);
 649                 let byteslen = byte_utils::slice_to_be16(&v[2..4]);
 650                 if v.len() < 4 + byteslen as usize {
 651                         return Err(DecodeError::ShortRead);
 652                 }
 653                 Ok(Self {
 654                         ponglen,
 655                         byteslen,
 656                 })
 657         }
 658 }
 659 impl MsgEncodable for Ping {
 660         fn encode(&self) -> Vec<u8> {
 661                 let mut res = Vec::with_capacity(self.byteslen as usize + 2);
 662                 res.extend_from_slice(&byte_utils::be16_to_array(self.byteslen));
 663                 res.resize(2 + self.byteslen as usize, 0);
 664                 res
 665         }
 666 }
 667
 668 impl MsgDecodable for Pong {
 669         fn decode(v: &[u8]) -> Result<Self, DecodeError> {
 670                 if v.len() < 2 {
 671                         return Err(DecodeError::ShortRead);
 672                 }
 673                 let byteslen = byte_utils::slice_to_be16(&v[0..2]);
 674                 if v.len() < 2 + byteslen as usize {
 675                         return Err(DecodeError::ShortRead);
 676                 }
 677                 Ok(Self {
 678                         byteslen
 679                 })
 680         }
 681 }
 682 impl MsgEncodable for Pong {
 683         fn encode(&self) -> Vec<u8> {
 684                 let mut res = Vec::with_capacity(self.byteslen as usize + 2);
 685                 res.extend_from_slice(&byte_utils::be16_to_array(self.byteslen));
 686                 res.resize(2 + self.byteslen as usize, 0);
 687                 res
 688         }
 689 }
 690
 691 impl MsgDecodable for OpenChannel {
 692         fn decode(v: &[u8]) -> Result<Self, DecodeError> {
 693                 if v.len() < 2*32+6*8+4+2*2+6*33+1 {
 694                         return Err(DecodeError::ShortRead);
 695                 }
 696                 let ctx = Secp256k1::without_caps();
 697
 698                 let mut shutdown_scriptpubkey = None;
 699                 if v.len() >= 321 {
 700                         let len = byte_utils::slice_to_be16(&v[319..321]) as usize;
 701                         if v.len() < 321+len {
 702                                 return Err(DecodeError::ShortRead);
 703                         }
 704                         shutdown_scriptpubkey = Some(Script::from(v[321..321+len].to_vec()));
 705                 }
 706                 let mut temp_channel_id = [0; 32];
 707                 temp_channel_id[..].copy_from_slice(&v[32..64]);
 708                 Ok(OpenChannel {
 709                         chain_hash: deserialize(&v[0..32]).unwrap(),
 710                         temporary_channel_id: temp_channel_id,
 711                         funding_satoshis: byte_utils::slice_to_be64(&v[64..72]),
 712                         push_msat: byte_utils::slice_to_be64(&v[72..80]),
 713                         dust_limit_satoshis: byte_utils::slice_to_be64(&v[80..88]),
 714                         max_htlc_value_in_flight_msat: byte_utils::slice_to_be64(&v[88..96]),
 715                         channel_reserve_satoshis: byte_utils::slice_to_be64(&v[96..104]),
 716                         htlc_minimum_msat: byte_utils::slice_to_be64(&v[104..112]),
 717                         feerate_per_kw: byte_utils::slice_to_be32(&v[112..116]),
 718                         to_self_delay: byte_utils::slice_to_be16(&v[116..118]),
 719                         max_accepted_htlcs: byte_utils::slice_to_be16(&v[118..120]),
 720                         funding_pubkey: secp_pubkey!(&ctx, &v[120..153]),
 721                         revocation_basepoint: secp_pubkey!(&ctx, &v[153..186]),
 722                         payment_basepoint: secp_pubkey!(&ctx, &v[186..219]),
 723                         delayed_payment_basepoint: secp_pubkey!(&ctx, &v[219..252]),
 724                         htlc_basepoint: secp_pubkey!(&ctx, &v[252..285]),
 725                         first_per_commitment_point: secp_pubkey!(&ctx, &v[285..318]),
 726                         channel_flags: v[318],
 727                         shutdown_scriptpubkey: shutdown_scriptpubkey
 728                 })
 729         }
 730 }
 731 impl MsgEncodable for OpenChannel {
 732         fn encode(&self) -> Vec<u8> {
 733                 let mut res = match &self.shutdown_scriptpubkey {
 734                         &Some(ref script) => Vec::with_capacity(319 + 2 + script.len()),
 735                         &None => Vec::with_capacity(319),
 736                 };
 737                 res.extend_from_slice(&serialize(&self.chain_hash).unwrap());
 738                 res.extend_from_slice(&serialize(&self.temporary_channel_id).unwrap());
 739                 res.extend_from_slice(&byte_utils::be64_to_array(self.funding_satoshis));
 740                 res.extend_from_slice(&byte_utils::be64_to_array(self.push_msat));
 741                 res.extend_from_slice(&byte_utils::be64_to_array(self.dust_limit_satoshis));
 742                 res.extend_from_slice(&byte_utils::be64_to_array(self.max_htlc_value_in_flight_msat));
 743                 res.extend_from_slice(&byte_utils::be64_to_array(self.channel_reserve_satoshis));
 744                 res.extend_from_slice(&byte_utils::be64_to_array(self.htlc_minimum_msat));
 745                 res.extend_from_slice(&byte_utils::be32_to_array(self.feerate_per_kw));
 746                 res.extend_from_slice(&byte_utils::be16_to_array(self.to_self_delay));
 747                 res.extend_from_slice(&byte_utils::be16_to_array(self.max_accepted_htlcs));
 748                 res.extend_from_slice(&self.funding_pubkey.serialize());
 749                 res.extend_from_slice(&self.revocation_basepoint.serialize());
 750                 res.extend_from_slice(&self.payment_basepoint.serialize());
 751                 res.extend_from_slice(&self.delayed_payment_basepoint.serialize());
 752                 res.extend_from_slice(&self.htlc_basepoint.serialize());
 753                 res.extend_from_slice(&self.first_per_commitment_point.serialize());
 754                 res.push(self.channel_flags);
 755                 if let &Some(ref script) = &self.shutdown_scriptpubkey {
 756                         res.extend_from_slice(&byte_utils::be16_to_array(script.len() as u16));
 757                         res.extend_from_slice(&script[..]);
 758                 }
 759                 res
 760         }
 761 }
 762
 763 impl MsgDecodable for AcceptChannel {
 764         fn decode(v: &[u8]) -> Result<Self, DecodeError> {
 765                 if v.len() < 32+4*8+4+2*2+6*33 {
 766                         return Err(DecodeError::ShortRead);
 767                 }
 768                 let ctx = Secp256k1::without_caps();
 769
 770                 let mut shutdown_scriptpubkey = None;
 771                 if v.len() >= 272 {
 772                         let len = byte_utils::slice_to_be16(&v[270..272]) as usize;
 773                         if v.len() < 272+len {
 774                                 return Err(DecodeError::ShortRead);
 775                         }
 776                         shutdown_scriptpubkey = Some(Script::from(v[272..272+len].to_vec()));
 777                 }
 778
 779                 let mut temporary_channel_id = [0; 32];
 780                 temporary_channel_id[..].copy_from_slice(&v[0..32]);
 781                 Ok(Self {
 782                         temporary_channel_id,
 783                         dust_limit_satoshis: byte_utils::slice_to_be64(&v[32..40]),
 784                         max_htlc_value_in_flight_msat: byte_utils::slice_to_be64(&v[40..48]),
 785                         channel_reserve_satoshis: byte_utils::slice_to_be64(&v[48..56]),
 786                         htlc_minimum_msat: byte_utils::slice_to_be64(&v[56..64]),
 787                         minimum_depth: byte_utils::slice_to_be32(&v[64..68]),
 788                         to_self_delay: byte_utils::slice_to_be16(&v[68..70]),
 789                         max_accepted_htlcs: byte_utils::slice_to_be16(&v[70..72]),
 790                         funding_pubkey: secp_pubkey!(&ctx, &v[72..105]),
 791                         revocation_basepoint: secp_pubkey!(&ctx, &v[105..138]),
 792                         payment_basepoint: secp_pubkey!(&ctx, &v[138..171]),
 793                         delayed_payment_basepoint: secp_pubkey!(&ctx, &v[171..204]),
 794                         htlc_basepoint: secp_pubkey!(&ctx, &v[204..237]),
 795                         first_per_commitment_point: secp_pubkey!(&ctx, &v[237..270]),
 796                         shutdown_scriptpubkey: shutdown_scriptpubkey
 797                 })
 798         }
 799 }
 800 impl MsgEncodable for AcceptChannel {
 801         fn encode(&self) -> Vec<u8> {
 802                 let mut res = match &self.shutdown_scriptpubkey {
 803                         &Some(ref script) => Vec::with_capacity(270 + 2 + script.len()),
 804                         &None => Vec::with_capacity(270),
 805                 };
 806                 res.extend_from_slice(&self.temporary_channel_id);
 807                 res.extend_from_slice(&byte_utils::be64_to_array(self.dust_limit_satoshis));
 808                 res.extend_from_slice(&byte_utils::be64_to_array(self.max_htlc_value_in_flight_msat));
 809                 res.extend_from_slice(&byte_utils::be64_to_array(self.channel_reserve_satoshis));
 810                 res.extend_from_slice(&byte_utils::be64_to_array(self.htlc_minimum_msat));
 811                 res.extend_from_slice(&byte_utils::be32_to_array(self.minimum_depth));
 812                 res.extend_from_slice(&byte_utils::be16_to_array(self.to_self_delay));
 813                 res.extend_from_slice(&byte_utils::be16_to_array(self.max_accepted_htlcs));
 814                 res.extend_from_slice(&self.funding_pubkey.serialize());
 815                 res.extend_from_slice(&self.revocation_basepoint.serialize());
 816                 res.extend_from_slice(&self.payment_basepoint.serialize());
 817                 res.extend_from_slice(&self.delayed_payment_basepoint.serialize());
 818                 res.extend_from_slice(&self.htlc_basepoint.serialize());
 819                 res.extend_from_slice(&self.first_per_commitment_point.serialize());
 820                 if let &Some(ref script) = &self.shutdown_scriptpubkey {
 821                         res.extend_from_slice(&byte_utils::be16_to_array(script.len() as u16));
 822                         res.extend_from_slice(&script[..]);
 823                 }
 824                 res
 825         }
 826 }
 827
 828 impl MsgDecodable for FundingCreated {
 829         fn decode(v: &[u8]) -> Result<Self, DecodeError> {
 830                 if v.len() < 32+32+2+64 {
 831                         return Err(DecodeError::ShortRead);
 832                 }
 833                 let ctx = Secp256k1::without_caps();
 834                 let mut temporary_channel_id = [0; 32];
 835                 temporary_channel_id[..].copy_from_slice(&v[0..32]);
 836                 Ok(Self {
 837                         temporary_channel_id,
 838                         funding_txid: deserialize(&v[32..64]).unwrap(),
 839                         funding_output_index: byte_utils::slice_to_be16(&v[64..66]),
 840                         signature: secp_signature!(&ctx, &v[66..130]),
 841                 })
 842         }
 843 }
 844 impl MsgEncodable for FundingCreated {
 845         fn encode(&self) -> Vec<u8> {
 846                 let mut res = Vec::with_capacity(32+32+2+64);
 847                 res.extend_from_slice(&self.temporary_channel_id);
 848                 res.extend_from_slice(&serialize(&self.funding_txid).unwrap()[..]);
 849                 res.extend_from_slice(&byte_utils::be16_to_array(self.funding_output_index));
 850                 let secp_ctx = Secp256k1::without_caps();
 851                 res.extend_from_slice(&self.signature.serialize_compact(&secp_ctx));
 852                 res
 853         }
 854 }
 855
 856 impl MsgDecodable for FundingSigned {
 857         fn decode(v: &[u8]) -> Result<Self, DecodeError> {
 858                 if v.len() < 32+64 {
 859                         return Err(DecodeError::ShortRead);
 860                 }
 861                 let ctx = Secp256k1::without_caps();
 862                 let mut channel_id = [0; 32];
 863                 channel_id[..].copy_from_slice(&v[0..32]);
 864                 Ok(Self {
 865                         channel_id,
 866                         signature: secp_signature!(&ctx, &v[32..96]),
 867                 })
 868         }
 869 }
 870 impl MsgEncodable for FundingSigned {
 871         fn encode(&self) -> Vec<u8> {
 872                 let mut res = Vec::with_capacity(32+64);
 873                 res.extend_from_slice(&self.channel_id);
 874                 res.extend_from_slice(&self.signature.serialize_compact(&Secp256k1::without_caps()));
 875                 res
 876         }
 877 }
 878
 879 impl MsgDecodable for FundingLocked {
 880         fn decode(v: &[u8]) -> Result<Self, DecodeError> {
 881                 if v.len() < 32+33 {
 882                         return Err(DecodeError::ShortRead);
 883                 }
 884                 let ctx = Secp256k1::without_caps();
 885                 let mut channel_id = [0; 32];
 886                 channel_id[..].copy_from_slice(&v[0..32]);
 887                 Ok(Self {
 888                         channel_id,
 889                         next_per_commitment_point: secp_pubkey!(&ctx, &v[32..65]),
 890                 })
 891         }
 892 }
 893 impl MsgEncodable for FundingLocked {
 894         fn encode(&self) -> Vec<u8> {
 895                 let mut res = Vec::with_capacity(32+33);
 896                 res.extend_from_slice(&self.channel_id);
 897                 res.extend_from_slice(&self.next_per_commitment_point.serialize());
 898                 res
 899         }
 900 }
 901
 902 impl MsgDecodable for Shutdown {
 903         fn decode(v: &[u8]) -> Result<Self, DecodeError> {
 904                 if v.len() < 32 + 2 {
 905                         return Err(DecodeError::ShortRead);
 906                 }
 907                 let scriptlen = byte_utils::slice_to_be16(&v[32..34]) as usize;
 908                 if v.len() < 32 + 2 + scriptlen {
 909                         return Err(DecodeError::ShortRead);
 910                 }
 911                 let mut channel_id = [0; 32];
 912                 channel_id[..].copy_from_slice(&v[0..32]);
 913                 Ok(Self {
 914                         channel_id,
 915                         scriptpubkey: Script::from(v[34..34 + scriptlen].to_vec()),
 916                 })
 917         }
 918 }
 919 impl MsgEncodable for Shutdown {
 920         fn encode(&self) -> Vec<u8> {
 921                 let mut res = Vec::with_capacity(32 + 2 + self.scriptpubkey.len());
 922                 res.extend_from_slice(&self.channel_id);
 923                 res.extend_from_slice(&byte_utils::be16_to_array(self.scriptpubkey.len() as u16));
 924                 res.extend_from_slice(&self.scriptpubkey[..]);
 925                 res
 926         }
 927 }
 928
 929 impl MsgDecodable for ClosingSigned {
 930         fn decode(v: &[u8]) -> Result<Self, DecodeError> {
 931                 if v.len() < 32 + 8 + 64 {
 932                         return Err(DecodeError::ShortRead);
 933                 }
 934                 let secp_ctx = Secp256k1::without_caps();
 935                 let mut channel_id = [0; 32];
 936                 channel_id[..].copy_from_slice(&v[0..32]);
 937                 Ok(Self {
 938                         channel_id,
 939                         fee_satoshis: byte_utils::slice_to_be64(&v[32..40]),
 940                         signature: secp_signature!(&secp_ctx, &v[40..104]),
 941                 })
 942         }
 943 }
 944 impl MsgEncodable for ClosingSigned {
 945         fn encode(&self) -> Vec<u8> {
 946                 let mut res = Vec::with_capacity(32+8+64);
 947                 res.extend_from_slice(&self.channel_id);
 948                 res.extend_from_slice(&byte_utils::be64_to_array(self.fee_satoshis));
 949                 let secp_ctx = Secp256k1::without_caps();
 950                 res.extend_from_slice(&self.signature.serialize_compact(&secp_ctx));
 951                 res
 952         }
 953 }
 954
 955 impl MsgDecodable for UpdateAddHTLC {
 956         fn decode(v: &[u8]) -> Result<Self, DecodeError> {
 957                 if v.len() < 32+8+8+32+4+1+33+20*65+32 {
 958                         return Err(DecodeError::ShortRead);
 959                 }
 960                 let mut channel_id = [0; 32];
 961                 channel_id[..].copy_from_slice(&v[0..32]);
 962                 let mut payment_hash = [0; 32];
 963                 payment_hash.copy_from_slice(&v[48..80]);
 964                 Ok(Self{
 965                         channel_id,
 966                         htlc_id: byte_utils::slice_to_be64(&v[32..40]),
 967                         amount_msat: byte_utils::slice_to_be64(&v[40..48]),
 968                         payment_hash,
 969                         cltv_expiry: byte_utils::slice_to_be32(&v[80..84]),
 970                         onion_routing_packet: OnionPacket::decode(&v[84..84+1366])?,
 971                 })
 972         }
 973 }
 974 impl MsgEncodable for UpdateAddHTLC {
 975         fn encode(&self) -> Vec<u8> {
 976                 let mut res = Vec::with_capacity(32+8+8+32+4+1366);
 977                 res.extend_from_slice(&self.channel_id);
 978                 res.extend_from_slice(&byte_utils::be64_to_array(self.htlc_id));
 979                 res.extend_from_slice(&byte_utils::be64_to_array(self.amount_msat));
 980                 res.extend_from_slice(&self.payment_hash);
 981                 res.extend_from_slice(&byte_utils::be32_to_array(self.cltv_expiry));
 982                 res.extend_from_slice(&self.onion_routing_packet.encode()[..]);
 983                 res
 984         }
 985 }
 986
 987 impl MsgDecodable for UpdateFulfillHTLC {
 988         fn decode(v: &[u8]) -> Result<Self, DecodeError> {
 989                 if v.len() < 32+8+32 {
 990                         return Err(DecodeError::ShortRead);
 991                 }
 992                 let mut channel_id = [0; 32];
 993                 channel_id[..].copy_from_slice(&v[0..32]);
 994                 let mut payment_preimage = [0; 32];
 995                 payment_preimage.copy_from_slice(&v[40..72]);
 996                 Ok(Self{
 997                         channel_id,
 998                         htlc_id: byte_utils::slice_to_be64(&v[32..40]),
 999                         payment_preimage,
1000                 })
1001         }
1002 }
1003 impl MsgEncodable for UpdateFulfillHTLC {
1004         fn encode(&self) -> Vec<u8> {
1005                 let mut res = Vec::with_capacity(32+8+32);
1006                 res.extend_from_slice(&self.channel_id);
1007                 res.extend_from_slice(&byte_utils::be64_to_array(self.htlc_id));
1008                 res.extend_from_slice(&self.payment_preimage);
1009                 res
1010         }
1011 }
1012
1013 impl MsgDecodable for UpdateFailHTLC {
1014         fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1015                 if v.len() < 32+8 {
1016                         return Err(DecodeError::ShortRead);
1017                 }
1018                 let mut channel_id = [0; 32];
1019                 channel_id[..].copy_from_slice(&v[0..32]);
1020                 Ok(Self{
1021                         channel_id,
1022                         htlc_id: byte_utils::slice_to_be64(&v[32..40]),
1023                         reason: OnionErrorPacket::decode(&v[40..])?,
1024                 })
1025         }
1026 }
1027 impl MsgEncodable for UpdateFailHTLC {
1028         fn encode(&self) -> Vec<u8> {
1029                 let reason = self.reason.encode();
1030                 let mut res = Vec::with_capacity(32+8+reason.len());
1031                 res.extend_from_slice(&self.channel_id);
1032                 res.extend_from_slice(&byte_utils::be64_to_array(self.htlc_id));
1033                 res.extend_from_slice(&reason[..]);
1034                 res
1035         }
1036 }
1037
1038 impl MsgDecodable for UpdateFailMalformedHTLC {
1039         fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1040                 if v.len() < 32+8+32+2 {
1041                         return Err(DecodeError::ShortRead);
1042                 }
1043                 let mut channel_id = [0; 32];
1044                 channel_id[..].copy_from_slice(&v[0..32]);
1045                 let mut sha256_of_onion = [0; 32];
1046                 sha256_of_onion.copy_from_slice(&v[40..72]);
1047                 Ok(Self{
1048                         channel_id,
1049                         htlc_id: byte_utils::slice_to_be64(&v[32..40]),
1050                         sha256_of_onion,
1051                         failure_code: byte_utils::slice_to_be16(&v[72..74]),
1052                 })
1053         }
1054 }
1055 impl MsgEncodable for UpdateFailMalformedHTLC {
1056         fn encode(&self) -> Vec<u8> {
1057                 let mut res = Vec::with_capacity(32+8+32+2);
1058                 res.extend_from_slice(&self.channel_id);
1059                 res.extend_from_slice(&byte_utils::be64_to_array(self.htlc_id));
1060                 res.extend_from_slice(&self.sha256_of_onion);
1061                 res.extend_from_slice(&byte_utils::be16_to_array(self.failure_code));
1062                 res
1063         }
1064 }
1065
1066 impl MsgDecodable for CommitmentSigned {
1067         fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1068                 if v.len() < 32+64+2 {
1069                         return Err(DecodeError::ShortRead);
1070                 }
1071                 let mut channel_id = [0; 32];
1072                 channel_id[..].copy_from_slice(&v[0..32]);
1073
1074                 let htlcs = byte_utils::slice_to_be16(&v[96..98]) as usize;
1075                 if v.len() < 32+64+2+htlcs*64 {
1076                         return Err(DecodeError::ShortRead);
1077                 }
1078                 let mut htlc_signatures = Vec::with_capacity(htlcs);
1079                 let secp_ctx = Secp256k1::without_caps();
1080                 for i in 0..htlcs {
1081                         htlc_signatures.push(secp_signature!(&secp_ctx, &v[98+i*64..98+(i+1)*64]));
1082                 }
1083                 Ok(Self {
1084                         channel_id,
1085                         signature: secp_signature!(&secp_ctx, &v[32..96]),
1086                         htlc_signatures,
1087                 })
1088         }
1089 }
1090 impl MsgEncodable for CommitmentSigned {
1091         fn encode(&self) -> Vec<u8> {
1092                 let mut res = Vec::with_capacity(32+64+2+self.htlc_signatures.len()*64);
1093                 res.extend_from_slice(&self.channel_id);
1094                 let secp_ctx = Secp256k1::without_caps();
1095                 res.extend_from_slice(&self.signature.serialize_compact(&secp_ctx));
1096                 res.extend_from_slice(&byte_utils::be16_to_array(self.htlc_signatures.len() as u16));
1097                 for i in 0..self.htlc_signatures.len() {
1098                         res.extend_from_slice(&self.htlc_signatures[i].serialize_compact(&secp_ctx));
1099                 }
1100                 res
1101         }
1102 }
1103
1104 impl MsgDecodable for RevokeAndACK {
1105         fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1106                 if v.len() < 32+32+33 {
1107                         return Err(DecodeError::ShortRead);
1108                 }
1109                 let mut channel_id = [0; 32];
1110                 channel_id[..].copy_from_slice(&v[0..32]);
1111                 let mut per_commitment_secret = [0; 32];
1112                 per_commitment_secret.copy_from_slice(&v[32..64]);
1113                 let secp_ctx = Secp256k1::without_caps();
1114                 Ok(Self {
1115                         channel_id,
1116                         per_commitment_secret,
1117                         next_per_commitment_point: secp_pubkey!(&secp_ctx, &v[64..97]),
1118                 })
1119         }
1120 }
1121 impl MsgEncodable for RevokeAndACK {
1122         fn encode(&self) -> Vec<u8> {
1123                 let mut res = Vec::with_capacity(32+32+33);
1124                 res.extend_from_slice(&self.channel_id);
1125                 res.extend_from_slice(&self.per_commitment_secret);
1126                 res.extend_from_slice(&self.next_per_commitment_point.serialize());
1127                 res
1128         }
1129 }
1130
1131 impl MsgDecodable for UpdateFee {
1132         fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1133                 if v.len() < 32+4 {
1134                         return Err(DecodeError::ShortRead);
1135                 }
1136                 let mut channel_id = [0; 32];
1137                 channel_id[..].copy_from_slice(&v[0..32]);
1138                 Ok(Self {
1139                         channel_id,
1140                         feerate_per_kw: byte_utils::slice_to_be32(&v[32..36]),
1141                 })
1142         }
1143 }
1144 impl MsgEncodable for UpdateFee {
1145         fn encode(&self) -> Vec<u8> {
1146                 let mut res = Vec::with_capacity(32+4);
1147                 res.extend_from_slice(&self.channel_id);
1148                 res.extend_from_slice(&byte_utils::be32_to_array(self.feerate_per_kw));
1149                 res
1150         }
1151 }
1152
1153 impl MsgDecodable for ChannelReestablish {
1154         fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1155                 if v.len() < 32+2*8 {
1156                         return Err(DecodeError::ShortRead);
1157                 }
1158
1159                 let data_loss_protect = if v.len() > 32+2*8 {
1160                         if v.len() < 32+2*8 + 33+32 {
1161                                 return Err(DecodeError::ShortRead);
1162                         }
1163                         let mut inner_array = [0; 32];
1164                         inner_array.copy_from_slice(&v[48..48+32]);
1165                         Some(DataLossProtect {
1166                                 your_last_per_commitment_secret: inner_array,
1167                                 my_current_per_commitment_point: secp_pubkey!(&Secp256k1::without_caps(), &v[48+32..48+32+33]),
1168                         })
1169                 } else { None };
1170
1171                 Ok(Self {
1172                         channel_id: deserialize(&v[0..32]).unwrap(),
1173                         next_local_commitment_number: byte_utils::slice_to_be64(&v[32..40]),
1174                         next_remote_commitment_number: byte_utils::slice_to_be64(&v[40..48]),
1175                         data_loss_protect: data_loss_protect,
1176                 })
1177         }
1178 }
1179 impl MsgEncodable for ChannelReestablish {
1180         fn encode(&self) -> Vec<u8> {
1181                 let mut res = Vec::with_capacity(if self.data_loss_protect.is_some() { 32+2*8+33+32 } else { 32+2*8 });
1182
1183                 res.extend_from_slice(&serialize(&self.channel_id).unwrap()[..]);
1184                 res.extend_from_slice(&byte_utils::be64_to_array(self.next_local_commitment_number));
1185                 res.extend_from_slice(&byte_utils::be64_to_array(self.next_remote_commitment_number));
1186
1187                 if let &Some(ref data_loss_protect) = &self.data_loss_protect {
1188                         res.extend_from_slice(&data_loss_protect.your_last_per_commitment_secret[..]);
1189                         res.extend_from_slice(&data_loss_protect.my_current_per_commitment_point.serialize());
1190                 }
1191                 res
1192         }
1193 }
1194
1195 impl MsgDecodable for AnnouncementSignatures {
1196         fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1197                 if v.len() < 32+8+64*2 {
1198                         return Err(DecodeError::ShortRead);
1199                 }
1200                 let secp_ctx = Secp256k1::without_caps();
1201                 let mut channel_id = [0; 32];
1202                 channel_id[..].copy_from_slice(&v[0..32]);
1203                 Ok(Self {
1204                         channel_id,
1205                         short_channel_id: byte_utils::slice_to_be64(&v[32..40]),
1206                         node_signature: secp_signature!(&secp_ctx, &v[40..104]),
1207                         bitcoin_signature: secp_signature!(&secp_ctx, &v[104..168]),
1208                 })
1209         }
1210 }
1211 impl MsgEncodable for AnnouncementSignatures {
1212         fn encode(&self) -> Vec<u8> {
1213                 let mut res = Vec::with_capacity(32+8+64*2);
1214                 res.extend_from_slice(&self.channel_id);
1215                 res.extend_from_slice(&byte_utils::be64_to_array(self.short_channel_id));
1216                 let secp_ctx = Secp256k1::without_caps();
1217                 res.extend_from_slice(&self.node_signature.serialize_compact(&secp_ctx));
1218                 res.extend_from_slice(&self.bitcoin_signature.serialize_compact(&secp_ctx));
1219                 res
1220         }
1221 }
1222
1223 impl MsgDecodable for UnsignedNodeAnnouncement {
1224         fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1225                 let features = GlobalFeatures::decode(&v[..])?;
1226                 if features.requires_unknown_bits() {
1227                         return Err(DecodeError::UnknownRequiredFeature);
1228                 }
1229
1230                 if v.len() < features.encoded_len() + 4 + 33 + 3 + 32 + 2 {
1231                         return Err(DecodeError::ShortRead);
1232                 }
1233                 let start = features.encoded_len();
1234
1235                 let mut rgb = [0; 3];
1236                 rgb.copy_from_slice(&v[start + 37..start + 40]);
1237
1238                 let mut alias = [0; 32];
1239                 alias.copy_from_slice(&v[start + 40..start + 72]);
1240
1241                 let addrlen = byte_utils::slice_to_be16(&v[start + 72..start + 74]) as usize;
1242                 if v.len() < start + 74 + addrlen {
1243                         return Err(DecodeError::ShortRead);
1244                 }
1245                 let addr_read_limit = start + 74 + addrlen;
1246
1247                 let mut addresses = Vec::with_capacity(4);
1248                 let mut read_pos = start + 74;
1249                 loop {
1250                         if addr_read_limit <= read_pos { break; }
1251                         match v[read_pos] {
1252                                 1 => {
1253                                         if addresses.len() > 0 {
1254                                                 return Err(DecodeError::ExtraAddressesPerType);
1255                                         }
1256                                         if addr_read_limit < read_pos + 1 + 6 {
1257                                                 return Err(DecodeError::BadLengthDescriptor);
1258                                         }
1259                                         let mut addr = [0; 4];
1260                                         addr.copy_from_slice(&v[read_pos + 1..read_pos + 5]);
1261                                         addresses.push(NetAddress::IPv4 {
1262                                                 addr,
1263                                                 port: byte_utils::slice_to_be16(&v[read_pos + 5..read_pos + 7]),
1264                                         });
1265                                         read_pos += 1 + 6;
1266                                 },
1267                                 2 => {
1268                                         if addresses.len() > 1 || (addresses.len() == 1 && addresses[0].get_id() != 1) {
1269                                                 return Err(DecodeError::ExtraAddressesPerType);
1270                                         }
1271                                         if addr_read_limit < read_pos + 1 + 18 {
1272                                                 return Err(DecodeError::BadLengthDescriptor);
1273                                         }
1274                                         let mut addr = [0; 16];
1275                                         addr.copy_from_slice(&v[read_pos + 1..read_pos + 17]);
1276                                         addresses.push(NetAddress::IPv6 {
1277                                                 addr,
1278                                                 port: byte_utils::slice_to_be16(&v[read_pos + 17..read_pos + 19]),
1279                                         });
1280                                         read_pos += 1 + 18;
1281                                 },
1282                                 3 => {
1283                                         if addresses.len() > 2 || (addresses.len() > 0 && addresses.last().unwrap().get_id() > 2) {
1284                                                 return Err(DecodeError::ExtraAddressesPerType);
1285                                         }
1286                                         if addr_read_limit < read_pos + 1 + 12 {
1287                                                 return Err(DecodeError::BadLengthDescriptor);
1288                                         }
1289                                         let mut addr = [0; 10];
1290                                         addr.copy_from_slice(&v[read_pos + 1..read_pos + 11]);
1291                                         addresses.push(NetAddress::OnionV2 {
1292                                                 addr,
1293                                                 port: byte_utils::slice_to_be16(&v[read_pos + 11..read_pos + 13]),
1294                                         });
1295                                         read_pos += 1 + 12;
1296                                 },
1297                                 4 => {
1298                                         if addresses.len() > 3 || (addresses.len() > 0 && addresses.last().unwrap().get_id() > 3) {
1299                                                 return Err(DecodeError::ExtraAddressesPerType);
1300                                         }
1301                                         if addr_read_limit < read_pos + 1 + 37 {
1302                                                 return Err(DecodeError::BadLengthDescriptor);
1303                                         }
1304                                         let mut ed25519_pubkey = [0; 32];
1305                                         ed25519_pubkey.copy_from_slice(&v[read_pos + 1..read_pos + 33]);
1306                                         addresses.push(NetAddress::OnionV3 {
1307                                                 ed25519_pubkey,
1308                                                 checksum: byte_utils::slice_to_be16(&v[read_pos + 33..read_pos + 35]),
1309                                                 version: v[read_pos + 35],
1310                                                 port: byte_utils::slice_to_be16(&v[read_pos + 36..read_pos + 38]),
1311                                         });
1312                                         read_pos += 1 + 37;
1313                                 },
1314                                 _ => { break; } // We've read all we can, we dont understand anything higher (and they're sorted)
1315                         }
1316                 }
1317
1318                 let excess_address_data = if read_pos < addr_read_limit {
1319                         let mut excess_address_data = Vec::with_capacity(addr_read_limit - read_pos);
1320                         excess_address_data.extend_from_slice(&v[read_pos..addr_read_limit]);
1321                         excess_address_data
1322                 } else { Vec::new() };
1323
1324                 let mut excess_data = Vec::with_capacity(v.len() - addr_read_limit);
1325                 excess_data.extend_from_slice(&v[addr_read_limit..]);
1326
1327                 let secp_ctx = Secp256k1::without_caps();
1328                 Ok(Self {
1329                         features,
1330                         timestamp: byte_utils::slice_to_be32(&v[start..start + 4]),
1331                         node_id: secp_pubkey!(&secp_ctx, &v[start + 4..start + 37]),
1332                         rgb,
1333                         alias,
1334                         addresses,
1335                         excess_address_data,
1336                         excess_data,
1337                 })
1338         }
1339 }
1340 impl MsgEncodable for UnsignedNodeAnnouncement {
1341         fn encode(&self) -> Vec<u8> {
1342                 let features = self.features.encode();
1343                 let mut res = Vec::with_capacity(74 + features.len() + self.addresses.len()*7 + self.excess_address_data.len() + self.excess_data.len());
1344                 res.extend_from_slice(&features[..]);
1345                 res.extend_from_slice(&byte_utils::be32_to_array(self.timestamp));
1346                 res.extend_from_slice(&self.node_id.serialize());
1347                 res.extend_from_slice(&self.rgb);
1348                 res.extend_from_slice(&self.alias);
1349                 let mut addr_slice = Vec::with_capacity(self.addresses.len() * 18);
1350                 let mut addrs_to_encode = self.addresses.clone();
1351                 addrs_to_encode.sort_unstable_by(|a, b| { a.get_id().cmp(&b.get_id()) });
1352                 addrs_to_encode.dedup_by(|a, b| { a.get_id() == b.get_id() });
1353                 for addr in addrs_to_encode.iter() {
1354                         match addr {
1355                                 &NetAddress::IPv4{addr, port} => {
1356                                         addr_slice.push(1);
1357                                         addr_slice.extend_from_slice(&addr);
1358                                         addr_slice.extend_from_slice(&byte_utils::be16_to_array(port));
1359                                 },
1360                                 &NetAddress::IPv6{addr, port} => {
1361                                         addr_slice.push(2);
1362                                         addr_slice.extend_from_slice(&addr);
1363                                         addr_slice.extend_from_slice(&byte_utils::be16_to_array(port));
1364                                 },
1365                                 &NetAddress::OnionV2{addr, port} => {
1366                                         addr_slice.push(3);
1367                                         addr_slice.extend_from_slice(&addr);
1368                                         addr_slice.extend_from_slice(&byte_utils::be16_to_array(port));
1369                                 },
1370                                 &NetAddress::OnionV3{ed25519_pubkey, checksum, version, port} => {
1371                                         addr_slice.push(4);
1372                                         addr_slice.extend_from_slice(&ed25519_pubkey);
1373                                         addr_slice.extend_from_slice(&byte_utils::be16_to_array(checksum));
1374                                         addr_slice.push(version);
1375                                         addr_slice.extend_from_slice(&byte_utils::be16_to_array(port));
1376                                 },
1377                         }
1378                 }
1379                 res.extend_from_slice(&byte_utils::be16_to_array((addr_slice.len() + self.excess_address_data.len()) as u16));
1380                 res.extend_from_slice(&addr_slice[..]);
1381                 res.extend_from_slice(&self.excess_address_data[..]);
1382                 res.extend_from_slice(&self.excess_data[..]);
1383                 res
1384         }
1385 }
1386
1387 impl MsgDecodable for NodeAnnouncement {
1388         fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1389                 if v.len() < 64 {
1390                         return Err(DecodeError::ShortRead);
1391                 }
1392                 let secp_ctx = Secp256k1::without_caps();
1393                 Ok(Self {
1394                         signature: secp_signature!(&secp_ctx, &v[0..64]),
1395                         contents: UnsignedNodeAnnouncement::decode(&v[64..])?,
1396                 })
1397         }
1398 }
1399 impl MsgEncodable for NodeAnnouncement {
1400         fn encode(&self) -> Vec<u8> {
1401                 let contents = self.contents.encode();
1402                 let mut res = Vec::with_capacity(64 + contents.len());
1403                 let secp_ctx = Secp256k1::without_caps();
1404                 res.extend_from_slice(&self.signature.serialize_compact(&secp_ctx));
1405                 res.extend_from_slice(&contents);
1406                 res
1407         }
1408 }
1409
1410 impl MsgDecodable for UnsignedChannelAnnouncement {
1411         fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1412                 let features = GlobalFeatures::decode(&v[..])?;
1413                 if features.requires_unknown_bits() {
1414                         return Err(DecodeError::UnknownRequiredFeature);
1415                 }
1416                 if v.len() < features.encoded_len() + 32 + 8 + 33*4 {
1417                         return Err(DecodeError::ShortRead);
1418                 }
1419                 let start = features.encoded_len();
1420                 let secp_ctx = Secp256k1::without_caps();
1421                 let mut excess_data = Vec::with_capacity(v.len() - start - 172);
1422                 excess_data.extend_from_slice(&v[start + 172..]);
1423                 Ok(Self {
1424                         features,
1425                         chain_hash: deserialize(&v[start..start + 32]).unwrap(),
1426                         short_channel_id: byte_utils::slice_to_be64(&v[start + 32..start + 40]),
1427                         node_id_1: secp_pubkey!(&secp_ctx, &v[start + 40..start + 73]),
1428                         node_id_2: secp_pubkey!(&secp_ctx, &v[start + 73..start + 106]),
1429                         bitcoin_key_1: secp_pubkey!(&secp_ctx, &v[start + 106..start + 139]),
1430                         bitcoin_key_2: secp_pubkey!(&secp_ctx, &v[start + 139..start + 172]),
1431                         excess_data,
1432                 })
1433         }
1434 }
1435 impl MsgEncodable for UnsignedChannelAnnouncement {
1436         fn encode(&self) -> Vec<u8> {
1437                 let features = self.features.encode();
1438                 let mut res = Vec::with_capacity(172 + features.len() + self.excess_data.len());
1439                 res.extend_from_slice(&features[..]);
1440                 res.extend_from_slice(&self.chain_hash[..]);
1441                 res.extend_from_slice(&byte_utils::be64_to_array(self.short_channel_id));
1442                 res.extend_from_slice(&self.node_id_1.serialize());
1443                 res.extend_from_slice(&self.node_id_2.serialize());
1444                 res.extend_from_slice(&self.bitcoin_key_1.serialize());
1445                 res.extend_from_slice(&self.bitcoin_key_2.serialize());
1446                 res.extend_from_slice(&self.excess_data[..]);
1447                 res
1448         }
1449 }
1450
1451 impl MsgDecodable for ChannelAnnouncement {
1452         fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1453                 if v.len() < 64*4 {
1454                         return Err(DecodeError::ShortRead);
1455                 }
1456                 let secp_ctx = Secp256k1::without_caps();
1457                 Ok(Self {
1458                         node_signature_1: secp_signature!(&secp_ctx, &v[0..64]),
1459                         node_signature_2: secp_signature!(&secp_ctx, &v[64..128]),
1460                         bitcoin_signature_1: secp_signature!(&secp_ctx, &v[128..192]),
1461                         bitcoin_signature_2: secp_signature!(&secp_ctx, &v[192..256]),
1462                         contents: UnsignedChannelAnnouncement::decode(&v[256..])?,
1463                 })
1464         }
1465 }
1466 impl MsgEncodable for ChannelAnnouncement {
1467         fn encode(&self) -> Vec<u8> {
1468                 let secp_ctx = Secp256k1::without_caps();
1469                 let contents = self.contents.encode();
1470                 let mut res = Vec::with_capacity(64 + contents.len());
1471                 res.extend_from_slice(&self.node_signature_1.serialize_compact(&secp_ctx));
1472                 res.extend_from_slice(&self.node_signature_2.serialize_compact(&secp_ctx));
1473                 res.extend_from_slice(&self.bitcoin_signature_1.serialize_compact(&secp_ctx));
1474                 res.extend_from_slice(&self.bitcoin_signature_2.serialize_compact(&secp_ctx));
1475                 res.extend_from_slice(&contents);
1476                 res
1477         }
1478 }
1479
1480 impl MsgDecodable for UnsignedChannelUpdate {
1481         fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1482                 if v.len() < 32+8+4+2+2+8+4+4 {
1483                         return Err(DecodeError::ShortRead);
1484                 }
1485                 let mut excess_data = Vec::with_capacity(v.len() - 64);
1486                 excess_data.extend_from_slice(&v[64..]);
1487                 Ok(Self {
1488                         chain_hash: deserialize(&v[0..32]).unwrap(),
1489                         short_channel_id: byte_utils::slice_to_be64(&v[32..40]),
1490                         timestamp: byte_utils::slice_to_be32(&v[40..44]),
1491                         flags: byte_utils::slice_to_be16(&v[44..46]),
1492                         cltv_expiry_delta: byte_utils::slice_to_be16(&v[46..48]),
1493                         htlc_minimum_msat: byte_utils::slice_to_be64(&v[48..56]),
1494                         fee_base_msat: byte_utils::slice_to_be32(&v[56..60]),
1495                         fee_proportional_millionths: byte_utils::slice_to_be32(&v[60..64]),
1496                         excess_data
1497                 })
1498         }
1499 }
1500 impl MsgEncodable for UnsignedChannelUpdate {
1501         fn encode(&self) -> Vec<u8> {
1502                 let mut res = Vec::with_capacity(64 + self.excess_data.len());
1503                 res.extend_from_slice(&self.chain_hash[..]);
1504                 res.extend_from_slice(&byte_utils::be64_to_array(self.short_channel_id));
1505                 res.extend_from_slice(&byte_utils::be32_to_array(self.timestamp));
1506                 res.extend_from_slice(&byte_utils::be16_to_array(self.flags));
1507                 res.extend_from_slice(&byte_utils::be16_to_array(self.cltv_expiry_delta));
1508                 res.extend_from_slice(&byte_utils::be64_to_array(self.htlc_minimum_msat));
1509                 res.extend_from_slice(&byte_utils::be32_to_array(self.fee_base_msat));
1510                 res.extend_from_slice(&byte_utils::be32_to_array(self.fee_proportional_millionths));
1511                 res.extend_from_slice(&self.excess_data[..]);
1512                 res
1513         }
1514 }
1515
1516 impl MsgDecodable for ChannelUpdate {
1517         fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1518                 if v.len() < 128 {
1519                         return Err(DecodeError::ShortRead);
1520                 }
1521                 let secp_ctx = Secp256k1::without_caps();
1522                 Ok(Self {
1523                         signature: secp_signature!(&secp_ctx, &v[0..64]),
1524                         contents: UnsignedChannelUpdate::decode(&v[64..])?,
1525                 })
1526         }
1527 }
1528 impl MsgEncodable for ChannelUpdate {
1529         fn encode(&self) -> Vec<u8> {
1530                 let mut res = Vec::with_capacity(128);
1531                 res.extend_from_slice(&self.signature.serialize_compact(&Secp256k1::without_caps())[..]);
1532                 res.extend_from_slice(&self.contents.encode()[..]);
1533                 res
1534         }
1535 }
1536
1537 impl MsgDecodable for OnionRealm0HopData {
1538         fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1539                 if v.len() < 32 {
1540                         return Err(DecodeError::ShortRead);
1541                 }
1542                 Ok(OnionRealm0HopData {
1543                         short_channel_id: byte_utils::slice_to_be64(&v[0..8]),
1544                         amt_to_forward: byte_utils::slice_to_be64(&v[8..16]),
1545                         outgoing_cltv_value: byte_utils::slice_to_be32(&v[16..20]),
1546                 })
1547         }
1548 }
1549 impl MsgEncodable for OnionRealm0HopData {
1550         fn encode(&self) -> Vec<u8> {
1551                 let mut res = Vec::with_capacity(32);
1552                 res.extend_from_slice(&byte_utils::be64_to_array(self.short_channel_id));
1553                 res.extend_from_slice(&byte_utils::be64_to_array(self.amt_to_forward));
1554                 res.extend_from_slice(&byte_utils::be32_to_array(self.outgoing_cltv_value));
1555                 res.resize(32, 0);
1556                 res
1557         }
1558 }
1559
1560 impl MsgDecodable for OnionHopData {
1561         fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1562                 if v.len() < 65 {
1563                         return Err(DecodeError::ShortRead);
1564                 }
1565                 let realm = v[0];
1566                 if realm != 0 {
1567                         return Err(DecodeError::UnknownRealmByte);
1568                 }
1569                 let mut hmac = [0; 32];
1570                 hmac[..].copy_from_slice(&v[33..65]);
1571                 Ok(OnionHopData {
1572                         realm: realm,
1573                         data: OnionRealm0HopData::decode(&v[1..33])?,
1574                         hmac: hmac,
1575                 })
1576         }
1577 }
1578 impl MsgEncodable for OnionHopData {
1579         fn encode(&self) -> Vec<u8> {
1580                 let mut res = Vec::with_capacity(65);
1581                 res.push(self.realm);
1582                 res.extend_from_slice(&self.data.encode()[..]);
1583                 res.extend_from_slice(&self.hmac);
1584                 res
1585         }
1586 }
1587
1588 impl MsgDecodable for OnionPacket {
1589         fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1590                 if v.len() < 1+33+20*65+32 {
1591                         return Err(DecodeError::ShortRead);
1592                 }
1593                 let mut hop_data = [0; 20*65];
1594                 hop_data.copy_from_slice(&v[34..1334]);
1595                 let mut hmac = [0; 32];
1596                 hmac.copy_from_slice(&v[1334..1366]);
1597                 let secp_ctx = Secp256k1::without_caps();
1598                 Ok(Self {
1599                         version: v[0],
1600                         public_key: PublicKey::from_slice(&secp_ctx, &v[1..34]),
1601                         hop_data,
1602                         hmac,
1603                 })
1604         }
1605 }
1606 impl MsgEncodable for OnionPacket {
1607         fn encode(&self) -> Vec<u8> {
1608                 let mut res = Vec::with_capacity(1 + 33 + 20*65 + 32);
1609                 res.push(self.version);
1610                 match self.public_key {
1611                         Ok(pubkey) => res.extend_from_slice(&pubkey.serialize()),
1612                         Err(_) => res.extend_from_slice(&[0; 33]),
1613                 }
1614                 res.extend_from_slice(&self.hop_data);
1615                 res.extend_from_slice(&self.hmac);
1616                 res
1617         }
1618 }
1619
1620 impl MsgDecodable for DecodedOnionErrorPacket {
1621         fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1622                 if v.len() < 32 + 4 {
1623                         return Err(DecodeError::ShortRead);
1624                 }
1625                 let failuremsg_len = byte_utils::slice_to_be16(&v[32..34]) as usize;
1626                 if v.len() < 32 + 4 + failuremsg_len {
1627                         return Err(DecodeError::ShortRead);
1628                 }
1629                 let padding_len = byte_utils::slice_to_be16(&v[34 + failuremsg_len..]) as usize;
1630                 if v.len() < 32 + 4 + failuremsg_len + padding_len {
1631                         return Err(DecodeError::ShortRead);
1632                 }
1633
1634                 let mut hmac = [0; 32];
1635                 hmac.copy_from_slice(&v[0..32]);
1636                 Ok(Self {
1637                         hmac,
1638                         failuremsg: v[34..34 + failuremsg_len].to_vec(),
1639                         pad: v[36 + failuremsg_len..36 + failuremsg_len + padding_len].to_vec(),
1640                 })
1641         }
1642 }
1643 impl MsgEncodable for DecodedOnionErrorPacket {
1644         fn encode(&self) -> Vec<u8> {
1645                 let mut res = Vec::with_capacity(32 + 4 + self.failuremsg.len() + self.pad.len());
1646                 res.extend_from_slice(&self.hmac);
1647                 res.extend_from_slice(&[((self.failuremsg.len() >> 8) & 0xff) as u8, (self.failuremsg.len() & 0xff) as u8]);
1648                 res.extend_from_slice(&self.failuremsg);
1649                 res.extend_from_slice(&[((self.pad.len() >> 8) & 0xff) as u8, (self.pad.len() & 0xff) as u8]);
1650                 res.extend_from_slice(&self.pad);
1651                 res
1652         }
1653 }
1654
1655 impl MsgDecodable for OnionErrorPacket {
1656         fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1657                 if v.len() < 2 {
1658                         return Err(DecodeError::ShortRead);
1659                 }
1660                 let len = byte_utils::slice_to_be16(&v[0..2]) as usize;
1661                 if v.len() < 2 + len {
1662                         return Err(DecodeError::ShortRead);
1663                 }
1664                 Ok(Self {
1665                         data: v[2..len+2].to_vec(),
1666                 })
1667         }
1668 }
1669 impl MsgEncodable for OnionErrorPacket {
1670         fn encode(&self) -> Vec<u8> {
1671                 let mut res = Vec::with_capacity(2 + self.data.len());
1672                 res.extend_from_slice(&byte_utils::be16_to_array(self.data.len() as u16));
1673                 res.extend_from_slice(&self.data);
1674                 res
1675         }
1676 }
1677
1678 impl MsgEncodable for ErrorMessage {
1679         fn encode(&self) -> Vec<u8> {
1680                 let mut res = Vec::with_capacity(34 + self.data.len());
1681                 res.extend_from_slice(&self.channel_id);
1682                 res.extend_from_slice(&byte_utils::be16_to_array(self.data.len() as u16));
1683                 res.extend_from_slice(&self.data.as_bytes());
1684                 res
1685         }
1686 }
1687 impl MsgDecodable for ErrorMessage {
1688         fn decode(v: &[u8]) -> Result<Self,DecodeError> {
1689                 if v.len() < 34 {
1690                         return Err(DecodeError::ShortRead);
1691                 }
1692                 // Unlike most messages, BOLT 1 requires we truncate our read if the value is out of range
1693                 let len = cmp::min(byte_utils::slice_to_be16(&v[32..34]) as usize, v.len() - 34);
1694                 let data = match String::from_utf8(v[34..34 + len].to_vec()) {
1695                         Ok(s) => s,
1696                         Err(_) => return Err(DecodeError::BadText),
1697                 };
1698                 let mut channel_id = [0; 32];
1699                 channel_id[..].copy_from_slice(&v[0..32]);
1700                 Ok(Self {
1701                         channel_id,
1702                         data,
1703                 })
1704         }
1705 }
1706
1707 impl_writeable_len_match!(AcceptChannel, {
1708                 {AcceptChannel{ shutdown_scriptpubkey: Some(ref script), ..}, 270 + 2 + script.len()},
1709                 {_, 270}
1710         }, {
1711         temporary_channel_id,
1712         dust_limit_satoshis,
1713         max_htlc_value_in_flight_msat,
1714         channel_reserve_satoshis,
1715         htlc_minimum_msat,
1716         minimum_depth,
1717         to_self_delay,
1718         max_accepted_htlcs,
1719         funding_pubkey,
1720         revocation_basepoint,
1721         payment_basepoint,
1722         delayed_payment_basepoint,
1723         htlc_basepoint,
1724         first_per_commitment_point,
1725         shutdown_scriptpubkey
1726 });
1727
1728 impl_writeable!(AnnouncementSignatures, 32+8+64*2, {
1729         channel_id,
1730         short_channel_id,
1731         node_signature,
1732         bitcoin_signature
1733 });
1734
1735 impl<W: Writer> Writeable<W> for ChannelReestablish {
1736         fn write(&self, w: &mut W) -> Result<(), DecodeError> {
1737                 w.size_hint(if self.data_loss_protect.is_some() { 32+2*8+33+32 } else { 32+2*8 });
1738                 self.channel_id.write(w)?;
1739                 self.next_local_commitment_number.write(w)?;
1740                 self.next_remote_commitment_number.write(w)?;
1741                 if let Some(ref data_loss_protect) = self.data_loss_protect {
1742                         data_loss_protect.your_last_per_commitment_secret.write(w)?;
1743                         data_loss_protect.my_current_per_commitment_point.write(w)?;
1744                 }
1745                 Ok(())
1746         }
1747 }
1748
1749 impl<R: Read> Readable<R> for ChannelReestablish{
1750         fn read(r: &mut R) -> Result<Self, DecodeError> {
1751                 Ok(Self {
1752                         channel_id: Readable::read(r)?,
1753                         next_local_commitment_number: Readable::read(r)?,
1754                         next_remote_commitment_number: Readable::read(r)?,
1755                         data_loss_protect: {
1756                                 match <[u8; 32] as Readable<R>>::read(r) {
1757                                         Ok(your_last_per_commitment_secret) =>
1758                                                 Some(DataLossProtect {
1759                                                         your_last_per_commitment_secret,
1760                                                         my_current_per_commitment_point: Readable::read(r)?,
1761                                                 }),
1762                                         Err(DecodeError::ShortRead) => None,
1763                                         Err(e) => return Err(e)
1764                                 }
1765                         }
1766                 })
1767         }
1768 }
1769
1770 impl_writeable!(ClosingSigned, 32+8+64, {
1771         channel_id,
1772         fee_satoshis,
1773         signature
1774 });
1775
1776 impl_writeable_len_match!(CommitmentSigned, {
1777                 { CommitmentSigned { ref htlc_signatures, .. }, 32+64+2+htlc_signatures.len()*64 }
1778         }, {
1779         channel_id,
1780         signature,
1781         htlc_signatures
1782 });
1783
1784 impl_writeable_len_match!(DecodedOnionErrorPacket, {
1785                 { DecodedOnionErrorPacket { ref failuremsg, ref pad, .. }, 32 + 4 + failuremsg.len() + pad.len() }
1786         }, {
1787         hmac,
1788         failuremsg,
1789         pad
1790 });
1791
1792 impl_writeable!(FundingCreated, 32+32+2+64, {
1793         temporary_channel_id,
1794         funding_txid,
1795         funding_output_index,
1796         signature
1797 });
1798
1799 impl_writeable!(FundingSigned, 32+64, {
1800         channel_id,
1801         signature
1802 });
1803
1804 impl_writeable!(FundingLocked, 32+33, {
1805         channel_id,
1806         next_per_commitment_point
1807 });
1808
1809 impl_writeable_len_match!(GlobalFeatures, {
1810                 { GlobalFeatures { ref flags }, flags.len() + 2 }
1811         }, {
1812         flags
1813 });
1814
1815 impl_writeable_len_match!(LocalFeatures, {
1816                 { LocalFeatures { ref flags }, flags.len() + 2 }
1817         }, {
1818         flags
1819 });
1820
1821 impl_writeable_len_match!(Init, {
1822                 { Init { ref global_features, ref local_features }, global_features.flags.len() + local_features.flags.len() + 4 }
1823         }, {
1824         global_features,
1825         local_features
1826 });
1827
1828 impl_writeable_len_match!(OpenChannel, {
1829                 { OpenChannel { shutdown_scriptpubkey: Some(ref script), .. }, 319 + 2 + script.len() },
1830                 { OpenChannel { shutdown_scriptpubkey: None, .. }, 319 }
1831         }, {
1832         chain_hash,
1833         temporary_channel_id,
1834         funding_satoshis,
1835         push_msat,
1836         dust_limit_satoshis,
1837         max_htlc_value_in_flight_msat,
1838         channel_reserve_satoshis,
1839         htlc_minimum_msat,
1840         feerate_per_kw,
1841         to_self_delay,
1842         max_accepted_htlcs,
1843         funding_pubkey,
1844         revocation_basepoint,
1845         payment_basepoint,
1846         delayed_payment_basepoint,
1847         htlc_basepoint,
1848         first_per_commitment_point,
1849         channel_flags,
1850         shutdown_scriptpubkey
1851 });
1852
1853 impl_writeable!(RevokeAndACK, 32+32+33, {
1854         channel_id,
1855         per_commitment_secret,
1856         next_per_commitment_point
1857 });
1858
1859 impl_writeable_len_match!(Shutdown, {
1860                 { Shutdown { ref scriptpubkey, .. }, 32 + 2 + scriptpubkey.len() }
1861         }, {
1862         channel_id,
1863         scriptpubkey
1864 });
1865
1866 impl_writeable_len_match!(UpdateFailHTLC, {
1867                 { UpdateFailHTLC { ref reason, .. }, 32 + 10 + reason.data.len() }
1868         }, {
1869         channel_id,
1870         htlc_id,
1871         reason
1872 });
1873
1874 impl_writeable!(UpdateFailMalformedHTLC, 32+8+32+2, {
1875         channel_id,
1876         htlc_id,
1877         sha256_of_onion,
1878         failure_code
1879 });
1880
1881 impl_writeable!(UpdateFee, 32+4, {
1882         channel_id,
1883         feerate_per_kw
1884 });
1885
1886 impl_writeable!(UpdateFulfillHTLC, 32+8+32, {
1887         channel_id,
1888         htlc_id,
1889         payment_preimage
1890 });
1891
1892 impl_writeable_len_match!(OnionErrorPacket, {
1893                 { OnionErrorPacket { ref data, .. }, 2 + data.len() }
1894         }, {
1895         data
1896 });
1897
1898 impl<W: Writer> Writeable<W> for OnionPacket {
1899         fn write(&self, w: &mut W) -> Result<(), DecodeError> {
1900                 w.size_hint(1 + 33 + 20*65 + 32);
1901                 self.version.write(w)?;
1902                 match self.public_key {
1903                         Ok(pubkey) => pubkey.write(w)?,
1904                         Err(_) => [0u8;33].write(w)?,
1905                 }
1906                 w.write_all(&self.hop_data)?;
1907                 self.hmac.write(w)?;
1908                 Ok(())
1909         }
1910 }
1911
1912 impl<R: Read> Readable<R> for OnionPacket {
1913         fn read(r: &mut R) -> Result<Self, DecodeError> {
1914                 Ok(OnionPacket {
1915                         version: Readable::read(r)?,
1916                         public_key: {
1917                                 let mut buf = [0u8;33];
1918                                 r.read_exact(&mut buf)?;
1919                                 PublicKey::from_slice(&Secp256k1::without_caps(), &buf)
1920                         },
1921                         hop_data: Readable::read(r)?,
1922                         hmac: Readable::read(r)?,
1923                 })
1924         }
1925 }
1926
1927 impl_writeable!(UpdateAddHTLC, 32+8+8+32+4+1366, {
1928         channel_id,
1929         htlc_id,
1930         amount_msat,
1931         payment_hash,
1932         cltv_expiry,
1933         onion_routing_packet
1934 });
1935
1936 impl<W: Writer> Writeable<W> for OnionRealm0HopData {
1937         fn write(&self, w: &mut W) -> Result<(), DecodeError> {
1938                 w.size_hint(32);
1939                 self.short_channel_id.write(w)?;
1940                 self.amt_to_forward.write(w)?;
1941                 self.outgoing_cltv_value.write(w)?;
1942                 w.write_all(&[0;12])?;
1943                 Ok(())
1944         }
1945 }
1946
1947 impl<R: Read> Readable<R> for OnionRealm0HopData {
1948         fn read(r: &mut R) -> Result<Self, DecodeError> {
1949                 Ok(OnionRealm0HopData {
1950                         short_channel_id: Readable::read(r)?,
1951                         amt_to_forward: Readable::read(r)?,
1952                         outgoing_cltv_value: {
1953                                 let v: u32 = Readable::read(r)?;
1954                                 r.read_exact(&mut [0; 12])?;
1955                                 v
1956                         }
1957                 })
1958         }
1959 }
1960
1961 impl<W: Writer> Writeable<W> for OnionHopData {
1962         fn write(&self, w: &mut W) -> Result<(), DecodeError> {
1963                 w.size_hint(65);
1964                 self.realm.write(w)?;
1965                 self.data.write(w)?;
1966                 self.hmac.write(w)?;
1967                 Ok(())
1968         }
1969 }
1970
1971 impl<R: Read> Readable<R> for OnionHopData {
1972         fn read(r: &mut R) -> Result<Self, DecodeError> {
1973                 Ok(OnionHopData {
1974                         realm: {
1975                                 let r: u8 = Readable::read(r)?;
1976                                 if r != 0 {
1977                                         return Err(DecodeError::UnknownRealmByte);
1978                                 }
1979                                 r
1980                         },
1981                         data: Readable::read(r)?,
1982                         hmac: Readable::read(r)?,
1983                 })
1984         }
1985 }
1986
1987 impl<W: Writer> Writeable<W> for Ping {
1988         fn write(&self, w: &mut W) -> Result<(), DecodeError> {
1989                 w.size_hint(self.byteslen as usize + 4);
1990                 self.ponglen.write(w)?;
1991                 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
1992                 Ok(())
1993         }
1994 }
1995
1996 impl<R: Read> Readable<R> for Ping {
1997         fn read(r: &mut R) -> Result<Self, DecodeError> {
1998                 Ok(Ping {
1999                         ponglen: Readable::read(r)?,
2000                         byteslen: {
2001                                 let byteslen = Readable::read(r)?;
2002                                 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2003                                 byteslen
2004                         }
2005                 })
2006         }
2007 }
2008
2009 impl<W: Writer> Writeable<W> for Pong {
2010         fn write(&self, w: &mut W) -> Result<(), DecodeError> {
2011                 w.size_hint(self.byteslen as usize + 2);
2012                 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2013                 Ok(())
2014         }
2015 }
2016
2017 impl<R: Read> Readable<R> for Pong {
2018         fn read(r: &mut R) -> Result<Self, DecodeError> {
2019                 Ok(Pong {
2020                         byteslen: {
2021                                 let byteslen = Readable::read(r)?;
2022                                 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2023                                 byteslen
2024                         }
2025                 })
2026         }
2027 }
2028
2029 impl<W: Writer> Writeable<W> for UnsignedChannelAnnouncement {
2030         fn write(&self, w: &mut W) -> Result<(), DecodeError> {
2031                 w.size_hint(2 + 2*32 + 4*33 + self.features.flags.len() + self.excess_data.len());
2032                 self.features.write(w)?;
2033                 self.chain_hash.write(w)?;
2034                 self.short_channel_id.write(w)?;
2035                 self.node_id_1.write(w)?;
2036                 self.node_id_2.write(w)?;
2037                 self.bitcoin_key_1.write(w)?;
2038                 self.bitcoin_key_2.write(w)?;
2039                 w.write_all(&self.excess_data[..])?;
2040                 Ok(())
2041         }
2042 }
2043
2044 impl<R: Read> Readable<R> for UnsignedChannelAnnouncement {
2045         fn read(r: &mut R) -> Result<Self, DecodeError> {
2046                 Ok(Self {
2047                         features: {
2048                                 let f: GlobalFeatures = Readable::read(r)?;
2049                                 if f.requires_unknown_bits() {
2050                                         return Err(DecodeError::UnknownRequiredFeature);
2051                                 }
2052                                 f
2053                         },
2054                         chain_hash: Readable::read(r)?,
2055                         short_channel_id: Readable::read(r)?,
2056                         node_id_1: Readable::read(r)?,
2057                         node_id_2: Readable::read(r)?,
2058                         bitcoin_key_1: Readable::read(r)?,
2059                         bitcoin_key_2: Readable::read(r)?,
2060                         excess_data: {
2061                                 let mut excess_data = vec![];
2062                                 r.read_to_end(&mut excess_data)?;
2063                                 excess_data
2064                         },
2065                 })
2066         }
2067 }
2068
2069 impl_writeable_len_match!(ChannelAnnouncement, {
2070                 { ChannelAnnouncement { contents: UnsignedChannelAnnouncement {ref features, ref excess_data, ..}, .. },
2071                         2 + 2*32 + 4*33 + features.flags.len() + excess_data.len() + 4*64 }
2072         }, {
2073         node_signature_1,
2074         node_signature_2,
2075         bitcoin_signature_1,
2076         bitcoin_signature_2,
2077         contents
2078 });
2079
2080 impl<W: Writer> Writeable<W> for UnsignedChannelUpdate {
2081         fn write(&self, w: &mut W) -> Result<(), DecodeError> {
2082                 w.size_hint(64 + self.excess_data.len());
2083                 self.chain_hash.write(w)?;
2084                 self.short_channel_id.write(w)?;
2085                 self.timestamp.write(w)?;
2086                 self.flags.write(w)?;
2087                 self.cltv_expiry_delta.write(w)?;
2088                 self.htlc_minimum_msat.write(w)?;
2089                 self.fee_base_msat.write(w)?;
2090                 self.fee_proportional_millionths.write(w)?;
2091                 w.write_all(&self.excess_data[..])?;
2092                 Ok(())
2093         }
2094 }
2095
2096 impl<R: Read> Readable<R> for UnsignedChannelUpdate {
2097         fn read(r: &mut R) -> Result<Self, DecodeError> {
2098                 Ok(Self {
2099                         chain_hash: Readable::read(r)?,
2100                         short_channel_id: Readable::read(r)?,
2101                         timestamp: Readable::read(r)?,
2102                         flags: Readable::read(r)?,
2103                         cltv_expiry_delta: Readable::read(r)?,
2104                         htlc_minimum_msat: Readable::read(r)?,
2105                         fee_base_msat: Readable::read(r)?,
2106                         fee_proportional_millionths: Readable::read(r)?,
2107                         excess_data: {
2108                                 let mut excess_data = vec![];
2109                                 r.read_to_end(&mut excess_data)?;
2110                                 excess_data
2111                         },
2112                 })
2113         }
2114 }
2115
2116 impl_writeable_len_match!(ChannelUpdate, {
2117                 { ChannelUpdate { contents: UnsignedChannelUpdate {ref excess_data, ..}, .. },
2118                         64 + excess_data.len() + 64 }
2119         }, {
2120         signature,
2121         contents
2122 });
2123
2124 impl<W: Writer> Writeable<W> for ErrorMessage {
2125         fn write(&self, w: &mut W) -> Result<(), DecodeError> {
2126                 w.size_hint(32 + 2 + self.data.len());
2127                 self.channel_id.write(w)?;
2128                 (self.data.len() as u16).write(w)?;
2129                 w.write_all(self.data.as_bytes())?;
2130                 Ok(())
2131         }
2132 }
2133
2134 impl<R: Read> Readable<R> for ErrorMessage {
2135         fn read(r: &mut R) -> Result<Self, DecodeError> {
2136                 Ok(Self {
2137                         channel_id: Readable::read(r)?,
2138                         data: {
2139                                 let mut sz: usize = <u16 as Readable<R>>::read(r)? as usize;
2140                                 let mut data = vec![];
2141                                 let data_len = r.read_to_end(&mut data)?;
2142                                 sz = cmp::min(data_len, sz);
2143                                 match String::from_utf8(data[..sz as usize].to_vec()) {
2144                                         Ok(s) => s,
2145                                         Err(_) => return Err(DecodeError::BadText),
2146                                 }
2147                         }
2148                 })
2149         }
2150 }
2151
2152 impl<W: Writer> Writeable<W> for UnsignedNodeAnnouncement {
2153         fn write(&self, w: &mut W) -> Result<(), DecodeError> {
2154                 w.size_hint(64 + 76 + self.features.flags.len() + self.addresses.len()*38 + self.excess_address_data.len() + self.excess_data.len());
2155                 self.features.write(w)?;
2156                 self.timestamp.write(w)?;
2157                 self.node_id.write(w)?;
2158                 w.write_all(&self.rgb)?;
2159                 self.alias.write(w)?;
2160
2161                 let mut addr_slice = Vec::with_capacity(self.addresses.len() * 18);
2162                 let mut addrs_to_encode = self.addresses.clone();
2163                 addrs_to_encode.sort_unstable_by(|a, b| { a.get_id().cmp(&b.get_id()) });
2164                 addrs_to_encode.dedup_by(|a, b| { a.get_id() == b.get_id() });
2165                 for addr in addrs_to_encode.iter() {
2166                         match addr {
2167                                 &NetAddress::IPv4{addr, port} => {
2168                                         addr_slice.push(1);
2169                                         addr_slice.extend_from_slice(&addr);
2170                                         addr_slice.extend_from_slice(&byte_utils::be16_to_array(port));
2171                                 },
2172                                 &NetAddress::IPv6{addr, port} => {
2173                                         addr_slice.push(2);
2174                                         addr_slice.extend_from_slice(&addr);
2175                                         addr_slice.extend_from_slice(&byte_utils::be16_to_array(port));
2176                                 },
2177                                 &NetAddress::OnionV2{addr, port} => {
2178                                         addr_slice.push(3);
2179                                         addr_slice.extend_from_slice(&addr);
2180                                         addr_slice.extend_from_slice(&byte_utils::be16_to_array(port));
2181                                 },
2182                                 &NetAddress::OnionV3{ed25519_pubkey, checksum, version, port} => {
2183                                         addr_slice.push(4);
2184                                         addr_slice.extend_from_slice(&ed25519_pubkey);
2185                                         addr_slice.extend_from_slice(&byte_utils::be16_to_array(checksum));
2186                                         addr_slice.push(version);
2187                                         addr_slice.extend_from_slice(&byte_utils::be16_to_array(port));
2188                                 },
2189                         }
2190                 }
2191                 ((addr_slice.len() + self.excess_address_data.len()) as u16).write(w)?;
2192                 w.write_all(&addr_slice[..])?;
2193                 w.write_all(&self.excess_address_data[..])?;
2194                 w.write_all(&self.excess_data[..])?;
2195                 Ok(())
2196         }
2197 }
2198
2199 impl<R: Read> Readable<R> for UnsignedNodeAnnouncement {
2200         fn read(r: &mut R) -> Result<Self, DecodeError> {
2201                 let features: GlobalFeatures = Readable::read(r)?;
2202                 if features.requires_unknown_bits() {
2203                         return Err(DecodeError::UnknownRequiredFeature);
2204                 }
2205                 let timestamp: u32 = Readable::read(r)?;
2206                 let node_id: PublicKey = Readable::read(r)?;
2207                 let mut rgb = [0; 3];
2208                 r.read_exact(&mut rgb)?;
2209                 let alias: [u8; 32] = Readable::read(r)?;
2210
2211                 let addrlen: u16 = Readable::read(r)?;
2212                 let mut addr_readpos = 0;
2213                 let mut addresses = Vec::with_capacity(4);
2214                 let mut f: u8 = 0;
2215                 let mut excess = 0;
2216                 loop {
2217                         if addrlen <= addr_readpos { break; }
2218                         f = Readable::read(r)?;
2219                         match f {
2220                                 1 => {
2221                                         if addresses.len() > 0 {
2222                                                 return Err(DecodeError::ExtraAddressesPerType);
2223                                         }
2224                                         if addrlen < addr_readpos + 1 + 6 {
2225                                                 return Err(DecodeError::BadLengthDescriptor);
2226                                         }
2227                                         addresses.push(NetAddress::IPv4 {
2228                                                 addr: {
2229                                                         let mut addr = [0; 4];
2230                                                         r.read_exact(&mut addr)?;
2231                                                         addr
2232                                                 },
2233                                                 port: Readable::read(r)?,
2234                                         });
2235                                         addr_readpos += 1 + 6
2236                                 },
2237                                 2 => {
2238                                         if addresses.len() > 1 || (addresses.len() == 1 && addresses[0].get_id() != 1) {
2239                                                 return Err(DecodeError::ExtraAddressesPerType);
2240                                         }
2241                                         if addrlen < addr_readpos + 1 + 18 {
2242                                                 return Err(DecodeError::BadLengthDescriptor);
2243                                         }
2244                                         addresses.push(NetAddress::IPv6 {
2245                                                 addr: {
2246                                                         let mut addr = [0; 16];
2247                                                         r.read_exact(&mut addr)?;
2248                                                         addr
2249                                                 },
2250                                                 port: Readable::read(r)?,
2251                                         });
2252                                         addr_readpos += 1 + 18
2253                                 },
2254                                 3 => {
2255                                         if addresses.len() > 2 || (addresses.len() > 0 && addresses.last().unwrap().get_id() > 2) {
2256                                                 return Err(DecodeError::ExtraAddressesPerType);
2257                                         }
2258                                         if addrlen < addr_readpos + 1 + 12 {
2259                                                 return Err(DecodeError::BadLengthDescriptor);
2260                                         }
2261                                         addresses.push(NetAddress::OnionV2 {
2262                                                 addr: {
2263                                                         let mut addr = [0; 10];
2264                                                         r.read_exact(&mut addr)?;
2265                                                         addr
2266                                                 },
2267                                                 port: Readable::read(r)?,
2268                                         });
2269                                         addr_readpos += 1 + 12
2270                                 },
2271                                 4 => {
2272                                         if addresses.len() > 3 || (addresses.len() > 0 && addresses.last().unwrap().get_id() > 3) {
2273                                                 return Err(DecodeError::ExtraAddressesPerType);
2274                                         }
2275                                         if addrlen < addr_readpos + 1 + 37 {
2276                                                 return Err(DecodeError::BadLengthDescriptor);
2277                                         }
2278                                         addresses.push(NetAddress::OnionV3 {
2279                                                 ed25519_pubkey: Readable::read(r)?,
2280                                                 checksum: Readable::read(r)?,
2281                                                 version: Readable::read(r)?,
2282                                                 port: Readable::read(r)?,
2283                                         });
2284                                         addr_readpos += 1 + 37
2285                                 },
2286                                 _ => { excess = 1; break; }
2287                         }
2288                 }
2289
2290                 let mut excess_data = vec![];
2291                 let excess_address_data = if addr_readpos < addrlen {
2292                         let mut excess_address_data = vec![0; (addrlen - addr_readpos) as usize];
2293                         r.read_exact(&mut excess_address_data[excess..])?;
2294                         if excess == 1 {
2295                                 excess_address_data[0] = f;
2296                         }
2297                         excess_address_data
2298                 } else {
2299                         if excess == 1 {
2300                                 excess_data.push(f);
2301                         }
2302                         Vec::new()
2303                 };
2304
2305                 Ok(UnsignedNodeAnnouncement {
2306                         features: features,
2307                         timestamp: timestamp,
2308                         node_id: node_id,
2309                         rgb: rgb,
2310                         alias: alias,
2311                         addresses: addresses,
2312                         excess_address_data: excess_address_data,
2313                         excess_data: {
2314                                 r.read_to_end(&mut excess_data)?;
2315                                 excess_data
2316                         },
2317                 })
2318         }
2319 }
2320
2321 impl_writeable_len_match!(NodeAnnouncement, {
2322                 { NodeAnnouncement { contents: UnsignedNodeAnnouncement { ref features, ref addresses, ref excess_address_data, ref excess_data, ..}, .. },
2323                         64 + 76 + features.flags.len() + addresses.len()*38 + excess_address_data.len() + excess_data.len() }
2324         }, {
2325         signature,
2326         contents
2327 });
2328
2329 #[cfg(test)]
2330 mod tests {
2331         use hex;
2332         use ln::msgs::MsgEncodable;
2333         use ln::msgs;
2334         use secp256k1::key::{PublicKey,SecretKey};
2335         use secp256k1::Secp256k1;
2336
2337         #[test]
2338         fn encoding_channel_reestablish_no_secret() {
2339                 let cr = msgs::ChannelReestablish {
2340                         channel_id: [4, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0],
2341                         next_local_commitment_number: 3,
2342                         next_remote_commitment_number: 4,
2343                         data_loss_protect: None,
2344                 };
2345
2346                 let encoded_value = cr.encode();
2347                 assert_eq!(
2348                         encoded_value,
2349                         vec![4, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 4]
2350                 );
2351         }
2352
2353         #[test]
2354         fn encoding_channel_reestablish_with_secret() {
2355                 let public_key = {
2356                         let secp_ctx = Secp256k1::new();
2357                         PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2358                 };
2359
2360                 let cr = msgs::ChannelReestablish {
2361                         channel_id: [4, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0],
2362                         next_local_commitment_number: 3,
2363                         next_remote_commitment_number: 4,
2364                         data_loss_protect: Some(msgs::DataLossProtect { your_last_per_commitment_secret: [9;32], my_current_per_commitment_point: public_key}),
2365                 };
2366
2367                 let encoded_value = cr.encode();
2368                 assert_eq!(
2369                         encoded_value,
2370                         vec![4, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 4, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 3, 27, 132, 197, 86, 123, 18, 100, 64, 153, 93, 62, 213, 170, 186, 5, 101, 215, 30, 24, 52, 96, 72, 25, 255, 156, 23, 245, 233, 213, 221, 7, 143]
2371                 );
2372         }
2373 }