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

type ('pk, 'id, 'token_permissions, 'token_symbol, 'amount, 'nonce, 'receipt_chain_hash, 'delegate, 'state_hash, 'timing, 'permissions, 'zkapp_opt)
  t =
  {

public_key : 'pk;

token_id : 'id;

token_permissions : 'token_permissions;

token_symbol : 'token_symbol;

balance : 'amount;

nonce : 'nonce;

receipt_chain_hash : 'receipt_chain_hash;

delegate : 'delegate;

voting_for : 'state_hash;

timing : 'timing;

permissions : 'permissions;

zkapp : 'zkapp_opt;

}

val to_yojson : 
  'pk 'id 'token_permissions 'token_symbol 'amount 'nonce 'receipt_chain_hash 'delegate 'state_hash 'timing 'permissions 'zkapp_opt. 
  ( 'pk ->
    Yojson.Safe.t ) ->
  ( 'id -> Yojson.Safe.t ) ->
  ( 'token_permissions -> Yojson.Safe.t ) ->
  ( 'token_symbol -> Yojson.Safe.t ) ->
  ( 'amount -> Yojson.Safe.t ) ->
  ( 'nonce -> Yojson.Safe.t ) ->
  ( 'receipt_chain_hash -> Yojson.Safe.t ) ->
  ( 'delegate -> Yojson.Safe.t ) ->
  ( 'state_hash -> Yojson.Safe.t ) ->
  ( 'timing -> Yojson.Safe.t ) ->
  ( 'permissions -> Yojson.Safe.t ) ->
  ( 'zkapp_opt -> Yojson.Safe.t ) ->
  ( 'pk,
    'id,
    'token_permissions,
    'token_symbol,
    'amount,
    'nonce,
    'receipt_chain_hash,
    'delegate,
    'state_hash,
    'timing,
    'permissions,
    'zkapp_opt )
    t ->
  Yojson.Safe.t

val of_yojson : 
  'pk 'id 'token_permissions 'token_symbol 'amount 'nonce 'receipt_chain_hash 'delegate 'state_hash 'timing 'permissions 'zkapp_opt. 
  ( Yojson.Safe.t ->
    'pk Ppx_deriving_yojson_runtime.error_or ) ->
  ( Yojson.Safe.t -> 'id Ppx_deriving_yojson_runtime.error_or ) ->
  ( Yojson.Safe.t -> 'token_permissions Ppx_deriving_yojson_runtime.error_or ) ->
  ( Yojson.Safe.t -> 'token_symbol Ppx_deriving_yojson_runtime.error_or ) ->
  ( Yojson.Safe.t -> 'amount Ppx_deriving_yojson_runtime.error_or ) ->
  ( Yojson.Safe.t -> 'nonce Ppx_deriving_yojson_runtime.error_or ) ->
  ( Yojson.Safe.t -> 'receipt_chain_hash Ppx_deriving_yojson_runtime.error_or ) ->
  ( Yojson.Safe.t -> 'delegate Ppx_deriving_yojson_runtime.error_or ) ->
  ( Yojson.Safe.t -> 'state_hash Ppx_deriving_yojson_runtime.error_or ) ->
  ( Yojson.Safe.t -> 'timing Ppx_deriving_yojson_runtime.error_or ) ->
  ( Yojson.Safe.t -> 'permissions Ppx_deriving_yojson_runtime.error_or ) ->
  ( Yojson.Safe.t -> 'zkapp_opt Ppx_deriving_yojson_runtime.error_or ) ->
  Yojson.Safe.t ->
  ( 'pk,
    'id,
    'token_permissions,
    'token_symbol,
    'amount,
    'nonce,
    'receipt_chain_hash,
    'delegate,
    'state_hash,
    'timing,
    'permissions,
    'zkapp_opt )
    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 -> 'h Ppx_deriving_yojson_runtime.error_or ) ->
  ( Yojson.Safe.t -> 'i Ppx_deriving_yojson_runtime.error_or ) ->
  ( Yojson.Safe.t -> 'j Ppx_deriving_yojson_runtime.error_or ) ->
  ( Yojson.Safe.t -> 'k Ppx_deriving_yojson_runtime.error_or ) ->
  ( Yojson.Safe.t -> 'l Ppx_deriving_yojson_runtime.error_or ) ->
  Yojson.Safe.t ->
  ( 'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, 'j, 'k, 'l ) 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 ->
  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 : 
  'pk 'id 'token_permissions 'token_symbol 'amount 'nonce 'receipt_chain_hash 'delegate 'state_hash 'timing 'permissions 'zkapp_opt. 
  'pk Core_kernel.Bin_prot.Size.sizer ->
  'id Core_kernel.Bin_prot.Size.sizer ->
  'token_permissions Core_kernel.Bin_prot.Size.sizer ->
  'token_symbol Core_kernel.Bin_prot.Size.sizer ->
  'amount Core_kernel.Bin_prot.Size.sizer ->
  'nonce Core_kernel.Bin_prot.Size.sizer ->
  'receipt_chain_hash Core_kernel.Bin_prot.Size.sizer ->
  'delegate Core_kernel.Bin_prot.Size.sizer ->
  'state_hash Core_kernel.Bin_prot.Size.sizer ->
  'timing Core_kernel.Bin_prot.Size.sizer ->
  'permissions Core_kernel.Bin_prot.Size.sizer ->
  'zkapp_opt Core_kernel.Bin_prot.Size.sizer ->
  ( 'pk,
    'id,
    'token_permissions,
    'token_symbol,
    'amount,
    'nonce,
    'receipt_chain_hash,
    'delegate,
    'state_hash,
    'timing,
    'permissions,
    'zkapp_opt )
    t
    Core_kernel.Bin_prot.Size.sizer

val bin_write_t : 
  'pk 'id 'token_permissions 'token_symbol 'amount 'nonce 'receipt_chain_hash 'delegate 'state_hash 'timing 'permissions 'zkapp_opt. 
  'pk Core_kernel.Bin_prot.Write.writer ->
  'id Core_kernel.Bin_prot.Write.writer ->
  'token_permissions Core_kernel.Bin_prot.Write.writer ->
  'token_symbol Core_kernel.Bin_prot.Write.writer ->
  'amount Core_kernel.Bin_prot.Write.writer ->
  'nonce Core_kernel.Bin_prot.Write.writer ->
  'receipt_chain_hash Core_kernel.Bin_prot.Write.writer ->
  'delegate Core_kernel.Bin_prot.Write.writer ->
  'state_hash Core_kernel.Bin_prot.Write.writer ->
  'timing Core_kernel.Bin_prot.Write.writer ->
  'permissions Core_kernel.Bin_prot.Write.writer ->
  'zkapp_opt Core_kernel.Bin_prot.Write.writer ->
  ( 'pk,
    'id,
    'token_permissions,
    'token_symbol,
    'amount,
    'nonce,
    'receipt_chain_hash,
    'delegate,
    'state_hash,
    'timing,
    'permissions,
    'zkapp_opt )
    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 Core_kernel.Bin_prot.Type_class.writer ->
  'i Core_kernel.Bin_prot.Type_class.writer ->
  'j Core_kernel.Bin_prot.Type_class.writer ->
  'k Core_kernel.Bin_prot.Type_class.writer ->
  'l Core_kernel.Bin_prot.Type_class.writer ->
  ( 'm, 'n, 'o, 'p, 'q, 'r, 's, 't, 'u, 'v, 'w, 'x ) t
    Core_kernel.Bin_prot.Type_class.writer

val __bin_read_t__ : 
  'pk 'id 'token_permissions 'token_symbol 'amount 'nonce 'receipt_chain_hash 'delegate 'state_hash 'timing 'permissions 'zkapp_opt. 
  'pk Core_kernel.Bin_prot.Read.reader ->
  'id Core_kernel.Bin_prot.Read.reader ->
  'token_permissions Core_kernel.Bin_prot.Read.reader ->
  'token_symbol Core_kernel.Bin_prot.Read.reader ->
  'amount Core_kernel.Bin_prot.Read.reader ->
  'nonce Core_kernel.Bin_prot.Read.reader ->
  'receipt_chain_hash Core_kernel.Bin_prot.Read.reader ->
  'delegate Core_kernel.Bin_prot.Read.reader ->
  'state_hash Core_kernel.Bin_prot.Read.reader ->
  'timing Core_kernel.Bin_prot.Read.reader ->
  'permissions Core_kernel.Bin_prot.Read.reader ->
  'zkapp_opt Core_kernel.Bin_prot.Read.reader ->
  ( int ->
    ( 'pk,
      'id,
      'token_permissions,
      'token_symbol,
      'amount,
      'nonce,
      'receipt_chain_hash,
      'delegate,
      'state_hash,
      'timing,
      'permissions,
      'zkapp_opt )
      t )
    Core_kernel.Bin_prot.Read.reader

val bin_read_t : 
  'pk 'id 'token_permissions 'token_symbol 'amount 'nonce 'receipt_chain_hash 'delegate 'state_hash 'timing 'permissions 'zkapp_opt. 
  'pk Core_kernel.Bin_prot.Read.reader ->
  'id Core_kernel.Bin_prot.Read.reader ->
  'token_permissions Core_kernel.Bin_prot.Read.reader ->
  'token_symbol Core_kernel.Bin_prot.Read.reader ->
  'amount Core_kernel.Bin_prot.Read.reader ->
  'nonce Core_kernel.Bin_prot.Read.reader ->
  'receipt_chain_hash Core_kernel.Bin_prot.Read.reader ->
  'delegate Core_kernel.Bin_prot.Read.reader ->
  'state_hash Core_kernel.Bin_prot.Read.reader ->
  'timing Core_kernel.Bin_prot.Read.reader ->
  'permissions Core_kernel.Bin_prot.Read.reader ->
  'zkapp_opt Core_kernel.Bin_prot.Read.reader ->
  ( 'pk,
    'id,
    'token_permissions,
    'token_symbol,
    'amount,
    'nonce,
    'receipt_chain_hash,
    'delegate,
    'state_hash,
    'timing,
    'permissions,
    'zkapp_opt )
    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 Core_kernel.Bin_prot.Type_class.reader ->
  'i Core_kernel.Bin_prot.Type_class.reader ->
  'j Core_kernel.Bin_prot.Type_class.reader ->
  'k Core_kernel.Bin_prot.Type_class.reader ->
  'l Core_kernel.Bin_prot.Type_class.reader ->
  ( 'm, 'n, 'o, 'p, 'q, 'r, 's, 't, 'u, 'v, 'w, 'x ) 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 Core_kernel.Bin_prot.Type_class.t ->
  'i Core_kernel.Bin_prot.Type_class.t ->
  'j Core_kernel.Bin_prot.Type_class.t ->
  'k Core_kernel.Bin_prot.Type_class.t ->
  'l Core_kernel.Bin_prot.Type_class.t ->
  ( 'm, 'n, 'o, 'p, 'q, 'r, 's, 't, 'u, 'v, 'w, 'x ) t
    Core_kernel.Bin_prot.Type_class.t

val version : int

val __versioned__ : unit

val t_of_sexp : 
  'pk 'id 'token_permissions 'token_symbol 'amount 'nonce 'receipt_chain_hash 'delegate 'state_hash 'timing 'permissions 'zkapp_opt. 
  ( Ppx_sexp_conv_lib.Sexp.t ->
    'pk ) ->
  ( Ppx_sexp_conv_lib.Sexp.t -> 'id ) ->
  ( Ppx_sexp_conv_lib.Sexp.t -> 'token_permissions ) ->
  ( Ppx_sexp_conv_lib.Sexp.t -> 'token_symbol ) ->
  ( Ppx_sexp_conv_lib.Sexp.t -> 'amount ) ->
  ( Ppx_sexp_conv_lib.Sexp.t -> 'nonce ) ->
  ( Ppx_sexp_conv_lib.Sexp.t -> 'receipt_chain_hash ) ->
  ( Ppx_sexp_conv_lib.Sexp.t -> 'delegate ) ->
  ( Ppx_sexp_conv_lib.Sexp.t -> 'state_hash ) ->
  ( Ppx_sexp_conv_lib.Sexp.t -> 'timing ) ->
  ( Ppx_sexp_conv_lib.Sexp.t -> 'permissions ) ->
  ( Ppx_sexp_conv_lib.Sexp.t -> 'zkapp_opt ) ->
  Ppx_sexp_conv_lib.Sexp.t ->
  ( 'pk,
    'id,
    'token_permissions,
    'token_symbol,
    'amount,
    'nonce,
    'receipt_chain_hash,
    'delegate,
    'state_hash,
    'timing,
    'permissions,
    'zkapp_opt )
    t

val sexp_of_t : 
  'pk 'id 'token_permissions 'token_symbol 'amount 'nonce 'receipt_chain_hash 'delegate 'state_hash 'timing 'permissions 'zkapp_opt. 
  ( 'pk ->
    Ppx_sexp_conv_lib.Sexp.t ) ->
  ( 'id -> Ppx_sexp_conv_lib.Sexp.t ) ->
  ( 'token_permissions -> Ppx_sexp_conv_lib.Sexp.t ) ->
  ( 'token_symbol -> Ppx_sexp_conv_lib.Sexp.t ) ->
  ( 'amount -> Ppx_sexp_conv_lib.Sexp.t ) ->
  ( 'nonce -> Ppx_sexp_conv_lib.Sexp.t ) ->
  ( 'receipt_chain_hash -> Ppx_sexp_conv_lib.Sexp.t ) ->
  ( 'delegate -> Ppx_sexp_conv_lib.Sexp.t ) ->
  ( 'state_hash -> Ppx_sexp_conv_lib.Sexp.t ) ->
  ( 'timing -> Ppx_sexp_conv_lib.Sexp.t ) ->
  ( 'permissions -> Ppx_sexp_conv_lib.Sexp.t ) ->
  ( 'zkapp_opt -> Ppx_sexp_conv_lib.Sexp.t ) ->
  ( 'pk,
    'id,
    'token_permissions,
    'token_symbol,
    'amount,
    'nonce,
    'receipt_chain_hash,
    'delegate,
    'state_hash,
    'timing,
    'permissions,
    'zkapp_opt )
    t ->
  Ppx_sexp_conv_lib.Sexp.t

val equal : 
  'pk 'id 'token_permissions 'token_symbol 'amount 'nonce 'receipt_chain_hash 'delegate 'state_hash 'timing 'permissions 'zkapp_opt. 
  ( 'pk ->
    'pk ->
    bool ) ->
  ( 'id -> 'id -> bool ) ->
  ( 'token_permissions -> 'token_permissions -> bool ) ->
  ( 'token_symbol -> 'token_symbol -> bool ) ->
  ( 'amount -> 'amount -> bool ) ->
  ( 'nonce -> 'nonce -> bool ) ->
  ( 'receipt_chain_hash -> 'receipt_chain_hash -> bool ) ->
  ( 'delegate -> 'delegate -> bool ) ->
  ( 'state_hash -> 'state_hash -> bool ) ->
  ( 'timing -> 'timing -> bool ) ->
  ( 'permissions -> 'permissions -> bool ) ->
  ( 'zkapp_opt -> 'zkapp_opt -> bool ) ->
  ( 'pk,
    'id,
    'token_permissions,
    'token_symbol,
    'amount,
    'nonce,
    'receipt_chain_hash,
    'delegate,
    'state_hash,
    'timing,
    'permissions,
    'zkapp_opt )
    t ->
  ( 'pk,
    'id,
    'token_permissions,
    'token_symbol,
    'amount,
    'nonce,
    'receipt_chain_hash,
    'delegate,
    'state_hash,
    'timing,
    'permissions,
    'zkapp_opt )
    t ->
  bool

val compare : 
  'pk 'id 'token_permissions 'token_symbol 'amount 'nonce 'receipt_chain_hash 'delegate 'state_hash 'timing 'permissions 'zkapp_opt. 
  ( 'pk ->
    'pk ->
    int ) ->
  ( 'id -> 'id -> int ) ->
  ( 'token_permissions -> 'token_permissions -> int ) ->
  ( 'token_symbol -> 'token_symbol -> int ) ->
  ( 'amount -> 'amount -> int ) ->
  ( 'nonce -> 'nonce -> int ) ->
  ( 'receipt_chain_hash -> 'receipt_chain_hash -> int ) ->
  ( 'delegate -> 'delegate -> int ) ->
  ( 'state_hash -> 'state_hash -> int ) ->
  ( 'timing -> 'timing -> int ) ->
  ( 'permissions -> 'permissions -> int ) ->
  ( 'zkapp_opt -> 'zkapp_opt -> int ) ->
  ( 'pk,
    'id,
    'token_permissions,
    'token_symbol,
    'amount,
    'nonce,
    'receipt_chain_hash,
    'delegate,
    'state_hash,
    'timing,
    'permissions,
    'zkapp_opt )
    t ->
  ( 'pk,
    'id,
    'token_permissions,
    'token_symbol,
    'amount,
    'nonce,
    'receipt_chain_hash,
    'delegate,
    'state_hash,
    'timing,
    'permissions,
    'zkapp_opt )
    t ->
  int

val hash_fold_t : 
  'pk 'id 'token_permissions 'token_symbol 'amount 'nonce 'receipt_chain_hash 'delegate 'state_hash 'timing 'permissions 'zkapp_opt. 
  ( Ppx_hash_lib.Std.Hash.state ->
    'pk ->
    Ppx_hash_lib.Std.Hash.state ) ->
  ( Ppx_hash_lib.Std.Hash.state -> 'id -> Ppx_hash_lib.Std.Hash.state ) ->
  ( Ppx_hash_lib.Std.Hash.state ->
    'token_permissions ->
    Ppx_hash_lib.Std.Hash.state ) ->
  ( Ppx_hash_lib.Std.Hash.state ->
    'token_symbol ->
    Ppx_hash_lib.Std.Hash.state ) ->
  ( Ppx_hash_lib.Std.Hash.state -> 'amount -> Ppx_hash_lib.Std.Hash.state ) ->
  ( Ppx_hash_lib.Std.Hash.state -> 'nonce -> Ppx_hash_lib.Std.Hash.state ) ->
  ( Ppx_hash_lib.Std.Hash.state ->
    'receipt_chain_hash ->
    Ppx_hash_lib.Std.Hash.state ) ->
  ( Ppx_hash_lib.Std.Hash.state -> 'delegate -> Ppx_hash_lib.Std.Hash.state ) ->
  ( Ppx_hash_lib.Std.Hash.state -> 'state_hash -> Ppx_hash_lib.Std.Hash.state ) ->
  ( Ppx_hash_lib.Std.Hash.state -> 'timing -> Ppx_hash_lib.Std.Hash.state ) ->
  ( Ppx_hash_lib.Std.Hash.state ->
    'permissions ->
    Ppx_hash_lib.Std.Hash.state ) ->
  ( Ppx_hash_lib.Std.Hash.state -> 'zkapp_opt -> Ppx_hash_lib.Std.Hash.state ) ->
  Ppx_hash_lib.Std.Hash.state ->
  ( 'pk,
    'id,
    'token_permissions,
    'token_symbol,
    'amount,
    'nonce,
    'receipt_chain_hash,
    'delegate,
    'state_hash,
    'timing,
    'permissions,
    'zkapp_opt )
    t ->
  Ppx_hash_lib.Std.Hash.state

val zkapp : ( 'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, 'j, 'k, 'l ) t -> 'm

val permissions : ( 'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, 'j, 'k, 'l ) t -> 'm

val timing : ( 'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, 'j, 'k, 'l ) t -> 'm

val voting_for : ( 'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, 'j, 'k, 'l ) t -> 'm

val delegate : ( 'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, 'j, 'k, 'l ) t -> 'm

val receipt_chain_hash : 
  ( 'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, 'j, 'k, 'l ) t ->
  'm

val nonce : ( 'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, 'j, 'k, 'l ) t -> 'm

val balance : ( 'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, 'j, 'k, 'l ) t -> 'm

val token_symbol : ( 'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, 'j, 'k, 'l ) t -> 'm

val token_permissions : 
  ( 'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, 'j, 'k, 'l ) t ->
  'm

val token_id : ( 'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, 'j, 'k, 'l ) t -> 'm

val public_key : ( 'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, 'j, 'k, 'l ) t -> 'm

module Fields : sig ... end

val to_hlist : 
  ( 'pk,
    'id,
    'token_permissions,
    'token_symbol,
    'amount,
    'nonce,
    'receipt_chain_hash,
    'delegate,
    'state_hash,
    'timing,
    'permissions,
    'zkapp_opt )
    t ->
  ( unit,
    'pk ->
    'id ->
    'token_permissions ->
    'token_symbol ->
    'amount ->
    'nonce ->
    'receipt_chain_hash ->
    'delegate ->
    'state_hash ->
    'timing ->
    'permissions ->
    'zkapp_opt ->
    unit )
    H_list.t

val of_hlist : 
  ( unit,
    'pk ->
    'id ->
    'token_permissions ->
    'token_symbol ->
    'amount ->
    'nonce ->
    'receipt_chain_hash ->
    'delegate ->
    'state_hash ->
    'timing ->
    'permissions ->
    'zkapp_opt ->
    unit )
    H_list.t ->
  ( 'pk,
    'id,
    'token_permissions,
    'token_symbol,
    'amount,
    'nonce,
    'receipt_chain_hash,
    'delegate,
    'state_hash,
    'timing,
    'permissions,
    'zkapp_opt )
    t

val to_latest : 'a -> 'a