,
+ _prng: PhantomData,
+}
+
+impl SaltedMerkleTree
+where
+ Standard: Distribution<::Digest>,
+{
+ // CONSTRUCTORS
+ // --------------------------------------------------------------------------------------------
+
+ pub fn new(leaves: Vec, prng: &mut P) -> Result {
+ if leaves.len() < 2 {
+ return Err(MerkleTreeError::TooFewLeaves(2, leaves.len()));
+ }
+ if !leaves.len().is_power_of_two() {
+ return Err(MerkleTreeError::NumberOfLeavesNotPowerOfTwo(leaves.len()));
+ }
+
+ let num_leaves = leaves.len();
+ let salts: Vec = (0..num_leaves).map(|_| prng.sample(Standard)).collect();
+
+ let salted_leaves: Vec = leaves
+ .iter()
+ .zip(salts.iter())
+ .map(|(leaf, salt)| H::merge(&[*leaf, *salt]))
+ .collect();
+
+ let tree = MerkleTree::new(salted_leaves)?;
+
+ Ok(Self { tree, leaves, salts, _prng: PhantomData })
+ }
+
+ /// Returns the root of the tree.
+ pub fn root(&self) -> &H::Digest {
+ self.tree.root()
+ }
+
+ /// Returns the depth of the tree.
+ pub fn depth(&self) -> usize {
+ self.tree.depth()
+ }
+
+ /// Returns a Merkle proof to a leaf at the specified `index`.
+ pub fn prove(&self, index: usize) -> Result, MerkleTreeError> {
+ let (_, proof) = self.tree.prove(index)?;
+ Ok((self.leaves[index], (self.salts[index], proof)))
+ }
+
+ /// Computes Merkle proofs for the provided indexes, compresses the proofs into a single batch
+ /// and returns the batch proof alongside the leaves at the provided indexes.
+ pub fn prove_batch(
+ &self,
+ indexes: &[usize],
+ ) -> Result, MerkleTreeError> {
+ let (_, proof) = self.tree.prove_batch(indexes)?;
+ let leaves_at_indices = indexes.iter().map(|index| self.leaves[*index]).collect();
+ let salts_at_indices = indexes.iter().map(|index| self.salts[*index]).collect();
+ Ok((leaves_at_indices, (salts_at_indices, proof)))
+ }
+
+ /// Checks whether the `proof` for the given `leaf` at the specified `index` is valid.
+ pub fn verify(
+ root: H::Digest,
+ index: usize,
+ leaf: H::Digest,
+ salt: H::Digest,
+ proof: &[H::Digest],
+ ) -> Result<(), MerkleTreeError> {
+ let salted_leaf = H::merge(&[leaf, salt]);
+ MerkleTree::::verify(root, index, salted_leaf, proof)
+ }
+
+ /// Checks whether the batch proof contains Merkle paths for the of the specified `indexes`.
+ pub fn verify_batch(
+ root: &H::Digest,
+ indexes: &[usize],
+ leaves: &[H::Digest],
+ salts: &[H::Digest],
+ proof: &BatchMerkleProof,
+ ) -> Result<(), MerkleTreeError> {
+ let salted_leaves: Vec = leaves
+ .iter()
+ .zip(salts.iter())
+ .map(|(leaf, salt)| H::merge(&[*leaf, *salt]))
+ .collect();
+
+ MerkleTree::::verify_batch(root, indexes, &salted_leaves, proof)
+ }
+}
+
+impl Distribution> for Standard {
+ fn sample(&self, rng: &mut R) -> ByteDigest<32> {
+ let mut dest = [0; 32];
+ rng.fill_bytes(&mut dest);
+ ByteDigest::new(dest)
+ }
+}
+
+impl VectorCommitment for SaltedMerkleTree
+where
+ Standard: Distribution<::Digest>,
+{
+ type Options = ();
+
+ type Proof = (H::Digest, Vec);
+
+ type MultiProof = (Vec, BatchMerkleProof);
+
+ type Error = MerkleTreeError;
+
+ fn new(items: Vec) -> Result {
+ // TODO: make random
+ let seed = P::Seed::default();
+ let mut prng = P::from_seed(seed);
+ SaltedMerkleTree::new(items, &mut prng)
+ }
+
+ fn with_options(items: Vec, _options: Self::Options) -> Result {
+ // TODO: make random
+ let seed = P::Seed::default();
+ let mut prng = P::from_seed(seed);
+ Self::new(items, &mut prng)
+ }
+
+ fn get_domain_len(&self) -> usize {
+ 1 << self.depth()
+ }
+
+ fn get_proof_domain_len(proof: &Self::Proof) -> usize {
+ proof.1.len()
+ }
+
+ fn get_multiproof_domain_len(proof: &Self::MultiProof) -> usize {
+ 1 << proof.1.depth
+ }
+
+ fn commitment(&self) -> H::Digest {
+ *self.root()
+ }
+
+ fn open(&self, index: usize) -> Result<(H::Digest, Self::Proof), Self::Error> {
+ self.prove(index)
+ }
+
+ fn open_many(
+ &self,
+ indexes: &[usize],
+ ) -> Result<(Vec, Self::MultiProof), Self::Error> {
+ self.prove_batch(indexes)
+ }
+
+ fn verify(
+ commitment: H::Digest,
+ index: usize,
+ item: H::Digest,
+ proof: &Self::Proof,
+ ) -> Result<(), Self::Error> {
+ SaltedMerkleTree::::verify(commitment, index, item, proof.0, &proof.1)
+ }
+
+ fn verify_many(
+ commitment: H::Digest,
+ indexes: &[usize],
+ items: &[H::Digest],
+ proof: &Self::MultiProof,
+ ) -> Result<(), Self::Error> {
+ SaltedMerkleTree::::verify_batch(&commitment, indexes, items, &proof.0, &proof.1)
+ }
+}
diff --git a/crypto/src/merkle/tests.rs b/crypto/src/merkle/tests.rs
index f66c638a2..c6e60aa9d 100644
--- a/crypto/src/merkle/tests.rs
+++ b/crypto/src/merkle/tests.rs
@@ -5,6 +5,7 @@
use math::fields::f128::BaseElement;
use proptest::prelude::*;
+use rand_chacha::ChaCha20Rng;
use super::*;
@@ -254,6 +255,56 @@ fn from_proofs() {
assert_eq!(proof1.depth, proof2.depth);
}
+#[test]
+fn verify_salted() {
+ // depth 4
+ let leaves = Digest256::bytes_as_digests(&LEAVES4).to_vec();
+ let mut prng = ChaCha20Rng::from_entropy();
+ let tree: SaltedMerkleTree = SaltedMerkleTree::new(leaves, &mut prng).unwrap();
+ let (leaf, (salt, proof)) = tree.prove(1).unwrap();
+ assert!(SaltedMerkleTree::::verify(
+ *tree.root(),
+ 1,
+ leaf,
+ salt,
+ &proof
+ )
+ .is_ok());
+
+ let (leaf, (salt, proof)) = tree.prove(2).unwrap();
+ assert!(SaltedMerkleTree::::verify(
+ *tree.root(),
+ 2,
+ leaf,
+ salt,
+ &proof
+ )
+ .is_ok());
+
+ // depth 5
+ let leaf = Digest256::bytes_as_digests(&LEAVES8).to_vec();
+ let tree: SaltedMerkleTree = SaltedMerkleTree::new(leaf, &mut prng).unwrap();
+ let (leaf, (salt, proof)) = tree.prove(1).unwrap();
+ assert!(SaltedMerkleTree::::verify(
+ *tree.root(),
+ 1,
+ leaf,
+ salt,
+ &proof
+ )
+ .is_ok());
+
+ let (leaf, (salt, proof)) = tree.prove(6).unwrap();
+ assert!(SaltedMerkleTree::::verify(
+ *tree.root(),
+ 6,
+ leaf,
+ salt,
+ &proof
+ )
+ .is_ok());
+}
+
proptest! {
#[test]
fn prove_n_verify(tree in random_blake3_merkle_tree(128),
diff --git a/crypto/src/random/default.rs b/crypto/src/random/default.rs
index f5a996404..fa002171d 100644
--- a/crypto/src/random/default.rs
+++ b/crypto/src/random/default.rs
@@ -118,6 +118,22 @@ impl> RandomCoin for DefaultRando
self.counter = 0;
}
+ fn reseed_with_salt(
+ &mut self,
+ data: ::Digest,
+ salt: Option<::Digest>,
+ ) {
+ // TODO: revisit
+ if let Some(salt) = salt {
+ self.seed = H::merge(&[self.seed, data]);
+ self.seed = H::merge(&[self.seed, salt]);
+ self.counter = 0;
+ } else {
+ self.seed = H::merge(&[self.seed, data]);
+ self.counter = 0;
+ }
+ }
+
// PUBLIC ACCESSORS
// --------------------------------------------------------------------------------------------
diff --git a/crypto/src/random/mod.rs b/crypto/src/random/mod.rs
index 7ee540ee5..10ee5d40c 100644
--- a/crypto/src/random/mod.rs
+++ b/crypto/src/random/mod.rs
@@ -38,6 +38,14 @@ pub trait RandomCoin: Sync {
/// Reseeds the coin with the specified data by setting the new seed to hash(`seed` || `data`).
fn reseed(&mut self, data: ::Digest);
+ /// Similar to `Self::reseed` but takes a salt which is not a `None` when zero-knowledge is enabled.
+ /// TODO: Should we remove `Self::reseed`?
+ fn reseed_with_salt(
+ &mut self,
+ data: ::Digest,
+ salt: Option<::Digest>,
+ );
+
/// Computes hash(`seed` || `value`) and returns the number of leading zeros in the resulting
/// value if it is interpreted as an integer in big-endian byte order.
fn check_leading_zeros(&self, value: u64) -> u32;
diff --git a/examples/Cargo.toml b/examples/Cargo.toml
index f86e9ad50..6588e7d07 100644
--- a/examples/Cargo.toml
+++ b/examples/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "examples"
-version = "0.10.0"
+version = "0.11.0"
description = "Examples of using Winterfell STARK prover/verifier"
authors = ["winterfell contributors"]
readme = "README.md"
@@ -26,15 +26,18 @@ default = ["std"]
std = ["core-utils/std", "hex/std", "rand-utils", "winterfell/std"]
[dependencies]
+air = { version = "0.11", path = "../air", package = "winter-air", default-features = false }
blake3 = { version = "1.5", default-features = false }
-core-utils = { version = "0.10", path = "../utils/core", package = "winter-utils", default-features = false }
+core-utils = { version = "0.11", path = "../utils/core", package = "winter-utils", default-features = false }
hex = { version = "0.4", optional = true }
-rand-utils = { version = "0.10", path = "../utils/rand", package = "winter-rand-utils", optional = true }
+rand = { version = "0.8" }
+rand-utils = { version = "0.11", path = "../utils/rand", package = "winter-rand-utils", optional = true }
structopt = { version = "0.3", default-features = false }
tracing = { version = "0.1", default-features = false }
tracing-forest = { version = "0.1", features = ["ansi", "smallvec"], optional = true }
tracing-subscriber = { version = "0.3", features = ["std", "env-filter"] }
-winterfell = { version = "0.10", path = "../winterfell", default-features = false }
+winterfell = { version = "0.11", path = "../winterfell", default-features = false }
+rand_chacha = { version = "0.3", default-features = false }
[dev-dependencies]
criterion = "0.5"
diff --git a/examples/benches/fibonacci.rs b/examples/benches/fibonacci.rs
index 44094beaf..076f2ee2f 100644
--- a/examples/benches/fibonacci.rs
+++ b/examples/benches/fibonacci.rs
@@ -18,7 +18,7 @@ fn fibonacci(c: &mut Criterion) {
group.sample_size(10);
group.measurement_time(Duration::from_secs(20));
- let options = ProofOptions::new(32, 8, 0, FieldExtension::None, 4, 255);
+ let options = ProofOptions::new(32, 8, 0, FieldExtension::None, 4, 255, false);
for &size in SIZES.iter() {
let fib =
diff --git a/examples/benches/rescue.rs b/examples/benches/rescue.rs
index bf6e8cc26..19e3a0815 100644
--- a/examples/benches/rescue.rs
+++ b/examples/benches/rescue.rs
@@ -18,7 +18,7 @@ fn rescue(c: &mut Criterion) {
group.sample_size(10);
group.measurement_time(Duration::from_secs(25));
- let options = ProofOptions::new(32, 32, 0, FieldExtension::None, 4, 255);
+ let options = ProofOptions::new(32, 32, 0, FieldExtension::None, 4, 255, false);
for &size in SIZES.iter() {
let resc = rescue::RescueExample::>::new(size, options.clone());
diff --git a/examples/src/fibonacci/fib2/mod.rs b/examples/src/fibonacci/fib2/mod.rs
index ddc6cf77e..ff6e80680 100644
--- a/examples/src/fibonacci/fib2/mod.rs
+++ b/examples/src/fibonacci/fib2/mod.rs
@@ -6,9 +6,10 @@
use core::marker::PhantomData;
use std::time::Instant;
+use rand::{distributions::Standard, prelude::Distribution};
use tracing::{field, info_span};
use winterfell::{
- crypto::{DefaultRandomCoin, ElementHasher, MerkleTree},
+ crypto::{DefaultRandomCoin, ElementHasher, Hasher, MerkleTree},
math::{fields::f128::BaseElement, FieldElement},
Proof, ProofOptions, Prover, Trace, VerifierError,
};
@@ -88,6 +89,7 @@ impl FibExample {
impl Example for FibExample
where
H: ElementHasher + Sync,
+ Standard: Distribution<::Digest>,
{
fn prove(&self) -> Proof {
println!(
@@ -108,7 +110,7 @@ where
});
// generate the proof
- prover.prove(trace).unwrap()
+ prover.prove(trace, None).unwrap()
}
fn verify(&self, proof: Proof) -> Result<(), VerifierError> {
diff --git a/examples/src/fibonacci/fib2/prover.rs b/examples/src/fibonacci/fib2/prover.rs
index 99d48f004..91070896b 100644
--- a/examples/src/fibonacci/fib2/prover.rs
+++ b/examples/src/fibonacci/fib2/prover.rs
@@ -3,10 +3,12 @@
// This source code is licensed under the MIT license found in the
// LICENSE file in the root directory of this source tree.
+use air::ZkParameters;
use winterfell::{
- crypto::MerkleTree, matrix::ColMatrix, AuxRandElements, ConstraintCompositionCoefficients,
- DefaultConstraintEvaluator, DefaultTraceLde, PartitionOptions, StarkDomain, Trace, TraceInfo,
- TracePolyTable, TraceTable,
+ crypto::MerkleTree, matrix::ColMatrix, AuxRandElements, CompositionPoly, CompositionPolyTrace,
+ ConstraintCompositionCoefficients, DefaultConstraintCommitment, DefaultConstraintEvaluator,
+ DefaultTraceLde, MockPrng, PartitionOptions, StarkDomain, Trace, TraceInfo, TracePolyTable,
+ TraceTable,
};
use super::{
@@ -60,8 +62,11 @@ where
type RandomCoin = DefaultRandomCoin;
type TraceLde> =
DefaultTraceLde;
+ type ConstraintCommitment> =
+ DefaultConstraintCommitment;
type ConstraintEvaluator<'a, E: FieldElement> =
DefaultConstraintEvaluator<'a, Self::Air, E>;
+ type ZkPrng = MockPrng;
fn get_pub_inputs(&self, trace: &Self::Trace) -> BaseElement {
let last_step = trace.length() - 1;
@@ -78,8 +83,10 @@ where
main_trace: &ColMatrix,
domain: &StarkDomain,
partition_option: PartitionOptions,
+ zk_parameters: Option,
+ prng: &mut Option,
) -> (Self::TraceLde, TracePolyTable) {
- DefaultTraceLde::new(trace_info, main_trace, domain, partition_option)
+ DefaultTraceLde::new(trace_info, main_trace, domain, partition_option, zk_parameters, prng)
}
fn new_evaluator<'a, E: FieldElement>(
@@ -90,4 +97,23 @@ where
) -> Self::ConstraintEvaluator<'a, E> {
DefaultConstraintEvaluator::new(air, aux_rand_elements, composition_coefficients)
}
+
+ fn build_constraint_commitment>(
+ &self,
+ composition_poly_trace: CompositionPolyTrace,
+ num_constraint_composition_columns: usize,
+ domain: &StarkDomain,
+ partition_options: PartitionOptions,
+ zk_parameters: Option,
+ prng: &mut Option,
+ ) -> (Self::ConstraintCommitment, CompositionPoly) {
+ DefaultConstraintCommitment::new(
+ composition_poly_trace,
+ num_constraint_composition_columns,
+ domain,
+ partition_options,
+ zk_parameters,
+ prng,
+ )
+ }
}
diff --git a/examples/src/fibonacci/fib8/mod.rs b/examples/src/fibonacci/fib8/mod.rs
index 322079c21..fabc71055 100644
--- a/examples/src/fibonacci/fib8/mod.rs
+++ b/examples/src/fibonacci/fib8/mod.rs
@@ -6,9 +6,10 @@
use core::marker::PhantomData;
use std::time::Instant;
+use rand::{distributions::Standard, prelude::Distribution};
use tracing::{field, info_span};
use winterfell::{
- crypto::{DefaultRandomCoin, ElementHasher, MerkleTree},
+ crypto::{DefaultRandomCoin, ElementHasher, Hasher, MerkleTree},
math::{fields::f128::BaseElement, FieldElement},
Proof, ProofOptions, Prover, Trace, VerifierError,
};
@@ -88,6 +89,7 @@ impl Fib8Example {
impl Example for Fib8Example
where
H: ElementHasher + Sync,
+ Standard: Distribution<::Digest>,
{
fn prove(&self) -> Proof {
println!(
@@ -108,7 +110,7 @@ where
});
// generate the proof
- prover.prove(trace).unwrap()
+ prover.prove(trace, None).unwrap()
}
fn verify(&self, proof: Proof) -> Result<(), VerifierError> {
diff --git a/examples/src/fibonacci/fib8/prover.rs b/examples/src/fibonacci/fib8/prover.rs
index 64182978c..5f4e1d8aa 100644
--- a/examples/src/fibonacci/fib8/prover.rs
+++ b/examples/src/fibonacci/fib8/prover.rs
@@ -3,10 +3,12 @@
// This source code is licensed under the MIT license found in the
// LICENSE file in the root directory of this source tree.
+use air::ZkParameters;
use winterfell::{
- crypto::MerkleTree, matrix::ColMatrix, AuxRandElements, ConstraintCompositionCoefficients,
- DefaultConstraintEvaluator, DefaultTraceLde, PartitionOptions, StarkDomain, Trace, TraceInfo,
- TracePolyTable, TraceTable,
+ crypto::MerkleTree, matrix::ColMatrix, AuxRandElements, CompositionPoly, CompositionPolyTrace,
+ ConstraintCompositionCoefficients, DefaultConstraintCommitment, DefaultConstraintEvaluator,
+ DefaultTraceLde, MockPrng, PartitionOptions, StarkDomain, Trace, TraceInfo, TracePolyTable,
+ TraceTable,
};
use super::{
@@ -75,8 +77,11 @@ where
type RandomCoin = DefaultRandomCoin;
type TraceLde> =
DefaultTraceLde;
+ type ConstraintCommitment> =
+ DefaultConstraintCommitment;
type ConstraintEvaluator<'a, E: FieldElement> =
DefaultConstraintEvaluator<'a, Self::Air, E>;
+ type ZkPrng = MockPrng;
fn get_pub_inputs(&self, trace: &Self::Trace) -> BaseElement {
let last_step = trace.length() - 1;
@@ -93,8 +98,10 @@ where
main_trace: &ColMatrix,
domain: &StarkDomain,
partition_option: PartitionOptions,
+ zk_parameters: Option,
+ prng: &mut Option,
) -> (Self::TraceLde, TracePolyTable) {
- DefaultTraceLde::new(trace_info, main_trace, domain, partition_option)
+ DefaultTraceLde::new(trace_info, main_trace, domain, partition_option, zk_parameters, prng)
}
fn new_evaluator<'a, E: FieldElement>(
@@ -105,4 +112,23 @@ where
) -> Self::ConstraintEvaluator<'a, E> {
DefaultConstraintEvaluator::new(air, aux_rand_elements, composition_coefficients)
}
+
+ fn build_constraint_commitment>(
+ &self,
+ composition_poly_trace: CompositionPolyTrace,
+ num_constraint_composition_columns: usize,
+ domain: &StarkDomain,
+ partition_options: PartitionOptions,
+ zk_parameters: Option,
+ prng: &mut Option,
+ ) -> (Self::ConstraintCommitment, CompositionPoly) {
+ DefaultConstraintCommitment::new(
+ composition_poly_trace,
+ num_constraint_composition_columns,
+ domain,
+ partition_options,
+ zk_parameters,
+ prng,
+ )
+ }
}
diff --git a/examples/src/fibonacci/fib_small/mod.rs b/examples/src/fibonacci/fib_small/mod.rs
index 672605ac4..05b7b3e9e 100644
--- a/examples/src/fibonacci/fib_small/mod.rs
+++ b/examples/src/fibonacci/fib_small/mod.rs
@@ -6,9 +6,10 @@
use core::marker::PhantomData;
use std::time::Instant;
+use rand::{distributions::Standard, prelude::Distribution};
use tracing::{field, info_span};
use winterfell::{
- crypto::{DefaultRandomCoin, ElementHasher, MerkleTree},
+ crypto::{DefaultRandomCoin, ElementHasher, Hasher, MerkleTree},
math::{fields::f64::BaseElement, FieldElement},
Proof, ProofOptions, Prover, Trace, VerifierError,
};
@@ -99,6 +100,7 @@ impl FibExample {
impl Example for FibExample
where
H: ElementHasher + Sync,
+ Standard: Distribution<::Digest>,
{
fn prove(&self) -> Proof {
println!(
@@ -119,7 +121,7 @@ where
});
// generate the proof
- prover.prove(trace).unwrap()
+ prover.prove(trace, None).unwrap()
}
fn verify(&self, proof: Proof) -> Result<(), VerifierError> {
diff --git a/examples/src/fibonacci/fib_small/prover.rs b/examples/src/fibonacci/fib_small/prover.rs
index 553988064..4b4cc6860 100644
--- a/examples/src/fibonacci/fib_small/prover.rs
+++ b/examples/src/fibonacci/fib_small/prover.rs
@@ -2,10 +2,12 @@
//
// This source code is licensed under the MIT license found in the
// LICENSE file in the root directory of this source tree.
+use air::ZkParameters;
use winterfell::{
- crypto::MerkleTree, matrix::ColMatrix, AuxRandElements, ConstraintCompositionCoefficients,
- DefaultConstraintEvaluator, DefaultTraceLde, PartitionOptions, StarkDomain, Trace, TraceInfo,
- TracePolyTable, TraceTable,
+ crypto::MerkleTree, matrix::ColMatrix, AuxRandElements, CompositionPoly, CompositionPolyTrace,
+ ConstraintCompositionCoefficients, DefaultConstraintCommitment, DefaultConstraintEvaluator,
+ DefaultTraceLde, MockPrng, PartitionOptions, StarkDomain, Trace, TraceInfo, TracePolyTable,
+ TraceTable,
};
use super::{
@@ -65,8 +67,11 @@ where
type RandomCoin = DefaultRandomCoin;
type TraceLde> =
DefaultTraceLde;
+ type ConstraintCommitment> =
+ DefaultConstraintCommitment;
type ConstraintEvaluator<'a, E: FieldElement> =
DefaultConstraintEvaluator<'a, Self::Air, E>;
+ type ZkPrng = MockPrng;
fn get_pub_inputs(&self, trace: &Self::Trace) -> BaseElement {
let last_step = trace.length() - 1;
@@ -83,8 +88,10 @@ where
main_trace: &ColMatrix,
domain: &StarkDomain,
partition_option: PartitionOptions,
+ zk_parameters: Option,
+ prng: &mut Option,
) -> (Self::TraceLde, TracePolyTable) {
- DefaultTraceLde::new(trace_info, main_trace, domain, partition_option)
+ DefaultTraceLde::new(trace_info, main_trace, domain, partition_option, zk_parameters, prng)
}
fn new_evaluator<'a, E: FieldElement>(
@@ -95,4 +102,23 @@ where
) -> Self::ConstraintEvaluator<'a, E> {
DefaultConstraintEvaluator::new(air, aux_rand_elements, composition_coefficients)
}
+
+ fn build_constraint_commitment>(
+ &self,
+ composition_poly_trace: CompositionPolyTrace,
+ num_constraint_composition_columns: usize,
+ domain: &StarkDomain,
+ partition_options: PartitionOptions,
+ zk_parameters: Option,
+ prng: &mut Option,
+ ) -> (Self::ConstraintCommitment, CompositionPoly) {
+ DefaultConstraintCommitment::new(
+ composition_poly_trace,
+ num_constraint_composition_columns,
+ domain,
+ partition_options,
+ zk_parameters,
+ prng,
+ )
+ }
}
diff --git a/examples/src/fibonacci/mulfib2/mod.rs b/examples/src/fibonacci/mulfib2/mod.rs
index d7b3e11d8..a999f6ebd 100644
--- a/examples/src/fibonacci/mulfib2/mod.rs
+++ b/examples/src/fibonacci/mulfib2/mod.rs
@@ -6,9 +6,10 @@
use core::marker::PhantomData;
use std::time::Instant;
+use rand::{distributions::Standard, prelude::Distribution};
use tracing::{field, info_span};
use winterfell::{
- crypto::{DefaultRandomCoin, ElementHasher, MerkleTree},
+ crypto::{DefaultRandomCoin, ElementHasher, Hasher, MerkleTree},
math::{fields::f128::BaseElement, FieldElement},
Proof, ProofOptions, Prover, Trace, VerifierError,
};
@@ -87,6 +88,7 @@ impl MulFib2Example {
impl Example for MulFib2Example
where
H: ElementHasher + Sync,
+ Standard: Distribution<::Digest>,
{
fn prove(&self) -> Proof {
let sequence_length = self.sequence_length;
@@ -108,7 +110,7 @@ where
});
// generate the proof
- prover.prove(trace).unwrap()
+ prover.prove(trace, None).unwrap()
}
fn verify(&self, proof: Proof) -> Result<(), VerifierError> {
diff --git a/examples/src/fibonacci/mulfib2/prover.rs b/examples/src/fibonacci/mulfib2/prover.rs
index 4c99187bf..5356f4a29 100644
--- a/examples/src/fibonacci/mulfib2/prover.rs
+++ b/examples/src/fibonacci/mulfib2/prover.rs
@@ -3,10 +3,12 @@
// This source code is licensed under the MIT license found in the
// LICENSE file in the root directory of this source tree.
+use air::ZkParameters;
use winterfell::{
- crypto::MerkleTree, matrix::ColMatrix, AuxRandElements, ConstraintCompositionCoefficients,
- DefaultConstraintEvaluator, DefaultTraceLde, PartitionOptions, StarkDomain, Trace, TraceInfo,
- TracePolyTable, TraceTable,
+ crypto::MerkleTree, matrix::ColMatrix, AuxRandElements, CompositionPoly, CompositionPolyTrace,
+ ConstraintCompositionCoefficients, DefaultConstraintCommitment, DefaultConstraintEvaluator,
+ DefaultTraceLde, MockPrng, PartitionOptions, StarkDomain, Trace, TraceInfo, TracePolyTable,
+ TraceTable,
};
use super::{
@@ -56,8 +58,11 @@ where
type RandomCoin = DefaultRandomCoin;
type TraceLde> =
DefaultTraceLde;
+ type ConstraintCommitment> =
+ DefaultConstraintCommitment;
type ConstraintEvaluator<'a, E: FieldElement> =
DefaultConstraintEvaluator<'a, Self::Air, E>;
+ type ZkPrng = MockPrng;
fn get_pub_inputs(&self, trace: &Self::Trace) -> BaseElement {
let last_step = trace.length() - 1;
@@ -74,8 +79,10 @@ where
main_trace: &ColMatrix,
domain: &StarkDomain,
partition_option: PartitionOptions,
+ zk_parameters: Option,
+ prng: &mut Option,
) -> (Self::TraceLde, TracePolyTable) {
- DefaultTraceLde::new(trace_info, main_trace, domain, partition_option)
+ DefaultTraceLde::new(trace_info, main_trace, domain, partition_option, zk_parameters, prng)
}
fn new_evaluator<'a, E: FieldElement>(
@@ -86,4 +93,23 @@ where
) -> Self::ConstraintEvaluator<'a, E> {
DefaultConstraintEvaluator::new(air, aux_rand_elements, composition_coefficients)
}
+
+ fn build_constraint_commitment>(
+ &self,
+ composition_poly_trace: CompositionPolyTrace,
+ num_constraint_composition_columns: usize,
+ domain: &StarkDomain,
+ partition_options: PartitionOptions,
+ zk_parameters: Option,
+ prng: &mut Option,
+ ) -> (Self::ConstraintCommitment, CompositionPoly) {
+ DefaultConstraintCommitment::new(
+ composition_poly_trace,
+ num_constraint_composition_columns,
+ domain,
+ partition_options,
+ zk_parameters,
+ prng,
+ )
+ }
}
diff --git a/examples/src/fibonacci/mulfib8/mod.rs b/examples/src/fibonacci/mulfib8/mod.rs
index 43bd27be0..65341d136 100644
--- a/examples/src/fibonacci/mulfib8/mod.rs
+++ b/examples/src/fibonacci/mulfib8/mod.rs
@@ -6,9 +6,10 @@
use core::marker::PhantomData;
use std::time::Instant;
+use rand::{distributions::Standard, prelude::Distribution};
use tracing::{field, info_span};
use winterfell::{
- crypto::{DefaultRandomCoin, ElementHasher, MerkleTree},
+ crypto::{DefaultRandomCoin, ElementHasher, Hasher, MerkleTree},
math::{fields::f128::BaseElement, FieldElement},
Proof, ProofOptions, Prover, Trace, VerifierError,
};
@@ -88,6 +89,7 @@ impl
-
-
+
+
A STARK prover and verifier for arbitrary computations.
@@ -270,6 +270,8 @@ impl Prover for WorkProver {
type TraceLde