Move verify_slice() into a trait

src/bin/historian-demo.rs

@@ -4,7 +4,7 @@ use solana::entry::Entry;
 use solana::event::Event;
 use solana::hash::Hash;
 use solana::historian::Historian;
-use solana::ledger::verify_slice;
+use solana::ledger::Block;
 use solana::recorder::Signal;
 use solana::signature::{KeyPair, KeyPairUtil};
 use solana::transaction::Transaction;
@@ -33,5 +33,5 @@ fn main() {
     }
     // Proof-of-History: Verify the historian learned about the events
     // in the same order they appear in the vector.
-    assert!(verify_slice(&entries, &seed));
+    assert!(entries[..].verify(&seed));
 }

src/historian.rs

@@ -53,7 +53,7 @@ impl Historian {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use ledger::*;
+    use ledger::Block;
     use std::thread::sleep;
     use std::time::Duration;
 
@@ -82,7 +82,7 @@ mod tests {
             ExitReason::RecvDisconnected
         );
 
-        assert!(verify_slice(&[entry0, entry1, entry2], &zero));
+        assert!([entry0, entry1, entry2].verify(&zero));
     }
 
     #[test]

src/ledger.rs

@@ -5,11 +5,17 @@ use entry::{next_tick, Entry};
 use hash::Hash;
 use rayon::prelude::*;
 
-/// Verifies the hashes and counts of a slice of events are all consistent.
-pub fn verify_slice(entries: &[Entry], start_hash: &Hash) -> bool {
-    let genesis = [Entry::new_tick(Default::default(), start_hash)];
-    let entry_pairs = genesis.par_iter().chain(entries).zip(entries);
-    entry_pairs.all(|(x0, x1)| x1.verify(&x0.id))
+pub trait Block {
+    /// Verifies the hashes and counts of a slice of events are all consistent.
+    fn verify(&self, start_hash: &Hash) -> bool;
+}
+
+impl Block for [Entry] {
+    fn verify(&self, start_hash: &Hash) -> bool {
+        let genesis = [Entry::new_tick(0, start_hash)];
+        let entry_pairs = genesis.par_iter().chain(self).zip(self);
+        entry_pairs.all(|(x0, x1)| x1.verify(&x0.id))
+    }
 }
 
 /// Create a vector of Ticks of length `len` from `start_hash` hash and `num_hashes`.
@@ -33,14 +39,14 @@ mod tests {
     fn test_verify_slice() {
         let zero = Hash::default();
         let one = hash(&zero);
-        assert!(verify_slice(&vec![], &zero)); // base case
-        assert!(verify_slice(&vec![Entry::new_tick(0, &zero)], &zero)); // singleton case 1
-        assert!(!verify_slice(&vec![Entry::new_tick(0, &zero)], &one)); // singleton case 2, bad
-        assert!(verify_slice(&next_ticks(&zero, 0, 2), &zero)); // inductive step
+        assert!(vec![][..].verify(&zero)); // base case
+        assert!(vec![Entry::new_tick(0, &zero)][..].verify(&zero)); // singleton case 1
+        assert!(!vec![Entry::new_tick(0, &zero)][..].verify(&one)); // singleton case 2, bad
+        assert!(next_ticks(&zero, 0, 2)[..].verify(&zero)); // inductive step
 
         let mut bad_ticks = next_ticks(&zero, 0, 2);
         bad_ticks[1].id = one;
-        assert!(!verify_slice(&bad_ticks, &zero)); // inductive step, bad
+        assert!(!bad_ticks.verify(&zero)); // inductive step, bad
     }
 }
 
@@ -52,10 +58,10 @@ mod bench {
 
     #[bench]
     fn event_bench(bencher: &mut Bencher) {
-        let start_hash = Default::default();
-        let events = next_ticks(&start_hash, 10_000, 8);
+        let start_hash = Hash::default();
+        let entries = next_ticks(&start_hash, 10_000, 8);
         bencher.iter(|| {
-            assert!(verify_slice(&events, &start_hash));
+            assert!(entries.verify(&start_hash));
         });
     }
 }

src/mint.rs

@@ -57,7 +57,7 @@ impl Mint {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use ledger::verify_slice;
+    use ledger::Block;
     use plan::Plan;
 
     #[test]
@@ -74,6 +74,6 @@ mod tests {
     #[test]
     fn test_verify_entries() {
         let entries = Mint::new(100).create_entries();
-        assert!(verify_slice(&entries, &entries[0].id));
+        assert!(entries[..].verify(&entries[0].id));
     }
 }