solana 0.7.0-alpha

extern crate atty;
extern crate rayon;
extern crate serde_json;
extern crate solana;

use atty::{is, Stream};
use rayon::prelude::*;
use solana::bank::MAX_ENTRY_IDS;
use solana::entry::next_entry;
use solana::ledger::next_entries;
use solana::mint::MintDemo;
use solana::signature::{GenKeys, KeyPairUtil};
use solana::transaction::Transaction;
use std::io::{stdin, Read};
use std::process::exit;

// Generate a ledger with lots and lots of accounts.
fn main() {
    if is(Stream::Stdin) {
        eprintln!("nothing found on stdin, expected a json file");
        exit(1);
    }

    let mut buffer = String::new();
    let num_bytes = stdin().read_to_string(&mut buffer).unwrap();
    if num_bytes == 0 {
        eprintln!("empty file on stdin, expected a json file");
        exit(1);
    }

    let demo: MintDemo = serde_json::from_str(&buffer).unwrap_or_else(|e| {
        eprintln!("failed to parse json: {}", e);
        exit(1);
    });

    let mut seed = [0u8; 32];
    seed.copy_from_slice(&demo.mint.keypair().public_key_bytes()[..32]);
    let rnd = GenKeys::new(seed);
    let num_accounts = demo.num_accounts;
    let tokens_per_user = 500;

    let keypairs = rnd.gen_n_keypairs(num_accounts);

    let mint_keypair = demo.mint.keypair();
    let last_id = demo.mint.last_id();

    for entry in demo.mint.create_entries() {
        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;
    let mut last_ids = vec![];
    for _ in 0..MAX_ENTRY_IDS {
        let entry = next_entry(&last_id, 1, vec![]);
        last_id = entry.id;
        last_ids.push(last_id);
        let serialized = serde_json::to_string(&entry).unwrap_or_else(|e| {
            eprintln!("failed to serialize: {}", e);
            exit(1);
        });
        println!("{}", serialized);
    }

    eprintln!("Creating {} transactions...", num_accounts);
    let transactions: Vec<_> = keypairs
        .into_par_iter()
        .enumerate()
        .map(|(i, rando)| {
            let last_id = last_ids[i % MAX_ENTRY_IDS];
            Transaction::new(&mint_keypair, rando.pubkey(), tokens_per_user, last_id)
        })
        .collect();

    eprintln!("Logging the creation of {} accounts...", num_accounts);
    let entries = next_entries(&last_id, 0, transactions);
    for entry in entries {
        println!("{}", serde_json::to_string(&entry).unwrap());
    }
}