pub fn create_channel(&self, their_network_key: PublicKey, channel_value_satoshis: u64, user_id: u64) -> Result<msgs::OpenChannel, HandleError> {
let channel = Channel::new_outbound(&*self.fee_estimator, their_network_key, channel_value_satoshis, self.announce_channels_publicly, user_id);
- let res = try!(channel.get_open_channel(self.genesis_hash.clone(), &*self.fee_estimator));
+ let res = channel.get_open_channel(self.genesis_hash.clone(), &*self.fee_estimator)?;
let mut channels = self.channels.lock().unwrap();
match channels.by_id.insert(channel.channel_id(), channel) {
Some(_) => panic!("RNG is bad???"),
let associated_data = Vec::new(); //TODO: What to put here?
- let onion_keys = try!(ChannelManager::construct_onion_keys(&self.secp_ctx, route, &session_priv));
- let (onion_payloads, htlc_msat, htlc_cltv) = try!(ChannelManager::build_onion_payloads(route));
- let onion_packet = try!(ChannelManager::construct_onion_packet(onion_payloads, onion_keys, associated_data));
+ let onion_keys = ChannelManager::construct_onion_keys(&self.secp_ctx, route, &session_priv)?;
+ let (onion_payloads, htlc_msat, htlc_cltv) = ChannelManager::build_onion_payloads(route)?;
+ let onion_packet = ChannelManager::construct_onion_packet(onion_payloads, onion_keys, associated_data)?;
let mut channels = self.channels.lock().unwrap();
let id = match channels.short_to_id.get(&route.hops.first().unwrap().short_channel_id) {
fn get_announcement_sigs(&self, chan: &Channel) -> Result<Option<msgs::AnnouncementSignatures>, HandleError> {
if !chan.is_usable() { return Ok(None) }
- let (announcement, our_bitcoin_sig) = try!(chan.get_channel_announcement(self.get_our_node_id(), self.genesis_hash.clone()));
+ let (announcement, our_bitcoin_sig) = chan.get_channel_announcement(self.get_our_node_id(), self.genesis_hash.clone())?;
let msghash = Message::from_slice(&Sha256dHash::from_data(&announcement.encode()[..])[..]).unwrap();
let our_node_sig = secp_call!(self.secp_ctx.sign(&msghash, &self.our_network_key));
if channels.by_id.contains_key(&msg.temporary_channel_id) {
return Err(HandleError{err: "temporary_channel_id collision!", msg: None});
}
- let channel = try!(Channel::new_from_req(&*self.fee_estimator, their_node_id.clone(), msg, 0, self.announce_channels_publicly));
- let accept_msg = try!(channel.get_accept_channel());
+ let channel = Channel::new_from_req(&*self.fee_estimator, their_node_id.clone(), msg, 0, self.announce_channels_publicly)?;
+ let accept_msg = channel.get_accept_channel()?;
channels.by_id.insert(channel.channel_id(), channel);
Ok(accept_msg)
}
if chan.get_their_node_id() != *their_node_id {
return Err(HandleError{err: "Got a message for a channel from the wrong node!", msg: None})
}
- try!(chan.accept_channel(&msg));
+ chan.accept_channel(&msg)?;
(chan.get_value_satoshis(), chan.get_funding_redeemscript().to_v0_p2wsh(), chan.get_user_id())
},
None => return Err(HandleError{err: "Failed to find corresponding channel", msg: None})
// channel back-to-back with funding_created, we'll end up thinking they sent a message
// for a bogus channel.
let chan_monitor = chan.0.channel_monitor();
- try!(self.monitor.add_update_monitor(chan_monitor.get_funding_txo().unwrap(), chan_monitor));
+ self.monitor.add_update_monitor(chan_monitor.get_funding_txo().unwrap(), chan_monitor)?;
let mut channels = self.channels.lock().unwrap();
channels.by_id.insert(chan.1.channel_id, chan.0);
Ok(chan.1)
if chan.get_their_node_id() != *their_node_id {
return Err(HandleError{err: "Got a message for a channel from the wrong node!", msg: None})
}
- try!(chan.funding_signed(&msg));
+ chan.funding_signed(&msg)?;
(chan.get_funding_txo().unwrap(), chan.get_user_id())
},
None => return Err(HandleError{err: "Failed to find corresponding channel", msg: None})
if chan.get_their_node_id() != *their_node_id {
return Err(HandleError{err: "Got a message for a channel from the wrong node!", msg: None})
}
- try!(chan.funding_locked(&msg));
- return Ok(try!(self.get_announcement_sigs(chan)));
+ chan.funding_locked(&msg)?;
+ return Ok(self.get_announcement_sigs(chan)?);
},
None => return Err(HandleError{err: "Failed to find corresponding channel", msg: None})
};
if chan.get_their_node_id() != *their_node_id {
return Err(HandleError{err: "Got a message for a channel from the wrong node!", msg: None})
}
- (try!(chan.commitment_signed(&msg)), chan.channel_monitor())
+ (chan.commitment_signed(&msg)?, chan.channel_monitor())
},
None => return Err(HandleError{err: "Failed to find corresponding channel", msg: None})
}
};
//TODO: Only if we store HTLC sigs
- try!(self.monitor.add_update_monitor(monitor.get_funding_txo().unwrap(), monitor));
+ self.monitor.add_update_monitor(monitor.get_funding_txo().unwrap(), monitor)?;
let mut forward_event = None;
{
if chan.get_their_node_id() != *their_node_id {
return Err(HandleError{err: "Got a message for a channel from the wrong node!", msg: None})
}
- try!(chan.revoke_and_ack(&msg));
+ chan.revoke_and_ack(&msg)?;
chan.channel_monitor()
},
None => return Err(HandleError{err: "Failed to find corresponding channel", msg: None})
}
};
- try!(self.monitor.add_update_monitor(monitor.get_funding_txo().unwrap(), monitor));
+ self.monitor.add_update_monitor(monitor.get_funding_txo().unwrap(), monitor)?;
Ok(())
}
}
let our_node_id = self.get_our_node_id();
- let (announcement, our_bitcoin_sig) = try!(chan.get_channel_announcement(our_node_id.clone(), self.genesis_hash.clone()));
+ let (announcement, our_bitcoin_sig) = chan.get_channel_announcement(our_node_id.clone(), self.genesis_hash.clone())?;
let were_node_one = announcement.node_id_1 == our_node_id;
let msghash = Message::from_slice(&Sha256dHash::from_data(&announcement.encode()[..])[..]).unwrap();
#[cfg(test)]
mod tests {
+ use chain::chaininterface;
use ln::channelmanager::{ChannelManager,OnionKeys};
use ln::router::{Route, RouteHop, Router};
use ln::msgs;
}
static mut CHAN_COUNT: u16 = 0;
- fn confirm_transaction(chain: &test_utils::TestWatchInterface, tx: &Transaction) {
+ fn confirm_transaction(chain: &chaininterface::ChainWatchInterfaceUtil, tx: &Transaction) {
let mut header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
let chan_id = unsafe { CHAN_COUNT };
- chain.watch_util.do_call_block_connected(&header, 1, &[tx; 1], &[chan_id as u32; 1]);
+ chain.block_connected_checked(&header, 1, &[tx; 1], &[chan_id as u32; 1]);
for i in 2..100 {
header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
- chain.watch_util.do_call_block_connected(&header, i, &[tx; 0], &[0; 0]);
+ chain.block_connected_checked(&header, i, &[tx; 0], &[0; 0]);
}
}
- fn create_chan_between_nodes(node_a: &ChannelManager, chain_a: &test_utils::TestWatchInterface, node_b: &ChannelManager, chain_b: &test_utils::TestWatchInterface) -> (msgs::ChannelAnnouncement, msgs::ChannelUpdate, msgs::ChannelUpdate) {
+ fn create_chan_between_nodes(node_a: &ChannelManager, chain_a: &chaininterface::ChainWatchInterfaceUtil, node_b: &ChannelManager, chain_b: &chaininterface::ChainWatchInterfaceUtil) -> (msgs::ChannelAnnouncement, msgs::ChannelUpdate, msgs::ChannelUpdate) {
let open_chan = node_a.create_channel(node_b.get_our_node_id(), (1 << 24) - 1, 42).unwrap();
let accept_chan = node_b.handle_open_channel(&node_a.get_our_node_id(), &open_chan).unwrap();
node_a.handle_accept_channel(&node_b.get_our_node_id(), &accept_chan).unwrap();
let secp_ctx = Secp256k1::new();
let feeest_1 = Arc::new(test_utils::TestFeeEstimator { sat_per_vbyte: 1 });
- let chain_monitor_1 = Arc::new(test_utils::TestWatchInterface::new());
+ let chain_monitor_1 = Arc::new(chaininterface::ChainWatchInterfaceUtil::new());
let chan_monitor_1 = Arc::new(test_utils::TestChannelMonitor{});
let node_id_1 = {
let mut key_slice = [0; 32];
let router_1 = Router::new(PublicKey::from_secret_key(&secp_ctx, &node_id_1).unwrap());
let feeest_2 = Arc::new(test_utils::TestFeeEstimator { sat_per_vbyte: 1 });
- let chain_monitor_2 = Arc::new(test_utils::TestWatchInterface::new());
+ let chain_monitor_2 = Arc::new(chaininterface::ChainWatchInterfaceUtil::new());
let chan_monitor_2 = Arc::new(test_utils::TestChannelMonitor{});
let node_id_2 = {
let mut key_slice = [0; 32];
let router_2 = Router::new(PublicKey::from_secret_key(&secp_ctx, &node_id_2).unwrap());
let feeest_3 = Arc::new(test_utils::TestFeeEstimator { sat_per_vbyte: 1 });
- let chain_monitor_3 = Arc::new(test_utils::TestWatchInterface::new());
+ let chain_monitor_3 = Arc::new(chaininterface::ChainWatchInterfaceUtil::new());
let chan_monitor_3 = Arc::new(test_utils::TestChannelMonitor{});
let node_id_3 = {
let mut key_slice = [0; 32];
let router_3 = Router::new(PublicKey::from_secret_key(&secp_ctx, &node_id_3).unwrap());
let feeest_4 = Arc::new(test_utils::TestFeeEstimator { sat_per_vbyte: 1 });
- let chain_monitor_4 = Arc::new(test_utils::TestWatchInterface::new());
+ let chain_monitor_4 = Arc::new(chaininterface::ChainWatchInterfaceUtil::new());
let chan_monitor_4 = Arc::new(test_utils::TestChannelMonitor{});
let node_id_4 = {
let mut key_slice = [0; 32];
projects / rust-lightning / blobdiff