V1 (pickles.Composition_types.Wrap.Statement.Stable.V1)

type ('plonk, 'scalar_challenge, 'fp, 'messages_for_next_wrap_proof, 'digest, 'messages_for_next_step_proof, 'bp_chals, 'index)
  t =
  ( 'plonk,
    'scalar_challenge,
    'fp,
    'messages_for_next_wrap_proof,
    'digest,
    'messages_for_next_step_proof,
    'bp_chals,
    'index )
    Mina_wire_types.Pickles_composition_types.Wrap.Statement.V1.t =
  {

proof_state : ( 'plonk,
                'scalar_challenge,
                'fp,
                'messages_for_next_wrap_proof,
                'digest,
                'bp_chals,
                'index )
                Proof_state.Stable.V1.t;

messages_for_next_step_proof : 'messages_for_next_step_proof;

}

val to_yojson : 
  ( 'plonk -> Yojson.Safe.t ) ->
  ( 'scalar_challenge -> Yojson.Safe.t ) ->
  ( 'fp -> Yojson.Safe.t ) ->
  ( 'messages_for_next_wrap_proof -> Yojson.Safe.t ) ->
  ( 'digest -> Yojson.Safe.t ) ->
  ( 'messages_for_next_step_proof -> Yojson.Safe.t ) ->
  ( 'bp_chals -> Yojson.Safe.t ) ->
  ( 'index -> Yojson.Safe.t ) ->
  ( 'plonk,
    'scalar_challenge,
    'fp,
    'messages_for_next_wrap_proof,
    'digest,
    'messages_for_next_step_proof,
    'bp_chals,
    'index )
    t ->
  Yojson.Safe.t

val of_yojson : 
  ( Yojson.Safe.t -> 'plonk Ppx_deriving_yojson_runtime.error_or ) ->
  ( Yojson.Safe.t -> 'scalar_challenge Ppx_deriving_yojson_runtime.error_or ) ->
  ( Yojson.Safe.t -> 'fp Ppx_deriving_yojson_runtime.error_or ) ->
  ( Yojson.Safe.t ->
    'messages_for_next_wrap_proof Ppx_deriving_yojson_runtime.error_or ) ->
  ( Yojson.Safe.t -> 'digest Ppx_deriving_yojson_runtime.error_or ) ->
  ( Yojson.Safe.t ->
    'messages_for_next_step_proof Ppx_deriving_yojson_runtime.error_or ) ->
  ( Yojson.Safe.t -> 'bp_chals Ppx_deriving_yojson_runtime.error_or ) ->
  ( Yojson.Safe.t -> 'index Ppx_deriving_yojson_runtime.error_or ) ->
  Yojson.Safe.t ->
  ( 'plonk,
    'scalar_challenge,
    'fp,
    'messages_for_next_wrap_proof,
    'digest,
    'messages_for_next_step_proof,
    'bp_chals,
    'index )
    t
    Ppx_deriving_yojson_runtime.error_or

val compare : 
  ( 'plonk -> 'plonk -> int ) ->
  ( 'scalar_challenge -> 'scalar_challenge -> int ) ->
  ( 'fp -> 'fp -> int ) ->
  ( 'messages_for_next_wrap_proof -> 'messages_for_next_wrap_proof -> int ) ->
  ( 'digest -> 'digest -> int ) ->
  ( 'messages_for_next_step_proof -> 'messages_for_next_step_proof -> int ) ->
  ( 'bp_chals -> 'bp_chals -> int ) ->
  ( 'index -> 'index -> int ) ->
  ( 'plonk,
    'scalar_challenge,
    'fp,
    'messages_for_next_wrap_proof,
    'digest,
    'messages_for_next_step_proof,
    'bp_chals,
    'index )
    t ->
  ( 'plonk,
    'scalar_challenge,
    'fp,
    'messages_for_next_wrap_proof,
    'digest,
    'messages_for_next_step_proof,
    'bp_chals,
    'index )
    t ->
  int

val sexp_of_t : 
  ( 'plonk -> Ppx_sexp_conv_lib.Sexp.t ) ->
  ( 'scalar_challenge -> Ppx_sexp_conv_lib.Sexp.t ) ->
  ( 'fp -> Ppx_sexp_conv_lib.Sexp.t ) ->
  ( 'messages_for_next_wrap_proof -> Ppx_sexp_conv_lib.Sexp.t ) ->
  ( 'digest -> Ppx_sexp_conv_lib.Sexp.t ) ->
  ( 'messages_for_next_step_proof -> Ppx_sexp_conv_lib.Sexp.t ) ->
  ( 'bp_chals -> Ppx_sexp_conv_lib.Sexp.t ) ->
  ( 'index -> Ppx_sexp_conv_lib.Sexp.t ) ->
  ( 'plonk,
    'scalar_challenge,
    'fp,
    'messages_for_next_wrap_proof,
    'digest,
    'messages_for_next_step_proof,
    'bp_chals,
    'index )
    t ->
  Ppx_sexp_conv_lib.Sexp.t

val t_of_sexp : 
  ( Ppx_sexp_conv_lib.Sexp.t -> 'plonk ) ->
  ( Ppx_sexp_conv_lib.Sexp.t -> 'scalar_challenge ) ->
  ( Ppx_sexp_conv_lib.Sexp.t -> 'fp ) ->
  ( Ppx_sexp_conv_lib.Sexp.t -> 'messages_for_next_wrap_proof ) ->
  ( Ppx_sexp_conv_lib.Sexp.t -> 'digest ) ->
  ( Ppx_sexp_conv_lib.Sexp.t -> 'messages_for_next_step_proof ) ->
  ( Ppx_sexp_conv_lib.Sexp.t -> 'bp_chals ) ->
  ( Ppx_sexp_conv_lib.Sexp.t -> 'index ) ->
  Ppx_sexp_conv_lib.Sexp.t ->
  ( 'plonk,
    'scalar_challenge,
    'fp,
    'messages_for_next_wrap_proof,
    'digest,
    'messages_for_next_step_proof,
    'bp_chals,
    'index )
    t

val hash_fold_t : 
  ( Ppx_hash_lib.Std.Hash.state -> 'plonk -> Ppx_hash_lib.Std.Hash.state ) ->
  ( Ppx_hash_lib.Std.Hash.state ->
    'scalar_challenge ->
    Ppx_hash_lib.Std.Hash.state ) ->
  ( Ppx_hash_lib.Std.Hash.state -> 'fp -> Ppx_hash_lib.Std.Hash.state ) ->
  ( Ppx_hash_lib.Std.Hash.state ->
    'messages_for_next_wrap_proof ->
    Ppx_hash_lib.Std.Hash.state ) ->
  ( Ppx_hash_lib.Std.Hash.state -> 'digest -> Ppx_hash_lib.Std.Hash.state ) ->
  ( Ppx_hash_lib.Std.Hash.state ->
    'messages_for_next_step_proof ->
    Ppx_hash_lib.Std.Hash.state ) ->
  ( Ppx_hash_lib.Std.Hash.state -> 'bp_chals -> Ppx_hash_lib.Std.Hash.state ) ->
  ( Ppx_hash_lib.Std.Hash.state -> 'index -> Ppx_hash_lib.Std.Hash.state ) ->
  Ppx_hash_lib.Std.Hash.state ->
  ( 'plonk,
    'scalar_challenge,
    'fp,
    'messages_for_next_wrap_proof,
    'digest,
    'messages_for_next_step_proof,
    'bp_chals,
    'index )
    t ->
  Ppx_hash_lib.Std.Hash.state

val equal : 
  ( 'plonk -> 'plonk -> bool ) ->
  ( 'scalar_challenge -> 'scalar_challenge -> bool ) ->
  ( 'fp -> 'fp -> bool ) ->
  ( 'messages_for_next_wrap_proof -> 'messages_for_next_wrap_proof -> bool ) ->
  ( 'digest -> 'digest -> bool ) ->
  ( 'messages_for_next_step_proof -> 'messages_for_next_step_proof -> bool ) ->
  ( 'bp_chals -> 'bp_chals -> bool ) ->
  ( 'index -> 'index -> bool ) ->
  ( 'plonk,
    'scalar_challenge,
    'fp,
    'messages_for_next_wrap_proof,
    'digest,
    'messages_for_next_step_proof,
    'bp_chals,
    'index )
    t ->
  ( 'plonk,
    'scalar_challenge,
    'fp,
    'messages_for_next_wrap_proof,
    'digest,
    'messages_for_next_step_proof,
    'bp_chals,
    'index )
    t ->
  bool

val bin_shape_t : 
  Bin_prot.Shape.t ->
  Bin_prot.Shape.t ->
  Bin_prot.Shape.t ->
  Bin_prot.Shape.t ->
  Bin_prot.Shape.t ->
  Bin_prot.Shape.t ->
  Bin_prot.Shape.t ->
  Bin_prot.Shape.t ->
  Bin_prot.Shape.t

val bin_size_t : 
  'plonk Bin_prot.Size.sizer ->
  'scalar_challenge Bin_prot.Size.sizer ->
  'fp Bin_prot.Size.sizer ->
  'messages_for_next_wrap_proof Bin_prot.Size.sizer ->
  'digest Bin_prot.Size.sizer ->
  'messages_for_next_step_proof Bin_prot.Size.sizer ->
  'bp_chals Bin_prot.Size.sizer ->
  'index Bin_prot.Size.sizer ->
  ( 'plonk,
    'scalar_challenge,
    'fp,
    'messages_for_next_wrap_proof,
    'digest,
    'messages_for_next_step_proof,
    'bp_chals,
    'index )
    t
    Bin_prot.Size.sizer

val bin_write_t : 
  'plonk Bin_prot.Write.writer ->
  'scalar_challenge Bin_prot.Write.writer ->
  'fp Bin_prot.Write.writer ->
  'messages_for_next_wrap_proof Bin_prot.Write.writer ->
  'digest Bin_prot.Write.writer ->
  'messages_for_next_step_proof Bin_prot.Write.writer ->
  'bp_chals Bin_prot.Write.writer ->
  'index Bin_prot.Write.writer ->
  ( 'plonk,
    'scalar_challenge,
    'fp,
    'messages_for_next_wrap_proof,
    'digest,
    'messages_for_next_step_proof,
    'bp_chals,
    'index )
    t
    Bin_prot.Write.writer

val bin_writer_t : 
  'plonk Bin_prot.Type_class.writer ->
  'scalar_challenge Bin_prot.Type_class.writer ->
  'fp Bin_prot.Type_class.writer ->
  'messages_for_next_wrap_proof Bin_prot.Type_class.writer ->
  'digest Bin_prot.Type_class.writer ->
  'messages_for_next_step_proof Bin_prot.Type_class.writer ->
  'bp_chals Bin_prot.Type_class.writer ->
  'index Bin_prot.Type_class.writer ->
  ( 'plonk,
    'scalar_challenge,
    'fp,
    'messages_for_next_wrap_proof,
    'digest,
    'messages_for_next_step_proof,
    'bp_chals,
    'index )
    t
    Bin_prot.Type_class.writer

val bin_read_t : 
  'plonk Bin_prot.Read.reader ->
  'scalar_challenge Bin_prot.Read.reader ->
  'fp Bin_prot.Read.reader ->
  'messages_for_next_wrap_proof Bin_prot.Read.reader ->
  'digest Bin_prot.Read.reader ->
  'messages_for_next_step_proof Bin_prot.Read.reader ->
  'bp_chals Bin_prot.Read.reader ->
  'index Bin_prot.Read.reader ->
  ( 'plonk,
    'scalar_challenge,
    'fp,
    'messages_for_next_wrap_proof,
    'digest,
    'messages_for_next_step_proof,
    'bp_chals,
    'index )
    t
    Bin_prot.Read.reader

val __bin_read_t__ : 
  'plonk Bin_prot.Read.reader ->
  'scalar_challenge Bin_prot.Read.reader ->
  'fp Bin_prot.Read.reader ->
  'messages_for_next_wrap_proof Bin_prot.Read.reader ->
  'digest Bin_prot.Read.reader ->
  'messages_for_next_step_proof Bin_prot.Read.reader ->
  'bp_chals Bin_prot.Read.reader ->
  'index Bin_prot.Read.reader ->
  ( int ->
    ( 'plonk,
      'scalar_challenge,
      'fp,
      'messages_for_next_wrap_proof,
      'digest,
      'messages_for_next_step_proof,
      'bp_chals,
      'index )
      t )
    Bin_prot.Read.reader

val bin_reader_t : 
  'plonk Bin_prot.Type_class.reader ->
  'scalar_challenge Bin_prot.Type_class.reader ->
  'fp Bin_prot.Type_class.reader ->
  'messages_for_next_wrap_proof Bin_prot.Type_class.reader ->
  'digest Bin_prot.Type_class.reader ->
  'messages_for_next_step_proof Bin_prot.Type_class.reader ->
  'bp_chals Bin_prot.Type_class.reader ->
  'index Bin_prot.Type_class.reader ->
  ( 'plonk,
    'scalar_challenge,
    'fp,
    'messages_for_next_wrap_proof,
    'digest,
    'messages_for_next_step_proof,
    'bp_chals,
    'index )
    t
    Bin_prot.Type_class.reader

val bin_t : 
  'plonk Bin_prot.Type_class.t ->
  'scalar_challenge Bin_prot.Type_class.t ->
  'fp Bin_prot.Type_class.t ->
  'messages_for_next_wrap_proof Bin_prot.Type_class.t ->
  'digest Bin_prot.Type_class.t ->
  'messages_for_next_step_proof Bin_prot.Type_class.t ->
  'bp_chals Bin_prot.Type_class.t ->
  'index Bin_prot.Type_class.t ->
  ( 'plonk,
    'scalar_challenge,
    'fp,
    'messages_for_next_wrap_proof,
    'digest,
    'messages_for_next_step_proof,
    'bp_chals,
    'index )
    t
    Bin_prot.Type_class.t

include Pickles_types.Sigs.VERSIONED

val version : int

val __versioned__ : unit