X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Futil%2Ftest_utils.rs;h=8fc5a8197a78c38e13740ea663e678582676515f;hb=3fd85c8cf8be08480a3959bd2b829be17bdfdaa9;hp=a96711d144c1441f5aa0a846990d13c5060d4f54;hpb=5bf58f0d33b13bd3d9f88c4f2021fbd77745274a;p=rust-lightning

diff --git a/lightning/src/util/test_utils.rs b/lightning/src/util/test_utils.rs
index a96711d1..8fc5a819 100644
--- a/lightning/src/util/test_utils.rs
+++ b/lightning/src/util/test_utils.rs
@@ -70,7 +70,7 @@ use crate::sync::{Mutex, Arc};
 use core::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
 use core::mem;
 use bitcoin::bech32::u5;
-use crate::sign::{InMemorySigner, Recipient, EntropySource, NodeSigner, SignerProvider};
+use crate::sign::{InMemorySigner, RandomBytes, Recipient, EntropySource, NodeSigner, SignerProvider};
 
 #[cfg(feature = "std")]
 use std::time::{SystemTime, UNIX_EPOCH};
@@ -107,10 +107,12 @@ pub struct TestRouter<'a> {
 	pub router: DefaultRouter<
 		Arc<NetworkGraph<&'a TestLogger>>,
 		&'a TestLogger,
+		Arc<RandomBytes>,
 		&'a RwLock<TestScorer>,
 		(),
 		TestScorer,
 	>,
+	//pub entropy_source: &'a RandomBytes,
 	pub network_graph: Arc<NetworkGraph<&'a TestLogger>>,
 	pub next_routes: Mutex<VecDeque<(RouteParameters, Result<Route, LightningError>)>>,
 	pub scorer: &'a RwLock<TestScorer>,
@@ -119,10 +121,11 @@ pub struct TestRouter<'a> {
 impl<'a> TestRouter<'a> {
 	pub fn new(
 		network_graph: Arc<NetworkGraph<&'a TestLogger>>, logger: &'a TestLogger,
-		scorer: &'a RwLock<TestScorer>
+		scorer: &'a RwLock<TestScorer>,
 	) -> Self {
+		let entropy_source = Arc::new(RandomBytes::new([42; 32]));
 		Self {
-			router: DefaultRouter::new(network_graph.clone(), logger, [42u8; 32], scorer, ()),
+			router: DefaultRouter::new(network_graph.clone(), logger, entropy_source, scorer, ()),
 			network_graph,
 			next_routes: Mutex::new(VecDeque::new()),
 			scorer,
@@ -165,7 +168,7 @@ impl<'a> Router for TestRouter<'a> {
 										details: first_hops[idx],
 										payer_node_id: &node_id,
 									});
-									scorer.channel_penalty_msat(&candidate, usage, &());
+									scorer.channel_penalty_msat(&candidate, usage, &Default::default());
 									continue;
 								}
 							}
@@ -177,7 +180,7 @@ impl<'a> Router for TestRouter<'a> {
 								info: directed,
 								short_channel_id: hop.short_channel_id,
 							});
-							scorer.channel_penalty_msat(&candidate, usage, &());
+							scorer.channel_penalty_msat(&candidate, usage, &Default::default());
 						} else {
 							let target_node_id = NodeId::from_pubkey(&hop.pubkey);
 							let route_hint = RouteHintHop {
@@ -192,7 +195,7 @@ impl<'a> Router for TestRouter<'a> {
 								hint: &route_hint,
 								target_node_id: &target_node_id,
 							});
-							scorer.channel_penalty_msat(&candidate, usage, &());
+							scorer.channel_penalty_msat(&candidate, usage, &Default::default());
 						}
 						prev_hop_node = &hop.pubkey;
 					}
@@ -205,13 +208,13 @@ impl<'a> Router for TestRouter<'a> {
 	}
 
 	fn create_blinded_payment_paths<
