zec
/
halo2
mirror of https://github.com/zcash/halo2.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Migrate to latest halo2 Circuit APIs 

- The `Circuit` trait now has a `FloorPlanner` associated type.
- `circuit_layout` has been replaced by `CircuitLayout`.
This commit is contained in:
Jack Grigg 2021-07-09 02:56:27 +01:00
parent cc3e1ad0b4
commit d47a7d2105
11 changed files with 113 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Cargo.toml
View File

@ -62,5 +62,5 @@ name = "small"
harness = false
[patch.crates-io]
halo2 = { git = "https://github.com/zcash/halo2.git", rev = "d04b532368d05b505e622f8cac4c0693574fbd93" }
halo2 = { git = "https://github.com/zcash/halo2.git", rev = "d5be50a8488a433a9b20f1127ff1e21f121c5a2c" }
zcash_note_encryption = { git = "https://github.com/zcash/librustzcash.git", rev = "cc533a9da4f6a7209a7be05f82b12a03969152c9" }

8
src/circuit.rs
View File

@ -4,6 +4,7 @@ use std::mem;
use group::Curve;
use halo2::{
circuit::{Layouter, SimpleFloorPlanner},
plonk,
poly::{EvaluationDomain, LagrangeCoeff, Polynomial, Rotation},
transcript::{Blake2bRead, Blake2bWrite},
@ -28,6 +29,11 @@ pub struct Circuit {}
impl plonk::Circuit<pallas::Base> for Circuit {
type Config = ();
type FloorPlanner = SimpleFloorPlanner;
fn without_witnesses(&self) -> Self {
Circuit {}
}
fn configure(meta: &mut plonk::ConstraintSystem<pallas::Base>) -> Self::Config {
// Placeholder so the proving key is correctly built.
@ -42,8 +48,8 @@ impl plonk::Circuit<pallas::Base> for Circuit {
fn synthesize(
&self,
_cs: &mut impl plonk::Assignment<pallas::Base>,
_config: Self::Config,
_layouter: impl Layouter<pallas::Base>,
) -> Result<(), plonk::Error> {
Ok(())
}

16
src/circuit/gadget/ecc.rs
View File

@ -426,9 +426,9 @@ mod tests {
use group::{prime::PrimeCurveAffine, Curve, Group};
use halo2::{
circuit::{layouter::SingleChipLayouter, Layouter},
circuit::{Layouter, SimpleFloorPlanner},
dev::MockProver,
plonk::{Assignment, Circuit, ConstraintSystem, Error},
plonk::{Circuit, ConstraintSystem, Error},
};
use pasta_curves::pallas;
@ -439,6 +439,11 @@ mod tests {
#[allow(non_snake_case)]
impl Circuit<pallas::Base> for MyCircuit {
type Config = EccConfig;
type FloorPlanner = SimpleFloorPlanner;
fn without_witnesses(&self) -> Self {
MyCircuit {}
}
fn configure(meta: &mut ConstraintSystem<pallas::Base>) -> Self::Config {
let advices = [
@ -469,10 +474,9 @@ mod tests {
fn synthesize(
&self,
cs: &mut impl Assignment<pallas::Base>,
config: Self::Config,
mut layouter: impl Layouter<pallas::Base>,
) -> Result<(), Error> {
let mut layouter = SingleChipLayouter::new(cs)?;
let chip = EccChip::construct(config.clone());
// Load 10-bit lookup table. In the Action circuit, this will be
@ -586,6 +590,8 @@ mod tests {
let root = root.titled("Ecc Chip Layout", ("sans-serif", 60)).unwrap();
let circuit = MyCircuit {};
halo2::dev::circuit_layout(&circuit, &root).unwrap();
halo2::dev::CircuitLayout::default()
.render(&circuit, &root)
.unwrap();
}
}

26
src/circuit/gadget/poseidon/pow5t3.rs
View File

@ -603,10 +603,10 @@ mod tests {
use ff::PrimeField;
use halo2::{
arithmetic::FieldExt,
circuit::{layouter, Layouter},
circuit::{Layouter, SimpleFloorPlanner},
dev::MockProver,
pasta::Fp,
plonk::{Assignment, Circuit, ConstraintSystem, Error},
plonk::{Circuit, ConstraintSystem, Error},
};
use pasta_curves::pallas;
@ -620,6 +620,11 @@ mod tests {
impl Circuit<Fp> for PermuteCircuit {
type Config = Pow5T3Config<Fp>;
type FloorPlanner = SimpleFloorPlanner;
fn without_witnesses(&self) -> Self {
PermuteCircuit {}
}
fn configure(meta: &mut ConstraintSystem<Fp>) -> Pow5T3Config<Fp> {
let state = [
@ -633,11 +638,9 @@ mod tests {
fn synthesize(
&self,
cs: &mut impl Assignment<Fp>,
config: Pow5T3Config<Fp>,
mut layouter: impl Layouter<Fp>,
) -> Result<(), Error> {
let mut layouter = layouter::SingleChipLayouter::new(cs)?;
let initial_state = layouter.assign_region(
|| "prepare initial state",
|mut region| {
@ -702,6 +705,7 @@ mod tests {
assert_eq!(prover.verify(), Ok(()))
}
#[derive(Default)]
struct HashCircuit {
message: Option<[Fp; 2]>,
// For the purpose of this test, witness the result.
@ -711,6 +715,11 @@ mod tests {
impl Circuit<Fp> for HashCircuit {
type Config = Pow5T3Config<Fp>;
type FloorPlanner = SimpleFloorPlanner;
fn without_witnesses(&self) -> Self {
Self::default()
}
fn configure(meta: &mut ConstraintSystem<Fp>) -> Pow5T3Config<Fp> {
let state = [
@ -724,10 +733,9 @@ mod tests {
fn synthesize(
&self,
cs: &mut impl Assignment<Fp>,
config: Pow5T3Config<Fp>,
mut layouter: impl Layouter<Fp>,
) -> Result<(), Error> {
let mut layouter = layouter::SingleChipLayouter::<'_, Fp, _>::new(cs)?;
let chip = Pow5T3Chip::construct(config.clone());
let message = layouter.assign_region(
@ -817,6 +825,8 @@ mod tests {
message: None,
output: None,
};
halo2::dev::circuit_layout(&circuit, &root).unwrap();
halo2::dev::CircuitLayout::default()
.render(&circuit, &root)
.unwrap();
}
}

16
src/circuit/gadget/sinsemilla.rs
View File

@ -293,10 +293,10 @@ pub trait HashDomains<C: CurveAffine>: Clone + Debug {
#[cfg(test)]
mod tests {
use halo2::{
circuit::{layouter::SingleChipLayouter, Layouter},
circuit::{Layouter, SimpleFloorPlanner},
dev::MockProver,
pasta::pallas,
plonk::{Assignment, Circuit, ConstraintSystem, Error},
plonk::{Circuit, ConstraintSystem, Error},
};
use super::{
@ -322,6 +322,11 @@ mod tests {
impl Circuit<pallas::Base> for MyCircuit {
type Config = (EccConfig, SinsemillaConfig, SinsemillaConfig);
type FloorPlanner = SimpleFloorPlanner;
fn without_witnesses(&self) -> Self {
MyCircuit {}
}
#[allow(non_snake_case)]
fn configure(meta: &mut ConstraintSystem<pallas::Base>) -> Self::Config {
@ -393,10 +398,9 @@ mod tests {
fn synthesize(
&self,
cs: &mut impl Assignment<pallas::Base>,
config: Self::Config,
mut layouter: impl Layouter<pallas::Base>,
) -> Result<(), Error> {
let mut layouter = SingleChipLayouter::new(cs)?;
let ecc_chip = EccChip::construct(config.0);
// The two `SinsemillaChip`s share the same lookup table.
@ -503,6 +507,8 @@ mod tests {
let root = root.titled("SinsemillaHash", ("sans-serif", 60)).unwrap();
let circuit = MyCircuit {};
halo2::dev::circuit_layout(&circuit, &root).unwrap();
halo2::dev::CircuitLayout::default()
.render(&circuit, &root)
.unwrap();
}
}

14
src/circuit/gadget/sinsemilla/merkle.rs
View File

@ -149,15 +149,16 @@ pub mod tests {
use ff::PrimeFieldBits;
use halo2::{
arithmetic::FieldExt,
circuit::{layouter::SingleChipLayouter, Layouter},
circuit::{Layouter, SimpleFloorPlanner},
dev::MockProver,
pasta::pallas,
plonk::{Assignment, Circuit, ConstraintSystem, Error},
plonk::{Circuit, ConstraintSystem, Error},
};
use rand::random;
use std::convert::TryInto;
#[derive(Default)]
struct MyCircuit {
leaf: Option<pallas::Base>,
leaf_pos: Option<u32>,
@ -166,6 +167,11 @@ pub mod tests {
impl Circuit<pallas::Base> for MyCircuit {
type Config = (MerkleConfig, MerkleConfig);
type FloorPlanner = SimpleFloorPlanner;
fn without_witnesses(&self) -> Self {
Self::default()
}
fn configure(meta: &mut ConstraintSystem<pallas::Base>) -> Self::Config {
let advices = [
@ -239,11 +245,9 @@ pub mod tests {
fn synthesize(
&self,
cs: &mut impl Assignment<pallas::Base>,
config: Self::Config,
mut layouter: impl Layouter<pallas::Base>,
) -> Result<(), Error> {
let mut layouter = SingleChipLayouter::new(cs)?;
// Load generator table (shared across both configs)
SinsemillaChip::load(config.0.sinsemilla_config.clone(), &mut layouter)?;

18
src/circuit/gadget/utilities.rs
View File

@ -135,9 +135,9 @@ mod tests {
use bigint::U256;
use ff::PrimeField;
use halo2::{
circuit::{layouter::SingleChipLayouter, Layouter},
circuit::{Layouter, SimpleFloorPlanner},
dev::{MockProver, VerifyFailure},
plonk::{Assignment, Circuit, ConstraintSystem, Error, Selector},
plonk::{Circuit, ConstraintSystem, Error, Selector},
poly::Rotation,
};
use pasta_curves::pallas;
@ -158,6 +158,11 @@ mod tests {
impl<const RANGE: usize> Circuit<pallas::Base> for MyCircuit<RANGE> {
type Config = Config;
type FloorPlanner = SimpleFloorPlanner;
fn without_witnesses(&self) -> Self {
MyCircuit(self.0)
}
fn configure(meta: &mut ConstraintSystem<pallas::Base>) -> Self::Config {
let selector = meta.selector();
@ -175,11 +180,9 @@ mod tests {
fn synthesize(
&self,
cs: &mut impl Assignment<pallas::Base>,
config: Self::Config,
mut layouter: impl Layouter<pallas::Base>,
) -> Result<(), Error> {
let mut layouter = SingleChipLayouter::new(cs)?;
layouter.assign_region(
|| "range constrain",
|mut region| {
@ -209,10 +212,7 @@ mod tests {
assert_eq!(
prover.verify(),
Err(vec![VerifyFailure::Constraint {
gate_index: 0,
gate_name: "range check",
constraint_index: 0,
constraint_name: "",
constraint: ((0, "range check").into(), 0, "").into(),
row: 0
}])
);

13
src/circuit/gadget/utilities/cond_swap.rs
View File

@ -210,14 +210,15 @@ mod tests {
use super::super::UtilitiesInstructions;
use super::{CondSwapChip, CondSwapConfig, CondSwapInstructions};
use halo2::{
circuit::{layouter::SingleChipLayouter, Layouter},
circuit::{Layouter, SimpleFloorPlanner},
dev::MockProver,
plonk::{Any, Assignment, Circuit, Column, ConstraintSystem, Error},
plonk::{Any, Circuit, Column, ConstraintSystem, Error},
};
use pasta_curves::{arithmetic::FieldExt, pallas::Base};
#[test]
fn cond_swap() {
#[derive(Default)]
struct MyCircuit<F: FieldExt> {
a: Option<F>,
b: Option<F>,
@ -226,6 +227,11 @@ mod tests {
impl<F: FieldExt> Circuit<F> for MyCircuit<F> {
type Config = CondSwapConfig;
type FloorPlanner = SimpleFloorPlanner;
fn without_witnesses(&self) -> Self {
Self::default()
}
fn configure(meta: &mut ConstraintSystem<F>) -> Self::Config {
let advices = [
@ -248,10 +254,9 @@ mod tests {
fn synthesize(
&self,
cs: &mut impl Assignment<F>,
config: Self::Config,
mut layouter: impl Layouter<F>,
) -> Result<(), Error> {
let mut layouter = SingleChipLayouter::new(cs)?;
let chip = CondSwapChip::<F>::construct(config.clone());
// Load the pair and the swap flag into the circuit.

18
src/circuit/gadget/utilities/enable_flag.rs
View File

@ -131,14 +131,15 @@ mod tests {
use super::super::UtilitiesInstructions;
use super::{EnableFlagChip, EnableFlagConfig, EnableFlagInstructions};
use halo2::{
circuit::{layouter::SingleChipLayouter, Layouter},
circuit::{Layouter, SimpleFloorPlanner},
dev::{MockProver, VerifyFailure},
plonk::{Any, Assignment, Circuit, Column, ConstraintSystem, Error},
plonk::{Any, Circuit, Column, ConstraintSystem, Error},
};
use pasta_curves::{arithmetic::FieldExt, pallas::Base};
#[test]
fn enable_flag() {
#[derive(Default)]
struct MyCircuit<F: FieldExt> {
value: Option<F>,
enable_flag: Option<bool>,
@ -146,6 +147,11 @@ mod tests {
impl<F: FieldExt> Circuit<F> for MyCircuit<F> {
type Config = EnableFlagConfig;
type FloorPlanner = SimpleFloorPlanner;
fn without_witnesses(&self) -> Self {
Self::default()
}
fn configure(meta: &mut ConstraintSystem<F>) -> Self::Config {
let advices = [meta.advice_column(), meta.advice_column()];
@ -162,10 +168,9 @@ mod tests {
fn synthesize(
&self,
cs: &mut impl Assignment<F>,
config: Self::Config,
mut layouter: impl Layouter<F>,
) -> Result<(), Error> {
let mut layouter = SingleChipLayouter::new(cs)?;
let chip = EnableFlagChip::<F>::construct(config.clone());
// Load the value and the enable flag into the circuit.
@ -219,10 +224,7 @@ mod tests {
assert_eq!(
prover.verify(),
Err(vec![VerifyFailure::Constraint {
gate_index: 0,
gate_name: "Enable flag",
constraint_index: 0,
constraint_name: "",
constraint: ((0, "Enable flag").into(), 0, "").into(),
row: 1,
}])
);

27
src/circuit/gadget/utilities/lookup_range_check.rs
View File

@ -369,9 +369,9 @@ mod tests {
use crate::spec::lebs2ip;
use ff::{Field, PrimeFieldBits};
use halo2::{
circuit::{layouter::SingleChipLayouter, Layouter},
circuit::{Layouter, SimpleFloorPlanner},
dev::{MockProver, VerifyFailure},
plonk::{Assignment, Circuit, ConstraintSystem, Error},
plonk::{Circuit, ConstraintSystem, Error},
};
use pasta_curves::{arithmetic::FieldExt, pallas};
@ -379,6 +379,7 @@ mod tests {
#[test]
fn lookup_range_check() {
#[derive(Clone, Copy)]
struct MyCircuit<F: FieldExt + PrimeFieldBits> {
num_words: usize,
_marker: PhantomData<F>,
@ -386,6 +387,11 @@ mod tests {
impl<F: FieldExt + PrimeFieldBits> Circuit<F> for MyCircuit<F> {
type Config = LookupRangeCheckConfig<F, K>;
type FloorPlanner = SimpleFloorPlanner;
fn without_witnesses(&self) -> Self {
*self
}
fn configure(meta: &mut ConstraintSystem<F>) -> Self::Config {
let running_sum = meta.advice_column();
@ -404,11 +410,9 @@ mod tests {
fn synthesize(
&self,
cs: &mut impl Assignment<F>,
config: Self::Config,
mut layouter: impl Layouter<F>,
) -> Result<(), Error> {
let mut layouter = SingleChipLayouter::new(cs)?;
// Load table_idx
config.load(&mut layouter)?;
@ -491,6 +495,15 @@ mod tests {
impl<F: FieldExt + PrimeFieldBits> Circuit<F> for MyCircuit<F> {
type Config = LookupRangeCheckConfig<F, K>;
type FloorPlanner = SimpleFloorPlanner;
fn without_witnesses(&self) -> Self {
MyCircuit {
element: None,
num_bits: self.num_bits,
_marker: self._marker,
}
}
fn configure(meta: &mut ConstraintSystem<F>) -> Self::Config {
let running_sum = meta.advice_column();
@ -509,11 +522,9 @@ mod tests {
fn synthesize(
&self,
cs: &mut impl Assignment<F>,
config: Self::Config,
mut layouter: impl Layouter<F>,
) -> Result<(), Error> {
let mut layouter = SingleChipLayouter::new(cs)?;
// Load table_idx
config.load(&mut layouter)?;

13
src/circuit/gadget/utilities/plonk.rs
View File

@ -225,14 +225,15 @@ mod tests {
use super::super::UtilitiesInstructions;
use super::{PLONKChip, PLONKConfig, PLONKInstructions};
use halo2::{
circuit::{layouter::SingleChipLayouter, Layouter},
circuit::{Layouter, SimpleFloorPlanner},
dev::MockProver,
plonk::{Any, Assignment, Circuit, Column, ConstraintSystem, Error},
plonk::{Any, Circuit, Column, ConstraintSystem, Error},
};
use pasta_curves::{arithmetic::FieldExt, pallas::Base};
#[test]
fn plonk_util() {
#[derive(Default)]
struct MyCircuit<F: FieldExt> {
a: Option<F>,
b: Option<F>,
@ -240,6 +241,11 @@ mod tests {
impl<F: FieldExt> Circuit<F> for MyCircuit<F> {
type Config = PLONKConfig;
type FloorPlanner = SimpleFloorPlanner;
fn without_witnesses(&self) -> Self {
Self::default()
}
fn configure(meta: &mut ConstraintSystem<F>) -> Self::Config {
let advices = [
@ -260,10 +266,9 @@ mod tests {
fn synthesize(
&self,
cs: &mut impl Assignment<F>,
config: Self::Config,
mut layouter: impl Layouter<F>,
) -> Result<(), Error> {
let mut layouter = SingleChipLayouter::new(cs)?;
let chip = PLONKChip::<F>::construct(config.clone());
let a = chip.load_private(layouter.namespace(|| "a"), config.a, self.a)?;