tezos-protocol-alpha 20.1 · OCaml Package

type player =

| Alice
| Bob

val player_equal : player -> player -> bool

val player_encoding : player Tezos_protocol_environment_alpha.Data_encoding.t

type dissection_chunk = Dissection_chunk.t

type game_state =

| Dissecting of {
1. dissection : dissection_chunk list;
2. default_number_of_sections : int;
}
| Final_move of {
1. agreed_start_chunk : dissection_chunk;
2. refuted_stop_chunk : dissection_chunk;
}

val game_state_encoding : 
  game_state Tezos_protocol_environment_alpha.Data_encoding.t

val game_state_equal : game_state -> game_state -> bool

type t = {

turn : player;
inbox_snapshot : Inbox.history_proof;
dal_snapshot : Dal.Slots_history.t;
start_level : Raw_level.t;
inbox_level : Raw_level.t;
game_state : game_state;

}

val pp_dissection : 
  Tezos_protocol_environment_alpha.Format.formatter ->
  dissection_chunk list ->
  unit

val pp : Tezos_protocol_environment_alpha.Format.formatter -> t -> unit

module Index : sig ... end

val encoding : t Tezos_protocol_environment_alpha.Data_encoding.t

val opponent : player -> player

type step =

| Dissection of dissection_chunk list
| Proof of Proof.serialized Proof.t

type refutation =

| Start of {
1. player_commitment_hash : Commitment.Hash.t;
2. opponent_commitment_hash : Commitment.Hash.t;
}
| Move of {
1. choice : Tick.t;
2. step : step;
}

val refutation_encoding : 
  refutation Tezos_protocol_environment_alpha.Data_encoding.t

val pp_refutation : 
  Tezos_protocol_environment_alpha.Format.formatter ->
  refutation ->
  unit

type reason =

| Conflict_resolved
| Timeout

val pp_reason : 
  Tezos_protocol_environment_alpha.Format.formatter ->
  reason ->
  unit

val reason_encoding : reason Tezos_protocol_environment_alpha.Data_encoding.t

type game_result =

| Loser of {
1. reason : reason;
2. loser : Staker.t;
}
| Draw

val pp_game_result : 
  Tezos_protocol_environment_alpha.Format.formatter ->
  game_result ->
  unit

val game_result_encoding : 
  game_result Tezos_protocol_environment_alpha.Data_encoding.t

type status =

| Ongoing
| Ended of game_result

val pp_status : 
  Tezos_protocol_environment_alpha.Format.formatter ->
  status ->
  unit

val status_encoding : status Tezos_protocol_environment_alpha.Data_encoding.t

val initial : 
  Inbox.history_proof ->
  Dal.Slots_history.t ->
  start_level:Raw_level.t ->
  parent_commitment:Commitment.t ->
  defender_commitment:Commitment.t ->
  refuter:Staker.t ->
  defender:Staker.t ->
  default_number_of_sections:int ->
  t

val play : 
  Kind.t ->
  Dal.parameters ->
  dal_activation_level:Raw_level.t option ->
  dal_attestation_lag:int ->
  dal_number_of_slots:int ->
  stakers:Index.t ->
  Metadata.t ->
  t ->
  step:step ->
  choice:Tick.t ->
  is_reveal_enabled:is_reveal_enabled ->
  dal_attested_slots_validity_lag:int ->
  (game_result, t) Tezos_protocol_environment_alpha.Either.t
    Tezos_protocol_environment_alpha.Error_monad.tzresult
    Tezos_protocol_environment_alpha.Lwt.t

type timeout = {

alice : int;
bob : int;
last_turn_level : Raw_level.t;

}

val timeout_encoding : timeout Tezos_protocol_environment_alpha.Data_encoding.t

type Tezos_protocol_environment_alpha.Error_monad.error +=

| Dissection_choice_not_found of Tick.t
| Proof_unexpected_section_size of Tezos_protocol_environment_alpha.Z.t
| Proof_start_state_hash_mismatch of {
1. start_state_hash : State_hash.t option;
2. start_proof : State_hash.t;
}
| Proof_stop_state_hash_failed_to_refute of {
1. stop_state_hash : State_hash.t option;
2. stop_proof : State_hash.t option;
}
| Proof_stop_state_hash_failed_to_validate of {
1. stop_state_hash : State_hash.t option;
2. stop_proof : State_hash.t option;
}
| Dissecting_during_final_move

module Internal_for_tests : sig ... end

package tezos-protocol-alpha