-		ES: EntropySource + ?Sized, T: secp256k1::Signing + secp256k1::Verification
+		T: secp256k1::Signing + secp256k1::Verification
 	>(
 		&self, recipient: PublicKey, first_hops: Vec<ChannelDetails>, tlvs: ReceiveTlvs,
-		amount_msats: u64, entropy_source: &ES, secp_ctx: &Secp256k1<T>
+		amount_msats: u64, secp_ctx: &Secp256k1<T>,
 	) -> Result<Vec<(BlindedPayInfo, BlindedPath)>, ()> {
 		self.router.create_blinded_payment_paths(
-			recipient, first_hops, tlvs, amount_msats, entropy_source, secp_ctx
+			recipient, first_hops, tlvs, amount_msats, secp_ctx
 		)
 	}
 }
@@ -224,12 +227,11 @@ impl<'a> MessageRouter for TestRouter<'a> {
 	}
 
 	fn create_blinded_paths<
-		ES: EntropySource + ?Sized, T: secp256k1::Signing + secp256k1::Verification
+		T: secp256k1::Signing + secp256k1::Verification
 	>(
-		&self, recipient: PublicKey, peers: Vec<PublicKey>, entropy_source: &ES,
-		secp_ctx: &Secp256k1<T>
+		&self, recipient: PublicKey, peers: Vec<PublicKey>, secp_ctx: &Secp256k1<T>,
 	) -> Result<Vec<BlindedPath>, ()> {
-		self.router.create_blinded_paths(recipient, peers, entropy_source, secp_ctx)
+		self.router.create_blinded_paths(recipient, peers, secp_ctx)
 	}
 }
 
@@ -245,12 +247,12 @@ impl<'a> Drop for TestRouter<'a> {
 }
 
 pub struct TestMessageRouter<'a> {
