Module Cryptobox.Internal_for_tests

val init_prover_dal : unit -> unit

The initialisation parameters can be too large for testing purposes. This function creates an unsafe initialisation parameters using default parameters designed to handle test cases.

val init_verifier_dal : unit -> unit

This function creates an unsafe initialisation parameters for the verifier using default parameters designed to handle test cases.

val init_verifier_dal_default : unit -> unit

This function loads in memory the default verifier SRS. The difference with init_verifier_dal is that the latter loads a SRS that should be only used for tests.

val make_dummy_shards : t -> state:Stdlib.Random.State.t -> shard Stdlib.Seq.t

Returns a randomized valid sequence of shards using the random state state for the given parameters.

val polynomials_equal : polynomial -> polynomial -> bool

polynomials_equal p1 p2 returns true if and only if p1 and p2 represent the same polynomial.

val page_proof_equal : page_proof -> page_proof -> bool

page_proof_equal proof1 proof2 returns true if and only if proof1 and proof2 represent the same proof.

val alter_page_proof : page_proof -> page_proof

alter_page_proof page_proof returns a different page proof than the input.

val alter_shard_proof : shard_proof -> shard_proof

alter_shard_proof shard_proof returns a different shard proof than the input.

val alter_commitment_proof : commitment_proof -> commitment_proof

alter_commitment_proof commitment_proof returns a different commitment proof than the input.

val minimum_number_of_shards_to_reconstruct_slot : t -> int

minimum_number_of_shards_to_reconstruct_slot t returns the minimum number of shards to reconstruct a slot using polynomial_from_shards.

val dummy_commitment : state:Stdlib.Random.State.t -> unit -> commitment
val dummy_page_proof : state:Stdlib.Random.State.t -> unit -> page_proof
val dummy_shard_proof : state:Stdlib.Random.State.t -> unit -> shard_proof
val make_dummy_shard : state:Stdlib.Random.State.t -> index:int -> length:int -> shard
val number_of_pages : t -> int
val shard_length : t -> int
val dummy_polynomial : state:Stdlib.Random.State.t -> degree:int -> polynomial
val srs_size_g1 : t -> int
val select_fft_domain : int -> int * int * int

select_fft_domain domain_size selects a suitable domain for the FFT.

The domain size domain_size is expected to be strictly positive. Return (size, power_of_two, remainder) such that: * If domain_size > 1, then size is the smallest integer greater or equal to domain_size and is of the form 2^a * 3^b * 11^c * 19^d, where:

     a ∈ ⟦0, 32⟧, b ∈ {0, 1}, c ∈ {0, 1}, d ∈ {0, 1}

* If domain_size = 1, then size = 2. * size = power_of_two * remainder, power_of_two is a power of two, and remainder is not divisible by 2.

val precomputation_equal : shards_proofs_precomputation -> shards_proofs_precomputation -> bool
val encoded_share_size : t -> int
val ensure_validity : parameters -> bool

ensure_validity parameters returns true if the parameters are valid. See implementation file for details.

val ensure_validity_without_srs : parameters -> (unit, [> `Fail of string ]) Stdlib.result

Same as ensure_validity parameters, except that it returns an error if the parameters aren't valid and doesn't check the SRS.

val slot_as_polynomial_length : slot_size:int -> page_size:int -> int