`Tezos_raw_protocol_alpha.Raw_context`

State of the validation.

Two parts:

1. Context.t: what is stored between blocks, this includes an Irmin tree typically stored on disk and the cache (stored in RAM).

2. Additional information needed during the validation of a block but not persisted across blocks, always stored in RAM. The gas counter is here.

`Alpha_context.t`

is actually implemented as `Raw_context.t`

. The difference is that Alpha_context.mli does not expose this so functions manipulating an Alpha_context.t are guaranteed to only access the context through the storage modules exposed in Alpha_context.mli. These modules are in charge of maintaining invariants over the structure of the context.

`type storage_error = `

`| Incompatible_protocol_version of string` |

`| Missing_key of string list * missing_key_kind` |

`| Existing_key of string list` |

`| Corrupted_data of string list` |

An internal storage error that should not happen

`type Tezos_protocol_environment_alpha.Error_monad.error += `

```
| Failed_to_decode_parameter of Tezos_protocol_environment_alpha.Data_encoding.json
* string
``` |

```
val storage_error :
storage_error ->
'a Tezos_protocol_environment_alpha.Error_monad.tzresult
```

Abstract view of the context. Includes a handle to the functional key-value database (`Context`

.t) along with some in-memory values (gas, etc.).

`type root = t`

```
val prepare :
level:Tezos_protocol_environment_alpha.Int32.t ->
predecessor_timestamp:Tezos_protocol_environment_alpha.Time.t ->
timestamp:Tezos_protocol_environment_alpha.Time.t ->
Tezos_protocol_environment_alpha.Context.t ->
t Tezos_protocol_environment_alpha.Error_monad.tzresult
Tezos_protocol_environment_alpha.Lwt.t
```

Retrieves the state of the database and gives its abstract view. It also returns wether this is the first block validated with this version of the protocol.

```
val prepare_first_block :
level:int32 ->
timestamp:Tezos_protocol_environment_alpha.Time.t ->
Tezos_protocol_environment_alpha.Context.t ->
(previous_protocol * t) Tezos_protocol_environment_alpha.Error_monad.tzresult
Tezos_protocol_environment_alpha.Lwt.t
```

```
val activate :
t ->
Tezos_protocol_environment_alpha.Protocol_hash.t ->
t Tezos_protocol_environment_alpha.Lwt.t
```

`val recover : t -> Tezos_protocol_environment_alpha.Context.t`

Returns the state of the database resulting of operations on its abstract view

`val current_level : t -> Level_repr.t`

`val predecessor_timestamp : t -> Tezos_protocol_environment_alpha.Time.t`

`val current_timestamp : t -> Tezos_protocol_environment_alpha.Time.t`

`val constants : t -> Constants_parametric_repr.t`

`val tx_rollup : t -> Constants_parametric_repr.tx_rollup`

`val sc_rollup : t -> Constants_parametric_repr.sc_rollup`

`val zk_rollup : t -> Constants_parametric_repr.zk_rollup`

```
val patch_constants :
t ->
( Constants_parametric_repr.t -> Constants_parametric_repr.t ) ->
t Tezos_protocol_environment_alpha.Lwt.t
```

`val round_durations : t -> Round_repr.Durations.t`

`val cycle_eras : t -> Level_repr.cycle_eras`

Retrieve the cycle eras.

```
val credit_collected_fees_only_call_from_token :
t ->
Tez_repr.t ->
t Tezos_protocol_environment_alpha.Error_monad.tzresult
```

Increment the current block fee stash that will be credited to the payload producer's account at finalize_application

```
val spend_collected_fees_only_call_from_token :
t ->
Tez_repr.t ->
t Tezos_protocol_environment_alpha.Error_monad.tzresult
```

Decrement the current block fee stash that will be credited to the payload producer's account at finalize_application

`val get_collected_fees : t -> Tez_repr.t`

Returns the current block fee stash that will be credited to the payload producer's account at finalize_application

```
val consume_gas_limit_in_block :
t ->
'a Gas_limit_repr.Arith.t ->
t Tezos_protocol_environment_alpha.Error_monad.tzresult
```

`consume_gas_limit_in_block ctxt gas_limit`

checks that `gas_limit`

is well-formed (i.e. it does not exceed the hard gas limit per operation as defined in `ctxt`

, and it is positive), then consumes `gas_limit`

in the current block gas level of `ctxt`

.

`val set_gas_limit : t -> 'a Gas_limit_repr.Arith.t -> t`

