Skip to content

Commit 114dee7

Browse files
TheBlueMattTheBlueMatt
committed
Simplify serialization a bit by removing the useless newtypes
1 parent e478f98 commit 114dee7

File tree

7 files changed

+158
-198
lines changed

7 files changed

+158
-198
lines changed

‎fuzz/fuzz_targets/channel_target.rs

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -15,7 +15,7 @@ use lightning::chain::chaininterface::{FeeEstimator, ConfirmationTarget};
1515
use lightning::chain::transaction::OutPoint;
1616
use lightning::util::reset_rng_state;
1717
use lightning::util::logger::Logger;
18-
use lightning::util::ser::{Readable, Reader};
18+
use lightning::util::ser::Readable;
1919

2020
mod utils;
2121

@@ -121,7 +121,7 @@ pub fn do_test(data: &[u8]) {
121121

122122
macro_rules! decode_msg {
123123
($MsgType: path, $len: expr) => {{
124-
let mut reader = Reader::new(::std::io::Cursor::new(get_slice!($len)));
124+
let mut reader = ::std::io::Cursor::new(get_slice!($len));
125125
match <($MsgType)>::read(&mut reader) {
126126
Ok(msg) => msg,
127127
Err(e) => match e {

‎fuzz/fuzz_targets/msg_targets/utils.rs

Lines changed: 21 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -4,16 +4,16 @@
44
macro_rules! test_msg {
55
($MsgType: path, $data: ident) => {
66
{
7-
use lightning::util::ser::{Writer, Reader, Writeable, Readable};
8-
let mut r = Reader::new(::std::io::Cursor::new($data));
7+
use lightning::util::ser::{Writeable, Readable};
8+
let mut r = ::std::io::Cursor::new($data);
99
if let Ok(msg) = <$MsgType as Readable<::std::io::Cursor<&[u8]>>>::read(&mut r) {
10-
let p = r.get_ref().position() as usize;
11-
let mut w = Writer::new(::std::io::Cursor::new(vec![]));
10+
let p = r.position() as usize;
11+
let mut w = ::std::io::Cursor::new(vec![]);
1212
msg.write(&mut w).unwrap();
1313

14-
let buf = w.into_inner().into_inner();
14+
let buf = w.into_inner();
1515
assert_eq!(buf.len(), p);
16-
assert_eq!(&r.into_inner().into_inner()[..p], &buf[..p]);
16+
assert_eq!(&r.into_inner()[..p], &buf[..p]);
1717
}
1818
}
1919
}
@@ -23,10 +23,10 @@ macro_rules! test_msg {
2323
macro_rules! test_msg_simple {
2424
($MsgType: path, $data: ident) => {
2525
{
26-
use lightning::util::ser::{Writer, Reader, Writeable, Readable};
27-
let mut r = Reader::new(::std::io::Cursor::new($data));
26+
use lightning::util::ser::{Writeable, Readable};
27+
let mut r = ::std::io::Cursor::new($data);
2828
if let Ok(msg) = <$MsgType as Readable<::std::io::Cursor<&[u8]>>>::read(&mut r) {
29-
msg.write(&mut Writer::new(::std::io::Cursor::new(vec![]))).unwrap();
29+
msg.write(&mut ::std::io::Cursor::new(vec![])).unwrap();
3030
}
3131
}
3232
}
@@ -36,14 +36,14 @@ macro_rules! test_msg_simple {
3636
macro_rules! test_msg_exact {
3737
($MsgType: path, $data: ident) => {
3838
{
39-
use lightning::util::ser::{Writer, Reader, Writeable, Readable};
40-
let mut r = Reader::new(::std::io::Cursor::new($data));
39+
use lightning::util::ser::{Writeable, Readable};
40+
let mut r = ::std::io::Cursor::new($data);
4141
if let Ok(msg) = <$MsgType as Readable<::std::io::Cursor<&[u8]>>>::read(&mut r) {
42-
let mut w = Writer::new(::std::io::Cursor::new(vec![]));
42+
let mut w = ::std::io::Cursor::new(vec![]);
4343
msg.write(&mut w).unwrap();
4444

45-
let buf = w.into_inner().into_inner();
46-
assert_eq!(&r.into_inner().into_inner()[..], &buf[..]);
45+
let buf = w.into_inner();
46+
assert_eq!(&r.into_inner()[..], &buf[..]);
4747
}
4848
}
4949
}
@@ -53,17 +53,17 @@ macro_rules! test_msg_exact {
5353
macro_rules! test_msg_hole {
5454
($MsgType: path, $data: ident, $hole: expr, $hole_len: expr) => {
5555
{
56-
use lightning::util::ser::{Writer, Reader, Writeable, Readable};
57-
let mut r = Reader::new(::std::io::Cursor::new($data));
56+
use lightning::util::ser::{Writeable, Readable};
57+
let mut r = ::std::io::Cursor::new($data);
5858
if let Ok(msg) = <$MsgType as Readable<::std::io::Cursor<&[u8]>>>::read(&mut r) {
59-
let mut w = Writer::new(::std::io::Cursor::new(vec![]));
59+
let mut w = ::std::io::Cursor::new(vec![]);
6060
msg.write(&mut w).unwrap();
61-
let p = w.get_ref().position() as usize;
61+
let p = w.position() as usize;
6262

63-
let buf = w.into_inner().into_inner();
63+
let buf = w.into_inner();
6464
assert_eq!(buf.len(),p);
65-
assert_eq!(&r.get_ref().get_ref()[..$hole], &buf[..$hole]);
66-
assert_eq!(&r.get_ref().get_ref()[$hole+$hole_len..p], &buf[$hole+$hole_len..]);
65+
assert_eq!(&r.get_ref()[..$hole], &buf[..$hole]);
66+
assert_eq!(&r.get_ref()[$hole+$hole_len..p], &buf[$hole+$hole_len..]);
6767
}
6868
}
6969
}

‎fuzz/fuzz_targets/router_target.rs

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -12,7 +12,7 @@ use lightning::ln::msgs::{RoutingMessageHandler};
1212
use lightning::ln::router::{Router, RouteHint};
1313
use lightning::util::reset_rng_state;
1414
use lightning::util::logger::Logger;
15-
use lightning::util::ser::{Reader, Readable};
15+
use lightning::util::ser::Readable;
1616

1717
use secp256k1::key::PublicKey;
1818
use secp256k1::Secp256k1;
@@ -121,7 +121,7 @@ pub fn do_test(data: &[u8]) {
121121

122122
macro_rules! decode_msg {
123123
($MsgType: path, $len: expr) => {{
124-
let mut reader = Reader::new(::std::io::Cursor::new(get_slice!($len)));
124+
let mut reader = ::std::io::Cursor::new(get_slice!($len));
125125
match <($MsgType)>::read(&mut reader) {
126126
Ok(msg) => msg,
127127
Err(e) => match e {

‎src/ln/msgs.rs

Lines changed: 42 additions & 41 deletions
Original file line numberDiff line numberDiff line change
@@ -7,10 +7,11 @@ use bitcoin::blockdata::script::Script;
77

88
use std::error::Error;
99
use std::{cmp, fmt};
10+
use std::io::Read;
1011
use std::result::Result;
1112

1213
use util::{byte_utils, internal_traits, events};
13-
use util::ser::{Readable, Reader, Writeable, Writer};
14+
use util::ser::{Readable, Writeable, Writer};
1415

1516
pub trait MsgEncodable {
1617
fn encode(&self) -> Vec<u8>;
@@ -1728,8 +1729,8 @@ impl_writeable!(AnnouncementSignatures, {
17281729
bitcoin_signature
17291730
});
17301731

1731-
impl<W: ::std::io::Write> Writeable<W> for ChannelReestablish {
1732-
fn write(&self, w: &mut Writer<W>) -> Result<(), DecodeError> {
1732+
impl<W: Writer> Writeable<W> for ChannelReestablish {
1733+
fn write(&self, w: &mut W) -> Result<(), DecodeError> {
17331734
self.channel_id.write(w)?;
17341735
self.next_local_commitment_number.write(w)?;
17351736
self.next_remote_commitment_number.write(w)?;
@@ -1741,8 +1742,8 @@ impl<W: ::std::io::Write> Writeable<W> for ChannelReestablish {
17411742
}
17421743
}
17431744

1744-
impl<R: ::std::io::Read> Readable<R> for ChannelReestablish{
1745-
fn read(r: &mut Reader<R>) -> Result<Self, DecodeError> {
1745+
impl<R: Read> Readable<R> for ChannelReestablish{
1746+
fn read(r: &mut R) -> Result<Self, DecodeError> {
17461747
Ok(Self {
17471748
channel_id: Readable::read(r)?,
17481749
next_local_commitment_number: Readable::read(r)?,
@@ -1871,8 +1872,8 @@ impl_writeable!(OnionErrorPacket, {
18711872
data
18721873
});
18731874

1874-
impl<W: ::std::io::Write> Writeable<W> for OnionPacket {
1875-
fn write(&self, w: &mut Writer<W>) -> Result<(), DecodeError> {
1875+
impl<W: Writer> Writeable<W> for OnionPacket {
1876+
fn write(&self, w: &mut W) -> Result<(), DecodeError> {
18761877
self.version.write(w)?;
18771878
match self.public_key {
18781879
Ok(pubkey) => pubkey.write(w)?,
@@ -1884,8 +1885,8 @@ impl<W: ::std::io::Write> Writeable<W> for OnionPacket {
18841885
}
18851886
}
18861887

1887-
impl<R: ::std::io::Read> Readable<R> for OnionPacket {
1888-
fn read(r: &mut Reader<R>) -> Result<Self, DecodeError> {
1888+
impl<R: Read> Readable<R> for OnionPacket {
1889+
fn read(r: &mut R) -> Result<Self, DecodeError> {
18891890
Ok(OnionPacket {
18901891
version: Readable::read(r)?,
18911892
public_key: {
@@ -1908,8 +1909,8 @@ impl_writeable!(UpdateAddHTLC, {
19081909
onion_routing_packet
19091910
});
19101911

1911-
impl<W: ::std::io::Write> Writeable<W> for OnionRealm0HopData {
1912-
fn write(&self, w: &mut Writer<W>) -> Result<(), DecodeError> {
1912+
impl<W: Writer> Writeable<W> for OnionRealm0HopData {
1913+
fn write(&self, w: &mut W) -> Result<(), DecodeError> {
19131914
self.short_channel_id.write(w)?;
19141915
self.amt_to_forward.write(w)?;
19151916
self.outgoing_cltv_value.write(w)?;
@@ -1918,8 +1919,8 @@ impl<W: ::std::io::Write> Writeable<W> for OnionRealm0HopData {
19181919
}
19191920
}
19201921

1921-
impl<R: ::std::io::Read> Readable<R> for OnionRealm0HopData {
1922-
fn read(r: &mut Reader<R>) -> Result<Self, DecodeError> {
1922+
impl<R: Read> Readable<R> for OnionRealm0HopData {
1923+
fn read(r: &mut R) -> Result<Self, DecodeError> {
19231924
Ok(OnionRealm0HopData {
19241925
short_channel_id: Readable::read(r)?,
19251926
amt_to_forward: Readable::read(r)?,
@@ -1932,17 +1933,17 @@ impl<R: ::std::io::Read> Readable<R> for OnionRealm0HopData {
19321933
}
19331934
}
19341935

1935-
impl<W: ::std::io::Write> Writeable<W> for OnionHopData {
1936-
fn write(&self, w: &mut Writer<W>) -> Result<(), DecodeError> {
1936+
impl<W: Writer> Writeable<W> for OnionHopData {
1937+
fn write(&self, w: &mut W) -> Result<(), DecodeError> {
19371938
self.realm.write(w)?;
19381939
self.data.write(w)?;
19391940
self.hmac.write(w)?;
19401941
Ok(())
19411942
}
19421943
}
19431944

1944-
impl<R: ::std::io::Read> Readable<R> for OnionHopData {
1945-
fn read(r: &mut Reader<R>) -> Result<Self, DecodeError> {
1945+
impl<R: Read> Readable<R> for OnionHopData {
1946+
fn read(r: &mut R) -> Result<Self, DecodeError> {
19461947
Ok(OnionHopData {
19471948
realm: {
19481949
let r: u8 = Readable::read(r)?;
@@ -1957,16 +1958,16 @@ impl<R: ::std::io::Read> Readable<R> for OnionHopData {
19571958
}
19581959
}
19591960

1960-
impl<W: ::std::io::Write> Writeable<W> for Ping {
1961-
fn write(&self, w: &mut Writer<W>) -> Result<(), DecodeError> {
1961+
impl<W: Writer> Writeable<W> for Ping {
1962+
fn write(&self, w: &mut W) -> Result<(), DecodeError> {
19621963
self.ponglen.write(w)?;
19631964
vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
19641965
Ok(())
19651966
}
19661967
}
19671968

1968-
impl<R: ::std::io::Read> Readable<R> for Ping {
1969-
fn read(r: &mut Reader<R>) -> Result<Self, DecodeError> {
1969+
impl<R: Read> Readable<R> for Ping {
1970+
fn read(r: &mut R) -> Result<Self, DecodeError> {
19701971
Ok(Ping {
19711972
ponglen: Readable::read(r)?,
19721973
byteslen: {
@@ -1978,15 +1979,15 @@ impl<R: ::std::io::Read> Readable<R> for Ping {
19781979
}
19791980
}
19801981

1981-
impl<W: ::std::io::Write> Writeable<W> for Pong {
1982-
fn write(&self, w: &mut Writer<W>) -> Result<(), DecodeError> {
1982+
impl<W: Writer> Writeable<W> for Pong {
1983+
fn write(&self, w: &mut W) -> Result<(), DecodeError> {
19831984
vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
19841985
Ok(())
19851986
}
19861987
}
19871988

1988-
impl<R: ::std::io::Read> Readable<R> for Pong {
1989-
fn read(r: &mut Reader<R>) -> Result<Self, DecodeError> {
1989+
impl<R: Read> Readable<R> for Pong {
1990+
fn read(r: &mut R) -> Result<Self, DecodeError> {
19901991
Ok(Pong {
19911992
byteslen: {
19921993
let byteslen = Readable::read(r)?;
@@ -1997,8 +1998,8 @@ impl<R: ::std::io::Read> Readable<R> for Pong {
19971998
}
19981999
}
19992000

2000-
impl<W: ::std::io::Write> Writeable<W> for UnsignedChannelAnnouncement {
2001-
fn write(&self, w: &mut Writer<W>) -> Result<(), DecodeError> {
2001+
impl<W: Writer> Writeable<W> for UnsignedChannelAnnouncement {
2002+
fn write(&self, w: &mut W) -> Result<(), DecodeError> {
20022003
self.features.write(w)?;
20032004
self.chain_hash.write(w)?;
20042005
self.short_channel_id.write(w)?;
@@ -2011,8 +2012,8 @@ impl<W: ::std::io::Write> Writeable<W> for UnsignedChannelAnnouncement {
20112012
}
20122013
}
20132014

2014-
impl<R: ::std::io::Read> Readable<R> for UnsignedChannelAnnouncement {
2015-
fn read(r: &mut Reader<R>) -> Result<Self, DecodeError> {
2015+
impl<R: Read> Readable<R> for UnsignedChannelAnnouncement {
2016+
fn read(r: &mut R) -> Result<Self, DecodeError> {
20162017
Ok(Self {
20172018
features: {
20182019
let f: GlobalFeatures = Readable::read(r)?;
@@ -2044,8 +2045,8 @@ impl_writeable!(ChannelAnnouncement,{
20442045
contents
20452046
});
20462047

2047-
impl<W: ::std::io::Write> Writeable<W> for UnsignedChannelUpdate {
2048-
fn write(&self, w: &mut Writer<W>) -> Result<(), DecodeError> {
2048+
impl<W: Writer> Writeable<W> for UnsignedChannelUpdate {
2049+
fn write(&self, w: &mut W) -> Result<(), DecodeError> {
20492050
self.chain_hash.write(w)?;
20502051
self.short_channel_id.write(w)?;
20512052
self.timestamp.write(w)?;
@@ -2059,8 +2060,8 @@ impl<W: ::std::io::Write> Writeable<W> for UnsignedChannelUpdate {
20592060
}
20602061
}
20612062

2062-
impl<R: ::std::io::Read> Readable<R> for UnsignedChannelUpdate {
2063-
fn read(r: &mut Reader<R>) -> Result<Self, DecodeError> {
2063+
impl<R: Read> Readable<R> for UnsignedChannelUpdate {
2064+
fn read(r: &mut R) -> Result<Self, DecodeError> {
20642065
Ok(Self {
20652066
chain_hash: Readable::read(r)?,
20662067
short_channel_id: Readable::read(r)?,
@@ -2084,16 +2085,16 @@ impl_writeable!(ChannelUpdate, {
20842085
contents
20852086
});
20862087

2087-
impl<W: ::std::io::Write> Writeable<W> for ErrorMessage {
2088-
fn write(&self, w: &mut Writer<W>) -> Result<(), DecodeError> {
2088+
impl<W: Writer> Writeable<W> for ErrorMessage {
2089+
fn write(&self, w: &mut W) -> Result<(), DecodeError> {
20892090
self.channel_id.write(w)?;
20902091
self.data.as_bytes().to_vec().write(w)?; // write with size prefix
20912092
Ok(())
20922093
}
20932094
}
20942095

2095-
impl<R: ::std::io::Read> Readable<R> for ErrorMessage {
2096-
fn read(r: &mut Reader<R>) -> Result<Self, DecodeError> {
2096+
impl<R: Read> Readable<R> for ErrorMessage {
2097+
fn read(r: &mut R) -> Result<Self, DecodeError> {
20972098
Ok(Self {
20982099
channel_id: Readable::read(r)?,
20992100
data: {
@@ -2110,8 +2111,8 @@ impl<R: ::std::io::Read> Readable<R> for ErrorMessage {
21102111
}
21112112
}
21122113

2113-
impl<W: ::std::io::Write> Writeable<W> for UnsignedNodeAnnouncement {
2114-
fn write(&self, w: &mut Writer<W>) -> Result<(), DecodeError> {
2114+
impl<W: Writer> Writeable<W> for UnsignedNodeAnnouncement {
2115+
fn write(&self, w: &mut W) -> Result<(), DecodeError> {
21152116
self.features.write(w)?;
21162117
self.timestamp.write(w)?;
21172118
self.node_id.write(w)?;
@@ -2156,8 +2157,8 @@ impl<W: ::std::io::Write> Writeable<W> for UnsignedNodeAnnouncement {
21562157
}
21572158
}
21582159

2159-
impl<R: ::std::io::Read> Readable<R> for UnsignedNodeAnnouncement {
2160-
fn read(r: &mut Reader<R>) -> Result<Self, DecodeError> {
2160+
impl<R: Read> Readable<R> for UnsignedNodeAnnouncement {
2161+
fn read(r: &mut R) -> Result<Self, DecodeError> {
21612162
let features: GlobalFeatures = Readable::read(r)?;
21622163
if features.requires_unknown_bits() {
21632164
return Err(DecodeError::UnknownRequiredFeature);

‎src/ln/peer_handler.rs

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,7 @@
11
use secp256k1::key::{SecretKey,PublicKey};
22

33
use ln::msgs;
4-
use util::ser::{Writer, Reader, Writeable, Readable};
4+
use util::ser::{Writeable, Readable};
55
use ln::peer_channel_encryptor::{PeerChannelEncryptor,NextNoiseStep};
66
use util::byte_utils;
77
use util::events::{EventsProvider,Event};
@@ -114,10 +114,10 @@ pub struct PeerManager<Descriptor: SocketDescriptor> {
114114

115115
macro_rules! encode_msg {
116116
($msg: expr, $msg_code: expr) => {{
117-
let mut w = Writer::new(::std::io::Cursor::new(vec![]));
117+
let mut w = ::std::io::Cursor::new(vec![]);
118118
0u16.write(&mut w).unwrap();
119119
$msg.write(&mut w).unwrap();
120-
let mut msg = w.into_inner().into_inner();
120+
let mut msg = w.into_inner();
121121
let len = msg.len();
122122
msg[..2].copy_from_slice(&byte_utils::be16_to_array(len as u16 - 2));
123123
msg
@@ -437,7 +437,7 @@ impl<Descriptor: SocketDescriptor> PeerManager<Descriptor> {
437437
// Need an init message as first message
438438
return Err(PeerHandleError{ no_connection_possible: false });
439439
}
440-
let mut reader = Reader::new(::std::io::Cursor::new(&msg_data[2..]));
440+
let mut reader = ::std::io::Cursor::new(&msg_data[2..]);
441441
match msg_type {
442442
// Connection control:
443443
16 => {

0 commit comments

Comments
 (0)