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>;
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 handle_error(&self, their_node_id: &PublicKey, msg: &ErrorMessage);
469 pub trait RoutingMessageHandler : Send + Sync {
470 fn handle_node_announcement(&self, msg: &NodeAnnouncement) -> Result<bool, HandleError>;
471 /// Handle a channel_announcement message, returning true if it should be forwarded on, false
472 /// or returning an Err otherwise.
473 fn handle_channel_announcement(&self, msg: &ChannelAnnouncement) -> Result<bool, HandleError>;
474 fn handle_channel_update(&self, msg: &ChannelUpdate) -> Result<bool, HandleError>;
475 fn handle_htlc_fail_channel_update(&self, update: &HTLCFailChannelUpdate);
478 pub struct OnionRealm0HopData {
479 pub short_channel_id: u64,
480 pub amt_to_forward: u64,
481 pub outgoing_cltv_value: u32,
482 // 12 bytes of 0-padding
485 pub struct OnionHopData {
487 pub data: OnionRealm0HopData,
490 unsafe impl internal_traits::NoDealloc for OnionHopData{}
493 pub struct OnionPacket {
495 /// In order to ensure we always return an error on Onion decode in compliance with BOLT 4, we
496 /// have to deserialize OnionPackets contained in UpdateAddHTLCs even if the ephemeral public
497 /// key (here) is bogus, so we hold a Result instead of a PublicKey as we'd like.
498 pub public_key: Result<PublicKey, secp256k1::Error>,
499 pub hop_data: [u8; 20*65],
503 pub struct DecodedOnionErrorPacket {
505 pub failuremsg: Vec<u8>,
510 pub struct OnionErrorPacket {
511 // This really should be a constant size slice, but the spec lets these things be up to 128KB?
512 // (TODO) We limit it in decode to much lower...
516 impl Error for DecodeError {
517 fn description(&self) -> &str {
519 DecodeError::UnknownRealmByte => "Unknown realm byte in Onion packet",
520 DecodeError::UnknownRequiredFeature => "Unknown required feature preventing decode",
521 DecodeError::BadPublicKey => "Invalid public key in packet",
522 DecodeError::BadSignature => "Invalid signature in packet",
523 DecodeError::BadText => "Invalid text in packet",
524 DecodeError::ShortRead => "Packet extended beyond the provided bytes",
525 DecodeError::ExtraAddressesPerType => "More than one address of a single type",
526 DecodeError::BadLengthDescriptor => "A length descriptor in the packet didn't describe the later data correctly",
527 DecodeError::Io(ref e) => e.description(),
528 DecodeError::InvalidValue => "0 or 1 is not found for boolean",
532 impl fmt::Display for DecodeError {
533 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
534 f.write_str(self.description())
538 impl fmt::Debug for HandleError {
539 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
540 f.write_str(self.err)
544 impl From<::std::io::Error> for DecodeError {
545 fn from(e: ::std::io::Error) -> Self {
546 if e.kind() == ::std::io::ErrorKind::UnexpectedEof {
547 DecodeError::ShortRead
554 macro_rules! secp_pubkey {
555 ( $ctx: expr, $slice: expr ) => {
556 match PublicKey::from_slice($ctx, $slice) {
558 Err(_) => return Err(DecodeError::BadPublicKey)
563 macro_rules! secp_signature {
564 ( $ctx: expr, $slice: expr ) => {
565 match Signature::from_compact($ctx, $slice) {
567 Err(_) => return Err(DecodeError::BadSignature)
572 impl MsgDecodable for LocalFeatures {
573 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
574 if v.len() < 2 { return Err(DecodeError::ShortRead); }
575 let len = byte_utils::slice_to_be16(&v[0..2]) as usize;
576 if v.len() < len + 2 { return Err(DecodeError::ShortRead); }
577 let mut flags = Vec::with_capacity(len);
578 flags.extend_from_slice(&v[2..2 + len]);
584 impl MsgEncodable for LocalFeatures {
585 fn encode(&self) -> Vec<u8> {
586 let mut res = Vec::with_capacity(self.flags.len() + 2);
587 res.extend_from_slice(&byte_utils::be16_to_array(self.flags.len() as u16));
588 res.extend_from_slice(&self.flags[..]);
591 fn encoded_len(&self) -> usize { self.flags.len() + 2 }
594 impl MsgDecodable for GlobalFeatures {
595 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
596 if v.len() < 2 { return Err(DecodeError::ShortRead); }
597 let len = byte_utils::slice_to_be16(&v[0..2]) as usize;
598 if v.len() < len + 2 { return Err(DecodeError::ShortRead); }
599 let mut flags = Vec::with_capacity(len);
600 flags.extend_from_slice(&v[2..2 + len]);
606 impl MsgEncodable for GlobalFeatures {
607 fn encode(&self) -> Vec<u8> {
608 let mut res = Vec::with_capacity(self.flags.len() + 2);
609 res.extend_from_slice(&byte_utils::be16_to_array(self.flags.len() as u16));
610 res.extend_from_slice(&self.flags[..]);
613 fn encoded_len(&self) -> usize { self.flags.len() + 2 }
616 impl MsgDecodable for Init {
617 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
618 let global_features = GlobalFeatures::decode(v)?;
619 if v.len() < global_features.flags.len() + 4 {
620 return Err(DecodeError::ShortRead);
622 let local_features = LocalFeatures::decode(&v[global_features.flags.len() + 2..])?;
624 global_features: global_features,
625 local_features: local_features,
629 impl MsgEncodable for Init {
630 fn encode(&self) -> Vec<u8> {
631 let mut res = Vec::with_capacity(self.global_features.flags.len() + self.local_features.flags.len());
632 res.extend_from_slice(&self.global_features.encode()[..]);
633 res.extend_from_slice(&self.local_features.encode()[..]);
638 impl MsgDecodable for Ping {
639 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
641 return Err(DecodeError::ShortRead);
643 let ponglen = byte_utils::slice_to_be16(&v[0..2]);
644 let byteslen = byte_utils::slice_to_be16(&v[2..4]);
645 if v.len() < 4 + byteslen as usize {
646 return Err(DecodeError::ShortRead);
654 impl MsgEncodable for Ping {
655 fn encode(&self) -> Vec<u8> {
656 let mut res = Vec::with_capacity(self.byteslen as usize + 2);
657 res.extend_from_slice(&byte_utils::be16_to_array(self.byteslen));
658 res.resize(2 + self.byteslen as usize, 0);
663 impl MsgDecodable for Pong {
664 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
666 return Err(DecodeError::ShortRead);
668 let byteslen = byte_utils::slice_to_be16(&v[0..2]);
669 if v.len() < 2 + byteslen as usize {
670 return Err(DecodeError::ShortRead);
677 impl MsgEncodable for Pong {
678 fn encode(&self) -> Vec<u8> {
679 let mut res = Vec::with_capacity(self.byteslen as usize + 2);
680 res.extend_from_slice(&byte_utils::be16_to_array(self.byteslen));
681 res.resize(2 + self.byteslen as usize, 0);
686 impl MsgDecodable for OpenChannel {
687 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
688 if v.len() < 2*32+6*8+4+2*2+6*33+1 {
689 return Err(DecodeError::ShortRead);
691 let ctx = Secp256k1::without_caps();
693 let mut shutdown_scriptpubkey = None;
695 let len = byte_utils::slice_to_be16(&v[319..321]) as usize;
696 if v.len() < 321+len {
697 return Err(DecodeError::ShortRead);
699 shutdown_scriptpubkey = Some(Script::from(v[321..321+len].to_vec()));
701 let mut temp_channel_id = [0; 32];
702 temp_channel_id[..].copy_from_slice(&v[32..64]);
704 chain_hash: deserialize(&v[0..32]).unwrap(),
705 temporary_channel_id: temp_channel_id,
706 funding_satoshis: byte_utils::slice_to_be64(&v[64..72]),
707 push_msat: byte_utils::slice_to_be64(&v[72..80]),
708 dust_limit_satoshis: byte_utils::slice_to_be64(&v[80..88]),
709 max_htlc_value_in_flight_msat: byte_utils::slice_to_be64(&v[88..96]),
710 channel_reserve_satoshis: byte_utils::slice_to_be64(&v[96..104]),
711 htlc_minimum_msat: byte_utils::slice_to_be64(&v[104..112]),
712 feerate_per_kw: byte_utils::slice_to_be32(&v[112..116]),
713 to_self_delay: byte_utils::slice_to_be16(&v[116..118]),
714 max_accepted_htlcs: byte_utils::slice_to_be16(&v[118..120]),
715 funding_pubkey: secp_pubkey!(&ctx, &v[120..153]),
716 revocation_basepoint: secp_pubkey!(&ctx, &v[153..186]),
717 payment_basepoint: secp_pubkey!(&ctx, &v[186..219]),
718 delayed_payment_basepoint: secp_pubkey!(&ctx, &v[219..252]),
719 htlc_basepoint: secp_pubkey!(&ctx, &v[252..285]),
720 first_per_commitment_point: secp_pubkey!(&ctx, &v[285..318]),
721 channel_flags: v[318],
722 shutdown_scriptpubkey: shutdown_scriptpubkey
726 impl MsgEncodable for OpenChannel {
727 fn encode(&self) -> Vec<u8> {
728 let mut res = match &self.shutdown_scriptpubkey {
729 &Some(ref script) => Vec::with_capacity(319 + 2 + script.len()),
730 &None => Vec::with_capacity(319),
732 res.extend_from_slice(&serialize(&self.chain_hash).unwrap());
733 res.extend_from_slice(&serialize(&self.temporary_channel_id).unwrap());
734 res.extend_from_slice(&byte_utils::be64_to_array(self.funding_satoshis));
735 res.extend_from_slice(&byte_utils::be64_to_array(self.push_msat));
736 res.extend_from_slice(&byte_utils::be64_to_array(self.dust_limit_satoshis));
737 res.extend_from_slice(&byte_utils::be64_to_array(self.max_htlc_value_in_flight_msat));
738 res.extend_from_slice(&byte_utils::be64_to_array(self.channel_reserve_satoshis));
739 res.extend_from_slice(&byte_utils::be64_to_array(self.htlc_minimum_msat));
740 res.extend_from_slice(&byte_utils::be32_to_array(self.feerate_per_kw));
741 res.extend_from_slice(&byte_utils::be16_to_array(self.to_self_delay));
742 res.extend_from_slice(&byte_utils::be16_to_array(self.max_accepted_htlcs));
743 res.extend_from_slice(&self.funding_pubkey.serialize());
744 res.extend_from_slice(&self.revocation_basepoint.serialize());
745 res.extend_from_slice(&self.payment_basepoint.serialize());
746 res.extend_from_slice(&self.delayed_payment_basepoint.serialize());
747 res.extend_from_slice(&self.htlc_basepoint.serialize());
748 res.extend_from_slice(&self.first_per_commitment_point.serialize());
749 res.push(self.channel_flags);
750 if let &Some(ref script) = &self.shutdown_scriptpubkey {
751 res.extend_from_slice(&byte_utils::be16_to_array(script.len() as u16));
752 res.extend_from_slice(&script[..]);
758 impl MsgDecodable for AcceptChannel {
759 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
760 if v.len() < 32+4*8+4+2*2+6*33 {
761 return Err(DecodeError::ShortRead);
763 let ctx = Secp256k1::without_caps();
765 let mut shutdown_scriptpubkey = None;
767 let len = byte_utils::slice_to_be16(&v[270..272]) as usize;
768 if v.len() < 272+len {
769 return Err(DecodeError::ShortRead);
771 shutdown_scriptpubkey = Some(Script::from(v[272..272+len].to_vec()));
774 let mut temporary_channel_id = [0; 32];
775 temporary_channel_id[..].copy_from_slice(&v[0..32]);
777 temporary_channel_id,
778 dust_limit_satoshis: byte_utils::slice_to_be64(&v[32..40]),
779 max_htlc_value_in_flight_msat: byte_utils::slice_to_be64(&v[40..48]),
780 channel_reserve_satoshis: byte_utils::slice_to_be64(&v[48..56]),
781 htlc_minimum_msat: byte_utils::slice_to_be64(&v[56..64]),
782 minimum_depth: byte_utils::slice_to_be32(&v[64..68]),
783 to_self_delay: byte_utils::slice_to_be16(&v[68..70]),
784 max_accepted_htlcs: byte_utils::slice_to_be16(&v[70..72]),
785 funding_pubkey: secp_pubkey!(&ctx, &v[72..105]),
786 revocation_basepoint: secp_pubkey!(&ctx, &v[105..138]),
787 payment_basepoint: secp_pubkey!(&ctx, &v[138..171]),
788 delayed_payment_basepoint: secp_pubkey!(&ctx, &v[171..204]),
789 htlc_basepoint: secp_pubkey!(&ctx, &v[204..237]),
790 first_per_commitment_point: secp_pubkey!(&ctx, &v[237..270]),
791 shutdown_scriptpubkey: shutdown_scriptpubkey
795 impl MsgEncodable for AcceptChannel {
796 fn encode(&self) -> Vec<u8> {
797 let mut res = match &self.shutdown_scriptpubkey {
798 &Some(ref script) => Vec::with_capacity(270 + 2 + script.len()),
799 &None => Vec::with_capacity(270),
801 res.extend_from_slice(&self.temporary_channel_id);
802 res.extend_from_slice(&byte_utils::be64_to_array(self.dust_limit_satoshis));
803 res.extend_from_slice(&byte_utils::be64_to_array(self.max_htlc_value_in_flight_msat));
804 res.extend_from_slice(&byte_utils::be64_to_array(self.channel_reserve_satoshis));
805 res.extend_from_slice(&byte_utils::be64_to_array(self.htlc_minimum_msat));
806 res.extend_from_slice(&byte_utils::be32_to_array(self.minimum_depth));
807 res.extend_from_slice(&byte_utils::be16_to_array(self.to_self_delay));
808 res.extend_from_slice(&byte_utils::be16_to_array(self.max_accepted_htlcs));
809 res.extend_from_slice(&self.funding_pubkey.serialize());
810 res.extend_from_slice(&self.revocation_basepoint.serialize());
811 res.extend_from_slice(&self.payment_basepoint.serialize());
812 res.extend_from_slice(&self.delayed_payment_basepoint.serialize());
813 res.extend_from_slice(&self.htlc_basepoint.serialize());
814 res.extend_from_slice(&self.first_per_commitment_point.serialize());
815 if let &Some(ref script) = &self.shutdown_scriptpubkey {
816 res.extend_from_slice(&byte_utils::be16_to_array(script.len() as u16));
817 res.extend_from_slice(&script[..]);
823 impl MsgDecodable for FundingCreated {
824 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
825 if v.len() < 32+32+2+64 {
826 return Err(DecodeError::ShortRead);
828 let ctx = Secp256k1::without_caps();
829 let mut temporary_channel_id = [0; 32];
830 temporary_channel_id[..].copy_from_slice(&v[0..32]);
832 temporary_channel_id,
833 funding_txid: deserialize(&v[32..64]).unwrap(),
834 funding_output_index: byte_utils::slice_to_be16(&v[64..66]),
835 signature: secp_signature!(&ctx, &v[66..130]),
839 impl MsgEncodable for FundingCreated {
840 fn encode(&self) -> Vec<u8> {
841 let mut res = Vec::with_capacity(32+32+2+64);
842 res.extend_from_slice(&self.temporary_channel_id);
843 res.extend_from_slice(&serialize(&self.funding_txid).unwrap()[..]);
844 res.extend_from_slice(&byte_utils::be16_to_array(self.funding_output_index));
845 let secp_ctx = Secp256k1::without_caps();
846 res.extend_from_slice(&self.signature.serialize_compact(&secp_ctx));
851 impl MsgDecodable for FundingSigned {
852 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
854 return Err(DecodeError::ShortRead);
856 let ctx = Secp256k1::without_caps();
857 let mut channel_id = [0; 32];
858 channel_id[..].copy_from_slice(&v[0..32]);
861 signature: secp_signature!(&ctx, &v[32..96]),
865 impl MsgEncodable for FundingSigned {
866 fn encode(&self) -> Vec<u8> {
867 let mut res = Vec::with_capacity(32+64);
868 res.extend_from_slice(&self.channel_id);
869 res.extend_from_slice(&self.signature.serialize_compact(&Secp256k1::without_caps()));
874 impl MsgDecodable for FundingLocked {
875 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
877 return Err(DecodeError::ShortRead);
879 let ctx = Secp256k1::without_caps();
880 let mut channel_id = [0; 32];
881 channel_id[..].copy_from_slice(&v[0..32]);
884 next_per_commitment_point: secp_pubkey!(&ctx, &v[32..65]),
888 impl MsgEncodable for FundingLocked {
889 fn encode(&self) -> Vec<u8> {
890 let mut res = Vec::with_capacity(32+33);
891 res.extend_from_slice(&self.channel_id);
892 res.extend_from_slice(&self.next_per_commitment_point.serialize());
897 impl MsgDecodable for Shutdown {
898 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
899 if v.len() < 32 + 2 {
900 return Err(DecodeError::ShortRead);
902 let scriptlen = byte_utils::slice_to_be16(&v[32..34]) as usize;
903 if v.len() < 32 + 2 + scriptlen {
904 return Err(DecodeError::ShortRead);
906 let mut channel_id = [0; 32];
907 channel_id[..].copy_from_slice(&v[0..32]);
910 scriptpubkey: Script::from(v[34..34 + scriptlen].to_vec()),
914 impl MsgEncodable for Shutdown {
915 fn encode(&self) -> Vec<u8> {
916 let mut res = Vec::with_capacity(32 + 2 + self.scriptpubkey.len());
917 res.extend_from_slice(&self.channel_id);
918 res.extend_from_slice(&byte_utils::be16_to_array(self.scriptpubkey.len() as u16));
919 res.extend_from_slice(&self.scriptpubkey[..]);
924 impl MsgDecodable for ClosingSigned {
925 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
926 if v.len() < 32 + 8 + 64 {
927 return Err(DecodeError::ShortRead);
929 let secp_ctx = Secp256k1::without_caps();
930 let mut channel_id = [0; 32];
931 channel_id[..].copy_from_slice(&v[0..32]);
934 fee_satoshis: byte_utils::slice_to_be64(&v[32..40]),
935 signature: secp_signature!(&secp_ctx, &v[40..104]),
939 impl MsgEncodable for ClosingSigned {
940 fn encode(&self) -> Vec<u8> {
941 let mut res = Vec::with_capacity(32+8+64);
942 res.extend_from_slice(&self.channel_id);
943 res.extend_from_slice(&byte_utils::be64_to_array(self.fee_satoshis));
944 let secp_ctx = Secp256k1::without_caps();
945 res.extend_from_slice(&self.signature.serialize_compact(&secp_ctx));
950 impl MsgDecodable for UpdateAddHTLC {
951 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
952 if v.len() < 32+8+8+32+4+1+33+20*65+32 {
953 return Err(DecodeError::ShortRead);
955 let mut channel_id = [0; 32];
956 channel_id[..].copy_from_slice(&v[0..32]);
957 let mut payment_hash = [0; 32];
958 payment_hash.copy_from_slice(&v[48..80]);
961 htlc_id: byte_utils::slice_to_be64(&v[32..40]),
962 amount_msat: byte_utils::slice_to_be64(&v[40..48]),
964 cltv_expiry: byte_utils::slice_to_be32(&v[80..84]),
965 onion_routing_packet: OnionPacket::decode(&v[84..84+1366])?,
969 impl MsgEncodable for UpdateAddHTLC {
970 fn encode(&self) -> Vec<u8> {
971 let mut res = Vec::with_capacity(32+8+8+32+4+1366);
972 res.extend_from_slice(&self.channel_id);
973 res.extend_from_slice(&byte_utils::be64_to_array(self.htlc_id));
974 res.extend_from_slice(&byte_utils::be64_to_array(self.amount_msat));
975 res.extend_from_slice(&self.payment_hash);
976 res.extend_from_slice(&byte_utils::be32_to_array(self.cltv_expiry));
977 res.extend_from_slice(&self.onion_routing_packet.encode()[..]);
982 impl MsgDecodable for UpdateFulfillHTLC {
983 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
984 if v.len() < 32+8+32 {
985 return Err(DecodeError::ShortRead);
987 let mut channel_id = [0; 32];
988 channel_id[..].copy_from_slice(&v[0..32]);
989 let mut payment_preimage = [0; 32];
990 payment_preimage.copy_from_slice(&v[40..72]);
993 htlc_id: byte_utils::slice_to_be64(&v[32..40]),
998 impl MsgEncodable for UpdateFulfillHTLC {
999 fn encode(&self) -> Vec<u8> {
1000 let mut res = Vec::with_capacity(32+8+32);
1001 res.extend_from_slice(&self.channel_id);
1002 res.extend_from_slice(&byte_utils::be64_to_array(self.htlc_id));
1003 res.extend_from_slice(&self.payment_preimage);
1008 impl MsgDecodable for UpdateFailHTLC {
1009 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1011 return Err(DecodeError::ShortRead);
1013 let mut channel_id = [0; 32];
1014 channel_id[..].copy_from_slice(&v[0..32]);
1017 htlc_id: byte_utils::slice_to_be64(&v[32..40]),
1018 reason: OnionErrorPacket::decode(&v[40..])?,
1022 impl MsgEncodable for UpdateFailHTLC {
1023 fn encode(&self) -> Vec<u8> {
1024 let reason = self.reason.encode();
1025 let mut res = Vec::with_capacity(32+8+reason.len());
1026 res.extend_from_slice(&self.channel_id);
1027 res.extend_from_slice(&byte_utils::be64_to_array(self.htlc_id));
1028 res.extend_from_slice(&reason[..]);
1033 impl MsgDecodable for UpdateFailMalformedHTLC {
1034 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1035 if v.len() < 32+8+32+2 {
1036 return Err(DecodeError::ShortRead);
1038 let mut channel_id = [0; 32];
1039 channel_id[..].copy_from_slice(&v[0..32]);
1040 let mut sha256_of_onion = [0; 32];
1041 sha256_of_onion.copy_from_slice(&v[40..72]);
1044 htlc_id: byte_utils::slice_to_be64(&v[32..40]),
1046 failure_code: byte_utils::slice_to_be16(&v[72..74]),
1050 impl MsgEncodable for UpdateFailMalformedHTLC {
1051 fn encode(&self) -> Vec<u8> {
1052 let mut res = Vec::with_capacity(32+8+32+2);
1053 res.extend_from_slice(&self.channel_id);
1054 res.extend_from_slice(&byte_utils::be64_to_array(self.htlc_id));
1055 res.extend_from_slice(&self.sha256_of_onion);
1056 res.extend_from_slice(&byte_utils::be16_to_array(self.failure_code));
1061 impl MsgDecodable for CommitmentSigned {
1062 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1063 if v.len() < 32+64+2 {
1064 return Err(DecodeError::ShortRead);
1066 let mut channel_id = [0; 32];
1067 channel_id[..].copy_from_slice(&v[0..32]);
1069 let htlcs = byte_utils::slice_to_be16(&v[96..98]) as usize;
1070 if v.len() < 32+64+2+htlcs*64 {
1071 return Err(DecodeError::ShortRead);
1073 let mut htlc_signatures = Vec::with_capacity(htlcs);
1074 let secp_ctx = Secp256k1::without_caps();
1076 htlc_signatures.push(secp_signature!(&secp_ctx, &v[98+i*64..98+(i+1)*64]));
1080 signature: secp_signature!(&secp_ctx, &v[32..96]),
1085 impl MsgEncodable for CommitmentSigned {
1086 fn encode(&self) -> Vec<u8> {
1087 let mut res = Vec::with_capacity(32+64+2+self.htlc_signatures.len()*64);
1088 res.extend_from_slice(&self.channel_id);
1089 let secp_ctx = Secp256k1::without_caps();
1090 res.extend_from_slice(&self.signature.serialize_compact(&secp_ctx));
1091 res.extend_from_slice(&byte_utils::be16_to_array(self.htlc_signatures.len() as u16));
1092 for i in 0..self.htlc_signatures.len() {
1093 res.extend_from_slice(&self.htlc_signatures[i].serialize_compact(&secp_ctx));
1099 impl MsgDecodable for RevokeAndACK {
1100 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1101 if v.len() < 32+32+33 {
1102 return Err(DecodeError::ShortRead);
1104 let mut channel_id = [0; 32];
1105 channel_id[..].copy_from_slice(&v[0..32]);
1106 let mut per_commitment_secret = [0; 32];
1107 per_commitment_secret.copy_from_slice(&v[32..64]);
1108 let secp_ctx = Secp256k1::without_caps();
1111 per_commitment_secret,
1112 next_per_commitment_point: secp_pubkey!(&secp_ctx, &v[64..97]),
1116 impl MsgEncodable for RevokeAndACK {
1117 fn encode(&self) -> Vec<u8> {
1118 let mut res = Vec::with_capacity(32+32+33);
1119 res.extend_from_slice(&self.channel_id);
1120 res.extend_from_slice(&self.per_commitment_secret);
1121 res.extend_from_slice(&self.next_per_commitment_point.serialize());
1126 impl MsgDecodable for UpdateFee {
1127 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1129 return Err(DecodeError::ShortRead);
1131 let mut channel_id = [0; 32];
1132 channel_id[..].copy_from_slice(&v[0..32]);
1135 feerate_per_kw: byte_utils::slice_to_be32(&v[32..36]),
1139 impl MsgEncodable for UpdateFee {
1140 fn encode(&self) -> Vec<u8> {
1141 let mut res = Vec::with_capacity(32+4);
1142 res.extend_from_slice(&self.channel_id);
1143 res.extend_from_slice(&byte_utils::be32_to_array(self.feerate_per_kw));
1148 impl MsgDecodable for ChannelReestablish {
1149 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1150 if v.len() < 32+2*8 {
1151 return Err(DecodeError::ShortRead);
1154 let data_loss_protect = if v.len() > 32+2*8 {
1155 if v.len() < 32+2*8 + 33+32 {
1156 return Err(DecodeError::ShortRead);
1158 let mut inner_array = [0; 32];
1159 inner_array.copy_from_slice(&v[48..48+32]);
1160 Some(DataLossProtect {
1161 your_last_per_commitment_secret: inner_array,
1162 my_current_per_commitment_point: secp_pubkey!(&Secp256k1::without_caps(), &v[48+32..48+32+33]),
1167 channel_id: deserialize(&v[0..32]).unwrap(),
1168 next_local_commitment_number: byte_utils::slice_to_be64(&v[32..40]),
1169 next_remote_commitment_number: byte_utils::slice_to_be64(&v[40..48]),
1170 data_loss_protect: data_loss_protect,
1174 impl MsgEncodable for ChannelReestablish {
1175 fn encode(&self) -> Vec<u8> {
1176 let mut res = Vec::with_capacity(if self.data_loss_protect.is_some() { 32+2*8+33+32 } else { 32+2*8 });
1178 res.extend_from_slice(&serialize(&self.channel_id).unwrap()[..]);
1179 res.extend_from_slice(&byte_utils::be64_to_array(self.next_local_commitment_number));
1180 res.extend_from_slice(&byte_utils::be64_to_array(self.next_remote_commitment_number));
1182 if let &Some(ref data_loss_protect) = &self.data_loss_protect {
1183 res.extend_from_slice(&data_loss_protect.your_last_per_commitment_secret[..]);
1184 res.extend_from_slice(&data_loss_protect.my_current_per_commitment_point.serialize());
1190 impl MsgDecodable for AnnouncementSignatures {
1191 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1192 if v.len() < 32+8+64*2 {
1193 return Err(DecodeError::ShortRead);
1195 let secp_ctx = Secp256k1::without_caps();
1196 let mut channel_id = [0; 32];
1197 channel_id[..].copy_from_slice(&v[0..32]);
1200 short_channel_id: byte_utils::slice_to_be64(&v[32..40]),
1201 node_signature: secp_signature!(&secp_ctx, &v[40..104]),
1202 bitcoin_signature: secp_signature!(&secp_ctx, &v[104..168]),
1206 impl MsgEncodable for AnnouncementSignatures {
1207 fn encode(&self) -> Vec<u8> {
1208 let mut res = Vec::with_capacity(32+8+64*2);
1209 res.extend_from_slice(&self.channel_id);
1210 res.extend_from_slice(&byte_utils::be64_to_array(self.short_channel_id));
1211 let secp_ctx = Secp256k1::without_caps();
1212 res.extend_from_slice(&self.node_signature.serialize_compact(&secp_ctx));
1213 res.extend_from_slice(&self.bitcoin_signature.serialize_compact(&secp_ctx));
1218 impl MsgDecodable for UnsignedNodeAnnouncement {
1219 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1220 let features = GlobalFeatures::decode(&v[..])?;
1221 if features.requires_unknown_bits() {
1222 return Err(DecodeError::UnknownRequiredFeature);
1225 if v.len() < features.encoded_len() + 4 + 33 + 3 + 32 + 2 {
1226 return Err(DecodeError::ShortRead);
1228 let start = features.encoded_len();
1230 let mut rgb = [0; 3];
1231 rgb.copy_from_slice(&v[start + 37..start + 40]);
1233 let mut alias = [0; 32];
1234 alias.copy_from_slice(&v[start + 40..start + 72]);
1236 let addrlen = byte_utils::slice_to_be16(&v[start + 72..start + 74]) as usize;
1237 if v.len() < start + 74 + addrlen {
1238 return Err(DecodeError::ShortRead);
1240 let addr_read_limit = start + 74 + addrlen;
1242 let mut addresses = Vec::with_capacity(4);
1243 let mut read_pos = start + 74;
1245 if addr_read_limit <= read_pos { break; }
1248 if addresses.len() > 0 {
1249 return Err(DecodeError::ExtraAddressesPerType);
1251 if addr_read_limit < read_pos + 1 + 6 {
1252 return Err(DecodeError::BadLengthDescriptor);
1254 let mut addr = [0; 4];
1255 addr.copy_from_slice(&v[read_pos + 1..read_pos + 5]);
1256 addresses.push(NetAddress::IPv4 {
1258 port: byte_utils::slice_to_be16(&v[read_pos + 5..read_pos + 7]),
1263 if addresses.len() > 1 || (addresses.len() == 1 && addresses[0].get_id() != 1) {
1264 return Err(DecodeError::ExtraAddressesPerType);
1266 if addr_read_limit < read_pos + 1 + 18 {
1267 return Err(DecodeError::BadLengthDescriptor);
1269 let mut addr = [0; 16];
1270 addr.copy_from_slice(&v[read_pos + 1..read_pos + 17]);
1271 addresses.push(NetAddress::IPv6 {
1273 port: byte_utils::slice_to_be16(&v[read_pos + 17..read_pos + 19]),
1278 if addresses.len() > 2 || (addresses.len() > 0 && addresses.last().unwrap().get_id() > 2) {
1279 return Err(DecodeError::ExtraAddressesPerType);
1281 if addr_read_limit < read_pos + 1 + 12 {
1282 return Err(DecodeError::BadLengthDescriptor);
1284 let mut addr = [0; 10];
1285 addr.copy_from_slice(&v[read_pos + 1..read_pos + 11]);
1286 addresses.push(NetAddress::OnionV2 {
1288 port: byte_utils::slice_to_be16(&v[read_pos + 11..read_pos + 13]),
1293 if addresses.len() > 3 || (addresses.len() > 0 && addresses.last().unwrap().get_id() > 3) {
1294 return Err(DecodeError::ExtraAddressesPerType);
1296 if addr_read_limit < read_pos + 1 + 37 {
1297 return Err(DecodeError::BadLengthDescriptor);
1299 let mut ed25519_pubkey = [0; 32];
1300 ed25519_pubkey.copy_from_slice(&v[read_pos + 1..read_pos + 33]);
1301 addresses.push(NetAddress::OnionV3 {
1303 checksum: byte_utils::slice_to_be16(&v[read_pos + 33..read_pos + 35]),
1304 version: v[read_pos + 35],
1305 port: byte_utils::slice_to_be16(&v[read_pos + 36..read_pos + 38]),
1309 _ => { break; } // We've read all we can, we dont understand anything higher (and they're sorted)
1313 let excess_address_data = if read_pos < addr_read_limit {
1314 let mut excess_address_data = Vec::with_capacity(addr_read_limit - read_pos);
1315 excess_address_data.extend_from_slice(&v[read_pos..addr_read_limit]);
1317 } else { Vec::new() };
1319 let mut excess_data = Vec::with_capacity(v.len() - addr_read_limit);
1320 excess_data.extend_from_slice(&v[addr_read_limit..]);
1322 let secp_ctx = Secp256k1::without_caps();
1325 timestamp: byte_utils::slice_to_be32(&v[start..start + 4]),
1326 node_id: secp_pubkey!(&secp_ctx, &v[start + 4..start + 37]),
1330 excess_address_data,
1335 impl MsgEncodable for UnsignedNodeAnnouncement {
1336 fn encode(&self) -> Vec<u8> {
1337 let features = self.features.encode();
1338 let mut res = Vec::with_capacity(74 + features.len() + self.addresses.len()*7 + self.excess_address_data.len() + self.excess_data.len());
1339 res.extend_from_slice(&features[..]);
1340 res.extend_from_slice(&byte_utils::be32_to_array(self.timestamp));
1341 res.extend_from_slice(&self.node_id.serialize());
1342 res.extend_from_slice(&self.rgb);
1343 res.extend_from_slice(&self.alias);
1344 let mut addr_slice = Vec::with_capacity(self.addresses.len() * 18);
1345 let mut addrs_to_encode = self.addresses.clone();
1346 addrs_to_encode.sort_unstable_by(|a, b| { a.get_id().cmp(&b.get_id()) });
1347 addrs_to_encode.dedup_by(|a, b| { a.get_id() == b.get_id() });
1348 for addr in addrs_to_encode.iter() {
1350 &NetAddress::IPv4{addr, port} => {
1352 addr_slice.extend_from_slice(&addr);
1353 addr_slice.extend_from_slice(&byte_utils::be16_to_array(port));
1355 &NetAddress::IPv6{addr, port} => {
1357 addr_slice.extend_from_slice(&addr);
1358 addr_slice.extend_from_slice(&byte_utils::be16_to_array(port));
1360 &NetAddress::OnionV2{addr, port} => {
1362 addr_slice.extend_from_slice(&addr);
1363 addr_slice.extend_from_slice(&byte_utils::be16_to_array(port));
1365 &NetAddress::OnionV3{ed25519_pubkey, checksum, version, port} => {
1367 addr_slice.extend_from_slice(&ed25519_pubkey);
1368 addr_slice.extend_from_slice(&byte_utils::be16_to_array(checksum));
1369 addr_slice.push(version);
1370 addr_slice.extend_from_slice(&byte_utils::be16_to_array(port));
1374 res.extend_from_slice(&byte_utils::be16_to_array((addr_slice.len() + self.excess_address_data.len()) as u16));
1375 res.extend_from_slice(&addr_slice[..]);
1376 res.extend_from_slice(&self.excess_address_data[..]);
1377 res.extend_from_slice(&self.excess_data[..]);
1382 impl MsgDecodable for NodeAnnouncement {
1383 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1385 return Err(DecodeError::ShortRead);
1387 let secp_ctx = Secp256k1::without_caps();
1389 signature: secp_signature!(&secp_ctx, &v[0..64]),
1390 contents: UnsignedNodeAnnouncement::decode(&v[64..])?,
1394 impl MsgEncodable for NodeAnnouncement {
1395 fn encode(&self) -> Vec<u8> {
1396 let contents = self.contents.encode();
1397 let mut res = Vec::with_capacity(64 + contents.len());
1398 let secp_ctx = Secp256k1::without_caps();
1399 res.extend_from_slice(&self.signature.serialize_compact(&secp_ctx));
1400 res.extend_from_slice(&contents);
1405 impl MsgDecodable for UnsignedChannelAnnouncement {
1406 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1407 let features = GlobalFeatures::decode(&v[..])?;
1408 if features.requires_unknown_bits() {
1409 return Err(DecodeError::UnknownRequiredFeature);
1411 if v.len() < features.encoded_len() + 32 + 8 + 33*4 {
1412 return Err(DecodeError::ShortRead);
1414 let start = features.encoded_len();
1415 let secp_ctx = Secp256k1::without_caps();
1416 let mut excess_data = Vec::with_capacity(v.len() - start - 172);
1417 excess_data.extend_from_slice(&v[start + 172..]);
1420 chain_hash: deserialize(&v[start..start + 32]).unwrap(),
1421 short_channel_id: byte_utils::slice_to_be64(&v[start + 32..start + 40]),
1422 node_id_1: secp_pubkey!(&secp_ctx, &v[start + 40..start + 73]),
1423 node_id_2: secp_pubkey!(&secp_ctx, &v[start + 73..start + 106]),
1424 bitcoin_key_1: secp_pubkey!(&secp_ctx, &v[start + 106..start + 139]),
1425 bitcoin_key_2: secp_pubkey!(&secp_ctx, &v[start + 139..start + 172]),
1430 impl MsgEncodable for UnsignedChannelAnnouncement {
1431 fn encode(&self) -> Vec<u8> {
1432 let features = self.features.encode();
1433 let mut res = Vec::with_capacity(172 + features.len() + self.excess_data.len());
1434 res.extend_from_slice(&features[..]);
1435 res.extend_from_slice(&self.chain_hash[..]);
1436 res.extend_from_slice(&byte_utils::be64_to_array(self.short_channel_id));
1437 res.extend_from_slice(&self.node_id_1.serialize());
1438 res.extend_from_slice(&self.node_id_2.serialize());
1439 res.extend_from_slice(&self.bitcoin_key_1.serialize());
1440 res.extend_from_slice(&self.bitcoin_key_2.serialize());
1441 res.extend_from_slice(&self.excess_data[..]);
1446 impl MsgDecodable for ChannelAnnouncement {
1447 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1449 return Err(DecodeError::ShortRead);
1451 let secp_ctx = Secp256k1::without_caps();
1453 node_signature_1: secp_signature!(&secp_ctx, &v[0..64]),
1454 node_signature_2: secp_signature!(&secp_ctx, &v[64..128]),
1455 bitcoin_signature_1: secp_signature!(&secp_ctx, &v[128..192]),
1456 bitcoin_signature_2: secp_signature!(&secp_ctx, &v[192..256]),
1457 contents: UnsignedChannelAnnouncement::decode(&v[256..])?,
1461 impl MsgEncodable for ChannelAnnouncement {
1462 fn encode(&self) -> Vec<u8> {
1463 let secp_ctx = Secp256k1::without_caps();
1464 let contents = self.contents.encode();
1465 let mut res = Vec::with_capacity(64 + contents.len());
1466 res.extend_from_slice(&self.node_signature_1.serialize_compact(&secp_ctx));
1467 res.extend_from_slice(&self.node_signature_2.serialize_compact(&secp_ctx));
1468 res.extend_from_slice(&self.bitcoin_signature_1.serialize_compact(&secp_ctx));
1469 res.extend_from_slice(&self.bitcoin_signature_2.serialize_compact(&secp_ctx));
1470 res.extend_from_slice(&contents);
1475 impl MsgDecodable for UnsignedChannelUpdate {
1476 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1477 if v.len() < 32+8+4+2+2+8+4+4 {
1478 return Err(DecodeError::ShortRead);
1480 let mut excess_data = Vec::with_capacity(v.len() - 64);
1481 excess_data.extend_from_slice(&v[64..]);
1483 chain_hash: deserialize(&v[0..32]).unwrap(),
1484 short_channel_id: byte_utils::slice_to_be64(&v[32..40]),
1485 timestamp: byte_utils::slice_to_be32(&v[40..44]),
1486 flags: byte_utils::slice_to_be16(&v[44..46]),
1487 cltv_expiry_delta: byte_utils::slice_to_be16(&v[46..48]),
1488 htlc_minimum_msat: byte_utils::slice_to_be64(&v[48..56]),
1489 fee_base_msat: byte_utils::slice_to_be32(&v[56..60]),
1490 fee_proportional_millionths: byte_utils::slice_to_be32(&v[60..64]),
1495 impl MsgEncodable for UnsignedChannelUpdate {
1496 fn encode(&self) -> Vec<u8> {
1497 let mut res = Vec::with_capacity(64 + self.excess_data.len());
1498 res.extend_from_slice(&self.chain_hash[..]);
1499 res.extend_from_slice(&byte_utils::be64_to_array(self.short_channel_id));
1500 res.extend_from_slice(&byte_utils::be32_to_array(self.timestamp));
1501 res.extend_from_slice(&byte_utils::be16_to_array(self.flags));
1502 res.extend_from_slice(&byte_utils::be16_to_array(self.cltv_expiry_delta));
1503 res.extend_from_slice(&byte_utils::be64_to_array(self.htlc_minimum_msat));
1504 res.extend_from_slice(&byte_utils::be32_to_array(self.fee_base_msat));
1505 res.extend_from_slice(&byte_utils::be32_to_array(self.fee_proportional_millionths));
1506 res.extend_from_slice(&self.excess_data[..]);
1511 impl MsgDecodable for ChannelUpdate {
1512 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1514 return Err(DecodeError::ShortRead);
1516 let secp_ctx = Secp256k1::without_caps();
1518 signature: secp_signature!(&secp_ctx, &v[0..64]),
1519 contents: UnsignedChannelUpdate::decode(&v[64..])?,
1523 impl MsgEncodable for ChannelUpdate {
1524 fn encode(&self) -> Vec<u8> {
1525 let mut res = Vec::with_capacity(128);
1526 res.extend_from_slice(&self.signature.serialize_compact(&Secp256k1::without_caps())[..]);
1527 res.extend_from_slice(&self.contents.encode()[..]);
1532 impl MsgDecodable for OnionRealm0HopData {
1533 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1535 return Err(DecodeError::ShortRead);
1537 Ok(OnionRealm0HopData {
1538 short_channel_id: byte_utils::slice_to_be64(&v[0..8]),
1539 amt_to_forward: byte_utils::slice_to_be64(&v[8..16]),
1540 outgoing_cltv_value: byte_utils::slice_to_be32(&v[16..20]),
1544 impl MsgEncodable for OnionRealm0HopData {
1545 fn encode(&self) -> Vec<u8> {
1546 let mut res = Vec::with_capacity(32);
1547 res.extend_from_slice(&byte_utils::be64_to_array(self.short_channel_id));
1548 res.extend_from_slice(&byte_utils::be64_to_array(self.amt_to_forward));
1549 res.extend_from_slice(&byte_utils::be32_to_array(self.outgoing_cltv_value));
1555 impl MsgDecodable for OnionHopData {
1556 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1558 return Err(DecodeError::ShortRead);
1562 return Err(DecodeError::UnknownRealmByte);
1564 let mut hmac = [0; 32];
1565 hmac[..].copy_from_slice(&v[33..65]);
1568 data: OnionRealm0HopData::decode(&v[1..33])?,
1573 impl MsgEncodable for OnionHopData {
1574 fn encode(&self) -> Vec<u8> {
1575 let mut res = Vec::with_capacity(65);
1576 res.push(self.realm);
1577 res.extend_from_slice(&self.data.encode()[..]);
1578 res.extend_from_slice(&self.hmac);
1583 impl MsgDecodable for OnionPacket {
1584 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1585 if v.len() < 1+33+20*65+32 {
1586 return Err(DecodeError::ShortRead);
1588 let mut hop_data = [0; 20*65];
1589 hop_data.copy_from_slice(&v[34..1334]);
1590 let mut hmac = [0; 32];
1591 hmac.copy_from_slice(&v[1334..1366]);
1592 let secp_ctx = Secp256k1::without_caps();
1595 public_key: PublicKey::from_slice(&secp_ctx, &v[1..34]),
1601 impl MsgEncodable for OnionPacket {
1602 fn encode(&self) -> Vec<u8> {
1603 let mut res = Vec::with_capacity(1 + 33 + 20*65 + 32);
1604 res.push(self.version);
1605 match self.public_key {
1606 Ok(pubkey) => res.extend_from_slice(&pubkey.serialize()),
1607 Err(_) => res.extend_from_slice(&[0; 33]),
1609 res.extend_from_slice(&self.hop_data);
1610 res.extend_from_slice(&self.hmac);
1615 impl MsgDecodable for DecodedOnionErrorPacket {
1616 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1617 if v.len() < 32 + 4 {
1618 return Err(DecodeError::ShortRead);
1620 let failuremsg_len = byte_utils::slice_to_be16(&v[32..34]) as usize;
1621 if v.len() < 32 + 4 + failuremsg_len {
1622 return Err(DecodeError::ShortRead);
1624 let padding_len = byte_utils::slice_to_be16(&v[34 + failuremsg_len..]) as usize;
1625 if v.len() < 32 + 4 + failuremsg_len + padding_len {
1626 return Err(DecodeError::ShortRead);
1629 let mut hmac = [0; 32];
1630 hmac.copy_from_slice(&v[0..32]);
1633 failuremsg: v[34..34 + failuremsg_len].to_vec(),
1634 pad: v[36 + failuremsg_len..36 + failuremsg_len + padding_len].to_vec(),
1638 impl MsgEncodable for DecodedOnionErrorPacket {
1639 fn encode(&self) -> Vec<u8> {
1640 let mut res = Vec::with_capacity(32 + 4 + self.failuremsg.len() + self.pad.len());
1641 res.extend_from_slice(&self.hmac);
1642 res.extend_from_slice(&[((self.failuremsg.len() >> 8) & 0xff) as u8, (self.failuremsg.len() & 0xff) as u8]);
1643 res.extend_from_slice(&self.failuremsg);
1644 res.extend_from_slice(&[((self.pad.len() >> 8) & 0xff) as u8, (self.pad.len() & 0xff) as u8]);
1645 res.extend_from_slice(&self.pad);
1650 impl MsgDecodable for OnionErrorPacket {
1651 fn decode(v: &[u8]) -> Result<Self, DecodeError> {
1653 return Err(DecodeError::ShortRead);
1655 let len = byte_utils::slice_to_be16(&v[0..2]) as usize;
1656 if v.len() < 2 + len {
1657 return Err(DecodeError::ShortRead);
1660 data: v[2..len+2].to_vec(),
1664 impl MsgEncodable for OnionErrorPacket {
1665 fn encode(&self) -> Vec<u8> {
1666 let mut res = Vec::with_capacity(2 + self.data.len());
1667 res.extend_from_slice(&byte_utils::be16_to_array(self.data.len() as u16));
1668 res.extend_from_slice(&self.data);
1673 impl MsgEncodable for ErrorMessage {
1674 fn encode(&self) -> Vec<u8> {
1675 let mut res = Vec::with_capacity(34 + self.data.len());
1676 res.extend_from_slice(&self.channel_id);
1677 res.extend_from_slice(&byte_utils::be16_to_array(self.data.len() as u16));
1678 res.extend_from_slice(&self.data.as_bytes());
1682 impl MsgDecodable for ErrorMessage {
1683 fn decode(v: &[u8]) -> Result<Self,DecodeError> {
1685 return Err(DecodeError::ShortRead);
1687 // Unlike most messages, BOLT 1 requires we truncate our read if the value is out of range
1688 let len = cmp::min(byte_utils::slice_to_be16(&v[32..34]) as usize, v.len() - 34);
1689 let data = match String::from_utf8(v[34..34 + len].to_vec()) {
1691 Err(_) => return Err(DecodeError::BadText),
1693 let mut channel_id = [0; 32];
1694 channel_id[..].copy_from_slice(&v[0..32]);
1702 impl_writeable!(AcceptChannel, {
1703 temporary_channel_id,
1704 dust_limit_satoshis,
1705 max_htlc_value_in_flight_msat,
1706 channel_reserve_satoshis,
1712 revocation_basepoint,
1714 delayed_payment_basepoint,
1716 first_per_commitment_point,
1717 shutdown_scriptpubkey
1720 impl_writeable!(AnnouncementSignatures, {
1727 impl<W: ::std::io::Write> Writeable<W> for ChannelReestablish {
1728 fn write(&self, w: &mut Writer<W>) -> Result<(), DecodeError> {
1729 self.channel_id.write(w)?;
1730 self.next_local_commitment_number.write(w)?;
1731 self.next_remote_commitment_number.write(w)?;
1732 if let Some(ref data_loss_protect) = self.data_loss_protect {
1733 data_loss_protect.your_last_per_commitment_secret.write(w)?;
1734 data_loss_protect.my_current_per_commitment_point.write(w)?;
1740 impl<R: ::std::io::Read> Readable<R> for ChannelReestablish{
1741 fn read(r: &mut Reader<R>) -> Result<Self, DecodeError> {
1743 channel_id: Readable::read(r)?,
1744 next_local_commitment_number: Readable::read(r)?,
1745 next_remote_commitment_number: Readable::read(r)?,
1746 data_loss_protect: {
1747 match <[u8; 32] as Readable<R>>::read(r) {
1748 Ok(your_last_per_commitment_secret) =>
1749 Some(DataLossProtect {
1750 your_last_per_commitment_secret,
1751 my_current_per_commitment_point: Readable::read(r)?,
1753 Err(DecodeError::ShortRead) => None,
1754 Err(e) => return Err(e)
1761 impl_writeable!(ClosingSigned, {
1767 impl_writeable!(CommitmentSigned, {
1773 impl_writeable!(DecodedOnionErrorPacket, {
1779 impl_writeable!(FundingCreated, {
1780 temporary_channel_id,
1782 funding_output_index,
1786 impl_writeable!(FundingSigned, {
1791 impl_writeable!(FundingLocked, {
1793 next_per_commitment_point
1796 impl_writeable!(GlobalFeatures, {
1800 impl_writeable!(LocalFeatures, {
1804 impl_writeable!(Init, {
1809 impl_writeable!(OpenChannel, {
1811 temporary_channel_id,
1814 dust_limit_satoshis,
1815 max_htlc_value_in_flight_msat,
1816 channel_reserve_satoshis,
1822 revocation_basepoint,
1824 delayed_payment_basepoint,
1826 first_per_commitment_point,
1828 shutdown_scriptpubkey
1831 impl_writeable!(RevokeAndACK, {
1833 per_commitment_secret,
1834 next_per_commitment_point
1837 impl_writeable!(Shutdown, {
1842 impl_writeable!(UpdateFailHTLC, {
1848 impl_writeable!(UpdateFailMalformedHTLC, {
1855 impl_writeable!(UpdateFee, {
1860 impl_writeable!(UpdateFulfillHTLC, {
1866 impl_writeable!(OnionErrorPacket, {
1870 impl<W: ::std::io::Write> Writeable<W> for OnionPacket {
1871 fn write(&self, w: &mut Writer<W>) -> Result<(), DecodeError> {
1872 self.version.write(w)?;
1873 match self.public_key {
1874 Ok(pubkey) => pubkey.write(w)?,
1875 Err(_) => [0u8;33].write(w)?,
1877 w.write_all(&self.hop_data)?;
1878 self.hmac.write(w)?;
1883 impl<R: ::std::io::Read> Readable<R> for OnionPacket {
1884 fn read(r: &mut Reader<R>) -> Result<Self, DecodeError> {
1886 version: Readable::read(r)?,
1888 let mut buf = [0u8;33];
1889 r.read_exact(&mut buf)?;
1890 PublicKey::from_slice(&Secp256k1::without_caps(), &buf)
1892 hop_data: Readable::read(r)?,
1893 hmac: Readable::read(r)?,
1898 impl_writeable!(UpdateAddHTLC, {
1904 onion_routing_packet
1907 impl<W: ::std::io::Write> Writeable<W> for OnionRealm0HopData {
1908 fn write(&self, w: &mut Writer<W>) -> Result<(), DecodeError> {
1909 self.short_channel_id.write(w)?;
1910 self.amt_to_forward.write(w)?;
1911 self.outgoing_cltv_value.write(w)?;
1912 w.write_all(&[0;12])?;
1917 impl<R: ::std::io::Read> Readable<R> for OnionRealm0HopData {
1918 fn read(r: &mut Reader<R>) -> Result<Self, DecodeError> {
1919 Ok(OnionRealm0HopData {
1920 short_channel_id: Readable::read(r)?,
1921 amt_to_forward: Readable::read(r)?,
1922 outgoing_cltv_value: {
1923 let v: u32 = Readable::read(r)?;
1924 r.read_exact(&mut [0; 12])?;
1931 impl<W: ::std::io::Write> Writeable<W> for OnionHopData {
1932 fn write(&self, w: &mut Writer<W>) -> Result<(), DecodeError> {
1933 self.realm.write(w)?;
1934 self.data.write(w)?;
1935 self.hmac.write(w)?;
1940 impl<R: ::std::io::Read> Readable<R> for OnionHopData {
1941 fn read(r: &mut Reader<R>) -> Result<Self, DecodeError> {
1944 let r: u8 = Readable::read(r)?;
1946 return Err(DecodeError::UnknownRealmByte);
1950 data: Readable::read(r)?,
1951 hmac: Readable::read(r)?,
1956 impl<W: ::std::io::Write> Writeable<W> for Ping {
1957 fn write(&self, w: &mut Writer<W>) -> Result<(), DecodeError> {
1958 self.ponglen.write(w)?;
1959 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
1964 impl<R: ::std::io::Read> Readable<R> for Ping {
1965 fn read(r: &mut Reader<R>) -> Result<Self, DecodeError> {
1967 ponglen: Readable::read(r)?,
1969 let byteslen = Readable::read(r)?;
1970 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
1977 impl<W: ::std::io::Write> Writeable<W> for Pong {
1978 fn write(&self, w: &mut Writer<W>) -> Result<(), DecodeError> {
1979 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
1984 impl<R: ::std::io::Read> Readable<R> for Pong {
1985 fn read(r: &mut Reader<R>) -> Result<Self, DecodeError> {
1988 let byteslen = Readable::read(r)?;
1989 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
1996 impl<W: ::std::io::Write> Writeable<W> for UnsignedChannelAnnouncement {
1997 fn write(&self, w: &mut Writer<W>) -> Result<(), DecodeError> {
1998 self.features.write(w)?;
1999 self.chain_hash.write(w)?;
2000 self.short_channel_id.write(w)?;
2001 self.node_id_1.write(w)?;
2002 self.node_id_2.write(w)?;
2003 self.bitcoin_key_1.write(w)?;
2004 self.bitcoin_key_2.write(w)?;
2005 w.write_all(&self.excess_data[..])?;
2010 impl<R: ::std::io::Read> Readable<R> for UnsignedChannelAnnouncement {
2011 fn read(r: &mut Reader<R>) -> Result<Self, DecodeError> {
2014 let f: GlobalFeatures = Readable::read(r)?;
2015 if f.requires_unknown_bits() {
2016 return Err(DecodeError::UnknownRequiredFeature);
2020 chain_hash: Readable::read(r)?,
2021 short_channel_id: Readable::read(r)?,
2022 node_id_1: Readable::read(r)?,
2023 node_id_2: Readable::read(r)?,
2024 bitcoin_key_1: Readable::read(r)?,
2025 bitcoin_key_2: Readable::read(r)?,
2027 let mut excess_data = vec![];
2028 r.read_to_end(&mut excess_data)?;
2035 impl_writeable!(ChannelAnnouncement,{
2038 bitcoin_signature_1,
2039 bitcoin_signature_2,
2043 impl<W: ::std::io::Write> Writeable<W> for UnsignedChannelUpdate {
2044 fn write(&self, w: &mut Writer<W>) -> Result<(), DecodeError> {
2045 self.chain_hash.write(w)?;
2046 self.short_channel_id.write(w)?;
2047 self.timestamp.write(w)?;
2048 self.flags.write(w)?;
2049 self.cltv_expiry_delta.write(w)?;
2050 self.htlc_minimum_msat.write(w)?;
2051 self.fee_base_msat.write(w)?;
2052 self.fee_proportional_millionths.write(w)?;
2053 w.write_all(&self.excess_data[..])?;
2058 impl<R: ::std::io::Read> Readable<R> for UnsignedChannelUpdate {
2059 fn read(r: &mut Reader<R>) -> Result<Self, DecodeError> {
2061 chain_hash: Readable::read(r)?,
2062 short_channel_id: Readable::read(r)?,
2063 timestamp: Readable::read(r)?,
2064 flags: Readable::read(r)?,
2065 cltv_expiry_delta: Readable::read(r)?,
2066 htlc_minimum_msat: Readable::read(r)?,
2067 fee_base_msat: Readable::read(r)?,
2068 fee_proportional_millionths: Readable::read(r)?,
2070 let mut excess_data = vec![];
2071 r.read_to_end(&mut excess_data)?;
2078 impl_writeable!(ChannelUpdate, {
2083 impl<W: ::std::io::Write> Writeable<W> for ErrorMessage {
2084 fn write(&self, w: &mut Writer<W>) -> Result<(), DecodeError> {
2085 self.channel_id.write(w)?;
2086 self.data.as_bytes().to_vec().write(w)?; // write with size prefix
2091 impl<R: ::std::io::Read> Readable<R> for ErrorMessage {
2092 fn read(r: &mut Reader<R>) -> Result<Self, DecodeError> {
2094 channel_id: Readable::read(r)?,
2096 let mut sz: usize = <u16 as Readable<R>>::read(r)? as usize;
2097 let mut data = vec![];
2098 let data_len = r.read_to_end(&mut data)?;
2099 sz = cmp::min(data_len, sz);
2100 match String::from_utf8(data[..sz as usize].to_vec()) {
2102 Err(_) => return Err(DecodeError::BadText),
2109 impl<W: ::std::io::Write> Writeable<W> for UnsignedNodeAnnouncement {
2110 fn write(&self, w: &mut Writer<W>) -> Result<(), DecodeError> {
2111 self.features.write(w)?;
2112 self.timestamp.write(w)?;
2113 self.node_id.write(w)?;
2114 w.write_all(&self.rgb)?;
2115 self.alias.write(w)?;
2117 let mut addr_slice = Vec::with_capacity(self.addresses.len() * 18);
2118 let mut addrs_to_encode = self.addresses.clone();
2119 addrs_to_encode.sort_unstable_by(|a, b| { a.get_id().cmp(&b.get_id()) });
2120 addrs_to_encode.dedup_by(|a, b| { a.get_id() == b.get_id() });
2121 for addr in addrs_to_encode.iter() {
2123 &NetAddress::IPv4{addr, port} => {
2125 addr_slice.extend_from_slice(&addr);
2126 addr_slice.extend_from_slice(&byte_utils::be16_to_array(port));
2128 &NetAddress::IPv6{addr, port} => {
2130 addr_slice.extend_from_slice(&addr);
2131 addr_slice.extend_from_slice(&byte_utils::be16_to_array(port));
2133 &NetAddress::OnionV2{addr, port} => {
2135 addr_slice.extend_from_slice(&addr);
2136 addr_slice.extend_from_slice(&byte_utils::be16_to_array(port));
2138 &NetAddress::OnionV3{ed25519_pubkey, checksum, version, port} => {
2140 addr_slice.extend_from_slice(&ed25519_pubkey);
2141 addr_slice.extend_from_slice(&byte_utils::be16_to_array(checksum));
2142 addr_slice.push(version);
2143 addr_slice.extend_from_slice(&byte_utils::be16_to_array(port));
2147 ((addr_slice.len() + self.excess_address_data.len()) as u16).write(w)?;
2148 w.write_all(&addr_slice[..])?;
2149 w.write_all(&self.excess_address_data[..])?;
2150 w.write_all(&self.excess_data[..])?;
2155 impl<R: ::std::io::Read> Readable<R> for UnsignedNodeAnnouncement {
2156 fn read(r: &mut Reader<R>) -> Result<Self, DecodeError> {
2157 let features: GlobalFeatures = Readable::read(r)?;
2158 if features.requires_unknown_bits() {
2159 return Err(DecodeError::UnknownRequiredFeature);
2161 let timestamp: u32 = Readable::read(r)?;
2162 let node_id: PublicKey = Readable::read(r)?;
2163 let mut rgb = [0; 3];
2164 r.read_exact(&mut rgb)?;
2165 let alias: [u8; 32] = Readable::read(r)?;
2167 let addrlen: u16 = Readable::read(r)?;
2168 let mut addr_readpos = 0;
2169 let mut addresses = Vec::with_capacity(4);
2173 if addrlen <= addr_readpos { break; }
2174 f = Readable::read(r)?;
2177 if addresses.len() > 0 {
2178 return Err(DecodeError::ExtraAddressesPerType);
2180 if addrlen < addr_readpos + 1 + 6 {
2181 return Err(DecodeError::BadLengthDescriptor);
2183 addresses.push(NetAddress::IPv4 {
2185 let mut addr = [0; 4];
2186 r.read_exact(&mut addr)?;
2189 port: Readable::read(r)?,
2191 addr_readpos += 1 + 6
2194 if addresses.len() > 1 || (addresses.len() == 1 && addresses[0].get_id() != 1) {
2195 return Err(DecodeError::ExtraAddressesPerType);
2197 if addrlen < addr_readpos + 1 + 18 {
2198 return Err(DecodeError::BadLengthDescriptor);
2200 addresses.push(NetAddress::IPv6 {
2202 let mut addr = [0; 16];
2203 r.read_exact(&mut addr)?;
2206 port: Readable::read(r)?,
2208 addr_readpos += 1 + 18
2211 if addresses.len() > 2 || (addresses.len() > 0 && addresses.last().unwrap().get_id() > 2) {
2212 return Err(DecodeError::ExtraAddressesPerType);
2214 if addrlen < addr_readpos + 1 + 12 {
2215 return Err(DecodeError::BadLengthDescriptor);
2217 addresses.push(NetAddress::OnionV2 {
2219 let mut addr = [0; 10];
2220 r.read_exact(&mut addr)?;
2223 port: Readable::read(r)?,
2225 addr_readpos += 1 + 12
2228 if addresses.len() > 3 || (addresses.len() > 0 && addresses.last().unwrap().get_id() > 3) {
2229 return Err(DecodeError::ExtraAddressesPerType);
2231 if addrlen < addr_readpos + 1 + 37 {
2232 return Err(DecodeError::BadLengthDescriptor);
2234 addresses.push(NetAddress::OnionV3 {
2235 ed25519_pubkey: Readable::read(r)?,
2236 checksum: Readable::read(r)?,
2237 version: Readable::read(r)?,
2238 port: Readable::read(r)?,
2240 addr_readpos += 1 + 37
2242 _ => { excess = 1; break; }
2246 let mut excess_data = vec![];
2247 let excess_address_data = if addr_readpos < addrlen {
2248 let mut excess_address_data = vec![0; (addrlen - addr_readpos) as usize];
2249 r.read_exact(&mut excess_address_data[excess..])?;
2251 excess_address_data[0] = f;
2256 excess_data.push(f);
2261 Ok(UnsignedNodeAnnouncement {
2263 timestamp: timestamp,
2267 addresses: addresses,
2268 excess_address_data: excess_address_data,
2270 r.read_to_end(&mut excess_data)?;
2277 impl_writeable!(NodeAnnouncement, {
2285 use ln::msgs::MsgEncodable;
2287 use secp256k1::key::{PublicKey,SecretKey};
2288 use secp256k1::Secp256k1;
2291 fn encoding_channel_reestablish_no_secret() {
2292 let cr = msgs::ChannelReestablish {
2293 channel_id: [4, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0],
2294 next_local_commitment_number: 3,
2295 next_remote_commitment_number: 4,
2296 data_loss_protect: None,
2299 let encoded_value = cr.encode();
2302 vec![4, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 4]
2307 fn encoding_channel_reestablish_with_secret() {
2309 let secp_ctx = Secp256k1::new();
2310 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2313 let cr = msgs::ChannelReestablish {
2314 channel_id: [4, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0],
2315 next_local_commitment_number: 3,
2316 next_remote_commitment_number: 4,
2317 data_loss_protect: Some(msgs::DataLossProtect { your_last_per_commitment_secret: [9;32], my_current_per_commitment_point: public_key}),
2320 let encoded_value = cr.encode();
2323 vec![4, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 4, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 3, 27, 132, 197, 86, 123, 18, 100, 64, 153, 93, 62, 213, 170, 186, 5, 101, 215, 30, 24, 52, 96, 72, 25, 255, 156, 23, 245, 233, 213, 221, 7, 143]