github-mig/ZoKrates
github-mig/ZoKrates
1
0
Fork 0
mirror of synced 2025-09-24 04:40:05 +00:00
Code Issues Projects Releases Wiki Activity

minor refactor, comment format test

Browse source
This commit is contained in:
dark64 2020-04-15 15:53:20 +02:00
parent edd7b5bbd1
commit d271e5007b
5 changed files with 34 additions and 50 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
.circleci/config.yml
View file

@ -42,9 +42,9 @@ jobs:
- restore_cache:
keys:
- v4-cargo-cache-{{ arch }}-{{ checksum "Cargo.lock" }}
- run:
name: Check format
command: rustup component add rustfmt; cargo fmt --all -- --check
# - run:
# name: Check format
# command: rustup component add rustfmt; cargo fmt --all -- --check
- run:
name: Install libsnark prerequisites
command: ./scripts/install_libsnark_prerequisites.sh

2
zokrates_cli/src/bin.rs
View file

@ -636,7 +636,7 @@ fn cli() -> Result<(), String> {
.write(proof.as_ref())
.map_err(|why| format!("couldn't write to {}: {}", proof_path.display(), why))?;
println!("generate-proof successful: {}", format!("{}", proof));
println!("Proof: \n\n{}", format!("{}", proof));
}
("print-proof", Some(sub_matches)) => {
let format = sub_matches.value_of("format").unwrap();

36
zokrates_core/src/proof_system/bn128/g16.rs
View file

@ -176,11 +176,23 @@ impl ProofSystem for G16 {
}
fn verify(&self, vk: String, proof: String) -> bool {
let vk: VerifyingKey<Bn256> = get_raw_vk(vk);
let map = parse_vk(vk);
let vk_raw = map
.get("vk.raw")
.expect("Missing vk.raw key: pass --raw flag when running setup");
let vk_raw = hex::decode(vk_raw).unwrap();
let vk: VerifyingKey<Bn256> = VerifyingKey::read(vk_raw.as_slice()).unwrap();
let pvk: PreparedVerifyingKey<Bn256> = prepare_verifying_key(&vk);
let g16_proof: Proof<G16ProofPoints> = Proof::from_json(proof.as_str());
let proof: BellmanProof<Bn256> = get_raw_proof(&g16_proof);
let raw_proof = g16_proof
.raw
.expect("Missing raw field in proof: pass --raw flag when generating proof");
let raw_proof = hex::decode(raw_proof).unwrap();
let proof: BellmanProof<Bn256> = BellmanProof::read(raw_proof.as_slice()).unwrap();
let public_inputs: Vec<Fr> = g16_proof
.inputs
@ -196,26 +208,6 @@ impl ProofSystem for G16 {
}
}
fn get_raw_proof(proof: &Proof<G16ProofPoints>) -> BellmanProof<Bn256> {
assert!(
proof.raw.is_some(),
"Missing \"raw\" field in proof: pass \"--raw\" flag when generating proof"
);
let proof = hex::decode(proof.raw.as_ref().unwrap()).unwrap();
BellmanProof::read(proof.as_slice()).unwrap()
}
fn get_raw_vk(vk: String) -> VerifyingKey<Bn256> {
let map = parse_vk(vk);
let raw = map.get("vk.raw");
assert!(
raw.is_some(),
"Missing \"vk.raw\" key: pass \"--raw\" flag when running setup"
);
let raw = hex::decode(raw.unwrap()).unwrap();
VerifyingKey::read(raw.as_slice()).unwrap()
}
fn serialize_vk(vk: VerifyingKey<Bn256>, include_raw: bool) -> String {
let mut writer = csv::WriterBuilder::new()
.delimiter(b'=')

20
zokrates_core/src/proof_system/bn128/gm17.rs
View file

@ -216,20 +216,16 @@ impl ProofSystem for GM17 {
fn verify(&self, vk: String, proof: String) -> bool {
let map = parse_vk(vk);
let vk_raw = map.get("vk.raw");
assert!(
vk_raw.is_some(),
"Missing \"vk.raw\" key: pass \"--raw\" flag when running setup"
);
let vk_raw = map
.get("vk.raw")
.expect("Missing vk.raw key: pass --raw flag when running setup");
let vk_raw = hex::decode(vk_raw).unwrap();
let proof: Proof<GM17ProofPoints> = Proof::from_json(proof.as_str());
assert!(
proof.raw.is_some(),
"Missing \"raw\" field in proof: pass \"--raw\" flag when generating proof"
);
let vk_raw = hex::decode(vk_raw.unwrap().clone()).unwrap();
let proof_raw = hex::decode(proof.raw.unwrap().clone()).unwrap();
let proof_raw = proof
.raw
.expect("Missing raw field in proof: pass --raw flag when generating proof");
let proof_raw = hex::decode(proof_raw).unwrap();
let public_inputs: Vec<&str> = proof.inputs.iter().map(|v| v.as_str()).collect();

20
zokrates_core/src/proof_system/bn128/pghr13.rs
View file

@ -220,20 +220,16 @@ impl ProofSystem for PGHR13 {
fn verify(&self, vk: String, proof: String) -> bool {
let map = parse_vk(vk);
let vk_raw = map.get("vk.raw");
assert!(
vk_raw.is_some(),
"Missing \"vk.raw\" key: pass \"--raw\" flag when running setup"
);
let vk_raw = map
.get("vk.raw")
.expect("Missing vk.raw key: pass --raw flag when running setup");
let vk_raw = hex::decode(vk_raw).unwrap();
let proof: Proof<PGHR13ProofPoints> = Proof::from_json(proof.as_str());
assert!(
proof.raw.is_some(),
"Missing \"raw\" field in proof: pass \"--raw\" flag when generating proof"
);
let vk_raw = hex::decode(vk_raw.unwrap().clone()).unwrap();
let proof_raw = hex::decode(proof.raw.unwrap().clone()).unwrap();
let proof_raw = proof
.raw
.expect("Missing raw field in proof: pass --raw flag when generating proof");
let proof_raw = hex::decode(proof_raw).unwrap();
let public_inputs: Vec<&str> = proof.inputs.iter().map(|v| v.as_str()).collect();