arnaucube/fri-commitment
1
1
Fork 0
mirror of https://github.com/arnaucube/fri-commitment.git synced 2026-01-12 08:51:32 +01:00
Code Issues Projects Releases Wiki Activity

Abstract hash function, upgrade to arkworks v0.4.0

Browse Source
This commit is contained in:
arnaucube
2023-03-21 20:24:18 +01:00
parent 5c56460a06
commit 47409275b0
4 changed files with 102 additions and 155 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
Cargo.toml
View File

@@ -9,18 +9,13 @@ repository = "https://github.com/arnaucube/fri-commitment"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
ark-std = "0.3.0"
ark-ff = "0.3.0"
ark-poly = "0.3.0"
ark-bn254 = { version = "^0.3.0", default-features = false }
ark-ed-on-bn254 = { version = "^0.3.0", default-features = true }
ark-crypto-primitives = { version = "^0.3.0", default-features = true }
ark-std = "0.4.0"
ark-ff = "0.4.0"
ark-poly = "0.4.0"
ark-bn254 = { version = "0.4.0", default-features = false }
ark-ed-on-bn254 = { version = "0.4.0", default-features = true }
ark-crypto-primitives = { version = "0.4.0", default-features = true }
ark-serialize = { version = "0.4.0", default-features = false, features = [ "derive" ] }
rand = { version = "0.8", features = [ "std", "std_rng" ] }
# poseidon related
arkworks-utils = { git = "https://github.com/aragonzkresearch/arkworks-gadgets", name="arkworks-utils", features=["poseidon_bn254_x5_4"] }
arkworks-native-gadgets = { git = "https://github.com/aragonzkresearch/arkworks-gadgets", name="arkworks-native-gadgets"}
# transcript related
sha3 = "0.10.6"
merlin = { version = "3.0.0" }
ark-serialize = { version = "^0.3.0", default-features = false, features = [ "derive" ] }

25
src/lib.rs
View File

