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