mirrors/rust-lightning
1
0
Fork 0
mirror of https://github.com/lightningdevkit/rust-lightning.git synced 2025-02-25 07:17:40 +01:00
Code Issues Projects Releases Packages Wiki Activity

Make channel open confs configurable (and change from 12 to 6)

Browse source 
This fixes compatibility with c-lightning etc as they won't accept
a minimum_depth of 12.
This commit is contained in:
Sebastian Geisler 2019-03-26 12:16:20 -07:00 • committed by Matt Corallo
parent f5a572926f
commit 80aa4f20a9
5 changed files with 43 additions and 29 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
fuzz/fuzz_targets/chanmon_fail_consistency.rs
View file

@ -148,7 +148,7 @@ pub fn do_test(data: &[u8]) {
let mut config = UserConfig::new();
config.channel_options.fee_proportional_millionths = 0;
config.channel_options.announced_channel = true;
config.channel_limits.min_dust_limit_satoshis = 0;
config.peer_channel_config_limits.min_dust_limit_satoshis = 0;
(ChannelManager::new(Network::Bitcoin, fee_est.clone(), monitor.clone(), watch.clone(), broadcast.clone(), Arc::clone(&logger), keys_manager.clone(), config).unwrap(),
monitor)
} }

2
fuzz/fuzz_targets/full_stack_target.rs
View file

