Module Tezos_protocol_plugin_alpha.Mempool

type error_classification = [
| `Branch_delayed of Tezos_base.TzPervasives.tztrace
| `Branch_refused of Tezos_base.TzPervasives.tztrace
| `Refused of Tezos_base.TzPervasives.tztrace
| `Outdated of Tezos_base.TzPervasives.tztrace
]
type nanotez = Q.t
val nanotez_enc : nanotez Tezos_base.TzPervasives.Data_encoding.t
val manager_op_replacement_factor_enc : Q.t Tezos_base.TzPervasives.Data_encoding.t
type config = {
minimal_fees : Tezos_protocol_alpha.Protocol.Alpha_context.Tez.t;
minimal_nanotez_per_gas_unit : nanotez;
minimal_nanotez_per_byte : nanotez;
allow_script_failure : bool;(*

If true, this makes post_filter_manager unconditionally return `Passed_postfilter filter_state, no matter the operation's success.

*)
clock_drift : Tezos_protocol_alpha.Protocol.Alpha_context.Period.t option;
replace_by_fee_factor : Q.t;(*

This field determines the amount of additional fees (given as a factor of the declared fees) a manager should add to an operation in order to (eventually) replace an existing (prechecked) one in the mempool. Note that other criteria, such as the gas ratio, are also taken into account to decide whether to accept the replacement or not.

*)
max_prechecked_manager_operations : int;(*

Maximal number of prechecked operations to keep. The mempool only keeps the max_prechecked_manager_operations operations with the highest fee/gas and fee/size ratios.

*)
}
val default_minimal_nanotez_per_gas_unit : Q.t
val default_minimal_nanotez_per_byte : Q.t
val managers_index : int
val default_config : config
val config_encoding : config Tezos_base.TzPervasives.Data_encoding.t

An Alpha_context manager operation, packed so that the type is not parametrized by 'kind.

type manager_op_info = {
manager_op : manager_op;(*

Used when we want to remove the operation with Validate.remove_manager_operation.

*)
fee : Tezos_protocol_alpha.Protocol.Alpha_context.Tez.t;
gas_limit : Tezos_protocol_alpha.Protocol.Fixed_point_repr.integral_tag Tezos_protocol_alpha.Protocol.Alpha_context.Gas.Arith.t;(*

Both fee and gas_limit are used to determine whether a new operation from the same manager should replace this one.

*)
weight : Q.t;(*

Used to update ops_prechecked and min_prechecked_op_weight in state when appropriate.

*)
}

Information stored for each prechecked manager operation.

Note that this record does not include the operation hash because it is instead used as key in the map that stores this information in the state below.

type manager_op_weight = {
operation_hash : Tezos_crypto.Operation_hash.t;
weight : Q.t;
}

Build a manager_op_weight from operation hash and manager_op_info.

val compare_manager_op_weight : manager_op_weight -> manager_op_weight -> int
module ManagerOpWeightSet : sig ... end
type state_info = {
grandparent_level_start : Tezos_protocol_alpha.Protocol.Alpha_context.Timestamp.t;
round_zero_duration : Tezos_protocol_alpha.Protocol.Alpha_context.Period.t;
proposal_round : Tezos_protocol_alpha.Protocol.Alpha_context.Round.t;
alpha_ctxt : Tezos_protocol_alpha.Protocol.Alpha_context.t;(*

Protocol context at the initialization of the mempool filter. Note that it never gets updated.

*)
}

Static information to store in the filter state.

type state = {
state_info : state_info option;
prechecked_manager_op_count : int;(*

Number of prechecked manager operations. Invariants:

  • prechecked_manager_op_count = Operation_hash.Map.cardinal prechecked_manager_ops = ManagerOpWeightSet.cardinal prechecked_op_weights
  • prechecked_manager_op_count <= max_prechecked_manager_operations
*)
prechecked_manager_ops : manager_op_info Tezos_crypto.Operation_hash.Map.t;(*

All prechecked manager operations. See manager_op_info.

*)
prechecked_op_weights : ManagerOpWeightSet.t;(*

The manager_op_weight of all prechecked manager operations.

*)
min_prechecked_op_weight : manager_op_weight option;(*

The prechecked operation in op_prechecked_managers, if any, with the minimal weight. Invariant:

  • min_prechecked_op_weight = min { x | x \in prechecked_op_weights }
*)
}
val empty : state
val manager_prio : 'a -> [> `Low of 'a ]
val consensus_prio : [> `High ]
val other_prio : [> `Medium ]
val on_flush : 'a -> state -> ?validation_state:Tezos_protocol_alpha.Protocol.validation_state -> predecessor:Tezos_base.Block_header.t -> unit -> state Tezos_base.TzPervasives.tzresult Lwt.t
type Tezos_protocol_alpha.Environment.Error_monad.error +=
| Removed_fees_too_low_for_mempool

Returns the weight and resources consumption of an operation. The weight corresponds to the one implemented by the baker, to decide which operations to put in a block first (the code is largely duplicated). See Tezos_baking_alpha.Operation_selection.weight_manager

Returns the weight of an operation, i.e. the fees w.r.t the gas and size consumption in the block.

val required_fee_manager_operation_weight : op_resources:Q.t -> min_weight:Q.t -> Tezos_protocol_alpha.Protocol.Alpha_context.Tez.t

Return fee for an operation that consumes op_resources for its weight to be strictly greater than min_weight.

Check if an operation as a weight (fees w.r.t gas and size) large enough to be prechecked and return said weight. In the case where the prechecked mempool is full, return an error if the weight is too small, or return the operation to be replaced otherwise.

type Tezos_protocol_alpha.Environment.Error_monad.error +=
| Consensus_operation_in_far_future

consensus operation filtering

In Tenderbake, we increased a lot the number of consensus operations, therefore it seems necessary to be able to filter consensus operations that could be produced by a Byzantine baker mis-using its right to produce operations in future rounds or levels.

We consider the situation where the head is at level h_l, round h_r, and with timestamp h_ts, with the predecessor of the head being at round hp_r. We receive at a time now a consensus operation for level op_l and round op_r.

A consensus operation is considered too far in the future, and therefore filtered, if the earliest possible starting time of its round is greater than the current time plus a safety margin of config.clock_drift.

To consider potential level 2 reorgs, we first compute the expected timestamp of round zero at previous level hp0_ts,

All ops at level p_l and round r' such that time(r') is greater than (now + drift) are deemed too far in the future:

h_r op_ts now+drift (h_l,r') hp0_ts h_0 h_l | | | +----+-----+---------+-------------------+--+-----+--------------+----------- | | | | | | | | h_ts h_r end time | now | earliest expected | | | | time of round r' |<----op_r rounds duration -------->| | | |<--------------- operations kept ---->|<-rejected----------... | |<-----------operations considered by the filter -----------...

For an operation on a proposal at the next level, we consider the minimum starting time of the operation's round, obtained by assuming that the proposal at the next level was built on top of a proposal at round 0 for the current level, itself based on a proposal at round 0 of previous level. Operations on proposal with higher levels are treated similarly.

All ops at the next level and round r' such that timestamp(r') > now+drift are deemed too far in the future.

r=0 r=1 h_r now now+drift (h_l+1,r') hp0_ts h_0 h_l h_l | | | +----+---- |-------+----+---------+----------+----------+---------- | | | | | | t0 | h_ts earliest expected | | | | time of round r' |<--- | earliest| | | next level| | | |<---------------------------------->| round_offset(r')

At a given level a consensus operation is acceptable if its earliest expected timestamp, op_earliest_ts is below the current clock with an accepted drift for the clock given by a configuration.

Check that an operation with the given op_round, at level op_level is likely to be correct, meaning it could have been produced before now (+ the safety margin from configuration).

Given an operation at level greater or equal than/to the current level, we compute the expected timestamp of the operation's round. If the operation is at a greater level, we assume that it is based on the proposal at round zero of the current level.

All operations whose (level, round) is lower than or equal to the current head are deemed valid. Note that in case where their is a high drift in the computer clock, they might not have been considered valid by comparing their expected timestamp to the clock.

This is a stricter than necessary filter as it will reject operations that could be valid in the current timeframe if the proposal they endorse is built over a predecessor of the current proposal that would be of lower round than the current one.

What can we do that would be smarter: get current head's predecessor round and timestamp to compute the timestamp t0 of a predecessor that would have been proposed at round 0.

Timestamp of round at current level for an alternative head that would be based on such proposal would be computed based on t0. For level higher than current head, compute the round's earliest timestamp if all proposal passed at round 0 starting from t0.

val pre_filter_far_future_consensus_ops : config -> filter_state:state -> Tezos_protocol_alpha.Protocol.Alpha_context.consensus_content -> bool Lwt.t
val pre_filter : config -> filter_state:state -> ?validation_state_before:Tezos_protocol_alpha.Protocol.validation_state -> Tezos_protocol_alpha.Protocol.Main.operation -> [> `Branch_delayed of Tezos_base.TzPervasives.tztrace | `Branch_refused of Tezos_base.TzPervasives.error list | `Outdated of Tezos_base.TzPervasives.tztrace | `Passed_prefilter of [> `High | `Low of Q.t list | `Medium ] | `Refused of Tezos_base.TzPervasives.error list ] Lwt.t

A quasi infinite amount of "valid" (pre)endorsements could be sent by a committee member, one for each possible round number.

This filter rejects (pre)endorsements that refer to a round that could not have been reached within the time span between the last head's timestamp and the current local clock.

We add config.clock_drift time as a safety margin.

Call the protocol's Validate.validate_operation and return either:

  • the updated validation_state when the validation is successful, or
  • the protocol error trace converted to an error trace, together with the corresponding error_classification.

The signature check is skipped when the operation has previously been validated successfully, ie. nb_successful_prechecks > 0.

Call the protocol's Validate.validate_operation on a manager operation and return:

  • `Success containing the updated validation_state when the validation is successful;
  • `Conflict containing the hash of the conflicting operation, and the error_classification corresponding to the protocol error trace, when the validation fails because of the one-manager-operation-per-manager-per-block restriction;
  • an error containing the relevant error_classification when the validation fails with any other protocol error.

The signature check is skipped when the operation has previously been validated successfully, ie. nb_successful_prechecks > 0.

Remove a manager operation from the protocol's validation_state.

Call the protocol validation on a manager operation and handle potential conflicts: if either the 1M restriction is triggered or the mempool exceeds the maximal number of prechecked operations, then this function is responsible for either discarding the new operation, or removing an old operation to free up space for the new operation.

Return the updated protocol validation_state and, when applicable, the replaced operation accompanied by its new classification.

Note that this function does not handle the update of the filter_state.

val remove : filter_state:state -> Tezos_crypto.Operation_hash.Map.key -> state

Remove a manager operation hash from the filter state. Do nothing if the operation was not in the state.

val add_manager_op : state -> Tezos_crypto.Operation_hash.Map.key -> manager_op_info -> [< `No_replace | `Replace of Tezos_crypto.Operation_hash.Map.key * 'a ] -> state

Add a manager operation hash and information to the filter state. Do nothing if the operation is already present in the state.

Call validate_manager_operation_and_handle_conflicts then update the filter_state by adding the newly validated operation, and removing the replaced one one when applicable.

Return either the updated filter_state, updated validation_state, and operation replacement, or an error containing the appropriate classification.

Call precheck_manager_result then convert its error monad result into the appropriate return type for precheck.

Call the protocol's Validate.validate_operation. If successful, return the updated validation_state, the unchanged filter_state, and no operation replacement. Otherwise, return the classification associated with the protocol error. Note that when there is a conflict with a previously validated operation, the new operation is always discarded. As it does not allow for any fee market, this function is designed for non-manager operations.

val precheck : config -> filter_state:state -> validation_state:Tezos_protocol_alpha.Protocol.validation_state -> Tezos_crypto.Operation_hash.t -> Tezos_protocol_alpha.Protocol.Main.operation -> nb_successful_prechecks:int -> [ `Branch_delayed of Tezos_base.TzPervasives.tztrace | `Branch_refused of Tezos_base.TzPervasives.tztrace | `Outdated of Tezos_base.TzPervasives.tztrace | `Passed_precheck of state * Tezos_protocol_alpha.Protocol.validation_state * [ `No_replace | `Replace of Tezos_crypto.Operation_hash.t * error_classification ] | `Refused of Tezos_base.TzPervasives.tztrace | `Undecided ] Lwt.t
val post_filter_manager : 't. Tezos_protocol_alpha.Protocol.Alpha_context.t -> state -> 't Tezos_protocol_alpha.Protocol.Alpha_context.Kind.manager Tezos_protocol_alpha.Protocol.Apply_results.contents_result_list -> config -> [ `Passed_postfilter of state | `Refused of Tezos_base.TzPervasives.tztrace ]
val post_filter : config -> filter_state:state -> validation_state_before:'a -> validation_state_after: Tezos_protocol_alpha.Protocol.Validate.validation_state -> ('b * Tezos_protocol_alpha.Protocol.Apply_results.packed_operation_metadata) -> [ `Passed_postfilter of state | `Refused of Tezos_base.TzPervasives.tztrace ] Lwt.t