Use specific signer ops masks for monitor async signing tests

Author: alecchendev

lightning/src/ln/async_signer_tests.rs

@@ -381,7 +381,6 @@ fn do_test_async_holder_signatures(anchors: bool, remote_commitment: bool) {
 	route_payment(&nodes[0], &[&nodes[1]], 1_000_000);
 	let error_message = "Channel force-closed";
 
-	nodes[0].set_channel_signer_available(&nodes[1].node.get_our_node_id(), &chan_id, false);
 
 	if remote_commitment {
 		// Make the counterparty broadcast its latest commitment.
@@ -390,6 +389,8 @@ fn do_test_async_holder_signatures(anchors: bool, remote_commitment: bool) {
 		check_closed_broadcast(&nodes[1], 1, true);
 		check_closed_event(&nodes[1], 1, ClosureReason::HolderForceClosed, false, &[nodes[0].node.get_our_node_id()], 100_000);
 	} else {
+		nodes[0].set_channel_signer_ops_available(&nodes[1].node.get_our_node_id(), &chan_id, ops::SIGN_HOLDER_COMMITMENT_AND_HTLCS, false);
+		nodes[0].set_channel_signer_ops_available(&nodes[1].node.get_our_node_id(), &chan_id, ops::SIGN_HOLDER_HTLC_TRANSACTION, false);
 		// We'll connect blocks until the sender has to go onchain to time out the HTLC.
 		connect_blocks(&nodes[0], TEST_FINAL_CLTV + LATENCY_GRACE_PERIOD_BLOCKS + 1);
 
@@ -398,7 +399,8 @@ fn do_test_async_holder_signatures(anchors: bool, remote_commitment: bool) {
 		assert!(nodes[0].chain_monitor.chain_monitor.get_and_clear_pending_events().is_empty());
 
 		// Mark it as available now, we should see the signed commitment transaction.
-		nodes[0].set_channel_signer_available(&nodes[1].node.get_our_node_id(), &chan_id, true);
+		nodes[0].set_channel_signer_ops_available(&nodes[1].node.get_our_node_id(), &chan_id, ops::SIGN_HOLDER_COMMITMENT_AND_HTLCS, true);
+		nodes[0].set_channel_signer_ops_available(&nodes[1].node.get_our_node_id(), &chan_id, ops::SIGN_HOLDER_HTLC_TRANSACTION, true);
 		get_monitor!(nodes[0], chan_id).signer_unblocked(nodes[0].tx_broadcaster, nodes[0].fee_estimator, &nodes[0].logger);
 	}
 
@@ -424,7 +426,13 @@ fn do_test_async_holder_signatures(anchors: bool, remote_commitment: bool) {
 
 	// Mark it as unavailable again to now test the HTLC transaction. We'll mine the commitment such
 	// that the HTLC transaction is retried.
-	nodes[0].set_channel_signer_available(&nodes[1].node.get_our_node_id(), &chan_id, false);
+	let sign_htlc_mask = if remote_commitment {
+		ops::SIGN_COUNTERPARTY_HTLC_TRANSACTION
+	} else {
+		ops::SIGN_HOLDER_HTLC_TRANSACTION
+	};
+	nodes[0].set_channel_signer_ops_available(&nodes[1].node.get_our_node_id(), &chan_id, sign_htlc_mask, false);
+	nodes[0].set_channel_signer_ops_available(&nodes[1].node.get_our_node_id(), &chan_id, ops::SIGN_HOLDER_ANCHOR_INPUT, false);
 	mine_transaction(&nodes[0], &commitment_tx);
 
 	check_added_monitors(&nodes[0], 1);
@@ -444,7 +452,8 @@ fn do_test_async_holder_signatures(anchors: bool, remote_commitment: bool) {
 	assert!(nodes[0].tx_broadcaster.txn_broadcast().is_empty());
 
 	// Mark it as available now, we should see the signed HTLC transaction.
-	nodes[0].set_channel_signer_available(&nodes[1].node.get_our_node_id(), &chan_id, true);
+	nodes[0].set_channel_signer_ops_available(&nodes[1].node.get_our_node_id(), &chan_id, sign_htlc_mask, true);
+	nodes[0].set_channel_signer_ops_available(&nodes[1].node.get_our_node_id(), &chan_id, ops::SIGN_HOLDER_ANCHOR_INPUT, true);
 	get_monitor!(nodes[0], chan_id).signer_unblocked(nodes[0].tx_broadcaster, nodes[0].fee_estimator, &nodes[0].logger);
 
 	if anchors && !remote_commitment {
@@ -458,9 +467,21 @@ fn do_test_async_holder_signatures(anchors: bool, remote_commitment: bool) {
 }
 
 #[test]
-fn test_async_holder_signatures() {
+fn test_async_holder_signatures_no_anchors() {
 	do_test_async_holder_signatures(false, false);
+}
+
+#[test]
+fn test_async_holder_signatures_remote_commitment_no_anchors() {
 	do_test_async_holder_signatures(false, true);
+}
+
+#[test]
+fn test_async_holder_signatures_anchors() {
 	do_test_async_holder_signatures(true, false);
+}
+
+#[test]
+fn test_async_holder_signatures_remote_commitment_anchors() {
 	do_test_async_holder_signatures(true, true);
 }

lightning/src/util/test_channel_signer.rs

@@ -210,7 +210,7 @@ impl ChannelSigner for TestChannelSigner {
 	}
 
 	fn validate_counterparty_revocation(&self, idx: u64, _secret: &SecretKey) -> Result<(), ()> {
-		if !*self.available.lock().unwrap() {
+		if !self.is_signer_available(ops::VALIDATE_COUNTERPARTY_REVOCATION) {
 			return Err(());
 		}
 		let mut state = self.state.lock().unwrap();
@@ -252,7 +252,7 @@ impl EcdsaChannelSigner for TestChannelSigner {
 	}
 
 	fn sign_holder_commitment(&self, commitment_tx: &HolderCommitmentTransaction, secp_ctx: &Secp256k1<secp256k1::All>) -> Result<Signature, ()> {
-		if !*self.available.lock().unwrap() {
+		if !self.is_signer_available(ops::SIGN_HOLDER_COMMITMENT_AND_HTLCS) {
 			return Err(());
 		}
 		let trusted_tx = self.verify_holder_commitment_tx(commitment_tx, secp_ctx);
@@ -273,14 +273,14 @@ impl EcdsaChannelSigner for TestChannelSigner {
 	}
 
 	fn sign_justice_revoked_output(&self, justice_tx: &Transaction, input: usize, amount: u64, per_commitment_key: &SecretKey, secp_ctx: &Secp256k1<secp256k1::All>) -> Result<Signature, ()> {
-		if !*self.available.lock().unwrap() {
+		if !self.is_signer_available(ops::SIGN_JUSTICE_REVOKED_OUTPUT) {
 			return Err(());
 		}
 		Ok(EcdsaChannelSigner::sign_justice_revoked_output(&self.inner, justice_tx, input, amount, per_commitment_key, secp_ctx).unwrap())
 	}
 
 	fn sign_justice_revoked_htlc(&self, justice_tx: &Transaction, input: usize, amount: u64, per_commitment_key: &SecretKey, htlc: &HTLCOutputInCommitment, secp_ctx: &Secp256k1<secp256k1::All>) -> Result<Signature, ()> {
-		if !*self.available.lock().unwrap() {
+		if !self.is_signer_available(ops::SIGN_JUSTICE_REVOKED_HTLC) {
 			return Err(());
 		}
 		Ok(EcdsaChannelSigner::sign_justice_revoked_htlc(&self.inner, justice_tx, input, amount, per_commitment_key, htlc, secp_ctx).unwrap())
@@ -290,7 +290,7 @@ impl EcdsaChannelSigner for TestChannelSigner {
 		&self, htlc_tx: &Transaction, input: usize, htlc_descriptor: &HTLCDescriptor,
 		secp_ctx: &Secp256k1<secp256k1::All>
 	) -> Result<Signature, ()> {
-		if !*self.available.lock().unwrap() {
+		if !self.is_signer_available(ops::SIGN_HOLDER_HTLC_TRANSACTION) {
 			return Err(());
 		}
 		let state = self.state.lock().unwrap();
@@ -326,7 +326,7 @@ impl EcdsaChannelSigner for TestChannelSigner {
 	}
 
 	fn sign_counterparty_htlc_transaction(&self, htlc_tx: &Transaction, input: usize, amount: u64, per_commitment_point: &PublicKey, htlc: &HTLCOutputInCommitment, secp_ctx: &Secp256k1<secp256k1::All>) -> Result<Signature, ()> {
-		if !*self.available.lock().unwrap() {
+		if !self.is_signer_available(ops::SIGN_COUNTERPARTY_HTLC_TRANSACTION) {
 			return Err(());
 		}
 		Ok(EcdsaChannelSigner::sign_counterparty_htlc_transaction(&self.inner, htlc_tx, input, amount, per_commitment_point, htlc, secp_ctx).unwrap())
@@ -345,7 +345,7 @@ impl EcdsaChannelSigner for TestChannelSigner {
 		// As long as our minimum dust limit is enforced and is greater than our anchor output
 		// value, an anchor output can only have an index within [0, 1].
 		assert!(anchor_tx.input[input].previous_output.vout == 0 || anchor_tx.input[input].previous_output.vout == 1);
-		if !*self.available.lock().unwrap() {
+		if !self.is_signer_available(ops::SIGN_HOLDER_ANCHOR_INPUT) {
 			return Err(());
 		}
 		EcdsaChannelSigner::sign_holder_anchor_input(&self.inner, anchor_tx, input, secp_ctx)