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
include module type of struct include Store_v2 end
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.

include Store_sig.S with type 'a store := 'a Store_v0.store

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 = Store_v2.Messages

Storage for persisting messages downloaded from the L1 node.

module Inboxes = Store_v2.Inboxes

Storage for persisting inboxes.

module Commitments = Store_v2.Commitments

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

module Lcc = Store_v2.Lcc

Storage containing the last cemented commitment.

module Lpc = Store_v2.Lpc

Storage containing a single commitment for the last published commitment.

module Dal_slots_headers = Store_v2.Dal_slots_headers

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 Protocols = Store_v2.Protocols
module Gc_levels = Store_v2.Gc_levels

Data related to the effects of garbage collection.

module Last_context_split = Store_v2.Last_context_split

Level at which context was last split.

module History_mode = Store_v2.History_mode

History mode of the rollup node.

type +'a store = 'a Store_v2.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. last_context_split_level : 'a Last_context_split.t;
  15. 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.

Read/write store 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.

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