test: add test for standardness and mempool policy checks

Author: aagbotemi

src/lib.rs

@@ -19,6 +19,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

@@ -380,3 +380,258 @@ 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_tip() -> ChainTip {
+        ChainTip {
+            height: absolute::Height::from_consensus(3_000).unwrap(),
+            mtp: absolute::Time::from_consensus(500_001_000).unwrap(),
+        }
+    }
+
+    #[test]
+    fn default_policy_matches_bitcoin_core_v30() {
+        let default_policy = MempoolPolicy::default();
+        let v30 = MempoolPolicy::bitcoin_core_v30();
+        assert_eq!(default_policy.dust_relay_feerate, v30.dust_relay_feerate);
+        assert_eq!(default_policy.min_relay_feerate, v30.min_relay_feerate);
+        assert_eq!(
+            default_policy.max_op_return_aggregate_bytes,
+            v30.max_op_return_aggregate_bytes
+        );
+        assert_eq!(
+            default_policy.max_standard_tx_weight,
+            v30.max_standard_tx_weight
+        );
+        assert_eq!(default_policy.max_truc_tx_weight, v30.max_truc_tx_weight);
+        assert_eq!(
+            default_policy.min_standard_tx_nonwitness_size,
+            v30.min_standard_tx_nonwitness_size
+        );
+        assert_eq!(
+            default_policy.max_witness_stack_items,
+            v30.max_witness_stack_items
+        );
+        assert_eq!(default_policy.allowed_versions, v30.allowed_versions);
+    }
+
+    #[test]
+    fn test_tx_version() {
+        let policy = MempoolPolicy::default();
+        let tip = default_tip();
+        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_post_selection(&selection, &tx, tip).is_ok());
+
+        // Test version 1, which is also standard.
+        tx.version = Version::ONE;
+        assert!(policy.check_post_selection(&selection, &tx, tip).is_ok());
+
+        // Version 3 (TRUC) is standard under v30+.
+        tx.version = Version(3);
+        assert!(policy.check_post_selection(&selection, &tx, tip).is_ok());
+
+        // Test version 4, which is non-standard.
+        tx.version = Version(4);
+        assert!(matches!(
+            policy.check_post_selection(&selection, &tx, tip),
+            Err(MempoolPolicyError::UnsupportedVersion(_))
+        ));
+    }
+
+    #[test]
+    fn test_tx_locktime() {
+        let policy = MempoolPolicy::default();
+        let tip = default_tip();
+        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_post_selection(&selection, &tx, tip).is_ok());
+
+        // Locktime below the tip height.
+        tx.lock_time = absolute::LockTime::from_consensus(2_500);
+        assert!(policy.check_post_selection(&selection, &tx, tip).is_ok());
+
+        // Locktime above the tip height.
+        tx.lock_time = absolute::LockTime::from_consensus(3_001);
+        assert!(matches!(
+            policy.check_post_selection(&selection, &tx, tip),
+            Err(MempoolPolicyError::LockTimeNotMet(_))
+        ));
+
+        // Locktime one second below the tip MTP.
+        tx.lock_time = absolute::LockTime::from_consensus(500_000_999);
+        assert!(policy.check_post_selection(&selection, &tx, tip).is_ok());
+
+        // Locktime exactly equal to the tip MTP.
+        tx.lock_time = absolute::LockTime::from_consensus(500_001_000);
+        assert!(matches!(
+            policy.check_post_selection(&selection, &tx, tip),
+            Err(MempoolPolicyError::LockTimeNotMet(_))
+        ));
+
+        // Locktime above the tip MTP.
+        tx.lock_time = absolute::LockTime::from_consensus(500_002_000);
+        assert!(matches!(
+            policy.check_post_selection(&selection, &tx, tip),
+            Err(MempoolPolicyError::LockTimeNotMet(_))
+        ));
+    }
+
+    #[test]
+    fn test_max_tx_weight() {
+        let policy = MempoolPolicy::default();
+        let tip = default_tip();
+
+        // 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_post_selection(&selection, &tx, tip).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() > policy.max_standard_tx_weight);
+        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 = MempoolPolicy::default();
+        let tip = default_tip();
+        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_post_selection(&selection, &tx, tip).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() < policy.min_standard_tx_nonwitness_size);
+        assert!(matches!(
+            policy.check_post_selection(&empty_selection, &tx_below_min_non_witness_size, tip),
+            Err(MempoolPolicyError::TxTooSmall { .. })
+        ));
+    }
+
+    #[test]
+    fn test_min_fee_relay() {
+        let policy = MempoolPolicy::default();
+        let tip = default_tip();
+
+        // 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_post_selection(&selection, &tx, tip).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_post_selection(
+                &selection_with_insufficient_fee,
+                &tx_with_insufficient_fee,
+                tip
+            ),
+            Err(MempoolPolicyError::MinRelayFeeNotMet { .. })
+        ));
+    }
+
+    #[test]
+    fn test_max_witness_stack() {
+        let policy = MempoolPolicy::default();
+        let input = setup_test_input(2_000).unwrap();
+
+        assert!(policy.check_max_witness_stack(&[input]).is_ok());
+    }
+
+    #[test]
+    fn test_input_spendability() {
+        let policy = MempoolPolicy::default();
+        let tip = default_tip();
+
+        // Confirmed input.
+        let input = setup_test_input(2_000).unwrap();
+        assert!(policy.check_input_spendability(&[input], tip).is_ok());
+
+        // Immature coinbase (within COINBASE_MATURITY of the tip).
+        let input_with_immature_coinbase = setup_test_input(2_950).unwrap();
+        assert!(policy
+            .check_input_spendability(&[input_with_immature_coinbase], tip)
+            .is_err());
+    }
+
+    #[test]
+    fn test_input_script_type() {
+        let policy = MempoolPolicy::default();
+        let input = setup_test_input(2_000).unwrap();
+        assert!(policy.check_input_script_type(&[input]).is_ok());
+    }
+
+    #[test]
+    fn test_custom_policy_overrides_default() {
+        // A custom policy that allows only v3 (TRUC) transactions.
+        static V3_ONLY: &[Version] = &[Version(3)];
+        let policy = MempoolPolicy {
+            allowed_versions: V3_ONLY,
+            ..MempoolPolicy::default()
+        };
+
+        let tip = default_tip();
+        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]);
+
+        // v2 (the default tx version) is now rejected.
+        tx.version = Version::TWO;
+        assert!(matches!(
+            policy.check_post_selection(&selection, &tx, tip),
+            Err(MempoolPolicyError::UnsupportedVersion(_))
+        ));
+
+        // v3 passes.
+        tx.version = Version(3);
+        assert!(policy.check_post_selection(&selection, &tx, tip).is_ok());
+    }
+}