@ -350,7 +350,7 @@ pub fn do_test(data: &[u8], logger: &Arc<Logger>) {
let mut config = UserConfig::new();
config.channel_options.fee_proportional_millionths = slice_to_be32(get_slice!(4));
config.channel_options.announced_channel = get_slice!(1)[0] != 0;
config.channel_limits.min_dust_limit_satoshis = 0;
config.peer_channel_config_limits.min_dust_limit_satoshis = 0;
let channelmanager = ChannelManager::new(Network::Bitcoin, fee_est.clone(), monitor.clone(), watch.clone(), broadcast.clone(), Arc::clone(&logger), keys_manager.clone(), config).unwrap();
let router = Arc::new(Router::new(PublicKey::from_secret_key(&Secp256k1::signing_only(), &keys_manager.get_node_secret()), watch.clone(), Arc::clone(&logger)));

39
src/ln/channel.rs
View file

@ -410,13 +410,6 @@ impl Channel {
1000 // TODO
}
fn derive_minimum_depth(_channel_value_satoshis_msat: u64, _value_to_self_msat: u64) -> u32 {
// Note that in order to comply with BOLT 7 announcement_signatures requirements this must
// be at least 6.
const CONF_TARGET: u32 = 12; //TODO: Should be much higher
CONF_TARGET
}
// Constructors:
pub fn new_outbound(fee_estimator: &FeeEstimator, keys_provider: &Arc<KeysInterface>, their_node_id: PublicKey, channel_value_satoshis: u64, push_msat: u64, user_id: u64, logger: Arc<Logger>, config: &UserConfig) -> Result<Channel, APIError> {
let chan_keys = keys_provider.get_channel_keys(false);
@ -565,32 +558,32 @@ impl Channel {
}
// Now check against optional parameters as set by config...
if msg.funding_satoshis < config.channel_limits.min_funding_satoshis {
if msg.funding_satoshis < config.peer_channel_config_limits.min_funding_satoshis {
return Err(ChannelError::Close("funding satoshis is less than the user specified limit"));
}
if msg.htlc_minimum_msat > config.channel_limits.max_htlc_minimum_msat {
if msg.htlc_minimum_msat > config.peer_channel_config_limits.max_htlc_minimum_msat {
return Err(ChannelError::Close("htlc minimum msat is higher than the user specified limit"));
}
if msg.max_htlc_value_in_flight_msat < config.channel_limits.min_max_htlc_value_in_flight_msat {
if msg.max_htlc_value_in_flight_msat < config.peer_channel_config_limits.min_max_htlc_value_in_flight_msat {
return Err(ChannelError::Close("max htlc value in flight msat is less than the user specified limit"));
}
if msg.channel_reserve_satoshis > config.channel_limits.max_channel_reserve_satoshis {
if msg.channel_reserve_satoshis > config.peer_channel_config_limits.max_channel_reserve_satoshis {
return Err(ChannelError::Close("channel reserve satoshis is higher than the user specified limit"));
}
if msg.max_accepted_htlcs < config.channel_limits.min_max_accepted_htlcs {
if msg.max_accepted_htlcs < config.peer_channel_config_limits.min_max_accepted_htlcs {
return Err(ChannelError::Close("max accepted htlcs is less than the user specified limit"));
}
if msg.dust_limit_satoshis < config.channel_limits.min_dust_limit_satoshis {
if msg.dust_limit_satoshis < config.peer_channel_config_limits.min_dust_limit_satoshis {
return Err(ChannelError::Close("dust limit satoshis is less than the user specified limit"));
}
if msg.dust_limit_satoshis > config.channel_limits.max_dust_limit_satoshis {
if msg.dust_limit_satoshis > config.peer_channel_config_limits.max_dust_limit_satoshis {
return Err(ChannelError::Close("dust limit satoshis is greater than the user specified limit"));
}
// Convert things into internal flags and prep our state:
let their_announce = if (msg.channel_flags & 1) == 1 { true } else { false };
if config.channel_limits.force_announced_channel_preference {
if config.peer_channel_config_limits.force_announced_channel_preference {
if local_config.announced_channel != their_announce {
return Err(ChannelError::Close("Peer tried to open channel but their announcement preference is different from ours"));
}
@ -687,7 +680,7 @@ impl Channel {
our_htlc_minimum_msat: Channel::derive_our_htlc_minimum_msat(msg.feerate_per_kw as u64),
their_to_self_delay: msg.to_self_delay,
their_max_accepted_htlcs: msg.max_accepted_htlcs,
minimum_depth: Channel::derive_minimum_depth(msg.funding_satoshis*1000, msg.push_msat),
minimum_depth: config.own_channel_config.minimum_depth,
their_funding_pubkey: Some(msg.funding_pubkey),
their_revocation_basepoint: Some(msg.revocation_basepoint),
@ -1383,25 +1376,25 @@ impl Channel {
}
// Now check against optional parameters as set by config...
if msg.htlc_minimum_msat > config.channel_limits.max_htlc_minimum_msat {
if msg.htlc_minimum_msat > config.peer_channel_config_limits.max_htlc_minimum_msat {
return Err(ChannelError::Close("htlc minimum msat is higher than the user specified limit"));
}
if msg.max_htlc_value_in_flight_msat < config.channel_limits.min_max_htlc_value_in_flight_msat {
if msg.max_htlc_value_in_flight_msat < config.peer_channel_config_limits.min_max_htlc_value_in_flight_msat {
return Err(ChannelError::Close("max htlc value in flight msat is less than the user specified limit"));
}
if msg.channel_reserve_satoshis > config.channel_limits.max_channel_reserve_satoshis {
if msg.channel_reserve_satoshis > config.peer_channel_config_limits.max_channel_reserve_satoshis {
return Err(ChannelError::Close("channel reserve satoshis is higher than the user specified limit"));
}
if msg.max_accepted_htlcs < config.channel_limits.min_max_accepted_htlcs {
if msg.max_accepted_htlcs < config.peer_channel_config_limits.min_max_accepted_htlcs {
return Err(ChannelError::Close("max accepted htlcs is less than the user specified limit"));
}
if msg.dust_limit_satoshis < config.channel_limits.min_dust_limit_satoshis {
if msg.dust_limit_satoshis < config.peer_channel_config_limits.min_dust_limit_satoshis {
return Err(ChannelError::Close("dust limit satoshis is less than the user specified limit"));
}
if msg.dust_limit_satoshis > config.channel_limits.max_dust_limit_satoshis {
if msg.dust_limit_satoshis > config.peer_channel_config_limits.max_dust_limit_satoshis {
return Err(ChannelError::Close("dust limit satoshis is greater than the user specified limit"));
}
if msg.minimum_depth > config.channel_limits.max_minimum_depth {
if msg.minimum_depth > config.peer_channel_config_limits.max_minimum_depth {
return Err(ChannelError::Close("We consider the minimum depth to be unreasonably large"));
}

2
src/ln/functional_test_utils.rs
View file

@ -824,7 +824,7 @@ pub fn create_network(node_count: usize) -> Vec<Node> {
let chan_monitor = Arc::new(test_utils::TestChannelMonitor::new(chain_monitor.clone(), tx_broadcaster.clone(), logger.clone()));
let mut config = UserConfig::new();
config.channel_options.announced_channel = true;
config.channel_limits.force_announced_channel_preference = false;
config.peer_channel_config_limits.force_announced_channel_preference = false;
let node = ChannelManager::new(Network::Testnet, feeest.clone(), chan_monitor.clone(), chain_monitor.clone(), tx_broadcaster.clone(), Arc::clone(&logger), keys_manager.clone(), config).unwrap();
let router = Router::new(PublicKey::from_secret_key(&secp_ctx, &keys_manager.get_node_secret()), chain_monitor.clone(), Arc::clone(&logger));
nodes.push(Node { chain_monitor, tx_broadcaster, chan_monitor, node, router, keys_manager, node_seed: seed,

27
src/util/config.rs
View file

@ -4,8 +4,10 @@
/// Top-level config which holds ChannelHandshakeLimits and ChannelConfig.
#[derive(Clone, Debug)]
pub struct UserConfig {
/// Limits applied during channel creation.
pub channel_limits: ChannelHandshakeLimits,
/// Channel config that we propose to our counterparty.
pub own_channel_config: ChannelHandshakeConfig,
/// Limits applied to our counterparty's proposed channel config settings.
pub peer_channel_config_limits: ChannelHandshakeLimits,
/// Channel config which affects behavior during channel lifetime.
pub channel_options: ChannelConfig,
}
@ -14,12 +16,31 @@ impl UserConfig {
/// Provides sane defaults for most configurations (but with 0 relay fees!)
pub fn new() -> Self{
UserConfig {
channel_limits: ChannelHandshakeLimits::new(),
own_channel_config: ChannelHandshakeConfig::new(),
peer_channel_config_limits: ChannelHandshakeLimits::new(),
channel_options: ChannelConfig::new(),
}
}
}
/// Configuration we set when applicable.
#[derive(Clone, Debug)]
pub struct ChannelHandshakeConfig {
/// Confirmations we will wait for before considering the channel locked in.
/// Applied only for inbound channels (see ChannelHandshakeLimits::max_minimum_depth for the
/// equivalent limit applied to outbound channels).
pub minimum_depth: u32,
}
impl ChannelHandshakeConfig {
/// Provides sane defaults for `ChannelHandshakeConfig`
pub fn new() -> ChannelHandshakeConfig {
ChannelHandshakeConfig {
minimum_depth: 6,
}
}
}
/// Optional channel limits which are applied during channel creation.
///
/// These limits are only applied to our counterparty's limits, not our own.