//! interrogate it to get routes for your own payments.
use secp256k1::key::PublicKey;
-use secp256k1::{Secp256k1,Message};
+use secp256k1::Secp256k1;
use secp256k1;
-use bitcoin::util::hash::Sha256dHash;
+use bitcoin_hashes::sha256d::Hash as Sha256dHash;
+use bitcoin_hashes::Hash;
use bitcoin::blockdata::script::Builder;
use bitcoin::blockdata::opcodes;
use chain::chaininterface::{ChainError, ChainWatchInterface};
use ln::channelmanager;
-use ln::msgs::{DecodeError,ErrorAction,HandleError,RoutingMessageHandler,NetAddress,GlobalFeatures};
+use ln::msgs::{DecodeError,ErrorAction,LightningError,RoutingMessageHandler,NetAddress,GlobalFeatures};
use ln::msgs;
-use util::ser::{Writeable, Readable};
+use util::ser::{Writeable, Readable, Writer, ReadableArgs};
use util::logger::Logger;
use std::cmp;
}
}
+#[derive(PartialEq)]
struct DirectionalChannelInfo {
src_node_id: PublicKey,
last_update: u32,
}
}
+impl_writeable!(DirectionalChannelInfo, 0, {
+ src_node_id,
+ last_update,
+ enabled,
+ cltv_expiry_delta,
+ htlc_minimum_msat,
+ fee_base_msat,
+ fee_proportional_millionths,
+ last_update_message
+});
+
+#[derive(PartialEq)]
struct ChannelInfo {
features: GlobalFeatures,
one_to_two: DirectionalChannelInfo,
}
}
+impl_writeable!(ChannelInfo, 0, {
+ features,
+ one_to_two,
+ two_to_one,
+ announcement_message
+});
+
+#[derive(PartialEq)]
struct NodeInfo {
#[cfg(feature = "non_bitcoin_chain_hash_routing")]
channels: Vec<(u64, Sha256dHash)>,
}
}
+impl Writeable for NodeInfo {
+ fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
+ (self.channels.len() as u64).write(writer)?;
+ for ref chan in self.channels.iter() {
+ chan.write(writer)?;
+ }
+ self.lowest_inbound_channel_fee_base_msat.write(writer)?;
+ self.lowest_inbound_channel_fee_proportional_millionths.write(writer)?;
+ self.features.write(writer)?;
+ self.last_update.write(writer)?;
+ self.rgb.write(writer)?;
+ self.alias.write(writer)?;
+ (self.addresses.len() as u64).write(writer)?;
+ for ref addr in &self.addresses {
+ addr.write(writer)?;
+ }
+ self.announcement_message.write(writer)?;
+ Ok(())
+ }
+}
+
+const MAX_ALLOC_SIZE: u64 = 64*1024;
+
+impl<R: ::std::io::Read> Readable<R> for NodeInfo {
+ fn read(reader: &mut R) -> Result<NodeInfo, DecodeError> {
+ let channels_count: u64 = Readable::read(reader)?;
+ let mut channels = Vec::with_capacity(cmp::min(channels_count, MAX_ALLOC_SIZE / 8) as usize);
+ for _ in 0..channels_count {
+ channels.push(Readable::read(reader)?);
+ }
+ let lowest_inbound_channel_fee_base_msat = Readable::read(reader)?;
+ let lowest_inbound_channel_fee_proportional_millionths = Readable::read(reader)?;
+ let features = Readable::read(reader)?;
+ let last_update = Readable::read(reader)?;
+ let rgb = Readable::read(reader)?;
+ let alias = Readable::read(reader)?;
+ let addresses_count: u64 = Readable::read(reader)?;
+ let mut addresses = Vec::with_capacity(cmp::min(addresses_count, MAX_ALLOC_SIZE / 40) as usize);
+ for _ in 0..addresses_count {
+ match Readable::read(reader) {
+ Ok(Ok(addr)) => { addresses.push(addr); },
+ Ok(Err(_)) => return Err(DecodeError::InvalidValue),
+ Err(DecodeError::ShortRead) => return Err(DecodeError::BadLengthDescriptor),
+ _ => unreachable!(),
+ }
+ }
+ let announcement_message = Readable::read(reader)?;
+ Ok(NodeInfo {
+ channels,
+ lowest_inbound_channel_fee_base_msat,
+ lowest_inbound_channel_fee_proportional_millionths,
+ features,
+ last_update,
+ rgb,
+ alias,
+ addresses,
+ announcement_message
+ })
+ }
+}
+
+#[derive(PartialEq)]
struct NetworkMap {
#[cfg(feature = "non_bitcoin_chain_hash_routing")]
channels: BTreeMap<(u64, Sha256dHash), ChannelInfo>,
our_node_id: PublicKey,
nodes: BTreeMap<PublicKey, NodeInfo>,
}
+
+impl Writeable for NetworkMap {
+ fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
+ (self.channels.len() as u64).write(writer)?;
+ for (ref chan_id, ref chan_info) in self.channels.iter() {
+ (*chan_id).write(writer)?;
+ chan_info.write(writer)?;
+ }
+ self.our_node_id.write(writer)?;
+ (self.nodes.len() as u64).write(writer)?;
+ for (ref node_id, ref node_info) in self.nodes.iter() {
+ node_id.write(writer)?;
+ node_info.write(writer)?;
+ }
+ Ok(())
+ }
+}
+
+impl<R: ::std::io::Read> Readable<R> for NetworkMap {
+ fn read(reader: &mut R) -> Result<NetworkMap, DecodeError> {
+ let channels_count: u64 = Readable::read(reader)?;
+ let mut channels = BTreeMap::new();
+ for _ in 0..channels_count {
+ let chan_id: u64 = Readable::read(reader)?;
+ let chan_info = Readable::read(reader)?;
+ channels.insert(chan_id, chan_info);
+ }
+ let our_node_id = Readable::read(reader)?;
+ let nodes_count: u64 = Readable::read(reader)?;
+ let mut nodes = BTreeMap::new();
+ for _ in 0..nodes_count {
+ let node_id = Readable::read(reader)?;
+ let node_info = Readable::read(reader)?;
+ nodes.insert(node_id, node_info);
+ }
+ Ok(NetworkMap {
+ channels,
+ our_node_id,
+ nodes,
+ })
+ }
+}
+
struct MutNetworkMap<'a> {
#[cfg(feature = "non_bitcoin_chain_hash_routing")]
channels: &'a mut BTreeMap<(u64, Sha256dHash), ChannelInfo>,
logger: Arc<Logger>,
}
+const SERIALIZATION_VERSION: u8 = 1;
+const MIN_SERIALIZATION_VERSION: u8 = 1;
+
+impl Writeable for Router {
+ fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
+ writer.write_all(&[SERIALIZATION_VERSION; 1])?;
+ writer.write_all(&[MIN_SERIALIZATION_VERSION; 1])?;
+
+ let network = self.network_map.read().unwrap();
+ network.write(writer)?;
+ Ok(())
+ }
+}
+
+/// Arguments for the creation of a Router that are not deserialized.
+/// At a high-level, the process for deserializing a Router and resuming normal operation is:
+/// 1) Deserialize the Router by filling in this struct and calling <Router>::read(reaser, args).
+/// 2) Register the new Router with your ChainWatchInterface
+pub struct RouterReadArgs {
+ /// The ChainWatchInterface for use in the Router in the future.
+ ///
+ /// No calls to the ChainWatchInterface will be made during deserialization.
+ pub chain_monitor: Arc<ChainWatchInterface>,
+ /// The Logger for use in the ChannelManager and which may be used to log information during
+ /// deserialization.
+ pub logger: Arc<Logger>,
+}
+
+impl<R: ::std::io::Read> ReadableArgs<R, RouterReadArgs> for Router {
+ fn read(reader: &mut R, args: RouterReadArgs) -> Result<Router, DecodeError> {
+ let _ver: u8 = Readable::read(reader)?;
+ let min_ver: u8 = Readable::read(reader)?;
+ if min_ver > SERIALIZATION_VERSION {
+ return Err(DecodeError::UnknownVersion);
+ }
+ let network_map = Readable::read(reader)?;
+ Ok(Router {
+ secp_ctx: Secp256k1::verification_only(),
+ network_map: RwLock::new(network_map),
+ chain_monitor: args.chain_monitor,
+ logger: args.logger,
+ })
+ }
+}
+
macro_rules! secp_verify_sig {
( $secp_ctx: expr, $msg: expr, $sig: expr, $pubkey: expr ) => {
match $secp_ctx.verify($msg, $sig, $pubkey) {
Ok(_) => {},
- Err(_) => return Err(HandleError{err: "Invalid signature from remote node", action: None}),
+ Err(_) => return Err(LightningError{err: "Invalid signature from remote node", action: ErrorAction::IgnoreError}),
}
};
}
impl RoutingMessageHandler for Router {
- fn handle_node_announcement(&self, msg: &msgs::NodeAnnouncement) -> Result<bool, HandleError> {
- let msg_hash = Message::from_slice(&Sha256dHash::from_data(&msg.contents.encode()[..])[..]).unwrap();
+ fn handle_node_announcement(&self, msg: &msgs::NodeAnnouncement) -> Result<bool, LightningError> {
+ let msg_hash = hash_to_message!(&Sha256dHash::hash(&msg.contents.encode()[..])[..]);
secp_verify_sig!(self.secp_ctx, &msg_hash, &msg.signature, &msg.contents.node_id);
if msg.contents.features.requires_unknown_bits() {
let mut network = self.network_map.write().unwrap();
match network.nodes.get_mut(&msg.contents.node_id) {
- None => Err(HandleError{err: "No existing channels for node_announcement", action: Some(ErrorAction::IgnoreError)}),
+ None => Err(LightningError{err: "No existing channels for node_announcement", action: ErrorAction::IgnoreError}),
Some(node) => {
if node.last_update >= msg.contents.timestamp {
- return Err(HandleError{err: "Update older than last processed update", action: Some(ErrorAction::IgnoreError)});
+ return Err(LightningError{err: "Update older than last processed update", action: ErrorAction::IgnoreError});
}
node.features = msg.contents.features.clone();
}
}
- fn handle_channel_announcement(&self, msg: &msgs::ChannelAnnouncement) -> Result<bool, HandleError> {
+ fn handle_channel_announcement(&self, msg: &msgs::ChannelAnnouncement) -> Result<bool, LightningError> {
if msg.contents.node_id_1 == msg.contents.node_id_2 || msg.contents.bitcoin_key_1 == msg.contents.bitcoin_key_2 {
- return Err(HandleError{err: "Channel announcement node had a channel with itself", action: Some(ErrorAction::IgnoreError)});
+ return Err(LightningError{err: "Channel announcement node had a channel with itself", action: ErrorAction::IgnoreError});
}
- let msg_hash = Message::from_slice(&Sha256dHash::from_data(&msg.contents.encode()[..])[..]).unwrap();
+ let msg_hash = hash_to_message!(&Sha256dHash::hash(&msg.contents.encode()[..])[..]);
secp_verify_sig!(self.secp_ctx, &msg_hash, &msg.node_signature_1, &msg.contents.node_id_1);
secp_verify_sig!(self.secp_ctx, &msg_hash, &msg.node_signature_2, &msg.contents.node_id_2);
secp_verify_sig!(self.secp_ctx, &msg_hash, &msg.bitcoin_signature_1, &msg.contents.bitcoin_key_1);
.push_opcode(opcodes::all::OP_PUSHNUM_2)
.push_opcode(opcodes::all::OP_CHECKMULTISIG).into_script().to_v0_p2wsh();
if script_pubkey != expected_script {
- return Err(HandleError{err: "Channel announcement keys didn't match on-chain script", action: Some(ErrorAction::IgnoreError)});
+ return Err(LightningError{err: "Channel announcement keys didn't match on-chain script", action: ErrorAction::IgnoreError});
}
//TODO: Check if value is worth storing, use it to inform routing, and compare it
//to the new HTLC max field in channel_update
false
},
Err(ChainError::NotWatched) => {
- return Err(HandleError{err: "Channel announced on an unknown chain", action: Some(ErrorAction::IgnoreError)});
+ return Err(LightningError{err: "Channel announced on an unknown chain", action: ErrorAction::IgnoreError});
},
Err(ChainError::UnknownTx) => {
- return Err(HandleError{err: "Channel announced without corresponding UTXO entry", action: Some(ErrorAction::IgnoreError)});
+ return Err(LightningError{err: "Channel announced without corresponding UTXO entry", action: ErrorAction::IgnoreError});
},
};
match network.channels.entry(NetworkMap::get_key(msg.contents.short_channel_id, msg.contents.chain_hash)) {
BtreeEntry::Occupied(mut entry) => {
//TODO: because asking the blockchain if short_channel_id is valid is only optional
- //in the blockchain API, we need to handle it smartly here, though its unclear
+ //in the blockchain API, we need to handle it smartly here, though it's unclear
//exactly how...
if checked_utxo {
// Either our UTXO provider is busted, there was a reorg, or the UTXO provider
Self::remove_channel_in_nodes(network.nodes, &entry.get(), msg.contents.short_channel_id);
*entry.get_mut() = chan_info;
} else {
- return Err(HandleError{err: "Already have knowledge of channel", action: Some(ErrorAction::IgnoreError)})
+ return Err(LightningError{err: "Already have knowledge of channel", action: ErrorAction::IgnoreError})
}
},
BtreeEntry::Vacant(entry) => {
}
}
- fn handle_channel_update(&self, msg: &msgs::ChannelUpdate) -> Result<bool, HandleError> {
+ fn handle_channel_update(&self, msg: &msgs::ChannelUpdate) -> Result<bool, LightningError> {
let mut network = self.network_map.write().unwrap();
let dest_node_id;
let chan_enabled = msg.contents.flags & (1 << 1) != (1 << 1);
let chan_was_enabled;
match network.channels.get_mut(&NetworkMap::get_key(msg.contents.short_channel_id, msg.contents.chain_hash)) {
- None => return Err(HandleError{err: "Couldn't find channel for update", action: Some(ErrorAction::IgnoreError)}),
+ None => return Err(LightningError{err: "Couldn't find channel for update", action: ErrorAction::IgnoreError}),
Some(channel) => {
macro_rules! maybe_update_channel_info {
( $target: expr) => {
if $target.last_update >= msg.contents.timestamp {
- return Err(HandleError{err: "Update older than last processed update", action: Some(ErrorAction::IgnoreError)});
+ return Err(LightningError{err: "Update older than last processed update", action: ErrorAction::IgnoreError});
}
chan_was_enabled = $target.enabled;
$target.last_update = msg.contents.timestamp;
};
}
}
- let msg_hash = Message::from_slice(&Sha256dHash::from_data(&msg.contents.encode()[..])[..]).unwrap();
+ let msg_hash = hash_to_message!(&Sha256dHash::hash(&msg.contents.encode()[..])[..]);
if msg.contents.flags & 1 == 1 {
dest_node_id = channel.one_to_two.src_node_id.clone();
secp_verify_sig!(self.secp_ctx, &msg_hash, &msg.signature, &channel.two_to_one.src_node_id);
}
/// Marks a node as having failed a route. This will avoid re-using the node in routes for now,
- /// with an expotnential decay in node "badness". Note that there is deliberately no
+ /// with an exponential decay in node "badness". Note that there is deliberately no
/// mark_channel_bad as a node may simply lie and suggest that an upstream channel from it is
/// what failed the route and not the node itself. Instead, setting the blamed_upstream_node
/// boolean will reduce the penalty, returning the node to usability faster. If the node is
/// The fees on channels from us to next-hops are ignored (as they are assumed to all be
/// equal), however the enabled/disabled bit on such channels as well as the htlc_minimum_msat
/// *is* checked as they may change based on the receiving node.
- pub fn get_route(&self, target: &PublicKey, first_hops: Option<&[channelmanager::ChannelDetails]>, last_hops: &[RouteHint], final_value_msat: u64, final_cltv: u32) -> Result<Route, HandleError> {
+ pub fn get_route(&self, target: &PublicKey, first_hops: Option<&[channelmanager::ChannelDetails]>, last_hops: &[RouteHint], final_value_msat: u64, final_cltv: u32) -> Result<Route, LightningError> {
// TODO: Obviously *only* using total fee cost sucks. We should consider weighting by
// uptime/success in using a node in the past.
let network = self.network_map.read().unwrap();
if *target == network.our_node_id {
- return Err(HandleError{err: "Cannot generate a route to ourselves", action: None});
+ return Err(LightningError{err: "Cannot generate a route to ourselves", action: ErrorAction::IgnoreError});
}
if final_value_msat > 21_000_000 * 1_0000_0000 * 1000 {
- return Err(HandleError{err: "Cannot generate a route of more value than all existing satoshis", action: None});
+ return Err(LightningError{err: "Cannot generate a route of more value than all existing satoshis", action: ErrorAction::IgnoreError});
}
// We do a dest-to-source Dijkstra's sorting by each node's distance from the destination
first_hop_targets.insert(chan.remote_network_id, short_channel_id);
}
if first_hop_targets.is_empty() {
- return Err(HandleError{err: "Cannot route when there are no outbound routes away from us", action: None});
+ return Err(LightningError{err: "Cannot route when there are no outbound routes away from us", action: ErrorAction::IgnoreError});
}
}
while res.last().unwrap().pubkey != *target {
let new_entry = match dist.remove(&res.last().unwrap().pubkey) {
Some(hop) => hop.3,
- None => return Err(HandleError{err: "Failed to find a non-fee-overflowing path to the given destination", action: None}),
+ None => return Err(LightningError{err: "Failed to find a non-fee-overflowing path to the given destination", action: ErrorAction::IgnoreError}),
};
res.last_mut().unwrap().fee_msat = new_entry.fee_msat;
res.last_mut().unwrap().cltv_expiry_delta = new_entry.cltv_expiry_delta;
}
}
- Err(HandleError{err: "Failed to find a path to the given destination", action: None})
+ Err(LightningError{err: "Failed to find a path to the given destination", action: ErrorAction::IgnoreError})
}
}
use ln::router::{Router,NodeInfo,NetworkMap,ChannelInfo,DirectionalChannelInfo,RouteHint};
use ln::msgs::GlobalFeatures;
use util::test_utils;
+ use util::test_utils::TestVecWriter;
use util::logger::Logger;
+ use util::ser::{Writeable, Readable};
- use bitcoin::util::hash::Sha256dHash;
+ use bitcoin_hashes::sha256d::Hash as Sha256dHash;
+ use bitcoin_hashes::Hash;
use bitcoin::network::constants::Network;
use hex;
let node7 = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode("0808080808080808080808080808080808080808080808080808080808080808").unwrap()[..]).unwrap());
let node8 = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode("0909090909090909090909090909090909090909090909090909090909090909").unwrap()[..]).unwrap());
- let zero_hash = Sha256dHash::from_data(&[0; 32]);
+ let zero_hash = Sha256dHash::hash(&[0; 32]);
{
let mut network = router.network_map.write().unwrap();
remote_network_id: node8.clone(),
channel_value_satoshis: 0,
user_id: 0,
+ outbound_capacity_msat: 0,
+ inbound_capacity_msat: 0,
+ is_live: true,
}];
let route = router.get_route(&node3, Some(&our_chans), &Vec::new(), 100, 42).unwrap();
assert_eq!(route.hops.len(), 2);
remote_network_id: node4.clone(),
channel_value_satoshis: 0,
user_id: 0,
+ outbound_capacity_msat: 0,
+ inbound_capacity_msat: 0,
+ is_live: true,
}];
let route = router.get_route(&node7, Some(&our_chans), &last_hops, 100, 42).unwrap();
assert_eq!(route.hops.len(), 2);
assert_eq!(route.hops[4].fee_msat, 2000);
assert_eq!(route.hops[4].cltv_expiry_delta, 42);
}
+
+ { // Test Router serialization/deserialization
+ let mut w = TestVecWriter(Vec::new());
+ let network = router.network_map.read().unwrap();
+ assert!(!network.channels.is_empty());
+ assert!(!network.nodes.is_empty());
+ network.write(&mut w).unwrap();
+ assert!(<NetworkMap>::read(&mut ::std::io::Cursor::new(&w.0)).unwrap() == *network);
+ }
}
}