An Alpha_context.t is an immutable snapshot of the ledger state at some block height, preserving type-safety and invariants of the ledger state.

This declares Protocol RPC services.

Amendments and proposals.

This module supports advancing the ledger state by applying operations.

Types representing results of applying an operation.

This module handles hashes of implicit contract addresses used for commitments in the origin block.

Representation of block headers.

A specialized Blake2B implementation for hashing block's payloads.

Value on which validators try to reach a consensus.

This module defines identifiers for frozen bonds.

Frequently used data should be kept in memory and persisted along a chain of blocks. The caching mechanism allows the economic protocol to declare such data and to rely on a Least Recently Used strategy to keep the cache size under a fixed limit.

The Carbonated_map_costs module contains gas cost functions for Carbonated_map.

A specialized Blake2B implementation for hashing contract identifiers.

This module defines identifiers for two basic types of contracts. It also specifies how to compute originated contract's hash from origination nonce.

Low-level handlers of raw contexts for base operations on contracts.

Dependent booleans

The type of the destination argument of the Operation_repr.manager_operation.Transaction manager operation.

This module defines a standard signature for modules providing fixed-point arithmetic.

Simple abstraction from low-level storage to handle frozen deposits

Gas_input_size includes the definitions for the different sizes used in the gas models of the protocol. They do not always represent memory sizes, but rather they can be seen as an information size. They are tailored to the models that use them, and should not be used for anything other than gas computation.

Gas_input_size includes the definitions for the different sizes used in the gas models of the protocol. They do not always represent memory sizes, but rather they can be seen as an information size. They are tailored to the models that use them, and should not be used for anything other than gas computation.

Internal representation of the gas limit available to the node baking a new block. It should be proportional to the time and energy required to perform a computation.

Costs function for the global table of constants.

This module represents access to a global table of constant Micheline values. Users may register a Micheline value in the table, paying the cost of storage. Once stored, contracts source code may reference this value by its hash.

In transaction rollups, some values can be replaced by indexes in the messages sent from the layer-1 to the layer-2.

Functions to setup storage. Used by Alpha_context.prepare.

See Lazy_storage_kind for an introduction on lazy storage.

Lazy_storage offers a unified interface for specific Michelson datatype that behave somewhat lazily, because they are intended to be quite big. Instead of serializing/deserializing the whole value to/from the storage, only an identifier is used. The identifier acts like a pointer. When using the value in a Michelson script, some part of it may be read from the storage, and a lightweight diff is computed. The diff is effectively applied to the storage at the end of the execution.

This module defines the protocol representation of a level. Besides the "raw level", which is the shell's notion of the level, this representation also contains additional information, like the cycle the level belongs to.

Options available for the Liquidity Baking per-block vote

This module exposes an API for local gas counting. It provides a set of functions for updating a gas counter without applying it on an an Alpha_context.context.

Tezos Protocol Implementation - Protocol Signature Instance

A specialized Blake2B implementation for hashing nonces.

Tezos Protocol Implementation - Low level Repr. of Operations

This module defines protocol parameters, i.e. constants regulating the behaviour of the blockchain under the protocol.

State of the validation.

All context manipulation functions. This signature is included as-is for direct context accesses, and used in Storage_functors to provide restricted views to the context.

A round represents an iteration of the single-shot consensus algorithm.

Efficient sampling from given finitely supported (nonzero, positive) measures using the alias method. Measures need not be normalized on input, but sampling proceeds from the normalized probability measure associated to the given measure.

This module provides saturated arithmetic between 0 and 2^62 - 1.

This module provides a temporary toy rollup to be used as a demo.

This module provides a refutation game logic for smart contract rollups.

Merkelizing inbox for smart-contract rollups.

The basic components of an optimistic rollup for smart-contracts.

Defines storage for Smart Contract Optimistic Rollups.

This module defines Tick.t, an execution step counter for smart-contract rollups.

This module manages the cache for smart contracts.

A specialized Blake2B implementation for hashing Michelson expressions.

This is the Michelson interpreter.

Defines a Michelson expression representation as a Micheline node with canonical (int) location and Michelson_v1_primitives.prim as content.

Strings of printable characters

This module defines the typechecking context used during the translation from Michelson untyped nodes to typed nodes (Script_ir_translator). The context keeps track of the origin of the code (top-level from a contract, in a view, etc.), plus some information to allow or forbid instructions given the context (no `SELF` in a lambda for example).

Defines the internal Michelson representation for timestamps and basic operations that can be performed on it.

This module provides overapproximation of memory footprint for Michelson-related values.

Tezos Protocol Implementation - Random number generation

Functions for RPC service registration, using Updater.rpc_context and RPC_service.t from the Protocol Environment.

This module provides an implementation of the skip list data structure.

Slot index representation

This library provides basic operations (accessors and setters) on staking tokens.

A specialized Blake2B implementation for hashing internal states of random number generators.

Tezos Protocol Implementation - Typed storage

This module is responsible for building the description of the current state of the storage, which is then used to build specification of the RPC endpoints for accessing the storage. It produces resto RPC_directory.t values, which can be used directly to construct the RPC endpoint tree.

Tezos Protocol Implementation - Typed storage builders.

This module exposes a function for generating a ticket-balance key-hash given an owner and a ticket-token. The key-hash is used for populating the global ticket-balance table that tracks ownership of tickets for different tokens.

This module contains constants and utility functions for gas metering functions used for extracting and handling tickets for the global ticket balance table.

Ticket hashes are used to uniquely identify pairs made of Michelson ticktes and their owner.

A module that provides functionality for extracting ticket-token differences from a list of operations.

This module provides an API for extracting tickets of arbitrary types from an OCaml values, given a type-witness.

A module for handling ticket-tokens. A ticket-token represents the combination of a ticketer (creator of a ticket) and the content. That is, a ticket comprises a ticket-token and an amount.

A module exposing a carbonated map where keys are Ticket_token.ex_token values.

The aim of this module is to manage operations involving tokens such as minting, transferring, and burning. Every constructor of the types source, container, or sink represents a kind of account that holds a given (or possibly infinite) amount of tokens.

This module introduces various functions to manipulate the storage related to commitments for transaction rollups.

Functions to manipulate transaction rollup’s inboxes.

This module introduces the types used to identify ticket holders within a transaction rollup.

This module introduces the interpretation (off-chain) of layer2 operations read from its inboxes.

This module introduces the batches of transactions that the layer-2 (1) reads from its inboxes (see Tx_rollup_message_repr.t.Batch), and (2) interprets off-chain.

A specialized Blake2B implementation for hashing tx_rollup contexts.

This module is an abstraction on top of int64 to build positive (or zero) quantities within the int64 bounds. It comes with a compact encoding to be used in the transaction rollup batches.

The Blake2B hash of a message.

Communication from the layer-1 (Tezos) to the layer-2 (a transaction rollup) happens thanks to messages, crafted in the layer-1 to be interpreted in the layer-2.

The hash of the result of a layer-2 operation: that is, the hash of (l2_ctxt_hash ^ withdraw_hash) where l2_ctxt_hash is the Merkle tree root of the L2 context after any message (ie. deposit or batch), and withdraw_hash is a Tx_rollup_withdraw_repr.withdrawals_merkle_root

A module for representing and extracting typed transactional rollup parameters.

This module defines identifiers for transaction only rollup (or tx rollup). It also specifies how to compute originated tx rollup's hash from origination nonce.

A collection of functions to manipulate the state of a transaction rollup.

This module provides various helpers to manipulate tickets, that are used by the Transaction Rollups.

Manages all the voting related storage in Storage.Vote.