lib-q-ml-dsa 0.0.2

use crate::constants::{
    BYTES_FOR_VERIFICATION_KEY_HASH,
    Eta,
    RING_ELEMENT_OF_T0S_SIZE,
    SEED_FOR_A_SIZE,
    SEED_FOR_SIGNING_SIZE,
};
use crate::encoding;
use crate::hash_functions::shake256;
use crate::helper::cloop;
use crate::polynomial::PolynomialRingElement;
use crate::simd::traits::Operations;

#[cfg_attr(tarpaulin, inline(never))]
#[cfg_attr(not(tarpaulin), inline(always))]
#[allow(clippy::too_many_arguments)]
pub(crate) fn generate_serialized<SIMDUnit: Operations, Shake256: shake256::DsaXof>(
    eta: Eta,
    error_ring_element_size: usize,
    seed_matrix: &[u8],
    seed_signing: &[u8],
    verification_key: &[u8],
    s1_2: &[PolynomialRingElement<SIMDUnit>],
    t0: &[PolynomialRingElement<SIMDUnit>],
    signing_key_serialized: &mut [u8],
) {
    let mut offset = 0;

    signing_key_serialized[offset..offset + SEED_FOR_A_SIZE].copy_from_slice(seed_matrix);
    offset += SEED_FOR_A_SIZE;

    signing_key_serialized[offset..offset + SEED_FOR_SIGNING_SIZE].copy_from_slice(seed_signing);
    offset += SEED_FOR_SIGNING_SIZE;

    let mut verification_key_hash = [0; BYTES_FOR_VERIFICATION_KEY_HASH];
    Shake256::shake256::<BYTES_FOR_VERIFICATION_KEY_HASH>(
        verification_key,
        &mut verification_key_hash,
    );
    signing_key_serialized[offset..offset + BYTES_FOR_VERIFICATION_KEY_HASH]
        .copy_from_slice(&verification_key_hash);
    offset += BYTES_FOR_VERIFICATION_KEY_HASH;

    for elem in s1_2.iter() {
        encoding::error::serialize::<SIMDUnit>(
            eta,
            elem,
            &mut signing_key_serialized[offset..offset + error_ring_element_size],
        );
        offset += error_ring_element_size;
    }

    cloop! {
        for ring_element in t0.iter() {
            encoding::t0::serialize::<SIMDUnit>(
                ring_element,
                &mut signing_key_serialized[offset..offset + RING_ELEMENT_OF_T0S_SIZE],
            );
            offset += RING_ELEMENT_OF_T0S_SIZE;
        }
    }
}