Transaction_snark_scan_state (transaction_snark_scan_state.Transaction_snark_scan

module Ledger = Mina_ledger.Ledger

module Stable : sig ... end

type t = Stable.Latest.t

include Ppx_sexp_conv_lib.Sexpable.S with type t := t

val t_of_sexp : Sexplib0__.Sexp.t -> t

val sexp_of_t : t -> Sexplib0__.Sexp.t

module Transaction_with_witness : sig ... end

module Ledger_proof_with_sok_message : sig ... end

module Available_job : sig ... end

module Space_partition : sig ... end

module Job_view : sig ... end

module Make_statement_scanner (Verifier : sig ... end) : sig ... end

val empty : 
  constraint_constants:Genesis_constants.Constraint_constants.t ->
  unit ->
  t

val fill_work_and_enqueue_transactions : 
  t ->
  Transaction_with_witness.t list ->
  Transaction_snark_work.t list ->
  ((Ledger_proof.t
    * (Mina_transaction.Transaction.t Mina_base.With_status.t
       * Mina_base.State_hash.t)
        list)
     option
   * t)
    Core_kernel.Or_error.t

val latest_ledger_proof : 
  t ->
  (Ledger_proof_with_sok_message.t
   * (Mina_transaction.Transaction.t Mina_base.With_status.t
      * Mina_base.State_hash.t)
       list)
    option

val free_space : t -> int

val base_jobs_on_latest_tree : t -> Transaction_with_witness.t list

val base_jobs_on_earlier_tree : 
  t ->
  index:int ->
  Transaction_with_witness.t list

val hash : t -> Mina_base.Staged_ledger_hash.Aux_hash.t

val staged_transactions : 
  t ->
  Mina_transaction.Transaction.t Mina_base.With_status.t list

All the transactions in the order in which they were applied

val staged_transactions_with_protocol_states : 
  t ->
  get_state:
    ( Mina_base.State_hash.t ->
      Mina_state.Protocol_state.value Core_kernel.Or_error.t ) ->
  (Mina_transaction.Transaction.t Mina_base.With_status.t
   * Mina_state.Protocol_state.value)
    list
    Core_kernel.Or_error.t

All the transactions with parent protocol state of the block in which they were included in the order in which they were applied

val partition_if_overflowing : t -> Space_partition.t

Available space and the corresponding required work-count in one and/or two trees (if the slots to be occupied are in two different trees)

val statement_of_job : Available_job.t -> Transaction_snark.Statement.t option

val snark_job_list_json : t -> string

val all_work_statements_exn : 
  t ->
  Transaction_snark.Statement.t One_or_two.t list

All the proof bundles

val required_work_pairs : t -> slots:int -> Available_job.t One_or_two.t list

Required proof bundles for a certain number of slots

val k_work_pairs_for_new_diff : t -> k:int -> Available_job.t One_or_two.t list

K proof bundles

val work_statements_for_new_diff : 
  t ->
  Transaction_snark.Statement.t One_or_two.t list

All the proof bundles for 2**transaction_capacity_log2 slots that can be used up in one diff

val next_on_new_tree : t -> bool

True if the latest tree is full and transactions would be added on to a new tree

val update_metrics : t -> unit Core_kernel.Or_error.t

update scan state metrics

val required_state_hashes : t -> Mina_base.State_hash.Set.t

Hashes of the protocol states required for proving transactions

val check_required_protocol_states : 
  t ->
  protocol_states:
    Mina_state.Protocol_state.value Mina_base.State_hash.With_state_hashes.t
      list ->
  Mina_state.Protocol_state.value Mina_base.State_hash.With_state_hashes.t list
    Core_kernel.Or_error.t

Validate protocol states required for proving the transactions. Returns an association list of state_hash and the corresponding state

val all_work_pairs : 
  t ->
  get_state:
    ( Mina_base.State_hash.t ->
      Mina_state.Protocol_state.value Core_kernel.Or_error.t ) ->
  ( Transaction_witness.t, Ledger_proof.t ) Snark_work_lib.Work.Single.Spec.t
    One_or_two.t
    list
    Core_kernel.Or_error.t

All the proof bundles for snark workers