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