- Changed test file name descriptor_macro.rs

- Changed style for macro
- Remove println from tests
- Updated the valiid values and invalid values in test file `descriptor_macro.rs`
- Removed impl with Error::Relocktime and made use of existing Error::Miniscript
- Removed the RelLockTime enum Error in error.rs

Author: AmosOO7

src/descriptor/dsl.rs

@@ -724,10 +724,10 @@ macro_rules! fragment {
         $crate::impl_leaf_opcode_value!(After, $crate::miniscript::AbsLockTime::from_consensus($value).expect("valid `AbsLockTime`"))
     });
     ( older ( $value:expr ) ) => ({
-        match $crate::miniscript::RelLockTime::from_consensus($value) {
-            Ok(lock_time) => $crate::impl_leaf_opcode_value!(Older, lock_time),
-            Err(e) => Err($crate::descriptor::DescriptorError::RelLockTime(e)),
-        }
+        $crate::miniscript::RelLockTime::from_consensus($value)
+            // Corrected variant name: RelativeLockTime (capital T)
+            .map_err(|e| $crate::descriptor::DescriptorError::Miniscript($crate::miniscript::Error::RelativeLockTime(e)))
+            .and_then(|rel_lock_time| $crate::impl_leaf_opcode_value!(Older, rel_lock_time))
     });
     ( sha256 ( $hash:expr ) ) => ({
         $crate::impl_leaf_opcode_value!(Sha256, $hash)

src/descriptor/error.rs

@@ -44,8 +44,6 @@ pub enum Error {
     Hex(bitcoin::hex::HexToBytesError),
     /// The provided wallet descriptors are identical
     ExternalAndInternalAreTheSame,
-    /// RelLockTime validation error
-    RelLockTime(miniscript::RelLockTimeError),
 }
 
 impl From<crate::keys::KeyError> for Error {
@@ -86,13 +84,11 @@ impl fmt::Display for Error {
             Self::ExternalAndInternalAreTheSame => {
                 write!(f, "External and internal descriptors are the same")
             }
-            Self::RelLockTime(err) => write!(f, "RelLockTime error: {err}"),
         }
     }
 }
 
-#[cfg(feature = "std")]
-impl std::error::Error for Error {}
+impl core::error::Error for Error {}
 
 impl From<bitcoin::bip32::Error> for Error {
     fn from(err: bitcoin::bip32::Error) -> Self {
@@ -129,9 +125,3 @@ impl From<crate::descriptor::policy::PolicyError> for Error {
         Error::Policy(err)
     }
 }
-
-impl From<miniscript::RelLockTimeError> for Error {
-    fn from(err: miniscript::RelLockTimeError) -> Self {
-        Error::RelLockTime(err)
-    }
-}

tests/test_rellocktime_issue.rs tests/descriptor_macro.rstests/test_rellocktime_issue.rs renamed to tests/descriptor_macro.rs

@@ -1,7 +1,7 @@
 /// Test to demonstrate the RelLockTime issue in dsl.rs
 ///
 /// The issue: older() macro uses .expect() on RelLockTime::from_consensus(),
-/// which can panic if given an invalid value (> 16,777,215).
+/// which can panic if given an invalid value (> 65,535).
 ///
 /// This file shows the problem and how to catch it.
 use bdk_wallet::descriptor;
@@ -20,17 +20,18 @@ fn test_older_with_invalid_rellocktime_too_large() {
     );
 
     // Check that it's the right kind of error
-    if let Err(descriptor::DescriptorError::RelLockTime(_)) = result {
-        // Good, it's the expected error type
+    if let Err(descriptor::DescriptorError::Miniscript(miniscript::Error::RelativeLockTime(_))) =
+        result
+    {
     } else {
         panic!("Expected RelLockTime error, got {:?}", result);
     }
 }
 
 #[test]
 fn test_older_with_valid_rellocktime_max() {
-    // Max valid value is 16,777,215 (0xFFFFFF)
-    let max_valid_value = 16_777_215;
+    // Max valid value is 65,535 (0xFFFF)
+    let max_valid_value = 65_535;
     let result = descriptor!(wsh(older(max_valid_value)));
     assert!(result.is_ok(), "Max valid RelLockTime should work");
 }
@@ -70,33 +71,52 @@ fn test_demonstrate_proper_error_handling() {
     use miniscript::RelLockTime;
 
     // Valid case
-    match RelLockTime::from_consensus(144) {
-        Ok(lock_time) => println!("Valid: {:?}", lock_time),
-        Err(e) => println!("Invalid: {}", e),
-    }
+    let valid_lock = RelLockTime::from_consensus(144);
+    assert!(
+        valid_lock.is_ok(),
+        "144 blocks should be a valid RelLockTime"
+    );
 
-    // Invalid case - properly handled
-    match RelLockTime::from_consensus(16_777_216) {
-        Ok(lock_time) => println!("Valid: {:?}", lock_time),
-        Err(e) => {
-            println!("Invalid RelLockTime value: {}", e);
-        }
-    }
+    // Invalid case
+    let invalid_value = 0x8000_0000;
+    let invalid_result = RelLockTime::from_consensus(invalid_value);
+    assert!(
+        invalid_result.is_err(),
+        "Value 0x{:x} should return a RelLockTime error",
+        invalid_value
+    );
 }
 
 #[test]
 fn test_rel_lock_time_error() {
-    // Create a RelLockTimeError by trying to create an invalid RelLockTime
-    let invalid_value = 0x80000000u32; // Value that causes RelLockTime::from_consensus to fail
+    // 1. Create the underlying RelLockTime error (high bit set)
+    let invalid_value = 0x80000000u32;
     let rel_lock_time_result = miniscript::RelLockTime::from_consensus(invalid_value);
     assert!(rel_lock_time_result.is_err());
+
     let rel_lock_time_error = rel_lock_time_result.unwrap_err();
 
-    // Test the From impl
-    let error: descriptor::DescriptorError = rel_lock_time_error.into();
-    assert!(matches!(error, descriptor::DescriptorError::RelLockTime(_)));
+    // 2. Wrap it in the Miniscript error variant (matching your new macro logic)
+    let minisc_err = miniscript::Error::RelativeLockTime(rel_lock_time_error);
+
+    // 3. Test the From impl (Miniscript -> DescriptorError)
+    let error: descriptor::DescriptorError = minisc_err.into();
+
+    // Check that it matches the nested structure
+    assert!(matches!(
+        error,
+        descriptor::DescriptorError::Miniscript(miniscript::Error::RelativeLockTime(_))
+    ));
 
-    // Test the Display impl
+    // 4. Test the Display impl
     let display_string = format!("{}", error);
-    assert!(display_string.starts_with("RelLockTime error:"));
+
+    // FIX: Since the error is now wrapped in DescriptorError::Miniscript,
+    // the string likely starts with "Miniscript error:" or similar.
+    // Using .contains() is more robust for nested errors.
+    assert!(
+        display_string.contains("relative locktime"),
+        "Display string was: '{}'",
+        display_string
+    );
 }