octez-libs 20.1 (latest) · OCaml Package

Parameters

module Main_KZG : Plonk.Main_protocol.S with type public_inputs = Kzg.Bls.Scalar.t array list

module Main_Pack : 
  Aggregation.Main_protocol.S
    with type public_inputs = Kzg.Bls.Scalar.t array list
    with module PP.Answers_commitment = Main_KZG.Input_commitment

module PIs : Pi_parameters.S

Signature

module Aggreg_circuit : sig ... end

module L = Plompiler.LibCircuit

exception Entry_not_in_table of string

exception Rest_not_null of string

module Input_commitment = Main_Pack.Input_commitment

type scalar = Kzg.Bls.Scalar.t

val scalar_t : Kzg.Bls.Scalar.t Repr.t

type circuit_map = Main_Pack.circuit_map

type prover_meta_pp = {

meta_pp : Main_KZG.prover_public_parameters;
meta_solver : Plompiler.Solver.t;
public_input_size : int;
input_com_sizes : int list;
nb_proofs : int;
nb_rc_wires : int;

}

val prover_meta_pp_t : prover_meta_pp Repr.t

type verifier_meta_pp = {

meta_pp : Main_KZG.verifier_public_parameters;
public_input_size : int;
nb_proofs : int;

}

val verifier_meta_pp_t : verifier_meta_pp Repr.t

type prover_public_parameters = {

main_pp : Main_Pack.prover_public_parameters;
meta_pps : prover_meta_pp SMap.t;

}

val prover_public_parameters_t : prover_public_parameters Repr.t

type verifier_public_parameters = {

main_pp : Main_Pack.verifier_public_parameters;
meta_pps : verifier_meta_pp SMap.t;

}

val verifier_public_parameters_t : verifier_public_parameters Repr.t

type proof = {

main_proof : Main_Pack.proof;
meta_proofs : Main_KZG.proof SMap.t;
batch : Main_KZG.scalar SMap.t list;
batches : (Main_KZG.scalar * int) SMap.t list SMap.t;
cms_answers : Main_Pack.PP.Answers_commitment.public SMap.t;
cms_pi : Main_Pack.PP.Answers_commitment.public SMap.t;
ids_batch : (Main_KZG.scalar * int) SMap.t;
t_answers : Main_KZG.scalar list;

}

val proof_t : proof Repr.t

type circuit_prover_input = Main_Pack.circuit_prover_input = {

witness : scalar array;
input_commitments : Main_Pack.Input_commitment.t list;

}

val circuit_prover_input_t : circuit_prover_input Repr.t

type prover_inputs = circuit_prover_input list SMap.t

val prover_inputs_t : circuit_prover_input list SMap.t Repr.ty

type public_inputs = scalar list

val public_inputs_t : Kzg.Bls.Scalar.t list Repr.t

type circuit_verifier_input = {

nb_proofs : int;
public : public_inputs;
commitments : Input_commitment.public list list;

}

val circuit_verifier_input_t : circuit_verifier_input Repr.t

type verifier_inputs = circuit_verifier_input SMap.t

val verifier_inputs_t : circuit_verifier_input SMap.t Repr.ty

val to_verifier_inputs : 
  prover_public_parameters ->
  Main_Pack.prover_inputs ->
  circuit_verifier_input SMap.t

val update_prover_public_parameters : 
  'a Repr.ty ->
  'b ->
  prover_public_parameters ->
  prover_public_parameters

val update_verifier_public_parameters : 
  'a Repr.ty ->
  'b ->
  verifier_public_parameters ->
  verifier_public_parameters

val filter_prv_pp_circuits : 
  prover_public_parameters ->
  'a Kzg.SMap.t ->
  prover_public_parameters

val filter_vrf_pp_circuits : 
  verifier_public_parameters ->
  'a Kzg.SMap.t ->
  verifier_public_parameters

val cs_global : Plompiler.LibCircuit.cs_result SMap.t ref

val input_commit_funcs : 
  prover_public_parameters ->
  'a list SMap.t ->
  Main_Pack.input_commit_funcs SMap.t

val input_commit : 
  ?size:'a ->
  ?shift:'b ->
  prover_public_parameters ->
  'c ->
  'd

val meta_setup : 
  zero_knowledge:bool ->
  srs:(Kzg.Bls.Srs.t * Kzg.Bls.Srs.t) ->
  main_prover_pp:Main_Pack.prover_public_parameters ->
  nb_batches:int ->
  SMap.key ->
  (Plonk.Circuit.t * int) ->
  prover_meta_pp * verifier_meta_pp

val setup : 
  zero_knowledge:bool ->
  Main_Pack.circuit_map ->
  srs:(Kzg.Bls.Srs.t * Kzg.Bls.Srs.t) ->
  prover_public_parameters * verifier_public_parameters

val meta_prove : 
  main_prover_aux:Main_Pack.prover_aux ->
  meta_pps:prover_meta_pp SMap.t ->
  inner_pi_map:Main_Pack.circuit_verifier_input SMap.t ->
  transcript:Kzg.Utils.Transcript.t ->
  (Main_Pack.scalar * 'a) Kzg.SMap.t list SMap.t ->
  SMap.key ->
  'b list ->
  Main_KZG.proof

val meta_proof : 
  prover_public_parameters ->
  Main_Pack.prover_inputs ->
  (Main_Pack.proof * Main_Pack.prover_aux) ->
  proof

val prove : prover_public_parameters -> inputs:prover_inputs -> proof

val meta_verify : 
  transcript:Kzg.Utils.Transcript.t ->
  inputs:circuit_verifier_input SMap.t ->
  proof:proof ->
  (Main_KZG.scalar
   * Main_KZG.scalar
   * Main_KZG.scalar
   * Main_KZG.scalar
   * Main_KZG.scalar
   * Main_KZG.scalar) ->
  SMap.key ->
  verifier_meta_pp ->
  bool

val verify : 
  verifier_public_parameters ->
  inputs:verifier_inputs ->
  proof ->
  bool

val scalar_encoding : Main_Pack.scalar Data_encoding.t

val data_encoding_of_repr : 'a Repr.t -> 'b Data_encoding.encoding

val proof_encoding : proof Data_encoding.encoding

val verifier_public_parameters_encoding : 
  verifier_public_parameters Data_encoding.encoding

module Internal_for_tests : sig ... end

package octez-libs

Parameters

Signature