use bitcoin::util::hash::Sha256dHash;
+use chain::chaininterface::ChainWatchInterface;
use ln::channelmanager;
use ln::msgs::{ErrorAction,HandleError,RoutingMessageHandler,MsgEncodable,NetAddress,GlobalFeatures};
use ln::msgs;
pub struct Router {
secp_ctx: Secp256k1<secp256k1::VerifyOnly>,
network_map: RwLock<NetworkMap>,
+ chain_monitor: Arc<ChainWatchInterface>,
logger: Arc<Logger>,
}
}
impl RoutingMessageHandler for Router {
- fn handle_node_announcement(&self, msg: &msgs::NodeAnnouncement) -> Result<(), HandleError> {
+ fn handle_node_announcement(&self, msg: &msgs::NodeAnnouncement) -> Result<bool, HandleError> {
let msg_hash = Message::from_slice(&Sha256dHash::from_data(&msg.contents.encode()[..])[..]).unwrap();
secp_verify_sig!(self.secp_ctx, &msg_hash, &msg.signature, &msg.contents.node_id);
+ if msg.contents.features.requires_unknown_bits() {
+ panic!("Unknown-required-features NodeAnnouncements should never deserialize!");
+ }
+
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)}),
node.rgb = msg.contents.rgb;
node.alias = msg.contents.alias;
node.addresses = msg.contents.addresses.clone();
- Ok(())
+ Ok(msg.contents.excess_data.is_empty() && msg.contents.excess_address_data.is_empty() && !msg.contents.features.supports_unknown_bits())
}
}
}
//TODO: Only allow bitcoin chain_hash
if msg.contents.features.requires_unknown_bits() {
- return Err(HandleError{err: "Channel announcement required unknown feature flags", action: None});
+ panic!("Unknown-required-features ChannelAnnouncements should never deserialize!");
}
let mut network = self.network_map.write().unwrap();
add_channel_to_node!(msg.contents.node_id_1);
add_channel_to_node!(msg.contents.node_id_2);
- Ok(!msg.contents.features.supports_unknown_bits())
+ Ok(msg.contents.excess_data.is_empty() && !msg.contents.features.supports_unknown_bits())
}
fn handle_htlc_fail_channel_update(&self, update: &msgs::HTLCFailChannelUpdate) {
}
}
- fn handle_channel_update(&self, msg: &msgs::ChannelUpdate) -> Result<(), HandleError> {
+ fn handle_channel_update(&self, msg: &msgs::ChannelUpdate) -> Result<bool, HandleError> {
let mut network = self.network_map.write().unwrap();
let dest_node_id;
let chan_enabled = msg.contents.flags & (1 << 1) != (1 << 1);
mut_node.lowest_inbound_channel_fee_proportional_millionths = lowest_inbound_channel_fee_proportional_millionths;
}
- Ok(())
+ Ok(msg.contents.excess_data.is_empty())
}
}
}
impl Router {
- pub fn new(our_pubkey: PublicKey, logger: Arc<Logger>) -> Router {
+ pub fn new(our_pubkey: PublicKey, chain_monitor: Arc<ChainWatchInterface>, logger: Arc<Logger>) -> Router {
let mut nodes = HashMap::new();
nodes.insert(our_pubkey.clone(), NodeInfo {
channels: Vec::new(),
our_node_id: our_pubkey,
nodes: nodes,
}),
+ chain_monitor,
logger,
}
}
#[cfg(test)]
mod tests {
+ use chain::chaininterface;
use ln::channelmanager;
use ln::router::{Router,NodeInfo,NetworkMap,ChannelInfo,DirectionalChannelInfo,RouteHint};
use ln::msgs::GlobalFeatures;
let secp_ctx = Secp256k1::new();
let our_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap());
let logger: Arc<Logger> = Arc::new(test_utils::TestLogger::new());
- let router = Router::new(our_id, Arc::clone(&logger));
+ let chain_monitor = Arc::new(chaininterface::ChainWatchInterfaceUtil::new(Network::Testnet, Arc::clone(&logger)));
+ let router = Router::new(our_id, chain_monitor, Arc::clone(&logger));
// Build network from our_id to node8:
//