This module defines costs for the adaptive issuance operations.

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.

This module is responsible for ensuring that a delegate doesn't get slashed twice for the same offense. To do so, it maintains the Storage.Already_denounced table, which tracks which denunciations have already been seen in blocks.

Amendments and proposals.

This module supports advancing the ledger state by applying operations.

Types representing results of applying an internal operation.

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.

This module provides functions that can be used in a private network to delay initial rewarding, typically when waiting for more bakers to join the network.

A bounded cache associating values to keys.

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.

An in-memory data-structure for a key-value map where all operations account for gas costs.

This module provides functions to extract the value of protocol parameters from the context. See Constant_repr.parametric for more details about these values.

This module deals with the delegates of a contract. It is responsible for maintaining the tables Storage.Contract.Delegate and Storage.Contract.Delegated.

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.

This module defines RPC services to access the information associated to contracts (balance, delegate, script, etc.).

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

This module provides a type and functions to manipulate cycle numbers.

This modules handles all the validation/application/finalisation of any operation related to the DAL.

Slot attestation representation for the data-availability layer.

Storage management of slots for the data-availability layer.

This module deals with delegates' activity. Typically, the provided functions can be used to deactivate a delegate that has not shown activity for a certain number of cycles, and to reactivate it when appropriate.

Management of a delegate's consensus key, the one used to sign blocks and consensus operations. It is responsible for maintaining the tables Storage.Consensus_keys, Storage.Contract.Consensus_key, and Storage.Contract.Pending_consensus_keys.

Per-cycle management of delegates.

This modules deals with delegates' participation in consensus.

This module draws random values for a cycle based on the Seed_repr.seed associated that cycle. These random values are only delegates associated with slots. The selection of delegates is done by sampling from a particular distribution of the stake among the active delegates.

This module defines RPC services to access the information associated to delegates (who they are, their delegators, their different kinds of balances, their activity, etc.).

This module handles the slashing of delegates for double signing.

This module groups everything related to delegate registration. For the invariants maintained, see the submodule Contract.

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.

This module maintains the storage related to forbidden delegates. It is responsible for maintaining the Storage.Tenderbake.Forbidden_delegates table.

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, scripts 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.

Issuance bonus.

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.

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

Counters are used as anti-replay protection mechanism in manager operations: each manager account stores a counter and each manager operation declares a value for the counter. When a manager operation is applied, the value of the counter of its manager is checked and incremented.

This module implements a mempool structure meant to be used by a shell and bakers in order to incrementally accumulate commutative operations which could then be safely used to bake a new block. These mempool components guarantee a set of properties useful for these purposes:

This module provides the gas costs for typechecking Michelson scripts, parsing and unparsing Michelson values, and interpreting Michelson instructions.

A specialized Blake2B implementation for hashing nonces.

This module provides types and functions to manipulate 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.

This module deals with pending denunciations before they are used to slash delegates.

Options available for per-block votes

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 introduces the semantics of Proof-generating Virtual Machines.

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

Defines storage for Smart Contract Optimistic Rollups.

This module contains constants and utility functions for gas metering functions used when handling SC rollups operations in context.

DAL related parameters for the PVMs.

The values are versioned, to let the possibility to modify the values in future iterations of the protocol.

The smart contract rollup refutation game types are defined here, as well as the basic pure logic for:

This module exposes a type t that represents inbox messages. Inbox messages are produced by the Layer 1 protocol and are encoded using the serialize function, before being added to a smart-contract rollup's inbox.

This module provides instantiation of both the WASM and Arith PVM which can be used to perform rollup computations, but cannot be used to compute proofs.

This module provides a typed API for the Rollup Management Protocol that defines the communication protocol for exchanging messages between Layer 1 and Layer 2 for smart-contract rollups.

Static rollup-related metadata for the PVMs.

This module defines a data type t that represents messages from Layer 2 to Layer 1.

A module for managing state concerning a rollup's outbox.

A refutation game proof is required as part of the final move in a game.

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

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

Here is the list of PVMs available in this protocol.

Semantics of logical and bit-shift operators for bytes

This module manages the cache for smart contracts.

A specialized Blake2B implementation for hashing Michelson expressions.

This is the Michelson interpreter.

Functions to ease the manipulation of Michelson maps.

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

Functions to ease the manipulation of sets of values in Michelson.

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

This module registers all the errors from Script_tc_errors as a top-level effect.

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

This modules handles the storage of random nonce seeds.

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

Slot index representation

Functions on stake and depending on the context.

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

This module is responsible for maintaining the Storage.Contract.Frozen_deposits_pseudotokens and Storage.Contract.Staking_pseudotokens tables.

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.

A module for representing the increase/decrease of tickets in the storage. It will be used to display ticket update information in the operation receipt.

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 giver, container, or receiver represents a kind of account that holds a given (or possibly infinite) amount of tokens.

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

Simple abstraction from low-level storage to handle unstake requests.

Datatype for a map from cycle to deposits, where all unslashable cycles are squashed.

Simple abstraction from low-level storage to handle unstaked frozen deposits.

This module provides functions pertaining to the validation of blocks and operations. Most elements in this module are either used or wrapped in the Main module (though some of them are also directly used by the plugin).

Manages all the voting related storage in Storage.Vote.

This module provides RPC services that return voting-related information.

This module handles all the validation/application of any operation related to the ZK Rollup. All of the functions defined in this module require that the ZKRU feature flag is enabled.

Abstraction layer for the public inputs to the ZKRU aPlonk circuits.

A module for representing and extracting typed ZK rollup parameters.

Representation of scalars used by the ZK Rollup alongside manipulation functions

Payload of a ZK Rollup update operation. The operator only needs to send a subset of the public inputs defined in Zk_rollup_circuit_public_inputs_repr, the rest is provided by the protocol.