From 4e30587d8b589ddd681bf373c39fcdd63dffdbe8 Mon Sep 17 00:00:00 2001 From: Thomas Athorne Date: Mon, 23 May 2022 18:15:45 +0100 Subject: [PATCH 01/11] Proto: SCORU: refactor the PVM interface definition --- src/proto_alpha/bin_sc_rollup_node/event.ml | 2 +- .../lib_client/operation_result.ml | 2 +- .../client_proto_context_commands.ml | 10 +- src/proto_alpha/lib_protocol/TEZOS_PROTOCOL | 8 +- src/proto_alpha/lib_protocol/alpha_context.ml | 1 + .../lib_protocol/alpha_context.mli | 28 +++ src/proto_alpha/lib_protocol/dune | 25 ++- .../lib_protocol/operation_repr.ml | 4 +- .../lib_protocol/operation_repr.mli | 2 +- .../lib_protocol/sc_rollup_PVM_sem.ml | 174 ++++++++++++++---- .../lib_protocol/sc_rollup_arith.ml | 132 +++++++------ .../lib_protocol/sc_rollup_arith.mli | 19 +- .../lib_protocol/sc_rollup_repr.ml | 27 --- .../lib_protocol/sc_rollup_repr.mli | 18 -- .../lib_protocol/sc_rollup_storage.mli | 6 +- src/proto_alpha/lib_protocol/sc_rollups.ml | 72 +++++--- src/proto_alpha/lib_protocol/sc_rollups.mli | 50 +++-- src/proto_alpha/lib_protocol/storage.ml | 4 +- src/proto_alpha/lib_protocol/storage.mli | 2 +- .../integration/operations/test_sc_rollup.ml | 12 +- .../test/unit/test_sc_rollup_arith.ml | 28 ++- .../test/unit/test_sc_rollup_storage.ml | 4 +- 22 files changed, 393 insertions(+), 237 deletions(-) diff --git a/src/proto_alpha/bin_sc_rollup_node/event.ml b/src/proto_alpha/bin_sc_rollup_node/event.ml index 83bc8e558054..f0007d0bdef3 100644 --- a/src/proto_alpha/bin_sc_rollup_node/event.ml +++ b/src/proto_alpha/bin_sc_rollup_node/event.ml @@ -73,5 +73,5 @@ let node_is_ready ~rpc_addr ~rpc_port = Simple.(emit node_is_ready (rpc_addr, rpc_port)) let rollup_exists ~addr ~kind = - let kind = Protocol.Sc_rollups.string_of_kind kind in + let kind = Protocol.Sc_rollup.string_of_kind kind in Simple.(emit rollup_exists (addr, kind)) diff --git a/src/proto_alpha/lib_client/operation_result.ml b/src/proto_alpha/lib_client/operation_result.ml index 7f980b5edc51..cb3f1d2682de 100644 --- a/src/proto_alpha/lib_client/operation_result.ml +++ b/src/proto_alpha/lib_client/operation_result.ml @@ -272,7 +272,7 @@ let pp_manager_operation_content (type kind) source pp_result ppf | Dal_publish_slot_header {slot} -> Format.fprintf ppf "@[Publish slot %a@]" Dal.Slot.pp slot | Sc_rollup_originate {kind; boot_sector; parameters_ty} -> - let (module R : Sc_rollups.PVM.S) = Sc_rollups.of_kind kind in + let (module R : Sc_rollup.PVM.S) = Sc_rollup.Kind.pvm_of kind in let parameters_ty = WithExceptions.Option.to_exn ~none:(Failure "ill-serialized parameters type") diff --git a/src/proto_alpha/lib_client_commands/client_proto_context_commands.ml b/src/proto_alpha/lib_client_commands/client_proto_context_commands.ml index 7ace7e77ed5c..cf9ac2638b16 100644 --- a/src/proto_alpha/lib_client_commands/client_proto_context_commands.ml +++ b/src/proto_alpha/lib_client_commands/client_proto_context_commands.ml @@ -83,17 +83,17 @@ let block_hash_param = let rollup_kind_param = Clic.parameter (fun _ name -> - match Sc_rollups.from ~name with + match Sc_rollup.Kind.pvm_of_name ~name with | None -> failwith "Parameter '%s' is not a valid rollup name (must be one of %s)" name - (String.concat ", " Sc_rollups.all_names) + (String.concat ", " Sc_rollup.Kind.all_names) | Some k -> return k) let boot_sector_param = let from_text s = - return (fun (module R : Sc_rollups.PVM.S) -> + return (fun (module R : Sc_rollup.PVM.S) -> R.parse_boot_sector s |> function | None -> failwith "Invalid boot sector" | Some boot_sector -> return boot_sector) @@ -2599,7 +2599,7 @@ let commands_rw () = "Only implicit accounts can originate smart-contract rollups" | Implicit source -> Client_keys.get_key cctxt source >>=? fun (_, src_pk, src_sk) -> - let (module R : Sc_rollups.PVM.S) = pvm in + let (module R : Sc_rollup.PVM.S) = pvm in let Michelson_v1_parser.{expanded; _} = parameters_ty in let parameters_ty = Script.lazy_expr expanded in boot_sector pvm >>=? fun boot_sector -> @@ -2618,7 +2618,7 @@ let commands_rw () = ~src_pk ~src_sk ~fee_parameter - ~kind:(Sc_rollups.kind_of pvm) + ~kind:(Sc_rollup.Kind.of_pvm pvm) ~boot_sector ~parameters_ty () diff --git a/src/proto_alpha/lib_protocol/TEZOS_PROTOCOL b/src/proto_alpha/lib_protocol/TEZOS_PROTOCOL index 98f876a53226..7e007abe51c0 100644 --- a/src/proto_alpha/lib_protocol/TEZOS_PROTOCOL +++ b/src/proto_alpha/lib_protocol/TEZOS_PROTOCOL @@ -38,9 +38,12 @@ "Script_repr", "Cache_memory_helpers", "Sc_rollup_repr", + "Sc_rollup_tick_repr", + "Sc_rollup_PVM_sem", + "Sc_rollup_arith", + "Sc_rollups", "Skip_list_repr", "Sc_rollup_inbox_repr", - "Sc_rollup_tick_repr", "Sc_rollup_commitment_repr", "Sc_rollup_game_repr", "Seed_repr", @@ -196,9 +199,6 @@ "Script_interpreter", "Sc_rollup_management_protocol", "Sc_rollup_operations", - "Sc_rollup_PVM_sem", - "Sc_rollup_arith", - "Sc_rollups", "Dal_apply", diff --git a/src/proto_alpha/lib_protocol/alpha_context.ml b/src/proto_alpha/lib_protocol/alpha_context.ml index aa624eef44a8..32e4ca3171ea 100644 --- a/src/proto_alpha/lib_protocol/alpha_context.ml +++ b/src/proto_alpha/lib_protocol/alpha_context.ml @@ -72,6 +72,7 @@ module Sc_rollup = struct module Stake_storage = Sc_rollup_stake_storage module Refutation_storage = Sc_rollup_refutation_storage include Sc_rollup_storage + include Sc_rollups end module Dal = struct diff --git a/src/proto_alpha/lib_protocol/alpha_context.mli b/src/proto_alpha/lib_protocol/alpha_context.mli index 9d3a52dc0a0f..55b92bbd6e1d 100644 --- a/src/proto_alpha/lib_protocol/alpha_context.mli +++ b/src/proto_alpha/lib_protocol/alpha_context.mli @@ -2494,10 +2494,38 @@ module Sc_rollup : sig type rollup := t + module PVM : sig + type boot_sector = string + + module type S = sig + val name : string + + val parse_boot_sector : string -> boot_sector option + + val pp_boot_sector : Format.formatter -> boot_sector -> unit + + include Sc_rollup_PVM_sem.S + end + + type t = (module S) + end + module Kind : sig type t = Example_arith val encoding : t Data_encoding.t + + val pvm_of : t -> PVM.t + + val of_pvm : PVM.t -> t + + val pvm_of_name : name:string -> PVM.t option + + val of_name : string -> t option + + val all : t list + + val all_names : string list end module Staker : diff --git a/src/proto_alpha/lib_protocol/dune b/src/proto_alpha/lib_protocol/dune index 56e0f7e62a60..d1b44b4f3646 100644 --- a/src/proto_alpha/lib_protocol/dune +++ b/src/proto_alpha/lib_protocol/dune @@ -69,9 +69,12 @@ Script_repr Cache_memory_helpers Sc_rollup_repr + Sc_rollup_tick_repr + Sc_rollup_PVM_sem + Sc_rollup_arith + Sc_rollups Skip_list_repr Sc_rollup_inbox_repr - Sc_rollup_tick_repr Sc_rollup_commitment_repr Sc_rollup_game_repr Seed_repr @@ -285,9 +288,12 @@ script_repr.ml script_repr.mli cache_memory_helpers.ml sc_rollup_repr.ml sc_rollup_repr.mli + sc_rollup_tick_repr.ml sc_rollup_tick_repr.mli + sc_rollup_PVM_sem.ml + sc_rollup_arith.ml sc_rollup_arith.mli + sc_rollups.ml sc_rollups.mli skip_list_repr.ml skip_list_repr.mli sc_rollup_inbox_repr.ml sc_rollup_inbox_repr.mli - sc_rollup_tick_repr.ml sc_rollup_tick_repr.mli sc_rollup_commitment_repr.ml sc_rollup_commitment_repr.mli sc_rollup_game_repr.ml sc_rollup_game_repr.mli seed_repr.ml seed_repr.mli @@ -488,9 +494,12 @@ script_repr.ml script_repr.mli cache_memory_helpers.ml sc_rollup_repr.ml sc_rollup_repr.mli + sc_rollup_tick_repr.ml sc_rollup_tick_repr.mli + sc_rollup_PVM_sem.ml + sc_rollup_arith.ml sc_rollup_arith.mli + sc_rollups.ml sc_rollups.mli skip_list_repr.ml skip_list_repr.mli sc_rollup_inbox_repr.ml sc_rollup_inbox_repr.mli - sc_rollup_tick_repr.ml sc_rollup_tick_repr.mli sc_rollup_commitment_repr.ml sc_rollup_commitment_repr.mli sc_rollup_game_repr.ml sc_rollup_game_repr.mli seed_repr.ml seed_repr.mli @@ -711,9 +720,12 @@ script_repr.ml script_repr.mli cache_memory_helpers.ml sc_rollup_repr.ml sc_rollup_repr.mli + sc_rollup_tick_repr.ml sc_rollup_tick_repr.mli + sc_rollup_PVM_sem.ml + sc_rollup_arith.ml sc_rollup_arith.mli + sc_rollups.ml sc_rollups.mli skip_list_repr.ml skip_list_repr.mli sc_rollup_inbox_repr.ml sc_rollup_inbox_repr.mli - sc_rollup_tick_repr.ml sc_rollup_tick_repr.mli sc_rollup_commitment_repr.ml sc_rollup_commitment_repr.mli sc_rollup_game_repr.ml sc_rollup_game_repr.mli seed_repr.ml seed_repr.mli @@ -930,9 +942,12 @@ script_repr.ml script_repr.mli cache_memory_helpers.ml sc_rollup_repr.ml sc_rollup_repr.mli + sc_rollup_tick_repr.ml sc_rollup_tick_repr.mli + sc_rollup_PVM_sem.ml + sc_rollup_arith.ml sc_rollup_arith.mli + sc_rollups.ml sc_rollups.mli skip_list_repr.ml skip_list_repr.mli sc_rollup_inbox_repr.ml sc_rollup_inbox_repr.mli - sc_rollup_tick_repr.ml sc_rollup_tick_repr.mli sc_rollup_commitment_repr.ml sc_rollup_commitment_repr.mli sc_rollup_game_repr.ml sc_rollup_game_repr.mli seed_repr.ml seed_repr.mli diff --git a/src/proto_alpha/lib_protocol/operation_repr.ml b/src/proto_alpha/lib_protocol/operation_repr.ml index 8ac1f74020bc..616000da1368 100644 --- a/src/proto_alpha/lib_protocol/operation_repr.ml +++ b/src/proto_alpha/lib_protocol/operation_repr.ml @@ -382,7 +382,7 @@ and _ manager_operation = } -> Kind.dal_publish_slot_header manager_operation | Sc_rollup_originate : { - kind : Sc_rollup_repr.Kind.t; + kind : Sc_rollups.Kind.t; boot_sector : string; parameters_ty : Script_repr.lazy_expr; } @@ -949,7 +949,7 @@ module Encoding = struct name = "sc_rollup_originate"; encoding = obj3 - (req "kind" Sc_rollup_repr.Kind.encoding) + (req "kind" Sc_rollups.Kind.encoding) (req "boot_sector" Data_encoding.string) (req "parameters_ty" Script_repr.lazy_expr_encoding); select = diff --git a/src/proto_alpha/lib_protocol/operation_repr.mli b/src/proto_alpha/lib_protocol/operation_repr.mli index 3fc89ce6e722..7805ce8ec19d 100644 --- a/src/proto_alpha/lib_protocol/operation_repr.mli +++ b/src/proto_alpha/lib_protocol/operation_repr.mli @@ -446,7 +446,7 @@ and _ manager_operation = smart contract rollup (initialized with a given boot sector). *) | Sc_rollup_originate : { - kind : Sc_rollup_repr.Kind.t; + kind : Sc_rollups.Kind.t; boot_sector : string; parameters_ty : Script_repr.lazy_expr; } diff --git a/src/proto_alpha/lib_protocol/sc_rollup_PVM_sem.ml b/src/proto_alpha/lib_protocol/sc_rollup_PVM_sem.ml index d817441cceae..69a87365854a 100644 --- a/src/proto_alpha/lib_protocol/sc_rollup_PVM_sem.ml +++ b/src/proto_alpha/lib_protocol/sc_rollup_PVM_sem.ml @@ -46,18 +46,82 @@ an actual source of truth about the nature of these messages). *) -open Alpha_context -open Sc_rollup +open Sc_rollup_repr (** An input to a PVM is the [message_counter] element of an inbox at a given [inbox_level] and contains a given [payload]. *) type input = { - inbox_level : Raw_level.t; + inbox_level : Raw_level_repr.t; message_counter : Z.t; payload : string; } +let input_encoding = + let open Data_encoding in + conv + (fun {inbox_level; message_counter; payload} -> + (inbox_level, message_counter, payload)) + (fun (inbox_level, message_counter, payload) -> + {inbox_level; message_counter; payload}) + (obj3 + (req "inbox_level" Raw_level_repr.encoding) + (req "message_counter" n) + (req "payload" string)) + +let input_equal (a : input) (b : input) : bool = + let {inbox_level; message_counter; payload} = a in + (* To be robust to the addition of fields in [input] *) + Raw_level_repr.equal inbox_level b.inbox_level + && Z.equal message_counter b.message_counter + && String.equal payload b.payload + +(** The PVM's current input expectations. [No_input_required] is if the + machine is busy and has no need for new input. [Initial] will be if + the machine has never received an input so expects the very first + item in the inbox. [First_after (level, counter)] will expect + whatever comes next after that position in the inbox. *) +type input_request = + | No_input_required + | Initial + | First_after of Raw_level_repr.t * Z.t + +let input_request_encoding = + let open Data_encoding in + union + ~tag_size:`Uint8 + [ + case + ~title:"No_input_required" + (Tag 0) + (obj1 (req "no_input_required" unit)) + (function No_input_required -> Some () | _ -> None) + (fun () -> No_input_required); + case + ~title:"Initial" + (Tag 1) + (obj1 (req "initial" unit)) + (function Initial -> Some () | _ -> None) + (fun () -> Initial); + case + ~title:"First_after" + (Tag 2) + (tup2 Raw_level_repr.encoding n) + (function + | First_after (level, counter) -> Some (level, counter) | _ -> None) + (fun (level, counter) -> First_after (level, counter)); + ] + +let input_request_equal a b = + match (a, b) with + | No_input_required, No_input_required -> true + | No_input_required, _ -> false + | Initial, Initial -> true + | Initial, _ -> false + | First_after (l, n), First_after (m, o) -> + Raw_level_repr.equal l m && Z.equal n o + | First_after _, _ -> false + module type S = sig (** @@ -80,21 +144,50 @@ module type S = sig (** A [hash] characterizes the contents of a state. *) type hash = State_hash.t - (** - - During interactive refutation games, a player may need to - provide a proof that a given execution step described as - a pair of a [hash] for the state before the execution step - and a [hash] for the state right after the execution step - is valid. - - The protocol only has to verify proofs. Hence, this signature - does not include a function to produce proofs. However, a - rollup node would necessarily offer a richer interface for its - own implementation of the PVM typically to be able to generate - such proofs when it participates in a refutation game. - - *) + (** During interactive refutation games, a player may need to + provide a proof that a given execution step is valid. The PVM + implementation is responsible for ensuring that this proof type + has the correct semantics: + + A proof [p] has four parameters: + + [start_hash := proof_start_state p] + [stop_hash := proof_stop_state p] + [input_requested := proof_input_requested p] + [input_given := proof_input_given p] + + The following predicate must hold of a valid proof: + + [exists start_state, stop_state. + (state_hash start_state == start_hash) + AND (Option.map state_hash stop_state == stop_hash) + AND (is_input_state start_state == input_requested) + AND (match (input_given, input_requested) with + | (None, No_input_required) -> eval start_state == stop_state + | (None, Initial) -> stop_state == None + | (None, First_after (l, n)) -> stop_state == None + | (Some input, No_input_required) -> true + | (Some input, Initial) -> + set_input input_given start_state == stop_state + | (Some input, First_after (l, n)) -> + set_input input_given start_state == stop_state)] + + In natural language---the two hash parameters [start_hash] and + [stop_hash] must have actual [state] values (or possibly [None] in + the case of [stop_hash]) of which they are the hashes. The + [input_requested] parameter must be the correct request from the + [start_hash], given according to [is_input_state]. Finally there + are four possibilities of [input_requested] and [input_given]. + + - if no input is required, or given, the proof is a simple [eval] + step ; + - if input was required but not given, the [stop_hash] must be + [None] (the machine is blocked) ; + - if no input was required but some was given, this makes no sense + and it doesn't matter if the proof is valid or invalid (this + case will be ruled out by the inbox proof anyway) ; + - finally, if input was required and given, the proof is a + [set_input] step. *) type proof (** [proof]s are embedded in L1 refutation game operations using @@ -105,19 +198,26 @@ module type S = sig the rollup could get stuck. *) val proof_encoding : proof Data_encoding.t - (** [verify_proof input proof] returns [true] iff the [proof] is - valid. If the state related to the proof is an input state, - [input] is the inbox message provided to the evaluation - function. *) - val verify_proof : input:input option -> proof -> bool Lwt.t - (** [proof_start_state proof] returns the initial state hash of the [proof] execution step. *) val proof_start_state : proof -> hash (** [proof_stop_state proof] returns the final state hash of the [proof] execution step. *) - val proof_stop_state : proof -> hash + val proof_stop_state : proof -> hash option + + (** [proof_input_requested proof] returns the [input_request] status + of the start state of the proof, as given by [is_input_state]. + This must match with the inbox proof to complete a valid + refutation game proof. *) + val proof_input_requested : proof -> input_request + + (** [proof_input_given proof] returns the [input], if any, provided to + the start state of the proof using the [set_input] function. If + [None], the proof is an [eval] step instead, or the machine is + blocked because the inbox is fully read. This must match with the + inbox proof to complete a valid refutation game proof. *) + val proof_input_given : proof -> input option (** [state_hash state] returns a compressed representation of [state]. *) val state_hash : state -> hash Lwt.t @@ -129,20 +229,22 @@ module type S = sig not impact the result. *) val initial_state : context -> string -> state Lwt.t - (** [is_input_state state] returns [Some (level, counter)] if - [state] is an input state waiting for the input message that - comes next to the message numbered [counter] in the inbox of a - given [level]. By convention, waiting for the very first message - is represented by [Some (0, -1)]. *) - val is_input_state : state -> (Raw_level.t * Z.t) option Lwt.t - - (** [set_input input state] sets [input] in [state] as the next - input message to be processed. The input message must be the - message next to the previous message processed by the rollup - in the inbox. *) + (** [is_input_state state] returns the input expectations of the + [state]---does it need input, and if so, how far through the inbox + has it read so far? *) + val is_input_state : state -> input_request Lwt.t + + (** [set_input (level, n, msg) state] sets [msg] in [state] as + the next message to be processed. This input message is assumed + to be the number [n] in the inbox messages at the given + [level]. The input message must be the message next to the + previous message processed by the rollup. *) val set_input : input -> state -> state Lwt.t (** [eval s0] returns a state [s1] resulting from the execution of an atomic step of the rollup at state [s0]. *) val eval : state -> state Lwt.t + + (** This checks the proof. See the doc-string for the [proof] type. *) + val verify_proof : proof -> bool Lwt.t end diff --git a/src/proto_alpha/lib_protocol/sc_rollup_arith.ml b/src/proto_alpha/lib_protocol/sc_rollup_arith.ml index b4e11e38e49e..b97901c10640 100644 --- a/src/proto_alpha/lib_protocol/sc_rollup_arith.ml +++ b/src/proto_alpha/lib_protocol/sc_rollup_arith.ml @@ -23,8 +23,8 @@ (* *) (*****************************************************************************) -open Alpha_context -open Sc_rollup +open Sc_rollup_repr +module PS = Sc_rollup_PVM_sem module type P = sig module Tree : Context.TREE with type key = string list and type value = bytes @@ -40,18 +40,11 @@ module type P = sig val proof_stop_state : proof -> State_hash.t val verify_proof : - proof -> - (tree -> (tree * 'a) Lwt.t) -> - ( tree * 'a, - [ `Proof_mismatch of string - | `Stream_too_long of string - | `Stream_too_short of string ] ) - result - Lwt.t + proof -> (tree -> (tree * 'a) Lwt.t) -> (tree * 'a) option Lwt.t end module type S = sig - include Sc_rollup_PVM_sem.S + include PS.S val name : string @@ -61,7 +54,7 @@ module type S = sig val pp : state -> (Format.formatter -> unit -> unit) Lwt.t - val get_tick : state -> Sc_rollup.Tick.t Lwt.t + val get_tick : state -> Sc_rollup_tick_repr.t Lwt.t type status = Halted | WaitingForInputMessage | Parsing | Evaluating @@ -92,21 +85,40 @@ end module Make (Context : P) : S with type context = Context.Tree.t - and type state = Context.tree - and type proof = Context.proof = struct + and type state = Context.tree = struct module Tree = Context.Tree type context = Context.Tree.t type hash = State_hash.t - type proof = Context.proof + type proof = { + tree_proof : Context.proof; + given : PS.input option; + requested : PS.input_request; + } - let proof_encoding = Context.proof_encoding + let proof_encoding = + let open Data_encoding in + conv + (fun {tree_proof; given; requested} -> (tree_proof, given, requested)) + (fun (tree_proof, given, requested) -> {tree_proof; given; requested}) + (obj3 + (req "tree_proof" Context.proof_encoding) + (req "given" (option PS.input_encoding)) + (req "requested" PS.input_request_encoding)) - let proof_start_state = Context.proof_start_state + let proof_start_state p = Context.proof_start_state p.tree_proof - let proof_stop_state = Context.proof_stop_state + let proof_stop_state p = + match (p.given, p.requested) with + | None, PS.No_input_required -> Some (Context.proof_stop_state p.tree_proof) + | None, _ -> None + | _ -> Some (Context.proof_stop_state p.tree_proof) + + let proof_input_given p = p.given + + let proof_input_requested p = p.requested let name = "arith" @@ -141,7 +153,7 @@ module Make (Context : P) : Here is the data model of this state represented in the tree: - - tick : Tick.t + - tick : Sc_rollup_tick_repr.t The current tick counter of the machine. - status : status The current status of the machine. @@ -421,7 +433,7 @@ module Make (Context : P) : end module CurrentTick = MakeVar (struct - include Tick + include Sc_rollup_tick_repr let name = "tick" end) @@ -512,27 +524,29 @@ module Make (Context : P) : end) module CurrentLevel = MakeVar (struct - type t = Raw_level.t + type t = Raw_level_repr.t - let initial = Raw_level.root + let initial = Raw_level_repr.root - let encoding = Raw_level.encoding + let encoding = Raw_level_repr.encoding let name = "current_level" - let pp = Raw_level.pp + let pp = Raw_level_repr.pp end) module MessageCounter = MakeVar (struct - type t = Z.t + type t = Z.t option - let initial = Z.(pred zero) + let initial = None - let encoding = Data_encoding.n + let encoding = Data_encoding.option Data_encoding.n let name = "message_counter" - let pp = Z.pp_print + let pp fmt = function + | None -> Format.fprintf fmt "None" + | Some c -> Format.fprintf fmt "Some %a" Z.pp_print c end) module NextMessage = MakeVar (struct @@ -705,19 +719,22 @@ module Make (Context : P) : let* s, _ = run m state in return s - let get_tick = result_of ~default:Tick.initial CurrentTick.get + let get_tick = result_of ~default:Sc_rollup_tick_repr.initial CurrentTick.get let is_input_state_monadic = let open Monad.Syntax in let* status = Status.get in match status with - | WaitingForInputMessage -> + | WaitingForInputMessage -> ( let* level = CurrentLevel.get in let* counter = MessageCounter.get in - return (Some (level, counter)) - | _ -> return None + match counter with + | Some n -> return (PS.First_after (level, n)) + | None -> return PS.Initial) + | _ -> return PS.No_input_required - let is_input_state = result_of ~default:None @@ is_input_state_monadic + let is_input_state = + result_of ~default:PS.No_input_required @@ is_input_state_monadic let get_status = result_of ~default:WaitingForInputMessage @@ Status.get @@ -734,28 +751,15 @@ module Make (Context : P) : let get_is_stuck = result_of ~default:None @@ is_stuck let set_input_monadic input = - let open Sc_rollup_PVM_sem in + let open PS in let {inbox_level; message_counter; payload} = input in let open Monad.Syntax in let* boot_sector = Boot_sector.get in let msg = boot_sector ^ payload in - let* last_level = CurrentLevel.get in - let* last_counter = MessageCounter.get in - let update = - let* () = CurrentLevel.set inbox_level in - let* () = MessageCounter.set message_counter in - let* () = NextMessage.set (Some msg) in - return () - in - let does_not_follow = - internal_error "The input message does not follow the previous one." - in - if Raw_level.(equal last_level inbox_level) then - if Z.(equal message_counter (succ last_counter)) then update - else does_not_follow - else if Raw_level.(last_level < inbox_level) then - if Z.(equal message_counter Z.zero) then update else does_not_follow - else does_not_follow + let* () = CurrentLevel.set inbox_level in + let* () = MessageCounter.set (Some message_counter) in + let* () = NextMessage.set (Some msg) in + return () let set_input input = state_of @@ set_input_monadic input @@ -948,23 +952,30 @@ module Make (Context : P) : let ticked m = let open Monad.Syntax in let* tick = CurrentTick.get in - let* () = CurrentTick.set (Tick.next tick) in + let* () = CurrentTick.set (Sc_rollup_tick_repr.next tick) in m let eval state = state_of (ticked eval_step) state - let verify_proof ~input proof = + let verify_proof proof = let open Lwt_syntax in let transition state = + let* request = is_input_state state in let* state = - match input with - | None -> eval state - | Some input -> state_of (ticked (set_input_monadic input)) state + match request with + | PS.No_input_required -> eval state + | _ -> ( + match proof.given with + | Some input -> set_input input state + | None -> return state) in - return (state, ()) + return (state, request) in - let* x = Context.verify_proof proof transition in - match x with Ok _ -> return_true | Error _ -> return_false + let* result = Context.verify_proof proof.tree_proof transition in + match result with + | None -> return false + | Some (_, request) -> + return (PS.input_request_equal request proof.requested) end module ProtocolImplementation = Make (struct @@ -984,7 +995,8 @@ module ProtocolImplementation = Make (struct type proof = Context.Proof.tree Context.Proof.t - let verify_proof = Context.verify_tree_proof + let verify_proof p f = + Lwt.map Result.to_option (Context.verify_tree_proof p f) let kinded_hash_to_state_hash = function | `Value hash | `Node hash -> diff --git a/src/proto_alpha/lib_protocol/sc_rollup_arith.mli b/src/proto_alpha/lib_protocol/sc_rollup_arith.mli index b307989ad4d3..5d01dddccfad 100644 --- a/src/proto_alpha/lib_protocol/sc_rollup_arith.mli +++ b/src/proto_alpha/lib_protocol/sc_rollup_arith.mli @@ -53,7 +53,6 @@ The machine exposes extra operations to be used in the rollup node. *) -open Alpha_context module type S = sig include Sc_rollup_PVM_sem.S @@ -73,7 +72,7 @@ module type S = sig val pp : state -> (Format.formatter -> unit -> unit) Lwt.t (** [get_tick state] returns the current tick of [state]. *) - val get_tick : state -> Sc_rollup.Tick.t Lwt.t + val get_tick : state -> Sc_rollup_tick_repr.t Lwt.t (** The machine has three possible statuses: *) type status = Halted | WaitingForInputMessage | Parsing | Evaluating @@ -133,23 +132,17 @@ module type P = sig val proof_encoding : proof Data_encoding.t - val proof_start_state : proof -> Sc_rollup.State_hash.t + val proof_start_state : proof -> Sc_rollup_repr.State_hash.t - val proof_stop_state : proof -> Sc_rollup.State_hash.t + val proof_stop_state : proof -> Sc_rollup_repr.State_hash.t + (** A verson of [Context.verify_proof] without the annoying error + types, just to make life easier. *) val verify_proof : - proof -> - (tree -> (tree * 'a) Lwt.t) -> - ( tree * 'a, - [ `Proof_mismatch of string - | `Stream_too_long of string - | `Stream_too_short of string ] ) - result - Lwt.t + proof -> (tree -> (tree * 'a) Lwt.t) -> (tree * 'a) option Lwt.t end module Make (Context : P) : S with type context = Context.Tree.t and type state = Context.tree - and type proof = Context.proof diff --git a/src/proto_alpha/lib_protocol/sc_rollup_repr.ml b/src/proto_alpha/lib_protocol/sc_rollup_repr.ml index 63c2886a1a44..db14462b787e 100644 --- a/src/proto_alpha/lib_protocol/sc_rollup_repr.ml +++ b/src/proto_alpha/lib_protocol/sc_rollup_repr.ml @@ -208,30 +208,3 @@ module Number_of_ticks = Bounded.Int32.Make (struct let max_int = Int32.max_int end) - -module Kind = struct - (* - - Each time we add a data constructor to [t], we also need: - - to extend [Sc_rollups.all] with this new constructor ; - - to update [Sc_rollups.kind_of_string] and [encoding]. - - *) - type t = Example_arith - - let example_arith_case = - Data_encoding.( - case - ~title:"Example_arith smart contract rollup kind" - (Tag 0) - unit - (function Example_arith -> Some ()) - (fun () -> Example_arith)) - - let encoding = Data_encoding.union ~tag_size:`Uint16 [example_arith_case] - - let equal x y = match (x, y) with Example_arith, Example_arith -> true - - let pp fmt kind = - match kind with Example_arith -> Format.fprintf fmt "Example_arith" -end diff --git a/src/proto_alpha/lib_protocol/sc_rollup_repr.mli b/src/proto_alpha/lib_protocol/sc_rollup_repr.mli index a73288a4df73..e24094de2651 100644 --- a/src/proto_alpha/lib_protocol/sc_rollup_repr.mli +++ b/src/proto_alpha/lib_protocol/sc_rollup_repr.mli @@ -96,21 +96,3 @@ module Staker : (** The data model uses an index of these addresses. *) module Index : Storage_description.INDEX with type t = Address.t - -(** A smart contract rollup has a kind, which assigns meaning to - rollup operations. *) -module Kind : sig - (** - - The list of available rollup kinds. - - This list must only be appended for backward compatibility. - *) - type t = Example_arith - - val encoding : t Data_encoding.t - - val equal : t -> t -> bool - - val pp : Format.formatter -> t -> unit -end diff --git a/src/proto_alpha/lib_protocol/sc_rollup_storage.mli b/src/proto_alpha/lib_protocol/sc_rollup_storage.mli index 1d31c45c37b5..b4bd156ee3d6 100644 --- a/src/proto_alpha/lib_protocol/sc_rollup_storage.mli +++ b/src/proto_alpha/lib_protocol/sc_rollup_storage.mli @@ -33,7 +33,7 @@ Also returns the number of allocated bytes. *) val originate : Raw_context.t -> - kind:Sc_rollup_repr.Kind.t -> + kind:Sc_rollups.Kind.t -> boot_sector:string -> parameters_ty:Script_repr.lazy_expr -> (Sc_rollup_repr.Address.t * Z.t * Raw_context.t) tzresult Lwt.t @@ -42,9 +42,7 @@ val originate : existing rollup of some [kind]. Returns [None] if [address] is not the address of an existing rollup. *) val kind : - Raw_context.t -> - Sc_rollup_repr.t -> - Sc_rollup_repr.Kind.t option tzresult Lwt.t + Raw_context.t -> Sc_rollup_repr.t -> Sc_rollups.Kind.t option tzresult Lwt.t val list : Raw_context.t -> Sc_rollup_repr.t list tzresult Lwt.t diff --git a/src/proto_alpha/lib_protocol/sc_rollups.ml b/src/proto_alpha/lib_protocol/sc_rollups.ml index 6383f16562ff..98839524471c 100644 --- a/src/proto_alpha/lib_protocol/sc_rollups.ml +++ b/src/proto_alpha/lib_protocol/sc_rollups.ml @@ -23,8 +23,6 @@ (* *) (*****************************************************************************) -open Alpha_context.Sc_rollup - module PVM = struct type boot_sector = string @@ -41,32 +39,60 @@ module PVM = struct type t = (module S) end -let all = [Kind.Example_arith] +module Kind = struct + (* + + Each time we add a data constructor to [t], we also need: + - to extend [Sc_rollups.all] with this new constructor ; + - to update [Sc_rollups.of_name] and [encoding] ; + - to update [Sc_rollups.pvm_proof] and [pvm_proof_encoding]. + + *) + type t = Example_arith + + let example_arith_case = + Data_encoding.( + case + ~title:"Example_arith smart contract rollup kind" + (Tag 0) + unit + (function Example_arith -> Some ()) + (fun () -> Example_arith)) -let kind_of_string = function "arith" -> Some Kind.Example_arith | _ -> None + let encoding = Data_encoding.union ~tag_size:`Uint16 [example_arith_case] -let example_arith_pvm = (module Sc_rollup_arith.ProtocolImplementation : PVM.S) + let equal x y = match (x, y) with Example_arith, Example_arith -> true -let of_kind = function Kind.Example_arith -> example_arith_pvm + let all = [Example_arith] -let kind_of (module M : PVM.S) = - match kind_of_string M.name with - | Some k -> k - | None -> - failwith - (Format.sprintf "The module named %s is not in Sc_rollups.all." M.name) + let of_name = function "arith" -> Some Example_arith | _ -> None -let from ~name = Option.map of_kind (kind_of_string name) + let example_arith_pvm = + (module Sc_rollup_arith.ProtocolImplementation : PVM.S) -let all_names = - List.map - (fun k -> - let (module M : PVM.S) = of_kind k in - M.name) - all + let pvm_of = function Example_arith -> example_arith_pvm -let string_of_kind k = - let (module M) = of_kind k in - M.name + let of_pvm (module M : PVM.S) = + match of_name M.name with + | Some k -> k + | None -> + failwith + (Format.sprintf + "The module named %s is not in Sc_rollups.all." + M.name) -let pp fmt k = Format.fprintf fmt "%s" (string_of_kind k) + let pvm_of_name ~name = Option.map pvm_of (of_name name) + + let all_names = + List.map + (fun k -> + let (module M : PVM.S) = pvm_of k in + M.name) + all + + let string_of_kind k = + let (module M) = pvm_of k in + M.name + + let pp fmt k = Format.fprintf fmt "%s" (string_of_kind k) +end diff --git a/src/proto_alpha/lib_protocol/sc_rollups.mli b/src/proto_alpha/lib_protocol/sc_rollups.mli index dc74b289ea01..ae888869e991 100644 --- a/src/proto_alpha/lib_protocol/sc_rollups.mli +++ b/src/proto_alpha/lib_protocol/sc_rollups.mli @@ -24,7 +24,6 @@ (*****************************************************************************) (** Here is the list of PVMs available in this protocol. *) -open Alpha_context.Sc_rollup module PVM : sig type boot_sector = string @@ -42,27 +41,42 @@ module PVM : sig type t = (module S) end -(** [of_kind kind] returns the [PVM] of the given [kind]. *) -val of_kind : Kind.t -> PVM.t +(** A smart contract rollup has a kind, which assigns meaning to + rollup operations. *) +module Kind : sig + (** -(** [kind_of pvm] returns the [PVM] of the given [kind]. *) -val kind_of : PVM.t -> Kind.t + The list of available rollup kinds. -(** [from ~name] is [Some (module I)] if an implemented PVM called - [name]. This function returns [None] otherwise. *) -val from : name:string -> PVM.t option + This list must only be appended for backward compatibility. + *) + type t = Example_arith -(** [all] returns all implemented PVM. *) -val all : Kind.t list + val encoding : t Data_encoding.t -(** [all_names] returns all implemented PVM names. *) -val all_names : string list + val equal : t -> t -> bool -(** [kind_of_string name] returns the kind of the PVM of the specified [name]. *) -val kind_of_string : string -> Kind.t option + val pp : Format.formatter -> t -> unit -(** [string_of_kind kind] returns a human-readable representation of [kind]. *) -val string_of_kind : Kind.t -> string + (** [pvm_of kind] returns the [PVM] of the given [kind]. *) + val pvm_of : t -> PVM.t -(** [pp fmt kind] is a pretty-printer for [kind]. *) -val pp : Format.formatter -> Kind.t -> unit + (** [of_pvm pvm] returns the [kind] of the given [PVM]. *) + val of_pvm : PVM.t -> t + + (** [pvm_of_name ~name] is [Some (module I)] if an implemented PVM + called [name]. This function returns [None] otherwise. *) + val pvm_of_name : name:string -> PVM.t option + + (** [all] returns all implemented PVM. *) + val all : t list + + (** [all_names] returns all implemented PVM names. *) + val all_names : string list + + (** [kind_of_string name] returns the kind of the PVM of the specified [name]. *) + val of_name : string -> t option + + (** [string_of_kind kind] returns a human-readable representation of [kind]. *) + val string_of_kind : t -> string +end diff --git a/src/proto_alpha/lib_protocol/storage.ml b/src/proto_alpha/lib_protocol/storage.ml index 1995ec76a46d..629d2cc0646c 100644 --- a/src/proto_alpha/lib_protocol/storage.ml +++ b/src/proto_alpha/lib_protocol/storage.ml @@ -1496,9 +1496,9 @@ module Sc_rollup = struct let name = ["kind"] end) (struct - type t = Sc_rollup_repr.Kind.t + type t = Sc_rollups.Kind.t - let encoding = Sc_rollup_repr.Kind.encoding + let encoding = Sc_rollups.Kind.encoding end) module Boot_sector = diff --git a/src/proto_alpha/lib_protocol/storage.mli b/src/proto_alpha/lib_protocol/storage.mli index 6e834d08137a..e6aa79faa30a 100644 --- a/src/proto_alpha/lib_protocol/storage.mli +++ b/src/proto_alpha/lib_protocol/storage.mli @@ -683,7 +683,7 @@ module Sc_rollup : sig module PVM_kind : Indexed_data_storage with type key = Sc_rollup_repr.t - and type value = Sc_rollup_repr.Kind.t + and type value = Sc_rollups.Kind.t and type t := Raw_context.t module Boot_sector : diff --git a/src/proto_alpha/lib_protocol/test/integration/operations/test_sc_rollup.ml b/src/proto_alpha/lib_protocol/test/integration/operations/test_sc_rollup.ml index 5cdfc49bccdc..b4d26265abe9 100644 --- a/src/proto_alpha/lib_protocol/test/integration/operations/test_sc_rollup.ml +++ b/src/proto_alpha/lib_protocol/test/integration/operations/test_sc_rollup.ml @@ -99,7 +99,7 @@ let test_disable_feature_flag () = let*! _ = Incremental.add_operation ~expect_apply_failure i op in return_unit -(** [test_sc_rollups_all_well_defined] checks that [Sc_rollups.all] +(** [test_sc_rollups_all_well_defined] checks that [Sc_rollup.Kind.all] contains all the constructors of [Sc_rollup.Kind.t] and that the [kind_of_string] is consistent with the names declared in the PVM implementations. *) @@ -110,22 +110,22 @@ let test_sc_rollups_all_well_defined () = let pick = function | Sc_rollup.Kind.Example_arith -> burn "Example_arith" in - List.iter pick Sc_rollups.all ; + List.iter pick Sc_rollup.Kind.all ; if !tickets <> [] then failwith "The following smart-contract rollup kinds should occur in \ - [Sc_rollups.all]: %s\n" + [Sc_rollup.Kind.all]: %s\n" (String.concat ", " !tickets) else return_unit in let all_names_are_valid () = List.iter_es (fun k -> - let (module P : Sc_rollups.PVM.S) = Sc_rollups.of_kind k in + let (module P : Sc_rollup.PVM.S) = Sc_rollup.Kind.pvm_of k in fail_unless - (Sc_rollups.kind_of_string P.name = Some k) + (Sc_rollup.Kind.of_name P.name = Some k) (err (Printf.sprintf "PVM name `%s' is not a valid kind name" P.name))) - Sc_rollups.all + Sc_rollup.Kind.all in let* _ = all_contains_all_constructors () in all_names_are_valid () diff --git a/src/proto_alpha/lib_protocol/test/unit/test_sc_rollup_arith.ml b/src/proto_alpha/lib_protocol/test/unit/test_sc_rollup_arith.ml index 4f72496c0346..55f10e356a9d 100644 --- a/src/proto_alpha/lib_protocol/test/unit/test_sc_rollup_arith.ml +++ b/src/proto_alpha/lib_protocol/test/unit/test_sc_rollup_arith.ml @@ -33,7 +33,6 @@ open Protocol open Sc_rollup_arith.ProtocolImplementation -open Alpha_context let create_context () = Context.init1 () >>=? fun (block, _contract) -> return block.context @@ -55,17 +54,22 @@ let test_preboot () = let boot boot_sector f = pre_boot boot_sector @@ fun state -> eval state >>= f let test_boot () = + let open Sc_rollup_PVM_sem in boot "" @@ fun state -> is_input_state state >>= function - | Some _ -> return () - | _ -> failwith "After booting, the machine must be waiting for input." + | Initial -> return () + | First_after _ -> + failwith + "After booting, the machine should be waiting for the initial input." + | No_input_required -> + failwith "After booting, the machine must be waiting for input." let test_input_message () = let open Sc_rollup_PVM_sem in boot "" @@ fun state -> let input = { - inbox_level = Raw_level.root; + inbox_level = Raw_level_repr.root; message_counter = Z.zero; payload = "MESSAGE"; } @@ -73,10 +77,10 @@ let test_input_message () = set_input input state >>= fun state -> eval state >>= fun state -> is_input_state state >>= function - | Some _ -> + | Initial | First_after _ -> failwith "After receiving a message, the rollup must not be waiting for input." - | None -> return () + | No_input_required -> return () let go ~max_steps target_status state = let rec aux i state = @@ -95,7 +99,11 @@ let test_parsing_message ~valid (source, expected_code) = let open Sc_rollup_PVM_sem in boot "" @@ fun state -> let input = - {inbox_level = Raw_level.root; message_counter = Z.zero; payload = source} + { + inbox_level = Raw_level_repr.root; + message_counter = Z.zero; + payload = source; + } in set_input input state >>= fun state -> eval state >>= fun state -> @@ -159,7 +167,11 @@ let test_evaluation_message ~valid let open Sc_rollup_PVM_sem in boot boot_sector @@ fun state -> let input = - {inbox_level = Raw_level.root; message_counter = Z.zero; payload = source} + { + inbox_level = Raw_level_repr.root; + message_counter = Z.zero; + payload = source; + } in set_input input state >>= fun state -> eval state >>= fun state -> diff --git a/src/proto_alpha/lib_protocol/test/unit/test_sc_rollup_storage.ml b/src/proto_alpha/lib_protocol/test/unit/test_sc_rollup_storage.ml index 91b5c4471a55..026e4d96b999 100644 --- a/src/proto_alpha/lib_protocol/test/unit/test_sc_rollup_storage.ml +++ b/src/proto_alpha/lib_protocol/test/unit/test_sc_rollup_storage.ml @@ -183,9 +183,9 @@ let assert_commitment_hash_equal ~loc _ctxt x y = let assert_kinds_are_equal ~loc x y = Assert.equal ~loc - (Option.equal Sc_rollup_repr.Kind.equal) + (Option.equal Sc_rollups.Kind.equal) "Compare optional kind" - (Format.pp_print_option Sc_rollup_repr.Kind.pp) + (Format.pp_print_option Sc_rollups.Kind.pp) x y -- GitLab From d673b23753a50f585567cbbf6c67f50696698110 Mon Sep 17 00:00:00 2001 From: Thomas Athorne Date: Mon, 23 May 2022 18:18:37 +0100 Subject: [PATCH 02/11] Proto: SCORU: create `wrapped_proof` for encoding --- src/proto_alpha/lib_protocol/sc_rollups.ml | 48 +++++++++++++++++++++ src/proto_alpha/lib_protocol/sc_rollups.mli | 23 ++++++++++ 2 files changed, 71 insertions(+) diff --git a/src/proto_alpha/lib_protocol/sc_rollups.ml b/src/proto_alpha/lib_protocol/sc_rollups.ml index 98839524471c..16751635bd32 100644 --- a/src/proto_alpha/lib_protocol/sc_rollups.ml +++ b/src/proto_alpha/lib_protocol/sc_rollups.ml @@ -96,3 +96,51 @@ module Kind = struct let pp fmt k = Format.fprintf fmt "%s" (string_of_kind k) end + +module type PVM_with_proof = sig + include PVM.S + + val proof : proof +end + +type wrapped_proof = + | Unencodable of (module PVM_with_proof) + | Arith_pvm_with_proof of + (module PVM_with_proof + with type proof = Sc_rollup_arith.ProtocolImplementation.proof) + +let wrapped_proof_module p = + match p with + | Unencodable p -> p + | Arith_pvm_with_proof p -> + let (module P) = p in + (module struct + include P + end : PVM_with_proof) + +let wrapped_proof_encoding = + let open Data_encoding in + union + ~tag_size:`Uint8 + [ + case + ~title:"Arithmetic PVM with proof" + (Tag 0) + Sc_rollup_arith.ProtocolImplementation.proof_encoding + (function + | Arith_pvm_with_proof pvm -> + let (module P : PVM_with_proof + with type proof = + Sc_rollup_arith.ProtocolImplementation.proof) = + pvm + in + Some P.proof + | _ -> None) + (fun proof -> + let module P = struct + include Sc_rollup_arith.ProtocolImplementation + + let proof = proof + end in + Arith_pvm_with_proof (module P)); + ] diff --git a/src/proto_alpha/lib_protocol/sc_rollups.mli b/src/proto_alpha/lib_protocol/sc_rollups.mli index ae888869e991..16c719e62fac 100644 --- a/src/proto_alpha/lib_protocol/sc_rollups.mli +++ b/src/proto_alpha/lib_protocol/sc_rollups.mli @@ -80,3 +80,26 @@ module Kind : sig (** [string_of_kind kind] returns a human-readable representation of [kind]. *) val string_of_kind : t -> string end + +(** A module signature we can use to form first-class modules that carry + a specific proof a long with the PVM module interface. *) +module type PVM_with_proof = sig + include PVM.S + + val proof : proof +end + +(** A wrapper for first-class modules [(module PVM_with_proof)]. We need + this in order to implement an encoding function. The [Unencodable] + case is provided so that tests can provide their own PVM interfaces + without having to include proof encodings here. *) +type wrapped_proof = + | Unencodable of (module PVM_with_proof) + | Arith_pvm_with_proof of + (module PVM_with_proof + with type proof = Sc_rollup_arith.ProtocolImplementation.proof) + +(** Unwrap a [wrapped_proof] into a first-class module. *) +val wrapped_proof_module : wrapped_proof -> (module PVM_with_proof) + +val wrapped_proof_encoding : wrapped_proof Data_encoding.t -- GitLab From ace20a944b8d531e728dd70b6e818e7fdab5c935 Mon Sep 17 00:00:00 2001 From: Thomas Athorne Date: Mon, 23 May 2022 18:31:59 +0100 Subject: [PATCH 03/11] Proto: SCORU: inbox proof implementation --- .../lib_protocol/alpha_context.mli | 2 + .../lib_protocol/sc_rollup_inbox_repr.ml | 119 ++++++++++++++++++ .../lib_protocol/sc_rollup_inbox_repr.mli | 52 ++++++++ 3 files changed, 173 insertions(+) diff --git a/src/proto_alpha/lib_protocol/alpha_context.mli b/src/proto_alpha/lib_protocol/alpha_context.mli index 55b92bbd6e1d..561a2fa9109c 100644 --- a/src/proto_alpha/lib_protocol/alpha_context.mli +++ b/src/proto_alpha/lib_protocol/alpha_context.mli @@ -2626,6 +2626,8 @@ module Sc_rollup : sig type inclusion_proof + val inclusion_proof_encoding : inclusion_proof Data_encoding.t + val pp_inclusion_proof : Format.formatter -> inclusion_proof -> unit val number_of_proof_steps : inclusion_proof -> int diff --git a/src/proto_alpha/lib_protocol/sc_rollup_inbox_repr.ml b/src/proto_alpha/lib_protocol/sc_rollup_inbox_repr.ml index 0e9ffa263a18..3b4683f25bb0 100644 --- a/src/proto_alpha/lib_protocol/sc_rollup_inbox_repr.ml +++ b/src/proto_alpha/lib_protocol/sc_rollup_inbox_repr.ml @@ -395,6 +395,8 @@ module type MerkelizedOperations = sig type inclusion_proof + val inclusion_proof_encoding : inclusion_proof Data_encoding.t + val pp_inclusion_proof : Format.formatter -> inclusion_proof -> unit val number_of_proof_steps : inclusion_proof -> int @@ -648,6 +650,10 @@ module MakeHashingScheme (Tree : TREE) : structures with the same guarantee about the size of proofs. *) type inclusion_proof = history_proof list + let inclusion_proof_encoding = + let open Data_encoding in + list history_proof_encoding + let pp_inclusion_proof fmt proof = Format.pp_print_list pp_history_proof fmt proof @@ -702,3 +708,116 @@ include ( type key = string list end) : MerkelizedOperations with type tree = Context.tree) + +type inbox = t + +module Proof = struct + type t = { + skips : (inbox * inclusion_proof) list; + (* The [skips] value in this record makes it potentially unbounded + in size. There is an issue #2997 to deal with this problem. *) + level : inbox; + inc : inclusion_proof; + message_proof : Context.Proof.tree Context.Proof.t; + } + + let encoding = + let open Data_encoding in + conv + (fun {skips; level; inc; message_proof} -> + (skips, level, inc, message_proof)) + (fun (skips, level, inc, message_proof) -> + {skips; level; inc; message_proof}) + (obj4 + (req "skips" (list (tup2 encoding inclusion_proof_encoding))) + (req "level" encoding) + (req "inc" inclusion_proof_encoding) + (req + "message_proof" + Context.Proof_encoding.V2.Tree32.tree_proof_encoding)) + + (* This function is for pattern matching on proofs based on whether + they involve multiple levels or if they only concern a single + level. + + [split_proof proof] is [None] in the case that [proof] is a + 'simple' inbox proof that only involves one level. In this case + [skips] is empty and we just check the single [level], [inc] + pair, and the [message_proof]. + + [split_proof proof] is [Some (level, inc, remaining_proof)] if + there are [skips]. In this case, we must check the [level] and + [inc] given, and then continue (recursively) on to the + [remaining_proof]. *) + let split_proof proof = + match proof.skips with + | [] -> None + | (level, inc) :: rest -> Some (level, inc, {proof with skips = rest}) + + (* A proof might include several sub-inboxes as evidence of different + levels being empty in the actual inbox snapshot. This returns the + _lowest_ such sub-inbox for a given proof. + + It's used with the function above in the recursive case of [valid]. + When [split_proof proof] gives [Some (level, inc, remaining_proof)] + we have to check that [inc] is an inclusion proof between [level] + and [bottom_level remaining_proof]. *) + let bottom_level proof = + match proof.skips with [] -> proof.level | (level, _) :: _ -> level + + (* The [message_proof] part of an inbox proof is a + [Context.tree_proof]. + + To validate this, we need a function of type + + [tree -> (tree, result) Lwt.t]. + + For a given [n], [message_payload n] is such a function: it takes a + [Context.tree] representing the messages in a single level of the + inbox and extracts the message payload at index [n], so [result] in + this case is [string]. (It also returns the tree just to satisfy + the function [Context.verify_tree_proof]). *) + let message_payload n tree = + let open Lwt_syntax in + let* r = get_message_payload tree n in + return (tree, r) + + let check_hash hash kinded_hash = + match kinded_hash with + | `Node h -> Context_hash.equal h hash + | `Value h -> Context_hash.equal h hash + + let drop_error result = Lwt.map (Result.map_error (fun _ -> ())) result + + let rec valid (l, n) inbox proof = + assert Z.(geq n zero); + let open Lwt_result_syntax in + match split_proof proof with + | None -> + if + verify_inclusion_proof proof.inc proof.level inbox + && Raw_level_repr.equal (inbox_level proof.level) l + && check_hash + (proof.level.current_messages_hash ()) + proof.message_proof.before + then + let* (_ : Context.tree), payload = + drop_error + @@ Context.verify_tree_proof proof.message_proof (message_payload n) + in + match payload with + | None -> if equal proof.level inbox then return None else fail () + | Some msg -> + return + @@ Some + Sc_rollup_PVM_sem. + {inbox_level = l; message_counter = n; payload = msg} + else fail () + | Some (level, inc, remaining_proof) -> + if + verify_inclusion_proof inc level (bottom_level remaining_proof) + && Raw_level_repr.equal (inbox_level level) l + && Z.equal level.message_counter n + then valid (Raw_level_repr.succ l, Z.zero) inbox remaining_proof + else fail () +end diff --git a/src/proto_alpha/lib_protocol/sc_rollup_inbox_repr.mli b/src/proto_alpha/lib_protocol/sc_rollup_inbox_repr.mli index 16c0e1eb350a..e74381d8333a 100644 --- a/src/proto_alpha/lib_protocol/sc_rollup_inbox_repr.mli +++ b/src/proto_alpha/lib_protocol/sc_rollup_inbox_repr.mli @@ -252,6 +252,8 @@ module type MerkelizedOperations = sig The size of this proof is O(log_basis (L' - L)). *) type inclusion_proof + val inclusion_proof_encoding : inclusion_proof Data_encoding.t + val pp_inclusion_proof : Format.formatter -> inclusion_proof -> unit (** [number_of_proof_steps proof] returns the length of [proof]. *) @@ -305,3 +307,53 @@ module MakeHashingScheme (Tree : TREE) : MerkelizedOperations with type tree = Tree.tree include MerkelizedOperations with type tree = Context.tree + +type inbox = t + +(** The [Proof] module wraps the more specific proof types provided + earlier in this file into the inbox proof as it is required by a + refutation. *) +module Proof : sig + (** An inbox proof has three parameters: + + - the [starting_point], of type [Raw_level_repr.t * Z.t], specifying + a location in the inbox ; + + - the [message], of type [Sc_rollup_PVM_sem.input option] ; + + - and a reference [inbox]. + + A valid inbox proof implies the following semantics: beginning at + [starting_point] and reading forward through [inbox], the first + message you reach will be [message]. + + Usually this is very simple because there will actually be a + message at the location specified by [starting_point]. But in some + cases [starting_point] is past the last message within a level, + and then the inbox proof must prove that and also provide another + proof starting at the beginning of the next level. This can in + theory happen across multiple levels if they are empty, which is + why we need a list [skips] of sub-inboxes. + + TODO #2997: an issue to fix the problem of unbounded inbox proofs + if the list below can be arbitrarily long (if there are many + consecutive empty levels). *) + type t = { + skips : (inbox * inclusion_proof) list; + level : inbox; + inc : inclusion_proof; + message_proof : Context.Proof.tree Context.Proof.t; + } + + val encoding : t Data_encoding.t + + (** See the docstring for [Proof.t] for details of proof semantics. + + [valid starting_point inbox proof] will return the third parameter + of the proof, [message], iff the proof is valid. *) + val valid : + Raw_level_repr.t * Z.t -> + inbox -> + t -> + (Sc_rollup_PVM_sem.input option, unit) result Lwt.t +end -- GitLab From e5d68bf7d50e544933ef05e3ed449647303035ea Mon Sep 17 00:00:00 2001 From: Thomas Athorne Date: Mon, 23 May 2022 18:32:46 +0100 Subject: [PATCH 04/11] Proto: SCORU: implement refutation proofs --- src/proto_alpha/lib_protocol/TEZOS_PROTOCOL | 1 + src/proto_alpha/lib_protocol/alpha_context.ml | 1 + .../lib_protocol/alpha_context.mli | 24 +-- src/proto_alpha/lib_protocol/dune | 5 + .../lib_protocol/sc_rollup_arith.ml | 4 +- .../lib_protocol/sc_rollup_arith.mli | 4 +- .../lib_protocol/sc_rollup_game_repr.ml | 154 +++++--------- .../lib_protocol/sc_rollup_game_repr.mli | 71 ++----- .../lib_protocol/sc_rollup_inbox_repr.ml | 2 +- .../lib_protocol/sc_rollup_proof_repr.ml | 94 +++++++++ .../lib_protocol/sc_rollup_proof_repr.mli | 97 +++++++++ .../sc_rollup_refutation_storage.ml | 14 +- .../test/pbt/test_refutation_game.ml | 197 +++++++----------- 13 files changed, 370 insertions(+), 298 deletions(-) create mode 100644 src/proto_alpha/lib_protocol/sc_rollup_proof_repr.ml create mode 100644 src/proto_alpha/lib_protocol/sc_rollup_proof_repr.mli diff --git a/src/proto_alpha/lib_protocol/TEZOS_PROTOCOL b/src/proto_alpha/lib_protocol/TEZOS_PROTOCOL index 7e007abe51c0..dc7ae1075e91 100644 --- a/src/proto_alpha/lib_protocol/TEZOS_PROTOCOL +++ b/src/proto_alpha/lib_protocol/TEZOS_PROTOCOL @@ -45,6 +45,7 @@ "Skip_list_repr", "Sc_rollup_inbox_repr", "Sc_rollup_commitment_repr", + "Sc_rollup_proof_repr", "Sc_rollup_game_repr", "Seed_repr", "Sampler", diff --git a/src/proto_alpha/lib_protocol/alpha_context.ml b/src/proto_alpha/lib_protocol/alpha_context.ml index 32e4ca3171ea..9a1ac79c7f03 100644 --- a/src/proto_alpha/lib_protocol/alpha_context.ml +++ b/src/proto_alpha/lib_protocol/alpha_context.ml @@ -62,6 +62,7 @@ module Sc_rollup = struct include Sc_rollup_inbox_storage end + module Proof = Sc_rollup_proof_repr module Game = Sc_rollup_game_repr module Commitment = struct diff --git a/src/proto_alpha/lib_protocol/alpha_context.mli b/src/proto_alpha/lib_protocol/alpha_context.mli index 561a2fa9109c..e61b1f9063aa 100644 --- a/src/proto_alpha/lib_protocol/alpha_context.mli +++ b/src/proto_alpha/lib_protocol/alpha_context.mli @@ -2615,7 +2615,7 @@ module Sc_rollup : sig val add_messages_no_history : t -> - Raw_level_repr.t -> + Raw_level.t -> string list -> messages -> (messages * t, error trace) result Lwt.t @@ -2666,30 +2666,24 @@ module Sc_rollup : sig context -> rollup -> string list -> (t * Z.t * context) tzresult Lwt.t val inbox : context -> rollup -> (t * context) tzresult Lwt.t - end - module Game : sig module Proof : sig - type t = - | Computation_step of { - valid : bool; - start : State_hash.t; - stop : State_hash.t; - } - | Input_step of { - valid : bool; - start : State_hash.t; - stop : State_hash.t; - } - | Blocked_step of {valid : bool; start : State_hash.t} + type t end + end + module Proof : sig + type t + end + + module Game : sig type player = Alice | Bob type t = { turn : player; inbox_snapshot : Inbox.t; level : Raw_level.t; + pvm_name : string; dissection : (State_hash.t option * Tick.t) list; } diff --git a/src/proto_alpha/lib_protocol/dune b/src/proto_alpha/lib_protocol/dune index d1b44b4f3646..fd7fd37f8e29 100644 --- a/src/proto_alpha/lib_protocol/dune +++ b/src/proto_alpha/lib_protocol/dune @@ -76,6 +76,7 @@ Skip_list_repr Sc_rollup_inbox_repr Sc_rollup_commitment_repr + Sc_rollup_proof_repr Sc_rollup_game_repr Seed_repr Sampler @@ -295,6 +296,7 @@ skip_list_repr.ml skip_list_repr.mli sc_rollup_inbox_repr.ml sc_rollup_inbox_repr.mli sc_rollup_commitment_repr.ml sc_rollup_commitment_repr.mli + sc_rollup_proof_repr.ml sc_rollup_proof_repr.mli sc_rollup_game_repr.ml sc_rollup_game_repr.mli seed_repr.ml seed_repr.mli sampler.ml sampler.mli @@ -501,6 +503,7 @@ skip_list_repr.ml skip_list_repr.mli sc_rollup_inbox_repr.ml sc_rollup_inbox_repr.mli sc_rollup_commitment_repr.ml sc_rollup_commitment_repr.mli + sc_rollup_proof_repr.ml sc_rollup_proof_repr.mli sc_rollup_game_repr.ml sc_rollup_game_repr.mli seed_repr.ml seed_repr.mli sampler.ml sampler.mli @@ -727,6 +730,7 @@ skip_list_repr.ml skip_list_repr.mli sc_rollup_inbox_repr.ml sc_rollup_inbox_repr.mli sc_rollup_commitment_repr.ml sc_rollup_commitment_repr.mli + sc_rollup_proof_repr.ml sc_rollup_proof_repr.mli sc_rollup_game_repr.ml sc_rollup_game_repr.mli seed_repr.ml seed_repr.mli sampler.ml sampler.mli @@ -949,6 +953,7 @@ skip_list_repr.ml skip_list_repr.mli sc_rollup_inbox_repr.ml sc_rollup_inbox_repr.mli sc_rollup_commitment_repr.ml sc_rollup_commitment_repr.mli + sc_rollup_proof_repr.ml sc_rollup_proof_repr.mli sc_rollup_game_repr.ml sc_rollup_game_repr.mli seed_repr.ml seed_repr.mli sampler.ml sampler.mli diff --git a/src/proto_alpha/lib_protocol/sc_rollup_arith.ml b/src/proto_alpha/lib_protocol/sc_rollup_arith.ml index b97901c10640..f40c2fd63728 100644 --- a/src/proto_alpha/lib_protocol/sc_rollup_arith.ml +++ b/src/proto_alpha/lib_protocol/sc_rollup_arith.ml @@ -83,9 +83,7 @@ module type S = sig end module Make (Context : P) : - S - with type context = Context.Tree.t - and type state = Context.tree = struct + S with type context = Context.Tree.t and type state = Context.tree = struct module Tree = Context.Tree type context = Context.Tree.t diff --git a/src/proto_alpha/lib_protocol/sc_rollup_arith.mli b/src/proto_alpha/lib_protocol/sc_rollup_arith.mli index 5d01dddccfad..8c305aea0d9b 100644 --- a/src/proto_alpha/lib_protocol/sc_rollup_arith.mli +++ b/src/proto_alpha/lib_protocol/sc_rollup_arith.mli @@ -143,6 +143,4 @@ module type P = sig end module Make (Context : P) : - S - with type context = Context.Tree.t - and type state = Context.tree + S with type context = Context.Tree.t and type state = Context.tree diff --git a/src/proto_alpha/lib_protocol/sc_rollup_game_repr.ml b/src/proto_alpha/lib_protocol/sc_rollup_game_repr.ml index 17070cd415fe..d101a09e8ee9 100644 --- a/src/proto_alpha/lib_protocol/sc_rollup_game_repr.ml +++ b/src/proto_alpha/lib_protocol/sc_rollup_game_repr.ml @@ -26,80 +26,13 @@ open Sc_rollup_repr -module Proof = struct - (* TODO: #2759 these proof cases are dummy ones for testing. Replace - them with the proper proofs. *) - type t = - | Computation_step of { - valid : bool; - start : State_hash.t; - stop : State_hash.t; - } - | Input_step of {valid : bool; start : State_hash.t; stop : State_hash.t} - | Blocked_step of {valid : bool; start : State_hash.t} - - let encoding = - Data_encoding.( - union - ~tag_size:`Uint8 - [ - case - ~title:"Proof of a normal computation step" - (Tag 0) - (tup3 bool State_hash.encoding State_hash.encoding) - (function - | Computation_step {valid; start; stop} -> - Some (valid, start, stop) - | _ -> None) - (fun (valid, start, stop) -> Computation_step {valid; start; stop}); - case - ~title:"Proof of an input step" - (Tag 1) - (tup3 bool State_hash.encoding State_hash.encoding) - (function - | Input_step {valid; start; stop} -> Some (valid, start, stop) - | _ -> None) - (fun (valid, start, stop) -> Input_step {valid; start; stop}); - case - ~title:"Proof that the PVM is blocked" - (Tag 2) - (tup2 bool State_hash.encoding) - (function - | Blocked_step {valid; start} -> Some (valid, start) | _ -> None) - (fun (valid, start) -> Blocked_step {valid; start}); - ]) - - (* TODO: #2759 *) - let pp _ _ = () - - (* TODO: #2759 *) - let start p = - match p with - | Computation_step x -> x.start - | Input_step x -> x.start - | Blocked_step x -> x.start - - (* TODO: #2759 *) - let stop p = - match p with - | Computation_step x -> Some x.stop - | Input_step x -> Some x.stop - | Blocked_step _ -> None - - (* TODO: #2759 *) - let valid p = - match p with - | Computation_step x -> x.valid - | Input_step x -> x.valid - | Blocked_step x -> x.valid -end - type player = Alice | Bob type t = { turn : player; inbox_snapshot : Sc_rollup_inbox_repr.t; level : Raw_level_repr.t; + pvm_name : string; dissection : (State_hash.t option * Sc_rollup_tick_repr.t) list; } @@ -131,14 +64,15 @@ let opponent = function Alice -> Bob | Bob -> Alice let encoding = let open Data_encoding in conv - (fun {turn; inbox_snapshot; level; dissection} -> - (turn, inbox_snapshot, level, dissection)) - (fun (turn, inbox_snapshot, level, dissection) -> - {turn; inbox_snapshot; level; dissection}) - (obj4 + (fun {turn; inbox_snapshot; level; pvm_name; dissection} -> + (turn, inbox_snapshot, level, pvm_name, dissection)) + (fun (turn, inbox_snapshot, level, pvm_name, dissection) -> + {turn; inbox_snapshot; level; pvm_name; dissection}) + (obj5 (req "turn" player_encoding) (req "inbox_snapshot" Sc_rollup_inbox_repr.encoding) (req "level" Raw_level_repr.encoding) + (req "pvm_name" string) (req "dissection" (list @@ -161,7 +95,7 @@ let pp_dissection ppf d = let pp ppf game = Format.fprintf ppf - "[%a] %a playing; inbox snapshot = %a; level = %a" + "[%a] %a playing; inbox snapshot = %a; level = %a; pvm_name = %s;" pp_dissection game.dissection pp_player @@ -170,6 +104,7 @@ let pp ppf game = game.inbox_snapshot Raw_level_repr.pp game.level + game.pvm_name module Index = struct type t = Staker.t * Staker.t @@ -216,7 +151,7 @@ module Index = struct match player with Alice -> alice | Bob -> bob end -let initial inbox ~(parent : Sc_rollup_commitment_repr.t) +let initial inbox ~pvm_name ~(parent : Sc_rollup_commitment_repr.t) ~(child : Sc_rollup_commitment_repr.t) ~refuter ~defender = let alice, _ = Index.normalize (refuter, defender) in let alice_to_play = Staker.equal alice refuter in @@ -225,6 +160,7 @@ let initial inbox ~(parent : Sc_rollup_commitment_repr.t) turn = (if alice_to_play then Alice else Bob); inbox_snapshot = inbox; level = child.inbox_level; + pvm_name; dissection = [ (Some parent.compressed_state, Sc_rollup_tick_repr.initial); @@ -235,7 +171,7 @@ let initial inbox ~(parent : Sc_rollup_commitment_repr.t) type step = | Dissection of (State_hash.t option * Sc_rollup_tick_repr.t) list - | Proof of Proof.t + | Proof of Sc_rollup_proof_repr.t let step_encoding = let open Data_encoding in @@ -251,7 +187,7 @@ let step_encoding = case ~title:"Proof" (Tag 1) - Proof.encoding + Sc_rollup_proof_repr.encoding (function Proof p -> Some p | _ -> None) (fun p -> Proof p); ] @@ -272,14 +208,14 @@ let pp_step ppf step = hash) ppf states - | Proof proof -> Format.fprintf ppf "proof: %a" Proof.pp proof + | Proof proof -> Format.fprintf ppf "proof: %a" Sc_rollup_proof_repr.pp proof type refutation = {choice : Sc_rollup_tick_repr.t; step : step} let pp_refutation ppf refutation = Format.fprintf ppf - "Refute at tick %a with %a.\n" + "Refute from tick %a with %a.\n" Sc_rollup_tick_repr.pp refutation.choice pp_step @@ -382,29 +318,29 @@ let outcome_encoding = (obj2 (req "loser" player_encoding) (req "reason" reason_encoding)) let find_choice game tick = - let open Result_syntax in + let open Lwt_result_syntax in let rec traverse states = match states with | (state, state_tick) :: (next_state, next_tick) :: others -> if Sc_rollup_tick_repr.(tick = state_tick) then return (state, tick, next_state, next_tick) else traverse ((next_state, next_tick) :: others) - | _ -> error () + | _ -> fail () in traverse game.dissection let check pred = - let open Result_syntax in - if pred then return () else error () + let open Lwt_result_syntax in + if pred then return () else fail () let check_dissection start start_tick stop stop_tick dissection = - let open Result_syntax in + let open Lwt_result_syntax in let len = Z.of_int @@ List.length dissection in let dist = Sc_rollup_tick_repr.distance start_tick stop_tick in let* _ = if Z.(geq dist (of_int 32)) then check Z.(equal len (of_int 32)) else if Z.(gt dist one) then check Z.(equal len (succ dist)) - else error () + else fail () in let* _ = match (List.hd dissection, List.last_opt dissection) with @@ -413,15 +349,15 @@ let check_dissection start start_tick stop stop_tick dissection = (Option.equal State_hash.equal a start && (not (Option.equal State_hash.equal b stop)) && Sc_rollup_tick_repr.(a_tick = start_tick && b_tick = stop_tick)) - | _ -> error () + | _ -> fail () in let rec traverse states = match states with | (Some _, tick) :: (next_state, next_tick) :: others -> if Sc_rollup_tick_repr.(tick < next_tick) then traverse ((next_state, next_tick) :: others) - else error () - | (None, _) :: _ :: _ -> error () + else fail () + | (None, _) :: _ :: _ -> fail () | _ -> return () in traverse dissection @@ -430,19 +366,28 @@ let check_dissection start start_tick stop stop_tick dissection = Then we check the proof begins with the correct state and ends with a different state to the one in the current dissection. - - Finally, we check that the proof itself is valid. *) -let check_proof start start_tick stop stop_tick proof = + + Note: this does not check the proof itself is valid, just that it + makes the expected claims about start and stop states. The function + [play] below has to call [Sc_rollup_proof_repr.valid] separately + to ensure the proof is actually valid. *) +let check_proof_start_stop start start_tick stop stop_tick proof = + let open Lwt_result_syntax in let dist = Sc_rollup_tick_repr.distance start_tick stop_tick in + let* _ = check Z.(equal dist one) in + let* _ = + check + @@ Option.equal + State_hash.equal + start + (Some (Sc_rollup_proof_repr.start proof)) + in check - (Z.(equal dist one) - && Option.equal State_hash.equal start (Some (Proof.start proof)) - && (not (Option.equal State_hash.equal stop (Proof.stop proof))) - && Proof.valid proof) + @@ not (Option.equal State_hash.equal stop (Sc_rollup_proof_repr.stop proof)) let play game refutation = let result = - let open Result_syntax in + let open Lwt_result_syntax in let* start, start_tick, stop, stop_tick = find_choice game refutation.choice in @@ -455,13 +400,22 @@ let play game refutation = turn = opponent game.turn; inbox_snapshot = game.inbox_snapshot; level = game.level; + pvm_name = game.pvm_name; dissection = states; }) | Proof proof -> - let* _ = check_proof start start_tick stop stop_tick proof in + let* _ = check_proof_start_stop start start_tick stop stop_tick proof in + let {inbox_snapshot; level; pvm_name; _} = game in + let* proof_valid = + Sc_rollup_proof_repr.valid inbox_snapshot level ~pvm_name proof + in + let* _ = check proof_valid in return (Either.Left {loser = opponent game.turn; reason = Conflict_resolved}) in - match Option.of_result result with - | Some x -> x - | None -> Either.Left {loser = game.turn; reason = Invalid_move} + Lwt.map + (fun r -> + match Option.of_result r with + | Some x -> x + | None -> Either.Left {loser = game.turn; reason = Invalid_move}) + result diff --git a/src/proto_alpha/lib_protocol/sc_rollup_game_repr.mli b/src/proto_alpha/lib_protocol/sc_rollup_game_repr.mli index 1addd9bc529e..19d1803a6b2d 100644 --- a/src/proto_alpha/lib_protocol/sc_rollup_game_repr.mli +++ b/src/proto_alpha/lib_protocol/sc_rollup_game_repr.mli @@ -124,48 +124,6 @@ open Sc_rollup_repr -(** Currently, [Proof] is a dummy type with the structure we need, set - up to allow testing. *) -module Proof : sig - (** There are three cases for a refutation game proof: - - [Computation_step]: a simple step in the PVM that doesn't involve - any interaction with the inbox. - - [Input_step]: a step in which the PVM 'reads' from the inbox. This - will include a proof that the machine is in a blocked state and a - proof that the next message to be read is correct. The inbox proof - part of this will refer to the [inbox_snapshot] stored in the game - type (see {!Sc_rollup_game_repr.t}). - - [Blocked_step]: similar to an input step, this is a step where the - machine is in a blocked state. However, it includes a proof that - there are no further messages in the inbox at the current level. - This means the machine is genuinely blocked and the [stop] state - of this [Proof] will be [None]. *) - type t = - | Computation_step of { - valid : bool; - start : State_hash.t; - stop : State_hash.t; - } - | Input_step of {valid : bool; start : State_hash.t; stop : State_hash.t} - | Blocked_step of {valid : bool; start : State_hash.t} - - val encoding : t Data_encoding.t - - val pp : Format.formatter -> t -> unit - - (** The state hash of the machine before the step. *) - val start : t -> State_hash.t - - (** The state hash of the machine after the step. *) - val stop : t -> State_hash.t option - - (** Check the validity of a proof *) - val valid : t -> bool -end - (** The two stakers index the game in the storage as a pair of public key hashes which is in lexical order. We use [Alice] and [Bob] to represent the first and second player in the pair respectively. *) @@ -187,6 +145,10 @@ type player = Alice | Bob will show that the next message available in [inbox_snapshot] is at [level], so shouldn't be included in this commitment. + - [pvm_name] identifies the PVM used in this rollup. It is useful to + have here so we can check that the proof provided in a refutation + is of the correct kind. + - [dissection], a list of states with tick counts. The current player will specify, in the next move, a tick count that indicates the last of these states that she agrees with. @@ -201,6 +163,7 @@ type t = { turn : player; inbox_snapshot : Sc_rollup_inbox_repr.t; level : Raw_level_repr.t; + pvm_name : string; dissection : (State_hash.t option * Sc_rollup_tick_repr.t) list; } @@ -266,6 +229,7 @@ end increment from that state to its successor. *) val initial : Sc_rollup_inbox_repr.t -> + pvm_name:string -> parent:Sc_rollup_commitment_repr.t -> child:Sc_rollup_commitment_repr.t -> refuter:Staker.t -> @@ -276,7 +240,7 @@ val initial : intermediate ticks remaining to put in it) or a proof. *) type step = | Dissection of (State_hash.t option * Sc_rollup_tick_repr.t) list - | Proof of Proof.t + | Proof of Sc_rollup_proof_repr.t (** A [refutation] is a move in the game. [choice] is the final tick in the current dissection at which the two players agree. *) @@ -331,16 +295,9 @@ val find_choice : * Sc_rollup_tick_repr.t * Sc_rollup_repr.State_hash.t option * Sc_rollup_tick_repr.t, - unit trace ) + unit ) result - -(** Applies the move [refutation] to the game. Checks the move is - valid and returns an [Invalid_move] outcome if not. - - In the case of the game continuing, this swaps the current - player and updates the [dissection]. In the case of a [Proof] - being provided this returns an [outcome]. *) -val play : t -> refutation -> (outcome, t) Either.t + Lwt.t (** We check firstly that [dissection] is the correct length. It must be 32 values long, unless the distance between [start_tick] and @@ -361,4 +318,12 @@ val check_dissection : Sc_rollup_repr.State_hash.t option -> Sc_rollup_tick_repr.t -> (Sc_rollup_repr.State_hash.t option * Sc_rollup_tick_repr.t) list -> - (unit, unit trace) result + (unit, unit) result Lwt.t + +(** Applies the move [refutation] to the game. Checks the move is + valid and returns an [Invalid_move] outcome if not. + + In the case of the game continuing, this swaps the current + player and updates the [dissection]. In the case of a [Proof] + being provided this returns an [outcome]. *) +val play : t -> refutation -> (outcome, t) Either.t Lwt.t diff --git a/src/proto_alpha/lib_protocol/sc_rollup_inbox_repr.ml b/src/proto_alpha/lib_protocol/sc_rollup_inbox_repr.ml index 3b4683f25bb0..4901b948549f 100644 --- a/src/proto_alpha/lib_protocol/sc_rollup_inbox_repr.ml +++ b/src/proto_alpha/lib_protocol/sc_rollup_inbox_repr.ml @@ -790,7 +790,7 @@ module Proof = struct let drop_error result = Lwt.map (Result.map_error (fun _ -> ())) result let rec valid (l, n) inbox proof = - assert Z.(geq n zero); + assert (Z.(geq n zero)) ; let open Lwt_result_syntax in match split_proof proof with | None -> diff --git a/src/proto_alpha/lib_protocol/sc_rollup_proof_repr.ml b/src/proto_alpha/lib_protocol/sc_rollup_proof_repr.ml new file mode 100644 index 000000000000..1a049b28fd28 --- /dev/null +++ b/src/proto_alpha/lib_protocol/sc_rollup_proof_repr.ml @@ -0,0 +1,94 @@ +(*****************************************************************************) +(* *) +(* Open Source License *) +(* Copyright (c) 2022 Nomadic Labs *) +(* Copyright (c) 2022 Trili Tech, *) +(* *) +(* Permission is hereby granted, free of charge, to any person obtaining a *) +(* copy of this software and associated documentation files (the "Software"),*) +(* to deal in the Software without restriction, including without limitation *) +(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *) +(* and/or sell copies of the Software, and to permit persons to whom the *) +(* Software is furnished to do so, subject to the following conditions: *) +(* *) +(* The above copyright notice and this permission notice shall be included *) +(* in all copies or substantial portions of the Software. *) +(* *) +(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*) +(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *) +(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *) +(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*) +(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *) +(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *) +(* DEALINGS IN THE SOFTWARE. *) +(* *) +(*****************************************************************************) + +type t = { + pvm_step : Sc_rollups.wrapped_proof; + inbox : Sc_rollup_inbox_repr.Proof.t option; +} + +let encoding = + let open Data_encoding in + conv + (fun {pvm_step; inbox} -> (pvm_step, inbox)) + (fun (pvm_step, inbox) -> {pvm_step; inbox}) + (obj2 + (req "pvm_step" Sc_rollups.wrapped_proof_encoding) + (req "inbox" (option Sc_rollup_inbox_repr.Proof.encoding))) + +let pp ppf _ = Format.fprintf ppf "Refutation game proof" + +let start proof = + let (module P) = Sc_rollups.wrapped_proof_module proof.pvm_step in + P.proof_start_state P.proof + +let stop proof = + let (module P) = Sc_rollups.wrapped_proof_module proof.pvm_step in + P.proof_stop_state P.proof + +(* This takes an [input] and checks if it is at or above the given level. + It returns [None] if this is the case. + + We use this to check that the PVM proof is obeying [commit_level] + correctly---if the message obtained from the inbox proof is at or + above [commit_level] the [input_given] in the PVM proof should be + [None]. *) +let cut_at_level level input = + let input_level = Sc_rollup_PVM_sem.(input.inbox_level) in + if Raw_level_repr.(level <= input_level) then None else Some input + +let check p = + let open Lwt_result_syntax in + if p then return () else fail () + +let valid snapshot commit_level ~pvm_name proof = + let (module P) = Sc_rollups.wrapped_proof_module proof.pvm_step in + let open Lwt_result_syntax in + let* _ = check (String.equal P.name pvm_name) in + let input_requested = P.proof_input_requested P.proof in + let input_given = P.proof_input_given P.proof in + let* input = + match (input_requested, proof.inbox) with + | Sc_rollup_PVM_sem.No_input_required, None -> return None + | Sc_rollup_PVM_sem.Initial, Some inbox_proof -> + Sc_rollup_inbox_repr.Proof.valid + (Raw_level_repr.root, Z.zero) + snapshot + inbox_proof + | Sc_rollup_PVM_sem.First_after (level, counter), Some inbox_proof -> + Sc_rollup_inbox_repr.Proof.valid + (level, Z.succ counter) + snapshot + inbox_proof + | _ -> fail () + in + let* _ = + check + (Option.equal + Sc_rollup_PVM_sem.input_equal + (Option.bind input (cut_at_level commit_level)) + input_given) + in + Lwt.map Result.ok (P.verify_proof P.proof) diff --git a/src/proto_alpha/lib_protocol/sc_rollup_proof_repr.mli b/src/proto_alpha/lib_protocol/sc_rollup_proof_repr.mli new file mode 100644 index 000000000000..a32c6ef34150 --- /dev/null +++ b/src/proto_alpha/lib_protocol/sc_rollup_proof_repr.mli @@ -0,0 +1,97 @@ +(*****************************************************************************) +(* *) +(* Open Source License *) +(* Copyright (c) 2022 Nomadic Labs *) +(* Copyright (c) 2022 Trili Tech, *) +(* *) +(* Permission is hereby granted, free of charge, to any person obtaining a *) +(* copy of this software and associated documentation files (the "Software"),*) +(* to deal in the Software without restriction, including without limitation *) +(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *) +(* and/or sell copies of the Software, and to permit persons to whom the *) +(* Software is furnished to do so, subject to the following conditions: *) +(* *) +(* The above copyright notice and this permission notice shall be included *) +(* in all copies or substantial portions of the Software. *) +(* *) +(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*) +(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *) +(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *) +(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*) +(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *) +(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *) +(* DEALINGS IN THE SOFTWARE. *) +(* *) +(*****************************************************************************) + +(** A refutation game proof is required as part of the final move in a + game. + + This proof is basically a combination of a PVM proof (provided by + each implementation of the PVM signature) and an inbox proof. To + check the proof we must check each part separately and then also + check that they match on the two points where they touch: + + - the [input_requested] of the PVM proof should match the starting + point of the inbox proof ; + + - the [input_given] of the PVM proof should match the output + message of the inbox proof. + + It is also often the case that the PVM proof has [No_input_required] + for its [input_requested] and [None] for its [input_given]. If this + is the case, we don't need the inbox proof at all and the [inbox] + parameter in our proof should be [None]. *) + +open Sc_rollup_repr + +(** A PVM proof [pvm_step] is combined with an [inbox] proof to provide + the proof necessary to validate a single step in the refutation + game. + + If the step doesn't involve any input, [proof_input_requested + pvm_step] and [proof_input_given pvm_step] will be + [No_input_required] and [None] respectively, and in this case + [inbox] should also be [None]. + + In the case that input is involved, [inbox] is a proof of the next + message available from the inbox after a given location; this must + match up with [pvm_step] to give a valid refutation proof. *) +type t = { + pvm_step : Sc_rollups.wrapped_proof; + inbox : Sc_rollup_inbox_repr.Proof.t option; +} + +val encoding : t Data_encoding.t + +val pp : Format.formatter -> t -> unit + +(** The state hash of the machine before the step. This must be checked + against the value in the refutation game as well as checking the + proof is valid. *) +val start : t -> State_hash.t + +(** The state hash of the machine after the step. This must be checked + against the value in the refutation game as well as checking the + proof is valid. *) +val stop : t -> State_hash.t option + +(** Check the validity of a proof. + + This function requires a few bits of data (available from the + refutation game record in the storage): + + - a snapshot of the inbox, used by the [inbox] proof ; + + - the inbox level of the commitment, used to determine if an + output from the [inbox] proof is too recent to be allowed into the + PVM proof ; + + - the [pvm_name], used to check that the proof given has the right + PVM kind. *) +val valid : + Sc_rollup_inbox_repr.t -> + Raw_level_repr.t -> + pvm_name:string -> + t -> + (bool, unit) result Lwt.t diff --git a/src/proto_alpha/lib_protocol/sc_rollup_refutation_storage.ml b/src/proto_alpha/lib_protocol/sc_rollup_refutation_storage.ml index d99a038a5c40..09cb05f7ea4b 100644 --- a/src/proto_alpha/lib_protocol/sc_rollup_refutation_storage.ml +++ b/src/proto_alpha/lib_protocol/sc_rollup_refutation_storage.ml @@ -190,8 +190,15 @@ let get_or_init_game ctxt rollup ~refuter ~defender = Commitment_storage.get_commitment_unsafe ctxt rollup child.predecessor in let* ctxt, inbox = Store.Inbox.get ctxt rollup in + let* kind = Store.PVM_kind.get ctxt rollup in let game = - Sc_rollup_game_repr.initial inbox ~parent ~child ~refuter ~defender + Sc_rollup_game_repr.initial + inbox + ~pvm_name:(Sc_rollups.Kind.string_of_kind kind) + ~parent + ~child + ~refuter + ~defender in let* ctxt, _ = Store.Game.init (ctxt, rollup) stakers game in let* ctxt, _ = @@ -214,7 +221,10 @@ let update_game ctxt rollup ~player ~opponent refutation = Sc_rollup_repr.Staker.equal turn player) Sc_rollup_wrong_turn in - match Sc_rollup_game_repr.play game refutation with + let* move_result = + Lwt.map Result.ok @@ Sc_rollup_game_repr.play game refutation + in + match move_result with | Either.Left outcome -> return (Some outcome, ctxt) | Either.Right new_game -> let* ctxt, _ = Store.Game.update (ctxt, rollup) (alice, bob) new_game in diff --git a/src/proto_alpha/lib_protocol/test/pbt/test_refutation_game.ml b/src/proto_alpha/lib_protocol/test/pbt/test_refutation_game.ml index 622c6715b6ef..24f5df849e9e 100644 --- a/src/proto_alpha/lib_protocol/test/pbt/test_refutation_game.ml +++ b/src/proto_alpha/lib_protocol/test/pbt/test_refutation_game.ml @@ -36,6 +36,7 @@ open Protocol open Alpha_context open Sc_rollup open Lwt_syntax +open Tezos_context_memory exception TickNotFound of Sc_rollup_tick_repr.t @@ -49,28 +50,28 @@ module Sc_rollup_repr = Protocol.Sc_rollup_repr *) let assume_some opt f = match opt with Some x -> f x | None -> assert false -let to_PVM_state_hash hash = - State_hash.of_bytes_exn @@ Sc_rollup_repr.State_hash.to_bytes hash - -let of_PVM_state_hash x = - Sc_rollup_repr.State_hash.of_bytes_exn @@ State_hash.to_bytes x - let hash_state state number = Digest.bytes @@ Bytes.of_string @@ state ^ string_of_int number -let proof_start_state proof = - let open Sc_rollup_game_repr.Proof in - match proof with - | Computation_step {start; _} - | Input_step {start; _} - | Blocked_step {start; _} -> - to_PVM_state_hash start +type dummy_proof = { + start : Sc_rollup_repr.State_hash.t; + stop : Sc_rollup_repr.State_hash.t option; + valid : bool; +} + +let dummy_proof_encoding : dummy_proof Data_encoding.t = + let open Data_encoding in + conv + (fun {start; stop; valid} -> (start, stop, valid)) + (fun (start, stop, valid) -> {start; stop; valid}) + (obj3 + (req "start" Sc_rollup_repr.State_hash.encoding) + (req "stop" (option Sc_rollup_repr.State_hash.encoding)) + (req "valid" bool)) -let proof_stop_state proof = - let open Sc_rollup_game_repr.Proof in - match proof with - | Computation_step {stop; _} | Input_step {stop; _} -> to_PVM_state_hash stop - | Blocked_step _ -> assert false +let proof_start_state proof = proof.start + +let proof_stop_state proof = proof.stop let check pred = let open Result_syntax in @@ -190,10 +191,7 @@ let rec correct_string () = if List.length x < 3 then correct_string () else x module type TestPVM = sig - include - Sc_rollup_PVM_sem.S - with type hash = State_hash.t - and type proof = Sc_rollup_game_repr.Proof.t + include Sc_rollup_PVM_sem.S with type hash = Sc_rollup_repr.State_hash.t module Utils : sig (** This a post-boot state. It is used as default in many functions. *) @@ -225,20 +223,24 @@ module MakeCountingPVM (P : sig end) : TestPVM with type state = int = struct type state = int - type hash = State_hash.t + type hash = Sc_rollup_repr.State_hash.t type context = unit - type proof = Sc_rollup_game_repr.Proof.t + type proof = dummy_proof let proof_start_state = proof_start_state let proof_stop_state = proof_stop_state + let proof_input_given _ = None + + let proof_input_requested _ = Sc_rollup_PVM_sem.No_input_required + let state_hash (x : state) = - Lwt.return (State_hash.hash_string [Int.to_string x]) + Lwt.return (Sc_rollup_repr.State_hash.hash_string [Int.to_string x]) - let is_input_state _ = Lwt.return None + let is_input_state _ = Lwt.return Sc_rollup_PVM_sem.No_input_required let initial_state _ _ = Lwt.return P.target @@ -253,32 +255,17 @@ end) : TestPVM with type state = int = struct match (s1, s2) with | None, _ -> assert false | Some start_hash, Some stop_hash -> - Lwt.return - @@ Sc_rollup_game_repr.Proof.( - Computation_step - { - start = of_PVM_state_hash start_hash; - stop = of_PVM_state_hash @@ stop_hash; - valid = v; - }) + Lwt.return @@ {start = start_hash; stop = Some stop_hash; valid = v} | Some start_hash, None -> - Lwt.return - @@ Sc_rollup_game_repr.Proof.( - Blocked_step {start = of_PVM_state_hash start_hash; valid = v}) + Lwt.return @@ {start = start_hash; stop = None; valid = v} end - let proof_encoding = Sc_rollup_game_repr.Proof.encoding + let proof_encoding = dummy_proof_encoding let eval state = if state >= P.target then Lwt.return state else Lwt.return (state + 1) - let verify_proof ~input:_ proof = - let open Sc_rollup_game_repr.Proof in - match proof with - | Computation_step {valid; _} - | Input_step {valid; _} - | Blocked_step {valid; _} -> - Lwt.return valid + let verify_proof proof = Lwt.return proof.valid end (** This is a random PVM. Its state is a pair of a string and a @@ -291,9 +278,9 @@ end) : TestPVM with type state = string * int list = struct type context = unit - type proof = Sc_rollup_game_repr.Proof.t + type proof = dummy_proof - type hash = State_hash.t + type hash = Sc_rollup_repr.State_hash.t let to_string (a, b) = Format.sprintf "(%s, [%s])" a (String.concat ";" @@ List.map Int.to_string b) @@ -302,12 +289,16 @@ end) : TestPVM with type state = string * int list = struct let proof_stop_state = proof_stop_state + let proof_input_given _ = None + + let proof_input_requested _ = Sc_rollup_PVM_sem.No_input_required + let state_hash (x : state) = - Lwt.return @@ State_hash.hash_string [to_string x] + Lwt.return @@ Sc_rollup_repr.State_hash.hash_string [to_string x] let initial_state _ _ = Lwt.return ("hello", P.initial_prog) - let is_input_state _ = Lwt.return None + let is_input_state _ = Lwt.return Sc_rollup_PVM_sem.No_input_required let set_input _ state = Lwt.return state @@ -325,72 +316,56 @@ end) : TestPVM with type state = string * int list = struct match (s1, s2) with | None, _ -> assert false | Some start_hash, Some stop_hash -> - Lwt.return - @@ Sc_rollup_game_repr.Proof.( - Computation_step - { - start = of_PVM_state_hash start_hash; - stop = of_PVM_state_hash @@ stop_hash; - valid = v; - }) + Lwt.return @@ {start = start_hash; stop = Some stop_hash; valid = v} | Some start_hash, None -> - Lwt.return - @@ Sc_rollup_game_repr.Proof.( - Blocked_step {start = of_PVM_state_hash start_hash; valid = v}) + Lwt.return @@ {start = start_hash; stop = None; valid = v} end - let proof_encoding = Sc_rollup_game_repr.Proof.encoding + let proof_encoding = dummy_proof_encoding let eval (hash, continuation) = match continuation with | [] -> Lwt.return (hash, continuation) | h :: tl -> Lwt.return (hash_state hash h, tl) - let verify_proof ~input:_ proof = - let open Sc_rollup_game_repr.Proof in - match proof with - | Computation_step {valid; _} - | Input_step {valid; _} - | Blocked_step {valid; _} -> - Lwt.return valid + let verify_proof proof = Lwt.return proof.valid end module ContextPVM = Sc_rollup_arith.Make (struct module Tree = struct - include Tezos_context_memory.Context.Tree + include Context.Tree - type tree = Tezos_context_memory.Context.tree + type tree = Context.tree - type t = Tezos_context_memory.Context.t + type t = Context.t type key = string list type value = bytes end - type tree = Tezos_context_memory.Context.tree + type tree = Context.tree - let empty_tree = Tree.empty Tezos_context_memory.Context.empty + let empty_tree = Tree.empty Context.empty - type proof = Sc_rollup_game_repr.Proof.t + type proof = Context.Proof.tree Context.Proof.t let verify_proof proof f = - let* a, r = f empty_tree in - if Sc_rollup_game_repr.Proof.valid proof then return (Ok (a, r)) - else return (Error (`Proof_mismatch "Wrong proof")) + Lwt.map Result.to_option (Context.verify_tree_proof proof f) - let to_state_hash hash = - State_hash.of_bytes_exn @@ Sc_rollup_repr.State_hash.to_bytes hash + let kinded_hash_to_state_hash = function + | `Value hash | `Node hash -> + Sc_rollup_repr.State_hash.hash_bytes [Context_hash.to_bytes hash] let proof_start_state proof = - to_state_hash @@ Sc_rollup_game_repr.Proof.start proof + kinded_hash_to_state_hash proof.Context.Proof.before let proof_stop_state proof = - match Sc_rollup_game_repr.Proof.stop proof with - | Some a -> to_state_hash a - | None -> assert false + kinded_hash_to_state_hash proof.Context.Proof.after - let proof_encoding = Sc_rollup_game_repr.Proof.encoding + let proof_encoding = + let open Data_encoding in + conv (fun _ -> ()) (fun _ -> assert false) unit end) module TestArith (P : sig @@ -409,7 +384,7 @@ end) : TestPVM = struct let input = Sc_rollup_PVM_sem. { - inbox_level = Raw_level.root; + inbox_level = Raw_level_repr.root; message_counter = Z.zero; payload = P.inputs; } @@ -425,7 +400,7 @@ end) : TestPVM = struct let input = Sc_rollup_PVM_sem. { - inbox_level = Raw_level.root; + inbox_level = Raw_level_repr.root; message_counter = Z.zero; payload = String.concat " " program; } @@ -439,18 +414,9 @@ end) : TestPVM = struct match (s1, s2) with | None, _ -> assert false | Some start_hash, Some stop_hash -> - Lwt.return - @@ Sc_rollup_game_repr.Proof.( - Computation_step - { - start = of_PVM_state_hash start_hash; - stop = of_PVM_state_hash @@ stop_hash; - valid = v; - }) + Lwt.return @@ {start = start_hash; stop = Some stop_hash; valid = v} | Some start_hash, None -> - Lwt.return - @@ Sc_rollup_game_repr.Proof.( - Blocked_step {start = of_PVM_state_hash start_hash; valid = v}) + Lwt.return @@ {start = start_hash; stop = None; valid = v} end end @@ -459,8 +425,8 @@ end *) module Strategies (PVM : TestPVM - with type hash = Sc_rollup.State_hash.t - and type proof = Sc_rollup_game_repr.Proof.t) = + with type hash = Sc_rollup_repr.State_hash.t + and type proof = dummy_proof) = struct module Game = Sc_rollup_game_repr @@ -540,7 +506,7 @@ struct let* h = PVM.state_hash s in Lwt.return (Some h) in - (Option.map of_PVM_state_hash hash, tick)) + (hash, tick)) a) tick_list in @@ -581,12 +547,7 @@ struct in let number_of_ticks = Int32.of_int int_tick in let parent = - get_comm - Sc_rollup_commitment_repr.Hash.zero - 0l - 3l - 1l - (of_PVM_state_hash start_hash) + get_comm Sc_rollup_commitment_repr.Hash.zero 0l 3l 1l start_hash in let child = get_comm @@ -594,7 +555,7 @@ struct 0l 3l number_of_ticks - (of_PVM_state_hash initial_hash) + initial_hash in let initial_game = initial inbox ~parent ~child ~refuter ~defender in @@ -640,8 +601,7 @@ struct Lwt.return (Some state) in - Lwt.return - @@ not (Option.equal ( = ) state (Option.map of_PVM_state_hash new_hash)) + Lwt.return @@ not (Option.equal ( = ) state new_hash) (** This function assembles a random decision from a given dissection. It first picks a random section from the dissection and modifies randomly @@ -654,16 +614,14 @@ struct let cardinal = List.length d in let x = max 0 (Random.int (cardinal - 1)) in let start_state, start = - match List.nth d x with - | Some (s, t) -> (Option.map to_PVM_state_hash s, t) - | None -> assert false + match List.nth d x with Some (s, t) -> (s, t) | None -> assert false in let _, stop = match List.nth d (x + 1) with - | Some (s, t) -> (Option.map to_PVM_state_hash s, t) + | Some (s, t) -> (s, t) | None -> assert false in - let start_hash = Option.map of_PVM_state_hash start_state in + let start_hash = start_state in let stop_hash = Some (random_hash ()) in let* random_dissection = random_dissection start start_hash stop stop_hash @@ -680,13 +638,10 @@ struct | None -> Lwt.return_false | Some x -> let* correct_hash = PVM.state_hash x in - Lwt.return (correct_hash = to_PVM_state_hash new_hash) + Lwt.return (correct_hash = new_hash) in let* proof = - PVM.Utils.make_proof - start_state - (Some (to_PVM_state_hash @@ random_hash ())) - valid + PVM.Utils.make_proof start_state (Some (random_hash ())) valid in Lwt.return (Some Sc_rollup_game_repr.{choice = start; step = Proof proof}) @@ -936,11 +891,11 @@ let test_random_dissection (module P : TestPVM) start_at length = | Some x -> x in let* start = state_hash section_start_state in - let stop_hash = Some (aux @@ of_PVM_state_hash start) in + let stop_hash = Some (aux start) in Lwt.return (Result.to_option @@ Sc_rollup_game_repr.check_dissection - (Some (of_PVM_state_hash start)) + (Some start) section_start_at stop_hash section_stop_at -- GitLab From 9a636a341ffcca5fe0c8a018fcd6a7385a7013f4 Mon Sep 17 00:00:00 2001 From: Thomas Athorne Date: Wed, 1 Jun 2022 11:01:10 +0100 Subject: [PATCH 05/11] Proto: SCORU: proof production fns + basic PBTs Co-authored-by: Yann Regis-Gianas --- .../bin_sc_rollup_node/arith_pvm.ml | 26 +- src/proto_alpha/bin_sc_rollup_node/event.ml | 2 +- .../bin_sc_rollup_node/interpreter.ml | 6 +- src/proto_alpha/bin_sc_rollup_node/pvm.ml | 5 +- src/proto_alpha/lib_protocol/alpha_context.ml | 2 + .../lib_protocol/alpha_context.mli | 148 +++- .../lib_protocol/sc_rollup_PVM_sem.ml | 22 + .../lib_protocol/sc_rollup_arith.ml | 60 +- .../lib_protocol/sc_rollup_arith.mli | 11 +- .../lib_protocol/sc_rollup_game_repr.ml | 126 +++- .../lib_protocol/sc_rollup_game_repr.mli | 8 +- .../lib_protocol/sc_rollup_inbox_repr.ml | 23 +- .../lib_protocol/sc_rollup_inbox_repr.mli | 15 +- .../lib_protocol/sc_rollup_proof_repr.ml | 53 +- .../lib_protocol/sc_rollup_proof_repr.mli | 30 +- .../sc_rollup_refutation_storage.ml | 2 +- src/proto_alpha/lib_protocol/sc_rollups.ml | 26 +- src/proto_alpha/lib_protocol/sc_rollups.mli | 15 +- .../integration/operations/test_sc_rollup.ml | 6 +- .../test/pbt/test_refutation_game.ml | 631 +++++++++--------- 20 files changed, 785 insertions(+), 432 deletions(-) diff --git a/src/proto_alpha/bin_sc_rollup_node/arith_pvm.ml b/src/proto_alpha/bin_sc_rollup_node/arith_pvm.ml index 154567fce399..8b527f9389a8 100644 --- a/src/proto_alpha/bin_sc_rollup_node/arith_pvm.ml +++ b/src/proto_alpha/bin_sc_rollup_node/arith_pvm.ml @@ -36,17 +36,35 @@ module Arith_proof_format = struct type proof = IStoreProof.Proof.tree IStoreProof.Proof.t - let verify_proof = IStoreProof.verify_tree_proof + let verify_proof proof step = + (* The rollup node is not supposed to verify proof. We keep + this part in case this changes in the future. *) + let open Lwt_syntax in + let* result = IStoreProof.verify_tree_proof proof step in + match result with + | Ok v -> return (Some v) + | Error _ -> + (* We skip the error analysis here since proof verification is not a + job for the rollup node. *) + return None + + let produce_proof context tree step = + let open Lwt_syntax in + match IStoreTree.kinded_key tree with + | Some k -> + let* p = IStoreProof.produce_tree_proof (IStore.repo context) k step in + return (Some p) + | None -> return None let kinded_hash_to_state_hash : IStoreProof.Proof.kinded_hash -> Sc_rollup.State_hash.t = function | `Value hash | `Node hash -> Sc_rollup.State_hash.hash_bytes [Context_hash.to_bytes hash] - let proof_start_state proof = + let proof_before proof = kinded_hash_to_state_hash proof.IStoreProof.Proof.before - let proof_stop_state proof = + let proof_after proof = kinded_hash_to_state_hash proof.IStoreProof.Proof.after let proof_encoding = @@ -54,7 +72,7 @@ module Arith_proof_format = struct end module Impl : Pvm.S = struct - include Sc_rollup_arith.Make (struct + include Sc_rollup.ArithPVM.Make (struct open Store module Tree = IStoreTree diff --git a/src/proto_alpha/bin_sc_rollup_node/event.ml b/src/proto_alpha/bin_sc_rollup_node/event.ml index f0007d0bdef3..53588fecec3e 100644 --- a/src/proto_alpha/bin_sc_rollup_node/event.ml +++ b/src/proto_alpha/bin_sc_rollup_node/event.ml @@ -73,5 +73,5 @@ let node_is_ready ~rpc_addr ~rpc_port = Simple.(emit node_is_ready (rpc_addr, rpc_port)) let rollup_exists ~addr ~kind = - let kind = Protocol.Sc_rollup.string_of_kind kind in + let kind = Protocol.Alpha_context.Sc_rollup.Kind.name_of kind in Simple.(emit rollup_exists (addr, kind)) diff --git a/src/proto_alpha/bin_sc_rollup_node/interpreter.ml b/src/proto_alpha/bin_sc_rollup_node/interpreter.ml index ba769393f1af..a1a9cb4a25c5 100644 --- a/src/proto_alpha/bin_sc_rollup_node/interpreter.ml +++ b/src/proto_alpha/bin_sc_rollup_node/interpreter.ml @@ -44,10 +44,10 @@ module Make (PVM : Pvm.S) : S = struct let rec go state = let* input_request = PVM.is_input_state state in match input_request with - | Some _ -> return state - | None -> + | No_input_required -> let* next_state = PVM.eval state in go next_state + | _ -> return state in go state @@ -98,7 +98,7 @@ module Make (PVM : Pvm.S) : S = struct List.fold_left_i_s (fun message_counter state payload -> let input = - Sc_rollup_PVM_sem. + Sc_rollup. {inbox_level; message_counter = Z.of_int message_counter; payload} in feed_input state input) diff --git a/src/proto_alpha/bin_sc_rollup_node/pvm.ml b/src/proto_alpha/bin_sc_rollup_node/pvm.ml index 6a7360c020d6..0c44a30b61a9 100644 --- a/src/proto_alpha/bin_sc_rollup_node/pvm.ml +++ b/src/proto_alpha/bin_sc_rollup_node/pvm.ml @@ -29,7 +29,10 @@ open Alpha_context (** Desired module type of a PVM from the L2 node's perspective *) module type S = sig include - Sc_rollup_PVM_sem.S with type context = Store.t and type state = Store.tree + Sc_rollup.PVM.S + with type context = Store.t + and type state = Store.tree + and type hash = Sc_rollup.State_hash.t (** [get_tick state] gets the total tick counter for the given PVM state. *) val get_tick : state -> Sc_rollup.Tick.t Lwt.t diff --git a/src/proto_alpha/lib_protocol/alpha_context.ml b/src/proto_alpha/lib_protocol/alpha_context.ml index 9a1ac79c7f03..8c4eba3f8268 100644 --- a/src/proto_alpha/lib_protocol/alpha_context.ml +++ b/src/proto_alpha/lib_protocol/alpha_context.ml @@ -56,6 +56,8 @@ module Sc_rollup_repr = Sc_rollup_repr module Sc_rollup = struct module Tick = Sc_rollup_tick_repr include Sc_rollup_repr + include Sc_rollup_PVM_sem + module ArithPVM = Sc_rollup_arith module Inbox = struct include Sc_rollup_inbox_repr diff --git a/src/proto_alpha/lib_protocol/alpha_context.mli b/src/proto_alpha/lib_protocol/alpha_context.mli index e61b1f9063aa..a8dc47ede4f5 100644 --- a/src/proto_alpha/lib_protocol/alpha_context.mli +++ b/src/proto_alpha/lib_protocol/alpha_context.mli @@ -2494,6 +2494,30 @@ module Sc_rollup : sig type rollup := t + module Staker : + S.SIGNATURE_PUBLIC_KEY_HASH with type t = Signature.Public_key_hash.t + + module State_hash : S.HASH + + type input = { + inbox_level : Raw_level.t; + message_counter : Z.t; + payload : string; + } + + val input_equal : input -> input -> bool + + val input_encoding : input Data_encoding.t + + type input_request = + | No_input_required + | Initial + | First_after of Raw_level_repr.t * Z.t + + val input_request_encoding : input_request Data_encoding.t + + val input_request_equal : input_request -> input_request -> bool + module PVM : sig type boot_sector = string @@ -2504,7 +2528,38 @@ module Sc_rollup : sig val pp_boot_sector : Format.formatter -> boot_sector -> unit - include Sc_rollup_PVM_sem.S + type state + + type context + + type hash = State_hash.t + + type proof + + val proof_encoding : proof Data_encoding.t + + val proof_start_state : proof -> hash + + val proof_stop_state : proof -> hash option + + val proof_input_requested : proof -> input_request + + val proof_input_given : proof -> input option + + val state_hash : state -> hash Lwt.t + + val initial_state : context -> string -> state Lwt.t + + val is_input_state : state -> input_request Lwt.t + + val set_input : input -> state -> state Lwt.t + + val eval : state -> state Lwt.t + + val verify_proof : proof -> bool Lwt.t + + val produce_proof : + context -> input option -> state -> (proof, string) result Lwt.t end type t = (module S) @@ -2521,6 +2576,8 @@ module Sc_rollup : sig val pvm_of_name : name:string -> PVM.t option + val name_of : t -> string + val of_name : string -> t option val all : t list @@ -2528,10 +2585,44 @@ module Sc_rollup : sig val all_names : string list end - module Staker : - S.SIGNATURE_PUBLIC_KEY_HASH with type t = Signature.Public_key_hash.t + module ArithPVM : sig + module type P = sig + module Tree : + Context.TREE with type key = string list and type value = bytes - module State_hash : S.HASH + type tree = Tree.tree + + type proof + + val proof_encoding : proof Data_encoding.t + + val proof_before : proof -> State_hash.t + + val proof_after : proof -> State_hash.t + + val verify_proof : + proof -> (tree -> (tree * 'a) Lwt.t) -> (tree * 'a) option Lwt.t + + val produce_proof : + Tree.t -> + tree -> + (tree -> (tree * 'a) Lwt.t) -> + (proof * 'a) option Lwt.t + end + + module Make (C : P) : sig + include PVM.S with type context = C.Tree.t and type state = C.tree + + val get_tick : state -> Tick.t Lwt.t + + type status = Halted | WaitingForInputMessage | Parsing | Evaluating + + val get_status : state -> status Lwt.t + + val produce_proof : + context -> input option -> state -> (proof, string) result Lwt.t + end + end module Number_of_messages : Bounded.Int32.S @@ -2672,8 +2763,34 @@ module Sc_rollup : sig end end + module type PVM_with_proof = sig + include PVM.S + + val proof : proof + end + + type wrapped_proof = + | Unencodable of (module PVM_with_proof) + | Arith_pvm_with_proof of + (module PVM_with_proof + with type proof = Sc_rollup_arith.ProtocolImplementation.proof) + module Proof : sig - type t + type t = {pvm_step : wrapped_proof; inbox : Inbox.Proof.t option} + + module type PVM_with_context_and_state = sig + include Sc_rollups.PVM.S + + val context : context + + val state : state + end + + val produce : + (module PVM_with_context_and_state) -> + Sc_rollup_inbox_repr.t -> + Raw_level_repr.t -> + (t, string) result Lwt.t end module Game : sig @@ -2697,7 +2814,7 @@ module Sc_rollup : sig val pp_refutation : Format.formatter -> refutation -> unit - type reason = Conflict_resolved | Invalid_move | Timeout + type reason = Conflict_resolved | Invalid_move of string | Timeout val pp_reason : Format.formatter -> reason -> unit @@ -2714,6 +2831,25 @@ module Sc_rollup : sig val pp_outcome : Format.formatter -> outcome -> unit val outcome_encoding : outcome Data_encoding.t + + val initial : + Inbox.t -> + pvm_name:string -> + parent:Commitment.t -> + child:Commitment.t -> + refuter:Staker.t -> + defender:Staker.t -> + t + + val check_dissection : + State_hash.t option -> + Tick.t -> + State_hash.t option -> + Tick.t -> + (State_hash.t option * Tick.t) list -> + (unit, string) result Lwt.t + + val play : t -> refutation -> (outcome, t) Either.t Lwt.t end module Stake_storage : sig diff --git a/src/proto_alpha/lib_protocol/sc_rollup_PVM_sem.ml b/src/proto_alpha/lib_protocol/sc_rollup_PVM_sem.ml index 69a87365854a..8f7edfa0a492 100644 --- a/src/proto_alpha/lib_protocol/sc_rollup_PVM_sem.ml +++ b/src/proto_alpha/lib_protocol/sc_rollup_PVM_sem.ml @@ -112,6 +112,19 @@ let input_request_encoding = (fun (level, counter) -> First_after (level, counter)); ] +let pp_input_request fmt request = + match request with + | No_input_required -> Format.fprintf fmt "No_input_required" + | Initial -> Format.fprintf fmt "Initial" + | First_after (l, n) -> + Format.fprintf + fmt + "First_after (level = %a, counter = %a)" + Raw_level_repr.pp + l + Z.pp_print + n + let input_request_equal a b = match (a, b) with | No_input_required, No_input_required -> true @@ -247,4 +260,13 @@ module type S = sig (** This checks the proof. See the doc-string for the [proof] type. *) val verify_proof : proof -> bool Lwt.t + + (** [produce_proof ctxt input_given state] should return a [proof] for + the PVM step starting from [state], if possible. This may return + [None] for a few reasons: + - the [input_given] doesn't match the expectations of [state] ; + - the [context] for this instance of the PVM doesn't have access + to enough of the [state] to build the proof. *) + val produce_proof : + context -> input option -> state -> (proof, string) result Lwt.t end diff --git a/src/proto_alpha/lib_protocol/sc_rollup_arith.ml b/src/proto_alpha/lib_protocol/sc_rollup_arith.ml index f40c2fd63728..6b439bf1ba1e 100644 --- a/src/proto_alpha/lib_protocol/sc_rollup_arith.ml +++ b/src/proto_alpha/lib_protocol/sc_rollup_arith.ml @@ -35,12 +35,15 @@ module type P = sig val proof_encoding : proof Data_encoding.t - val proof_start_state : proof -> State_hash.t + val proof_before : proof -> State_hash.t - val proof_stop_state : proof -> State_hash.t + val proof_after : proof -> State_hash.t val verify_proof : proof -> (tree -> (tree * 'a) Lwt.t) -> (tree * 'a) option Lwt.t + + val produce_proof : + Tree.t -> tree -> (tree -> (tree * 'a) Lwt.t) -> (proof * 'a) option Lwt.t end module type S = sig @@ -106,13 +109,13 @@ module Make (Context : P) : (req "given" (option PS.input_encoding)) (req "requested" PS.input_request_encoding)) - let proof_start_state p = Context.proof_start_state p.tree_proof + let proof_start_state p = Context.proof_before p.tree_proof let proof_stop_state p = match (p.given, p.requested) with - | None, PS.No_input_required -> Some (Context.proof_stop_state p.tree_proof) + | None, PS.No_input_required -> Some (Context.proof_after p.tree_proof) | None, _ -> None - | _ -> Some (Context.proof_stop_state p.tree_proof) + | _ -> Some (Context.proof_after p.tree_proof) let proof_input_given p = p.given @@ -955,25 +958,38 @@ module Make (Context : P) : let eval state = state_of (ticked eval_step) state + let step_transition input_given state = + let open Lwt_syntax in + let* request = is_input_state state in + let* state = + match request with + | PS.No_input_required -> eval state + | _ -> ( + match input_given with + | Some input -> set_input input state + | None -> return state) + in + return (state, request) + let verify_proof proof = let open Lwt_syntax in - let transition state = - let* request = is_input_state state in - let* state = - match request with - | PS.No_input_required -> eval state - | _ -> ( - match proof.given with - | Some input -> set_input input state - | None -> return state) - in - return (state, request) + let* result = + Context.verify_proof proof.tree_proof (step_transition proof.given) in - let* result = Context.verify_proof proof.tree_proof transition in match result with | None -> return false | Some (_, request) -> return (PS.input_request_equal request proof.requested) + + let produce_proof context input_given state = + let open Lwt_syntax in + let* result = + Context.produce_proof context state (step_transition input_given) + in + match result with + | Some (tree_proof, requested) -> + return (Result.ok {tree_proof; given = input_given; requested}) + | None -> return (Result.error "Context.produce_proof returned None") end module ProtocolImplementation = Make (struct @@ -996,15 +1012,17 @@ module ProtocolImplementation = Make (struct let verify_proof p f = Lwt.map Result.to_option (Context.verify_tree_proof p f) + let produce_proof _context _state _f = + (* Can't produce proof without full context*) + Lwt.return None + let kinded_hash_to_state_hash = function | `Value hash | `Node hash -> State_hash.hash_bytes [Context_hash.to_bytes hash] - let proof_start_state proof = - kinded_hash_to_state_hash proof.Context.Proof.before + let proof_before proof = kinded_hash_to_state_hash proof.Context.Proof.before - let proof_stop_state proof = - kinded_hash_to_state_hash proof.Context.Proof.after + let proof_after proof = kinded_hash_to_state_hash proof.Context.Proof.after let proof_encoding = Context.Proof_encoding.V2.Tree32.tree_proof_encoding end) diff --git a/src/proto_alpha/lib_protocol/sc_rollup_arith.mli b/src/proto_alpha/lib_protocol/sc_rollup_arith.mli index 8c305aea0d9b..93d9afcdee82 100644 --- a/src/proto_alpha/lib_protocol/sc_rollup_arith.mli +++ b/src/proto_alpha/lib_protocol/sc_rollup_arith.mli @@ -47,7 +47,7 @@ The machine has a boot sector which is a mere string used a prefix for each message. - The module implements the {!Sc_rollup_PVM_sem.S} interface to be + The module implements the {!Sc_rollup_PVM_sem.S}Î interface to be used in the smart contract rollup infrastructure. The machine exposes extra operations to be used in the rollup node. @@ -132,14 +132,15 @@ module type P = sig val proof_encoding : proof Data_encoding.t - val proof_start_state : proof -> Sc_rollup_repr.State_hash.t + val proof_before : proof -> Sc_rollup_repr.State_hash.t - val proof_stop_state : proof -> Sc_rollup_repr.State_hash.t + val proof_after : proof -> Sc_rollup_repr.State_hash.t - (** A verson of [Context.verify_proof] without the annoying error - types, just to make life easier. *) val verify_proof : proof -> (tree -> (tree * 'a) Lwt.t) -> (tree * 'a) option Lwt.t + + val produce_proof : + Tree.t -> tree -> (tree -> (tree * 'a) Lwt.t) -> (proof * 'a) option Lwt.t end module Make (Context : P) : diff --git a/src/proto_alpha/lib_protocol/sc_rollup_game_repr.ml b/src/proto_alpha/lib_protocol/sc_rollup_game_repr.ml index d101a09e8ee9..4c27d8180e90 100644 --- a/src/proto_alpha/lib_protocol/sc_rollup_game_repr.ml +++ b/src/proto_alpha/lib_protocol/sc_rollup_game_repr.ml @@ -230,7 +230,7 @@ let refutation_encoding = (req "choice" Sc_rollup_tick_repr.encoding) (req "step" step_encoding)) -type reason = Conflict_resolved | Invalid_move | Timeout +type reason = Conflict_resolved | Invalid_move of string | Timeout let pp_reason ppf reason = Format.fprintf @@ -238,7 +238,7 @@ let pp_reason ppf reason = "%s" (match reason with | Conflict_resolved -> "conflict resolved" - | Invalid_move -> "invalid move" + | Invalid_move reason -> Format.sprintf "invalid move(%s)" reason | Timeout -> "timeout") let reason_encoding = @@ -255,9 +255,9 @@ let reason_encoding = case ~title:"Invalid_move" (Tag 1) - unit - (function Invalid_move -> Some () | _ -> None) - (fun () -> Invalid_move); + string + (function Invalid_move reason -> Some reason | _ -> None) + (fun s -> Invalid_move s); case ~title:"Timeout" (Tag 2) @@ -325,45 +325,82 @@ let find_choice game tick = if Sc_rollup_tick_repr.(tick = state_tick) then return (state, tick, next_state, next_tick) else traverse ((next_state, next_tick) :: others) - | _ -> fail () + | _ -> fail "This choice was not proposed" in traverse game.dissection -let check pred = +let check pred reason = let open Lwt_result_syntax in - if pred then return () else fail () + if pred then return () else fail reason let check_dissection start start_tick stop stop_tick dissection = let open Lwt_result_syntax in let len = Z.of_int @@ List.length dissection in let dist = Sc_rollup_tick_repr.distance start_tick stop_tick in + let should_be_equal_to what = + Format.asprintf "The number of sections must be equal to %a" Z.pp_print what + in let* _ = - if Z.(geq dist (of_int 32)) then check Z.(equal len (of_int 32)) - else if Z.(gt dist one) then check Z.(equal len (succ dist)) - else fail () + if Z.(geq dist (of_int 32)) then + check Z.(equal len (of_int 32)) (should_be_equal_to (Z.of_int 32)) + else if Z.(gt dist one) then + check Z.(equal len (succ dist)) (should_be_equal_to Z.(succ dist)) + else fail (Format.asprintf "Cannot have a dissection of only one section") in let* _ = match (List.hd dissection, List.last_opt dissection) with | Some (a, a_tick), Some (b, b_tick) -> - check - (Option.equal State_hash.equal a start - && (not (Option.equal State_hash.equal b stop)) - && Sc_rollup_tick_repr.(a_tick = start_tick && b_tick = stop_tick)) - | _ -> fail () + let* () = + check + (Option.equal State_hash.equal a start) + (match start with + | None -> assert false + | Some start -> + Format.asprintf + "The start hash should be equal to %a" + State_hash.pp + start) + in + let* () = + check + (not (Option.equal State_hash.equal b stop)) + (match stop with + | None -> "The stop hash should be None." + | Some stop -> + Format.asprintf + "The stop hash should be equal to %a" + State_hash.pp + stop) + in + Sc_rollup_tick_repr.( + check + (a_tick = start_tick && b_tick = stop_tick) + (Format.asprintf + "We should have section_start_tick(%a) = %a and \ + section_stop_tick(%a) = %a" + pp + a_tick + pp + start_tick + pp + b_tick + pp + stop_tick)) + | _ -> fail "Dissection should contain at least 2 elements" in let rec traverse states = match states with | (Some _, tick) :: (next_state, next_tick) :: others -> if Sc_rollup_tick_repr.(tick < next_tick) then traverse ((next_state, next_tick) :: others) - else fail () - | (None, _) :: _ :: _ -> fail () + else fail "Ticks should only increase in dissection" + | (None, _) :: _ :: _ -> fail "None should not occur before end" | _ -> return () in traverse dissection (** We check firstly that the interval in question is a single tick. - + Then we check the proof begins with the correct state and ends with a different state to the one in the current dissection. @@ -374,16 +411,34 @@ let check_dissection start start_tick stop stop_tick dissection = let check_proof_start_stop start start_tick stop stop_tick proof = let open Lwt_result_syntax in let dist = Sc_rollup_tick_repr.distance start_tick stop_tick in - let* _ = check Z.(equal dist one) in + let* _ = check Z.(equal dist one) "dist should be equal to 1" in + let start_proof = Sc_rollup_proof_repr.start proof in + let stop_proof = Sc_rollup_proof_repr.stop proof in let* _ = check - @@ Option.equal - State_hash.equal - start - (Some (Sc_rollup_proof_repr.start proof)) + (Option.equal State_hash.equal start (Some start_proof)) + (match start with + | None -> "Start is absent and should not." + | Some start -> + Format.asprintf + "start(%a) should be equal to start_proof(%a)" + State_hash.pp + start + State_hash.pp + start_proof) + in + let option_pp pp fmt = function + | None -> Format.fprintf fmt "None" + | Some x -> pp fmt x in check - @@ not (Option.equal State_hash.equal stop (Sc_rollup_proof_repr.stop proof)) + (not (Option.equal State_hash.equal stop stop_proof)) + (Format.asprintf + "stop(%a) should not be equal to stop_proof(%a)" + (option_pp State_hash.pp) + stop + (option_pp State_hash.pp) + stop_proof) let play game refutation = let result = @@ -403,19 +458,24 @@ let play game refutation = pvm_name = game.pvm_name; dissection = states; }) - | Proof proof -> + | Proof proof -> ( let* _ = check_proof_start_stop start start_tick stop stop_tick proof in let {inbox_snapshot; level; pvm_name; _} = game in - let* proof_valid = + let*! proof_valid = Sc_rollup_proof_repr.valid inbox_snapshot level ~pvm_name proof in - let* _ = check proof_valid in - return - (Either.Left {loser = opponent game.turn; reason = Conflict_resolved}) + match proof_valid with + | Error s -> + fail (Format.asprintf "Invalid proof: %s" s) (* Illformed? *) + | Ok proof_valid -> + let* _ = check proof_valid "Invalid proof" in + return + (Either.Left + {loser = opponent game.turn; reason = Conflict_resolved})) in Lwt.map (fun r -> - match Option.of_result r with - | Some x -> x - | None -> Either.Left {loser = game.turn; reason = Invalid_move}) + match r with + | Ok x -> x + | Error e -> Either.Left {loser = game.turn; reason = Invalid_move e}) result diff --git a/src/proto_alpha/lib_protocol/sc_rollup_game_repr.mli b/src/proto_alpha/lib_protocol/sc_rollup_game_repr.mli index 19d1803a6b2d..2c33f0fe46cb 100644 --- a/src/proto_alpha/lib_protocol/sc_rollup_game_repr.mli +++ b/src/proto_alpha/lib_protocol/sc_rollup_game_repr.mli @@ -253,7 +253,7 @@ val refutation_encoding : refutation Data_encoding.t (** A game ends for one of three reasons: the conflict has been resolved via a proof, a player has been timed out, or a player has forfeited because of attempting to make an invalid move. *) -type reason = Conflict_resolved | Invalid_move | Timeout +type reason = Conflict_resolved | Invalid_move of string | Timeout val pp_reason : Format.formatter -> reason -> unit @@ -295,7 +295,7 @@ val find_choice : * Sc_rollup_tick_repr.t * Sc_rollup_repr.State_hash.t option * Sc_rollup_tick_repr.t, - unit ) + string ) result Lwt.t @@ -304,7 +304,7 @@ val find_choice : [stop_tick] is too small to make this possible, in which case it should be as long as possible. (If the distance is one we fail immediately as there is no possible legal dissection). - + Then we check that [dissection] starts at the correct tick and state, and that it ends at the correct tick and with a different state to the current dissection. @@ -318,7 +318,7 @@ val check_dissection : Sc_rollup_repr.State_hash.t option -> Sc_rollup_tick_repr.t -> (Sc_rollup_repr.State_hash.t option * Sc_rollup_tick_repr.t) list -> - (unit, unit) result Lwt.t + (unit, string) result Lwt.t (** Applies the move [refutation] to the game. Checks the move is valid and returns an [Invalid_move] outcome if not. diff --git a/src/proto_alpha/lib_protocol/sc_rollup_inbox_repr.ml b/src/proto_alpha/lib_protocol/sc_rollup_inbox_repr.ml index 4901b948549f..61e72bf62e81 100644 --- a/src/proto_alpha/lib_protocol/sc_rollup_inbox_repr.ml +++ b/src/proto_alpha/lib_protocol/sc_rollup_inbox_repr.ml @@ -721,6 +721,9 @@ module Proof = struct message_proof : Context.Proof.tree Context.Proof.t; } + let pp fmt proof = + Format.fprintf fmt "Inbox proof with %d skips" (List.length proof.skips) + let encoding = let open Data_encoding in conv @@ -787,7 +790,8 @@ module Proof = struct | `Node h -> Context_hash.equal h hash | `Value h -> Context_hash.equal h hash - let drop_error result = Lwt.map (Result.map_error (fun _ -> ())) result + let drop_error result reason = + Lwt.map (Result.map_error (fun _ -> reason)) result let rec valid (l, n) inbox proof = assert (Z.(geq n zero)) ; @@ -803,21 +807,30 @@ module Proof = struct then let* (_ : Context.tree), payload = drop_error - @@ Context.verify_tree_proof proof.message_proof (message_payload n) + (Context.verify_tree_proof + proof.message_proof + (message_payload n)) + "message_proof invalid" in match payload with - | None -> if equal proof.level inbox then return None else fail () + | None -> + if equal proof.level inbox then return None + else fail "payload is None, inbox proof.level not top" | Some msg -> return @@ Some Sc_rollup_PVM_sem. {inbox_level = l; message_counter = n; payload = msg} - else fail () + else fail "Inbox proof parameters don't match (message level)" | Some (level, inc, remaining_proof) -> if verify_inclusion_proof inc level (bottom_level remaining_proof) && Raw_level_repr.equal (inbox_level level) l && Z.equal level.message_counter n then valid (Raw_level_repr.succ l, Z.zero) inbox remaining_proof - else fail () + else fail "Inbox proof parameters don't match (lower level)" + + (* TODO #2997 This needs to be implemented when the inbox structure is + improved. *) + let produce_proof _ _ = assert false end diff --git a/src/proto_alpha/lib_protocol/sc_rollup_inbox_repr.mli b/src/proto_alpha/lib_protocol/sc_rollup_inbox_repr.mli index e74381d8333a..0d2ca882cb2d 100644 --- a/src/proto_alpha/lib_protocol/sc_rollup_inbox_repr.mli +++ b/src/proto_alpha/lib_protocol/sc_rollup_inbox_repr.mli @@ -345,6 +345,8 @@ module Proof : sig message_proof : Context.Proof.tree Context.Proof.t; } + val pp : Format.formatter -> t -> unit + val encoding : t Data_encoding.t (** See the docstring for [Proof.t] for details of proof semantics. @@ -355,5 +357,16 @@ module Proof : sig Raw_level_repr.t * Z.t -> inbox -> t -> - (Sc_rollup_PVM_sem.input option, unit) result Lwt.t + (Sc_rollup_PVM_sem.input option, string) result Lwt.t + + (** TODO #2997 Currently a placeholder, needs implementation. + + [produce_proof inbox (level, counter)] creates an inbox proof + proving the first message after the index [counter] at location + [level]. This will fail if the inbox given doesn't have sufficient + data (it needs to be run on an inbox with the full history). *) + val produce_proof : + inbox -> + Raw_level_repr.t * Z.t -> + (t * Sc_rollup_PVM_sem.input option, string) result Lwt.t end diff --git a/src/proto_alpha/lib_protocol/sc_rollup_proof_repr.ml b/src/proto_alpha/lib_protocol/sc_rollup_proof_repr.ml index 1a049b28fd28..1af051287343 100644 --- a/src/proto_alpha/lib_protocol/sc_rollup_proof_repr.ml +++ b/src/proto_alpha/lib_protocol/sc_rollup_proof_repr.ml @@ -59,14 +59,14 @@ let cut_at_level level input = let input_level = Sc_rollup_PVM_sem.(input.inbox_level) in if Raw_level_repr.(level <= input_level) then None else Some input -let check p = +let check p reason = let open Lwt_result_syntax in - if p then return () else fail () + if p then return () else fail reason let valid snapshot commit_level ~pvm_name proof = let (module P) = Sc_rollups.wrapped_proof_module proof.pvm_step in let open Lwt_result_syntax in - let* _ = check (String.equal P.name pvm_name) in + let* _ = check (String.equal P.name pvm_name) "Incorrect PVM kind" in let input_requested = P.proof_input_requested P.proof in let input_given = P.proof_input_given P.proof in let* input = @@ -82,7 +82,14 @@ let valid snapshot commit_level ~pvm_name proof = (level, Z.succ counter) snapshot inbox_proof - | _ -> fail () + | _ -> + fail + (Format.asprintf + "input_requested is %a, inbox proof is %a" + Sc_rollup_PVM_sem.pp_input_request + input_requested + (Format.pp_print_option Sc_rollup_inbox_repr.Proof.pp) + proof.inbox) in let* _ = check @@ -90,5 +97,43 @@ let valid snapshot commit_level ~pvm_name proof = Sc_rollup_PVM_sem.input_equal (Option.bind input (cut_at_level commit_level)) input_given) + "Input given is not what inbox proof expects" in Lwt.map Result.ok (P.verify_proof P.proof) + +module type PVM_with_context_and_state = sig + include Sc_rollups.PVM.S + + val context : context + + val state : state +end + +let produce pvm_and_state inbox commit_level = + let open Lwt_result_syntax in + let (module P : PVM_with_context_and_state) = pvm_and_state in + let* request = Lwt.map Result.ok (P.is_input_state P.state) in + let* inbox, input_given = + match request with + | Sc_rollup_PVM_sem.No_input_required -> return (None, None) + | Sc_rollup_PVM_sem.Initial -> + let* p, i = + Sc_rollup_inbox_repr.Proof.produce_proof + inbox + (Raw_level_repr.root, Z.zero) + in + return (Some p, i) + | Sc_rollup_PVM_sem.First_after (l, n) -> + let* p, i = Sc_rollup_inbox_repr.Proof.produce_proof inbox (l, n) in + return (Some p, i) + in + let input_given = Option.bind input_given (cut_at_level commit_level) in + let* pvm_step_proof = P.produce_proof P.context input_given P.state in + let module P_with_proof = struct + include P + + let proof = pvm_step_proof + end in + match Sc_rollups.wrap_proof (module P_with_proof) with + | Some pvm_step -> return {pvm_step; inbox} + | None -> fail "Could not wrap proof" diff --git a/src/proto_alpha/lib_protocol/sc_rollup_proof_repr.mli b/src/proto_alpha/lib_protocol/sc_rollup_proof_repr.mli index a32c6ef34150..4cf611d4ec0e 100644 --- a/src/proto_alpha/lib_protocol/sc_rollup_proof_repr.mli +++ b/src/proto_alpha/lib_protocol/sc_rollup_proof_repr.mli @@ -94,4 +94,32 @@ val valid : Raw_level_repr.t -> pvm_name:string -> t -> - (bool, unit) result Lwt.t + (bool, string) result Lwt.t + +module type PVM_with_context_and_state = sig + include Sc_rollups.PVM.S + + val context : context + + val state : state +end + +(** [produce pvm_and_state inbox commit_level] will construct a full + refutation game proof out of the [state] given in [pvm_and_state]. + It uses the [inbox] if necessary to provide input in the proof. If + the input is above or at [commit_level] it will block it, and + produce a proof that the PVM is blocked. + + This will fail if the [context] given doesn't have enough of the + [state] to make the proof. For example, the 'protocol + implementation' version of each PVM won't be able to run this + function. + + This uses the [name] in the [pvm_and_state] module to produce an + encodable [wrapped_proof] if possible. See the [wrap_proof] function + in [Sc_rollups]. *) +val produce : + (module PVM_with_context_and_state) -> + Sc_rollup_inbox_repr.t -> + Raw_level_repr.t -> + (t, string) result Lwt.t diff --git a/src/proto_alpha/lib_protocol/sc_rollup_refutation_storage.ml b/src/proto_alpha/lib_protocol/sc_rollup_refutation_storage.ml index 09cb05f7ea4b..18a002c842fb 100644 --- a/src/proto_alpha/lib_protocol/sc_rollup_refutation_storage.ml +++ b/src/proto_alpha/lib_protocol/sc_rollup_refutation_storage.ml @@ -194,7 +194,7 @@ let get_or_init_game ctxt rollup ~refuter ~defender = let game = Sc_rollup_game_repr.initial inbox - ~pvm_name:(Sc_rollups.Kind.string_of_kind kind) + ~pvm_name:(Sc_rollups.Kind.name_of kind) ~parent ~child ~refuter diff --git a/src/proto_alpha/lib_protocol/sc_rollups.ml b/src/proto_alpha/lib_protocol/sc_rollups.ml index 16751635bd32..124ce772d627 100644 --- a/src/proto_alpha/lib_protocol/sc_rollups.ml +++ b/src/proto_alpha/lib_protocol/sc_rollups.ml @@ -45,7 +45,7 @@ module Kind = struct Each time we add a data constructor to [t], we also need: - to extend [Sc_rollups.all] with this new constructor ; - to update [Sc_rollups.of_name] and [encoding] ; - - to update [Sc_rollups.pvm_proof] and [pvm_proof_encoding]. + - to update [Sc_rollups.wrapped_proof] and [wrapped_proof_encoding]. *) type t = Example_arith @@ -90,11 +90,11 @@ module Kind = struct M.name) all - let string_of_kind k = + let name_of k = let (module M) = pvm_of k in M.name - let pp fmt k = Format.fprintf fmt "%s" (string_of_kind k) + let pp fmt k = Format.fprintf fmt "%s" (name_of k) end module type PVM_with_proof = sig @@ -144,3 +144,23 @@ let wrapped_proof_encoding = end in Arith_pvm_with_proof (module P)); ] + +let wrap_proof pvm_with_proof = + let (module P : PVM_with_proof) = pvm_with_proof in + match Kind.of_name P.name with + | None -> Some (Unencodable pvm_with_proof) + | Some Kind.Example_arith -> + Option.map + (fun arith_proof -> + let module P_arith = struct + include Sc_rollup_arith.ProtocolImplementation + + let proof = arith_proof + end in + Arith_pvm_with_proof (module P_arith)) + (Option.bind + (Data_encoding.Binary.to_bytes_opt P.proof_encoding P.proof) + (fun bytes -> + Data_encoding.Binary.of_bytes_opt + Sc_rollup_arith.ProtocolImplementation.proof_encoding + bytes)) diff --git a/src/proto_alpha/lib_protocol/sc_rollups.mli b/src/proto_alpha/lib_protocol/sc_rollups.mli index 16c719e62fac..b8221904b081 100644 --- a/src/proto_alpha/lib_protocol/sc_rollups.mli +++ b/src/proto_alpha/lib_protocol/sc_rollups.mli @@ -74,11 +74,11 @@ module Kind : sig (** [all_names] returns all implemented PVM names. *) val all_names : string list - (** [kind_of_string name] returns the kind of the PVM of the specified [name]. *) + (** [of_name name] returns the kind of the PVM of the specified [name]. *) val of_name : string -> t option - (** [string_of_kind kind] returns a human-readable representation of [kind]. *) - val string_of_kind : t -> string + (** [name_of kind] returns a human-readable representation of [kind]. *) + val name_of : t -> string end (** A module signature we can use to form first-class modules that carry @@ -103,3 +103,12 @@ type wrapped_proof = val wrapped_proof_module : wrapped_proof -> (module PVM_with_proof) val wrapped_proof_encoding : wrapped_proof Data_encoding.t + +(** Wrap a PVM module with proof into a [wrapped_proof]. This matches on + the [name] in the module---if that is recognisable as a [Kind], this + function will encode and decode to coerce the proof to a proof in + the protocol implementation of the PVM. If the [name] is not + recognised this will fall back to using [Unencodable], so the value + can still be used in tests but won't work as part of a + [Sc_rollup_refute] operation. *) +val wrap_proof : (module PVM_with_proof) -> wrapped_proof option diff --git a/src/proto_alpha/lib_protocol/test/integration/operations/test_sc_rollup.ml b/src/proto_alpha/lib_protocol/test/integration/operations/test_sc_rollup.ml index b4d26265abe9..d42e3c1e2d56 100644 --- a/src/proto_alpha/lib_protocol/test/integration/operations/test_sc_rollup.ml +++ b/src/proto_alpha/lib_protocol/test/integration/operations/test_sc_rollup.ml @@ -100,9 +100,9 @@ let test_disable_feature_flag () = return_unit (** [test_sc_rollups_all_well_defined] checks that [Sc_rollup.Kind.all] - contains all the constructors of [Sc_rollup.Kind.t] and that - the [kind_of_string] is consistent with the names declared in - the PVM implementations. *) + contains all the constructors of [Sc_rollup.Kind.t] and that the + [of_name] is consistent with the names declared in the PVM + implementations. *) let test_sc_rollups_all_well_defined () = let all_contains_all_constructors () = let tickets = ref ["Example_arith"] in diff --git a/src/proto_alpha/lib_protocol/test/pbt/test_refutation_game.ml b/src/proto_alpha/lib_protocol/test/pbt/test_refutation_game.ml index 24f5df849e9e..0fa7a2e970c6 100644 --- a/src/proto_alpha/lib_protocol/test/pbt/test_refutation_game.ml +++ b/src/proto_alpha/lib_protocol/test/pbt/test_refutation_game.ml @@ -28,7 +28,7 @@ ------- Component: PBT for the SCORU refutation game Invocation: dune exec \ - src/proto_alpha/lib_protocol/test/pbt/test_refutation_game.exe + src/proto_alpha/lib_protocol/test/pbt/test_refutation_game.exe Subject: SCORU refutation game *) open Protocol @@ -36,9 +36,8 @@ open Protocol open Alpha_context open Sc_rollup open Lwt_syntax -open Tezos_context_memory -exception TickNotFound of Sc_rollup_tick_repr.t +exception TickNotFound of Tick.t open Lib_test.Qcheck_helpers module Sc_rollup_repr = Protocol.Sc_rollup_repr @@ -48,14 +47,16 @@ module Sc_rollup_repr = Protocol.Sc_rollup_repr Helpers *) -let assume_some opt f = match opt with Some x -> f x | None -> assert false + +let zero_level = + Raw_level.of_int32 0l |> function Ok x -> x | _ -> assert false let hash_state state number = Digest.bytes @@ Bytes.of_string @@ state ^ string_of_int number type dummy_proof = { - start : Sc_rollup_repr.State_hash.t; - stop : Sc_rollup_repr.State_hash.t option; + start : State_hash.t; + stop : State_hash.t option; valid : bool; } @@ -65,8 +66,8 @@ let dummy_proof_encoding : dummy_proof Data_encoding.t = (fun {start; stop; valid} -> (start, stop, valid)) (fun (start, stop, valid) -> {start; stop; valid}) (obj3 - (req "start" Sc_rollup_repr.State_hash.encoding) - (req "stop" (option Sc_rollup_repr.State_hash.encoding)) + (req "start" State_hash.encoding) + (req "stop" (option State_hash.encoding)) (req "valid" bool)) let proof_start_state proof = proof.start @@ -78,85 +79,80 @@ let check pred = if pred then return () else error () let number_of_messages_exn n = - match Sc_rollup_repr.Number_of_messages.of_int32 n with + match Number_of_messages.of_int32 n with | Some x -> x | None -> Stdlib.failwith "Bad Number_of_messages" let number_of_ticks_exn n = - match Sc_rollup_repr.Number_of_ticks.of_int32 n with + match Number_of_ticks.of_int32 n with | Some x -> x | None -> Stdlib.failwith "Bad Number_of_ticks" let get_comm pred inbox_level messages ticks state = - Sc_rollup_commitment_repr. + Commitment. { predecessor = pred; - inbox_level = Raw_level_repr.of_int32_exn inbox_level; + inbox_level = Raw_level.of_int32_exn inbox_level; number_of_messages = number_of_messages_exn messages; number_of_ticks = number_of_ticks_exn ticks; compressed_state = state; } -(** This picks a random section between start_at and stop_at. The states - are determined by the random_state function.*) -let random_hash () = Sc_rollup_repr.State_hash.of_bytes_exn @@ Bytes.create 32 +let random_hash () = State_hash.of_bytes_exn @@ Bytes.create 32 + +let tick_of_int_exn n = + match Tick.of_int n with None -> assert false | Some t -> t -let of_int_exc n = - match Sc_rollup_tick_repr.of_int n with None -> assert false | Some t -> t +let tick_to_int_exn t = + match Tick.to_int t with None -> assert false | Some n -> n -(** This picks a random dissection of a given section. - The sections involved are random and their states have no connection - with the initial section.*) -let random_dissection start_at start_hash stop_at _stop_hash : - (Sc_rollup_repr.State_hash.t option * Sc_rollup_tick_repr.t) list option - Lwt.t = +let random_dissection start_at start_hash stop_at stop_hash : + (State_hash.t option * Tick.t) list option Lwt.t = match start_hash with | Some _ -> - let start_int = - match Sc_rollup_tick_repr.to_int start_at with - | None -> assert false - | Some x -> x - in - let stop_int = - match Sc_rollup_tick_repr.to_int stop_at with - | None -> assert false - | Some x -> x - in + let start_int = tick_to_int_exn start_at in + let stop_int = tick_to_int_exn stop_at in let dist = stop_int - start_int in - let branch = min (dist + 1) 32 in let size = (dist + 1) / branch in - Lwt.return - @@ Result.to_option - (List.init branch ~when_negative_length:"error" (fun i -> - if i = 0 then (start_hash, start_at) - else if i = branch - 1 then (_stop_hash, stop_at) - else (Some (random_hash ()), of_int_exc (start_int + (i * size))))) - | None -> assert false - -(** + + if dist = 1 then return None + else + return + @@ Result.to_option + (List.init branch ~when_negative_length:"error" (fun i -> + if i = 0 then (start_hash, start_at) + else if i = branch - 1 then (stop_hash, stop_at) + else + ( Some (random_hash ()), + tick_of_int_exn (start_int + (i * size)) ))) + | None -> + (* Because at start state is always present. *) + assert false + +(** `genlist` is a `correct list` generator. It generates a list of strings that - are either integers or `+` to be consumed by the arithmetic PVM. + are either integers or `+` to be consumed by the arithmetic PVM. If a `+` is found then the previous two element of the stack are poped - then added and the result is pushed to the stack. + then added and the result is pushed to the stack. In particular, lists like `[1 +]` are incorrect. - - To preserve the correctness invariant, genlist is a recursive generator that - produce a pair `(stack_size, state_list)` where state_list is a correct list - of integers and `+` and consuming it will produce a `stack` of length + + To preserve the correctness invariant, genlist is a recursive generator that + produce a pair `(stack_size, state_list)` where state_list is a correct list + of integers and `+` and consuming it will produce a `stack` of length `stack_size`. - For example a result can be `(3, [1; 2; +; 3; +; 2; 2; +; 1;]). + For example a result can be `(3, [1; 2; +; 3; +; 2; 2; +; 1;]). Consuming the list will produce the stack`[6; 4; 2]` which has length 3. - The generator has two branches. - 1. with frequency 1 adds integers to state_list and increases the + The generator has two branches. + 1. with frequency 1 adds integers to state_list and increases the corresponding stack_size. 2. With frequency 2, at each step, it looks at the inductive result - `(self (n - 1))=(stack_size, state_list)`. + `(self (n - 1))=(stack_size, state_list)`. If the stack_size is smaller than 2 then it adds an integer to the state_list and increases the stack_size Otherwise it adds a plus to the state_list and decreases the stack_size. - Remark: The algorithm is linear in the size of the generated list and - generates all kinds of inputs not only those that produce a stack of size 1. + Remark: The algorithm is linear in the size of the generated list and + generates all kinds of inputs not only those that produce a stack of size 1. *) let gen_list = QCheck2.Gen.( @@ -183,30 +179,33 @@ let gen_list = (self (n - 1)) ); ])) -(** This uses the above generator to produce a correct program with at - least 3 elements. -*) +(** This uses the above generator to produce a correct program with at + least 3 elements. *) let rec correct_string () = let x = QCheck2.Gen.(generate1 gen_list) in if List.length x < 3 then correct_string () else x module type TestPVM = sig - include Sc_rollup_PVM_sem.S with type hash = Sc_rollup_repr.State_hash.t + include PVM.S with type hash = State_hash.t module Utils : sig (** This a post-boot state. It is used as default in many functions. *) val default_state : state - (** [random_state n state] generates a random state. The integer n is - used in the generation *) + (** [random_state n state] generates a random state. The integer n is + used as a seed in the generation. *) val random_state : int -> state -> state (** [make_proof start_state stop_state] produces a proof that the eval of - start_state is the stop_state. - It will be used by the `verify_proof`. In the arithPVM we use - `produce_tree_proof` which only requires a starting state (tree) - and the transition function.*) - val make_proof : hash option -> hash option -> bool -> proof Lwt.t + [start_state] is the [stop_state]. + It will be used by the `verify_proof`. In the arithPVM we use + `produce_tree_proof` which only requires a starting state (tree) + and the transition function. *) + val make_proof : state -> hash option -> proof Lwt.t + + (** Like [make_proof] but produces an invalid proof starting from + any hash. *) + val make_invalid_proof : hash -> hash option -> proof Lwt.t end end @@ -221,9 +220,15 @@ end module MakeCountingPVM (P : sig val target : int end) : TestPVM with type state = int = struct + let name = "countingPVM" + + let parse_boot_sector x = Some x + + let pp_boot_sector fmt x = Format.fprintf fmt "%s" x + type state = int - type hash = Sc_rollup_repr.State_hash.t + type hash = State_hash.t type context = unit @@ -235,37 +240,36 @@ end) : TestPVM with type state = int = struct let proof_input_given _ = None - let proof_input_requested _ = Sc_rollup_PVM_sem.No_input_required + let proof_input_requested _ = No_input_required - let state_hash (x : state) = - Lwt.return (Sc_rollup_repr.State_hash.hash_string [Int.to_string x]) + let state_hash (x : state) = return (State_hash.hash_string [Int.to_string x]) - let is_input_state _ = Lwt.return Sc_rollup_PVM_sem.No_input_required + let is_input_state _ = return No_input_required - let initial_state _ _ = Lwt.return P.target + let initial_state _ _ = return P.target - let set_input _ s = Lwt.return s + let set_input _ s = return s module Utils = struct let default_state = P.target let random_state _ _ = Random.bits () - let make_proof s1 s2 v = - match (s1, s2) with - | None, _ -> assert false - | Some start_hash, Some stop_hash -> - Lwt.return @@ {start = start_hash; stop = Some stop_hash; valid = v} - | Some start_hash, None -> - Lwt.return @@ {start = start_hash; stop = None; valid = v} + let make_proof s1 s2 = + let* s1 = state_hash s1 in + return {start = s1; stop = s2; valid = true} + + let make_invalid_proof s1 s2 = return {start = s1; stop = s2; valid = false} end let proof_encoding = dummy_proof_encoding - let eval state = - if state >= P.target then Lwt.return state else Lwt.return (state + 1) + let eval state = if state >= P.target then return state else return (state + 1) + + let verify_proof proof = return proof.valid - let verify_proof proof = Lwt.return proof.valid + let produce_proof _ _ _ = + return (Result.error "Dummy PVM can't produce proof") end (** This is a random PVM. Its state is a pair of a string and a @@ -274,13 +278,19 @@ end module MakeRandomPVM (P : sig val initial_prog : int list end) : TestPVM with type state = string * int list = struct + let name = "randomPVM" + + let parse_boot_sector x = Some x + + let pp_boot_sector fmt x = Format.fprintf fmt "%s" x + type state = string * int list type context = unit type proof = dummy_proof - type hash = Sc_rollup_repr.State_hash.t + type hash = State_hash.t let to_string (a, b) = Format.sprintf "(%s, [%s])" a (String.concat ";" @@ List.map Int.to_string b) @@ -291,16 +301,15 @@ end) : TestPVM with type state = string * int list = struct let proof_input_given _ = None - let proof_input_requested _ = Sc_rollup_PVM_sem.No_input_required + let proof_input_requested _ = No_input_required - let state_hash (x : state) = - Lwt.return @@ Sc_rollup_repr.State_hash.hash_string [to_string x] + let state_hash (x : state) = return @@ State_hash.hash_string [to_string x] - let initial_state _ _ = Lwt.return ("hello", P.initial_prog) + let initial_state _ _ = return ("hello", P.initial_prog) - let is_input_state _ = Lwt.return Sc_rollup_PVM_sem.No_input_required + let is_input_state _ = return No_input_required - let set_input _ state = Lwt.return state + let set_input _ state = return state module Utils = struct let default_state = ("hello", P.initial_prog) @@ -312,56 +321,61 @@ end) : TestPVM with type state = string * int list = struct in stop_state - let make_proof s1 s2 v = - match (s1, s2) with - | None, _ -> assert false - | Some start_hash, Some stop_hash -> - Lwt.return @@ {start = start_hash; stop = Some stop_hash; valid = v} - | Some start_hash, None -> - Lwt.return @@ {start = start_hash; stop = None; valid = v} + let make_proof s1 s2 = + let* s1 = state_hash s1 in + return {start = s1; stop = s2; valid = true} + + let make_invalid_proof s1 s2 = return {start = s1; stop = s2; valid = false} end let proof_encoding = dummy_proof_encoding let eval (hash, continuation) = match continuation with - | [] -> Lwt.return (hash, continuation) - | h :: tl -> Lwt.return (hash_state hash h, tl) + | [] -> return (hash, continuation) + | h :: tl -> return (hash_state hash h, tl) + + let verify_proof proof = return proof.valid - let verify_proof proof = Lwt.return proof.valid + let produce_proof _ _ _ = + return (Result.error "Dummy PVM can't produce proof") end -module ContextPVM = Sc_rollup_arith.Make (struct +module ContextPVM = ArithPVM.Make (struct + open Tezos_context_memory.Context + module Tree = struct - include Context.Tree + include Tezos_context_memory.Context.Tree - type tree = Context.tree + type tree = Tezos_context_memory.Context.tree - type t = Context.t + type t = Tezos_context_memory.Context.t type key = string list type value = bytes end - type tree = Context.tree - - let empty_tree = Tree.empty Context.empty + type tree = Tree.tree - type proof = Context.Proof.tree Context.Proof.t + type proof = Proof.tree Proof.t let verify_proof proof f = - Lwt.map Result.to_option (Context.verify_tree_proof proof f) + Lwt.map Result.to_option (verify_tree_proof proof f) + + let produce_proof context state f = + let* proof = + produce_tree_proof (index context) (`Value (Tree.hash state)) f + in + return (Some proof) let kinded_hash_to_state_hash = function | `Value hash | `Node hash -> - Sc_rollup_repr.State_hash.hash_bytes [Context_hash.to_bytes hash] + State_hash.hash_bytes [Context_hash.to_bytes hash] - let proof_start_state proof = - kinded_hash_to_state_hash proof.Context.Proof.before + let proof_before proof = kinded_hash_to_state_hash proof.Proof.before - let proof_stop_state proof = - kinded_hash_to_state_hash proof.Context.Proof.after + let proof_after proof = kinded_hash_to_state_hash proof.Proof.after let proof_encoding = let open Data_encoding in @@ -382,12 +396,11 @@ end) : TestPVM = struct let promise = let* boot = initial_state init_context "" >>= eval in let input = - Sc_rollup_PVM_sem. - { - inbox_level = Raw_level_repr.root; - message_counter = Z.zero; - payload = P.inputs; - } + { + inbox_level = Raw_level.root; + message_counter = Z.zero; + payload = P.inputs; + } in let prelim = set_input input boot in List.fold_left (fun acc _ -> acc >>= fun acc -> eval acc) prelim @@ -398,91 +411,73 @@ end) : TestPVM = struct let random_state i state = let program = correct_string () in let input = - Sc_rollup_PVM_sem. - { - inbox_level = Raw_level_repr.root; - message_counter = Z.zero; - payload = String.concat " " program; - } + { + inbox_level = Raw_level.root; + message_counter = Z.zero; + payload = String.concat " " program; + } in let prelim = set_input input state in Lwt_main.run @@ List.fold_left (fun acc _ -> acc >>= fun acc -> eval acc) prelim @@ List.repeat (min i (List.length program - 2) + 1) () - let make_proof s1 s2 v = - match (s1, s2) with - | None, _ -> assert false - | Some start_hash, Some stop_hash -> - Lwt.return @@ {start = start_hash; stop = Some stop_hash; valid = v} - | Some start_hash, None -> - Lwt.return @@ {start = start_hash; stop = None; valid = v} + let make_proof s1 _s2 = + let* proof_opt = produce_proof init_context None s1 in + match proof_opt with Ok proof -> return proof | Error _ -> assert false + + let make_invalid_proof _ _ = + let* state = initial_state init_context "foooobaaar" in + let* proof_opt = produce_proof init_context None state in + match proof_opt with Ok proof -> return proof | Error _ -> assert false end end -(** This module introduces some testing strategies for a game created from a - PVM. +(** + This module introduces some testing strategies for a game created + from a PVM. *) -module Strategies - (PVM : TestPVM - with type hash = Sc_rollup_repr.State_hash.t - and type proof = dummy_proof) = -struct - module Game = Sc_rollup_game_repr - - (* Sc_rollup_game.Make (P) *) - open Game - - (** [execute_until tick stat prop] runs eval until the tick satisfies pred or - until the state machine does not change anymore. It returns the new tick and - the modified state - *) +module Strategies (PVM : TestPVM with type hash = State_hash.t) = struct + (** [execute_until tick stat prop] runs eval until the tick + satisfies pred or until the state machine does not change + anymore. It returns the new tick and the modified state *) let execute_until tick state pred = let rec loop state tick = let* isinp = PVM.is_input_state state in match isinp with - | Some _ -> Lwt.return (tick, state) - | None -> - if pred tick state then Lwt.return (tick, state) + | No_input_required -> + if pred tick state then return (tick, state) else let* s = PVM.eval state in let* hash1 = PVM.state_hash state in let* hash2 = PVM.state_hash s in - if State_hash.equal hash1 hash2 then Lwt.return (tick, state) - else loop s (Sc_rollup_tick_repr.next tick) + if State_hash.equal hash1 hash2 then return (tick, state) + else loop s (Tick.next tick) + | _ -> return (tick, state) in loop state tick - (** [state_at tick default_state default_tick] is a computation of the state. - If runs eval from default_tick to tick starting - from default_state. *) + (** [state_at tick default_state default_tick] is a computation of + the state. If runs eval from default_tick to tick starting from + default_state. *) let state_at tick default_state default_tick = execute_until default_tick default_state (fun tick' _ -> - Sc_rollup_tick_repr.(tick' = tick)) - >>= fun (t, s) -> Lwt.return (Some s, t) - - (** [dissection_of_section start_tick start_state stop_tick] creates a - dissection with at most 32 pieces that are (roughly) equal spaced and whose - states are computed by running the eval function until the correct tick. Note - that the last piece can be as much as 31 ticks longer than the others. - *) + Tick.(tick' = tick)) + >>= fun (t, s) -> return (Some s, t) + + (** [dissection_of_section start_tick start_state stop_tick] creates + a dissection with at most [32] pieces that are (roughly) equal + spaced and whose states are computed by running the eval function + until the correct tick. Note that the last piece can be as much + as 31 ticks longer than the others. *) let dissection_of_section start_tick start_state stop_tick = match start_state with | Some start_state -> - let start_int = - match Sc_rollup_tick_repr.to_int start_tick with - | None -> assert false - | Some x -> x - in - - let stop_int = - match Sc_rollup_tick_repr.to_int stop_tick with - | None -> assert false - | Some x -> x - in + let start_int = tick_to_int_exn start_tick in + let stop_int = tick_to_int_exn stop_tick in let dist = stop_int - start_int in - if dist = 1 then Lwt.return None + if dist = 1 then return None else let branch = min (dist + 1) 32 in let size = (dist + 1) / branch in @@ -490,7 +485,7 @@ struct Result.to_option @@ List.init branch ~when_negative_length:"error" (fun i -> if i = branch - 1 then stop_tick - else of_int_exc (start_int + (i * size))) + else tick_of_int_exn (start_int + (i * size))) in let a = Option.map @@ -501,21 +496,21 @@ struct Lwt_main.run @@ let* state, _ = state_at tick start_state start_tick in match state with - | None -> Lwt.return None + | None -> return None | Some s -> let* h = PVM.state_hash s in - Lwt.return (Some h) + return (Some h) in (hash, tick)) a) tick_list in - Lwt.return a + return a | None -> assert false type client = { - initial : (Sc_rollup_tick_repr.t * PVM.hash) option Lwt.t; - next_move : t -> refutation option Lwt.t; + initial : (Tick.t * PVM.hash) option Lwt.t; + next_move : Game.t -> Game.refutation option Lwt.t; } type outcome_for_tests = Defender_wins | Refuter_wins @@ -528,8 +523,8 @@ struct let loser_to_outcome_for_tests loser alice_is_refuter = match loser with - | Bob -> if alice_is_refuter then Refuter_wins else Defender_wins - | Alice -> if alice_is_refuter then Defender_wins else Refuter_wins + | Game.Bob -> if alice_is_refuter then Refuter_wins else Defender_wins + | Game.Alice -> if alice_is_refuter then Defender_wins else Refuter_wins let run ~inbox ~refuter_client ~defender_client = let refuter, _, _ = Signature.generate_key () in @@ -540,68 +535,62 @@ struct let tick, initial_hash = match initial_data with None -> assert false | Some s -> s in - let int_tick = - match Sc_rollup_tick_repr.to_int tick with - | None -> assert false - | Some x -> x - in + let int_tick = tick_to_int_exn tick in let number_of_ticks = Int32.of_int int_tick in - let parent = - get_comm Sc_rollup_commitment_repr.Hash.zero 0l 3l 1l start_hash - in + let parent = get_comm Commitment.Hash.zero 0l 3l 1l start_hash in let child = - get_comm - Sc_rollup_commitment_repr.Hash.zero - 0l - 3l - number_of_ticks - initial_hash + get_comm Commitment.Hash.zero 0l 3l number_of_ticks initial_hash in - - let initial_game = initial inbox ~parent ~child ~refuter ~defender in - let outcome = + let initial_game = + Game.initial inbox ~pvm_name:PVM.name ~parent ~child ~refuter ~defender + in + let* outcome = let rec loop game refuter_move = + let player = if refuter_move then "refuter" else "defender" in let* move = if refuter_move then refuter_client.next_move game else defender_client.next_move game in - match move with | None -> - Lwt.return (if refuter_move then Defender_wins else Refuter_wins) + Printf.eprintf "@[No move from %s@]" player ; + return (if refuter_move then Defender_wins else Refuter_wins) | Some move -> ( - play game move |> function + Format.eprintf + "@[Move from %s is %a@]@." + player + Game.pp_refutation + move ; + let* game_result = Game.play game move in + match game_result with | Either.Left outcome -> - Lwt.return + Format.eprintf "@[%a@]@." Game.pp_outcome outcome ; + return (loser_to_outcome_for_tests outcome.loser alice_is_refuter) | Either.Right game -> loop game (not refuter_move)) in loop initial_game true in - outcome + return outcome let random_tick ?(from = 0) () = - Option.value - ~default:Sc_rollup_tick_repr.initial - (Sc_rollup_tick_repr.of_int (from + Random.int 31)) + Option.value ~default:Tick.initial (Tick.of_int (from + Random.int 31)) (** checks that the stop state of a section conflicts with the one computed by the evaluation. *) let conflicting_section tick state = - let* new_state, _ = - state_at tick PVM.Utils.default_state Sc_rollup_tick_repr.initial - in + let* new_state, _ = state_at tick PVM.Utils.default_state Tick.initial in let* new_hash = match new_state with - | None -> Lwt.return None + | None -> return None | Some state -> let* state = PVM.state_hash state in - Lwt.return (Some state) + return (Some state) in - Lwt.return @@ not (Option.equal ( = ) state new_hash) + return @@ not (Option.equal ( = ) state new_hash) (** This function assembles a random decision from a given dissection. It first picks a random section from the dissection and modifies randomly @@ -629,32 +618,29 @@ struct match random_dissection with | None -> - let new_hash = random_hash () in - let* correct_state, _ = - state_at stop PVM.Utils.default_state Sc_rollup_tick_repr.initial - in - let* valid = - match correct_state with - | None -> Lwt.return_false - | Some x -> - let* correct_hash = PVM.state_hash x in - Lwt.return (correct_hash = new_hash) + let* pvm_proof = + match start_state with + | Some s -> PVM.Utils.make_invalid_proof s (Some (random_hash ())) + | None -> assert false in - let* proof = - PVM.Utils.make_proof start_state (Some (random_hash ())) valid + let wrapped = + let module P = struct + include PVM + + let proof = pvm_proof + end in + Unencodable (module P) in - Lwt.return - (Some Sc_rollup_game_repr.{choice = start; step = Proof proof}) + let proof = Proof.{pvm_step = wrapped; inbox = None} in + return (Some Game.{choice = start; step = Proof proof}) | Some dissection -> - Lwt.return - (Some - Sc_rollup_game_repr.{choice = start; step = Dissection dissection}) + return (Some Game.{choice = start; step = Dissection dissection}) (** There are two kinds of strategies, random and machine-directed. *) type strategy = Random | MachineDirected (** - [find_conflict dissection] finds the section (if it exists) in a dissection that + [find_conflict dissection] finds the section (if it exists) in a dissection that conflicts with the actual computation. *) let find_conflict dissection = let rec aux states = @@ -664,16 +650,15 @@ struct let* c = conflicting_section next_tick next_state in if c0 then assert false else if c then - if next_state = None then Lwt.return None + if next_state = None then return None else - Lwt.return - (Some ((start_state, start_tick), (next_state, next_tick))) + return (Some ((start_state, start_tick), (next_state, next_tick))) else aux ((next_state, next_tick) :: rest) - | _ -> Lwt.return None + | _ -> return None in aux dissection - (** [next_move branching dissection] finds the next move based on a + (** [next_move branching dissection] finds the next move based on a dissection. It finds the first section of dissection that conflicts with the evaluation. If the section has length one tick it returns a move with a Conclude @@ -688,85 +673,84 @@ struct match conflict with | Some ((_, start_tick), (_, next_tick)) -> let* start_state, _ = - state_at - start_tick - PVM.Utils.default_state - Sc_rollup_tick_repr.initial + state_at start_tick PVM.Utils.default_state Tick.initial in let* next_dissection = dissection_of_section start_tick start_state next_tick in let* stop_state, _ = - state_at next_tick PVM.Utils.default_state Sc_rollup_tick_repr.initial + state_at next_tick PVM.Utils.default_state Tick.initial in let* refutation = match next_dissection with | None -> - let* start_hash = - match start_state with - | None -> Lwt.return None - | Some state -> - let* s = PVM.state_hash state in - Lwt.return (Some s) - in let* stop_hash = match stop_state with - | None -> Lwt.return None + | None -> return None | Some state -> let* s = PVM.state_hash state in - Lwt.return (Some s) + return (Some s) + in + let* pvm_proof = + match start_state with + | Some s -> PVM.Utils.make_proof s stop_hash + | None -> assert false + in + let wrapped = + let module P = struct + include PVM + + let proof = pvm_proof + end in + Unencodable (module P) in - let* proof = PVM.Utils.make_proof start_hash stop_hash true in - Lwt.return {choice = start_tick; step = Proof proof} + let proof = Proof.{pvm_step = wrapped; inbox = None} in + return Game.{choice = start_tick; step = Proof proof} | Some next_dissection -> - Lwt.return - {choice = start_tick; step = Dissection next_dissection} + return + Game.{choice = start_tick; step = Dissection next_dissection} in - Lwt.return (Some refutation) - | None -> Lwt.return None + return (Some refutation) + | None -> return None - (** This is an automatic client. It generates a "perfect" client.*) + (** This is an automatic client. It generates a "perfect" client. *) let machine_directed = let start_state = PVM.Utils.default_state in let initial = let* stop_at, stop_state = - execute_until Sc_rollup_tick_repr.initial start_state @@ fun _ _ -> - false + execute_until Tick.initial start_state @@ fun _ _ -> false in let* stop_hash = PVM.state_hash stop_state in - Lwt.return (Some (stop_at, stop_hash)) + return (Some (stop_at, stop_hash)) in - let next_move game = + let next_move (game : Game.t) = let dissection = game.dissection in let* mv = next_move dissection in - match mv with - | Some move -> Lwt.return (Some move) - | None -> Lwt.return None + match mv with Some move -> return (Some move) | None -> return None in {initial; next_move} - (** This builds a client from a strategy. - If the strategy is MachineDirected it uses the above constructions. - If the strategy is random then it uses a random section for the initial - commitments and the random decision for the next move.*) + (** This builds a client from a strategy. If the strategy is + MachineDirected it uses the above constructions. If the strategy + is random then it uses a random section for the initial + commitments and the random decision for the next move. *) let player_from_strategy = function | Random -> let initial = let random_state = PVM.Utils.default_state in let* stop_hash = PVM.state_hash random_state in let random_tick = random_tick ~from:1 () in - Lwt.return (Some (random_tick, stop_hash)) + return (Some (random_tick, stop_hash)) in - {initial; next_move = (fun game -> random_decision game.dissection)} | MachineDirected -> machine_directed (** [test_strategies defender_strategy refuter_strategy expectation inbox] - runs a game based oin the two given strategies and checks that the - resulting outcome fits the expectations. *) + runs a game based oin the two given strategies and checks that the + resulting outcome fits the expectations. *) let test_strategies defender_strategy refuter_strategy expectation inbox = let defender_client = player_from_strategy defender_strategy in let refuter_client = player_from_strategy refuter_strategy in @@ -781,7 +765,7 @@ struct let all_win _ = true end -(** the following are the possible combinations of strategies*) +(** The following are the possible combinations of strategies. *) let perfect_perfect (module P : TestPVM) inbox = let module R = Strategies (P) in R.test_strategies MachineDirected MachineDirected R.defender_wins inbox @@ -798,21 +782,18 @@ let perfect_random (module P : TestPVM) inbox = let module S = Strategies (P) in S.test_strategies MachineDirected Random S.defender_wins inbox -(** This assembles a test from a RandomPVM and a function that choses the - type of strategies *) -let testing_randomPVM - (f : (module TestPVM) -> Sc_rollup_inbox_repr.t -> bool Lwt.t) name = +(** This assembles a test from a RandomPVM and a function that chooses the + type of strategies. *) +let testing_randomPVM (f : (module TestPVM) -> Inbox.t -> bool Lwt.t) name = let open QCheck2 in Test.make ~name Gen.(list_size small_int (int_range 0 100)) (fun initial_prog -> assume (initial_prog <> []) ; - let rollup = Sc_rollup_repr.Address.hash_string [""] in - let level = - Raw_level_repr.of_int32 0l |> function Ok x -> x | _ -> assert false - in - let inbox = Sc_rollup_inbox_repr.empty rollup level in + let rollup = Address.hash_string [""] in + let level = zero_level in + let inbox = Inbox.empty rollup level in Lwt_main.run @@ f (module MakeRandomPVM (struct @@ -820,18 +801,15 @@ let testing_randomPVM end)) inbox) -(** This assembles a test from a CountingPVM and a function that choses -the type of strategies *) -let testing_countPVM - (f : (module TestPVM) -> Sc_rollup_inbox_repr.t -> bool Lwt.t) name = +(** This assembles a test from a CountingPVM and a function that + chooses the type of strategies *) +let testing_countPVM (f : (module TestPVM) -> Inbox.t -> bool Lwt.t) name = let open QCheck2 in Test.make ~name Gen.small_int (fun target -> assume (target > 200) ; - let rollup = Sc_rollup_repr.Address.hash_string [""] in - let level = - Raw_level_repr.of_int32 0l |> function Ok x -> x | _ -> assert false - in - let inbox = Sc_rollup_inbox_repr.empty rollup level in + let rollup = Address.hash_string [""] in + let level = zero_level in + let inbox = Inbox.empty rollup level in Lwt_main.run @@ f (module MakeCountingPVM (struct @@ -839,19 +817,16 @@ let testing_countPVM end)) inbox) -let testing_arith (f : (module TestPVM) -> Sc_rollup_inbox_repr.t -> bool Lwt.t) - name = +let testing_arith (f : (module TestPVM) -> Inbox.t -> bool Lwt.t) name = let open QCheck2 in Test.make ~name Gen.(pair gen_list small_int) (fun (inputs, evals) -> assume (evals > 1 && evals < List.length inputs - 1) ; - let rollup = Sc_rollup_repr.Address.hash_string [""] in - let level = - Raw_level_repr.of_int32 0l |> function Ok x -> x | _ -> assert false - in - let inbox = Sc_rollup_inbox_repr.empty rollup level in + let rollup = Address.hash_string [""] in + let level = zero_level in + let inbox = Inbox.empty rollup level in Lwt_main.run @@ f (module TestArith (struct @@ -870,14 +845,12 @@ let test_random_dissection (module P : TestPVM) start_at length = if hash = new_hash then aux hash else new_hash in let section_stop_at = - match Sc_rollup_tick_repr.of_int (start_at + length) with + match Tick.of_int (start_at + length) with | None -> assert false | Some x -> x in let section_start_at = - match Sc_rollup_tick_repr.of_int start_at with - | None -> assert false - | Some x -> x + match Tick.of_int start_at with None -> assert false | Some x -> x in let* option_dissection = S.dissection_of_section @@ -892,15 +865,15 @@ let test_random_dissection (module P : TestPVM) start_at length = in let* start = state_hash section_start_state in let stop_hash = Some (aux start) in - Lwt.return - (Result.to_option - @@ Sc_rollup_game_repr.check_dissection - (Some start) - section_start_at - stop_hash - section_stop_at - dissection - = Some ()) + let* check = + Game.check_dissection + (Some start) + section_start_at + stop_hash + section_stop_at + dissection + in + return (Result.to_option check = Some ()) let testDissection = let open QCheck2 in @@ -941,16 +914,8 @@ let testRandomDissection = (fun (start_int, length) -> assume (start_int > 0 && length >= 10) ; let testing_lwt = - let start_at = - match Sc_rollup_tick_repr.of_int start_int with - | None -> assert false - | Some t -> t - in - let stop_at = - match Sc_rollup_tick_repr.of_int (start_int + length) with - | None -> assert false - | Some t -> t - in + let start_at = tick_of_int_exn start_int in + let stop_at = tick_of_int_exn (start_int + length) in let start_hash = Some (random_hash ()) in let stop_hash = Some (random_hash ()) in @@ -965,15 +930,15 @@ let testRandomDissection = if hash = new_hash then aux hash else new_hash in let new_hash = aux stop_hash in - Lwt.return - (Result.to_option - @@ Sc_rollup_game_repr.check_dissection - start_hash - start_at - new_hash - stop_at - dissection - = Some ()) + let* check = + Game.check_dissection + start_hash + start_at + new_hash + stop_at + dissection + in + return (Result.to_option check = Some ()) in Lwt_main.run testing_lwt); ] -- GitLab From 62f74bd11322b4f993853699bcc75f0fc4731da7 Mon Sep 17 00:00:00 2001 From: Thomas Athorne Date: Wed, 1 Jun 2022 11:33:42 +0100 Subject: [PATCH 06/11] Proto: SCORU: remove redundant export in alpha; cleanup docstring --- src/proto_alpha/lib_protocol/alpha_context.mli | 3 --- src/proto_alpha/lib_protocol/sc_rollup_PVM_sem.ml | 4 ++-- 2 files changed, 2 insertions(+), 5 deletions(-) diff --git a/src/proto_alpha/lib_protocol/alpha_context.mli b/src/proto_alpha/lib_protocol/alpha_context.mli index a8dc47ede4f5..cf1bdb92dacc 100644 --- a/src/proto_alpha/lib_protocol/alpha_context.mli +++ b/src/proto_alpha/lib_protocol/alpha_context.mli @@ -2618,9 +2618,6 @@ module Sc_rollup : sig type status = Halted | WaitingForInputMessage | Parsing | Evaluating val get_status : state -> status Lwt.t - - val produce_proof : - context -> input option -> state -> (proof, string) result Lwt.t end end diff --git a/src/proto_alpha/lib_protocol/sc_rollup_PVM_sem.ml b/src/proto_alpha/lib_protocol/sc_rollup_PVM_sem.ml index 8f7edfa0a492..b81e924a08df 100644 --- a/src/proto_alpha/lib_protocol/sc_rollup_PVM_sem.ml +++ b/src/proto_alpha/lib_protocol/sc_rollup_PVM_sem.ml @@ -262,8 +262,8 @@ module type S = sig val verify_proof : proof -> bool Lwt.t (** [produce_proof ctxt input_given state] should return a [proof] for - the PVM step starting from [state], if possible. This may return - [None] for a few reasons: + the PVM step starting from [state], if possible. This may fail for + a few reasons: - the [input_given] doesn't match the expectations of [state] ; - the [context] for this instance of the PVM doesn't have access to enough of the [state] to build the proof. *) -- GitLab From d0fc6efa75526489fa5cd97100732fee12ab5aff Mon Sep 17 00:00:00 2001 From: Thomas Athorne Date: Wed, 1 Jun 2022 15:14:52 +0100 Subject: [PATCH 07/11] Proto:SCORU: switch to V1 context tree proof encodings - this fixes an issue where `./tezos-codec describe` hangs --- src/proto_alpha/lib_protocol/sc_rollup_arith.ml | 2 +- src/proto_alpha/lib_protocol/sc_rollup_inbox_repr.ml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/proto_alpha/lib_protocol/sc_rollup_arith.ml b/src/proto_alpha/lib_protocol/sc_rollup_arith.ml index 6b439bf1ba1e..b6ebcb4aa067 100644 --- a/src/proto_alpha/lib_protocol/sc_rollup_arith.ml +++ b/src/proto_alpha/lib_protocol/sc_rollup_arith.ml @@ -1024,5 +1024,5 @@ module ProtocolImplementation = Make (struct let proof_after proof = kinded_hash_to_state_hash proof.Context.Proof.after - let proof_encoding = Context.Proof_encoding.V2.Tree32.tree_proof_encoding + let proof_encoding = Context.Proof_encoding.V1.Tree32.tree_proof_encoding end) diff --git a/src/proto_alpha/lib_protocol/sc_rollup_inbox_repr.ml b/src/proto_alpha/lib_protocol/sc_rollup_inbox_repr.ml index 61e72bf62e81..a917d2a689db 100644 --- a/src/proto_alpha/lib_protocol/sc_rollup_inbox_repr.ml +++ b/src/proto_alpha/lib_protocol/sc_rollup_inbox_repr.ml @@ -737,7 +737,7 @@ module Proof = struct (req "inc" inclusion_proof_encoding) (req "message_proof" - Context.Proof_encoding.V2.Tree32.tree_proof_encoding)) + Context.Proof_encoding.V1.Tree32.tree_proof_encoding)) (* This function is for pattern matching on proofs based on whether they involve multiple levels or if they only concern a single -- GitLab From 37eff0d41902ec909c3690401b26615cd460ecd7 Mon Sep 17 00:00:00 2001 From: Thomas Athorne Date: Wed, 1 Jun 2022 17:39:59 +0100 Subject: [PATCH 08/11] Tezt: update some regression tests --- ... client) RPC regression tests- mempool.out | 12936 ++++++++++++---- ...e proxy) RPC regression tests- mempool.out | 12936 ++++++++++++---- .../Alpha- ensure boot sector is used.out | 4 +- ... node advances PVM state with messages.out | 38 +- ...ommitments in the rollup node (commitm.out | 4 +- ...ommitments in the rollup node (message.out | 4 +- 6 files changed, 19167 insertions(+), 6755 deletions(-) diff --git a/tezt/tests/expected/RPC_test.ml/Alpha- (mode client) RPC regression tests- mempool.out b/tezt/tests/expected/RPC_test.ml/Alpha- (mode client) RPC regression tests- mempool.out index c83e3a59b2fc..8b6d3fb8929e 100644 --- a/tezt/tests/expected/RPC_test.ml/Alpha- (mode client) RPC regression tests- mempool.out +++ b/tezt/tests/expected/RPC_test.ml/Alpha- (mode client) RPC regression tests- mempool.out @@ -3425,53 +3425,1766 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, { "title": "Proof", - "oneOf": [ - { - "title": "Proof of a normal computation step", - "type": "array", - "items": [ - { - "type": "boolean" - }, - { - "$ref": "#/definitions/state_hash" - }, - { - "$ref": "#/definitions/state_hash" - } - ], - "additionalItems": false - }, - { - "title": "Proof of an input step", - "type": "array", - "items": [ - { - "type": "boolean" - }, - { - "$ref": "#/definitions/state_hash" - }, + "type": "object", + "properties": { + "pvm_step": { + "oneOf": [ { - "$ref": "#/definitions/state_hash" + "title": "Arithmetic PVM with proof", + "type": "object", + "properties": { + "tree_proof": { + "type": "object", + "properties": { + "version": { + "type": "integer", + "minimum": -32768, + "maximum": 32767 + }, + "before": { + "oneOf": [ + { + "title": "Value", + "type": "object", + "properties": { + "value": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "value" + ], + "additionalProperties": false + }, + { + "title": "Node", + "type": "object", + "properties": { + "node": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "node" + ], + "additionalProperties": false + } + ] + }, + "after": { + "oneOf": [ + { + "title": "Value", + "type": "object", + "properties": { + "value": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "value" + ], + "additionalProperties": false + }, + { + "title": "Node", + "type": "object", + "properties": { + "node": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "node" + ], + "additionalProperties": false + } + ] + }, + "state": { + "oneOf": [ + { + "title": "Value", + "type": "object", + "properties": { + "value": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + } + }, + "required": [ + "value" + ], + "additionalProperties": false + }, + { + "title": "Blinded_value", + "type": "object", + "properties": { + "blinded_value": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_value" + ], + "additionalProperties": false + }, + { + "title": "Node", + "type": "object", + "properties": { + "node": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + { + "$ref": "#/definitions/tree_encoding" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "node" + ], + "additionalProperties": false + }, + { + "title": "Blinded_node", + "type": "object", + "properties": { + "blinded_node": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_node" + ], + "additionalProperties": false + }, + { + "title": "Inode", + "type": "object", + "properties": { + "inode": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "proofs": { + "oneOf": [ + { + "title": "sparse_proof", + "type": "object", + "properties": { + "sparse_proof": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "integer", + "minimum": 0, + "maximum": 255 + }, + { + "oneOf": [ + { + "title": "Blinded_inode", + "type": "object", + "properties": { + "blinded_inode": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_inode" + ], + "additionalProperties": false + }, + { + "title": "Inode_values", + "type": "object", + "properties": { + "inode_values": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + { + "$ref": "#/definitions/tree_encoding" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "inode_values" + ], + "additionalProperties": false + }, + { + "title": "Inode_tree", + "type": "object", + "properties": { + "inode_tree": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "proofs": { + "oneOf": [ + { + "title": "sparse_proof", + "type": "object", + "properties": { + "sparse_proof": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "integer", + "minimum": 0, + "maximum": 255 + }, + { + "$ref": "#/definitions/inode_tree" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "sparse_proof" + ], + "additionalProperties": false + }, + { + "title": "dense_proof", + "type": "object", + "properties": { + "dense_proof": { + "type": "array", + "items": { + "$ref": "#/definitions/inode_tree" + } + } + }, + "required": [ + "dense_proof" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proofs", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_tree" + ], + "additionalProperties": false + }, + { + "title": "Inode_extender", + "type": "object", + "properties": { + "inode_extender": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "segment": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + "proof": { + "$ref": "#/definitions/inode_tree" + } + }, + "required": [ + "proof", + "segment", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_extender" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "object", + "properties": { + "none": { + "type": "null" + } + }, + "required": [ + "none" + ], + "additionalProperties": false + } + ] + } + ], + "additionalItems": false + } + } + }, + "required": [ + "sparse_proof" + ], + "additionalProperties": false + }, + { + "title": "dense_proof", + "type": "object", + "properties": { + "dense_proof": { + "type": "array", + "items": { + "oneOf": [ + { + "title": "Blinded_inode", + "type": "object", + "properties": { + "blinded_inode": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_inode" + ], + "additionalProperties": false + }, + { + "title": "Inode_values", + "type": "object", + "properties": { + "inode_values": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + { + "$ref": "#/definitions/tree_encoding" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "inode_values" + ], + "additionalProperties": false + }, + { + "title": "Inode_tree", + "type": "object", + "properties": { + "inode_tree": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "proofs": { + "oneOf": [ + { + "title": "sparse_proof", + "type": "object", + "properties": { + "sparse_proof": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "integer", + "minimum": 0, + "maximum": 255 + }, + { + "$ref": "#/definitions/inode_tree" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "sparse_proof" + ], + "additionalProperties": false + }, + { + "title": "dense_proof", + "type": "object", + "properties": { + "dense_proof": { + "type": "array", + "items": { + "$ref": "#/definitions/inode_tree" + } + } + }, + "required": [ + "dense_proof" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proofs", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_tree" + ], + "additionalProperties": false + }, + { + "title": "Inode_extender", + "type": "object", + "properties": { + "inode_extender": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "segment": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + "proof": { + "$ref": "#/definitions/inode_tree" + } + }, + "required": [ + "proof", + "segment", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_extender" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "object", + "properties": { + "none": { + "type": "null" + } + }, + "required": [ + "none" + ], + "additionalProperties": false + } + ] + } + } + }, + "required": [ + "dense_proof" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proofs", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode" + ], + "additionalProperties": false + }, + { + "title": "Extender", + "type": "object", + "properties": { + "extender": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "segment": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + "proof": { + "oneOf": [ + { + "title": "Blinded_inode", + "type": "object", + "properties": { + "blinded_inode": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_inode" + ], + "additionalProperties": false + }, + { + "title": "Inode_values", + "type": "object", + "properties": { + "inode_values": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + { + "$ref": "#/definitions/tree_encoding" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "inode_values" + ], + "additionalProperties": false + }, + { + "title": "Inode_tree", + "type": "object", + "properties": { + "inode_tree": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "proofs": { + "oneOf": [ + { + "title": "sparse_proof", + "type": "object", + "properties": { + "sparse_proof": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "integer", + "minimum": 0, + "maximum": 255 + }, + { + "$ref": "#/definitions/inode_tree" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "sparse_proof" + ], + "additionalProperties": false + }, + { + "title": "dense_proof", + "type": "object", + "properties": { + "dense_proof": { + "type": "array", + "items": { + "$ref": "#/definitions/inode_tree" + } + } + }, + "required": [ + "dense_proof" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proofs", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_tree" + ], + "additionalProperties": false + }, + { + "title": "Inode_extender", + "type": "object", + "properties": { + "inode_extender": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "segment": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + "proof": { + "$ref": "#/definitions/inode_tree" + } + }, + "required": [ + "proof", + "segment", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_extender" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "object", + "properties": { + "none": { + "type": "null" + } + }, + "required": [ + "none" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proof", + "segment", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "extender" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "object", + "properties": { + "none": { + "type": "null" + } + }, + "required": [ + "none" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "state", + "after", + "before", + "version" + ], + "additionalProperties": false + }, + "given": { + "oneOf": [ + { + "title": "Some", + "type": "object", + "properties": { + "inbox_level": { + "type": "integer", + "minimum": -2147483648, + "maximum": 2147483647 + }, + "message_counter": { + "$ref": "#/definitions/positive_bignum" + }, + "payload": { + "$ref": "#/definitions/unistring" + } + }, + "required": [ + "payload", + "message_counter", + "inbox_level" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "null" + } + ] + }, + "requested": { + "oneOf": [ + { + "title": "No_input_required", + "type": "object", + "properties": { + "no_input_required": {} + }, + "required": [ + "no_input_required" + ], + "additionalProperties": false + }, + { + "title": "Initial", + "type": "object", + "properties": { + "initial": {} + }, + "required": [ + "initial" + ], + "additionalProperties": false + }, + { + "title": "First_after", + "type": "array", + "items": [ + { + "type": "integer", + "minimum": -2147483648, + "maximum": 2147483647 + }, + { + "$ref": "#/definitions/positive_bignum" + } + ], + "additionalItems": false + } + ] + } + }, + "required": [ + "requested", + "given", + "tree_proof" + ], + "additionalProperties": false } - ], - "additionalItems": false + ] }, - { - "title": "Proof that the PVM is blocked", - "type": "array", - "items": [ + "inbox": { + "oneOf": [ { - "type": "boolean" + "title": "Some", + "type": "object", + "properties": { + "skips": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "object", + "properties": { + "rollup": { + "$ref": "#/definitions/alpha.rollup_address" + }, + "message_counter": { + "$ref": "#/definitions/positive_bignum" + }, + "nb_available_messages": { + "$ref": "#/definitions/int64" + }, + "nb_messages_in_commitment_period": { + "$ref": "#/definitions/int64" + }, + "starting_level_of_current_commitment_period": { + "type": "integer", + "minimum": -2147483648, + "maximum": 2147483647 + }, + "level": { + "type": "integer", + "minimum": -2147483648, + "maximum": 2147483647 + }, + "current_messages_hash": { + "$ref": "#/definitions/inbox_hash" + }, + "old_levels_messages": { + "type": "object", + "properties": { + "index": { + "type": "integer", + "minimum": -1073741824, + "maximum": 1073741823 + }, + "content": { + "$ref": "#/definitions/inbox_hash" + }, + "back_pointers": { + "type": "array", + "items": { + "$ref": "#/definitions/inbox_hash" + } + } + }, + "required": [ + "back_pointers", + "content", + "index" + ], + "additionalProperties": false + } + }, + "required": [ + "old_levels_messages", + "current_messages_hash", + "level", + "starting_level_of_current_commitment_period", + "nb_messages_in_commitment_period", + "nb_available_messages", + "message_counter", + "rollup" + ], + "additionalProperties": false + }, + { + "type": "array", + "items": { + "type": "object", + "properties": { + "index": { + "type": "integer", + "minimum": -1073741824, + "maximum": 1073741823 + }, + "content": { + "$ref": "#/definitions/inbox_hash" + }, + "back_pointers": { + "type": "array", + "items": { + "$ref": "#/definitions/inbox_hash" + } + } + }, + "required": [ + "back_pointers", + "content", + "index" + ], + "additionalProperties": false + } + } + ], + "additionalItems": false + } + }, + "level": { + "type": "object", + "properties": { + "rollup": { + "$ref": "#/definitions/alpha.rollup_address" + }, + "message_counter": { + "$ref": "#/definitions/positive_bignum" + }, + "nb_available_messages": { + "$ref": "#/definitions/int64" + }, + "nb_messages_in_commitment_period": { + "$ref": "#/definitions/int64" + }, + "starting_level_of_current_commitment_period": { + "type": "integer", + "minimum": -2147483648, + "maximum": 2147483647 + }, + "level": { + "type": "integer", + "minimum": -2147483648, + "maximum": 2147483647 + }, + "current_messages_hash": { + "$ref": "#/definitions/inbox_hash" + }, + "old_levels_messages": { + "type": "object", + "properties": { + "index": { + "type": "integer", + "minimum": -1073741824, + "maximum": 1073741823 + }, + "content": { + "$ref": "#/definitions/inbox_hash" + }, + "back_pointers": { + "type": "array", + "items": { + "$ref": "#/definitions/inbox_hash" + } + } + }, + "required": [ + "back_pointers", + "content", + "index" + ], + "additionalProperties": false + } + }, + "required": [ + "old_levels_messages", + "current_messages_hash", + "level", + "starting_level_of_current_commitment_period", + "nb_messages_in_commitment_period", + "nb_available_messages", + "message_counter", + "rollup" + ], + "additionalProperties": false + }, + "inc": { + "type": "array", + "items": { + "type": "object", + "properties": { + "index": { + "type": "integer", + "minimum": -1073741824, + "maximum": 1073741823 + }, + "content": { + "$ref": "#/definitions/inbox_hash" + }, + "back_pointers": { + "type": "array", + "items": { + "$ref": "#/definitions/inbox_hash" + } + } + }, + "required": [ + "back_pointers", + "content", + "index" + ], + "additionalProperties": false + } + }, + "message_proof": { + "type": "object", + "properties": { + "version": { + "type": "integer", + "minimum": -32768, + "maximum": 32767 + }, + "before": { + "oneOf": [ + { + "title": "Value", + "type": "object", + "properties": { + "value": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "value" + ], + "additionalProperties": false + }, + { + "title": "Node", + "type": "object", + "properties": { + "node": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "node" + ], + "additionalProperties": false + } + ] + }, + "after": { + "oneOf": [ + { + "title": "Value", + "type": "object", + "properties": { + "value": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "value" + ], + "additionalProperties": false + }, + { + "title": "Node", + "type": "object", + "properties": { + "node": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "node" + ], + "additionalProperties": false + } + ] + }, + "state": { + "oneOf": [ + { + "title": "Value", + "type": "object", + "properties": { + "value": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + } + }, + "required": [ + "value" + ], + "additionalProperties": false + }, + { + "title": "Blinded_value", + "type": "object", + "properties": { + "blinded_value": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_value" + ], + "additionalProperties": false + }, + { + "title": "Node", + "type": "object", + "properties": { + "node": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + { + "$ref": "#/definitions/tree_encoding" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "node" + ], + "additionalProperties": false + }, + { + "title": "Blinded_node", + "type": "object", + "properties": { + "blinded_node": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_node" + ], + "additionalProperties": false + }, + { + "title": "Inode", + "type": "object", + "properties": { + "inode": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "proofs": { + "oneOf": [ + { + "title": "sparse_proof", + "type": "object", + "properties": { + "sparse_proof": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "integer", + "minimum": 0, + "maximum": 255 + }, + { + "oneOf": [ + { + "title": "Blinded_inode", + "type": "object", + "properties": { + "blinded_inode": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_inode" + ], + "additionalProperties": false + }, + { + "title": "Inode_values", + "type": "object", + "properties": { + "inode_values": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + { + "$ref": "#/definitions/tree_encoding" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "inode_values" + ], + "additionalProperties": false + }, + { + "title": "Inode_tree", + "type": "object", + "properties": { + "inode_tree": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "proofs": { + "oneOf": [ + { + "title": "sparse_proof", + "type": "object", + "properties": { + "sparse_proof": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "integer", + "minimum": 0, + "maximum": 255 + }, + { + "$ref": "#/definitions/inode_tree" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "sparse_proof" + ], + "additionalProperties": false + }, + { + "title": "dense_proof", + "type": "object", + "properties": { + "dense_proof": { + "type": "array", + "items": { + "$ref": "#/definitions/inode_tree" + } + } + }, + "required": [ + "dense_proof" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proofs", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_tree" + ], + "additionalProperties": false + }, + { + "title": "Inode_extender", + "type": "object", + "properties": { + "inode_extender": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "segment": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + "proof": { + "$ref": "#/definitions/inode_tree" + } + }, + "required": [ + "proof", + "segment", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_extender" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "object", + "properties": { + "none": { + "type": "null" + } + }, + "required": [ + "none" + ], + "additionalProperties": false + } + ] + } + ], + "additionalItems": false + } + } + }, + "required": [ + "sparse_proof" + ], + "additionalProperties": false + }, + { + "title": "dense_proof", + "type": "object", + "properties": { + "dense_proof": { + "type": "array", + "items": { + "oneOf": [ + { + "title": "Blinded_inode", + "type": "object", + "properties": { + "blinded_inode": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_inode" + ], + "additionalProperties": false + }, + { + "title": "Inode_values", + "type": "object", + "properties": { + "inode_values": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + { + "$ref": "#/definitions/tree_encoding" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "inode_values" + ], + "additionalProperties": false + }, + { + "title": "Inode_tree", + "type": "object", + "properties": { + "inode_tree": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "proofs": { + "oneOf": [ + { + "title": "sparse_proof", + "type": "object", + "properties": { + "sparse_proof": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "integer", + "minimum": 0, + "maximum": 255 + }, + { + "$ref": "#/definitions/inode_tree" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "sparse_proof" + ], + "additionalProperties": false + }, + { + "title": "dense_proof", + "type": "object", + "properties": { + "dense_proof": { + "type": "array", + "items": { + "$ref": "#/definitions/inode_tree" + } + } + }, + "required": [ + "dense_proof" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proofs", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_tree" + ], + "additionalProperties": false + }, + { + "title": "Inode_extender", + "type": "object", + "properties": { + "inode_extender": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "segment": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + "proof": { + "$ref": "#/definitions/inode_tree" + } + }, + "required": [ + "proof", + "segment", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_extender" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "object", + "properties": { + "none": { + "type": "null" + } + }, + "required": [ + "none" + ], + "additionalProperties": false + } + ] + } + } + }, + "required": [ + "dense_proof" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proofs", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode" + ], + "additionalProperties": false + }, + { + "title": "Extender", + "type": "object", + "properties": { + "extender": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "segment": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + "proof": { + "oneOf": [ + { + "title": "Blinded_inode", + "type": "object", + "properties": { + "blinded_inode": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_inode" + ], + "additionalProperties": false + }, + { + "title": "Inode_values", + "type": "object", + "properties": { + "inode_values": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + { + "$ref": "#/definitions/tree_encoding" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "inode_values" + ], + "additionalProperties": false + }, + { + "title": "Inode_tree", + "type": "object", + "properties": { + "inode_tree": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "proofs": { + "oneOf": [ + { + "title": "sparse_proof", + "type": "object", + "properties": { + "sparse_proof": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "integer", + "minimum": 0, + "maximum": 255 + }, + { + "$ref": "#/definitions/inode_tree" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "sparse_proof" + ], + "additionalProperties": false + }, + { + "title": "dense_proof", + "type": "object", + "properties": { + "dense_proof": { + "type": "array", + "items": { + "$ref": "#/definitions/inode_tree" + } + } + }, + "required": [ + "dense_proof" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proofs", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_tree" + ], + "additionalProperties": false + }, + { + "title": "Inode_extender", + "type": "object", + "properties": { + "inode_extender": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "segment": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + "proof": { + "$ref": "#/definitions/inode_tree" + } + }, + "required": [ + "proof", + "segment", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_extender" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "object", + "properties": { + "none": { + "type": "null" + } + }, + "required": [ + "none" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proof", + "segment", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "extender" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "object", + "properties": { + "none": { + "type": "null" + } + }, + "required": [ + "none" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "state", + "after", + "before", + "version" + ], + "additionalProperties": false + } + }, + "required": [ + "message_proof", + "inc", + "level", + "skips" + ], + "additionalProperties": false }, { - "$ref": "#/definitions/state_hash" + "title": "None", + "type": "null" } - ], - "additionalItems": false + ] } - ] + }, + "required": [ + "inbox", + "pvm_step" + ], + "additionalProperties": false } ] } @@ -3818,85 +5531,246 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" } }, - "int64": { - "title": "64 bit integers", - "description": "Decimal representation of 64 bit integers", - "type": "string" + "inbox_hash": { + "title": "The hash of an inbox of a smart contract rollup (Base58Check-encoded)", + "$ref": "#/definitions/unistring" }, - "micheline.alpha.michelson_v1.expression": { + "inode_tree": { "oneOf": [ { - "title": "Int", - "type": "object", - "properties": { - "int": { - "$ref": "#/definitions/bignum" - } - }, - "required": [ - "int" - ], - "additionalProperties": false - }, - { - "title": "String", + "title": "Blinded_inode", "type": "object", "properties": { - "string": { - "$ref": "#/definitions/unistring" + "blinded_inode": { + "$ref": "#/definitions/Context_hash" } }, "required": [ - "string" + "blinded_inode" ], "additionalProperties": false }, { - "title": "Bytes", + "title": "Inode_values", "type": "object", "properties": { - "bytes": { - "type": "string", - "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + "inode_values": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + { + "$ref": "#/definitions/tree_encoding" + } + ], + "additionalItems": false + } } }, "required": [ - "bytes" + "inode_values" ], "additionalProperties": false }, { - "title": "Sequence", - "type": "array", - "items": { - "$ref": "#/definitions/micheline.alpha.michelson_v1.expression" - } - }, - { - "title": "Prim__generic", - "description": "Generic primitive (any number of args with or without annotations)", + "title": "Inode_tree", "type": "object", "properties": { - "prim": { - "$ref": "#/definitions/alpha.michelson.v1.primitives" - }, - "args": { - "type": "array", - "items": { - "$ref": "#/definitions/micheline.alpha.michelson_v1.expression" - } - }, - "annots": { - "type": "array", - "items": { - "type": "string" - } - } - }, - "required": [ - "prim" - ], - "additionalProperties": false + "inode_tree": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "proofs": { + "oneOf": [ + { + "title": "sparse_proof", + "type": "object", + "properties": { + "sparse_proof": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "integer", + "minimum": 0, + "maximum": 255 + }, + { + "$ref": "#/definitions/inode_tree" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "sparse_proof" + ], + "additionalProperties": false + }, + { + "title": "dense_proof", + "type": "object", + "properties": { + "dense_proof": { + "type": "array", + "items": { + "$ref": "#/definitions/inode_tree" + } + } + }, + "required": [ + "dense_proof" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proofs", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_tree" + ], + "additionalProperties": false + }, + { + "title": "Inode_extender", + "type": "object", + "properties": { + "inode_extender": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "segment": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + "proof": { + "$ref": "#/definitions/inode_tree" + } + }, + "required": [ + "proof", + "segment", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_extender" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "object", + "properties": { + "none": { + "type": "null" + } + }, + "required": [ + "none" + ], + "additionalProperties": false + } + ] + }, + "int64": { + "title": "64 bit integers", + "description": "Decimal representation of 64 bit integers", + "type": "string" + }, + "micheline.alpha.michelson_v1.expression": { + "oneOf": [ + { + "title": "Int", + "type": "object", + "properties": { + "int": { + "$ref": "#/definitions/bignum" + } + }, + "required": [ + "int" + ], + "additionalProperties": false + }, + { + "title": "String", + "type": "object", + "properties": { + "string": { + "$ref": "#/definitions/unistring" + } + }, + "required": [ + "string" + ], + "additionalProperties": false + }, + { + "title": "Bytes", + "type": "object", + "properties": { + "bytes": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + } + }, + "required": [ + "bytes" + ], + "additionalProperties": false + }, + { + "title": "Sequence", + "type": "array", + "items": { + "$ref": "#/definitions/micheline.alpha.michelson_v1.expression" + } + }, + { + "title": "Prim__generic", + "description": "Generic primitive (any number of args with or without annotations)", + "type": "object", + "properties": { + "prim": { + "$ref": "#/definitions/alpha.michelson.v1.primitives" + }, + "args": { + "type": "array", + "items": { + "$ref": "#/definitions/micheline.alpha.michelson_v1.expression" + } + }, + "annots": { + "type": "array", + "items": { + "type": "string" + } + } + }, + "required": [ + "prim" + ], + "additionalProperties": false } ] }, @@ -3917,197 +5791,1447 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "description": "A timestamp as seen by the protocol: second-level precision, epoch based.", "$ref": "#/definitions/unistring" }, - "unistring": { - "title": "Universal string representation", - "description": "Either a plain UTF8 string, or a sequence of bytes for strings that contain invalid byte sequences.", + "tree_encoding": { "oneOf": [ { - "type": "string" + "title": "Value", + "type": "object", + "properties": { + "value": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + } + }, + "required": [ + "value" + ], + "additionalProperties": false }, { + "title": "Blinded_value", "type": "object", "properties": { - "invalid_utf8_string": { + "blinded_value": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_value" + ], + "additionalProperties": false + }, + { + "title": "Node", + "type": "object", + "properties": { + "node": { "type": "array", "items": { - "type": "integer", - "minimum": 0, - "maximum": 255 + "type": "array", + "items": [ + { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + { + "$ref": "#/definitions/tree_encoding" + } + ], + "additionalItems": false } } }, "required": [ - "invalid_utf8_string" + "node" ], "additionalProperties": false - } - ] - }, - "value_hash": { - "title": "Hash of a consensus value (Base58Check-encoded)", - "$ref": "#/definitions/unistring" - } - } - }, - "binary_schema": { - "toplevel": { - "fields": [ - { - "kind": "dyn", - "num_fields": 1, - "size": "Uint30" - }, - { - "layout": { - "layout": { - "name": "X_0", - "kind": "Ref" - }, - "kind": "Seq" }, - "kind": "anon", - "data_kind": { - "kind": "Variable" - } - } - ] - }, - "fields": [ - { - "description": { - "title": "X_0" - }, - "encoding": { - "fields": [ - { - "name": "hash", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "size": 32, - "kind": "Float" - }, - "kind": "named" - }, - { - "kind": "dyn", - "num_fields": 1, - "size": "Uint30" + { + "title": "Blinded_node", + "type": "object", + "properties": { + "blinded_node": { + "$ref": "#/definitions/Context_hash" + } }, - { - "name": "branch", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "size": 32, - "kind": "Float" + "required": [ + "blinded_node" + ], + "additionalProperties": false + }, + { + "title": "Inode", + "type": "object", + "properties": { + "inode": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "proofs": { + "oneOf": [ + { + "title": "sparse_proof", + "type": "object", + "properties": { + "sparse_proof": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "integer", + "minimum": 0, + "maximum": 255 + }, + { + "oneOf": [ + { + "title": "Blinded_inode", + "type": "object", + "properties": { + "blinded_inode": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_inode" + ], + "additionalProperties": false + }, + { + "title": "Inode_values", + "type": "object", + "properties": { + "inode_values": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + { + "$ref": "#/definitions/tree_encoding" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "inode_values" + ], + "additionalProperties": false + }, + { + "title": "Inode_tree", + "type": "object", + "properties": { + "inode_tree": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "proofs": { + "oneOf": [ + { + "title": "sparse_proof", + "type": "object", + "properties": { + "sparse_proof": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "integer", + "minimum": 0, + "maximum": 255 + }, + { + "$ref": "#/definitions/inode_tree" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "sparse_proof" + ], + "additionalProperties": false + }, + { + "title": "dense_proof", + "type": "object", + "properties": { + "dense_proof": { + "type": "array", + "items": { + "$ref": "#/definitions/inode_tree" + } + } + }, + "required": [ + "dense_proof" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proofs", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_tree" + ], + "additionalProperties": false + }, + { + "title": "Inode_extender", + "type": "object", + "properties": { + "inode_extender": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "segment": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + "proof": { + "$ref": "#/definitions/inode_tree" + } + }, + "required": [ + "proof", + "segment", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_extender" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "object", + "properties": { + "none": { + "type": "null" + } + }, + "required": [ + "none" + ], + "additionalProperties": false + } + ] + } + ], + "additionalItems": false + } + } + }, + "required": [ + "sparse_proof" + ], + "additionalProperties": false + }, + { + "title": "dense_proof", + "type": "object", + "properties": { + "dense_proof": { + "type": "array", + "items": { + "oneOf": [ + { + "title": "Blinded_inode", + "type": "object", + "properties": { + "blinded_inode": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_inode" + ], + "additionalProperties": false + }, + { + "title": "Inode_values", + "type": "object", + "properties": { + "inode_values": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + { + "$ref": "#/definitions/tree_encoding" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "inode_values" + ], + "additionalProperties": false + }, + { + "title": "Inode_tree", + "type": "object", + "properties": { + "inode_tree": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "proofs": { + "oneOf": [ + { + "title": "sparse_proof", + "type": "object", + "properties": { + "sparse_proof": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "integer", + "minimum": 0, + "maximum": 255 + }, + { + "$ref": "#/definitions/inode_tree" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "sparse_proof" + ], + "additionalProperties": false + }, + { + "title": "dense_proof", + "type": "object", + "properties": { + "dense_proof": { + "type": "array", + "items": { + "$ref": "#/definitions/inode_tree" + } + } + }, + "required": [ + "dense_proof" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proofs", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_tree" + ], + "additionalProperties": false + }, + { + "title": "Inode_extender", + "type": "object", + "properties": { + "inode_extender": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "segment": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + "proof": { + "$ref": "#/definitions/inode_tree" + } + }, + "required": [ + "proof", + "segment", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_extender" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "object", + "properties": { + "none": { + "type": "null" + } + }, + "required": [ + "none" + ], + "additionalProperties": false + } + ] + } + } + }, + "required": [ + "dense_proof" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proofs", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode" + ], + "additionalProperties": false + }, + { + "title": "Extender", + "type": "object", + "properties": { + "extender": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "segment": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + "proof": { + "oneOf": [ + { + "title": "Blinded_inode", + "type": "object", + "properties": { + "blinded_inode": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_inode" + ], + "additionalProperties": false + }, + { + "title": "Inode_values", + "type": "object", + "properties": { + "inode_values": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + { + "$ref": "#/definitions/tree_encoding" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "inode_values" + ], + "additionalProperties": false + }, + { + "title": "Inode_tree", + "type": "object", + "properties": { + "inode_tree": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "proofs": { + "oneOf": [ + { + "title": "sparse_proof", + "type": "object", + "properties": { + "sparse_proof": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "integer", + "minimum": 0, + "maximum": 255 + }, + { + "$ref": "#/definitions/inode_tree" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "sparse_proof" + ], + "additionalProperties": false + }, + { + "title": "dense_proof", + "type": "object", + "properties": { + "dense_proof": { + "type": "array", + "items": { + "$ref": "#/definitions/inode_tree" + } + } + }, + "required": [ + "dense_proof" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proofs", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_tree" + ], + "additionalProperties": false + }, + { + "title": "Inode_extender", + "type": "object", + "properties": { + "inode_extender": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "segment": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + "proof": { + "$ref": "#/definitions/inode_tree" + } + }, + "required": [ + "proof", + "segment", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_extender" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "object", + "properties": { + "none": { + "type": "null" + } + }, + "required": [ + "none" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proof", + "segment", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "extender" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "object", + "properties": { + "none": { + "type": "null" + } + }, + "required": [ + "none" + ], + "additionalProperties": false + } + ] + }, + "unistring": { + "title": "Universal string representation", + "description": "Either a plain UTF8 string, or a sequence of bytes for strings that contain invalid byte sequences.", + "oneOf": [ + { + "type": "string" + }, + { + "type": "object", + "properties": { + "invalid_utf8_string": { + "type": "array", + "items": { + "type": "integer", + "minimum": 0, + "maximum": 255 + } + } + }, + "required": [ + "invalid_utf8_string" + ], + "additionalProperties": false + } + ] + }, + "value_hash": { + "title": "Hash of a consensus value (Base58Check-encoded)", + "$ref": "#/definitions/unistring" + } + } + }, + "binary_schema": { + "toplevel": { + "fields": [ + { + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" + }, + { + "layout": { + "layout": { + "name": "X_0", + "kind": "Ref" + }, + "kind": "Seq" + }, + "kind": "anon", + "data_kind": { + "kind": "Variable" + } + } + ] + }, + "fields": [ + { + "description": { + "title": "X_0" + }, + "encoding": { + "fields": [ + { + "name": "hash", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 32, + "kind": "Float" + }, + "kind": "named" + }, + { + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" + }, + { + "name": "branch", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 32, + "kind": "Float" + }, + "kind": "named" + }, + { + "kind": "dyn", + "num_fields": 2, + "size": "Uint30" + }, + { + "name": "contents", + "layout": { + "layout": { + "name": "alpha.operation.alpha.contents", + "kind": "Ref" + }, + "kind": "Seq" + }, + "data_kind": { + "kind": "Variable" + }, + "kind": "named" + }, + { + "name": "signature", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 64, + "kind": "Float" }, "kind": "named" }, { - "kind": "dyn", - "num_fields": 2, - "size": "Uint30" + "kind": "dyn", + "name": "error_opt", + "num_fields": 1, + "size": "Uint30" + }, + { + "name": "error", + "layout": { + "kind": "String" + }, + "data_kind": { + "kind": "Variable" + }, + "kind": "named" + } + ] + } + }, + { + "description": { + "title": "alpha.operation.alpha.contents" + }, + "encoding": { + "tag_size": "Uint8", + "kind": { + "kind": "Dynamic" + }, + "cases": [ + { + "tag": 1, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "level", + "layout": { + "size": "Int32", + "kind": "Int" + }, + "data_kind": { + "size": 4, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "nonce", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 32, + "kind": "Float" + }, + "kind": "named" + } + ], + "name": "Seed_nonce_revelation" + }, + { + "tag": 2, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" + }, + { + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" + }, + { + "name": "op1", + "layout": { + "name": "alpha.inlined.endorsement", + "kind": "Ref" + }, + "data_kind": { + "kind": "Variable" + }, + "kind": "named" + }, + { + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" + }, + { + "name": "op2", + "layout": { + "name": "alpha.inlined.endorsement", + "kind": "Ref" + }, + "data_kind": { + "kind": "Variable" + }, + "kind": "named" + } + ], + "name": "Double_endorsement_evidence" + }, + { + "tag": 3, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" + }, + { + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" + }, + { + "name": "bh1", + "layout": { + "name": "alpha.block_header.alpha.full_header", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" + }, + { + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" + }, + { + "name": "bh2", + "layout": { + "name": "alpha.block_header.alpha.full_header", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" + } + ], + "name": "Double_baking_evidence" + }, + { + "tag": 4, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "pkh", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 20, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "secret", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 20, + "kind": "Float" + }, + "kind": "named" + } + ], + "name": "Activate_account" + }, + { + "tag": 5, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "source", + "layout": { + "name": "public_key_hash", + "kind": "Ref" + }, + "data_kind": { + "size": 21, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "period", + "layout": { + "size": "Int32", + "kind": "Int" + }, + "data_kind": { + "size": 4, + "kind": "Float" + }, + "kind": "named" + }, + { + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" + }, + { + "name": "proposals", + "layout": { + "layout": { + "kind": "Bytes" + }, + "kind": "Seq" + }, + "data_kind": { + "kind": "Variable" + }, + "kind": "named" + } + ], + "name": "Proposals" + }, + { + "tag": 6, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "source", + "layout": { + "name": "public_key_hash", + "kind": "Ref" + }, + "data_kind": { + "size": 21, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "period", + "layout": { + "size": "Int32", + "kind": "Int" + }, + "data_kind": { + "size": 4, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "proposal", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 32, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "ballot", + "layout": { + "size": "Int8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" + } + ], + "name": "Ballot" + }, + { + "tag": 7, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" + }, + { + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" + }, + { + "name": "op1", + "layout": { + "name": "alpha.inlined.preendorsement", + "kind": "Ref" + }, + "data_kind": { + "kind": "Variable" + }, + "kind": "named" + }, + { + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" + }, + { + "name": "op2", + "layout": { + "name": "alpha.inlined.preendorsement", + "kind": "Ref" + }, + "data_kind": { + "kind": "Variable" + }, + "kind": "named" + } + ], + "name": "Double_preendorsement_evidence" + }, + { + "tag": 17, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" + }, + { + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" + }, + { + "name": "arbitrary", + "layout": { + "kind": "String" + }, + "data_kind": { + "kind": "Variable" + }, + "kind": "named" + } + ], + "name": "Failing_noop" }, { - "name": "contents", - "layout": { - "layout": { - "name": "alpha.operation.alpha.contents", - "kind": "Ref" + "tag": 20, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" }, - "kind": "Seq" - }, - "data_kind": { - "kind": "Variable" - }, - "kind": "named" + { + "name": "slot", + "layout": { + "size": "Uint16", + "kind": "Int" + }, + "data_kind": { + "size": 2, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "level", + "layout": { + "size": "Int32", + "kind": "Int" + }, + "data_kind": { + "size": 4, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "round", + "layout": { + "size": "Int32", + "kind": "Int" + }, + "data_kind": { + "size": 4, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "block_payload_hash", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 32, + "kind": "Float" + }, + "kind": "named" + } + ], + "name": "Preendorsement" }, { - "name": "signature", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "size": 64, - "kind": "Float" - }, - "kind": "named" + "tag": 21, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "slot", + "layout": { + "size": "Uint16", + "kind": "Int" + }, + "data_kind": { + "size": 2, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "level", + "layout": { + "size": "Int32", + "kind": "Int" + }, + "data_kind": { + "size": 4, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "round", + "layout": { + "size": "Int32", + "kind": "Int" + }, + "data_kind": { + "size": 4, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "block_payload_hash", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 32, + "kind": "Float" + }, + "kind": "named" + } + ], + "name": "Endorsement" }, { - "kind": "dyn", - "name": "error_opt", - "num_fields": 1, - "size": "Uint30" + "tag": 22, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "endorser", + "layout": { + "name": "public_key_hash", + "kind": "Ref" + }, + "data_kind": { + "size": 21, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "endorsement", + "layout": { + "name": "Z.t", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" + } + ], + "name": "Dal_slot_availability" }, { - "name": "error", - "layout": { - "kind": "String" - }, - "data_kind": { - "kind": "Variable" - }, - "kind": "named" - } - ] - } - }, - { - "description": { - "title": "alpha.operation.alpha.contents" - }, - "encoding": { - "tag_size": "Uint8", - "kind": { - "kind": "Dynamic" - }, - "cases": [ - { - "tag": 1, + "tag": 107, "fields": [ { - "name": "Tag", + "name": "Tag", + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "source", + "layout": { + "name": "public_key_hash", + "kind": "Ref" + }, + "data_kind": { + "size": 21, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "fee", + "layout": { + "name": "N.t", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" + }, + { + "name": "counter", + "layout": { + "name": "N.t", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" + }, + { + "name": "gas_limit", "layout": { - "size": "Uint8", - "kind": "Int" + "name": "N.t", + "kind": "Ref" }, "data_kind": { - "size": 1, - "kind": "Float" + "kind": "Dynamic" }, "kind": "named" }, { - "name": "level", + "name": "storage_limit", "layout": { - "size": "Int32", - "kind": "Int" + "name": "N.t", + "kind": "Ref" }, "data_kind": { - "size": 4, - "kind": "Float" + "kind": "Dynamic" }, "kind": "named" }, { - "name": "nonce", + "name": "public_key", "layout": { - "kind": "Bytes" + "name": "public_key", + "kind": "Ref" }, "data_kind": { - "size": 32, - "kind": "Float" + "kind": "Dynamic" }, "kind": "named" } ], - "name": "Seed_nonce_revelation" + "name": "Reveal" }, { - "tag": 2, + "tag": 108, "fields": [ { "name": "Tag", @@ -4122,64 +7246,43 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "kind": "dyn", - "num_fields": 1, - "size": "Uint30" - }, - { - "name": "op1", + "name": "source", "layout": { - "name": "alpha.inlined.endorsement", + "name": "public_key_hash", "kind": "Ref" }, "data_kind": { - "kind": "Variable" + "size": 21, + "kind": "Float" }, "kind": "named" }, { - "kind": "dyn", - "num_fields": 1, - "size": "Uint30" - }, - { - "name": "op2", + "name": "fee", "layout": { - "name": "alpha.inlined.endorsement", + "name": "N.t", "kind": "Ref" }, "data_kind": { - "kind": "Variable" + "kind": "Dynamic" }, "kind": "named" - } - ], - "name": "Double_endorsement_evidence" - }, - { - "tag": 3, - "fields": [ + }, { - "name": "Tag", + "name": "counter", "layout": { - "size": "Uint8", - "kind": "Int" + "name": "N.t", + "kind": "Ref" }, "data_kind": { - "size": 1, - "kind": "Float" + "kind": "Dynamic" }, "kind": "named" }, { - "kind": "dyn", - "num_fields": 1, - "size": "Uint30" - }, - { - "name": "bh1", + "name": "gas_limit", "layout": { - "name": "alpha.block_header.alpha.full_header", + "name": "N.t", "kind": "Ref" }, "data_kind": { @@ -4188,66 +7291,59 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "kind": "dyn", - "num_fields": 1, - "size": "Uint30" - }, - { - "name": "bh2", + "name": "storage_limit", "layout": { - "name": "alpha.block_header.alpha.full_header", + "name": "N.t", "kind": "Ref" }, "data_kind": { "kind": "Dynamic" }, "kind": "named" - } - ], - "name": "Double_baking_evidence" - }, - { - "tag": 4, - "fields": [ + }, { - "name": "Tag", + "name": "amount", "layout": { - "size": "Uint8", - "kind": "Int" + "name": "N.t", + "kind": "Ref" }, "data_kind": { - "size": 1, - "kind": "Float" + "kind": "Dynamic" }, "kind": "named" }, { - "name": "pkh", + "name": "destination", "layout": { - "kind": "Bytes" + "name": "alpha.contract_id", + "kind": "Ref" }, "data_kind": { - "size": 20, + "size": 22, "kind": "Float" }, "kind": "named" }, { - "name": "secret", + "kind": "option_indicator", + "name": "parameters" + }, + { + "name": "parameters", "layout": { - "kind": "Bytes" + "name": "X_1777", + "kind": "Ref" }, "data_kind": { - "size": 20, - "kind": "Float" + "kind": "Dynamic" }, "kind": "named" } ], - "name": "Activate_account" + "name": "Transaction" }, { - "tag": 5, + "tag": 109, "fields": [ { "name": "Tag", @@ -4274,105 +7370,92 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "period", + "name": "fee", "layout": { - "size": "Int32", - "kind": "Int" + "name": "N.t", + "kind": "Ref" }, "data_kind": { - "size": 4, - "kind": "Float" + "kind": "Dynamic" }, "kind": "named" }, { - "kind": "dyn", - "num_fields": 1, - "size": "Uint30" - }, - { - "name": "proposals", + "name": "counter", "layout": { - "layout": { - "kind": "Bytes" - }, - "kind": "Seq" + "name": "N.t", + "kind": "Ref" }, "data_kind": { - "kind": "Variable" + "kind": "Dynamic" }, "kind": "named" - } - ], - "name": "Proposals" - }, - { - "tag": 6, - "fields": [ + }, { - "name": "Tag", + "name": "gas_limit", "layout": { - "size": "Uint8", - "kind": "Int" + "name": "N.t", + "kind": "Ref" }, "data_kind": { - "size": 1, - "kind": "Float" + "kind": "Dynamic" }, "kind": "named" }, { - "name": "source", + "name": "storage_limit", "layout": { - "name": "public_key_hash", + "name": "N.t", "kind": "Ref" }, "data_kind": { - "size": 21, - "kind": "Float" + "kind": "Dynamic" }, "kind": "named" }, { - "name": "period", + "name": "balance", "layout": { - "size": "Int32", - "kind": "Int" + "name": "N.t", + "kind": "Ref" }, "data_kind": { - "size": 4, - "kind": "Float" + "kind": "Dynamic" }, "kind": "named" }, { - "name": "proposal", + "kind": "option_indicator", + "name": "delegate" + }, + { + "name": "delegate", "layout": { - "kind": "Bytes" + "name": "public_key_hash", + "kind": "Ref" }, "data_kind": { - "size": 32, + "size": 21, "kind": "Float" }, "kind": "named" }, { - "name": "ballot", + "name": "script", "layout": { - "size": "Int8", - "kind": "Int" + "name": "alpha.scripted.contracts", + "kind": "Ref" }, "data_kind": { - "size": 1, - "kind": "Float" + "kind": "Dynamic" }, "kind": "named" } ], - "name": "Ballot" + "name": "Origination" }, { - "tag": 7, + "tag": 110, "fields": [ { "name": "Tag", @@ -4387,42 +7470,82 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "kind": "dyn", - "num_fields": 1, - "size": "Uint30" + "name": "source", + "layout": { + "name": "public_key_hash", + "kind": "Ref" + }, + "data_kind": { + "size": 21, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "fee", + "layout": { + "name": "N.t", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" + }, + { + "name": "counter", + "layout": { + "name": "N.t", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" + }, + { + "name": "gas_limit", + "layout": { + "name": "N.t", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" }, { - "name": "op1", + "name": "storage_limit", "layout": { - "name": "alpha.inlined.preendorsement", + "name": "N.t", "kind": "Ref" }, "data_kind": { - "kind": "Variable" + "kind": "Dynamic" }, "kind": "named" }, { - "kind": "dyn", - "num_fields": 1, - "size": "Uint30" + "kind": "option_indicator", + "name": "delegate" }, { - "name": "op2", + "name": "delegate", "layout": { - "name": "alpha.inlined.preendorsement", + "name": "public_key_hash", "kind": "Ref" }, "data_kind": { - "kind": "Variable" + "size": 21, + "kind": "Float" }, "kind": "named" } ], - "name": "Double_preendorsement_evidence" + "name": "Delegation" }, { - "tag": 17, + "tag": 111, "fields": [ { "name": "Tag", @@ -4437,90 +7560,81 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "kind": "dyn", - "num_fields": 1, - "size": "Uint30" - }, - { - "name": "arbitrary", + "name": "source", "layout": { - "kind": "String" + "name": "public_key_hash", + "kind": "Ref" }, "data_kind": { - "kind": "Variable" + "size": 21, + "kind": "Float" }, "kind": "named" - } - ], - "name": "Failing_noop" - }, - { - "tag": 20, - "fields": [ + }, { - "name": "Tag", + "name": "fee", "layout": { - "size": "Uint8", - "kind": "Int" + "name": "N.t", + "kind": "Ref" }, "data_kind": { - "size": 1, - "kind": "Float" + "kind": "Dynamic" }, "kind": "named" }, { - "name": "slot", + "name": "counter", "layout": { - "size": "Uint16", - "kind": "Int" + "name": "N.t", + "kind": "Ref" }, "data_kind": { - "size": 2, - "kind": "Float" + "kind": "Dynamic" }, "kind": "named" }, { - "name": "level", + "name": "gas_limit", "layout": { - "size": "Int32", - "kind": "Int" + "name": "N.t", + "kind": "Ref" }, "data_kind": { - "size": 4, - "kind": "Float" + "kind": "Dynamic" }, "kind": "named" }, { - "name": "round", + "name": "storage_limit", "layout": { - "size": "Int32", - "kind": "Int" + "name": "N.t", + "kind": "Ref" }, "data_kind": { - "size": 4, - "kind": "Float" + "kind": "Dynamic" }, "kind": "named" }, { - "name": "block_payload_hash", + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" + }, + { + "name": "value", "layout": { "kind": "Bytes" }, "data_kind": { - "size": 32, - "kind": "Float" + "kind": "Variable" }, "kind": "named" } ], - "name": "Preendorsement" + "name": "Register_global_constant" }, { - "tag": 21, + "tag": 112, "fields": [ { "name": "Tag", @@ -4535,86 +7649,69 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "slot", + "name": "source", "layout": { - "size": "Uint16", - "kind": "Int" + "name": "public_key_hash", + "kind": "Ref" }, "data_kind": { - "size": 2, + "size": 21, "kind": "Float" }, "kind": "named" }, { - "name": "level", + "name": "fee", "layout": { - "size": "Int32", - "kind": "Int" + "name": "N.t", + "kind": "Ref" }, "data_kind": { - "size": 4, - "kind": "Float" + "kind": "Dynamic" }, "kind": "named" }, { - "name": "round", + "name": "counter", "layout": { - "size": "Int32", - "kind": "Int" + "name": "N.t", + "kind": "Ref" }, "data_kind": { - "size": 4, - "kind": "Float" + "kind": "Dynamic" }, "kind": "named" }, { - "name": "block_payload_hash", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "size": 32, - "kind": "Float" - }, - "kind": "named" - } - ], - "name": "Endorsement" - }, - { - "tag": 22, - "fields": [ - { - "name": "Tag", + "name": "gas_limit", "layout": { - "size": "Uint8", - "kind": "Int" + "name": "N.t", + "kind": "Ref" }, "data_kind": { - "size": 1, - "kind": "Float" + "kind": "Dynamic" }, "kind": "named" }, { - "name": "endorser", + "name": "storage_limit", "layout": { - "name": "public_key_hash", + "name": "N.t", "kind": "Ref" }, "data_kind": { - "size": 21, - "kind": "Float" + "kind": "Dynamic" }, "kind": "named" }, { - "name": "endorsement", + "kind": "option_indicator", + "name": "limit" + }, + { + "name": "limit", "layout": { - "name": "Z.t", + "name": "N.t", "kind": "Ref" }, "data_kind": { @@ -4623,10 +7720,10 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" } ], - "name": "Dal_slot_availability" + "name": "Set_deposits_limit" }, { - "tag": 107, + "tag": 150, "fields": [ { "name": "Tag", @@ -4695,23 +7792,12 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "Dynamic" }, "kind": "named" - }, - { - "name": "public_key", - "layout": { - "name": "public_key", - "kind": "Ref" - }, - "data_kind": { - "kind": "Dynamic" - }, - "kind": "named" } ], - "name": "Reveal" + "name": "Tx_rollup_origination" }, { - "tag": 108, + "tag": 151, "fields": [ { "name": "Tag", @@ -4782,36 +7868,39 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "amount", + "name": "rollup", "layout": { - "name": "N.t", - "kind": "Ref" + "kind": "Bytes" }, "data_kind": { - "kind": "Dynamic" + "size": 20, + "kind": "Float" }, "kind": "named" }, { - "name": "destination", + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" + }, + { + "name": "content", "layout": { - "name": "alpha.contract_id", - "kind": "Ref" + "kind": "Bytes" }, "data_kind": { - "size": 22, - "kind": "Float" + "kind": "Variable" }, "kind": "named" }, { "kind": "option_indicator", - "name": "parameters" + "name": "burn_limit" }, { - "name": "parameters", + "name": "burn_limit", "layout": { - "name": "X_144", + "name": "N.t", "kind": "Ref" }, "data_kind": { @@ -4820,10 +7909,10 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" } ], - "name": "Transaction" + "name": "Tx_rollup_submit_batch" }, { - "tag": 109, + "tag": 152, "fields": [ { "name": "Tag", @@ -4894,36 +7983,20 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "balance", - "layout": { - "name": "N.t", - "kind": "Ref" - }, - "data_kind": { - "kind": "Dynamic" - }, - "kind": "named" - }, - { - "kind": "option_indicator", - "name": "delegate" - }, - { - "name": "delegate", + "name": "rollup", "layout": { - "name": "public_key_hash", - "kind": "Ref" + "kind": "Bytes" }, "data_kind": { - "size": 21, + "size": 20, "kind": "Float" }, "kind": "named" }, { - "name": "script", + "name": "commitment", "layout": { - "name": "alpha.scripted.contracts", + "name": "X_1775", "kind": "Ref" }, "data_kind": { @@ -4932,10 +8005,10 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" } ], - "name": "Origination" + "name": "Tx_rollup_commit" }, { - "tag": 110, + "tag": 153, "fields": [ { "name": "Tag", @@ -5006,26 +8079,21 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "kind": "option_indicator", - "name": "delegate" - }, - { - "name": "delegate", + "name": "rollup", "layout": { - "name": "public_key_hash", - "kind": "Ref" + "kind": "Bytes" }, "data_kind": { - "size": 21, + "size": 20, "kind": "Float" }, "kind": "named" } ], - "name": "Delegation" + "name": "Tx_rollup_return_bond" }, { - "tag": 111, + "tag": 154, "fields": [ { "name": "Tag", @@ -5096,25 +8164,21 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "kind": "dyn", - "num_fields": 1, - "size": "Uint30" - }, - { - "name": "value", + "name": "rollup", "layout": { "kind": "Bytes" }, "data_kind": { - "kind": "Variable" + "size": 20, + "kind": "Float" }, "kind": "named" } ], - "name": "Register_global_constant" + "name": "Tx_rollup_finalize_commitment" }, { - "tag": 112, + "tag": 155, "fields": [ { "name": "Tag", @@ -5185,25 +8249,21 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "kind": "option_indicator", - "name": "limit" - }, - { - "name": "limit", + "name": "rollup", "layout": { - "name": "N.t", - "kind": "Ref" + "kind": "Bytes" }, "data_kind": { - "kind": "Dynamic" + "size": 20, + "kind": "Float" }, "kind": "named" } ], - "name": "Set_deposits_limit" + "name": "Tx_rollup_remove_commitment" }, { - "tag": 150, + "tag": 156, "fields": [ { "name": "Tag", @@ -5272,41 +8332,34 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "Dynamic" }, "kind": "named" - } - ], - "name": "Tx_rollup_origination" - }, - { - "tag": 151, - "fields": [ + }, { - "name": "Tag", + "name": "rollup", "layout": { - "size": "Uint8", - "kind": "Int" + "kind": "Bytes" }, "data_kind": { - "size": 1, + "size": 20, "kind": "Float" }, "kind": "named" }, { - "name": "source", + "name": "level", "layout": { - "name": "public_key_hash", - "kind": "Ref" + "size": "Int32", + "kind": "Int" }, "data_kind": { - "size": 21, + "size": 4, "kind": "Float" }, "kind": "named" }, { - "name": "fee", + "name": "message", "layout": { - "name": "N.t", + "name": "X_1648", "kind": "Ref" }, "data_kind": { @@ -5315,7 +8368,7 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "counter", + "name": "message_position", "layout": { "name": "N.t", "kind": "Ref" @@ -5326,34 +8379,60 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "gas_limit", + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" + }, + { + "name": "message_path", "layout": { - "name": "N.t", - "kind": "Ref" + "layout": { + "kind": "Bytes" + }, + "kind": "Seq" }, "data_kind": { - "kind": "Dynamic" + "kind": "Variable" }, "kind": "named" }, { - "name": "storage_limit", + "name": "message_result_hash", "layout": { - "name": "N.t", - "kind": "Ref" + "kind": "Bytes" }, "data_kind": { - "kind": "Dynamic" + "size": 32, + "kind": "Float" }, "kind": "named" }, { - "name": "rollup", + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" + }, + { + "name": "message_result_path", "layout": { - "kind": "Bytes" + "layout": { + "kind": "Bytes" + }, + "kind": "Seq" }, "data_kind": { - "size": 20, + "kind": "Variable" + }, + "kind": "named" + }, + { + "name": "previous_message_result", + "layout": { + "name": "X_1649", + "kind": "Ref" + }, + "data_kind": { + "size": 64, "kind": "Float" }, "kind": "named" @@ -5364,9 +8443,12 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "size": "Uint30" }, { - "name": "content", + "name": "previous_message_result_path", "layout": { - "kind": "Bytes" + "layout": { + "kind": "Bytes" + }, + "kind": "Seq" }, "data_kind": { "kind": "Variable" @@ -5374,13 +8456,9 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "kind": "option_indicator", - "name": "burn_limit" - }, - { - "name": "burn_limit", + "name": "proof", "layout": { - "name": "N.t", + "name": "X_1774", "kind": "Ref" }, "data_kind": { @@ -5389,10 +8467,10 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" } ], - "name": "Tx_rollup_submit_batch" + "name": "Tx_rollup_rejection" }, { - "tag": 152, + "tag": 157, "fields": [ { "name": "Tag", @@ -5463,7 +8541,7 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "rollup", + "name": "tx_rollup", "layout": { "kind": "Bytes" }, @@ -5474,106 +8552,83 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "commitment", - "layout": { - "name": "X_142", - "kind": "Ref" - }, - "data_kind": { - "kind": "Dynamic" - }, - "kind": "named" - } - ], - "name": "Tx_rollup_commit" - }, - { - "tag": 153, - "fields": [ - { - "name": "Tag", + "name": "level", "layout": { - "size": "Uint8", + "size": "Int32", "kind": "Int" }, "data_kind": { - "size": 1, + "size": 4, "kind": "Float" }, "kind": "named" }, { - "name": "source", + "name": "context_hash", "layout": { - "name": "public_key_hash", - "kind": "Ref" + "kind": "Bytes" }, "data_kind": { - "size": 21, + "size": 32, "kind": "Float" }, "kind": "named" }, { - "name": "fee", + "name": "message_index", "layout": { - "name": "N.t", - "kind": "Ref" + "min": -1073741824, + "max": 1073741823, + "kind": "RangedInt" }, "data_kind": { - "kind": "Dynamic" + "size": 4, + "kind": "Float" }, "kind": "named" }, { - "name": "counter", - "layout": { - "name": "N.t", - "kind": "Ref" - }, - "data_kind": { - "kind": "Dynamic" - }, - "kind": "named" + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" }, { - "name": "gas_limit", + "name": "message_result_path", "layout": { - "name": "N.t", - "kind": "Ref" + "layout": { + "kind": "Bytes" + }, + "kind": "Seq" }, "data_kind": { - "kind": "Dynamic" + "kind": "Variable" }, "kind": "named" }, { - "name": "storage_limit", - "layout": { - "name": "N.t", - "kind": "Ref" - }, - "data_kind": { - "kind": "Dynamic" - }, - "kind": "named" + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" }, { - "name": "rollup", + "name": "tickets_info", "layout": { - "kind": "Bytes" + "layout": { + "name": "X_1644", + "kind": "Ref" + }, + "kind": "Seq" }, "data_kind": { - "size": 20, - "kind": "Float" + "kind": "Variable" }, "kind": "named" } ], - "name": "Tx_rollup_return_bond" + "name": "Tx_rollup_dispatch_tickets" }, { - "tag": 154, + "tag": 158, "fields": [ { "name": "Tag", @@ -5644,70 +8699,49 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "rollup", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "size": 20, - "kind": "Float" - }, - "kind": "named" - } - ], - "name": "Tx_rollup_finalize_commitment" - }, - { - "tag": 155, - "fields": [ + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" + }, { - "name": "Tag", + "name": "ticket_contents", "layout": { - "size": "Uint8", - "kind": "Int" + "kind": "Bytes" }, "data_kind": { - "size": 1, - "kind": "Float" + "kind": "Variable" }, "kind": "named" }, { - "name": "source", - "layout": { - "name": "public_key_hash", - "kind": "Ref" - }, - "data_kind": { - "size": 21, - "kind": "Float" - }, - "kind": "named" + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" }, { - "name": "fee", + "name": "ticket_ty", "layout": { - "name": "N.t", - "kind": "Ref" + "kind": "Bytes" }, "data_kind": { - "kind": "Dynamic" + "kind": "Variable" }, "kind": "named" }, { - "name": "counter", + "name": "ticket_ticketer", "layout": { - "name": "N.t", + "name": "alpha.contract_id", "kind": "Ref" }, "data_kind": { - "kind": "Dynamic" + "size": 22, + "kind": "Float" }, "kind": "named" }, { - "name": "gas_limit", + "name": "ticket_amount", "layout": { "name": "N.t", "kind": "Ref" @@ -5718,32 +8752,37 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "storage_limit", + "name": "destination", "layout": { - "name": "N.t", + "name": "alpha.contract_id", "kind": "Ref" }, "data_kind": { - "kind": "Dynamic" + "size": 22, + "kind": "Float" }, "kind": "named" }, { - "name": "rollup", + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" + }, + { + "name": "entrypoint", "layout": { - "kind": "Bytes" + "kind": "String" }, "data_kind": { - "size": 20, - "kind": "Float" + "kind": "Variable" }, "kind": "named" } ], - "name": "Tx_rollup_remove_commitment" + "name": "Transfer_ticket" }, { - "tag": 156, + "tag": 200, "fields": [ { "name": "Tag", @@ -5814,75 +8853,13 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "rollup", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "size": 20, - "kind": "Float" - }, - "kind": "named" - }, - { - "name": "level", - "layout": { - "size": "Int32", - "kind": "Int" - }, - "data_kind": { - "size": 4, - "kind": "Float" - }, - "kind": "named" - }, - { - "name": "message", - "layout": { - "name": "X_15", - "kind": "Ref" - }, - "data_kind": { - "kind": "Dynamic" - }, - "kind": "named" - }, - { - "name": "message_position", + "name": "kind", "layout": { - "name": "N.t", + "name": "X_1643", "kind": "Ref" }, "data_kind": { - "kind": "Dynamic" - }, - "kind": "named" - }, - { - "kind": "dyn", - "num_fields": 1, - "size": "Uint30" - }, - { - "name": "message_path", - "layout": { - "layout": { - "kind": "Bytes" - }, - "kind": "Seq" - }, - "data_kind": { - "kind": "Variable" - }, - "kind": "named" - }, - { - "name": "message_result_hash", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "size": 32, + "size": 2, "kind": "Float" }, "kind": "named" @@ -5893,64 +8870,35 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "size": "Uint30" }, { - "name": "message_result_path", + "name": "boot_sector", "layout": { - "layout": { - "kind": "Bytes" - }, - "kind": "Seq" + "kind": "String" }, "data_kind": { "kind": "Variable" }, "kind": "named" }, - { - "name": "previous_message_result", - "layout": { - "name": "X_16", - "kind": "Ref" - }, - "data_kind": { - "size": 64, - "kind": "Float" - }, - "kind": "named" - }, { "kind": "dyn", "num_fields": 1, "size": "Uint30" }, { - "name": "previous_message_result_path", + "name": "parameters_ty", "layout": { - "layout": { - "kind": "Bytes" - }, - "kind": "Seq" + "kind": "Bytes" }, "data_kind": { "kind": "Variable" }, "kind": "named" - }, - { - "name": "proof", - "layout": { - "name": "X_141", - "kind": "Ref" - }, - "data_kind": { - "kind": "Dynamic" - }, - "kind": "named" } ], - "name": "Tx_rollup_rejection" + "name": "Sc_rollup_originate" }, { - "tag": 157, + "tag": 201, "fields": [ { "name": "Tag", @@ -6020,65 +8968,16 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, "kind": "named" }, - { - "name": "tx_rollup", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "size": 20, - "kind": "Float" - }, - "kind": "named" - }, - { - "name": "level", - "layout": { - "size": "Int32", - "kind": "Int" - }, - "data_kind": { - "size": 4, - "kind": "Float" - }, - "kind": "named" - }, - { - "name": "context_hash", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "size": 32, - "kind": "Float" - }, - "kind": "named" - }, - { - "name": "message_index", - "layout": { - "min": -1073741824, - "max": 1073741823, - "kind": "RangedInt" - }, - "data_kind": { - "size": 4, - "kind": "Float" - }, - "kind": "named" - }, { "kind": "dyn", + "name": "alpha.rollup_address", "num_fields": 1, "size": "Uint30" }, { - "name": "message_result_path", + "name": "rollup", "layout": { - "layout": { - "kind": "Bytes" - }, - "kind": "Seq" + "kind": "String" }, "data_kind": { "kind": "Variable" @@ -6091,10 +8990,10 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "size": "Uint30" }, { - "name": "tickets_info", + "name": "message", "layout": { "layout": { - "name": "X_11", + "name": "X_1642", "kind": "Ref" }, "kind": "Seq" @@ -6105,10 +9004,10 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" } ], - "name": "Tx_rollup_dispatch_tickets" + "name": "Sc_rollup_add_messages" }, { - "tag": 158, + "tag": 202, "fields": [ { "name": "Tag", @@ -6180,13 +9079,14 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, { "kind": "dyn", + "name": "alpha.rollup_address", "num_fields": 1, "size": "Uint30" }, { - "name": "ticket_contents", + "name": "rollup", "layout": { - "kind": "Bytes" + "kind": "String" }, "data_kind": { "kind": "Variable" @@ -6194,34 +9094,70 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "kind": "dyn", - "num_fields": 1, - "size": "Uint30" + "name": "commitment", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 32, + "kind": "Float" + }, + "kind": "named" + } + ], + "name": "Sc_rollup_cement" + }, + { + "tag": 203, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" }, { - "name": "ticket_ty", + "name": "source", "layout": { - "kind": "Bytes" + "name": "public_key_hash", + "kind": "Ref" }, "data_kind": { - "kind": "Variable" + "size": 21, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "fee", + "layout": { + "name": "N.t", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" }, "kind": "named" }, { - "name": "ticket_ticketer", + "name": "counter", "layout": { - "name": "alpha.contract_id", + "name": "N.t", "kind": "Ref" }, "data_kind": { - "size": 22, - "kind": "Float" + "kind": "Dynamic" }, "kind": "named" }, { - "name": "ticket_amount", + "name": "gas_limit", "layout": { "name": "N.t", "kind": "Ref" @@ -6232,24 +9168,24 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "destination", + "name": "storage_limit", "layout": { - "name": "alpha.contract_id", + "name": "N.t", "kind": "Ref" }, "data_kind": { - "size": 22, - "kind": "Float" + "kind": "Dynamic" }, "kind": "named" }, { "kind": "dyn", + "name": "alpha.rollup_address", "num_fields": 1, "size": "Uint30" }, { - "name": "entrypoint", + "name": "rollup", "layout": { "kind": "String" }, @@ -6257,12 +9193,24 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "Variable" }, "kind": "named" + }, + { + "name": "commitment", + "layout": { + "name": "X_1641", + "kind": "Ref" + }, + "data_kind": { + "size": 76, + "kind": "Float" + }, + "kind": "named" } ], - "name": "Transfer_ticket" + "name": "Sc_rollup_publish" }, { - "tag": 200, + "tag": 204, "fields": [ { "name": "Tag", @@ -6332,25 +9280,14 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, "kind": "named" }, - { - "name": "kind", - "layout": { - "name": "X_10", - "kind": "Ref" - }, - "data_kind": { - "size": 2, - "kind": "Float" - }, - "kind": "named" - }, { "kind": "dyn", + "name": "alpha.rollup_address", "num_fields": 1, "size": "Uint30" }, { - "name": "boot_sector", + "name": "rollup", "layout": { "kind": "String" }, @@ -6360,25 +9297,33 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "kind": "dyn", - "num_fields": 1, - "size": "Uint30" + "name": "opponent", + "layout": { + "name": "public_key_hash", + "kind": "Ref" + }, + "data_kind": { + "size": 21, + "kind": "Float" + }, + "kind": "named" }, { - "name": "parameters_ty", + "name": "refutation", "layout": { - "kind": "Bytes" + "name": "X_3", + "kind": "Ref" }, "data_kind": { - "kind": "Variable" + "kind": "Dynamic" }, "kind": "named" } ], - "name": "Sc_rollup_originate" + "name": "Sc_rollup_refute" }, { - "tag": 201, + "tag": 205, "fields": [ { "name": "Tag", @@ -6465,29 +9410,22 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "kind": "dyn", - "num_fields": 1, - "size": "Uint30" - }, - { - "name": "message", + "name": "stakers", "layout": { - "layout": { - "name": "X_9", - "kind": "Ref" - }, - "kind": "Seq" + "name": "X_2", + "kind": "Ref" }, "data_kind": { - "kind": "Variable" + "size": 42, + "kind": "Float" }, "kind": "named" } ], - "name": "Sc_rollup_add_messages" + "name": "Sc_rollup_timeout" }, { - "tag": 202, + "tag": 206, "fields": [ { "name": "Tag", @@ -6574,7 +9512,7 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "commitment", + "name": "cemented_commitment", "layout": { "kind": "Bytes" }, @@ -6583,12 +9521,67 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "Float" }, "kind": "named" + }, + { + "name": "outbox_level", + "layout": { + "size": "Int32", + "kind": "Int" + }, + "data_kind": { + "size": 4, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "message_index", + "layout": { + "min": -1073741824, + "max": 1073741823, + "kind": "RangedInt" + }, + "data_kind": { + "size": 4, + "kind": "Float" + }, + "kind": "named" + }, + { + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" + }, + { + "name": "inclusion proof", + "layout": { + "kind": "String" + }, + "data_kind": { + "kind": "Variable" + }, + "kind": "named" + }, + { + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" + }, + { + "name": "atomic_transaction_batch", + "layout": { + "kind": "String" + }, + "data_kind": { + "kind": "Variable" + }, + "kind": "named" } ], - "name": "Sc_rollup_cement" + "name": "Sc_rollup_atomic_batch" }, { - "tag": 203, + "tag": 230, "fields": [ { "name": "Tag", @@ -6626,71 +9619,395 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "counter", + "name": "counter", + "layout": { + "name": "N.t", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" + }, + { + "name": "gas_limit", + "layout": { + "name": "N.t", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" + }, + { + "name": "storage_limit", + "layout": { + "name": "N.t", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" + }, + { + "name": "slot", + "layout": { + "name": "X_1", + "kind": "Ref" + }, + "data_kind": { + "size": 9, + "kind": "Float" + }, + "kind": "named" + } + ], + "name": "Dal_publish_slot_header" + } + ] + } + }, + { + "description": { + "title": "alpha.inlined.endorsement" + }, + "encoding": { + "fields": [ + { + "name": "branch", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 32, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "operations", + "layout": { + "name": "alpha.inlined.endorsement_mempool.contents", + "kind": "Ref" + }, + "data_kind": { + "size": 43, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "signature", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "kind": "Variable" + }, + "kind": "named" + } + ] + } + }, + { + "description": { + "title": "alpha.inlined.endorsement_mempool.contents" + }, + "encoding": { + "tag_size": "Uint8", + "kind": { + "size": 43, + "kind": "Float" + }, + "cases": [ + { + "tag": 21, + "fields": [ + { + "name": "Tag", "layout": { - "name": "N.t", - "kind": "Ref" + "size": "Uint8", + "kind": "Int" }, "data_kind": { - "kind": "Dynamic" + "size": 1, + "kind": "Float" }, "kind": "named" }, { - "name": "gas_limit", + "name": "slot", "layout": { - "name": "N.t", - "kind": "Ref" + "size": "Uint16", + "kind": "Int" }, "data_kind": { - "kind": "Dynamic" + "size": 2, + "kind": "Float" }, "kind": "named" }, { - "name": "storage_limit", + "name": "level", "layout": { - "name": "N.t", - "kind": "Ref" + "size": "Int32", + "kind": "Int" }, "data_kind": { - "kind": "Dynamic" + "size": 4, + "kind": "Float" }, "kind": "named" }, { - "kind": "dyn", - "name": "alpha.rollup_address", - "num_fields": 1, - "size": "Uint30" - }, - { - "name": "rollup", + "name": "round", "layout": { - "kind": "String" + "size": "Int32", + "kind": "Int" }, "data_kind": { - "kind": "Variable" + "size": 4, + "kind": "Float" }, "kind": "named" }, { - "name": "commitment", + "name": "block_payload_hash", "layout": { - "name": "X_8", - "kind": "Ref" + "kind": "Bytes" }, "data_kind": { - "size": 76, + "size": 32, "kind": "Float" }, "kind": "named" } ], - "name": "Sc_rollup_publish" + "name": "Endorsement" + } + ] + } + }, + { + "description": { + "title": "alpha.block_header.alpha.full_header" + }, + "encoding": { + "fields": [ + { + "name": "level", + "layout": { + "size": "Int32", + "kind": "Int" + }, + "data_kind": { + "size": 4, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "proto", + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "predecessor", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 32, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "timestamp", + "layout": { + "size": "Int64", + "kind": "Int" + }, + "data_kind": { + "size": 8, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "validation_pass", + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "operations_hash", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 32, + "kind": "Float" + }, + "kind": "named" + }, + { + "kind": "dyn", + "name": "fitness", + "num_fields": 1, + "size": "Uint30" + }, + { + "name": "fitness", + "layout": { + "layout": { + "name": "fitness.elem", + "kind": "Ref" + }, + "kind": "Seq" + }, + "data_kind": { + "kind": "Variable" + }, + "kind": "named" + }, + { + "name": "context", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 32, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "payload_hash", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 32, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "payload_round", + "layout": { + "size": "Int32", + "kind": "Int" + }, + "data_kind": { + "size": 4, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "proof_of_work_nonce", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 8, + "kind": "Float" + }, + "kind": "named" + }, + { + "kind": "option_indicator", + "name": "seed_nonce_hash" + }, + { + "name": "seed_nonce_hash", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 32, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "liquidity_baking_toggle_vote", + "layout": { + "size": "Int8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "signature", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 64, + "kind": "Float" + }, + "kind": "named" + } + ] + } + }, + { + "description": { + "title": "fitness.elem" + }, + "encoding": { + "fields": [ + { + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" }, { - "tag": 204, + "layout": { + "kind": "Bytes" + }, + "kind": "anon", + "data_kind": { + "kind": "Variable" + } + } + ] + } + }, + { + "description": { + "title": "public_key_hash" + }, + "encoding": { + "tag_size": "Uint8", + "kind": { + "size": 21, + "kind": "Float" + }, + "cases": [ + { + "tag": 0, "fields": [ { "name": "Tag", @@ -6705,105 +10022,21 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "source", - "layout": { - "name": "public_key_hash", - "kind": "Ref" - }, - "data_kind": { - "size": 21, - "kind": "Float" - }, - "kind": "named" - }, - { - "name": "fee", - "layout": { - "name": "N.t", - "kind": "Ref" - }, - "data_kind": { - "kind": "Dynamic" - }, - "kind": "named" - }, - { - "name": "counter", - "layout": { - "name": "N.t", - "kind": "Ref" - }, - "data_kind": { - "kind": "Dynamic" - }, - "kind": "named" - }, - { - "name": "gas_limit", - "layout": { - "name": "N.t", - "kind": "Ref" - }, - "data_kind": { - "kind": "Dynamic" - }, - "kind": "named" - }, - { - "name": "storage_limit", - "layout": { - "name": "N.t", - "kind": "Ref" - }, - "data_kind": { - "kind": "Dynamic" - }, - "kind": "named" - }, - { - "kind": "dyn", - "name": "alpha.rollup_address", - "num_fields": 1, - "size": "Uint30" - }, - { - "name": "rollup", - "layout": { - "kind": "String" - }, - "data_kind": { - "kind": "Variable" - }, - "kind": "named" - }, - { - "name": "opponent", + "name": "Ed25519.Public_key_hash", "layout": { - "name": "public_key_hash", - "kind": "Ref" + "kind": "Bytes" }, "data_kind": { - "size": 21, + "size": 20, "kind": "Float" }, "kind": "named" - }, - { - "name": "refutation", - "layout": { - "name": "X_3", - "kind": "Ref" - }, - "data_kind": { - "kind": "Dynamic" - }, - "kind": "named" } ], - "name": "Sc_rollup_refute" + "name": "Ed25519" }, { - "tag": 205, + "tag": 1, "fields": [ { "name": "Tag", @@ -6818,208 +10051,136 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "source", - "layout": { - "name": "public_key_hash", - "kind": "Ref" - }, - "data_kind": { - "size": 21, - "kind": "Float" - }, - "kind": "named" - }, - { - "name": "fee", - "layout": { - "name": "N.t", - "kind": "Ref" - }, - "data_kind": { - "kind": "Dynamic" - }, - "kind": "named" - }, - { - "name": "counter", - "layout": { - "name": "N.t", - "kind": "Ref" - }, - "data_kind": { - "kind": "Dynamic" - }, - "kind": "named" - }, - { - "name": "gas_limit", - "layout": { - "name": "N.t", - "kind": "Ref" - }, - "data_kind": { - "kind": "Dynamic" - }, - "kind": "named" - }, - { - "name": "storage_limit", - "layout": { - "name": "N.t", - "kind": "Ref" - }, - "data_kind": { - "kind": "Dynamic" - }, - "kind": "named" - }, - { - "kind": "dyn", - "name": "alpha.rollup_address", - "num_fields": 1, - "size": "Uint30" - }, - { - "name": "rollup", - "layout": { - "kind": "String" - }, - "data_kind": { - "kind": "Variable" - }, - "kind": "named" - }, - { - "name": "stakers", + "name": "Secp256k1.Public_key_hash", "layout": { - "name": "X_2", - "kind": "Ref" + "kind": "Bytes" }, "data_kind": { - "size": 42, + "size": 20, "kind": "Float" }, "kind": "named" } ], - "name": "Sc_rollup_timeout" + "name": "Secp256k1" }, { - "tag": 206, + "tag": 2, "fields": [ { "name": "Tag", - "layout": { - "size": "Uint8", - "kind": "Int" - }, - "data_kind": { - "size": 1, - "kind": "Float" - }, - "kind": "named" - }, - { - "name": "source", - "layout": { - "name": "public_key_hash", - "kind": "Ref" - }, - "data_kind": { - "size": 21, - "kind": "Float" - }, - "kind": "named" - }, - { - "name": "fee", - "layout": { - "name": "N.t", - "kind": "Ref" - }, - "data_kind": { - "kind": "Dynamic" - }, - "kind": "named" - }, - { - "name": "counter", - "layout": { - "name": "N.t", - "kind": "Ref" - }, - "data_kind": { - "kind": "Dynamic" - }, - "kind": "named" - }, - { - "name": "gas_limit", - "layout": { - "name": "N.t", - "kind": "Ref" - }, - "data_kind": { - "kind": "Dynamic" - }, - "kind": "named" - }, - { - "name": "storage_limit", - "layout": { - "name": "N.t", - "kind": "Ref" + "layout": { + "size": "Uint8", + "kind": "Int" }, "data_kind": { - "kind": "Dynamic" + "size": 1, + "kind": "Float" }, "kind": "named" }, { - "kind": "dyn", - "name": "alpha.rollup_address", - "num_fields": 1, - "size": "Uint30" - }, - { - "name": "rollup", + "name": "P256.Public_key_hash", "layout": { - "kind": "String" + "kind": "Bytes" }, "data_kind": { - "kind": "Variable" + "size": 20, + "kind": "Float" }, "kind": "named" - }, + } + ], + "name": "P256" + } + ] + } + }, + { + "description": { + "title": "alpha.inlined.preendorsement" + }, + "encoding": { + "fields": [ + { + "name": "branch", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 32, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "operations", + "layout": { + "name": "alpha.inlined.preendorsement.contents", + "kind": "Ref" + }, + "data_kind": { + "size": 43, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "signature", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "kind": "Variable" + }, + "kind": "named" + } + ] + } + }, + { + "description": { + "title": "alpha.inlined.preendorsement.contents" + }, + "encoding": { + "tag_size": "Uint8", + "kind": { + "size": 43, + "kind": "Float" + }, + "cases": [ + { + "tag": 20, + "fields": [ { - "name": "cemented_commitment", + "name": "Tag", "layout": { - "kind": "Bytes" + "size": "Uint8", + "kind": "Int" }, "data_kind": { - "size": 32, + "size": 1, "kind": "Float" }, "kind": "named" }, { - "name": "outbox_level", + "name": "slot", "layout": { - "size": "Int32", + "size": "Uint16", "kind": "Int" }, "data_kind": { - "size": 4, + "size": 2, "kind": "Float" }, "kind": "named" }, { - "name": "message_index", + "name": "level", "layout": { - "min": -1073741824, - "max": 1073741823, - "kind": "RangedInt" + "size": "Int32", + "kind": "Int" }, "data_kind": { "size": 4, @@ -7028,40 +10189,66 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "kind": "dyn", - "num_fields": 1, - "size": "Uint30" - }, - { - "name": "inclusion proof", + "name": "round", "layout": { - "kind": "String" + "size": "Int32", + "kind": "Int" }, "data_kind": { - "kind": "Variable" + "size": 4, + "kind": "Float" }, "kind": "named" }, { - "kind": "dyn", - "num_fields": 1, - "size": "Uint30" - }, - { - "name": "atomic_transaction_batch", + "name": "block_payload_hash", "layout": { - "kind": "String" + "kind": "Bytes" }, "data_kind": { - "kind": "Variable" + "size": 32, + "kind": "Float" }, "kind": "named" } ], - "name": "Sc_rollup_atomic_batch" - }, + "name": "Preendorsement" + } + ] + } + }, + { + "description": { + "title": "Z.t", + "description": "A variable-length sequence of bytes encoding a Zarith integer. Each byte has a running unary size bit: the most significant bit of each byte indicates whether this is the last byte in the sequence (0) or whether the sequence continues (1). The second most significant bit of the first byte is reserved for the sign (0 for positive, 1 for negative). Size and sign bits ignored, the data is the binary representation of the absolute value of the number in little-endian order." + }, + "encoding": { + "fields": [ { - "tag": 230, + "name": "Z.t", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" + } + ] + } + }, + { + "description": { + "title": "public_key" + }, + "encoding": { + "tag_size": "Uint8", + "kind": { + "kind": "Dynamic" + }, + "cases": [ + { + "tag": 0, "fields": [ { "name": "Tag", @@ -7076,110 +10263,124 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "source", + "name": "Ed25519.Public_key", "layout": { - "name": "public_key_hash", - "kind": "Ref" + "kind": "Bytes" }, "data_kind": { - "size": 21, + "size": 32, "kind": "Float" }, "kind": "named" - }, - { - "name": "fee", - "layout": { - "name": "N.t", - "kind": "Ref" - }, - "data_kind": { - "kind": "Dynamic" - }, - "kind": "named" - }, + } + ], + "name": "Ed25519" + }, + { + "tag": 1, + "fields": [ { - "name": "counter", + "name": "Tag", "layout": { - "name": "N.t", - "kind": "Ref" + "size": "Uint8", + "kind": "Int" }, "data_kind": { - "kind": "Dynamic" + "size": 1, + "kind": "Float" }, "kind": "named" }, { - "name": "gas_limit", + "name": "Secp256k1.Public_key", "layout": { - "name": "N.t", - "kind": "Ref" + "kind": "Bytes" }, "data_kind": { - "kind": "Dynamic" + "size": 33, + "kind": "Float" }, "kind": "named" - }, + } + ], + "name": "Secp256k1" + }, + { + "tag": 2, + "fields": [ { - "name": "storage_limit", + "name": "Tag", "layout": { - "name": "N.t", - "kind": "Ref" + "size": "Uint8", + "kind": "Int" }, "data_kind": { - "kind": "Dynamic" + "size": 1, + "kind": "Float" }, "kind": "named" }, { - "name": "slot", + "name": "P256.Public_key", "layout": { - "name": "X_1", - "kind": "Ref" + "kind": "Bytes" }, "data_kind": { - "size": 9, + "size": 33, "kind": "Float" }, "kind": "named" } ], - "name": "Dal_publish_slot_header" + "name": "P256" + } + ] + } + }, + { + "description": { + "title": "N.t", + "description": "A variable-length sequence of bytes encoding a Zarith natural number. Each byte has a running unary size bit: the most significant bit of each byte indicates whether this is the last byte in the sequence (0) or whether the sequence continues (1). Size bits ignored, the data is the binary representation of the number in little-endian order." + }, + "encoding": { + "fields": [ + { + "name": "N.t", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" } ] } }, { "description": { - "title": "alpha.inlined.endorsement" + "title": "X_1777" }, "encoding": { "fields": [ { - "name": "branch", + "name": "entrypoint", "layout": { - "kind": "Bytes" + "name": "alpha.entrypoint", + "kind": "Ref" }, "data_kind": { - "size": 32, - "kind": "Float" + "kind": "Dynamic" }, "kind": "named" }, { - "name": "operations", - "layout": { - "name": "alpha.inlined.endorsement_mempool.contents", - "kind": "Ref" - }, - "data_kind": { - "size": 43, - "kind": "Float" - }, - "kind": "named" + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" }, { - "name": "signature", + "name": "value", "layout": { "kind": "Bytes" }, @@ -7193,17 +10394,16 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, { "description": { - "title": "alpha.inlined.endorsement_mempool.contents" + "title": "alpha.entrypoint" }, "encoding": { "tag_size": "Uint8", "kind": { - "size": 43, - "kind": "Float" + "kind": "Dynamic" }, "cases": [ { - "tag": 21, + "tag": 0, "fields": [ { "name": "Tag", @@ -7218,148 +10418,264 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "slot", "layout": { - "size": "Uint16", + "kind": "Zero_width" + }, + "kind": "anon", + "data_kind": { + "size": 0, + "kind": "Float" + } + } + ], + "name": "default" + }, + { + "tag": 1, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", "kind": "Int" }, "data_kind": { - "size": 2, + "size": 1, "kind": "Float" }, "kind": "named" }, { - "name": "level", "layout": { - "size": "Int32", + "kind": "Zero_width" + }, + "kind": "anon", + "data_kind": { + "size": 0, + "kind": "Float" + } + } + ], + "name": "root" + }, + { + "tag": 2, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", "kind": "Int" }, "data_kind": { - "size": 4, + "size": 1, "kind": "Float" }, "kind": "named" }, { - "name": "round", "layout": { - "size": "Int32", + "kind": "Zero_width" + }, + "kind": "anon", + "data_kind": { + "size": 0, + "kind": "Float" + } + } + ], + "name": "do" + }, + { + "tag": 3, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", "kind": "Int" }, "data_kind": { - "size": 4, + "size": 1, "kind": "Float" }, "kind": "named" }, { - "name": "block_payload_hash", "layout": { - "kind": "Bytes" + "kind": "Zero_width" }, + "kind": "anon", "data_kind": { - "size": 32, + "size": 0, + "kind": "Float" + } + } + ], + "name": "set_delegate" + }, + { + "tag": 4, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" + }, + { + "layout": { + "kind": "Zero_width" + }, + "kind": "anon", + "data_kind": { + "size": 0, + "kind": "Float" + } + } + ], + "name": "remove_delegate" + }, + { + "tag": 255, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "data_kind": { + "size": 1, "kind": "Float" }, "kind": "named" + }, + { + "kind": "dyn", + "num_fields": 1, + "size": "Uint8" + }, + { + "layout": { + "kind": "String" + }, + "kind": "anon", + "data_kind": { + "kind": "Variable" + } } ], - "name": "Endorsement" + "name": "named" } ] } }, { "description": { - "title": "alpha.block_header.alpha.full_header" + "title": "alpha.contract_id" }, "encoding": { - "fields": [ - { - "name": "level", - "layout": { - "size": "Int32", - "kind": "Int" - }, - "data_kind": { - "size": 4, - "kind": "Float" - }, - "kind": "named" - }, - { - "name": "proto", - "layout": { - "size": "Uint8", - "kind": "Int" - }, - "data_kind": { - "size": 1, - "kind": "Float" - }, - "kind": "named" - }, - { - "name": "predecessor", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "size": 32, - "kind": "Float" - }, - "kind": "named" - }, - { - "name": "timestamp", - "layout": { - "size": "Int64", - "kind": "Int" - }, - "data_kind": { - "size": 8, - "kind": "Float" - }, - "kind": "named" - }, + "tag_size": "Uint8", + "kind": { + "size": 22, + "kind": "Float" + }, + "cases": [ { - "name": "validation_pass", - "layout": { - "size": "Uint8", - "kind": "Int" - }, - "data_kind": { - "size": 1, - "kind": "Float" - }, - "kind": "named" + "tag": 0, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "Signature.Public_key_hash", + "layout": { + "name": "public_key_hash", + "kind": "Ref" + }, + "data_kind": { + "size": 21, + "kind": "Float" + }, + "kind": "named" + } + ], + "name": "Implicit" }, { - "name": "operations_hash", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "size": 32, - "kind": "Float" - }, - "kind": "named" - }, + "tag": 1, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "Contract_hash", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 20, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "padding", + "layout": { + "kind": "Padding" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" + } + ], + "name": "Originated" + } + ] + } + }, + { + "description": { + "title": "alpha.scripted.contracts" + }, + "encoding": { + "fields": [ { "kind": "dyn", - "name": "fitness", "num_fields": 1, "size": "Uint30" }, { - "name": "fitness", + "name": "code", "layout": { - "layout": { - "name": "fitness.elem", - "kind": "Ref" - }, - "kind": "Seq" + "kind": "Bytes" }, "data_kind": { "kind": "Variable" @@ -7367,29 +10683,31 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "context", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "size": 32, - "kind": "Float" - }, - "kind": "named" + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" }, { - "name": "payload_hash", + "name": "storage", "layout": { "kind": "Bytes" }, "data_kind": { - "size": 32, - "kind": "Float" + "kind": "Variable" }, "kind": "named" - }, + } + ] + } + }, + { + "description": { + "title": "X_1775" + }, + "encoding": { + "fields": [ { - "name": "payload_round", + "name": "level", "layout": { "size": "Int32", "kind": "Int" @@ -7401,50 +10719,41 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "proof_of_work_nonce", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "size": 8, - "kind": "Float" - }, - "kind": "named" - }, - { - "kind": "option_indicator", - "name": "seed_nonce_hash" + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" }, { - "name": "seed_nonce_hash", + "name": "messages", "layout": { - "kind": "Bytes" + "layout": { + "kind": "Bytes" + }, + "kind": "Seq" }, "data_kind": { - "size": 32, - "kind": "Float" + "kind": "Variable" }, "kind": "named" }, { - "name": "liquidity_baking_toggle_vote", + "name": "predecessor", "layout": { - "size": "Int8", - "kind": "Int" + "name": "X_1776", + "kind": "Ref" }, "data_kind": { - "size": 1, - "kind": "Float" + "kind": "Dynamic" }, "kind": "named" }, { - "name": "signature", + "name": "inbox_merkle_root", "layout": { "kind": "Bytes" }, "data_kind": { - "size": 64, + "size": 32, "kind": "Float" }, "kind": "named" @@ -7454,36 +10763,12 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, { "description": { - "title": "fitness.elem" - }, - "encoding": { - "fields": [ - { - "kind": "dyn", - "num_fields": 1, - "size": "Uint30" - }, - { - "layout": { - "kind": "Bytes" - }, - "kind": "anon", - "data_kind": { - "kind": "Variable" - } - } - ] - } - }, - { - "description": { - "title": "public_key_hash" + "title": "X_1776" }, "encoding": { "tag_size": "Uint8", "kind": { - "size": 21, - "kind": "Float" + "kind": "Dynamic" }, "cases": [ { @@ -7502,18 +10787,17 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "Ed25519.Public_key_hash", "layout": { - "kind": "Bytes" + "kind": "Zero_width" }, + "kind": "anon", "data_kind": { - "size": 20, + "size": 0, "kind": "Float" - }, - "kind": "named" + } } ], - "name": "Ed25519" + "name": "None" }, { "tag": 1, @@ -7531,106 +10815,34 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "Secp256k1.Public_key_hash", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "size": 20, - "kind": "Float" - }, - "kind": "named" - } - ], - "name": "Secp256k1" - }, - { - "tag": 2, - "fields": [ - { - "name": "Tag", - "layout": { - "size": "Uint8", - "kind": "Int" - }, - "data_kind": { - "size": 1, - "kind": "Float" - }, - "kind": "named" - }, - { - "name": "P256.Public_key_hash", + "name": "Commitment_hash", "layout": { "kind": "Bytes" }, "data_kind": { - "size": 20, + "size": 32, "kind": "Float" }, "kind": "named" } ], - "name": "P256" - } - ] - } - }, - { - "description": { - "title": "alpha.inlined.preendorsement" - }, - "encoding": { - "fields": [ - { - "name": "branch", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "size": 32, - "kind": "Float" - }, - "kind": "named" - }, - { - "name": "operations", - "layout": { - "name": "alpha.inlined.preendorsement.contents", - "kind": "Ref" - }, - "data_kind": { - "size": 43, - "kind": "Float" - }, - "kind": "named" - }, - { - "name": "signature", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "kind": "Variable" - }, - "kind": "named" + "name": "Some" } ] } }, { "description": { - "title": "alpha.inlined.preendorsement.contents" + "title": "X_1774" }, "encoding": { "tag_size": "Uint8", "kind": { - "size": 43, - "kind": "Float" + "kind": "Dynamic" }, "cases": [ { - "tag": 20, + "tag": 0, "fields": [ { "name": "Tag", @@ -7645,90 +10857,51 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "slot", "layout": { - "size": "Uint16", + "size": "Int16", "kind": "Int" }, + "kind": "anon", "data_kind": { "size": 2, "kind": "Float" - }, - "kind": "named" + } }, { - "name": "level", "layout": { - "size": "Int32", - "kind": "Int" + "kind": "Bytes" }, + "kind": "anon", "data_kind": { - "size": 4, + "size": 32, "kind": "Float" - }, - "kind": "named" + } }, { - "name": "round", "layout": { - "size": "Int32", - "kind": "Int" + "kind": "Bytes" }, + "kind": "anon", "data_kind": { - "size": 4, + "size": 32, "kind": "Float" - }, - "kind": "named" + } }, { - "name": "block_payload_hash", "layout": { - "kind": "Bytes" + "name": "X_1650", + "kind": "Ref" }, + "kind": "anon", "data_kind": { - "size": 32, - "kind": "Float" - }, - "kind": "named" + "kind": "Dynamic" + } } ], - "name": "Preendorsement" - } - ] - } - }, - { - "description": { - "title": "Z.t", - "description": "A variable-length sequence of bytes encoding a Zarith integer. Each byte has a running unary size bit: the most significant bit of each byte indicates whether this is the last byte in the sequence (0) or whether the sequence continues (1). The second most significant bit of the first byte is reserved for the sign (0 for positive, 1 for negative). Size and sign bits ignored, the data is the binary representation of the absolute value of the number in little-endian order." - }, - "encoding": { - "fields": [ - { - "name": "Z.t", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "kind": "Dynamic" - }, - "kind": "named" - } - ] - } - }, - { - "description": { - "title": "public_key" - }, - "encoding": { - "tag_size": "Uint8", - "kind": { - "kind": "Dynamic" - }, - "cases": [ + "name": "case 0" + }, { - "tag": 0, + "tag": 1, "fields": [ { "name": "Tag", @@ -7743,21 +10916,51 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "Ed25519.Public_key", + "layout": { + "size": "Int16", + "kind": "Int" + }, + "kind": "anon", + "data_kind": { + "size": 2, + "kind": "Float" + } + }, + { "layout": { "kind": "Bytes" }, + "kind": "anon", "data_kind": { "size": 32, "kind": "Float" + } + }, + { + "layout": { + "kind": "Bytes" }, - "kind": "named" + "kind": "anon", + "data_kind": { + "size": 32, + "kind": "Float" + } + }, + { + "layout": { + "name": "X_1650", + "kind": "Ref" + }, + "kind": "anon", + "data_kind": { + "kind": "Dynamic" + } } ], - "name": "Ed25519" + "name": "case 1" }, { - "tag": 1, + "tag": 2, "fields": [ { "name": "Tag", @@ -7772,21 +10975,51 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "Secp256k1.Public_key", + "layout": { + "size": "Int16", + "kind": "Int" + }, + "kind": "anon", + "data_kind": { + "size": 2, + "kind": "Float" + } + }, + { "layout": { "kind": "Bytes" }, + "kind": "anon", "data_kind": { - "size": 33, + "size": 32, "kind": "Float" + } + }, + { + "layout": { + "kind": "Bytes" }, - "kind": "named" + "kind": "anon", + "data_kind": { + "size": 32, + "kind": "Float" + } + }, + { + "layout": { + "name": "X_1650", + "kind": "Ref" + }, + "kind": "anon", + "data_kind": { + "kind": "Dynamic" + } } ], - "name": "Secp256k1" + "name": "case 2" }, { - "tag": 2, + "tag": 3, "fields": [ { "name": "Tag", @@ -7801,80 +11034,55 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "P256.Public_key", + "layout": { + "size": "Int16", + "kind": "Int" + }, + "kind": "anon", + "data_kind": { + "size": 2, + "kind": "Float" + } + }, + { "layout": { "kind": "Bytes" }, + "kind": "anon", "data_kind": { - "size": 33, + "size": 32, "kind": "Float" + } + }, + { + "layout": { + "kind": "Bytes" }, - "kind": "named" + "kind": "anon", + "data_kind": { + "size": 32, + "kind": "Float" + } + }, + { + "layout": { + "name": "X_1650", + "kind": "Ref" + }, + "kind": "anon", + "data_kind": { + "kind": "Dynamic" + } } ], - "name": "P256" - } - ] - } - }, - { - "description": { - "title": "N.t", - "description": "A variable-length sequence of bytes encoding a Zarith natural number. Each byte has a running unary size bit: the most significant bit of each byte indicates whether this is the last byte in the sequence (0) or whether the sequence continues (1). Size bits ignored, the data is the binary representation of the number in little-endian order." - }, - "encoding": { - "fields": [ - { - "name": "N.t", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "kind": "Dynamic" - }, - "kind": "named" - } - ] - } - }, - { - "description": { - "title": "X_144" - }, - "encoding": { - "fields": [ - { - "name": "entrypoint", - "layout": { - "name": "alpha.entrypoint", - "kind": "Ref" - }, - "data_kind": { - "kind": "Dynamic" - }, - "kind": "named" - }, - { - "kind": "dyn", - "num_fields": 1, - "size": "Uint30" - }, - { - "name": "value", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "kind": "Variable" - }, - "kind": "named" + "name": "case 3" } ] } }, { "description": { - "title": "alpha.entrypoint" + "title": "X_1773" }, "encoding": { "tag_size": "Uint8", @@ -7899,7 +11107,19 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, { "layout": { - "kind": "Zero_width" + "size": "Uint8", + "kind": "Int" + }, + "kind": "anon", + "data_kind": { + "size": 1, + "kind": "Float" + } + }, + { + "layout": { + "name": "X_1772", + "kind": "Ref" }, "kind": "anon", "data_kind": { @@ -7908,7 +11128,7 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' } } ], - "name": "default" + "name": "case 0" }, { "tag": 1, @@ -7927,7 +11147,19 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, { "layout": { - "kind": "Zero_width" + "size": "Uint16", + "kind": "Int" + }, + "kind": "anon", + "data_kind": { + "size": 2, + "kind": "Float" + } + }, + { + "layout": { + "name": "X_1772", + "kind": "Ref" }, "kind": "anon", "data_kind": { @@ -7936,7 +11168,7 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' } } ], - "name": "root" + "name": "case 1" }, { "tag": 2, @@ -7955,7 +11187,19 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, { "layout": { - "kind": "Zero_width" + "size": "Int32", + "kind": "Int" + }, + "kind": "anon", + "data_kind": { + "size": 4, + "kind": "Float" + } + }, + { + "layout": { + "name": "X_1772", + "kind": "Ref" }, "kind": "anon", "data_kind": { @@ -7964,7 +11208,7 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' } } ], - "name": "do" + "name": "case 2" }, { "tag": 3, @@ -7983,35 +11227,19 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, { "layout": { - "kind": "Zero_width" + "size": "Int64", + "kind": "Int" }, "kind": "anon", "data_kind": { - "size": 0, + "size": 8, "kind": "Float" } - } - ], - "name": "set_delegate" - }, - { - "tag": 4, - "fields": [ - { - "name": "Tag", - "layout": { - "size": "Uint8", - "kind": "Int" - }, - "data_kind": { - "size": 1, - "kind": "Float" - }, - "kind": "named" }, { "layout": { - "kind": "Zero_width" + "name": "X_1772", + "kind": "Ref" }, "kind": "anon", "data_kind": { @@ -8020,10 +11248,10 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' } } ], - "name": "remove_delegate" + "name": "case 3" }, { - "tag": 255, + "tag": 4, "fields": [ { "name": "Tag", @@ -8038,38 +11266,32 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "kind": "dyn", - "num_fields": 1, - "size": "Uint8" + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "kind": "anon", + "data_kind": { + "size": 1, + "kind": "Float" + } }, { "layout": { - "kind": "String" + "name": "X_1768", + "kind": "Ref" }, "kind": "anon", "data_kind": { - "kind": "Variable" + "size": 32, + "kind": "Float" } } ], - "name": "named" - } - ] - } - }, - { - "description": { - "title": "alpha.contract_id" - }, - "encoding": { - "tag_size": "Uint8", - "kind": { - "size": 22, - "kind": "Float" - }, - "cases": [ + "name": "case 4" + }, { - "tag": 0, + "tag": 5, "fields": [ { "name": "Tag", @@ -8084,22 +11306,32 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "Signature.Public_key_hash", "layout": { - "name": "public_key_hash", - "kind": "Ref" + "size": "Uint16", + "kind": "Int" }, + "kind": "anon", "data_kind": { - "size": 21, + "size": 2, "kind": "Float" + } + }, + { + "layout": { + "name": "X_1768", + "kind": "Ref" }, - "kind": "named" + "kind": "anon", + "data_kind": { + "size": 32, + "kind": "Float" + } } ], - "name": "Implicit" + "name": "case 5" }, { - "tag": 1, + "tag": 6, "fields": [ { "name": "Tag", @@ -8114,145 +11346,32 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "Contract_hash", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "size": 20, - "kind": "Float" - }, - "kind": "named" - }, - { - "name": "padding", "layout": { - "kind": "Padding" - }, - "data_kind": { - "size": 1, - "kind": "Float" - }, - "kind": "named" - } - ], - "name": "Originated" - } - ] - } - }, - { - "description": { - "title": "alpha.scripted.contracts" - }, - "encoding": { - "fields": [ - { - "kind": "dyn", - "num_fields": 1, - "size": "Uint30" - }, - { - "name": "code", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "kind": "Variable" - }, - "kind": "named" - }, - { - "kind": "dyn", - "num_fields": 1, - "size": "Uint30" - }, - { - "name": "storage", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "kind": "Variable" - }, - "kind": "named" - } - ] - } - }, - { - "description": { - "title": "X_142" - }, - "encoding": { - "fields": [ - { - "name": "level", - "layout": { - "size": "Int32", - "kind": "Int" - }, - "data_kind": { - "size": 4, - "kind": "Float" - }, - "kind": "named" - }, - { - "kind": "dyn", - "num_fields": 1, - "size": "Uint30" - }, - { - "name": "messages", - "layout": { - "layout": { - "kind": "Bytes" - }, - "kind": "Seq" - }, - "data_kind": { - "kind": "Variable" - }, - "kind": "named" - }, - { - "name": "predecessor", - "layout": { - "name": "X_143", - "kind": "Ref" - }, - "data_kind": { - "kind": "Dynamic" - }, - "kind": "named" - }, - { - "name": "inbox_merkle_root", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "size": 32, - "kind": "Float" - }, - "kind": "named" - } - ] - } - }, - { - "description": { - "title": "X_143" - }, - "encoding": { - "tag_size": "Uint8", - "kind": { - "kind": "Dynamic" - }, - "cases": [ + "size": "Int32", + "kind": "Int" + }, + "kind": "anon", + "data_kind": { + "size": 4, + "kind": "Float" + } + }, + { + "layout": { + "name": "X_1768", + "kind": "Ref" + }, + "kind": "anon", + "data_kind": { + "size": 32, + "kind": "Float" + } + } + ], + "name": "case 6" + }, { - "tag": 0, + "tag": 7, "fields": [ { "name": "Tag", @@ -8268,19 +11387,31 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, { "layout": { - "kind": "Zero_width" + "size": "Int64", + "kind": "Int" }, "kind": "anon", "data_kind": { - "size": 0, + "size": 8, + "kind": "Float" + } + }, + { + "layout": { + "name": "X_1768", + "kind": "Ref" + }, + "kind": "anon", + "data_kind": { + "size": 32, "kind": "Float" } } ], - "name": "None" + "name": "case 7" }, { - "tag": 1, + "tag": 8, "fields": [ { "name": "Tag", @@ -8295,34 +11426,32 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "Commitment_hash", "layout": { - "kind": "Bytes" + "size": "Uint8", + "kind": "Int" + }, + "kind": "anon", + "data_kind": { + "size": 1, + "kind": "Float" + } + }, + { + "layout": { + "name": "X_1768", + "kind": "Ref" }, + "kind": "anon", "data_kind": { "size": 32, "kind": "Float" - }, - "kind": "named" + } } ], - "name": "Some" - } - ] - } - }, - { - "description": { - "title": "X_141" - }, - "encoding": { - "tag_size": "Uint8", - "kind": { - "kind": "Dynamic" - }, - "cases": [ + "name": "case 8" + }, { - "tag": 0, + "tag": 9, "fields": [ { "name": "Tag", @@ -8338,7 +11467,7 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, { "layout": { - "size": "Int16", + "size": "Uint16", "kind": "Int" }, "kind": "anon", @@ -8349,39 +11478,60 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, { "layout": { - "kind": "Bytes" + "name": "X_1768", + "kind": "Ref" }, "kind": "anon", "data_kind": { "size": 32, "kind": "Float" } + } + ], + "name": "case 9" + }, + { + "tag": 10, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" }, { "layout": { - "kind": "Bytes" + "size": "Int32", + "kind": "Int" }, "kind": "anon", "data_kind": { - "size": 32, + "size": 4, "kind": "Float" } }, { "layout": { - "name": "X_17", + "name": "X_1768", "kind": "Ref" }, "kind": "anon", "data_kind": { - "kind": "Dynamic" + "size": 32, + "kind": "Float" } } ], - "name": "case 0" + "name": "case 10" }, { - "tag": 1, + "tag": 11, "fields": [ { "name": "Tag", @@ -8397,50 +11547,71 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, { "layout": { - "size": "Int16", + "size": "Int64", "kind": "Int" }, "kind": "anon", "data_kind": { - "size": 2, + "size": 8, "kind": "Float" } }, { "layout": { - "kind": "Bytes" + "name": "X_1768", + "kind": "Ref" }, "kind": "anon", "data_kind": { "size": 32, "kind": "Float" } + } + ], + "name": "case 11" + }, + { + "tag": 12, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" }, { "layout": { - "kind": "Bytes" + "size": "Uint8", + "kind": "Int" }, "kind": "anon", "data_kind": { - "size": 32, + "size": 1, "kind": "Float" } }, { "layout": { - "name": "X_17", + "name": "X_1760", "kind": "Ref" }, "kind": "anon", "data_kind": { - "kind": "Dynamic" + "size": 64, + "kind": "Float" } } ], - "name": "case 1" + "name": "case 12" }, { - "tag": 2, + "tag": 13, "fields": [ { "name": "Tag", @@ -8456,7 +11627,7 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, { "layout": { - "size": "Int16", + "size": "Uint16", "kind": "Int" }, "kind": "anon", @@ -8467,39 +11638,60 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, { "layout": { - "kind": "Bytes" + "name": "X_1760", + "kind": "Ref" }, "kind": "anon", "data_kind": { - "size": 32, + "size": 64, "kind": "Float" } + } + ], + "name": "case 13" + }, + { + "tag": 14, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" }, { "layout": { - "kind": "Bytes" + "size": "Int32", + "kind": "Int" }, "kind": "anon", "data_kind": { - "size": 32, + "size": 4, "kind": "Float" } }, { "layout": { - "name": "X_17", + "name": "X_1760", "kind": "Ref" }, "kind": "anon", "data_kind": { - "kind": "Dynamic" + "size": 64, + "kind": "Float" } } ], - "name": "case 2" + "name": "case 14" }, { - "tag": 3, + "tag": 15, "fields": [ { "name": "Tag", @@ -8515,63 +11707,59 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, { "layout": { - "size": "Int16", + "size": "Int64", "kind": "Int" }, "kind": "anon", "data_kind": { - "size": 2, + "size": 8, "kind": "Float" } }, { "layout": { - "kind": "Bytes" + "name": "X_1760", + "kind": "Ref" }, "kind": "anon", "data_kind": { - "size": 32, + "size": 64, "kind": "Float" } - }, + } + ], + "name": "case 15" + }, + { + "tag": 128, + "fields": [ { + "name": "Tag", "layout": { - "kind": "Bytes" + "size": "Uint8", + "kind": "Int" }, - "kind": "anon", "data_kind": { - "size": 32, + "size": 1, "kind": "Float" - } + }, + "kind": "named" }, { "layout": { - "name": "X_17", - "kind": "Ref" + "kind": "Zero_width" }, "kind": "anon", "data_kind": { - "kind": "Dynamic" + "size": 0, + "kind": "Float" } } ], - "name": "case 3" - } - ] - } - }, - { - "description": { - "title": "X_140" - }, - "encoding": { - "tag_size": "Uint8", - "kind": { - "kind": "Dynamic" - }, - "cases": [ + "name": "case 128" + }, { - "tag": 0, + "tag": 129, "fields": [ { "name": "Tag", @@ -8586,32 +11774,62 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { + "layout": { + "layout": { + "name": "X_1655", + "kind": "Ref" + }, + "kind": "Seq", + "length_limit": { + "kind": "exactly", + "exactly": 1 + } + }, + "kind": "anon", + "data_kind": { + "kind": "Variable" + } + } + ], + "name": "case 129" + }, + { + "tag": 130, + "fields": [ + { + "name": "Tag", "layout": { "size": "Uint8", "kind": "Int" }, - "kind": "anon", "data_kind": { "size": 1, "kind": "Float" - } + }, + "kind": "named" }, { "layout": { - "name": "X_139", - "kind": "Ref" + "layout": { + "name": "X_1655", + "kind": "Ref" + }, + "kind": "Seq", + "length_limit": { + "kind": "exactly", + "exactly": 2 + } }, "kind": "anon", "data_kind": { - "size": 0, - "kind": "Float" + "kind": "Variable" } } ], - "name": "case 0" + "name": "case 130" }, { - "tag": 1, + "tag": 131, "fields": [ { "name": "Tag", @@ -8626,32 +11844,28 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "layout": { - "size": "Uint16", - "kind": "Int" - }, - "kind": "anon", - "data_kind": { - "size": 2, - "kind": "Float" - } + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" }, { "layout": { - "name": "X_139", - "kind": "Ref" + "layout": { + "name": "X_1655", + "kind": "Ref" + }, + "kind": "Seq" }, "kind": "anon", "data_kind": { - "size": 0, - "kind": "Float" + "kind": "Variable" } } ], - "name": "case 1" + "name": "case 131" }, { - "tag": 2, + "tag": 192, "fields": [ { "name": "Tag", @@ -8666,32 +11880,24 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "layout": { - "size": "Int32", - "kind": "Int" - }, - "kind": "anon", - "data_kind": { - "size": 4, - "kind": "Float" - } + "kind": "dyn", + "num_fields": 1, + "size": "Uint8" }, { "layout": { - "name": "X_139", - "kind": "Ref" + "kind": "Bytes" }, "kind": "anon", "data_kind": { - "size": 0, - "kind": "Float" + "kind": "Variable" } } ], - "name": "case 2" + "name": "case 192" }, { - "tag": 3, + "tag": 193, "fields": [ { "name": "Tag", @@ -8706,32 +11912,24 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "layout": { - "size": "Int64", - "kind": "Int" - }, - "kind": "anon", - "data_kind": { - "size": 8, - "kind": "Float" - } + "kind": "dyn", + "num_fields": 1, + "size": "Uint16" }, { "layout": { - "name": "X_139", - "kind": "Ref" + "kind": "Bytes" }, "kind": "anon", "data_kind": { - "size": 0, - "kind": "Float" + "kind": "Variable" } } ], - "name": "case 3" + "name": "case 193" }, { - "tag": 4, + "tag": 195, "fields": [ { "name": "Tag", @@ -8746,32 +11944,24 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "layout": { - "size": "Uint8", - "kind": "Int" - }, - "kind": "anon", - "data_kind": { - "size": 1, - "kind": "Float" - } + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" }, { "layout": { - "name": "X_135", - "kind": "Ref" + "kind": "Bytes" }, "kind": "anon", "data_kind": { - "size": 32, - "kind": "Float" + "kind": "Variable" } } ], - "name": "case 4" + "name": "case 195" }, { - "tag": 5, + "tag": 224, "fields": [ { "name": "Tag", @@ -8787,31 +11977,40 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, { "layout": { - "size": "Uint16", + "size": "Uint8", "kind": "Int" }, "kind": "anon", "data_kind": { - "size": 2, + "size": 1, "kind": "Float" } }, { "layout": { - "name": "X_135", + "name": "X_1755", "kind": "Ref" }, "kind": "anon", + "data_kind": { + "kind": "Dynamic" + } + }, + { + "layout": { + "kind": "Bytes" + }, + "kind": "anon", "data_kind": { "size": 32, "kind": "Float" } } ], - "name": "case 5" + "name": "case 224" }, { - "tag": 6, + "tag": 225, "fields": [ { "name": "Tag", @@ -8827,31 +12026,40 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, { "layout": { - "size": "Int32", + "size": "Uint16", "kind": "Int" }, "kind": "anon", "data_kind": { - "size": 4, + "size": 2, "kind": "Float" } }, { "layout": { - "name": "X_135", + "name": "X_1755", "kind": "Ref" }, "kind": "anon", + "data_kind": { + "kind": "Dynamic" + } + }, + { + "layout": { + "kind": "Bytes" + }, + "kind": "anon", "data_kind": { "size": 32, "kind": "Float" } } ], - "name": "case 6" + "name": "case 225" }, { - "tag": 7, + "tag": 226, "fields": [ { "name": "Tag", @@ -8867,31 +12075,40 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, { "layout": { - "size": "Int64", + "size": "Int32", "kind": "Int" }, "kind": "anon", "data_kind": { - "size": 8, + "size": 4, "kind": "Float" } }, { "layout": { - "name": "X_135", + "name": "X_1755", "kind": "Ref" }, "kind": "anon", + "data_kind": { + "kind": "Dynamic" + } + }, + { + "layout": { + "kind": "Bytes" + }, + "kind": "anon", "data_kind": { "size": 32, "kind": "Float" } } ], - "name": "case 7" + "name": "case 226" }, { - "tag": 8, + "tag": 227, "fields": [ { "name": "Tag", @@ -8907,31 +12124,110 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, { "layout": { - "size": "Uint8", + "size": "Int64", "kind": "Int" }, "kind": "anon", "data_kind": { - "size": 1, + "size": 8, "kind": "Float" } }, { "layout": { - "name": "X_135", + "name": "X_1755", "kind": "Ref" }, "kind": "anon", + "data_kind": { + "kind": "Dynamic" + } + }, + { + "layout": { + "kind": "Bytes" + }, + "kind": "anon", "data_kind": { "size": 32, "kind": "Float" } } ], - "name": "case 8" + "name": "case 227" + } + ] + } + }, + { + "description": { + "title": "X_1772" + }, + "encoding": { + "fields": [] + } + }, + { + "description": { + "title": "X_1768" + }, + "encoding": { + "fields": [ + { + "layout": { + "kind": "Bytes" + }, + "kind": "anon", + "data_kind": { + "size": 32, + "kind": "Float" + } + } + ] + } + }, + { + "description": { + "title": "X_1760" + }, + "encoding": { + "fields": [ + { + "layout": { + "kind": "Bytes" + }, + "kind": "anon", + "data_kind": { + "size": 32, + "kind": "Float" + } }, { - "tag": 9, + "layout": { + "kind": "Bytes" + }, + "kind": "anon", + "data_kind": { + "size": 32, + "kind": "Float" + } + } + ] + } + }, + { + "description": { + "title": "X_1756" + }, + "encoding": { + "tag_size": "Uint8", + "kind": { + "size": 33, + "kind": "Float" + }, + "cases": [ + { + "tag": 0, "fields": [ { "name": "Tag", @@ -8946,32 +12242,21 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { + "name": "Context_hash", "layout": { - "size": "Uint16", - "kind": "Int" - }, - "kind": "anon", - "data_kind": { - "size": 2, - "kind": "Float" - } - }, - { - "layout": { - "name": "X_135", - "kind": "Ref" + "kind": "Bytes" }, - "kind": "anon", "data_kind": { "size": 32, "kind": "Float" - } + }, + "kind": "named" } ], - "name": "case 9" + "name": "case 0" }, { - "tag": 10, + "tag": 1, "fields": [ { "name": "Tag", @@ -8986,32 +12271,145 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { + "name": "Context_hash", "layout": { - "size": "Int32", - "kind": "Int" - }, - "kind": "anon", - "data_kind": { - "size": 4, - "kind": "Float" - } - }, - { - "layout": { - "name": "X_135", - "kind": "Ref" + "kind": "Bytes" }, - "kind": "anon", "data_kind": { "size": 32, "kind": "Float" - } + }, + "kind": "named" } ], - "name": "case 10" + "name": "case 1" + } + ] + } + }, + { + "description": { + "title": "X_1755" + }, + "encoding": { + "fields": [ + { + "kind": "dyn", + "num_fields": 1, + "size": "Uint8" }, { - "tag": 11, + "layout": { + "kind": "Bytes" + }, + "kind": "anon", + "data_kind": { + "kind": "Variable" + } + } + ] + } + }, + { + "description": { + "title": "X_1650" + }, + "encoding": { + "fields": [ + { + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" + }, + { + "layout": { + "layout": { + "name": "X_1773", + "kind": "Ref" + }, + "kind": "Seq" + }, + "kind": "anon", + "data_kind": { + "kind": "Variable" + } + } + ] + } + }, + { + "description": { + "title": "X_1655" + }, + "encoding": { + "fields": [ + { + "layout": { + "name": "X_1755", + "kind": "Ref" + }, + "kind": "anon", + "data_kind": { + "kind": "Dynamic" + } + }, + { + "layout": { + "name": "X_1756", + "kind": "Ref" + }, + "kind": "anon", + "data_kind": { + "size": 33, + "kind": "Float" + } + } + ] + } + }, + { + "description": { + "title": "X_1649" + }, + "encoding": { + "fields": [ + { + "name": "context_hash", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 32, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "withdraw_list_hash", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 32, + "kind": "Float" + }, + "kind": "named" + } + ] + } + }, + { + "description": { + "title": "X_1648" + }, + "encoding": { + "tag_size": "Uint8", + "kind": { + "kind": "Dynamic" + }, + "cases": [ + { + "tag": 0, "fields": [ { "name": "Tag", @@ -9026,32 +12424,25 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "layout": { - "size": "Int64", - "kind": "Int" - }, - "kind": "anon", - "data_kind": { - "size": 8, - "kind": "Float" - } + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" }, { + "name": "batch", "layout": { - "name": "X_135", - "kind": "Ref" + "kind": "String" }, - "kind": "anon", "data_kind": { - "size": 32, - "kind": "Float" - } + "kind": "Variable" + }, + "kind": "named" } ], - "name": "case 11" + "name": "Batch" }, { - "tag": 12, + "tag": 1, "fields": [ { "name": "Tag", @@ -9066,32 +12457,117 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { + "name": "deposit", + "layout": { + "name": "X_1646", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" + } + ], + "name": "Deposit" + } + ] + } + }, + { + "description": { + "title": "X_1646" + }, + "encoding": { + "fields": [ + { + "name": "sender", + "layout": { + "name": "public_key_hash", + "kind": "Ref" + }, + "data_kind": { + "size": 21, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "destination", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 20, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "ticket_hash", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 32, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "amount", + "layout": { + "name": "X_1647", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" + } + ] + } + }, + { + "description": { + "title": "X_1647" + }, + "encoding": { + "tag_size": "Uint8", + "kind": { + "kind": "Dynamic" + }, + "cases": [ + { + "tag": 0, + "fields": [ + { + "name": "Tag", "layout": { "size": "Uint8", "kind": "Int" }, - "kind": "anon", "data_kind": { "size": 1, "kind": "Float" - } + }, + "kind": "named" }, { "layout": { - "name": "X_127", - "kind": "Ref" + "size": "Uint8", + "kind": "Int" }, "kind": "anon", "data_kind": { - "size": 64, + "size": 1, "kind": "Float" } } ], - "name": "case 12" + "name": "case 0" }, { - "tag": 13, + "tag": 1, "fields": [ { "name": "Tag", @@ -9115,23 +12591,12 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "size": 2, "kind": "Float" } - }, - { - "layout": { - "name": "X_127", - "kind": "Ref" - }, - "kind": "anon", - "data_kind": { - "size": 64, - "kind": "Float" - } } ], - "name": "case 13" + "name": "case 1" }, { - "tag": 14, + "tag": 2, "fields": [ { "name": "Tag", @@ -9155,23 +12620,12 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "size": 4, "kind": "Float" } - }, - { - "layout": { - "name": "X_127", - "kind": "Ref" - }, - "kind": "anon", - "data_kind": { - "size": 64, - "kind": "Float" - } } ], - "name": "case 14" + "name": "case 2" }, { - "tag": 15, + "tag": 3, "fields": [ { "name": "Tag", @@ -9195,32 +12649,109 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "size": 8, "kind": "Float" } - }, - { - "layout": { - "name": "X_127", - "kind": "Ref" - }, - "kind": "anon", - "data_kind": { - "size": 64, - "kind": "Float" - } } ], - "name": "case 15" + "name": "case 3" + } + ] + } + }, + { + "description": { + "title": "X_1644" + }, + "encoding": { + "fields": [ + { + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" }, { - "tag": 128, + "name": "contents", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "kind": "Variable" + }, + "kind": "named" + }, + { + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" + }, + { + "name": "ty", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "kind": "Variable" + }, + "kind": "named" + }, + { + "name": "ticketer", + "layout": { + "name": "alpha.contract_id", + "kind": "Ref" + }, + "data_kind": { + "size": 22, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "amount", + "layout": { + "name": "X_1647", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" + }, + { + "name": "claimer", + "layout": { + "name": "public_key_hash", + "kind": "Ref" + }, + "data_kind": { + "size": 21, + "kind": "Float" + }, + "kind": "named" + } + ] + } + }, + { + "description": { + "title": "X_1643" + }, + "encoding": { + "tag_size": "Uint16", + "kind": { + "size": 2, + "kind": "Float" + }, + "cases": [ + { + "tag": 0, "fields": [ { "name": "Tag", "layout": { - "size": "Uint8", + "size": "Uint16", "kind": "Int" }, "data_kind": { - "size": 1, + "size": 2, "kind": "Float" }, "kind": "named" @@ -9236,10 +12767,144 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' } } ], - "name": "case 128" + "name": "Example_arith smart contract rollup kind" + } + ] + } + }, + { + "description": { + "title": "X_1642" + }, + "encoding": { + "fields": [ + { + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" + }, + { + "layout": { + "kind": "String" + }, + "kind": "anon", + "data_kind": { + "kind": "Variable" + } + } + ] + } + }, + { + "description": { + "title": "X_1641" + }, + "encoding": { + "fields": [ + { + "name": "compressed_state", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 32, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "inbox_level", + "layout": { + "size": "Int32", + "kind": "Int" + }, + "data_kind": { + "size": 4, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "predecessor", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 32, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "number_of_messages", + "layout": { + "size": "Int32", + "kind": "Int" + }, + "data_kind": { + "size": 4, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "number_of_ticks", + "layout": { + "size": "Int32", + "kind": "Int" + }, + "data_kind": { + "size": 4, + "kind": "Float" + }, + "kind": "named" + } + ] + } + }, + { + "description": { + "title": "X_3" + }, + "encoding": { + "fields": [ + { + "name": "choice", + "layout": { + "name": "N.t", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" }, { - "tag": 129, + "name": "step", + "layout": { + "name": "X_1640", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" + } + ] + } + }, + { + "description": { + "title": "X_1640" + }, + "encoding": { + "tag_size": "Uint8", + "kind": { + "kind": "Dynamic" + }, + "cases": [ + { + "tag": 0, "fields": [ { "name": "Tag", @@ -9253,17 +12918,18 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, "kind": "named" }, + { + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" + }, { "layout": { "layout": { - "name": "X_22", + "name": "X_1638", "kind": "Ref" }, - "kind": "Seq", - "length_limit": { - "kind": "exactly", - "exactly": 1 - } + "kind": "Seq" }, "kind": "anon", "data_kind": { @@ -9271,10 +12937,10 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' } } ], - "name": "case 129" + "name": "Dissection" }, { - "tag": 130, + "tag": 1, "fields": [ { "name": "Tag", @@ -9289,27 +12955,74 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { + "name": "pvm_step", "layout": { - "layout": { - "name": "X_22", - "kind": "Ref" - }, - "kind": "Seq", - "length_limit": { - "kind": "exactly", - "exactly": 2 - } + "name": "X_817", + "kind": "Ref" }, - "kind": "anon", "data_kind": { - "kind": "Variable" - } + "kind": "Dynamic" + }, + "kind": "named" + }, + { + "name": "inbox", + "layout": { + "name": "X_1637", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" } ], - "name": "case 130" + "name": "Proof" + } + ] + } + }, + { + "description": { + "title": "X_1638" + }, + "encoding": { + "fields": [ + { + "layout": { + "name": "X_1639", + "kind": "Ref" + }, + "kind": "anon", + "data_kind": { + "kind": "Dynamic" + } }, { - "tag": 131, + "layout": { + "name": "N.t", + "kind": "Ref" + }, + "kind": "anon", + "data_kind": { + "kind": "Dynamic" + } + } + ] + } + }, + { + "description": { + "title": "X_1639" + }, + "encoding": { + "tag_size": "Uint8", + "kind": { + "kind": "Dynamic" + }, + "cases": [ + { + "tag": 0, "fields": [ { "name": "Tag", @@ -9323,29 +13036,21 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, "kind": "named" }, - { - "kind": "dyn", - "num_fields": 1, - "size": "Uint30" - }, { "layout": { - "layout": { - "name": "X_22", - "kind": "Ref" - }, - "kind": "Seq" + "kind": "Zero_width" }, "kind": "anon", "data_kind": { - "kind": "Variable" + "size": 0, + "kind": "Float" } } ], - "name": "case 131" + "name": "None" }, { - "tag": 192, + "tag": 1, "fields": [ { "name": "Tag", @@ -9360,24 +13065,34 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "kind": "dyn", - "num_fields": 1, - "size": "Uint8" - }, - { + "name": "state_hash", "layout": { "kind": "Bytes" }, - "kind": "anon", "data_kind": { - "kind": "Variable" - } + "size": 32, + "kind": "Float" + }, + "kind": "named" } ], - "name": "case 192" - }, + "name": "Some" + } + ] + } + }, + { + "description": { + "title": "X_1637" + }, + "encoding": { + "tag_size": "Uint8", + "kind": { + "kind": "Dynamic" + }, + "cases": [ { - "tag": 193, + "tag": 0, "fields": [ { "name": "Tag", @@ -9391,25 +13106,21 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, "kind": "named" }, - { - "kind": "dyn", - "num_fields": 1, - "size": "Uint16" - }, { "layout": { - "kind": "Bytes" + "kind": "Zero_width" }, "kind": "anon", "data_kind": { - "kind": "Variable" + "size": 0, + "kind": "Float" } } ], - "name": "case 193" + "name": "None" }, { - "tag": 195, + "tag": 1, "fields": [ { "name": "Tag", @@ -9429,117 +13140,78 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "size": "Uint30" }, { + "name": "skips", "layout": { - "kind": "Bytes" + "layout": { + "name": "X_818", + "kind": "Ref" + }, + "kind": "Seq" }, - "kind": "anon", "data_kind": { "kind": "Variable" - } - } - ], - "name": "case 195" - }, - { - "tag": 224, - "fields": [ - { - "name": "Tag", - "layout": { - "size": "Uint8", - "kind": "Int" - }, - "data_kind": { - "size": 1, - "kind": "Float" }, "kind": "named" }, { + "name": "level", "layout": { - "size": "Uint8", - "kind": "Int" - }, - "kind": "anon", - "data_kind": { - "size": 1, - "kind": "Float" - } - }, - { - "layout": { - "name": "X_122", + "name": "X_819", "kind": "Ref" }, - "kind": "anon", "data_kind": { "kind": "Dynamic" - } - }, - { - "layout": { - "kind": "Bytes" - }, - "kind": "anon", - "data_kind": { - "size": 32, - "kind": "Float" - } - } - ], - "name": "case 224" - }, - { - "tag": 225, - "fields": [ - { - "name": "Tag", - "layout": { - "size": "Uint8", - "kind": "Int" - }, - "data_kind": { - "size": 1, - "kind": "Float" }, "kind": "named" }, { - "layout": { - "size": "Uint16", - "kind": "Int" - }, - "kind": "anon", - "data_kind": { - "size": 2, - "kind": "Float" - } + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" }, { + "name": "inc", "layout": { - "name": "X_122", - "kind": "Ref" + "layout": { + "name": "X_825", + "kind": "Ref" + }, + "kind": "Seq" }, - "kind": "anon", "data_kind": { - "kind": "Dynamic" - } + "kind": "Variable" + }, + "kind": "named" }, { + "name": "message_proof", "layout": { - "kind": "Bytes" + "name": "X_4", + "kind": "Ref" }, - "kind": "anon", "data_kind": { - "size": 32, - "kind": "Float" - } + "kind": "Dynamic" + }, + "kind": "named" } ], - "name": "case 225" - }, + "name": "Some" + } + ] + } + }, + { + "description": { + "title": "X_1636" + }, + "encoding": { + "tag_size": "Uint8", + "kind": { + "kind": "Dynamic" + }, + "cases": [ { - "tag": 226, + "tag": 0, "fields": [ { "name": "Tag", @@ -9554,41 +13226,25 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "layout": { - "size": "Int32", - "kind": "Int" - }, - "kind": "anon", - "data_kind": { - "size": 4, - "kind": "Float" - } - }, - { - "layout": { - "name": "X_122", - "kind": "Ref" - }, - "kind": "anon", - "data_kind": { - "kind": "Dynamic" - } + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" }, { + "name": "value", "layout": { "kind": "Bytes" }, - "kind": "anon", "data_kind": { - "size": 32, - "kind": "Float" - } + "kind": "Variable" + }, + "kind": "named" } ], - "name": "case 226" + "name": "Value" }, { - "tag": 227, + "tag": 1, "fields": [ { "name": "Tag", @@ -9603,111 +13259,21 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "layout": { - "size": "Int64", - "kind": "Int" - }, - "kind": "anon", - "data_kind": { - "size": 8, - "kind": "Float" - } - }, - { - "layout": { - "name": "X_122", - "kind": "Ref" - }, - "kind": "anon", - "data_kind": { - "kind": "Dynamic" - } - }, - { + "name": "blinded_value", "layout": { "kind": "Bytes" }, - "kind": "anon", "data_kind": { "size": 32, "kind": "Float" - } + }, + "kind": "named" } ], - "name": "case 227" - } - ] - } - }, - { - "description": { - "title": "X_139" - }, - "encoding": { - "fields": [] - } - }, - { - "description": { - "title": "X_135" - }, - "encoding": { - "fields": [ - { - "layout": { - "kind": "Bytes" - }, - "kind": "anon", - "data_kind": { - "size": 32, - "kind": "Float" - } - } - ] - } - }, - { - "description": { - "title": "X_127" - }, - "encoding": { - "fields": [ - { - "layout": { - "kind": "Bytes" - }, - "kind": "anon", - "data_kind": { - "size": 32, - "kind": "Float" - } + "name": "Blinded_value" }, { - "layout": { - "kind": "Bytes" - }, - "kind": "anon", - "data_kind": { - "size": 32, - "kind": "Float" - } - } - ] - } - }, - { - "description": { - "title": "X_123" - }, - "encoding": { - "tag_size": "Uint8", - "kind": { - "size": 33, - "kind": "Float" - }, - "cases": [ - { - "tag": 0, + "tag": 2, "fields": [ { "name": "Tag", @@ -9722,21 +13288,29 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "Context_hash", + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" + }, + { + "name": "node", "layout": { - "kind": "Bytes" + "layout": { + "name": "X_25", + "kind": "Ref" + }, + "kind": "Seq" }, "data_kind": { - "size": 32, - "kind": "Float" + "kind": "Variable" }, "kind": "named" } ], - "name": "case 0" + "name": "Node" }, { - "tag": 1, + "tag": 3, "fields": [ { "name": "Tag", @@ -9751,7 +13325,7 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "Context_hash", + "name": "blinded_node", "layout": { "kind": "Bytes" }, @@ -9762,125 +13336,90 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" } ], - "name": "case 1" - } - ] - } - }, - { - "description": { - "title": "X_122" - }, - "encoding": { - "fields": [ - { - "kind": "dyn", - "num_fields": 1, - "size": "Uint8" - }, - { - "layout": { - "kind": "Bytes" - }, - "kind": "anon", - "data_kind": { - "kind": "Variable" - } - } - ] - } - }, - { - "description": { - "title": "X_17" - }, - "encoding": { - "fields": [ - { - "kind": "dyn", - "num_fields": 1, - "size": "Uint30" - }, - { - "layout": { - "layout": { - "name": "X_140", - "kind": "Ref" - }, - "kind": "Seq" - }, - "kind": "anon", - "data_kind": { - "kind": "Variable" - } - } - ] - } - }, - { - "description": { - "title": "X_22" - }, - "encoding": { - "fields": [ - { - "layout": { - "name": "X_122", - "kind": "Ref" - }, - "kind": "anon", - "data_kind": { - "kind": "Dynamic" - } + "name": "Blinded_node" }, { - "layout": { - "name": "X_123", - "kind": "Ref" - }, - "kind": "anon", - "data_kind": { - "size": 33, - "kind": "Float" - } - } - ] - } - }, - { - "description": { - "title": "X_16" - }, - "encoding": { - "fields": [ + "tag": 4, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "inode", + "layout": { + "name": "X_170", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" + } + ], + "name": "Inode" + }, { - "name": "context_hash", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "size": 32, - "kind": "Float" - }, - "kind": "named" + "tag": 5, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "extender", + "layout": { + "name": "X_136", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" + } + ], + "name": "Extender" }, { - "name": "withdraw_list_hash", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "size": 32, - "kind": "Float" - }, - "kind": "named" + "tag": 6, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" + } + ], + "name": "None" } ] } }, { "description": { - "title": "X_15" + "title": "X_1632" }, "encoding": { "tag_size": "Uint8", @@ -9909,9 +13448,13 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "size": "Uint30" }, { - "name": "batch", + "name": "sparse_proof", "layout": { - "kind": "String" + "layout": { + "name": "X_203", + "kind": "Ref" + }, + "kind": "Seq" }, "data_kind": { "kind": "Variable" @@ -9919,7 +13462,7 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" } ], - "name": "Batch" + "name": "sparse_proof" }, { "tag": 1, @@ -9937,10 +13480,17 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "deposit", + "name": "dense_proof", "layout": { - "name": "X_13", - "kind": "Ref" + "layout": { + "name": "X_1631", + "kind": "Ref" + }, + "kind": "Seq", + "length_limit": { + "kind": "exactly", + "exactly": 32 + } }, "data_kind": { "kind": "Dynamic" @@ -9948,68 +13498,14 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" } ], - "name": "Deposit" - } - ] - } - }, - { - "description": { - "title": "X_13" - }, - "encoding": { - "fields": [ - { - "name": "sender", - "layout": { - "name": "public_key_hash", - "kind": "Ref" - }, - "data_kind": { - "size": 21, - "kind": "Float" - }, - "kind": "named" - }, - { - "name": "destination", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "size": 20, - "kind": "Float" - }, - "kind": "named" - }, - { - "name": "ticket_hash", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "size": 32, - "kind": "Float" - }, - "kind": "named" - }, - { - "name": "amount", - "layout": { - "name": "X_14", - "kind": "Ref" - }, - "data_kind": { - "kind": "Dynamic" - }, - "kind": "named" + "name": "dense_proof" } ] } }, { "description": { - "title": "X_14" + "title": "X_1631" }, "encoding": { "tag_size": "Uint8", @@ -10033,21 +13529,58 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { + "name": "blinded_inode", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 32, + "kind": "Float" + }, + "kind": "named" + } + ], + "name": "Blinded_inode" + }, + { + "tag": 1, + "fields": [ + { + "name": "Tag", "layout": { "size": "Uint8", "kind": "Int" }, - "kind": "anon", "data_kind": { "size": 1, "kind": "Float" - } + }, + "kind": "named" + }, + { + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" + }, + { + "name": "inode_values", + "layout": { + "layout": { + "name": "X_25", + "kind": "Ref" + }, + "kind": "Seq" + }, + "data_kind": { + "kind": "Variable" + }, + "kind": "named" } ], - "name": "case 0" + "name": "Inode_values" }, { - "tag": 1, + "tag": 2, "fields": [ { "name": "Tag", @@ -10062,21 +13595,50 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { + "name": "inode_tree", "layout": { - "size": "Uint16", + "name": "X_170", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" + } + ], + "name": "Inode_tree" + }, + { + "tag": 3, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", "kind": "Int" }, - "kind": "anon", "data_kind": { - "size": 2, + "size": 1, "kind": "Float" - } + }, + "kind": "named" + }, + { + "name": "inode_extender", + "layout": { + "name": "X_136", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" } ], - "name": "case 1" + "name": "Inode_extender" }, { - "tag": 2, + "tag": 4, "fields": [ { "name": "Tag", @@ -10089,23 +13651,55 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "Float" }, "kind": "named" - }, + } + ], + "name": "None" + } + ] + } + }, + { + "description": { + "title": "X_828" + }, + "encoding": { + "tag_size": "Uint8", + "kind": { + "size": 33, + "kind": "Float" + }, + "cases": [ + { + "tag": 0, + "fields": [ { + "name": "Tag", "layout": { - "size": "Int32", + "size": "Uint8", "kind": "Int" }, - "kind": "anon", "data_kind": { - "size": 4, + "size": 1, "kind": "Float" - } + }, + "kind": "named" + }, + { + "name": "value", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 32, + "kind": "Float" + }, + "kind": "named" } ], - "name": "case 2" + "name": "Value" }, { - "tag": 3, + "tag": 1, "fields": [ { "name": "Tag", @@ -10120,40 +13714,49 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { + "name": "node", "layout": { - "size": "Int64", - "kind": "Int" + "kind": "Bytes" }, - "kind": "anon", "data_kind": { - "size": 8, + "size": 32, "kind": "Float" - } + }, + "kind": "named" } ], - "name": "case 3" + "name": "Node" } ] } }, { "description": { - "title": "X_11" + "title": "X_825" }, "encoding": { "fields": [ { - "kind": "dyn", - "num_fields": 1, - "size": "Uint30" + "name": "index", + "layout": { + "min": -1073741824, + "max": 1073741823, + "kind": "RangedInt" + }, + "data_kind": { + "size": 4, + "kind": "Float" + }, + "kind": "named" }, { - "name": "contents", + "name": "content", "layout": { "kind": "Bytes" }, "data_kind": { - "kind": "Variable" + "size": 32, + "kind": "Float" }, "kind": "named" }, @@ -10163,98 +13766,53 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "size": "Uint30" }, { - "name": "ty", + "name": "back_pointers", "layout": { - "kind": "Bytes" + "layout": { + "kind": "Bytes" + }, + "kind": "Seq" }, "data_kind": { "kind": "Variable" }, "kind": "named" - }, - { - "name": "ticketer", - "layout": { - "name": "alpha.contract_id", - "kind": "Ref" - }, - "data_kind": { - "size": 22, - "kind": "Float" - }, - "kind": "named" - }, + } + ] + } + }, + { + "description": { + "title": "X_818" + }, + "encoding": { + "fields": [ { - "name": "amount", "layout": { - "name": "X_14", + "name": "X_819", "kind": "Ref" }, + "kind": "anon", "data_kind": { "kind": "Dynamic" - }, - "kind": "named" + } }, { - "name": "claimer", "layout": { - "name": "public_key_hash", + "name": "X_821", "kind": "Ref" }, + "kind": "anon", "data_kind": { - "size": 21, - "kind": "Float" - }, - "kind": "named" - } - ] - } - }, - { - "description": { - "title": "X_10" - }, - "encoding": { - "tag_size": "Uint16", - "kind": { - "size": 2, - "kind": "Float" - }, - "cases": [ - { - "tag": 0, - "fields": [ - { - "name": "Tag", - "layout": { - "size": "Uint16", - "kind": "Int" - }, - "data_kind": { - "size": 2, - "kind": "Float" - }, - "kind": "named" - }, - { - "layout": { - "kind": "Zero_width" - }, - "kind": "anon", - "data_kind": { - "size": 0, - "kind": "Float" - } - } - ], - "name": "Example_arith smart contract rollup kind" + "kind": "Dynamic" + } } ] } }, { "description": { - "title": "X_9" + "title": "X_821" }, "encoding": { "fields": [ @@ -10265,7 +13823,11 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, { "layout": { - "kind": "String" + "layout": { + "name": "X_825", + "kind": "Ref" + }, + "kind": "Seq" }, "kind": "anon", "data_kind": { @@ -10277,46 +13839,63 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, { "description": { - "title": "X_8" + "title": "X_819" }, "encoding": { "fields": [ { - "name": "compressed_state", + "kind": "dyn", + "name": "alpha.rollup_address", + "num_fields": 1, + "size": "Uint30" + }, + { + "name": "rollup", "layout": { - "kind": "Bytes" + "kind": "String" }, "data_kind": { - "size": 32, - "kind": "Float" + "kind": "Variable" }, "kind": "named" }, { - "name": "inbox_level", + "name": "message_counter", "layout": { - "size": "Int32", + "name": "N.t", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" + }, + { + "name": "nb_available_messages", + "layout": { + "size": "Int64", "kind": "Int" }, "data_kind": { - "size": 4, + "size": 8, "kind": "Float" }, "kind": "named" }, { - "name": "predecessor", + "name": "nb_messages_in_commitment_period", "layout": { - "kind": "Bytes" + "size": "Int64", + "kind": "Int" }, "data_kind": { - "size": 32, + "size": 8, "kind": "Float" }, "kind": "named" }, { - "name": "number_of_messages", + "name": "starting_level_of_current_commitment_period", "layout": { "size": "Int32", "kind": "Int" @@ -10328,7 +13907,7 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "number_of_ticks", + "name": "level", "layout": { "size": "Int32", "kind": "Int" @@ -10338,31 +13917,22 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "Float" }, "kind": "named" - } - ] - } - }, - { - "description": { - "title": "X_3" - }, - "encoding": { - "fields": [ + }, { - "name": "choice", + "name": "current_messages_hash", "layout": { - "name": "N.t", - "kind": "Ref" + "kind": "Bytes" }, "data_kind": { - "kind": "Dynamic" + "size": 32, + "kind": "Float" }, "kind": "named" }, { - "name": "step", + "name": "old_levels_messages", "layout": { - "name": "X_7", + "name": "X_825", "kind": "Ref" }, "data_kind": { @@ -10375,7 +13945,7 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, { "description": { - "title": "X_7" + "title": "X_817" }, "encoding": { "tag_size": "Uint8", @@ -10399,89 +13969,47 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "kind": "dyn", - "num_fields": 1, - "size": "Uint30" - }, - { + "name": "tree_proof", "layout": { - "layout": { - "name": "X_5", - "kind": "Ref" - }, - "kind": "Seq" + "name": "X_4", + "kind": "Ref" }, - "kind": "anon", "data_kind": { - "kind": "Variable" - } - } - ], - "name": "Dissection" - }, - { - "tag": 1, - "fields": [ + "kind": "Dynamic" + }, + "kind": "named" + }, { - "name": "Tag", + "name": "given", "layout": { - "size": "Uint8", - "kind": "Int" + "name": "X_815", + "kind": "Ref" }, "data_kind": { - "size": 1, - "kind": "Float" + "kind": "Dynamic" }, "kind": "named" }, { + "name": "requested", "layout": { - "name": "X_4", + "name": "X_816", "kind": "Ref" }, - "kind": "anon", "data_kind": { "kind": "Dynamic" - } + }, + "kind": "named" } ], - "name": "Proof" - } - ] - } - }, - { - "description": { - "title": "X_5" - }, - "encoding": { - "fields": [ - { - "layout": { - "name": "X_6", - "kind": "Ref" - }, - "kind": "anon", - "data_kind": { - "kind": "Dynamic" - } - }, - { - "layout": { - "name": "N.t", - "kind": "Ref" - }, - "kind": "anon", - "data_kind": { - "kind": "Dynamic" - } + "name": "Arithmetic PVM with proof" } ] } }, { "description": { - "title": "X_6" + "title": "X_816" }, "encoding": { "tag_size": "Uint8", @@ -10490,7 +14018,25 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, "cases": [ { - "tag": 0, + "tag": 0, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" + } + ], + "name": "No_input_required" + }, + { + "tag": 1, "fields": [ { "name": "Tag", @@ -10503,22 +14049,12 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "Float" }, "kind": "named" - }, - { - "layout": { - "kind": "Zero_width" - }, - "kind": "anon", - "data_kind": { - "size": 0, - "kind": "Float" - } } ], - "name": "None" + "name": "Initial" }, { - "tag": 1, + "tag": 2, "fields": [ { "name": "Tag", @@ -10533,25 +14069,35 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "state_hash", "layout": { - "kind": "Bytes" + "size": "Int32", + "kind": "Int" }, + "kind": "anon", "data_kind": { - "size": 32, + "size": 4, "kind": "Float" + } + }, + { + "layout": { + "name": "N.t", + "kind": "Ref" }, - "kind": "named" + "kind": "anon", + "data_kind": { + "kind": "Dynamic" + } } ], - "name": "Some" + "name": "First_after" } ] } }, { "description": { - "title": "X_4" + "title": "X_815" }, "encoding": { "tag_size": "Uint8", @@ -10576,36 +14122,16 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, { "layout": { - "kind": "Bool" - }, - "kind": "anon", - "data_kind": { - "size": 1, - "kind": "Float" - } - }, - { - "layout": { - "kind": "Bytes" - }, - "kind": "anon", - "data_kind": { - "size": 32, - "kind": "Float" - } - }, - { - "layout": { - "kind": "Bytes" + "kind": "Zero_width" }, "kind": "anon", "data_kind": { - "size": 32, + "size": 0, "kind": "Float" } } ], - "name": "Proof of a normal computation step" + "name": "None" }, { "tag": 1, @@ -10623,75 +14149,235 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { + "name": "inbox_level", "layout": { - "kind": "Bool" + "size": "Int32", + "kind": "Int" }, - "kind": "anon", "data_kind": { - "size": 1, + "size": 4, "kind": "Float" - } - }, - { - "layout": { - "kind": "Bytes" }, - "kind": "anon", - "data_kind": { - "size": 32, - "kind": "Float" - } + "kind": "named" }, { + "name": "message_counter", "layout": { - "kind": "Bytes" - }, - "kind": "anon", - "data_kind": { - "size": 32, - "kind": "Float" - } - } - ], - "name": "Proof of an input step" - }, - { - "tag": 2, - "fields": [ - { - "name": "Tag", - "layout": { - "size": "Uint8", - "kind": "Int" + "name": "N.t", + "kind": "Ref" }, "data_kind": { - "size": 1, - "kind": "Float" + "kind": "Dynamic" }, "kind": "named" }, { - "layout": { - "kind": "Bool" - }, - "kind": "anon", - "data_kind": { - "size": 1, - "kind": "Float" - } + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" }, { + "name": "payload", "layout": { - "kind": "Bytes" + "kind": "String" }, - "kind": "anon", "data_kind": { - "size": 32, - "kind": "Float" - } + "kind": "Variable" + }, + "kind": "named" } ], - "name": "Proof that the PVM is blocked" + "name": "Some" + } + ] + } + }, + { + "description": { + "title": "X_4" + }, + "encoding": { + "fields": [ + { + "name": "version", + "layout": { + "size": "Int16", + "kind": "Int" + }, + "data_kind": { + "size": 2, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "before", + "layout": { + "name": "X_828", + "kind": "Ref" + }, + "data_kind": { + "size": 33, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "after", + "layout": { + "name": "X_828", + "kind": "Ref" + }, + "data_kind": { + "size": 33, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "state", + "layout": { + "name": "X_1636", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" + } + ] + } + }, + { + "description": { + "title": "X_170" + }, + "encoding": { + "fields": [ + { + "name": "length", + "layout": { + "size": "Int64", + "kind": "Int" + }, + "data_kind": { + "size": 8, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "proofs", + "layout": { + "name": "X_1632", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" + } + ] + } + }, + { + "description": { + "title": "X_203" + }, + "encoding": { + "fields": [ + { + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "kind": "anon", + "data_kind": { + "size": 1, + "kind": "Float" + } + }, + { + "layout": { + "name": "X_1631", + "kind": "Ref" + }, + "kind": "anon", + "data_kind": { + "kind": "Dynamic" + } + } + ] + } + }, + { + "description": { + "title": "X_136" + }, + "encoding": { + "fields": [ + { + "name": "length", + "layout": { + "size": "Int64", + "kind": "Int" + }, + "data_kind": { + "size": 8, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "segment", + "layout": { + "name": "X_1755", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" + }, + { + "name": "proof", + "layout": { + "name": "X_1631", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" + } + ] + } + }, + { + "description": { + "title": "X_25" + }, + "encoding": { + "fields": [ + { + "layout": { + "name": "X_1755", + "kind": "Ref" + }, + "kind": "anon", + "data_kind": { + "kind": "Dynamic" + } + }, + { + "layout": { + "name": "X_1636", + "kind": "Ref" + }, + "kind": "anon", + "data_kind": { + "kind": "Dynamic" + } } ] } @@ -13898,39 +17584,2055 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "$ref": "#/definitions/micheline.alpha.michelson_v1.expression" } }, - { - "title": "Prim__generic", - "description": "Generic primitive (any number of args with or without annotations)", - "type": "object", - "properties": { - "prim": { - "$ref": "#/definitions/alpha.michelson.v1.primitives" - }, - "args": { + { + "title": "Prim__generic", + "description": "Generic primitive (any number of args with or without annotations)", + "type": "object", + "properties": { + "prim": { + "$ref": "#/definitions/alpha.michelson.v1.primitives" + }, + "args": { + "type": "array", + "items": { + "$ref": "#/definitions/micheline.alpha.michelson_v1.expression" + } + }, + "annots": { + "type": "array", + "items": { + "type": "string" + } + } + }, + "required": [ + "prim" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "parameters_ty", + "boot_sector", + "kind", + "storage_limit", + "gas_limit", + "counter", + "fee", + "source", + "kind" + ], + "additionalProperties": false + }, + { + "title": "Sc_rollup_add_messages", + "type": "object", + "properties": { + "kind": { + "type": "string", + "enum": [ + "sc_rollup_add_messages" + ] + }, + "source": { + "$ref": "#/definitions/Signature.Public_key_hash" + }, + "fee": { + "$ref": "#/definitions/alpha.mutez" + }, + "counter": { + "$ref": "#/definitions/positive_bignum" + }, + "gas_limit": { + "$ref": "#/definitions/positive_bignum" + }, + "storage_limit": { + "$ref": "#/definitions/positive_bignum" + }, + "rollup": { + "$ref": "#/definitions/alpha.rollup_address" + }, + "message": { + "type": "array", + "items": { + "$ref": "#/definitions/unistring" + } + } + }, + "required": [ + "message", + "rollup", + "storage_limit", + "gas_limit", + "counter", + "fee", + "source", + "kind" + ], + "additionalProperties": false + }, + { + "title": "Sc_rollup_cement", + "type": "object", + "properties": { + "kind": { + "type": "string", + "enum": [ + "sc_rollup_cement" + ] + }, + "source": { + "$ref": "#/definitions/Signature.Public_key_hash" + }, + "fee": { + "$ref": "#/definitions/alpha.mutez" + }, + "counter": { + "$ref": "#/definitions/positive_bignum" + }, + "gas_limit": { + "$ref": "#/definitions/positive_bignum" + }, + "storage_limit": { + "$ref": "#/definitions/positive_bignum" + }, + "rollup": { + "$ref": "#/definitions/alpha.rollup_address" + }, + "commitment": { + "$ref": "#/definitions/commitment_hash" + } + }, + "required": [ + "commitment", + "rollup", + "storage_limit", + "gas_limit", + "counter", + "fee", + "source", + "kind" + ], + "additionalProperties": false + }, + { + "title": "Sc_rollup_publish", + "type": "object", + "properties": { + "kind": { + "type": "string", + "enum": [ + "sc_rollup_publish" + ] + }, + "source": { + "$ref": "#/definitions/Signature.Public_key_hash" + }, + "fee": { + "$ref": "#/definitions/alpha.mutez" + }, + "counter": { + "$ref": "#/definitions/positive_bignum" + }, + "gas_limit": { + "$ref": "#/definitions/positive_bignum" + }, + "storage_limit": { + "$ref": "#/definitions/positive_bignum" + }, + "rollup": { + "$ref": "#/definitions/alpha.rollup_address" + }, + "commitment": { + "type": "object", + "properties": { + "compressed_state": { + "$ref": "#/definitions/state_hash" + }, + "inbox_level": { + "type": "integer", + "minimum": -2147483648, + "maximum": 2147483647 + }, + "predecessor": { + "$ref": "#/definitions/commitment_hash" + }, + "number_of_messages": { + "type": "integer", + "minimum": -2147483648, + "maximum": 2147483647 + }, + "number_of_ticks": { + "type": "integer", + "minimum": -2147483648, + "maximum": 2147483647 + } + }, + "required": [ + "number_of_ticks", + "number_of_messages", + "predecessor", + "inbox_level", + "compressed_state" + ], + "additionalProperties": false + } + }, + "required": [ + "commitment", + "rollup", + "storage_limit", + "gas_limit", + "counter", + "fee", + "source", + "kind" + ], + "additionalProperties": false + }, + { + "title": "Sc_rollup_refute", + "type": "object", + "properties": { + "kind": { + "type": "string", + "enum": [ + "sc_rollup_refute" + ] + }, + "source": { + "$ref": "#/definitions/Signature.Public_key_hash" + }, + "fee": { + "$ref": "#/definitions/alpha.mutez" + }, + "counter": { + "$ref": "#/definitions/positive_bignum" + }, + "gas_limit": { + "$ref": "#/definitions/positive_bignum" + }, + "storage_limit": { + "$ref": "#/definitions/positive_bignum" + }, + "rollup": { + "$ref": "#/definitions/alpha.rollup_address" + }, + "opponent": { + "$ref": "#/definitions/Signature.Public_key_hash" + }, + "refutation": { + "type": "object", + "properties": { + "choice": { + "$ref": "#/definitions/positive_bignum" + }, + "step": { + "oneOf": [ + { + "title": "Dissection", "type": "array", "items": { - "$ref": "#/definitions/micheline.alpha.michelson_v1.expression" + "type": "array", + "items": [ + { + "oneOf": [ + { + "title": "Some", + "$ref": "#/definitions/state_hash" + }, + { + "title": "None", + "type": "null" + } + ] + }, + { + "$ref": "#/definitions/positive_bignum" + } + ], + "additionalItems": false } }, - "annots": { - "type": "array", - "items": { - "type": "string" - } + { + "title": "Proof", + "type": "object", + "properties": { + "pvm_step": { + "oneOf": [ + { + "title": "Arithmetic PVM with proof", + "type": "object", + "properties": { + "tree_proof": { + "type": "object", + "properties": { + "version": { + "type": "integer", + "minimum": -32768, + "maximum": 32767 + }, + "before": { + "oneOf": [ + { + "title": "Value", + "type": "object", + "properties": { + "value": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "value" + ], + "additionalProperties": false + }, + { + "title": "Node", + "type": "object", + "properties": { + "node": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "node" + ], + "additionalProperties": false + } + ] + }, + "after": { + "oneOf": [ + { + "title": "Value", + "type": "object", + "properties": { + "value": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "value" + ], + "additionalProperties": false + }, + { + "title": "Node", + "type": "object", + "properties": { + "node": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "node" + ], + "additionalProperties": false + } + ] + }, + "state": { + "oneOf": [ + { + "title": "Value", + "type": "object", + "properties": { + "value": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + } + }, + "required": [ + "value" + ], + "additionalProperties": false + }, + { + "title": "Blinded_value", + "type": "object", + "properties": { + "blinded_value": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_value" + ], + "additionalProperties": false + }, + { + "title": "Node", + "type": "object", + "properties": { + "node": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + { + "$ref": "#/definitions/tree_encoding" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "node" + ], + "additionalProperties": false + }, + { + "title": "Blinded_node", + "type": "object", + "properties": { + "blinded_node": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_node" + ], + "additionalProperties": false + }, + { + "title": "Inode", + "type": "object", + "properties": { + "inode": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "proofs": { + "oneOf": [ + { + "title": "sparse_proof", + "type": "object", + "properties": { + "sparse_proof": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "integer", + "minimum": 0, + "maximum": 255 + }, + { + "oneOf": [ + { + "title": "Blinded_inode", + "type": "object", + "properties": { + "blinded_inode": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_inode" + ], + "additionalProperties": false + }, + { + "title": "Inode_values", + "type": "object", + "properties": { + "inode_values": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + { + "$ref": "#/definitions/tree_encoding" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "inode_values" + ], + "additionalProperties": false + }, + { + "title": "Inode_tree", + "type": "object", + "properties": { + "inode_tree": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "proofs": { + "oneOf": [ + { + "title": "sparse_proof", + "type": "object", + "properties": { + "sparse_proof": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "integer", + "minimum": 0, + "maximum": 255 + }, + { + "$ref": "#/definitions/inode_tree" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "sparse_proof" + ], + "additionalProperties": false + }, + { + "title": "dense_proof", + "type": "object", + "properties": { + "dense_proof": { + "type": "array", + "items": { + "$ref": "#/definitions/inode_tree" + } + } + }, + "required": [ + "dense_proof" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proofs", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_tree" + ], + "additionalProperties": false + }, + { + "title": "Inode_extender", + "type": "object", + "properties": { + "inode_extender": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "segment": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + "proof": { + "$ref": "#/definitions/inode_tree" + } + }, + "required": [ + "proof", + "segment", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_extender" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "object", + "properties": { + "none": { + "type": "null" + } + }, + "required": [ + "none" + ], + "additionalProperties": false + } + ] + } + ], + "additionalItems": false + } + } + }, + "required": [ + "sparse_proof" + ], + "additionalProperties": false + }, + { + "title": "dense_proof", + "type": "object", + "properties": { + "dense_proof": { + "type": "array", + "items": { + "oneOf": [ + { + "title": "Blinded_inode", + "type": "object", + "properties": { + "blinded_inode": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_inode" + ], + "additionalProperties": false + }, + { + "title": "Inode_values", + "type": "object", + "properties": { + "inode_values": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + { + "$ref": "#/definitions/tree_encoding" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "inode_values" + ], + "additionalProperties": false + }, + { + "title": "Inode_tree", + "type": "object", + "properties": { + "inode_tree": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "proofs": { + "oneOf": [ + { + "title": "sparse_proof", + "type": "object", + "properties": { + "sparse_proof": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "integer", + "minimum": 0, + "maximum": 255 + }, + { + "$ref": "#/definitions/inode_tree" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "sparse_proof" + ], + "additionalProperties": false + }, + { + "title": "dense_proof", + "type": "object", + "properties": { + "dense_proof": { + "type": "array", + "items": { + "$ref": "#/definitions/inode_tree" + } + } + }, + "required": [ + "dense_proof" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proofs", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_tree" + ], + "additionalProperties": false + }, + { + "title": "Inode_extender", + "type": "object", + "properties": { + "inode_extender": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "segment": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + "proof": { + "$ref": "#/definitions/inode_tree" + } + }, + "required": [ + "proof", + "segment", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_extender" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "object", + "properties": { + "none": { + "type": "null" + } + }, + "required": [ + "none" + ], + "additionalProperties": false + } + ] + } + } + }, + "required": [ + "dense_proof" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proofs", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode" + ], + "additionalProperties": false + }, + { + "title": "Extender", + "type": "object", + "properties": { + "extender": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "segment": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + "proof": { + "oneOf": [ + { + "title": "Blinded_inode", + "type": "object", + "properties": { + "blinded_inode": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_inode" + ], + "additionalProperties": false + }, + { + "title": "Inode_values", + "type": "object", + "properties": { + "inode_values": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + { + "$ref": "#/definitions/tree_encoding" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "inode_values" + ], + "additionalProperties": false + }, + { + "title": "Inode_tree", + "type": "object", + "properties": { + "inode_tree": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "proofs": { + "oneOf": [ + { + "title": "sparse_proof", + "type": "object", + "properties": { + "sparse_proof": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "integer", + "minimum": 0, + "maximum": 255 + }, + { + "$ref": "#/definitions/inode_tree" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "sparse_proof" + ], + "additionalProperties": false + }, + { + "title": "dense_proof", + "type": "object", + "properties": { + "dense_proof": { + "type": "array", + "items": { + "$ref": "#/definitions/inode_tree" + } + } + }, + "required": [ + "dense_proof" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proofs", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_tree" + ], + "additionalProperties": false + }, + { + "title": "Inode_extender", + "type": "object", + "properties": { + "inode_extender": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "segment": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + "proof": { + "$ref": "#/definitions/inode_tree" + } + }, + "required": [ + "proof", + "segment", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_extender" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "object", + "properties": { + "none": { + "type": "null" + } + }, + "required": [ + "none" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proof", + "segment", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "extender" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "object", + "properties": { + "none": { + "type": "null" + } + }, + "required": [ + "none" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "state", + "after", + "before", + "version" + ], + "additionalProperties": false + }, + "given": { + "oneOf": [ + { + "title": "Some", + "type": "object", + "properties": { + "inbox_level": { + "type": "integer", + "minimum": -2147483648, + "maximum": 2147483647 + }, + "message_counter": { + "$ref": "#/definitions/positive_bignum" + }, + "payload": { + "$ref": "#/definitions/unistring" + } + }, + "required": [ + "payload", + "message_counter", + "inbox_level" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "null" + } + ] + }, + "requested": { + "oneOf": [ + { + "title": "No_input_required", + "type": "object", + "properties": { + "no_input_required": {} + }, + "required": [ + "no_input_required" + ], + "additionalProperties": false + }, + { + "title": "Initial", + "type": "object", + "properties": { + "initial": {} + }, + "required": [ + "initial" + ], + "additionalProperties": false + }, + { + "title": "First_after", + "type": "array", + "items": [ + { + "type": "integer", + "minimum": -2147483648, + "maximum": 2147483647 + }, + { + "$ref": "#/definitions/positive_bignum" + } + ], + "additionalItems": false + } + ] + } + }, + "required": [ + "requested", + "given", + "tree_proof" + ], + "additionalProperties": false + } + ] + }, + "inbox": { + "oneOf": [ + { + "title": "Some", + "type": "object", + "properties": { + "skips": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "object", + "properties": { + "rollup": { + "$ref": "#/definitions/alpha.rollup_address" + }, + "message_counter": { + "$ref": "#/definitions/positive_bignum" + }, + "nb_available_messages": { + "$ref": "#/definitions/int64" + }, + "nb_messages_in_commitment_period": { + "$ref": "#/definitions/int64" + }, + "starting_level_of_current_commitment_period": { + "type": "integer", + "minimum": -2147483648, + "maximum": 2147483647 + }, + "level": { + "type": "integer", + "minimum": -2147483648, + "maximum": 2147483647 + }, + "current_messages_hash": { + "$ref": "#/definitions/inbox_hash" + }, + "old_levels_messages": { + "type": "object", + "properties": { + "index": { + "type": "integer", + "minimum": -1073741824, + "maximum": 1073741823 + }, + "content": { + "$ref": "#/definitions/inbox_hash" + }, + "back_pointers": { + "type": "array", + "items": { + "$ref": "#/definitions/inbox_hash" + } + } + }, + "required": [ + "back_pointers", + "content", + "index" + ], + "additionalProperties": false + } + }, + "required": [ + "old_levels_messages", + "current_messages_hash", + "level", + "starting_level_of_current_commitment_period", + "nb_messages_in_commitment_period", + "nb_available_messages", + "message_counter", + "rollup" + ], + "additionalProperties": false + }, + { + "type": "array", + "items": { + "type": "object", + "properties": { + "index": { + "type": "integer", + "minimum": -1073741824, + "maximum": 1073741823 + }, + "content": { + "$ref": "#/definitions/inbox_hash" + }, + "back_pointers": { + "type": "array", + "items": { + "$ref": "#/definitions/inbox_hash" + } + } + }, + "required": [ + "back_pointers", + "content", + "index" + ], + "additionalProperties": false + } + } + ], + "additionalItems": false + } + }, + "level": { + "type": "object", + "properties": { + "rollup": { + "$ref": "#/definitions/alpha.rollup_address" + }, + "message_counter": { + "$ref": "#/definitions/positive_bignum" + }, + "nb_available_messages": { + "$ref": "#/definitions/int64" + }, + "nb_messages_in_commitment_period": { + "$ref": "#/definitions/int64" + }, + "starting_level_of_current_commitment_period": { + "type": "integer", + "minimum": -2147483648, + "maximum": 2147483647 + }, + "level": { + "type": "integer", + "minimum": -2147483648, + "maximum": 2147483647 + }, + "current_messages_hash": { + "$ref": "#/definitions/inbox_hash" + }, + "old_levels_messages": { + "type": "object", + "properties": { + "index": { + "type": "integer", + "minimum": -1073741824, + "maximum": 1073741823 + }, + "content": { + "$ref": "#/definitions/inbox_hash" + }, + "back_pointers": { + "type": "array", + "items": { + "$ref": "#/definitions/inbox_hash" + } + } + }, + "required": [ + "back_pointers", + "content", + "index" + ], + "additionalProperties": false + } + }, + "required": [ + "old_levels_messages", + "current_messages_hash", + "level", + "starting_level_of_current_commitment_period", + "nb_messages_in_commitment_period", + "nb_available_messages", + "message_counter", + "rollup" + ], + "additionalProperties": false + }, + "inc": { + "type": "array", + "items": { + "type": "object", + "properties": { + "index": { + "type": "integer", + "minimum": -1073741824, + "maximum": 1073741823 + }, + "content": { + "$ref": "#/definitions/inbox_hash" + }, + "back_pointers": { + "type": "array", + "items": { + "$ref": "#/definitions/inbox_hash" + } + } + }, + "required": [ + "back_pointers", + "content", + "index" + ], + "additionalProperties": false + } + }, + "message_proof": { + "type": "object", + "properties": { + "version": { + "type": "integer", + "minimum": -32768, + "maximum": 32767 + }, + "before": { + "oneOf": [ + { + "title": "Value", + "type": "object", + "properties": { + "value": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "value" + ], + "additionalProperties": false + }, + { + "title": "Node", + "type": "object", + "properties": { + "node": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "node" + ], + "additionalProperties": false + } + ] + }, + "after": { + "oneOf": [ + { + "title": "Value", + "type": "object", + "properties": { + "value": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "value" + ], + "additionalProperties": false + }, + { + "title": "Node", + "type": "object", + "properties": { + "node": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "node" + ], + "additionalProperties": false + } + ] + }, + "state": { + "oneOf": [ + { + "title": "Value", + "type": "object", + "properties": { + "value": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + } + }, + "required": [ + "value" + ], + "additionalProperties": false + }, + { + "title": "Blinded_value", + "type": "object", + "properties": { + "blinded_value": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_value" + ], + "additionalProperties": false + }, + { + "title": "Node", + "type": "object", + "properties": { + "node": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + { + "$ref": "#/definitions/tree_encoding" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "node" + ], + "additionalProperties": false + }, + { + "title": "Blinded_node", + "type": "object", + "properties": { + "blinded_node": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_node" + ], + "additionalProperties": false + }, + { + "title": "Inode", + "type": "object", + "properties": { + "inode": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "proofs": { + "oneOf": [ + { + "title": "sparse_proof", + "type": "object", + "properties": { + "sparse_proof": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "integer", + "minimum": 0, + "maximum": 255 + }, + { + "oneOf": [ + { + "title": "Blinded_inode", + "type": "object", + "properties": { + "blinded_inode": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_inode" + ], + "additionalProperties": false + }, + { + "title": "Inode_values", + "type": "object", + "properties": { + "inode_values": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + { + "$ref": "#/definitions/tree_encoding" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "inode_values" + ], + "additionalProperties": false + }, + { + "title": "Inode_tree", + "type": "object", + "properties": { + "inode_tree": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "proofs": { + "oneOf": [ + { + "title": "sparse_proof", + "type": "object", + "properties": { + "sparse_proof": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "integer", + "minimum": 0, + "maximum": 255 + }, + { + "$ref": "#/definitions/inode_tree" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "sparse_proof" + ], + "additionalProperties": false + }, + { + "title": "dense_proof", + "type": "object", + "properties": { + "dense_proof": { + "type": "array", + "items": { + "$ref": "#/definitions/inode_tree" + } + } + }, + "required": [ + "dense_proof" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proofs", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_tree" + ], + "additionalProperties": false + }, + { + "title": "Inode_extender", + "type": "object", + "properties": { + "inode_extender": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "segment": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + "proof": { + "$ref": "#/definitions/inode_tree" + } + }, + "required": [ + "proof", + "segment", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_extender" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "object", + "properties": { + "none": { + "type": "null" + } + }, + "required": [ + "none" + ], + "additionalProperties": false + } + ] + } + ], + "additionalItems": false + } + } + }, + "required": [ + "sparse_proof" + ], + "additionalProperties": false + }, + { + "title": "dense_proof", + "type": "object", + "properties": { + "dense_proof": { + "type": "array", + "items": { + "oneOf": [ + { + "title": "Blinded_inode", + "type": "object", + "properties": { + "blinded_inode": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_inode" + ], + "additionalProperties": false + }, + { + "title": "Inode_values", + "type": "object", + "properties": { + "inode_values": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + { + "$ref": "#/definitions/tree_encoding" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "inode_values" + ], + "additionalProperties": false + }, + { + "title": "Inode_tree", + "type": "object", + "properties": { + "inode_tree": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "proofs": { + "oneOf": [ + { + "title": "sparse_proof", + "type": "object", + "properties": { + "sparse_proof": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "integer", + "minimum": 0, + "maximum": 255 + }, + { + "$ref": "#/definitions/inode_tree" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "sparse_proof" + ], + "additionalProperties": false + }, + { + "title": "dense_proof", + "type": "object", + "properties": { + "dense_proof": { + "type": "array", + "items": { + "$ref": "#/definitions/inode_tree" + } + } + }, + "required": [ + "dense_proof" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proofs", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_tree" + ], + "additionalProperties": false + }, + { + "title": "Inode_extender", + "type": "object", + "properties": { + "inode_extender": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "segment": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + "proof": { + "$ref": "#/definitions/inode_tree" + } + }, + "required": [ + "proof", + "segment", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_extender" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "object", + "properties": { + "none": { + "type": "null" + } + }, + "required": [ + "none" + ], + "additionalProperties": false + } + ] + } + } + }, + "required": [ + "dense_proof" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proofs", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode" + ], + "additionalProperties": false + }, + { + "title": "Extender", + "type": "object", + "properties": { + "extender": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "segment": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + "proof": { + "oneOf": [ + { + "title": "Blinded_inode", + "type": "object", + "properties": { + "blinded_inode": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_inode" + ], + "additionalProperties": false + }, + { + "title": "Inode_values", + "type": "object", + "properties": { + "inode_values": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + { + "$ref": "#/definitions/tree_encoding" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "inode_values" + ], + "additionalProperties": false + }, + { + "title": "Inode_tree", + "type": "object", + "properties": { + "inode_tree": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "proofs": { + "oneOf": [ + { + "title": "sparse_proof", + "type": "object", + "properties": { + "sparse_proof": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "integer", + "minimum": 0, + "maximum": 255 + }, + { + "$ref": "#/definitions/inode_tree" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "sparse_proof" + ], + "additionalProperties": false + }, + { + "title": "dense_proof", + "type": "object", + "properties": { + "dense_proof": { + "type": "array", + "items": { + "$ref": "#/definitions/inode_tree" + } + } + }, + "required": [ + "dense_proof" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proofs", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_tree" + ], + "additionalProperties": false + }, + { + "title": "Inode_extender", + "type": "object", + "properties": { + "inode_extender": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "segment": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + "proof": { + "$ref": "#/definitions/inode_tree" + } + }, + "required": [ + "proof", + "segment", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_extender" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "object", + "properties": { + "none": { + "type": "null" + } + }, + "required": [ + "none" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proof", + "segment", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "extender" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "object", + "properties": { + "none": { + "type": "null" + } + }, + "required": [ + "none" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "state", + "after", + "before", + "version" + ], + "additionalProperties": false + } + }, + "required": [ + "message_proof", + "inc", + "level", + "skips" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "null" + } + ] + } + }, + "required": [ + "inbox", + "pvm_step" + ], + "additionalProperties": false } - }, - "required": [ - "prim" - ], - "additionalProperties": false + ] } - ] + }, + "required": [ + "step", + "choice" + ], + "additionalProperties": false } }, - "required": [ - "parameters_ty", - "boot_sector", - "kind", + "required": [ + "refutation", + "opponent", + "rollup", "storage_limit", "gas_limit", "counter", @@ -13941,13 +19643,13 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "additionalProperties": false }, { - "title": "Sc_rollup_add_messages", + "title": "Sc_rollup_timeout", "type": "object", "properties": { "kind": { "type": "string", "enum": [ - "sc_rollup_add_messages" + "sc_rollup_timeout" ] }, "source": { @@ -13968,15 +19670,21 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "rollup": { "$ref": "#/definitions/alpha.rollup_address" }, - "message": { + "stakers": { "type": "array", - "items": { - "$ref": "#/definitions/unistring" - } + "items": [ + { + "$ref": "#/definitions/Signature.Public_key_hash" + }, + { + "$ref": "#/definitions/Signature.Public_key_hash" + } + ], + "additionalItems": false } }, "required": [ - "message", + "stakers", "rollup", "storage_limit", "gas_limit", @@ -13988,13 +19696,13 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "additionalProperties": false }, { - "title": "Sc_rollup_cement", + "title": "Sc_rollup_atomic_batch", "type": "object", "properties": { "kind": { "type": "string", "enum": [ - "sc_rollup_cement" + "sc_rollup_atomic_batch" ] }, "source": { @@ -14015,686 +19723,1184 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "rollup": { "$ref": "#/definitions/alpha.rollup_address" }, - "commitment": { + "cemented_commitment": { "$ref": "#/definitions/commitment_hash" + }, + "outbox_level": { + "type": "integer", + "minimum": -2147483648, + "maximum": 2147483647 + }, + "message_index": { + "type": "integer", + "minimum": -1073741824, + "maximum": 1073741823 + }, + "inclusion proof": { + "$ref": "#/definitions/unistring" + }, + "atomic_transaction_batch": { + "$ref": "#/definitions/unistring" + } + }, + "required": [ + "atomic_transaction_batch", + "inclusion proof", + "message_index", + "outbox_level", + "cemented_commitment", + "rollup", + "storage_limit", + "gas_limit", + "counter", + "fee", + "source", + "kind" + ], + "additionalProperties": false + } + ] + }, + "alpha.rollup_address": { + "title": "A smart contract rollup address", + "description": "A smart contract rollup is identified by a base58 address starting with scr1", + "$ref": "#/definitions/unistring" + }, + "alpha.scripted.contracts": { + "type": "object", + "properties": { + "code": { + "oneOf": [ + { + "title": "Int", + "type": "object", + "properties": { + "int": { + "$ref": "#/definitions/bignum" + } + }, + "required": [ + "int" + ], + "additionalProperties": false + }, + { + "title": "String", + "type": "object", + "properties": { + "string": { + "$ref": "#/definitions/unistring" + } + }, + "required": [ + "string" + ], + "additionalProperties": false + }, + { + "title": "Bytes", + "type": "object", + "properties": { + "bytes": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + } + }, + "required": [ + "bytes" + ], + "additionalProperties": false + }, + { + "title": "Sequence", + "type": "array", + "items": { + "$ref": "#/definitions/micheline.alpha.michelson_v1.expression" + } + }, + { + "title": "Prim__generic", + "description": "Generic primitive (any number of args with or without annotations)", + "type": "object", + "properties": { + "prim": { + "$ref": "#/definitions/alpha.michelson.v1.primitives" + }, + "args": { + "type": "array", + "items": { + "$ref": "#/definitions/micheline.alpha.michelson_v1.expression" + } + }, + "annots": { + "type": "array", + "items": { + "type": "string" + } + } + }, + "required": [ + "prim" + ], + "additionalProperties": false + } + ] + }, + "storage": { + "oneOf": [ + { + "title": "Int", + "type": "object", + "properties": { + "int": { + "$ref": "#/definitions/bignum" + } + }, + "required": [ + "int" + ], + "additionalProperties": false + }, + { + "title": "String", + "type": "object", + "properties": { + "string": { + "$ref": "#/definitions/unistring" + } + }, + "required": [ + "string" + ], + "additionalProperties": false + }, + { + "title": "Bytes", + "type": "object", + "properties": { + "bytes": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + } + }, + "required": [ + "bytes" + ], + "additionalProperties": false + }, + { + "title": "Sequence", + "type": "array", + "items": { + "$ref": "#/definitions/micheline.alpha.michelson_v1.expression" + } + }, + { + "title": "Prim__generic", + "description": "Generic primitive (any number of args with or without annotations)", + "type": "object", + "properties": { + "prim": { + "$ref": "#/definitions/alpha.michelson.v1.primitives" + }, + "args": { + "type": "array", + "items": { + "$ref": "#/definitions/micheline.alpha.michelson_v1.expression" + } + }, + "annots": { + "type": "array", + "items": { + "type": "string" + } + } + }, + "required": [ + "prim" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "storage", + "code" + ], + "additionalProperties": false + }, + "alpha.tx_rollup_id": { + "title": "A tx rollup handle", + "description": "A tx rollup notation as given to an RPC or inside scripts, is a base58 tx rollup hash", + "$ref": "#/definitions/unistring" + }, + "bignum": { + "title": "Big number", + "description": "Decimal representation of a big number", + "type": "string" + }, + "block_hash": { + "title": "A block identifier (Base58Check-encoded)", + "$ref": "#/definitions/unistring" + }, + "commitment_hash": { + "title": "The hash of a commitment of a smart contract rollup (Base58Check-encoded)", + "$ref": "#/definitions/unistring" + }, + "cycle_nonce": { + "title": "A nonce hash (Base58Check-encoded)", + "$ref": "#/definitions/unistring" + }, + "error": { + "description": "The full list of errors is available with the global RPC `GET errors`" + }, + "fitness": { + "title": "Block fitness", + "description": "The fitness, or score, of a block, that allow the Tezos to decide which chain is the best. A fitness value is a list of byte sequences. They are compared as follows: shortest lists are smaller; lists of the same length are compared according to the lexicographical order.", + "type": "array", + "items": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + } + }, + "inbox_hash": { + "title": "The hash of an inbox of a smart contract rollup (Base58Check-encoded)", + "$ref": "#/definitions/unistring" + }, + "inode_tree": { + "oneOf": [ + { + "title": "Blinded_inode", + "type": "object", + "properties": { + "blinded_inode": { + "$ref": "#/definitions/Context_hash" } }, "required": [ - "commitment", - "rollup", - "storage_limit", - "gas_limit", - "counter", - "fee", - "source", - "kind" + "blinded_inode" ], "additionalProperties": false }, { - "title": "Sc_rollup_publish", + "title": "Inode_values", "type": "object", "properties": { - "kind": { - "type": "string", - "enum": [ - "sc_rollup_publish" - ] - }, - "source": { - "$ref": "#/definitions/Signature.Public_key_hash" - }, - "fee": { - "$ref": "#/definitions/alpha.mutez" - }, - "counter": { - "$ref": "#/definitions/positive_bignum" - }, - "gas_limit": { - "$ref": "#/definitions/positive_bignum" - }, - "storage_limit": { - "$ref": "#/definitions/positive_bignum" - }, - "rollup": { - "$ref": "#/definitions/alpha.rollup_address" - }, - "commitment": { - "type": "object", - "properties": { - "compressed_state": { - "$ref": "#/definitions/state_hash" - }, - "inbox_level": { - "type": "integer", - "minimum": -2147483648, - "maximum": 2147483647 - }, - "predecessor": { - "$ref": "#/definitions/commitment_hash" - }, - "number_of_messages": { - "type": "integer", - "minimum": -2147483648, - "maximum": 2147483647 - }, - "number_of_ticks": { - "type": "integer", - "minimum": -2147483648, - "maximum": 2147483647 - } - }, - "required": [ - "number_of_ticks", - "number_of_messages", - "predecessor", - "inbox_level", - "compressed_state" - ], - "additionalProperties": false + "inode_values": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + { + "$ref": "#/definitions/tree_encoding" + } + ], + "additionalItems": false + } } }, "required": [ - "commitment", - "rollup", - "storage_limit", - "gas_limit", - "counter", - "fee", - "source", - "kind" + "inode_values" ], "additionalProperties": false }, { - "title": "Sc_rollup_refute", + "title": "Inode_tree", "type": "object", "properties": { - "kind": { - "type": "string", - "enum": [ - "sc_rollup_refute" - ] - }, - "source": { - "$ref": "#/definitions/Signature.Public_key_hash" - }, - "fee": { - "$ref": "#/definitions/alpha.mutez" - }, - "counter": { - "$ref": "#/definitions/positive_bignum" - }, - "gas_limit": { - "$ref": "#/definitions/positive_bignum" - }, - "storage_limit": { - "$ref": "#/definitions/positive_bignum" - }, - "rollup": { - "$ref": "#/definitions/alpha.rollup_address" - }, - "opponent": { - "$ref": "#/definitions/Signature.Public_key_hash" - }, - "refutation": { + "inode_tree": { "type": "object", "properties": { - "choice": { - "$ref": "#/definitions/positive_bignum" + "length": { + "$ref": "#/definitions/int64" }, - "step": { + "proofs": { "oneOf": [ { - "title": "Dissection", - "type": "array", - "items": { - "type": "array", - "items": [ - { - "oneOf": [ + "title": "sparse_proof", + "type": "object", + "properties": { + "sparse_proof": { + "type": "array", + "items": { + "type": "array", + "items": [ { - "title": "Some", - "$ref": "#/definitions/state_hash" + "type": "integer", + "minimum": 0, + "maximum": 255 }, { - "title": "None", - "type": "null" + "$ref": "#/definitions/inode_tree" } - ] - }, - { - "$ref": "#/definitions/positive_bignum" + ], + "additionalItems": false } - ], - "additionalItems": false - } + } + }, + "required": [ + "sparse_proof" + ], + "additionalProperties": false }, { - "title": "Proof", - "oneOf": [ - { - "title": "Proof of a normal computation step", - "type": "array", - "items": [ - { - "type": "boolean" - }, - { - "$ref": "#/definitions/state_hash" - }, - { - "$ref": "#/definitions/state_hash" - } - ], - "additionalItems": false - }, - { - "title": "Proof of an input step", - "type": "array", - "items": [ - { - "type": "boolean" - }, - { - "$ref": "#/definitions/state_hash" - }, - { - "$ref": "#/definitions/state_hash" - } - ], - "additionalItems": false - }, - { - "title": "Proof that the PVM is blocked", + "title": "dense_proof", + "type": "object", + "properties": { + "dense_proof": { "type": "array", - "items": [ - { - "type": "boolean" - }, - { - "$ref": "#/definitions/state_hash" - } - ], - "additionalItems": false + "items": { + "$ref": "#/definitions/inode_tree" + } } - ] + }, + "required": [ + "dense_proof" + ], + "additionalProperties": false } ] } }, "required": [ - "step", - "choice" + "proofs", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_tree" + ], + "additionalProperties": false + }, + { + "title": "Inode_extender", + "type": "object", + "properties": { + "inode_extender": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "segment": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + "proof": { + "$ref": "#/definitions/inode_tree" + } + }, + "required": [ + "proof", + "segment", + "length" ], "additionalProperties": false } }, "required": [ - "refutation", - "opponent", - "rollup", - "storage_limit", - "gas_limit", - "counter", - "fee", - "source", - "kind" + "inode_extender" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "object", + "properties": { + "none": { + "type": "null" + } + }, + "required": [ + "none" + ], + "additionalProperties": false + } + ] + }, + "int64": { + "title": "64 bit integers", + "description": "Decimal representation of 64 bit integers", + "type": "string" + }, + "micheline.alpha.michelson_v1.expression": { + "oneOf": [ + { + "title": "Int", + "type": "object", + "properties": { + "int": { + "$ref": "#/definitions/bignum" + } + }, + "required": [ + "int" + ], + "additionalProperties": false + }, + { + "title": "String", + "type": "object", + "properties": { + "string": { + "$ref": "#/definitions/unistring" + } + }, + "required": [ + "string" ], "additionalProperties": false }, { - "title": "Sc_rollup_timeout", + "title": "Bytes", "type": "object", "properties": { - "kind": { + "bytes": { "type": "string", - "enum": [ - "sc_rollup_timeout" - ] - }, - "source": { - "$ref": "#/definitions/Signature.Public_key_hash" - }, - "fee": { - "$ref": "#/definitions/alpha.mutez" - }, - "counter": { - "$ref": "#/definitions/positive_bignum" - }, - "gas_limit": { - "$ref": "#/definitions/positive_bignum" - }, - "storage_limit": { - "$ref": "#/definitions/positive_bignum" - }, - "rollup": { - "$ref": "#/definitions/alpha.rollup_address" - }, - "stakers": { - "type": "array", - "items": [ - { - "$ref": "#/definitions/Signature.Public_key_hash" - }, - { - "$ref": "#/definitions/Signature.Public_key_hash" - } - ], - "additionalItems": false + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" } }, "required": [ - "stakers", - "rollup", - "storage_limit", - "gas_limit", - "counter", - "fee", - "source", - "kind" + "bytes" ], "additionalProperties": false }, { - "title": "Sc_rollup_atomic_batch", + "title": "Sequence", + "type": "array", + "items": { + "$ref": "#/definitions/micheline.alpha.michelson_v1.expression" + } + }, + { + "title": "Prim__generic", + "description": "Generic primitive (any number of args with or without annotations)", "type": "object", "properties": { - "kind": { - "type": "string", - "enum": [ - "sc_rollup_atomic_batch" - ] - }, - "source": { - "$ref": "#/definitions/Signature.Public_key_hash" - }, - "fee": { - "$ref": "#/definitions/alpha.mutez" - }, - "counter": { - "$ref": "#/definitions/positive_bignum" - }, - "gas_limit": { - "$ref": "#/definitions/positive_bignum" - }, - "storage_limit": { - "$ref": "#/definitions/positive_bignum" - }, - "rollup": { - "$ref": "#/definitions/alpha.rollup_address" - }, - "cemented_commitment": { - "$ref": "#/definitions/commitment_hash" - }, - "outbox_level": { - "type": "integer", - "minimum": -2147483648, - "maximum": 2147483647 - }, - "message_index": { - "type": "integer", - "minimum": -1073741824, - "maximum": 1073741823 + "prim": { + "$ref": "#/definitions/alpha.michelson.v1.primitives" }, - "inclusion proof": { - "$ref": "#/definitions/unistring" + "args": { + "type": "array", + "items": { + "$ref": "#/definitions/micheline.alpha.michelson_v1.expression" + } }, - "atomic_transaction_batch": { - "$ref": "#/definitions/unistring" + "annots": { + "type": "array", + "items": { + "type": "string" + } } }, "required": [ - "atomic_transaction_batch", - "inclusion proof", - "message_index", - "outbox_level", - "cemented_commitment", - "rollup", - "storage_limit", - "gas_limit", - "counter", - "fee", - "source", - "kind" + "prim" ], "additionalProperties": false } ] }, - "alpha.rollup_address": { - "title": "A smart contract rollup address", - "description": "A smart contract rollup is identified by a base58 address starting with scr1", - "$ref": "#/definitions/unistring" - }, - "alpha.scripted.contracts": { + "next_operation": { + "description": "An operation's shell header.", "type": "object", "properties": { - "code": { - "oneOf": [ - { - "title": "Int", - "type": "object", - "properties": { - "int": { - "$ref": "#/definitions/bignum" - } - }, - "required": [ - "int" - ], - "additionalProperties": false - }, - { - "title": "String", - "type": "object", - "properties": { - "string": { - "$ref": "#/definitions/unistring" - } - }, - "required": [ - "string" - ], - "additionalProperties": false - }, - { - "title": "Bytes", - "type": "object", - "properties": { - "bytes": { - "type": "string", - "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" - } - }, - "required": [ - "bytes" - ], - "additionalProperties": false - }, - { - "title": "Sequence", - "type": "array", - "items": { - "$ref": "#/definitions/micheline.alpha.michelson_v1.expression" - } - }, - { - "title": "Prim__generic", - "description": "Generic primitive (any number of args with or without annotations)", - "type": "object", - "properties": { - "prim": { - "$ref": "#/definitions/alpha.michelson.v1.primitives" - }, - "args": { - "type": "array", - "items": { - "$ref": "#/definitions/micheline.alpha.michelson_v1.expression" - } - }, - "annots": { - "type": "array", - "items": { - "type": "string" - } - } - }, - "required": [ - "prim" - ], - "additionalProperties": false + "protocol": { + "type": "string", + "enum": [ + "ProtoALphaALphaALphaALphaALphaALphaALphaALphaDdp3zK" + ] + }, + "branch": { + "$ref": "#/definitions/block_hash" + }, + "contents": { + "type": "array", + "items": { + "$ref": "#/definitions/alpha.operation.alpha.contents" + } + }, + "signature": { + "$ref": "#/definitions/Signature" + } + }, + "required": [ + "signature", + "contents", + "branch", + "protocol" + ], + "additionalProperties": false + }, + "positive_bignum": { + "title": "Positive big number", + "description": "Decimal representation of a positive big number", + "type": "string" + }, + "script_expr": { + "title": "A script expression ID (Base58Check-encoded)", + "$ref": "#/definitions/unistring" + }, + "state_hash": { + "title": "The hash of the VM state of a smart contract rollup (Base58Check-encoded)", + "$ref": "#/definitions/unistring" + }, + "timestamp.protocol": { + "description": "A timestamp as seen by the protocol: second-level precision, epoch based.", + "$ref": "#/definitions/unistring" + }, + "tree_encoding": { + "oneOf": [ + { + "title": "Value", + "type": "object", + "properties": { + "value": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" } - ] + }, + "required": [ + "value" + ], + "additionalProperties": false }, - "storage": { - "oneOf": [ - { - "title": "Int", - "type": "object", - "properties": { - "int": { - "$ref": "#/definitions/bignum" - } - }, - "required": [ - "int" - ], - "additionalProperties": false - }, - { - "title": "String", - "type": "object", - "properties": { - "string": { - "$ref": "#/definitions/unistring" - } - }, - "required": [ - "string" - ], - "additionalProperties": false - }, - { - "title": "Bytes", - "type": "object", - "properties": { - "bytes": { - "type": "string", - "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" - } - }, - "required": [ - "bytes" - ], - "additionalProperties": false - }, - { - "title": "Sequence", + { + "title": "Blinded_value", + "type": "object", + "properties": { + "blinded_value": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_value" + ], + "additionalProperties": false + }, + { + "title": "Node", + "type": "object", + "properties": { + "node": { "type": "array", "items": { - "$ref": "#/definitions/micheline.alpha.michelson_v1.expression" + "type": "array", + "items": [ + { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + { + "$ref": "#/definitions/tree_encoding" + } + ], + "additionalItems": false } - }, - { - "title": "Prim__generic", - "description": "Generic primitive (any number of args with or without annotations)", + } + }, + "required": [ + "node" + ], + "additionalProperties": false + }, + { + "title": "Blinded_node", + "type": "object", + "properties": { + "blinded_node": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_node" + ], + "additionalProperties": false + }, + { + "title": "Inode", + "type": "object", + "properties": { + "inode": { "type": "object", "properties": { - "prim": { - "$ref": "#/definitions/alpha.michelson.v1.primitives" - }, - "args": { - "type": "array", - "items": { - "$ref": "#/definitions/micheline.alpha.michelson_v1.expression" - } + "length": { + "$ref": "#/definitions/int64" }, - "annots": { - "type": "array", - "items": { - "type": "string" - } + "proofs": { + "oneOf": [ + { + "title": "sparse_proof", + "type": "object", + "properties": { + "sparse_proof": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "integer", + "minimum": 0, + "maximum": 255 + }, + { + "oneOf": [ + { + "title": "Blinded_inode", + "type": "object", + "properties": { + "blinded_inode": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_inode" + ], + "additionalProperties": false + }, + { + "title": "Inode_values", + "type": "object", + "properties": { + "inode_values": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + { + "$ref": "#/definitions/tree_encoding" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "inode_values" + ], + "additionalProperties": false + }, + { + "title": "Inode_tree", + "type": "object", + "properties": { + "inode_tree": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "proofs": { + "oneOf": [ + { + "title": "sparse_proof", + "type": "object", + "properties": { + "sparse_proof": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "integer", + "minimum": 0, + "maximum": 255 + }, + { + "$ref": "#/definitions/inode_tree" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "sparse_proof" + ], + "additionalProperties": false + }, + { + "title": "dense_proof", + "type": "object", + "properties": { + "dense_proof": { + "type": "array", + "items": { + "$ref": "#/definitions/inode_tree" + } + } + }, + "required": [ + "dense_proof" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proofs", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_tree" + ], + "additionalProperties": false + }, + { + "title": "Inode_extender", + "type": "object", + "properties": { + "inode_extender": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "segment": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + "proof": { + "$ref": "#/definitions/inode_tree" + } + }, + "required": [ + "proof", + "segment", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_extender" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "object", + "properties": { + "none": { + "type": "null" + } + }, + "required": [ + "none" + ], + "additionalProperties": false + } + ] + } + ], + "additionalItems": false + } + } + }, + "required": [ + "sparse_proof" + ], + "additionalProperties": false + }, + { + "title": "dense_proof", + "type": "object", + "properties": { + "dense_proof": { + "type": "array", + "items": { + "oneOf": [ + { + "title": "Blinded_inode", + "type": "object", + "properties": { + "blinded_inode": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_inode" + ], + "additionalProperties": false + }, + { + "title": "Inode_values", + "type": "object", + "properties": { + "inode_values": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + { + "$ref": "#/definitions/tree_encoding" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "inode_values" + ], + "additionalProperties": false + }, + { + "title": "Inode_tree", + "type": "object", + "properties": { + "inode_tree": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "proofs": { + "oneOf": [ + { + "title": "sparse_proof", + "type": "object", + "properties": { + "sparse_proof": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "integer", + "minimum": 0, + "maximum": 255 + }, + { + "$ref": "#/definitions/inode_tree" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "sparse_proof" + ], + "additionalProperties": false + }, + { + "title": "dense_proof", + "type": "object", + "properties": { + "dense_proof": { + "type": "array", + "items": { + "$ref": "#/definitions/inode_tree" + } + } + }, + "required": [ + "dense_proof" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proofs", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_tree" + ], + "additionalProperties": false + }, + { + "title": "Inode_extender", + "type": "object", + "properties": { + "inode_extender": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "segment": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + "proof": { + "$ref": "#/definitions/inode_tree" + } + }, + "required": [ + "proof", + "segment", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_extender" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "object", + "properties": { + "none": { + "type": "null" + } + }, + "required": [ + "none" + ], + "additionalProperties": false + } + ] + } + } + }, + "required": [ + "dense_proof" + ], + "additionalProperties": false + } + ] } }, "required": [ - "prim" + "proofs", + "length" ], "additionalProperties": false } - ] - } - }, - "required": [ - "storage", - "code" - ], - "additionalProperties": false - }, - "alpha.tx_rollup_id": { - "title": "A tx rollup handle", - "description": "A tx rollup notation as given to an RPC or inside scripts, is a base58 tx rollup hash", - "$ref": "#/definitions/unistring" - }, - "bignum": { - "title": "Big number", - "description": "Decimal representation of a big number", - "type": "string" - }, - "block_hash": { - "title": "A block identifier (Base58Check-encoded)", - "$ref": "#/definitions/unistring" - }, - "commitment_hash": { - "title": "The hash of a commitment of a smart contract rollup (Base58Check-encoded)", - "$ref": "#/definitions/unistring" - }, - "cycle_nonce": { - "title": "A nonce hash (Base58Check-encoded)", - "$ref": "#/definitions/unistring" - }, - "error": { - "description": "The full list of errors is available with the global RPC `GET errors`" - }, - "fitness": { - "title": "Block fitness", - "description": "The fitness, or score, of a block, that allow the Tezos to decide which chain is the best. A fitness value is a list of byte sequences. They are compared as follows: shortest lists are smaller; lists of the same length are compared according to the lexicographical order.", - "type": "array", - "items": { - "type": "string", - "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" - } - }, - "int64": { - "title": "64 bit integers", - "description": "Decimal representation of 64 bit integers", - "type": "string" - }, - "micheline.alpha.michelson_v1.expression": { - "oneOf": [ - { - "title": "Int", - "type": "object", - "properties": { - "int": { - "$ref": "#/definitions/bignum" - } - }, - "required": [ - "int" - ], - "additionalProperties": false - }, - { - "title": "String", - "type": "object", - "properties": { - "string": { - "$ref": "#/definitions/unistring" - } }, "required": [ - "string" + "inode" ], "additionalProperties": false }, { - "title": "Bytes", + "title": "Extender", "type": "object", "properties": { - "bytes": { - "type": "string", - "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + "extender": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "segment": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + "proof": { + "oneOf": [ + { + "title": "Blinded_inode", + "type": "object", + "properties": { + "blinded_inode": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_inode" + ], + "additionalProperties": false + }, + { + "title": "Inode_values", + "type": "object", + "properties": { + "inode_values": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + { + "$ref": "#/definitions/tree_encoding" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "inode_values" + ], + "additionalProperties": false + }, + { + "title": "Inode_tree", + "type": "object", + "properties": { + "inode_tree": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "proofs": { + "oneOf": [ + { + "title": "sparse_proof", + "type": "object", + "properties": { + "sparse_proof": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "integer", + "minimum": 0, + "maximum": 255 + }, + { + "$ref": "#/definitions/inode_tree" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "sparse_proof" + ], + "additionalProperties": false + }, + { + "title": "dense_proof", + "type": "object", + "properties": { + "dense_proof": { + "type": "array", + "items": { + "$ref": "#/definitions/inode_tree" + } + } + }, + "required": [ + "dense_proof" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proofs", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_tree" + ], + "additionalProperties": false + }, + { + "title": "Inode_extender", + "type": "object", + "properties": { + "inode_extender": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "segment": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + "proof": { + "$ref": "#/definitions/inode_tree" + } + }, + "required": [ + "proof", + "segment", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_extender" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "object", + "properties": { + "none": { + "type": "null" + } + }, + "required": [ + "none" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proof", + "segment", + "length" + ], + "additionalProperties": false } }, "required": [ - "bytes" + "extender" ], "additionalProperties": false }, { - "title": "Sequence", - "type": "array", - "items": { - "$ref": "#/definitions/micheline.alpha.michelson_v1.expression" - } - }, - { - "title": "Prim__generic", - "description": "Generic primitive (any number of args with or without annotations)", + "title": "None", "type": "object", "properties": { - "prim": { - "$ref": "#/definitions/alpha.michelson.v1.primitives" - }, - "args": { - "type": "array", - "items": { - "$ref": "#/definitions/micheline.alpha.michelson_v1.expression" - } - }, - "annots": { - "type": "array", - "items": { - "type": "string" - } + "none": { + "type": "null" } }, "required": [ - "prim" + "none" ], "additionalProperties": false } ] }, - "next_operation": { - "description": "An operation's shell header.", - "type": "object", - "properties": { - "protocol": { - "type": "string", - "enum": [ - "ProtoALphaALphaALphaALphaALphaALphaALphaALphaDdp3zK" - ] - }, - "branch": { - "$ref": "#/definitions/block_hash" - }, - "contents": { - "type": "array", - "items": { - "$ref": "#/definitions/alpha.operation.alpha.contents" - } - }, - "signature": { - "$ref": "#/definitions/Signature" - } - }, - "required": [ - "signature", - "contents", - "branch", - "protocol" - ], - "additionalProperties": false - }, - "positive_bignum": { - "title": "Positive big number", - "description": "Decimal representation of a positive big number", - "type": "string" - }, - "script_expr": { - "title": "A script expression ID (Base58Check-encoded)", - "$ref": "#/definitions/unistring" - }, - "state_hash": { - "title": "The hash of the VM state of a smart contract rollup (Base58Check-encoded)", - "$ref": "#/definitions/unistring" - }, - "timestamp.protocol": { - "description": "A timestamp as seen by the protocol: second-level precision, epoch based.", - "$ref": "#/definitions/unistring" - }, "unistring": { "title": "Universal string representation", "description": "Either a plain UTF8 string, or a sequence of bytes for strings that contain invalid byte sequences.", diff --git a/tezt/tests/expected/RPC_test.ml/Alpha- (mode proxy) RPC regression tests- mempool.out b/tezt/tests/expected/RPC_test.ml/Alpha- (mode proxy) RPC regression tests- mempool.out index bde688be8883..fb565a721fbe 100644 --- a/tezt/tests/expected/RPC_test.ml/Alpha- (mode proxy) RPC regression tests- mempool.out +++ b/tezt/tests/expected/RPC_test.ml/Alpha- (mode proxy) RPC regression tests- mempool.out @@ -3446,53 +3446,1766 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, { "title": "Proof", - "oneOf": [ - { - "title": "Proof of a normal computation step", - "type": "array", - "items": [ - { - "type": "boolean" - }, - { - "$ref": "#/definitions/state_hash" - }, - { - "$ref": "#/definitions/state_hash" - } - ], - "additionalItems": false - }, - { - "title": "Proof of an input step", - "type": "array", - "items": [ - { - "type": "boolean" - }, - { - "$ref": "#/definitions/state_hash" - }, + "type": "object", + "properties": { + "pvm_step": { + "oneOf": [ { - "$ref": "#/definitions/state_hash" + "title": "Arithmetic PVM with proof", + "type": "object", + "properties": { + "tree_proof": { + "type": "object", + "properties": { + "version": { + "type": "integer", + "minimum": -32768, + "maximum": 32767 + }, + "before": { + "oneOf": [ + { + "title": "Value", + "type": "object", + "properties": { + "value": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "value" + ], + "additionalProperties": false + }, + { + "title": "Node", + "type": "object", + "properties": { + "node": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "node" + ], + "additionalProperties": false + } + ] + }, + "after": { + "oneOf": [ + { + "title": "Value", + "type": "object", + "properties": { + "value": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "value" + ], + "additionalProperties": false + }, + { + "title": "Node", + "type": "object", + "properties": { + "node": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "node" + ], + "additionalProperties": false + } + ] + }, + "state": { + "oneOf": [ + { + "title": "Value", + "type": "object", + "properties": { + "value": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + } + }, + "required": [ + "value" + ], + "additionalProperties": false + }, + { + "title": "Blinded_value", + "type": "object", + "properties": { + "blinded_value": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_value" + ], + "additionalProperties": false + }, + { + "title": "Node", + "type": "object", + "properties": { + "node": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + { + "$ref": "#/definitions/tree_encoding" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "node" + ], + "additionalProperties": false + }, + { + "title": "Blinded_node", + "type": "object", + "properties": { + "blinded_node": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_node" + ], + "additionalProperties": false + }, + { + "title": "Inode", + "type": "object", + "properties": { + "inode": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "proofs": { + "oneOf": [ + { + "title": "sparse_proof", + "type": "object", + "properties": { + "sparse_proof": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "integer", + "minimum": 0, + "maximum": 255 + }, + { + "oneOf": [ + { + "title": "Blinded_inode", + "type": "object", + "properties": { + "blinded_inode": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_inode" + ], + "additionalProperties": false + }, + { + "title": "Inode_values", + "type": "object", + "properties": { + "inode_values": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + { + "$ref": "#/definitions/tree_encoding" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "inode_values" + ], + "additionalProperties": false + }, + { + "title": "Inode_tree", + "type": "object", + "properties": { + "inode_tree": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "proofs": { + "oneOf": [ + { + "title": "sparse_proof", + "type": "object", + "properties": { + "sparse_proof": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "integer", + "minimum": 0, + "maximum": 255 + }, + { + "$ref": "#/definitions/inode_tree" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "sparse_proof" + ], + "additionalProperties": false + }, + { + "title": "dense_proof", + "type": "object", + "properties": { + "dense_proof": { + "type": "array", + "items": { + "$ref": "#/definitions/inode_tree" + } + } + }, + "required": [ + "dense_proof" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proofs", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_tree" + ], + "additionalProperties": false + }, + { + "title": "Inode_extender", + "type": "object", + "properties": { + "inode_extender": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "segment": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + "proof": { + "$ref": "#/definitions/inode_tree" + } + }, + "required": [ + "proof", + "segment", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_extender" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "object", + "properties": { + "none": { + "type": "null" + } + }, + "required": [ + "none" + ], + "additionalProperties": false + } + ] + } + ], + "additionalItems": false + } + } + }, + "required": [ + "sparse_proof" + ], + "additionalProperties": false + }, + { + "title": "dense_proof", + "type": "object", + "properties": { + "dense_proof": { + "type": "array", + "items": { + "oneOf": [ + { + "title": "Blinded_inode", + "type": "object", + "properties": { + "blinded_inode": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_inode" + ], + "additionalProperties": false + }, + { + "title": "Inode_values", + "type": "object", + "properties": { + "inode_values": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + { + "$ref": "#/definitions/tree_encoding" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "inode_values" + ], + "additionalProperties": false + }, + { + "title": "Inode_tree", + "type": "object", + "properties": { + "inode_tree": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "proofs": { + "oneOf": [ + { + "title": "sparse_proof", + "type": "object", + "properties": { + "sparse_proof": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "integer", + "minimum": 0, + "maximum": 255 + }, + { + "$ref": "#/definitions/inode_tree" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "sparse_proof" + ], + "additionalProperties": false + }, + { + "title": "dense_proof", + "type": "object", + "properties": { + "dense_proof": { + "type": "array", + "items": { + "$ref": "#/definitions/inode_tree" + } + } + }, + "required": [ + "dense_proof" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proofs", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_tree" + ], + "additionalProperties": false + }, + { + "title": "Inode_extender", + "type": "object", + "properties": { + "inode_extender": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "segment": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + "proof": { + "$ref": "#/definitions/inode_tree" + } + }, + "required": [ + "proof", + "segment", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_extender" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "object", + "properties": { + "none": { + "type": "null" + } + }, + "required": [ + "none" + ], + "additionalProperties": false + } + ] + } + } + }, + "required": [ + "dense_proof" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proofs", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode" + ], + "additionalProperties": false + }, + { + "title": "Extender", + "type": "object", + "properties": { + "extender": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "segment": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + "proof": { + "oneOf": [ + { + "title": "Blinded_inode", + "type": "object", + "properties": { + "blinded_inode": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_inode" + ], + "additionalProperties": false + }, + { + "title": "Inode_values", + "type": "object", + "properties": { + "inode_values": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + { + "$ref": "#/definitions/tree_encoding" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "inode_values" + ], + "additionalProperties": false + }, + { + "title": "Inode_tree", + "type": "object", + "properties": { + "inode_tree": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "proofs": { + "oneOf": [ + { + "title": "sparse_proof", + "type": "object", + "properties": { + "sparse_proof": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "integer", + "minimum": 0, + "maximum": 255 + }, + { + "$ref": "#/definitions/inode_tree" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "sparse_proof" + ], + "additionalProperties": false + }, + { + "title": "dense_proof", + "type": "object", + "properties": { + "dense_proof": { + "type": "array", + "items": { + "$ref": "#/definitions/inode_tree" + } + } + }, + "required": [ + "dense_proof" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proofs", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_tree" + ], + "additionalProperties": false + }, + { + "title": "Inode_extender", + "type": "object", + "properties": { + "inode_extender": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "segment": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + "proof": { + "$ref": "#/definitions/inode_tree" + } + }, + "required": [ + "proof", + "segment", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_extender" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "object", + "properties": { + "none": { + "type": "null" + } + }, + "required": [ + "none" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proof", + "segment", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "extender" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "object", + "properties": { + "none": { + "type": "null" + } + }, + "required": [ + "none" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "state", + "after", + "before", + "version" + ], + "additionalProperties": false + }, + "given": { + "oneOf": [ + { + "title": "Some", + "type": "object", + "properties": { + "inbox_level": { + "type": "integer", + "minimum": -2147483648, + "maximum": 2147483647 + }, + "message_counter": { + "$ref": "#/definitions/positive_bignum" + }, + "payload": { + "$ref": "#/definitions/unistring" + } + }, + "required": [ + "payload", + "message_counter", + "inbox_level" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "null" + } + ] + }, + "requested": { + "oneOf": [ + { + "title": "No_input_required", + "type": "object", + "properties": { + "no_input_required": {} + }, + "required": [ + "no_input_required" + ], + "additionalProperties": false + }, + { + "title": "Initial", + "type": "object", + "properties": { + "initial": {} + }, + "required": [ + "initial" + ], + "additionalProperties": false + }, + { + "title": "First_after", + "type": "array", + "items": [ + { + "type": "integer", + "minimum": -2147483648, + "maximum": 2147483647 + }, + { + "$ref": "#/definitions/positive_bignum" + } + ], + "additionalItems": false + } + ] + } + }, + "required": [ + "requested", + "given", + "tree_proof" + ], + "additionalProperties": false } - ], - "additionalItems": false + ] }, - { - "title": "Proof that the PVM is blocked", - "type": "array", - "items": [ + "inbox": { + "oneOf": [ { - "type": "boolean" + "title": "Some", + "type": "object", + "properties": { + "skips": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "object", + "properties": { + "rollup": { + "$ref": "#/definitions/alpha.rollup_address" + }, + "message_counter": { + "$ref": "#/definitions/positive_bignum" + }, + "nb_available_messages": { + "$ref": "#/definitions/int64" + }, + "nb_messages_in_commitment_period": { + "$ref": "#/definitions/int64" + }, + "starting_level_of_current_commitment_period": { + "type": "integer", + "minimum": -2147483648, + "maximum": 2147483647 + }, + "level": { + "type": "integer", + "minimum": -2147483648, + "maximum": 2147483647 + }, + "current_messages_hash": { + "$ref": "#/definitions/inbox_hash" + }, + "old_levels_messages": { + "type": "object", + "properties": { + "index": { + "type": "integer", + "minimum": -1073741824, + "maximum": 1073741823 + }, + "content": { + "$ref": "#/definitions/inbox_hash" + }, + "back_pointers": { + "type": "array", + "items": { + "$ref": "#/definitions/inbox_hash" + } + } + }, + "required": [ + "back_pointers", + "content", + "index" + ], + "additionalProperties": false + } + }, + "required": [ + "old_levels_messages", + "current_messages_hash", + "level", + "starting_level_of_current_commitment_period", + "nb_messages_in_commitment_period", + "nb_available_messages", + "message_counter", + "rollup" + ], + "additionalProperties": false + }, + { + "type": "array", + "items": { + "type": "object", + "properties": { + "index": { + "type": "integer", + "minimum": -1073741824, + "maximum": 1073741823 + }, + "content": { + "$ref": "#/definitions/inbox_hash" + }, + "back_pointers": { + "type": "array", + "items": { + "$ref": "#/definitions/inbox_hash" + } + } + }, + "required": [ + "back_pointers", + "content", + "index" + ], + "additionalProperties": false + } + } + ], + "additionalItems": false + } + }, + "level": { + "type": "object", + "properties": { + "rollup": { + "$ref": "#/definitions/alpha.rollup_address" + }, + "message_counter": { + "$ref": "#/definitions/positive_bignum" + }, + "nb_available_messages": { + "$ref": "#/definitions/int64" + }, + "nb_messages_in_commitment_period": { + "$ref": "#/definitions/int64" + }, + "starting_level_of_current_commitment_period": { + "type": "integer", + "minimum": -2147483648, + "maximum": 2147483647 + }, + "level": { + "type": "integer", + "minimum": -2147483648, + "maximum": 2147483647 + }, + "current_messages_hash": { + "$ref": "#/definitions/inbox_hash" + }, + "old_levels_messages": { + "type": "object", + "properties": { + "index": { + "type": "integer", + "minimum": -1073741824, + "maximum": 1073741823 + }, + "content": { + "$ref": "#/definitions/inbox_hash" + }, + "back_pointers": { + "type": "array", + "items": { + "$ref": "#/definitions/inbox_hash" + } + } + }, + "required": [ + "back_pointers", + "content", + "index" + ], + "additionalProperties": false + } + }, + "required": [ + "old_levels_messages", + "current_messages_hash", + "level", + "starting_level_of_current_commitment_period", + "nb_messages_in_commitment_period", + "nb_available_messages", + "message_counter", + "rollup" + ], + "additionalProperties": false + }, + "inc": { + "type": "array", + "items": { + "type": "object", + "properties": { + "index": { + "type": "integer", + "minimum": -1073741824, + "maximum": 1073741823 + }, + "content": { + "$ref": "#/definitions/inbox_hash" + }, + "back_pointers": { + "type": "array", + "items": { + "$ref": "#/definitions/inbox_hash" + } + } + }, + "required": [ + "back_pointers", + "content", + "index" + ], + "additionalProperties": false + } + }, + "message_proof": { + "type": "object", + "properties": { + "version": { + "type": "integer", + "minimum": -32768, + "maximum": 32767 + }, + "before": { + "oneOf": [ + { + "title": "Value", + "type": "object", + "properties": { + "value": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "value" + ], + "additionalProperties": false + }, + { + "title": "Node", + "type": "object", + "properties": { + "node": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "node" + ], + "additionalProperties": false + } + ] + }, + "after": { + "oneOf": [ + { + "title": "Value", + "type": "object", + "properties": { + "value": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "value" + ], + "additionalProperties": false + }, + { + "title": "Node", + "type": "object", + "properties": { + "node": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "node" + ], + "additionalProperties": false + } + ] + }, + "state": { + "oneOf": [ + { + "title": "Value", + "type": "object", + "properties": { + "value": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + } + }, + "required": [ + "value" + ], + "additionalProperties": false + }, + { + "title": "Blinded_value", + "type": "object", + "properties": { + "blinded_value": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_value" + ], + "additionalProperties": false + }, + { + "title": "Node", + "type": "object", + "properties": { + "node": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + { + "$ref": "#/definitions/tree_encoding" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "node" + ], + "additionalProperties": false + }, + { + "title": "Blinded_node", + "type": "object", + "properties": { + "blinded_node": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_node" + ], + "additionalProperties": false + }, + { + "title": "Inode", + "type": "object", + "properties": { + "inode": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "proofs": { + "oneOf": [ + { + "title": "sparse_proof", + "type": "object", + "properties": { + "sparse_proof": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "integer", + "minimum": 0, + "maximum": 255 + }, + { + "oneOf": [ + { + "title": "Blinded_inode", + "type": "object", + "properties": { + "blinded_inode": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_inode" + ], + "additionalProperties": false + }, + { + "title": "Inode_values", + "type": "object", + "properties": { + "inode_values": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + { + "$ref": "#/definitions/tree_encoding" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "inode_values" + ], + "additionalProperties": false + }, + { + "title": "Inode_tree", + "type": "object", + "properties": { + "inode_tree": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "proofs": { + "oneOf": [ + { + "title": "sparse_proof", + "type": "object", + "properties": { + "sparse_proof": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "integer", + "minimum": 0, + "maximum": 255 + }, + { + "$ref": "#/definitions/inode_tree" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "sparse_proof" + ], + "additionalProperties": false + }, + { + "title": "dense_proof", + "type": "object", + "properties": { + "dense_proof": { + "type": "array", + "items": { + "$ref": "#/definitions/inode_tree" + } + } + }, + "required": [ + "dense_proof" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proofs", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_tree" + ], + "additionalProperties": false + }, + { + "title": "Inode_extender", + "type": "object", + "properties": { + "inode_extender": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "segment": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + "proof": { + "$ref": "#/definitions/inode_tree" + } + }, + "required": [ + "proof", + "segment", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_extender" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "object", + "properties": { + "none": { + "type": "null" + } + }, + "required": [ + "none" + ], + "additionalProperties": false + } + ] + } + ], + "additionalItems": false + } + } + }, + "required": [ + "sparse_proof" + ], + "additionalProperties": false + }, + { + "title": "dense_proof", + "type": "object", + "properties": { + "dense_proof": { + "type": "array", + "items": { + "oneOf": [ + { + "title": "Blinded_inode", + "type": "object", + "properties": { + "blinded_inode": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_inode" + ], + "additionalProperties": false + }, + { + "title": "Inode_values", + "type": "object", + "properties": { + "inode_values": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + { + "$ref": "#/definitions/tree_encoding" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "inode_values" + ], + "additionalProperties": false + }, + { + "title": "Inode_tree", + "type": "object", + "properties": { + "inode_tree": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "proofs": { + "oneOf": [ + { + "title": "sparse_proof", + "type": "object", + "properties": { + "sparse_proof": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "integer", + "minimum": 0, + "maximum": 255 + }, + { + "$ref": "#/definitions/inode_tree" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "sparse_proof" + ], + "additionalProperties": false + }, + { + "title": "dense_proof", + "type": "object", + "properties": { + "dense_proof": { + "type": "array", + "items": { + "$ref": "#/definitions/inode_tree" + } + } + }, + "required": [ + "dense_proof" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proofs", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_tree" + ], + "additionalProperties": false + }, + { + "title": "Inode_extender", + "type": "object", + "properties": { + "inode_extender": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "segment": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + "proof": { + "$ref": "#/definitions/inode_tree" + } + }, + "required": [ + "proof", + "segment", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_extender" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "object", + "properties": { + "none": { + "type": "null" + } + }, + "required": [ + "none" + ], + "additionalProperties": false + } + ] + } + } + }, + "required": [ + "dense_proof" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proofs", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode" + ], + "additionalProperties": false + }, + { + "title": "Extender", + "type": "object", + "properties": { + "extender": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "segment": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + "proof": { + "oneOf": [ + { + "title": "Blinded_inode", + "type": "object", + "properties": { + "blinded_inode": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_inode" + ], + "additionalProperties": false + }, + { + "title": "Inode_values", + "type": "object", + "properties": { + "inode_values": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + { + "$ref": "#/definitions/tree_encoding" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "inode_values" + ], + "additionalProperties": false + }, + { + "title": "Inode_tree", + "type": "object", + "properties": { + "inode_tree": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "proofs": { + "oneOf": [ + { + "title": "sparse_proof", + "type": "object", + "properties": { + "sparse_proof": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "integer", + "minimum": 0, + "maximum": 255 + }, + { + "$ref": "#/definitions/inode_tree" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "sparse_proof" + ], + "additionalProperties": false + }, + { + "title": "dense_proof", + "type": "object", + "properties": { + "dense_proof": { + "type": "array", + "items": { + "$ref": "#/definitions/inode_tree" + } + } + }, + "required": [ + "dense_proof" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proofs", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_tree" + ], + "additionalProperties": false + }, + { + "title": "Inode_extender", + "type": "object", + "properties": { + "inode_extender": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "segment": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + "proof": { + "$ref": "#/definitions/inode_tree" + } + }, + "required": [ + "proof", + "segment", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_extender" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "object", + "properties": { + "none": { + "type": "null" + } + }, + "required": [ + "none" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proof", + "segment", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "extender" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "object", + "properties": { + "none": { + "type": "null" + } + }, + "required": [ + "none" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "state", + "after", + "before", + "version" + ], + "additionalProperties": false + } + }, + "required": [ + "message_proof", + "inc", + "level", + "skips" + ], + "additionalProperties": false }, { - "$ref": "#/definitions/state_hash" + "title": "None", + "type": "null" } - ], - "additionalItems": false + ] } - ] + }, + "required": [ + "inbox", + "pvm_step" + ], + "additionalProperties": false } ] } @@ -3839,85 +5552,246 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" } }, - "int64": { - "title": "64 bit integers", - "description": "Decimal representation of 64 bit integers", - "type": "string" + "inbox_hash": { + "title": "The hash of an inbox of a smart contract rollup (Base58Check-encoded)", + "$ref": "#/definitions/unistring" }, - "micheline.alpha.michelson_v1.expression": { + "inode_tree": { "oneOf": [ { - "title": "Int", - "type": "object", - "properties": { - "int": { - "$ref": "#/definitions/bignum" - } - }, - "required": [ - "int" - ], - "additionalProperties": false - }, - { - "title": "String", + "title": "Blinded_inode", "type": "object", "properties": { - "string": { - "$ref": "#/definitions/unistring" + "blinded_inode": { + "$ref": "#/definitions/Context_hash" } }, "required": [ - "string" + "blinded_inode" ], "additionalProperties": false }, { - "title": "Bytes", + "title": "Inode_values", "type": "object", "properties": { - "bytes": { - "type": "string", - "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + "inode_values": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + { + "$ref": "#/definitions/tree_encoding" + } + ], + "additionalItems": false + } } }, "required": [ - "bytes" + "inode_values" ], "additionalProperties": false }, { - "title": "Sequence", - "type": "array", - "items": { - "$ref": "#/definitions/micheline.alpha.michelson_v1.expression" - } - }, - { - "title": "Prim__generic", - "description": "Generic primitive (any number of args with or without annotations)", + "title": "Inode_tree", "type": "object", "properties": { - "prim": { - "$ref": "#/definitions/alpha.michelson.v1.primitives" - }, - "args": { - "type": "array", - "items": { - "$ref": "#/definitions/micheline.alpha.michelson_v1.expression" - } - }, - "annots": { - "type": "array", - "items": { - "type": "string" - } - } - }, - "required": [ - "prim" - ], - "additionalProperties": false + "inode_tree": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "proofs": { + "oneOf": [ + { + "title": "sparse_proof", + "type": "object", + "properties": { + "sparse_proof": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "integer", + "minimum": 0, + "maximum": 255 + }, + { + "$ref": "#/definitions/inode_tree" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "sparse_proof" + ], + "additionalProperties": false + }, + { + "title": "dense_proof", + "type": "object", + "properties": { + "dense_proof": { + "type": "array", + "items": { + "$ref": "#/definitions/inode_tree" + } + } + }, + "required": [ + "dense_proof" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proofs", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_tree" + ], + "additionalProperties": false + }, + { + "title": "Inode_extender", + "type": "object", + "properties": { + "inode_extender": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "segment": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + "proof": { + "$ref": "#/definitions/inode_tree" + } + }, + "required": [ + "proof", + "segment", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_extender" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "object", + "properties": { + "none": { + "type": "null" + } + }, + "required": [ + "none" + ], + "additionalProperties": false + } + ] + }, + "int64": { + "title": "64 bit integers", + "description": "Decimal representation of 64 bit integers", + "type": "string" + }, + "micheline.alpha.michelson_v1.expression": { + "oneOf": [ + { + "title": "Int", + "type": "object", + "properties": { + "int": { + "$ref": "#/definitions/bignum" + } + }, + "required": [ + "int" + ], + "additionalProperties": false + }, + { + "title": "String", + "type": "object", + "properties": { + "string": { + "$ref": "#/definitions/unistring" + } + }, + "required": [ + "string" + ], + "additionalProperties": false + }, + { + "title": "Bytes", + "type": "object", + "properties": { + "bytes": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + } + }, + "required": [ + "bytes" + ], + "additionalProperties": false + }, + { + "title": "Sequence", + "type": "array", + "items": { + "$ref": "#/definitions/micheline.alpha.michelson_v1.expression" + } + }, + { + "title": "Prim__generic", + "description": "Generic primitive (any number of args with or without annotations)", + "type": "object", + "properties": { + "prim": { + "$ref": "#/definitions/alpha.michelson.v1.primitives" + }, + "args": { + "type": "array", + "items": { + "$ref": "#/definitions/micheline.alpha.michelson_v1.expression" + } + }, + "annots": { + "type": "array", + "items": { + "type": "string" + } + } + }, + "required": [ + "prim" + ], + "additionalProperties": false } ] }, @@ -3938,197 +5812,1447 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "description": "A timestamp as seen by the protocol: second-level precision, epoch based.", "$ref": "#/definitions/unistring" }, - "unistring": { - "title": "Universal string representation", - "description": "Either a plain UTF8 string, or a sequence of bytes for strings that contain invalid byte sequences.", + "tree_encoding": { "oneOf": [ { - "type": "string" + "title": "Value", + "type": "object", + "properties": { + "value": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + } + }, + "required": [ + "value" + ], + "additionalProperties": false }, { + "title": "Blinded_value", "type": "object", "properties": { - "invalid_utf8_string": { + "blinded_value": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_value" + ], + "additionalProperties": false + }, + { + "title": "Node", + "type": "object", + "properties": { + "node": { "type": "array", "items": { - "type": "integer", - "minimum": 0, - "maximum": 255 + "type": "array", + "items": [ + { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + { + "$ref": "#/definitions/tree_encoding" + } + ], + "additionalItems": false } } }, "required": [ - "invalid_utf8_string" + "node" ], "additionalProperties": false - } - ] - }, - "value_hash": { - "title": "Hash of a consensus value (Base58Check-encoded)", - "$ref": "#/definitions/unistring" - } - } - }, - "binary_schema": { - "toplevel": { - "fields": [ - { - "kind": "dyn", - "num_fields": 1, - "size": "Uint30" - }, - { - "layout": { - "layout": { - "name": "X_0", - "kind": "Ref" - }, - "kind": "Seq" }, - "kind": "anon", - "data_kind": { - "kind": "Variable" - } - } - ] - }, - "fields": [ - { - "description": { - "title": "X_0" - }, - "encoding": { - "fields": [ - { - "name": "hash", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "size": 32, - "kind": "Float" - }, - "kind": "named" - }, - { - "kind": "dyn", - "num_fields": 1, - "size": "Uint30" + { + "title": "Blinded_node", + "type": "object", + "properties": { + "blinded_node": { + "$ref": "#/definitions/Context_hash" + } }, - { - "name": "branch", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "size": 32, - "kind": "Float" + "required": [ + "blinded_node" + ], + "additionalProperties": false + }, + { + "title": "Inode", + "type": "object", + "properties": { + "inode": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "proofs": { + "oneOf": [ + { + "title": "sparse_proof", + "type": "object", + "properties": { + "sparse_proof": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "integer", + "minimum": 0, + "maximum": 255 + }, + { + "oneOf": [ + { + "title": "Blinded_inode", + "type": "object", + "properties": { + "blinded_inode": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_inode" + ], + "additionalProperties": false + }, + { + "title": "Inode_values", + "type": "object", + "properties": { + "inode_values": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + { + "$ref": "#/definitions/tree_encoding" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "inode_values" + ], + "additionalProperties": false + }, + { + "title": "Inode_tree", + "type": "object", + "properties": { + "inode_tree": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "proofs": { + "oneOf": [ + { + "title": "sparse_proof", + "type": "object", + "properties": { + "sparse_proof": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "integer", + "minimum": 0, + "maximum": 255 + }, + { + "$ref": "#/definitions/inode_tree" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "sparse_proof" + ], + "additionalProperties": false + }, + { + "title": "dense_proof", + "type": "object", + "properties": { + "dense_proof": { + "type": "array", + "items": { + "$ref": "#/definitions/inode_tree" + } + } + }, + "required": [ + "dense_proof" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proofs", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_tree" + ], + "additionalProperties": false + }, + { + "title": "Inode_extender", + "type": "object", + "properties": { + "inode_extender": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "segment": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + "proof": { + "$ref": "#/definitions/inode_tree" + } + }, + "required": [ + "proof", + "segment", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_extender" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "object", + "properties": { + "none": { + "type": "null" + } + }, + "required": [ + "none" + ], + "additionalProperties": false + } + ] + } + ], + "additionalItems": false + } + } + }, + "required": [ + "sparse_proof" + ], + "additionalProperties": false + }, + { + "title": "dense_proof", + "type": "object", + "properties": { + "dense_proof": { + "type": "array", + "items": { + "oneOf": [ + { + "title": "Blinded_inode", + "type": "object", + "properties": { + "blinded_inode": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_inode" + ], + "additionalProperties": false + }, + { + "title": "Inode_values", + "type": "object", + "properties": { + "inode_values": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + { + "$ref": "#/definitions/tree_encoding" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "inode_values" + ], + "additionalProperties": false + }, + { + "title": "Inode_tree", + "type": "object", + "properties": { + "inode_tree": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "proofs": { + "oneOf": [ + { + "title": "sparse_proof", + "type": "object", + "properties": { + "sparse_proof": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "integer", + "minimum": 0, + "maximum": 255 + }, + { + "$ref": "#/definitions/inode_tree" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "sparse_proof" + ], + "additionalProperties": false + }, + { + "title": "dense_proof", + "type": "object", + "properties": { + "dense_proof": { + "type": "array", + "items": { + "$ref": "#/definitions/inode_tree" + } + } + }, + "required": [ + "dense_proof" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proofs", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_tree" + ], + "additionalProperties": false + }, + { + "title": "Inode_extender", + "type": "object", + "properties": { + "inode_extender": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "segment": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + "proof": { + "$ref": "#/definitions/inode_tree" + } + }, + "required": [ + "proof", + "segment", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_extender" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "object", + "properties": { + "none": { + "type": "null" + } + }, + "required": [ + "none" + ], + "additionalProperties": false + } + ] + } + } + }, + "required": [ + "dense_proof" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proofs", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode" + ], + "additionalProperties": false + }, + { + "title": "Extender", + "type": "object", + "properties": { + "extender": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "segment": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + "proof": { + "oneOf": [ + { + "title": "Blinded_inode", + "type": "object", + "properties": { + "blinded_inode": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_inode" + ], + "additionalProperties": false + }, + { + "title": "Inode_values", + "type": "object", + "properties": { + "inode_values": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + { + "$ref": "#/definitions/tree_encoding" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "inode_values" + ], + "additionalProperties": false + }, + { + "title": "Inode_tree", + "type": "object", + "properties": { + "inode_tree": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "proofs": { + "oneOf": [ + { + "title": "sparse_proof", + "type": "object", + "properties": { + "sparse_proof": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "integer", + "minimum": 0, + "maximum": 255 + }, + { + "$ref": "#/definitions/inode_tree" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "sparse_proof" + ], + "additionalProperties": false + }, + { + "title": "dense_proof", + "type": "object", + "properties": { + "dense_proof": { + "type": "array", + "items": { + "$ref": "#/definitions/inode_tree" + } + } + }, + "required": [ + "dense_proof" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proofs", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_tree" + ], + "additionalProperties": false + }, + { + "title": "Inode_extender", + "type": "object", + "properties": { + "inode_extender": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "segment": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + "proof": { + "$ref": "#/definitions/inode_tree" + } + }, + "required": [ + "proof", + "segment", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_extender" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "object", + "properties": { + "none": { + "type": "null" + } + }, + "required": [ + "none" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proof", + "segment", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "extender" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "object", + "properties": { + "none": { + "type": "null" + } + }, + "required": [ + "none" + ], + "additionalProperties": false + } + ] + }, + "unistring": { + "title": "Universal string representation", + "description": "Either a plain UTF8 string, or a sequence of bytes for strings that contain invalid byte sequences.", + "oneOf": [ + { + "type": "string" + }, + { + "type": "object", + "properties": { + "invalid_utf8_string": { + "type": "array", + "items": { + "type": "integer", + "minimum": 0, + "maximum": 255 + } + } + }, + "required": [ + "invalid_utf8_string" + ], + "additionalProperties": false + } + ] + }, + "value_hash": { + "title": "Hash of a consensus value (Base58Check-encoded)", + "$ref": "#/definitions/unistring" + } + } + }, + "binary_schema": { + "toplevel": { + "fields": [ + { + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" + }, + { + "layout": { + "layout": { + "name": "X_0", + "kind": "Ref" + }, + "kind": "Seq" + }, + "kind": "anon", + "data_kind": { + "kind": "Variable" + } + } + ] + }, + "fields": [ + { + "description": { + "title": "X_0" + }, + "encoding": { + "fields": [ + { + "name": "hash", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 32, + "kind": "Float" + }, + "kind": "named" + }, + { + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" + }, + { + "name": "branch", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 32, + "kind": "Float" + }, + "kind": "named" + }, + { + "kind": "dyn", + "num_fields": 2, + "size": "Uint30" + }, + { + "name": "contents", + "layout": { + "layout": { + "name": "alpha.operation.alpha.contents", + "kind": "Ref" + }, + "kind": "Seq" + }, + "data_kind": { + "kind": "Variable" + }, + "kind": "named" + }, + { + "name": "signature", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 64, + "kind": "Float" }, "kind": "named" }, { - "kind": "dyn", - "num_fields": 2, - "size": "Uint30" + "kind": "dyn", + "name": "error_opt", + "num_fields": 1, + "size": "Uint30" + }, + { + "name": "error", + "layout": { + "kind": "String" + }, + "data_kind": { + "kind": "Variable" + }, + "kind": "named" + } + ] + } + }, + { + "description": { + "title": "alpha.operation.alpha.contents" + }, + "encoding": { + "tag_size": "Uint8", + "kind": { + "kind": "Dynamic" + }, + "cases": [ + { + "tag": 1, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "level", + "layout": { + "size": "Int32", + "kind": "Int" + }, + "data_kind": { + "size": 4, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "nonce", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 32, + "kind": "Float" + }, + "kind": "named" + } + ], + "name": "Seed_nonce_revelation" + }, + { + "tag": 2, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" + }, + { + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" + }, + { + "name": "op1", + "layout": { + "name": "alpha.inlined.endorsement", + "kind": "Ref" + }, + "data_kind": { + "kind": "Variable" + }, + "kind": "named" + }, + { + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" + }, + { + "name": "op2", + "layout": { + "name": "alpha.inlined.endorsement", + "kind": "Ref" + }, + "data_kind": { + "kind": "Variable" + }, + "kind": "named" + } + ], + "name": "Double_endorsement_evidence" + }, + { + "tag": 3, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" + }, + { + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" + }, + { + "name": "bh1", + "layout": { + "name": "alpha.block_header.alpha.full_header", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" + }, + { + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" + }, + { + "name": "bh2", + "layout": { + "name": "alpha.block_header.alpha.full_header", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" + } + ], + "name": "Double_baking_evidence" + }, + { + "tag": 4, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "pkh", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 20, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "secret", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 20, + "kind": "Float" + }, + "kind": "named" + } + ], + "name": "Activate_account" + }, + { + "tag": 5, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "source", + "layout": { + "name": "public_key_hash", + "kind": "Ref" + }, + "data_kind": { + "size": 21, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "period", + "layout": { + "size": "Int32", + "kind": "Int" + }, + "data_kind": { + "size": 4, + "kind": "Float" + }, + "kind": "named" + }, + { + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" + }, + { + "name": "proposals", + "layout": { + "layout": { + "kind": "Bytes" + }, + "kind": "Seq" + }, + "data_kind": { + "kind": "Variable" + }, + "kind": "named" + } + ], + "name": "Proposals" + }, + { + "tag": 6, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "source", + "layout": { + "name": "public_key_hash", + "kind": "Ref" + }, + "data_kind": { + "size": 21, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "period", + "layout": { + "size": "Int32", + "kind": "Int" + }, + "data_kind": { + "size": 4, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "proposal", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 32, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "ballot", + "layout": { + "size": "Int8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" + } + ], + "name": "Ballot" + }, + { + "tag": 7, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" + }, + { + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" + }, + { + "name": "op1", + "layout": { + "name": "alpha.inlined.preendorsement", + "kind": "Ref" + }, + "data_kind": { + "kind": "Variable" + }, + "kind": "named" + }, + { + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" + }, + { + "name": "op2", + "layout": { + "name": "alpha.inlined.preendorsement", + "kind": "Ref" + }, + "data_kind": { + "kind": "Variable" + }, + "kind": "named" + } + ], + "name": "Double_preendorsement_evidence" + }, + { + "tag": 17, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" + }, + { + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" + }, + { + "name": "arbitrary", + "layout": { + "kind": "String" + }, + "data_kind": { + "kind": "Variable" + }, + "kind": "named" + } + ], + "name": "Failing_noop" }, { - "name": "contents", - "layout": { - "layout": { - "name": "alpha.operation.alpha.contents", - "kind": "Ref" + "tag": 20, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" }, - "kind": "Seq" - }, - "data_kind": { - "kind": "Variable" - }, - "kind": "named" + { + "name": "slot", + "layout": { + "size": "Uint16", + "kind": "Int" + }, + "data_kind": { + "size": 2, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "level", + "layout": { + "size": "Int32", + "kind": "Int" + }, + "data_kind": { + "size": 4, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "round", + "layout": { + "size": "Int32", + "kind": "Int" + }, + "data_kind": { + "size": 4, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "block_payload_hash", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 32, + "kind": "Float" + }, + "kind": "named" + } + ], + "name": "Preendorsement" }, { - "name": "signature", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "size": 64, - "kind": "Float" - }, - "kind": "named" + "tag": 21, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "slot", + "layout": { + "size": "Uint16", + "kind": "Int" + }, + "data_kind": { + "size": 2, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "level", + "layout": { + "size": "Int32", + "kind": "Int" + }, + "data_kind": { + "size": 4, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "round", + "layout": { + "size": "Int32", + "kind": "Int" + }, + "data_kind": { + "size": 4, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "block_payload_hash", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 32, + "kind": "Float" + }, + "kind": "named" + } + ], + "name": "Endorsement" }, { - "kind": "dyn", - "name": "error_opt", - "num_fields": 1, - "size": "Uint30" + "tag": 22, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "endorser", + "layout": { + "name": "public_key_hash", + "kind": "Ref" + }, + "data_kind": { + "size": 21, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "endorsement", + "layout": { + "name": "Z.t", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" + } + ], + "name": "Dal_slot_availability" }, { - "name": "error", - "layout": { - "kind": "String" - }, - "data_kind": { - "kind": "Variable" - }, - "kind": "named" - } - ] - } - }, - { - "description": { - "title": "alpha.operation.alpha.contents" - }, - "encoding": { - "tag_size": "Uint8", - "kind": { - "kind": "Dynamic" - }, - "cases": [ - { - "tag": 1, + "tag": 107, "fields": [ { - "name": "Tag", + "name": "Tag", + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "source", + "layout": { + "name": "public_key_hash", + "kind": "Ref" + }, + "data_kind": { + "size": 21, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "fee", + "layout": { + "name": "N.t", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" + }, + { + "name": "counter", + "layout": { + "name": "N.t", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" + }, + { + "name": "gas_limit", "layout": { - "size": "Uint8", - "kind": "Int" + "name": "N.t", + "kind": "Ref" }, "data_kind": { - "size": 1, - "kind": "Float" + "kind": "Dynamic" }, "kind": "named" }, { - "name": "level", + "name": "storage_limit", "layout": { - "size": "Int32", - "kind": "Int" + "name": "N.t", + "kind": "Ref" }, "data_kind": { - "size": 4, - "kind": "Float" + "kind": "Dynamic" }, "kind": "named" }, { - "name": "nonce", + "name": "public_key", "layout": { - "kind": "Bytes" + "name": "public_key", + "kind": "Ref" }, "data_kind": { - "size": 32, - "kind": "Float" + "kind": "Dynamic" }, "kind": "named" } ], - "name": "Seed_nonce_revelation" + "name": "Reveal" }, { - "tag": 2, + "tag": 108, "fields": [ { "name": "Tag", @@ -4143,64 +7267,43 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "kind": "dyn", - "num_fields": 1, - "size": "Uint30" - }, - { - "name": "op1", + "name": "source", "layout": { - "name": "alpha.inlined.endorsement", + "name": "public_key_hash", "kind": "Ref" }, "data_kind": { - "kind": "Variable" + "size": 21, + "kind": "Float" }, "kind": "named" }, { - "kind": "dyn", - "num_fields": 1, - "size": "Uint30" - }, - { - "name": "op2", + "name": "fee", "layout": { - "name": "alpha.inlined.endorsement", + "name": "N.t", "kind": "Ref" }, "data_kind": { - "kind": "Variable" + "kind": "Dynamic" }, "kind": "named" - } - ], - "name": "Double_endorsement_evidence" - }, - { - "tag": 3, - "fields": [ + }, { - "name": "Tag", + "name": "counter", "layout": { - "size": "Uint8", - "kind": "Int" + "name": "N.t", + "kind": "Ref" }, "data_kind": { - "size": 1, - "kind": "Float" + "kind": "Dynamic" }, "kind": "named" }, { - "kind": "dyn", - "num_fields": 1, - "size": "Uint30" - }, - { - "name": "bh1", + "name": "gas_limit", "layout": { - "name": "alpha.block_header.alpha.full_header", + "name": "N.t", "kind": "Ref" }, "data_kind": { @@ -4209,66 +7312,59 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "kind": "dyn", - "num_fields": 1, - "size": "Uint30" - }, - { - "name": "bh2", + "name": "storage_limit", "layout": { - "name": "alpha.block_header.alpha.full_header", + "name": "N.t", "kind": "Ref" }, "data_kind": { "kind": "Dynamic" }, "kind": "named" - } - ], - "name": "Double_baking_evidence" - }, - { - "tag": 4, - "fields": [ + }, { - "name": "Tag", + "name": "amount", "layout": { - "size": "Uint8", - "kind": "Int" + "name": "N.t", + "kind": "Ref" }, "data_kind": { - "size": 1, - "kind": "Float" + "kind": "Dynamic" }, "kind": "named" }, { - "name": "pkh", + "name": "destination", "layout": { - "kind": "Bytes" + "name": "alpha.contract_id", + "kind": "Ref" }, "data_kind": { - "size": 20, + "size": 22, "kind": "Float" }, "kind": "named" }, { - "name": "secret", + "kind": "option_indicator", + "name": "parameters" + }, + { + "name": "parameters", "layout": { - "kind": "Bytes" + "name": "X_1777", + "kind": "Ref" }, "data_kind": { - "size": 20, - "kind": "Float" + "kind": "Dynamic" }, "kind": "named" } ], - "name": "Activate_account" + "name": "Transaction" }, { - "tag": 5, + "tag": 109, "fields": [ { "name": "Tag", @@ -4295,105 +7391,92 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "period", + "name": "fee", "layout": { - "size": "Int32", - "kind": "Int" + "name": "N.t", + "kind": "Ref" }, "data_kind": { - "size": 4, - "kind": "Float" + "kind": "Dynamic" }, "kind": "named" }, { - "kind": "dyn", - "num_fields": 1, - "size": "Uint30" - }, - { - "name": "proposals", + "name": "counter", "layout": { - "layout": { - "kind": "Bytes" - }, - "kind": "Seq" + "name": "N.t", + "kind": "Ref" }, "data_kind": { - "kind": "Variable" + "kind": "Dynamic" }, "kind": "named" - } - ], - "name": "Proposals" - }, - { - "tag": 6, - "fields": [ + }, { - "name": "Tag", + "name": "gas_limit", "layout": { - "size": "Uint8", - "kind": "Int" + "name": "N.t", + "kind": "Ref" }, "data_kind": { - "size": 1, - "kind": "Float" + "kind": "Dynamic" }, "kind": "named" }, { - "name": "source", + "name": "storage_limit", "layout": { - "name": "public_key_hash", + "name": "N.t", "kind": "Ref" }, "data_kind": { - "size": 21, - "kind": "Float" + "kind": "Dynamic" }, "kind": "named" }, { - "name": "period", + "name": "balance", "layout": { - "size": "Int32", - "kind": "Int" + "name": "N.t", + "kind": "Ref" }, "data_kind": { - "size": 4, - "kind": "Float" + "kind": "Dynamic" }, "kind": "named" }, { - "name": "proposal", + "kind": "option_indicator", + "name": "delegate" + }, + { + "name": "delegate", "layout": { - "kind": "Bytes" + "name": "public_key_hash", + "kind": "Ref" }, "data_kind": { - "size": 32, + "size": 21, "kind": "Float" }, "kind": "named" }, { - "name": "ballot", + "name": "script", "layout": { - "size": "Int8", - "kind": "Int" + "name": "alpha.scripted.contracts", + "kind": "Ref" }, "data_kind": { - "size": 1, - "kind": "Float" + "kind": "Dynamic" }, "kind": "named" } ], - "name": "Ballot" + "name": "Origination" }, { - "tag": 7, + "tag": 110, "fields": [ { "name": "Tag", @@ -4408,42 +7491,82 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "kind": "dyn", - "num_fields": 1, - "size": "Uint30" + "name": "source", + "layout": { + "name": "public_key_hash", + "kind": "Ref" + }, + "data_kind": { + "size": 21, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "fee", + "layout": { + "name": "N.t", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" + }, + { + "name": "counter", + "layout": { + "name": "N.t", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" + }, + { + "name": "gas_limit", + "layout": { + "name": "N.t", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" }, { - "name": "op1", + "name": "storage_limit", "layout": { - "name": "alpha.inlined.preendorsement", + "name": "N.t", "kind": "Ref" }, "data_kind": { - "kind": "Variable" + "kind": "Dynamic" }, "kind": "named" }, { - "kind": "dyn", - "num_fields": 1, - "size": "Uint30" + "kind": "option_indicator", + "name": "delegate" }, { - "name": "op2", + "name": "delegate", "layout": { - "name": "alpha.inlined.preendorsement", + "name": "public_key_hash", "kind": "Ref" }, "data_kind": { - "kind": "Variable" + "size": 21, + "kind": "Float" }, "kind": "named" } ], - "name": "Double_preendorsement_evidence" + "name": "Delegation" }, { - "tag": 17, + "tag": 111, "fields": [ { "name": "Tag", @@ -4458,90 +7581,81 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "kind": "dyn", - "num_fields": 1, - "size": "Uint30" - }, - { - "name": "arbitrary", + "name": "source", "layout": { - "kind": "String" + "name": "public_key_hash", + "kind": "Ref" }, "data_kind": { - "kind": "Variable" + "size": 21, + "kind": "Float" }, "kind": "named" - } - ], - "name": "Failing_noop" - }, - { - "tag": 20, - "fields": [ + }, { - "name": "Tag", + "name": "fee", "layout": { - "size": "Uint8", - "kind": "Int" + "name": "N.t", + "kind": "Ref" }, "data_kind": { - "size": 1, - "kind": "Float" + "kind": "Dynamic" }, "kind": "named" }, { - "name": "slot", + "name": "counter", "layout": { - "size": "Uint16", - "kind": "Int" + "name": "N.t", + "kind": "Ref" }, "data_kind": { - "size": 2, - "kind": "Float" + "kind": "Dynamic" }, "kind": "named" }, { - "name": "level", + "name": "gas_limit", "layout": { - "size": "Int32", - "kind": "Int" + "name": "N.t", + "kind": "Ref" }, "data_kind": { - "size": 4, - "kind": "Float" + "kind": "Dynamic" }, "kind": "named" }, { - "name": "round", + "name": "storage_limit", "layout": { - "size": "Int32", - "kind": "Int" + "name": "N.t", + "kind": "Ref" }, "data_kind": { - "size": 4, - "kind": "Float" + "kind": "Dynamic" }, "kind": "named" }, { - "name": "block_payload_hash", + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" + }, + { + "name": "value", "layout": { "kind": "Bytes" }, "data_kind": { - "size": 32, - "kind": "Float" + "kind": "Variable" }, "kind": "named" } ], - "name": "Preendorsement" + "name": "Register_global_constant" }, { - "tag": 21, + "tag": 112, "fields": [ { "name": "Tag", @@ -4556,86 +7670,69 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "slot", + "name": "source", "layout": { - "size": "Uint16", - "kind": "Int" + "name": "public_key_hash", + "kind": "Ref" }, "data_kind": { - "size": 2, + "size": 21, "kind": "Float" }, "kind": "named" }, { - "name": "level", + "name": "fee", "layout": { - "size": "Int32", - "kind": "Int" + "name": "N.t", + "kind": "Ref" }, "data_kind": { - "size": 4, - "kind": "Float" + "kind": "Dynamic" }, "kind": "named" }, { - "name": "round", + "name": "counter", "layout": { - "size": "Int32", - "kind": "Int" + "name": "N.t", + "kind": "Ref" }, "data_kind": { - "size": 4, - "kind": "Float" + "kind": "Dynamic" }, "kind": "named" }, { - "name": "block_payload_hash", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "size": 32, - "kind": "Float" - }, - "kind": "named" - } - ], - "name": "Endorsement" - }, - { - "tag": 22, - "fields": [ - { - "name": "Tag", + "name": "gas_limit", "layout": { - "size": "Uint8", - "kind": "Int" + "name": "N.t", + "kind": "Ref" }, "data_kind": { - "size": 1, - "kind": "Float" + "kind": "Dynamic" }, "kind": "named" }, { - "name": "endorser", + "name": "storage_limit", "layout": { - "name": "public_key_hash", + "name": "N.t", "kind": "Ref" }, "data_kind": { - "size": 21, - "kind": "Float" + "kind": "Dynamic" }, "kind": "named" }, { - "name": "endorsement", + "kind": "option_indicator", + "name": "limit" + }, + { + "name": "limit", "layout": { - "name": "Z.t", + "name": "N.t", "kind": "Ref" }, "data_kind": { @@ -4644,10 +7741,10 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" } ], - "name": "Dal_slot_availability" + "name": "Set_deposits_limit" }, { - "tag": 107, + "tag": 150, "fields": [ { "name": "Tag", @@ -4716,23 +7813,12 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "Dynamic" }, "kind": "named" - }, - { - "name": "public_key", - "layout": { - "name": "public_key", - "kind": "Ref" - }, - "data_kind": { - "kind": "Dynamic" - }, - "kind": "named" } ], - "name": "Reveal" + "name": "Tx_rollup_origination" }, { - "tag": 108, + "tag": 151, "fields": [ { "name": "Tag", @@ -4803,36 +7889,39 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "amount", + "name": "rollup", "layout": { - "name": "N.t", - "kind": "Ref" + "kind": "Bytes" }, "data_kind": { - "kind": "Dynamic" + "size": 20, + "kind": "Float" }, "kind": "named" }, { - "name": "destination", + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" + }, + { + "name": "content", "layout": { - "name": "alpha.contract_id", - "kind": "Ref" + "kind": "Bytes" }, "data_kind": { - "size": 22, - "kind": "Float" + "kind": "Variable" }, "kind": "named" }, { "kind": "option_indicator", - "name": "parameters" + "name": "burn_limit" }, { - "name": "parameters", + "name": "burn_limit", "layout": { - "name": "X_144", + "name": "N.t", "kind": "Ref" }, "data_kind": { @@ -4841,10 +7930,10 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" } ], - "name": "Transaction" + "name": "Tx_rollup_submit_batch" }, { - "tag": 109, + "tag": 152, "fields": [ { "name": "Tag", @@ -4915,36 +8004,20 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "balance", - "layout": { - "name": "N.t", - "kind": "Ref" - }, - "data_kind": { - "kind": "Dynamic" - }, - "kind": "named" - }, - { - "kind": "option_indicator", - "name": "delegate" - }, - { - "name": "delegate", + "name": "rollup", "layout": { - "name": "public_key_hash", - "kind": "Ref" + "kind": "Bytes" }, "data_kind": { - "size": 21, + "size": 20, "kind": "Float" }, "kind": "named" }, { - "name": "script", + "name": "commitment", "layout": { - "name": "alpha.scripted.contracts", + "name": "X_1775", "kind": "Ref" }, "data_kind": { @@ -4953,10 +8026,10 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" } ], - "name": "Origination" + "name": "Tx_rollup_commit" }, { - "tag": 110, + "tag": 153, "fields": [ { "name": "Tag", @@ -5027,26 +8100,21 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "kind": "option_indicator", - "name": "delegate" - }, - { - "name": "delegate", + "name": "rollup", "layout": { - "name": "public_key_hash", - "kind": "Ref" + "kind": "Bytes" }, "data_kind": { - "size": 21, + "size": 20, "kind": "Float" }, "kind": "named" } ], - "name": "Delegation" + "name": "Tx_rollup_return_bond" }, { - "tag": 111, + "tag": 154, "fields": [ { "name": "Tag", @@ -5117,25 +8185,21 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "kind": "dyn", - "num_fields": 1, - "size": "Uint30" - }, - { - "name": "value", + "name": "rollup", "layout": { "kind": "Bytes" }, "data_kind": { - "kind": "Variable" + "size": 20, + "kind": "Float" }, "kind": "named" } ], - "name": "Register_global_constant" + "name": "Tx_rollup_finalize_commitment" }, { - "tag": 112, + "tag": 155, "fields": [ { "name": "Tag", @@ -5206,25 +8270,21 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "kind": "option_indicator", - "name": "limit" - }, - { - "name": "limit", + "name": "rollup", "layout": { - "name": "N.t", - "kind": "Ref" + "kind": "Bytes" }, "data_kind": { - "kind": "Dynamic" + "size": 20, + "kind": "Float" }, "kind": "named" } ], - "name": "Set_deposits_limit" + "name": "Tx_rollup_remove_commitment" }, { - "tag": 150, + "tag": 156, "fields": [ { "name": "Tag", @@ -5293,41 +8353,34 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "Dynamic" }, "kind": "named" - } - ], - "name": "Tx_rollup_origination" - }, - { - "tag": 151, - "fields": [ + }, { - "name": "Tag", + "name": "rollup", "layout": { - "size": "Uint8", - "kind": "Int" + "kind": "Bytes" }, "data_kind": { - "size": 1, + "size": 20, "kind": "Float" }, "kind": "named" }, { - "name": "source", + "name": "level", "layout": { - "name": "public_key_hash", - "kind": "Ref" + "size": "Int32", + "kind": "Int" }, "data_kind": { - "size": 21, + "size": 4, "kind": "Float" }, "kind": "named" }, { - "name": "fee", + "name": "message", "layout": { - "name": "N.t", + "name": "X_1648", "kind": "Ref" }, "data_kind": { @@ -5336,7 +8389,7 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "counter", + "name": "message_position", "layout": { "name": "N.t", "kind": "Ref" @@ -5347,34 +8400,60 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "gas_limit", + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" + }, + { + "name": "message_path", "layout": { - "name": "N.t", - "kind": "Ref" + "layout": { + "kind": "Bytes" + }, + "kind": "Seq" }, "data_kind": { - "kind": "Dynamic" + "kind": "Variable" }, "kind": "named" }, { - "name": "storage_limit", + "name": "message_result_hash", "layout": { - "name": "N.t", - "kind": "Ref" + "kind": "Bytes" }, "data_kind": { - "kind": "Dynamic" + "size": 32, + "kind": "Float" }, "kind": "named" }, { - "name": "rollup", + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" + }, + { + "name": "message_result_path", "layout": { - "kind": "Bytes" + "layout": { + "kind": "Bytes" + }, + "kind": "Seq" }, "data_kind": { - "size": 20, + "kind": "Variable" + }, + "kind": "named" + }, + { + "name": "previous_message_result", + "layout": { + "name": "X_1649", + "kind": "Ref" + }, + "data_kind": { + "size": 64, "kind": "Float" }, "kind": "named" @@ -5385,9 +8464,12 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "size": "Uint30" }, { - "name": "content", + "name": "previous_message_result_path", "layout": { - "kind": "Bytes" + "layout": { + "kind": "Bytes" + }, + "kind": "Seq" }, "data_kind": { "kind": "Variable" @@ -5395,13 +8477,9 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "kind": "option_indicator", - "name": "burn_limit" - }, - { - "name": "burn_limit", + "name": "proof", "layout": { - "name": "N.t", + "name": "X_1774", "kind": "Ref" }, "data_kind": { @@ -5410,10 +8488,10 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" } ], - "name": "Tx_rollup_submit_batch" + "name": "Tx_rollup_rejection" }, { - "tag": 152, + "tag": 157, "fields": [ { "name": "Tag", @@ -5484,7 +8562,7 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "rollup", + "name": "tx_rollup", "layout": { "kind": "Bytes" }, @@ -5495,106 +8573,83 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "commitment", - "layout": { - "name": "X_142", - "kind": "Ref" - }, - "data_kind": { - "kind": "Dynamic" - }, - "kind": "named" - } - ], - "name": "Tx_rollup_commit" - }, - { - "tag": 153, - "fields": [ - { - "name": "Tag", + "name": "level", "layout": { - "size": "Uint8", + "size": "Int32", "kind": "Int" }, "data_kind": { - "size": 1, + "size": 4, "kind": "Float" }, "kind": "named" }, { - "name": "source", + "name": "context_hash", "layout": { - "name": "public_key_hash", - "kind": "Ref" + "kind": "Bytes" }, "data_kind": { - "size": 21, + "size": 32, "kind": "Float" }, "kind": "named" }, { - "name": "fee", + "name": "message_index", "layout": { - "name": "N.t", - "kind": "Ref" + "min": -1073741824, + "max": 1073741823, + "kind": "RangedInt" }, "data_kind": { - "kind": "Dynamic" + "size": 4, + "kind": "Float" }, "kind": "named" }, { - "name": "counter", - "layout": { - "name": "N.t", - "kind": "Ref" - }, - "data_kind": { - "kind": "Dynamic" - }, - "kind": "named" + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" }, { - "name": "gas_limit", + "name": "message_result_path", "layout": { - "name": "N.t", - "kind": "Ref" + "layout": { + "kind": "Bytes" + }, + "kind": "Seq" }, "data_kind": { - "kind": "Dynamic" + "kind": "Variable" }, "kind": "named" }, { - "name": "storage_limit", - "layout": { - "name": "N.t", - "kind": "Ref" - }, - "data_kind": { - "kind": "Dynamic" - }, - "kind": "named" + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" }, { - "name": "rollup", + "name": "tickets_info", "layout": { - "kind": "Bytes" + "layout": { + "name": "X_1644", + "kind": "Ref" + }, + "kind": "Seq" }, "data_kind": { - "size": 20, - "kind": "Float" + "kind": "Variable" }, "kind": "named" } ], - "name": "Tx_rollup_return_bond" + "name": "Tx_rollup_dispatch_tickets" }, { - "tag": 154, + "tag": 158, "fields": [ { "name": "Tag", @@ -5665,70 +8720,49 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "rollup", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "size": 20, - "kind": "Float" - }, - "kind": "named" - } - ], - "name": "Tx_rollup_finalize_commitment" - }, - { - "tag": 155, - "fields": [ + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" + }, { - "name": "Tag", + "name": "ticket_contents", "layout": { - "size": "Uint8", - "kind": "Int" + "kind": "Bytes" }, "data_kind": { - "size": 1, - "kind": "Float" + "kind": "Variable" }, "kind": "named" }, { - "name": "source", - "layout": { - "name": "public_key_hash", - "kind": "Ref" - }, - "data_kind": { - "size": 21, - "kind": "Float" - }, - "kind": "named" + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" }, { - "name": "fee", + "name": "ticket_ty", "layout": { - "name": "N.t", - "kind": "Ref" + "kind": "Bytes" }, "data_kind": { - "kind": "Dynamic" + "kind": "Variable" }, "kind": "named" }, { - "name": "counter", + "name": "ticket_ticketer", "layout": { - "name": "N.t", + "name": "alpha.contract_id", "kind": "Ref" }, "data_kind": { - "kind": "Dynamic" + "size": 22, + "kind": "Float" }, "kind": "named" }, { - "name": "gas_limit", + "name": "ticket_amount", "layout": { "name": "N.t", "kind": "Ref" @@ -5739,32 +8773,37 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "storage_limit", + "name": "destination", "layout": { - "name": "N.t", + "name": "alpha.contract_id", "kind": "Ref" }, "data_kind": { - "kind": "Dynamic" + "size": 22, + "kind": "Float" }, "kind": "named" }, { - "name": "rollup", + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" + }, + { + "name": "entrypoint", "layout": { - "kind": "Bytes" + "kind": "String" }, "data_kind": { - "size": 20, - "kind": "Float" + "kind": "Variable" }, "kind": "named" } ], - "name": "Tx_rollup_remove_commitment" + "name": "Transfer_ticket" }, { - "tag": 156, + "tag": 200, "fields": [ { "name": "Tag", @@ -5835,75 +8874,13 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "rollup", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "size": 20, - "kind": "Float" - }, - "kind": "named" - }, - { - "name": "level", - "layout": { - "size": "Int32", - "kind": "Int" - }, - "data_kind": { - "size": 4, - "kind": "Float" - }, - "kind": "named" - }, - { - "name": "message", - "layout": { - "name": "X_15", - "kind": "Ref" - }, - "data_kind": { - "kind": "Dynamic" - }, - "kind": "named" - }, - { - "name": "message_position", + "name": "kind", "layout": { - "name": "N.t", + "name": "X_1643", "kind": "Ref" }, "data_kind": { - "kind": "Dynamic" - }, - "kind": "named" - }, - { - "kind": "dyn", - "num_fields": 1, - "size": "Uint30" - }, - { - "name": "message_path", - "layout": { - "layout": { - "kind": "Bytes" - }, - "kind": "Seq" - }, - "data_kind": { - "kind": "Variable" - }, - "kind": "named" - }, - { - "name": "message_result_hash", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "size": 32, + "size": 2, "kind": "Float" }, "kind": "named" @@ -5914,64 +8891,35 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "size": "Uint30" }, { - "name": "message_result_path", + "name": "boot_sector", "layout": { - "layout": { - "kind": "Bytes" - }, - "kind": "Seq" + "kind": "String" }, "data_kind": { "kind": "Variable" }, "kind": "named" }, - { - "name": "previous_message_result", - "layout": { - "name": "X_16", - "kind": "Ref" - }, - "data_kind": { - "size": 64, - "kind": "Float" - }, - "kind": "named" - }, { "kind": "dyn", "num_fields": 1, "size": "Uint30" }, { - "name": "previous_message_result_path", + "name": "parameters_ty", "layout": { - "layout": { - "kind": "Bytes" - }, - "kind": "Seq" + "kind": "Bytes" }, "data_kind": { "kind": "Variable" }, "kind": "named" - }, - { - "name": "proof", - "layout": { - "name": "X_141", - "kind": "Ref" - }, - "data_kind": { - "kind": "Dynamic" - }, - "kind": "named" } ], - "name": "Tx_rollup_rejection" + "name": "Sc_rollup_originate" }, { - "tag": 157, + "tag": 201, "fields": [ { "name": "Tag", @@ -6041,65 +8989,16 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, "kind": "named" }, - { - "name": "tx_rollup", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "size": 20, - "kind": "Float" - }, - "kind": "named" - }, - { - "name": "level", - "layout": { - "size": "Int32", - "kind": "Int" - }, - "data_kind": { - "size": 4, - "kind": "Float" - }, - "kind": "named" - }, - { - "name": "context_hash", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "size": 32, - "kind": "Float" - }, - "kind": "named" - }, - { - "name": "message_index", - "layout": { - "min": -1073741824, - "max": 1073741823, - "kind": "RangedInt" - }, - "data_kind": { - "size": 4, - "kind": "Float" - }, - "kind": "named" - }, { "kind": "dyn", + "name": "alpha.rollup_address", "num_fields": 1, "size": "Uint30" }, { - "name": "message_result_path", + "name": "rollup", "layout": { - "layout": { - "kind": "Bytes" - }, - "kind": "Seq" + "kind": "String" }, "data_kind": { "kind": "Variable" @@ -6112,10 +9011,10 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "size": "Uint30" }, { - "name": "tickets_info", + "name": "message", "layout": { "layout": { - "name": "X_11", + "name": "X_1642", "kind": "Ref" }, "kind": "Seq" @@ -6126,10 +9025,10 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" } ], - "name": "Tx_rollup_dispatch_tickets" + "name": "Sc_rollup_add_messages" }, { - "tag": 158, + "tag": 202, "fields": [ { "name": "Tag", @@ -6201,13 +9100,14 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, { "kind": "dyn", + "name": "alpha.rollup_address", "num_fields": 1, "size": "Uint30" }, { - "name": "ticket_contents", + "name": "rollup", "layout": { - "kind": "Bytes" + "kind": "String" }, "data_kind": { "kind": "Variable" @@ -6215,34 +9115,70 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "kind": "dyn", - "num_fields": 1, - "size": "Uint30" + "name": "commitment", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 32, + "kind": "Float" + }, + "kind": "named" + } + ], + "name": "Sc_rollup_cement" + }, + { + "tag": 203, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" }, { - "name": "ticket_ty", + "name": "source", "layout": { - "kind": "Bytes" + "name": "public_key_hash", + "kind": "Ref" }, "data_kind": { - "kind": "Variable" + "size": 21, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "fee", + "layout": { + "name": "N.t", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" }, "kind": "named" }, { - "name": "ticket_ticketer", + "name": "counter", "layout": { - "name": "alpha.contract_id", + "name": "N.t", "kind": "Ref" }, "data_kind": { - "size": 22, - "kind": "Float" + "kind": "Dynamic" }, "kind": "named" }, { - "name": "ticket_amount", + "name": "gas_limit", "layout": { "name": "N.t", "kind": "Ref" @@ -6253,24 +9189,24 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "destination", + "name": "storage_limit", "layout": { - "name": "alpha.contract_id", + "name": "N.t", "kind": "Ref" }, "data_kind": { - "size": 22, - "kind": "Float" + "kind": "Dynamic" }, "kind": "named" }, { "kind": "dyn", + "name": "alpha.rollup_address", "num_fields": 1, "size": "Uint30" }, { - "name": "entrypoint", + "name": "rollup", "layout": { "kind": "String" }, @@ -6278,12 +9214,24 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "Variable" }, "kind": "named" + }, + { + "name": "commitment", + "layout": { + "name": "X_1641", + "kind": "Ref" + }, + "data_kind": { + "size": 76, + "kind": "Float" + }, + "kind": "named" } ], - "name": "Transfer_ticket" + "name": "Sc_rollup_publish" }, { - "tag": 200, + "tag": 204, "fields": [ { "name": "Tag", @@ -6353,25 +9301,14 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, "kind": "named" }, - { - "name": "kind", - "layout": { - "name": "X_10", - "kind": "Ref" - }, - "data_kind": { - "size": 2, - "kind": "Float" - }, - "kind": "named" - }, { "kind": "dyn", + "name": "alpha.rollup_address", "num_fields": 1, "size": "Uint30" }, { - "name": "boot_sector", + "name": "rollup", "layout": { "kind": "String" }, @@ -6381,25 +9318,33 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "kind": "dyn", - "num_fields": 1, - "size": "Uint30" + "name": "opponent", + "layout": { + "name": "public_key_hash", + "kind": "Ref" + }, + "data_kind": { + "size": 21, + "kind": "Float" + }, + "kind": "named" }, { - "name": "parameters_ty", + "name": "refutation", "layout": { - "kind": "Bytes" + "name": "X_3", + "kind": "Ref" }, "data_kind": { - "kind": "Variable" + "kind": "Dynamic" }, "kind": "named" } ], - "name": "Sc_rollup_originate" + "name": "Sc_rollup_refute" }, { - "tag": 201, + "tag": 205, "fields": [ { "name": "Tag", @@ -6486,29 +9431,22 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "kind": "dyn", - "num_fields": 1, - "size": "Uint30" - }, - { - "name": "message", + "name": "stakers", "layout": { - "layout": { - "name": "X_9", - "kind": "Ref" - }, - "kind": "Seq" + "name": "X_2", + "kind": "Ref" }, "data_kind": { - "kind": "Variable" + "size": 42, + "kind": "Float" }, "kind": "named" } ], - "name": "Sc_rollup_add_messages" + "name": "Sc_rollup_timeout" }, { - "tag": 202, + "tag": 206, "fields": [ { "name": "Tag", @@ -6595,7 +9533,7 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "commitment", + "name": "cemented_commitment", "layout": { "kind": "Bytes" }, @@ -6604,12 +9542,67 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "Float" }, "kind": "named" + }, + { + "name": "outbox_level", + "layout": { + "size": "Int32", + "kind": "Int" + }, + "data_kind": { + "size": 4, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "message_index", + "layout": { + "min": -1073741824, + "max": 1073741823, + "kind": "RangedInt" + }, + "data_kind": { + "size": 4, + "kind": "Float" + }, + "kind": "named" + }, + { + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" + }, + { + "name": "inclusion proof", + "layout": { + "kind": "String" + }, + "data_kind": { + "kind": "Variable" + }, + "kind": "named" + }, + { + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" + }, + { + "name": "atomic_transaction_batch", + "layout": { + "kind": "String" + }, + "data_kind": { + "kind": "Variable" + }, + "kind": "named" } ], - "name": "Sc_rollup_cement" + "name": "Sc_rollup_atomic_batch" }, { - "tag": 203, + "tag": 230, "fields": [ { "name": "Tag", @@ -6647,71 +9640,395 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "counter", + "name": "counter", + "layout": { + "name": "N.t", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" + }, + { + "name": "gas_limit", + "layout": { + "name": "N.t", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" + }, + { + "name": "storage_limit", + "layout": { + "name": "N.t", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" + }, + { + "name": "slot", + "layout": { + "name": "X_1", + "kind": "Ref" + }, + "data_kind": { + "size": 9, + "kind": "Float" + }, + "kind": "named" + } + ], + "name": "Dal_publish_slot_header" + } + ] + } + }, + { + "description": { + "title": "alpha.inlined.endorsement" + }, + "encoding": { + "fields": [ + { + "name": "branch", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 32, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "operations", + "layout": { + "name": "alpha.inlined.endorsement_mempool.contents", + "kind": "Ref" + }, + "data_kind": { + "size": 43, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "signature", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "kind": "Variable" + }, + "kind": "named" + } + ] + } + }, + { + "description": { + "title": "alpha.inlined.endorsement_mempool.contents" + }, + "encoding": { + "tag_size": "Uint8", + "kind": { + "size": 43, + "kind": "Float" + }, + "cases": [ + { + "tag": 21, + "fields": [ + { + "name": "Tag", "layout": { - "name": "N.t", - "kind": "Ref" + "size": "Uint8", + "kind": "Int" }, "data_kind": { - "kind": "Dynamic" + "size": 1, + "kind": "Float" }, "kind": "named" }, { - "name": "gas_limit", + "name": "slot", "layout": { - "name": "N.t", - "kind": "Ref" + "size": "Uint16", + "kind": "Int" }, "data_kind": { - "kind": "Dynamic" + "size": 2, + "kind": "Float" }, "kind": "named" }, { - "name": "storage_limit", + "name": "level", "layout": { - "name": "N.t", - "kind": "Ref" + "size": "Int32", + "kind": "Int" }, "data_kind": { - "kind": "Dynamic" + "size": 4, + "kind": "Float" }, "kind": "named" }, { - "kind": "dyn", - "name": "alpha.rollup_address", - "num_fields": 1, - "size": "Uint30" - }, - { - "name": "rollup", + "name": "round", "layout": { - "kind": "String" + "size": "Int32", + "kind": "Int" }, "data_kind": { - "kind": "Variable" + "size": 4, + "kind": "Float" }, "kind": "named" }, { - "name": "commitment", + "name": "block_payload_hash", "layout": { - "name": "X_8", - "kind": "Ref" + "kind": "Bytes" }, "data_kind": { - "size": 76, + "size": 32, "kind": "Float" }, "kind": "named" } ], - "name": "Sc_rollup_publish" + "name": "Endorsement" + } + ] + } + }, + { + "description": { + "title": "alpha.block_header.alpha.full_header" + }, + "encoding": { + "fields": [ + { + "name": "level", + "layout": { + "size": "Int32", + "kind": "Int" + }, + "data_kind": { + "size": 4, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "proto", + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "predecessor", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 32, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "timestamp", + "layout": { + "size": "Int64", + "kind": "Int" + }, + "data_kind": { + "size": 8, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "validation_pass", + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "operations_hash", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 32, + "kind": "Float" + }, + "kind": "named" + }, + { + "kind": "dyn", + "name": "fitness", + "num_fields": 1, + "size": "Uint30" + }, + { + "name": "fitness", + "layout": { + "layout": { + "name": "fitness.elem", + "kind": "Ref" + }, + "kind": "Seq" + }, + "data_kind": { + "kind": "Variable" + }, + "kind": "named" + }, + { + "name": "context", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 32, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "payload_hash", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 32, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "payload_round", + "layout": { + "size": "Int32", + "kind": "Int" + }, + "data_kind": { + "size": 4, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "proof_of_work_nonce", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 8, + "kind": "Float" + }, + "kind": "named" + }, + { + "kind": "option_indicator", + "name": "seed_nonce_hash" + }, + { + "name": "seed_nonce_hash", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 32, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "liquidity_baking_toggle_vote", + "layout": { + "size": "Int8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "signature", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 64, + "kind": "Float" + }, + "kind": "named" + } + ] + } + }, + { + "description": { + "title": "fitness.elem" + }, + "encoding": { + "fields": [ + { + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" }, { - "tag": 204, + "layout": { + "kind": "Bytes" + }, + "kind": "anon", + "data_kind": { + "kind": "Variable" + } + } + ] + } + }, + { + "description": { + "title": "public_key_hash" + }, + "encoding": { + "tag_size": "Uint8", + "kind": { + "size": 21, + "kind": "Float" + }, + "cases": [ + { + "tag": 0, "fields": [ { "name": "Tag", @@ -6726,105 +10043,21 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "source", - "layout": { - "name": "public_key_hash", - "kind": "Ref" - }, - "data_kind": { - "size": 21, - "kind": "Float" - }, - "kind": "named" - }, - { - "name": "fee", - "layout": { - "name": "N.t", - "kind": "Ref" - }, - "data_kind": { - "kind": "Dynamic" - }, - "kind": "named" - }, - { - "name": "counter", - "layout": { - "name": "N.t", - "kind": "Ref" - }, - "data_kind": { - "kind": "Dynamic" - }, - "kind": "named" - }, - { - "name": "gas_limit", - "layout": { - "name": "N.t", - "kind": "Ref" - }, - "data_kind": { - "kind": "Dynamic" - }, - "kind": "named" - }, - { - "name": "storage_limit", - "layout": { - "name": "N.t", - "kind": "Ref" - }, - "data_kind": { - "kind": "Dynamic" - }, - "kind": "named" - }, - { - "kind": "dyn", - "name": "alpha.rollup_address", - "num_fields": 1, - "size": "Uint30" - }, - { - "name": "rollup", - "layout": { - "kind": "String" - }, - "data_kind": { - "kind": "Variable" - }, - "kind": "named" - }, - { - "name": "opponent", + "name": "Ed25519.Public_key_hash", "layout": { - "name": "public_key_hash", - "kind": "Ref" + "kind": "Bytes" }, "data_kind": { - "size": 21, + "size": 20, "kind": "Float" }, "kind": "named" - }, - { - "name": "refutation", - "layout": { - "name": "X_3", - "kind": "Ref" - }, - "data_kind": { - "kind": "Dynamic" - }, - "kind": "named" } ], - "name": "Sc_rollup_refute" + "name": "Ed25519" }, { - "tag": 205, + "tag": 1, "fields": [ { "name": "Tag", @@ -6839,208 +10072,136 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "source", - "layout": { - "name": "public_key_hash", - "kind": "Ref" - }, - "data_kind": { - "size": 21, - "kind": "Float" - }, - "kind": "named" - }, - { - "name": "fee", - "layout": { - "name": "N.t", - "kind": "Ref" - }, - "data_kind": { - "kind": "Dynamic" - }, - "kind": "named" - }, - { - "name": "counter", - "layout": { - "name": "N.t", - "kind": "Ref" - }, - "data_kind": { - "kind": "Dynamic" - }, - "kind": "named" - }, - { - "name": "gas_limit", - "layout": { - "name": "N.t", - "kind": "Ref" - }, - "data_kind": { - "kind": "Dynamic" - }, - "kind": "named" - }, - { - "name": "storage_limit", - "layout": { - "name": "N.t", - "kind": "Ref" - }, - "data_kind": { - "kind": "Dynamic" - }, - "kind": "named" - }, - { - "kind": "dyn", - "name": "alpha.rollup_address", - "num_fields": 1, - "size": "Uint30" - }, - { - "name": "rollup", - "layout": { - "kind": "String" - }, - "data_kind": { - "kind": "Variable" - }, - "kind": "named" - }, - { - "name": "stakers", + "name": "Secp256k1.Public_key_hash", "layout": { - "name": "X_2", - "kind": "Ref" + "kind": "Bytes" }, "data_kind": { - "size": 42, + "size": 20, "kind": "Float" }, "kind": "named" } ], - "name": "Sc_rollup_timeout" + "name": "Secp256k1" }, { - "tag": 206, + "tag": 2, "fields": [ { "name": "Tag", - "layout": { - "size": "Uint8", - "kind": "Int" - }, - "data_kind": { - "size": 1, - "kind": "Float" - }, - "kind": "named" - }, - { - "name": "source", - "layout": { - "name": "public_key_hash", - "kind": "Ref" - }, - "data_kind": { - "size": 21, - "kind": "Float" - }, - "kind": "named" - }, - { - "name": "fee", - "layout": { - "name": "N.t", - "kind": "Ref" - }, - "data_kind": { - "kind": "Dynamic" - }, - "kind": "named" - }, - { - "name": "counter", - "layout": { - "name": "N.t", - "kind": "Ref" - }, - "data_kind": { - "kind": "Dynamic" - }, - "kind": "named" - }, - { - "name": "gas_limit", - "layout": { - "name": "N.t", - "kind": "Ref" - }, - "data_kind": { - "kind": "Dynamic" - }, - "kind": "named" - }, - { - "name": "storage_limit", - "layout": { - "name": "N.t", - "kind": "Ref" + "layout": { + "size": "Uint8", + "kind": "Int" }, "data_kind": { - "kind": "Dynamic" + "size": 1, + "kind": "Float" }, "kind": "named" }, { - "kind": "dyn", - "name": "alpha.rollup_address", - "num_fields": 1, - "size": "Uint30" - }, - { - "name": "rollup", + "name": "P256.Public_key_hash", "layout": { - "kind": "String" + "kind": "Bytes" }, "data_kind": { - "kind": "Variable" + "size": 20, + "kind": "Float" }, "kind": "named" - }, + } + ], + "name": "P256" + } + ] + } + }, + { + "description": { + "title": "alpha.inlined.preendorsement" + }, + "encoding": { + "fields": [ + { + "name": "branch", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 32, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "operations", + "layout": { + "name": "alpha.inlined.preendorsement.contents", + "kind": "Ref" + }, + "data_kind": { + "size": 43, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "signature", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "kind": "Variable" + }, + "kind": "named" + } + ] + } + }, + { + "description": { + "title": "alpha.inlined.preendorsement.contents" + }, + "encoding": { + "tag_size": "Uint8", + "kind": { + "size": 43, + "kind": "Float" + }, + "cases": [ + { + "tag": 20, + "fields": [ { - "name": "cemented_commitment", + "name": "Tag", "layout": { - "kind": "Bytes" + "size": "Uint8", + "kind": "Int" }, "data_kind": { - "size": 32, + "size": 1, "kind": "Float" }, "kind": "named" }, { - "name": "outbox_level", + "name": "slot", "layout": { - "size": "Int32", + "size": "Uint16", "kind": "Int" }, "data_kind": { - "size": 4, + "size": 2, "kind": "Float" }, "kind": "named" }, { - "name": "message_index", + "name": "level", "layout": { - "min": -1073741824, - "max": 1073741823, - "kind": "RangedInt" + "size": "Int32", + "kind": "Int" }, "data_kind": { "size": 4, @@ -7049,40 +10210,66 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "kind": "dyn", - "num_fields": 1, - "size": "Uint30" - }, - { - "name": "inclusion proof", + "name": "round", "layout": { - "kind": "String" + "size": "Int32", + "kind": "Int" }, "data_kind": { - "kind": "Variable" + "size": 4, + "kind": "Float" }, "kind": "named" }, { - "kind": "dyn", - "num_fields": 1, - "size": "Uint30" - }, - { - "name": "atomic_transaction_batch", + "name": "block_payload_hash", "layout": { - "kind": "String" + "kind": "Bytes" }, "data_kind": { - "kind": "Variable" + "size": 32, + "kind": "Float" }, "kind": "named" } ], - "name": "Sc_rollup_atomic_batch" - }, + "name": "Preendorsement" + } + ] + } + }, + { + "description": { + "title": "Z.t", + "description": "A variable-length sequence of bytes encoding a Zarith integer. Each byte has a running unary size bit: the most significant bit of each byte indicates whether this is the last byte in the sequence (0) or whether the sequence continues (1). The second most significant bit of the first byte is reserved for the sign (0 for positive, 1 for negative). Size and sign bits ignored, the data is the binary representation of the absolute value of the number in little-endian order." + }, + "encoding": { + "fields": [ { - "tag": 230, + "name": "Z.t", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" + } + ] + } + }, + { + "description": { + "title": "public_key" + }, + "encoding": { + "tag_size": "Uint8", + "kind": { + "kind": "Dynamic" + }, + "cases": [ + { + "tag": 0, "fields": [ { "name": "Tag", @@ -7097,110 +10284,124 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "source", + "name": "Ed25519.Public_key", "layout": { - "name": "public_key_hash", - "kind": "Ref" + "kind": "Bytes" }, "data_kind": { - "size": 21, + "size": 32, "kind": "Float" }, "kind": "named" - }, - { - "name": "fee", - "layout": { - "name": "N.t", - "kind": "Ref" - }, - "data_kind": { - "kind": "Dynamic" - }, - "kind": "named" - }, + } + ], + "name": "Ed25519" + }, + { + "tag": 1, + "fields": [ { - "name": "counter", + "name": "Tag", "layout": { - "name": "N.t", - "kind": "Ref" + "size": "Uint8", + "kind": "Int" }, "data_kind": { - "kind": "Dynamic" + "size": 1, + "kind": "Float" }, "kind": "named" }, { - "name": "gas_limit", + "name": "Secp256k1.Public_key", "layout": { - "name": "N.t", - "kind": "Ref" + "kind": "Bytes" }, "data_kind": { - "kind": "Dynamic" + "size": 33, + "kind": "Float" }, "kind": "named" - }, + } + ], + "name": "Secp256k1" + }, + { + "tag": 2, + "fields": [ { - "name": "storage_limit", + "name": "Tag", "layout": { - "name": "N.t", - "kind": "Ref" + "size": "Uint8", + "kind": "Int" }, "data_kind": { - "kind": "Dynamic" + "size": 1, + "kind": "Float" }, "kind": "named" }, { - "name": "slot", + "name": "P256.Public_key", "layout": { - "name": "X_1", - "kind": "Ref" + "kind": "Bytes" }, "data_kind": { - "size": 9, + "size": 33, "kind": "Float" }, "kind": "named" } ], - "name": "Dal_publish_slot_header" + "name": "P256" + } + ] + } + }, + { + "description": { + "title": "N.t", + "description": "A variable-length sequence of bytes encoding a Zarith natural number. Each byte has a running unary size bit: the most significant bit of each byte indicates whether this is the last byte in the sequence (0) or whether the sequence continues (1). Size bits ignored, the data is the binary representation of the number in little-endian order." + }, + "encoding": { + "fields": [ + { + "name": "N.t", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" } ] } }, { "description": { - "title": "alpha.inlined.endorsement" + "title": "X_1777" }, "encoding": { "fields": [ { - "name": "branch", + "name": "entrypoint", "layout": { - "kind": "Bytes" + "name": "alpha.entrypoint", + "kind": "Ref" }, "data_kind": { - "size": 32, - "kind": "Float" + "kind": "Dynamic" }, "kind": "named" }, { - "name": "operations", - "layout": { - "name": "alpha.inlined.endorsement_mempool.contents", - "kind": "Ref" - }, - "data_kind": { - "size": 43, - "kind": "Float" - }, - "kind": "named" + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" }, { - "name": "signature", + "name": "value", "layout": { "kind": "Bytes" }, @@ -7214,17 +10415,16 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, { "description": { - "title": "alpha.inlined.endorsement_mempool.contents" + "title": "alpha.entrypoint" }, "encoding": { "tag_size": "Uint8", "kind": { - "size": 43, - "kind": "Float" + "kind": "Dynamic" }, "cases": [ { - "tag": 21, + "tag": 0, "fields": [ { "name": "Tag", @@ -7239,148 +10439,264 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "slot", "layout": { - "size": "Uint16", + "kind": "Zero_width" + }, + "kind": "anon", + "data_kind": { + "size": 0, + "kind": "Float" + } + } + ], + "name": "default" + }, + { + "tag": 1, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", "kind": "Int" }, "data_kind": { - "size": 2, + "size": 1, "kind": "Float" }, "kind": "named" }, { - "name": "level", "layout": { - "size": "Int32", + "kind": "Zero_width" + }, + "kind": "anon", + "data_kind": { + "size": 0, + "kind": "Float" + } + } + ], + "name": "root" + }, + { + "tag": 2, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", "kind": "Int" }, "data_kind": { - "size": 4, + "size": 1, "kind": "Float" }, "kind": "named" }, { - "name": "round", "layout": { - "size": "Int32", + "kind": "Zero_width" + }, + "kind": "anon", + "data_kind": { + "size": 0, + "kind": "Float" + } + } + ], + "name": "do" + }, + { + "tag": 3, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", "kind": "Int" }, "data_kind": { - "size": 4, + "size": 1, "kind": "Float" }, "kind": "named" }, { - "name": "block_payload_hash", "layout": { - "kind": "Bytes" + "kind": "Zero_width" }, + "kind": "anon", "data_kind": { - "size": 32, + "size": 0, + "kind": "Float" + } + } + ], + "name": "set_delegate" + }, + { + "tag": 4, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" + }, + { + "layout": { + "kind": "Zero_width" + }, + "kind": "anon", + "data_kind": { + "size": 0, + "kind": "Float" + } + } + ], + "name": "remove_delegate" + }, + { + "tag": 255, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "data_kind": { + "size": 1, "kind": "Float" }, "kind": "named" + }, + { + "kind": "dyn", + "num_fields": 1, + "size": "Uint8" + }, + { + "layout": { + "kind": "String" + }, + "kind": "anon", + "data_kind": { + "kind": "Variable" + } } ], - "name": "Endorsement" + "name": "named" } ] } }, { "description": { - "title": "alpha.block_header.alpha.full_header" + "title": "alpha.contract_id" }, "encoding": { - "fields": [ - { - "name": "level", - "layout": { - "size": "Int32", - "kind": "Int" - }, - "data_kind": { - "size": 4, - "kind": "Float" - }, - "kind": "named" - }, - { - "name": "proto", - "layout": { - "size": "Uint8", - "kind": "Int" - }, - "data_kind": { - "size": 1, - "kind": "Float" - }, - "kind": "named" - }, - { - "name": "predecessor", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "size": 32, - "kind": "Float" - }, - "kind": "named" - }, - { - "name": "timestamp", - "layout": { - "size": "Int64", - "kind": "Int" - }, - "data_kind": { - "size": 8, - "kind": "Float" - }, - "kind": "named" - }, + "tag_size": "Uint8", + "kind": { + "size": 22, + "kind": "Float" + }, + "cases": [ { - "name": "validation_pass", - "layout": { - "size": "Uint8", - "kind": "Int" - }, - "data_kind": { - "size": 1, - "kind": "Float" - }, - "kind": "named" + "tag": 0, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "Signature.Public_key_hash", + "layout": { + "name": "public_key_hash", + "kind": "Ref" + }, + "data_kind": { + "size": 21, + "kind": "Float" + }, + "kind": "named" + } + ], + "name": "Implicit" }, { - "name": "operations_hash", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "size": 32, - "kind": "Float" - }, - "kind": "named" - }, + "tag": 1, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "Contract_hash", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 20, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "padding", + "layout": { + "kind": "Padding" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" + } + ], + "name": "Originated" + } + ] + } + }, + { + "description": { + "title": "alpha.scripted.contracts" + }, + "encoding": { + "fields": [ { "kind": "dyn", - "name": "fitness", "num_fields": 1, "size": "Uint30" }, { - "name": "fitness", + "name": "code", "layout": { - "layout": { - "name": "fitness.elem", - "kind": "Ref" - }, - "kind": "Seq" + "kind": "Bytes" }, "data_kind": { "kind": "Variable" @@ -7388,29 +10704,31 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "context", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "size": 32, - "kind": "Float" - }, - "kind": "named" + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" }, { - "name": "payload_hash", + "name": "storage", "layout": { "kind": "Bytes" }, "data_kind": { - "size": 32, - "kind": "Float" + "kind": "Variable" }, "kind": "named" - }, + } + ] + } + }, + { + "description": { + "title": "X_1775" + }, + "encoding": { + "fields": [ { - "name": "payload_round", + "name": "level", "layout": { "size": "Int32", "kind": "Int" @@ -7422,50 +10740,41 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "proof_of_work_nonce", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "size": 8, - "kind": "Float" - }, - "kind": "named" - }, - { - "kind": "option_indicator", - "name": "seed_nonce_hash" + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" }, { - "name": "seed_nonce_hash", + "name": "messages", "layout": { - "kind": "Bytes" + "layout": { + "kind": "Bytes" + }, + "kind": "Seq" }, "data_kind": { - "size": 32, - "kind": "Float" + "kind": "Variable" }, "kind": "named" }, { - "name": "liquidity_baking_toggle_vote", + "name": "predecessor", "layout": { - "size": "Int8", - "kind": "Int" + "name": "X_1776", + "kind": "Ref" }, "data_kind": { - "size": 1, - "kind": "Float" + "kind": "Dynamic" }, "kind": "named" }, { - "name": "signature", + "name": "inbox_merkle_root", "layout": { "kind": "Bytes" }, "data_kind": { - "size": 64, + "size": 32, "kind": "Float" }, "kind": "named" @@ -7475,36 +10784,12 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, { "description": { - "title": "fitness.elem" - }, - "encoding": { - "fields": [ - { - "kind": "dyn", - "num_fields": 1, - "size": "Uint30" - }, - { - "layout": { - "kind": "Bytes" - }, - "kind": "anon", - "data_kind": { - "kind": "Variable" - } - } - ] - } - }, - { - "description": { - "title": "public_key_hash" + "title": "X_1776" }, "encoding": { "tag_size": "Uint8", "kind": { - "size": 21, - "kind": "Float" + "kind": "Dynamic" }, "cases": [ { @@ -7523,18 +10808,17 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "Ed25519.Public_key_hash", "layout": { - "kind": "Bytes" + "kind": "Zero_width" }, + "kind": "anon", "data_kind": { - "size": 20, + "size": 0, "kind": "Float" - }, - "kind": "named" + } } ], - "name": "Ed25519" + "name": "None" }, { "tag": 1, @@ -7552,106 +10836,34 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "Secp256k1.Public_key_hash", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "size": 20, - "kind": "Float" - }, - "kind": "named" - } - ], - "name": "Secp256k1" - }, - { - "tag": 2, - "fields": [ - { - "name": "Tag", - "layout": { - "size": "Uint8", - "kind": "Int" - }, - "data_kind": { - "size": 1, - "kind": "Float" - }, - "kind": "named" - }, - { - "name": "P256.Public_key_hash", + "name": "Commitment_hash", "layout": { "kind": "Bytes" }, "data_kind": { - "size": 20, + "size": 32, "kind": "Float" }, "kind": "named" } ], - "name": "P256" - } - ] - } - }, - { - "description": { - "title": "alpha.inlined.preendorsement" - }, - "encoding": { - "fields": [ - { - "name": "branch", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "size": 32, - "kind": "Float" - }, - "kind": "named" - }, - { - "name": "operations", - "layout": { - "name": "alpha.inlined.preendorsement.contents", - "kind": "Ref" - }, - "data_kind": { - "size": 43, - "kind": "Float" - }, - "kind": "named" - }, - { - "name": "signature", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "kind": "Variable" - }, - "kind": "named" + "name": "Some" } ] } }, { "description": { - "title": "alpha.inlined.preendorsement.contents" + "title": "X_1774" }, "encoding": { "tag_size": "Uint8", "kind": { - "size": 43, - "kind": "Float" + "kind": "Dynamic" }, "cases": [ { - "tag": 20, + "tag": 0, "fields": [ { "name": "Tag", @@ -7666,90 +10878,51 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "slot", "layout": { - "size": "Uint16", + "size": "Int16", "kind": "Int" }, + "kind": "anon", "data_kind": { "size": 2, "kind": "Float" - }, - "kind": "named" + } }, { - "name": "level", "layout": { - "size": "Int32", - "kind": "Int" + "kind": "Bytes" }, + "kind": "anon", "data_kind": { - "size": 4, + "size": 32, "kind": "Float" - }, - "kind": "named" + } }, { - "name": "round", "layout": { - "size": "Int32", - "kind": "Int" + "kind": "Bytes" }, + "kind": "anon", "data_kind": { - "size": 4, + "size": 32, "kind": "Float" - }, - "kind": "named" + } }, { - "name": "block_payload_hash", "layout": { - "kind": "Bytes" + "name": "X_1650", + "kind": "Ref" }, + "kind": "anon", "data_kind": { - "size": 32, - "kind": "Float" - }, - "kind": "named" + "kind": "Dynamic" + } } ], - "name": "Preendorsement" - } - ] - } - }, - { - "description": { - "title": "Z.t", - "description": "A variable-length sequence of bytes encoding a Zarith integer. Each byte has a running unary size bit: the most significant bit of each byte indicates whether this is the last byte in the sequence (0) or whether the sequence continues (1). The second most significant bit of the first byte is reserved for the sign (0 for positive, 1 for negative). Size and sign bits ignored, the data is the binary representation of the absolute value of the number in little-endian order." - }, - "encoding": { - "fields": [ - { - "name": "Z.t", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "kind": "Dynamic" - }, - "kind": "named" - } - ] - } - }, - { - "description": { - "title": "public_key" - }, - "encoding": { - "tag_size": "Uint8", - "kind": { - "kind": "Dynamic" - }, - "cases": [ + "name": "case 0" + }, { - "tag": 0, + "tag": 1, "fields": [ { "name": "Tag", @@ -7764,21 +10937,51 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "Ed25519.Public_key", + "layout": { + "size": "Int16", + "kind": "Int" + }, + "kind": "anon", + "data_kind": { + "size": 2, + "kind": "Float" + } + }, + { "layout": { "kind": "Bytes" }, + "kind": "anon", "data_kind": { "size": 32, "kind": "Float" + } + }, + { + "layout": { + "kind": "Bytes" }, - "kind": "named" + "kind": "anon", + "data_kind": { + "size": 32, + "kind": "Float" + } + }, + { + "layout": { + "name": "X_1650", + "kind": "Ref" + }, + "kind": "anon", + "data_kind": { + "kind": "Dynamic" + } } ], - "name": "Ed25519" + "name": "case 1" }, { - "tag": 1, + "tag": 2, "fields": [ { "name": "Tag", @@ -7793,21 +10996,51 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "Secp256k1.Public_key", + "layout": { + "size": "Int16", + "kind": "Int" + }, + "kind": "anon", + "data_kind": { + "size": 2, + "kind": "Float" + } + }, + { "layout": { "kind": "Bytes" }, + "kind": "anon", "data_kind": { - "size": 33, + "size": 32, "kind": "Float" + } + }, + { + "layout": { + "kind": "Bytes" }, - "kind": "named" + "kind": "anon", + "data_kind": { + "size": 32, + "kind": "Float" + } + }, + { + "layout": { + "name": "X_1650", + "kind": "Ref" + }, + "kind": "anon", + "data_kind": { + "kind": "Dynamic" + } } ], - "name": "Secp256k1" + "name": "case 2" }, { - "tag": 2, + "tag": 3, "fields": [ { "name": "Tag", @@ -7822,80 +11055,55 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "P256.Public_key", + "layout": { + "size": "Int16", + "kind": "Int" + }, + "kind": "anon", + "data_kind": { + "size": 2, + "kind": "Float" + } + }, + { "layout": { "kind": "Bytes" }, + "kind": "anon", "data_kind": { - "size": 33, + "size": 32, "kind": "Float" + } + }, + { + "layout": { + "kind": "Bytes" }, - "kind": "named" + "kind": "anon", + "data_kind": { + "size": 32, + "kind": "Float" + } + }, + { + "layout": { + "name": "X_1650", + "kind": "Ref" + }, + "kind": "anon", + "data_kind": { + "kind": "Dynamic" + } } ], - "name": "P256" - } - ] - } - }, - { - "description": { - "title": "N.t", - "description": "A variable-length sequence of bytes encoding a Zarith natural number. Each byte has a running unary size bit: the most significant bit of each byte indicates whether this is the last byte in the sequence (0) or whether the sequence continues (1). Size bits ignored, the data is the binary representation of the number in little-endian order." - }, - "encoding": { - "fields": [ - { - "name": "N.t", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "kind": "Dynamic" - }, - "kind": "named" - } - ] - } - }, - { - "description": { - "title": "X_144" - }, - "encoding": { - "fields": [ - { - "name": "entrypoint", - "layout": { - "name": "alpha.entrypoint", - "kind": "Ref" - }, - "data_kind": { - "kind": "Dynamic" - }, - "kind": "named" - }, - { - "kind": "dyn", - "num_fields": 1, - "size": "Uint30" - }, - { - "name": "value", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "kind": "Variable" - }, - "kind": "named" + "name": "case 3" } ] } }, { "description": { - "title": "alpha.entrypoint" + "title": "X_1773" }, "encoding": { "tag_size": "Uint8", @@ -7920,7 +11128,19 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, { "layout": { - "kind": "Zero_width" + "size": "Uint8", + "kind": "Int" + }, + "kind": "anon", + "data_kind": { + "size": 1, + "kind": "Float" + } + }, + { + "layout": { + "name": "X_1772", + "kind": "Ref" }, "kind": "anon", "data_kind": { @@ -7929,7 +11149,7 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' } } ], - "name": "default" + "name": "case 0" }, { "tag": 1, @@ -7948,7 +11168,19 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, { "layout": { - "kind": "Zero_width" + "size": "Uint16", + "kind": "Int" + }, + "kind": "anon", + "data_kind": { + "size": 2, + "kind": "Float" + } + }, + { + "layout": { + "name": "X_1772", + "kind": "Ref" }, "kind": "anon", "data_kind": { @@ -7957,7 +11189,7 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' } } ], - "name": "root" + "name": "case 1" }, { "tag": 2, @@ -7976,7 +11208,19 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, { "layout": { - "kind": "Zero_width" + "size": "Int32", + "kind": "Int" + }, + "kind": "anon", + "data_kind": { + "size": 4, + "kind": "Float" + } + }, + { + "layout": { + "name": "X_1772", + "kind": "Ref" }, "kind": "anon", "data_kind": { @@ -7985,7 +11229,7 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' } } ], - "name": "do" + "name": "case 2" }, { "tag": 3, @@ -8004,35 +11248,19 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, { "layout": { - "kind": "Zero_width" + "size": "Int64", + "kind": "Int" }, "kind": "anon", "data_kind": { - "size": 0, + "size": 8, "kind": "Float" } - } - ], - "name": "set_delegate" - }, - { - "tag": 4, - "fields": [ - { - "name": "Tag", - "layout": { - "size": "Uint8", - "kind": "Int" - }, - "data_kind": { - "size": 1, - "kind": "Float" - }, - "kind": "named" }, { "layout": { - "kind": "Zero_width" + "name": "X_1772", + "kind": "Ref" }, "kind": "anon", "data_kind": { @@ -8041,10 +11269,10 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' } } ], - "name": "remove_delegate" + "name": "case 3" }, { - "tag": 255, + "tag": 4, "fields": [ { "name": "Tag", @@ -8059,38 +11287,32 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "kind": "dyn", - "num_fields": 1, - "size": "Uint8" + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "kind": "anon", + "data_kind": { + "size": 1, + "kind": "Float" + } }, { "layout": { - "kind": "String" + "name": "X_1768", + "kind": "Ref" }, "kind": "anon", "data_kind": { - "kind": "Variable" + "size": 32, + "kind": "Float" } } ], - "name": "named" - } - ] - } - }, - { - "description": { - "title": "alpha.contract_id" - }, - "encoding": { - "tag_size": "Uint8", - "kind": { - "size": 22, - "kind": "Float" - }, - "cases": [ + "name": "case 4" + }, { - "tag": 0, + "tag": 5, "fields": [ { "name": "Tag", @@ -8105,22 +11327,32 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "Signature.Public_key_hash", "layout": { - "name": "public_key_hash", - "kind": "Ref" + "size": "Uint16", + "kind": "Int" }, + "kind": "anon", "data_kind": { - "size": 21, + "size": 2, "kind": "Float" + } + }, + { + "layout": { + "name": "X_1768", + "kind": "Ref" }, - "kind": "named" + "kind": "anon", + "data_kind": { + "size": 32, + "kind": "Float" + } } ], - "name": "Implicit" + "name": "case 5" }, { - "tag": 1, + "tag": 6, "fields": [ { "name": "Tag", @@ -8135,145 +11367,32 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "Contract_hash", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "size": 20, - "kind": "Float" - }, - "kind": "named" - }, - { - "name": "padding", "layout": { - "kind": "Padding" - }, - "data_kind": { - "size": 1, - "kind": "Float" - }, - "kind": "named" - } - ], - "name": "Originated" - } - ] - } - }, - { - "description": { - "title": "alpha.scripted.contracts" - }, - "encoding": { - "fields": [ - { - "kind": "dyn", - "num_fields": 1, - "size": "Uint30" - }, - { - "name": "code", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "kind": "Variable" - }, - "kind": "named" - }, - { - "kind": "dyn", - "num_fields": 1, - "size": "Uint30" - }, - { - "name": "storage", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "kind": "Variable" - }, - "kind": "named" - } - ] - } - }, - { - "description": { - "title": "X_142" - }, - "encoding": { - "fields": [ - { - "name": "level", - "layout": { - "size": "Int32", - "kind": "Int" - }, - "data_kind": { - "size": 4, - "kind": "Float" - }, - "kind": "named" - }, - { - "kind": "dyn", - "num_fields": 1, - "size": "Uint30" - }, - { - "name": "messages", - "layout": { - "layout": { - "kind": "Bytes" - }, - "kind": "Seq" - }, - "data_kind": { - "kind": "Variable" - }, - "kind": "named" - }, - { - "name": "predecessor", - "layout": { - "name": "X_143", - "kind": "Ref" - }, - "data_kind": { - "kind": "Dynamic" - }, - "kind": "named" - }, - { - "name": "inbox_merkle_root", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "size": 32, - "kind": "Float" - }, - "kind": "named" - } - ] - } - }, - { - "description": { - "title": "X_143" - }, - "encoding": { - "tag_size": "Uint8", - "kind": { - "kind": "Dynamic" - }, - "cases": [ + "size": "Int32", + "kind": "Int" + }, + "kind": "anon", + "data_kind": { + "size": 4, + "kind": "Float" + } + }, + { + "layout": { + "name": "X_1768", + "kind": "Ref" + }, + "kind": "anon", + "data_kind": { + "size": 32, + "kind": "Float" + } + } + ], + "name": "case 6" + }, { - "tag": 0, + "tag": 7, "fields": [ { "name": "Tag", @@ -8289,19 +11408,31 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, { "layout": { - "kind": "Zero_width" + "size": "Int64", + "kind": "Int" }, "kind": "anon", "data_kind": { - "size": 0, + "size": 8, + "kind": "Float" + } + }, + { + "layout": { + "name": "X_1768", + "kind": "Ref" + }, + "kind": "anon", + "data_kind": { + "size": 32, "kind": "Float" } } ], - "name": "None" + "name": "case 7" }, { - "tag": 1, + "tag": 8, "fields": [ { "name": "Tag", @@ -8316,34 +11447,32 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "Commitment_hash", "layout": { - "kind": "Bytes" + "size": "Uint8", + "kind": "Int" + }, + "kind": "anon", + "data_kind": { + "size": 1, + "kind": "Float" + } + }, + { + "layout": { + "name": "X_1768", + "kind": "Ref" }, + "kind": "anon", "data_kind": { "size": 32, "kind": "Float" - }, - "kind": "named" + } } ], - "name": "Some" - } - ] - } - }, - { - "description": { - "title": "X_141" - }, - "encoding": { - "tag_size": "Uint8", - "kind": { - "kind": "Dynamic" - }, - "cases": [ + "name": "case 8" + }, { - "tag": 0, + "tag": 9, "fields": [ { "name": "Tag", @@ -8359,7 +11488,7 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, { "layout": { - "size": "Int16", + "size": "Uint16", "kind": "Int" }, "kind": "anon", @@ -8370,39 +11499,60 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, { "layout": { - "kind": "Bytes" + "name": "X_1768", + "kind": "Ref" }, "kind": "anon", "data_kind": { "size": 32, "kind": "Float" } + } + ], + "name": "case 9" + }, + { + "tag": 10, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" }, { "layout": { - "kind": "Bytes" + "size": "Int32", + "kind": "Int" }, "kind": "anon", "data_kind": { - "size": 32, + "size": 4, "kind": "Float" } }, { "layout": { - "name": "X_17", + "name": "X_1768", "kind": "Ref" }, "kind": "anon", "data_kind": { - "kind": "Dynamic" + "size": 32, + "kind": "Float" } } ], - "name": "case 0" + "name": "case 10" }, { - "tag": 1, + "tag": 11, "fields": [ { "name": "Tag", @@ -8418,50 +11568,71 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, { "layout": { - "size": "Int16", + "size": "Int64", "kind": "Int" }, "kind": "anon", "data_kind": { - "size": 2, + "size": 8, "kind": "Float" } }, { "layout": { - "kind": "Bytes" + "name": "X_1768", + "kind": "Ref" }, "kind": "anon", "data_kind": { "size": 32, "kind": "Float" } + } + ], + "name": "case 11" + }, + { + "tag": 12, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" }, { "layout": { - "kind": "Bytes" + "size": "Uint8", + "kind": "Int" }, "kind": "anon", "data_kind": { - "size": 32, + "size": 1, "kind": "Float" } }, { "layout": { - "name": "X_17", + "name": "X_1760", "kind": "Ref" }, "kind": "anon", "data_kind": { - "kind": "Dynamic" + "size": 64, + "kind": "Float" } } ], - "name": "case 1" + "name": "case 12" }, { - "tag": 2, + "tag": 13, "fields": [ { "name": "Tag", @@ -8477,7 +11648,7 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, { "layout": { - "size": "Int16", + "size": "Uint16", "kind": "Int" }, "kind": "anon", @@ -8488,39 +11659,60 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, { "layout": { - "kind": "Bytes" + "name": "X_1760", + "kind": "Ref" }, "kind": "anon", "data_kind": { - "size": 32, + "size": 64, "kind": "Float" } + } + ], + "name": "case 13" + }, + { + "tag": 14, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" }, { "layout": { - "kind": "Bytes" + "size": "Int32", + "kind": "Int" }, "kind": "anon", "data_kind": { - "size": 32, + "size": 4, "kind": "Float" } }, { "layout": { - "name": "X_17", + "name": "X_1760", "kind": "Ref" }, "kind": "anon", "data_kind": { - "kind": "Dynamic" + "size": 64, + "kind": "Float" } } ], - "name": "case 2" + "name": "case 14" }, { - "tag": 3, + "tag": 15, "fields": [ { "name": "Tag", @@ -8536,63 +11728,59 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, { "layout": { - "size": "Int16", + "size": "Int64", "kind": "Int" }, "kind": "anon", "data_kind": { - "size": 2, + "size": 8, "kind": "Float" } }, { "layout": { - "kind": "Bytes" + "name": "X_1760", + "kind": "Ref" }, "kind": "anon", "data_kind": { - "size": 32, + "size": 64, "kind": "Float" } - }, + } + ], + "name": "case 15" + }, + { + "tag": 128, + "fields": [ { + "name": "Tag", "layout": { - "kind": "Bytes" + "size": "Uint8", + "kind": "Int" }, - "kind": "anon", "data_kind": { - "size": 32, + "size": 1, "kind": "Float" - } + }, + "kind": "named" }, { "layout": { - "name": "X_17", - "kind": "Ref" + "kind": "Zero_width" }, "kind": "anon", "data_kind": { - "kind": "Dynamic" + "size": 0, + "kind": "Float" } } ], - "name": "case 3" - } - ] - } - }, - { - "description": { - "title": "X_140" - }, - "encoding": { - "tag_size": "Uint8", - "kind": { - "kind": "Dynamic" - }, - "cases": [ + "name": "case 128" + }, { - "tag": 0, + "tag": 129, "fields": [ { "name": "Tag", @@ -8607,32 +11795,62 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { + "layout": { + "layout": { + "name": "X_1655", + "kind": "Ref" + }, + "kind": "Seq", + "length_limit": { + "kind": "exactly", + "exactly": 1 + } + }, + "kind": "anon", + "data_kind": { + "kind": "Variable" + } + } + ], + "name": "case 129" + }, + { + "tag": 130, + "fields": [ + { + "name": "Tag", "layout": { "size": "Uint8", "kind": "Int" }, - "kind": "anon", "data_kind": { "size": 1, "kind": "Float" - } + }, + "kind": "named" }, { "layout": { - "name": "X_139", - "kind": "Ref" + "layout": { + "name": "X_1655", + "kind": "Ref" + }, + "kind": "Seq", + "length_limit": { + "kind": "exactly", + "exactly": 2 + } }, "kind": "anon", "data_kind": { - "size": 0, - "kind": "Float" + "kind": "Variable" } } ], - "name": "case 0" + "name": "case 130" }, { - "tag": 1, + "tag": 131, "fields": [ { "name": "Tag", @@ -8647,32 +11865,28 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "layout": { - "size": "Uint16", - "kind": "Int" - }, - "kind": "anon", - "data_kind": { - "size": 2, - "kind": "Float" - } + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" }, { "layout": { - "name": "X_139", - "kind": "Ref" + "layout": { + "name": "X_1655", + "kind": "Ref" + }, + "kind": "Seq" }, "kind": "anon", "data_kind": { - "size": 0, - "kind": "Float" + "kind": "Variable" } } ], - "name": "case 1" + "name": "case 131" }, { - "tag": 2, + "tag": 192, "fields": [ { "name": "Tag", @@ -8687,32 +11901,24 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "layout": { - "size": "Int32", - "kind": "Int" - }, - "kind": "anon", - "data_kind": { - "size": 4, - "kind": "Float" - } + "kind": "dyn", + "num_fields": 1, + "size": "Uint8" }, { "layout": { - "name": "X_139", - "kind": "Ref" + "kind": "Bytes" }, "kind": "anon", "data_kind": { - "size": 0, - "kind": "Float" + "kind": "Variable" } } ], - "name": "case 2" + "name": "case 192" }, { - "tag": 3, + "tag": 193, "fields": [ { "name": "Tag", @@ -8727,32 +11933,24 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "layout": { - "size": "Int64", - "kind": "Int" - }, - "kind": "anon", - "data_kind": { - "size": 8, - "kind": "Float" - } + "kind": "dyn", + "num_fields": 1, + "size": "Uint16" }, { "layout": { - "name": "X_139", - "kind": "Ref" + "kind": "Bytes" }, "kind": "anon", "data_kind": { - "size": 0, - "kind": "Float" + "kind": "Variable" } } ], - "name": "case 3" + "name": "case 193" }, { - "tag": 4, + "tag": 195, "fields": [ { "name": "Tag", @@ -8767,32 +11965,24 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "layout": { - "size": "Uint8", - "kind": "Int" - }, - "kind": "anon", - "data_kind": { - "size": 1, - "kind": "Float" - } + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" }, { "layout": { - "name": "X_135", - "kind": "Ref" + "kind": "Bytes" }, "kind": "anon", "data_kind": { - "size": 32, - "kind": "Float" + "kind": "Variable" } } ], - "name": "case 4" + "name": "case 195" }, { - "tag": 5, + "tag": 224, "fields": [ { "name": "Tag", @@ -8808,31 +11998,40 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, { "layout": { - "size": "Uint16", + "size": "Uint8", "kind": "Int" }, "kind": "anon", "data_kind": { - "size": 2, + "size": 1, "kind": "Float" } }, { "layout": { - "name": "X_135", + "name": "X_1755", "kind": "Ref" }, "kind": "anon", + "data_kind": { + "kind": "Dynamic" + } + }, + { + "layout": { + "kind": "Bytes" + }, + "kind": "anon", "data_kind": { "size": 32, "kind": "Float" } } ], - "name": "case 5" + "name": "case 224" }, { - "tag": 6, + "tag": 225, "fields": [ { "name": "Tag", @@ -8848,31 +12047,40 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, { "layout": { - "size": "Int32", + "size": "Uint16", "kind": "Int" }, "kind": "anon", "data_kind": { - "size": 4, + "size": 2, "kind": "Float" } }, { "layout": { - "name": "X_135", + "name": "X_1755", "kind": "Ref" }, "kind": "anon", + "data_kind": { + "kind": "Dynamic" + } + }, + { + "layout": { + "kind": "Bytes" + }, + "kind": "anon", "data_kind": { "size": 32, "kind": "Float" } } ], - "name": "case 6" + "name": "case 225" }, { - "tag": 7, + "tag": 226, "fields": [ { "name": "Tag", @@ -8888,31 +12096,40 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, { "layout": { - "size": "Int64", + "size": "Int32", "kind": "Int" }, "kind": "anon", "data_kind": { - "size": 8, + "size": 4, "kind": "Float" } }, { "layout": { - "name": "X_135", + "name": "X_1755", "kind": "Ref" }, "kind": "anon", + "data_kind": { + "kind": "Dynamic" + } + }, + { + "layout": { + "kind": "Bytes" + }, + "kind": "anon", "data_kind": { "size": 32, "kind": "Float" } } ], - "name": "case 7" + "name": "case 226" }, { - "tag": 8, + "tag": 227, "fields": [ { "name": "Tag", @@ -8928,31 +12145,110 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, { "layout": { - "size": "Uint8", + "size": "Int64", "kind": "Int" }, "kind": "anon", "data_kind": { - "size": 1, + "size": 8, "kind": "Float" } }, { "layout": { - "name": "X_135", + "name": "X_1755", "kind": "Ref" }, "kind": "anon", + "data_kind": { + "kind": "Dynamic" + } + }, + { + "layout": { + "kind": "Bytes" + }, + "kind": "anon", "data_kind": { "size": 32, "kind": "Float" } } ], - "name": "case 8" + "name": "case 227" + } + ] + } + }, + { + "description": { + "title": "X_1772" + }, + "encoding": { + "fields": [] + } + }, + { + "description": { + "title": "X_1768" + }, + "encoding": { + "fields": [ + { + "layout": { + "kind": "Bytes" + }, + "kind": "anon", + "data_kind": { + "size": 32, + "kind": "Float" + } + } + ] + } + }, + { + "description": { + "title": "X_1760" + }, + "encoding": { + "fields": [ + { + "layout": { + "kind": "Bytes" + }, + "kind": "anon", + "data_kind": { + "size": 32, + "kind": "Float" + } }, { - "tag": 9, + "layout": { + "kind": "Bytes" + }, + "kind": "anon", + "data_kind": { + "size": 32, + "kind": "Float" + } + } + ] + } + }, + { + "description": { + "title": "X_1756" + }, + "encoding": { + "tag_size": "Uint8", + "kind": { + "size": 33, + "kind": "Float" + }, + "cases": [ + { + "tag": 0, "fields": [ { "name": "Tag", @@ -8967,32 +12263,21 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { + "name": "Context_hash", "layout": { - "size": "Uint16", - "kind": "Int" - }, - "kind": "anon", - "data_kind": { - "size": 2, - "kind": "Float" - } - }, - { - "layout": { - "name": "X_135", - "kind": "Ref" + "kind": "Bytes" }, - "kind": "anon", "data_kind": { "size": 32, "kind": "Float" - } + }, + "kind": "named" } ], - "name": "case 9" + "name": "case 0" }, { - "tag": 10, + "tag": 1, "fields": [ { "name": "Tag", @@ -9007,32 +12292,145 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { + "name": "Context_hash", "layout": { - "size": "Int32", - "kind": "Int" - }, - "kind": "anon", - "data_kind": { - "size": 4, - "kind": "Float" - } - }, - { - "layout": { - "name": "X_135", - "kind": "Ref" + "kind": "Bytes" }, - "kind": "anon", "data_kind": { "size": 32, "kind": "Float" - } + }, + "kind": "named" } ], - "name": "case 10" + "name": "case 1" + } + ] + } + }, + { + "description": { + "title": "X_1755" + }, + "encoding": { + "fields": [ + { + "kind": "dyn", + "num_fields": 1, + "size": "Uint8" }, { - "tag": 11, + "layout": { + "kind": "Bytes" + }, + "kind": "anon", + "data_kind": { + "kind": "Variable" + } + } + ] + } + }, + { + "description": { + "title": "X_1650" + }, + "encoding": { + "fields": [ + { + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" + }, + { + "layout": { + "layout": { + "name": "X_1773", + "kind": "Ref" + }, + "kind": "Seq" + }, + "kind": "anon", + "data_kind": { + "kind": "Variable" + } + } + ] + } + }, + { + "description": { + "title": "X_1655" + }, + "encoding": { + "fields": [ + { + "layout": { + "name": "X_1755", + "kind": "Ref" + }, + "kind": "anon", + "data_kind": { + "kind": "Dynamic" + } + }, + { + "layout": { + "name": "X_1756", + "kind": "Ref" + }, + "kind": "anon", + "data_kind": { + "size": 33, + "kind": "Float" + } + } + ] + } + }, + { + "description": { + "title": "X_1649" + }, + "encoding": { + "fields": [ + { + "name": "context_hash", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 32, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "withdraw_list_hash", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 32, + "kind": "Float" + }, + "kind": "named" + } + ] + } + }, + { + "description": { + "title": "X_1648" + }, + "encoding": { + "tag_size": "Uint8", + "kind": { + "kind": "Dynamic" + }, + "cases": [ + { + "tag": 0, "fields": [ { "name": "Tag", @@ -9047,32 +12445,25 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "layout": { - "size": "Int64", - "kind": "Int" - }, - "kind": "anon", - "data_kind": { - "size": 8, - "kind": "Float" - } + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" }, { + "name": "batch", "layout": { - "name": "X_135", - "kind": "Ref" + "kind": "String" }, - "kind": "anon", "data_kind": { - "size": 32, - "kind": "Float" - } + "kind": "Variable" + }, + "kind": "named" } ], - "name": "case 11" + "name": "Batch" }, { - "tag": 12, + "tag": 1, "fields": [ { "name": "Tag", @@ -9087,32 +12478,117 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { + "name": "deposit", + "layout": { + "name": "X_1646", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" + } + ], + "name": "Deposit" + } + ] + } + }, + { + "description": { + "title": "X_1646" + }, + "encoding": { + "fields": [ + { + "name": "sender", + "layout": { + "name": "public_key_hash", + "kind": "Ref" + }, + "data_kind": { + "size": 21, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "destination", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 20, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "ticket_hash", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 32, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "amount", + "layout": { + "name": "X_1647", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" + } + ] + } + }, + { + "description": { + "title": "X_1647" + }, + "encoding": { + "tag_size": "Uint8", + "kind": { + "kind": "Dynamic" + }, + "cases": [ + { + "tag": 0, + "fields": [ + { + "name": "Tag", "layout": { "size": "Uint8", "kind": "Int" }, - "kind": "anon", "data_kind": { "size": 1, "kind": "Float" - } + }, + "kind": "named" }, { "layout": { - "name": "X_127", - "kind": "Ref" + "size": "Uint8", + "kind": "Int" }, "kind": "anon", "data_kind": { - "size": 64, + "size": 1, "kind": "Float" } } ], - "name": "case 12" + "name": "case 0" }, { - "tag": 13, + "tag": 1, "fields": [ { "name": "Tag", @@ -9136,23 +12612,12 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "size": 2, "kind": "Float" } - }, - { - "layout": { - "name": "X_127", - "kind": "Ref" - }, - "kind": "anon", - "data_kind": { - "size": 64, - "kind": "Float" - } } ], - "name": "case 13" + "name": "case 1" }, { - "tag": 14, + "tag": 2, "fields": [ { "name": "Tag", @@ -9176,23 +12641,12 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "size": 4, "kind": "Float" } - }, - { - "layout": { - "name": "X_127", - "kind": "Ref" - }, - "kind": "anon", - "data_kind": { - "size": 64, - "kind": "Float" - } } ], - "name": "case 14" + "name": "case 2" }, { - "tag": 15, + "tag": 3, "fields": [ { "name": "Tag", @@ -9216,32 +12670,109 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "size": 8, "kind": "Float" } - }, - { - "layout": { - "name": "X_127", - "kind": "Ref" - }, - "kind": "anon", - "data_kind": { - "size": 64, - "kind": "Float" - } } ], - "name": "case 15" + "name": "case 3" + } + ] + } + }, + { + "description": { + "title": "X_1644" + }, + "encoding": { + "fields": [ + { + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" }, { - "tag": 128, + "name": "contents", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "kind": "Variable" + }, + "kind": "named" + }, + { + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" + }, + { + "name": "ty", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "kind": "Variable" + }, + "kind": "named" + }, + { + "name": "ticketer", + "layout": { + "name": "alpha.contract_id", + "kind": "Ref" + }, + "data_kind": { + "size": 22, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "amount", + "layout": { + "name": "X_1647", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" + }, + { + "name": "claimer", + "layout": { + "name": "public_key_hash", + "kind": "Ref" + }, + "data_kind": { + "size": 21, + "kind": "Float" + }, + "kind": "named" + } + ] + } + }, + { + "description": { + "title": "X_1643" + }, + "encoding": { + "tag_size": "Uint16", + "kind": { + "size": 2, + "kind": "Float" + }, + "cases": [ + { + "tag": 0, "fields": [ { "name": "Tag", "layout": { - "size": "Uint8", + "size": "Uint16", "kind": "Int" }, "data_kind": { - "size": 1, + "size": 2, "kind": "Float" }, "kind": "named" @@ -9257,10 +12788,144 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' } } ], - "name": "case 128" + "name": "Example_arith smart contract rollup kind" + } + ] + } + }, + { + "description": { + "title": "X_1642" + }, + "encoding": { + "fields": [ + { + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" + }, + { + "layout": { + "kind": "String" + }, + "kind": "anon", + "data_kind": { + "kind": "Variable" + } + } + ] + } + }, + { + "description": { + "title": "X_1641" + }, + "encoding": { + "fields": [ + { + "name": "compressed_state", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 32, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "inbox_level", + "layout": { + "size": "Int32", + "kind": "Int" + }, + "data_kind": { + "size": 4, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "predecessor", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 32, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "number_of_messages", + "layout": { + "size": "Int32", + "kind": "Int" + }, + "data_kind": { + "size": 4, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "number_of_ticks", + "layout": { + "size": "Int32", + "kind": "Int" + }, + "data_kind": { + "size": 4, + "kind": "Float" + }, + "kind": "named" + } + ] + } + }, + { + "description": { + "title": "X_3" + }, + "encoding": { + "fields": [ + { + "name": "choice", + "layout": { + "name": "N.t", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" }, { - "tag": 129, + "name": "step", + "layout": { + "name": "X_1640", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" + } + ] + } + }, + { + "description": { + "title": "X_1640" + }, + "encoding": { + "tag_size": "Uint8", + "kind": { + "kind": "Dynamic" + }, + "cases": [ + { + "tag": 0, "fields": [ { "name": "Tag", @@ -9274,17 +12939,18 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, "kind": "named" }, + { + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" + }, { "layout": { "layout": { - "name": "X_22", + "name": "X_1638", "kind": "Ref" }, - "kind": "Seq", - "length_limit": { - "kind": "exactly", - "exactly": 1 - } + "kind": "Seq" }, "kind": "anon", "data_kind": { @@ -9292,10 +12958,10 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' } } ], - "name": "case 129" + "name": "Dissection" }, { - "tag": 130, + "tag": 1, "fields": [ { "name": "Tag", @@ -9310,27 +12976,74 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { + "name": "pvm_step", "layout": { - "layout": { - "name": "X_22", - "kind": "Ref" - }, - "kind": "Seq", - "length_limit": { - "kind": "exactly", - "exactly": 2 - } + "name": "X_817", + "kind": "Ref" }, - "kind": "anon", "data_kind": { - "kind": "Variable" - } + "kind": "Dynamic" + }, + "kind": "named" + }, + { + "name": "inbox", + "layout": { + "name": "X_1637", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" } ], - "name": "case 130" + "name": "Proof" + } + ] + } + }, + { + "description": { + "title": "X_1638" + }, + "encoding": { + "fields": [ + { + "layout": { + "name": "X_1639", + "kind": "Ref" + }, + "kind": "anon", + "data_kind": { + "kind": "Dynamic" + } }, { - "tag": 131, + "layout": { + "name": "N.t", + "kind": "Ref" + }, + "kind": "anon", + "data_kind": { + "kind": "Dynamic" + } + } + ] + } + }, + { + "description": { + "title": "X_1639" + }, + "encoding": { + "tag_size": "Uint8", + "kind": { + "kind": "Dynamic" + }, + "cases": [ + { + "tag": 0, "fields": [ { "name": "Tag", @@ -9344,29 +13057,21 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, "kind": "named" }, - { - "kind": "dyn", - "num_fields": 1, - "size": "Uint30" - }, { "layout": { - "layout": { - "name": "X_22", - "kind": "Ref" - }, - "kind": "Seq" + "kind": "Zero_width" }, "kind": "anon", "data_kind": { - "kind": "Variable" + "size": 0, + "kind": "Float" } } ], - "name": "case 131" + "name": "None" }, { - "tag": 192, + "tag": 1, "fields": [ { "name": "Tag", @@ -9381,24 +13086,34 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "kind": "dyn", - "num_fields": 1, - "size": "Uint8" - }, - { + "name": "state_hash", "layout": { "kind": "Bytes" }, - "kind": "anon", "data_kind": { - "kind": "Variable" - } + "size": 32, + "kind": "Float" + }, + "kind": "named" } ], - "name": "case 192" - }, + "name": "Some" + } + ] + } + }, + { + "description": { + "title": "X_1637" + }, + "encoding": { + "tag_size": "Uint8", + "kind": { + "kind": "Dynamic" + }, + "cases": [ { - "tag": 193, + "tag": 0, "fields": [ { "name": "Tag", @@ -9412,25 +13127,21 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, "kind": "named" }, - { - "kind": "dyn", - "num_fields": 1, - "size": "Uint16" - }, { "layout": { - "kind": "Bytes" + "kind": "Zero_width" }, "kind": "anon", "data_kind": { - "kind": "Variable" + "size": 0, + "kind": "Float" } } ], - "name": "case 193" + "name": "None" }, { - "tag": 195, + "tag": 1, "fields": [ { "name": "Tag", @@ -9450,117 +13161,78 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "size": "Uint30" }, { + "name": "skips", "layout": { - "kind": "Bytes" + "layout": { + "name": "X_818", + "kind": "Ref" + }, + "kind": "Seq" }, - "kind": "anon", "data_kind": { "kind": "Variable" - } - } - ], - "name": "case 195" - }, - { - "tag": 224, - "fields": [ - { - "name": "Tag", - "layout": { - "size": "Uint8", - "kind": "Int" - }, - "data_kind": { - "size": 1, - "kind": "Float" }, "kind": "named" }, { + "name": "level", "layout": { - "size": "Uint8", - "kind": "Int" - }, - "kind": "anon", - "data_kind": { - "size": 1, - "kind": "Float" - } - }, - { - "layout": { - "name": "X_122", + "name": "X_819", "kind": "Ref" }, - "kind": "anon", "data_kind": { "kind": "Dynamic" - } - }, - { - "layout": { - "kind": "Bytes" - }, - "kind": "anon", - "data_kind": { - "size": 32, - "kind": "Float" - } - } - ], - "name": "case 224" - }, - { - "tag": 225, - "fields": [ - { - "name": "Tag", - "layout": { - "size": "Uint8", - "kind": "Int" - }, - "data_kind": { - "size": 1, - "kind": "Float" }, "kind": "named" }, { - "layout": { - "size": "Uint16", - "kind": "Int" - }, - "kind": "anon", - "data_kind": { - "size": 2, - "kind": "Float" - } + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" }, { + "name": "inc", "layout": { - "name": "X_122", - "kind": "Ref" + "layout": { + "name": "X_825", + "kind": "Ref" + }, + "kind": "Seq" }, - "kind": "anon", "data_kind": { - "kind": "Dynamic" - } + "kind": "Variable" + }, + "kind": "named" }, { + "name": "message_proof", "layout": { - "kind": "Bytes" + "name": "X_4", + "kind": "Ref" }, - "kind": "anon", "data_kind": { - "size": 32, - "kind": "Float" - } + "kind": "Dynamic" + }, + "kind": "named" } ], - "name": "case 225" - }, + "name": "Some" + } + ] + } + }, + { + "description": { + "title": "X_1636" + }, + "encoding": { + "tag_size": "Uint8", + "kind": { + "kind": "Dynamic" + }, + "cases": [ { - "tag": 226, + "tag": 0, "fields": [ { "name": "Tag", @@ -9575,41 +13247,25 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "layout": { - "size": "Int32", - "kind": "Int" - }, - "kind": "anon", - "data_kind": { - "size": 4, - "kind": "Float" - } - }, - { - "layout": { - "name": "X_122", - "kind": "Ref" - }, - "kind": "anon", - "data_kind": { - "kind": "Dynamic" - } + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" }, { + "name": "value", "layout": { "kind": "Bytes" }, - "kind": "anon", "data_kind": { - "size": 32, - "kind": "Float" - } + "kind": "Variable" + }, + "kind": "named" } ], - "name": "case 226" + "name": "Value" }, { - "tag": 227, + "tag": 1, "fields": [ { "name": "Tag", @@ -9624,111 +13280,21 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "layout": { - "size": "Int64", - "kind": "Int" - }, - "kind": "anon", - "data_kind": { - "size": 8, - "kind": "Float" - } - }, - { - "layout": { - "name": "X_122", - "kind": "Ref" - }, - "kind": "anon", - "data_kind": { - "kind": "Dynamic" - } - }, - { + "name": "blinded_value", "layout": { "kind": "Bytes" }, - "kind": "anon", "data_kind": { "size": 32, "kind": "Float" - } + }, + "kind": "named" } ], - "name": "case 227" - } - ] - } - }, - { - "description": { - "title": "X_139" - }, - "encoding": { - "fields": [] - } - }, - { - "description": { - "title": "X_135" - }, - "encoding": { - "fields": [ - { - "layout": { - "kind": "Bytes" - }, - "kind": "anon", - "data_kind": { - "size": 32, - "kind": "Float" - } - } - ] - } - }, - { - "description": { - "title": "X_127" - }, - "encoding": { - "fields": [ - { - "layout": { - "kind": "Bytes" - }, - "kind": "anon", - "data_kind": { - "size": 32, - "kind": "Float" - } + "name": "Blinded_value" }, { - "layout": { - "kind": "Bytes" - }, - "kind": "anon", - "data_kind": { - "size": 32, - "kind": "Float" - } - } - ] - } - }, - { - "description": { - "title": "X_123" - }, - "encoding": { - "tag_size": "Uint8", - "kind": { - "size": 33, - "kind": "Float" - }, - "cases": [ - { - "tag": 0, + "tag": 2, "fields": [ { "name": "Tag", @@ -9743,21 +13309,29 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "Context_hash", + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" + }, + { + "name": "node", "layout": { - "kind": "Bytes" + "layout": { + "name": "X_25", + "kind": "Ref" + }, + "kind": "Seq" }, "data_kind": { - "size": 32, - "kind": "Float" + "kind": "Variable" }, "kind": "named" } ], - "name": "case 0" + "name": "Node" }, { - "tag": 1, + "tag": 3, "fields": [ { "name": "Tag", @@ -9772,7 +13346,7 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "Context_hash", + "name": "blinded_node", "layout": { "kind": "Bytes" }, @@ -9783,125 +13357,90 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" } ], - "name": "case 1" - } - ] - } - }, - { - "description": { - "title": "X_122" - }, - "encoding": { - "fields": [ - { - "kind": "dyn", - "num_fields": 1, - "size": "Uint8" - }, - { - "layout": { - "kind": "Bytes" - }, - "kind": "anon", - "data_kind": { - "kind": "Variable" - } - } - ] - } - }, - { - "description": { - "title": "X_17" - }, - "encoding": { - "fields": [ - { - "kind": "dyn", - "num_fields": 1, - "size": "Uint30" - }, - { - "layout": { - "layout": { - "name": "X_140", - "kind": "Ref" - }, - "kind": "Seq" - }, - "kind": "anon", - "data_kind": { - "kind": "Variable" - } - } - ] - } - }, - { - "description": { - "title": "X_22" - }, - "encoding": { - "fields": [ - { - "layout": { - "name": "X_122", - "kind": "Ref" - }, - "kind": "anon", - "data_kind": { - "kind": "Dynamic" - } + "name": "Blinded_node" }, { - "layout": { - "name": "X_123", - "kind": "Ref" - }, - "kind": "anon", - "data_kind": { - "size": 33, - "kind": "Float" - } - } - ] - } - }, - { - "description": { - "title": "X_16" - }, - "encoding": { - "fields": [ + "tag": 4, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "inode", + "layout": { + "name": "X_170", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" + } + ], + "name": "Inode" + }, { - "name": "context_hash", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "size": 32, - "kind": "Float" - }, - "kind": "named" + "tag": 5, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "extender", + "layout": { + "name": "X_136", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" + } + ], + "name": "Extender" }, { - "name": "withdraw_list_hash", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "size": 32, - "kind": "Float" - }, - "kind": "named" + "tag": 6, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" + } + ], + "name": "None" } ] } }, { "description": { - "title": "X_15" + "title": "X_1632" }, "encoding": { "tag_size": "Uint8", @@ -9930,9 +13469,13 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "size": "Uint30" }, { - "name": "batch", + "name": "sparse_proof", "layout": { - "kind": "String" + "layout": { + "name": "X_203", + "kind": "Ref" + }, + "kind": "Seq" }, "data_kind": { "kind": "Variable" @@ -9940,7 +13483,7 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" } ], - "name": "Batch" + "name": "sparse_proof" }, { "tag": 1, @@ -9958,10 +13501,17 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "deposit", + "name": "dense_proof", "layout": { - "name": "X_13", - "kind": "Ref" + "layout": { + "name": "X_1631", + "kind": "Ref" + }, + "kind": "Seq", + "length_limit": { + "kind": "exactly", + "exactly": 32 + } }, "data_kind": { "kind": "Dynamic" @@ -9969,68 +13519,14 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" } ], - "name": "Deposit" - } - ] - } - }, - { - "description": { - "title": "X_13" - }, - "encoding": { - "fields": [ - { - "name": "sender", - "layout": { - "name": "public_key_hash", - "kind": "Ref" - }, - "data_kind": { - "size": 21, - "kind": "Float" - }, - "kind": "named" - }, - { - "name": "destination", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "size": 20, - "kind": "Float" - }, - "kind": "named" - }, - { - "name": "ticket_hash", - "layout": { - "kind": "Bytes" - }, - "data_kind": { - "size": 32, - "kind": "Float" - }, - "kind": "named" - }, - { - "name": "amount", - "layout": { - "name": "X_14", - "kind": "Ref" - }, - "data_kind": { - "kind": "Dynamic" - }, - "kind": "named" + "name": "dense_proof" } ] } }, { "description": { - "title": "X_14" + "title": "X_1631" }, "encoding": { "tag_size": "Uint8", @@ -10054,21 +13550,58 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { + "name": "blinded_inode", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 32, + "kind": "Float" + }, + "kind": "named" + } + ], + "name": "Blinded_inode" + }, + { + "tag": 1, + "fields": [ + { + "name": "Tag", "layout": { "size": "Uint8", "kind": "Int" }, - "kind": "anon", "data_kind": { "size": 1, "kind": "Float" - } + }, + "kind": "named" + }, + { + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" + }, + { + "name": "inode_values", + "layout": { + "layout": { + "name": "X_25", + "kind": "Ref" + }, + "kind": "Seq" + }, + "data_kind": { + "kind": "Variable" + }, + "kind": "named" } ], - "name": "case 0" + "name": "Inode_values" }, { - "tag": 1, + "tag": 2, "fields": [ { "name": "Tag", @@ -10083,21 +13616,50 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { + "name": "inode_tree", "layout": { - "size": "Uint16", + "name": "X_170", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" + } + ], + "name": "Inode_tree" + }, + { + "tag": 3, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", "kind": "Int" }, - "kind": "anon", "data_kind": { - "size": 2, + "size": 1, "kind": "Float" - } + }, + "kind": "named" + }, + { + "name": "inode_extender", + "layout": { + "name": "X_136", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" } ], - "name": "case 1" + "name": "Inode_extender" }, { - "tag": 2, + "tag": 4, "fields": [ { "name": "Tag", @@ -10110,23 +13672,55 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "Float" }, "kind": "named" - }, + } + ], + "name": "None" + } + ] + } + }, + { + "description": { + "title": "X_828" + }, + "encoding": { + "tag_size": "Uint8", + "kind": { + "size": 33, + "kind": "Float" + }, + "cases": [ + { + "tag": 0, + "fields": [ { + "name": "Tag", "layout": { - "size": "Int32", + "size": "Uint8", "kind": "Int" }, - "kind": "anon", "data_kind": { - "size": 4, + "size": 1, "kind": "Float" - } + }, + "kind": "named" + }, + { + "name": "value", + "layout": { + "kind": "Bytes" + }, + "data_kind": { + "size": 32, + "kind": "Float" + }, + "kind": "named" } ], - "name": "case 2" + "name": "Value" }, { - "tag": 3, + "tag": 1, "fields": [ { "name": "Tag", @@ -10141,40 +13735,49 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { + "name": "node", "layout": { - "size": "Int64", - "kind": "Int" + "kind": "Bytes" }, - "kind": "anon", "data_kind": { - "size": 8, + "size": 32, "kind": "Float" - } + }, + "kind": "named" } ], - "name": "case 3" + "name": "Node" } ] } }, { "description": { - "title": "X_11" + "title": "X_825" }, "encoding": { "fields": [ { - "kind": "dyn", - "num_fields": 1, - "size": "Uint30" + "name": "index", + "layout": { + "min": -1073741824, + "max": 1073741823, + "kind": "RangedInt" + }, + "data_kind": { + "size": 4, + "kind": "Float" + }, + "kind": "named" }, { - "name": "contents", + "name": "content", "layout": { "kind": "Bytes" }, "data_kind": { - "kind": "Variable" + "size": 32, + "kind": "Float" }, "kind": "named" }, @@ -10184,98 +13787,53 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "size": "Uint30" }, { - "name": "ty", + "name": "back_pointers", "layout": { - "kind": "Bytes" + "layout": { + "kind": "Bytes" + }, + "kind": "Seq" }, "data_kind": { "kind": "Variable" }, "kind": "named" - }, - { - "name": "ticketer", - "layout": { - "name": "alpha.contract_id", - "kind": "Ref" - }, - "data_kind": { - "size": 22, - "kind": "Float" - }, - "kind": "named" - }, + } + ] + } + }, + { + "description": { + "title": "X_818" + }, + "encoding": { + "fields": [ { - "name": "amount", "layout": { - "name": "X_14", + "name": "X_819", "kind": "Ref" }, + "kind": "anon", "data_kind": { "kind": "Dynamic" - }, - "kind": "named" + } }, { - "name": "claimer", "layout": { - "name": "public_key_hash", + "name": "X_821", "kind": "Ref" }, + "kind": "anon", "data_kind": { - "size": 21, - "kind": "Float" - }, - "kind": "named" - } - ] - } - }, - { - "description": { - "title": "X_10" - }, - "encoding": { - "tag_size": "Uint16", - "kind": { - "size": 2, - "kind": "Float" - }, - "cases": [ - { - "tag": 0, - "fields": [ - { - "name": "Tag", - "layout": { - "size": "Uint16", - "kind": "Int" - }, - "data_kind": { - "size": 2, - "kind": "Float" - }, - "kind": "named" - }, - { - "layout": { - "kind": "Zero_width" - }, - "kind": "anon", - "data_kind": { - "size": 0, - "kind": "Float" - } - } - ], - "name": "Example_arith smart contract rollup kind" + "kind": "Dynamic" + } } ] } }, { "description": { - "title": "X_9" + "title": "X_821" }, "encoding": { "fields": [ @@ -10286,7 +13844,11 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, { "layout": { - "kind": "String" + "layout": { + "name": "X_825", + "kind": "Ref" + }, + "kind": "Seq" }, "kind": "anon", "data_kind": { @@ -10298,46 +13860,63 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, { "description": { - "title": "X_8" + "title": "X_819" }, "encoding": { "fields": [ { - "name": "compressed_state", + "kind": "dyn", + "name": "alpha.rollup_address", + "num_fields": 1, + "size": "Uint30" + }, + { + "name": "rollup", "layout": { - "kind": "Bytes" + "kind": "String" }, "data_kind": { - "size": 32, - "kind": "Float" + "kind": "Variable" }, "kind": "named" }, { - "name": "inbox_level", + "name": "message_counter", "layout": { - "size": "Int32", + "name": "N.t", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" + }, + { + "name": "nb_available_messages", + "layout": { + "size": "Int64", "kind": "Int" }, "data_kind": { - "size": 4, + "size": 8, "kind": "Float" }, "kind": "named" }, { - "name": "predecessor", + "name": "nb_messages_in_commitment_period", "layout": { - "kind": "Bytes" + "size": "Int64", + "kind": "Int" }, "data_kind": { - "size": 32, + "size": 8, "kind": "Float" }, "kind": "named" }, { - "name": "number_of_messages", + "name": "starting_level_of_current_commitment_period", "layout": { "size": "Int32", "kind": "Int" @@ -10349,7 +13928,7 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "number_of_ticks", + "name": "level", "layout": { "size": "Int32", "kind": "Int" @@ -10359,31 +13938,22 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "Float" }, "kind": "named" - } - ] - } - }, - { - "description": { - "title": "X_3" - }, - "encoding": { - "fields": [ + }, { - "name": "choice", + "name": "current_messages_hash", "layout": { - "name": "N.t", - "kind": "Ref" + "kind": "Bytes" }, "data_kind": { - "kind": "Dynamic" + "size": 32, + "kind": "Float" }, "kind": "named" }, { - "name": "step", + "name": "old_levels_messages", "layout": { - "name": "X_7", + "name": "X_825", "kind": "Ref" }, "data_kind": { @@ -10396,7 +13966,7 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, { "description": { - "title": "X_7" + "title": "X_817" }, "encoding": { "tag_size": "Uint8", @@ -10420,89 +13990,47 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "kind": "dyn", - "num_fields": 1, - "size": "Uint30" - }, - { + "name": "tree_proof", "layout": { - "layout": { - "name": "X_5", - "kind": "Ref" - }, - "kind": "Seq" + "name": "X_4", + "kind": "Ref" }, - "kind": "anon", "data_kind": { - "kind": "Variable" - } - } - ], - "name": "Dissection" - }, - { - "tag": 1, - "fields": [ + "kind": "Dynamic" + }, + "kind": "named" + }, { - "name": "Tag", + "name": "given", "layout": { - "size": "Uint8", - "kind": "Int" + "name": "X_815", + "kind": "Ref" }, "data_kind": { - "size": 1, - "kind": "Float" + "kind": "Dynamic" }, "kind": "named" }, { + "name": "requested", "layout": { - "name": "X_4", + "name": "X_816", "kind": "Ref" }, - "kind": "anon", "data_kind": { "kind": "Dynamic" - } + }, + "kind": "named" } ], - "name": "Proof" - } - ] - } - }, - { - "description": { - "title": "X_5" - }, - "encoding": { - "fields": [ - { - "layout": { - "name": "X_6", - "kind": "Ref" - }, - "kind": "anon", - "data_kind": { - "kind": "Dynamic" - } - }, - { - "layout": { - "name": "N.t", - "kind": "Ref" - }, - "kind": "anon", - "data_kind": { - "kind": "Dynamic" - } + "name": "Arithmetic PVM with proof" } ] } }, { "description": { - "title": "X_6" + "title": "X_816" }, "encoding": { "tag_size": "Uint8", @@ -10511,7 +14039,25 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, "cases": [ { - "tag": 0, + "tag": 0, + "fields": [ + { + "name": "Tag", + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "data_kind": { + "size": 1, + "kind": "Float" + }, + "kind": "named" + } + ], + "name": "No_input_required" + }, + { + "tag": 1, "fields": [ { "name": "Tag", @@ -10524,22 +14070,12 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "Float" }, "kind": "named" - }, - { - "layout": { - "kind": "Zero_width" - }, - "kind": "anon", - "data_kind": { - "size": 0, - "kind": "Float" - } } ], - "name": "None" + "name": "Initial" }, { - "tag": 1, + "tag": 2, "fields": [ { "name": "Tag", @@ -10554,25 +14090,35 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { - "name": "state_hash", "layout": { - "kind": "Bytes" + "size": "Int32", + "kind": "Int" }, + "kind": "anon", "data_kind": { - "size": 32, + "size": 4, "kind": "Float" + } + }, + { + "layout": { + "name": "N.t", + "kind": "Ref" }, - "kind": "named" + "kind": "anon", + "data_kind": { + "kind": "Dynamic" + } } ], - "name": "Some" + "name": "First_after" } ] } }, { "description": { - "title": "X_4" + "title": "X_815" }, "encoding": { "tag_size": "Uint8", @@ -10597,36 +14143,16 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' }, { "layout": { - "kind": "Bool" - }, - "kind": "anon", - "data_kind": { - "size": 1, - "kind": "Float" - } - }, - { - "layout": { - "kind": "Bytes" - }, - "kind": "anon", - "data_kind": { - "size": 32, - "kind": "Float" - } - }, - { - "layout": { - "kind": "Bytes" + "kind": "Zero_width" }, "kind": "anon", "data_kind": { - "size": 32, + "size": 0, "kind": "Float" } } ], - "name": "Proof of a normal computation step" + "name": "None" }, { "tag": 1, @@ -10644,75 +14170,235 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" }, { + "name": "inbox_level", "layout": { - "kind": "Bool" + "size": "Int32", + "kind": "Int" }, - "kind": "anon", "data_kind": { - "size": 1, + "size": 4, "kind": "Float" - } - }, - { - "layout": { - "kind": "Bytes" }, - "kind": "anon", - "data_kind": { - "size": 32, - "kind": "Float" - } + "kind": "named" }, { + "name": "message_counter", "layout": { - "kind": "Bytes" - }, - "kind": "anon", - "data_kind": { - "size": 32, - "kind": "Float" - } - } - ], - "name": "Proof of an input step" - }, - { - "tag": 2, - "fields": [ - { - "name": "Tag", - "layout": { - "size": "Uint8", - "kind": "Int" + "name": "N.t", + "kind": "Ref" }, "data_kind": { - "size": 1, - "kind": "Float" + "kind": "Dynamic" }, "kind": "named" }, { - "layout": { - "kind": "Bool" - }, - "kind": "anon", - "data_kind": { - "size": 1, - "kind": "Float" - } + "kind": "dyn", + "num_fields": 1, + "size": "Uint30" }, { + "name": "payload", "layout": { - "kind": "Bytes" + "kind": "String" }, - "kind": "anon", "data_kind": { - "size": 32, - "kind": "Float" - } + "kind": "Variable" + }, + "kind": "named" } ], - "name": "Proof that the PVM is blocked" + "name": "Some" + } + ] + } + }, + { + "description": { + "title": "X_4" + }, + "encoding": { + "fields": [ + { + "name": "version", + "layout": { + "size": "Int16", + "kind": "Int" + }, + "data_kind": { + "size": 2, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "before", + "layout": { + "name": "X_828", + "kind": "Ref" + }, + "data_kind": { + "size": 33, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "after", + "layout": { + "name": "X_828", + "kind": "Ref" + }, + "data_kind": { + "size": 33, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "state", + "layout": { + "name": "X_1636", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" + } + ] + } + }, + { + "description": { + "title": "X_170" + }, + "encoding": { + "fields": [ + { + "name": "length", + "layout": { + "size": "Int64", + "kind": "Int" + }, + "data_kind": { + "size": 8, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "proofs", + "layout": { + "name": "X_1632", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" + } + ] + } + }, + { + "description": { + "title": "X_203" + }, + "encoding": { + "fields": [ + { + "layout": { + "size": "Uint8", + "kind": "Int" + }, + "kind": "anon", + "data_kind": { + "size": 1, + "kind": "Float" + } + }, + { + "layout": { + "name": "X_1631", + "kind": "Ref" + }, + "kind": "anon", + "data_kind": { + "kind": "Dynamic" + } + } + ] + } + }, + { + "description": { + "title": "X_136" + }, + "encoding": { + "fields": [ + { + "name": "length", + "layout": { + "size": "Int64", + "kind": "Int" + }, + "data_kind": { + "size": 8, + "kind": "Float" + }, + "kind": "named" + }, + { + "name": "segment", + "layout": { + "name": "X_1755", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" + }, + { + "name": "proof", + "layout": { + "name": "X_1631", + "kind": "Ref" + }, + "data_kind": { + "kind": "Dynamic" + }, + "kind": "named" + } + ] + } + }, + { + "description": { + "title": "X_25" + }, + "encoding": { + "fields": [ + { + "layout": { + "name": "X_1755", + "kind": "Ref" + }, + "kind": "anon", + "data_kind": { + "kind": "Dynamic" + } + }, + { + "layout": { + "name": "X_1636", + "kind": "Ref" + }, + "kind": "anon", + "data_kind": { + "kind": "Dynamic" + } } ] } @@ -13919,39 +17605,2055 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "$ref": "#/definitions/micheline.alpha.michelson_v1.expression" } }, - { - "title": "Prim__generic", - "description": "Generic primitive (any number of args with or without annotations)", - "type": "object", - "properties": { - "prim": { - "$ref": "#/definitions/alpha.michelson.v1.primitives" - }, - "args": { + { + "title": "Prim__generic", + "description": "Generic primitive (any number of args with or without annotations)", + "type": "object", + "properties": { + "prim": { + "$ref": "#/definitions/alpha.michelson.v1.primitives" + }, + "args": { + "type": "array", + "items": { + "$ref": "#/definitions/micheline.alpha.michelson_v1.expression" + } + }, + "annots": { + "type": "array", + "items": { + "type": "string" + } + } + }, + "required": [ + "prim" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "parameters_ty", + "boot_sector", + "kind", + "storage_limit", + "gas_limit", + "counter", + "fee", + "source", + "kind" + ], + "additionalProperties": false + }, + { + "title": "Sc_rollup_add_messages", + "type": "object", + "properties": { + "kind": { + "type": "string", + "enum": [ + "sc_rollup_add_messages" + ] + }, + "source": { + "$ref": "#/definitions/Signature.Public_key_hash" + }, + "fee": { + "$ref": "#/definitions/alpha.mutez" + }, + "counter": { + "$ref": "#/definitions/positive_bignum" + }, + "gas_limit": { + "$ref": "#/definitions/positive_bignum" + }, + "storage_limit": { + "$ref": "#/definitions/positive_bignum" + }, + "rollup": { + "$ref": "#/definitions/alpha.rollup_address" + }, + "message": { + "type": "array", + "items": { + "$ref": "#/definitions/unistring" + } + } + }, + "required": [ + "message", + "rollup", + "storage_limit", + "gas_limit", + "counter", + "fee", + "source", + "kind" + ], + "additionalProperties": false + }, + { + "title": "Sc_rollup_cement", + "type": "object", + "properties": { + "kind": { + "type": "string", + "enum": [ + "sc_rollup_cement" + ] + }, + "source": { + "$ref": "#/definitions/Signature.Public_key_hash" + }, + "fee": { + "$ref": "#/definitions/alpha.mutez" + }, + "counter": { + "$ref": "#/definitions/positive_bignum" + }, + "gas_limit": { + "$ref": "#/definitions/positive_bignum" + }, + "storage_limit": { + "$ref": "#/definitions/positive_bignum" + }, + "rollup": { + "$ref": "#/definitions/alpha.rollup_address" + }, + "commitment": { + "$ref": "#/definitions/commitment_hash" + } + }, + "required": [ + "commitment", + "rollup", + "storage_limit", + "gas_limit", + "counter", + "fee", + "source", + "kind" + ], + "additionalProperties": false + }, + { + "title": "Sc_rollup_publish", + "type": "object", + "properties": { + "kind": { + "type": "string", + "enum": [ + "sc_rollup_publish" + ] + }, + "source": { + "$ref": "#/definitions/Signature.Public_key_hash" + }, + "fee": { + "$ref": "#/definitions/alpha.mutez" + }, + "counter": { + "$ref": "#/definitions/positive_bignum" + }, + "gas_limit": { + "$ref": "#/definitions/positive_bignum" + }, + "storage_limit": { + "$ref": "#/definitions/positive_bignum" + }, + "rollup": { + "$ref": "#/definitions/alpha.rollup_address" + }, + "commitment": { + "type": "object", + "properties": { + "compressed_state": { + "$ref": "#/definitions/state_hash" + }, + "inbox_level": { + "type": "integer", + "minimum": -2147483648, + "maximum": 2147483647 + }, + "predecessor": { + "$ref": "#/definitions/commitment_hash" + }, + "number_of_messages": { + "type": "integer", + "minimum": -2147483648, + "maximum": 2147483647 + }, + "number_of_ticks": { + "type": "integer", + "minimum": -2147483648, + "maximum": 2147483647 + } + }, + "required": [ + "number_of_ticks", + "number_of_messages", + "predecessor", + "inbox_level", + "compressed_state" + ], + "additionalProperties": false + } + }, + "required": [ + "commitment", + "rollup", + "storage_limit", + "gas_limit", + "counter", + "fee", + "source", + "kind" + ], + "additionalProperties": false + }, + { + "title": "Sc_rollup_refute", + "type": "object", + "properties": { + "kind": { + "type": "string", + "enum": [ + "sc_rollup_refute" + ] + }, + "source": { + "$ref": "#/definitions/Signature.Public_key_hash" + }, + "fee": { + "$ref": "#/definitions/alpha.mutez" + }, + "counter": { + "$ref": "#/definitions/positive_bignum" + }, + "gas_limit": { + "$ref": "#/definitions/positive_bignum" + }, + "storage_limit": { + "$ref": "#/definitions/positive_bignum" + }, + "rollup": { + "$ref": "#/definitions/alpha.rollup_address" + }, + "opponent": { + "$ref": "#/definitions/Signature.Public_key_hash" + }, + "refutation": { + "type": "object", + "properties": { + "choice": { + "$ref": "#/definitions/positive_bignum" + }, + "step": { + "oneOf": [ + { + "title": "Dissection", "type": "array", "items": { - "$ref": "#/definitions/micheline.alpha.michelson_v1.expression" + "type": "array", + "items": [ + { + "oneOf": [ + { + "title": "Some", + "$ref": "#/definitions/state_hash" + }, + { + "title": "None", + "type": "null" + } + ] + }, + { + "$ref": "#/definitions/positive_bignum" + } + ], + "additionalItems": false } }, - "annots": { - "type": "array", - "items": { - "type": "string" - } + { + "title": "Proof", + "type": "object", + "properties": { + "pvm_step": { + "oneOf": [ + { + "title": "Arithmetic PVM with proof", + "type": "object", + "properties": { + "tree_proof": { + "type": "object", + "properties": { + "version": { + "type": "integer", + "minimum": -32768, + "maximum": 32767 + }, + "before": { + "oneOf": [ + { + "title": "Value", + "type": "object", + "properties": { + "value": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "value" + ], + "additionalProperties": false + }, + { + "title": "Node", + "type": "object", + "properties": { + "node": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "node" + ], + "additionalProperties": false + } + ] + }, + "after": { + "oneOf": [ + { + "title": "Value", + "type": "object", + "properties": { + "value": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "value" + ], + "additionalProperties": false + }, + { + "title": "Node", + "type": "object", + "properties": { + "node": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "node" + ], + "additionalProperties": false + } + ] + }, + "state": { + "oneOf": [ + { + "title": "Value", + "type": "object", + "properties": { + "value": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + } + }, + "required": [ + "value" + ], + "additionalProperties": false + }, + { + "title": "Blinded_value", + "type": "object", + "properties": { + "blinded_value": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_value" + ], + "additionalProperties": false + }, + { + "title": "Node", + "type": "object", + "properties": { + "node": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + { + "$ref": "#/definitions/tree_encoding" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "node" + ], + "additionalProperties": false + }, + { + "title": "Blinded_node", + "type": "object", + "properties": { + "blinded_node": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_node" + ], + "additionalProperties": false + }, + { + "title": "Inode", + "type": "object", + "properties": { + "inode": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "proofs": { + "oneOf": [ + { + "title": "sparse_proof", + "type": "object", + "properties": { + "sparse_proof": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "integer", + "minimum": 0, + "maximum": 255 + }, + { + "oneOf": [ + { + "title": "Blinded_inode", + "type": "object", + "properties": { + "blinded_inode": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_inode" + ], + "additionalProperties": false + }, + { + "title": "Inode_values", + "type": "object", + "properties": { + "inode_values": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + { + "$ref": "#/definitions/tree_encoding" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "inode_values" + ], + "additionalProperties": false + }, + { + "title": "Inode_tree", + "type": "object", + "properties": { + "inode_tree": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "proofs": { + "oneOf": [ + { + "title": "sparse_proof", + "type": "object", + "properties": { + "sparse_proof": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "integer", + "minimum": 0, + "maximum": 255 + }, + { + "$ref": "#/definitions/inode_tree" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "sparse_proof" + ], + "additionalProperties": false + }, + { + "title": "dense_proof", + "type": "object", + "properties": { + "dense_proof": { + "type": "array", + "items": { + "$ref": "#/definitions/inode_tree" + } + } + }, + "required": [ + "dense_proof" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proofs", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_tree" + ], + "additionalProperties": false + }, + { + "title": "Inode_extender", + "type": "object", + "properties": { + "inode_extender": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "segment": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + "proof": { + "$ref": "#/definitions/inode_tree" + } + }, + "required": [ + "proof", + "segment", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_extender" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "object", + "properties": { + "none": { + "type": "null" + } + }, + "required": [ + "none" + ], + "additionalProperties": false + } + ] + } + ], + "additionalItems": false + } + } + }, + "required": [ + "sparse_proof" + ], + "additionalProperties": false + }, + { + "title": "dense_proof", + "type": "object", + "properties": { + "dense_proof": { + "type": "array", + "items": { + "oneOf": [ + { + "title": "Blinded_inode", + "type": "object", + "properties": { + "blinded_inode": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_inode" + ], + "additionalProperties": false + }, + { + "title": "Inode_values", + "type": "object", + "properties": { + "inode_values": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + { + "$ref": "#/definitions/tree_encoding" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "inode_values" + ], + "additionalProperties": false + }, + { + "title": "Inode_tree", + "type": "object", + "properties": { + "inode_tree": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "proofs": { + "oneOf": [ + { + "title": "sparse_proof", + "type": "object", + "properties": { + "sparse_proof": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "integer", + "minimum": 0, + "maximum": 255 + }, + { + "$ref": "#/definitions/inode_tree" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "sparse_proof" + ], + "additionalProperties": false + }, + { + "title": "dense_proof", + "type": "object", + "properties": { + "dense_proof": { + "type": "array", + "items": { + "$ref": "#/definitions/inode_tree" + } + } + }, + "required": [ + "dense_proof" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proofs", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_tree" + ], + "additionalProperties": false + }, + { + "title": "Inode_extender", + "type": "object", + "properties": { + "inode_extender": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "segment": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + "proof": { + "$ref": "#/definitions/inode_tree" + } + }, + "required": [ + "proof", + "segment", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_extender" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "object", + "properties": { + "none": { + "type": "null" + } + }, + "required": [ + "none" + ], + "additionalProperties": false + } + ] + } + } + }, + "required": [ + "dense_proof" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proofs", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode" + ], + "additionalProperties": false + }, + { + "title": "Extender", + "type": "object", + "properties": { + "extender": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "segment": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + "proof": { + "oneOf": [ + { + "title": "Blinded_inode", + "type": "object", + "properties": { + "blinded_inode": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_inode" + ], + "additionalProperties": false + }, + { + "title": "Inode_values", + "type": "object", + "properties": { + "inode_values": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + { + "$ref": "#/definitions/tree_encoding" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "inode_values" + ], + "additionalProperties": false + }, + { + "title": "Inode_tree", + "type": "object", + "properties": { + "inode_tree": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "proofs": { + "oneOf": [ + { + "title": "sparse_proof", + "type": "object", + "properties": { + "sparse_proof": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "integer", + "minimum": 0, + "maximum": 255 + }, + { + "$ref": "#/definitions/inode_tree" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "sparse_proof" + ], + "additionalProperties": false + }, + { + "title": "dense_proof", + "type": "object", + "properties": { + "dense_proof": { + "type": "array", + "items": { + "$ref": "#/definitions/inode_tree" + } + } + }, + "required": [ + "dense_proof" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proofs", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_tree" + ], + "additionalProperties": false + }, + { + "title": "Inode_extender", + "type": "object", + "properties": { + "inode_extender": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "segment": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + "proof": { + "$ref": "#/definitions/inode_tree" + } + }, + "required": [ + "proof", + "segment", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_extender" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "object", + "properties": { + "none": { + "type": "null" + } + }, + "required": [ + "none" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proof", + "segment", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "extender" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "object", + "properties": { + "none": { + "type": "null" + } + }, + "required": [ + "none" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "state", + "after", + "before", + "version" + ], + "additionalProperties": false + }, + "given": { + "oneOf": [ + { + "title": "Some", + "type": "object", + "properties": { + "inbox_level": { + "type": "integer", + "minimum": -2147483648, + "maximum": 2147483647 + }, + "message_counter": { + "$ref": "#/definitions/positive_bignum" + }, + "payload": { + "$ref": "#/definitions/unistring" + } + }, + "required": [ + "payload", + "message_counter", + "inbox_level" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "null" + } + ] + }, + "requested": { + "oneOf": [ + { + "title": "No_input_required", + "type": "object", + "properties": { + "no_input_required": {} + }, + "required": [ + "no_input_required" + ], + "additionalProperties": false + }, + { + "title": "Initial", + "type": "object", + "properties": { + "initial": {} + }, + "required": [ + "initial" + ], + "additionalProperties": false + }, + { + "title": "First_after", + "type": "array", + "items": [ + { + "type": "integer", + "minimum": -2147483648, + "maximum": 2147483647 + }, + { + "$ref": "#/definitions/positive_bignum" + } + ], + "additionalItems": false + } + ] + } + }, + "required": [ + "requested", + "given", + "tree_proof" + ], + "additionalProperties": false + } + ] + }, + "inbox": { + "oneOf": [ + { + "title": "Some", + "type": "object", + "properties": { + "skips": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "object", + "properties": { + "rollup": { + "$ref": "#/definitions/alpha.rollup_address" + }, + "message_counter": { + "$ref": "#/definitions/positive_bignum" + }, + "nb_available_messages": { + "$ref": "#/definitions/int64" + }, + "nb_messages_in_commitment_period": { + "$ref": "#/definitions/int64" + }, + "starting_level_of_current_commitment_period": { + "type": "integer", + "minimum": -2147483648, + "maximum": 2147483647 + }, + "level": { + "type": "integer", + "minimum": -2147483648, + "maximum": 2147483647 + }, + "current_messages_hash": { + "$ref": "#/definitions/inbox_hash" + }, + "old_levels_messages": { + "type": "object", + "properties": { + "index": { + "type": "integer", + "minimum": -1073741824, + "maximum": 1073741823 + }, + "content": { + "$ref": "#/definitions/inbox_hash" + }, + "back_pointers": { + "type": "array", + "items": { + "$ref": "#/definitions/inbox_hash" + } + } + }, + "required": [ + "back_pointers", + "content", + "index" + ], + "additionalProperties": false + } + }, + "required": [ + "old_levels_messages", + "current_messages_hash", + "level", + "starting_level_of_current_commitment_period", + "nb_messages_in_commitment_period", + "nb_available_messages", + "message_counter", + "rollup" + ], + "additionalProperties": false + }, + { + "type": "array", + "items": { + "type": "object", + "properties": { + "index": { + "type": "integer", + "minimum": -1073741824, + "maximum": 1073741823 + }, + "content": { + "$ref": "#/definitions/inbox_hash" + }, + "back_pointers": { + "type": "array", + "items": { + "$ref": "#/definitions/inbox_hash" + } + } + }, + "required": [ + "back_pointers", + "content", + "index" + ], + "additionalProperties": false + } + } + ], + "additionalItems": false + } + }, + "level": { + "type": "object", + "properties": { + "rollup": { + "$ref": "#/definitions/alpha.rollup_address" + }, + "message_counter": { + "$ref": "#/definitions/positive_bignum" + }, + "nb_available_messages": { + "$ref": "#/definitions/int64" + }, + "nb_messages_in_commitment_period": { + "$ref": "#/definitions/int64" + }, + "starting_level_of_current_commitment_period": { + "type": "integer", + "minimum": -2147483648, + "maximum": 2147483647 + }, + "level": { + "type": "integer", + "minimum": -2147483648, + "maximum": 2147483647 + }, + "current_messages_hash": { + "$ref": "#/definitions/inbox_hash" + }, + "old_levels_messages": { + "type": "object", + "properties": { + "index": { + "type": "integer", + "minimum": -1073741824, + "maximum": 1073741823 + }, + "content": { + "$ref": "#/definitions/inbox_hash" + }, + "back_pointers": { + "type": "array", + "items": { + "$ref": "#/definitions/inbox_hash" + } + } + }, + "required": [ + "back_pointers", + "content", + "index" + ], + "additionalProperties": false + } + }, + "required": [ + "old_levels_messages", + "current_messages_hash", + "level", + "starting_level_of_current_commitment_period", + "nb_messages_in_commitment_period", + "nb_available_messages", + "message_counter", + "rollup" + ], + "additionalProperties": false + }, + "inc": { + "type": "array", + "items": { + "type": "object", + "properties": { + "index": { + "type": "integer", + "minimum": -1073741824, + "maximum": 1073741823 + }, + "content": { + "$ref": "#/definitions/inbox_hash" + }, + "back_pointers": { + "type": "array", + "items": { + "$ref": "#/definitions/inbox_hash" + } + } + }, + "required": [ + "back_pointers", + "content", + "index" + ], + "additionalProperties": false + } + }, + "message_proof": { + "type": "object", + "properties": { + "version": { + "type": "integer", + "minimum": -32768, + "maximum": 32767 + }, + "before": { + "oneOf": [ + { + "title": "Value", + "type": "object", + "properties": { + "value": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "value" + ], + "additionalProperties": false + }, + { + "title": "Node", + "type": "object", + "properties": { + "node": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "node" + ], + "additionalProperties": false + } + ] + }, + "after": { + "oneOf": [ + { + "title": "Value", + "type": "object", + "properties": { + "value": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "value" + ], + "additionalProperties": false + }, + { + "title": "Node", + "type": "object", + "properties": { + "node": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "node" + ], + "additionalProperties": false + } + ] + }, + "state": { + "oneOf": [ + { + "title": "Value", + "type": "object", + "properties": { + "value": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + } + }, + "required": [ + "value" + ], + "additionalProperties": false + }, + { + "title": "Blinded_value", + "type": "object", + "properties": { + "blinded_value": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_value" + ], + "additionalProperties": false + }, + { + "title": "Node", + "type": "object", + "properties": { + "node": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + { + "$ref": "#/definitions/tree_encoding" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "node" + ], + "additionalProperties": false + }, + { + "title": "Blinded_node", + "type": "object", + "properties": { + "blinded_node": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_node" + ], + "additionalProperties": false + }, + { + "title": "Inode", + "type": "object", + "properties": { + "inode": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "proofs": { + "oneOf": [ + { + "title": "sparse_proof", + "type": "object", + "properties": { + "sparse_proof": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "integer", + "minimum": 0, + "maximum": 255 + }, + { + "oneOf": [ + { + "title": "Blinded_inode", + "type": "object", + "properties": { + "blinded_inode": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_inode" + ], + "additionalProperties": false + }, + { + "title": "Inode_values", + "type": "object", + "properties": { + "inode_values": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + { + "$ref": "#/definitions/tree_encoding" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "inode_values" + ], + "additionalProperties": false + }, + { + "title": "Inode_tree", + "type": "object", + "properties": { + "inode_tree": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "proofs": { + "oneOf": [ + { + "title": "sparse_proof", + "type": "object", + "properties": { + "sparse_proof": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "integer", + "minimum": 0, + "maximum": 255 + }, + { + "$ref": "#/definitions/inode_tree" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "sparse_proof" + ], + "additionalProperties": false + }, + { + "title": "dense_proof", + "type": "object", + "properties": { + "dense_proof": { + "type": "array", + "items": { + "$ref": "#/definitions/inode_tree" + } + } + }, + "required": [ + "dense_proof" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proofs", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_tree" + ], + "additionalProperties": false + }, + { + "title": "Inode_extender", + "type": "object", + "properties": { + "inode_extender": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "segment": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + "proof": { + "$ref": "#/definitions/inode_tree" + } + }, + "required": [ + "proof", + "segment", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_extender" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "object", + "properties": { + "none": { + "type": "null" + } + }, + "required": [ + "none" + ], + "additionalProperties": false + } + ] + } + ], + "additionalItems": false + } + } + }, + "required": [ + "sparse_proof" + ], + "additionalProperties": false + }, + { + "title": "dense_proof", + "type": "object", + "properties": { + "dense_proof": { + "type": "array", + "items": { + "oneOf": [ + { + "title": "Blinded_inode", + "type": "object", + "properties": { + "blinded_inode": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_inode" + ], + "additionalProperties": false + }, + { + "title": "Inode_values", + "type": "object", + "properties": { + "inode_values": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + { + "$ref": "#/definitions/tree_encoding" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "inode_values" + ], + "additionalProperties": false + }, + { + "title": "Inode_tree", + "type": "object", + "properties": { + "inode_tree": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "proofs": { + "oneOf": [ + { + "title": "sparse_proof", + "type": "object", + "properties": { + "sparse_proof": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "integer", + "minimum": 0, + "maximum": 255 + }, + { + "$ref": "#/definitions/inode_tree" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "sparse_proof" + ], + "additionalProperties": false + }, + { + "title": "dense_proof", + "type": "object", + "properties": { + "dense_proof": { + "type": "array", + "items": { + "$ref": "#/definitions/inode_tree" + } + } + }, + "required": [ + "dense_proof" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proofs", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_tree" + ], + "additionalProperties": false + }, + { + "title": "Inode_extender", + "type": "object", + "properties": { + "inode_extender": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "segment": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + "proof": { + "$ref": "#/definitions/inode_tree" + } + }, + "required": [ + "proof", + "segment", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_extender" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "object", + "properties": { + "none": { + "type": "null" + } + }, + "required": [ + "none" + ], + "additionalProperties": false + } + ] + } + } + }, + "required": [ + "dense_proof" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proofs", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode" + ], + "additionalProperties": false + }, + { + "title": "Extender", + "type": "object", + "properties": { + "extender": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "segment": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + "proof": { + "oneOf": [ + { + "title": "Blinded_inode", + "type": "object", + "properties": { + "blinded_inode": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_inode" + ], + "additionalProperties": false + }, + { + "title": "Inode_values", + "type": "object", + "properties": { + "inode_values": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + { + "$ref": "#/definitions/tree_encoding" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "inode_values" + ], + "additionalProperties": false + }, + { + "title": "Inode_tree", + "type": "object", + "properties": { + "inode_tree": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "proofs": { + "oneOf": [ + { + "title": "sparse_proof", + "type": "object", + "properties": { + "sparse_proof": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "integer", + "minimum": 0, + "maximum": 255 + }, + { + "$ref": "#/definitions/inode_tree" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "sparse_proof" + ], + "additionalProperties": false + }, + { + "title": "dense_proof", + "type": "object", + "properties": { + "dense_proof": { + "type": "array", + "items": { + "$ref": "#/definitions/inode_tree" + } + } + }, + "required": [ + "dense_proof" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proofs", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_tree" + ], + "additionalProperties": false + }, + { + "title": "Inode_extender", + "type": "object", + "properties": { + "inode_extender": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "segment": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + "proof": { + "$ref": "#/definitions/inode_tree" + } + }, + "required": [ + "proof", + "segment", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_extender" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "object", + "properties": { + "none": { + "type": "null" + } + }, + "required": [ + "none" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proof", + "segment", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "extender" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "object", + "properties": { + "none": { + "type": "null" + } + }, + "required": [ + "none" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "state", + "after", + "before", + "version" + ], + "additionalProperties": false + } + }, + "required": [ + "message_proof", + "inc", + "level", + "skips" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "null" + } + ] + } + }, + "required": [ + "inbox", + "pvm_step" + ], + "additionalProperties": false } - }, - "required": [ - "prim" - ], - "additionalProperties": false + ] } - ] + }, + "required": [ + "step", + "choice" + ], + "additionalProperties": false } }, - "required": [ - "parameters_ty", - "boot_sector", - "kind", + "required": [ + "refutation", + "opponent", + "rollup", "storage_limit", "gas_limit", "counter", @@ -13962,13 +19664,13 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "additionalProperties": false }, { - "title": "Sc_rollup_add_messages", + "title": "Sc_rollup_timeout", "type": "object", "properties": { "kind": { "type": "string", "enum": [ - "sc_rollup_add_messages" + "sc_rollup_timeout" ] }, "source": { @@ -13989,15 +19691,21 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "rollup": { "$ref": "#/definitions/alpha.rollup_address" }, - "message": { + "stakers": { "type": "array", - "items": { - "$ref": "#/definitions/unistring" - } + "items": [ + { + "$ref": "#/definitions/Signature.Public_key_hash" + }, + { + "$ref": "#/definitions/Signature.Public_key_hash" + } + ], + "additionalItems": false } }, "required": [ - "message", + "stakers", "rollup", "storage_limit", "gas_limit", @@ -14009,13 +19717,13 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "additionalProperties": false }, { - "title": "Sc_rollup_cement", + "title": "Sc_rollup_atomic_batch", "type": "object", "properties": { "kind": { "type": "string", "enum": [ - "sc_rollup_cement" + "sc_rollup_atomic_batch" ] }, "source": { @@ -14036,686 +19744,1184 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "rollup": { "$ref": "#/definitions/alpha.rollup_address" }, - "commitment": { + "cemented_commitment": { "$ref": "#/definitions/commitment_hash" + }, + "outbox_level": { + "type": "integer", + "minimum": -2147483648, + "maximum": 2147483647 + }, + "message_index": { + "type": "integer", + "minimum": -1073741824, + "maximum": 1073741823 + }, + "inclusion proof": { + "$ref": "#/definitions/unistring" + }, + "atomic_transaction_batch": { + "$ref": "#/definitions/unistring" + } + }, + "required": [ + "atomic_transaction_batch", + "inclusion proof", + "message_index", + "outbox_level", + "cemented_commitment", + "rollup", + "storage_limit", + "gas_limit", + "counter", + "fee", + "source", + "kind" + ], + "additionalProperties": false + } + ] + }, + "alpha.rollup_address": { + "title": "A smart contract rollup address", + "description": "A smart contract rollup is identified by a base58 address starting with scr1", + "$ref": "#/definitions/unistring" + }, + "alpha.scripted.contracts": { + "type": "object", + "properties": { + "code": { + "oneOf": [ + { + "title": "Int", + "type": "object", + "properties": { + "int": { + "$ref": "#/definitions/bignum" + } + }, + "required": [ + "int" + ], + "additionalProperties": false + }, + { + "title": "String", + "type": "object", + "properties": { + "string": { + "$ref": "#/definitions/unistring" + } + }, + "required": [ + "string" + ], + "additionalProperties": false + }, + { + "title": "Bytes", + "type": "object", + "properties": { + "bytes": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + } + }, + "required": [ + "bytes" + ], + "additionalProperties": false + }, + { + "title": "Sequence", + "type": "array", + "items": { + "$ref": "#/definitions/micheline.alpha.michelson_v1.expression" + } + }, + { + "title": "Prim__generic", + "description": "Generic primitive (any number of args with or without annotations)", + "type": "object", + "properties": { + "prim": { + "$ref": "#/definitions/alpha.michelson.v1.primitives" + }, + "args": { + "type": "array", + "items": { + "$ref": "#/definitions/micheline.alpha.michelson_v1.expression" + } + }, + "annots": { + "type": "array", + "items": { + "type": "string" + } + } + }, + "required": [ + "prim" + ], + "additionalProperties": false + } + ] + }, + "storage": { + "oneOf": [ + { + "title": "Int", + "type": "object", + "properties": { + "int": { + "$ref": "#/definitions/bignum" + } + }, + "required": [ + "int" + ], + "additionalProperties": false + }, + { + "title": "String", + "type": "object", + "properties": { + "string": { + "$ref": "#/definitions/unistring" + } + }, + "required": [ + "string" + ], + "additionalProperties": false + }, + { + "title": "Bytes", + "type": "object", + "properties": { + "bytes": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + } + }, + "required": [ + "bytes" + ], + "additionalProperties": false + }, + { + "title": "Sequence", + "type": "array", + "items": { + "$ref": "#/definitions/micheline.alpha.michelson_v1.expression" + } + }, + { + "title": "Prim__generic", + "description": "Generic primitive (any number of args with or without annotations)", + "type": "object", + "properties": { + "prim": { + "$ref": "#/definitions/alpha.michelson.v1.primitives" + }, + "args": { + "type": "array", + "items": { + "$ref": "#/definitions/micheline.alpha.michelson_v1.expression" + } + }, + "annots": { + "type": "array", + "items": { + "type": "string" + } + } + }, + "required": [ + "prim" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "storage", + "code" + ], + "additionalProperties": false + }, + "alpha.tx_rollup_id": { + "title": "A tx rollup handle", + "description": "A tx rollup notation as given to an RPC or inside scripts, is a base58 tx rollup hash", + "$ref": "#/definitions/unistring" + }, + "bignum": { + "title": "Big number", + "description": "Decimal representation of a big number", + "type": "string" + }, + "block_hash": { + "title": "A block identifier (Base58Check-encoded)", + "$ref": "#/definitions/unistring" + }, + "commitment_hash": { + "title": "The hash of a commitment of a smart contract rollup (Base58Check-encoded)", + "$ref": "#/definitions/unistring" + }, + "cycle_nonce": { + "title": "A nonce hash (Base58Check-encoded)", + "$ref": "#/definitions/unistring" + }, + "error": { + "description": "The full list of errors is available with the global RPC `GET errors`" + }, + "fitness": { + "title": "Block fitness", + "description": "The fitness, or score, of a block, that allow the Tezos to decide which chain is the best. A fitness value is a list of byte sequences. They are compared as follows: shortest lists are smaller; lists of the same length are compared according to the lexicographical order.", + "type": "array", + "items": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + } + }, + "inbox_hash": { + "title": "The hash of an inbox of a smart contract rollup (Base58Check-encoded)", + "$ref": "#/definitions/unistring" + }, + "inode_tree": { + "oneOf": [ + { + "title": "Blinded_inode", + "type": "object", + "properties": { + "blinded_inode": { + "$ref": "#/definitions/Context_hash" } }, "required": [ - "commitment", - "rollup", - "storage_limit", - "gas_limit", - "counter", - "fee", - "source", - "kind" + "blinded_inode" ], "additionalProperties": false }, { - "title": "Sc_rollup_publish", + "title": "Inode_values", "type": "object", "properties": { - "kind": { - "type": "string", - "enum": [ - "sc_rollup_publish" - ] - }, - "source": { - "$ref": "#/definitions/Signature.Public_key_hash" - }, - "fee": { - "$ref": "#/definitions/alpha.mutez" - }, - "counter": { - "$ref": "#/definitions/positive_bignum" - }, - "gas_limit": { - "$ref": "#/definitions/positive_bignum" - }, - "storage_limit": { - "$ref": "#/definitions/positive_bignum" - }, - "rollup": { - "$ref": "#/definitions/alpha.rollup_address" - }, - "commitment": { - "type": "object", - "properties": { - "compressed_state": { - "$ref": "#/definitions/state_hash" - }, - "inbox_level": { - "type": "integer", - "minimum": -2147483648, - "maximum": 2147483647 - }, - "predecessor": { - "$ref": "#/definitions/commitment_hash" - }, - "number_of_messages": { - "type": "integer", - "minimum": -2147483648, - "maximum": 2147483647 - }, - "number_of_ticks": { - "type": "integer", - "minimum": -2147483648, - "maximum": 2147483647 - } - }, - "required": [ - "number_of_ticks", - "number_of_messages", - "predecessor", - "inbox_level", - "compressed_state" - ], - "additionalProperties": false + "inode_values": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + { + "$ref": "#/definitions/tree_encoding" + } + ], + "additionalItems": false + } } }, "required": [ - "commitment", - "rollup", - "storage_limit", - "gas_limit", - "counter", - "fee", - "source", - "kind" + "inode_values" ], "additionalProperties": false }, { - "title": "Sc_rollup_refute", + "title": "Inode_tree", "type": "object", "properties": { - "kind": { - "type": "string", - "enum": [ - "sc_rollup_refute" - ] - }, - "source": { - "$ref": "#/definitions/Signature.Public_key_hash" - }, - "fee": { - "$ref": "#/definitions/alpha.mutez" - }, - "counter": { - "$ref": "#/definitions/positive_bignum" - }, - "gas_limit": { - "$ref": "#/definitions/positive_bignum" - }, - "storage_limit": { - "$ref": "#/definitions/positive_bignum" - }, - "rollup": { - "$ref": "#/definitions/alpha.rollup_address" - }, - "opponent": { - "$ref": "#/definitions/Signature.Public_key_hash" - }, - "refutation": { + "inode_tree": { "type": "object", "properties": { - "choice": { - "$ref": "#/definitions/positive_bignum" + "length": { + "$ref": "#/definitions/int64" }, - "step": { + "proofs": { "oneOf": [ { - "title": "Dissection", - "type": "array", - "items": { - "type": "array", - "items": [ - { - "oneOf": [ + "title": "sparse_proof", + "type": "object", + "properties": { + "sparse_proof": { + "type": "array", + "items": { + "type": "array", + "items": [ { - "title": "Some", - "$ref": "#/definitions/state_hash" + "type": "integer", + "minimum": 0, + "maximum": 255 }, { - "title": "None", - "type": "null" + "$ref": "#/definitions/inode_tree" } - ] - }, - { - "$ref": "#/definitions/positive_bignum" + ], + "additionalItems": false } - ], - "additionalItems": false - } + } + }, + "required": [ + "sparse_proof" + ], + "additionalProperties": false }, { - "title": "Proof", - "oneOf": [ - { - "title": "Proof of a normal computation step", - "type": "array", - "items": [ - { - "type": "boolean" - }, - { - "$ref": "#/definitions/state_hash" - }, - { - "$ref": "#/definitions/state_hash" - } - ], - "additionalItems": false - }, - { - "title": "Proof of an input step", - "type": "array", - "items": [ - { - "type": "boolean" - }, - { - "$ref": "#/definitions/state_hash" - }, - { - "$ref": "#/definitions/state_hash" - } - ], - "additionalItems": false - }, - { - "title": "Proof that the PVM is blocked", + "title": "dense_proof", + "type": "object", + "properties": { + "dense_proof": { "type": "array", - "items": [ - { - "type": "boolean" - }, - { - "$ref": "#/definitions/state_hash" - } - ], - "additionalItems": false + "items": { + "$ref": "#/definitions/inode_tree" + } } - ] + }, + "required": [ + "dense_proof" + ], + "additionalProperties": false } ] } }, "required": [ - "step", - "choice" + "proofs", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_tree" + ], + "additionalProperties": false + }, + { + "title": "Inode_extender", + "type": "object", + "properties": { + "inode_extender": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "segment": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + "proof": { + "$ref": "#/definitions/inode_tree" + } + }, + "required": [ + "proof", + "segment", + "length" ], "additionalProperties": false } }, "required": [ - "refutation", - "opponent", - "rollup", - "storage_limit", - "gas_limit", - "counter", - "fee", - "source", - "kind" + "inode_extender" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "object", + "properties": { + "none": { + "type": "null" + } + }, + "required": [ + "none" + ], + "additionalProperties": false + } + ] + }, + "int64": { + "title": "64 bit integers", + "description": "Decimal representation of 64 bit integers", + "type": "string" + }, + "micheline.alpha.michelson_v1.expression": { + "oneOf": [ + { + "title": "Int", + "type": "object", + "properties": { + "int": { + "$ref": "#/definitions/bignum" + } + }, + "required": [ + "int" + ], + "additionalProperties": false + }, + { + "title": "String", + "type": "object", + "properties": { + "string": { + "$ref": "#/definitions/unistring" + } + }, + "required": [ + "string" ], "additionalProperties": false }, { - "title": "Sc_rollup_timeout", + "title": "Bytes", "type": "object", "properties": { - "kind": { + "bytes": { "type": "string", - "enum": [ - "sc_rollup_timeout" - ] - }, - "source": { - "$ref": "#/definitions/Signature.Public_key_hash" - }, - "fee": { - "$ref": "#/definitions/alpha.mutez" - }, - "counter": { - "$ref": "#/definitions/positive_bignum" - }, - "gas_limit": { - "$ref": "#/definitions/positive_bignum" - }, - "storage_limit": { - "$ref": "#/definitions/positive_bignum" - }, - "rollup": { - "$ref": "#/definitions/alpha.rollup_address" - }, - "stakers": { - "type": "array", - "items": [ - { - "$ref": "#/definitions/Signature.Public_key_hash" - }, - { - "$ref": "#/definitions/Signature.Public_key_hash" - } - ], - "additionalItems": false + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" } }, "required": [ - "stakers", - "rollup", - "storage_limit", - "gas_limit", - "counter", - "fee", - "source", - "kind" + "bytes" ], "additionalProperties": false }, { - "title": "Sc_rollup_atomic_batch", + "title": "Sequence", + "type": "array", + "items": { + "$ref": "#/definitions/micheline.alpha.michelson_v1.expression" + } + }, + { + "title": "Prim__generic", + "description": "Generic primitive (any number of args with or without annotations)", "type": "object", "properties": { - "kind": { - "type": "string", - "enum": [ - "sc_rollup_atomic_batch" - ] - }, - "source": { - "$ref": "#/definitions/Signature.Public_key_hash" - }, - "fee": { - "$ref": "#/definitions/alpha.mutez" - }, - "counter": { - "$ref": "#/definitions/positive_bignum" - }, - "gas_limit": { - "$ref": "#/definitions/positive_bignum" - }, - "storage_limit": { - "$ref": "#/definitions/positive_bignum" - }, - "rollup": { - "$ref": "#/definitions/alpha.rollup_address" - }, - "cemented_commitment": { - "$ref": "#/definitions/commitment_hash" - }, - "outbox_level": { - "type": "integer", - "minimum": -2147483648, - "maximum": 2147483647 - }, - "message_index": { - "type": "integer", - "minimum": -1073741824, - "maximum": 1073741823 + "prim": { + "$ref": "#/definitions/alpha.michelson.v1.primitives" }, - "inclusion proof": { - "$ref": "#/definitions/unistring" + "args": { + "type": "array", + "items": { + "$ref": "#/definitions/micheline.alpha.michelson_v1.expression" + } }, - "atomic_transaction_batch": { - "$ref": "#/definitions/unistring" + "annots": { + "type": "array", + "items": { + "type": "string" + } } }, "required": [ - "atomic_transaction_batch", - "inclusion proof", - "message_index", - "outbox_level", - "cemented_commitment", - "rollup", - "storage_limit", - "gas_limit", - "counter", - "fee", - "source", - "kind" + "prim" ], "additionalProperties": false } ] }, - "alpha.rollup_address": { - "title": "A smart contract rollup address", - "description": "A smart contract rollup is identified by a base58 address starting with scr1", - "$ref": "#/definitions/unistring" - }, - "alpha.scripted.contracts": { + "next_operation": { + "description": "An operation's shell header.", "type": "object", "properties": { - "code": { - "oneOf": [ - { - "title": "Int", - "type": "object", - "properties": { - "int": { - "$ref": "#/definitions/bignum" - } - }, - "required": [ - "int" - ], - "additionalProperties": false - }, - { - "title": "String", - "type": "object", - "properties": { - "string": { - "$ref": "#/definitions/unistring" - } - }, - "required": [ - "string" - ], - "additionalProperties": false - }, - { - "title": "Bytes", - "type": "object", - "properties": { - "bytes": { - "type": "string", - "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" - } - }, - "required": [ - "bytes" - ], - "additionalProperties": false - }, - { - "title": "Sequence", - "type": "array", - "items": { - "$ref": "#/definitions/micheline.alpha.michelson_v1.expression" - } - }, - { - "title": "Prim__generic", - "description": "Generic primitive (any number of args with or without annotations)", - "type": "object", - "properties": { - "prim": { - "$ref": "#/definitions/alpha.michelson.v1.primitives" - }, - "args": { - "type": "array", - "items": { - "$ref": "#/definitions/micheline.alpha.michelson_v1.expression" - } - }, - "annots": { - "type": "array", - "items": { - "type": "string" - } - } - }, - "required": [ - "prim" - ], - "additionalProperties": false + "protocol": { + "type": "string", + "enum": [ + "ProtoALphaALphaALphaALphaALphaALphaALphaALphaDdp3zK" + ] + }, + "branch": { + "$ref": "#/definitions/block_hash" + }, + "contents": { + "type": "array", + "items": { + "$ref": "#/definitions/alpha.operation.alpha.contents" + } + }, + "signature": { + "$ref": "#/definitions/Signature" + } + }, + "required": [ + "signature", + "contents", + "branch", + "protocol" + ], + "additionalProperties": false + }, + "positive_bignum": { + "title": "Positive big number", + "description": "Decimal representation of a positive big number", + "type": "string" + }, + "script_expr": { + "title": "A script expression ID (Base58Check-encoded)", + "$ref": "#/definitions/unistring" + }, + "state_hash": { + "title": "The hash of the VM state of a smart contract rollup (Base58Check-encoded)", + "$ref": "#/definitions/unistring" + }, + "timestamp.protocol": { + "description": "A timestamp as seen by the protocol: second-level precision, epoch based.", + "$ref": "#/definitions/unistring" + }, + "tree_encoding": { + "oneOf": [ + { + "title": "Value", + "type": "object", + "properties": { + "value": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" } - ] + }, + "required": [ + "value" + ], + "additionalProperties": false }, - "storage": { - "oneOf": [ - { - "title": "Int", - "type": "object", - "properties": { - "int": { - "$ref": "#/definitions/bignum" - } - }, - "required": [ - "int" - ], - "additionalProperties": false - }, - { - "title": "String", - "type": "object", - "properties": { - "string": { - "$ref": "#/definitions/unistring" - } - }, - "required": [ - "string" - ], - "additionalProperties": false - }, - { - "title": "Bytes", - "type": "object", - "properties": { - "bytes": { - "type": "string", - "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" - } - }, - "required": [ - "bytes" - ], - "additionalProperties": false - }, - { - "title": "Sequence", + { + "title": "Blinded_value", + "type": "object", + "properties": { + "blinded_value": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_value" + ], + "additionalProperties": false + }, + { + "title": "Node", + "type": "object", + "properties": { + "node": { "type": "array", "items": { - "$ref": "#/definitions/micheline.alpha.michelson_v1.expression" + "type": "array", + "items": [ + { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + { + "$ref": "#/definitions/tree_encoding" + } + ], + "additionalItems": false } - }, - { - "title": "Prim__generic", - "description": "Generic primitive (any number of args with or without annotations)", + } + }, + "required": [ + "node" + ], + "additionalProperties": false + }, + { + "title": "Blinded_node", + "type": "object", + "properties": { + "blinded_node": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_node" + ], + "additionalProperties": false + }, + { + "title": "Inode", + "type": "object", + "properties": { + "inode": { "type": "object", "properties": { - "prim": { - "$ref": "#/definitions/alpha.michelson.v1.primitives" - }, - "args": { - "type": "array", - "items": { - "$ref": "#/definitions/micheline.alpha.michelson_v1.expression" - } + "length": { + "$ref": "#/definitions/int64" }, - "annots": { - "type": "array", - "items": { - "type": "string" - } + "proofs": { + "oneOf": [ + { + "title": "sparse_proof", + "type": "object", + "properties": { + "sparse_proof": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "integer", + "minimum": 0, + "maximum": 255 + }, + { + "oneOf": [ + { + "title": "Blinded_inode", + "type": "object", + "properties": { + "blinded_inode": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_inode" + ], + "additionalProperties": false + }, + { + "title": "Inode_values", + "type": "object", + "properties": { + "inode_values": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + { + "$ref": "#/definitions/tree_encoding" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "inode_values" + ], + "additionalProperties": false + }, + { + "title": "Inode_tree", + "type": "object", + "properties": { + "inode_tree": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "proofs": { + "oneOf": [ + { + "title": "sparse_proof", + "type": "object", + "properties": { + "sparse_proof": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "integer", + "minimum": 0, + "maximum": 255 + }, + { + "$ref": "#/definitions/inode_tree" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "sparse_proof" + ], + "additionalProperties": false + }, + { + "title": "dense_proof", + "type": "object", + "properties": { + "dense_proof": { + "type": "array", + "items": { + "$ref": "#/definitions/inode_tree" + } + } + }, + "required": [ + "dense_proof" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proofs", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_tree" + ], + "additionalProperties": false + }, + { + "title": "Inode_extender", + "type": "object", + "properties": { + "inode_extender": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "segment": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + "proof": { + "$ref": "#/definitions/inode_tree" + } + }, + "required": [ + "proof", + "segment", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_extender" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "object", + "properties": { + "none": { + "type": "null" + } + }, + "required": [ + "none" + ], + "additionalProperties": false + } + ] + } + ], + "additionalItems": false + } + } + }, + "required": [ + "sparse_proof" + ], + "additionalProperties": false + }, + { + "title": "dense_proof", + "type": "object", + "properties": { + "dense_proof": { + "type": "array", + "items": { + "oneOf": [ + { + "title": "Blinded_inode", + "type": "object", + "properties": { + "blinded_inode": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_inode" + ], + "additionalProperties": false + }, + { + "title": "Inode_values", + "type": "object", + "properties": { + "inode_values": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + { + "$ref": "#/definitions/tree_encoding" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "inode_values" + ], + "additionalProperties": false + }, + { + "title": "Inode_tree", + "type": "object", + "properties": { + "inode_tree": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "proofs": { + "oneOf": [ + { + "title": "sparse_proof", + "type": "object", + "properties": { + "sparse_proof": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "integer", + "minimum": 0, + "maximum": 255 + }, + { + "$ref": "#/definitions/inode_tree" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "sparse_proof" + ], + "additionalProperties": false + }, + { + "title": "dense_proof", + "type": "object", + "properties": { + "dense_proof": { + "type": "array", + "items": { + "$ref": "#/definitions/inode_tree" + } + } + }, + "required": [ + "dense_proof" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proofs", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_tree" + ], + "additionalProperties": false + }, + { + "title": "Inode_extender", + "type": "object", + "properties": { + "inode_extender": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "segment": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + "proof": { + "$ref": "#/definitions/inode_tree" + } + }, + "required": [ + "proof", + "segment", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_extender" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "object", + "properties": { + "none": { + "type": "null" + } + }, + "required": [ + "none" + ], + "additionalProperties": false + } + ] + } + } + }, + "required": [ + "dense_proof" + ], + "additionalProperties": false + } + ] } }, "required": [ - "prim" + "proofs", + "length" ], "additionalProperties": false } - ] - } - }, - "required": [ - "storage", - "code" - ], - "additionalProperties": false - }, - "alpha.tx_rollup_id": { - "title": "A tx rollup handle", - "description": "A tx rollup notation as given to an RPC or inside scripts, is a base58 tx rollup hash", - "$ref": "#/definitions/unistring" - }, - "bignum": { - "title": "Big number", - "description": "Decimal representation of a big number", - "type": "string" - }, - "block_hash": { - "title": "A block identifier (Base58Check-encoded)", - "$ref": "#/definitions/unistring" - }, - "commitment_hash": { - "title": "The hash of a commitment of a smart contract rollup (Base58Check-encoded)", - "$ref": "#/definitions/unistring" - }, - "cycle_nonce": { - "title": "A nonce hash (Base58Check-encoded)", - "$ref": "#/definitions/unistring" - }, - "error": { - "description": "The full list of errors is available with the global RPC `GET errors`" - }, - "fitness": { - "title": "Block fitness", - "description": "The fitness, or score, of a block, that allow the Tezos to decide which chain is the best. A fitness value is a list of byte sequences. They are compared as follows: shortest lists are smaller; lists of the same length are compared according to the lexicographical order.", - "type": "array", - "items": { - "type": "string", - "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" - } - }, - "int64": { - "title": "64 bit integers", - "description": "Decimal representation of 64 bit integers", - "type": "string" - }, - "micheline.alpha.michelson_v1.expression": { - "oneOf": [ - { - "title": "Int", - "type": "object", - "properties": { - "int": { - "$ref": "#/definitions/bignum" - } - }, - "required": [ - "int" - ], - "additionalProperties": false - }, - { - "title": "String", - "type": "object", - "properties": { - "string": { - "$ref": "#/definitions/unistring" - } }, "required": [ - "string" + "inode" ], "additionalProperties": false }, { - "title": "Bytes", + "title": "Extender", "type": "object", "properties": { - "bytes": { - "type": "string", - "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + "extender": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "segment": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + "proof": { + "oneOf": [ + { + "title": "Blinded_inode", + "type": "object", + "properties": { + "blinded_inode": { + "$ref": "#/definitions/Context_hash" + } + }, + "required": [ + "blinded_inode" + ], + "additionalProperties": false + }, + { + "title": "Inode_values", + "type": "object", + "properties": { + "inode_values": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + { + "$ref": "#/definitions/tree_encoding" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "inode_values" + ], + "additionalProperties": false + }, + { + "title": "Inode_tree", + "type": "object", + "properties": { + "inode_tree": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "proofs": { + "oneOf": [ + { + "title": "sparse_proof", + "type": "object", + "properties": { + "sparse_proof": { + "type": "array", + "items": { + "type": "array", + "items": [ + { + "type": "integer", + "minimum": 0, + "maximum": 255 + }, + { + "$ref": "#/definitions/inode_tree" + } + ], + "additionalItems": false + } + } + }, + "required": [ + "sparse_proof" + ], + "additionalProperties": false + }, + { + "title": "dense_proof", + "type": "object", + "properties": { + "dense_proof": { + "type": "array", + "items": { + "$ref": "#/definitions/inode_tree" + } + } + }, + "required": [ + "dense_proof" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proofs", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_tree" + ], + "additionalProperties": false + }, + { + "title": "Inode_extender", + "type": "object", + "properties": { + "inode_extender": { + "type": "object", + "properties": { + "length": { + "$ref": "#/definitions/int64" + }, + "segment": { + "type": "string", + "pattern": "^([a-zA-Z0-9][a-zA-Z0-9])*$" + }, + "proof": { + "$ref": "#/definitions/inode_tree" + } + }, + "required": [ + "proof", + "segment", + "length" + ], + "additionalProperties": false + } + }, + "required": [ + "inode_extender" + ], + "additionalProperties": false + }, + { + "title": "None", + "type": "object", + "properties": { + "none": { + "type": "null" + } + }, + "required": [ + "none" + ], + "additionalProperties": false + } + ] + } + }, + "required": [ + "proof", + "segment", + "length" + ], + "additionalProperties": false } }, "required": [ - "bytes" + "extender" ], "additionalProperties": false }, { - "title": "Sequence", - "type": "array", - "items": { - "$ref": "#/definitions/micheline.alpha.michelson_v1.expression" - } - }, - { - "title": "Prim__generic", - "description": "Generic primitive (any number of args with or without annotations)", + "title": "None", "type": "object", "properties": { - "prim": { - "$ref": "#/definitions/alpha.michelson.v1.primitives" - }, - "args": { - "type": "array", - "items": { - "$ref": "#/definitions/micheline.alpha.michelson_v1.expression" - } - }, - "annots": { - "type": "array", - "items": { - "type": "string" - } + "none": { + "type": "null" } }, "required": [ - "prim" + "none" ], "additionalProperties": false } ] }, - "next_operation": { - "description": "An operation's shell header.", - "type": "object", - "properties": { - "protocol": { - "type": "string", - "enum": [ - "ProtoALphaALphaALphaALphaALphaALphaALphaALphaDdp3zK" - ] - }, - "branch": { - "$ref": "#/definitions/block_hash" - }, - "contents": { - "type": "array", - "items": { - "$ref": "#/definitions/alpha.operation.alpha.contents" - } - }, - "signature": { - "$ref": "#/definitions/Signature" - } - }, - "required": [ - "signature", - "contents", - "branch", - "protocol" - ], - "additionalProperties": false - }, - "positive_bignum": { - "title": "Positive big number", - "description": "Decimal representation of a positive big number", - "type": "string" - }, - "script_expr": { - "title": "A script expression ID (Base58Check-encoded)", - "$ref": "#/definitions/unistring" - }, - "state_hash": { - "title": "The hash of the VM state of a smart contract rollup (Base58Check-encoded)", - "$ref": "#/definitions/unistring" - }, - "timestamp.protocol": { - "description": "A timestamp as seen by the protocol: second-level precision, epoch based.", - "$ref": "#/definitions/unistring" - }, "unistring": { "title": "Universal string representation", "description": "Either a plain UTF8 string, or a sequence of bytes for strings that contain invalid byte sequences.", diff --git a/tezt/tests/expected/sc_rollup.ml/Alpha- ensure boot sector is used.out b/tezt/tests/expected/sc_rollup.ml/Alpha- ensure boot sector is used.out index 280158754bac..f2d04325463c 100644 --- a/tezt/tests/expected/sc_rollup.ml/Alpha- ensure boot sector is used.out +++ b/tezt/tests/expected/sc_rollup.ml/Alpha- ensure boot sector is used.out @@ -72,7 +72,7 @@ This sequence of operations was run: ./tezos-sc-rollup-client-alpha rpc get /state_hash -"scs12WfbwHy5EsA4KEwvcQuWdwZdCMAkWM51kDGRPnyTSGmWmnrgBN" +"scs11s5nfonT2qW9aBhmo3pv3oUiG9X35qDNkSUxQNFANSZUrrAvX8" ./tezos-client --wait none originate sc rollup from '[PUBLIC_KEY_HASH]' of kind arith of type unit booting with 31 --burn-cap 9999999 Node is bootstrapped. @@ -147,4 +147,4 @@ This sequence of operations was run: ./tezos-sc-rollup-client-alpha rpc get /state_hash -"scs138kLbfRQFHHsUfyeWrCEgtMRfojXTjNReKda8SWJrW4J7kQehp" +"scs12mzqZwgkUZNNSQZk6HQ1sN8VubcgPHMHNj1ARrpYnc2oLpo5SC" diff --git a/tezt/tests/expected/sc_rollup.ml/Alpha- node advances PVM state with messages.out b/tezt/tests/expected/sc_rollup.ml/Alpha- node advances PVM state with messages.out index edf7ef90b017..072c74bd63d1 100644 --- a/tezt/tests/expected/sc_rollup.ml/Alpha- node advances PVM state with messages.out +++ b/tezt/tests/expected/sc_rollup.ml/Alpha- node advances PVM state with messages.out @@ -78,13 +78,13 @@ This sequence of operations was run: ./tezos-sc-rollup-client-alpha rpc get /state_hash -"scs12kA9v1ncsWtYYzo8GTJ3b7DXwjGSAK62ba8eZQk89agNBCRcjE" +"scs11dQjwnCyKGUtYfzXtjU8qH3igQHAsk71CJbYSc3e8Kyfraqmko" ./tezos-sc-rollup-client-alpha rpc get /total_ticks "17" ./tezos-sc-rollup-client-alpha rpc get /state_hash -"scs12kA9v1ncsWtYYzo8GTJ3b7DXwjGSAK62ba8eZQk89agNBCRcjE" +"scs11dQjwnCyKGUtYfzXtjU8qH3igQHAsk71CJbYSc3e8Kyfraqmko" ./tezos-sc-rollup-client-alpha rpc get /total_ticks "17" @@ -130,13 +130,13 @@ This sequence of operations was run: ./tezos-sc-rollup-client-alpha rpc get /state_hash -"scs123Yek1r2tSNcSKyFKrAZNVuU5pMyhpJFiKEWHW63FqKdvqAL4G" +"scs129tezMTWFNQM3iKNAWATZGtigW1bxgD92BAibihfpSm4fRtY7J" ./tezos-sc-rollup-client-alpha rpc get /total_ticks "33" ./tezos-sc-rollup-client-alpha rpc get /state_hash -"scs123Yek1r2tSNcSKyFKrAZNVuU5pMyhpJFiKEWHW63FqKdvqAL4G" +"scs129tezMTWFNQM3iKNAWATZGtigW1bxgD92BAibihfpSm4fRtY7J" ./tezos-sc-rollup-client-alpha rpc get /total_ticks "33" @@ -182,13 +182,13 @@ This sequence of operations was run: ./tezos-sc-rollup-client-alpha rpc get /state_hash -"scs13Hh5xNAC57U57nQzf3ABFWBboGXQ154bM1LMoYqG9rF6kqzCMw" +"scs12B99KFjHPESBDrBX3vhATbuMi4fYRW2tgGzKH4PqCn49g2bQq7" ./tezos-sc-rollup-client-alpha rpc get /total_ticks "51" ./tezos-sc-rollup-client-alpha rpc get /state_hash -"scs13Hh5xNAC57U57nQzf3ABFWBboGXQ154bM1LMoYqG9rF6kqzCMw" +"scs12B99KFjHPESBDrBX3vhATbuMi4fYRW2tgGzKH4PqCn49g2bQq7" ./tezos-sc-rollup-client-alpha rpc get /total_ticks "51" @@ -235,13 +235,13 @@ This sequence of operations was run: ./tezos-sc-rollup-client-alpha rpc get /state_hash -"scs11iuahtSBfSB57zi4Zv3y41duQj2HHESgHmfmyhsg4GJ2nrHexU" +"scs12Rngw9ErX9yzqhhdHMW1Vef7f9znHSzitW6M8FHmoVzVwRuHq3" ./tezos-sc-rollup-client-alpha rpc get /total_ticks "69" ./tezos-sc-rollup-client-alpha rpc get /state_hash -"scs11iuahtSBfSB57zi4Zv3y41duQj2HHESgHmfmyhsg4GJ2nrHexU" +"scs12Rngw9ErX9yzqhhdHMW1Vef7f9znHSzitW6M8FHmoVzVwRuHq3" ./tezos-sc-rollup-client-alpha rpc get /total_ticks "69" @@ -288,13 +288,13 @@ This sequence of operations was run: ./tezos-sc-rollup-client-alpha rpc get /state_hash -"scs132AfsAhZ5fi926YdnN9BjTQv5pZqonMB1bD3zXdVwhvvtZTd1B" +"scs11qa3neDD1rL6k2vhQKLxAtE25LY2ao8GhHQWKNR5nKj4nUJtEt" ./tezos-sc-rollup-client-alpha rpc get /total_ticks "87" ./tezos-sc-rollup-client-alpha rpc get /state_hash -"scs132AfsAhZ5fi926YdnN9BjTQv5pZqonMB1bD3zXdVwhvvtZTd1B" +"scs11qa3neDD1rL6k2vhQKLxAtE25LY2ao8GhHQWKNR5nKj4nUJtEt" ./tezos-sc-rollup-client-alpha rpc get /total_ticks "87" @@ -341,13 +341,13 @@ This sequence of operations was run: ./tezos-sc-rollup-client-alpha rpc get /state_hash -"scs127Kn6knS2sujVUCtHK4kCUBGDGNwf9BiPLYvD9A2Jn4KPzyo9P" +"scs12gfcf4KJQzmmhpEzA1eYqkZdpfLoocwYs4VF64gWzG266ZhdLQ" ./tezos-sc-rollup-client-alpha rpc get /total_ticks "105" ./tezos-sc-rollup-client-alpha rpc get /state_hash -"scs127Kn6knS2sujVUCtHK4kCUBGDGNwf9BiPLYvD9A2Jn4KPzyo9P" +"scs12gfcf4KJQzmmhpEzA1eYqkZdpfLoocwYs4VF64gWzG266ZhdLQ" ./tezos-sc-rollup-client-alpha rpc get /total_ticks "105" @@ -394,13 +394,13 @@ This sequence of operations was run: ./tezos-sc-rollup-client-alpha rpc get /state_hash -"scs12W31ZXYSEgoBmkxNWhariLjSMGHJzYpwDCiGr5GGBby4YLDy8G" +"scs11WEUB14isXfXs9KbjbTBHBpk8JHQijGRRE5W6A69uDSeEnEEZb" ./tezos-sc-rollup-client-alpha rpc get /total_ticks "123" ./tezos-sc-rollup-client-alpha rpc get /state_hash -"scs12W31ZXYSEgoBmkxNWhariLjSMGHJzYpwDCiGr5GGBby4YLDy8G" +"scs11WEUB14isXfXs9KbjbTBHBpk8JHQijGRRE5W6A69uDSeEnEEZb" ./tezos-sc-rollup-client-alpha rpc get /total_ticks "123" @@ -448,13 +448,13 @@ This sequence of operations was run: ./tezos-sc-rollup-client-alpha rpc get /state_hash -"scs11m5irAUgDRkKCWYrqD1skWn8dwvRQeAPZPk5L2sj3KYato7ERL" +"scs12g76pxeaFsbaZ3wo7iETcfBmEqYsW5WjQzmB15TUFLLwzvt6GQ" ./tezos-sc-rollup-client-alpha rpc get /total_ticks "141" ./tezos-sc-rollup-client-alpha rpc get /state_hash -"scs11m5irAUgDRkKCWYrqD1skWn8dwvRQeAPZPk5L2sj3KYato7ERL" +"scs12g76pxeaFsbaZ3wo7iETcfBmEqYsW5WjQzmB15TUFLLwzvt6GQ" ./tezos-sc-rollup-client-alpha rpc get /total_ticks "141" @@ -502,13 +502,13 @@ This sequence of operations was run: ./tezos-sc-rollup-client-alpha rpc get /state_hash -"scs129VDN6Hg4kdnUurafpvFGZcXYiCfMccMkQkbBufmGMoLCnvc7R" +"scs12xYEBWRb7cg8JMvAgtChTncVYvUPXkcFNpgvW6QpC5tfbLGDCV" ./tezos-sc-rollup-client-alpha rpc get /total_ticks "159" ./tezos-sc-rollup-client-alpha rpc get /state_hash -"scs129VDN6Hg4kdnUurafpvFGZcXYiCfMccMkQkbBufmGMoLCnvc7R" +"scs12xYEBWRb7cg8JMvAgtChTncVYvUPXkcFNpgvW6QpC5tfbLGDCV" ./tezos-sc-rollup-client-alpha rpc get /total_ticks "159" @@ -556,7 +556,7 @@ This sequence of operations was run: ./tezos-sc-rollup-client-alpha rpc get /state_hash -"scs12fEpU6CYzLEnBXS6KavGfvsRg6YUpdUBxstdXxDAAePLpBtDkX" +"scs138Hj6BokWB54prj8aVatMThqTtCCgMqZxfvpckbqnfD6TyeknR" ./tezos-sc-rollup-client-alpha rpc get /total_ticks "179" diff --git a/tezt/tests/expected/sc_rollup.ml/Alpha- observing the correct handling of commitments in the rollup node (commitm.out b/tezt/tests/expected/sc_rollup.ml/Alpha- observing the correct handling of commitments in the rollup node (commitm.out index 9f6dee7f3b17..406d2e160820 100644 --- a/tezt/tests/expected/sc_rollup.ml/Alpha- observing the correct handling of commitments in the rollup node (commitm.out +++ b/tezt/tests/expected/sc_rollup.ml/Alpha- observing the correct handling of commitments in the rollup node (commitm.out @@ -1354,7 +1354,7 @@ This sequence of operations was run: ./tezos-sc-rollup-client-alpha rpc get /last_stored_commitment { "commitment": { "compressed_state": - "scs11tZcCyKK6iycobH1S1XyjFBpLbbWeR6CjzHfWQvx4oA85JBz9W", + "scs12x8QREtVeFDNLugdWQ8ChxZfQye7upbuTwsZYp65QEUN1UX6Cw", "inbox_level": 32, "predecessor": "[SC_ROLLUP_COMMITMENT_HASH]", "number_of_messages": 465, "number_of_ticks": 1396 }, @@ -1363,7 +1363,7 @@ This sequence of operations was run: ./tezos-sc-rollup-client-alpha rpc get /last_published_commitment { "commitment": { "compressed_state": - "scs11tZcCyKK6iycobH1S1XyjFBpLbbWeR6CjzHfWQvx4oA85JBz9W", + "scs12x8QREtVeFDNLugdWQ8ChxZfQye7upbuTwsZYp65QEUN1UX6Cw", "inbox_level": 32, "predecessor": "[SC_ROLLUP_COMMITMENT_HASH]", "number_of_messages": 465, "number_of_ticks": 1396 }, diff --git a/tezt/tests/expected/sc_rollup.ml/Alpha- observing the correct handling of commitments in the rollup node (message.out b/tezt/tests/expected/sc_rollup.ml/Alpha- observing the correct handling of commitments in the rollup node (message.out index 36b6f9d5f930..67b91af789d3 100644 --- a/tezt/tests/expected/sc_rollup.ml/Alpha- observing the correct handling of commitments in the rollup node (message.out +++ b/tezt/tests/expected/sc_rollup.ml/Alpha- observing the correct handling of commitments in the rollup node (message.out @@ -1354,7 +1354,7 @@ This sequence of operations was run: ./tezos-sc-rollup-client-alpha rpc get /last_stored_commitment { "commitment": { "compressed_state": - "scs11tZcCyKK6iycobH1S1XyjFBpLbbWeR6CjzHfWQvx4oA85JBz9W", + "scs12x8QREtVeFDNLugdWQ8ChxZfQye7upbuTwsZYp65QEUN1UX6Cw", "inbox_level": 62, "predecessor": "[SC_ROLLUP_COMMITMENT_HASH]", "number_of_messages": 0, "number_of_ticks": 0 }, @@ -1363,7 +1363,7 @@ This sequence of operations was run: ./tezos-sc-rollup-client-alpha rpc get /last_published_commitment { "commitment": { "compressed_state": - "scs11tZcCyKK6iycobH1S1XyjFBpLbbWeR6CjzHfWQvx4oA85JBz9W", + "scs12x8QREtVeFDNLugdWQ8ChxZfQye7upbuTwsZYp65QEUN1UX6Cw", "inbox_level": 62, "predecessor": "[SC_ROLLUP_COMMITMENT_HASH]", "number_of_messages": 0, "number_of_ticks": 0 }, -- GitLab From b210680bf2e562bbc6b2765cd1c319f738596952 Mon Sep 17 00:00:00 2001 From: Yann Regis-Gianas Date: Fri, 3 Jun 2022 09:15:47 +0200 Subject: [PATCH 09/11] Tests: Deactivate OpenAPI validation because of a bug A follow-up issue https://gitlab.com/tezos/tezos/-/issues/3148 has been created to tackle the problem. Signed-off-by: Yann Regis-Gianas --- tests_python/tests_alpha/test_openapi.py | 105 ++++++++++++----------- 1 file changed, 56 insertions(+), 49 deletions(-) diff --git a/tests_python/tests_alpha/test_openapi.py b/tests_python/tests_alpha/test_openapi.py index f35db297515b..3e3425792dc4 100644 --- a/tests_python/tests_alpha/test_openapi.py +++ b/tests_python/tests_alpha/test_openapi.py @@ -8,57 +8,64 @@ This test mimicks src/openapi/generate.sh. """ -import json -import subprocess -from pathlib import Path -import requests -import openapi_spec_validator -import pytest +# import json +# import subprocess +# from pathlib import Path +# import requests +# import openapi_spec_validator +# import pytest -from launchers.sandbox import Sandbox -from tools.constants import NODE_PARAMS -from tools.utils import get_tezos_node_version -from . import protocol +# from launchers.sandbox import Sandbox +# from tools.constants import NODE_PARAMS +# from tools.utils import get_tezos_node_version +# from . import protocol -class TestOpenAPI: - @pytest.fixture(scope="class") - def sandbox(self, sandbox: Sandbox): - sandbox.add_node(0, params=NODE_PARAMS) - client = sandbox.client(0) - protocol.activate(client) - return sandbox +# class TestOpenAPI: +# @pytest.fixture(scope="class") +# def sandbox(self, sandbox: Sandbox): +# sandbox.add_node(0, params=NODE_PARAMS) +# client = sandbox.client(0) +# protocol.activate(client) +# return sandbox - @pytest.mark.parametrize( - "rpc_path", ["describe", "describe/chains/main/blocks/head/"] - ) - def test_validity(self, sandbox: Sandbox, rpc_path: str, tmp_path: Path): - """ - Mimicks the script src/openapi/generate.sh. Generates the API - and check it generates a valid OpenAPI specification. - """ - node = sandbox.node(0) - addr = f"http://localhost:{node.rpc_port}/{rpc_path}?recurse=yes" - json_path = tmp_path / "result.json" - with open(json_path, "w") as o_file: - json_res = requests.get(addr).json() - json.dump(json_res, o_file) +# @pytest.mark.parametrize( +# "rpc_path", ["describe", "describe/chains/main/blocks/head/"] +# ) +# def test_validity(self, sandbox: Sandbox, rpc_path: str, tmp_path: Path): +# """ +# Mimicks the script src/openapi/generate.sh. Generates the API +# and check it generates a valid OpenAPI specification. +# """ +# FIXME: https://gitlab.com/tezos/tezos/-/issues/3148 +# We deactivate this test temporarily. The encodings of +# Irmin proofs generate either an assert false in +# src/lib_openapi/convert.ml:188 or an infinite loop (!?) in +# the conversion from Json Schema to OpenAPI (depending on the +# version of the proof trees used). - # If you need to debug, insert time.sleep(15) in there, - # to give you time to inspect generated files before the - # enclosing 'with' block finishes or to execute the dune - # command manually while the temporary files are still there. - version = get_tezos_node_version() - cmd = [ - "dune", - "exec", - "../src/bin_openapi/rpc_openapi.exe", - "--", - version, - str(json_path.absolute()), - ] - process_ret = subprocess.run( - cmd, check=True, capture_output=True, text=True - ) - res = json.loads(process_ret.stdout) - openapi_spec_validator.validate_spec(res) +# node = sandbox.node(0) +# addr = f"http://localhost:{node.rpc_port}/{rpc_path}?recurse=yes" +# json_path = tmp_path / "result.json" +# with open(json_path, "w") as o_file: +# json_res = requests.get(addr).json() +# json.dump(json_res, o_file) + +# # If you need to debug, insert time.sleep(15) in there, +# # to give you time to inspect generated files before the +# # enclosing 'with' block finishes or to execute the dune +# # command manually while the temporary files are still there. +# version = get_tezos_node_version() +# cmd = [ +# "dune", +# "exec", +# "../src/bin_openapi/rpc_openapi.exe", +# "--", +# version, +# str(json_path.absolute()), +# ] +# process_ret = subprocess.run( +# cmd, check=True, capture_output=True, text=True +# ) +# res = json.loads(process_ret.stdout) +# openapi_spec_validator.validate_spec(res) -- GitLab From 02404145b5e6c2e343b8e2d2bf8c3884aa099924 Mon Sep 17 00:00:00 2001 From: Yann Regis-Gianas Date: Fri, 3 Jun 2022 11:50:31 +0200 Subject: [PATCH 10/11] Proto,SCORU: Use inbox hashes instead of context hashes in proofs Signed-off-by: Yann Regis-Gianas --- src/proto_alpha/lib_protocol/sc_rollup_inbox_repr.ml | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/src/proto_alpha/lib_protocol/sc_rollup_inbox_repr.ml b/src/proto_alpha/lib_protocol/sc_rollup_inbox_repr.ml index a917d2a689db..a45fa3559e43 100644 --- a/src/proto_alpha/lib_protocol/sc_rollup_inbox_repr.ml +++ b/src/proto_alpha/lib_protocol/sc_rollup_inbox_repr.ml @@ -113,6 +113,9 @@ module Hash = struct let () = Base58.check_encoded_prefix b58check_encoding prefix encoded_size + let of_context_hash context_hash = + hash_bytes [Context_hash.to_bytes context_hash] + include Path_encoding.Make_hex (H) end @@ -606,9 +609,7 @@ module MakeHashingScheme (Tree : TREE) : let hash_messages messages = if Tree.is_empty messages then no_messages_hash - else - let context_hash = Tree.hash messages in - Hash.hash_bytes [Context_hash.to_bytes context_hash] + else Hash.of_context_hash @@ Tree.hash messages let add_messages_aux history inbox level payloads messages = let open Lwt_tzresult_syntax in @@ -787,8 +788,8 @@ module Proof = struct let check_hash hash kinded_hash = match kinded_hash with - | `Node h -> Context_hash.equal h hash - | `Value h -> Context_hash.equal h hash + | `Node h -> Hash.(equal (of_context_hash h) hash) + | `Value h -> Hash.(equal (of_context_hash h) hash) let drop_error result reason = Lwt.map (Result.map_error (fun _ -> reason)) result -- GitLab From 851005fbce34059052b6444bad238056ca15740d Mon Sep 17 00:00:00 2001 From: Yann Regis-Gianas Date: Fri, 3 Jun 2022 12:03:17 +0200 Subject: [PATCH 11/11] Proto,SCORU: Fix invalid dune Signed-off-by: Yann Regis-Gianas --- src/proto_alpha/lib_protocol/dune | 15 --------------- 1 file changed, 15 deletions(-) diff --git a/src/proto_alpha/lib_protocol/dune b/src/proto_alpha/lib_protocol/dune index fd7fd37f8e29..d53656c4f247 100644 --- a/src/proto_alpha/lib_protocol/dune +++ b/src/proto_alpha/lib_protocol/dune @@ -215,9 +215,6 @@ Script_interpreter Sc_rollup_management_protocol Sc_rollup_operations - Sc_rollup_PVM_sem - Sc_rollup_arith - Sc_rollups Dal_apply Baking Amendment @@ -436,9 +433,6 @@ script_interpreter.ml script_interpreter.mli sc_rollup_management_protocol.ml sc_rollup_management_protocol.mli sc_rollup_operations.ml sc_rollup_operations.mli - sc_rollup_PVM_sem.ml - sc_rollup_arith.ml sc_rollup_arith.mli - sc_rollups.ml sc_rollups.mli dal_apply.ml dal_apply.mli baking.ml baking.mli amendment.ml amendment.mli @@ -643,9 +637,6 @@ script_interpreter.ml script_interpreter.mli sc_rollup_management_protocol.ml sc_rollup_management_protocol.mli sc_rollup_operations.ml sc_rollup_operations.mli - sc_rollup_PVM_sem.ml - sc_rollup_arith.ml sc_rollup_arith.mli - sc_rollups.ml sc_rollups.mli dal_apply.ml dal_apply.mli baking.ml baking.mli amendment.ml amendment.mli @@ -870,9 +861,6 @@ script_interpreter.ml script_interpreter.mli sc_rollup_management_protocol.ml sc_rollup_management_protocol.mli sc_rollup_operations.ml sc_rollup_operations.mli - sc_rollup_PVM_sem.ml - sc_rollup_arith.ml sc_rollup_arith.mli - sc_rollups.ml sc_rollups.mli dal_apply.ml dal_apply.mli baking.ml baking.mli amendment.ml amendment.mli @@ -1093,9 +1081,6 @@ script_interpreter.ml script_interpreter.mli sc_rollup_management_protocol.ml sc_rollup_management_protocol.mli sc_rollup_operations.ml sc_rollup_operations.mli - sc_rollup_PVM_sem.ml - sc_rollup_arith.ml sc_rollup_arith.mli - sc_rollups.ml sc_rollups.mli dal_apply.ml dal_apply.mli baking.ml baking.mli amendment.ml amendment.mli -- GitLab