-	inner: DefaultMessageRouter<Arc<NetworkGraph<&'a TestLogger>>, &'a TestLogger>,
+	inner: DefaultMessageRouter<Arc<NetworkGraph<&'a TestLogger>>, &'a TestLogger, &'a TestKeysInterface>,
 }
 
 impl<'a> TestMessageRouter<'a> {
-	pub fn new(network_graph: Arc<NetworkGraph<&'a TestLogger>>) -> Self {
-		Self { inner: DefaultMessageRouter::new(network_graph) }
+	pub fn new(network_graph: Arc<NetworkGraph<&'a TestLogger>>, entropy_source: &'a TestKeysInterface) -> Self {
+		Self { inner: DefaultMessageRouter::new(network_graph, entropy_source) }
 	}
 }
 
@@ -261,13 +263,10 @@ impl<'a> MessageRouter for TestMessageRouter<'a> {
 		self.inner.find_path(sender, peers, destination)
 	}
 
-	fn create_blinded_paths<
-		ES: EntropySource + ?Sized, T: secp256k1::Signing + secp256k1::Verification
-	>(
-		&self, recipient: PublicKey, peers: Vec<PublicKey>, entropy_source: &ES,
-		secp_ctx: &Secp256k1<T>
+	fn create_blinded_paths<T: secp256k1::Signing + secp256k1::Verification>(
+		&self, recipient: PublicKey, peers: Vec<PublicKey>, secp_ctx: &Secp256k1<T>,
 	) -> Result<Vec<BlindedPath>, ()> {
-		self.inner.create_blinded_paths(recipient, peers, entropy_source, secp_ctx)
+		self.inner.create_blinded_paths(recipient, peers, secp_ctx)
 	}
 }
 
@@ -318,8 +317,8 @@ impl<'a> TestChainMonitor<'a> {
 	pub fn new(chain_source: Option<&'a TestChainSource>, broadcaster: &'a dyn chaininterface::BroadcasterInterface, logger: &'a TestLogger, fee_estimator: &'a TestFeeEstimator, persister: &'a dyn chainmonitor::Persist<TestChannelSigner>, keys_manager: &'a TestKeysInterface) -> Self {
 		Self {
 			added_monitors: Mutex::new(Vec::new()),
-			monitor_updates: Mutex::new(HashMap::new()),
-			latest_monitor_update_id: Mutex::new(HashMap::new()),
+			monitor_updates: Mutex::new(new_hash_map()),
+			latest_monitor_update_id: Mutex::new(new_hash_map()),
 			chain_monitor: chainmonitor::ChainMonitor::new(chain_source, broadcaster, logger, fee_estimator, persister),
 			keys_manager,
 			expect_channel_force_closed: Mutex::new(None),
@@ -414,8 +413,8 @@ impl WatchtowerPersister {
 	pub(crate) fn new(destination_script: ScriptBuf) -> Self {
 		WatchtowerPersister {
 			persister: TestPersister::new(),
-			unsigned_justice_tx_data: Mutex::new(HashMap::new()),
-			watchtower_state: Mutex::new(HashMap::new()),
+			unsigned_justice_tx_data: Mutex::new(new_hash_map()),
+			watchtower_state: Mutex::new(new_hash_map()),
 			destination_script,
 		}
 	}
@@ -448,7 +447,7 @@ impl<Signer: sign::ecdsa::WriteableEcdsaChannelSigner> chainmonitor::Persist<Sig
 		assert!(self.unsigned_justice_tx_data.lock().unwrap()
 			.insert(funding_txo, VecDeque::new()).is_none());
 		assert!(self.watchtower_state.lock().unwrap()
-			.insert(funding_txo, HashMap::new()).is_none());
+			.insert(funding_txo, new_hash_map()).is_none());
 
 		let initial_counterparty_commitment_tx = data.initial_counterparty_commitment_tx()
 			.expect("First and only call expects Some");
@@ -509,8 +508,8 @@ impl TestPersister {
 	pub fn new() -> Self {
 		Self {
 			update_rets: Mutex::new(VecDeque::new()),
-			chain_sync_monitor_persistences: Mutex::new(HashMap::new()),
-			offchain_monitor_updates: Mutex::new(HashMap::new()),
+			chain_sync_monitor_persistences: Mutex::new(new_hash_map()),
+			offchain_monitor_updates: Mutex::new(new_hash_map()),
 		}
 	}
 
@@ -534,9 +533,9 @@ impl<Signer: sign::ecdsa::WriteableEcdsaChannelSigner> chainmonitor::Persist<Sig
 		}
 		let is_chain_sync = if let UpdateOrigin::ChainSync(_) = update_id.contents { true } else { false };
 		if is_chain_sync {
-			self.chain_sync_monitor_persistences.lock().unwrap().entry(funding_txo).or_insert(HashSet::new()).insert(update_id);
+			self.chain_sync_monitor_persistences.lock().unwrap().entry(funding_txo).or_insert(new_hash_set()).insert(update_id);
 		} else {
-			self.offchain_monitor_updates.lock().unwrap().entry(funding_txo).or_insert(HashSet::new()).insert(update_id);
+			self.offchain_monitor_updates.lock().unwrap().entry(funding_txo).or_insert(new_hash_set()).insert(update_id);
 		}
 		ret
 	}
@@ -549,7 +548,7 @@ pub struct TestStore {
 
 impl TestStore {
 	pub fn new(read_only: bool) -> Self {
-		let persisted_bytes = Mutex::new(HashMap::new());
+		let persisted_bytes = Mutex::new(new_hash_map());
 		Self { persisted_bytes, read_only }
 	}
 }
@@ -589,7 +588,7 @@ impl KVStore for TestStore {
 		} else {
 			format!("{}/{}", primary_namespace, secondary_namespace)
 		};
-		let outer_e = persisted_lock.entry(prefixed).or_insert(HashMap::new());
+		let outer_e = persisted_lock.entry(prefixed).or_insert(new_hash_map());
 		let mut bytes = Vec::new();
 		bytes.write_all(buf)?;
 		outer_e.insert(key.to_string(), bytes);
@@ -633,6 +632,9 @@ impl KVStore for TestStore {
 	}
 }
 
+unsafe impl Sync for TestStore {}
+unsafe impl Send for TestStore {}
+
 pub struct TestBroadcaster {
 	pub txn_broadcasted: Mutex<Vec<Transaction>>,
 	pub blocks: Arc<Mutex<Vec<(Block, u32)>>>,
@@ -656,7 +658,7 @@ impl TestBroadcaster {
 
 	pub fn unique_txn_broadcast(&self) -> Vec<Transaction> {
 		let mut txn = self.txn_broadcasted.lock().unwrap().split_off(0);
-		let mut seen = HashSet::new();
+		let mut seen = new_hash_set();
 		txn.retain(|tx| seen.insert(tx.txid()));
 		txn
 	}
@@ -693,7 +695,7 @@ impl TestChannelMessageHandler {
 		TestChannelMessageHandler {
 			pending_events: Mutex::new(Vec::new()),
 			expected_recv_msgs: Mutex::new(None),
-			connected_peers: Mutex::new(HashSet::new()),
+			connected_peers: Mutex::new(new_hash_set()),
 			message_fetch_counter: AtomicUsize::new(0),
 			chain_hash,
 		}
@@ -1045,8 +1047,8 @@ impl TestLogger {
 		TestLogger {
 			level: Level::Trace,
 			id,
-			lines: Mutex::new(HashMap::new()),
-			context: Mutex::new(HashMap::new()),
+			lines: Mutex::new(new_hash_map()),
+			context: Mutex::new(new_hash_map()),
 		}
 	}
 	pub fn enable(&mut self, level: Level) {
@@ -1165,6 +1167,7 @@ pub struct TestKeysInterface {
 	pub disable_revocation_policy_check: bool,
 	enforcement_states: Mutex<HashMap<[u8;32], Arc<Mutex<EnforcementState>>>>,
 	expectations: Mutex<Option<VecDeque<OnGetShutdownScriptpubkey>>>,
+	pub unavailable_signers: Mutex<HashSet<[u8; 32]>>,
 }
 
 impl EntropySource for TestKeysInterface {
@@ -1223,7 +1226,11 @@ impl SignerProvider for TestKeysInterface {
 	fn derive_channel_signer(&self, channel_value_satoshis: u64, channel_keys_id: [u8; 32]) -> TestChannelSigner {
 		let keys = self.backing.derive_channel_signer(channel_value_satoshis, channel_keys_id);
 		let state = self.make_enforcement_state_cell(keys.commitment_seed);
-		TestChannelSigner::new_with_revoked(keys, state, self.disable_revocation_policy_check)
+		let signer = TestChannelSigner::new_with_revoked(keys, state, self.disable_revocation_policy_check);
+		if self.unavailable_signers.lock().unwrap().contains(&channel_keys_id) {
+			signer.set_available(false);
+		}
+		signer
 	}
 
 	fn read_chan_signer(&self, buffer: &[u8]) -> Result<Self::EcdsaSigner, msgs::DecodeError> {
@@ -1259,8 +1266,9 @@ impl TestKeysInterface {
 			backing: sign::PhantomKeysManager::new(seed, now.as_secs(), now.subsec_nanos(), seed),
 			override_random_bytes: Mutex::new(None),
 			disable_revocation_policy_check: false,
-			enforcement_states: Mutex::new(HashMap::new()),
+			enforcement_states: Mutex::new(new_hash_map()),
 			expectations: Mutex::new(None),
+			unavailable_signers: Mutex::new(new_hash_set()),
 		}
 	}
 
@@ -1274,9 +1282,7 @@ impl TestKeysInterface {
 	}
 
 	pub fn derive_channel_keys(&self, channel_value_satoshis: u64, id: &[u8; 32]) -> TestChannelSigner {
-		let keys = self.backing.derive_channel_keys(channel_value_satoshis, id);
-		let state = self.make_enforcement_state_cell(keys.commitment_seed);
-		TestChannelSigner::new_with_revoked(keys, state, self.disable_revocation_policy_check)
+		self.derive_channel_signer(channel_value_satoshis, *id)
 	}
 
 	fn make_enforcement_state_cell(&self, commitment_seed: [u8; 32]) -> Arc<Mutex<EnforcementState>> {
@@ -1340,8 +1346,8 @@ impl TestChainSource {
 			chain_hash: ChainHash::using_genesis_block(network),
 			utxo_ret: Mutex::new(UtxoResult::Sync(Ok(TxOut { value: u64::max_value(), script_pubkey }))),
 			get_utxo_call_count: AtomicUsize::new(0),
-			watched_txn: Mutex::new(HashSet::new()),
-			watched_outputs: Mutex::new(HashSet::new()),
+			watched_txn: Mutex::new(new_hash_set()),
+			watched_outputs: Mutex::new(new_hash_set()),
 		}
 	}
 }