tezos-protocol-020-PsParisC 20.1

type root

The type for root contexts.

include VIEW

type t

The type for context views.

type key = string list

The type for context keys.

type value = bytes

The type for context values.

type tree

The type for context trees.

Getters

val mem : t -> key -> bool Tezos_protocol_environment_020_PsParisC.Lwt.t

mem t k is an Lwt promise that resolves to true iff k is bound to a value in t.

val mem_tree : t -> key -> bool Tezos_protocol_environment_020_PsParisC.Lwt.t

mem_tree t k is like mem but for trees.

val get : 
  t ->
  key ->
  value Tezos_protocol_environment_020_PsParisC.Error_monad.tzresult
    Tezos_protocol_environment_020_PsParisC.Lwt.t

get t k is an Lwt promise that resolves to Ok v if k is bound to the value v in t and Storage_ErrorMissing_key otherwise.

val get_tree : 
  t ->
  key ->
  tree Tezos_protocol_environment_020_PsParisC.Error_monad.tzresult
    Tezos_protocol_environment_020_PsParisC.Lwt.t

get_tree is like get but for trees.

val find : 
  t ->
  key ->
  value option Tezos_protocol_environment_020_PsParisC.Lwt.t

find t k is an Lwt promise that resolves to Some v if k is bound to the value v in t and None otherwise.

val find_tree : 
  t ->
  key ->
  tree option Tezos_protocol_environment_020_PsParisC.Lwt.t

find_tree t k is like find but for trees.

val list : 
  t ->
  ?offset:int ->
  ?length:int ->
  key ->
  (string * tree) list Tezos_protocol_environment_020_PsParisC.Lwt.t

list t key is the list of files and sub-nodes stored under k in t. The result order is not specified but is stable.

offset and length are used for pagination.

Setters

val init : 
  t ->
  key ->
  value ->
  t Tezos_protocol_environment_020_PsParisC.Error_monad.tzresult
    Tezos_protocol_environment_020_PsParisC.Lwt.t

init t k v is an Lwt promise that resolves to Ok c if:

k is unbound in t;
k is bound to v in c;
and c is similar to t otherwise.

It is Storage_errorExisting_key if k is already bound in t.

val init_tree : 
  t ->
  key ->
  tree ->
  t Tezos_protocol_environment_020_PsParisC.Error_monad.tzresult
    Tezos_protocol_environment_020_PsParisC.Lwt.t

init_tree is like init but for trees.

val update : 
  t ->
  key ->
  value ->
  t Tezos_protocol_environment_020_PsParisC.Error_monad.tzresult
    Tezos_protocol_environment_020_PsParisC.Lwt.t

update t k v is an Lwt promise that resolves to Ok c if:

k is bound in t;
k is bound to v in c;
and c is similar to t otherwise.

It is Storage_errorMissing_key if k is not already bound in t.

val update_tree : 
  t ->
  key ->
  tree ->
  t Tezos_protocol_environment_020_PsParisC.Error_monad.tzresult
    Tezos_protocol_environment_020_PsParisC.Lwt.t

update_tree is like update but for trees.

val add : t -> key -> value -> t Tezos_protocol_environment_020_PsParisC.Lwt.t

add t k v is an Lwt promise that resolves to c such that:

k is bound to v in c;
and c is similar to t otherwise.

If k was already bound in t to a value that is physically equal to v, the result of the function is a promise that resolves to t. Otherwise, the previous binding of k in t disappears.

val add_tree : 
  t ->
  key ->
  tree ->
  t Tezos_protocol_environment_020_PsParisC.Lwt.t

add_tree is like add but for trees.

val remove : t -> key -> t Tezos_protocol_environment_020_PsParisC.Lwt.t

remove t k v is an Lwt promise that resolves to c such that:

k is unbound in c;
and c is similar to t otherwise.

val remove_existing : 
  t ->
  key ->
  t Tezos_protocol_environment_020_PsParisC.Error_monad.tzresult
    Tezos_protocol_environment_020_PsParisC.Lwt.t

remove_existing t k v is an Lwt promise that resolves to Ok c if:

k is bound in t to a value;
k is unbound in c;
and c is similar to t otherwise.

val remove_existing_tree : 
  t ->
  key ->
  t Tezos_protocol_environment_020_PsParisC.Error_monad.tzresult
    Tezos_protocol_environment_020_PsParisC.Lwt.t

remove_existing_tree t k v is an Lwt promise that reolves to Ok c if:

k is bound in t to a tree;
k is unbound in c;
and c is similar to t otherwise.

val add_or_remove : 
  t ->
  key ->
  value option ->
  t Tezos_protocol_environment_020_PsParisC.Lwt.t

add_or_remove t k v is:

add t k x if v is Some x;
remove t k otherwise.

val add_or_remove_tree : 
  t ->
  key ->
  tree option ->
  t Tezos_protocol_environment_020_PsParisC.Lwt.t

add_or_remove_tree t k v is:

add_tree t k x if v is Some x;
remove t k otherwise.

Folds

val fold : 
  ?depth:depth ->
  t ->
  key ->
  order:[ `Sorted | `Undefined ] ->
  init:'a ->
  f:(key -> tree -> 'a -> 'a Tezos_protocol_environment_020_PsParisC.Lwt.t) ->
  'a Tezos_protocol_environment_020_PsParisC.Lwt.t

fold ?depth t root ~order ~init ~f recursively folds over the trees and values of t. The f callbacks are called with a key relative to root. f is never called with an empty key for values; i.e., folding over a value is a no-op.

The depth is 0-indexed. If depth is set (by default it is not), then f is only called when the conditions described by the parameter is true:

