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 154567fce399fbe238af6df21e9ac1b1d5f791a8..8b527f9389a815f6b412055a081fa6d7b5f0c7d3 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 83bc8e55805412bd75c4a7d7ea5f6d2a02cb8a46..53588fecec3e7508d3dd921345af0d729d650a72 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.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 ba769393f1af90ec3d5ecc4f1e54b7249581ead9..a1a9cb4a25c57759e391dec6b72d350f4dc439df 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 6a7360c020d601f31591f711428a4c15caa00ac1..0c44a30b61a9ec85315402d7d166f3f09b4f0b49 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_client/operation_result.ml b/src/proto_alpha/lib_client/operation_result.ml index 7f980b5edc515d114fa3e52be254db83a68ee3fe..cb3f1d2682de16bad735b166e8bf7e29d5e28837 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 7ace7e77ed5cb60e64dfa926f000450333063fe8..cf9ac2638b16ffabf735bd6484f5b15943cf2e67 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 98f876a532260a37950d0b271f664f8196ecac29..dc7ae1075e91f5508fa031149fd555309cacd6d5 100644 --- a/src/proto_alpha/lib_protocol/TEZOS_PROTOCOL +++ b/src/proto_alpha/lib_protocol/TEZOS_PROTOCOL @@ -38,10 +38,14 @@ "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_proof_repr", "Sc_rollup_game_repr", "Seed_repr", "Sampler", @@ -196,9 +200,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 aa624eef44a835d1669005610bf4257a4b06482e..8c4eba3f826810342ff1997781cd74f13dda906a 100644 --- a/src/proto_alpha/lib_protocol/alpha_context.ml +++ b/src/proto_alpha/lib_protocol/alpha_context.ml @@ -56,12 +56,15 @@ 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 include Sc_rollup_inbox_storage end + module Proof = Sc_rollup_proof_repr module Game = Sc_rollup_game_repr module Commitment = struct @@ -72,6 +75,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 9d3a52dc0a0f16fc5f012d9b188989ab4a587fbb..cf1bdb92daccf0b5640269b1c7ebad2f142f2c58 100644 --- a/src/proto_alpha/lib_protocol/alpha_context.mli +++ b/src/proto_alpha/lib_protocol/alpha_context.mli @@ -2494,16 +2494,132 @@ 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 + + module type S = sig + val name : string + + val parse_boot_sector : string -> boot_sector option + + val pp_boot_sector : Format.formatter -> boot_sector -> unit + + 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) + 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 name_of : t -> string + + val of_name : string -> t option + + val all : t list + + 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 + end + end module Number_of_messages : Bounded.Int32.S @@ -2587,7 +2703,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 @@ -2598,6 +2714,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 @@ -2636,30 +2754,50 @@ 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 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 = {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 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; } @@ -2673,7 +2811,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 @@ -2690,6 +2828,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/dune b/src/proto_alpha/lib_protocol/dune index 56e0f7e62a60d7958b7a8dbc0116f3742a4e6157..d53656c4f247d3ee74cb60cd36262714bcf67a10 100644 --- a/src/proto_alpha/lib_protocol/dune +++ b/src/proto_alpha/lib_protocol/dune @@ -69,10 +69,14 @@ 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_proof_repr Sc_rollup_game_repr Seed_repr Sampler @@ -211,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 @@ -285,10 +286,14 @@ 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_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 @@ -428,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 @@ -488,10 +490,14 @@ 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_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 @@ -631,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 @@ -711,10 +714,14 @@ 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_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 @@ -854,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 @@ -930,10 +934,14 @@ 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_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 @@ -1073,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 diff --git a/src/proto_alpha/lib_protocol/operation_repr.ml b/src/proto_alpha/lib_protocol/operation_repr.ml index 8ac1f74020bc5ca0945473e086069bdd7b2a53b9..616000da1368cca3aa11e93c327e4ab7973e832f 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 3fc89ce6e72280a5f1fedfb6612f30a5f76c9eea..7805ce8ec19d61ce60e9ef4e1fa12d0396068f1d 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 d817441cceae2b742b730b70492d9a250d263912..b81e924a08df3a97f7984252517bc6d425c4afe1 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,95 @@ 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 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 + | 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 +157,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 is valid. The PVM + implementation is responsible for ensuring that this proof type + has the correct semantics: - 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. + A proof [p] has four parameters: - 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. + [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 +211,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 +242,31 @@ 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 + + (** [produce_proof ctxt input_given state] should return a [proof] for + 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. *) + 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 b4e11e38e49e715529567a7100c885b2c40abe9b..b6ebcb4aa067f8638e874f73f1a569082cd46af4 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 @@ -35,23 +35,19 @@ 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, - [ `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 + + val produce_proof : + Tree.t -> tree -> (tree -> (tree * 'a) Lwt.t) -> (proof * 'a) option Lwt.t end module type S = sig - include Sc_rollup_PVM_sem.S + include PS.S val name : string @@ -61,7 +57,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 @@ -90,23 +86,40 @@ module type S = sig end module Make (Context : P) : - S - with type context = Context.Tree.t - and type state = Context.tree - and type proof = Context.proof = struct + S with type context = Context.Tree.t 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 = + 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 p = Context.proof_before p.tree_proof - let proof_encoding = Context.proof_encoding + let proof_stop_state p = + match (p.given, p.requested) with + | None, PS.No_input_required -> Some (Context.proof_after p.tree_proof) + | None, _ -> None + | _ -> Some (Context.proof_after p.tree_proof) - let proof_start_state = Context.proof_start_state + let proof_input_given p = p.given - let proof_stop_state = Context.proof_stop_state + let proof_input_requested p = p.requested let name = "arith" @@ -141,7 +154,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 +434,7 @@ module Make (Context : P) : end module CurrentTick = MakeVar (struct - include Tick + include Sc_rollup_tick_repr let name = "tick" end) @@ -512,27 +525,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 +720,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 +752,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 +953,43 @@ 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 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* state = - match input with - | None -> eval state - | Some input -> state_of (ticked (set_input_monadic input)) state - in - return (state, ()) + let* result = + Context.verify_proof proof.tree_proof (step_transition proof.given) in - let* x = Context.verify_proof proof transition in - match x with Ok _ -> return_true | Error _ -> return_false + 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 @@ -984,17 +1009,20 @@ 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 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 + let proof_encoding = Context.Proof_encoding.V1.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 b307989ad4d3dc260d687708dbe57e437b383406..93d9afcdee827c724a968ac5f3a127446a3b21ec 100644 --- a/src/proto_alpha/lib_protocol/sc_rollup_arith.mli +++ b/src/proto_alpha/lib_protocol/sc_rollup_arith.mli @@ -47,13 +47,12 @@ 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. *) -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,16 @@ module type P = sig val proof_encoding : proof Data_encoding.t - val proof_start_state : proof -> Sc_rollup.State_hash.t + val proof_before : proof -> Sc_rollup_repr.State_hash.t - val proof_stop_state : proof -> Sc_rollup.State_hash.t + val proof_after : proof -> Sc_rollup_repr.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 + + val produce_proof : + Tree.t -> tree -> (tree -> (tree * 'a) Lwt.t) -> (proof * '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 + 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 17070cd415fe814b2e0e0e6c51869a4b9d6a784c..4c27d8180e90d469f91d2fc9d0091aed5541dca8 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 @@ -294,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 @@ -302,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 = @@ -319,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) @@ -382,67 +318,131 @@ 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 "This choice was not proposed" in traverse game.dissection -let check pred = - let open Result_syntax in - if pred then return () else error () +let check pred reason = + let open Lwt_result_syntax in + if pred then return () else fail reason 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 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 error () + 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)) - | _ -> error () + 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 error () - | (None, _) :: _ :: _ -> error () + 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. - - 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) "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 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 - (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 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 = - 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 +455,27 @@ 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 - return - (Either.Left {loser = opponent game.turn; reason = Conflict_resolved}) + | 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 = + Sc_rollup_proof_repr.valid inbox_snapshot level ~pvm_name proof + in + 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 - match Option.of_result result with - | Some x -> x - | None -> Either.Left {loser = game.turn; reason = Invalid_move} + Lwt.map + (fun r -> + 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 1addd9bc529ec841f724257d2b2c66e6d3ea56b8..2c33f0fe46cb49ef64efa1bdad9a7fe7e132fd87 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. *) @@ -289,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 @@ -331,23 +295,16 @@ val find_choice : * Sc_rollup_tick_repr.t * Sc_rollup_repr.State_hash.t option * Sc_rollup_tick_repr.t, - unit trace ) + string ) 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 [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. @@ -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, string) 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 0e9ffa263a18abe5fc2759e15af6322f2a91c631..a45fa3559e432c8c78ede79ebc5580993b092f6b 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 @@ -395,6 +398,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 @@ -604,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 @@ -648,6 +651,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 +709,129 @@ 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 pp fmt proof = + Format.fprintf fmt "Inbox proof with %d skips" (List.length proof.skips) + + 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.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 + 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 -> 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 + + 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)) + "message_proof invalid" + in + match payload with + | 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 "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 "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 16c0e1eb350a0241a0bb1e2ba5e413ecb0a4bace..0d2ca882cb2d0b943ef3d8d3d003f066995d8453 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,66 @@ 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 pp : Format.formatter -> t -> unit + + 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, 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 new file mode 100644 index 0000000000000000000000000000000000000000..1af051287343b078737f511340a06940c3bfa866 --- /dev/null +++ b/src/proto_alpha/lib_protocol/sc_rollup_proof_repr.ml @@ -0,0 +1,139 @@ +(*****************************************************************************) +(* *) +(* 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 reason = + let open Lwt_result_syntax in + 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) "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 = + 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 + (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 + (Option.equal + 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 new file mode 100644 index 0000000000000000000000000000000000000000..4cf611d4ec0e1e7c00d1b9ea7d2f260bd8433b9a --- /dev/null +++ b/src/proto_alpha/lib_protocol/sc_rollup_proof_repr.mli @@ -0,0 +1,125 @@ +(*****************************************************************************) +(* *) +(* 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, 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 d99a038a5c402760aa97909cc0475f45180d3a11..18a002c842fbf4f13b930975fe7f7a8f2042e5bb 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.name_of 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/sc_rollup_repr.ml b/src/proto_alpha/lib_protocol/sc_rollup_repr.ml index 63c2886a1a443536256446a0b5a9d9ede052aac7..db14462b787e1d22ea374a4aec61fe053798508f 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 a73288a4df73e89f261f07606a2340ccbdad3bab..e24094de265155f1f20a2d90df1198e0d0c4d2a1 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 1d31c45c37b56573e6db3eacad5a2b17c41766cd..b4bd156ee3d6e16950c8cd953ee875d14e1e9f43 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 6383f16562ff895d8da4f1b288f0465c9c94c97b..124ce772d627ed061df1a4546f20b290c20d68fa 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,128 @@ 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.wrapped_proof] and [wrapped_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 encoding = Data_encoding.union ~tag_size:`Uint16 [example_arith_case] + + let equal x y = match (x, y) with Example_arith, Example_arith -> true -let kind_of_string = function "arith" -> Some Kind.Example_arith | _ -> None + let all = [Example_arith] -let example_arith_pvm = (module Sc_rollup_arith.ProtocolImplementation : PVM.S) + let of_name = function "arith" -> Some Example_arith | _ -> None -let of_kind = function Kind.Example_arith -> example_arith_pvm + let example_arith_pvm = + (module Sc_rollup_arith.ProtocolImplementation : PVM.S) -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 pvm_of = function Example_arith -> example_arith_pvm -let from ~name = Option.map of_kind (kind_of_string 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 all_names = - List.map - (fun k -> - let (module M : PVM.S) = of_kind k in - M.name) - all + let pvm_of_name ~name = Option.map pvm_of (of_name name) -let string_of_kind k = - let (module M) = of_kind k in - M.name + let all_names = + List.map + (fun k -> + let (module M : PVM.S) = pvm_of k in + M.name) + all + + let name_of k = + let (module M) = pvm_of k in + M.name + + let pp fmt k = Format.fprintf fmt "%s" (name_of k) +end + +module type PVM_with_proof = sig + include PVM.S + + val proof : proof +end -let pp fmt k = Format.fprintf fmt "%s" (string_of_kind k) +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)); + ] + +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 dc74b289ea0183ef6c337bdf778db4c1ac6d0d34..b8221904b0810405d296144cc2e24f175ca14e19 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,74 @@ 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 + + (** [of_name name] returns the kind of the PVM of the specified [name]. *) + val of_name : string -> t option + + (** [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 + 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 + +(** 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/storage.ml b/src/proto_alpha/lib_protocol/storage.ml index 1995ec76a46d191a77326794b74fce438f8bc530..629d2cc0646ced15734ed5e51ed37db7cc60ba53 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 6e834d08137a24cd91f3ee4937a0ae4a18df1636..e6aa79faa30a4e6cd6930a5147047c545cf5c9f9 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 5cdfc49bccdc1845d42bbea64684d96e18f0e8f2..d42e3c1e2d5688663f3c0c03e6f732b64c23131c 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,10 +99,10 @@ 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] - 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. *) +(** [test_sc_rollups_all_well_defined] checks that [Sc_rollup.Kind.all] + 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 @@ -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/pbt/test_refutation_game.ml b/src/proto_alpha/lib_protocol/test/pbt/test_refutation_game.ml index 622c6715b6effe8a88c40c379759be6ec105e849..0fa7a2e970c6515f33eb626ebc712ee319c59225 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 @@ -37,7 +37,7 @@ open Alpha_context open Sc_rollup open Lwt_syntax -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 @@ -47,115 +47,112 @@ 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 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 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 -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 : State_hash.t; + stop : 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" State_hash.encoding) + (req "stop" (option State_hash.encoding)) + (req "valid" bool)) + +let proof_start_state proof = proof.start -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_stop_state proof = proof.stop let check pred = let open Result_syntax in 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 of_int_exc n = - match Sc_rollup_tick_repr.of_int n with None -> assert false | Some t -> t +let tick_of_int_exn n = + match Tick.of_int n with None -> assert false | Some t -> t -(** 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 tick_to_int_exn t = + match Tick.to_int t with None -> assert false | Some n -> n + +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.( @@ -182,33 +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 = State_hash.t - and type proof = Sc_rollup_game_repr.Proof.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 @@ -223,62 +220,56 @@ 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 = 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 state_hash (x : state) = - Lwt.return (State_hash.hash_string [Int.to_string x]) + let proof_input_given _ = None - let is_input_state _ = Lwt.return None + let proof_input_requested _ = No_input_required - let initial_state _ _ = Lwt.return P.target + let state_hash (x : state) = return (State_hash.hash_string [Int.to_string x]) - let set_input _ s = Lwt.return s + let is_input_state _ = return No_input_required + + let initial_state _ _ = return P.target + + 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 - @@ Sc_rollup_game_repr.Proof.( - Computation_step - { - start = of_PVM_state_hash start_hash; - stop = of_PVM_state_hash @@ 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}) + 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 = 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 eval state = if state >= P.target then return state else 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 = 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 @@ -287,11 +278,17 @@ 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 = Sc_rollup_game_repr.Proof.t + type proof = dummy_proof type hash = State_hash.t @@ -302,14 +299,17 @@ end) : TestPVM with type state = string * int list = struct let proof_stop_state = proof_stop_state - let state_hash (x : state) = - Lwt.return @@ State_hash.hash_string [to_string x] + let proof_input_given _ = None + + let proof_input_requested _ = No_input_required - let initial_state _ _ = Lwt.return ("hello", P.initial_prog) + let state_hash (x : state) = return @@ State_hash.hash_string [to_string x] - let is_input_state _ = Lwt.return None + let initial_state _ _ = return ("hello", P.initial_prog) - let set_input _ state = Lwt.return state + let is_input_state _ = return No_input_required + + let set_input _ state = return state module Utils = struct let default_state = ("hello", P.initial_prog) @@ -321,41 +321,29 @@ 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 - @@ Sc_rollup_game_repr.Proof.( - Computation_step - { - start = of_PVM_state_hash start_hash; - stop = of_PVM_state_hash @@ 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}) + 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 = 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 + | [] -> return (hash, continuation) + | h :: tl -> return (hash_state hash h, tl) + + let verify_proof proof = 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 Tezos_context_memory.Context.Tree @@ -368,29 +356,30 @@ module ContextPVM = Sc_rollup_arith.Make (struct type value = bytes end - type tree = Tezos_context_memory.Context.tree + type tree = Tree.tree - let empty_tree = Tree.empty Tezos_context_memory.Context.empty - - type proof = Sc_rollup_game_repr.Proof.t + type proof = Proof.tree 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 (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 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 -> + State_hash.hash_bytes [Context_hash.to_bytes hash] - let proof_start_state proof = - to_state_hash @@ Sc_rollup_game_repr.Proof.start proof + let proof_before proof = kinded_hash_to_state_hash proof.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 + let proof_after proof = kinded_hash_to_state_hash proof.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 @@ -407,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.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 @@ -423,100 +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.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 - @@ Sc_rollup_game_repr.Proof.( - Computation_step - { - start = of_PVM_state_hash start_hash; - stop = of_PVM_state_hash @@ 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}) + 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.State_hash.t - and type proof = Sc_rollup_game_repr.Proof.t) = -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 @@ -524,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 @@ -535,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 - (Option.map of_PVM_state_hash hash, tick)) + (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 @@ -562,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 @@ -574,74 +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 - (of_PVM_state_hash 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 - (of_PVM_state_hash 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 (Option.map of_PVM_state_hash 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 @@ -654,16 +603,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 @@ -671,35 +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 = to_PVM_state_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 (to_PVM_state_hash @@ 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 = @@ -709,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 @@ -733,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* proof = PVM.Utils.make_proof start_hash stop_hash true in - Lwt.return {choice = start_tick; step = Proof proof} + let wrapped = + let module P = struct + include PVM + + let proof = pvm_proof + end in + Unencodable (module P) + in + 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 @@ -826,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 @@ -843,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 @@ -865,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 @@ -884,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 @@ -915,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 @@ -936,16 +864,16 @@ 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 - Lwt.return - (Result.to_option - @@ Sc_rollup_game_repr.check_dissection - (Some (of_PVM_state_hash start)) - section_start_at - stop_hash - section_stop_at - dissection - = Some ()) + let stop_hash = Some (aux start) in + 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 @@ -986,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 @@ -1010,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); ] 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 4f72496c0346553c07120cd7fd299721c09dc9ad..55f10e356a9dff9dae4ad5f12893c910a6ac156c 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 91b5c4471a552b44674753eeb4a4e5693eb49a8e..026e4d96b9993e078f62bbb55f141ceafe07bd92 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 diff --git a/tests_python/tests_alpha/test_openapi.py b/tests_python/tests_alpha/test_openapi.py index f35db297515b8ae44897d79a475b3056da383b96..3e3425792dc47b2fe4d024d457d2408ffcfc3b3c 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) 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 c83e3a59b2fce320658ec408003b198cf445796f..8b6d3fb8929e555161ec7b0b8ab8e22bb28530fb 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 bde688be8883467e2cfd10dc0006c687fdae7eb6..fb565a721fbe05b3a9c754d7a824714eac494dc4 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 280158754bac83e99409db4a0b9491a0fc3d6c44..f2d04325463ca7bc2912f6ca4048beda96cfebd5 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 edf7ef90b01741745bb43f1a8e8dc2e3fbb40d9d..072c74bd63d1d07d9e97ed138e7c21a9c10c7f9c 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 9f6dee7f3b17217aa101fe773eee29e6483c5512..406d2e16082078bacb0a962ef6d476d30db9498d 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 36b6f9d5f93026e2e687eda8f3fd5586856383fe..67b91af789d35d7c22d211c58f68c389f57b168b 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 },