`val gas_level : t -> Gas_limit_repr.t`

`val gas_consumed : since:t -> until:t -> Gas_limit_repr.Arith.fp`

`val remaining_operation_gas : t -> Gas_limit_repr.Arith.fp`

`val update_remaining_operation_gas : t -> Gas_limit_repr.Arith.fp -> t`

`val block_gas_level : t -> Gas_limit_repr.Arith.fp`

`val update_remaining_block_gas : t -> Gas_limit_repr.Arith.fp -> t`

```
val init_origination_nonce :
t ->
Tezos_protocol_environment_alpha.Operation_hash.t ->
t
```

`init_origination_nonce ctxt hash`

initialise the origination nonce in memory from `hash`

. See `Origination_nonce.t`

for more information.

```
val get_origination_nonce :
t ->
Origination_nonce.t Tezos_protocol_environment_alpha.Error_monad.tzresult
```

```
val increment_origination_nonce :
t ->
(t * Origination_nonce.t)
Tezos_protocol_environment_alpha.Error_monad.tzresult
```

`unset_origination_nonce ctxt`

unset the origination nonce in memory. To be used only when no more origination can be done in that operation. See `Origination_nonce.t`

for more information.

`include T with type t := t and type local_context := local_context`

```
include Raw_context_intf.VIEW
with type key := key
with type value := value
with type tree := tree
with type t := t
```

`val mem : t -> key -> bool Tezos_protocol_environment_alpha.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_alpha.Lwt.t`

`mem_tree t k`

is like `mem`

but for trees.

```
val get :
t ->
key ->
value Tezos_protocol_environment_alpha.Error_monad.tzresult
Tezos_protocol_environment_alpha.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_alpha.Error_monad.tzresult
Tezos_protocol_environment_alpha.Lwt.t
```

`get_tree`

is like `get`

but for trees.

`val find : t -> key -> value option Tezos_protocol_environment_alpha.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_alpha.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_alpha.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.

```
val init :
t ->
key ->
value ->
t Tezos_protocol_environment_alpha.Error_monad.tzresult
Tezos_protocol_environment_alpha.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_alpha.Error_monad.tzresult
Tezos_protocol_environment_alpha.Lwt.t
```

`init_tree`

is like `init`

but for trees.

```
val update :
t ->
key ->
value ->
t Tezos_protocol_environment_alpha.Error_monad.tzresult
Tezos_protocol_environment_alpha.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_alpha.Error_monad.tzresult
Tezos_protocol_environment_alpha.Lwt.t
```

`update_tree`

is like `update`

but for trees.

`val add : t -> key -> value -> t Tezos_protocol_environment_alpha.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_alpha.Lwt.t`

`add_tree`

is like `add`

but for trees.

`val remove : t -> key -> t Tezos_protocol_environment_alpha.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_alpha.Error_monad.tzresult
Tezos_protocol_environment_alpha.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_alpha.Error_monad.tzresult
Tezos_protocol_environment_alpha.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_alpha.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_alpha.Lwt.t
```

`add_or_remove_tree t k v`

is:

`add_tree t k x`

if`v`

is`Some x`

;`remove t k`

otherwise.

```
val fold :
?depth:Raw_context_intf.depth ->
t ->
key ->
order:[ `Sorted | `Undefined ] ->
init:'a ->
f:( key -> tree -> 'a -> 'a Tezos_protocol_environment_alpha.Lwt.t ) ->
'a Tezos_protocol_environment_alpha.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`

.

`val config : t -> Raw_context_intf.config`

`config t`

is `t`

's hash configuration.

`val length : t -> key -> int Tezos_protocol_environment_alpha.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 `list t k >|= List.length`

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 :
Raw_context_intf.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 : Raw_context_intf.PROOF`

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

```
type ('proof, 'result) verifier :=
'proof ->
( tree -> (tree * 'result) Tezos_protocol_environment_alpha.Lwt.t ) ->
( tree * 'result,
[ `Proof_mismatch of string
| `Stream_too_long of string
| `Stream_too_short of string ] )
Tezos_protocol_environment_alpha.Pervasives.result
Tezos_protocol_environment_alpha.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.

`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 : Raw_context_intf.config -> Raw_context_intf.config -> bool`

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

Internally used in `Storage_functors`

to escape from a view.

Internally used in `Storage_functors`

to retrieve a full key from partial key relative a view.

Raised if block gas quota is exhausted during gas consumption.

Raised if operation gas quota is exhausted during gas consumption.

