Merge pull request #44 from garious/genesis

Finally, genesis block generation without channels

src/bin/genesis-block.rs

@@ -5,23 +5,12 @@ extern crate serde_json;
 extern crate silk;
 
 use silk::genesis::Genesis;
-use silk::log::{hash, verify_slice_u64};
+use silk::log::{create_entries, hash, verify_slice_u64};
-use silk::logger::Logger;
-use std::sync::mpsc::sync_channel;
 use std::io::stdin;
 
 fn main() {
     let gen: Genesis = serde_json::from_reader(stdin()).unwrap();
-
+    let entries = create_entries(&hash(&gen.pkcs8), gen.create_events());
-    let (_sender, event_receiver) = sync_channel(100);
-    let (entry_sender, receiver) = sync_channel(100);
-    let mut logger = Logger::new(event_receiver, entry_sender, hash(&gen.pkcs8));
-    for tx in gen.create_events() {
-        logger.log_event(tx).unwrap();
-    }
-    drop(logger.sender);
-
-    let entries = receiver.iter().collect::<Vec<_>>();
     verify_slice_u64(&entries, &entries[0].id);
     println!("[");
     let len = entries.len();

src/log.rs

@@ -19,7 +19,6 @@ use serde::Serialize;
 use event::{get_signature, verify_event, Event};
 use sha2::{Digest, Sha256};
 use rayon::prelude::*;
-use std::iter;
 
 pub type Sha256Hash = GenericArray<u8, U32>;
 
@@ -77,32 +76,41 @@ pub fn next_hash<T: Serialize>(
 }
 
 /// Creates the next Entry 'num_hashes' after 'start_hash'.
-pub fn next_entry<T: Serialize>(
+pub fn create_entry<T: Serialize>(
     start_hash: &Sha256Hash,
-    num_hashes: u64,
+    cur_hashes: u64,
     event: Event<T>,
 ) -> Entry<T> {
+    let sig = get_signature(&event);
+    let num_hashes = cur_hashes + if sig.is_some() { 1 } else { 0 };
+    let id = next_hash(start_hash, 0, &event);
     Entry {
         num_hashes,
-        id: next_hash(start_hash, num_hashes, &event),
+        id,
         event,
     }
 }
 
 /// Creates the next Tick Entry 'num_hashes' after 'start_hash'.
-pub fn next_entry_mut<T: Serialize>(
+pub fn create_entry_mut<T: Serialize>(
     start_hash: &mut Sha256Hash,
-    num_hashes: u64,
+    cur_hashes: &mut u64,
     event: Event<T>,
 ) -> Entry<T> {
-    let entry = next_entry(start_hash, num_hashes, event);
+    let entry = create_entry(start_hash, *cur_hashes, event);
     *start_hash = entry.id;
+    *cur_hashes = 0;
     entry
 }
 
 /// Creates the next Tick Entry 'num_hashes' after 'start_hash'.
 pub fn next_tick<T: Serialize>(start_hash: &Sha256Hash, num_hashes: u64) -> Entry<T> {
-    next_entry(start_hash, num_hashes, Event::Tick)
+    let event = Event::Tick;
+    Entry {
+        num_hashes,
+        id: next_hash(start_hash, num_hashes, &event),
+        event,
+    }
 }
 
 /// Verifies self.id is the result of hashing a 'start_hash' 'self.num_hashes' times.
@@ -137,27 +145,25 @@ pub fn verify_slice_seq<T: Serialize>(events: &[Entry<T>], start_hash: &Sha256Ha
 
 pub fn create_entries<T: Serialize>(
     start_hash: &Sha256Hash,
-    num_hashes: u64,
     events: Vec<Event<T>>,
 ) -> Vec<Entry<T>> {
     let mut id = *start_hash;
     events
         .into_iter()
-        .map(|event| next_entry_mut(&mut id, num_hashes, event))
+        .map(|event| create_entry_mut(&mut id, &mut 0, event))
         .collect()
 }
 
 /// Create a vector of Ticks of length 'len' from 'start_hash' hash and 'num_hashes'.
-pub fn create_ticks(
+pub fn next_ticks(start_hash: &Sha256Hash, num_hashes: u64, len: usize) -> Vec<Entry<Sha256Hash>> {
-    start_hash: &Sha256Hash,
-    num_hashes: u64,
-    len: usize,
-) -> Vec<Entry<Sha256Hash>> {
     let mut id = *start_hash;
-    iter::repeat(Event::Tick)
+    let mut ticks = vec![];
-        .take(len)
+    for _ in 0..len {
-        .map(|event| next_entry_mut(&mut id, num_hashes, event))
+        let entry = next_tick(&id, num_hashes);
-        .collect()
+        id = entry.id;
+        ticks.push(entry);
+    }
+    ticks
 }
 
 #[cfg(test)]
@@ -187,9 +193,9 @@ mod tests {
         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(&create_ticks(&zero, 0, 2), &zero)); // inductive step
+        assert!(verify_slice(&next_ticks(&zero, 0, 2), &zero)); // inductive step
 
-        let mut bad_ticks = create_ticks(&zero, 0, 2);
+        let mut bad_ticks = next_ticks(&zero, 0, 2);
         bad_ticks[1].id = one;
         assert!(!verify_slice(&bad_ticks, &zero)); // inductive step, bad
     }
@@ -214,7 +220,7 @@ mod tests {
         let event0 = Event::new_claim(get_pubkey(&keypair), zero, sign_claim_data(&zero, &keypair));
         let event1 = Event::new_claim(get_pubkey(&keypair), one, sign_claim_data(&one, &keypair));
         let events = vec![event0, event1];
-        let mut entries = create_entries(&zero, 0, events);
+        let mut entries = create_entries(&zero, events);
         assert!(verify_slice(&entries, &zero));
 
         // Next, swap two events and ensure verification fails.
@@ -231,7 +237,7 @@ mod tests {
         let data = hash(b"hello, world");
         let event0 = Event::new_claim(get_pubkey(&keypair), data, sign_claim_data(&data, &keypair));
         let zero = Sha256Hash::default();
-        let entries = create_entries(&zero, 0, vec![event0]);
+        let entries = create_entries(&zero, vec![event0]);
         assert!(verify_slice(&entries, &zero));
     }
 
@@ -244,7 +250,7 @@ mod tests {
             sign_claim_data(&hash(b"hello, world"), &keypair),
         );
         let zero = Sha256Hash::default();
-        let entries = create_entries(&zero, 0, vec![event0]);
+        let entries = create_entries(&zero, vec![event0]);
         assert!(!verify_slice(&entries, &zero));
     }
 
@@ -261,7 +267,7 @@ mod tests {
             sig: sign_transaction_data(&data, &keypair0, &pubkey1),
         };
         let zero = Sha256Hash::default();
-        let entries = create_entries(&zero, 0, vec![event0]);
+        let entries = create_entries(&zero, vec![event0]);
         assert!(verify_slice(&entries, &zero));
     }
 
@@ -278,7 +284,7 @@ mod tests {
             sig: sign_transaction_data(&data, &keypair0, &pubkey1),
         };
         let zero = Sha256Hash::default();
-        let entries = create_entries(&zero, 0, vec![event0]);
+        let entries = create_entries(&zero, vec![event0]);
         assert!(!verify_slice(&entries, &zero));
     }
 
@@ -296,7 +302,7 @@ mod tests {
             sig: sign_transaction_data(&data, &keypair0, &pubkey1),
         };
         let zero = Sha256Hash::default();
-        let entries = create_entries(&zero, 0, vec![event0]);
+        let entries = create_entries(&zero, vec![event0]);
         assert!(!verify_slice(&entries, &zero));
     }
 }
