zei 0.0.10

#[macro_use] extern crate criterion;
extern crate zei;
extern crate bacteria;
extern crate mohan;

use criterion::Criterion;

mod zei_benches {
    use super::*;
    use zei::{
        proofs::{
            bulletproofs::{PedersenGens},
        },
        core::{
            AssetId,
            OpenAssetOut,
            AssetOut,
            XProofs
        },
        Lockbox
    };
    use mohan::{
        mohan_rand,
        MukaTree,
        dalek::{
            scalar::Scalar
        },
        hash::H256
    };
    use bacteria::Transcript;
    use std::iter::FromIterator;

    // Helper functions to make the tests easier to read
    fn satoshi(q: u64) -> OpenAssetOut {
        let mut transcript = Transcript::new(b"satoshi_land");

        //randomize transcript
        let mut rng = transcript
            .build_rng()
            .finalize(&mut mohan_rand());

        //k , H(kPK || 0), H(kPK || 1)
        let blind_share = Scalar::random(&mut rng);
        let blind_share_value: H256 = MukaTree::from_iter(vec![H256::from(blind_share.to_bytes()), H256::zero()]).root();
        let blind_share_asset: H256 = MukaTree::from_iter(vec![H256::from(blind_share.to_bytes()), H256::from_vec(&vec![1])]).root();

        let flav_id = AssetId::from_inner(H256::from_vec(b"satoshi"));
        let pc_gens = PedersenGens::default();

        return OpenAssetOut {
            blinded: AssetOut {
                flavor: pc_gens.commit(flav_id.into_scalar(), blind_share_asset.into_scalar()).compress(),
                value: pc_gens.commit(q.into(), blind_share_value.into_scalar()).compress(),
                vessel: Lockbox::default()
            },
            value: q,
            value_blind: blind_share_value.into_scalar(),
            flavor_id: flav_id,
            flavor_blind: blind_share_asset.into_scalar(),
        };
    }

    fn proof_verify(c: &mut Criterion) {
        c.bench_function("Zei prooving", move |b| {
            b.iter(| | {
                let sat = satoshi(1);
                let tsat = satoshi(2);
                let ghost_sat = satoshi(1);
                let p = XProofs::proove(&vec![tsat.clone()], &vec![sat.clone(), ghost_sat.clone()]).unwrap();

                p.verify(&vec![tsat.blinded], &vec![sat.blinded, ghost_sat.blinded])
            })
        });
    }

    fn proof_verify2(c: &mut Criterion) {
        c.bench_function("Zei prooving", move |b| {
            b.iter(| | {
                let mut inputs = Vec::new();
                let mut outputs = Vec::new();

                for i in 0..12 {
                    inputs.push(satoshi(1));
                }

                for i in 0..4 {
                    outputs.push(satoshi(3));
                }

                let p = XProofs::proove(&inputs, &outputs).unwrap();

                let in_blinds = inputs.into_iter().map(|i| i.blinded).collect::<Vec<AssetOut>>();
                let out_blinds = outputs.into_iter().map(|i| i.blinded).collect::<Vec<AssetOut>>();

                p.verify(&in_blinds, &out_blinds)
            })
        });
    }


    criterion_group!{
        name = zei_benches;
        config = Criterion::default();
        targets =
            proof_verify2,
    }
}

criterion_main!(
    zei_benches::zei_benches,
);