Struct neptune::poseidon::PoseidonConstants

pub struct PoseidonConstants<F, A>
where
    F: PrimeField,
    A: Arity<F>,
{
    pub mds_matrices: MdsMatrices<F>,
    pub round_constants: Option<Vec<F>>,
    pub compressed_round_constants: Vec<F>,
    pub pre_sparse_matrix: Vec<Vec<F>>,
    pub sparse_matrixes: Vec<SparseMatrix<F>>,
    pub strength: Strength,
    pub domain_tag: F,
    pub full_rounds: usize,
    pub half_full_rounds: usize,
    pub partial_rounds: usize,
    pub hash_type: HashType<F, A>,
    /* private fields */
}

Holds constant values required for further Poseidon hashing. It contains MDS matrices, round constants and numbers, parameters that specify security level (Strength) and domain separation (HashType). Additional constants related to optimizations are also included.

For correct operation, PoseidonConstants instance should be parameterized with the same ff::PrimeField and Arity as Poseidon instance that consumes it.

See original Poseidon paper for more details.

Fields

mds_matrices: MdsMatrices<F>

round_constants: Option<Vec<F>>

compressed_round_constants: Vec<F>

pre_sparse_matrix: Vec<Vec<F>>

sparse_matrixes: Vec<SparseMatrix<F>>

strength: Strength

domain_tag: F

The domain tag is the first element of a Poseidon permutation. This extra element is necessary for 128-bit security.

full_rounds: usize

half_full_rounds: usize

partial_rounds: usize

hash_type: HashType<F, A>

Implementations

impl<F, A> PoseidonConstants<F, A>

where F: PrimeField, A: Arity<F>,

pub fn new() -> Self

Generates new instance of PoseidonConstants suitable for both optimized / non-optimized hashing with following default parameters:

• 128 bit of security;
• Merkle Tree (where all leafs are presented) domain separation (HashType).

Example

use neptune::poseidon::PoseidonConstants;
use neptune::Strength;
use neptune::hash_type::HashType;
use pasta_curves::Fp;
use generic_array::typenum::U2;

let constants: PoseidonConstants<Fp, U2> = PoseidonConstants::new();

assert_eq!(constants.strength, Strength::Standard);
assert_eq!(constants.hash_type, HashType::MerkleTree);

pub fn new_constant_length(length: usize) -> Self

Generates new instance of PoseidonConstants suitable for both optimized / non-optimized hashing of constant-size preimages with following parameters:

• 128 bit of security;
• Constant-Input-Length Hashing domain separation (HashType).

Instantiated PoseidonConstants still calculates internal constants based on Arity, but calculation of HashType::domain_tag is based on input length.

Example

use neptune::poseidon::PoseidonConstants;
use neptune::Strength;
use neptune::hash_type::HashType;
use pasta_curves::Fp;
use generic_array::typenum::U2;

let preimage_length = 2usize;
let constants: PoseidonConstants<Fp, U2> = PoseidonConstants::new_constant_length(preimage_length);

assert_eq!(constants.strength, Strength::Standard);
assert_eq!(constants.hash_type, HashType::<Fp, U2>::ConstantLength(preimage_length));

pub fn with_length(&self, length: usize) -> Self

Creates new instance of PoseidonConstants from already defined one with recomputed domain tag.

It is assumed that input length is equal or less than Arity.

Example

use neptune::poseidon::PoseidonConstants;
use neptune::Strength;
use neptune::hash_type::HashType;
use pasta_curves::Fp;
use generic_array::typenum::U8;

let preimage_length = 2usize;
let constants: PoseidonConstants<Fp, U8> = PoseidonConstants::new_constant_length(preimage_length);
let constants: PoseidonConstants<Fp, U8> = constants.with_length(preimage_length - 2);

assert_eq!(constants.strength, Strength::Standard);
assert_eq!(constants.hash_type, HashType::<Fp, U8>::ConstantLength(preimage_length - 2));

pub fn new_with_strength(strength: Strength) -> Self

Generates new instance of PoseidonConstants suitable for both optimized / non-optimized hashing with Merkle Tree (where all leafs are presented) domain separation (HashType) custom security level (Strength).

Example

use neptune::poseidon::PoseidonConstants;
use neptune::Strength;
use neptune::hash_type::HashType;
use pasta_curves::Fp;
use generic_array::typenum::U2;

let security_level = Strength::Strengthened;
let constants: PoseidonConstants<Fp, U2> = PoseidonConstants::new_with_strength(security_level);

assert_eq!(constants.strength, Strength::Strengthened);
assert_eq!(constants.hash_type, HashType::MerkleTree);

pub fn new_with_strength_and_type( strength: Strength, hash_type: HashType<F, A>, ) -> Self

Generates new instance of PoseidonConstants suitable for both optimized / non-optimized hashing with custom domain separation (HashType) and custom security level (Strength).

Example

use neptune::poseidon::PoseidonConstants;
use neptune::Strength;
use neptune::hash_type::HashType;
use pasta_curves::Fp;
use generic_array::typenum::U2;

let domain_separation = HashType::Encryption;
let security_level = Strength::Strengthened;
let constants: PoseidonConstants<Fp, U2> = PoseidonConstants::new_with_strength_and_type(security_level, domain_separation);

assert_eq!(constants.strength, Strength::Strengthened);
assert_eq!(constants.hash_type, HashType::Encryption);

pub fn arity(&self) -> usize

Returns the Arity value represented as usize.

Example

use neptune::poseidon::PoseidonConstants;
use pasta_curves::Fp;
use generic_array::typenum::U8;

let constants: PoseidonConstants<Fp, U8> = PoseidonConstants::new();

assert_eq!(constants.arity(), 8usize);

pub fn width(&self) -> usize

Returns width value represented as usize. It equals to Arity + 1.

Example

use neptune::poseidon::PoseidonConstants;
use pasta_curves::Fp;
use generic_array::typenum::U8;

let constants: PoseidonConstants<Fp, U8> = PoseidonConstants::new();

assert_eq!(constants.width(), 8 + 1);

Trait Implementations

impl<F, A> Clone for PoseidonConstants<F, A>

where F: PrimeField + Clone, A: Arity<F> + Clone,

fn clone(&self) -> PoseidonConstants<F, A>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<F, A> Debug for PoseidonConstants<F, A>

where F: PrimeField + Debug, A: Arity<F> + Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<F, A> Default for PoseidonConstants<F, A>

where F: PrimeField, A: Arity<F>,

fn default() -> Self

Returns the “default value” for a type.

impl<'de, F, A> Deserialize<'de> for PoseidonConstants<F, A>

where F: PrimeField + Deserialize<'de>, A: Arity<F>,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<F, A> PartialEq for PoseidonConstants<F, A>

where F: PrimeField + PartialEq, A: Arity<F> + PartialEq,

fn eq(&self, other: &PoseidonConstants<F, A>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<F, A> Serialize for PoseidonConstants<F, A>

where F: PrimeField + Serialize, A: Arity<F>,

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<F, A> StructuralPartialEq for PoseidonConstants<F, A>

where F: PrimeField, A: Arity<F>,