removed the Error::Asblocktime variant and made use of the Error::miniscript variant

Updated the display_string.contains for test_abs_lock_time_error_mapping

Removed unused AbslockTime enum Error

Author: AmosOO7

src/descriptor/dsl.rs

@@ -722,9 +722,10 @@ macro_rules! fragment {
     });
     ( after ( $value:expr ) ) => ({
         $crate::miniscript::AbsLockTime::from_consensus($value)
-            .map_err($crate::descriptor::DescriptorError::from)
+            .map_err(|e| $crate::descriptor::DescriptorError::Miniscript($crate::miniscript::Error::AbsoluteLockTime(e)))
             .and_then(|abs_lock_time| $crate::impl_leaf_opcode_value!(After, abs_lock_time))
     });
+
     ( older ( $value:expr ) ) => ({
         $crate::impl_leaf_opcode_value!(Older, $crate::miniscript::RelLockTime::from_consensus($value).expect("valid `RelLockTime`")) // TODO!!
     });

src/descriptor/error.rs

@@ -44,8 +44,6 @@ pub enum Error {
     Hex(bitcoin::hex::HexToBytesError),
     /// The provided wallet descriptors are identical
     ExternalAndInternalAreTheSame,
-    /// Abslocktime validation error
-    AbsLockTime(miniscript::AbsLockTimeError),
 }
 
 impl From<crate::keys::KeyError> for Error {
@@ -86,7 +84,6 @@ impl fmt::Display for Error {
             Self::ExternalAndInternalAreTheSame => {
                 write!(f, "External and internal descriptors are the same")
             }
-            Self::AbsLockTime(err) => write!(f, "AbsLockTime error: {err}"),
         }
     }
 }
@@ -128,9 +125,3 @@ impl From<crate::descriptor::policy::PolicyError> for Error {
         Error::Policy(err)
     }
 }
-
-impl From<miniscript::AbsLockTimeError> for Error {
-    fn from(err: miniscript::AbsLockTimeError) -> Self {
-        Error::AbsLockTime(err)
-    }
-}

tests/descriptor_macro.rs

@@ -13,7 +13,9 @@ fn test_after_with_invalid_abslocktime_zero() {
     );
 
     // Check for the correct error variant
-    if let Err(descriptor::DescriptorError::AbsLockTime(_)) = result {
+    if let Err(descriptor::DescriptorError::Miniscript(miniscript::Error::AbsoluteLockTime(_))) =
+        result
+    {
         // Success: Error was caught and mapped correctly
     } else {
         panic!("Expected AbsLockTime error, got {:?}", result);
@@ -55,8 +57,13 @@ fn test_after_with_invalid_just_above_max() {
     let result = descriptor!(wsh(after(too_large)));
 
     assert!(
-        result.is_err(),
-        "Value 2,147,483,649 should return a DescriptorError::AbsLockTime"
+        matches!(
+            result,
+            Err(descriptor::DescriptorError::Miniscript(
+                miniscript::Error::AbsoluteLockTime(_)
+            ))
+        ),
+        "Should fail specifically with a Miniscript AbsoluteLockTime error"
     );
 }
 
@@ -74,21 +81,26 @@ fn test_after_with_u32_max_is_invalid() {
 
 #[test]
 fn test_abs_lock_time_error_mapping() {
-    // Manually trigger the error to verify the From conversion into DescriptorError
     let invalid_value = 0;
     let abs_lock_result = AbsLockTime::from_consensus(invalid_value);
 
     assert!(abs_lock_result.is_err());
     let abs_err = abs_lock_result.unwrap_err();
 
-    // Verify the conversion into your custom DescriptorError
-    let error: descriptor::DescriptorError = abs_err.into();
-    assert!(matches!(error, descriptor::DescriptorError::AbsLockTime(_)));
+    // Wrap in the general Miniscript Error enum
+    let minisc_err = miniscript::Error::AbsoluteLockTime(abs_err);
+
+    // Convert to your local Error type using .into()
+    let error: descriptor::DescriptorError = minisc_err.into();
+
+    // Assert it landed in the Miniscript variant
+    assert!(matches!(error, descriptor::DescriptorError::Miniscript(_)));
 
-    // Check that the error message is descriptive
+    // Verify the error message contains the expected text
     let display_string = format!("{}", error);
     assert!(
-        display_string.contains("AbsLockTime"),
-        "Error message should mention AbsLockTime"
+        display_string.contains("absolute locktime"),
+        "Error message '{}' should mention locktime",
+        display_string
     );
 }