introduce RelLockTime type

Just like AbsLockTime, this gives us a locktime which implements Ord and
which cannot be constructed unless it meets the invariants specified by
Miniscript.

Author: apoelstra

src/lib.rs

@@ -151,6 +151,7 @@ pub use crate::miniscript::satisfy::{Preimage32, Satisfier};
 pub use crate::miniscript::{hash256, Miniscript};
 use crate::prelude::*;
 pub use crate::primitives::absolute_locktime::{AbsLockTime, AbsLockTimeError};
+pub use crate::primitives::relative_locktime::{RelLockTime, RelLockTimeError};
 
 /// Public key trait which can be converted to Hash type
 pub trait MiniscriptKey: Clone + Eq + Ord + fmt::Debug + fmt::Display + hash::Hash {
@@ -505,6 +506,8 @@ pub enum Error {
     MultipathDescLenMismatch,
     /// Invalid absolute locktime
     AbsoluteLockTime(AbsLockTimeError),
+    /// Invalid absolute locktime
+    RelativeLockTime(RelLockTimeError),
 }
 
 // https://github.com/sipa/miniscript/pull/5 for discussion on this number
@@ -581,6 +584,7 @@ impl fmt::Display for Error {
             Error::TrNoExplicitScript => write!(f, "No script code for Tr descriptors"),
             Error::MultipathDescLenMismatch => write!(f, "At least two BIP389 key expressions in the descriptor contain tuples of derivation indexes of different lengths"),
             Error::AbsoluteLockTime(ref e) => e.fmt(f),
+            Error::RelativeLockTime(ref e) => e.fmt(f),
         }
     }
 }
@@ -634,6 +638,7 @@ impl error::Error for Error {
             AnalysisError(e) => Some(e),
             PubKeyCtxError(e, _) => Some(e),
             AbsoluteLockTime(e) => Some(e),
+            RelativeLockTime(e) => Some(e),
         }
     }
 }

src/primitives/mod.rs

@@ -12,3 +12,4 @@
 //! should be re-exported at the crate root.
 
 pub mod absolute_locktime;
+pub mod relative_locktime;

src/primitives/relative_locktime.rs

@@ -0,0 +1,100 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Relative Locktimes
+
+use core::{cmp, convert, fmt};
+
+use bitcoin::{relative, Sequence};
+
+/// Error parsing an absolute locktime.
+#[derive(Debug, PartialEq)]
+pub struct RelLockTimeError {
+    value: u32,
+}
+
+impl fmt::Display for RelLockTimeError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        if self.value == 0 {
+            f.write_str("relative locktimes in Miniscript have a minimum value of 1")
+        } else {
+            debug_assert!(Sequence::from_consensus(self.value)
+                .to_relative_lock_time()
+                .is_none());
+            write!(f, "locktime value {} is not a valid BIP68 relative locktime", self.value)
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for RelLockTimeError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { None }
+}
+
+/// A relative locktime which implements `Ord`.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct RelLockTime(Sequence);
+
+impl RelLockTime {
+    /// The "0 blocks" constant.
+    pub const ZERO: Self = RelLockTime(Sequence::ZERO);
+
+    /// Constructs an `RelLockTime` from an nLockTime value or the argument to `CHEKCLOCKTIMEVERIFY`.
+    pub fn from_consensus(n: u32) -> Result<Self, RelLockTimeError> {
+        convert::TryFrom::try_from(Sequence::from_consensus(n))
+    }
+
+    /// Returns the inner `u32` value. This is the value used when creating this `LockTime`
+    /// i.e., `n OP_CHECKSEQUENCEVERIFY` or `nSequence`.
+    pub fn to_consensus_u32(self) -> u32 { self.0.to_consensus_u32() }
+
+    /// Takes a 16-bit number of blocks and produces a relative locktime from it.
+    pub fn from_height(height: u16) -> Self { RelLockTime(Sequence::from_height(height)) }
+
+    /// Takes a 16-bit number of 512-second time intervals and produces a relative locktime from it.
+    pub fn from_512_second_intervals(time: u16) -> Self {
+        RelLockTime(Sequence::from_512_second_intervals(time))
+    }
+
+    /// Whether this timelock is blockheight-based.
+    pub fn is_height_locked(&self) -> bool { self.0.is_height_locked() }
+
+    /// Whether this timelock is time-based.
+    pub fn is_time_locked(&self) -> bool { self.0.is_time_locked() }
+}
+
+impl convert::TryFrom<Sequence> for RelLockTime {
+    type Error = RelLockTimeError;
+    fn try_from(seq: Sequence) -> Result<Self, RelLockTimeError> {
+        if seq.is_relative_lock_time() {
+            Ok(RelLockTime(seq))
+        } else {
+            Err(RelLockTimeError { value: seq.to_consensus_u32() })
+        }
+    }
+}
+
+impl From<RelLockTime> for Sequence {
+    fn from(lock_time: RelLockTime) -> Sequence { lock_time.0 }
+}
+
+impl From<RelLockTime> for relative::LockTime {
+    fn from(lock_time: RelLockTime) -> relative::LockTime {
+        lock_time.0.to_relative_lock_time().unwrap()
+    }
+}
+
+impl cmp::PartialOrd for RelLockTime {
+    fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> { Some(self.cmp(other)) }
+}
+
+impl cmp::Ord for RelLockTime {
+    fn cmp(&self, other: &Self) -> cmp::Ordering {
+        let this = self.0.to_consensus_u32();
+        let that = other.0.to_consensus_u32();
+        this.cmp(&that)
+    }
+}
+
+impl fmt::Display for RelLockTime {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::Display::fmt(&self.0, f) }
+}