1 use secp256k1::key::PublicKey;
2 use secp256k1::{Secp256k1, Signature};
4 use bitcoin::util::hash::Sha256dHash;
5 use bitcoin::network::serialize::{deserialize,serialize};
6 use bitcoin::blockdata::script::Script;
10 use std::result::Result;
12 use util::{byte_utils, internal_traits, events};
13 use util::ser::{Readable, Reader, Writeable, Writer};
15 pub trait MsgEncodable {
16 fn encode(&self) -> Vec<u8>;
18 fn encoded_len(&self) -> usize { self.encode().len() }
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);
29 pub enum DecodeError {
30 /// Unknown realm byte in an OnionHopData packet
32 /// Unknown feature mandating we fail to parse message
33 UnknownRequiredFeature,
34 /// Failed to decode a public key (ie it's invalid)
36 /// Failed to decode a signature (ie it's invalid)
38 /// Value expected to be text wasn't decodable as text
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)
47 /// Error from std::io
49 /// 1 or 0 is not found for boolean value
52 pub trait MsgDecodable: Sized {
53 fn decode(v: &[u8]) -> Result<Self, DecodeError>;
56 /// Tracks localfeatures which are only in init messages
57 #[derive(Clone, PartialEq)]
58 pub struct LocalFeatures {
63 pub fn new() -> LocalFeatures {
69 pub fn supports_data_loss_protect(&self) -> bool {
70 self.flags.len() > 0 && (self.flags[0] & 3) != 0
72 pub fn requires_data_loss_protect(&self) -> bool {
73 self.flags.len() > 0 && (self.flags[0] & 1) != 0
76 pub fn initial_routing_sync(&self) -> bool {
77 self.flags.len() > 0 && (self.flags[0] & (1 << 3)) != 0
79 pub fn set_initial_routing_sync(&mut self) {
80 if self.flags.len() == 0 {
81 self.flags.resize(1, 1 << 3);
83 self.flags[0] |= 1 << 3;
87 pub fn supports_upfront_shutdown_script(&self) -> bool {
88 self.flags.len() > 0 && (self.flags[0] & (3 << 4)) != 0
90 pub fn requires_upfront_shutdown_script(&self) -> bool {
91 self.flags.len() > 0 && (self.flags[0] & (1 << 4)) != 0
94 pub fn requires_unknown_bits(&self) -> bool {
95 for (idx, &byte) in self.flags.iter().enumerate() {
96 if idx != 0 && (byte & 0x55) != 0 {
98 } else if idx == 0 && (byte & 0x14) != 0 {
105 pub fn supports_unknown_bits(&self) -> bool {
106 for (idx, &byte) in self.flags.iter().enumerate() {
107 if idx != 0 && byte != 0 {
109 } else if idx == 0 && (byte & 0xc4) != 0 {
117 /// Tracks globalfeatures which are in init messages and routing announcements
118 #[derive(Clone, PartialEq)]
119 pub struct GlobalFeatures {
123 impl GlobalFeatures {
124 pub fn new() -> GlobalFeatures {
130 pub fn requires_unknown_bits(&self) -> bool {
131 for &byte in self.flags.iter() {
132 if (byte & 0x55) != 0 {
139 pub fn supports_unknown_bits(&self) -> bool {
140 for &byte in self.flags.iter() {
150 pub global_features: GlobalFeatures,
151 pub local_features: LocalFeatures,
154 pub struct ErrorMessage {
155 pub channel_id: [u8; 32],
168 pub struct OpenChannel {
169 pub chain_hash: Sha256dHash,
170 pub temporary_channel_id: [u8; 32],
171 pub funding_satoshis: 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>,
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>,
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,
215 pub struct FundingSigned {
216 pub channel_id: [u8; 32],
217 pub signature: Signature,
220 pub struct FundingLocked {
221 pub channel_id: [u8; 32],
222 pub next_per_commitment_point: PublicKey,
225 pub struct Shutdown {
226 pub channel_id: [u8; 32],
227 pub scriptpubkey: Script,
230 pub struct ClosingSigned {
231 pub channel_id: [u8; 32],
232 pub fee_satoshis: u64,
233 pub signature: Signature,
237 pub struct UpdateAddHTLC {
238 pub channel_id: [u8; 32],
240 pub amount_msat: u64,
241 pub payment_hash: [u8; 32],
242 pub cltv_expiry: u32,
243 pub onion_routing_packet: OnionPacket,
247 pub struct UpdateFulfillHTLC {
248 pub channel_id: [u8; 32],
250 pub payment_preimage: [u8; 32],
254 pub struct UpdateFailHTLC {
255 pub channel_id: [u8; 32],
257 pub reason: OnionErrorPacket,
261 pub struct UpdateFailMalformedHTLC {
262 pub channel_id: [u8; 32],
264 pub sha256_of_onion: [u8; 32],
265 pub failure_code: u16,
269 pub struct CommitmentSigned {
270 pub channel_id: [u8; 32],
271 pub signature: Signature,
272 pub htlc_signatures: Vec<Signature>,
275 pub struct RevokeAndACK {
276 pub channel_id: [u8; 32],
277 pub per_commitment_secret: [u8; 32],
278 pub next_per_commitment_point: PublicKey,
281 pub struct UpdateFee {
282 pub channel_id: [u8; 32],
283 pub feerate_per_kw: u32,
286 pub struct DataLossProtect {
287 pub your_last_per_commitment_secret: [u8; 32],
288 pub my_current_per_commitment_point: PublicKey,
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>,
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,
307 pub enum NetAddress {
321 ed25519_pubkey: [u8; 32],
328 fn get_id(&self) -> u8 {
330 &NetAddress::IPv4 {..} => { 1 },
331 &NetAddress::IPv6 {..} => { 2 },
332 &NetAddress::OnionV2 {..} => { 3 },
333 &NetAddress::OnionV3 {..} => { 4 },
338 pub struct UnsignedNodeAnnouncement {
339 pub features: GlobalFeatures,
341 pub node_id: PublicKey,
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>,
350 pub struct NodeAnnouncement {
351 pub signature: Signature,
352 pub contents: UnsignedNodeAnnouncement,
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>,
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,
375 #[derive(PartialEq, Clone)]
376 pub struct UnsignedChannelUpdate {
377 pub chain_hash: Sha256dHash,
378 pub short_channel_id: u64,
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>,
387 #[derive(PartialEq, Clone)]
388 pub struct ChannelUpdate {
389 pub signature: Signature,
390 pub contents: UnsignedChannelUpdate,
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.
397 msg: Option<ErrorMessage>
399 /// The peer did something harmless that we weren't able to process, just log and ignore
401 /// The peer did something incorrect. Tell them.
407 pub struct HandleError { //TODO: rename me
408 pub err: &'static str,
409 pub action: Option<ErrorAction>, //TODO: Make this required
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,
422 pub enum HTLCFailChannelUpdate {
423 ChannelUpdateMessage {
427 short_channel_id: u64,
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 {
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>;
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>;
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>;
454 fn handle_update_fee(&self, their_node_id: &PublicKey, msg: &UpdateFee) -> Result<(), HandleError>;
456 // Channel-to-announce:
457 fn handle_announcement_signatures(&self, their_node_id: &PublicKey, msg: &AnnouncementSignatures) -> Result<(), HandleError>;
459 // Connection loss/reestablish:
460 /// Indicates a connection to the peer failed/an existing connection was lost. If no connection
461 /// is believed to be possible in the future (eg they're sending us messages we don't
462 /// understand or indicate they require unknown feature bits), no_connection_possible is set
463 /// and any outstanding channels should be failed.
464 fn peer_disconnected(&self, their_node_id: &PublicKey, no_connection_possible: bool);
466 fn peer_connected(&self, their_node_id: &PublicKey) -> Vec<ChannelReestablish>;
467 fn handle_channel_reestablish(&self, their_node_id: &PublicKey, msg: &ChannelReestablish) -> Result<(Option<FundingLocked>, Option<RevokeAndACK>, Option<CommitmentUpdate>), HandleError>;
470 fn handle_error(&self, their_node_id: &PublicKey, msg: &ErrorMessage);
473 pub trait RoutingMessageHandler : Send + Sync {
474 fn handle_node_announcement(&self, msg: &NodeAnnouncement) -> Result<bool, HandleError>;
475 /// Handle a channel_announcement message, returning true if it should be forwarded on, false
476 /// or returning an Err otherwise.
477 fn handle_channel_announcement(&self, msg: &ChannelAnnouncement) -> Result<bool, HandleError>;
478 fn handle_channel_update(&self, msg: &ChannelUpdate) -> Result<bool, HandleError>;
479 fn handle_htlc_fail_channel_update(&self, update: &HTLCFailChannelUpdate);
482 pub struct OnionRealm0HopData {
483 pub short_channel_id: u64,
484 pub amt_to_forward: u64,
485 pub outgoing_cltv_value: u32,
486 // 12 bytes of 0-padding
489 pub struct OnionHopData {
491 pub data: OnionRealm0HopData,
494 unsafe impl internal_traits::NoDealloc for OnionHopData{}
497 pub struct OnionPacket {
499 /// In order to ensure we always return an error on Onion decode in compliance with BOLT 4, we
500 /// have to deserialize OnionPackets contained in UpdateAddHTLCs even if the ephemeral public
501 /// key (here) is bogus, so we hold a Result instead of a PublicKey as we'd like.
502 pub public_key: Result<PublicKey, secp256k1::Error>,
503 pub hop_data: [u8; 20*65],
507 pub struct DecodedOnionErrorPacket {
509 pub failuremsg: Vec<u8>,
514 pub struct OnionErrorPacket {
515 // This really should be a constant size slice, but the spec lets these things be up to 128KB?
516 // (TODO) We limit it in decode to much lower...
520 impl Error for DecodeError {
521 fn description(&self) -> &str {
523 DecodeError::UnknownRealmByte => "Unknown realm byte in Onion packet",
524 DecodeError::UnknownRequiredFeature => "Unknown required feature preventing decode",
525 DecodeError::BadPublicKey => "Invalid public key in packet",
526 DecodeError::BadSignature => "Invalid signature in packet",
527 DecodeError::BadText => "Invalid text in packet",
528 DecodeError::ShortRead => "Packet extended beyond the provided bytes",
529 DecodeError::ExtraAddressesPerType => "More than one address of a single type",
530 DecodeError::BadLengthDescriptor => "A length descriptor in the packet didn't describe the later data correctly",
531 DecodeError::Io(ref e) => e.description(),
532 DecodeError::InvalidValue => "0 or 1 is not found for boolean",
536 impl fmt::Display for DecodeError {
537 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
538 f.write_str(self.description())
542 impl fmt::Debug for HandleError {
543 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
544 f.write_str(self.err)
548 impl From<::std::io::Error> for DecodeError {
549 fn from(e: ::std::io::Error) -> Self {
550 if e.kind() == ::std::io::ErrorKind::UnexpectedEof {
551 DecodeError::ShortRead
558 macro_rules! secp_pubkey {
559 ( $ctx: expr, $slice: expr ) => {
560 match PublicKey::from_slice($ctx, $slice) {
562 Err(_) => return Err(DecodeError::BadPublicKey)
567 macro_rules! secp_signature {
568 ( $ctx: expr, $slice: expr ) => {
569 match Signature::from_compact($ctx, $slice) {
571 Err(_) => return Err(DecodeError::BadSignature)
576 impl MsgDecodable for LocalFeatures {
577 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
578 if v.len() < 2 { return Err(DecodeError::ShortRead); }
579 let len = byte_utils::slice_to_be16(&v[0..2]) as usize;
580 if v.len() < len + 2 { return Err(DecodeError::ShortRead); }
581 let mut flags = Vec::with_capacity(len);
582 flags.extend_from_slice(&v[2..2 + len]);
588 impl MsgEncodable for LocalFeatures {
589 fn encode(&self) -> Vec<u8> {
590 let mut res = Vec::with_capacity(self.flags.len() + 2);
591 res.extend_from_slice(&byte_utils::be16_to_array(self.flags.len() as u16));
592 res.extend_from_slice(&self.flags[..]);
595 fn encoded_len(&self) -> usize { self.flags.len() + 2 }
598 impl MsgDecodable for GlobalFeatures {
599 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
600 if v.len() < 2 { return Err(DecodeError::ShortRead); }
601 let len = byte_utils::slice_to_be16(&v[0..2]) as usize;
602 if v.len() < len + 2 { return Err(DecodeError::ShortRead); }
603 let mut flags = Vec::with_capacity(len);
604 flags.extend_from_slice(&v[2..2 + len]);
610 impl MsgEncodable for GlobalFeatures {
611 fn encode(&self) -> Vec<u8> {
612 let mut res = Vec::with_capacity(self.flags.len() + 2);
613 res.extend_from_slice(&byte_utils::be16_to_array(self.flags.len() as u16));
614 res.extend_from_slice(&self.flags[..]);
617 fn encoded_len(&self) -> usize { self.flags.len() + 2 }
620 impl MsgDecodable for Init {
621 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
622 let global_features = GlobalFeatures::decode(v)?;
623 if v.len() < global_features.flags.len() + 4 {
624 return Err(DecodeError::ShortRead);
626 let local_features = LocalFeatures::decode(&v[global_features.flags.len() + 2..])?;
628 global_features: global_features,
629 local_features: local_features,
633 impl MsgEncodable for Init {
634 fn encode(&self) -> Vec<u8> {
635 let mut res = Vec::with_capacity(self.global_features.flags.len() + self.local_features.flags.len());
636 res.extend_from_slice(&self.global_features.encode()[..]);
637 res.extend_from_slice(&self.local_features.encode()[..]);
642 impl MsgDecodable for Ping {
643 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
645 return Err(DecodeError::ShortRead);
647 let ponglen = byte_utils::slice_to_be16(&v[0..2]);
648 let byteslen = byte_utils::slice_to_be16(&v[2..4]);
649 if v.len() < 4 + byteslen as usize {
650 return Err(DecodeError::ShortRead);
658 impl MsgEncodable for Ping {
659 fn encode(&self) -> Vec<u8> {
660 let mut res = Vec::with_capacity(self.byteslen as usize + 2);
661 res.extend_from_slice(&byte_utils::be16_to_array(self.byteslen));
662 res.resize(2 + self.byteslen as usize, 0);
667 impl MsgDecodable for Pong {
668 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
670 return Err(DecodeError::ShortRead);
672 let byteslen = byte_utils::slice_to_be16(&v[0..2]);
673 if v.len() < 2 + byteslen as usize {
674 return Err(DecodeError::ShortRead);
681 impl MsgEncodable for Pong {
682 fn encode(&self) -> Vec<u8> {
683 let mut res = Vec::with_capacity(self.byteslen as usize + 2);
684 res.extend_from_slice(&byte_utils::be16_to_array(self.byteslen));
685 res.resize(2 + self.byteslen as usize, 0);
690 impl MsgDecodable for OpenChannel {
691 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
692 if v.len() < 2*32+6*8+4+2*2+6*33+1 {
693 return Err(DecodeError::ShortRead);
695 let ctx = Secp256k1::without_caps();
697 let mut shutdown_scriptpubkey = None;
699 let len = byte_utils::slice_to_be16(&v[319..321]) as usize;
700 if v.len() < 321+len {
701 return Err(DecodeError::ShortRead);
703 shutdown_scriptpubkey = Some(Script::from(v[321..321+len].to_vec()));
705 let mut temp_channel_id = [0; 32];
706 temp_channel_id[..].copy_from_slice(&v[32..64]);
708 chain_hash: deserialize(&v[0..32]).unwrap(),
709 temporary_channel_id: temp_channel_id,
710 funding_satoshis: byte_utils::slice_to_be64(&v[64..72]),
711 push_msat: byte_utils::slice_to_be64(&v[72..80]),
712 dust_limit_satoshis: byte_utils::slice_to_be64(&v[80..88]),
713 max_htlc_value_in_flight_msat: byte_utils::slice_to_be64(&v[88..96]),
714 channel_reserve_satoshis: byte_utils::slice_to_be64(&v[96..104]),
715 htlc_minimum_msat: byte_utils::slice_to_be64(&v[104..112]),
716 feerate_per_kw: byte_utils::slice_to_be32(&v[112..116]),
717 to_self_delay: byte_utils::slice_to_be16(&v[116..118]),
718 max_accepted_htlcs: byte_utils::slice_to_be16(&v[118..120]),
719 funding_pubkey: secp_pubkey!(&ctx, &v[120..153]),
720 revocation_basepoint: secp_pubkey!(&ctx, &v[153..186]),
721 payment_basepoint: secp_pubkey!(&ctx, &v[186..219]),
722 delayed_payment_basepoint: secp_pubkey!(&ctx, &v[219..252]),
723 htlc_basepoint: secp_pubkey!(&ctx, &v[252..285]),
724 first_per_commitment_point: secp_pubkey!(&ctx, &v[285..318]),
725 channel_flags: v[318],
726 shutdown_scriptpubkey: shutdown_scriptpubkey
730 impl MsgEncodable for OpenChannel {
731 fn encode(&self) -> Vec<u8> {
732 let mut res = match &self.shutdown_scriptpubkey {
733 &Some(ref script) => Vec::with_capacity(319 + 2 + script.len()),
734 &None => Vec::with_capacity(319),
736 res.extend_from_slice(&serialize(&self.chain_hash).unwrap());
737 res.extend_from_slice(&serialize(&self.temporary_channel_id).unwrap());
738 res.extend_from_slice(&byte_utils::be64_to_array(self.funding_satoshis));
739 res.extend_from_slice(&byte_utils::be64_to_array(self.push_msat));
740 res.extend_from_slice(&byte_utils::be64_to_array(self.dust_limit_satoshis));
741 res.extend_from_slice(&byte_utils::be64_to_array(self.max_htlc_value_in_flight_msat));
742 res.extend_from_slice(&byte_utils::be64_to_array(self.channel_reserve_satoshis));
743 res.extend_from_slice(&byte_utils::be64_to_array(self.htlc_minimum_msat));
744 res.extend_from_slice(&byte_utils::be32_to_array(self.feerate_per_kw));
745 res.extend_from_slice(&byte_utils::be16_to_array(self.to_self_delay));
746 res.extend_from_slice(&byte_utils::be16_to_array(self.max_accepted_htlcs));
747 res.extend_from_slice(&self.funding_pubkey.serialize());
748 res.extend_from_slice(&self.revocation_basepoint.serialize());
749 res.extend_from_slice(&self.payment_basepoint.serialize());
750 res.extend_from_slice(&self.delayed_payment_basepoint.serialize());
751 res.extend_from_slice(&self.htlc_basepoint.serialize());
752 res.extend_from_slice(&self.first_per_commitment_point.serialize());
753 res.push(self.channel_flags);
754 if let &Some(ref script) = &self.shutdown_scriptpubkey {
755 res.extend_from_slice(&byte_utils::be16_to_array(script.len() as u16));
756 res.extend_from_slice(&script[..]);
762 impl MsgDecodable for AcceptChannel {
763 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
764 if v.len() < 32+4*8+4+2*2+6*33 {
765 return Err(DecodeError::ShortRead);
767 let ctx = Secp256k1::without_caps();
769 let mut shutdown_scriptpubkey = None;
771 let len = byte_utils::slice_to_be16(&v[270..272]) as usize;
772 if v.len() < 272+len {
773 return Err(DecodeError::ShortRead);
775 shutdown_scriptpubkey = Some(Script::from(v[272..272+len].to_vec()));
778 let mut temporary_channel_id = [0; 32];
779 temporary_channel_id[..].copy_from_slice(&v[0..32]);
781 temporary_channel_id,
782 dust_limit_satoshis: byte_utils::slice_to_be64(&v[32..40]),
783 max_htlc_value_in_flight_msat: byte_utils::slice_to_be64(&v[40..48]),
784 channel_reserve_satoshis: byte_utils::slice_to_be64(&v[48..56]),
785 htlc_minimum_msat: byte_utils::slice_to_be64(&v[56..64]),
786 minimum_depth: byte_utils::slice_to_be32(&v[64..68]),
787 to_self_delay: byte_utils::slice_to_be16(&v[68..70]),
788 max_accepted_htlcs: byte_utils::slice_to_be16(&v[70..72]),
789 funding_pubkey: secp_pubkey!(&ctx, &v[72..105]),
790 revocation_basepoint: secp_pubkey!(&ctx, &v[105..138]),
791 payment_basepoint: secp_pubkey!(&ctx, &v[138..171]),
792 delayed_payment_basepoint: secp_pubkey!(&ctx, &v[171..204]),
793 htlc_basepoint: secp_pubkey!(&ctx, &v[204..237]),
794 first_per_commitment_point: secp_pubkey!(&ctx, &v[237..270]),
795 shutdown_scriptpubkey: shutdown_scriptpubkey
799 impl MsgEncodable for AcceptChannel {
800 fn encode(&self) -> Vec<u8> {
801 let mut res = match &self.shutdown_scriptpubkey {
802 &Some(ref script) => Vec::with_capacity(270 + 2 + script.len()),
803 &None => Vec::with_capacity(270),
805 res.extend_from_slice(&self.temporary_channel_id);
806 res.extend_from_slice(&byte_utils::be64_to_array(self.dust_limit_satoshis));
807 res.extend_from_slice(&byte_utils::be64_to_array(self.max_htlc_value_in_flight_msat));
808 res.extend_from_slice(&byte_utils::be64_to_array(self.channel_reserve_satoshis));
809 res.extend_from_slice(&byte_utils::be64_to_array(self.htlc_minimum_msat));
810 res.extend_from_slice(&byte_utils::be32_to_array(self.minimum_depth));
811 res.extend_from_slice(&byte_utils::be16_to_array(self.to_self_delay));
812 res.extend_from_slice(&byte_utils::be16_to_array(self.max_accepted_htlcs));
813 res.extend_from_slice(&self.funding_pubkey.serialize());
814 res.extend_from_slice(&self.revocation_basepoint.serialize());
815 res.extend_from_slice(&self.payment_basepoint.serialize());
816 res.extend_from_slice(&self.delayed_payment_basepoint.serialize());
817 res.extend_from_slice(&self.htlc_basepoint.serialize());
818 res.extend_from_slice(&self.first_per_commitment_point.serialize());
819 if let &Some(ref script) = &self.shutdown_scriptpubkey {
820 res.extend_from_slice(&byte_utils::be16_to_array(script.len() as u16));
821 res.extend_from_slice(&script[..]);
827 impl MsgDecodable for FundingCreated {
828 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
829 if v.len() < 32+32+2+64 {
830 return Err(DecodeError::ShortRead);
832 let ctx = Secp256k1::without_caps();
833 let mut temporary_channel_id = [0; 32];
834 temporary_channel_id[..].copy_from_slice(&v[0..32]);
836 temporary_channel_id,
837 funding_txid: deserialize(&v[32..64]).unwrap(),
838 funding_output_index: byte_utils::slice_to_be16(&v[64..66]),
839 signature: secp_signature!(&ctx, &v[66..130]),
843 impl MsgEncodable for FundingCreated {
844 fn encode(&self) -> Vec<u8> {
845 let mut res = Vec::with_capacity(32+32+2+64);
846 res.extend_from_slice(&self.temporary_channel_id);
847 res.extend_from_slice(&serialize(&self.funding_txid).unwrap()[..]);
848 res.extend_from_slice(&byte_utils::be16_to_array(self.funding_output_index));
849 let secp_ctx = Secp256k1::without_caps();
850 res.extend_from_slice(&self.signature.serialize_compact(&secp_ctx));
855 impl MsgDecodable for FundingSigned {
856 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
858 return Err(DecodeError::ShortRead);
860 let ctx = Secp256k1::without_caps();
861 let mut channel_id = [0; 32];
862 channel_id[..].copy_from_slice(&v[0..32]);
865 signature: secp_signature!(&ctx, &v[32..96]),
869 impl MsgEncodable for FundingSigned {
870 fn encode(&self) -> Vec<u8> {
871 let mut res = Vec::with_capacity(32+64);
872 res.extend_from_slice(&self.channel_id);
873 res.extend_from_slice(&self.signature.serialize_compact(&Secp256k1::without_caps()));
878 impl MsgDecodable for FundingLocked {
879 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
881 return Err(DecodeError::ShortRead);
883 let ctx = Secp256k1::without_caps();
884 let mut channel_id = [0; 32];
885 channel_id[..].copy_from_slice(&v[0..32]);
888 next_per_commitment_point: secp_pubkey!(&ctx, &v[32..65]),
892 impl MsgEncodable for FundingLocked {
893 fn encode(&self) -> Vec<u8> {
894 let mut res = Vec::with_capacity(32+33);
895 res.extend_from_slice(&self.channel_id);
896 res.extend_from_slice(&self.next_per_commitment_point.serialize());
901 impl MsgDecodable for Shutdown {
902 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
903 if v.len() < 32 + 2 {
904 return Err(DecodeError::ShortRead);
906 let scriptlen = byte_utils::slice_to_be16(&v[32..34]) as usize;
907 if v.len() < 32 + 2 + scriptlen {
908 return Err(DecodeError::ShortRead);
910 let mut channel_id = [0; 32];
911 channel_id[..].copy_from_slice(&v[0..32]);
914 scriptpubkey: Script::from(v[34..34 + scriptlen].to_vec()),
918 impl MsgEncodable for Shutdown {
919 fn encode(&self) -> Vec<u8> {
920 let mut res = Vec::with_capacity(32 + 2 + self.scriptpubkey.len());
921 res.extend_from_slice(&self.channel_id);
922 res.extend_from_slice(&byte_utils::be16_to_array(self.scriptpubkey.len() as u16));
923 res.extend_from_slice(&self.scriptpubkey[..]);
928 impl MsgDecodable for ClosingSigned {
929 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
930 if v.len() < 32 + 8 + 64 {
931 return Err(DecodeError::ShortRead);
933 let secp_ctx = Secp256k1::without_caps();
934 let mut channel_id = [0; 32];
935 channel_id[..].copy_from_slice(&v[0..32]);
938 fee_satoshis: byte_utils::slice_to_be64(&v[32..40]),
939 signature: secp_signature!(&secp_ctx, &v[40..104]),
943 impl MsgEncodable for ClosingSigned {
944 fn encode(&self) -> Vec<u8> {
945 let mut res = Vec::with_capacity(32+8+64);
946 res.extend_from_slice(&self.channel_id);
947 res.extend_from_slice(&byte_utils::be64_to_array(self.fee_satoshis));
948 let secp_ctx = Secp256k1::without_caps();
949 res.extend_from_slice(&self.signature.serialize_compact(&secp_ctx));
954 impl MsgDecodable for UpdateAddHTLC {
955 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
956 if v.len() < 32+8+8+32+4+1+33+20*65+32 {
957 return Err(DecodeError::ShortRead);
959 let mut channel_id = [0; 32];
960 channel_id[..].copy_from_slice(&v[0..32]);
961 let mut payment_hash = [0; 32];
962 payment_hash.copy_from_slice(&v[48..80]);
965 htlc_id: byte_utils::slice_to_be64(&v[32..40]),
966 amount_msat: byte_utils::slice_to_be64(&v[40..48]),
968 cltv_expiry: byte_utils::slice_to_be32(&v[80..84]),
969 onion_routing_packet: OnionPacket::decode(&v[84..84+1366])?,
973 impl MsgEncodable for UpdateAddHTLC {
974 fn encode(&self) -> Vec<u8> {
975 let mut res = Vec::with_capacity(32+8+8+32+4+1366);
976 res.extend_from_slice(&self.channel_id);
977 res.extend_from_slice(&byte_utils::be64_to_array(self.htlc_id));
978 res.extend_from_slice(&byte_utils::be64_to_array(self.amount_msat));
979 res.extend_from_slice(&self.payment_hash);
980 res.extend_from_slice(&byte_utils::be32_to_array(self.cltv_expiry));
981 res.extend_from_slice(&self.onion_routing_packet.encode()[..]);
986 impl MsgDecodable for UpdateFulfillHTLC {
987 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
988 if v.len() < 32+8+32 {
989 return Err(DecodeError::ShortRead);
991 let mut channel_id = [0; 32];
992 channel_id[..].copy_from_slice(&v[0..32]);
993 let mut payment_preimage = [0; 32];
994 payment_preimage.copy_from_slice(&v[40..72]);
997 htlc_id: byte_utils::slice_to_be64(&v[32..40]),
1002 impl MsgEncodable for UpdateFulfillHTLC {
1003 fn encode(&self) -> Vec<u8> {
1004 let mut res = Vec::with_capacity(32+8+32);
1005 res.extend_from_slice(&self.channel_id);
1006 res.extend_from_slice(&byte_utils::be64_to_array(self.htlc_id));
1007 res.extend_from_slice(&self.payment_preimage);
1012 impl MsgDecodable for UpdateFailHTLC {
1013 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1015 return Err(DecodeError::ShortRead);
1017 let mut channel_id = [0; 32];
1018 channel_id[..].copy_from_slice(&v[0..32]);
1021 htlc_id: byte_utils::slice_to_be64(&v[32..40]),
1022 reason: OnionErrorPacket::decode(&v[40..])?,
1026 impl MsgEncodable for UpdateFailHTLC {
1027 fn encode(&self) -> Vec<u8> {
1028 let reason = self.reason.encode();
1029 let mut res = Vec::with_capacity(32+8+reason.len());
1030 res.extend_from_slice(&self.channel_id);
1031 res.extend_from_slice(&byte_utils::be64_to_array(self.htlc_id));
1032 res.extend_from_slice(&reason[..]);
1037 impl MsgDecodable for UpdateFailMalformedHTLC {
1038 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1039 if v.len() < 32+8+32+2 {
1040 return Err(DecodeError::ShortRead);
1042 let mut channel_id = [0; 32];
1043 channel_id[..].copy_from_slice(&v[0..32]);
1044 let mut sha256_of_onion = [0; 32];
1045 sha256_of_onion.copy_from_slice(&v[40..72]);
1048 htlc_id: byte_utils::slice_to_be64(&v[32..40]),
1050 failure_code: byte_utils::slice_to_be16(&v[72..74]),
1054 impl MsgEncodable for UpdateFailMalformedHTLC {
1055 fn encode(&self) -> Vec<u8> {
1056 let mut res = Vec::with_capacity(32+8+32+2);
1057 res.extend_from_slice(&self.channel_id);
1058 res.extend_from_slice(&byte_utils::be64_to_array(self.htlc_id));
1059 res.extend_from_slice(&self.sha256_of_onion);
1060 res.extend_from_slice(&byte_utils::be16_to_array(self.failure_code));
1065 impl MsgDecodable for CommitmentSigned {
1066 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1067 if v.len() < 32+64+2 {
1068 return Err(DecodeError::ShortRead);
1070 let mut channel_id = [0; 32];
1071 channel_id[..].copy_from_slice(&v[0..32]);
1073 let htlcs = byte_utils::slice_to_be16(&v[96..98]) as usize;
1074 if v.len() < 32+64+2+htlcs*64 {
1075 return Err(DecodeError::ShortRead);
1077 let mut htlc_signatures = Vec::with_capacity(htlcs);
1078 let secp_ctx = Secp256k1::without_caps();
1080 htlc_signatures.push(secp_signature!(&secp_ctx, &v[98+i*64..98+(i+1)*64]));
1084 signature: secp_signature!(&secp_ctx, &v[32..96]),
1089 impl MsgEncodable for CommitmentSigned {
1090 fn encode(&self) -> Vec<u8> {
1091 let mut res = Vec::with_capacity(32+64+2+self.htlc_signatures.len()*64);
1092 res.extend_from_slice(&self.channel_id);
1093 let secp_ctx = Secp256k1::without_caps();
1094 res.extend_from_slice(&self.signature.serialize_compact(&secp_ctx));
1095 res.extend_from_slice(&byte_utils::be16_to_array(self.htlc_signatures.len() as u16));
1096 for i in 0..self.htlc_signatures.len() {
1097 res.extend_from_slice(&self.htlc_signatures[i].serialize_compact(&secp_ctx));
1103 impl MsgDecodable for RevokeAndACK {
1104 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1105 if v.len() < 32+32+33 {
1106 return Err(DecodeError::ShortRead);
1108 let mut channel_id = [0; 32];
1109 channel_id[..].copy_from_slice(&v[0..32]);
1110 let mut per_commitment_secret = [0; 32];
1111 per_commitment_secret.copy_from_slice(&v[32..64]);
1112 let secp_ctx = Secp256k1::without_caps();
1115 per_commitment_secret,
1116 next_per_commitment_point: secp_pubkey!(&secp_ctx, &v[64..97]),
1120 impl MsgEncodable for RevokeAndACK {
1121 fn encode(&self) -> Vec<u8> {
1122 let mut res = Vec::with_capacity(32+32+33);
1123 res.extend_from_slice(&self.channel_id);
1124 res.extend_from_slice(&self.per_commitment_secret);
1125 res.extend_from_slice(&self.next_per_commitment_point.serialize());
1130 impl MsgDecodable for UpdateFee {
1131 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1133 return Err(DecodeError::ShortRead);
1135 let mut channel_id = [0; 32];
1136 channel_id[..].copy_from_slice(&v[0..32]);
1139 feerate_per_kw: byte_utils::slice_to_be32(&v[32..36]),
1143 impl MsgEncodable for UpdateFee {
1144 fn encode(&self) -> Vec<u8> {
1145 let mut res = Vec::with_capacity(32+4);
1146 res.extend_from_slice(&self.channel_id);
1147 res.extend_from_slice(&byte_utils::be32_to_array(self.feerate_per_kw));
1152 impl MsgDecodable for ChannelReestablish {
1153 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1154 if v.len() < 32+2*8 {
1155 return Err(DecodeError::ShortRead);
1158 let data_loss_protect = if v.len() > 32+2*8 {
1159 if v.len() < 32+2*8 + 33+32 {
1160 return Err(DecodeError::ShortRead);
1162 let mut inner_array = [0; 32];
1163 inner_array.copy_from_slice(&v[48..48+32]);
1164 Some(DataLossProtect {
1165 your_last_per_commitment_secret: inner_array,
1166 my_current_per_commitment_point: secp_pubkey!(&Secp256k1::without_caps(), &v[48+32..48+32+33]),
1171 channel_id: deserialize(&v[0..32]).unwrap(),
1172 next_local_commitment_number: byte_utils::slice_to_be64(&v[32..40]),
1173 next_remote_commitment_number: byte_utils::slice_to_be64(&v[40..48]),
1174 data_loss_protect: data_loss_protect,
1178 impl MsgEncodable for ChannelReestablish {
1179 fn encode(&self) -> Vec<u8> {
1180 let mut res = Vec::with_capacity(if self.data_loss_protect.is_some() { 32+2*8+33+32 } else { 32+2*8 });
1182 res.extend_from_slice(&serialize(&self.channel_id).unwrap()[..]);
1183 res.extend_from_slice(&byte_utils::be64_to_array(self.next_local_commitment_number));
1184 res.extend_from_slice(&byte_utils::be64_to_array(self.next_remote_commitment_number));
1186 if let &Some(ref data_loss_protect) = &self.data_loss_protect {
1187 res.extend_from_slice(&data_loss_protect.your_last_per_commitment_secret[..]);
1188 res.extend_from_slice(&data_loss_protect.my_current_per_commitment_point.serialize());
1194 impl MsgDecodable for AnnouncementSignatures {
1195 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1196 if v.len() < 32+8+64*2 {
1197 return Err(DecodeError::ShortRead);
1199 let secp_ctx = Secp256k1::without_caps();
1200 let mut channel_id = [0; 32];
1201 channel_id[..].copy_from_slice(&v[0..32]);
1204 short_channel_id: byte_utils::slice_to_be64(&v[32..40]),
1205 node_signature: secp_signature!(&secp_ctx, &v[40..104]),
1206 bitcoin_signature: secp_signature!(&secp_ctx, &v[104..168]),
1210 impl MsgEncodable for AnnouncementSignatures {
1211 fn encode(&self) -> Vec<u8> {
1212 let mut res = Vec::with_capacity(32+8+64*2);
1213 res.extend_from_slice(&self.channel_id);
1214 res.extend_from_slice(&byte_utils::be64_to_array(self.short_channel_id));
1215 let secp_ctx = Secp256k1::without_caps();
1216 res.extend_from_slice(&self.node_signature.serialize_compact(&secp_ctx));
1217 res.extend_from_slice(&self.bitcoin_signature.serialize_compact(&secp_ctx));
1222 impl MsgDecodable for UnsignedNodeAnnouncement {
1223 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1224 let features = GlobalFeatures::decode(&v[..])?;
1225 if features.requires_unknown_bits() {
1226 return Err(DecodeError::UnknownRequiredFeature);
1229 if v.len() < features.encoded_len() + 4 + 33 + 3 + 32 + 2 {
1230 return Err(DecodeError::ShortRead);
1232 let start = features.encoded_len();
1234 let mut rgb = [0; 3];
1235 rgb.copy_from_slice(&v[start + 37..start + 40]);
1237 let mut alias = [0; 32];
1238 alias.copy_from_slice(&v[start + 40..start + 72]);
1240 let addrlen = byte_utils::slice_to_be16(&v[start + 72..start + 74]) as usize;
1241 if v.len() < start + 74 + addrlen {
1242 return Err(DecodeError::ShortRead);
1244 let addr_read_limit = start + 74 + addrlen;
1246 let mut addresses = Vec::with_capacity(4);
1247 let mut read_pos = start + 74;
1249 if addr_read_limit <= read_pos { break; }
1252 if addresses.len() > 0 {
1253 return Err(DecodeError::ExtraAddressesPerType);
1255 if addr_read_limit < read_pos + 1 + 6 {
1256 return Err(DecodeError::BadLengthDescriptor);
1258 let mut addr = [0; 4];
1259 addr.copy_from_slice(&v[read_pos + 1..read_pos + 5]);
1260 addresses.push(NetAddress::IPv4 {
1262 port: byte_utils::slice_to_be16(&v[read_pos + 5..read_pos + 7]),
1267 if addresses.len() > 1 || (addresses.len() == 1 && addresses[0].get_id() != 1) {
1268 return Err(DecodeError::ExtraAddressesPerType);
1270 if addr_read_limit < read_pos + 1 + 18 {
1271 return Err(DecodeError::BadLengthDescriptor);
1273 let mut addr = [0; 16];
1274 addr.copy_from_slice(&v[read_pos + 1..read_pos + 17]);
1275 addresses.push(NetAddress::IPv6 {
1277 port: byte_utils::slice_to_be16(&v[read_pos + 17..read_pos + 19]),
1282 if addresses.len() > 2 || (addresses.len() > 0 && addresses.last().unwrap().get_id() > 2) {
1283 return Err(DecodeError::ExtraAddressesPerType);
1285 if addr_read_limit < read_pos + 1 + 12 {
1286 return Err(DecodeError::BadLengthDescriptor);
1288 let mut addr = [0; 10];
1289 addr.copy_from_slice(&v[read_pos + 1..read_pos + 11]);
1290 addresses.push(NetAddress::OnionV2 {
1292 port: byte_utils::slice_to_be16(&v[read_pos + 11..read_pos + 13]),
1297 if addresses.len() > 3 || (addresses.len() > 0 && addresses.last().unwrap().get_id() > 3) {
1298 return Err(DecodeError::ExtraAddressesPerType);
1300 if addr_read_limit < read_pos + 1 + 37 {
1301 return Err(DecodeError::BadLengthDescriptor);
1303 let mut ed25519_pubkey = [0; 32];
1304 ed25519_pubkey.copy_from_slice(&v[read_pos + 1..read_pos + 33]);
1305 addresses.push(NetAddress::OnionV3 {
1307 checksum: byte_utils::slice_to_be16(&v[read_pos + 33..read_pos + 35]),
1308 version: v[read_pos + 35],
1309 port: byte_utils::slice_to_be16(&v[read_pos + 36..read_pos + 38]),
1313 _ => { break; } // We've read all we can, we dont understand anything higher (and they're sorted)
1317 let excess_address_data = if read_pos < addr_read_limit {
1318 let mut excess_address_data = Vec::with_capacity(addr_read_limit - read_pos);
1319 excess_address_data.extend_from_slice(&v[read_pos..addr_read_limit]);
1321 } else { Vec::new() };
1323 let mut excess_data = Vec::with_capacity(v.len() - addr_read_limit);
1324 excess_data.extend_from_slice(&v[addr_read_limit..]);
1326 let secp_ctx = Secp256k1::without_caps();
1329 timestamp: byte_utils::slice_to_be32(&v[start..start + 4]),
1330 node_id: secp_pubkey!(&secp_ctx, &v[start + 4..start + 37]),
1334 excess_address_data,
1339 impl MsgEncodable for UnsignedNodeAnnouncement {
1340 fn encode(&self) -> Vec<u8> {
1341 let features = self.features.encode();
1342 let mut res = Vec::with_capacity(74 + features.len() + self.addresses.len()*7 + self.excess_address_data.len() + self.excess_data.len());
1343 res.extend_from_slice(&features[..]);
1344 res.extend_from_slice(&byte_utils::be32_to_array(self.timestamp));
1345 res.extend_from_slice(&self.node_id.serialize());
1346 res.extend_from_slice(&self.rgb);
1347 res.extend_from_slice(&self.alias);
1348 let mut addr_slice = Vec::with_capacity(self.addresses.len() * 18);
1349 let mut addrs_to_encode = self.addresses.clone();
1350 addrs_to_encode.sort_unstable_by(|a, b| { a.get_id().cmp(&b.get_id()) });
1351 addrs_to_encode.dedup_by(|a, b| { a.get_id() == b.get_id() });
1352 for addr in addrs_to_encode.iter() {
1354 &NetAddress::IPv4{addr, port} => {
1356 addr_slice.extend_from_slice(&addr);
1357 addr_slice.extend_from_slice(&byte_utils::be16_to_array(port));
1359 &NetAddress::IPv6{addr, port} => {
1361 addr_slice.extend_from_slice(&addr);
1362 addr_slice.extend_from_slice(&byte_utils::be16_to_array(port));
1364 &NetAddress::OnionV2{addr, port} => {
1366 addr_slice.extend_from_slice(&addr);
1367 addr_slice.extend_from_slice(&byte_utils::be16_to_array(port));
1369 &NetAddress::OnionV3{ed25519_pubkey, checksum, version, port} => {
1371 addr_slice.extend_from_slice(&ed25519_pubkey);
1372 addr_slice.extend_from_slice(&byte_utils::be16_to_array(checksum));
1373 addr_slice.push(version);
1374 addr_slice.extend_from_slice(&byte_utils::be16_to_array(port));
1378 res.extend_from_slice(&byte_utils::be16_to_array((addr_slice.len() + self.excess_address_data.len()) as u16));
1379 res.extend_from_slice(&addr_slice[..]);
1380 res.extend_from_slice(&self.excess_address_data[..]);
1381 res.extend_from_slice(&self.excess_data[..]);
1386 impl MsgDecodable for NodeAnnouncement {
1387 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1389 return Err(DecodeError::ShortRead);
1391 let secp_ctx = Secp256k1::without_caps();
1393 signature: secp_signature!(&secp_ctx, &v[0..64]),
1394 contents: UnsignedNodeAnnouncement::decode(&v[64..])?,
1398 impl MsgEncodable for NodeAnnouncement {
1399 fn encode(&self) -> Vec<u8> {
1400 let contents = self.contents.encode();
1401 let mut res = Vec::with_capacity(64 + contents.len());
1402 let secp_ctx = Secp256k1::without_caps();
1403 res.extend_from_slice(&self.signature.serialize_compact(&secp_ctx));
1404 res.extend_from_slice(&contents);
1409 impl MsgDecodable for UnsignedChannelAnnouncement {
1410 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1411 let features = GlobalFeatures::decode(&v[..])?;
1412 if features.requires_unknown_bits() {
1413 return Err(DecodeError::UnknownRequiredFeature);
1415 if v.len() < features.encoded_len() + 32 + 8 + 33*4 {
1416 return Err(DecodeError::ShortRead);
1418 let start = features.encoded_len();
1419 let secp_ctx = Secp256k1::without_caps();
1420 let mut excess_data = Vec::with_capacity(v.len() - start - 172);
1421 excess_data.extend_from_slice(&v[start + 172..]);
1424 chain_hash: deserialize(&v[start..start + 32]).unwrap(),
1425 short_channel_id: byte_utils::slice_to_be64(&v[start + 32..start + 40]),
1426 node_id_1: secp_pubkey!(&secp_ctx, &v[start + 40..start + 73]),
1427 node_id_2: secp_pubkey!(&secp_ctx, &v[start + 73..start + 106]),
1428 bitcoin_key_1: secp_pubkey!(&secp_ctx, &v[start + 106..start + 139]),
1429 bitcoin_key_2: secp_pubkey!(&secp_ctx, &v[start + 139..start + 172]),
1434 impl MsgEncodable for UnsignedChannelAnnouncement {
1435 fn encode(&self) -> Vec<u8> {
1436 let features = self.features.encode();
1437 let mut res = Vec::with_capacity(172 + features.len() + self.excess_data.len());
1438 res.extend_from_slice(&features[..]);
1439 res.extend_from_slice(&self.chain_hash[..]);
1440 res.extend_from_slice(&byte_utils::be64_to_array(self.short_channel_id));
1441 res.extend_from_slice(&self.node_id_1.serialize());
1442 res.extend_from_slice(&self.node_id_2.serialize());
1443 res.extend_from_slice(&self.bitcoin_key_1.serialize());
1444 res.extend_from_slice(&self.bitcoin_key_2.serialize());
1445 res.extend_from_slice(&self.excess_data[..]);
1450 impl MsgDecodable for ChannelAnnouncement {
1451 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1453 return Err(DecodeError::ShortRead);
1455 let secp_ctx = Secp256k1::without_caps();
1457 node_signature_1: secp_signature!(&secp_ctx, &v[0..64]),
1458 node_signature_2: secp_signature!(&secp_ctx, &v[64..128]),
1459 bitcoin_signature_1: secp_signature!(&secp_ctx, &v[128..192]),
1460 bitcoin_signature_2: secp_signature!(&secp_ctx, &v[192..256]),
1461 contents: UnsignedChannelAnnouncement::decode(&v[256..])?,
1465 impl MsgEncodable for ChannelAnnouncement {
1466 fn encode(&self) -> Vec<u8> {
1467 let secp_ctx = Secp256k1::without_caps();
1468 let contents = self.contents.encode();
1469 let mut res = Vec::with_capacity(64 + contents.len());
1470 res.extend_from_slice(&self.node_signature_1.serialize_compact(&secp_ctx));
1471 res.extend_from_slice(&self.node_signature_2.serialize_compact(&secp_ctx));
1472 res.extend_from_slice(&self.bitcoin_signature_1.serialize_compact(&secp_ctx));
1473 res.extend_from_slice(&self.bitcoin_signature_2.serialize_compact(&secp_ctx));
1474 res.extend_from_slice(&contents);
1479 impl MsgDecodable for UnsignedChannelUpdate {
1480 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1481 if v.len() < 32+8+4+2+2+8+4+4 {
1482 return Err(DecodeError::ShortRead);
1484 let mut excess_data = Vec::with_capacity(v.len() - 64);
1485 excess_data.extend_from_slice(&v[64..]);
1487 chain_hash: deserialize(&v[0..32]).unwrap(),
1488 short_channel_id: byte_utils::slice_to_be64(&v[32..40]),
1489 timestamp: byte_utils::slice_to_be32(&v[40..44]),
1490 flags: byte_utils::slice_to_be16(&v[44..46]),
1491 cltv_expiry_delta: byte_utils::slice_to_be16(&v[46..48]),
1492 htlc_minimum_msat: byte_utils::slice_to_be64(&v[48..56]),
1493 fee_base_msat: byte_utils::slice_to_be32(&v[56..60]),
1494 fee_proportional_millionths: byte_utils::slice_to_be32(&v[60..64]),
1499 impl MsgEncodable for UnsignedChannelUpdate {
1500 fn encode(&self) -> Vec<u8> {
1501 let mut res = Vec::with_capacity(64 + self.excess_data.len());
1502 res.extend_from_slice(&self.chain_hash[..]);
1503 res.extend_from_slice(&byte_utils::be64_to_array(self.short_channel_id));
1504 res.extend_from_slice(&byte_utils::be32_to_array(self.timestamp));
1505 res.extend_from_slice(&byte_utils::be16_to_array(self.flags));
1506 res.extend_from_slice(&byte_utils::be16_to_array(self.cltv_expiry_delta));
1507 res.extend_from_slice(&byte_utils::be64_to_array(self.htlc_minimum_msat));
1508 res.extend_from_slice(&byte_utils::be32_to_array(self.fee_base_msat));
1509 res.extend_from_slice(&byte_utils::be32_to_array(self.fee_proportional_millionths));
1510 res.extend_from_slice(&self.excess_data[..]);
1515 impl MsgDecodable for ChannelUpdate {
1516 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1518 return Err(DecodeError::ShortRead);
1520 let secp_ctx = Secp256k1::without_caps();
1522 signature: secp_signature!(&secp_ctx, &v[0..64]),
1523 contents: UnsignedChannelUpdate::decode(&v[64..])?,
1527 impl MsgEncodable for ChannelUpdate {
1528 fn encode(&self) -> Vec<u8> {
1529 let mut res = Vec::with_capacity(128);
1530 res.extend_from_slice(&self.signature.serialize_compact(&Secp256k1::without_caps())[..]);
1531 res.extend_from_slice(&self.contents.encode()[..]);
1536 impl MsgDecodable for OnionRealm0HopData {
1537 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1539 return Err(DecodeError::ShortRead);
1541 Ok(OnionRealm0HopData {
1542 short_channel_id: byte_utils::slice_to_be64(&v[0..8]),
1543 amt_to_forward: byte_utils::slice_to_be64(&v[8..16]),
1544 outgoing_cltv_value: byte_utils::slice_to_be32(&v[16..20]),
1548 impl MsgEncodable for OnionRealm0HopData {
1549 fn encode(&self) -> Vec<u8> {
1550 let mut res = Vec::with_capacity(32);
1551 res.extend_from_slice(&byte_utils::be64_to_array(self.short_channel_id));
1552 res.extend_from_slice(&byte_utils::be64_to_array(self.amt_to_forward));
1553 res.extend_from_slice(&byte_utils::be32_to_array(self.outgoing_cltv_value));
1559 impl MsgDecodable for OnionHopData {
1560 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1562 return Err(DecodeError::ShortRead);
1566 return Err(DecodeError::UnknownRealmByte);
1568 let mut hmac = [0; 32];
1569 hmac[..].copy_from_slice(&v[33..65]);
1572 data: OnionRealm0HopData::decode(&v[1..33])?,
1577 impl MsgEncodable for OnionHopData {
1578 fn encode(&self) -> Vec<u8> {
1579 let mut res = Vec::with_capacity(65);
1580 res.push(self.realm);
1581 res.extend_from_slice(&self.data.encode()[..]);
1582 res.extend_from_slice(&self.hmac);
1587 impl MsgDecodable for OnionPacket {
1588 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1589 if v.len() < 1+33+20*65+32 {
1590 return Err(DecodeError::ShortRead);
1592 let mut hop_data = [0; 20*65];
1593 hop_data.copy_from_slice(&v[34..1334]);
1594 let mut hmac = [0; 32];
1595 hmac.copy_from_slice(&v[1334..1366]);
1596 let secp_ctx = Secp256k1::without_caps();
1599 public_key: PublicKey::from_slice(&secp_ctx, &v[1..34]),
1605 impl MsgEncodable for OnionPacket {
1606 fn encode(&self) -> Vec<u8> {
1607 let mut res = Vec::with_capacity(1 + 33 + 20*65 + 32);
1608 res.push(self.version);
1609 match self.public_key {
1610 Ok(pubkey) => res.extend_from_slice(&pubkey.serialize()),
1611 Err(_) => res.extend_from_slice(&[0; 33]),
1613 res.extend_from_slice(&self.hop_data);
1614 res.extend_from_slice(&self.hmac);
1619 impl MsgDecodable for DecodedOnionErrorPacket {
1620 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1621 if v.len() < 32 + 4 {
1622 return Err(DecodeError::ShortRead);
1624 let failuremsg_len = byte_utils::slice_to_be16(&v[32..34]) as usize;
1625 if v.len() < 32 + 4 + failuremsg_len {
1626 return Err(DecodeError::ShortRead);
1628 let padding_len = byte_utils::slice_to_be16(&v[34 + failuremsg_len..]) as usize;
1629 if v.len() < 32 + 4 + failuremsg_len + padding_len {
1630 return Err(DecodeError::ShortRead);
1633 let mut hmac = [0; 32];
1634 hmac.copy_from_slice(&v[0..32]);
1637 failuremsg: v[34..34 + failuremsg_len].to_vec(),
1638 pad: v[36 + failuremsg_len..36 + failuremsg_len + padding_len].to_vec(),
1642 impl MsgEncodable for DecodedOnionErrorPacket {
1643 fn encode(&self) -> Vec<u8> {
1644 let mut res = Vec::with_capacity(32 + 4 + self.failuremsg.len() + self.pad.len());
1645 res.extend_from_slice(&self.hmac);
1646 res.extend_from_slice(&[((self.failuremsg.len() >> 8) & 0xff) as u8, (self.failuremsg.len() & 0xff) as u8]);
1647 res.extend_from_slice(&self.failuremsg);
1648 res.extend_from_slice(&[((self.pad.len() >> 8) & 0xff) as u8, (self.pad.len() & 0xff) as u8]);
1649 res.extend_from_slice(&self.pad);
1654 impl MsgDecodable for OnionErrorPacket {
1655 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1657 return Err(DecodeError::ShortRead);
1659 let len = byte_utils::slice_to_be16(&v[0..2]) as usize;
1660 if v.len() < 2 + len {
1661 return Err(DecodeError::ShortRead);
1664 data: v[2..len+2].to_vec(),
1668 impl MsgEncodable for OnionErrorPacket {
1669 fn encode(&self) -> Vec<u8> {
1670 let mut res = Vec::with_capacity(2 + self.data.len());
1671 res.extend_from_slice(&byte_utils::be16_to_array(self.data.len() as u16));
1672 res.extend_from_slice(&self.data);
1677 impl MsgEncodable for ErrorMessage {
1678 fn encode(&self) -> Vec<u8> {
1679 let mut res = Vec::with_capacity(34 + self.data.len());
1680 res.extend_from_slice(&self.channel_id);
1681 res.extend_from_slice(&byte_utils::be16_to_array(self.data.len() as u16));
1682 res.extend_from_slice(&self.data.as_bytes());
1686 impl MsgDecodable for ErrorMessage {
1687 fn decode(v: &[u8]) -> Result<Self,DecodeError> {
1689 return Err(DecodeError::ShortRead);
1691 // Unlike most messages, BOLT 1 requires we truncate our read if the value is out of range
1692 let len = cmp::min(byte_utils::slice_to_be16(&v[32..34]) as usize, v.len() - 34);
1693 let data = match String::from_utf8(v[34..34 + len].to_vec()) {
1695 Err(_) => return Err(DecodeError::BadText),
1697 let mut channel_id = [0; 32];
1698 channel_id[..].copy_from_slice(&v[0..32]);
1706 impl_writeable!(AcceptChannel, {
1707 temporary_channel_id,
1708 dust_limit_satoshis,
1709 max_htlc_value_in_flight_msat,
1710 channel_reserve_satoshis,
1716 revocation_basepoint,
1718 delayed_payment_basepoint,
1720 first_per_commitment_point,
1721 shutdown_scriptpubkey
1724 impl_writeable!(AnnouncementSignatures, {
1731 impl<W: ::std::io::Write> Writeable<W> for ChannelReestablish {
1732 fn write(&self, w: &mut Writer<W>) -> Result<(), DecodeError> {
1733 self.channel_id.write(w)?;
1734 self.next_local_commitment_number.write(w)?;
1735 self.next_remote_commitment_number.write(w)?;
1736 if let Some(ref data_loss_protect) = self.data_loss_protect {
1737 data_loss_protect.your_last_per_commitment_secret.write(w)?;
1738 data_loss_protect.my_current_per_commitment_point.write(w)?;
1744 impl<R: ::std::io::Read> Readable<R> for ChannelReestablish{
1745 fn read(r: &mut Reader<R>) -> Result<Self, DecodeError> {
1747 channel_id: Readable::read(r)?,
1748 next_local_commitment_number: Readable::read(r)?,
1749 next_remote_commitment_number: Readable::read(r)?,
1750 data_loss_protect: {
1751 match <[u8; 32] as Readable<R>>::read(r) {
1752 Ok(your_last_per_commitment_secret) =>
1753 Some(DataLossProtect {
1754 your_last_per_commitment_secret,
1755 my_current_per_commitment_point: Readable::read(r)?,
1757 Err(DecodeError::ShortRead) => None,
1758 Err(e) => return Err(e)
1765 impl_writeable!(ClosingSigned, {
1771 impl_writeable!(CommitmentSigned, {
1777 impl_writeable!(DecodedOnionErrorPacket, {
1783 impl_writeable!(FundingCreated, {
1784 temporary_channel_id,
1786 funding_output_index,
1790 impl_writeable!(FundingSigned, {
1795 impl_writeable!(FundingLocked, {
1797 next_per_commitment_point
1800 impl_writeable!(GlobalFeatures, {
1804 impl_writeable!(LocalFeatures, {
1808 impl_writeable!(Init, {
1813 impl_writeable!(OpenChannel, {
1815 temporary_channel_id,
1818 dust_limit_satoshis,
1819 max_htlc_value_in_flight_msat,
1820 channel_reserve_satoshis,
1826 revocation_basepoint,
1828 delayed_payment_basepoint,
1830 first_per_commitment_point,
1832 shutdown_scriptpubkey
1835 impl_writeable!(RevokeAndACK, {
1837 per_commitment_secret,
1838 next_per_commitment_point
1841 impl_writeable!(Shutdown, {
1846 impl_writeable!(UpdateFailHTLC, {
1852 impl_writeable!(UpdateFailMalformedHTLC, {
1859 impl_writeable!(UpdateFee, {
1864 impl_writeable!(UpdateFulfillHTLC, {
1870 impl_writeable!(OnionErrorPacket, {
1874 impl<W: ::std::io::Write> Writeable<W> for OnionPacket {
1875 fn write(&self, w: &mut Writer<W>) -> Result<(), DecodeError> {
1876 self.version.write(w)?;
1877 match self.public_key {
1878 Ok(pubkey) => pubkey.write(w)?,
1879 Err(_) => [0u8;33].write(w)?,
1881 w.write_all(&self.hop_data)?;
1882 self.hmac.write(w)?;
1887 impl<R: ::std::io::Read> Readable<R> for OnionPacket {
1888 fn read(r: &mut Reader<R>) -> Result<Self, DecodeError> {
1890 version: Readable::read(r)?,
1892 let mut buf = [0u8;33];
1893 r.read_exact(&mut buf)?;
1894 PublicKey::from_slice(&Secp256k1::without_caps(), &buf)
1896 hop_data: Readable::read(r)?,
1897 hmac: Readable::read(r)?,
1902 impl_writeable!(UpdateAddHTLC, {
1908 onion_routing_packet
1911 impl<W: ::std::io::Write> Writeable<W> for OnionRealm0HopData {
1912 fn write(&self, w: &mut Writer<W>) -> Result<(), DecodeError> {
1913 self.short_channel_id.write(w)?;
1914 self.amt_to_forward.write(w)?;
1915 self.outgoing_cltv_value.write(w)?;
1916 w.write_all(&[0;12])?;
1921 impl<R: ::std::io::Read> Readable<R> for OnionRealm0HopData {
1922 fn read(r: &mut Reader<R>) -> Result<Self, DecodeError> {
1923 Ok(OnionRealm0HopData {
1924 short_channel_id: Readable::read(r)?,
1925 amt_to_forward: Readable::read(r)?,
1926 outgoing_cltv_value: {
1927 let v: u32 = Readable::read(r)?;
1928 r.read_exact(&mut [0; 12])?;
1935 impl<W: ::std::io::Write> Writeable<W> for OnionHopData {
1936 fn write(&self, w: &mut Writer<W>) -> Result<(), DecodeError> {
1937 self.realm.write(w)?;
1938 self.data.write(w)?;
1939 self.hmac.write(w)?;
1944 impl<R: ::std::io::Read> Readable<R> for OnionHopData {
1945 fn read(r: &mut Reader<R>) -> Result<Self, DecodeError> {
1948 let r: u8 = Readable::read(r)?;
1950 return Err(DecodeError::UnknownRealmByte);
1954 data: Readable::read(r)?,
1955 hmac: Readable::read(r)?,
1960 impl<W: ::std::io::Write> Writeable<W> for Ping {
1961 fn write(&self, w: &mut Writer<W>) -> Result<(), DecodeError> {
1962 self.ponglen.write(w)?;
1963 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
1968 impl<R: ::std::io::Read> Readable<R> for Ping {
1969 fn read(r: &mut Reader<R>) -> Result<Self, DecodeError> {
1971 ponglen: Readable::read(r)?,
1973 let byteslen = Readable::read(r)?;
1974 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
1981 impl<W: ::std::io::Write> Writeable<W> for Pong {
1982 fn write(&self, w: &mut Writer<W>) -> Result<(), DecodeError> {
1983 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
1988 impl<R: ::std::io::Read> Readable<R> for Pong {
1989 fn read(r: &mut Reader<R>) -> Result<Self, DecodeError> {
1992 let byteslen = Readable::read(r)?;
1993 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2000 impl<W: ::std::io::Write> Writeable<W> for UnsignedChannelAnnouncement {
2001 fn write(&self, w: &mut Writer<W>) -> Result<(), DecodeError> {
2002 self.features.write(w)?;
2003 self.chain_hash.write(w)?;
2004 self.short_channel_id.write(w)?;
2005 self.node_id_1.write(w)?;
2006 self.node_id_2.write(w)?;
2007 self.bitcoin_key_1.write(w)?;
2008 self.bitcoin_key_2.write(w)?;
2009 w.write_all(&self.excess_data[..])?;
2014 impl<R: ::std::io::Read> Readable<R> for UnsignedChannelAnnouncement {
2015 fn read(r: &mut Reader<R>) -> Result<Self, DecodeError> {
2018 let f: GlobalFeatures = Readable::read(r)?;
2019 if f.requires_unknown_bits() {
2020 return Err(DecodeError::UnknownRequiredFeature);
2024 chain_hash: Readable::read(r)?,
2025 short_channel_id: Readable::read(r)?,
2026 node_id_1: Readable::read(r)?,
2027 node_id_2: Readable::read(r)?,
2028 bitcoin_key_1: Readable::read(r)?,
2029 bitcoin_key_2: Readable::read(r)?,
2031 let mut excess_data = vec![];
2032 r.read_to_end(&mut excess_data)?;
2039 impl_writeable!(ChannelAnnouncement,{
2042 bitcoin_signature_1,
2043 bitcoin_signature_2,
2047 impl<W: ::std::io::Write> Writeable<W> for UnsignedChannelUpdate {
2048 fn write(&self, w: &mut Writer<W>) -> Result<(), DecodeError> {
2049 self.chain_hash.write(w)?;
2050 self.short_channel_id.write(w)?;
2051 self.timestamp.write(w)?;
2052 self.flags.write(w)?;
2053 self.cltv_expiry_delta.write(w)?;
2054 self.htlc_minimum_msat.write(w)?;
2055 self.fee_base_msat.write(w)?;
2056 self.fee_proportional_millionths.write(w)?;
2057 w.write_all(&self.excess_data[..])?;
2062 impl<R: ::std::io::Read> Readable<R> for UnsignedChannelUpdate {
2063 fn read(r: &mut Reader<R>) -> Result<Self, DecodeError> {
2065 chain_hash: Readable::read(r)?,
2066 short_channel_id: Readable::read(r)?,
2067 timestamp: Readable::read(r)?,
2068 flags: Readable::read(r)?,
2069 cltv_expiry_delta: Readable::read(r)?,
2070 htlc_minimum_msat: Readable::read(r)?,
2071 fee_base_msat: Readable::read(r)?,
2072 fee_proportional_millionths: Readable::read(r)?,
2074 let mut excess_data = vec![];
2075 r.read_to_end(&mut excess_data)?;
2082 impl_writeable!(ChannelUpdate, {
2087 impl<W: ::std::io::Write> Writeable<W> for ErrorMessage {
2088 fn write(&self, w: &mut Writer<W>) -> Result<(), DecodeError> {
2089 self.channel_id.write(w)?;
2090 self.data.as_bytes().to_vec().write(w)?; // write with size prefix
2095 impl<R: ::std::io::Read> Readable<R> for ErrorMessage {
2096 fn read(r: &mut Reader<R>) -> Result<Self, DecodeError> {
2098 channel_id: Readable::read(r)?,
2100 let mut sz: usize = <u16 as Readable<R>>::read(r)? as usize;
2101 let mut data = vec![];
2102 let data_len = r.read_to_end(&mut data)?;
2103 sz = cmp::min(data_len, sz);
2104 match String::from_utf8(data[..sz as usize].to_vec()) {
2106 Err(_) => return Err(DecodeError::BadText),
2113 impl<W: ::std::io::Write> Writeable<W> for UnsignedNodeAnnouncement {
2114 fn write(&self, w: &mut Writer<W>) -> Result<(), DecodeError> {
2115 self.features.write(w)?;
2116 self.timestamp.write(w)?;
2117 self.node_id.write(w)?;
2118 w.write_all(&self.rgb)?;
2119 self.alias.write(w)?;
2121 let mut addr_slice = Vec::with_capacity(self.addresses.len() * 18);
2122 let mut addrs_to_encode = self.addresses.clone();
2123 addrs_to_encode.sort_unstable_by(|a, b| { a.get_id().cmp(&b.get_id()) });
2124 addrs_to_encode.dedup_by(|a, b| { a.get_id() == b.get_id() });
2125 for addr in addrs_to_encode.iter() {
2127 &NetAddress::IPv4{addr, port} => {
2129 addr_slice.extend_from_slice(&addr);
2130 addr_slice.extend_from_slice(&byte_utils::be16_to_array(port));
2132 &NetAddress::IPv6{addr, port} => {
2134 addr_slice.extend_from_slice(&addr);
2135 addr_slice.extend_from_slice(&byte_utils::be16_to_array(port));
2137 &NetAddress::OnionV2{addr, port} => {
2139 addr_slice.extend_from_slice(&addr);
2140 addr_slice.extend_from_slice(&byte_utils::be16_to_array(port));
2142 &NetAddress::OnionV3{ed25519_pubkey, checksum, version, port} => {
2144 addr_slice.extend_from_slice(&ed25519_pubkey);
2145 addr_slice.extend_from_slice(&byte_utils::be16_to_array(checksum));
2146 addr_slice.push(version);
2147 addr_slice.extend_from_slice(&byte_utils::be16_to_array(port));
2151 ((addr_slice.len() + self.excess_address_data.len()) as u16).write(w)?;
2152 w.write_all(&addr_slice[..])?;
2153 w.write_all(&self.excess_address_data[..])?;
2154 w.write_all(&self.excess_data[..])?;
2159 impl<R: ::std::io::Read> Readable<R> for UnsignedNodeAnnouncement {
2160 fn read(r: &mut Reader<R>) -> Result<Self, DecodeError> {
2161 let features: GlobalFeatures = Readable::read(r)?;
2162 if features.requires_unknown_bits() {
2163 return Err(DecodeError::UnknownRequiredFeature);
2165 let timestamp: u32 = Readable::read(r)?;
2166 let node_id: PublicKey = Readable::read(r)?;
2167 let mut rgb = [0; 3];
2168 r.read_exact(&mut rgb)?;
2169 let alias: [u8; 32] = Readable::read(r)?;
2171 let addrlen: u16 = Readable::read(r)?;
2172 let mut addr_readpos = 0;
2173 let mut addresses = Vec::with_capacity(4);
2177 if addrlen <= addr_readpos { break; }
2178 f = Readable::read(r)?;
2181 if addresses.len() > 0 {
2182 return Err(DecodeError::ExtraAddressesPerType);
2184 if addrlen < addr_readpos + 1 + 6 {
2185 return Err(DecodeError::BadLengthDescriptor);
2187 addresses.push(NetAddress::IPv4 {
2189 let mut addr = [0; 4];
2190 r.read_exact(&mut addr)?;
2193 port: Readable::read(r)?,
2195 addr_readpos += 1 + 6
2198 if addresses.len() > 1 || (addresses.len() == 1 && addresses[0].get_id() != 1) {
2199 return Err(DecodeError::ExtraAddressesPerType);
2201 if addrlen < addr_readpos + 1 + 18 {
2202 return Err(DecodeError::BadLengthDescriptor);
2204 addresses.push(NetAddress::IPv6 {
2206 let mut addr = [0; 16];
2207 r.read_exact(&mut addr)?;
2210 port: Readable::read(r)?,
2212 addr_readpos += 1 + 18
2215 if addresses.len() > 2 || (addresses.len() > 0 && addresses.last().unwrap().get_id() > 2) {
2216 return Err(DecodeError::ExtraAddressesPerType);
2218 if addrlen < addr_readpos + 1 + 12 {
2219 return Err(DecodeError::BadLengthDescriptor);
2221 addresses.push(NetAddress::OnionV2 {
2223 let mut addr = [0; 10];
2224 r.read_exact(&mut addr)?;
2227 port: Readable::read(r)?,
2229 addr_readpos += 1 + 12
2232 if addresses.len() > 3 || (addresses.len() > 0 && addresses.last().unwrap().get_id() > 3) {
2233 return Err(DecodeError::ExtraAddressesPerType);
2235 if addrlen < addr_readpos + 1 + 37 {
2236 return Err(DecodeError::BadLengthDescriptor);
2238 addresses.push(NetAddress::OnionV3 {
2239 ed25519_pubkey: Readable::read(r)?,
2240 checksum: Readable::read(r)?,
2241 version: Readable::read(r)?,
2242 port: Readable::read(r)?,
2244 addr_readpos += 1 + 37
2246 _ => { excess = 1; break; }
2250 let mut excess_data = vec![];
2251 let excess_address_data = if addr_readpos < addrlen {
2252 let mut excess_address_data = vec![0; (addrlen - addr_readpos) as usize];
2253 r.read_exact(&mut excess_address_data[excess..])?;
2255 excess_address_data[0] = f;
2260 excess_data.push(f);
2265 Ok(UnsignedNodeAnnouncement {
2267 timestamp: timestamp,
2271 addresses: addresses,
2272 excess_address_data: excess_address_data,
2274 r.read_to_end(&mut excess_data)?;
2281 impl_writeable!(NodeAnnouncement, {
2289 use ln::msgs::MsgEncodable;
2291 use secp256k1::key::{PublicKey,SecretKey};
2292 use secp256k1::Secp256k1;
2295 fn encoding_channel_reestablish_no_secret() {
2296 let cr = msgs::ChannelReestablish {
2297 channel_id: [4, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0],
2298 next_local_commitment_number: 3,
2299 next_remote_commitment_number: 4,
2300 data_loss_protect: None,
2303 let encoded_value = cr.encode();
2306 vec![4, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 4]
2311 fn encoding_channel_reestablish_with_secret() {
2313 let secp_ctx = Secp256k1::new();
2314 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2317 let cr = msgs::ChannelReestablish {
2318 channel_id: [4, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0],
2319 next_local_commitment_number: 3,
2320 next_remote_commitment_number: 4,
2321 data_loss_protect: Some(msgs::DataLossProtect { your_last_per_commitment_secret: [9;32], my_current_per_commitment_point: public_key}),
2324 let encoded_value = cr.encode();
2327 vec![4, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 4, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 3, 27, 132, 197, 86, 123, 18, 100, 64, 153, 93, 62, 213, 170, 186, 5, 101, 215, 30, 24, 52, 96, 72, 25, 255, 156, 23, 245, 233, 213, 221, 7, 143]