Module Mina_ledger.Ledger

include Merkle_mask.Maskable_merkle_tree_intf.S with module Location := Location with module Addr = Location.Addr with type root_hash := Mina_base.Ledger_hash.t and type hash := Mina_base.Ledger_hash.t and type account := Mina_base.Account.t and type key := Signature_lib.Public_key.Compressed.t and type token_id := Mina_base.Token_id.t and type token_id_set := Mina_base.Token_id.Set.t and type account_id := Mina_base.Account_id.t and type account_id_set := Mina_base.Account_id.Set.t and type t = Mask.Attached.t and type attached_mask = Mask.Attached.t and type unattached_mask = Mask.t
include Merkle_mask.Base_merkle_tree_intf.S with module Location := Location with module Addr = Location.Addr with type root_hash := Mina_base.Ledger_hash.t with type hash := Mina_base.Ledger_hash.t with type account := Mina_base.Account.t with type key := Signature_lib.Public_key.Compressed.t with type token_id := Mina_base.Token_id.t with type token_id_set := Mina_base.Token_id.Set.t with type account_id := Mina_base.Account_id.t with type account_id_set := Mina_base.Account_id.Set.t with type t = Mask.Attached.t
type index = int

no deriving, purposely; signatures that include this one may add deriving

module Addr = Location.Addr
include Merkle_ledger.Syncable_intf.S with type root_hash := Mina_base.Ledger_hash.t and type hash := Mina_base.Ledger_hash.t and type account := Mina_base.Account.t and type addr := Addr.t and type path = Path.t and type t := 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
type path = Path.t
val depth : t -> int
val merkle_path_at_addr_exn : t -> Addr.t -> path
val get_inner_hash_at_addr_exn : t -> Addr.t -> Mina_base.Ledger_hash.t
val set_inner_hash_at_addr_exn : t -> Addr.t -> Mina_base.Ledger_hash.t -> unit
val set_all_accounts_rooted_at_exn : t -> Addr.t -> Mina_base.Account.t list -> unit
val set_batch_accounts : t -> (Addr.t * Mina_base.Account.t) list -> unit
val get_all_accounts_rooted_at_exn : t -> Addr.t -> (Addr.t * Mina_base.Account.t) list

Get all of the accounts that are in a subtree of the underlying Merkle tree rooted at `address`. The accounts are ordered by their addresses.

val make_space_for : t -> int -> unit
val to_list : t -> Mina_base.Account.t list

list of accounts in the ledger

val iteri : t -> f:( index -> Mina_base.Account.t -> unit ) -> unit

iterate over all indexes and accounts

val foldi : t -> init:'accum -> f:( Addr.t -> 'accum -> Mina_base.Account.t -> 'accum ) -> 'accum

fold over accounts in the ledger, passing the Merkle address

val foldi_with_ignored_accounts : t -> Mina_base.Account_id.Set.t -> init:'accum -> f:( Addr.t -> 'accum -> Mina_base.Account.t -> 'accum ) -> 'accum

the set of account_ids are ledger elements to skip during the fold, because they're in a mask

val fold_until : t -> init:'accum -> f: ( 'accum -> Mina_base.Account.t -> ( 'accum, 'stop ) Base.Continue_or_stop.t ) -> finish:( 'accum -> 'stop ) -> 'stop

fold over accounts until stop condition reached when calling f; calls finish for result

val accounts : t -> Mina_base.Account_id.Set.t

set of account ids associated with accounts

val token_owner : t -> Mina_base.Token_id.t -> Mina_base.Account_id.t option

Get the account id that owns a token.

val token_owners : t -> Mina_base.Account_id.Set.t

Get the set of all accounts which own a token.

Get all of the tokens for which a public key has accounts.

val location_of_account : t -> Mina_base.Account_id.t -> Location.t option
val location_of_account_batch : t -> Mina_base.Account_id.t list -> (Mina_base.Account_id.t * Location.t option) list
val get_or_create_account : t -> Mina_base.Account_id.t -> Mina_base.Account.t -> ([ `Added | `Existed ] * Location.t) Core.Or_error.t

This may return an error if the ledger is full.

val close : t -> unit

the ledger should not be used after calling close

