arnaucube/sonobe
1
1
Fork 0
mirror of https://github.com/arnaucube/sonobe.git synced 2026-01-11 16:31:32 +01:00
Code Issues Projects Releases Wiki Activity

feat: add TranscriptVar trait (#42)

Browse Source 
* feat: add TranscriptVar trait

* Update src/transcript/poseidon.rs

Co-authored-by: arnaucube <root@arnaucube.com>

---------

Co-authored-by: arnaucube <root@arnaucube.com>
This commit is contained in:
Pierre
2023-12-05 20:28:06 +03:00
committed by GitHub
parent 905ba44d8d
commit 14a0b460e7
2 changed files with 27 additions and 7 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
src/transcript/mod.rs
View File

@@ -1,5 +1,8 @@
use crate::Error; use crate::Error;
use ark_ec::CurveGroup; use ark_ec::CurveGroup;
use ark_ff::PrimeField;
use ark_r1cs_std::{boolean::Boolean, fields::fp::FpVar};
use ark_relations::r1cs::{ConstraintSystemRef, SynthesisError};
use ark_std::fmt::Debug; use ark_std::fmt::Debug;
pub mod poseidon; pub mod poseidon;
@@ -16,3 +19,16 @@ pub trait Transcript<C: CurveGroup> {
fn get_challenge_nbits(&mut self, nbits: usize) -> Vec<bool>; fn get_challenge_nbits(&mut self, nbits: usize) -> Vec<bool>;
fn get_challenges(&mut self, n: usize) -> Vec<C::ScalarField>; fn get_challenges(&mut self, n: usize) -> Vec<C::ScalarField>;
} }
pub trait TranscriptVar<F: PrimeField> {
type TranscriptVarConfig: Debug;
fn new(cs: ConstraintSystemRef<F>, poseidon_config: &Self::TranscriptVarConfig) -> Self;
fn absorb(&mut self, v: FpVar<F>) -> Result<(), SynthesisError>;
fn absorb_vec(&mut self, v: &[FpVar<F>]) -> Result<(), SynthesisError>;
fn get_challenge(&mut self) -> Result<FpVar<F>, SynthesisError>;
/// returns the bit representation of the challenge, we use its output in-circuit for the
/// `GC.scalar_mul_le` method.
fn get_challenge_nbits(&mut self, nbits: usize) -> Result<Vec<Boolean<F>>, SynthesisError>;
fn get_challenges(&mut self, n: usize) -> Result<Vec<FpVar<F>>, SynthesisError>;
}

18
src/transcript/poseidon.rs
View File

@@ -12,6 +12,8 @@ use ark_std::{One, Zero};
use crate::transcript::Transcript; use crate::transcript::Transcript;
use crate::Error; use crate::Error;
use super::TranscriptVar;
/// PoseidonTranscript implements the Transcript trait using the Poseidon hash /// PoseidonTranscript implements the Transcript trait using the Poseidon hash
pub struct PoseidonTranscript<C: CurveGroup> pub struct PoseidonTranscript<C: CurveGroup>
where where
@@ -84,18 +86,20 @@ fn prepare_point<C: CurveGroup>(p: &C) -> Result<Vec<C::ScalarField>, Error> {
pub struct PoseidonTranscriptVar<F: PrimeField> { pub struct PoseidonTranscriptVar<F: PrimeField> {
sponge: PoseidonSpongeVar<F>, sponge: PoseidonSpongeVar<F>,
} }
impl<F: PrimeField> PoseidonTranscriptVar<F> { impl<F: PrimeField> TranscriptVar<F> for PoseidonTranscriptVar<F> {
pub fn new(cs: ConstraintSystemRef<F>, poseidon_config: &PoseidonConfig<F>) -> Self { type TranscriptVarConfig = PoseidonConfig<F>;
fn new(cs: ConstraintSystemRef<F>, poseidon_config: &Self::TranscriptVarConfig) -> Self {
let sponge = PoseidonSpongeVar::<F>::new(cs, poseidon_config); let sponge = PoseidonSpongeVar::<F>::new(cs, poseidon_config);
Self { sponge } Self { sponge }
} }
pub fn absorb(&mut self, v: FpVar<F>) -> Result<(), SynthesisError> { fn absorb(&mut self, v: FpVar<F>) -> Result<(), SynthesisError> {
self.sponge.absorb(&v) self.sponge.absorb(&v)
} }
pub fn absorb_vec(&mut self, v: &[FpVar<F>]) -> Result<(), SynthesisError> { fn absorb_vec(&mut self, v: &[FpVar<F>]) -> Result<(), SynthesisError> {
self.sponge.absorb(&v) self.sponge.absorb(&v)
} }
pub fn get_challenge(&mut self) -> Result<FpVar<F>, SynthesisError> { fn get_challenge(&mut self) -> Result<FpVar<F>, SynthesisError> {
let c = self.sponge.squeeze_field_elements(1)?; let c = self.sponge.squeeze_field_elements(1)?;
self.sponge.absorb(&c[0])?; self.sponge.absorb(&c[0])?;
Ok(c[0].clone()) Ok(c[0].clone())
@@ -103,10 +107,10 @@ impl<F: PrimeField> PoseidonTranscriptVar<F> {
/// returns the bit representation of the challenge, we use its output in-circuit for the /// returns the bit representation of the challenge, we use its output in-circuit for the
/// `GC.scalar_mul_le` method. /// `GC.scalar_mul_le` method.
pub fn get_challenge_nbits(&mut self, nbits: usize) -> Result<Vec<Boolean<F>>, SynthesisError> { fn get_challenge_nbits(&mut self, nbits: usize) -> Result<Vec<Boolean<F>>, SynthesisError> {
self.sponge.squeeze_bits(nbits) self.sponge.squeeze_bits(nbits)
} }
pub fn get_challenges(&mut self, n: usize) -> Result<Vec<FpVar<F>>, SynthesisError> { fn get_challenges(&mut self, n: usize) -> Result<Vec<FpVar<F>>, SynthesisError> {
let c = self.sponge.squeeze_field_elements(n)?; let c = self.sponge.squeeze_field_elements(n)?;
self.sponge.absorb(&c)?; self.sponge.absorb(&c)?;
Ok(c) Ok(c)