@@ -310,7 +316,7 @@ mod bench {
     #[bench]
     fn event_bench(bencher: &mut Bencher) {
         let start_hash = Default::default();
-        let events = create_ticks(&start_hash, 10_000, 8);
+        let events = next_ticks(&start_hash, 10_000, 8);
         bencher.iter(|| {
             assert!(verify_slice(&events, &start_hash));
         });
@@ -319,7 +325,7 @@ mod bench {
     #[bench]
     fn event_bench_seq(bencher: &mut Bencher) {
         let start_hash = Default::default();
-        let events = create_ticks(&start_hash, 10_000, 8);
+        let events = next_ticks(&start_hash, 10_000, 8);
         bencher.iter(|| {
             assert!(verify_slice_seq(&events, &start_hash));
         });

src/logger.rs

@@ -8,7 +8,7 @@
 use std::collections::HashSet;
 use std::sync::mpsc::{Receiver, SyncSender, TryRecvError};
 use std::time::{Duration, Instant};
-use log::{extend_and_hash, Entry, Sha256Hash};
+use log::{create_entry_mut, Entry, Sha256Hash};
 use event::{get_signature, verify_event, Event, Signature};
 use serde::Serialize;
 use std::fmt::Debug;
@@ -59,19 +59,10 @@ impl<T: Serialize + Clone + Debug> Logger<T> {
     }
 
     pub fn log_event(&mut self, event: Event<T>) -> Result<(), (Entry<T>, ExitReason)> {
-        if let Some(sig) = get_signature(&event) {
+        let entry = create_entry_mut(&mut self.last_id, &mut self.num_hashes, event);
-            self.last_id = extend_and_hash(&self.last_id, &sig);
-            self.num_hashes += 1;
-        }
-        let entry = Entry {
-            id: self.last_id,
-            num_hashes: self.num_hashes,
-            event,
-        };
         if let Err(_) = self.sender.send(entry.clone()) {
             return Err((entry, ExitReason::SendDisconnected));
         }
-        self.num_hashes = 0;
         Ok(())
     }