package octez-smart-rollup-node-lib

  1. Overview
  2. Docs
package octez-smart-rollup-node-lib
Legend:
Library
Module
Module type
Parameter
Class
Class type

This version of the store is used for the rollup nodes for protocols for and after Nairobi, i.e. >= 17.

include module type of struct include Store_v1 end
include module type of struct include Store_v0 end

Storage mapping commitment hashes to the level when they were published by the rollup node. It only contains hashes of commitments published by this rollup node.

Dal_slot_pages is a Store_utils.Nested_map used to store the contents of dal slots fetched by the rollup node, as a list of pages. The values of this storage module have type `string list`. A value of the form page_contents refers to a page of a slot that has been confirmed, and whose contents are page_contents.

include Store_sig.S with type 'a store := 'a Store_v0.store
module Dal_pages = Store_v1.Dal_pages
module Dal_processed_slots = Store_v1.Dal_processed_slots
module Dal_slots_statuses = Store_v1.Dal_slots_statuses

Dal_slots_statuses is a Store_utils.Nested_map used to store the attestation status of DAL slots. The values of this storage module have type ``Confirmed | `Unconfirmed`, depending on whether the content of the slot has been attested on L1 or not. If an entry is not present for a (block_hash, slot_index), this means that the corresponding block is not processed yet.

include Store_sig.S with type 'a store := 'a Store_v1.store
module Messages : Tezos_layer2_store.Indexed_store.INDEXED_FILE with type key := Octez_smart_rollup.Merkelized_payload_hashes_hash.t and type value := string list and type header := Tezos_base.TzPervasives.Block_hash.t

Storage for persisting messages downloaded from the L1 node.

module Inboxes : Tezos_layer2_store.Indexed_store.SIMPLE_INDEXED_FILE with type key := Octez_smart_rollup.Inbox.Hash.t and type value := Octez_smart_rollup.Inbox.t and type header := unit

Storage for persisting inboxes.

module Commitments : Tezos_layer2_store.Indexed_store.SIMPLE_INDEXED_FILE with type key := Octez_smart_rollup.Commitment.Hash.t and type value := Octez_smart_rollup.Commitment.t and type header := unit

Storage containing commitments and corresponding commitment hashes that the rollup node has knowledge of.

module Lcc : sig ... end

Storage containing the last cemented commitment.

module Lpc : Tezos_layer2_store.Indexed_store.SINGLETON_STORE with type value := Octez_smart_rollup.Commitment.t

Storage containing a single commitment for the last published commitment.

module Dal_slots_headers : Tezos_layer2_store.Store_sigs.Nested_map with type primary_key := Tezos_base.TzPervasives.Block_hash.t and type secondary_key := Octez_smart_rollup.Dal.Slot_index.t and type value := Octez_smart_rollup.Dal.Slot_header.t and type 'a store := 'a Irmin_store.t

Published slot headers per block hash, stored as a list of bindings from Dal_slot_index.t to Dal.Slot.t. The encoding function converts this list into a Dal.Slot_index.t-indexed map.

module Dal_confirmed_slots_history : Tezos_layer2_store.Store_sigs.Append_only_map with type key := Tezos_base.TzPervasives.Block_hash.t and type value := Octez_smart_rollup.Dal.Slot_history.t and type 'a store := 'a Irmin_store.t
module Dal_confirmed_slots_histories : Tezos_layer2_store.Store_sigs.Append_only_map with type key := Tezos_base.TzPervasives.Block_hash.t and type value := Octez_smart_rollup.Dal.Slot_history_cache.t and type 'a store := 'a Irmin_store.t

Confirmed DAL slots histories cache. See documentation of Dal_slot_repr.Slots_history for more details.

module Protocols : sig ... end
module Gc_levels : sig ... end

Data related to the effects of garbage collection.

module History_mode : Tezos_layer2_store.Indexed_store.SINGLETON_STORE with type value := Octez_smart_rollup_node.Configuration.history_mode

History mode of the rollup node.

type +'a store = {
  1. l2_blocks : 'a L2_blocks.t;
  2. messages : 'a Messages.t;
  3. inboxes : 'a Inboxes.t;
  4. commitments : 'a Commitments.t;
  5. commitments_published_at_level : 'a Commitments_published_at_level.t;
  6. l2_head : 'a L2_head.t;
  7. last_finalized_level : 'a Last_finalized_level.t;
  8. lcc : 'a Lcc.t;
  9. lpc : 'a Lpc.t;
  10. levels_to_hashes : 'a Levels_to_hashes.t;
  11. protocols : 'a Protocols.t;
  12. irmin_store : 'a Irmin_store.t;
  13. gc_levels : 'a Gc_levels.t;
  14. history_mode : 'a History_mode.t;
}
include Store_sig.S with type 'a store := 'a store
type 'a t = [< `Read | `Write Read ] as 'a store

Type of store. The parameter indicates if the store can be written or only read.

type rw = Tezos_layer2_store.Store_sigs.rw t

Read/write store t.

type ro = Tezos_layer2_store.Store_sigs.ro t

Read only store t.

val version : Store_version.t

Version supported by this code.

close store closes the store.

val load : 'a Tezos_layer2_store.Store_sigs.mode -> index_buffer_size:int -> l2_blocks_cache_size:int -> string -> 'a store Tezos_base.TzPervasives.tzresult Lwt.t

load mode ~index_buffer_size ~l2_blocks_cache_size directory loads a store from the data persisted in directory. If mode is Store_sigs.Read_only, then the indexes and irmin store will be opened in readonly mode and only read operations will be permitted. This allows to open a store for read access that is already opened in Store_sigs.Read_write mode in another process. index_buffer_size is the maximum cache size in memory before it is flushed to disk. l2_blocks_cache_size is the number of L2 blocks the rollup node will keep in memory.

val readonly : _ t -> ro

readonly store returns a read-only version of store.

val iter_l2_blocks : ?progress:string -> Metadata.t -> _ t -> (Octez_smart_rollup.Sc_rollup_block.t -> unit Tezos_base.TzPervasives.tzresult Lwt.t) -> unit Tezos_base.TzPervasives.tzresult Lwt.t

iter_l2_blocks ?progress metadata store f iterates f on all L2 blocks reachable from the head, from newest to oldest. If progress is provided, a progress bar is displayed with the progress messages during the iteration.

val gc : rw -> level:int32 -> unit Tezos_base.TzPervasives.tzresult Lwt.t

gc store ~level asynchronously garbage collects everything from the store that concerns blocks for levels below level.

val wait_gc_completion : 'a t -> unit Lwt.t

wait_gc_completion store returns a blocking thread if a GC run is currently ongoing.

val is_gc_finished : 'a t -> bool

is_gc_finished t returns true if there is no GC running.

OCaml

Innovation. Community. Security.

GitHub Discord Twitter Peertube RSS
About
Changelog Releases Industrial Users Academic Users Why OCaml
Ecosystem
Packages Community Events OCaml Planet Jobs
Resources
Install OCaml Get Started Platform Tools Language Manual Standard Library API Books Exercises Papers OCaml Playground Logo
Policies
Carbon Footprint Governance Privacy Code of Conduct