```
val consume_gas :
t ->
Gas_limit_repr.cost ->
t Tezos_protocol_environment_alpha.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_alpha.Error_monad.tzresult
```

Check if consume_gas will fail

`val description : t Storage_description.t`

```
val with_local_context :
t ->
key ->
( local_context ->
(local_context * 'a) Tezos_protocol_environment_alpha.Error_monad.tzresult
Tezos_protocol_environment_alpha.Lwt.t ) ->
(t * 'a) Tezos_protocol_environment_alpha.Error_monad.tzresult
Tezos_protocol_environment_alpha.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.

Initialize the local nonce used for preventing a script to duplicate an internal operation to replay it.

```
val fresh_internal_nonce :
t ->
(t * int) Tezos_protocol_environment_alpha.Error_monad.tzresult
```

Increments the internal operation nonce.

`val internal_nonce_already_recorded : t -> int -> bool`

Check is the internal operation nonce has been taken.

```
val fold_map_temporary_lazy_storage_ids :
t ->
( Lazy_storage_kind.Temp_ids.t -> Lazy_storage_kind.Temp_ids.t * 'res ) ->
t * 'res
```

```
val map_temporary_lazy_storage_ids_s :
t ->
( Lazy_storage_kind.Temp_ids.t ->
(t * Lazy_storage_kind.Temp_ids.t) Tezos_protocol_environment_alpha.Lwt.t ) ->
t Tezos_protocol_environment_alpha.Lwt.t
```

`module Cache : sig ... end`

```
val record_non_consensus_operation_hash :
t ->
Tezos_protocol_environment_alpha.Operation_hash.t ->
t
```

```
val non_consensus_operations :
t ->
Tezos_protocol_environment_alpha.Operation_hash.t list
```

`type consensus_pk = {`

`delegate : Tezos_protocol_environment_alpha.Signature.Public_key_hash.t;` |

`consensus_pk : Tezos_protocol_environment_alpha.Signature.Public_key.t;` |

`consensus_pkh : Tezos_protocol_environment_alpha.Signature.Public_key_hash.t;` |

`}`

```
val consensus_pk_encoding :
consensus_pk Tezos_protocol_environment_alpha.Data_encoding.t
```

`val dictator_proposal_seen : t -> bool`

Checks whether the dictator voted in this block.

```
val init_sampler_for_cycle :
t ->
Cycle_repr.t ->
Seed_repr.seed ->
consensus_pk Sampler.t ->
t Tezos_protocol_environment_alpha.Error_monad.tzresult
```

`init_sampler_for_cycle ctxt cycle seed state`

caches the seeded stake sampler (a.k.a. `seed, state`

) for `cycle`

in memory for quick access.

```
val sampler_for_cycle :
read:
( t ->
(Seed_repr.seed * consensus_pk Sampler.t)
Tezos_protocol_environment_alpha.Error_monad.tzresult
Tezos_protocol_environment_alpha.Lwt.t ) ->
t ->
Cycle_repr.t ->
(t * Seed_repr.seed * consensus_pk Sampler.t)
Tezos_protocol_environment_alpha.Error_monad.tzresult
Tezos_protocol_environment_alpha.Lwt.t
```

`sampler_for_cycle ~read ctxt cycle`

returns the seeded stake sampler for `cycle`

. The sampler is read in memory if `init_sampler_for_cycle`

or `sampler_for_cycle`

was previously called for the same `cycle`

. Otherwise, it is read "on-disk" with the `read`

function and then cached in `ctxt`

like `init_sampler_for_cycle`

.

```
val stake_distribution_for_current_cycle :
t ->
Tez_repr.t Tezos_protocol_environment_alpha.Signature.Public_key_hash.Map.t
Tezos_protocol_environment_alpha.Error_monad.tzresult
```

```
val init_stake_distribution_for_current_cycle :
t ->
Tez_repr.t Tezos_protocol_environment_alpha.Signature.Public_key_hash.Map.t ->
t
```

`module Internal_for_tests : sig ... end`

`module type CONSENSUS = sig ... end`

```
module Consensus :
CONSENSUS
with type t := t
and type slot := Slot_repr.t
and type 'a slot_map := 'a Slot_repr.Map.t
and type slot_set := Slot_repr.Set.t
and type round := Round_repr.t
and type consensus_pk := consensus_pk
```

`module Tx_rollup : sig ... end`

`module Sc_rollup_in_memory_inbox : sig ... end`

`module Dal : sig ... end`