let monitor = Arc::new(TestChannelMonitor::new(watch.clone(), broadcast.clone(), logger.clone(), fee_est.clone()));
let keys_manager = Arc::new(KeyProvider { node_id: $node_id, session_id: atomic::AtomicU8::new(0), channel_id: atomic::AtomicU8::new(0) });
- let mut config = UserConfig::new();
+ let mut config = UserConfig::default();
config.channel_options.fee_proportional_millionths = 0;
config.channel_options.announced_channel = true;
config.peer_channel_config_limits.min_dust_limit_satoshis = 0;
let monitor = Arc::new(TestChannelMonitor::new(watch.clone(), broadcast.clone(), logger.clone(), fee_est.clone()));
let keys_manager = Arc::new(KeyProvider { node_id: $node_id, session_id: atomic::AtomicU8::new(0), channel_id: atomic::AtomicU8::new(0) });
- let mut config = UserConfig::new();
+ let mut config = UserConfig::default();
config.channel_options.fee_proportional_millionths = 0;
config.channel_options.announced_channel = true;
config.peer_channel_config_limits.min_dust_limit_satoshis = 0;
let monitor = channelmonitor::SimpleManyChannelMonitor::new(watch.clone(), broadcast.clone(), Arc::clone(&logger), fee_est.clone());
let keys_manager = Arc::new(KeyProvider { node_secret: our_network_key.clone(), counter: AtomicU64::new(0) });
- let mut config = UserConfig::new();
+ let mut config = UserConfig::default();
config.channel_options.fee_proportional_millionths = slice_to_be32(get_slice!(4));
config.channel_options.announced_channel = get_slice!(1)[0] != 0;
config.peer_channel_config_limits.min_dust_limit_satoshis = 0;
let keys_provider: Arc<KeysInterface> = Arc::new(Keys { chan_keys });
let their_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
- let mut config = UserConfig::new();
+ let mut config = UserConfig::default();
config.channel_options.announced_channel = false;
let mut chan = Channel::new_outbound(&feeest, &keys_provider, their_node_id, 10000000, 100000, 42, Arc::clone(&logger), &config).unwrap(); // Nothing uses their network key in this test
chan.their_to_self_delay = 144;
let chan_monitor = Arc::new(test_utils::TestChannelMonitor::new(chain_monitor.clone(), tx_broadcaster.clone(), logger.clone(), feeest.clone()));
let weak_res = Arc::downgrade(&chan_monitor.simple_monitor);
block_notifier.register_listener(weak_res);
- let mut default_config = UserConfig::new();
+ let mut default_config = UserConfig::default();
default_config.channel_options.announced_channel = true;
default_config.peer_channel_config_limits.force_announced_channel_preference = false;
let node = ChannelManager::new(Network::Testnet, feeest.clone(), chan_monitor.clone(), tx_broadcaster.clone(), Arc::clone(&logger), keys_manager.clone(), if node_config[i].is_some() { node_config[i].clone().unwrap() } else { default_config }, 0).unwrap();
#[test]
fn test_justice_tx() {
// Test justice txn built on revoked HTLC-Success tx, against both sides
- let mut alice_config = UserConfig::new();
+ let mut alice_config = UserConfig::default();
alice_config.channel_options.announced_channel = true;
alice_config.peer_channel_config_limits.force_announced_channel_preference = false;
alice_config.own_channel_config.our_to_self_delay = 6 * 24 * 5;
- let mut bob_config = UserConfig::new();
+ let mut bob_config = UserConfig::default();
bob_config.channel_options.announced_channel = true;
bob_config.peer_channel_config_limits.force_announced_channel_preference = false;
bob_config.own_channel_config.our_to_self_delay = 6 * 24 * 3;
assert!(chan_0_monitor_read.is_empty());
let mut nodes_0_read = &nodes_0_serialized[..];
- let config = UserConfig::new();
+ let config = UserConfig::default();
let keys_manager = Arc::new(test_utils::TestKeysInterface::new(&nodes[0].node_seed, Network::Testnet, Arc::new(test_utils::TestLogger::new())));
let (_, nodes_0_deserialized) = {
let mut channel_monitors = HashMap::new();
let mut channel_monitors = HashMap::new();
channel_monitors.insert(chan_0_monitor.get_funding_txo().unwrap(), &chan_0_monitor);
<(Sha256dHash, ChannelManager)>::read(&mut nodes_0_read, ChannelManagerReadArgs {
- default_config: UserConfig::new(),
+ default_config: UserConfig::default(),
keys_manager,
fee_estimator: Arc::new(test_utils::TestFeeEstimator { sat_per_kw: 253 }),
monitor: nodes[0].chan_monitor.clone(),
let mut nodes_0_read = &nodes_0_serialized[..];
let keys_manager = Arc::new(test_utils::TestKeysInterface::new(&nodes[0].node_seed, Network::Testnet, Arc::new(test_utils::TestLogger::new())));
let (_, nodes_0_deserialized) = <(Sha256dHash, ChannelManager)>::read(&mut nodes_0_read, ChannelManagerReadArgs {
- default_config: UserConfig::new(),
+ default_config: UserConfig::default(),
keys_manager,
fee_estimator: Arc::new(test_utils::TestFeeEstimator { sat_per_kw: 253 }),
monitor: nodes[0].chan_monitor.clone(),
// BOLT 2 : Option upfront shutdown script, if peer commit its closing_script at channel opening
// enforce it at shutdown message
- let mut config = UserConfig::new();
+ let mut config = UserConfig::default();
config.channel_options.announced_channel = true;
config.peer_channel_config_limits.force_announced_channel_preference = false;
config.channel_options.commit_upfront_shutdown_pubkey = false;
fn test_user_configurable_csv_delay() {
// We test our channel constructors yield errors when we pass them absurd csv delay
- let mut low_our_to_self_config = UserConfig::new();
+ let mut low_our_to_self_config = UserConfig::default();
low_our_to_self_config.own_channel_config.our_to_self_delay = 6;
- let mut high_their_to_self_config = UserConfig::new();
+ let mut high_their_to_self_config = UserConfig::default();
high_their_to_self_config.peer_channel_config_limits.their_to_self_delay = 100;
let cfgs = [Some(high_their_to_self_config.clone()), None];
let nodes = create_network(2, &cfgs);
monitor: monitor.clone(),
logger: Arc::clone(&logger),
tx_broadcaster,
- default_config: UserConfig::new(),
+ default_config: UserConfig::default(),
channel_monitors: &channel_monitors
}).unwrap().1;
nodes[0].node = Arc::new(node_state_0);
pub channel_options: ChannelConfig,
}
-impl UserConfig {
+impl Default for UserConfig {
/// Provides sane defaults for most configurations (but with 0 relay fees!)
- pub fn new() -> Self{
+ fn default() -> Self {
UserConfig {
- own_channel_config: ChannelHandshakeConfig::new(),
- peer_channel_config_limits: ChannelHandshakeLimits::new(),
- channel_options: ChannelConfig::new(),
+ own_channel_config: ChannelHandshakeConfig::default(),
+ peer_channel_config_limits: ChannelHandshakeLimits::default(),
+ channel_options: ChannelConfig::default(),
}
}
}
pub our_to_self_delay: u16,
}
-impl ChannelHandshakeConfig {
+impl Default for ChannelHandshakeConfig {
/// Provides sane defaults for `ChannelHandshakeConfig`
- pub fn new() -> ChannelHandshakeConfig {
+ fn default() -> ChannelHandshakeConfig {
ChannelHandshakeConfig {
minimum_depth: 6,
our_to_self_delay: BREAKDOWN_TIMEOUT,
pub their_to_self_delay: u16
}
-impl ChannelHandshakeLimits {
+impl Default for ChannelHandshakeLimits {
/// Provides sane defaults for most configurations.
///
/// Most additional limits are disabled except those with which specify a default in individual
/// field documentation. Note that this may result in barely-usable channels, but since they
/// are applied mostly only to incoming channels that's not much of a problem.
- pub fn new() -> Self {
+ fn default() -> Self {
ChannelHandshakeLimits {
min_funding_satoshis: 0,
max_htlc_minimum_msat: <u64>::max_value(),
pub commit_upfront_shutdown_pubkey: bool
}
-impl ChannelConfig {
+impl Default for ChannelConfig {
/// Provides sane defaults for most configurations (but with zero relay fees!).
- pub fn new() -> Self {
+ fn default() -> Self {
ChannelConfig {
fee_proportional_millionths: 0,
announced_channel: false,
projects / rust-lightning / commitdiff