Method commit

src/commitments/poseidon_commit.rs:106–148

(
    &self,
    mut layouter: impl Layouter<F>,
    _gadget_config: Rc<GadgetConfig>,
    _constants: &HashMap<i64, CellRc<F>>,
    values: &Vec<CellRc<F>>,
    blinding: CellRc<F>,
  )

  for PoseidonCommitChip<F, WIDTH, RATE, L>
{
  fn commit(
    &self,
    mut layouter: impl Layouter<F>,
    _gadget_config: Rc<GadgetConfig>,
    _constants: &HashMap<i64, CellRc<F>>,
    values: &Vec<CellRc<F>>,
    blinding: CellRc<F>,
  ) -> Result<Vec<CellRc<F>>, Error> {
    let chip = Pow5Chip::construct(self.poseidon_config.clone());
    let mut hasher: MyHash<F, Pow5Chip<F, 3, 2>, P128Pow5T3Gen<F, 0>, ConstantLength<L>, 3, 2> =
      Sponge::new(chip, layouter.namespace(|| "sponge"))
        .map(|sponge| MyHash { sponge })
        .unwrap();

    let mut new_vals = values
      .iter()
      .map(|x| x.clone())
      .chain(vec![blinding.clone()])
      .collect::<Vec<_>>();
    while new_vals.len() % L != 0 {
      new_vals.push(blinding.clone());
    }
    for (i, value) in new_vals
      .iter()
      .map(|x| PaddedWord::Message((**x).clone()))
      .chain(<ConstantLength<L> as Domain<F, RATE>>::padding(L).map(PaddedWord::Padding))
      .enumerate()
    {
      hasher
        .sponge
        .absorb(layouter.namespace(|| format!("absorb {}", i)), value)
        .unwrap();
    }
    let outp = hasher
      .sponge
      .finish_absorbing(layouter.namespace(|| "finish absorbing"))
      .unwrap()
      .squeeze(layouter.namespace(|| "squeeze"))
      .unwrap();
    let outp = Rc::new(outp);

    Ok(vec![outp])
  }
}