X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=src%2Fln%2Fmsgs.rs;h=5100ed79c38a54fcf07aba82e663b886325b4667;hb=8322c756cb3574d74cf1b88893dad14ec5be57ad;hp=f2f9fcbd131002b8b6bb8d4b4cca7b67ca6955e9;hpb=89475381bb599baabdc1dff1d821b038c1f8e4fe;p=rust-lightning diff --git a/src/ln/msgs.rs b/src/ln/msgs.rs index f2f9fcbd..5100ed79 100644 --- a/src/ln/msgs.rs +++ b/src/ln/msgs.rs @@ -2,15 +2,16 @@ use secp256k1::key::PublicKey; use secp256k1::{Secp256k1, Signature}; use secp256k1; use bitcoin::util::hash::Sha256dHash; -use bitcoin::network::serialize::{deserialize,serialize}; +use bitcoin::network::serialize::serialize; use bitcoin::blockdata::script::Script; use std::error::Error; use std::{cmp, fmt}; +use std::io::Read; use std::result::Result; use util::{byte_utils, internal_traits, events}; -use util::ser::{Readable, Reader, Writeable, Writer}; +use util::ser::{Readable, Writeable, Writer}; pub trait MsgEncodable { fn encode(&self) -> Vec; @@ -46,12 +47,9 @@ pub enum DecodeError { BadLengthDescriptor, /// Error from std::io Io(::std::io::Error), - /// Invalid value found when decoding + /// 1 or 0 is not found for boolean value InvalidValue, } -pub trait MsgDecodable: Sized { - fn decode(v: &[u8]) -> Result; -} /// Tracks localfeatures which are only in init messages #[derive(Clone, PartialEq)] @@ -456,13 +454,17 @@ pub trait ChannelMessageHandler : events::EventsProvider + Send + Sync { // Channel-to-announce: fn handle_announcement_signatures(&self, their_node_id: &PublicKey, msg: &AnnouncementSignatures) -> Result<(), HandleError>; - // Error conditions: + // Connection loss/reestablish: /// Indicates a connection to the peer failed/an existing connection was lost. If no connection /// is believed to be possible in the future (eg they're sending us messages we don't /// understand or indicate they require unknown feature bits), no_connection_possible is set /// and any outstanding channels should be failed. fn peer_disconnected(&self, their_node_id: &PublicKey, no_connection_possible: bool); + fn peer_connected(&self, their_node_id: &PublicKey) -> Vec; + fn handle_channel_reestablish(&self, their_node_id: &PublicKey, msg: &ChannelReestablish) -> Result<(Option, Option, Option), HandleError>; + + // Error: fn handle_error(&self, their_node_id: &PublicKey, msg: &ErrorMessage); } @@ -525,7 +527,7 @@ impl Error for DecodeError { DecodeError::ExtraAddressesPerType => "More than one address of a single type", DecodeError::BadLengthDescriptor => "A length descriptor in the packet didn't describe the later data correctly", DecodeError::Io(ref e) => e.description(), - DecodeError::InvalidValue => "Invalid value in the bytes", + DecodeError::InvalidValue => "0 or 1 is not found for boolean", } } } @@ -551,58 +553,6 @@ impl From<::std::io::Error> for DecodeError { } } -macro_rules! secp_pubkey { - ( $ctx: expr, $slice: expr ) => { - match PublicKey::from_slice($ctx, $slice) { - Ok(key) => key, - Err(_) => return Err(DecodeError::BadPublicKey) - } - }; -} - -macro_rules! secp_signature { - ( $ctx: expr, $slice: expr ) => { - match Signature::from_compact($ctx, $slice) { - Ok(sig) => sig, - Err(_) => return Err(DecodeError::BadSignature) - } - }; -} - -impl MsgDecodable for LocalFeatures { - fn decode(v: &[u8]) -> Result { - if v.len() < 2 { return Err(DecodeError::ShortRead); } - let len = byte_utils::slice_to_be16(&v[0..2]) as usize; - if v.len() < len + 2 { return Err(DecodeError::ShortRead); } - let mut flags = Vec::with_capacity(len); - flags.extend_from_slice(&v[2..2 + len]); - Ok(Self { - flags: flags - }) - } -} -impl MsgEncodable for LocalFeatures { - fn encode(&self) -> Vec { - let mut res = Vec::with_capacity(self.flags.len() + 2); - res.extend_from_slice(&byte_utils::be16_to_array(self.flags.len() as u16)); - res.extend_from_slice(&self.flags[..]); - res - } - fn encoded_len(&self) -> usize { self.flags.len() + 2 } -} - -impl MsgDecodable for GlobalFeatures { - fn decode(v: &[u8]) -> Result { - if v.len() < 2 { return Err(DecodeError::ShortRead); } - let len = byte_utils::slice_to_be16(&v[0..2]) as usize; - if v.len() < len + 2 { return Err(DecodeError::ShortRead); } - let mut flags = Vec::with_capacity(len); - flags.extend_from_slice(&v[2..2 + len]); - Ok(Self { - flags: flags - }) - } -} impl MsgEncodable for GlobalFeatures { fn encode(&self) -> Vec { let mut res = Vec::with_capacity(self.flags.len() + 2); @@ -613,564 +563,6 @@ impl MsgEncodable for GlobalFeatures { fn encoded_len(&self) -> usize { self.flags.len() + 2 } } -impl MsgDecodable for Init { - fn decode(v: &[u8]) -> Result { - let global_features = GlobalFeatures::decode(v)?; - if v.len() < global_features.flags.len() + 4 { - return Err(DecodeError::ShortRead); - } - let local_features = LocalFeatures::decode(&v[global_features.flags.len() + 2..])?; - Ok(Self { - global_features: global_features, - local_features: local_features, - }) - } -} -impl MsgEncodable for Init { - fn encode(&self) -> Vec { - let mut res = Vec::with_capacity(self.global_features.flags.len() + self.local_features.flags.len()); - res.extend_from_slice(&self.global_features.encode()[..]); - res.extend_from_slice(&self.local_features.encode()[..]); - res - } -} - -impl MsgDecodable for Ping { - fn decode(v: &[u8]) -> Result { - if v.len() < 4 { - return Err(DecodeError::ShortRead); - } - let ponglen = byte_utils::slice_to_be16(&v[0..2]); - let byteslen = byte_utils::slice_to_be16(&v[2..4]); - if v.len() < 4 + byteslen as usize { - return Err(DecodeError::ShortRead); - } - Ok(Self { - ponglen, - byteslen, - }) - } -} -impl MsgEncodable for Ping { - fn encode(&self) -> Vec { - let mut res = Vec::with_capacity(self.byteslen as usize + 2); - res.extend_from_slice(&byte_utils::be16_to_array(self.byteslen)); - res.resize(2 + self.byteslen as usize, 0); - res - } -} - -impl MsgDecodable for Pong { - fn decode(v: &[u8]) -> Result { - if v.len() < 2 { - return Err(DecodeError::ShortRead); - } - let byteslen = byte_utils::slice_to_be16(&v[0..2]); - if v.len() < 2 + byteslen as usize { - return Err(DecodeError::ShortRead); - } - Ok(Self { - byteslen - }) - } -} -impl MsgEncodable for Pong { - fn encode(&self) -> Vec { - let mut res = Vec::with_capacity(self.byteslen as usize + 2); - res.extend_from_slice(&byte_utils::be16_to_array(self.byteslen)); - res.resize(2 + self.byteslen as usize, 0); - res - } -} - -impl MsgDecodable for OpenChannel { - fn decode(v: &[u8]) -> Result { - if v.len() < 2*32+6*8+4+2*2+6*33+1 { - return Err(DecodeError::ShortRead); - } - let ctx = Secp256k1::without_caps(); - - let mut shutdown_scriptpubkey = None; - if v.len() >= 321 { - let len = byte_utils::slice_to_be16(&v[319..321]) as usize; - if v.len() < 321+len { - return Err(DecodeError::ShortRead); - } - shutdown_scriptpubkey = Some(Script::from(v[321..321+len].to_vec())); - } - let mut temp_channel_id = [0; 32]; - temp_channel_id[..].copy_from_slice(&v[32..64]); - Ok(OpenChannel { - chain_hash: deserialize(&v[0..32]).unwrap(), - temporary_channel_id: temp_channel_id, - funding_satoshis: byte_utils::slice_to_be64(&v[64..72]), - push_msat: byte_utils::slice_to_be64(&v[72..80]), - dust_limit_satoshis: byte_utils::slice_to_be64(&v[80..88]), - max_htlc_value_in_flight_msat: byte_utils::slice_to_be64(&v[88..96]), - channel_reserve_satoshis: byte_utils::slice_to_be64(&v[96..104]), - htlc_minimum_msat: byte_utils::slice_to_be64(&v[104..112]), - feerate_per_kw: byte_utils::slice_to_be32(&v[112..116]), - to_self_delay: byte_utils::slice_to_be16(&v[116..118]), - max_accepted_htlcs: byte_utils::slice_to_be16(&v[118..120]), - funding_pubkey: secp_pubkey!(&ctx, &v[120..153]), - revocation_basepoint: secp_pubkey!(&ctx, &v[153..186]), - payment_basepoint: secp_pubkey!(&ctx, &v[186..219]), - delayed_payment_basepoint: secp_pubkey!(&ctx, &v[219..252]), - htlc_basepoint: secp_pubkey!(&ctx, &v[252..285]), - first_per_commitment_point: secp_pubkey!(&ctx, &v[285..318]), - channel_flags: v[318], - shutdown_scriptpubkey: shutdown_scriptpubkey - }) - } -} -impl MsgEncodable for OpenChannel { - fn encode(&self) -> Vec { - let mut res = match &self.shutdown_scriptpubkey { - &Some(ref script) => Vec::with_capacity(319 + 2 + script.len()), - &None => Vec::with_capacity(319), - }; - res.extend_from_slice(&serialize(&self.chain_hash).unwrap()); - res.extend_from_slice(&serialize(&self.temporary_channel_id).unwrap()); - res.extend_from_slice(&byte_utils::be64_to_array(self.funding_satoshis)); - res.extend_from_slice(&byte_utils::be64_to_array(self.push_msat)); - res.extend_from_slice(&byte_utils::be64_to_array(self.dust_limit_satoshis)); - res.extend_from_slice(&byte_utils::be64_to_array(self.max_htlc_value_in_flight_msat)); - res.extend_from_slice(&byte_utils::be64_to_array(self.channel_reserve_satoshis)); - res.extend_from_slice(&byte_utils::be64_to_array(self.htlc_minimum_msat)); - res.extend_from_slice(&byte_utils::be32_to_array(self.feerate_per_kw)); - res.extend_from_slice(&byte_utils::be16_to_array(self.to_self_delay)); - res.extend_from_slice(&byte_utils::be16_to_array(self.max_accepted_htlcs)); - res.extend_from_slice(&self.funding_pubkey.serialize()); - res.extend_from_slice(&self.revocation_basepoint.serialize()); - res.extend_from_slice(&self.payment_basepoint.serialize()); - res.extend_from_slice(&self.delayed_payment_basepoint.serialize()); - res.extend_from_slice(&self.htlc_basepoint.serialize()); - res.extend_from_slice(&self.first_per_commitment_point.serialize()); - res.push(self.channel_flags); - if let &Some(ref script) = &self.shutdown_scriptpubkey { - res.extend_from_slice(&byte_utils::be16_to_array(script.len() as u16)); - res.extend_from_slice(&script[..]); - } - res - } -} - -impl MsgDecodable for AcceptChannel { - fn decode(v: &[u8]) -> Result { - if v.len() < 32+4*8+4+2*2+6*33 { - return Err(DecodeError::ShortRead); - } - let ctx = Secp256k1::without_caps(); - - let mut shutdown_scriptpubkey = None; - if v.len() >= 272 { - let len = byte_utils::slice_to_be16(&v[270..272]) as usize; - if v.len() < 272+len { - return Err(DecodeError::ShortRead); - } - shutdown_scriptpubkey = Some(Script::from(v[272..272+len].to_vec())); - } - - let mut temporary_channel_id = [0; 32]; - temporary_channel_id[..].copy_from_slice(&v[0..32]); - Ok(Self { - temporary_channel_id, - dust_limit_satoshis: byte_utils::slice_to_be64(&v[32..40]), - max_htlc_value_in_flight_msat: byte_utils::slice_to_be64(&v[40..48]), - channel_reserve_satoshis: byte_utils::slice_to_be64(&v[48..56]), - htlc_minimum_msat: byte_utils::slice_to_be64(&v[56..64]), - minimum_depth: byte_utils::slice_to_be32(&v[64..68]), - to_self_delay: byte_utils::slice_to_be16(&v[68..70]), - max_accepted_htlcs: byte_utils::slice_to_be16(&v[70..72]), - funding_pubkey: secp_pubkey!(&ctx, &v[72..105]), - revocation_basepoint: secp_pubkey!(&ctx, &v[105..138]), - payment_basepoint: secp_pubkey!(&ctx, &v[138..171]), - delayed_payment_basepoint: secp_pubkey!(&ctx, &v[171..204]), - htlc_basepoint: secp_pubkey!(&ctx, &v[204..237]), - first_per_commitment_point: secp_pubkey!(&ctx, &v[237..270]), - shutdown_scriptpubkey: shutdown_scriptpubkey - }) - } -} -impl MsgEncodable for AcceptChannel { - fn encode(&self) -> Vec { - let mut res = match &self.shutdown_scriptpubkey { - &Some(ref script) => Vec::with_capacity(270 + 2 + script.len()), - &None => Vec::with_capacity(270), - }; - res.extend_from_slice(&self.temporary_channel_id); - res.extend_from_slice(&byte_utils::be64_to_array(self.dust_limit_satoshis)); - res.extend_from_slice(&byte_utils::be64_to_array(self.max_htlc_value_in_flight_msat)); - res.extend_from_slice(&byte_utils::be64_to_array(self.channel_reserve_satoshis)); - res.extend_from_slice(&byte_utils::be64_to_array(self.htlc_minimum_msat)); - res.extend_from_slice(&byte_utils::be32_to_array(self.minimum_depth)); - res.extend_from_slice(&byte_utils::be16_to_array(self.to_self_delay)); - res.extend_from_slice(&byte_utils::be16_to_array(self.max_accepted_htlcs)); - res.extend_from_slice(&self.funding_pubkey.serialize()); - res.extend_from_slice(&self.revocation_basepoint.serialize()); - res.extend_from_slice(&self.payment_basepoint.serialize()); - res.extend_from_slice(&self.delayed_payment_basepoint.serialize()); - res.extend_from_slice(&self.htlc_basepoint.serialize()); - res.extend_from_slice(&self.first_per_commitment_point.serialize()); - if let &Some(ref script) = &self.shutdown_scriptpubkey { - res.extend_from_slice(&byte_utils::be16_to_array(script.len() as u16)); - res.extend_from_slice(&script[..]); - } - res - } -} - -impl MsgDecodable for FundingCreated { - fn decode(v: &[u8]) -> Result { - if v.len() < 32+32+2+64 { - return Err(DecodeError::ShortRead); - } - let ctx = Secp256k1::without_caps(); - let mut temporary_channel_id = [0; 32]; - temporary_channel_id[..].copy_from_slice(&v[0..32]); - Ok(Self { - temporary_channel_id, - funding_txid: deserialize(&v[32..64]).unwrap(), - funding_output_index: byte_utils::slice_to_be16(&v[64..66]), - signature: secp_signature!(&ctx, &v[66..130]), - }) - } -} -impl MsgEncodable for FundingCreated { - fn encode(&self) -> Vec { - let mut res = Vec::with_capacity(32+32+2+64); - res.extend_from_slice(&self.temporary_channel_id); - res.extend_from_slice(&serialize(&self.funding_txid).unwrap()[..]); - res.extend_from_slice(&byte_utils::be16_to_array(self.funding_output_index)); - let secp_ctx = Secp256k1::without_caps(); - res.extend_from_slice(&self.signature.serialize_compact(&secp_ctx)); - res - } -} - -impl MsgDecodable for FundingSigned { - fn decode(v: &[u8]) -> Result { - if v.len() < 32+64 { - return Err(DecodeError::ShortRead); - } - let ctx = Secp256k1::without_caps(); - let mut channel_id = [0; 32]; - channel_id[..].copy_from_slice(&v[0..32]); - Ok(Self { - channel_id, - signature: secp_signature!(&ctx, &v[32..96]), - }) - } -} -impl MsgEncodable for FundingSigned { - fn encode(&self) -> Vec { - let mut res = Vec::with_capacity(32+64); - res.extend_from_slice(&self.channel_id); - res.extend_from_slice(&self.signature.serialize_compact(&Secp256k1::without_caps())); - res - } -} - -impl MsgDecodable for FundingLocked { - fn decode(v: &[u8]) -> Result { - if v.len() < 32+33 { - return Err(DecodeError::ShortRead); - } - let ctx = Secp256k1::without_caps(); - let mut channel_id = [0; 32]; - channel_id[..].copy_from_slice(&v[0..32]); - Ok(Self { - channel_id, - next_per_commitment_point: secp_pubkey!(&ctx, &v[32..65]), - }) - } -} -impl MsgEncodable for FundingLocked { - fn encode(&self) -> Vec { - let mut res = Vec::with_capacity(32+33); - res.extend_from_slice(&self.channel_id); - res.extend_from_slice(&self.next_per_commitment_point.serialize()); - res - } -} - -impl MsgDecodable for Shutdown { - fn decode(v: &[u8]) -> Result { - if v.len() < 32 + 2 { - return Err(DecodeError::ShortRead); - } - let scriptlen = byte_utils::slice_to_be16(&v[32..34]) as usize; - if v.len() < 32 + 2 + scriptlen { - return Err(DecodeError::ShortRead); - } - let mut channel_id = [0; 32]; - channel_id[..].copy_from_slice(&v[0..32]); - Ok(Self { - channel_id, - scriptpubkey: Script::from(v[34..34 + scriptlen].to_vec()), - }) - } -} -impl MsgEncodable for Shutdown { - fn encode(&self) -> Vec { - let mut res = Vec::with_capacity(32 + 2 + self.scriptpubkey.len()); - res.extend_from_slice(&self.channel_id); - res.extend_from_slice(&byte_utils::be16_to_array(self.scriptpubkey.len() as u16)); - res.extend_from_slice(&self.scriptpubkey[..]); - res - } -} - -impl MsgDecodable for ClosingSigned { - fn decode(v: &[u8]) -> Result { - if v.len() < 32 + 8 + 64 { - return Err(DecodeError::ShortRead); - } - let secp_ctx = Secp256k1::without_caps(); - let mut channel_id = [0; 32]; - channel_id[..].copy_from_slice(&v[0..32]); - Ok(Self { - channel_id, - fee_satoshis: byte_utils::slice_to_be64(&v[32..40]), - signature: secp_signature!(&secp_ctx, &v[40..104]), - }) - } -} -impl MsgEncodable for ClosingSigned { - fn encode(&self) -> Vec { - let mut res = Vec::with_capacity(32+8+64); - res.extend_from_slice(&self.channel_id); - res.extend_from_slice(&byte_utils::be64_to_array(self.fee_satoshis)); - let secp_ctx = Secp256k1::without_caps(); - res.extend_from_slice(&self.signature.serialize_compact(&secp_ctx)); - res - } -} - -impl MsgDecodable for UpdateAddHTLC { - fn decode(v: &[u8]) -> Result { - if v.len() < 32+8+8+32+4+1+33+20*65+32 { - return Err(DecodeError::ShortRead); - } - let mut channel_id = [0; 32]; - channel_id[..].copy_from_slice(&v[0..32]); - let mut payment_hash = [0; 32]; - payment_hash.copy_from_slice(&v[48..80]); - Ok(Self{ - channel_id, - htlc_id: byte_utils::slice_to_be64(&v[32..40]), - amount_msat: byte_utils::slice_to_be64(&v[40..48]), - payment_hash, - cltv_expiry: byte_utils::slice_to_be32(&v[80..84]), - onion_routing_packet: OnionPacket::decode(&v[84..84+1366])?, - }) - } -} -impl MsgEncodable for UpdateAddHTLC { - fn encode(&self) -> Vec { - let mut res = Vec::with_capacity(32+8+8+32+4+1366); - res.extend_from_slice(&self.channel_id); - res.extend_from_slice(&byte_utils::be64_to_array(self.htlc_id)); - res.extend_from_slice(&byte_utils::be64_to_array(self.amount_msat)); - res.extend_from_slice(&self.payment_hash); - res.extend_from_slice(&byte_utils::be32_to_array(self.cltv_expiry)); - res.extend_from_slice(&self.onion_routing_packet.encode()[..]); - res - } -} - -impl MsgDecodable for UpdateFulfillHTLC { - fn decode(v: &[u8]) -> Result { - if v.len() < 32+8+32 { - return Err(DecodeError::ShortRead); - } - let mut channel_id = [0; 32]; - channel_id[..].copy_from_slice(&v[0..32]); - let mut payment_preimage = [0; 32]; - payment_preimage.copy_from_slice(&v[40..72]); - Ok(Self{ - channel_id, - htlc_id: byte_utils::slice_to_be64(&v[32..40]), - payment_preimage, - }) - } -} -impl MsgEncodable for UpdateFulfillHTLC { - fn encode(&self) -> Vec { - let mut res = Vec::with_capacity(32+8+32); - res.extend_from_slice(&self.channel_id); - res.extend_from_slice(&byte_utils::be64_to_array(self.htlc_id)); - res.extend_from_slice(&self.payment_preimage); - res - } -} - -impl MsgDecodable for UpdateFailHTLC { - fn decode(v: &[u8]) -> Result { - if v.len() < 32+8 { - return Err(DecodeError::ShortRead); - } - let mut channel_id = [0; 32]; - channel_id[..].copy_from_slice(&v[0..32]); - Ok(Self{ - channel_id, - htlc_id: byte_utils::slice_to_be64(&v[32..40]), - reason: OnionErrorPacket::decode(&v[40..])?, - }) - } -} -impl MsgEncodable for UpdateFailHTLC { - fn encode(&self) -> Vec { - let reason = self.reason.encode(); - let mut res = Vec::with_capacity(32+8+reason.len()); - res.extend_from_slice(&self.channel_id); - res.extend_from_slice(&byte_utils::be64_to_array(self.htlc_id)); - res.extend_from_slice(&reason[..]); - res - } -} - -impl MsgDecodable for UpdateFailMalformedHTLC { - fn decode(v: &[u8]) -> Result { - if v.len() < 32+8+32+2 { - return Err(DecodeError::ShortRead); - } - let mut channel_id = [0; 32]; - channel_id[..].copy_from_slice(&v[0..32]); - let mut sha256_of_onion = [0; 32]; - sha256_of_onion.copy_from_slice(&v[40..72]); - Ok(Self{ - channel_id, - htlc_id: byte_utils::slice_to_be64(&v[32..40]), - sha256_of_onion, - failure_code: byte_utils::slice_to_be16(&v[72..74]), - }) - } -} -impl MsgEncodable for UpdateFailMalformedHTLC { - fn encode(&self) -> Vec { - let mut res = Vec::with_capacity(32+8+32+2); - res.extend_from_slice(&self.channel_id); - res.extend_from_slice(&byte_utils::be64_to_array(self.htlc_id)); - res.extend_from_slice(&self.sha256_of_onion); - res.extend_from_slice(&byte_utils::be16_to_array(self.failure_code)); - res - } -} - -impl MsgDecodable for CommitmentSigned { - fn decode(v: &[u8]) -> Result { - if v.len() < 32+64+2 { - return Err(DecodeError::ShortRead); - } - let mut channel_id = [0; 32]; - channel_id[..].copy_from_slice(&v[0..32]); - - let htlcs = byte_utils::slice_to_be16(&v[96..98]) as usize; - if v.len() < 32+64+2+htlcs*64 { - return Err(DecodeError::ShortRead); - } - let mut htlc_signatures = Vec::with_capacity(htlcs); - let secp_ctx = Secp256k1::without_caps(); - for i in 0..htlcs { - htlc_signatures.push(secp_signature!(&secp_ctx, &v[98+i*64..98+(i+1)*64])); - } - Ok(Self { - channel_id, - signature: secp_signature!(&secp_ctx, &v[32..96]), - htlc_signatures, - }) - } -} -impl MsgEncodable for CommitmentSigned { - fn encode(&self) -> Vec { - let mut res = Vec::with_capacity(32+64+2+self.htlc_signatures.len()*64); - res.extend_from_slice(&self.channel_id); - let secp_ctx = Secp256k1::without_caps(); - res.extend_from_slice(&self.signature.serialize_compact(&secp_ctx)); - res.extend_from_slice(&byte_utils::be16_to_array(self.htlc_signatures.len() as u16)); - for i in 0..self.htlc_signatures.len() { - res.extend_from_slice(&self.htlc_signatures[i].serialize_compact(&secp_ctx)); - } - res - } -} - -impl MsgDecodable for RevokeAndACK { - fn decode(v: &[u8]) -> Result { - if v.len() < 32+32+33 { - return Err(DecodeError::ShortRead); - } - let mut channel_id = [0; 32]; - channel_id[..].copy_from_slice(&v[0..32]); - let mut per_commitment_secret = [0; 32]; - per_commitment_secret.copy_from_slice(&v[32..64]); - let secp_ctx = Secp256k1::without_caps(); - Ok(Self { - channel_id, - per_commitment_secret, - next_per_commitment_point: secp_pubkey!(&secp_ctx, &v[64..97]), - }) - } -} -impl MsgEncodable for RevokeAndACK { - fn encode(&self) -> Vec { - let mut res = Vec::with_capacity(32+32+33); - res.extend_from_slice(&self.channel_id); - res.extend_from_slice(&self.per_commitment_secret); - res.extend_from_slice(&self.next_per_commitment_point.serialize()); - res - } -} - -impl MsgDecodable for UpdateFee { - fn decode(v: &[u8]) -> Result { - if v.len() < 32+4 { - return Err(DecodeError::ShortRead); - } - let mut channel_id = [0; 32]; - channel_id[..].copy_from_slice(&v[0..32]); - Ok(Self { - channel_id, - feerate_per_kw: byte_utils::slice_to_be32(&v[32..36]), - }) - } -} -impl MsgEncodable for UpdateFee { - fn encode(&self) -> Vec { - let mut res = Vec::with_capacity(32+4); - res.extend_from_slice(&self.channel_id); - res.extend_from_slice(&byte_utils::be32_to_array(self.feerate_per_kw)); - res - } -} - -impl MsgDecodable for ChannelReestablish { - fn decode(v: &[u8]) -> Result { - if v.len() < 32+2*8 { - return Err(DecodeError::ShortRead); - } - - let data_loss_protect = if v.len() > 32+2*8 { - if v.len() < 32+2*8 + 33+32 { - return Err(DecodeError::ShortRead); - } - let mut inner_array = [0; 32]; - inner_array.copy_from_slice(&v[48..48+32]); - Some(DataLossProtect { - your_last_per_commitment_secret: inner_array, - my_current_per_commitment_point: secp_pubkey!(&Secp256k1::without_caps(), &v[48+32..48+32+33]), - }) - } else { None }; - - Ok(Self { - channel_id: deserialize(&v[0..32]).unwrap(), - next_local_commitment_number: byte_utils::slice_to_be64(&v[32..40]), - next_remote_commitment_number: byte_utils::slice_to_be64(&v[40..48]), - data_loss_protect: data_loss_protect, - }) - } -} impl MsgEncodable for ChannelReestablish { fn encode(&self) -> Vec { let mut res = Vec::with_capacity(if self.data_loss_protect.is_some() { 32+2*8+33+32 } else { 32+2*8 }); @@ -1187,151 +579,6 @@ impl MsgEncodable for ChannelReestablish { } } -impl MsgDecodable for AnnouncementSignatures { - fn decode(v: &[u8]) -> Result { - if v.len() < 32+8+64*2 { - return Err(DecodeError::ShortRead); - } - let secp_ctx = Secp256k1::without_caps(); - let mut channel_id = [0; 32]; - channel_id[..].copy_from_slice(&v[0..32]); - Ok(Self { - channel_id, - short_channel_id: byte_utils::slice_to_be64(&v[32..40]), - node_signature: secp_signature!(&secp_ctx, &v[40..104]), - bitcoin_signature: secp_signature!(&secp_ctx, &v[104..168]), - }) - } -} -impl MsgEncodable for AnnouncementSignatures { - fn encode(&self) -> Vec { - let mut res = Vec::with_capacity(32+8+64*2); - res.extend_from_slice(&self.channel_id); - res.extend_from_slice(&byte_utils::be64_to_array(self.short_channel_id)); - let secp_ctx = Secp256k1::without_caps(); - res.extend_from_slice(&self.node_signature.serialize_compact(&secp_ctx)); - res.extend_from_slice(&self.bitcoin_signature.serialize_compact(&secp_ctx)); - res - } -} - -impl MsgDecodable for UnsignedNodeAnnouncement { - fn decode(v: &[u8]) -> Result { - let features = GlobalFeatures::decode(&v[..])?; - if features.requires_unknown_bits() { - return Err(DecodeError::UnknownRequiredFeature); - } - - if v.len() < features.encoded_len() + 4 + 33 + 3 + 32 + 2 { - return Err(DecodeError::ShortRead); - } - let start = features.encoded_len(); - - let mut rgb = [0; 3]; - rgb.copy_from_slice(&v[start + 37..start + 40]); - - let mut alias = [0; 32]; - alias.copy_from_slice(&v[start + 40..start + 72]); - - let addrlen = byte_utils::slice_to_be16(&v[start + 72..start + 74]) as usize; - if v.len() < start + 74 + addrlen { - return Err(DecodeError::ShortRead); - } - let addr_read_limit = start + 74 + addrlen; - - let mut addresses = Vec::with_capacity(4); - let mut read_pos = start + 74; - loop { - if addr_read_limit <= read_pos { break; } - match v[read_pos] { - 1 => { - if addresses.len() > 0 { - return Err(DecodeError::ExtraAddressesPerType); - } - if addr_read_limit < read_pos + 1 + 6 { - return Err(DecodeError::BadLengthDescriptor); - } - let mut addr = [0; 4]; - addr.copy_from_slice(&v[read_pos + 1..read_pos + 5]); - addresses.push(NetAddress::IPv4 { - addr, - port: byte_utils::slice_to_be16(&v[read_pos + 5..read_pos + 7]), - }); - read_pos += 1 + 6; - }, - 2 => { - if addresses.len() > 1 || (addresses.len() == 1 && addresses[0].get_id() != 1) { - return Err(DecodeError::ExtraAddressesPerType); - } - if addr_read_limit < read_pos + 1 + 18 { - return Err(DecodeError::BadLengthDescriptor); - } - let mut addr = [0; 16]; - addr.copy_from_slice(&v[read_pos + 1..read_pos + 17]); - addresses.push(NetAddress::IPv6 { - addr, - port: byte_utils::slice_to_be16(&v[read_pos + 17..read_pos + 19]), - }); - read_pos += 1 + 18; - }, - 3 => { - if addresses.len() > 2 || (addresses.len() > 0 && addresses.last().unwrap().get_id() > 2) { - return Err(DecodeError::ExtraAddressesPerType); - } - if addr_read_limit < read_pos + 1 + 12 { - return Err(DecodeError::BadLengthDescriptor); - } - let mut addr = [0; 10]; - addr.copy_from_slice(&v[read_pos + 1..read_pos + 11]); - addresses.push(NetAddress::OnionV2 { - addr, - port: byte_utils::slice_to_be16(&v[read_pos + 11..read_pos + 13]), - }); - read_pos += 1 + 12; - }, - 4 => { - if addresses.len() > 3 || (addresses.len() > 0 && addresses.last().unwrap().get_id() > 3) { - return Err(DecodeError::ExtraAddressesPerType); - } - if addr_read_limit < read_pos + 1 + 37 { - return Err(DecodeError::BadLengthDescriptor); - } - let mut ed25519_pubkey = [0; 32]; - ed25519_pubkey.copy_from_slice(&v[read_pos + 1..read_pos + 33]); - addresses.push(NetAddress::OnionV3 { - ed25519_pubkey, - checksum: byte_utils::slice_to_be16(&v[read_pos + 33..read_pos + 35]), - version: v[read_pos + 35], - port: byte_utils::slice_to_be16(&v[read_pos + 36..read_pos + 38]), - }); - read_pos += 1 + 37; - }, - _ => { break; } // We've read all we can, we dont understand anything higher (and they're sorted) - } - } - - let excess_address_data = if read_pos < addr_read_limit { - let mut excess_address_data = Vec::with_capacity(addr_read_limit - read_pos); - excess_address_data.extend_from_slice(&v[read_pos..addr_read_limit]); - excess_address_data - } else { Vec::new() }; - - let mut excess_data = Vec::with_capacity(v.len() - addr_read_limit); - excess_data.extend_from_slice(&v[addr_read_limit..]); - - let secp_ctx = Secp256k1::without_caps(); - Ok(Self { - features, - timestamp: byte_utils::slice_to_be32(&v[start..start + 4]), - node_id: secp_pubkey!(&secp_ctx, &v[start + 4..start + 37]), - rgb, - alias, - addresses, - excess_address_data, - excess_data, - }) - } -} impl MsgEncodable for UnsignedNodeAnnouncement { fn encode(&self) -> Vec { let features = self.features.encode(); @@ -1379,54 +626,6 @@ impl MsgEncodable for UnsignedNodeAnnouncement { } } -impl MsgDecodable for NodeAnnouncement { - fn decode(v: &[u8]) -> Result { - if v.len() < 64 { - return Err(DecodeError::ShortRead); - } - let secp_ctx = Secp256k1::without_caps(); - Ok(Self { - signature: secp_signature!(&secp_ctx, &v[0..64]), - contents: UnsignedNodeAnnouncement::decode(&v[64..])?, - }) - } -} -impl MsgEncodable for NodeAnnouncement { - fn encode(&self) -> Vec { - let contents = self.contents.encode(); - let mut res = Vec::with_capacity(64 + contents.len()); - let secp_ctx = Secp256k1::without_caps(); - res.extend_from_slice(&self.signature.serialize_compact(&secp_ctx)); - res.extend_from_slice(&contents); - res - } -} - -impl MsgDecodable for UnsignedChannelAnnouncement { - fn decode(v: &[u8]) -> Result { - let features = GlobalFeatures::decode(&v[..])?; - if features.requires_unknown_bits() { - return Err(DecodeError::UnknownRequiredFeature); - } - if v.len() < features.encoded_len() + 32 + 8 + 33*4 { - return Err(DecodeError::ShortRead); - } - let start = features.encoded_len(); - let secp_ctx = Secp256k1::without_caps(); - let mut excess_data = Vec::with_capacity(v.len() - start - 172); - excess_data.extend_from_slice(&v[start + 172..]); - Ok(Self { - features, - chain_hash: deserialize(&v[start..start + 32]).unwrap(), - short_channel_id: byte_utils::slice_to_be64(&v[start + 32..start + 40]), - node_id_1: secp_pubkey!(&secp_ctx, &v[start + 40..start + 73]), - node_id_2: secp_pubkey!(&secp_ctx, &v[start + 73..start + 106]), - bitcoin_key_1: secp_pubkey!(&secp_ctx, &v[start + 106..start + 139]), - bitcoin_key_2: secp_pubkey!(&secp_ctx, &v[start + 139..start + 172]), - excess_data, - }) - } -} impl MsgEncodable for UnsignedChannelAnnouncement { fn encode(&self) -> Vec { let features = self.features.encode(); @@ -1443,55 +642,6 @@ impl MsgEncodable for UnsignedChannelAnnouncement { } } -impl MsgDecodable for ChannelAnnouncement { - fn decode(v: &[u8]) -> Result { - if v.len() < 64*4 { - return Err(DecodeError::ShortRead); - } - let secp_ctx = Secp256k1::without_caps(); - Ok(Self { - node_signature_1: secp_signature!(&secp_ctx, &v[0..64]), - node_signature_2: secp_signature!(&secp_ctx, &v[64..128]), - bitcoin_signature_1: secp_signature!(&secp_ctx, &v[128..192]), - bitcoin_signature_2: secp_signature!(&secp_ctx, &v[192..256]), - contents: UnsignedChannelAnnouncement::decode(&v[256..])?, - }) - } -} -impl MsgEncodable for ChannelAnnouncement { - fn encode(&self) -> Vec { - let secp_ctx = Secp256k1::without_caps(); - let contents = self.contents.encode(); - let mut res = Vec::with_capacity(64 + contents.len()); - res.extend_from_slice(&self.node_signature_1.serialize_compact(&secp_ctx)); - res.extend_from_slice(&self.node_signature_2.serialize_compact(&secp_ctx)); - res.extend_from_slice(&self.bitcoin_signature_1.serialize_compact(&secp_ctx)); - res.extend_from_slice(&self.bitcoin_signature_2.serialize_compact(&secp_ctx)); - res.extend_from_slice(&contents); - res - } -} - -impl MsgDecodable for UnsignedChannelUpdate { - fn decode(v: &[u8]) -> Result { - if v.len() < 32+8+4+2+2+8+4+4 { - return Err(DecodeError::ShortRead); - } - let mut excess_data = Vec::with_capacity(v.len() - 64); - excess_data.extend_from_slice(&v[64..]); - Ok(Self { - chain_hash: deserialize(&v[0..32]).unwrap(), - short_channel_id: byte_utils::slice_to_be64(&v[32..40]), - timestamp: byte_utils::slice_to_be32(&v[40..44]), - flags: byte_utils::slice_to_be16(&v[44..46]), - cltv_expiry_delta: byte_utils::slice_to_be16(&v[46..48]), - htlc_minimum_msat: byte_utils::slice_to_be64(&v[48..56]), - fee_base_msat: byte_utils::slice_to_be32(&v[56..60]), - fee_proportional_millionths: byte_utils::slice_to_be32(&v[60..64]), - excess_data - }) - } -} impl MsgEncodable for UnsignedChannelUpdate { fn encode(&self) -> Vec { let mut res = Vec::with_capacity(64 + self.excess_data.len()); @@ -1508,18 +658,6 @@ impl MsgEncodable for UnsignedChannelUpdate { } } -impl MsgDecodable for ChannelUpdate { - fn decode(v: &[u8]) -> Result { - if v.len() < 128 { - return Err(DecodeError::ShortRead); - } - let secp_ctx = Secp256k1::without_caps(); - Ok(Self { - signature: secp_signature!(&secp_ctx, &v[0..64]), - contents: UnsignedChannelUpdate::decode(&v[64..])?, - }) - } -} impl MsgEncodable for ChannelUpdate { fn encode(&self) -> Vec { let mut res = Vec::with_capacity(128); @@ -1529,18 +667,6 @@ impl MsgEncodable for ChannelUpdate { } } -impl MsgDecodable for OnionRealm0HopData { - fn decode(v: &[u8]) -> Result { - if v.len() < 32 { - return Err(DecodeError::ShortRead); - } - Ok(OnionRealm0HopData { - short_channel_id: byte_utils::slice_to_be64(&v[0..8]), - amt_to_forward: byte_utils::slice_to_be64(&v[8..16]), - outgoing_cltv_value: byte_utils::slice_to_be32(&v[16..20]), - }) - } -} impl MsgEncodable for OnionRealm0HopData { fn encode(&self) -> Vec { let mut res = Vec::with_capacity(32); @@ -1552,24 +678,6 @@ impl MsgEncodable for OnionRealm0HopData { } } -impl MsgDecodable for OnionHopData { - fn decode(v: &[u8]) -> Result { - if v.len() < 65 { - return Err(DecodeError::ShortRead); - } - let realm = v[0]; - if realm != 0 { - return Err(DecodeError::UnknownRealmByte); - } - let mut hmac = [0; 32]; - hmac[..].copy_from_slice(&v[33..65]); - Ok(OnionHopData { - realm: realm, - data: OnionRealm0HopData::decode(&v[1..33])?, - hmac: hmac, - }) - } -} impl MsgEncodable for OnionHopData { fn encode(&self) -> Vec { let mut res = Vec::with_capacity(65); @@ -1580,24 +688,6 @@ impl MsgEncodable for OnionHopData { } } -impl MsgDecodable for OnionPacket { - fn decode(v: &[u8]) -> Result { - if v.len() < 1+33+20*65+32 { - return Err(DecodeError::ShortRead); - } - let mut hop_data = [0; 20*65]; - hop_data.copy_from_slice(&v[34..1334]); - let mut hmac = [0; 32]; - hmac.copy_from_slice(&v[1334..1366]); - let secp_ctx = Secp256k1::without_caps(); - Ok(Self { - version: v[0], - public_key: PublicKey::from_slice(&secp_ctx, &v[1..34]), - hop_data, - hmac, - }) - } -} impl MsgEncodable for OnionPacket { fn encode(&self) -> Vec { let mut res = Vec::with_capacity(1 + 33 + 20*65 + 32); @@ -1612,29 +702,6 @@ impl MsgEncodable for OnionPacket { } } -impl MsgDecodable for DecodedOnionErrorPacket { - fn decode(v: &[u8]) -> Result { - if v.len() < 32 + 4 { - return Err(DecodeError::ShortRead); - } - let failuremsg_len = byte_utils::slice_to_be16(&v[32..34]) as usize; - if v.len() < 32 + 4 + failuremsg_len { - return Err(DecodeError::ShortRead); - } - let padding_len = byte_utils::slice_to_be16(&v[34 + failuremsg_len..]) as usize; - if v.len() < 32 + 4 + failuremsg_len + padding_len { - return Err(DecodeError::ShortRead); - } - - let mut hmac = [0; 32]; - hmac.copy_from_slice(&v[0..32]); - Ok(Self { - hmac, - failuremsg: v[34..34 + failuremsg_len].to_vec(), - pad: v[36 + failuremsg_len..36 + failuremsg_len + padding_len].to_vec(), - }) - } -} impl MsgEncodable for DecodedOnionErrorPacket { fn encode(&self) -> Vec { let mut res = Vec::with_capacity(32 + 4 + self.failuremsg.len() + self.pad.len()); @@ -1647,59 +714,10 @@ impl MsgEncodable for DecodedOnionErrorPacket { } } -impl MsgDecodable for OnionErrorPacket { - fn decode(v: &[u8]) -> Result { - if v.len() < 2 { - return Err(DecodeError::ShortRead); - } - let len = byte_utils::slice_to_be16(&v[0..2]) as usize; - if v.len() < 2 + len { - return Err(DecodeError::ShortRead); - } - Ok(Self { - data: v[2..len+2].to_vec(), - }) - } -} -impl MsgEncodable for OnionErrorPacket { - fn encode(&self) -> Vec { - let mut res = Vec::with_capacity(2 + self.data.len()); - res.extend_from_slice(&byte_utils::be16_to_array(self.data.len() as u16)); - res.extend_from_slice(&self.data); - res - } -} - -impl MsgEncodable for ErrorMessage { - fn encode(&self) -> Vec { - let mut res = Vec::with_capacity(34 + self.data.len()); - res.extend_from_slice(&self.channel_id); - res.extend_from_slice(&byte_utils::be16_to_array(self.data.len() as u16)); - res.extend_from_slice(&self.data.as_bytes()); - res - } -} -impl MsgDecodable for ErrorMessage { - fn decode(v: &[u8]) -> Result { - if v.len() < 34 { - return Err(DecodeError::ShortRead); - } - // Unlike most messages, BOLT 1 requires we truncate our read if the value is out of range - let len = cmp::min(byte_utils::slice_to_be16(&v[32..34]) as usize, v.len() - 34); - let data = match String::from_utf8(v[34..34 + len].to_vec()) { - Ok(s) => s, - Err(_) => return Err(DecodeError::BadText), - }; - let mut channel_id = [0; 32]; - channel_id[..].copy_from_slice(&v[0..32]); - Ok(Self { - channel_id, - data, - }) - } -} - -impl_writeable!(AcceptChannel, { +impl_writeable_len_match!(AcceptChannel, { + {AcceptChannel{ shutdown_scriptpubkey: Some(ref script), ..}, 270 + 2 + script.len()}, + {_, 270} + }, { temporary_channel_id, dust_limit_satoshis, max_htlc_value_in_flight_msat, @@ -1717,15 +735,16 @@ impl_writeable!(AcceptChannel, { shutdown_scriptpubkey }); -impl_writeable!(AnnouncementSignatures, { +impl_writeable!(AnnouncementSignatures, 32+8+64*2, { channel_id, short_channel_id, node_signature, bitcoin_signature }); -impl Writeable for ChannelReestablish { - fn write(&self, w: &mut Writer) -> Result<(), DecodeError> { +impl Writeable for ChannelReestablish { + fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> { + w.size_hint(if self.data_loss_protect.is_some() { 32+2*8+33+32 } else { 32+2*8 }); self.channel_id.write(w)?; self.next_local_commitment_number.write(w)?; self.next_remote_commitment_number.write(w)?; @@ -1737,8 +756,8 @@ impl Writeable for ChannelReestablish { } } -impl Readable for ChannelReestablish{ - fn read(r: &mut Reader) -> Result { +impl Readable for ChannelReestablish{ + fn read(r: &mut R) -> Result { Ok(Self { channel_id: Readable::read(r)?, next_local_commitment_number: Readable::read(r)?, @@ -1758,55 +777,68 @@ impl Readable for ChannelReestablish{ } } -impl_writeable!(ClosingSigned, { +impl_writeable!(ClosingSigned, 32+8+64, { channel_id, fee_satoshis, signature }); -impl_writeable!(CommitmentSigned, { +impl_writeable_len_match!(CommitmentSigned, { + { CommitmentSigned { ref htlc_signatures, .. }, 32+64+2+htlc_signatures.len()*64 } + }, { channel_id, signature, htlc_signatures }); -impl_writeable!(DecodedOnionErrorPacket, { +impl_writeable_len_match!(DecodedOnionErrorPacket, { + { DecodedOnionErrorPacket { ref failuremsg, ref pad, .. }, 32 + 4 + failuremsg.len() + pad.len() } + }, { hmac, failuremsg, pad }); -impl_writeable!(FundingCreated, { +impl_writeable!(FundingCreated, 32+32+2+64, { temporary_channel_id, funding_txid, funding_output_index, signature }); -impl_writeable!(FundingSigned, { +impl_writeable!(FundingSigned, 32+64, { channel_id, signature }); -impl_writeable!(FundingLocked, { +impl_writeable!(FundingLocked, 32+33, { channel_id, next_per_commitment_point }); -impl_writeable!(GlobalFeatures, { +impl_writeable_len_match!(GlobalFeatures, { + { GlobalFeatures { ref flags }, flags.len() + 2 } + }, { flags }); -impl_writeable!(LocalFeatures, { +impl_writeable_len_match!(LocalFeatures, { + { LocalFeatures { ref flags }, flags.len() + 2 } + }, { flags }); -impl_writeable!(Init, { +impl_writeable_len_match!(Init, { + { Init { ref global_features, ref local_features }, global_features.flags.len() + local_features.flags.len() + 4 } + }, { global_features, local_features }); -impl_writeable!(OpenChannel, { +impl_writeable_len_match!(OpenChannel, { + { OpenChannel { shutdown_scriptpubkey: Some(ref script), .. }, 319 + 2 + script.len() }, + { OpenChannel { shutdown_scriptpubkey: None, .. }, 319 } + }, { chain_hash, temporary_channel_id, funding_satoshis, @@ -1828,47 +860,54 @@ impl_writeable!(OpenChannel, { shutdown_scriptpubkey }); -impl_writeable!(RevokeAndACK, { +impl_writeable!(RevokeAndACK, 32+32+33, { channel_id, per_commitment_secret, next_per_commitment_point }); -impl_writeable!(Shutdown, { +impl_writeable_len_match!(Shutdown, { + { Shutdown { ref scriptpubkey, .. }, 32 + 2 + scriptpubkey.len() } + }, { channel_id, scriptpubkey }); -impl_writeable!(UpdateFailHTLC, { +impl_writeable_len_match!(UpdateFailHTLC, { + { UpdateFailHTLC { ref reason, .. }, 32 + 10 + reason.data.len() } + }, { channel_id, htlc_id, reason }); -impl_writeable!(UpdateFailMalformedHTLC, { +impl_writeable!(UpdateFailMalformedHTLC, 32+8+32+2, { channel_id, htlc_id, sha256_of_onion, failure_code }); -impl_writeable!(UpdateFee, { +impl_writeable!(UpdateFee, 32+4, { channel_id, feerate_per_kw }); -impl_writeable!(UpdateFulfillHTLC, { +impl_writeable!(UpdateFulfillHTLC, 32+8+32, { channel_id, htlc_id, payment_preimage }); -impl_writeable!(OnionErrorPacket, { +impl_writeable_len_match!(OnionErrorPacket, { + { OnionErrorPacket { ref data, .. }, 2 + data.len() } + }, { data }); -impl Writeable for OnionPacket { - fn write(&self, w: &mut Writer) -> Result<(), DecodeError> { +impl Writeable for OnionPacket { + fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> { + w.size_hint(1 + 33 + 20*65 + 32); self.version.write(w)?; match self.public_key { Ok(pubkey) => pubkey.write(w)?, @@ -1880,8 +919,8 @@ impl Writeable for OnionPacket { } } -impl Readable for OnionPacket { - fn read(r: &mut Reader) -> Result { +impl Readable for OnionPacket { + fn read(r: &mut R) -> Result { Ok(OnionPacket { version: Readable::read(r)?, public_key: { @@ -1895,7 +934,7 @@ impl Readable for OnionPacket { } } -impl_writeable!(UpdateAddHTLC, { +impl_writeable!(UpdateAddHTLC, 32+8+8+32+4+1366, { channel_id, htlc_id, amount_msat, @@ -1904,8 +943,9 @@ impl_writeable!(UpdateAddHTLC, { onion_routing_packet }); -impl Writeable for OnionRealm0HopData { - fn write(&self, w: &mut Writer) -> Result<(), DecodeError> { +impl Writeable for OnionRealm0HopData { + fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> { + w.size_hint(32); self.short_channel_id.write(w)?; self.amt_to_forward.write(w)?; self.outgoing_cltv_value.write(w)?; @@ -1914,8 +954,8 @@ impl Writeable for OnionRealm0HopData { } } -impl Readable for OnionRealm0HopData { - fn read(r: &mut Reader) -> Result { +impl Readable for OnionRealm0HopData { + fn read(r: &mut R) -> Result { Ok(OnionRealm0HopData { short_channel_id: Readable::read(r)?, amt_to_forward: Readable::read(r)?, @@ -1928,8 +968,9 @@ impl Readable for OnionRealm0HopData { } } -impl Writeable for OnionHopData { - fn write(&self, w: &mut Writer) -> Result<(), DecodeError> { +impl Writeable for OnionHopData { + fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> { + w.size_hint(65); self.realm.write(w)?; self.data.write(w)?; self.hmac.write(w)?; @@ -1937,8 +978,8 @@ impl Writeable for OnionHopData { } } -impl Readable for OnionHopData { - fn read(r: &mut Reader) -> Result { +impl Readable for OnionHopData { + fn read(r: &mut R) -> Result { Ok(OnionHopData { realm: { let r: u8 = Readable::read(r)?; @@ -1953,16 +994,17 @@ impl Readable for OnionHopData { } } -impl Writeable for Ping { - fn write(&self, w: &mut Writer) -> Result<(), DecodeError> { +impl Writeable for Ping { + fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> { + w.size_hint(self.byteslen as usize + 4); self.ponglen.write(w)?; vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write Ok(()) } } -impl Readable for Ping { - fn read(r: &mut Reader) -> Result { +impl Readable for Ping { + fn read(r: &mut R) -> Result { Ok(Ping { ponglen: Readable::read(r)?, byteslen: { @@ -1974,15 +1016,16 @@ impl Readable for Ping { } } -impl Writeable for Pong { - fn write(&self, w: &mut Writer) -> Result<(), DecodeError> { +impl Writeable for Pong { + fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> { + w.size_hint(self.byteslen as usize + 2); vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write Ok(()) } } -impl Readable for Pong { - fn read(r: &mut Reader) -> Result { +impl Readable for Pong { + fn read(r: &mut R) -> Result { Ok(Pong { byteslen: { let byteslen = Readable::read(r)?; @@ -1993,8 +1036,9 @@ impl Readable for Pong { } } -impl Writeable for UnsignedChannelAnnouncement { - fn write(&self, w: &mut Writer) -> Result<(), DecodeError> { +impl Writeable for UnsignedChannelAnnouncement { + fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> { + w.size_hint(2 + 2*32 + 4*33 + self.features.flags.len() + self.excess_data.len()); self.features.write(w)?; self.chain_hash.write(w)?; self.short_channel_id.write(w)?; @@ -2007,8 +1051,8 @@ impl Writeable for UnsignedChannelAnnouncement { } } -impl Readable for UnsignedChannelAnnouncement { - fn read(r: &mut Reader) -> Result { +impl Readable for UnsignedChannelAnnouncement { + fn read(r: &mut R) -> Result { Ok(Self { features: { let f: GlobalFeatures = Readable::read(r)?; @@ -2032,7 +1076,10 @@ impl Readable for UnsignedChannelAnnouncement { } } -impl_writeable!(ChannelAnnouncement,{ +impl_writeable_len_match!(ChannelAnnouncement, { + { ChannelAnnouncement { contents: UnsignedChannelAnnouncement {ref features, ref excess_data, ..}, .. }, + 2 + 2*32 + 4*33 + features.flags.len() + excess_data.len() + 4*64 } + }, { node_signature_1, node_signature_2, bitcoin_signature_1, @@ -2040,8 +1087,9 @@ impl_writeable!(ChannelAnnouncement,{ contents }); -impl Writeable for UnsignedChannelUpdate { - fn write(&self, w: &mut Writer) -> Result<(), DecodeError> { +impl Writeable for UnsignedChannelUpdate { + fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> { + w.size_hint(64 + self.excess_data.len()); self.chain_hash.write(w)?; self.short_channel_id.write(w)?; self.timestamp.write(w)?; @@ -2055,8 +1103,8 @@ impl Writeable for UnsignedChannelUpdate { } } -impl Readable for UnsignedChannelUpdate { - fn read(r: &mut Reader) -> Result { +impl Readable for UnsignedChannelUpdate { + fn read(r: &mut R) -> Result { Ok(Self { chain_hash: Readable::read(r)?, short_channel_id: Readable::read(r)?, @@ -2075,21 +1123,26 @@ impl Readable for UnsignedChannelUpdate { } } -impl_writeable!(ChannelUpdate, { +impl_writeable_len_match!(ChannelUpdate, { + { ChannelUpdate { contents: UnsignedChannelUpdate {ref excess_data, ..}, .. }, + 64 + excess_data.len() + 64 } + }, { signature, contents }); -impl Writeable for ErrorMessage { - fn write(&self, w: &mut Writer) -> Result<(), DecodeError> { +impl Writeable for ErrorMessage { + fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> { + w.size_hint(32 + 2 + self.data.len()); self.channel_id.write(w)?; - self.data.as_bytes().to_vec().write(w)?; // write with size prefix + (self.data.len() as u16).write(w)?; + w.write_all(self.data.as_bytes())?; Ok(()) } } -impl Readable for ErrorMessage { - fn read(r: &mut Reader) -> Result { +impl Readable for ErrorMessage { + fn read(r: &mut R) -> Result { Ok(Self { channel_id: Readable::read(r)?, data: { @@ -2106,8 +1159,9 @@ impl Readable for ErrorMessage { } } -impl Writeable for UnsignedNodeAnnouncement { - fn write(&self, w: &mut Writer) -> Result<(), DecodeError> { +impl Writeable for UnsignedNodeAnnouncement { + fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> { + w.size_hint(64 + 76 + self.features.flags.len() + self.addresses.len()*38 + self.excess_address_data.len() + self.excess_data.len()); self.features.write(w)?; self.timestamp.write(w)?; self.node_id.write(w)?; @@ -2152,8 +1206,8 @@ impl Writeable for UnsignedNodeAnnouncement { } } -impl Readable for UnsignedNodeAnnouncement { - fn read(r: &mut Reader) -> Result { +impl Readable for UnsignedNodeAnnouncement { + fn read(r: &mut R) -> Result { let features: GlobalFeatures = Readable::read(r)?; if features.requires_unknown_bits() { return Err(DecodeError::UnknownRequiredFeature); @@ -2274,7 +1328,10 @@ impl Readable for UnsignedNodeAnnouncement { } } -impl_writeable!(NodeAnnouncement, { +impl_writeable_len_match!(NodeAnnouncement, { + { NodeAnnouncement { contents: UnsignedNodeAnnouncement { ref features, ref addresses, ref excess_address_data, ref excess_data, ..}, .. }, + 64 + 76 + features.flags.len() + addresses.len()*38 + excess_address_data.len() + excess_data.len() } + }, { signature, contents });