663 lines
23 KiB
Rust
663 lines
23 KiB
Rust
use serde::{Deserialize, Serialize};
|
|
use serde_json::to_string_pretty;
|
|
use std::convert::TryFrom;
|
|
use std::io::Cursor;
|
|
use std::path::PathBuf;
|
|
use typed_arena::Arena;
|
|
use wasm_bindgen::prelude::*;
|
|
use zokrates_abi::{parse_strict, Decode, Encode, Inputs};
|
|
use zokrates_ark::Ark;
|
|
use zokrates_ast::ir;
|
|
use zokrates_ast::ir::ProgEnum;
|
|
use zokrates_ast::typed::abi::Abi;
|
|
use zokrates_ast::typed::types::{ConcreteSignature, ConcreteType, GTupleType};
|
|
use zokrates_circom::{write_r1cs, write_witness};
|
|
use zokrates_common::helpers::{CurveParameter, SchemeParameter};
|
|
use zokrates_common::Resolver;
|
|
use zokrates_core::compile::{
|
|
compile as core_compile, CompilationArtifacts, CompileConfig, CompileError,
|
|
};
|
|
use zokrates_core::imports::Error;
|
|
use zokrates_field::{Bls12_377Field, Bls12_381Field, Bn128Field, Bw6_761Field, Field};
|
|
use zokrates_proof_systems::groth16::G16;
|
|
use zokrates_proof_systems::{
|
|
Backend, Marlin, NonUniversalBackend, NonUniversalScheme, Proof, Scheme,
|
|
SolidityCompatibleField, SolidityCompatibleScheme, TaggedKeypair, TaggedProof,
|
|
UniversalBackend, UniversalScheme, GM17,
|
|
};
|
|
|
|
#[wasm_bindgen]
|
|
pub struct CompilationResult {
|
|
program: Vec<u8>,
|
|
abi: Abi,
|
|
snarkjs_program: Option<Vec<u8>>,
|
|
}
|
|
|
|
#[wasm_bindgen]
|
|
impl CompilationResult {
|
|
pub fn program(&self) -> js_sys::Uint8Array {
|
|
let arr = js_sys::Uint8Array::new_with_length(self.program.len() as u32);
|
|
arr.copy_from(&self.program);
|
|
arr
|
|
}
|
|
pub fn abi(&self) -> JsValue {
|
|
JsValue::from_serde(&self.abi).unwrap()
|
|
}
|
|
|
|
pub fn snarkjs_program(&self) -> Option<js_sys::Uint8Array> {
|
|
self.snarkjs_program.as_ref().map(|p| {
|
|
let arr = js_sys::Uint8Array::new_with_length(p.len() as u32);
|
|
arr.copy_from(p);
|
|
arr
|
|
})
|
|
}
|
|
}
|
|
|
|
#[derive(Serialize, Deserialize)]
|
|
pub struct ResolverResult {
|
|
source: String,
|
|
location: String,
|
|
}
|
|
|
|
#[wasm_bindgen]
|
|
pub struct ComputationResult {
|
|
witness: String,
|
|
output: String,
|
|
snarkjs_witness: Option<Vec<u8>>,
|
|
}
|
|
|
|
#[wasm_bindgen]
|
|
impl ComputationResult {
|
|
pub fn witness(&self) -> JsValue {
|
|
JsValue::from_str(&self.witness)
|
|
}
|
|
pub fn output(&self) -> JsValue {
|
|
JsValue::from_str(&self.output)
|
|
}
|
|
pub fn snarkjs_witness(&self) -> Option<js_sys::Uint8Array> {
|
|
self.snarkjs_witness.as_ref().map(|w| {
|
|
let arr = js_sys::Uint8Array::new_with_length(w.len() as u32);
|
|
arr.copy_from(w);
|
|
arr
|
|
})
|
|
}
|
|
}
|
|
|
|
pub struct JsResolver<'a> {
|
|
callback: &'a js_sys::Function,
|
|
}
|
|
|
|
impl<'a> JsResolver<'a> {
|
|
pub fn new(callback: &'a js_sys::Function) -> Self {
|
|
JsResolver { callback }
|
|
}
|
|
}
|
|
|
|
impl<'a> Resolver<Error> for JsResolver<'a> {
|
|
fn resolve(
|
|
&self,
|
|
current_location: PathBuf,
|
|
import_location: PathBuf,
|
|
) -> Result<(String, PathBuf), Error> {
|
|
let value = self
|
|
.callback
|
|
.call2(
|
|
&JsValue::UNDEFINED,
|
|
¤t_location.to_str().unwrap().into(),
|
|
&import_location.to_str().unwrap().into(),
|
|
)
|
|
.map_err(|_| {
|
|
Error::new(format!(
|
|
"Could not resolve `{}`: error thrown in resolve callback",
|
|
import_location.display()
|
|
))
|
|
})?;
|
|
|
|
if value.is_null() || value.is_undefined() {
|
|
Err(Error::new(format!(
|
|
"Could not resolve `{}`",
|
|
import_location.display()
|
|
)))
|
|
} else {
|
|
let result: ResolverResult = value.into_serde().unwrap();
|
|
Ok((result.source, PathBuf::from(result.location)))
|
|
}
|
|
}
|
|
}
|
|
|
|
mod internal {
|
|
use super::*;
|
|
|
|
pub fn compile<T: Field>(
|
|
source: JsValue,
|
|
location: JsValue,
|
|
resolve_callback: &js_sys::Function,
|
|
config: JsValue,
|
|
) -> Result<CompilationResult, JsValue> {
|
|
let resolver = JsResolver::new(resolve_callback);
|
|
let config: serde_json::Value = config.into_serde().unwrap();
|
|
let with_snarkjs_program = config
|
|
.get("snarkjs")
|
|
.map(|v| *v == serde_json::Value::Bool(true))
|
|
.unwrap_or(false);
|
|
let config: CompileConfig = serde_json::from_value(config).unwrap_or_default();
|
|
|
|
let fmt_error = |e: &CompileError| format!("{}:{}", e.file().display(), e.value());
|
|
|
|
let arena = Arena::new();
|
|
let artifacts: CompilationArtifacts<T, _> = core_compile(
|
|
source.as_string().unwrap(),
|
|
PathBuf::from(location.as_string().unwrap()),
|
|
Some(&resolver),
|
|
config,
|
|
&arena,
|
|
)
|
|
.map_err(|ce| {
|
|
JsValue::from_str(
|
|
&ce.0
|
|
.iter()
|
|
.map(|e| fmt_error(e))
|
|
.collect::<Vec<_>>()
|
|
.join("\n"),
|
|
)
|
|
})?;
|
|
|
|
let abi = artifacts.abi().clone();
|
|
|
|
let program = artifacts.prog().collect();
|
|
let snarkjs_program = with_snarkjs_program.then(|| {
|
|
let mut buffer = Cursor::new(vec![]);
|
|
write_r1cs(&mut buffer, program.clone()).unwrap();
|
|
buffer.into_inner()
|
|
});
|
|
let mut buffer = Cursor::new(vec![]);
|
|
let _ = program.serialize(&mut buffer);
|
|
|
|
Ok(CompilationResult {
|
|
abi,
|
|
program: buffer.into_inner(),
|
|
snarkjs_program,
|
|
})
|
|
}
|
|
|
|
pub fn compute<T: Field>(
|
|
program: ir::Prog<T>,
|
|
abi: JsValue,
|
|
args: JsValue,
|
|
config: JsValue,
|
|
) -> Result<ComputationResult, JsValue> {
|
|
let input = args.as_string().unwrap();
|
|
|
|
let config: serde_json::Value = config.into_serde().unwrap();
|
|
let with_snarkjs_witness = config
|
|
.get("snarkjs")
|
|
.map(|v| *v == serde_json::Value::Bool(true))
|
|
.unwrap_or(false);
|
|
|
|
let (inputs, signature) = if abi.is_object() {
|
|
let abi: Abi = abi.into_serde().map_err(|err| {
|
|
JsValue::from_str(&format!("Could not deserialize `abi`: {}", err))
|
|
})?;
|
|
|
|
let signature = abi.signature();
|
|
let inputs = parse_strict(&input, signature.inputs.clone())
|
|
.map(Inputs::Abi)
|
|
.map_err(|err| JsValue::from_str(&err.to_string()))?;
|
|
|
|
(inputs, signature)
|
|
} else {
|
|
let signature = ConcreteSignature::new()
|
|
.inputs(vec![ConcreteType::FieldElement; program.arguments.len()])
|
|
.output(ConcreteType::Tuple(GTupleType::new(
|
|
vec![ConcreteType::FieldElement; program.return_count],
|
|
)));
|
|
|
|
let inputs = parse_strict(&input, signature.inputs.clone())
|
|
.map(Inputs::Abi)
|
|
.map_err(|err| JsValue::from_str(&err.to_string()))?;
|
|
|
|
(inputs, signature)
|
|
};
|
|
|
|
let interpreter = zokrates_interpreter::Interpreter::default();
|
|
|
|
let public_inputs = program.public_inputs();
|
|
|
|
let witness = interpreter
|
|
.execute(program, &inputs.encode())
|
|
.map_err(|err| JsValue::from_str(&format!("Execution failed: {}", err)))?;
|
|
|
|
let return_values: serde_json::Value =
|
|
zokrates_abi::Value::decode(witness.return_values(), *signature.output)
|
|
.into_serde_json();
|
|
|
|
let snarkjs_witness = with_snarkjs_witness.then(|| {
|
|
let mut buffer = Cursor::new(vec![]);
|
|
write_witness(&mut buffer, witness.clone(), public_inputs).unwrap();
|
|
buffer.into_inner()
|
|
});
|
|
|
|
Ok(ComputationResult {
|
|
witness: format!("{}", witness),
|
|
output: to_string_pretty(&return_values).unwrap(),
|
|
snarkjs_witness,
|
|
})
|
|
}
|
|
|
|
pub fn setup_non_universal<
|
|
T: Field,
|
|
S: NonUniversalScheme<T> + Serialize,
|
|
B: NonUniversalBackend<T, S>,
|
|
>(
|
|
program: ir::Prog<T>,
|
|
) -> JsValue {
|
|
let keypair = B::setup(program);
|
|
let tagged_keypair = TaggedKeypair::<T, S>::new(keypair);
|
|
JsValue::from_serde(&tagged_keypair).unwrap()
|
|
}
|
|
|
|
pub fn setup_universal<
|
|
T: Field,
|
|
I: IntoIterator<Item = ir::Statement<T>>,
|
|
S: UniversalScheme<T> + Serialize,
|
|
B: UniversalBackend<T, S>,
|
|
>(
|
|
srs: &[u8],
|
|
program: ir::ProgIterator<T, I>,
|
|
) -> Result<JsValue, JsValue> {
|
|
let keypair = B::setup(srs.to_vec(), program).map_err(|e| JsValue::from_str(&e))?;
|
|
Ok(JsValue::from_serde(&TaggedKeypair::<T, S>::new(keypair)).unwrap())
|
|
}
|
|
|
|
pub fn universal_setup_of_size<T: Field, S: UniversalScheme<T>, B: UniversalBackend<T, S>>(
|
|
size: u32,
|
|
) -> Vec<u8> {
|
|
B::universal_setup(size)
|
|
}
|
|
|
|
pub fn generate_proof<T: Field, S: Scheme<T>, B: Backend<T, S>>(
|
|
prog: ir::Prog<T>,
|
|
witness: JsValue,
|
|
pk: &[u8],
|
|
) -> Result<JsValue, JsValue> {
|
|
let str_witness = witness.as_string().unwrap();
|
|
let ir_witness: ir::Witness<T> = ir::Witness::read(str_witness.as_bytes())
|
|
.map_err(|err| JsValue::from_str(&format!("Could not read witness: {}", err)))?;
|
|
|
|
let proof = B::generate_proof(prog, ir_witness, pk.to_vec());
|
|
Ok(JsValue::from_serde(&TaggedProof::<T, S>::new(proof.proof, proof.inputs)).unwrap())
|
|
}
|
|
|
|
pub fn verify<T: Field, S: Scheme<T>, B: Backend<T, S>>(
|
|
vk: serde_json::Value,
|
|
proof: serde_json::Value,
|
|
) -> Result<JsValue, JsValue> {
|
|
let vk: S::VerificationKey =
|
|
serde_json::from_value(vk).map_err(|e| JsValue::from_str(&e.to_string()))?;
|
|
let proof: Proof<T, S> =
|
|
serde_json::from_value(proof).map_err(|e| JsValue::from_str(&e.to_string()))?;
|
|
|
|
let result = B::verify(vk, proof);
|
|
Ok(JsValue::from_serde(&result).unwrap())
|
|
}
|
|
|
|
pub fn format_proof<T: SolidityCompatibleField, S: SolidityCompatibleScheme<T>>(
|
|
proof: serde_json::Value,
|
|
) -> Result<JsValue, JsValue> {
|
|
use serde_json::json;
|
|
|
|
let proof: Proof<T, S> =
|
|
serde_json::from_value(proof).map_err(|err| JsValue::from_str(&format!("{}", err)))?;
|
|
|
|
let res = S::Proof::from(proof.proof);
|
|
|
|
let proof_object = serde_json::to_value(&res).unwrap();
|
|
let proof_vec = proof_object
|
|
.as_object()
|
|
.unwrap()
|
|
.iter()
|
|
.map(|(_, value)| value)
|
|
.collect::<Vec<_>>();
|
|
|
|
let result = if !proof.inputs.is_empty() {
|
|
json!([proof_vec, proof.inputs])
|
|
} else {
|
|
json!([proof_vec])
|
|
};
|
|
|
|
Ok(JsValue::from_serde(&result).unwrap())
|
|
}
|
|
|
|
pub fn export_solidity_verifier<T: SolidityCompatibleField, S: SolidityCompatibleScheme<T>>(
|
|
vk: serde_json::Value,
|
|
) -> Result<JsValue, JsValue> {
|
|
let vk: S::VerificationKey =
|
|
serde_json::from_value(vk).map_err(|err| JsValue::from_str(&format!("{}", err)))?;
|
|
|
|
Ok(JsValue::from_str(&S::export_solidity_verifier(vk)))
|
|
}
|
|
}
|
|
|
|
#[wasm_bindgen]
|
|
pub fn compile(
|
|
source: JsValue,
|
|
location: JsValue,
|
|
resolve_callback: &js_sys::Function,
|
|
config: JsValue,
|
|
curve: JsValue,
|
|
) -> Result<CompilationResult, JsValue> {
|
|
let curve = CurveParameter::try_from(curve.as_string().unwrap().as_str())
|
|
.map_err(|e| JsValue::from_str(&e))?;
|
|
|
|
match curve {
|
|
CurveParameter::Bn128 => {
|
|
internal::compile::<Bn128Field>(source, location, resolve_callback, config)
|
|
}
|
|
CurveParameter::Bls12_381 => {
|
|
internal::compile::<Bls12_381Field>(source, location, resolve_callback, config)
|
|
}
|
|
CurveParameter::Bls12_377 => {
|
|
internal::compile::<Bls12_377Field>(source, location, resolve_callback, config)
|
|
}
|
|
CurveParameter::Bw6_761 => {
|
|
internal::compile::<Bw6_761Field>(source, location, resolve_callback, config)
|
|
}
|
|
}
|
|
}
|
|
|
|
#[wasm_bindgen]
|
|
pub fn compute_witness(
|
|
program: &[u8],
|
|
abi: JsValue,
|
|
args: JsValue,
|
|
config: JsValue,
|
|
) -> Result<ComputationResult, JsValue> {
|
|
let prog = ir::ProgEnum::deserialize(program)
|
|
.map_err(|err| JsValue::from_str(&err))?
|
|
.collect();
|
|
match prog {
|
|
ProgEnum::Bn128Program(p) => internal::compute::<_>(p, abi, args, config),
|
|
ProgEnum::Bls12_381Program(p) => internal::compute::<_>(p, abi, args, config),
|
|
ProgEnum::Bls12_377Program(p) => internal::compute::<_>(p, abi, args, config),
|
|
ProgEnum::Bw6_761Program(p) => internal::compute::<_>(p, abi, args, config),
|
|
}
|
|
}
|
|
|
|
#[wasm_bindgen]
|
|
pub fn export_solidity_verifier(vk: JsValue) -> Result<JsValue, JsValue> {
|
|
let vk: serde_json::Value = vk
|
|
.into_serde()
|
|
.map_err(|e| JsValue::from_str(&e.to_string()))?;
|
|
let curve = CurveParameter::try_from(
|
|
vk["curve"]
|
|
.as_str()
|
|
.ok_or_else(|| JsValue::from_str("Invalid verification key: missing field `curve`"))?,
|
|
)
|
|
.map_err(|e| JsValue::from_str(&e))?;
|
|
|
|
let scheme =
|
|
SchemeParameter::try_from(vk["scheme"].as_str().ok_or_else(|| {
|
|
JsValue::from_str("Invalid verification key: missing field `scheme`")
|
|
})?)
|
|
.map_err(|e| JsValue::from_str(&e))?;
|
|
|
|
match (curve, scheme) {
|
|
(CurveParameter::Bn128, SchemeParameter::G16) => {
|
|
internal::export_solidity_verifier::<Bn128Field, G16>(vk)
|
|
}
|
|
(CurveParameter::Bn128, SchemeParameter::GM17) => {
|
|
internal::export_solidity_verifier::<Bn128Field, GM17>(vk)
|
|
}
|
|
(CurveParameter::Bn128, SchemeParameter::MARLIN) => {
|
|
internal::export_solidity_verifier::<Bn128Field, Marlin>(vk)
|
|
}
|
|
_ => Err(JsValue::from_str("Not supported")),
|
|
}
|
|
}
|
|
|
|
#[wasm_bindgen]
|
|
pub fn setup(program: &[u8], options: JsValue) -> Result<JsValue, JsValue> {
|
|
let options: serde_json::Value = options.into_serde().unwrap();
|
|
|
|
let scheme = SchemeParameter::try_from(
|
|
options["scheme"]
|
|
.as_str()
|
|
.ok_or_else(|| JsValue::from_str("Invalid options: missing field `scheme`"))?,
|
|
)
|
|
.map_err(|e| JsValue::from_str(&e))?;
|
|
|
|
let prog = ir::ProgEnum::deserialize(program)
|
|
.map_err(|err| JsValue::from_str(&err))?
|
|
.collect();
|
|
|
|
match scheme {
|
|
SchemeParameter::G16 => match prog {
|
|
ProgEnum::Bn128Program(p) => Ok(internal::setup_non_universal::<_, G16, Ark>(p)),
|
|
ProgEnum::Bls12_381Program(p) => Ok(internal::setup_non_universal::<_, G16, Ark>(p)),
|
|
ProgEnum::Bls12_377Program(p) => Ok(internal::setup_non_universal::<_, G16, Ark>(p)),
|
|
ProgEnum::Bw6_761Program(p) => Ok(internal::setup_non_universal::<_, G16, Ark>(p)),
|
|
},
|
|
SchemeParameter::GM17 => match prog {
|
|
ProgEnum::Bn128Program(p) => Ok(internal::setup_non_universal::<_, GM17, Ark>(p)),
|
|
ProgEnum::Bls12_381Program(p) => Ok(internal::setup_non_universal::<_, GM17, Ark>(p)),
|
|
ProgEnum::Bls12_377Program(p) => Ok(internal::setup_non_universal::<_, GM17, Ark>(p)),
|
|
ProgEnum::Bw6_761Program(p) => Ok(internal::setup_non_universal::<_, GM17, Ark>(p)),
|
|
},
|
|
_ => Err(JsValue::from_str("Unsupported scheme")),
|
|
}
|
|
}
|
|
|
|
#[wasm_bindgen]
|
|
pub fn setup_with_srs(srs: &[u8], program: &[u8], options: JsValue) -> Result<JsValue, JsValue> {
|
|
let options: serde_json::Value = options.into_serde().unwrap();
|
|
|
|
let scheme = SchemeParameter::try_from(
|
|
options["scheme"]
|
|
.as_str()
|
|
.ok_or_else(|| JsValue::from_str("Invalid options: missing field `scheme`"))?,
|
|
)
|
|
.map_err(|e| JsValue::from_str(&e))?;
|
|
|
|
let prog = ir::ProgEnum::deserialize(program)
|
|
.map_err(|err| JsValue::from_str(&err))?
|
|
.collect();
|
|
|
|
match scheme {
|
|
SchemeParameter::MARLIN => match prog {
|
|
ProgEnum::Bn128Program(p) => internal::setup_universal::<_, _, Marlin, Ark>(srs, p),
|
|
ProgEnum::Bls12_381Program(p) => internal::setup_universal::<_, _, Marlin, Ark>(srs, p),
|
|
ProgEnum::Bls12_377Program(p) => internal::setup_universal::<_, _, Marlin, Ark>(srs, p),
|
|
ProgEnum::Bw6_761Program(p) => internal::setup_universal::<_, _, Marlin, Ark>(srs, p),
|
|
},
|
|
_ => Err(JsValue::from_str("Given scheme is not universal")),
|
|
}
|
|
}
|
|
|
|
#[wasm_bindgen]
|
|
pub fn universal_setup(curve: JsValue, size: u32) -> Result<Vec<u8>, JsValue> {
|
|
let curve = CurveParameter::try_from(curve.as_string().unwrap().as_str())
|
|
.map_err(|e| JsValue::from_str(&e))?;
|
|
|
|
match curve {
|
|
CurveParameter::Bn128 => {
|
|
Ok(internal::universal_setup_of_size::<Bn128Field, Marlin, Ark>(size))
|
|
}
|
|
CurveParameter::Bls12_381 => Ok(internal::universal_setup_of_size::<
|
|
Bls12_381Field,
|
|
Marlin,
|
|
Ark,
|
|
>(size)),
|
|
CurveParameter::Bls12_377 => Ok(internal::universal_setup_of_size::<
|
|
Bls12_377Field,
|
|
Marlin,
|
|
Ark,
|
|
>(size)),
|
|
CurveParameter::Bw6_761 => {
|
|
Ok(internal::universal_setup_of_size::<Bw6_761Field, Marlin, Ark>(size))
|
|
}
|
|
}
|
|
}
|
|
|
|
#[wasm_bindgen]
|
|
pub fn generate_proof(
|
|
program: &[u8],
|
|
witness: JsValue,
|
|
pk: &[u8],
|
|
options: JsValue,
|
|
) -> Result<JsValue, JsValue> {
|
|
let options: serde_json::Value = options.into_serde().unwrap();
|
|
|
|
let scheme = SchemeParameter::try_from(
|
|
options["scheme"]
|
|
.as_str()
|
|
.ok_or_else(|| JsValue::from_str("Invalid options: missing field `scheme`"))?,
|
|
)
|
|
.map_err(|e| JsValue::from_str(&e))?;
|
|
|
|
let prog = ir::ProgEnum::deserialize(program)
|
|
.map_err(|err| JsValue::from_str(&err))?
|
|
.collect();
|
|
|
|
match scheme {
|
|
SchemeParameter::G16 => match prog {
|
|
ProgEnum::Bn128Program(p) => internal::generate_proof::<_, G16, Ark>(p, witness, pk),
|
|
ProgEnum::Bls12_381Program(p) => {
|
|
internal::generate_proof::<_, G16, Ark>(p, witness, pk)
|
|
}
|
|
ProgEnum::Bls12_377Program(p) => {
|
|
internal::generate_proof::<_, G16, Ark>(p, witness, pk)
|
|
}
|
|
ProgEnum::Bw6_761Program(p) => internal::generate_proof::<_, G16, Ark>(p, witness, pk),
|
|
},
|
|
SchemeParameter::GM17 => match prog {
|
|
ProgEnum::Bn128Program(p) => internal::generate_proof::<_, GM17, Ark>(p, witness, pk),
|
|
ProgEnum::Bls12_381Program(p) => {
|
|
internal::generate_proof::<_, GM17, Ark>(p, witness, pk)
|
|
}
|
|
ProgEnum::Bls12_377Program(p) => {
|
|
internal::generate_proof::<_, GM17, Ark>(p, witness, pk)
|
|
}
|
|
ProgEnum::Bw6_761Program(p) => internal::generate_proof::<_, GM17, Ark>(p, witness, pk),
|
|
},
|
|
SchemeParameter::MARLIN => match prog {
|
|
ProgEnum::Bn128Program(p) => internal::generate_proof::<_, Marlin, Ark>(p, witness, pk),
|
|
ProgEnum::Bls12_381Program(p) => {
|
|
internal::generate_proof::<_, Marlin, Ark>(p, witness, pk)
|
|
}
|
|
ProgEnum::Bls12_377Program(p) => {
|
|
internal::generate_proof::<_, Marlin, Ark>(p, witness, pk)
|
|
}
|
|
ProgEnum::Bw6_761Program(p) => {
|
|
internal::generate_proof::<_, Marlin, Ark>(p, witness, pk)
|
|
}
|
|
},
|
|
_ => Err(JsValue::from_str("Unsupported scheme")),
|
|
}
|
|
}
|
|
|
|
#[wasm_bindgen]
|
|
pub fn verify(vk: JsValue, proof: JsValue) -> Result<JsValue, JsValue> {
|
|
let vk: serde_json::Value = vk.into_serde().unwrap();
|
|
let proof: serde_json::Value = proof.into_serde().unwrap();
|
|
let vk_curve = CurveParameter::try_from(
|
|
vk["curve"]
|
|
.as_str()
|
|
.ok_or_else(|| JsValue::from_str("Invalid verification key: missing field `curve`"))?,
|
|
)
|
|
.map_err(|e| JsValue::from_str(&e))?;
|
|
|
|
let vk_scheme =
|
|
SchemeParameter::try_from(vk["scheme"].as_str().ok_or_else(|| {
|
|
JsValue::from_str("Invalid verification key: missing field `scheme`")
|
|
})?)
|
|
.map_err(|e| JsValue::from_str(&e))?;
|
|
|
|
let proof_curve = CurveParameter::try_from(
|
|
proof["curve"]
|
|
.as_str()
|
|
.ok_or_else(|| JsValue::from_str("Invalid proof: missing field `curve`"))?,
|
|
)
|
|
.map_err(|e| JsValue::from_str(&e))?;
|
|
|
|
let proof_scheme = SchemeParameter::try_from(
|
|
proof["scheme"]
|
|
.as_str()
|
|
.ok_or_else(|| JsValue::from_str("Invalid proof: missing field `scheme`"))?,
|
|
)
|
|
.map_err(|e| JsValue::from_str(&e))?;
|
|
|
|
if proof_curve != vk_curve {
|
|
return Err(JsValue::from_str(
|
|
"Proof and verification key should have the same curve",
|
|
));
|
|
}
|
|
|
|
if proof_scheme != vk_scheme {
|
|
return Err(JsValue::from_str(
|
|
"Proof and verification key should have the same scheme",
|
|
));
|
|
}
|
|
|
|
let scheme = vk_scheme;
|
|
let curve = vk_curve;
|
|
|
|
match scheme {
|
|
SchemeParameter::G16 => match curve {
|
|
CurveParameter::Bn128 => internal::verify::<Bn128Field, G16, Ark>(vk, proof),
|
|
CurveParameter::Bls12_381 => internal::verify::<Bls12_381Field, G16, Ark>(vk, proof),
|
|
CurveParameter::Bls12_377 => internal::verify::<Bls12_377Field, G16, Ark>(vk, proof),
|
|
CurveParameter::Bw6_761 => internal::verify::<Bw6_761Field, G16, Ark>(vk, proof),
|
|
},
|
|
SchemeParameter::GM17 => match curve {
|
|
CurveParameter::Bn128 => internal::verify::<Bn128Field, GM17, Ark>(vk, proof),
|
|
CurveParameter::Bls12_381 => internal::verify::<Bls12_381Field, GM17, Ark>(vk, proof),
|
|
CurveParameter::Bls12_377 => internal::verify::<Bls12_377Field, GM17, Ark>(vk, proof),
|
|
CurveParameter::Bw6_761 => internal::verify::<Bw6_761Field, GM17, Ark>(vk, proof),
|
|
},
|
|
SchemeParameter::MARLIN => match curve {
|
|
CurveParameter::Bn128 => internal::verify::<Bn128Field, Marlin, Ark>(vk, proof),
|
|
CurveParameter::Bls12_381 => internal::verify::<Bls12_381Field, Marlin, Ark>(vk, proof),
|
|
CurveParameter::Bls12_377 => internal::verify::<Bls12_377Field, Marlin, Ark>(vk, proof),
|
|
CurveParameter::Bw6_761 => internal::verify::<Bw6_761Field, Marlin, Ark>(vk, proof),
|
|
},
|
|
_ => Err(JsValue::from_str("Unsupported scheme")),
|
|
}
|
|
}
|
|
|
|
#[wasm_bindgen]
|
|
pub fn format_proof(proof: JsValue) -> Result<JsValue, JsValue> {
|
|
let proof: serde_json::Value = proof.into_serde().unwrap();
|
|
|
|
let curve = CurveParameter::try_from(
|
|
proof["curve"]
|
|
.as_str()
|
|
.ok_or_else(|| JsValue::from_str("Invalid proof: missing field `curve`"))?,
|
|
)
|
|
.map_err(|e| JsValue::from_str(&e))?;
|
|
|
|
let scheme = SchemeParameter::try_from(
|
|
proof["scheme"]
|
|
.as_str()
|
|
.ok_or_else(|| JsValue::from_str("Invalid proof: missing field `scheme`"))?,
|
|
)
|
|
.map_err(|e| JsValue::from_str(&e))?;
|
|
|
|
match (curve, scheme) {
|
|
(CurveParameter::Bn128, SchemeParameter::G16) => {
|
|
internal::format_proof::<Bn128Field, G16>(proof)
|
|
}
|
|
(CurveParameter::Bn128, SchemeParameter::GM17) => {
|
|
internal::format_proof::<Bn128Field, GM17>(proof)
|
|
}
|
|
(CurveParameter::Bn128, SchemeParameter::MARLIN) => {
|
|
internal::format_proof::<Bn128Field, Marlin>(proof)
|
|
}
|
|
_ => Err(JsValue::from_str("Unsupported options")),
|
|
}
|
|
}
|
|
|
|
#[wasm_bindgen(start)]
|
|
pub fn main_js() -> Result<(), JsValue> {
|
|
std::panic::set_hook(Box::new(console_error_panic_hook::hook));
|
|
Ok(())
|
|
}
|