Use lock_time instead of age

We currently use age/height as identifiers for values related to CLTV
and CSV. However we get them mixed up in the `at_age`/`at_height`
functions. This is a clear sign that the names are not good. Instead of
'age' use 'lock_time' - this is what the field in a transaction is
called and it is easier to remember because of nLockTime and
OP_CHECKLOCKTIMEVERIFY.

Author: tcharding

examples/sign_multisig.rs

@@ -60,7 +60,7 @@ fn main() {
          53ae"
     );
 
-    // Attempt to satisfy at age 0, height 0.
+    // Attempt to satisfy at lock_time 0, height 0.
     let original_txin = tx.input[0].clone();
 
     let mut sigs = HashMap::<bitcoin::PublicKey, miniscript::bitcoin::EcdsaSig>::new();

src/interpreter/mod.rs

@@ -48,7 +48,7 @@ pub struct Interpreter<'txin> {
     /// For non-Taproot spends, the scriptCode; for Taproot script-spends, this
     /// is the leaf script; for key-spends it is `None`.
     script_code: Option<bitcoin::Script>,
-    age: u32,
+    lock_time: u32,
     height: u32,
 }
 
@@ -169,15 +169,15 @@ impl<'txin> Interpreter<'txin> {
         spk: &bitcoin::Script,
         script_sig: &'txin bitcoin::Script,
         witness: &'txin Witness,
-        age: u32,
+        lock_time: u32,
         height: u32,
     ) -> Result<Self, Error> {
         let (inner, stack, script_code) = inner::from_txdata(spk, script_sig, witness)?;
         Ok(Interpreter {
             inner,
             stack,
             script_code,
-            age,
+            lock_time,
             height,
         })
     }
@@ -208,7 +208,7 @@ impl<'txin> Interpreter<'txin> {
             // Cloning the references to elements of stack should be fine as it allows
             // call interpreter.iter() without mutating interpreter
             stack: self.stack.clone(),
-            age: self.age,
+            lock_time: self.lock_time,
             height: self.height,
             has_errored: false,
         }
@@ -527,7 +527,7 @@ pub struct Iter<'intp, 'txin: 'intp> {
     public_key: Option<&'intp BitcoinKey>,
     state: Vec<NodeEvaluationState<'intp>>,
     stack: Stack<'txin>,
-    age: u32,
+    lock_time: u32,
     height: u32,
     has_errored: bool,
 }
@@ -605,7 +605,7 @@ where
                 Terminal::After(ref n) => {
                     debug_assert_eq!(node_state.n_evaluated, 0);
                     debug_assert_eq!(node_state.n_satisfied, 0);
-                    let res = self.stack.evaluate_after(n, self.age);
+                    let res = self.stack.evaluate_after(n, self.lock_time);
                     if res.is_some() {
                         return res;
                     }
@@ -1130,7 +1130,7 @@ mod tests {
                     n_evaluated: 0,
                     n_satisfied: 0,
                 }],
-                age: 1002,
+                lock_time: 1002,
                 height: 1002,
                 has_errored: false,
             }

src/interpreter/stack.rs

