Skip to content

Commit 47358b8

Browse files
author
Antoine Riard
committed
Implement serialize/deserialize for Router
1 parent 302f131 commit 47358b8

File tree

3 files changed

+312
-1
lines changed

3 files changed

+312
-1
lines changed

‎src/ln/msgs.rs

Lines changed: 74 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -382,6 +382,80 @@ impl NetAddress {
382382
}
383383
}
384384

385+
impl Writeable for NetAddress {
386+
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
387+
match self {
388+
&NetAddress::IPv4 { ref addr, ref port } => {
389+
0u8.write(writer)?;
390+
addr.write(writer)?;
391+
port.write(writer)?;
392+
},
393+
&NetAddress::IPv6 { ref addr, ref port } => {
394+
1u8.write(writer)?;
395+
addr.write(writer)?;
396+
port.write(writer)?;
397+
},
398+
&NetAddress::OnionV2 { ref addr, ref port } => {
399+
2u8.write(writer)?;
400+
addr.write(writer)?;
401+
port.write(writer)?;
402+
},
403+
&NetAddress::OnionV3 { ref ed25519_pubkey, ref checksum, ref version, ref port } => {
404+
3u8.write(writer)?;
405+
ed25519_pubkey.write(writer)?;
406+
checksum.write(writer)?;
407+
version.write(writer)?;
408+
port.write(writer)?;
409+
}
410+
}
411+
Ok(())
412+
}
413+
}
414+
415+
impl<R: ::std::io::Read> Readable<R> for NetAddress {
416+
fn read(reader: &mut R) -> Result<NetAddress, DecodeError> {
417+
match <u8 as Readable<R>>::read(reader)? {
418+
0 => {
419+
let addr = Readable::read(reader)?;
420+
let port = Readable::read(reader)?;
421+
Ok(NetAddress::IPv4 {
422+
addr,
423+
port,
424+
})
425+
},
426+
1 => {
427+
let addr = Readable::read(reader)?;
428+
let port = Readable::read(reader)?;
429+
Ok(NetAddress::IPv6 {
430+
addr,
431+
port,
432+
})
433+
},
434+
2 => {
435+
let addr = Readable::read(reader)?;
436+
let port = Readable::read(reader)?;
437+
Ok(NetAddress::OnionV2 {
438+
addr,
439+
port,
440+
})
441+
},
442+
3 => {
443+
let ed25519_pubkey = Readable::read(reader)?;
444+
let checksum = Readable::read(reader)?;
445+
let version = Readable::read(reader)?;
446+
let port = Readable::read(reader)?;
447+
Ok(NetAddress::OnionV3 {
448+
ed25519_pubkey,
449+
checksum,
450+
version,
451+
port,
452+
})
453+
}
454+
_ => return Err(DecodeError::InvalidValue),
455+
}
456+
}
457+
}
458+
385459
#[derive(Clone)]
386460
// Only exposed as broadcast of node_announcement should be filtered by node_id
387461
/// The unsigned part of a node_announcement

‎src/ln/router.rs

Lines changed: 234 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -15,7 +15,7 @@ use chain::chaininterface::{ChainError, ChainWatchInterface};
1515
use ln::channelmanager;
1616
use ln::msgs::{DecodeError,ErrorAction,HandleError,RoutingMessageHandler,NetAddress,GlobalFeatures};
1717
use ln::msgs;
18-
use util::ser::{Writeable, Readable};
18+
use util::ser::{Writeable, Readable, Writer, ReadableArgs};
1919
use util::logger::Logger;
2020

2121
use std::cmp;
@@ -96,6 +96,53 @@ impl std::fmt::Display for DirectionalChannelInfo {
9696
}
9797
}
9898

99+
impl Writeable for DirectionalChannelInfo {
100+
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
101+
self.src_node_id.write(writer)?;
102+
self.last_update.write(writer)?;
103+
self.enabled.write(writer)?;
104+
self.cltv_expiry_delta.write(writer)?;
105+
self.htlc_minimum_msat.write(writer)?;
106+
self.fee_base_msat.write(writer)?;
107+
self.fee_proportional_millionths.write(writer)?;
108+
match &self.last_update_message {
109+
&None => 0u8.write(writer)?,
110+
&Some(ref msg) => {
111+
1u8.write(writer)?;
112+
msg.write(writer)?;
113+
}
114+
}
115+
Ok(())
116+
}
117+
}
118+
119+
impl<R: ::std::io::Read> Readable<R> for DirectionalChannelInfo {
120+
fn read(reader: &mut R) -> Result<DirectionalChannelInfo, DecodeError> {
121+
let src_node_id = Readable::read(reader)?;
122+
let last_update = Readable::read(reader)?;
123+
let enabled = Readable::read(reader)?;
124+
let cltv_expiry_delta = Readable::read(reader)?;
125+
let htlc_minimum_msat = Readable::read(reader)?;
126+
let fee_base_msat = Readable::read(reader)?;
127+
let fee_proportional_millionths = Readable::read(reader)?;
128+
let last_update_message = match <u8 as Readable<R>>::read(reader)? {
129+
0 => None,
130+
1 => Some(msgs::ChannelUpdate::read(reader)?),
131+
_ => return Err(DecodeError::InvalidValue),
132+
};
133+
Ok(DirectionalChannelInfo {
134+
src_node_id,
135+
last_update,
136+
enabled,
137+
cltv_expiry_delta,
138+
htlc_minimum_msat,
139+
fee_base_msat,
140+
fee_proportional_millionths,
141+
last_update_message
142+
})
143+
}
144+
}
145+
99146
struct ChannelInfo {
100147
features: GlobalFeatures,
101148
one_to_two: DirectionalChannelInfo,
@@ -112,6 +159,41 @@ impl std::fmt::Display for ChannelInfo {
112159
}
113160
}
114161