@@ -3,13 +3,13 @@
#![allow(non_upper_case_globals)]
pub mod merkletree;
use merkletree::MerkleTreePoseidon as MT;
use merkletree::{Hash, MerkleTree};
pub mod transcript;
use transcript::Transcript;
use ark_ff::PrimeField;
use ark_poly::{
univariate::DensePolynomial, EvaluationDomain, GeneralEvaluationDomain, UVPolynomial,
univariate::DensePolynomial, DenseUVPolynomial, EvaluationDomain, GeneralEvaluationDomain,
};
use ark_std::cfg_into_iter;
@@ -19,20 +19,22 @@ use ark_std::ops::Mul;
// rho^-1
const rho1: usize = 8; // WIP
pub struct FRI_LDT<F: PrimeField, P: UVPolynomial<F>> {
pub struct FRI_LDT<F: PrimeField, P: DenseUVPolynomial<F>, H: Hash<F>> {
_f: PhantomData<F>,
_poly: PhantomData<P>,
_h: PhantomData<H>,
}
impl<F: PrimeField, P: UVPolynomial<F>> FRI_LDT<F, P> {
impl<F: PrimeField, P: DenseUVPolynomial<F>, H: Hash<F>> FRI_LDT<F, P, H> {
pub fn new() -> Self {
Self {
_f: PhantomData,
_poly: PhantomData,
_h: PhantomData,
}
}
pub fn split(p: &P) -> (P, P) {
fn split(p: &P) -> (P, P) {
// let d = p.degree() + 1;
let d = p.coeffs().len();
if (d != 0) && (d & (d - 1) != 0) {
@@ -57,7 +59,7 @@ impl<F: PrimeField, P: UVPolynomial<F>> FRI_LDT<F, P> {
let d = p.degree();
let mut commitments: Vec<F> = Vec::new();
let mut mts: Vec<MT<F>> = Vec::new();
let mut mts: Vec<MerkleTree<F, H>> = Vec::new();
// f_0(x) = fL_0(x^2) + x fR_0(x^2)
let mut f_i1 = p.clone();
@@ -85,8 +87,8 @@ impl<F: PrimeField, P: UVPolynomial<F>> FRI_LDT<F, P> {
.map(|k| f_i1.evaluate(&eval_sub_domain.element(k)))
.collect();
// commit to f_{i+1}(x) = fL_i(x) + alpha_i * fR_i(x)
let (cm_i, mt_i) = MT::commit(&subdomain_evaluations); // commit to the evaluation domain instead
// commit to f_{i+1}(x) = fL_i(x) + alpha_i * fR_i(x), commit to the evaluation domain
let (cm_i, mt_i) = MerkleTree::<F, H>::commit(&subdomain_evaluations);
commitments.push(cm_i);
mts.push(mt_i);
transcript.add(b"root_i", &cm_i);
@@ -181,7 +183,7 @@ impl<F: PrimeField, P: UVPolynomial<F>> FRI_LDT<F, P> {
transcript.add(b"f_i(-z^{2^i})", &evals[i + 1]);
// check commitment opening
if !MT::verify(
if !MerkleTree::<F, H>::verify(
commitments[i_z],
F::from(z_pos as u32),
evals[i],
@@ -220,6 +222,7 @@ mod tests {
use ark_poly::univariate::DensePolynomial;
use ark_poly::Polynomial;
use ark_std::log2;
use merkletree::Keccak256Hash;
#[test]
fn test_split() {
@@ -228,7 +231,7 @@ mod tests {
let p = DensePolynomial::<Fr>::rand(deg, &mut rng);
assert_eq!(p.degree(), deg);
type FRID = FRI_LDT<Fr, DensePolynomial<Fr>>;
type FRID = FRI_LDT<Fr, DensePolynomial<Fr>, Keccak256Hash<Fr>>;
let (pL, pR) = FRID::split(&p);
// check that f(z) == fL(x^2) + x * fR(x^2), for a rand z
@@ -248,7 +251,7 @@ mod tests {
assert_eq!(p.degree(), deg);
// println!("p {:?}", p);
type FRID = FRI_LDT<Fr, DensePolynomial<Fr>>;
type FRID = FRI_LDT<Fr, DensePolynomial<Fr>, Keccak256Hash<Fr>>;
let (commitments, mtproofs, evals, constvals) = FRID::prove(&p);
// commitments contains the commitments to each f_0, f_1, ..., f_n, with n=log2(d)

203
src/merkletree.rs
View File

@@ -4,40 +4,59 @@
// https://github.com/vocdoni/arbo).
use ark_ff::{BigInteger, PrimeField};
use ark_serialize::CanonicalSerialize;
use ark_std::log2;
use arkworks_native_gadgets::poseidon;
use arkworks_native_gadgets::poseidon::FieldHasher;
use arkworks_utils::{
bytes_matrix_to_f, bytes_vec_to_f, poseidon_params::setup_poseidon_params, Curve,
};
use ark_std::marker::PhantomData;
use sha3::{Digest, Keccak256};
pub struct Params<F: PrimeField> {
pub poseidon_hash: poseidon::Poseidon<F>,
// abstraction to set the hash function used
pub trait Hash<F>: Clone {
fn hash(_in: &[F]) -> F;
}
#[derive(Clone, Copy, Debug)]
pub struct Keccak256Hash<F: PrimeField> {
phantom: PhantomData<F>,
}
impl<F: PrimeField> Hash<F> for Keccak256Hash<F> {
fn hash(_in: &[F]) -> F {
let mut buf = vec![];
_in.serialize_uncompressed(&mut buf).unwrap();
let mut h = Keccak256::default();
h.update(buf);
let r = h.finalize();
let out = F::from_le_bytes_mod_order(&r);
out
}
}
#[derive(Clone, Debug)]
pub struct Node<F: PrimeField> {
pub struct Node<F: PrimeField, H: Hash<F>> {
phantom: PhantomData<H>,
hash: F,
left: Option<Box<Node<F>>>,
right: Option<Box<Node<F>>>,
left: Option<Box<Node<F, H>>>,
right: Option<Box<Node<F, H>>>,
value: Option<F>,
}
impl<F: PrimeField> Node<F> {
pub fn new_leaf(params: &Params<F>, v: F) -> Self {
let h = params.poseidon_hash.hash(&[v]).unwrap();
impl<F: PrimeField, H: Hash<F>> Node<F, H> {
pub fn new_leaf(v: F) -> Self {
let h = H::hash(&[v]);
Self {
phantom: PhantomData::<H>,
hash: h,
left: None,
right: None,
value: Some(v),
}
}
pub fn new_node(params: &Params<F>, l: Self, r: Self) -> Self {
pub fn new_node(l: Self, r: Self) -> Self {
let left = Box::new(l);
let right = Box::new(r);
let hash = params.poseidon_hash.hash(&[left.hash, right.hash]).unwrap();
let hash = H::hash(&[left.hash, right.hash]);
Self {
phantom: PhantomData::<H>,
hash,
left: Some(left),
right: Some(right),
@@ -46,40 +65,39 @@ impl<F: PrimeField> Node<F> {
}
}
pub struct MerkleTree<F: PrimeField> {
pub root: Node<F>,
pub struct MerkleTree<F: PrimeField, H: Hash<F>> {
pub root: Node<F, H>,
nlevels: u32,
}
impl<F: PrimeField> MerkleTree<F> {
pub fn setup(poseidon_hash: &poseidon::Poseidon<F>) -> Params<F> {
Params {
poseidon_hash: poseidon_hash.clone(),
}
}
pub fn new(params: &Params<F>, values: Vec<F>) -> Self {
impl<F: PrimeField, H: Hash<F>> MerkleTree<F, H> {
pub fn commit(values: &[F]) -> (F, Self) {
// for the moment assume that values length is a power of 2.
if (values.len() != 0) && (values.len() & (values.len() - 1) != 0) {
panic!("values.len() should be a power of 2");
}
// prepare the leafs
let mut leaf_nodes: Vec<Node<F>> = Vec::new();
let mut leaf_nodes: Vec<Node<F, H>> = Vec::new();
for i in 0..values.len() {
let node = Node::<F>::new_leaf(&params, values[i]);
let node = Node::<F, H>::new_leaf(values[i]);
leaf_nodes.push(node);
}
// go up from the leafs to the root
let top_nodes = Self::up_from_nodes(&params, leaf_nodes);
let top_nodes = Self::up_from_nodes(leaf_nodes);
(
top_nodes[0].hash,
Self {
root: top_nodes[0].clone(),
nlevels: log2(values.len()),
},
)
}
}
fn up_from_nodes(params: &Params<F>, nodes: Vec<Node<F>>) -> Vec<Node<F>> {
fn up_from_nodes(nodes: Vec<Node<F, H>>) -> Vec<Node<F, H>> {
if nodes.len() == 0 {
return [Node::<F> {
return [Node::<F, H> {
phantom: PhantomData::<H>,
hash: F::from(0_u32),
left: None,
right: None,
@@ -90,22 +108,22 @@ impl<F: PrimeField> MerkleTree<F> {
if nodes.len() == 1 {
return nodes;
}
let mut next_level_nodes: Vec<Node<F>> = Vec::new();
let mut next_level_nodes: Vec<Node<F, H>> = Vec::new();
for i in (0..nodes.len()).step_by(2) {
let node = Node::<F>::new_node(&params, nodes[i].clone(), nodes[i + 1].clone());
let node = Node::<F, H>::new_node(nodes[i].clone(), nodes[i + 1].clone());
next_level_nodes.push(node);
}
return Self::up_from_nodes(params, next_level_nodes);
return Self::up_from_nodes(next_level_nodes);
}
fn get_path(num_levels: u32, value: F) -> Vec<bool> {
let value_bytes = value.into_repr().to_bytes_le();
let value_bytes = value.into_bigint().to_bytes_le();
let mut path = Vec::new();
for i in 0..num_levels {
path.push(value_bytes[(i / 8) as usize] & (1 << (i % 8)) != 0);
}
path
}
pub fn gen_proof(&self, index: F) -> Vec<F> {
pub fn open(&self, index: F) -> Vec<F> {
// start from root, and go down to the index, while getting the siblings at each level
let path = Self::get_path(self.nlevels, index);
// reverse path as we're going from up to down
@@ -114,7 +132,7 @@ impl<F: PrimeField> MerkleTree<F> {
siblings = Self::go_down(path_inv, self.root.clone(), siblings);
return siblings;
}
fn go_down(path: Vec<bool>, node: Node<F>, mut siblings: Vec<F>) -> Vec<F> {
fn go_down(path: Vec<bool>, node: Node<F, H>, mut siblings: Vec<F>) -> Vec<F> {
if !node.value.is_none() {
return siblings;
}
@@ -126,20 +144,14 @@ impl<F: PrimeField> MerkleTree<F> {
return Self::go_down(path[1..].to_vec(), *node.right.unwrap(), siblings);
}
}
pub fn verify(params: &Params<F>, root: F, index: F, value: F, siblings: Vec<F>) -> bool {
let mut h = params.poseidon_hash.hash(&[value]).unwrap();
pub fn verify(root: F, index: F, value: F, siblings: Vec<F>) -> bool {
let mut h = H::hash(&[value]);
let path = Self::get_path(siblings.len() as u32, index);
for i in 0..siblings.len() {
if !path[i] {
h = params
.poseidon_hash
.hash(&[h, siblings[siblings.len() - 1 - i]])
.unwrap();
h = H::hash(&[h, siblings[siblings.len() - 1 - i]]);
} else {
h = params
.poseidon_hash
.hash(&[siblings[siblings.len() - 1 - i], h])
.unwrap();
h = H::hash(&[siblings[siblings.len() - 1 - i], h]);
}
}
if h == root {
@@ -149,47 +161,6 @@ impl<F: PrimeField> MerkleTree<F> {
}
}
pub struct MerkleTreePoseidon<F: PrimeField>(MerkleTree<F>);
impl<F: PrimeField> MerkleTreePoseidon<F> {
pub fn commit(values: &[F]) -> (F, Self) {
let poseidon_params = poseidon_setup_params::<F>(Curve::Bn254, 5, 4);
let poseidon_hash = poseidon::Poseidon::new(poseidon_params);
let params = MerkleTree::setup(&poseidon_hash);
let mt = MerkleTree::new(&params, values.to_vec());
(mt.root.hash, MerkleTreePoseidon(mt))
}
pub fn open(&self, index: F) -> Vec<F> {
self.0.gen_proof(index)
}
pub fn verify(root: F, index: F, value: F, siblings: Vec<F>) -> bool {
let poseidon_params = poseidon_setup_params::<F>(Curve::Bn254, 5, 4);
let poseidon_hash = poseidon::Poseidon::new(poseidon_params);
let params = MerkleTree::setup(&poseidon_hash);
MerkleTree::verify(&params, root, index, value, siblings)
}
}
pub fn poseidon_setup_params<F: PrimeField>(
curve: Curve,
exp: i8,
width: u8,
) -> poseidon::PoseidonParameters<F> {
let pos_data = setup_poseidon_params(curve, exp, width).unwrap();
let mds_f = bytes_matrix_to_f(&pos_data.mds);
let rounds_f = bytes_vec_to_f(&pos_data.rounds);
poseidon::PoseidonParameters {
mds_matrix: mds_f,
round_keys: rounds_f,
full_rounds: pos_data.full_rounds,
partial_rounds: pos_data.partial_rounds,
sbox: poseidon::sbox::PoseidonSbox(pos_data.exp),
width: pos_data.width,
}
}
#[cfg(test)]
mod tests {
use super::*;
@@ -199,47 +170,41 @@ mod tests {
#[test]
fn test_path() {
assert_eq!(
MerkleTree::get_path(8, Fr::from(0_u32)),
MerkleTree::<Fr, Keccak256Hash<Fr>>::get_path(8, Fr::from(0_u32)),
[false, false, false, false, false, false, false, false]
);
assert_eq!(
MerkleTree::get_path(8, Fr::from(1_u32)),
MerkleTree::<Fr, Keccak256Hash<Fr>>::get_path(8, Fr::from(1_u32)),
[true, false, false, false, false, false, false, false]
);
assert_eq!(
MerkleTree::get_path(8, Fr::from(2_u32)),
MerkleTree::<Fr, Keccak256Hash<Fr>>::get_path(8, Fr::from(2_u32)),
[false, true, false, false, false, false, false, false]
);
assert_eq!(
MerkleTree::get_path(8, Fr::from(3_u32)),
MerkleTree::<Fr, Keccak256Hash<Fr>>::get_path(8, Fr::from(3_u32)),
[true, true, false, false, false, false, false, false]
);
assert_eq!(
MerkleTree::get_path(8, Fr::from(254_u32)),
MerkleTree::<Fr, Keccak256Hash<Fr>>::get_path(8, Fr::from(254_u32)),
[false, true, true, true, true, true, true, true]
);
assert_eq!(
MerkleTree::get_path(8, Fr::from(255_u32)),
MerkleTree::<Fr, Keccak256Hash<Fr>>::get_path(8, Fr::from(255_u32)),
[true, true, true, true, true, true, true, true]
);
}
#[test]
fn test_new_empty_tree() {
let poseidon_params = poseidon_setup_params::<Fr>(Curve::Bn254, 5, 4);
let poseidon_hash = poseidon::Poseidon::new(poseidon_params);
let params = MerkleTree::setup(&poseidon_hash);
let mt = MerkleTree::new(&params, Vec::new());
let (root, mt) = MerkleTree::<Fr, Keccak256Hash<Fr>>::commit(&[]);
assert_eq!(mt.root.hash, Fr::from(0_u32));
assert_eq!(root, Fr::from(0_u32));
}
#[test]
fn test_proof() {
let poseidon_params = poseidon_setup_params::<Fr>(Curve::Bn254, 5, 4);
let poseidon_hash = poseidon::Poseidon::new(poseidon_params);
let params = MerkleTree::setup(&poseidon_hash);
type MT = MerkleTree<Fr, Keccak256Hash<Fr>>;
let values = [
Fr::from(0_u32),
@@ -252,32 +217,22 @@ mod tests {
Fr::from(203_u32),
];
let mt = MerkleTree::new(&params, values.to_vec());
let (root, mt) = MT::commit(&values);
assert_eq!(
mt.root.hash.to_string(),
"Fp256 \"(10E90845D7A113686E4F2F30D73B315BA891A5DB9A58782F1260C35F99660794)\""
root.to_string(),
"6195952497672867974990959901930625199810318409246598214215524466855665265259"
);
let index = 3;
let index_F = Fr::from(index as u32);
let siblings = mt.gen_proof(index_F);
let siblings = mt.open(index_F);
assert!(MerkleTree::verify(
&params,
mt.root.hash,
index_F,
values[index],
siblings
));
assert!(MT::verify(root, index_F, values[index], siblings));
}
#[test]
fn test_proofs() {
let poseidon_params = poseidon_setup_params::<Fr>(Curve::Bn254, 5, 4);
let poseidon_hash = poseidon::Poseidon::new(poseidon_params);
let params = MerkleTree::setup(&poseidon_hash);
type MT = MerkleTree<Fr, Keccak256Hash<Fr>>;
let mut rng = ark_std::test_rng();
let n_values = 64;
@@ -287,19 +242,13 @@ mod tests {
values.push(v);
}
let mt = MerkleTree::new(&params, values.to_vec());
let (root, mt) = MT::commit(&values);
assert_eq!(mt.nlevels, 6);
for i in 0..n_values {
let i_Fr = Fr::from(i as u32);
let siblings = mt.gen_proof(i_Fr);
assert!(MerkleTree::verify(
&params,
mt.root.hash,
i_Fr,
values[i],
siblings
));
let siblings = mt.open(i_Fr);
assert!(MT::verify(root, i_Fr, values[i], siblings));
}
}
}

2
src/transcript.rs
View File

@@ -20,7 +20,7 @@ impl<F: PrimeField> Transcript<F> {
}
pub fn add<T: CanonicalSerialize>(&mut self, label: &'static [u8], r: &T) {
let mut buf = vec![];
r.serialize(&mut buf).unwrap();
r.serialize_uncompressed(&mut buf).unwrap();
self.transcript.append_message(label, buf.as_ref());
}
pub fn get_challenge(&mut self, label: &'static [u8]) -> F {