@@ -231,9 +231,9 @@ impl<'txin> Stack<'txin> {
     pub(super) fn evaluate_after(
         &mut self,
         n: &u32,
-        age: u32,
+        lock_time: u32,
     ) -> Option<Result<SatisfiedConstraint, Error>> {
-        if age >= *n {
+        if lock_time >= *n {
             self.push(Element::Satisfied);
             Some(Ok(SatisfiedConstraint::AbsoluteTimelock { time: *n }))
         } else {

src/miniscript/mod.rs

@@ -854,7 +854,7 @@ mod tests {
         let mut abs = miniscript.lift().unwrap();
         assert_eq!(abs.n_keys(), 5);
         assert_eq!(abs.minimum_n_keys(), Some(2));
-        abs = abs.at_age(10000);
+        abs = abs.at_lock_time(10000);
         assert_eq!(abs.n_keys(), 5);
         assert_eq!(abs.minimum_n_keys(), Some(2));
         abs = abs.at_age(9999);

src/policy/compiler.rs

@@ -1382,13 +1382,13 @@ mod tests {
         let mut abs = policy.lift().unwrap();
         assert_eq!(abs.n_keys(), 8);
         assert_eq!(abs.minimum_n_keys(), Some(2));
-        abs = abs.at_age(10000);
+        abs = abs.at_lock_time(10000);
         assert_eq!(abs.n_keys(), 8);
         assert_eq!(abs.minimum_n_keys(), Some(2));
-        abs = abs.at_age(9999);
+        abs = abs.at_lock_time(9999);
         assert_eq!(abs.n_keys(), 5);
         assert_eq!(abs.minimum_n_keys(), Some(3));
-        abs = abs.at_age(0);
+        abs = abs.at_lock_time(0);
         assert_eq!(abs.n_keys(), 5);
         assert_eq!(abs.minimum_n_keys(), Some(3));
 

src/policy/semantic.rs

@@ -538,21 +538,21 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
         self.normalized()
     }
 
-    /// Filter a policy by eliminating absolute timelock constraints
-    /// that are not satisfied at the given age.
-    pub fn at_height(mut self, time: u32) -> Policy<Pk> {
+    /// Filter a policy by eliminating absolute timelock constraints that are not satisfied at the
+    /// given age `n` (n comes from `n OP_CHECKLOCKTIMEVERIFY`).
+    pub fn at_lock_time(mut self, n: u32) -> Policy<Pk> {
         self = match self {
             Policy::After(t) => {
-                if !timelock::absolute_timelocks_are_same_unit(t, time) {
+                if !timelock::absolute_timelocks_are_same_unit(t, n) {
                     Policy::Unsatisfiable
-                } else if t > time {
+                } else if t > n {
                     Policy::Unsatisfiable
                 } else {
                     Policy::After(t)
                 }
             }
             Policy::Threshold(k, subs) => {
-                Policy::Threshold(k, subs.into_iter().map(|sub| sub.at_height(time)).collect())
+                Policy::Threshold(k, subs.into_iter().map(|sub| sub.at_lock_time(n)).collect())
             }
             x => x,
         };
@@ -655,19 +655,19 @@ mod tests {
         assert_eq!(policy, Policy::KeyHash("".to_owned()));
         assert_eq!(policy.relative_timelocks(), vec![]);
         assert_eq!(policy.absolute_timelocks(), vec![]);
-        assert_eq!(policy.clone().at_age(0), policy.clone());
-        assert_eq!(policy.clone().at_age(10000), policy.clone());
+        assert_eq!(policy.clone().at_lock_time(0), policy.clone());
+        assert_eq!(policy.clone().at_lock_time(10000), policy.clone());
         assert_eq!(policy.n_keys(), 1);
         assert_eq!(policy.minimum_n_keys(), Some(1));
 
         let policy = StringPolicy::from_str("older(1000)").unwrap();
         assert_eq!(policy, Policy::Older(1000));
         assert_eq!(policy.absolute_timelocks(), vec![]);
         assert_eq!(policy.relative_timelocks(), vec![1000]);
-        assert_eq!(policy.clone().at_age(0), Policy::Unsatisfiable);
-        assert_eq!(policy.clone().at_age(999), Policy::Unsatisfiable);
-        assert_eq!(policy.clone().at_age(1000), policy.clone());
-        assert_eq!(policy.clone().at_age(10000), policy.clone());
+        assert_eq!(policy.clone().at_lock_time(0), Policy::Unsatisfiable);
+        assert_eq!(policy.clone().at_lock_time(999), Policy::Unsatisfiable);
+        assert_eq!(policy.clone().at_lock_time(1000), policy.clone());
+        assert_eq!(policy.clone().at_lock_time(10000), policy.clone());
         assert_eq!(policy.n_keys(), 0);
         assert_eq!(policy.minimum_n_keys(), Some(0));
 
@@ -681,10 +681,10 @@ mod tests {
         );
         assert_eq!(policy.relative_timelocks(), vec![1000]);
         assert_eq!(policy.absolute_timelocks(), vec![]);
-        assert_eq!(policy.clone().at_age(0), Policy::KeyHash("".to_owned()));
-        assert_eq!(policy.clone().at_age(999), Policy::KeyHash("".to_owned()));
-        assert_eq!(policy.clone().at_age(1000), policy.clone().normalized());
-        assert_eq!(policy.clone().at_age(10000), policy.clone().normalized());
+        assert_eq!(policy.clone().at_lock_time(0), Policy::KeyHash("".to_owned()));
+        assert_eq!(policy.clone().at_lock_time(999), Policy::KeyHash("".to_owned()));
+        assert_eq!(policy.clone().at_lock_time(1000), policy.clone().normalized());
+        assert_eq!(policy.clone().at_lock_time(10000), policy.clone().normalized());
         assert_eq!(policy.n_keys(), 1);
         assert_eq!(policy.minimum_n_keys(), Some(0));
 
@@ -813,7 +813,7 @@ mod tests {
         let backup_policy = StringPolicy::from_str("thresh(2,pkh(A),pkh(B),pkh(C))").unwrap();
         assert!(!backup_policy
             .clone()
-            .entails(liquid_pol.clone().at_age(4095))
+            .entails(liquid_pol.clone().at_lock_time(4095))
             .unwrap());
 
         // Finally test both spending paths