V2 (mina_base.Mina_base.Zkapp_account.Poly.Stable.V2)

type ('app_state, 'vk, 'zkapp_version, 'field, 'slot, 'bool, 'zkapp_uri) t = {

app_state : 'app_state;

verification_key : 'vk;

zkapp_version : 'zkapp_version;

sequence_state : 'field Pickles_types.Vector.Vector_5.Stable.V1.t;

last_sequence_slot : 'slot;

proved_state : 'bool;

zkapp_uri : 'zkapp_uri;

}

val to_yojson : 
  'app_state 'vk 'zkapp_version 'field 'slot 'bool 'zkapp_uri. ( 'app_state ->
                                                                 Yojson.Safe.t ) ->
  ( 'vk -> Yojson.Safe.t ) ->
  ( 'zkapp_version -> Yojson.Safe.t ) ->
  ( 'field -> Yojson.Safe.t ) ->
  ( 'slot -> Yojson.Safe.t ) ->
  ( 'bool -> Yojson.Safe.t ) ->
  ( 'zkapp_uri -> Yojson.Safe.t ) ->
  ( 'app_state, 'vk, 'zkapp_version, 'field, 'slot, 'bool, 'zkapp_uri ) t ->
  Yojson.Safe.t

val of_yojson : 
  'app_state 'vk 'zkapp_version 'field 'slot 'bool 'zkapp_uri. ( Yojson.Safe.t ->
                                                                 'app_state
                                                                   Ppx_deriving_yojson_runtime.error_or ) ->
  ( Yojson.Safe.t -> 'vk Ppx_deriving_yojson_runtime.error_or ) ->
  ( Yojson.Safe.t -> 'zkapp_version Ppx_deriving_yojson_runtime.error_or ) ->
  ( Yojson.Safe.t -> 'field Ppx_deriving_yojson_runtime.error_or ) ->
  ( Yojson.Safe.t -> 'slot Ppx_deriving_yojson_runtime.error_or ) ->
  ( Yojson.Safe.t -> 'bool Ppx_deriving_yojson_runtime.error_or ) ->
  ( Yojson.Safe.t -> 'zkapp_uri Ppx_deriving_yojson_runtime.error_or ) ->
  Yojson.Safe.t ->
  ( 'app_state, 'vk, 'zkapp_version, 'field, 'slot, 'bool, 'zkapp_uri ) t
    Ppx_deriving_yojson_runtime.error_or

val _ : 
  ( Yojson.Safe.t -> 'a Ppx_deriving_yojson_runtime.error_or ) ->
  ( Yojson.Safe.t -> 'b Ppx_deriving_yojson_runtime.error_or ) ->
  ( Yojson.Safe.t -> 'c Ppx_deriving_yojson_runtime.error_or ) ->
  ( Yojson.Safe.t -> 'd Ppx_deriving_yojson_runtime.error_or ) ->
  ( Yojson.Safe.t -> 'e Ppx_deriving_yojson_runtime.error_or ) ->
  ( Yojson.Safe.t -> 'f Ppx_deriving_yojson_runtime.error_or ) ->
  ( Yojson.Safe.t -> 'g Ppx_deriving_yojson_runtime.error_or ) ->
  Yojson.Safe.t ->
  ( 'a, 'b, 'c, 'd, 'e, 'f, 'g ) t Ppx_deriving_yojson_runtime.error_or

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

val bin_size_t : 
  'app_state 'vk 'zkapp_version 'field 'slot 'bool 'zkapp_uri. 'app_state
                                                                 Core_kernel.Bin_prot.Size.sizer ->
  'vk Core_kernel.Bin_prot.Size.sizer ->
  'zkapp_version Core_kernel.Bin_prot.Size.sizer ->
  'field Core_kernel.Bin_prot.Size.sizer ->
  'slot Core_kernel.Bin_prot.Size.sizer ->
  'bool Core_kernel.Bin_prot.Size.sizer ->
  'zkapp_uri Core_kernel.Bin_prot.Size.sizer ->
  ( 'app_state, 'vk, 'zkapp_version, 'field, 'slot, 'bool, 'zkapp_uri ) t
    Core_kernel.Bin_prot.Size.sizer

val bin_write_t : 
  'app_state 'vk 'zkapp_version 'field 'slot 'bool 'zkapp_uri. 'app_state
                                                                 Core_kernel.Bin_prot.Write.writer ->
  'vk Core_kernel.Bin_prot.Write.writer ->
  'zkapp_version Core_kernel.Bin_prot.Write.writer ->
  'field Core_kernel.Bin_prot.Write.writer ->
  'slot Core_kernel.Bin_prot.Write.writer ->
  'bool Core_kernel.Bin_prot.Write.writer ->
  'zkapp_uri Core_kernel.Bin_prot.Write.writer ->
  ( 'app_state, 'vk, 'zkapp_version, 'field, 'slot, 'bool, 'zkapp_uri ) t
    Core_kernel.Bin_prot.Write.writer

val bin_writer_t : 
  'a Core_kernel.Bin_prot.Type_class.writer ->
  'b Core_kernel.Bin_prot.Type_class.writer ->
  'c Core_kernel.Bin_prot.Type_class.writer ->
  'd Core_kernel.Bin_prot.Type_class.writer ->
  'e Core_kernel.Bin_prot.Type_class.writer ->
  'f Core_kernel.Bin_prot.Type_class.writer ->
  'g Core_kernel.Bin_prot.Type_class.writer ->
  ( 'h, 'i, 'j, 'k, 'l, 'm, 'n ) t Core_kernel.Bin_prot.Type_class.writer

val __bin_read_t__ : 
  'app_state 'vk 'zkapp_version 'field 'slot 'bool 'zkapp_uri. 'app_state
                                                                 Core_kernel.Bin_prot.Read.reader ->
  'vk Core_kernel.Bin_prot.Read.reader ->
  'zkapp_version Core_kernel.Bin_prot.Read.reader ->
  'field Core_kernel.Bin_prot.Read.reader ->
  'slot Core_kernel.Bin_prot.Read.reader ->
  'bool Core_kernel.Bin_prot.Read.reader ->
  'zkapp_uri Core_kernel.Bin_prot.Read.reader ->
  ( int ->
    ( 'app_state, 'vk, 'zkapp_version, 'field, 'slot, 'bool, 'zkapp_uri ) t )
    Core_kernel.Bin_prot.Read.reader

val bin_read_t : 
  'app_state 'vk 'zkapp_version 'field 'slot 'bool 'zkapp_uri. 'app_state
                                                                 Core_kernel.Bin_prot.Read.reader ->
  'vk Core_kernel.Bin_prot.Read.reader ->
  'zkapp_version Core_kernel.Bin_prot.Read.reader ->
  'field Core_kernel.Bin_prot.Read.reader ->
  'slot Core_kernel.Bin_prot.Read.reader ->
  'bool Core_kernel.Bin_prot.Read.reader ->
  'zkapp_uri Core_kernel.Bin_prot.Read.reader ->
  ( 'app_state, 'vk, 'zkapp_version, 'field, 'slot, 'bool, 'zkapp_uri ) t
    Core_kernel.Bin_prot.Read.reader

val bin_reader_t : 
  'a Core_kernel.Bin_prot.Type_class.reader ->
  'b Core_kernel.Bin_prot.Type_class.reader ->
  'c Core_kernel.Bin_prot.Type_class.reader ->
  'd Core_kernel.Bin_prot.Type_class.reader ->
  'e Core_kernel.Bin_prot.Type_class.reader ->
  'f Core_kernel.Bin_prot.Type_class.reader ->
  'g Core_kernel.Bin_prot.Type_class.reader ->
  ( 'h, 'i, 'j, 'k, 'l, 'm, 'n ) t Core_kernel.Bin_prot.Type_class.reader

val bin_t : 
  'a Core_kernel.Bin_prot.Type_class.t ->
  'b Core_kernel.Bin_prot.Type_class.t ->
  'c Core_kernel.Bin_prot.Type_class.t ->
  'd Core_kernel.Bin_prot.Type_class.t ->
  'e Core_kernel.Bin_prot.Type_class.t ->
  'f Core_kernel.Bin_prot.Type_class.t ->
  'g Core_kernel.Bin_prot.Type_class.t ->
  ( 'h, 'i, 'j, 'k, 'l, 'm, 'n ) t Core_kernel.Bin_prot.Type_class.t

val version : int

val __versioned__ : unit

val t_of_sexp : 
  'app_state 'vk 'zkapp_version 'field 'slot 'bool 'zkapp_uri. ( Ppx_sexp_conv_lib.Sexp.t ->
                                                                 'app_state ) ->
  ( Ppx_sexp_conv_lib.Sexp.t -> 'vk ) ->
  ( Ppx_sexp_conv_lib.Sexp.t -> 'zkapp_version ) ->
  ( Ppx_sexp_conv_lib.Sexp.t -> 'field ) ->
  ( Ppx_sexp_conv_lib.Sexp.t -> 'slot ) ->
  ( Ppx_sexp_conv_lib.Sexp.t -> 'bool ) ->
  ( Ppx_sexp_conv_lib.Sexp.t -> 'zkapp_uri ) ->
  Ppx_sexp_conv_lib.Sexp.t ->
  ( 'app_state, 'vk, 'zkapp_version, 'field, 'slot, 'bool, 'zkapp_uri ) t

val sexp_of_t : 
  'app_state 'vk 'zkapp_version 'field 'slot 'bool 'zkapp_uri. ( 'app_state ->
                                                                 Ppx_sexp_conv_lib.Sexp.t ) ->
  ( 'vk -> Ppx_sexp_conv_lib.Sexp.t ) ->
  ( 'zkapp_version -> Ppx_sexp_conv_lib.Sexp.t ) ->
  ( 'field -> Ppx_sexp_conv_lib.Sexp.t ) ->
  ( 'slot -> Ppx_sexp_conv_lib.Sexp.t ) ->
  ( 'bool -> Ppx_sexp_conv_lib.Sexp.t ) ->
  ( 'zkapp_uri -> Ppx_sexp_conv_lib.Sexp.t ) ->
  ( 'app_state, 'vk, 'zkapp_version, 'field, 'slot, 'bool, 'zkapp_uri ) t ->
  Ppx_sexp_conv_lib.Sexp.t

val equal : 
  'app_state 'vk 'zkapp_version 'field 'slot 'bool 'zkapp_uri. ( 'app_state ->
                                                                 'app_state ->
                                                                 bool ) ->
  ( 'vk -> 'vk -> bool ) ->
  ( 'zkapp_version -> 'zkapp_version -> bool ) ->
  ( 'field -> 'field -> bool ) ->
  ( 'slot -> 'slot -> bool ) ->
  ( 'bool -> 'bool -> bool ) ->
  ( 'zkapp_uri -> 'zkapp_uri -> bool ) ->
  ( 'app_state, 'vk, 'zkapp_version, 'field, 'slot, 'bool, 'zkapp_uri ) t ->
  ( 'app_state, 'vk, 'zkapp_version, 'field, 'slot, 'bool, 'zkapp_uri ) t ->
  bool

val compare : 
  'app_state 'vk 'zkapp_version 'field 'slot 'bool 'zkapp_uri. ( 'app_state ->
                                                                 'app_state ->
                                                                 int ) ->
  ( 'vk -> 'vk -> int ) ->
  ( 'zkapp_version -> 'zkapp_version -> int ) ->
  ( 'field -> 'field -> int ) ->
  ( 'slot -> 'slot -> int ) ->
  ( 'bool -> 'bool -> int ) ->
  ( 'zkapp_uri -> 'zkapp_uri -> int ) ->
  ( 'app_state, 'vk, 'zkapp_version, 'field, 'slot, 'bool, 'zkapp_uri ) t ->
  ( 'app_state, 'vk, 'zkapp_version, 'field, 'slot, 'bool, 'zkapp_uri ) t ->
  int

val hash_fold_t : 
  'app_state 'vk 'zkapp_version 'field 'slot 'bool 'zkapp_uri. ( Ppx_hash_lib.Std.Hash.state ->
                                                                 'app_state ->
                                                                 Ppx_hash_lib.Std.Hash.state ) ->
  ( Ppx_hash_lib.Std.Hash.state -> 'vk -> Ppx_hash_lib.Std.Hash.state ) ->
  ( Ppx_hash_lib.Std.Hash.state ->
    'zkapp_version ->
    Ppx_hash_lib.Std.Hash.state ) ->
  ( Ppx_hash_lib.Std.Hash.state -> 'field -> Ppx_hash_lib.Std.Hash.state ) ->
  ( Ppx_hash_lib.Std.Hash.state -> 'slot -> Ppx_hash_lib.Std.Hash.state ) ->
  ( Ppx_hash_lib.Std.Hash.state -> 'bool -> Ppx_hash_lib.Std.Hash.state ) ->
  ( Ppx_hash_lib.Std.Hash.state -> 'zkapp_uri -> Ppx_hash_lib.Std.Hash.state ) ->
  Ppx_hash_lib.Std.Hash.state ->
  ( 'app_state, 'vk, 'zkapp_version, 'field, 'slot, 'bool, 'zkapp_uri ) t ->
  Ppx_hash_lib.Std.Hash.state

val to_hlist : 
  ( 'app_state, 'vk, 'zkapp_version, 'field, 'slot, 'bool, 'zkapp_uri ) t ->
  ( unit,
    'app_state ->
    'vk ->
    'zkapp_version ->
    'field Pickles_types.Vector.Vector_5.Stable.V1.t ->
    'slot ->
    'bool ->
    'zkapp_uri ->
    unit )
    H_list.t

val of_hlist : 
  ( unit,
    'app_state ->
    'vk ->
    'zkapp_version ->
    'field Pickles_types.Vector.Vector_5.Stable.V1.t ->
    'slot ->
    'bool ->
    'zkapp_uri ->
    unit )
    H_list.t ->
  ( 'app_state, 'vk, 'zkapp_version, 'field, 'slot, 'bool, 'zkapp_uri ) t

val zkapp_uri : ( 'a, 'b, 'c, 'd, 'e, 'f, 'g ) t -> 'h

val proved_state : ( 'a, 'b, 'c, 'd, 'e, 'f, 'g ) t -> 'h

val last_sequence_slot : ( 'a, 'b, 'c, 'd, 'e, 'f, 'g ) t -> 'h

val sequence_state : 
  ( 'a, 'b, 'c, 'd, 'e, 'f, 'g ) t ->
  'd Pickles_types.Vector.Vector_5.Stable.V1.t

val zkapp_version : ( 'a, 'b, 'c, 'd, 'e, 'f, 'g ) t -> 'h

val verification_key : ( 'a, 'b, 'c, 'd, 'e, 'f, 'g ) t -> 'h

val app_state : ( 'a, 'b, 'c, 'd, 'e, 'f, 'g ) t -> 'h

module Fields : sig ... end