Return Timelocked instead of (Timelock, Vec<SpendableOutput>)

Timelocked doesn't expose the Vec yet requires calling not_locked(), 
unlocked(Timelock), or ignore_timelock().

coins/monero/src/transaction.rs

@@ -1,3 +1,5 @@
+use core::cmp::Ordering;
+
 use curve25519_dalek::edwards::EdwardsPoint;
 
 use crate::{hash, serialize::*, ringct::{RctPrunable, RctSignatures}};
@@ -131,6 +133,17 @@ impl Timelock {
   }
 }
 
+impl PartialOrd for Timelock {
+  fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+    match (self, other) {
+      (Timelock::None, _) => Some(Ordering::Less),
+      (Timelock::Block(a), Timelock::Block(b)) => a.partial_cmp(b),
+      (Timelock::Time(a), Timelock::Time(b)) => a.partial_cmp(b),
+      _ => None
+    }
+  }
+}
+
 #[derive(Clone, PartialEq, Debug)]
 pub struct TransactionPrefix {
   pub version: u64,

coins/monero/src/wallet/scan.rs

@@ -24,6 +24,30 @@ pub struct SpendableOutput {
   pub commitment: Commitment
 }
 
+pub struct Timelocked(Timelock, Vec<SpendableOutput>);
+impl Timelocked {
+  pub fn timelock(&self) -> Timelock {
+    self.0
+  }
+
+  pub fn not_locked(&self) -> Vec<SpendableOutput> {
+    if self.0 == Timelock::None {
+      return self.1.clone();
+    }
+    vec![]
+  }
+
+  /// Returns None if the Timelocks aren't comparable. Returns Some(vec![]) if none are unlocked
+  pub fn unlocked(&self, timelock: Timelock) -> Option<Vec<SpendableOutput>> {
+    // If the Timelocks are comparable, return the outputs if they're now unlocked
+    self.0.partial_cmp(&timelock).filter(|_| self.0 <= timelock).map(|_| self.1.clone())
+  }
+
+  pub fn ignore_timelock(&self) -> Vec<SpendableOutput> {
+    self.1.clone()
+  }
+}
+
 impl SpendableOutput {
   pub fn serialize(&self) -> Vec<u8> {
     let mut res = Vec::with_capacity(32 + 1 + 32 + 32 + 40);
@@ -57,7 +81,7 @@ impl Transaction {
     &self,
     view: ViewPair,
     guaranteed: bool
-  ) -> (Vec<SpendableOutput>, Timelock) {
+  ) -> Timelocked {
     let mut extra = vec![];
     write_varint(&u64::try_from(self.prefix.extra.len()).unwrap(), &mut extra).unwrap();
     extra.extend(&self.prefix.extra);
@@ -75,7 +99,7 @@ impl Transaction {
 
       pubkeys = m_pubkeys.iter().map(|key| key.point.decompress()).filter_map(|key| key).collect();
     } else {
-      return (vec![], self.prefix.timelock);
+      return Timelocked(self.prefix.timelock, vec![]);
     };
 
     let mut res = vec![];
@@ -132,6 +156,6 @@ impl Transaction {
       }
     }
 
-    (res, self.prefix.timelock)
+    Timelocked(self.prefix.timelock, res)
   }
 }

coins/monero/tests/send.rs

@@ -91,7 +91,7 @@ async fn send_core(test: usize, multisig: bool) {
 
       // Grab the largest output available
       let output = {
-        let mut outputs = tx.as_ref().unwrap().scan(view_pair, false).0;
+        let mut outputs = tx.as_ref().unwrap().scan(view_pair, false).ignore_timelock();
         outputs.sort_by(|x, y| x.commitment.amount.cmp(&y.commitment.amount).reverse());
         outputs.swap_remove(0)
       };
@@ -116,7 +116,7 @@ async fn send_core(test: usize, multisig: bool) {
 
       for i in (start + 1) .. (start + 9) {
         let tx = rpc.get_block_transactions(i).await.unwrap().swap_remove(0);
-        let output = tx.scan(view_pair, false).0.swap_remove(0);
+        let output = tx.scan(view_pair, false).ignore_timelock().swap_remove(0);
         amount += output.commitment.amount;
         outputs.push(output);
       }