use secp256k1::key::PublicKey;
use secp256k1::{Secp256k1, Signature};
+use secp256k1;
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};
BadSignature,
/// Value expected to be text wasn't decodable as text
BadText,
- /// Buffer not of right length (either too short or too long)
- WrongLength,
+ /// 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>;
pub next_local_commitment_number: u64,
pub next_remote_commitment_number: u64,
pub your_last_per_commitment_secret: Option<[u8; 32]>,
- pub my_current_per_commitment_point: PublicKey,
+ pub my_current_per_commitment_point: Option<PublicKey>,
}
#[derive(Clone)]
/// Used to put an error message in a HandleError
pub enum ErrorAction {
- /// Indicates an inbound HTLC add resulted in a failure, and the UpdateFailHTLC provided in msg
- /// should be sent back to the sender.
- UpdateFailHTLC {
- msg: UpdateFailHTLC
- },
/// The peer took some action which made us think they were useless. Disconnect them.
DisconnectPeer {
msg: Option<ErrorMessage>
pub update_add_htlcs: Vec<UpdateAddHTLC>,
pub update_fulfill_htlcs: Vec<UpdateFulfillHTLC>,
pub update_fail_htlcs: Vec<UpdateFailHTLC>,
+ pub update_fail_malformed_htlcs: Vec<UpdateFailMalformedHTLC>,
pub commitment_signed: CommitmentSigned,
}
// 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 : Send + Sync {
#[derive(Clone)]
pub struct OnionPacket {
pub version: u8,
- pub public_key: PublicKey,
+ /// In order to ensure we always return an error on Onion decode in compliance with BOLT 4, we
+ /// have to deserialize OnionPackets contained in UpdateAddHTLCs even if the ephemeral public
+ /// key (here) is bogus, so we hold a Result instead of a PublicKey as we'd like.
+ pub public_key: Result<PublicKey, secp256k1::Error>,
pub hop_data: [u8; 20*65],
pub hmac: [u8; 32],
}
DecodeError::BadPublicKey => "Invalid public key in packet",
DecodeError::BadSignature => "Invalid signature in packet",
DecodeError::BadText => "Invalid text in packet",
- DecodeError::WrongLength => "Data was wrong length for 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() < 2 { 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() < 2 { 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::WrongLength);
+ 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::WrongLength);
+ return Err(DecodeError::ShortRead);
}
Ok(Self {
ponglen,
impl MsgDecodable for Pong {
fn decode(v: &[u8]) -> Result<Self, DecodeError> {
if v.len() < 2 {
- return Err(DecodeError::WrongLength);
+ return Err(DecodeError::ShortRead);
}
let byteslen = byte_utils::slice_to_be16(&v[0..2]);
if v.len() < 2 + byteslen as usize {
- return Err(DecodeError::WrongLength);
+ return Err(DecodeError::ShortRead);
}
Ok(Self {
byteslen
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 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];
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];
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];
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];
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]);
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];
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]);
}
impl MsgEncodable for UpdateAddHTLC {
fn encode(&self) -> Vec<u8> {
- let mut res = Vec::with_capacity(32+8+8+32+4+1+1366);
+ 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));
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]);
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]);
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]);
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();
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]);
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]);
impl MsgDecodable for ChannelReestablish {
fn decode(v: &[u8]) -> Result<Self, DecodeError> {
- if v.len() < 32+2*8+33 {
- return Err(DecodeError::WrongLength);
+ if v.len() < 32+2*8 {
+ 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::WrongLength);
+ let (your_last_per_commitment_secret, my_current_per_commitment_point) = if v.len() > 32+2*8 {
+ if v.len() < 32+2*8 + 33+32 {
+ return Err(DecodeError::ShortRead);
}
let mut inner_array = [0; 32];
inner_array.copy_from_slice(&v[48..48+32]);
- Some(inner_array)
- } else { None };
+ (Some(inner_array), {
+ let ctx = Secp256k1::without_caps();
+ Some(secp_pubkey!(&ctx, &v[48+32..48+32+33]))
+ })
+ } else { (None, 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])
- }
+ my_current_per_commitment_point: my_current_per_commitment_point,
})
}
}
impl MsgEncodable for ChannelReestablish {
fn encode(&self) -> Vec<u8> {
- 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 });
+ let mut res = Vec::with_capacity(if self.your_last_per_commitment_secret.is_some() { 32+2*8+33+32 } else { 32+2*8 });
res.extend_from_slice(&serialize(&self.channel_id).unwrap()[..]);
res.extend_from_slice(&byte_utils::be64_to_array(self.next_local_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.expect("my_current_per_commitment_point should have been filled").serialize());
}
-
- 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];
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 {
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 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]);
let secp_ctx = Secp256k1::without_caps();
Ok(Self {
version: v[0],
- public_key: secp_pubkey!(&secp_ctx, &v[1..34]),
+ public_key: PublicKey::from_slice(&secp_ctx, &v[1..34]),
hop_data,
hmac,
})
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());
+ match self.public_key {
+ Ok(pubkey) => res.extend_from_slice(&pubkey.serialize()),
+ Err(_) => res.extend_from_slice(&[0; 33]),
+ }
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::WrongLength);
+ 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::WrongLength);
+ 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::WrongLength);
+ return Err(DecodeError::ShortRead);
}
let mut hmac = [0; 32];
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 MsgDecodable for ErrorMessage {
fn decode(v: &[u8]) -> Result<Self,DecodeError> {
if v.len() < 34 {
- return Err(DecodeError::WrongLength);
- }
- let len = byte_utils::slice_to_be16(&v[32..34]);
- if v.len() < 34 + len as usize {
- return Err(DecodeError::WrongLength);
+ return Err(DecodeError::ShortRead);
}
- let data = match String::from_utf8(v[34..34 + len as usize].to_vec()) {
+ // 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),
};
#[cfg(test)]
mod tests {
- use bitcoin::util::misc::hex_bytes;
+ use hex;
use ln::msgs::MsgEncodable;
use ln::msgs;
use secp256k1::key::{PublicKey,SecretKey};
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_bytes("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap()).unwrap()
+ PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
};
let cr = msgs::ChannelReestablish {
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_bytes("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap()).unwrap()
+ PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
};
let cr = msgs::ChannelReestablish {
projects / rust-lightning / blobdiff