github-mig/ZoKrates
github-mig/ZoKrates
1
0
Fork 0
mirror of synced 2025-09-23 12:18:44 +00:00
Code Issues Projects Releases Wiki Activity

bump nightly, fix clippy errors

Browse source
This commit is contained in:
schaeff 2022-07-06 15:51:45 +02:00
parent 9e1cb8a07e
commit 8b35413169
26 changed files with 120 additions and 113 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
rust-toolchain.toml
View file

@ -1,2 +1,2 @@
[toolchain] [toolchain]
channel = "nightly-2022-03-10" channel = "nightly-2022-07-01"

2
zokrates_abi/src/lib.rs
View file

@ -19,7 +19,7 @@ use zokrates_ast::typed::types::{ConcreteType, UBitwidth};
use zokrates_field::Field; use zokrates_field::Field;
#[derive(Debug, PartialEq)] #[derive(Debug, PartialEq, Eq)]
pub enum Error { pub enum Error {
Json(String), Json(String),
Conversion(String), Conversion(String),

4
zokrates_ast/src/common/format_string.rs
View file

@ -13,7 +13,7 @@ impl fmt::Display for FormatString {
} }
} }
impl<'a> FormatString { impl FormatString {
pub fn len(&self) -> usize { pub fn len(&self) -> usize {
self.parts.len() - 1 self.parts.len() - 1
} }
@ -23,7 +23,7 @@ impl<'a> FormatString {
} }
} }
impl<'a> From<&str> for FormatString { impl From<&str> for FormatString {
fn from(s: &str) -> Self { fn from(s: &str) -> Self {
let parts = s.split("{}").map(|p| p.to_string()); let parts = s.split("{}").map(|p| p.to_string());
FormatString { FormatString {

6
zokrates_ast/src/flat/mod.rs
View file

@ -30,7 +30,7 @@ pub type FlatFunction<T> = FlatFunctionIterator<T, Vec<FlatStatement<T>>>;
pub type FlatProgIterator<T, I> = FlatFunctionIterator<T, I>; pub type FlatProgIterator<T, I> = FlatFunctionIterator<T, I>;
#[derive(Clone, PartialEq, Debug)] #[derive(Clone, PartialEq, Eq, Debug)]
pub struct FlatFunctionIterator<T, I: IntoIterator<Item = FlatStatement<T>>> { pub struct FlatFunctionIterator<T, I: IntoIterator<Item = FlatStatement<T>>> {
/// Arguments of the function /// Arguments of the function
pub arguments: Vec<Parameter>, pub arguments: Vec<Parameter>,
@ -80,7 +80,7 @@ impl<T: Field> fmt::Display for FlatFunction<T> {
/// ///
/// * r1cs - R1CS in standard JSON data format /// * r1cs - R1CS in standard JSON data format
#[derive(Clone, PartialEq, Debug)] #[derive(Clone, PartialEq, Eq, Debug)]
pub enum FlatStatement<T> { pub enum FlatStatement<T> {
Condition(FlatExpression<T>, FlatExpression<T>, RuntimeError), Condition(FlatExpression<T>, FlatExpression<T>, RuntimeError),
Definition(Variable, FlatExpression<T>), Definition(Variable, FlatExpression<T>),
@ -290,7 +290,7 @@ impl<T: Field> From<Variable> for FlatExpression<T> {
} }
} }
#[derive(PartialEq, Debug)] #[derive(PartialEq, Eq, Debug)]
pub struct Error { pub struct Error {
message: String, message: String,
} }

2
zokrates_ast/src/ir/mod.rs
View file

@ -98,7 +98,7 @@ impl<T: Field> fmt::Display for Statement<T> {
pub type Prog<T> = ProgIterator<T, Vec<Statement<T>>>; pub type Prog<T> = ProgIterator<T, Vec<Statement<T>>>;
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Default)] #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, Default)]
pub struct ProgIterator<T, I: IntoIterator<Item = Statement<T>>> { pub struct ProgIterator<T, I: IntoIterator<Item = Statement<T>>> {
pub arguments: Vec<Parameter>, pub arguments: Vec<Parameter>,
pub return_count: usize, pub return_count: usize,

2
zokrates_ast/src/ir/serialize.rs
View file

@ -10,7 +10,7 @@ type DynamicError = Box<dyn std::error::Error>;
const ZOKRATES_MAGIC: &[u8; 4] = &[0x5a, 0x4f, 0x4b, 0]; const ZOKRATES_MAGIC: &[u8; 4] = &[0x5a, 0x4f, 0x4b, 0];
const ZOKRATES_VERSION_2: &[u8; 4] = &[0, 0, 0, 2]; const ZOKRATES_VERSION_2: &[u8; 4] = &[0, 0, 0, 2];
#[derive(PartialEq, Debug)] #[derive(PartialEq, Eq, Debug)]
pub enum ProgEnum< pub enum ProgEnum<
Bls12_381I: IntoIterator<Item = Statement<Bls12_381Field>>, Bls12_381I: IntoIterator<Item = Statement<Bls12_381Field>>,
Bn128I: IntoIterator<Item = Statement<Bn128Field>>, Bn128I: IntoIterator<Item = Statement<Bn128Field>>,

2
zokrates_ast/src/ir/witness.rs
View file

@ -5,7 +5,7 @@ use std::io;
use std::io::{Read, Write}; use std::io::{Read, Write};
use zokrates_field::Field; use zokrates_field::Field;
#[derive(Clone, Debug, PartialEq, Default)] #[derive(Clone, Debug, PartialEq, Eq, Default)]
pub struct Witness<T>(pub BTreeMap<Variable, T>); pub struct Witness<T>(pub BTreeMap<Variable, T>);
impl<T: Field> Witness<T> { impl<T: Field> Witness<T> {

2
zokrates_ast/src/typed/integer.rs
View file

@ -749,7 +749,7 @@ impl<'ast, T: Field> TupleExpression<'ast, T> {
TupleExpressionInner::Value(inline_tuple) => inline_tuple TupleExpressionInner::Value(inline_tuple) => inline_tuple
.into_iter() .into_iter()
.zip(target_tuple_ty.elements.iter()) .zip(target_tuple_ty.elements.iter())
.map(|(value, target_ty)| TypedExpression::align_to_type(value, &*target_ty)) .map(|(value, target_ty)| TypedExpression::align_to_type(value, target_ty))
.collect::<Result<Vec<_>, _>>() .collect::<Result<Vec<_>, _>>()
.map(|v| { .map(|v| {
let ty = TupleType::new(v.iter().map(|e| e.get_type()).collect()); let ty = TupleType::new(v.iter().map(|e| e.get_type()).collect());

18
zokrates_ast/src/typed/mod.rs
View file

@ -66,7 +66,7 @@ pub type TypedModules<'ast, T> = BTreeMap<OwnedTypedModuleId, TypedModule<'ast,
pub type TypedFunctionSymbols<'ast, T> = pub type TypedFunctionSymbols<'ast, T> =
BTreeMap<DeclarationFunctionKey<'ast, T>, TypedFunctionSymbol<'ast, T>>; BTreeMap<DeclarationFunctionKey<'ast, T>, TypedFunctionSymbol<'ast, T>>;
#[derive(Clone, Debug, PartialEq)] #[derive(Clone, Debug, PartialEq, Eq)]
pub enum TypedConstantSymbol<'ast, T> { pub enum TypedConstantSymbol<'ast, T> {
Here(TypedConstant<'ast, T>), Here(TypedConstant<'ast, T>),
There(CanonicalConstantIdentifier<'ast>), There(CanonicalConstantIdentifier<'ast>),
@ -80,7 +80,7 @@ pub type TypedConstantSymbols<'ast, T> = Vec<(
)>; )>;
/// A typed program as a collection of modules, one of them being the main /// A typed program as a collection of modules, one of them being the main
#[derive(PartialEq, Debug, Clone)] #[derive(PartialEq, Eq, Debug, Clone)]
pub struct TypedProgram<'ast, T> { pub struct TypedProgram<'ast, T> {
pub modules: TypedModules<'ast, T>, pub modules: TypedModules<'ast, T>,
pub main: OwnedTypedModuleId, pub main: OwnedTypedModuleId,
@ -151,7 +151,7 @@ impl<'ast, T: fmt::Display> fmt::Display for TypedProgram<'ast, T> {
} }
} }
#[derive(PartialEq, Debug, Clone)] #[derive(PartialEq, Eq, Debug, Clone)]
pub struct TypedFunctionSymbolDeclaration<'ast, T> { pub struct TypedFunctionSymbolDeclaration<'ast, T> {
pub key: DeclarationFunctionKey<'ast, T>, pub key: DeclarationFunctionKey<'ast, T>,
pub symbol: TypedFunctionSymbol<'ast, T>, pub symbol: TypedFunctionSymbol<'ast, T>,
@ -163,7 +163,7 @@ impl<'ast, T> TypedFunctionSymbolDeclaration<'ast, T> {
} }
} }
#[derive(PartialEq, Debug, Clone)] #[derive(PartialEq, Eq, Debug, Clone)]
pub struct TypedConstantSymbolDeclaration<'ast, T> { pub struct TypedConstantSymbolDeclaration<'ast, T> {
pub id: CanonicalConstantIdentifier<'ast>, pub id: CanonicalConstantIdentifier<'ast>,
pub symbol: TypedConstantSymbol<'ast, T>, pub symbol: TypedConstantSymbol<'ast, T>,
@ -179,7 +179,7 @@ impl<'ast, T> TypedConstantSymbolDeclaration<'ast, T> {
} }
#[allow(clippy::large_enum_variant)] #[allow(clippy::large_enum_variant)]
#[derive(PartialEq, Debug, Clone)] #[derive(PartialEq, Eq, Debug, Clone)]
pub enum TypedSymbolDeclaration<'ast, T> { pub enum TypedSymbolDeclaration<'ast, T> {
Function(TypedFunctionSymbolDeclaration<'ast, T>), Function(TypedFunctionSymbolDeclaration<'ast, T>),
Constant(TypedConstantSymbolDeclaration<'ast, T>), Constant(TypedConstantSymbolDeclaration<'ast, T>),
@ -209,7 +209,7 @@ impl<'ast, T: fmt::Display> fmt::Display for TypedSymbolDeclaration<'ast, T> {
pub type TypedSymbolDeclarations<'ast, T> = Vec<TypedSymbolDeclaration<'ast, T>>; pub type TypedSymbolDeclarations<'ast, T> = Vec<TypedSymbolDeclaration<'ast, T>>;
/// A typed module as a collection of functions. Types have been resolved during semantic checking. /// A typed module as a collection of functions. Types have been resolved during semantic checking.
#[derive(PartialEq, Debug, Clone)] #[derive(PartialEq, Eq, Debug, Clone)]
pub struct TypedModule<'ast, T> { pub struct TypedModule<'ast, T> {
pub symbols: TypedSymbolDeclarations<'ast, T>, pub symbols: TypedSymbolDeclarations<'ast, T>,
} }
@ -232,7 +232,7 @@ impl<'ast, T> TypedModule<'ast, T> {
} }
} }
#[derive(Clone, PartialEq, Debug)] #[derive(Clone, PartialEq, Eq, Debug)]
pub enum TypedFunctionSymbol<'ast, T> { pub enum TypedFunctionSymbol<'ast, T> {
Here(TypedFunction<'ast, T>), Here(TypedFunction<'ast, T>),
There(DeclarationFunctionKey<'ast, T>), There(DeclarationFunctionKey<'ast, T>),
@ -315,7 +315,7 @@ impl<'ast, T: fmt::Display> fmt::Display for TypedModule<'ast, T> {
} }
/// A typed function /// A typed function
#[derive(Clone, PartialEq, Debug, Hash)] #[derive(Clone, PartialEq, Eq, Debug, Hash)]
pub struct TypedFunction<'ast, T> { pub struct TypedFunction<'ast, T> {
/// Arguments of the function /// Arguments of the function
pub arguments: Vec<DeclarationParameter<'ast, T>>, pub arguments: Vec<DeclarationParameter<'ast, T>>,
@ -374,7 +374,7 @@ impl<'ast, T: fmt::Display> fmt::Display for TypedFunction<'ast, T> {
} }
} }
#[derive(Clone, PartialEq, Debug)] #[derive(Clone, PartialEq, Eq, Debug)]
pub struct TypedConstant<'ast, T> { pub struct TypedConstant<'ast, T> {
pub expression: TypedExpression<'ast, T>, pub expression: TypedExpression<'ast, T>,
pub ty: DeclarationType<'ast, T>, pub ty: DeclarationType<'ast, T>,

14
zokrates_ast/src/typed/types.rs
View file

@ -269,6 +269,7 @@ impl<'ast, T> TryInto<usize> for DeclarationConstant<'ast, T> {
pub type MemberId = String; pub type MemberId = String;
#[allow(clippy::derive_hash_xor_eq)]
#[derive(Debug, Clone, Eq, Hash, Serialize, Deserialize, PartialOrd, Ord)] #[derive(Debug, Clone, Eq, Hash, Serialize, Deserialize, PartialOrd, Ord)]
pub struct GStructMember<S> { pub struct GStructMember<S> {
#[serde(rename = "name")] #[serde(rename = "name")]
@ -281,7 +282,7 @@ pub type DeclarationStructMember<'ast, T> = GStructMember<DeclarationConstant<'a
pub type ConcreteStructMember = GStructMember<u32>; pub type ConcreteStructMember = GStructMember<u32>;
pub type StructMember<'ast, T> = GStructMember<UExpression<'ast, T>>; pub type StructMember<'ast, T> = GStructMember<UExpression<'ast, T>>;
impl<'ast, S, R: PartialEq<S>> PartialEq<GStructMember<S>> for GStructMember<R> { impl<S, R: PartialEq<S>> PartialEq<GStructMember<S>> for GStructMember<R> {
fn eq(&self, other: &GStructMember<S>) -> bool { fn eq(&self, other: &GStructMember<S>) -> bool {
self.id == other.id && *self.ty == *other.ty self.id == other.id && *self.ty == *other.ty
} }
@ -310,6 +311,7 @@ impl<'ast, T> From<ConcreteStructMember> for StructMember<'ast, T> {
} }
} }
#[allow(clippy::derive_hash_xor_eq)]
#[derive(Clone, Eq, Hash, Serialize, Deserialize, PartialOrd, Ord, Debug)] #[derive(Clone, Eq, Hash, Serialize, Deserialize, PartialOrd, Ord, Debug)]
pub struct GArrayType<S> { pub struct GArrayType<S> {
pub size: Box<S>, pub size: Box<S>,
@ -321,7 +323,7 @@ pub type DeclarationArrayType<'ast, T> = GArrayType<DeclarationConstant<'ast, T>
pub type ConcreteArrayType = GArrayType<u32>; pub type ConcreteArrayType = GArrayType<u32>;
pub type ArrayType<'ast, T> = GArrayType<UExpression<'ast, T>>; pub type ArrayType<'ast, T> = GArrayType<UExpression<'ast, T>>;
impl<'ast, S, R: PartialEq<S>> PartialEq<GArrayType<S>> for GArrayType<R> { impl<S, R: PartialEq<S>> PartialEq<GArrayType<S>> for GArrayType<R> {
fn eq(&self, other: &GArrayType<S>) -> bool { fn eq(&self, other: &GArrayType<S>) -> bool {
*self.ty == *other.ty && *self.size == *other.size *self.ty == *other.ty && *self.size == *other.size
} }
@ -376,6 +378,7 @@ impl<'ast, T> From<ConcreteArrayType> for ArrayType<'ast, T> {
} }
} }
#[allow(clippy::derive_hash_xor_eq)]
#[derive(Clone, Eq, Hash, Serialize, Deserialize, PartialOrd, Ord, Debug)] #[derive(Clone, Eq, Hash, Serialize, Deserialize, PartialOrd, Ord, Debug)]
pub struct GTupleType<S> { pub struct GTupleType<S> {
pub elements: Vec<GType<S>>, pub elements: Vec<GType<S>>,
@ -391,7 +394,7 @@ pub type DeclarationTupleType<'ast, T> = GTupleType<DeclarationConstant<'ast, T>
pub type ConcreteTupleType = GTupleType<u32>; pub type ConcreteTupleType = GTupleType<u32>;
pub type TupleType<'ast, T> = GTupleType<UExpression<'ast, T>>; pub type TupleType<'ast, T> = GTupleType<UExpression<'ast, T>>;
impl<'ast, S, R: PartialEq<S>> PartialEq<GTupleType<S>> for GTupleType<R> { impl<S, R: PartialEq<S>> PartialEq<GTupleType<S>> for GTupleType<R> {
fn eq(&self, other: &GTupleType<S>) -> bool { fn eq(&self, other: &GTupleType<S>) -> bool {
*self.elements == *other.elements *self.elements == *other.elements
} }
@ -481,7 +484,7 @@ pub type DeclarationStructType<'ast, T> = GStructType<DeclarationConstant<'ast,
pub type ConcreteStructType = GStructType<u32>; pub type ConcreteStructType = GStructType<u32>;
pub type StructType<'ast, T> = GStructType<UExpression<'ast, T>>; pub type StructType<'ast, T> = GStructType<UExpression<'ast, T>>;
impl<'ast, S, R: PartialEq<S>> PartialEq<GStructType<S>> for GStructType<R> { impl<S, R: PartialEq<S>> PartialEq<GStructType<S>> for GStructType<R> {
fn eq(&self, other: &GStructType<S>) -> bool { fn eq(&self, other: &GStructType<S>) -> bool {
self.canonical_location == other.canonical_location self.canonical_location == other.canonical_location
&& self && self
@ -627,6 +630,7 @@ impl fmt::Display for UBitwidth {
} }
} }
#[allow(clippy::derive_hash_xor_eq)]
#[derive(Clone, Eq, Hash, PartialOrd, Ord, Debug)] #[derive(Clone, Eq, Hash, PartialOrd, Ord, Debug)]
pub enum GType<S> { pub enum GType<S> {
FieldElement, FieldElement,
@ -754,7 +758,7 @@ pub type DeclarationType<'ast, T> = GType<DeclarationConstant<'ast, T>>;
pub type ConcreteType = GType<u32>; pub type ConcreteType = GType<u32>;
pub type Type<'ast, T> = GType<UExpression<'ast, T>>; pub type Type<'ast, T> = GType<UExpression<'ast, T>>;
impl<'ast, S, R: PartialEq<S>> PartialEq<GType<S>> for GType<R> { impl<S, R: PartialEq<S>> PartialEq<GType<S>> for GType<R> {
fn eq(&self, other: &GType<S>) -> bool { fn eq(&self, other: &GType<S>) -> bool {
use self::GType::*; use self::GType::*;

8
zokrates_ast/src/untyped/mod.rs
View file

@ -44,7 +44,7 @@ pub struct Program<'ast> {
pub main: OwnedModuleId, pub main: OwnedModuleId,
} }
#[derive(Debug, PartialEq, Clone)] #[derive(Debug, PartialEq, Eq, Clone)]
pub struct SymbolIdentifier<'ast> { pub struct SymbolIdentifier<'ast> {
pub id: Identifier<'ast>, pub id: Identifier<'ast>,
pub alias: Option<Identifier<'ast>>, pub alias: Option<Identifier<'ast>>,
@ -77,7 +77,7 @@ impl<'ast> fmt::Display for SymbolIdentifier<'ast> {
} }
} }
#[derive(Debug, Clone, PartialEq)] #[derive(Debug, Clone, PartialEq, Eq)]
pub struct CanonicalImport<'ast> { pub struct CanonicalImport<'ast> {
pub source: &'ast Path, pub source: &'ast Path,
pub id: SymbolIdentifier<'ast>, pub id: SymbolIdentifier<'ast>,
@ -91,7 +91,7 @@ impl<'ast> fmt::Display for CanonicalImport<'ast> {
} }
} }
#[derive(Debug, Clone, PartialEq)] #[derive(Debug, Clone, PartialEq, Eq)]
pub struct SymbolImport<'ast> { pub struct SymbolImport<'ast> {
pub module_id: OwnedModuleId, pub module_id: OwnedModuleId,
pub symbol_id: Identifier<'ast>, pub symbol_id: Identifier<'ast>,
@ -521,7 +521,7 @@ impl<'ast> fmt::Display for Range<'ast> {
} }
} }
#[derive(Debug, Clone, PartialEq)] #[derive(Debug, Clone, PartialEq, Eq)]
pub enum ConditionalKind { pub enum ConditionalKind {
IfElse, IfElse,
Ternary, Ternary,

4
zokrates_ast/src/zir/mod.rs
View file

@ -23,7 +23,7 @@ pub use self::folder::Folder;
pub use self::identifier::{Identifier, SourceIdentifier}; pub use self::identifier::{Identifier, SourceIdentifier};
/// A typed program as a collection of modules, one of them being the main /// A typed program as a collection of modules, one of them being the main
#[derive(PartialEq, Debug)] #[derive(PartialEq, Eq, Debug)]
pub struct ZirProgram<'ast, T> { pub struct ZirProgram<'ast, T> {
pub main: ZirFunction<'ast, T>, pub main: ZirFunction<'ast, T>,
} }
@ -34,7 +34,7 @@ impl<'ast, T: fmt::Display> fmt::Display for ZirProgram<'ast, T> {
} }
} }
/// A typed function /// A typed function
#[derive(Clone, PartialEq)] #[derive(Clone, PartialEq, Eq)]
pub struct ZirFunction<'ast, T> { pub struct ZirFunction<'ast, T> {
/// Arguments of the function /// Arguments of the function
pub arguments: Vec<Parameter<'ast>>, pub arguments: Vec<Parameter<'ast>>,

2
zokrates_ast/src/zir/parameter.rs
View file

@ -1,7 +1,7 @@
use crate::zir::Variable; use crate::zir::Variable;
use std::fmt; use std::fmt;
#[derive(Clone, PartialEq)] #[derive(Clone, PartialEq, Eq)]
pub struct Parameter<'ast> { pub struct Parameter<'ast> {
pub id: Variable<'ast>, pub id: Variable<'ast>,
pub private: bool, pub private: bool,

2
zokrates_circom/src/lib.rs
View file

@ -85,6 +85,6 @@ mod tests {
wire_mapping: Some(mapping), wire_mapping: Some(mapping),
}; };
let rng = create_rng(); let rng = create_rng();
assert!(prove(circuit.clone(), &params, rng).is_ok()); assert!(prove(circuit, &params, rng).is_ok());
} }
} }

