Compute new accumulated value after batch addition

Compute new accumulated value after batch removal

Create a random gamma and then P = gs * y + h * gamma

Returns the KZG opening proof for the given commitment key. Specifically, it returns $g^{f(alpha) - f(z) / (alpha - z)}$ for $a$ and $b$.

Prepare messages (commitments) to sign

Return a new vector `y` whose first `d` elements are coefficients of degree `d` polynomial `poly` and rest of the elements are of `t`, i.e. `y = [a_1,

Returns digits of `value` when expressed in sumset notation give sumset boundaries, i.e. `G`

Same as `Self::decrypt` but takes Groth16's verification key and the precomputed pairing powers

Same as `Self::decrypt` but expects pairing powers (see `PreparedDecryptionKey::pairing_powers`) that can be precomputed for even faster decryption

Credential issued by the a delegated issuer without adding any more attributes. The issued credential will have an orphan signature, i.e. the receiver

Derive commitment keys for Schnorr protocol from public params. This is done to avoid creating them if the same public params are used in multiple sta

Derive the membership proving key when doing a membership proof with a universal accumulator.

Given multiple `MetaStatement::WitnessEquality` which might have common witness references, return a list of `EqualWitnesses` with no common reference

First phase of signing where signers generate randomness

Second phase of signing where signers operate on the message and phase 1 output

Pass `full_message` if all signers know the full message. Pass `message_shares` if each signer knows only a share of the original message.

Convert field element vector from `[c_1, c_2, c_3, ..., c_n]` to `[c_1*c_2*...*c_n, c_2*c_3*...*c_n, c_3*...*c_n, ..., c_{n-1}*c_n, c_n, 1]`

evaluate the poly at t

Given a parent node, create its 2 children nodes

Add new elements to an already initialized accumulator that were not part of its `domain`.

Participant finishes Round 1 and starts Round 2.

This should be called after "sufficient" messages have been received. "sufficient" might be just the threshold or greater depending on the number of f

Attach a user's public key to an orphan signature.

Get the commitment key used for the Pedersen commitment to witnesses in the proof

Same as `Self::get_commitments_to_values` but accepts the generator `g` from the setup params

Get number of 32-bit chunks needed to represent a field element

In each round `i`, current `g` is split in 2 halves, `g_l` and `g_r` and new `g` is created as `c_i*g_l + g_r` where `g_l` and `g_r` are left and righ

Get LegoGroth16 randomness and proof to reuse for the given statement id

Get membership witnesses for multiple elements present in accumulator. Returns witnesses in the order of passed elements. It is more efficient than co

Return range, i.e. `max - min`, such that it's a multiple of `base-1`. If `base-1` does not divide `max - min`, the new range is `(max - min)*(base-1)

Returns true if commitment keys have the exact required length. It is necessary for the IPP scheme to work that commitment key have the exact same num

Initializes a Schnorr protocol to prove the knowledge of committed values in the Pedersen commitment in the Legosnark proof

Initialize 3 Schnorr proof of knowledge protocols to prove the knowledge of committed value in ciphertext

Params shouldn't be 0

Keys of `missing_responses` are the witness indices whose response was generated while creating this. Instead, these come from some other Schnorr prot

Returns an iterator over zipped pairs.

Produces an iterator emitting `n` items `u32::to_le_bytes` of the counter starting from zero.

Applies given `f` to the mutable reference of each contained entity producing a new `SecretKeyModel`.

Merges indexed messages sorted by index with indexed blindings sorted by index. Messages which don't have corresponding blindings will be blinded rand

Returns `[g, 2*g, 3*g, ..., n*g]`

Returns vector `[g * i * coeff, g * i^2 * coeff, g * i^3 * coeff, ..., g * i^n * coeff]`

fetches 32 bits of randomness

Obtain the number of digits in the base representation

Applies `sf` to a single item and `pf` to a pair.

Maps supplied iterator and attempts to pair each successfully validated item with a corresponding item from the slice. Validation errors will be propa

Maps supplied iterator and attempts to pair each item with an item from the slice which has provided index. Returns `Err` containing an invalid index

Calling `pairing_powers` on the prepared decryption key

Performs some high level checks on the length of vectors and others to make sure all items in the proofs are consistent with each other.

Plucks items from the supplied iterator corresponding to missed indices. This function implies that both iterators are sorted.

Compute the coefficients of the polynomial $\prod_{j=0}^{l-1} (1 + x_{l-j}(rX)^{2j})$ It does this in logarithmic time directly; here is an example wi

Verify the received credential and then randomize the credential, update key (if needed) and user's secret and public key