162+
impl Writeable for ChannelInfo {
163+
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
164+
self.features.write(writer)?;
165+
self.one_to_two.write(writer)?;
166+
self.two_to_one.write(writer)?;
167+
match &self.announcement_message {
168+
&None => 0u8.write(writer)?,
169+
&Some(ref msg) => {
170+
1u8.write(writer)?;
171+
msg.write(writer)?;
172+
}
173+
}
174+
Ok(())
175+
}
176+
}
177+
178+
impl<R: ::std::io::Read> Readable<R> for ChannelInfo {
179+
fn read(reader: &mut R) -> Result<ChannelInfo, DecodeError> {
180+
let features = Readable::read(reader)?;
181+
let one_to_two = Readable::read(reader)?;
182+
let two_to_one = Readable::read(reader)?;
183+
let announcement_message = match <u8 as Readable<R>>::read(reader)? {
184+
0 => None,
185+
1 => Some(msgs::ChannelAnnouncement::read(reader)?),
186+
_ => return Err(DecodeError::InvalidValue),
187+
};
188+
Ok(ChannelInfo {
189+
features,
190+
one_to_two,
191+
two_to_one,
192+
announcement_message,
193+
})
194+
}
195+
}
196+
115197
struct NodeInfo {
116198
#[cfg(feature = "non_bitcoin_chain_hash_routing")]
117199
channels: Vec<(u64, Sha256dHash)>,
@@ -138,6 +220,72 @@ impl std::fmt::Display for NodeInfo {
138220
}
139221
}
140222

223+
impl Writeable for NodeInfo {
224+
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
225+
(self.channels.len() as u64).write(writer)?;
226+
for ref chan in self.channels.iter() {
227+
chan.write(writer)?;
228+
}
229+
self.lowest_inbound_channel_fee_base_msat.write(writer)?;
230+
self.lowest_inbound_channel_fee_proportional_millionths.write(writer)?;
231+
self.features.write(writer)?;
232+
self.last_update.write(writer)?;
233+
self.rgb.write(writer)?;
234+
self.alias.write(writer)?;
235+
(self.addresses.len() as u64).write(writer)?;
236+
for ref addr in &self.addresses {
237+
addr.write(writer)?;
238+
}
239+
match &self.announcement_message {
240+
&None => 0u8.write(writer)?,
241+
&Some(ref msg) => {
242+
1u8.write(writer)?;
243+
msg.write(writer)?;
244+
}
245+
}
246+
Ok(())
247+
}
248+
}
249+
250+
impl<R: ::std::io::Read> Readable<R> for NodeInfo {
251+
fn read(reader: &mut R) -> Result<NodeInfo, DecodeError> {
252+
let channels_count: u64 = Readable::read(reader)?;
253+
let mut channels = Vec::with_capacity(channels_count as usize);
254+
for _ in 0..channels_count {
255+
channels.push(Readable::read(reader)?);
256+
}
257+
let lowest_inbound_channel_fee_base_msat = Readable::read(reader)?;
258+
let lowest_inbound_channel_fee_proportional_millionths = Readable::read(reader)?;
259+
let features = Readable::read(reader)?;
260+
let last_update = Readable::read(reader)?;
261+
let rgb = Readable::read(reader)?;
262+
let alias = Readable::read(reader)?;
263+
let addresses_count: u64 = Readable::read(reader)?;
264+
let mut addresses = Vec::with_capacity(addresses_count as usize);
265+
for _ in 0..addresses_count {
266+
addresses.push(Readable::read(reader)?);
267+
}
268+
let announcement_message = match <u8 as Readable<R>>::read(reader)? {
269+
0 => None,
270+
1 => Some(msgs::NodeAnnouncement::read(reader)?),
271+
_ => return Err(DecodeError::InvalidValue),
272+
273+
274+
};
275+
Ok(NodeInfo {
276+
channels,
277+
lowest_inbound_channel_fee_base_msat,
278+
lowest_inbound_channel_fee_proportional_millionths,
279+
features,
280+
last_update,
281+
rgb,
282+
alias,
283+
addresses,
284+
announcement_message
285+
})
286+
}
287+
}
288+
141289
struct NetworkMap {
142290
#[cfg(feature = "non_bitcoin_chain_hash_routing")]
143291
channels: BTreeMap<(u64, Sha256dHash), ChannelInfo>,
@@ -147,6 +295,49 @@ struct NetworkMap {
147295
our_node_id: PublicKey,
148296
nodes: BTreeMap<PublicKey, NodeInfo>,
149297
}
298+
299+
impl Writeable for NetworkMap {
300+
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
301+
(self.channels.len() as u64).write(writer)?;
302+
for (ref chan_id, ref chan_info) in self.channels.iter() {
303+
(*chan_id).write(writer)?;
304+
chan_info.write(writer)?;
305+
}
306+
self.our_node_id.write(writer)?;
307+
(self.nodes.len() as u64).write(writer)?;
308+
for (ref node_id, ref node_info) in self.nodes.iter() {
309+
node_id.write(writer)?;
310+
node_info.write(writer)?;
311+
}
312+
Ok(())
313+
}
314+
}
315+
316+
impl<R: ::std::io::Read> Readable<R> for NetworkMap {
317+
fn read(reader: &mut R) -> Result<NetworkMap, DecodeError> {
318+
let channels_count: u64 = Readable::read(reader)?;
319+
let mut channels = BTreeMap::new();
320+
for _ in 0..channels_count {
321+
let chan_id: u64 = Readable::read(reader)?;
322+
let chan_info = Readable::read(reader)?;
323+
channels.insert(chan_id, chan_info);
324+
}
325+
let our_node_id = Readable::read(reader)?;
326+
let nodes_count: u64 = Readable::read(reader)?;
327+
let mut nodes = BTreeMap::new();
328+
for _ in 0..nodes_count {
329+
let node_id = Readable::read(reader)?;
330+
let node_info = Readable::read(reader)?;
331+
nodes.insert(node_id, node_info);
332+
}
333+
Ok(NetworkMap {
334+
channels,
335+
our_node_id,
336+
nodes,
337+
})
338+
}
339+
}
340+
150341
struct MutNetworkMap<'a> {
151342
#[cfg(feature = "non_bitcoin_chain_hash_routing")]
152343
channels: &'a mut BTreeMap<(u64, Sha256dHash), ChannelInfo>,
@@ -228,6 +419,48 @@ pub struct Router {
228419
logger: Arc<Logger>,
229420
}
230421

