test: add test for standardness and mempool policy checks

Author: aagbotemi

src/lib.rs

@@ -18,6 +18,8 @@ mod rbf;
 mod selection;
 mod selector;
 mod signer;
+#[cfg(test)]
+pub(crate) mod test_utils;
 mod utils;
 
 pub use canonical_unspents::*;

src/policy.rs

@@ -185,7 +185,7 @@ impl MempoolPolicy {
         {
             return Err(MempoolPolicyError::SelectionTxMismatch);
         }
-        
+
         if !selection
             .outputs
             .iter()
@@ -350,3 +350,197 @@ impl core::fmt::Display for MempoolPolicyError {
 
 #[cfg(feature = "std")]
 impl std::error::Error for MempoolPolicyError {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{test_utils::*, Output};
+    use alloc::vec::Vec;
+    use bitcoin::{transaction::Version, Amount, ScriptBuf, Transaction, TxOut};
+
+    fn default_policy() -> MempoolPolicy {
+        MempoolPolicy {
+            tip_height: absolute::Height::from_consensus(3_000).unwrap(),
+            tip_mtp: absolute::Time::from_consensus(500_001_000).unwrap(),
+        }
+    }
+
+    #[test]
+    fn test_tx_version() {
+        let policy = default_policy();
+        let input = setup_test_input(2_000).unwrap();
+        let output = create_output(p2tr_script(), 9_000);
+        let (selection, mut tx) = build_selection_with_tx(&[input], &[output]);
+
+        // Default version is 2, which is standard.
+        assert!(policy.check_all(&selection, &tx).is_ok());
+
+        // Test version 1, which is also standard.
+        tx.version = Version::ONE;
+        assert!(policy.check_all(&selection, &tx).is_ok());
+
+        // Version 3 (TRUC) is standard under v30+.
+        tx.version = Version(3);
+        assert!(policy.check_all(&selection, &tx).is_ok());
+
+        // Test version 4, which is non-standard.
+        tx.version = Version(4);
+        assert!(matches!(
+            policy.check_all(&selection, &tx),
+            Err(MempoolPolicyError::UnsupportedVersion(_))
+        ));
+    }
+
+    #[test]
+    fn test_tx_locktime() {
+        let policy = default_policy();
+        let input = setup_test_input(2_000).unwrap();
+        let output = create_output(p2tr_script(), 9_000);
+        let (selection, mut tx) = build_selection_with_tx(&[input], &[output]);
+
+        // Locktime exactly equal to the tip height.
+        tx.lock_time = absolute::LockTime::from_consensus(3_000);
+        assert!(policy.check_all(&selection, &tx).is_ok());
+
+        // Locktime below the tip height.
+        tx.lock_time = absolute::LockTime::from_consensus(2_500);
+        assert!(policy.check_all(&selection, &tx).is_ok());
+
+        // Locktime above the tip height.
+        tx.lock_time = absolute::LockTime::from_consensus(3_001);
+        assert!(matches!(
+            policy.check_all(&selection, &tx),
+            Err(MempoolPolicyError::LockTimeNotMet(_))
+        ));
+
+        // Locktime one second below the tip MTP.
+        tx.lock_time = absolute::LockTime::from_consensus(500_000_999);
+        assert!(policy.check_all(&selection, &tx).is_ok());
+
+        // Locktime exactly equal to the tip MTP.
+        tx.lock_time = absolute::LockTime::from_consensus(500_001_000);
+        assert!(matches!(
+            policy.check_all(&selection, &tx),
+            Err(MempoolPolicyError::LockTimeNotMet(_))
+        ));
+
+        // Locktime above the tip MTP.
+        tx.lock_time = absolute::LockTime::from_consensus(500_002_000);
+        assert!(matches!(
+            policy.check_all(&selection, &tx),
+            Err(MempoolPolicyError::LockTimeNotMet(_))
+        ));
+    }
+
+    #[test]
+    fn test_max_tx_weight() {
+        let policy = default_policy();
+
+        // A normal transaction with 1 input and 1 output.
+        let input = setup_test_input(2_000).unwrap();
+        let output = create_output(p2tr_script(), 9_000);
+        let (selection, tx) = build_selection_with_tx(core::slice::from_ref(&input), &[output]);
+        assert!(policy.check_all(&selection, &tx).is_ok());
+
+        // Heavy transaction with excess weight.
+        let outputs_with_excess_weight: Vec<Output> = (0..2_350)
+            .map(|_| create_output(p2tr_script(), 1_000))
+            .collect();
+
+        let (_, heavy_tx) =
+            build_selection_with_tx(&[input], outputs_with_excess_weight.as_slice());
+
+        assert!(heavy_tx.weight().to_wu() > MAX_STANDARD_TX_WEIGHT as u64);
+        assert!(matches!(
+            policy.check_max_tx_weight(heavy_tx.weight(), heavy_tx.version),
+            Err(MempoolPolicyError::MaxWeightExceeded { .. })
+        ));
+    }
+
+    #[test]
+    fn test_tx_min_non_witness_size() {
+        let policy = default_policy();
+        let input = setup_test_input(2_000).unwrap();
+        let output = create_output(p2tr_script(), 9_000);
+
+        // Transaction with 1 input and 1 output.
+        let (selection, tx) = build_selection_with_tx(&[input], &[output]);
+        assert!(policy.check_all(&selection, &tx).is_ok());
+
+        // Transaction with no inputs and 1 output.
+        let tx_below_min_non_witness_size = Transaction {
+            version: Version::TWO,
+            lock_time: absolute::LockTime::ZERO,
+            input: vec![],
+            output: vec![TxOut {
+                script_pubkey: ScriptBuf::new(),
+                value: Amount::ZERO,
+            }],
+        };
+        let empty_selection = Selection {
+            inputs: vec![],
+            outputs: vec![Output::with_script(ScriptBuf::new(), Amount::ZERO)],
+        };
+        assert!(
+            tx_below_min_non_witness_size.base_size() < MIN_STANDARD_TX_NONWITNESS_SIZE as usize
+        );
+        assert!(matches!(
+            policy.check_all(&empty_selection, &tx_below_min_non_witness_size),
+            Err(MempoolPolicyError::TxTooSmall { .. })
+        ));
+    }
+
+    #[test]
+    fn test_min_fee_relay() {
+        let policy = default_policy();
+
+        // Sufficient fee passes.
+        let input = setup_test_input(2_000).unwrap();
+        let output = create_output(p2tr_script(), 9_000);
+
+        let (selection, tx) = build_selection_with_tx(&[input], &[output]);
+        assert!(policy.check_all(&selection, &tx).is_ok());
+
+        // Fee below the 1 sat/vB minimum is rejected.
+        let input_with_insufficient_fee = setup_test_input(2_000).unwrap();
+        let output_with_insufficient_fee = create_output(p2tr_script(), 9_999);
+
+        let (selection_with_insufficient_fee, tx_with_insufficient_fee) = build_selection_with_tx(
+            &[input_with_insufficient_fee],
+            &[output_with_insufficient_fee],
+        );
+        assert!(matches!(
+            policy.check_all(&selection_with_insufficient_fee, &tx_with_insufficient_fee),
+            Err(MempoolPolicyError::MinRelayFeeNotMet { .. })
+        ));
+    }
+
+    #[test]
+    fn test_max_witness_stack() {
+        let policy = default_policy();
+        let input = setup_test_input(2_000).unwrap();
+
+        assert!(policy.check_max_witness_stack(&[input]).is_ok());
+    }
+
+    #[test]
+    fn test_input_spendability() {
+        let policy = default_policy();
+        // A confirmed input
+        let input = setup_test_input(2_000).unwrap();
+        assert!(policy.check_input_spendability(&[input]).is_ok());
+
+        // An immature input
+        let input_with_immature_coinbase = setup_test_input(2_950).unwrap();
+        assert!(policy
+            .check_input_spendability(&[input_with_immature_coinbase])
+            .is_err());
+    }
+
+    #[test]
+    fn test_input_script_type() {
+        let policy = default_policy();
+        let input = setup_test_input(2_000).unwrap();
+        assert!(policy.check_input_script_type(&[input]).is_ok());
+    }
+}

src/selector.rs

@@ -687,3 +687,128 @@ impl<'c> Selector<'c> {
         })
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::test_utils::*;
+    use bitcoin::Amount;
+
+    fn test_builder() -> SelectorParamsBuilder {
+        SelectorParams::builder(
+            FeeRate::from_sat_per_vb_unchecked(1),
+            ChangeScript::from_script(p2tr_script(), Weight::from_wu(70)),
+        )
+    }
+
+    #[test]
+    fn test_new_skips_validation() {
+        // The unvalidated selection.
+        let params = SelectorParams::new(
+            FeeRate::from_sat_per_vb_unchecked(1),
+            vec![create_output(p2tr_script(), 1)], // dust
+            ChangeScript::from_script(p2tr_script(), Weight::from_wu(70)),
+        );
+        // Construction succeeds; explicit validation would fail.
+        assert!(matches!(
+            params.check_standardness(),
+            Err(SelectorParamsError::DustOutput { .. })
+        ));
+    }
+
+    #[test]
+    fn test_dust_output() {
+        let script = p2tr_script();
+        let dust_limit = script.minimal_non_dust();
+        let below_dust = dust_limit.to_sat() - 1;
+
+        // Output exactly at the minimum non-dust value.
+        assert!(test_builder()
+            .add_output(create_output(script.clone(), dust_limit.to_sat()))
+            .build()
+            .is_ok());
+
+        // OP_RETURN outputs are exempt from the dust check.
+        assert!(test_builder()
+            .add_output(create_output(op_return_script(b"test data"), 0))
+            .build()
+            .is_ok());
+
+        // Below the dust threshold reports the actual and required values.
+        match test_builder()
+            .add_output(create_output(script, below_dust))
+            .build()
+        {
+            Err(SelectorParamsError::DustOutput { actual, required }) => {
+                assert_eq!(actual, Amount::from_sat(below_dust));
+                assert_eq!(required, dust_limit);
+            }
+            other => panic!("expected DustOutput error, got {:?}", other),
+        }
+    }
+
+    #[test]
+    fn test_op_return_policy() {
+        // A single zero-value OP_RETURN.
+        assert!(test_builder()
+            .add_output(create_output(op_return_script(b"first message"), 0))
+            .build()
+            .is_ok());
+
+        // OP_RETURN with non-zero value is rejected.
+        assert!(matches!(
+            test_builder()
+                .add_output(create_output(op_return_script(b"data"), 1))
+                .build(),
+            Err(SelectorParamsError::OpReturnWithValue)
+        ));
+
+        // A single large OP_RETURN well under the cap passes.
+        let large_but_ok = op_return_script(&vec![0xab; 50_000]);
+        assert!(test_builder()
+            .add_output(create_output(large_but_ok, 0))
+            .build()
+            .is_ok());
+
+        // Two OP_RETURNs that individually fit but together exceed the
+        // aggregate cap are rejected.
+        let half_one = op_return_script_large(&vec![0xab; 60_000]);
+        let half_two = op_return_script_large(&vec![0xcd; 60_000]);
+        match test_builder()
+            .add_outputs(vec![create_output(half_one, 0), create_output(half_two, 0)])
+            .build()
+        {
+            Err(SelectorParamsError::OpReturnTooLarge { actual, max }) => {
+                assert!(actual > max);
+                assert_eq!(max, MAX_OP_RETURN_BYTES);
+            }
+            other => panic!("expected OpReturnTooLarge, got {:?}", other),
+        }
+
+        // A single OP_RETURN coexists with regular outputs.
+        assert!(test_builder()
+            .add_outputs(vec![
+                create_output(p2tr_script(), 50_000),
+                create_output(p2tr_script(), 30_000),
+                create_output(op_return_script(b"memo"), 0),
+            ])
+            .build()
+            .is_ok());
+    }
+    #[test]
+    fn test_output_script_type() {
+        // Standard P2TR output passes.
+        assert!(test_builder()
+            .add_output(create_output(p2tr_script(), 10_000))
+            .build()
+            .is_ok());
+
+        // Non-standard script is rejected.
+        assert!(matches!(
+            test_builder()
+                .add_output(create_output(non_standard_script(), 10_000))
+                .build(),
+            Err(SelectorParamsError::NonStandardScriptType)
+        ));
+    }
+}