2
zokrates_cli/src/ops/check.rs
View file

@ -94,7 +94,7 @@ fn cli_check<T: Field>(sub_matches: &ArgMatches) -> Result<(), String> {
CompileConfig::default().isolate_branches(sub_matches.is_present("isolate-branches")); CompileConfig::default().isolate_branches(sub_matches.is_present("isolate-branches"));
let resolver = FileSystemResolver::with_stdlib_root(stdlib_path); let resolver = FileSystemResolver::with_stdlib_root(stdlib_path);
let _ = check::<T, _>(source, path, Some(&resolver), &config).map_err(|e| { check::<T, _>(source, path, Some(&resolver), &config).map_err(|e| {
format!( format!(
"Check failed:\n\n{}", "Check failed:\n\n{}",
e.0.iter() e.0.iter()

12
zokrates_cli/tests/integration.rs
View file

@ -375,14 +375,14 @@ mod integration {
// Compile lib // Compile lib
let g2_lib = let g2_lib =
Contract::compile_from_src_string(&SOLIDITY_G2_ADDITION_LIB, "BN256G2", true, &[]) Contract::compile_from_src_string(SOLIDITY_G2_ADDITION_LIB, "BN256G2", true, &[])
.unwrap(); .unwrap();
// Deploy lib // Deploy lib
let create_result = evm let create_result = evm
.deploy(g2_lib.encode_create_contract_bytes(&[]).unwrap(), &deployer) .deploy(g2_lib.encode_create_contract_bytes(&[]).unwrap(), &deployer)
.unwrap(); .unwrap();
let lib_addr = create_result.addr.clone(); let lib_addr = create_result.addr;
// Compile contract // Compile contract
let contract = Contract::compile_from_src_string( let contract = Contract::compile_from_src_string(
@ -400,7 +400,7 @@ mod integration {
&deployer, &deployer,
) )
.unwrap(); .unwrap();
let contract_addr = create_result.addr.clone(); let contract_addr = create_result.addr;
// convert to the solidity proof format // convert to the solidity proof format
let solidity_proof = S::Proof::from(proof.proof); let solidity_proof = S::Proof::from(proof.proof);
@ -436,11 +436,11 @@ mod integration {
assert_eq!(&result.out, &to_be_bytes(&U256::from(1))); assert_eq!(&result.out, &to_be_bytes(&U256::from(1)));
// modify the proof // modify the proof
let modified_solidity_proof = S::modify(solidity_proof.clone()); let modified_solidity_proof = S::modify(solidity_proof);
let modified_proof_token = S::to_token(modified_solidity_proof.clone()); let modified_proof_token = S::to_token(modified_solidity_proof);
let inputs = [modified_proof_token, input_token.clone()]; let inputs = [modified_proof_token, input_token];
// Call verify function on contract // Call verify function on contract
let result = evm let result = evm

2
zokrates_core/src/imports.rs
View file

@ -18,7 +18,7 @@ use zokrates_ast::untyped::types::UnresolvedType;
use zokrates_common::Resolver; use zokrates_common::Resolver;
use zokrates_field::Field; use zokrates_field::Field;
#[derive(PartialEq, Debug)] #[derive(PartialEq, Eq, Debug)]
pub struct Error { pub struct Error {
pos: Option<(Position, Position)>, pos: Option<(Position, Position)>,
message: String, message: String,

15
zokrates_core/src/semantics.rs
View file

@ -26,13 +26,13 @@ use zokrates_ast::typed::types::{
TupleType, TupleType,
}; };
#[derive(PartialEq, Debug)] #[derive(PartialEq, Eq, Debug)]
pub struct ErrorInner { pub struct ErrorInner {
pos: Option<(Position, Position)>, pos: Option<(Position, Position)>,
message: String, message: String,
} }
#[derive(PartialEq, Debug)] #[derive(PartialEq, Eq, Debug)]
pub struct Error { pub struct Error {
pub inner: ErrorInner, pub inner: ErrorInner,
pub module_id: PathBuf, pub module_id: PathBuf,
@ -4715,9 +4715,7 @@ mod tests {
// should fail // should fail
let bar_statements: Vec<StatementNode> = vec![ let bar_statements: Vec<StatementNode> = vec![
Statement::Definition( Statement::Definition(
untyped::Variable::immutable("a", UnresolvedType::FieldElement.mock()) untyped::Variable::immutable("a", UnresolvedType::FieldElement.mock()).mock(),
.mock()
.into(),
Expression::FunctionCall(box Expression::Identifier("foo").mock(), None, vec![]) Expression::FunctionCall(box Expression::Identifier("foo").mock(), None, vec![])
.mock(), .mock(),
) )
@ -4766,9 +4764,7 @@ mod tests {
// should fail // should fail
let bar_statements: Vec<StatementNode> = vec![ let bar_statements: Vec<StatementNode> = vec![
Statement::Definition( Statement::Definition(
untyped::Variable::immutable("a", UnresolvedType::FieldElement.mock()) untyped::Variable::immutable("a", UnresolvedType::FieldElement.mock()).mock(),
.mock()
.into(),
Expression::FunctionCall(box Expression::Identifier("foo").mock(), None, vec![]) Expression::FunctionCall(box Expression::Identifier("foo").mock(), None, vec![])
.mock(), .mock(),
) )
@ -4920,8 +4916,7 @@ mod tests {
untyped::Expression::IntConstant(0usize.into()).mock(), untyped::Expression::IntConstant(0usize.into()).mock(),
), ),
) )
.mock() .mock(),
.into(),
Expression::FunctionCall(box Expression::Identifier("foo").mock(), None, vec![]) Expression::FunctionCall(box Expression::Identifier("foo").mock(), None, vec![])
.mock(), .mock(),
) )

2
zokrates_core/src/static_analysis/constant_resolver.rs
View file

@ -17,7 +17,7 @@ pub struct ConstantResolver<'ast, T> {
constants: ProgramConstants<'ast, T>, constants: ProgramConstants<'ast, T>,
} }
impl<'ast, 'a, T: Field> ConstantResolver<'ast, T> { impl<'ast, T: Field> ConstantResolver<'ast, T> {
pub fn new( pub fn new(
modules: TypedModules<'ast, T>, modules: TypedModules<'ast, T>,
location: OwnedTypedModuleId, location: OwnedTypedModuleId,

2
zokrates_core/src/static_analysis/propagation.rs
View file

@ -18,7 +18,7 @@ use zokrates_field::Field;
pub type Constants<'ast, T> = HashMap<Identifier<'ast>, TypedExpression<'ast, T>>; pub type Constants<'ast, T> = HashMap<Identifier<'ast>, TypedExpression<'ast, T>>;
#[derive(Debug, PartialEq)] #[derive(Debug, PartialEq, Eq)]
pub enum Error { pub enum Error {
Type(String), Type(String),
AssertionFailed(String), AssertionFailed(String),

4
zokrates_core/src/static_analysis/reducer/mod.rs
View file

@ -50,13 +50,13 @@ pub type ConstantDefinitions<'ast, T> =
pub type Versions<'ast> = HashMap<CoreIdentifier<'ast>, usize>; pub type Versions<'ast> = HashMap<CoreIdentifier<'ast>, usize>;
// A container to represent whether more treatment must be applied to the function // A container to represent whether more treatment must be applied to the function
#[derive(Debug, PartialEq)] #[derive(Debug, PartialEq, Eq)]
pub enum Output<U, V> { pub enum Output<U, V> {
Complete(U), Complete(U),
Incomplete(U, V), Incomplete(U, V),
} }
#[derive(Debug, Clone, PartialEq)] #[derive(Debug, Clone, PartialEq, Eq)]
pub enum Error { pub enum Error {
Incompatible(String), Incompatible(String),
GenericsInMain, GenericsInMain,

2
zokrates_core/src/static_analysis/zir_propagation.rs
View file

@ -11,7 +11,7 @@ use zokrates_field::Field;
type Constants<'ast, T> = HashMap<Identifier<'ast>, ZirExpression<'ast, T>>; type Constants<'ast, T> = HashMap<Identifier<'ast>, ZirExpression<'ast, T>>;
#[derive(Debug, PartialEq)] #[derive(Debug, PartialEq, Eq)]
pub enum Error { pub enum Error {
OutOfBounds(usize, usize), OutOfBounds(usize, usize),
DivisionByZero, DivisionByZero,

2
zokrates_embed/src/lib.rs
View file

@ -24,7 +24,7 @@ pub struct Witness<T> {
pub values: Vec<T>, pub values: Vec<T>,
} }
#[derive(Default, Debug, PartialEq, Clone)] #[derive(Default, Debug, PartialEq, Eq, Clone)]
pub struct Constraint<T> { pub struct Constraint<T> {
pub a: Vec<(T, usize)>, pub a: Vec<(T, usize)>,
pub b: Vec<(T, usize)>, pub b: Vec<(T, usize)>,

2
zokrates_interpreter/src/lib.rs
View file

@ -271,7 +271,7 @@ impl Interpreter {
#[derive(Debug)] #[derive(Debug)]
pub struct EvaluationError; pub struct EvaluationError;
#[derive(PartialEq, Clone, Serialize, Deserialize)] #[derive(PartialEq, Eq, Clone, Serialize, Deserialize)]
pub enum Error { pub enum Error {
UnsatisfiedConstraint { error: Option<RuntimeError> }, UnsatisfiedConstraint { error: Option<RuntimeError> },
Solver, Solver,

98
zokrates_pest_ast/src/lib.rs
View file

@ -124,7 +124,7 @@ mod ast {
pub span: Span<'ast>, pub span: Span<'ast>,
} }
#[derive(Debug, FromPest, PartialEq, Clone)] #[derive(Debug, FromPest, PartialEq, Eq, Clone)]
#[pest_ast(rule(Rule::pragma))] #[pest_ast(rule(Rule::pragma))]
pub struct Pragma<'ast> { pub struct Pragma<'ast> {
pub curve: Curve<'ast>, pub curve: Curve<'ast>,
@ -132,7 +132,7 @@ mod ast {
pub span: Span<'ast>, pub span: Span<'ast>,
} }
#[derive(Debug, FromPest, PartialEq, Clone)] #[derive(Debug, FromPest, PartialEq, Eq, Clone)]
#[pest_ast(rule(Rule::curve))] #[pest_ast(rule(Rule::curve))]
pub struct Curve<'ast> { pub struct Curve<'ast> {
#[pest_ast(outer(with(span_into_str)))] #[pest_ast(outer(with(span_into_str)))]
@ -201,14 +201,14 @@ mod ast {
pub span: Span<'ast>, pub span: Span<'ast>,
} }
#[derive(Debug, FromPest, PartialEq, Clone)] #[derive(Debug, FromPest, PartialEq, Eq, Clone)]
#[pest_ast(rule(Rule::import_directive))] #[pest_ast(rule(Rule::import_directive))]
pub enum ImportDirective<'ast> { pub enum ImportDirective<'ast> {
Main(MainImportDirective<'ast>), Main(MainImportDirective<'ast>),
From(FromImportDirective<'ast>), From(FromImportDirective<'ast>),
} }
#[derive(Debug, FromPest, PartialEq, Clone)] #[derive(Debug, FromPest, PartialEq, Eq, Clone)]
#[pest_ast(rule(Rule::main_import_directive))] #[pest_ast(rule(Rule::main_import_directive))]
pub struct MainImportDirective<'ast> { pub struct MainImportDirective<'ast> {
pub source: AnyString<'ast>, pub source: AnyString<'ast>,
@ -217,7 +217,7 @@ mod ast {
pub span: Span<'ast>, pub span: Span<'ast>,
} }
#[derive(Debug, FromPest, PartialEq, Clone)] #[derive(Debug, FromPest, PartialEq, Eq, Clone)]
#[pest_ast(rule(Rule::import_symbol))] #[pest_ast(rule(Rule::import_symbol))]
pub struct ImportSymbol<'ast> { pub struct ImportSymbol<'ast> {
pub id: IdentifierExpression<'ast>, pub id: IdentifierExpression<'ast>,
@ -226,7 +226,7 @@ mod ast {
pub span: Span<'ast>, pub span: Span<'ast>,
} }
#[derive(Debug, FromPest, PartialEq, Clone)] #[derive(Debug, FromPest, PartialEq, Eq, Clone)]
#[pest_ast(rule(Rule::from_import_directive))] #[pest_ast(rule(Rule::from_import_directive))]
pub struct FromImportDirective<'ast> { pub struct FromImportDirective<'ast> {
pub source: AnyString<'ast>, pub source: AnyString<'ast>,
@ -244,7 +244,7 @@ mod ast {
Tuple(TupleType<'ast>), Tuple(TupleType<'ast>),
} }
#[derive(Debug, FromPest, PartialEq, Clone)] #[derive(Debug, FromPest, PartialEq, Eq, Clone)]
#[pest_ast(rule(Rule::ty_basic))] #[pest_ast(rule(Rule::ty_basic))]
pub enum BasicType<'ast> { pub enum BasicType<'ast> {
Field(FieldType<'ast>), Field(FieldType<'ast>),
@ -255,7 +255,7 @@ mod ast {
U64(U64Type<'ast>), U64(U64Type<'ast>),
} }
#[derive(Debug, FromPest, PartialEq, Clone)] #[derive(Debug, FromPest, PartialEq, Eq, Clone)]
#[pest_ast(rule(Rule::ty_field))] #[pest_ast(rule(Rule::ty_field))]
pub struct FieldType<'ast> { pub struct FieldType<'ast> {
#[pest_ast(outer())] #[pest_ast(outer())]
@ -279,42 +279,42 @@ mod ast {
Tuple(TupleType<'ast>), Tuple(TupleType<'ast>),
} }
#[derive(Debug, FromPest, PartialEq, Clone)] #[derive(Debug, FromPest, PartialEq, Eq, Clone)]
#[pest_ast(rule(Rule::ty_bool))] #[pest_ast(rule(Rule::ty_bool))]
pub struct BooleanType<'ast> { pub struct BooleanType<'ast> {
#[pest_ast(outer())] #[pest_ast(outer())]
pub span: Span<'ast>, pub span: Span<'ast>,
} }
#[derive(Debug, FromPest, PartialEq, Clone)] #[derive(Debug, FromPest, PartialEq, Eq, Clone)]
#[pest_ast(rule(Rule::ty_u8))] #[pest_ast(rule(Rule::ty_u8))]
pub struct U8Type<'ast> { pub struct U8Type<'ast> {
#[pest_ast(outer())] #[pest_ast(outer())]
pub span: Span<'ast>, pub span: Span<'ast>,
} }
#[derive(Debug, FromPest, PartialEq, Clone)] #[derive(Debug, FromPest, PartialEq, Eq, Clone)]
#[pest_ast(rule(Rule::ty_u16))] #[pest_ast(rule(Rule::ty_u16))]
pub struct U16Type<'ast> { pub struct U16Type<'ast> {
#[pest_ast(outer())] #[pest_ast(outer())]
pub span: Span<'ast>, pub span: Span<'ast>,
} }
#[derive(Debug, FromPest, PartialEq, Clone)] #[derive(Debug, FromPest, PartialEq, Eq, Clone)]
#[pest_ast(rule(Rule::ty_u32))] #[pest_ast(rule(Rule::ty_u32))]
pub struct U32Type<'ast> { pub struct U32Type<'ast> {
#[pest_ast(outer())] #[pest_ast(outer())]
pub span: Span<'ast>, pub span: Span<'ast>,
} }
#[derive(Debug, FromPest, PartialEq, Clone)] #[derive(Debug, FromPest, PartialEq, Eq, Clone)]
#[pest_ast(rule(Rule::ty_u64))] #[pest_ast(rule(Rule::ty_u64))]
pub struct U64Type<'ast> { pub struct U64Type<'ast> {
#[pest_ast(outer())] #[pest_ast(outer())]
pub span: Span<'ast>, pub span: Span<'ast>,
} }
#[derive(Debug, FromPest, PartialEq, Clone)] #[derive(Debug, FromPest, PartialEq, Eq, Clone)]
#[pest_ast(rule(Rule::ty_struct))] #[pest_ast(rule(Rule::ty_struct))]
pub struct StructType<'ast> { pub struct StructType<'ast> {
pub id: IdentifierExpression<'ast>, pub id: IdentifierExpression<'ast>,
@ -342,18 +342,18 @@ mod ast {
pub span: Span<'ast>, pub span: Span<'ast>,
} }
#[derive(Debug, FromPest, PartialEq, Clone)] #[derive(Debug, FromPest, PartialEq, Eq, Clone)]
#[pest_ast(rule(Rule::vis))] #[pest_ast(rule(Rule::vis))]
pub enum Visibility { pub enum Visibility {
Public(PublicVisibility), Public(PublicVisibility),
Private(PrivateVisibility), Private(PrivateVisibility),
} }
#[derive(Debug, FromPest, PartialEq, Clone)] #[derive(Debug, FromPest, PartialEq, Eq, Clone)]
#[pest_ast(rule(Rule::vis_public))] #[pest_ast(rule(Rule::vis_public))]
pub struct PublicVisibility {} pub struct PublicVisibility {}
#[derive(Debug, FromPest, PartialEq, Clone)] #[derive(Debug, FromPest, PartialEq, Eq, Clone)]
#[pest_ast(rule(Rule::vis_private))] #[pest_ast(rule(Rule::vis_private))]
pub struct PrivateVisibility {} pub struct PrivateVisibility {}
@ -386,7 +386,7 @@ mod ast {
pub span: Span<'ast>, pub span: Span<'ast>,
} }
#[derive(Debug, FromPest, PartialEq, Clone)] #[derive(Debug, FromPest, PartialEq, Eq, Clone)]
#[pest_ast(rule(Rule::string))] #[pest_ast(rule(Rule::string))]
pub struct AnyString<'ast> { pub struct AnyString<'ast> {
#[pest_ast(outer(with(span_into_str)))] #[pest_ast(outer(with(span_into_str)))]
@ -423,7 +423,7 @@ mod ast {
pub span: Span<'ast>, pub span: Span<'ast>,
} }
#[derive(Debug, PartialEq, Clone)] #[derive(Debug, PartialEq, Eq, Clone)]
pub enum BinaryOperator { pub enum BinaryOperator {
BitXor, BitXor,
BitAnd, BitAnd,
@ -559,7 +559,7 @@ mod ast {
} }
} }
#[derive(Debug, FromPest, PartialEq, Clone)] #[derive(Debug, FromPest, PartialEq, Eq, Clone)]
#[pest_ast(rule(Rule::op_unary))] #[pest_ast(rule(Rule::op_unary))]
pub enum UnaryOperator { pub enum UnaryOperator {
Pos(PosOperator), Pos(PosOperator),
@ -567,15 +567,15 @@ mod ast {
Not(NotOperator), Not(NotOperator),
} }
#[derive(Debug, FromPest, PartialEq, Clone)] #[derive(Debug, FromPest, PartialEq, Eq, Clone)]
#[pest_ast(rule(Rule::op_pos))] #[pest_ast(rule(Rule::op_pos))]
pub struct PosOperator; pub struct PosOperator;
#[derive(Debug, FromPest, PartialEq, Clone)] #[derive(Debug, FromPest, PartialEq, Eq, Clone)]
#[pest_ast(rule(Rule::op_neg))] #[pest_ast(rule(Rule::op_neg))]
pub struct NegOperator; pub struct NegOperator;
#[derive(Debug, FromPest, PartialEq, Clone)] #[derive(Debug, FromPest, PartialEq, Eq, Clone)]
#[pest_ast(rule(Rule::op_not))] #[pest_ast(rule(Rule::op_not))]
pub struct NotOperator; pub struct NotOperator;
@ -593,7 +593,7 @@ mod ast {
} }
} }
#[derive(Debug, FromPest, PartialEq, Clone)] #[derive(Debug, FromPest, PartialEq, Eq, Clone)]
#[pest_ast(rule(Rule::primary_expression))] #[pest_ast(rule(Rule::primary_expression))]
pub enum PrimaryExpression<'ast> { pub enum PrimaryExpression<'ast> {
Identifier(IdentifierExpression<'ast>), Identifier(IdentifierExpression<'ast>),
@ -714,7 +714,7 @@ mod ast {
TypedIdentifier(TypedIdentifier<'ast>), TypedIdentifier(TypedIdentifier<'ast>),
} }
#[derive(Debug, FromPest, PartialEq, Clone)] #[derive(Debug, FromPest, PartialEq, Eq, Clone)]
#[pest_ast(rule(Rule::_mut))] #[pest_ast(rule(Rule::_mut))]
pub struct Mutable {} pub struct Mutable {}
@ -754,7 +754,7 @@ mod ast {
pub span: Span<'ast>, pub span: Span<'ast>,
} }
#[derive(Debug, FromPest, PartialEq, Clone)] #[derive(Debug, FromPest, PartialEq, Eq, Clone)]
#[pest_ast(rule(Rule::explicit_generics))] #[pest_ast(rule(Rule::explicit_generics))]
pub struct ExplicitGenerics<'ast> { pub struct ExplicitGenerics<'ast> {
pub values: Vec<ConstantGenericValue<'ast>>, pub values: Vec<ConstantGenericValue<'ast>>,
@ -762,7 +762,7 @@ mod ast {
pub span: Span<'ast>, pub span: Span<'ast>,
} }
#[derive(Debug, FromPest, PartialEq, Clone)] #[derive(Debug, FromPest, PartialEq, Eq, Clone)]
#[pest_ast(rule(Rule::constant_generics_value))] #[pest_ast(rule(Rule::constant_generics_value))]
pub enum ConstantGenericValue<'ast> { pub enum ConstantGenericValue<'ast> {
Value(LiteralExpression<'ast>), Value(LiteralExpression<'ast>),
@ -770,7 +770,7 @@ mod ast {
Underscore(Underscore<'ast>), Underscore(Underscore<'ast>),
} }
#[derive(Debug, FromPest, PartialEq, Clone)] #[derive(Debug, FromPest, PartialEq, Eq, Clone)]
#[pest_ast(rule(Rule::underscore))] #[pest_ast(rule(Rule::underscore))]
pub struct Underscore<'ast> { pub struct Underscore<'ast> {
#[pest_ast(outer())] #[pest_ast(outer())]
@ -793,7 +793,7 @@ mod ast {
pub span: Span<'ast>, pub span: Span<'ast>,
} }
#[derive(Debug, FromPest, PartialEq, Clone)] #[derive(Debug, FromPest, PartialEq, Eq, Clone)]
#[pest_ast(rule(Rule::dot_access))] #[pest_ast(rule(Rule::dot_access))]
pub struct DotAccess<'ast> { pub struct DotAccess<'ast> {
pub inner: IdentifierOrDecimal<'ast>, pub inner: IdentifierOrDecimal<'ast>,
@ -801,7 +801,7 @@ mod ast {
pub span: Span<'ast>, pub span: Span<'ast>,
} }
#[derive(Debug, FromPest, PartialEq, Clone)] #[derive(Debug, FromPest, PartialEq, Eq, Clone)]
#[pest_ast(rule(Rule::identifier_or_decimal))] #[pest_ast(rule(Rule::identifier_or_decimal))]
pub enum IdentifierOrDecimal<'ast> { pub enum IdentifierOrDecimal<'ast> {
Identifier(IdentifierExpression<'ast>), Identifier(IdentifierExpression<'ast>),
@ -928,7 +928,7 @@ mod ast {
} }
} }
#[derive(Debug, FromPest, PartialEq, Clone)] #[derive(Debug, FromPest, PartialEq, Eq, Clone)]
#[pest_ast(rule(Rule::literal))] #[pest_ast(rule(Rule::literal))]
pub enum LiteralExpression<'ast> { pub enum LiteralExpression<'ast> {
DecimalLiteral(DecimalLiteralExpression<'ast>), DecimalLiteral(DecimalLiteralExpression<'ast>),
@ -946,7 +946,7 @@ mod ast {
} }
} }
#[derive(Debug, FromPest, PartialEq, Clone)] #[derive(Debug, FromPest, PartialEq, Eq, Clone)]
#[pest_ast(rule(Rule::decimal_suffix))] #[pest_ast(rule(Rule::decimal_suffix))]
pub enum DecimalSuffix<'ast> { pub enum DecimalSuffix<'ast> {
U8(U8Suffix<'ast>), U8(U8Suffix<'ast>),
@ -956,49 +956,49 @@ mod ast {
Field(FieldSuffix<'ast>), Field(FieldSuffix<'ast>),
} }
#[derive(Debug, FromPest, PartialEq, Clone)] #[derive(Debug, FromPest, PartialEq, Eq, Clone)]
#[pest_ast(rule(Rule::decimal_suffix_u8))] #[pest_ast(rule(Rule::decimal_suffix_u8))]
pub struct U8Suffix<'ast> { pub struct U8Suffix<'ast> {
#[pest_ast(outer())] #[pest_ast(outer())]
pub span: Span<'ast>, pub span: Span<'ast>,
} }
#[derive(Debug, FromPest, PartialEq, Clone)] #[derive(Debug, FromPest, PartialEq, Eq, Clone)]
#[pest_ast(rule(Rule::decimal_suffix_u16))] #[pest_ast(rule(Rule::decimal_suffix_u16))]
pub struct U16Suffix<'ast> { pub struct U16Suffix<'ast> {
#[pest_ast(outer())] #[pest_ast(outer())]
pub span: Span<'ast>, pub span: Span<'ast>,
} }
#[derive(Debug, FromPest, PartialEq, Clone)] #[derive(Debug, FromPest, PartialEq, Eq, Clone)]
#[pest_ast(rule(Rule::decimal_suffix_u32))] #[pest_ast(rule(Rule::decimal_suffix_u32))]
pub struct U32Suffix<'ast> { pub struct U32Suffix<'ast> {
#[pest_ast(outer())] #[pest_ast(outer())]
pub span: Span<'ast>, pub span: Span<'ast>,
} }
#[derive(Debug, FromPest, PartialEq, Clone)] #[derive(Debug, FromPest, PartialEq, Eq, Clone)]
#[pest_ast(rule(Rule::decimal_suffix_u64))] #[pest_ast(rule(Rule::decimal_suffix_u64))]
pub struct U64Suffix<'ast> { pub struct U64Suffix<'ast> {
#[pest_ast(outer())] #[pest_ast(outer())]
pub span: Span<'ast>, pub span: Span<'ast>,
} }
#[derive(Debug, FromPest, PartialEq, Clone)] #[derive(Debug, FromPest, PartialEq, Eq, Clone)]
#[pest_ast(rule(Rule::decimal_suffix_field))] #[pest_ast(rule(Rule::decimal_suffix_field))]
pub struct FieldSuffix<'ast> { pub struct FieldSuffix<'ast> {
#[pest_ast(outer())] #[pest_ast(outer())]
pub span: Span<'ast>, pub span: Span<'ast>,
} }
#[derive(Debug, FromPest, PartialEq, Clone)] #[derive(Debug, FromPest, PartialEq, Eq, Clone)]
#[pest_ast(rule(Rule::decimal_number))] #[pest_ast(rule(Rule::decimal_number))]
pub struct DecimalNumber<'ast> { pub struct DecimalNumber<'ast> {
#[pest_ast(outer())] #[pest_ast(outer())]
pub span: Span<'ast>, pub span: Span<'ast>,
} }
#[derive(Debug, FromPest, PartialEq, Clone)] #[derive(Debug, FromPest, PartialEq, Eq, Clone)]
#[pest_ast(rule(Rule::decimal_literal))] #[pest_ast(rule(Rule::decimal_literal))]
pub struct DecimalLiteralExpression<'ast> { pub struct DecimalLiteralExpression<'ast> {
pub value: DecimalNumber<'ast>, pub value: DecimalNumber<'ast>,
@ -1007,7 +1007,7 @@ mod ast {
pub span: Span<'ast>, pub span: Span<'ast>,
} }
#[derive(Debug, FromPest, PartialEq, Clone)] #[derive(Debug, FromPest, PartialEq, Eq, Clone)]
#[pest_ast(rule(Rule::boolean_literal))] #[pest_ast(rule(Rule::boolean_literal))]
pub struct BooleanLiteralExpression<'ast> { pub struct BooleanLiteralExpression<'ast> {
#[pest_ast(outer(with(span_into_str)))] #[pest_ast(outer(with(span_into_str)))]
@ -1016,7 +1016,7 @@ mod ast {
pub span: Span<'ast>, pub span: Span<'ast>,
} }
#[derive(Debug, FromPest, PartialEq, Clone)] #[derive(Debug, FromPest, PartialEq, Eq, Clone)]
#[pest_ast(rule(Rule::hex_literal))] #[pest_ast(rule(Rule::hex_literal))]
pub struct HexLiteralExpression<'ast> { pub struct HexLiteralExpression<'ast> {
pub value: HexNumberExpression<'ast>, pub value: HexNumberExpression<'ast>,
@ -1024,7 +1024,7 @@ mod ast {
pub span: Span<'ast>, pub span: Span<'ast>,
} }
#[derive(Debug, FromPest, PartialEq, Clone)] #[derive(Debug, FromPest, PartialEq, Eq, Clone)]
#[pest_ast(rule(Rule::hex_number))] #[pest_ast(rule(Rule::hex_number))]
pub enum HexNumberExpression<'ast> { pub enum HexNumberExpression<'ast> {
U8(U8NumberExpression<'ast>), U8(U8NumberExpression<'ast>),
@ -1033,7 +1033,7 @@ mod ast {
U64(U64NumberExpression<'ast>), U64(U64NumberExpression<'ast>),
} }
#[derive(Debug, FromPest, PartialEq, Clone)] #[derive(Debug, FromPest, PartialEq, Eq, Clone)]
#[pest_ast(rule(Rule::hex_number_u8))] #[pest_ast(rule(Rule::hex_number_u8))]
pub struct U8NumberExpression<'ast> { pub struct U8NumberExpression<'ast> {
#[pest_ast(outer(with(span_into_str)))] #[pest_ast(outer(with(span_into_str)))]
@ -1042,7 +1042,7 @@ mod ast {
pub span: Span<'ast>, pub span: Span<'ast>,
} }
#[derive(Debug, FromPest, PartialEq, Clone)] #[derive(Debug, FromPest, PartialEq, Eq, Clone)]
#[pest_ast(rule(Rule::hex_number_u16))] #[pest_ast(rule(Rule::hex_number_u16))]
pub struct U16NumberExpression<'ast> { pub struct U16NumberExpression<'ast> {
#[pest_ast(outer(with(span_into_str)))] #[pest_ast(outer(with(span_into_str)))]
@ -1051,7 +1051,7 @@ mod ast {
pub span: Span<'ast>, pub span: Span<'ast>,
} }
#[derive(Debug, FromPest, PartialEq, Clone)] #[derive(Debug, FromPest, PartialEq, Eq, Clone)]
#[pest_ast(rule(Rule::hex_number_u32))] #[pest_ast(rule(Rule::hex_number_u32))]
pub struct U32NumberExpression<'ast> { pub struct U32NumberExpression<'ast> {
#[pest_ast(outer(with(span_into_str)))] #[pest_ast(outer(with(span_into_str)))]
@ -1060,7 +1060,7 @@ mod ast {
pub span: Span<'ast>, pub span: Span<'ast>,
} }
#[derive(Debug, FromPest, PartialEq, Clone)] #[derive(Debug, FromPest, PartialEq, Eq, Clone)]
#[pest_ast(rule(Rule::hex_number_u64))] #[pest_ast(rule(Rule::hex_number_u64))]
pub struct U64NumberExpression<'ast> { pub struct U64NumberExpression<'ast> {
#[pest_ast(outer(with(span_into_str)))] #[pest_ast(outer(with(span_into_str)))]
@ -1069,7 +1069,7 @@ mod ast {
pub span: Span<'ast>, pub span: Span<'ast>,
} }
#[derive(Debug, FromPest, PartialEq, Clone)] #[derive(Debug, FromPest, PartialEq, Eq, Clone)]
#[pest_ast(rule(Rule::identifier))] #[pest_ast(rule(Rule::identifier))]
pub struct IdentifierExpression<'ast> { pub struct IdentifierExpression<'ast> {
#[pest_ast(outer(with(span_into_str)))] #[pest_ast(outer(with(span_into_str)))]
@ -1091,7 +1091,7 @@ mod ast {
span.as_str().to_string() span.as_str().to_string()
} }
#[derive(Debug, FromPest, PartialEq, Clone)] #[derive(Debug, FromPest, PartialEq, Eq, Clone)]
#[pest_ast(rule(Rule::EOI))] #[pest_ast(rule(Rule::EOI))]
#[allow(clippy::upper_case_acronyms)] #[allow(clippy::upper_case_acronyms)]
pub struct EOI; pub struct EOI;
@ -1105,7 +1105,7 @@ impl<'ast> From<Pairs<'ast, Rule>> for Prog<'ast> {
} }
} }
#[derive(PartialEq, Clone, Debug)] #[derive(PartialEq, Eq, Clone, Debug)]
pub struct Error(PestError<Rule>); pub struct Error(PestError<Rule>);
impl fmt::Display for Error { impl fmt::Display for Error {

20
zokrates_proof_systems/src/scheme/marlin.rs
View file

@ -91,6 +91,8 @@ impl<T: SolidityCompatibleField> SolidityCompatibleScheme<T> for Marlin {
type Proof = SolidityProof<Fr, G1Affine>; type Proof = SolidityProof<Fr, G1Affine>;
fn export_solidity_verifier(vk: <Marlin as Scheme<T>>::VerificationKey) -> String { fn export_solidity_verifier(vk: <Marlin as Scheme<T>>::VerificationKey) -> String {
use std::fmt::Write;
let (template, solidity_pairing_lib) = let (template, solidity_pairing_lib) =
(String::from(CONTRACT_TEMPLATE), solidity_pairing_lib(false)); (String::from(CONTRACT_TEMPLATE), solidity_pairing_lib(false));
@ -103,13 +105,15 @@ impl<T: SolidityCompatibleField> SolidityCompatibleScheme<T> for Marlin {
.replace("<%vk_populate_index_comms%>", &{ .replace("<%vk_populate_index_comms%>", &{
let mut populate_index_comms = String::new(); let mut populate_index_comms = String::new();
for (i, (g, _)) in vk.index_comms.iter().enumerate() { for (i, (g, _)) in vk.index_comms.iter().enumerate() {
populate_index_comms.push_str(&format!( write!(
populate_index_comms,
"vk.index_comms[{}] = Pairing.G1Point({});", "vk.index_comms[{}] = Pairing.G1Point({});",
i, i,
&g.to_string() &g.to_string()
)); )
.unwrap();
if i < vk.index_comms.len() - 1 { if i < vk.index_comms.len() - 1 {
populate_index_comms.push_str("\n "); write!(populate_index_comms, "\n ").unwrap();
} }
} }
populate_index_comms populate_index_comms
@ -167,10 +171,14 @@ impl<T: SolidityCompatibleField> SolidityCompatibleScheme<T> for Marlin {
let mut populate_init_seed = String::new(); let mut populate_init_seed = String::new();
for i in 0..vk.fs_seed.len() / 32 { for i in 0..vk.fs_seed.len() / 32 {
let word_32_bytes = hex::encode(&vk.fs_seed[i * 32..i * 32 + 32]); let word_32_bytes = hex::encode(&vk.fs_seed[i * 32..i * 32 + 32]);
populate_init_seed write!(
.push_str(&format!("init_seed[{}] = 0x{};", i, &word_32_bytes)); populate_init_seed,
"init_seed[{}] = 0x{};",
i, &word_32_bytes
)
.unwrap();
if i < vk.fs_seed.len() / 32 - 1 { if i < vk.fs_seed.len() / 32 - 1 {
populate_init_seed.push_str("\n "); write!(populate_init_seed, "\n ").unwrap();
} }
} }
populate_init_seed populate_init_seed