//! You probably want to create a Router and use that as your RoutingMessageHandler and then
//! interrogate it to get routes for your own payments.
-use secp256k1::key::PublicKey;
-use secp256k1::Secp256k1;
-use secp256k1;
+use bitcoin::secp256k1::key::PublicKey;
+use bitcoin::secp256k1::Secp256k1;
+use bitcoin::secp256k1;
-use bitcoin_hashes::sha256d::Hash as Sha256dHash;
-use bitcoin_hashes::Hash;
+use bitcoin::hashes::sha256d::Hash as Sha256dHash;
+use bitcoin::hashes::Hash;
+use bitcoin::hash_types::BlockHash;
use bitcoin::blockdata::script::Builder;
use bitcoin::blockdata::opcodes;
impl NetworkMap {
#[cfg(feature = "non_bitcoin_chain_hash_routing")]
#[inline]
- fn get_key(short_channel_id: u64, chain_hash: Sha256dHash) -> (u64, Sha256dHash) {
+ fn get_key(short_channel_id: u64, chain_hash: BlockHash) -> (u64, BlockHash) {
(short_channel_id, chain_hash)
}
#[cfg(not(feature = "non_bitcoin_chain_hash_routing"))]
#[inline]
- fn get_key(short_channel_id: u64, _: Sha256dHash) -> u64 {
+ fn get_key(short_channel_id: u64, _: BlockHash) -> u64 {
short_channel_id
}
#[cfg(feature = "non_bitcoin_chain_hash_routing")]
#[inline]
- fn get_short_id(id: &(u64, Sha256dHash)) -> &u64 {
+ fn get_short_id(id: &(u64, BlockHash)) -> &u64 {
&id.0
}
return Ok(Route {
paths: vec![vec![RouteHop {
pubkey: chan.remote_network_id,
- node_features: NodeFeatures::with_known_relevant_init_flags(&chan.counterparty_features),
+ node_features: chan.counterparty_features.to_context(),
short_channel_id,
- channel_features: ChannelFeatures::with_known_relevant_init_flags(&chan.counterparty_features),
+ channel_features: chan.counterparty_features.to_context(),
fee_msat: final_value_msat,
cltv_expiry_delta: final_cltv,
}]],
( $node: expr, $node_id: expr, $fee_to_target_msat: expr ) => {
if first_hops.is_some() {
if let Some(&(ref first_hop, ref features)) = first_hop_targets.get(&$node_id) {
- add_entry!(first_hop, $node_id, dummy_directional_info, ChannelFeatures::with_known_relevant_init_flags(&features), $fee_to_target_msat);
+ add_entry!(first_hop, $node_id, dummy_directional_info, features.to_context(), $fee_to_target_msat);
}
}
// bit lazy here. In the future, we should pull them out via our
// ChannelManager, but there's no reason to waste the space until we
// need them.
- add_entry!(first_hop, hop.src_node_id, dummy_directional_info, ChannelFeatures::with_known_relevant_init_flags(&features), 0);
+ add_entry!(first_hop, hop.src_node_id, dummy_directional_info, features.to_context(), 0);
}
}
// BOLT 11 doesn't allow inclusion of features for the last hop hints, which
let mut res = vec!(dist.remove(&network.our_node_id).unwrap().3);
loop {
if let Some(&(_, ref features)) = first_hop_targets.get(&res.last().unwrap().pubkey) {
- res.last_mut().unwrap().node_features = NodeFeatures::with_known_relevant_init_flags(&features);
+ res.last_mut().unwrap().node_features = features.to_context();
} else if let Some(node) = network.nodes.get(&res.last().unwrap().pubkey) {
res.last_mut().unwrap().node_features = node.features.clone();
} else {
use util::logger::Logger;
use util::ser::{Writeable, Readable};
- use bitcoin_hashes::sha256d::Hash as Sha256dHash;
- use bitcoin_hashes::Hash;
+ use bitcoin::hashes::sha256d::Hash as Sha256dHash;
+ use bitcoin::hashes::Hash;
+ use bitcoin::hash_types::BlockHash;
use bitcoin::network::constants::Network;
use bitcoin::blockdata::constants::genesis_block;
use bitcoin::blockdata::script::Builder;
use hex;
- use secp256k1::key::{PublicKey,SecretKey};
- use secp256k1::All;
- use secp256k1::Secp256k1;
+ use bitcoin::secp256k1::key::{PublicKey,SecretKey};
+ use bitcoin::secp256k1::All;
+ use bitcoin::secp256k1::Secp256k1;
use std::sync::Arc;
use std::collections::btree_map::Entry as BtreeEntry;
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::hash(&[0; 32]);
+ let zero_hash = BlockHash::hash(&[0; 32]);
macro_rules! id_to_feature_flags {
// Set the feature flags to the id'th odd (ie non-required) feature bit so that we can
{ // Disable channels 4 and 12 by requiring unknown feature bits
let mut network = router.network_map.write().unwrap();
- network.channels.get_mut(&NetworkMap::get_key(4, zero_hash.clone())).unwrap().features.set_require_unknown_bits();
- network.channels.get_mut(&NetworkMap::get_key(12, zero_hash.clone())).unwrap().features.set_require_unknown_bits();
+ network.channels.get_mut(&NetworkMap::get_key(4, zero_hash.clone())).unwrap().features.set_required_unknown_bits();
+ network.channels.get_mut(&NetworkMap::get_key(12, zero_hash.clone())).unwrap().features.set_required_unknown_bits();
}
{ // If all the channels require some features we don't understand, route should fail
{ // Re-enable channels 4 and 12 by wiping the unknown feature bits
let mut network = router.network_map.write().unwrap();
- network.channels.get_mut(&NetworkMap::get_key(4, zero_hash.clone())).unwrap().features.clear_require_unknown_bits();
- network.channels.get_mut(&NetworkMap::get_key(12, zero_hash.clone())).unwrap().features.clear_require_unknown_bits();
+ network.channels.get_mut(&NetworkMap::get_key(4, zero_hash.clone())).unwrap().features.clear_unknown_bits();
+ network.channels.get_mut(&NetworkMap::get_key(12, zero_hash.clone())).unwrap().features.clear_unknown_bits();
}
{ // Disable nodes 1, 2, and 8 by requiring unknown feature bits
let mut network = router.network_map.write().unwrap();
- network.nodes.get_mut(&node1).unwrap().features.set_require_unknown_bits();
- network.nodes.get_mut(&node2).unwrap().features.set_require_unknown_bits();
- network.nodes.get_mut(&node8).unwrap().features.set_require_unknown_bits();
+ network.nodes.get_mut(&node1).unwrap().features.set_required_unknown_bits();
+ network.nodes.get_mut(&node2).unwrap().features.set_required_unknown_bits();
+ network.nodes.get_mut(&node8).unwrap().features.set_required_unknown_bits();
}
{ // If all nodes require some features we don't understand, route should fail
{ // Re-enable nodes 1, 2, and 8
let mut network = router.network_map.write().unwrap();
- network.nodes.get_mut(&node1).unwrap().features.clear_require_unknown_bits();
- network.nodes.get_mut(&node2).unwrap().features.clear_require_unknown_bits();
- network.nodes.get_mut(&node8).unwrap().features.clear_require_unknown_bits();
+ network.nodes.get_mut(&node1).unwrap().features.clear_unknown_bits();
+ network.nodes.get_mut(&node2).unwrap().features.clear_unknown_bits();
+ network.nodes.get_mut(&node8).unwrap().features.clear_unknown_bits();
}
// Note that we don't test disabling node 3 and failing to route to it, as we (somewhat
let first_announcement_time = 500;
let mut unsigned_announcement = UnsignedNodeAnnouncement {
- features: NodeFeatures::supported(),
+ features: NodeFeatures::known(),
timestamp: first_announcement_time,
node_id: node_id_1,
rgb: [0; 3],
{
// Announce a channel to add a corresponding node.
let unsigned_announcement = UnsignedChannelAnnouncement {
- features: ChannelFeatures::supported(),
+ features: ChannelFeatures::known(),
chain_hash: genesis_block(Network::Testnet).header.bitcoin_hash(),
short_channel_id: 0,
node_id_1,
let mut unsigned_announcement = UnsignedChannelAnnouncement {
- features: ChannelFeatures::supported(),
+ features: ChannelFeatures::known(),
chain_hash: genesis_block(Network::Testnet).header.bitcoin_hash(),
short_channel_id: 0,
node_id_1,
{
let mut unsigned_announcement = UnsignedNodeAnnouncement {
- features: NodeFeatures::supported(),
+ features: NodeFeatures::known(),
timestamp: 1000,
node_id: node_id_1,
rgb: [0; 3],
{
// Later announcement which should not be relayed (excess data) prevent us from sharing a node
let unsigned_announcement = UnsignedNodeAnnouncement {
- features: NodeFeatures::supported(),
+ features: NodeFeatures::known(),
timestamp: 1010,
node_id: node_id_2,
rgb: [0; 3],
projects / rust-lightning / blobdiff