poseidon2_permutation.hpp

Go to the documentation of this file.

// === AUDIT STATUS ===
// internal:    { status: Complete, auditors: [Sergei], commit: 777717f6af324188ecd6bb68c3c86ee7befef94d}
// external_1:  { status: Complete, auditors: [@ed25519 (Spearbit)], commit: }
// external_2:  { status: not started, auditors: [], commit: }
// =====================
 
#pragma once
#include <array>
#include <cstddef>
#include <cstdint>
 
#include "barretenberg/crypto/poseidon2/poseidon2_permutation.hpp"
#include "barretenberg/stdlib/primitives/circuit_builders/circuit_builders.hpp"
#include "barretenberg/stdlib/primitives/field/field.hpp"
 
namespace bb::stdlib {
 
template <typename Builder> class Poseidon2Permutation {
  public:
    using Params = crypto::Poseidon2Bn254ScalarFieldParams;
    using NativePermutation = crypto::Poseidon2Permutation<Params>;
    // t = sponge permutation size (in field elements)
    // t = rate + capacity
    // capacity = 1 field element
    // rate = number of field elements that can be compressed per permutation
    static constexpr size_t t = Params::t;
    // number of full sbox rounds
    static constexpr size_t rounds_f = Params::rounds_f;
    // number of partial sbox rounds
    static constexpr size_t rounds_p = Params::rounds_p;
    static constexpr size_t NUM_ROUNDS = Params::rounds_f + Params::rounds_p;
 
    using FF = typename Params::FF;
    using State = std::array<field_t<Builder>, t>;
    using NativeState = std::array<FF, t>;
 
    using RoundConstants = std::array<FF, t>;
    using RoundConstantsContainer = std::array<RoundConstants, NUM_ROUNDS>;
    static constexpr RoundConstantsContainer round_constants = Params::round_constants;
 
    static State permutation(Builder* builder, const State& input);
 
    static void matrix_multiplication_external(State& state)
        requires IsMegaBuilder<Builder>;
 
    static void matrix_multiplication_external(State& state)
        requires(!IsMegaBuilder<Builder>);
 
    static void propagate_current_state_to_next_row(Builder* builder, const State& state, auto& block)
    {
        builder->create_unconstrained_gate(block,
                                           state[0].get_witness_index(),
                                           state[1].get_witness_index(),
                                           state[2].get_witness_index(),
                                           state[3].get_witness_index());
    };
};
 
} // namespace bb::stdlib