Start genesis with a Tick, so that its hash can be used to bootstrap verification

src/bin/genesis-block.rs

@@ -6,7 +6,7 @@ extern crate serde_json;
 extern crate silk;
 
 use silk::genesis::Genesis;
-use silk::log::verify_slice_u64;
+use silk::log::{hash, verify_slice_u64};
 use silk::logger::Logger;
 use std::sync::mpsc::sync_channel;
 use std::io::stdin;
@@ -16,14 +16,14 @@ fn main() {
 
     let (_sender, event_receiver) = sync_channel(100);
     let (entry_sender, receiver) = sync_channel(100);
-    let mut logger = Logger::new(event_receiver, entry_sender, gen.seed);
+    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, &gen.seed);
+    verify_slice_u64(&entries, &entries[0].end_hash);
     println!("[");
     let len = entries.len();
     for (i, x) in entries.iter().enumerate() {

src/genesis.rs

@@ -1,8 +1,7 @@
 //! A library for generating the chain's genesis block.
 
 use event::{generate_keypair, get_pubkey, sign_claim_data, sign_transaction_data, Event, PublicKey};
-use log::Sha256Hash;
-use ring::rand::{SecureRandom, SystemRandom};
+use ring::rand::SystemRandom;
 use ring::signature::Ed25519KeyPair;
 use untrusted::Input;
 
@@ -38,7 +37,6 @@ impl Creator {
 
 #[derive(Serialize, Deserialize, Debug)]
 pub struct Genesis {
-    pub seed: Sha256Hash,
     pub pkcs8: Vec<u8>,
     pub tokens: u64,
     pub creators: Vec<Creator>,
@@ -47,12 +45,8 @@ pub struct Genesis {
 impl Genesis {
     pub fn new(tokens: u64, creators: Vec<Creator>) -> Self {
         let rnd = SystemRandom::new();
-        let mut seed_arr = [0; 32];
-        rnd.fill(&mut seed_arr).unwrap();
-        let seed = *Sha256Hash::from_slice(&seed_arr);
         let pkcs8 = Ed25519KeyPair::generate_pkcs8(&rnd).unwrap().to_vec();
         Genesis {
-            seed,
             pkcs8,
             tokens,
             creators,
@@ -62,8 +56,9 @@ impl Genesis {
     pub fn create_events(&self) -> Vec<Event<u64>> {
         let org_keypair = Ed25519KeyPair::from_pkcs8(Input::from(&self.pkcs8)).unwrap();
         let sig = sign_claim_data(&self.tokens, &org_keypair);
-        let event0 = Event::new_claim(get_pubkey(&org_keypair), self.tokens, sig);
-        let mut events = vec![event0];
+        let event0 = Event::Tick;
+        let event1 = Event::new_claim(get_pubkey(&org_keypair), self.tokens, sig);
+        let mut events = vec![event0, event1];
 
         for creator in &self.creators {
             let tx = creator.create_transaction(&org_keypair);
@@ -87,12 +82,12 @@ mod tests {
 
     #[test]
     fn test_create_events() {
-        assert_eq!(Genesis::new(100, vec![]).create_events().len(), 1);
+        assert_eq!(Genesis::new(100, vec![]).create_events().len(), 2);
         assert_eq!(
             Genesis::new(100, vec![Creator::new("Satoshi", 42)])
                 .create_events()
                 .len(),
-            2
+            3
         );
     }
 }

src/logger.rs

@@ -135,10 +135,10 @@ mod tests {
         assert!(!verify_event_and_reserve_signature(&mut sigs, &event0));
     }
 
-    fn run_genesis(gen: &Genesis) -> Vec<Entry<u64>> {
+    fn run_genesis(gen: Genesis) -> Vec<Entry<u64>> {
         let (_sender, event_receiver) = sync_channel(100);
         let (entry_sender, receiver) = sync_channel(100);
-        let mut logger = Logger::new(event_receiver, entry_sender, gen.seed);
+        let mut logger = Logger::new(event_receiver, entry_sender, hash(&gen.pkcs8));
         for tx in gen.create_events() {
             logger.log_event(tx).unwrap();
         }
@@ -148,13 +148,13 @@ mod tests {
 
     #[test]
     fn test_genesis_no_creators() {
-        let gen = Genesis::new(100, vec![]);
-        assert!(verify_slice_u64(&run_genesis(&gen), &gen.seed));
+        let entries = run_genesis(Genesis::new(100, vec![]));
+        assert!(verify_slice_u64(&entries, &entries[0].end_hash));
     }
 
     #[test]
     fn test_genesis() {
-        let gen = Genesis::new(100, vec![Creator::new("Satoshi", 42)]);
-        assert!(verify_slice_u64(&run_genesis(&gen), &gen.seed));
+        let entries = run_genesis(Genesis::new(100, vec![Creator::new("Satoshi", 42)]));
+        assert!(verify_slice_u64(&entries, &entries[0].end_hash));
     }
 }