src/selection.rs

@@ -727,4 +727,35 @@ mod tests {
             "should return UnsupportedVersion error for version < 2"
         );
     }
+
+    #[test]
+    fn test_create_psbt_with_policy_surfaces_violations() -> anyhow::Result<()> {
+        let input = setup_test_input(2_000)?;
+        let output = Output::with_script(ScriptBuf::new(), Amount::from_sat(9_000));
+        let selection = Selection {
+            inputs: vec![input],
+            outputs: vec![output],
+        };
+
+        // Custom policy accepting only v3 (TRUC). Default PsbtParams
+        // produces v2, so the policy must reject this PSBT.
+        static V3_ONLY: &[Version] = &[Version(3)];
+        let policy = MempoolPolicy {
+            allowed_versions: V3_ONLY,
+            ..MempoolPolicy::default()
+        };
+        let tip = ChainTip {
+            height: absolute::Height::from_consensus(3_000)?,
+            mtp: absolute::Time::from_consensus(500_001_000)?,
+        };
+
+        let result = selection.create_psbt_with_policy(PsbtParams::default(), &policy, tip);
+        assert!(matches!(
+            result,
+            Err(CreatePsbtError::Policy(
+                MempoolPolicyError::UnsupportedVersion(_)
+            ))
+        ));
+        Ok(())
+    }
 }