use secp256k1::key::PublicKey;
use secp256k1::{Secp256k1, Signature};
-use bitcoin::util::uint::Uint256;
use bitcoin::util::hash::Sha256dHash;
use bitcoin::network::serialize::{deserialize,serialize};
use bitcoin::blockdata::script::Script;
use std::error::Error;
-use std::fmt;
+use std::{cmp, fmt};
use std::result::Result;
use util::{byte_utils, internal_traits, events};
fn encode(&self) -> Vec<u8>;
#[inline]
fn encoded_len(&self) -> usize { self.encode().len() }
+ #[inline]
+ fn encode_with_len(&self) -> Vec<u8> {
+ let enc = self.encode();
+ let mut res = Vec::with_capacity(enc.len() + 2);
+ res.extend_from_slice(&byte_utils::be16_to_array(enc.len() as u16));
+ res.extend_from_slice(&enc);
+ res
+ }
}
#[derive(Debug)]
pub enum DecodeError {
BadPublicKey,
/// Failed to decode a signature (ie it's invalid)
BadSignature,
- /// Buffer not of right length (either too short or too long)
- WrongLength,
+ /// Value expected to be text wasn't decodable as text
+ BadText,
+ /// Buffer too short
+ ShortRead,
/// node_announcement included more than one address of a given type!
ExtraAddressesPerType,
+ /// A length descriptor in the packet didn't describe the later data correctly
+ /// (currently only generated in node_announcement)
+ BadLengthDescriptor,
}
pub trait MsgDecodable: Sized {
fn decode(v: &[u8]) -> Result<Self, DecodeError>;
self.flags.len() > 0 && (self.flags[0] & 1) != 0
}
- pub fn supports_initial_routing_sync(&self) -> bool {
+ pub fn initial_routing_sync(&self) -> bool {
self.flags.len() > 0 && (self.flags[0] & (1 << 3)) != 0
}
+ pub fn set_initial_routing_sync(&mut self) {
+ if self.flags.len() == 0 {
+ self.flags.resize(1, 1 << 3);
+ } else {
+ self.flags[0] |= 1 << 3;
+ }
+ }
pub fn supports_upfront_shutdown_script(&self) -> bool {
self.flags.len() > 0 && (self.flags[0] & (3 << 4)) != 0
pub local_features: LocalFeatures,
}
+pub struct ErrorMessage {
+ pub channel_id: [u8; 32],
+ pub data: String,
+}
+
+pub struct Ping {
+ pub ponglen: u16,
+ pub byteslen: u16,
+}
+
+pub struct Pong {
+ pub byteslen: u16,
+}
+
pub struct OpenChannel {
pub chain_hash: Sha256dHash,
- pub temporary_channel_id: Uint256,
+ pub temporary_channel_id: [u8; 32],
pub funding_satoshis: u64,
pub push_msat: u64,
pub dust_limit_satoshis: u64,
}
pub struct AcceptChannel {
- pub temporary_channel_id: Uint256,
+ pub temporary_channel_id: [u8; 32],
pub dust_limit_satoshis: u64,
pub max_htlc_value_in_flight_msat: u64,
pub channel_reserve_satoshis: u64,
}
pub struct FundingCreated {
- pub temporary_channel_id: Uint256,
+ pub temporary_channel_id: [u8; 32],
pub funding_txid: Sha256dHash,
pub funding_output_index: u16,
pub signature: Signature,
}
pub struct FundingSigned {
- pub channel_id: Uint256,
+ pub channel_id: [u8; 32],
pub signature: Signature,
}
pub struct FundingLocked {
- pub channel_id: Uint256,
+ pub channel_id: [u8; 32],
pub next_per_commitment_point: PublicKey,
}
pub struct Shutdown {
- pub channel_id: Uint256,
+ pub channel_id: [u8; 32],
pub scriptpubkey: Script,
}
pub struct ClosingSigned {
- pub channel_id: Uint256,
+ pub channel_id: [u8; 32],
pub fee_satoshis: u64,
pub signature: Signature,
}
#[derive(Clone)]
pub struct UpdateAddHTLC {
- pub channel_id: Uint256,
+ pub channel_id: [u8; 32],
pub htlc_id: u64,
pub amount_msat: u64,
pub payment_hash: [u8; 32],
#[derive(Clone)]
pub struct UpdateFulfillHTLC {
- pub channel_id: Uint256,
+ pub channel_id: [u8; 32],
pub htlc_id: u64,
pub payment_preimage: [u8; 32],
}
#[derive(Clone)]
pub struct UpdateFailHTLC {
- pub channel_id: Uint256,
+ pub channel_id: [u8; 32],
pub htlc_id: u64,
pub reason: OnionErrorPacket,
}
#[derive(Clone)]
pub struct UpdateFailMalformedHTLC {
- pub channel_id: Uint256,
+ pub channel_id: [u8; 32],
pub htlc_id: u64,
pub sha256_of_onion: [u8; 32],
pub failure_code: u16,
#[derive(Clone)]
pub struct CommitmentSigned {
- pub channel_id: Uint256,
+ pub channel_id: [u8; 32],
pub signature: Signature,
pub htlc_signatures: Vec<Signature>,
}
pub struct RevokeAndACK {
- pub channel_id: Uint256,
+ pub channel_id: [u8; 32],
pub per_commitment_secret: [u8; 32],
pub next_per_commitment_point: PublicKey,
}
pub struct UpdateFee {
- pub channel_id: Uint256,
+ pub channel_id: [u8; 32],
pub feerate_per_kw: u32,
}
pub struct ChannelReestablish {
- pub channel_id: Uint256,
+ pub channel_id: [u8; 32],
pub next_local_commitment_number: u64,
pub next_remote_commitment_number: u64,
pub your_last_per_commitment_secret: Option<[u8; 32]>,
#[derive(Clone)]
pub struct AnnouncementSignatures {
- pub channel_id: Uint256,
+ pub channel_id: [u8; 32],
pub short_channel_id: u64,
pub node_signature: Signature,
pub bitcoin_signature: Signature,
/// Used to put an error message in a HandleError
pub enum ErrorAction {
- UpdateFailHTLC {
- msg: UpdateFailHTLC
+ /// The peer took some action which made us think they were useless. Disconnect them.
+ DisconnectPeer {
+ msg: Option<ErrorMessage>
+ },
+ /// The peer did something harmless that we weren't able to process, just log and ignore
+ IgnoreError,
+ /// The peer did something incorrect. Tell them.
+ SendErrorMessage {
+ msg: ErrorMessage
},
- DisconnectPeer {},
}
pub struct HandleError { //TODO: rename me
pub err: &'static str,
- pub msg: Option<ErrorAction>, //TODO: Make this required and rename it
+ pub action: Option<ErrorAction>, //TODO: Make this required
+}
+
+/// Struct used to return values from revoke_and_ack messages, containing a bunch of commitment
+/// transaction updates if they were pending.
+pub struct CommitmentUpdate {
+ pub update_add_htlcs: Vec<UpdateAddHTLC>,
+ pub update_fulfill_htlcs: Vec<UpdateFulfillHTLC>,
+ pub update_fail_htlcs: Vec<UpdateFailHTLC>,
+ pub commitment_signed: CommitmentSigned,
+}
+
+pub enum HTLCFailChannelUpdate {
+ ChannelUpdateMessage {
+ msg: ChannelUpdate,
+ },
+ ChannelClosed {
+ short_channel_id: u64,
+ },
}
/// A trait to describe an object which can receive channel messages. Messages MAY be called in
/// paralell when they originate from different their_node_ids, however they MUST NOT be called in
/// paralell when the two calls have the same their_node_id.
-pub trait ChannelMessageHandler : events::EventsProvider {
+pub trait ChannelMessageHandler : events::EventsProvider + Send + Sync {
//Channel init:
fn handle_open_channel(&self, their_node_id: &PublicKey, msg: &OpenChannel) -> Result<AcceptChannel, HandleError>;
fn handle_accept_channel(&self, their_node_id: &PublicKey, msg: &AcceptChannel) -> Result<(), HandleError>;
// HTLC handling:
fn handle_update_add_htlc(&self, their_node_id: &PublicKey, msg: &UpdateAddHTLC) -> Result<(), HandleError>;
fn handle_update_fulfill_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFulfillHTLC) -> Result<(), HandleError>;
- fn handle_update_fail_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailHTLC) -> Result<(), HandleError>;
+ fn handle_update_fail_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailHTLC) -> Result<Option<HTLCFailChannelUpdate>, HandleError>;
fn handle_update_fail_malformed_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailMalformedHTLC) -> Result<(), HandleError>;
- fn handle_commitment_signed(&self, their_node_id: &PublicKey, msg: &CommitmentSigned) -> Result<RevokeAndACK, HandleError>;
- fn handle_revoke_and_ack(&self, their_node_id: &PublicKey, msg: &RevokeAndACK) -> Result<Option<(Vec<UpdateAddHTLC>, CommitmentSigned)>, HandleError>;
+ fn handle_commitment_signed(&self, their_node_id: &PublicKey, msg: &CommitmentSigned) -> Result<(RevokeAndACK, Option<CommitmentSigned>), HandleError>;
+ fn handle_revoke_and_ack(&self, their_node_id: &PublicKey, msg: &RevokeAndACK) -> Result<Option<CommitmentUpdate>, HandleError>;
fn handle_update_fee(&self, their_node_id: &PublicKey, msg: &UpdateFee) -> Result<(), HandleError>;
// Channel-to-announce:
fn handle_announcement_signatures(&self, their_node_id: &PublicKey, msg: &AnnouncementSignatures) -> Result<(), HandleError>;
- // Informational:
+ // Error conditions:
/// Indicates a connection to the peer failed/an existing connection was lost. If no connection
/// is believed to be possible in the future (eg they're sending us messages we don't
/// understand or indicate they require unknown feature bits), no_connection_possible is set
/// and any outstanding channels should be failed.
fn peer_disconnected(&self, their_node_id: &PublicKey, no_connection_possible: bool);
+
+ fn handle_error(&self, their_node_id: &PublicKey, msg: &ErrorMessage);
}
-pub trait RoutingMessageHandler {
+pub trait RoutingMessageHandler : Send + Sync {
fn handle_node_announcement(&self, msg: &NodeAnnouncement) -> Result<(), HandleError>;
/// Handle a channel_announcement message, returning true if it should be forwarded on, false
/// or returning an Err otherwise.
fn handle_channel_announcement(&self, msg: &ChannelAnnouncement) -> Result<bool, HandleError>;
fn handle_channel_update(&self, msg: &ChannelUpdate) -> Result<(), HandleError>;
+ fn handle_htlc_fail_channel_update(&self, update: &HTLCFailChannelUpdate);
}
pub struct OnionRealm0HopData {
DecodeError::UnknownRealmByte => "Unknown realm byte in Onion packet",
DecodeError::BadPublicKey => "Invalid public key in packet",
DecodeError::BadSignature => "Invalid signature in packet",
- DecodeError::WrongLength => "Data was wrong length for packet",
+ DecodeError::BadText => "Invalid text in packet",
+ DecodeError::ShortRead => "Packet extended beyond the provided bytes",
DecodeError::ExtraAddressesPerType => "More than one address of a single type",
+ DecodeError::BadLengthDescriptor => "A length descriptor in the packet didn't describe the later data correctly",
}
}
}
impl MsgDecodable for LocalFeatures {
fn decode(v: &[u8]) -> Result<Self, DecodeError> {
- if v.len() < 3 { return Err(DecodeError::WrongLength); }
+ if v.len() < 2 { return Err(DecodeError::ShortRead); }
let len = byte_utils::slice_to_be16(&v[0..2]) as usize;
- if v.len() < len + 2 { return Err(DecodeError::WrongLength); }
+ if v.len() < len + 2 { return Err(DecodeError::ShortRead); }
let mut flags = Vec::with_capacity(len);
flags.extend_from_slice(&v[2..2 + len]);
Ok(Self {
impl MsgDecodable for GlobalFeatures {
fn decode(v: &[u8]) -> Result<Self, DecodeError> {
- if v.len() < 3 { return Err(DecodeError::WrongLength); }
+ if v.len() < 2 { return Err(DecodeError::ShortRead); }
let len = byte_utils::slice_to_be16(&v[0..2]) as usize;
- if v.len() < len + 2 { return Err(DecodeError::WrongLength); }
+ if v.len() < len + 2 { return Err(DecodeError::ShortRead); }
let mut flags = Vec::with_capacity(len);
flags.extend_from_slice(&v[2..2 + len]);
Ok(Self {
fn decode(v: &[u8]) -> Result<Self, DecodeError> {
let global_features = GlobalFeatures::decode(v)?;
if v.len() < global_features.flags.len() + 4 {
- return Err(DecodeError::WrongLength);
+ return Err(DecodeError::ShortRead);
}
let local_features = LocalFeatures::decode(&v[global_features.flags.len() + 2..])?;
Ok(Self {
}
}
+impl MsgDecodable for Ping {
+ fn decode(v: &[u8]) -> Result<Self, DecodeError> {
+ if v.len() < 4 {
+ return Err(DecodeError::ShortRead);
+ }
+ let ponglen = byte_utils::slice_to_be16(&v[0..2]);
+ let byteslen = byte_utils::slice_to_be16(&v[2..4]);
+ if v.len() < 4 + byteslen as usize {
+ return Err(DecodeError::ShortRead);
+ }
+ Ok(Self {
+ ponglen,
+ byteslen,
+ })
+ }
+}
+impl MsgEncodable for Ping {
+ fn encode(&self) -> Vec<u8> {
+ let mut res = Vec::with_capacity(self.byteslen as usize + 2);
+ res.extend_from_slice(&byte_utils::be16_to_array(self.byteslen));
+ res.resize(2 + self.byteslen as usize, 0);
+ res
+ }
+}
+
+impl MsgDecodable for Pong {
+ fn decode(v: &[u8]) -> Result<Self, DecodeError> {
+ if v.len() < 2 {
+ return Err(DecodeError::ShortRead);
+ }
+ let byteslen = byte_utils::slice_to_be16(&v[0..2]);
+ if v.len() < 2 + byteslen as usize {
+ return Err(DecodeError::ShortRead);
+ }
+ Ok(Self {
+ byteslen
+ })
+ }
+}
+impl MsgEncodable for Pong {
+ fn encode(&self) -> Vec<u8> {
+ let mut res = Vec::with_capacity(self.byteslen as usize + 2);
+ res.extend_from_slice(&byte_utils::be16_to_array(self.byteslen));
+ res.resize(2 + self.byteslen as usize, 0);
+ res
+ }
+}
+
impl MsgDecodable for OpenChannel {
fn decode(v: &[u8]) -> Result<Self, DecodeError> {
if v.len() < 2*32+6*8+4+2*2+6*33+1 {
- return Err(DecodeError::WrongLength);
+ return Err(DecodeError::ShortRead);
}
let ctx = Secp256k1::without_caps();
if v.len() >= 321 {
let len = byte_utils::slice_to_be16(&v[319..321]) as usize;
if v.len() < 321+len {
- return Err(DecodeError::WrongLength);
+ return Err(DecodeError::ShortRead);
}
shutdown_scriptpubkey = Some(Script::from(v[321..321+len].to_vec()));
- } else if v.len() != 2*32+6*8+4+2*2+6*33+1 { // Message cant have 1 extra byte
- return Err(DecodeError::WrongLength);
}
Ok(OpenChannel {
}
impl MsgEncodable for OpenChannel {
fn encode(&self) -> Vec<u8> {
- unimplemented!();
+ let mut res = match &self.shutdown_scriptpubkey {
+ &Some(ref script) => Vec::with_capacity(319 + 2 + script.len()),
+ &None => Vec::with_capacity(319),
+ };
+ res.extend_from_slice(&serialize(&self.chain_hash).unwrap());
+ res.extend_from_slice(&serialize(&self.temporary_channel_id).unwrap());
+ res.extend_from_slice(&byte_utils::be64_to_array(self.funding_satoshis));
+ res.extend_from_slice(&byte_utils::be64_to_array(self.push_msat));
+ res.extend_from_slice(&byte_utils::be64_to_array(self.dust_limit_satoshis));
+ res.extend_from_slice(&byte_utils::be64_to_array(self.max_htlc_value_in_flight_msat));
+ res.extend_from_slice(&byte_utils::be64_to_array(self.channel_reserve_satoshis));
+ res.extend_from_slice(&byte_utils::be64_to_array(self.htlc_minimum_msat));
+ res.extend_from_slice(&byte_utils::be32_to_array(self.feerate_per_kw));
+ res.extend_from_slice(&byte_utils::be16_to_array(self.to_self_delay));
+ res.extend_from_slice(&byte_utils::be16_to_array(self.max_accepted_htlcs));
+ res.extend_from_slice(&self.funding_pubkey.serialize());
+ res.extend_from_slice(&self.revocation_basepoint.serialize());
+ res.extend_from_slice(&self.payment_basepoint.serialize());
+ res.extend_from_slice(&self.delayed_payment_basepoint.serialize());
+ res.extend_from_slice(&self.htlc_basepoint.serialize());
+ res.extend_from_slice(&self.first_per_commitment_point.serialize());
+ res.push(self.channel_flags);
+ if let &Some(ref script) = &self.shutdown_scriptpubkey {
+ res.extend_from_slice(&byte_utils::be16_to_array(script.len() as u16));
+ res.extend_from_slice(&script[..]);
+ }
+ res
}
}
impl MsgDecodable for AcceptChannel {
fn decode(v: &[u8]) -> Result<Self, DecodeError> {
if v.len() < 32+4*8+4+2*2+6*33 {
- return Err(DecodeError::WrongLength);
+ return Err(DecodeError::ShortRead);
}
let ctx = Secp256k1::without_caps();
if v.len() >= 272 {
let len = byte_utils::slice_to_be16(&v[270..272]) as usize;
if v.len() < 272+len {
- return Err(DecodeError::WrongLength);
+ return Err(DecodeError::ShortRead);
}
shutdown_scriptpubkey = Some(Script::from(v[272..272+len].to_vec()));
- } else if v.len() != 32+4*8+4+2*2+6*33 { // Message cant have 1 extra byte
- return Err(DecodeError::WrongLength);
}
+ let mut temporary_channel_id = [0; 32];
+ temporary_channel_id[..].copy_from_slice(&v[0..32]);
Ok(Self {
- temporary_channel_id: deserialize(&v[0..32]).unwrap(),
+ temporary_channel_id,
dust_limit_satoshis: byte_utils::slice_to_be64(&v[32..40]),
max_htlc_value_in_flight_msat: byte_utils::slice_to_be64(&v[40..48]),
channel_reserve_satoshis: byte_utils::slice_to_be64(&v[48..56]),
&Some(ref script) => Vec::with_capacity(270 + 2 + script.len()),
&None => Vec::with_capacity(270),
};
- res.extend_from_slice(&serialize(&self.temporary_channel_id).unwrap()[..]);
+ res.extend_from_slice(&self.temporary_channel_id);
res.extend_from_slice(&byte_utils::be64_to_array(self.dust_limit_satoshis));
res.extend_from_slice(&byte_utils::be64_to_array(self.max_htlc_value_in_flight_msat));
res.extend_from_slice(&byte_utils::be64_to_array(self.channel_reserve_satoshis));
impl MsgDecodable for FundingCreated {
fn decode(v: &[u8]) -> Result<Self, DecodeError> {
if v.len() < 32+32+2+64 {
- return Err(DecodeError::WrongLength);
+ return Err(DecodeError::ShortRead);
}
let ctx = Secp256k1::without_caps();
+ let mut temporary_channel_id = [0; 32];
+ temporary_channel_id[..].copy_from_slice(&v[0..32]);
Ok(Self {
- temporary_channel_id: deserialize(&v[0..32]).unwrap(),
+ temporary_channel_id,
funding_txid: deserialize(&v[32..64]).unwrap(),
funding_output_index: byte_utils::slice_to_be16(&v[64..66]),
signature: secp_signature!(&ctx, &v[66..130]),
impl MsgEncodable for FundingCreated {
fn encode(&self) -> Vec<u8> {
let mut res = Vec::with_capacity(32+32+2+64);
- res.extend_from_slice(&serialize(&self.temporary_channel_id).unwrap()[..]);
+ res.extend_from_slice(&self.temporary_channel_id);
res.extend_from_slice(&serialize(&self.funding_txid).unwrap()[..]);
res.extend_from_slice(&byte_utils::be16_to_array(self.funding_output_index));
let secp_ctx = Secp256k1::without_caps();
impl MsgDecodable for FundingSigned {
fn decode(v: &[u8]) -> Result<Self, DecodeError> {
if v.len() < 32+64 {
- return Err(DecodeError::WrongLength);
+ return Err(DecodeError::ShortRead);
}
let ctx = Secp256k1::without_caps();
+ let mut channel_id = [0; 32];
+ channel_id[..].copy_from_slice(&v[0..32]);
Ok(Self {
- channel_id: deserialize(&v[0..32]).unwrap(),
+ channel_id,
signature: secp_signature!(&ctx, &v[32..96]),
})
}
}
impl MsgEncodable for FundingSigned {
fn encode(&self) -> Vec<u8> {
- unimplemented!();
+ let mut res = Vec::with_capacity(32+64);
+ res.extend_from_slice(&self.channel_id);
+ res.extend_from_slice(&self.signature.serialize_compact(&Secp256k1::without_caps()));
+ res
}
}
impl MsgDecodable for FundingLocked {
fn decode(v: &[u8]) -> Result<Self, DecodeError> {
if v.len() < 32+33 {
- return Err(DecodeError::WrongLength);
+ return Err(DecodeError::ShortRead);
}
let ctx = Secp256k1::without_caps();
+ let mut channel_id = [0; 32];
+ channel_id[..].copy_from_slice(&v[0..32]);
Ok(Self {
- channel_id: deserialize(&v[0..32]).unwrap(),
+ channel_id,
next_per_commitment_point: secp_pubkey!(&ctx, &v[32..65]),
})
}
impl MsgEncodable for FundingLocked {
fn encode(&self) -> Vec<u8> {
let mut res = Vec::with_capacity(32+33);
- res.extend_from_slice(&serialize(&self.channel_id).unwrap());
+ res.extend_from_slice(&self.channel_id);
res.extend_from_slice(&self.next_per_commitment_point.serialize());
res
}
impl MsgDecodable for Shutdown {
fn decode(v: &[u8]) -> Result<Self, DecodeError> {
if v.len() < 32 + 2 {
- return Err(DecodeError::WrongLength);
+ return Err(DecodeError::ShortRead);
}
let scriptlen = byte_utils::slice_to_be16(&v[32..34]) as usize;
if v.len() < 32 + 2 + scriptlen {
- return Err(DecodeError::WrongLength);
+ return Err(DecodeError::ShortRead);
}
+ let mut channel_id = [0; 32];
+ channel_id[..].copy_from_slice(&v[0..32]);
Ok(Self {
- channel_id: deserialize(&v[0..32]).unwrap(),
+ channel_id,
scriptpubkey: Script::from(v[34..34 + scriptlen].to_vec()),
})
}
}
impl MsgEncodable for Shutdown {
fn encode(&self) -> Vec<u8> {
- unimplemented!();
+ let mut res = Vec::with_capacity(32 + 2 + self.scriptpubkey.len());
+ res.extend_from_slice(&self.channel_id);
+ res.extend_from_slice(&byte_utils::be16_to_array(self.scriptpubkey.len() as u16));
+ res.extend_from_slice(&self.scriptpubkey[..]);
+ res
}
}
impl MsgDecodable for ClosingSigned {
fn decode(v: &[u8]) -> Result<Self, DecodeError> {
if v.len() < 32 + 8 + 64 {
- return Err(DecodeError::WrongLength);
+ return Err(DecodeError::ShortRead);
}
let secp_ctx = Secp256k1::without_caps();
+ let mut channel_id = [0; 32];
+ channel_id[..].copy_from_slice(&v[0..32]);
Ok(Self {
- channel_id: deserialize(&v[0..32]).unwrap(),
+ channel_id,
fee_satoshis: byte_utils::slice_to_be64(&v[32..40]),
signature: secp_signature!(&secp_ctx, &v[40..104]),
})
}
impl MsgEncodable for ClosingSigned {
fn encode(&self) -> Vec<u8> {
- unimplemented!();
+ let mut res = Vec::with_capacity(32+8+64);
+ res.extend_from_slice(&self.channel_id);
+ res.extend_from_slice(&byte_utils::be64_to_array(self.fee_satoshis));
+ let secp_ctx = Secp256k1::without_caps();
+ res.extend_from_slice(&self.signature.serialize_compact(&secp_ctx));
+ res
}
}
impl MsgDecodable for UpdateAddHTLC {
fn decode(v: &[u8]) -> Result<Self, DecodeError> {
if v.len() < 32+8+8+32+4+1+33+20*65+32 {
- return Err(DecodeError::WrongLength);
+ return Err(DecodeError::ShortRead);
}
+ let mut channel_id = [0; 32];
+ channel_id[..].copy_from_slice(&v[0..32]);
let mut payment_hash = [0; 32];
payment_hash.copy_from_slice(&v[48..80]);
Ok(Self{
- channel_id: deserialize(&v[0..32]).unwrap(),
+ channel_id,
htlc_id: byte_utils::slice_to_be64(&v[32..40]),
amount_msat: byte_utils::slice_to_be64(&v[40..48]),
payment_hash,
cltv_expiry: byte_utils::slice_to_be32(&v[80..84]),
- onion_routing_packet: OnionPacket::decode(&v[84..])?,
+ onion_routing_packet: OnionPacket::decode(&v[84..84+1366])?,
})
}
}
impl MsgEncodable for UpdateAddHTLC {
fn encode(&self) -> Vec<u8> {
- unimplemented!();
+ let mut res = Vec::with_capacity(32+8+8+32+4+1366);
+ res.extend_from_slice(&self.channel_id);
+ res.extend_from_slice(&byte_utils::be64_to_array(self.htlc_id));
+ res.extend_from_slice(&byte_utils::be64_to_array(self.amount_msat));
+ res.extend_from_slice(&self.payment_hash);
+ res.extend_from_slice(&byte_utils::be32_to_array(self.cltv_expiry));
+ res.extend_from_slice(&self.onion_routing_packet.encode()[..]);
+ res
}
}
impl MsgDecodable for UpdateFulfillHTLC {
fn decode(v: &[u8]) -> Result<Self, DecodeError> {
if v.len() < 32+8+32 {
- return Err(DecodeError::WrongLength);
+ return Err(DecodeError::ShortRead);
}
+ let mut channel_id = [0; 32];
+ channel_id[..].copy_from_slice(&v[0..32]);
let mut payment_preimage = [0; 32];
payment_preimage.copy_from_slice(&v[40..72]);
Ok(Self{
- channel_id: deserialize(&v[0..32]).unwrap(),
+ channel_id,
htlc_id: byte_utils::slice_to_be64(&v[32..40]),
payment_preimage,
})
}
impl MsgEncodable for UpdateFulfillHTLC {
fn encode(&self) -> Vec<u8> {
- unimplemented!();
+ let mut res = Vec::with_capacity(32+8+32);
+ res.extend_from_slice(&self.channel_id);
+ res.extend_from_slice(&byte_utils::be64_to_array(self.htlc_id));
+ res.extend_from_slice(&self.payment_preimage);
+ res
}
}
impl MsgDecodable for UpdateFailHTLC {
fn decode(v: &[u8]) -> Result<Self, DecodeError> {
if v.len() < 32+8 {
- return Err(DecodeError::WrongLength);
+ return Err(DecodeError::ShortRead);
}
+ let mut channel_id = [0; 32];
+ channel_id[..].copy_from_slice(&v[0..32]);
Ok(Self{
- channel_id: deserialize(&v[0..32]).unwrap(),
+ channel_id,
htlc_id: byte_utils::slice_to_be64(&v[32..40]),
reason: OnionErrorPacket::decode(&v[40..])?,
})
}
impl MsgEncodable for UpdateFailHTLC {
fn encode(&self) -> Vec<u8> {
- unimplemented!();
+ let reason = self.reason.encode();
+ let mut res = Vec::with_capacity(32+8+reason.len());
+ res.extend_from_slice(&self.channel_id);
+ res.extend_from_slice(&byte_utils::be64_to_array(self.htlc_id));
+ res.extend_from_slice(&reason[..]);
+ res
}
}
impl MsgDecodable for UpdateFailMalformedHTLC {
fn decode(v: &[u8]) -> Result<Self, DecodeError> {
if v.len() < 32+8+32+2 {
- return Err(DecodeError::WrongLength);
+ return Err(DecodeError::ShortRead);
}
+ let mut channel_id = [0; 32];
+ channel_id[..].copy_from_slice(&v[0..32]);
let mut sha256_of_onion = [0; 32];
sha256_of_onion.copy_from_slice(&v[40..72]);
Ok(Self{
- channel_id: deserialize(&v[0..32]).unwrap(),
+ channel_id,
htlc_id: byte_utils::slice_to_be64(&v[32..40]),
sha256_of_onion,
failure_code: byte_utils::slice_to_be16(&v[72..74]),
}
impl MsgEncodable for UpdateFailMalformedHTLC {
fn encode(&self) -> Vec<u8> {
- unimplemented!();
+ let mut res = Vec::with_capacity(32+8+32+2);
+ res.extend_from_slice(&self.channel_id);
+ res.extend_from_slice(&byte_utils::be64_to_array(self.htlc_id));
+ res.extend_from_slice(&self.sha256_of_onion);
+ res.extend_from_slice(&byte_utils::be16_to_array(self.failure_code));
+ res
}
}
impl MsgDecodable for CommitmentSigned {
fn decode(v: &[u8]) -> Result<Self, DecodeError> {
if v.len() < 32+64+2 {
- return Err(DecodeError::WrongLength);
+ return Err(DecodeError::ShortRead);
}
+ let mut channel_id = [0; 32];
+ channel_id[..].copy_from_slice(&v[0..32]);
+
let htlcs = byte_utils::slice_to_be16(&v[96..98]) as usize;
if v.len() < 32+64+2+htlcs*64 {
- return Err(DecodeError::WrongLength);
+ return Err(DecodeError::ShortRead);
}
let mut htlc_signatures = Vec::with_capacity(htlcs);
let secp_ctx = Secp256k1::without_caps();
htlc_signatures.push(secp_signature!(&secp_ctx, &v[98+i*64..98+(i+1)*64]));
}
Ok(Self {
- channel_id: deserialize(&v[0..32]).unwrap(),
+ channel_id,
signature: secp_signature!(&secp_ctx, &v[32..96]),
htlc_signatures,
})
}
impl MsgEncodable for CommitmentSigned {
fn encode(&self) -> Vec<u8> {
- unimplemented!();
+ let mut res = Vec::with_capacity(32+64+2+self.htlc_signatures.len()*64);
+ res.extend_from_slice(&self.channel_id);
+ let secp_ctx = Secp256k1::without_caps();
+ res.extend_from_slice(&self.signature.serialize_compact(&secp_ctx));
+ res.extend_from_slice(&byte_utils::be16_to_array(self.htlc_signatures.len() as u16));
+ for i in 0..self.htlc_signatures.len() {
+ res.extend_from_slice(&self.htlc_signatures[i].serialize_compact(&secp_ctx));
+ }
+ res
}
}
impl MsgDecodable for RevokeAndACK {
fn decode(v: &[u8]) -> Result<Self, DecodeError> {
if v.len() < 32+32+33 {
- return Err(DecodeError::WrongLength);
+ return Err(DecodeError::ShortRead);
}
+ let mut channel_id = [0; 32];
+ channel_id[..].copy_from_slice(&v[0..32]);
let mut per_commitment_secret = [0; 32];
per_commitment_secret.copy_from_slice(&v[32..64]);
let secp_ctx = Secp256k1::without_caps();
Ok(Self {
- channel_id: deserialize(&v[0..32]).unwrap(),
+ channel_id,
per_commitment_secret,
next_per_commitment_point: secp_pubkey!(&secp_ctx, &v[64..97]),
})
}
impl MsgEncodable for RevokeAndACK {
fn encode(&self) -> Vec<u8> {
- unimplemented!();
+ let mut res = Vec::with_capacity(32+32+33);
+ res.extend_from_slice(&self.channel_id);
+ res.extend_from_slice(&self.per_commitment_secret);
+ res.extend_from_slice(&self.next_per_commitment_point.serialize());
+ res
}
}
impl MsgDecodable for UpdateFee {
fn decode(v: &[u8]) -> Result<Self, DecodeError> {
if v.len() < 32+4 {
- return Err(DecodeError::WrongLength);
+ return Err(DecodeError::ShortRead);
}
+ let mut channel_id = [0; 32];
+ channel_id[..].copy_from_slice(&v[0..32]);
Ok(Self {
- channel_id: deserialize(&v[0..32]).unwrap(),
+ channel_id,
feerate_per_kw: byte_utils::slice_to_be32(&v[32..36]),
})
}
}
impl MsgEncodable for UpdateFee {
fn encode(&self) -> Vec<u8> {
- unimplemented!();
+ let mut res = Vec::with_capacity(32+4);
+ res.extend_from_slice(&self.channel_id);
+ res.extend_from_slice(&byte_utils::be32_to_array(self.feerate_per_kw));
+ res
}
}
impl MsgDecodable for ChannelReestablish {
- fn decode(_v: &[u8]) -> Result<Self, DecodeError> {
- unimplemented!();
+ fn decode(v: &[u8]) -> Result<Self, DecodeError> {
+ if v.len() < 32+2*8+33 {
+ return Err(DecodeError::ShortRead);
+ }
+
+ let your_last_per_commitment_secret = if v.len() > 32+2*8+33 {
+ if v.len() < 32+2*8+33 + 32 {
+ return Err(DecodeError::ShortRead);
+ }
+ let mut inner_array = [0; 32];
+ inner_array.copy_from_slice(&v[48..48+32]);
+ Some(inner_array)
+ } else { None };
+
+ let option_size = match &your_last_per_commitment_secret {
+ &Some(ref _ary) => 32,
+ &None => 0,
+ };
+ Ok(Self {
+ channel_id: deserialize(&v[0..32]).unwrap(),
+ next_local_commitment_number: byte_utils::slice_to_be64(&v[32..40]),
+ next_remote_commitment_number: byte_utils::slice_to_be64(&v[40..48]),
+ your_last_per_commitment_secret: your_last_per_commitment_secret,
+ my_current_per_commitment_point: {
+ let ctx = Secp256k1::without_caps();
+ secp_pubkey!(&ctx, &v[48+option_size..48+option_size+33])
+ }
+ })
}
}
impl MsgEncodable for ChannelReestablish {
fn encode(&self) -> Vec<u8> {
- unimplemented!();
+ let mut res = Vec::with_capacity(if self.your_last_per_commitment_secret.is_some() { 32+2*3+33 + 32 } else { 32+2*8+33 });
+
+ res.extend_from_slice(&serialize(&self.channel_id).unwrap()[..]);
+ res.extend_from_slice(&byte_utils::be64_to_array(self.next_local_commitment_number));
+ res.extend_from_slice(&byte_utils::be64_to_array(self.next_remote_commitment_number));
+
+ if let &Some(ref ary) = &self.your_last_per_commitment_secret {
+ res.extend_from_slice(&ary[..]);
+ }
+
+ res.extend_from_slice(&self.my_current_per_commitment_point.serialize());
+ res
}
}
impl MsgDecodable for AnnouncementSignatures {
fn decode(v: &[u8]) -> Result<Self, DecodeError> {
if v.len() < 32+8+64*2 {
- return Err(DecodeError::WrongLength);
+ return Err(DecodeError::ShortRead);
}
let secp_ctx = Secp256k1::without_caps();
+ let mut channel_id = [0; 32];
+ channel_id[..].copy_from_slice(&v[0..32]);
Ok(Self {
- channel_id: deserialize(&v[0..32]).unwrap(),
+ channel_id,
short_channel_id: byte_utils::slice_to_be64(&v[32..40]),
node_signature: secp_signature!(&secp_ctx, &v[40..104]),
bitcoin_signature: secp_signature!(&secp_ctx, &v[104..168]),
impl MsgEncodable for AnnouncementSignatures {
fn encode(&self) -> Vec<u8> {
let mut res = Vec::with_capacity(32+8+64*2);
- res.extend_from_slice(&serialize(&self.channel_id).unwrap());
+ res.extend_from_slice(&self.channel_id);
res.extend_from_slice(&byte_utils::be64_to_array(self.short_channel_id));
let secp_ctx = Secp256k1::without_caps();
res.extend_from_slice(&self.node_signature.serialize_compact(&secp_ctx));
fn decode(v: &[u8]) -> Result<Self, DecodeError> {
let features = GlobalFeatures::decode(&v[..])?;
if v.len() < features.encoded_len() + 4 + 33 + 3 + 32 + 2 {
- return Err(DecodeError::WrongLength);
+ return Err(DecodeError::ShortRead);
}
let start = features.encoded_len();
let addrlen = byte_utils::slice_to_be16(&v[start + 72..start + 74]) as usize;
if v.len() < start + 74 + addrlen {
- return Err(DecodeError::WrongLength);
+ return Err(DecodeError::ShortRead);
}
+ let addr_read_limit = start + 74 + addrlen;
let mut addresses = Vec::with_capacity(4);
let mut read_pos = start + 74;
loop {
- if v.len() <= read_pos { break; }
+ if addr_read_limit <= read_pos { break; }
match v[read_pos] {
0 => { read_pos += 1; },
1 => {
- if v.len() < read_pos + 1 + 6 {
- return Err(DecodeError::WrongLength);
- }
if addresses.len() > 0 {
return Err(DecodeError::ExtraAddressesPerType);
}
+ if addr_read_limit < read_pos + 1 + 6 {
+ return Err(DecodeError::BadLengthDescriptor);
+ }
let mut addr = [0; 4];
addr.copy_from_slice(&v[read_pos + 1..read_pos + 5]);
addresses.push(NetAddress::IPv4 {
read_pos += 1 + 6;
},
2 => {
- if v.len() < read_pos + 1 + 18 {
- return Err(DecodeError::WrongLength);
- }
if addresses.len() > 1 || (addresses.len() == 1 && addresses[0].get_id() != 1) {
return Err(DecodeError::ExtraAddressesPerType);
}
+ if addr_read_limit < read_pos + 1 + 18 {
+ return Err(DecodeError::BadLengthDescriptor);
+ }
let mut addr = [0; 16];
addr.copy_from_slice(&v[read_pos + 1..read_pos + 17]);
addresses.push(NetAddress::IPv6 {
read_pos += 1 + 18;
},
3 => {
- if v.len() < read_pos + 1 + 12 {
- return Err(DecodeError::WrongLength);
- }
if addresses.len() > 2 || (addresses.len() > 0 && addresses.last().unwrap().get_id() > 2) {
return Err(DecodeError::ExtraAddressesPerType);
}
+ if addr_read_limit < read_pos + 1 + 12 {
+ return Err(DecodeError::BadLengthDescriptor);
+ }
let mut addr = [0; 10];
addr.copy_from_slice(&v[read_pos + 1..read_pos + 11]);
addresses.push(NetAddress::OnionV2 {
read_pos += 1 + 12;
},
4 => {
- if v.len() < read_pos + 1 + 37 {
- return Err(DecodeError::WrongLength);
- }
if addresses.len() > 3 || (addresses.len() > 0 && addresses.last().unwrap().get_id() > 3) {
return Err(DecodeError::ExtraAddressesPerType);
}
+ if addr_read_limit < read_pos + 1 + 37 {
+ return Err(DecodeError::BadLengthDescriptor);
+ }
let mut ed25519_pubkey = [0; 32];
ed25519_pubkey.copy_from_slice(&v[read_pos + 1..read_pos + 33]);
addresses.push(NetAddress::OnionV3 {
impl MsgDecodable for NodeAnnouncement {
fn decode(v: &[u8]) -> Result<Self, DecodeError> {
if v.len() < 64 {
- return Err(DecodeError::WrongLength);
+ return Err(DecodeError::ShortRead);
}
let secp_ctx = Secp256k1::without_caps();
Ok(Self {
}
impl MsgEncodable for NodeAnnouncement {
fn encode(&self) -> Vec<u8> {
- unimplemented!();
+ 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
}
}
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::WrongLength);
+ return Err(DecodeError::ShortRead);
}
let start = features.encoded_len();
let secp_ctx = Secp256k1::without_caps();
impl MsgDecodable for ChannelAnnouncement {
fn decode(v: &[u8]) -> Result<Self, DecodeError> {
if v.len() < 64*4 {
- return Err(DecodeError::WrongLength);
+ return Err(DecodeError::ShortRead);
}
let secp_ctx = Secp256k1::without_caps();
Ok(Self {
}
impl MsgEncodable for ChannelAnnouncement {
fn encode(&self) -> Vec<u8> {
- unimplemented!();
+ 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::WrongLength);
+ return Err(DecodeError::ShortRead);
}
Ok(Self {
chain_hash: deserialize(&v[0..32]).unwrap(),
impl MsgDecodable for ChannelUpdate {
fn decode(v: &[u8]) -> Result<Self, DecodeError> {
if v.len() < 128 {
- return Err(DecodeError::WrongLength);
+ return Err(DecodeError::ShortRead);
}
let secp_ctx = Secp256k1::without_caps();
Ok(Self {
impl MsgDecodable for OnionRealm0HopData {
fn decode(v: &[u8]) -> Result<Self, DecodeError> {
if v.len() < 32 {
- return Err(DecodeError::WrongLength);
+ return Err(DecodeError::ShortRead);
}
Ok(OnionRealm0HopData {
short_channel_id: byte_utils::slice_to_be64(&v[0..8]),
impl MsgDecodable for OnionHopData {
fn decode(v: &[u8]) -> Result<Self, DecodeError> {
if v.len() < 65 {
- return Err(DecodeError::WrongLength);
+ return Err(DecodeError::ShortRead);
}
let realm = v[0];
if realm != 0 {
impl MsgDecodable for OnionPacket {
fn decode(v: &[u8]) -> Result<Self, DecodeError> {
if v.len() < 1+33+20*65+32 {
- return Err(DecodeError::WrongLength);
+ return Err(DecodeError::ShortRead);
}
let mut hop_data = [0; 20*65];
hop_data.copy_from_slice(&v[34..1334]);
}
impl MsgDecodable for DecodedOnionErrorPacket {
- fn decode(_v: &[u8]) -> Result<Self, DecodeError> {
- unimplemented!();
+ 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 {
impl MsgDecodable for OnionErrorPacket {
fn decode(v: &[u8]) -> Result<Self, DecodeError> {
if v.len() < 2 {
- return Err(DecodeError::WrongLength);
+ return Err(DecodeError::ShortRead);
}
let len = byte_utils::slice_to_be16(&v[0..2]) as usize;
if v.len() < 2 + len {
- return Err(DecodeError::WrongLength);
+ return Err(DecodeError::ShortRead);
}
Ok(Self {
data: v[2..len+2].to_vec(),
}
impl MsgEncodable for OnionErrorPacket {
fn encode(&self) -> Vec<u8> {
- unimplemented!();
+ let mut res = Vec::with_capacity(2 + self.data.len());
+ res.extend_from_slice(&byte_utils::be16_to_array(self.data.len() as u16));
+ res.extend_from_slice(&self.data);
+ res
+ }
+}
+
+impl MsgEncodable for ErrorMessage {
+ fn encode(&self) -> Vec<u8> {
+ let mut res = Vec::with_capacity(34 + self.data.len());
+ res.extend_from_slice(&self.channel_id);
+ res.extend_from_slice(&byte_utils::be16_to_array(self.data.len() as u16));
+ res.extend_from_slice(&self.data.as_bytes());
+ res
}
}
+impl MsgDecodable for ErrorMessage {
+ fn decode(v: &[u8]) -> Result<Self,DecodeError> {
+ if v.len() < 34 {
+ return Err(DecodeError::ShortRead);
+ }
+ // Unlike most messages, BOLT 1 requires we truncate our read if the value is out of range
+ let len = cmp::min(byte_utils::slice_to_be16(&v[32..34]) as usize, v.len() - 34);
+ let data = match String::from_utf8(v[34..34 + len].to_vec()) {
+ Ok(s) => s,
+ Err(_) => return Err(DecodeError::BadText),
+ };
+ let mut channel_id = [0; 32];
+ channel_id[..].copy_from_slice(&v[0..32]);
+ Ok(Self {
+ channel_id,
+ data,
+ })
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use hex;
+ use ln::msgs::MsgEncodable;
+ use ln::msgs;
+ use secp256k1::key::{PublicKey,SecretKey};
+ use secp256k1::Secp256k1;
+ #[test]
+ fn encoding_channel_reestablish_no_secret() {
+ let public_key = {
+ let secp_ctx = Secp256k1::new();
+ PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
+ };
+
+ let cr = msgs::ChannelReestablish {
+ 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],
+ next_local_commitment_number: 3,
+ next_remote_commitment_number: 4,
+ your_last_per_commitment_secret: None,
+ my_current_per_commitment_point: public_key,
+ };
+
+ let encoded_value = cr.encode();
+ assert_eq!(
+ encoded_value,
+ 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, 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]
+ );
+ }
+
+ #[test]
+ fn encoding_channel_reestablish_with_secret() {
+ let public_key = {
+ let secp_ctx = Secp256k1::new();
+ PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
+ };
+
+ let cr = msgs::ChannelReestablish {
+ 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],
+ next_local_commitment_number: 3,
+ next_remote_commitment_number: 4,
+ your_last_per_commitment_secret: Some([9; 32]),
+ my_current_per_commitment_point: public_key,
+ };
+
+ let encoded_value = cr.encode();
+ assert_eq!(
+ encoded_value,
+ 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]
+ );
+ }
+}