Eq d folds over nodes and values of depth exactly d.
Lt d folds over nodes and values of depth strictly less than d.
Le d folds over nodes and values of depth less than or equal to d.
Gt d folds over nodes and values of depth strictly more than d.
Ge d folds over nodes and values of depth more than or equal to d.

If order is `Sorted (the default), the elements are traversed in lexicographic order of their keys. For large nodes, it is memory-consuming, use `Undefined for a more memory efficient fold.

Hash configurations

val config : t -> config

config t is t's hash configuration.

val length : t -> key -> int Tezos_protocol_environment_020_PsParisC.Lwt.t

length t key is an Lwt promise that resolves to the number of files and sub-nodes stored under k in t.

It is equivalent to let+ l = list t k in List.length l but has a constant-time complexity.

Most of the time, this function does not perform any I/O as the length is cached in the tree. It may perform one read to load the root node of the tree in case it has not been loaded already. The initial constant is the same between list and length. They both perform the same kind of I/O reads. While list usually performs a linear number of reads, length does at most one.

module Tree : 
  TREE
    with type t := t
     and type key := key
     and type value := value
     and type tree := tree

Tree provides immutable, in-memory partial mirror of the context, with lazy reads and delayed writes. The trees are Merkle trees that carry the same hash as the part of the context they mirror.

module Proof : PROOF

Proofs are compact representations of trees which can be shared between peers.

type ('proof, 'result) verifier :=
  'proof ->
  (tree -> (tree * 'result) Tezos_protocol_environment_020_PsParisC.Lwt.t) ->
  (tree * 'result,
    [ `Proof_mismatch of string
    | `Stream_too_long of string
    | `Stream_too_short of string ])
    Tezos_protocol_environment_020_PsParisC.Pervasives.result
    Tezos_protocol_environment_020_PsParisC.Lwt.t

verify p f runs f in checking mode. f is a function that takes a tree as input and returns a new version of the tree and a result. p is a proof, that is a minimal representation of the tree that contains what f should be expecting.

Therefore, contrary to trees found in a storage, the contents of the trees passed to f may not be available. For this reason, looking up a value at some path can now produce three distinct outcomes:

A value v is present in the proof p and returned : find tree path is a promise returning Some v;
path is known to have no value in tree : find tree path is a promise returning None; and
path is known to have a value in tree but p does not provide it because f should not need it: verify returns an error classifying path as an invalid path (see below).

The same semantics apply to all operations on the tree t passed to f and on all operations on the trees built from f.

The generated tree is the tree after f has completed. That tree is disconnected from any storage (i.e. index). It is possible to run operations on it as long as they don't require loading shallowed subtrees.

The result is Error (`Msg _) if the proof is rejected:

For tree proofs: when p.before is different from the hash of p.state;
For tree and stream proofs: when p.after is different from the hash of f p.state;
For tree proofs: when f p.state tries to access invalid paths in p.state;
For stream proofs: when the proof is not consumed in the exact same order it was produced;
For stream proofs: when the proof is too short or not empty once f is done.

raises Failure
if the proof version is invalid or incompatible with the verifier.

type tree_proof := Proof.tree Proof.t

The type for tree proofs.

Guarantee that the given computation performs exactly the same state operations as the generating computation, *in some order*.

val verify_tree_proof : (tree_proof, 'a) verifier

verify_tree_proof is the verifier of tree proofs.

type stream_proof := Proof.stream Proof.t

The type for stream proofs.

Guarantee that the given computation performs exactly the same state operations as the generating computation, in the exact same order.

val verify_stream_proof : (stream_proof, 'a) verifier

verify_stream is the verifier of stream proofs.

val equal_config : config -> config -> bool

The equality function for context configurations. If two context have the same configuration, they will generate the same context hashes.

val project : t -> root

Internally used in Storage_functors to escape from a view.

val absolute_key : t -> key -> key

Internally used in Storage_functors to retrieve a full key from partial key relative a view.

type Tezos_protocol_environment_020_PsParisC.Error_monad.error +=

| Block_quota_exceeded

Raised if block gas quota is exhausted during gas consumption.

type Tezos_protocol_environment_020_PsParisC.Error_monad.error +=

| Operation_quota_exceeded

Raised if operation gas quota is exhausted during gas consumption.

val consume_gas : 
  t ->
  Gas_limit_repr.cost ->
  t Tezos_protocol_environment_020_PsParisC.Error_monad.tzresult

Internally used in Storage_functors to consume gas from within a view. May raise Block_quota_exceeded or Operation_quota_exceeded.

val check_enough_gas : 
  t ->
  Gas_limit_repr.cost ->
  unit Tezos_protocol_environment_020_PsParisC.Error_monad.tzresult

Check if consume_gas will fail

val description : t Storage_description.t

type local_context

The type for local context accesses instead from the root. In order for the carbonated storage functions to consume the gas, this has gas infomation

val with_local_context : 
  t ->
  key ->
  (local_context ->
    (local_context * 'a)
      Tezos_protocol_environment_020_PsParisC.Error_monad.tzresult
      Tezos_protocol_environment_020_PsParisC.Lwt.t) ->
  (t * 'a) Tezos_protocol_environment_020_PsParisC.Error_monad.tzresult
    Tezos_protocol_environment_020_PsParisC.Lwt.t

with_local_context ctxt key f runs function f over the local context at path key of the global ctxt. Using the local context f can perform faster context accesses under key.

module Local_context : sig ... end

Local_context provides functions for local access from a specific directory.

package tezos-protocol-020-PsParisC

Getters

Setters

Folds

Hash configurations