Module type Database_intf.S

include Base_ledger_intf.S
type root_hash

a Merkle hash associated with the root node

type hash

a Merkle hash associated any non-root node

type account
type key
type token_id
type token_id_set
type account_id
type account_id_set
type index = int
type t

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

module Addr : module type of Merkle_address
module Path : Merkle_path.S with type hash := hash
module Location : sig ... end
include Syncable_intf.S with type root_hash := root_hash and type hash := hash and type account := account 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 num_accounts : t -> int
val merkle_path_at_addr_exn : t -> Addr.t -> path
val get_inner_hash_at_addr_exn : t -> Addr.t -> hash
val set_inner_hash_at_addr_exn : t -> Addr.t -> hash -> unit
val set_all_accounts_rooted_at_exn : t -> Addr.t -> account list -> unit
val set_batch_accounts : t -> (Addr.t * account) list -> unit
val get_all_accounts_rooted_at_exn : t -> Addr.t -> (Addr.t * account) 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 -> account list

list of accounts in the ledger

val iteri : t -> f:( index -> account -> unit ) -> unit

iterate over all indexes and accounts

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

fold over accounts in the ledger, passing the Merkle address

val foldi_with_ignored_accounts : t -> account_id_set -> init:'accum -> f:( Addr.t -> 'accum -> account -> '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 -> account -> ( '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 -> account_id_set

set of account ids associated with accounts

val token_owner : t -> token_id -> account_id option

Get the account id that owns a token.

val token_owners : t -> account_id_set

Get the set of all accounts which own a token.

val tokens : t -> key -> token_id_set

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

val location_of_account : t -> account_id -> Location.t option
val location_of_account_batch : t -> account_id list -> (account_id * Location.t option) list
val get_or_create_account : t -> account_id -> account -> ([ `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 -> account option
val get_batch : t -> Location.t list -> (Location.t * account option) list
val set : t -> Location.t -> account -> unit
val set_batch : t -> (Location.t * account) list -> unit
val get_at_index_exn : t -> int -> account
val set_at_index_exn : t -> int -> account -> unit
val index_of_account_exn : t -> account_id -> int
val merkle_root : t -> root_hash

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 -> account_id list -> unit
val detached_signal : t -> unit Async_kernel.Deferred.t

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

val create : ?directory_name:string -> depth:int -> unit -> t
val create_checkpoint : t -> directory_name:string -> unit -> t

create_checkpoint would create the checkpoint and open a db connection to that checkpoint

val make_checkpoint : t -> directory_name:string -> unit

make_checkpoint would only create the checkpoint

val with_ledger : depth:int -> f:( t -> 'a ) -> 'a
module For_tests : sig ... end