val last_filled : t -> Location.t option

for account locations in the ledger, the last (rightmost) filled location

val get_uuid : t -> Uuid.t
val get_directory : t -> string option

return Some directory for ledgers that use a file system, else None

val get : t -> Location.t -> Mina_base.Account.t option
val get_batch : t -> Location.t list -> (Location.t * Mina_base.Account.t option) list
val set : t -> Location.t -> Mina_base.Account.t -> unit
val set_batch : t -> (Location.t * Mina_base.Account.t) list -> unit
val get_at_index_exn : t -> int -> Mina_base.Account.t
val set_at_index_exn : t -> int -> Mina_base.Account.t -> unit
val index_of_account_exn : t -> Mina_base.Account_id.t -> int
val merkle_root : t -> Mina_base.Ledger_hash.t

meant to be a fast operation: the root hash is stored, rather than calculated dynamically

val merkle_path : t -> Location.t -> Path.t
val merkle_path_at_index_exn : t -> int -> Path.t
val remove_accounts_exn : t -> Mina_base.Account_id.t list -> unit
val detached_signal : t -> unit Async_kernel.Deferred.t

Triggers when the ledger has been detached and should no longer be accessed.

type unattached_mask = Mask.t
type attached_mask = Mask.Attached.t
val remove_and_reparent_exn : t -> attached_mask -> unit

* o * / * / * o --- o - * ^ ^ \ * parent | \ * mask o * children * * Removes the attached mask from its parent and attaches the children to the * parent instead. Raises an exception if the merkle roots of the mask and the * parent are not the same.

module Debug : sig ... end
val unregister_mask_exn : loc:string -> Mask.Attached.t -> Mask.t
type maskable_ledger = t
val with_ledger : depth:int -> f:( t -> 'a ) -> 'a
val with_ephemeral_ledger : depth:int -> f:( t -> 'a ) -> 'a
val create : ?directory_name:string -> depth:int -> unit -> t
val create_ephemeral : depth:int -> unit -> t
val of_database : Db.t -> t
val copy : t -> t

This is not _really_ copy, merely a stop-gap until we remove usages of copy in our codebase. What this actually does is creates a new empty mask on top of the current ledger

val register_mask : t -> Mask.t -> Mask.Attached.t
val commit : Mask.Attached.t -> unit
module Transaction_applied : sig ... end
val create_new_account_exn : t -> Mina_base.Account_id.t -> Mina_base.Account.t -> unit

Raises if the ledger is full, or if an account already exists for the given Account_id.t.

val apply_fee_transfer : constraint_constants:Genesis_constants.Constraint_constants.t -> txn_global_slot:Mina_numbers.Global_slot.t -> t -> Mina_base.Fee_transfer.t -> Transaction_applied.Fee_transfer_applied.t Core.Or_error.t
val apply_coinbase : constraint_constants:Genesis_constants.Constraint_constants.t -> txn_global_slot:Mina_numbers.Global_slot.t -> t -> Mina_base.Coinbase.t -> Transaction_applied.Coinbase_applied.t Core.Or_error.t

update sequence state, returned slot is new last sequence slot made available here so we can use this logic in the Zkapp_command generators

val has_locked_tokens : global_slot:Mina_numbers.Global_slot.t -> account_id:Mina_base.Account_id.t -> t -> bool Core.Or_error.t
val merkle_root_after_user_command_exn : constraint_constants:Genesis_constants.Constraint_constants.t -> txn_global_slot:Mina_numbers.Global_slot.t -> t -> Mina_base.Signed_command.With_valid_signature.t -> Mina_base.Ledger_hash.t
val create_empty_exn : t -> Mina_base.Account_id.t -> Path.t * Mina_base.Account.t

Raises if the ledger is full.

val num_accounts : t -> int
val sexp_of_init_state : init_state -> Ppx_sexp_conv_lib.Sexp.t
val gen_initial_ledger_state : init_state Core.Quickcheck.Generator.t

Generate an initial ledger state. There can't be a regular Quickcheck generator for this type because you need to detach a mask from its parent when you're done with it - the GC doesn't take care of that.

val apply_initial_ledger_state : t -> init_state -> unit

Apply a generated state to a blank, concrete ledger.