`Register.C`

```
val equal_config :
Tezos_context_sigs.Config.t ->
Tezos_context_sigs.Config.t ->
bool
```

`mem t k`

is an Lwt promise that resolves to `true`

iff `k`

is bound to a value in `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.

`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.

`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.

`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.

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

`config t`

is `t`

's hash configuration.

`module Tree : sig ... end`

`val set_protocol : t -> Tezos_crypto.Hashed.Protocol_hash.t -> t Lwt.t`

`val get_protocol : t -> Tezos_crypto.Hashed.Protocol_hash.t Lwt.t`

```
val fork_test_chain :
t ->
protocol:Tezos_crypto.Hashed.Protocol_hash.t ->
expiration:Tezos_base.TzPervasives.Time.Protocol.t ->
t Lwt.t
```

```
val set_hash_version :
t ->
Tezos_crypto.Hashed.Context_hash.Version.t ->
t Tezos_base.TzPervasives.tzresult Lwt.t
```

`val get_hash_version : t -> Tezos_crypto.Hashed.Context_hash.Version.t`

`module Proof : sig ... end`

`type tree_proof := Proof.tree Proof.t`

`type stream_proof := Proof.stream Proof.t`

`val verify_tree_proof : (tree_proof, 'a) verifier`

`val verify_stream_proof : (stream_proof, 'a) verifier`