422+
const SERIALIZATION_VERSION: u8 = 1;
423+
const MIN_SERIALIZATION_VERSION: u8 = 1;
424+
425+
impl Writeable for Router {
426+
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
427+
writer.write_all(&[SERIALIZATION_VERSION; 1])?;
428+
writer.write_all(&[MIN_SERIALIZATION_VERSION; 1])?;
429+
430+
let network = self.network_map.read().unwrap();
431+
network.write(writer)?;
432+
Ok(())
433+
}
434+
}
435+
436+
/// Arguments for the creation of a Router that are not deserialized
437+
pub struct RouterReadArgs {
438+
/// The ChainWatchInterface for use in the ChannelManager in the future.
439+
///
440+
/// No calls to the ChainWatchInterface will be made during deserialization.
441+
pub chain_monitor: Arc<ChainWatchInterface>,
442+
/// The Logger for use in the ChannelManager and which may be used to log information during
443+
/// deserialization.
444+
pub logger: Arc<Logger>,
445+
}
446+
447+
impl<R: ::std::io::Read> ReadableArgs<R, RouterReadArgs> for Router {
448+
fn read(reader: &mut R, args: RouterReadArgs) -> Result<Router, DecodeError> {
449+
let _ver: u8 = Readable::read(reader)?;
450+
let min_ver: u8 = Readable::read(reader)?;
451+
if min_ver > SERIALIZATION_VERSION {
452+
return Err(DecodeError::UnknownVersion);
453+
}
454+
let network_map = Readable::read(reader)?;
455+
Ok(Router {
456+
secp_ctx: Secp256k1::verification_only(),
457+
network_map: RwLock::new(network_map),
458+
chain_monitor: args.chain_monitor,
459+
logger: args.logger,
460+
})
461+
}
462+
}
463+
231464
macro_rules! secp_verify_sig {
232465
( $secp_ctx: expr, $msg: expr, $sig: expr, $pubkey: expr ) => {
233466
match $secp_ctx.verify($msg, $sig, $pubkey) {

‎src/util/ser.rs

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -202,6 +202,10 @@ macro_rules! impl_array {
202202
}
203203

204204
//TODO: performance issue with [u8; size] with impl_array!()
205+
impl_array!(3); // for rgb
206+
impl_array!(4); // for IPv4
207+
impl_array!(10); // for OnionV2
208+
impl_array!(16); // for IPv6
205209
impl_array!(32); // for channel id & hmac
206210
impl_array!(33); // for PublicKey
207211
impl_array!(64); // for Signature

0 commit comments

Comments
 (0)