Generate genesis log for the demo

This log contains a bunch of transactions that generate new
accounts, so that transactions to and from them can be processed
in parallel.

src/bin/genesis-demo.rs

@@ -1,21 +1,23 @@
 extern crate isatty;
+extern crate rayon;
+extern crate ring;
 extern crate serde_json;
 extern crate solana;
+extern crate untrusted;
 
 use isatty::stdin_isatty;
-use solana::entry::create_entry;
+use solana::entry::{create_entry, next_tick};
 use solana::event::Event;
-use solana::hash::Hash;
-use solana::mint::Mint;
-use solana::signature::{KeyPair, KeyPairUtil, PublicKey};
+use solana::accountant::MAX_ENTRY_IDS;
+use solana::mint::MintDemo;
+use solana::signature::{KeyPair, KeyPairUtil};
 use solana::transaction::Transaction;
 use std::io::{stdin, Read};
 use std::process::exit;
+use rayon::prelude::*;
+use untrusted::Input;
 
-fn transfer(from: &KeyPair, (to, tokens): (PublicKey, i64), last_id: Hash) -> Event {
-    Event::Transaction(Transaction::new(from, to, tokens, last_id))
-}
-
+// Generate a ledger with lots and lots of accounts.
 fn main() {
     if stdin_isatty() {
         eprintln!("nothing found on stdin, expected a json file");
@@ -29,20 +31,39 @@ fn main() {
         exit(1);
     }
 
-    let mint: Mint = serde_json::from_str(&buffer).unwrap_or_else(|e| {
+    let demo: MintDemo = serde_json::from_reader(stdin()).unwrap_or_else(|e| {
         eprintln!("failed to parse json: {}", e);
         exit(1);
     });
-    let mut entries = mint.create_entries();
 
-    let from = mint.keypair();
-    let seed = mint.seed();
-    let alice = (KeyPair::new().pubkey(), 200);
-    let bob = (KeyPair::new().pubkey(), 100);
-    let events = vec![transfer(&from, alice, seed), transfer(&from, bob, seed)];
-    entries.push(create_entry(&seed, 0, events));
+    let num_accounts = demo.users.len();
+    let last_id = demo.mint.last_id();
+    let mint_keypair = demo.mint.keypair();
 
-    for entry in entries {
+    eprintln!("Signing {} transactions...", num_accounts);
+    let events: Vec<_> = demo.users
+        .into_par_iter()
+        .map(|(pkcs8, tokens)| {
+            let rando = KeyPair::from_pkcs8(Input::from(&pkcs8)).unwrap();
+            let tr = Transaction::new(&mint_keypair, rando.pubkey(), tokens, last_id);
+            Event::Transaction(tr)
+        })
+        .collect();
+
+    for entry in demo.mint.create_entries() {
+        println!("{}", serde_json::to_string(&entry).unwrap());
+    }
+
+    eprintln!("Logging the creation of {} accounts...", num_accounts);
+    let entry = create_entry(&last_id, 0, events);
+    println!("{}", serde_json::to_string(&entry).unwrap());
+
+    eprintln!("Creating {} empty entries...", MAX_ENTRY_IDS);
+    // Offer client lots of entry IDs to use for each transaction's last_id.
+    let mut last_id = last_id;
+    for _ in 0..MAX_ENTRY_IDS {
+        let entry = next_tick(&last_id, 1);
+        last_id = entry.id;
         let serialized = serde_json::to_string(&entry).unwrap_or_else(|e| {
             eprintln!("failed to serialize: {}", e);
             exit(1);