- }
- res.extend_from_slice(&byte_utils::be16_to_array(addr_slice.len() as u16));
- res.extend_from_slice(&addr_slice[..]);
- res
- }
-}
-
-impl MsgDecodable for NodeAnnouncement {
- fn decode(v: &[u8]) -> Result<Self, DecodeError> {
- if v.len() < 64 {
- return Err(DecodeError::ShortRead);
- }
- let secp_ctx = Secp256k1::without_caps();
- Ok(Self {
- signature: secp_signature!(&secp_ctx, &v[0..64]),
- contents: UnsignedNodeAnnouncement::decode(&v[64..])?,
- })
- }
-}
-impl MsgEncodable for NodeAnnouncement {
- fn encode(&self) -> Vec<u8> {
- let contents = self.contents.encode();
- let mut res = Vec::with_capacity(64 + contents.len());
- let secp_ctx = Secp256k1::without_caps();
- res.extend_from_slice(&self.signature.serialize_compact(&secp_ctx));
- res.extend_from_slice(&contents);
- res
- }
-}
-
-impl MsgDecodable for UnsignedChannelAnnouncement {
- fn decode(v: &[u8]) -> Result<Self, DecodeError> {
- let features = GlobalFeatures::decode(&v[..])?;
- if v.len() < features.encoded_len() + 32 + 8 + 33*4 {
- return Err(DecodeError::ShortRead);
- }
- let start = features.encoded_len();
- let secp_ctx = Secp256k1::without_caps();
- Ok(Self {
- features,
- chain_hash: deserialize(&v[start..start + 32]).unwrap(),
- short_channel_id: byte_utils::slice_to_be64(&v[start + 32..start + 40]),
- node_id_1: secp_pubkey!(&secp_ctx, &v[start + 40..start + 73]),
- node_id_2: secp_pubkey!(&secp_ctx, &v[start + 73..start + 106]),
- bitcoin_key_1: secp_pubkey!(&secp_ctx, &v[start + 106..start + 139]),
- bitcoin_key_2: secp_pubkey!(&secp_ctx, &v[start + 139..start + 172]),
- })
- }
-}
-impl MsgEncodable for UnsignedChannelAnnouncement {
- fn encode(&self) -> Vec<u8> {
- let features = self.features.encode();
- let mut res = Vec::with_capacity(172 + features.len());
- res.extend_from_slice(&features[..]);
- res.extend_from_slice(&self.chain_hash[..]);
- res.extend_from_slice(&byte_utils::be64_to_array(self.short_channel_id));
- res.extend_from_slice(&self.node_id_1.serialize());
- res.extend_from_slice(&self.node_id_2.serialize());
- res.extend_from_slice(&self.bitcoin_key_1.serialize());
- res.extend_from_slice(&self.bitcoin_key_2.serialize());
- res
- }
-}
-
-impl MsgDecodable for ChannelAnnouncement {
- fn decode(v: &[u8]) -> Result<Self, DecodeError> {
- if v.len() < 64*4 {
- return Err(DecodeError::ShortRead);
- }
- let secp_ctx = Secp256k1::without_caps();
- Ok(Self {
- node_signature_1: secp_signature!(&secp_ctx, &v[0..64]),
- node_signature_2: secp_signature!(&secp_ctx, &v[64..128]),
- bitcoin_signature_1: secp_signature!(&secp_ctx, &v[128..192]),
- bitcoin_signature_2: secp_signature!(&secp_ctx, &v[192..256]),
- contents: UnsignedChannelAnnouncement::decode(&v[256..])?,
- })
- }
-}
-impl MsgEncodable for ChannelAnnouncement {
- fn encode(&self) -> Vec<u8> {
- let secp_ctx = Secp256k1::without_caps();
- let contents = self.contents.encode();
- let mut res = Vec::with_capacity(64 + contents.len());
- res.extend_from_slice(&self.node_signature_1.serialize_compact(&secp_ctx));
- res.extend_from_slice(&self.node_signature_2.serialize_compact(&secp_ctx));
- res.extend_from_slice(&self.bitcoin_signature_1.serialize_compact(&secp_ctx));
- res.extend_from_slice(&self.bitcoin_signature_2.serialize_compact(&secp_ctx));
- res.extend_from_slice(&contents);
- res
- }
-}
-
-impl MsgDecodable for UnsignedChannelUpdate {
- fn decode(v: &[u8]) -> Result<Self, DecodeError> {
- if v.len() < 32+8+4+2+2+8+4+4 {
- return Err(DecodeError::ShortRead);
- }
- Ok(Self {
- chain_hash: deserialize(&v[0..32]).unwrap(),
- short_channel_id: byte_utils::slice_to_be64(&v[32..40]),
- timestamp: byte_utils::slice_to_be32(&v[40..44]),
- flags: byte_utils::slice_to_be16(&v[44..46]),
- cltv_expiry_delta: byte_utils::slice_to_be16(&v[46..48]),
- htlc_minimum_msat: byte_utils::slice_to_be64(&v[48..56]),
- fee_base_msat: byte_utils::slice_to_be32(&v[56..60]),
- fee_proportional_millionths: byte_utils::slice_to_be32(&v[60..64]),
- })
- }
-}
-impl MsgEncodable for UnsignedChannelUpdate {
- fn encode(&self) -> Vec<u8> {
- let mut res = Vec::with_capacity(64);
- res.extend_from_slice(&self.chain_hash[..]);
- res.extend_from_slice(&byte_utils::be64_to_array(self.short_channel_id));
- res.extend_from_slice(&byte_utils::be32_to_array(self.timestamp));
- res.extend_from_slice(&byte_utils::be16_to_array(self.flags));
- res.extend_from_slice(&byte_utils::be16_to_array(self.cltv_expiry_delta));
- res.extend_from_slice(&byte_utils::be64_to_array(self.htlc_minimum_msat));
- res.extend_from_slice(&byte_utils::be32_to_array(self.fee_base_msat));
- res.extend_from_slice(&byte_utils::be32_to_array(self.fee_proportional_millionths));
- res
- }
-}
-
-impl MsgDecodable for ChannelUpdate {
- fn decode(v: &[u8]) -> Result<Self, DecodeError> {
- if v.len() < 128 {
- return Err(DecodeError::ShortRead);
- }
- let secp_ctx = Secp256k1::without_caps();
- Ok(Self {
- signature: secp_signature!(&secp_ctx, &v[0..64]),
- contents: UnsignedChannelUpdate::decode(&v[64..])?,
- })
- }
-}
-impl MsgEncodable for ChannelUpdate {
- fn encode(&self) -> Vec<u8> {
- let mut res = Vec::with_capacity(128);
- res.extend_from_slice(&self.signature.serialize_compact(&Secp256k1::without_caps())[..]);
- res.extend_from_slice(&self.contents.encode()[..]);
- res
- }
-}
-
-impl MsgDecodable for OnionRealm0HopData {
- fn decode(v: &[u8]) -> Result<Self, DecodeError> {
- if v.len() < 32 {
- return Err(DecodeError::ShortRead);
- }
- Ok(OnionRealm0HopData {
- short_channel_id: byte_utils::slice_to_be64(&v[0..8]),
- amt_to_forward: byte_utils::slice_to_be64(&v[8..16]),
- outgoing_cltv_value: byte_utils::slice_to_be32(&v[16..20]),
- })
- }
-}
-impl MsgEncodable for OnionRealm0HopData {
- fn encode(&self) -> Vec<u8> {
- let mut res = Vec::with_capacity(32);
- res.extend_from_slice(&byte_utils::be64_to_array(self.short_channel_id));
- res.extend_from_slice(&byte_utils::be64_to_array(self.amt_to_forward));
- res.extend_from_slice(&byte_utils::be32_to_array(self.outgoing_cltv_value));
- res.resize(32, 0);
- res
- }
-}
-
-impl MsgDecodable for OnionHopData {
- fn decode(v: &[u8]) -> Result<Self, DecodeError> {
- if v.len() < 65 {
- return Err(DecodeError::ShortRead);
- }
- let realm = v[0];
- if realm != 0 {
- return Err(DecodeError::UnknownRealmByte);
- }
- let mut hmac = [0; 32];
- hmac[..].copy_from_slice(&v[33..65]);
- Ok(OnionHopData {
- realm: realm,
- data: OnionRealm0HopData::decode(&v[1..33])?,
- hmac: hmac,
- })
- }
-}
-impl MsgEncodable for OnionHopData {
- fn encode(&self) -> Vec<u8> {
- let mut res = Vec::with_capacity(65);
- res.push(self.realm);
- res.extend_from_slice(&self.data.encode()[..]);
- res.extend_from_slice(&self.hmac);
- res
- }
-}
-
-impl MsgDecodable for OnionPacket {
- fn decode(v: &[u8]) -> Result<Self, DecodeError> {
- if v.len() < 1+33+20*65+32 {
- return Err(DecodeError::ShortRead);
- }
- let mut hop_data = [0; 20*65];
- hop_data.copy_from_slice(&v[34..1334]);
- let mut hmac = [0; 32];
- hmac.copy_from_slice(&v[1334..1366]);
- let secp_ctx = Secp256k1::without_caps();
- Ok(Self {
- version: v[0],
- public_key: secp_pubkey!(&secp_ctx, &v[1..34]),
- hop_data,
- hmac,
- })
- }
-}
-impl MsgEncodable for OnionPacket {
- fn encode(&self) -> Vec<u8> {
- let mut res = Vec::with_capacity(1 + 33 + 20*65 + 32);
- res.push(self.version);
- res.extend_from_slice(&self.public_key.serialize());
- res.extend_from_slice(&self.hop_data);
- res.extend_from_slice(&self.hmac);
- res
- }
-}
-
-impl MsgDecodable for DecodedOnionErrorPacket {
- fn decode(v: &[u8]) -> Result<Self, DecodeError> {
- if v.len() < 32 + 4 {
- return Err(DecodeError::ShortRead);
- }
- let failuremsg_len = byte_utils::slice_to_be16(&v[32..34]) as usize;
- if v.len() < 32 + 4 + failuremsg_len {
- return Err(DecodeError::ShortRead);
- }
- let padding_len = byte_utils::slice_to_be16(&v[34 + failuremsg_len..]) as usize;
- if v.len() < 32 + 4 + failuremsg_len + padding_len {
- return Err(DecodeError::ShortRead);
- }
-
- let mut hmac = [0; 32];
- hmac.copy_from_slice(&v[0..32]);
- Ok(Self {
- hmac,
- failuremsg: v[34..34 + failuremsg_len].to_vec(),
- pad: v[36 + failuremsg_len..36 + failuremsg_len + padding_len].to_vec(),
- })
- }
-}
-impl MsgEncodable for DecodedOnionErrorPacket {
- fn encode(&self) -> Vec<u8> {
- let mut res = Vec::with_capacity(32 + 4 + self.failuremsg.len() + self.pad.len());
- res.extend_from_slice(&self.hmac);
- res.extend_from_slice(&[((self.failuremsg.len() >> 8) & 0xff) as u8, (self.failuremsg.len() & 0xff) as u8]);
- res.extend_from_slice(&self.failuremsg);
- res.extend_from_slice(&[((self.pad.len() >> 8) & 0xff) as u8, (self.pad.len() & 0xff) as u8]);
- res.extend_from_slice(&self.pad);
- res
- }
-}