Compute an update to the witness after adding and removing batches of elements from the accumulator. Expects the update-info (`Omega`) published by th

Verifies a signature. Can verify aggregated signature and unblinded signature received from a signer as well.

Aggregate `n` zkSnark proofs, where `n` must be a power of two. WARNING: transcript_include represents everything that should be included in the trans

Adding and removing batches of elements from the accumulator

Commit to a message

Same as `Self::open_subset_unchecked` but additionally checks if the subset is indeed a subset and the opening is valid.

Given path relative to this crate, return absolute disk path

The commitment's contribution to the overall challenge of the protocol.

Ensures that each sequence pair satisfy provided predicate.

Verify if the proof is valid. Assumes that the public key and parameters have been validated already.

Verify the proof of knowledge of MAC. Requires the knowledge of the signer's secret key. It can be seen as composed of 2 parts, one requiring knowledg

Given `base`-ary representation of a value, commit to its `digits`, `g * (1 * digits[0] + base * digits[1] + base^2 * digits[2] + base^{n-1} * digits[

insert a continuous sequence of values at row r starting from c_offset

Generate keys for encryption and decryption. The parameters `g_i`, `delta_g` and `gamma_g` are shared with the SNARK SRS.

Return a scaled vector by multiplying each of its elements by `factor`. Returns `[arr_0 * factor, arr_1 * factor, arr_2 * factor, ...]`

Verify this proof. Delegates to [`verify_proof`] [`verify_proof`]: ProofProtocol::verify_proof

Same as `Self::verify_decryption` but takes Groth16's verification key instead of the generators used for Elgamal encryption

Add a sequence of group elements whose pairing product must be equal to the another given sequence of group elements, i.e. `\prod_{i}(e(a_i, b_i)) = \

Assumes that the public commitments and commitment key have already been included in the challenge

ChangeRep from the paper

Checks that should be done before adding the element to the accumulator, such as the element already being present

Same as `Self::decrypt` but takes Groth16's verification key instead of the generators used for Elgamal encryption

Use the supplied external `rng` to rekey the transcript, so that the finalized [`TranscriptRng`] is a PRF bound to randomness from the external RNG, a

Generate proof. Post-challenge phase of the protocol.

Remove an element from the accumulator updating both the internal accumulators.

Verify the proof of knowledge of MAC. Requires the knowledge of secret key. It can be seen as composed of 2 parts, one requiring knowledge of secret k

Verify the proof of knowledge of MAC. Requires the knowledge of secret key. It can be seen as composed of 2 parts, one requiring knowledge of secret k

Commits to 2 vector, 1 of group G1 elements and 1 of group G2 elements.

Generate proof when only response for witness2 has to be generated.

Get the member in the non-adaptive accumulator

Create accumulator and check whether multiple batch updates can be applied to a witness

Same as `base_n_digits` but pads representation with 0s to the end to make the output vector length as `size`

The key of the map is the index for which response has to be generated.

Schnorr response for relation `k_{l} = \sum_{j}(beta_tilde_{j} * m_{l}{j} + g_tilde * r_{l})`.

Generate secret key, encryption key, decryption key and generate SNARK proving and verifying key

Ensures that the given iterator satisfies provided validator for each item. The supplied option will be modified to `V::Failure` in case of failure, a

Same as `Self::is_valid` except it uses `RandomizedMultChecker` to combine the scalar multiplication checks into a single

Fill the supplied buffer with the verifier's challenge bytes. The `label` parameter is metadata about the challenge, and is also appended to the tran

Get the contribution of this protocol towards the challenge, i.e. bytecode of items that will be hashed

Checks that should be done before removing the element from the accumulator, such as the element already being absent

Create membership proof once the overall challenge is ready. Delegates to [`compute_responses`] [`compute_responses`]: ProofProtocol::compute_respons

Generate proof. Post-challenge phase of the protocol.

Given `elem` and number `n`, return `n` powers of `elem` as `[elem, elem^2, elem^3, ..., elem^n]`

Multiply with a many scalars

Naive multiplication (n^2) of 2 polynomials defined over prime fields Note: Using multiply operator from ark-poly is orders of magnitude slower than n

Checks if the commitment can be opened with the given opening and for the given set.