diff --git a/src/proto_alpha/bin_sc_rollup_node/RPC_server.ml b/src/proto_alpha/bin_sc_rollup_node/RPC_server.ml index 3b70e5f672eec441b8282f1faa4bc2c3fe0bd415..e34755c46787ae05ed505fd04c8959905e8b7539 100644 --- a/src/proto_alpha/bin_sc_rollup_node/RPC_server.ml +++ b/src/proto_alpha/bin_sc_rollup_node/RPC_server.ml @@ -91,7 +91,7 @@ module Common = struct (fun () () -> Layer1.current_head_hash store >>= function | Some head_hash -> - let*! inbox = Inbox.inbox_of_hash node_ctxt store head_hash in + let* inbox = Inbox.inbox_of_hash node_ctxt store head_hash in return_some inbox | None -> return None) 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 a9a22768175ca994f17b25de5e7dccc06ee5d458..1f594cf28986a2ff5227701cb0f13c7eadb6019f 100644 --- a/src/proto_alpha/bin_sc_rollup_node/arith_pvm.ml +++ b/src/proto_alpha/bin_sc_rollup_node/arith_pvm.ml @@ -57,7 +57,7 @@ module Arith_proof_format = struct let produce_proof context tree step = let open Lwt_syntax in - let* res = IStore.set_tree ~info:commit_info context [] tree in + let* res = IStore.set_tree ~info:commit_info context ["pvm_state"] tree in match res with | Error _ -> return None | Ok () -> ( diff --git a/src/proto_alpha/bin_sc_rollup_node/commitment.ml b/src/proto_alpha/bin_sc_rollup_node/commitment.ml index bcdb68176cbc51984595ffde3b58a8c9900ca5ba..f792d70547d8c5612f1a32355e340d4056d051bc 100644 --- a/src/proto_alpha/bin_sc_rollup_node/commitment.ml +++ b/src/proto_alpha/bin_sc_rollup_node/commitment.ml @@ -362,8 +362,18 @@ module Make (PVM : Pvm.S) : Commitment_sig.S with module PVM = PVM = struct (Raw_level.to_int32 published_at_level) (sc_rollup_challenge_window node_ctxt) - let can_be_cemented earliest_cementing_level head_level = - earliest_cementing_level <= head_level + let can_be_cemented node_ctxt earliest_cementing_level head_level + commitment_hash = + let {Node_context.cctxt; rollup_address; _} = node_ctxt in + let open Lwt_result_syntax in + if earliest_cementing_level <= head_level then + Plugin.RPC.Sc_rollup.can_be_cemented + cctxt + (cctxt#chain, cctxt#block) + rollup_address + commitment_hash + () + else return_false let cement_commitment ({Node_context.cctxt; rollup_address; _} as node_ctxt) ({Sc_rollup.Commitment.inbox_level; _} as commitment) commitment_hash @@ -431,7 +441,14 @@ module Make (PVM : Pvm.S) : Commitment_sig.S with module PVM = PVM = struct has previously published `commitment`, which means that the rollup is indirectly staked on it. *) | Some earliest_cementing_level -> - if can_be_cemented earliest_cementing_level head_level then + let* green_flag = + can_be_cemented + node_ctxt + earliest_cementing_level + head_level + commitment_hash + in + if green_flag then cement_commitment node_ctxt commitment commitment_hash store else return () | None -> return ()) diff --git a/src/proto_alpha/bin_sc_rollup_node/components.ml b/src/proto_alpha/bin_sc_rollup_node/components.ml index fd412ff4aef56357b420d327fa59d5b6997e68d2..79c4e5ea5f76126bb39724ca369f20e317f20f57 100644 --- a/src/proto_alpha/bin_sc_rollup_node/components.ml +++ b/src/proto_alpha/bin_sc_rollup_node/components.ml @@ -32,6 +32,8 @@ module type S = sig module Commitment : Commitment_sig.S with module PVM = PVM module RPC_server : RPC_server.S with module PVM = PVM + + module Refutation_game : Refutation_game.S with module PVM = PVM end module Make (PVM : Pvm.S) : S with module PVM = PVM = struct @@ -39,6 +41,7 @@ module Make (PVM : Pvm.S) : S with module PVM = PVM = struct module Interpreter = Interpreter.Make (PVM) module Commitment = Commitment.Make (PVM) module RPC_server = RPC_server.Make (PVM) + module Refutation_game = Refutation_game.Make (PVM) end let pvm_of_kind : Protocol.Alpha_context.Sc_rollup.Kind.t -> (module Pvm.S) = diff --git a/src/proto_alpha/bin_sc_rollup_node/configuration.ml b/src/proto_alpha/bin_sc_rollup_node/configuration.ml index 5dad522a9eb5cd4a11b10d0329b54385196547f6..77fe8aa4f20975a5ed92c9a6465ab89cb7407c7f 100644 --- a/src/proto_alpha/bin_sc_rollup_node/configuration.ml +++ b/src/proto_alpha/bin_sc_rollup_node/configuration.ml @@ -33,6 +33,7 @@ type t = { rpc_addr : string; rpc_port : int; fee_parameter : Injection.fee_parameter; + loser_mode : Loser_mode.t; } let default_data_dir = @@ -151,19 +152,22 @@ let encoding : t Data_encoding.t = rpc_addr; rpc_port; fee_parameter; + loser_mode; } -> ( data_dir, sc_rollup_address, sc_rollup_node_operator, rpc_addr, rpc_port, - fee_parameter )) + fee_parameter, + loser_mode )) (fun ( data_dir, sc_rollup_address, sc_rollup_node_operator, rpc_addr, rpc_port, - fee_parameter ) -> + fee_parameter, + loser_mode ) -> { data_dir; sc_rollup_address; @@ -171,8 +175,9 @@ let encoding : t Data_encoding.t = rpc_addr; rpc_port; fee_parameter; + loser_mode; }) - (obj6 + (obj7 (dft "data-dir" ~description:"Location of the data dir" @@ -193,9 +198,27 @@ let encoding : t Data_encoding.t = "fee-parameter" ~description:"The fee parameter used when injecting operations in L1" fee_parameter_encoding - default_fee_parameter)) + default_fee_parameter) + (dft + "loser-mode" + ~description: + "If enabled, the rollup node will issue wrong commitments (for \ + test only!)" + Loser_mode.encoding + Loser_mode.no_failures)) + +let loser_warning_message config = + if config.loser_mode <> Loser_mode.no_failures then + Format.printf + {| +************ WARNING ************* +This rollup node is in loser mode. +This should be used for test only! +************ WARNING ************* +|} let save config = + loser_warning_message config ; let open Lwt_syntax in let json = Data_encoding.Json.construct encoding config in let* () = Lwt_utils_unix.create_dir config.data_dir in @@ -204,4 +227,6 @@ let save config = let load ~data_dir = let open Lwt_result_syntax in let+ json = Lwt_utils_unix.Json.read_file (relative_filename data_dir) in - Data_encoding.Json.destruct encoding json + let config = Data_encoding.Json.destruct encoding json in + loser_warning_message config ; + config diff --git a/src/proto_alpha/bin_sc_rollup_node/configuration.mli b/src/proto_alpha/bin_sc_rollup_node/configuration.mli index 5c5c41e6b069c86b5aaa6c41c028806c885380ae..1a4844ac09d50a4f827422b777aa67898b7fad17 100644 --- a/src/proto_alpha/bin_sc_rollup_node/configuration.mli +++ b/src/proto_alpha/bin_sc_rollup_node/configuration.mli @@ -31,6 +31,7 @@ type t = { rpc_addr : string; rpc_port : int; fee_parameter : Injection.fee_parameter; + loser_mode : Loser_mode.t; } (** [default_data_dir] is the default value for [data_dir]. *) diff --git a/src/proto_alpha/bin_sc_rollup_node/daemon.ml b/src/proto_alpha/bin_sc_rollup_node/daemon.ml index 0f78d078e14e301fdb14f8cde0d2561abf9b5c0a..727c6697febbd9e0ba65b624457bb4374e4cfdcf 100644 --- a/src/proto_alpha/bin_sc_rollup_node/daemon.ml +++ b/src/proto_alpha/bin_sc_rollup_node/daemon.ml @@ -89,8 +89,8 @@ module Make (PVM : Pvm.S) = struct Dal_slots_tracker.process_head node_ctxt store head in let* () = - if finalized then Components.Commitment.process_head node_ctxt store head - else return_unit + when_ finalized @@ fun () -> + Components.Commitment.process_head node_ctxt store head in (* Publishing a commitment when one is available does not depend on the state of the current head, but we still need to ensure that the node only published @@ -99,6 +99,12 @@ module Make (PVM : Pvm.S) = struct let* () = Components.Commitment.cement_commitment_if_possible node_ctxt store head in + let* () = + (* At each block, there may be some refutation related actions to + be performed. *) + when_ finalized @@ fun () -> + Components.Refutation_game.process head node_ctxt store + in when_ finalized (fun () -> let*! () = Layer1.mark_processed_head store head in return ()) @@ -234,20 +240,18 @@ let run ~data_dir (cctxt : Protocol_client_context.full) = let*! () = Event.starting_node () in let* configuration = Configuration.load ~data_dir in let open Configuration in - let {sc_rollup_address; sc_rollup_node_operator; fee_parameter; _} = - configuration - in let*! store = Store.load configuration in let* l1_ctxt, genesis_info, kind = Layer1.start configuration cctxt store in let* node_ctxt = Node_context.init cctxt l1_ctxt - sc_rollup_address + configuration.sc_rollup_address genesis_info kind - sc_rollup_node_operator - fee_parameter + configuration.sc_rollup_node_operator + configuration.fee_parameter + ~loser_mode:configuration.loser_mode in let* _pkh, _pk, _skh = Node_context.get_operator_keys node_ctxt in (* Check that the public key hash is valid. *) diff --git a/src/proto_alpha/bin_sc_rollup_node/inbox.ml b/src/proto_alpha/bin_sc_rollup_node/inbox.ml index 9c99c15c109074ff6625fbfa221eb5c4dd0c54af..bd17c8ac8839c8b9aa8b690ed4a4d0f71c71c55a 100644 --- a/src/proto_alpha/bin_sc_rollup_node/inbox.ml +++ b/src/proto_alpha/bin_sc_rollup_node/inbox.ml @@ -45,31 +45,66 @@ module State = struct let add_history = Store.Histories.add + (** [inbox_of_hash node_ctxt store block_hash] returns the latest + inbox at the given [block_hash]. This function always returns + [Some inbox] for all levels after the rollup genesis even when + no messages has been issued at this specific [block_hash]. In + this case, the inbox is the same as the one found in the level + when the latest message has been inserted. *) let inbox_of_hash node_ctxt store block_hash = - let open Lwt_syntax in + let open Lwt_result_syntax in let open Node_context in - let* possible_inbox = Store.Inboxes.find store block_hash in + let*! possible_inbox = Store.Inboxes.find store block_hash in match possible_inbox with | None -> (* We won't find inboxes for blocks before the rollup origination level. Fortunately this case will only ever be called once when dealing with the rollup origination block. After that we would always find an inbox. *) - Store.Inbox.empty - store - node_ctxt.rollup_address - node_ctxt.genesis_info.level + let*! block_level = Layer1.level_of_hash store block_hash in + let block_level = Raw_level.of_int32_exn block_level in + if Raw_level.(block_level <= node_ctxt.genesis_info.level) then + let*! inbox = + Store.Inbox.empty store node_ctxt.rollup_address Raw_level.root + in + return inbox + else + failwith + "The inbox for block hash %a (level = %a) is missing." + Block_hash.pp + block_hash + Raw_level.pp + block_level | Some inbox -> return inbox - let history_of_hash store block_hash = - Store.Histories.find_with_default store block_hash ~on_default:(fun () -> - Store.Inbox.history_at_genesis ~bound:(Int64.of_int 60000)) + let history_of_hash node_ctxt store block_hash = + let open Lwt_result_syntax in + let open Node_context in + let*! res = Store.Histories.find store block_hash in + match res with + | Some history -> return history + | None -> + (* We won't find inboxes for blocks before the rollup origination level. + Fortunately this case will only ever be called once when dealing with + the rollup origination block. After that we would always find an + inbox. *) + let*! block_level = Layer1.level_of_hash store block_hash in + let block_level = Raw_level.of_int32_exn block_level in + if Raw_level.(block_level <= node_ctxt.genesis_info.level) then + return @@ Store.Inbox.history_at_genesis ~bound:(Int64.of_int 60000) + else + failwith + "The inbox history for hash %a is missing." + Block_hash.pp + block_hash let find_message_tree = Store.MessageTrees.find let set_message_tree = Store.MessageTrees.set end +let find_message_tree = State.find_message_tree + let get_messages Node_context.{l1_ctxt; rollup_address; _} head = let open Lwt_result_syntax in let* block = Layer1.fetch_tezos_block l1_ctxt head in @@ -124,7 +159,6 @@ let process_head node_ctxt store Layer1.(Head {level; hash = head_hash} as head) let*! res = get_messages node_ctxt head_hash in match res with | Error e -> head_processing_failure e - | Ok [] -> return_unit | Ok messages -> let*! () = Inbox_event.get_messages head_hash level (List.length messages) @@ -138,26 +172,33 @@ let process_head node_ctxt store Layer1.(Head {level; hash = head_hash} as head) *) let*! predecessor = Layer1.predecessor store head in - let*! inbox = State.inbox_of_hash node_ctxt store predecessor in + let* inbox = State.inbox_of_hash node_ctxt store predecessor in + let* history = State.history_of_hash node_ctxt store predecessor in lift - @@ let*! history = State.history_of_hash store predecessor in - let*! messages_tree = State.find_message_tree store predecessor in + @@ let*! messages_tree = State.find_message_tree store predecessor in let*? level = Raw_level.of_int32 level in let*? messages = List.map_e Store.Inbox.Message.serialize messages in - let* messages_tree, history, inbox = - Store.Inbox.add_messages - store - history - inbox - level - messages - messages_tree + let* history, inbox = + if messages = [] then return (history, inbox) + else + let* messages_tree, history, inbox = + Store.Inbox.add_messages + store + history + inbox + level + messages + messages_tree + in + let*! () = State.set_message_tree store head_hash messages_tree in + return (history, inbox) in - let*! () = State.set_message_tree store head_hash messages_tree in let*! () = State.add_inbox store head_hash inbox in let*! () = State.add_history store head_hash history in return_unit let inbox_of_hash = State.inbox_of_hash +let history_of_hash = State.history_of_hash + let start () = Inbox_event.starting () diff --git a/src/proto_alpha/bin_sc_rollup_node/inbox.mli b/src/proto_alpha/bin_sc_rollup_node/inbox.mli index 194adb4ac1f5307f598cd9158a09d6491bf80a4e..4c1a486269522357afa422149bfeadead1df4424 100644 --- a/src/proto_alpha/bin_sc_rollup_node/inbox.mli +++ b/src/proto_alpha/bin_sc_rollup_node/inbox.mli @@ -46,7 +46,17 @@ val inbox_of_hash : Node_context.t -> Store.t -> Block_hash.t -> - Alpha_context.Sc_rollup.Inbox.t Lwt.t + Alpha_context.Sc_rollup.Inbox.t tzresult Lwt.t + +(** [history_of_hash node_ctxt store block_hash] returns the rollup + inbox history at the end of the given validation of [block_hash]. *) +val history_of_hash : + Node_context.t -> + Store.t -> + Block_hash.t -> + Store.Inbox.history tzresult Lwt.t + +val find_message_tree : Store.t -> Block_hash.t -> Store.tree option Lwt.t (** [start ()] initializes the inbox to track the messages being published. *) val start : unit -> unit Lwt.t diff --git a/src/proto_alpha/bin_sc_rollup_node/interpreter.ml b/src/proto_alpha/bin_sc_rollup_node/interpreter.ml index 093a3c34b00ba4341615460b0c6eabdc1b84bad9..ae03e8950fe4b926a62b925c42fa1a023172e95d 100644 --- a/src/proto_alpha/bin_sc_rollup_node/interpreter.ml +++ b/src/proto_alpha/bin_sc_rollup_node/interpreter.ml @@ -28,96 +28,210 @@ open Alpha_context module Inbox = Store.Inbox module type S = sig + module PVM : Pvm.S + (** [process_head node_ctxt store head] interprets the messages associated with a [head] from a chain [event]. This requires the inbox to be updated beforehand. *) val process_head : Node_context.t -> Store.t -> Layer1.head -> unit tzresult Lwt.t + + (** [state_of_tick node_ctxt store tick level] returns [Some (state, hash)] + for a given [tick] if this [tick] happened before + [level]. Otherwise, returns [None].*) + val state_of_tick : + Node_context.t -> + Store.t -> + Sc_rollup.Tick.t -> + Raw_level.t -> + (PVM.state * PVM.hash) option tzresult Lwt.t end -module Make (PVM : Pvm.S) : S = struct - (** [eval_until_input state] advances a PVM [state] until it wants more inputs. *) - let eval_until_input state = +module Make (PVM : Pvm.S) : S with module PVM = PVM = struct + module PVM = PVM + + let consume_fuel = Option.map pred + + let continue_with_fuel fuel state f = + let open Lwt_syntax in + match fuel with + | Some 0 -> return (state, fuel) + | _ -> f (consume_fuel fuel) state + + (** [eval_until_input level message_index ~fuel start_tick + failing_ticks state] advances a PVM [state] until it wants more + inputs or there are no more [fuel] (if [Some fuel] is + specified). The evaluation is running under the processing of + some [message_index] at a given [level] and this is the + [start_tick] of this message processing. If some [failing_ticks] + are planned by the loser mode, they will be made. *) + let eval_until_input level message_index ~fuel start_tick failing_ticks state + = let open Lwt_syntax in - let rec go state = + let eval_tick tick failing_ticks state = + let normal_eval state = + let* state = PVM.eval state in + return (state, failing_ticks) + in + let failure_insertion_eval state failing_ticks' = + let* () = + Interpreter_event.intended_failure + ~level + ~message_index + ~message_tick:tick + ~internal:true + in + let* state = PVM.Internal_for_tests.insert_failure state in + return (state, failing_ticks') + in + match failing_ticks with + | xtick :: failing_ticks' when xtick = tick -> + failure_insertion_eval state failing_ticks' + | _ -> normal_eval state + in + let rec go fuel tick failing_ticks state = let* input_request = PVM.is_input_state state in - match input_request with - | No_input_required -> - let* next_state = PVM.eval state in - go next_state - | _ -> return state + match fuel with + | Some 0 -> return (state, fuel, tick, failing_ticks) + | None | Some _ -> ( + match input_request with + | No_input_required -> + let* next_state, failing_ticks = + eval_tick tick failing_ticks state + in + go (consume_fuel fuel) (tick + 1) failing_ticks next_state + | _ -> return (state, fuel, tick, failing_ticks)) in - go state + go fuel start_tick failing_ticks state + + (** [mutate input] corrupts the payload of [input] for testing purposes. *) + let mutate input = + let payload = Inbox.Message.unsafe_of_string "0xC4C4" in + {input with Sc_rollup.payload} - (** [feed_input state input] feeds [input] to the PVM in order to advance [state] to the next step - that requires an input. *) - let feed_input state input = + (** [feed_input level message_index ~fuel ~failing_ticks state + input] feeds [input] (that has a given [message_index] in inbox + of [level]) to the PVM in order to advance [state] to the next + step that requires an input. This function is controlled by + some [fuel] and may introduce intended failures at some given + [failing_ticks]. *) + let feed_input level message_index ~fuel ~failing_ticks state input = let open Lwt_syntax in - let* state = eval_until_input state in + let* state, fuel, tick, failing_ticks = + eval_until_input level message_index ~fuel 0 failing_ticks state + in + continue_with_fuel fuel state @@ fun fuel state -> + let* input, failing_ticks = + match failing_ticks with + | xtick :: failing_ticks' -> + if xtick = tick then + let* () = + Interpreter_event.intended_failure + ~level + ~message_index + ~message_tick:tick + ~internal:false + in + return (mutate input, failing_ticks') + else return (input, failing_ticks) + | _ -> return (input, failing_ticks) + in let* state = PVM.set_input input state in - let* state = PVM.eval state in - let* state = eval_until_input state in - return state + let* state, fuel, _tick, _failing_ticks = + eval_until_input level message_index ~fuel tick failing_ticks state + in + return (state, fuel) + + let eval_block_inbox ?fuel failures store hash state = + let open Lwt_result_syntax in + (* Obtain inbox and its messages for this block. *) + let*! inbox = Store.Inboxes.find store hash in + match inbox with + | None -> + (* A level with no messages for use. Skip it. *) + let*! level = Layer1.level_of_hash store hash in + return (state, Z.zero, Raw_level.of_int32_exn level, fuel) + | Some inbox -> + let inbox_level = Inbox.inbox_level inbox in + let*! messages = Store.Messages.get store hash in + (* TODO: #2717 + The length of messages here can potentially overflow the [int] returned from [List.length]. + *) + let num_messages = List.length messages |> Z.of_int in + (* Iterate the PVM state with all the messages for this level. *) + let* state, fuel = + List.fold_left_i_es + (fun message_counter (state, fuel) message -> + let*? payload = + Sc_rollup.Inbox.Message.( + message |> serialize |> Environment.wrap_tzresult) + in + let input = + Sc_rollup. + { + inbox_level; + message_counter = Z.of_int message_counter; + payload; + } + in + let level = Raw_level.to_int32 inbox_level |> Int32.to_int in + let failing_ticks = + Loser_mode.is_failure + failures + ~level + ~message_index:message_counter + in + let*! state, fuel = + feed_input + level + message_counter + ~fuel + ~failing_ticks + state + input + in + return (state, fuel)) + (state, fuel) + messages + in + return (state, num_messages, inbox_level, fuel) + + let genesis_state head_block node_ctxt store = + let open Node_context in + let open Lwt_result_syntax in + let* boot_sector = + Plugin.RPC.Sc_rollup.boot_sector + node_ctxt.cctxt + (node_ctxt.cctxt#chain, head_block) + node_ctxt.rollup_address + in + let*! initial_state = PVM.initial_state store in + let*! genesis_state = PVM.install_boot_sector initial_state boot_sector in + return genesis_state + + let state_of_hash node_ctxt store hash = + let open Lwt_result_syntax in + let head_block = `Hash (hash, 0) in + let*! state = Store.PVMState.find store hash in + match state with + | None -> genesis_state head_block node_ctxt store + | Some state -> return state (** [transition_pvm node_ctxt store predecessor_hash hash] runs a PVM at the previous state from block [predecessor_hash] by consuming as many messages as possible from block [hash]. *) let transition_pvm node_ctxt store predecessor_hash hash = - let open Node_context in let open Lwt_result_syntax in + let head_block = `Hash (hash, 0) in (* Retrieve the previous PVM state from store. *) let*! predecessor_state = Store.PVMState.find store predecessor_hash in let* predecessor_state = match predecessor_state with - | None -> - (* The predecessor is before the origination. - Here we use an RPC to get the boot sector instead of doing this - before and packing it into the [node_ctxt] because the bootsector - might be very large and we don't want to keep that in memory for - ever. - *) - let* boot_sector = - Plugin.RPC.Sc_rollup.boot_sector - node_ctxt.cctxt - (node_ctxt.cctxt#chain, node_ctxt.cctxt#block) - node_ctxt.rollup_address - in - let*! state = PVM.initial_state store in - let*! state = PVM.install_boot_sector state boot_sector in - return state + | None -> genesis_state head_block node_ctxt store | Some predecessor_state -> return predecessor_state in - (* Obtain inbox and its messages for this block. *) - let*! inbox_opt = Store.Inboxes.find store hash in - - (* Iterate the PVM state with all the messages for this level. *) - let* state, messages = - match inbox_opt with - | Some inbox -> - let inbox_level = Inbox.inbox_level inbox in - let*! messages = Store.Messages.get store hash in - let* state = - List.fold_left_i_es - (fun message_counter state message -> - let*? payload = - Environment.wrap_tzresult - (Sc_rollup.Inbox.Message.serialize message) - in - let input = - Sc_rollup. - { - inbox_level; - message_counter = Z.of_int message_counter; - payload; - } - in - let*! state = feed_input state input in - return state) - predecessor_state - messages - in - return (state, messages) - | None -> return (predecessor_state, []) + let* state, num_messages, inbox_level, _fuel = + eval_block_inbox node_ctxt.loser_mode store hash predecessor_state in (* Write final state to store. *) @@ -125,21 +239,34 @@ module Make (PVM : Pvm.S) : S = struct (* Compute extra information about the state. *) let*! initial_tick = PVM.get_tick predecessor_state in + + let*! () = + let open Store.StateHistoryRepr in + let event = + { + tick = initial_tick; + block_hash = hash; + predecessor_hash; + level = inbox_level; + } + in + Store.StateHistory.insert store event + in + let*! last_tick = PVM.get_tick state in (* TODO: #2717 - The number of ticks should not be an arbitrarily-sized integer. + The number of ticks should not be an arbitrarily-sized integer or + the difference between two ticks should be made an arbitrarily-sized + integer too. *) let num_ticks = Sc_rollup.Tick.distance initial_tick last_tick in - (* TODO: #2717 - The length of messages here can potentially overflow the [int] returned from [List.length]. - *) - let num_messages = Z.of_int (List.length messages) in let*! () = Store.StateInfo.add store hash {num_messages; num_ticks; initial_tick} in - (* Produce events. *) - let*! () = Interpreter_event.transitioned_pvm state num_messages in + let*! () = + Interpreter_event.transitioned_pvm inbox_level state num_messages + in return_unit @@ -148,4 +275,49 @@ module Make (PVM : Pvm.S) : S = struct let open Lwt_result_syntax in let*! predecessor_hash = Layer1.predecessor store head in transition_pvm node_ctxt store predecessor_hash hash + + (** [run_for_ticks node_ctxt store predecessor_hash hash + tick_distance] starts the evaluation of the inbox at block [hash] + for at most [tick_distance]. *) + let run_for_ticks node_ctxt store predecessor_hash hash tick_distance = + let open Lwt_result_syntax in + let* state = state_of_hash node_ctxt store predecessor_hash in + let* state, _counter, _level, _fuel = + eval_block_inbox node_ctxt.loser_mode ~fuel:tick_distance store hash state + in + return state + + (** [state_of_tick node_ctxt store tick level] returns [Some (state, hash)] + for a given [tick] if this [tick] happened before [level]. + Otherwise, returns [None].*) + let state_of_tick node_ctxt store tick level = + let open Lwt_result_syntax in + let* closest_event = + Store.StateHistory.event_of_largest_tick_before store tick + in + match closest_event with + | None -> return None + | Some event -> + if Raw_level.(event.level > level) then return None + else + let tick_distance = + Sc_rollup.Tick.distance tick event.tick |> Z.to_int + in + (* TODO: #3384 + We assume that [StateHistory] correctly stores enough + events to compute the state of any tick using + [run_for_ticks]. In particular, this assumes that + [event.block_hash] is the block where the tick + happened. We should test that this is always true because + [state_of_tick] is a critical function. *) + let* state = + run_for_ticks + node_ctxt + store + event.predecessor_hash + event.block_hash + tick_distance + in + let*! hash = PVM.state_hash state in + return (Some (state, hash)) end diff --git a/src/proto_alpha/bin_sc_rollup_node/interpreter_event.ml b/src/proto_alpha/bin_sc_rollup_node/interpreter_event.ml index d177dd810f3a434b18e9d3d9530a52c7894720b9..2c13a77c89039856579ee28d7510982d8799fdbc 100644 --- a/src/proto_alpha/bin_sc_rollup_node/interpreter_event.ml +++ b/src/proto_alpha/bin_sc_rollup_node/interpreter_event.ml @@ -31,21 +31,39 @@ module Simple = struct let section = ["sc_rollup_node"; "interpreter"] let transitioned_pvm = - declare_3 + declare_4 ~section ~name:"sc_rollup_node_interpreter_transitioned_pvm" ~msg: - "Transitioned PVM to {state_hash} at tick {ticks} with {num_messages} \ - messages" + "Transitioned PVM at inbox level {inbox_level} to {state_hash} at tick \ + {ticks} with {num_messages} messages" ~level:Notice + ("inbox_level", Protocol.Alpha_context.Raw_level.encoding) ("state_hash", State_hash.encoding) ("ticks", Tick.encoding) ("num_messages", Data_encoding.z) + + let intended_failure = + declare_4 + ~section + ~name:"sc_rollup_node_interpreter_intended_failure" + ~msg: + "Intended failure at level {level} for message indexed {message_index} \ + and at the tick {message_tick} of message processing (internal = \ + {internal})." + ~level:Notice + ("level", Data_encoding.int31) + ("message_index", Data_encoding.int31) + ("message_tick", Data_encoding.int31) + ("internal", Data_encoding.bool) end -let transitioned_pvm state num_messages = +let transitioned_pvm inbox_level state num_messages = let open Lwt_syntax in (* TODO (#3094): is this code path taken for Wasm_2_0_0_pvm. Do we need to abstract? *) let* hash = Arith_pvm.state_hash state in let* ticks = Arith_pvm.get_tick state in - Simple.(emit transitioned_pvm (hash, ticks, num_messages)) + Simple.(emit transitioned_pvm (inbox_level, hash, ticks, num_messages)) + +let intended_failure ~level ~message_index ~message_tick ~internal = + Simple.(emit intended_failure (level, message_index, message_tick, internal)) diff --git a/src/proto_alpha/bin_sc_rollup_node/interpreter_event.mli b/src/proto_alpha/bin_sc_rollup_node/interpreter_event.mli index 2c7cd5106921ca8110d7664730d8ecd700f183a2..85403d5ebb33f27b9a3975830928938a4d1c8f19 100644 --- a/src/proto_alpha/bin_sc_rollup_node/interpreter_event.mli +++ b/src/proto_alpha/bin_sc_rollup_node/interpreter_event.mli @@ -26,6 +26,22 @@ (** This module defines functions that emit the events used when running a PVM transition (see {!Interpreter}). *) -(** [transition_pvm hash n] emits the event that a PVM transition is leading to - the state of the given [hash] by processing [n] messages. *) -val transitioned_pvm : Arith_pvm.state -> Z.t -> unit Lwt.t +(** [transition_pvm inbox_level hash n] emits the event that a PVM + transition is leading to the state of the given [hash] by + processing [n] messages. *) +val transitioned_pvm : + Protocol.Alpha_context.Raw_level.t -> Arith_pvm.state -> Z.t -> unit Lwt.t + +(** [intended_failure level message_index message_tick internal] emits + the event that an intended failure has been injected at some given + [level], during the processing of a given [message_index] and at + tick [message_tick] during this message processing. [internal] is + [true] if the failure is injected in a PVM internal + step. [internal] is [false] if the failure is injected in the input + to the PVM. *) +val intended_failure : + level:int -> + message_index:int -> + message_tick:int -> + internal:bool -> + unit Lwt.t diff --git a/src/proto_alpha/bin_sc_rollup_node/layer1.ml b/src/proto_alpha/bin_sc_rollup_node/layer1.ml index 11d30e3fca23f638ccc0f7367c4f2edaed9681df..0d4dfc905faf7fd4ce592ac1a441ff5469a4ed85 100644 --- a/src/proto_alpha/bin_sc_rollup_node/layer1.ml +++ b/src/proto_alpha/bin_sc_rollup_node/layer1.ml @@ -424,6 +424,11 @@ let current_level store = let hash_of_level = State.hash_of_level +let level_of_hash store hash = + let open Lwt_syntax in + let* (Block {level; _}) = State.block_of_hash store hash in + return level + let predecessor store (Head {hash; _}) = let open Lwt_syntax in let+ (Block {predecessor; _}) = State.block_of_hash store hash in @@ -439,6 +444,11 @@ let processed = function let mark_processed_head store head = State.mark_processed_head store head +let last_processed_head_hash store = + let open Lwt_syntax in + let+ info = State.last_processed_head store in + Option.map (fun (Head {hash; _}) -> hash) info + (* We forget about the last seen heads that are not processed so that the rollup node can process them when restarted. Notice that this does prevent skipping heads when the node is interrupted in a bad diff --git a/src/proto_alpha/bin_sc_rollup_node/layer1.mli b/src/proto_alpha/bin_sc_rollup_node/layer1.mli index 966ba395bb9325f6e0e6478c28cfb8b101568bb6..e5821777d585090388cc72e66eed437757622d89 100644 --- a/src/proto_alpha/bin_sc_rollup_node/layer1.mli +++ b/src/proto_alpha/bin_sc_rollup_node/layer1.mli @@ -87,10 +87,16 @@ val current_head_hash : Store.t -> Block_hash.t option Lwt.t made. *) val current_level : Store.t -> int32 option Lwt.t -(** [hash_of_level level] returns the current block hash for a given - [level]. *) +(** [hash_of_level store level] returns the current block hash for a + given [level]. Raise [Invalid_argument] if [hash] does not belong + to [store]. *) val hash_of_level : Store.t -> int32 -> Block_hash.t Lwt.t +(** [level_of_hash store hash] returns the level for a given block + [hash]. Raise [Invalid_argument] if [hash] does not belong to + [store]. *) +val level_of_hash : Store.t -> Block_hash.t -> int32 Lwt.t + (** [predecessor store head] returns the hash of the head's predecessor block] *) val predecessor : Store.t -> head -> Block_hash.t Lwt.t @@ -106,6 +112,10 @@ val processed : chain_event -> unit Lwt.t it. *) val mark_processed_head : Store.t -> head -> unit Lwt.t +(** [last_processed_head_hash store] returns the hash of + the last processed head. *) +val last_processed_head_hash : Store.t -> Block_hash.t option Lwt.t + (** [shutdown store] properly shut the layer 1 down. *) val shutdown : Store.t -> unit Lwt.t diff --git a/src/proto_alpha/bin_sc_rollup_node/loser_mode.ml b/src/proto_alpha/bin_sc_rollup_node/loser_mode.ml new file mode 100644 index 0000000000000000000000000000000000000000..fd2dcc70ce0588bcd29229753aa0d53b2f35da79 --- /dev/null +++ b/src/proto_alpha/bin_sc_rollup_node/loser_mode.ml @@ -0,0 +1,76 @@ +(*****************************************************************************) +(* *) +(* Open Source License *) +(* Copyright (c) 2022 Nomadic Labs, *) +(* *) +(* 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 failure = {level : int; message_index : int; message_tick : int} + +let failure_encoding = + let open Data_encoding in + conv + (fun {level; message_index; message_tick} -> + (level, message_index, message_tick)) + (fun (level, message_index, message_tick) -> + {level; message_index; message_tick}) + (obj3 + (req "level" int31) + (req "message_index" int31) + (req "message_tick" int31)) + +let compare_failure {level; message_index; message_tick} f2 = + let open Compare.Int in + match compare level f2.level with + | 0 -> ( + match compare message_index f2.message_index with + | 0 -> compare message_tick f2.message_tick + | n -> n) + | n -> n + +type t = failure list + +let encoding = Data_encoding.list failure_encoding + +let no_failures = [] + +let make s = + let tokens = String.split_on_char ' ' s in + let rec chop = function + | [] | [""] -> [] + | level :: message_index :: message_tick :: rest -> + { + level = int_of_string level; + message_index = int_of_string message_index; + message_tick = int_of_string message_tick; + } + :: chop rest + | _ -> raise Not_found + in + try Some (chop tokens |> List.sort compare_failure) with _ -> None + +let is_failure failures ~level ~message_index = + List.filter_map + (fun f -> + if Compare.Int.(f.level = level && f.message_index = message_index) then + Some f.message_tick + else None) + failures diff --git a/src/proto_alpha/bin_sc_rollup_node/loser_mode.mli b/src/proto_alpha/bin_sc_rollup_node/loser_mode.mli new file mode 100644 index 0000000000000000000000000000000000000000..d86a269ee844a2529a13b30e531a068fed52659d --- /dev/null +++ b/src/proto_alpha/bin_sc_rollup_node/loser_mode.mli @@ -0,0 +1,46 @@ +(*****************************************************************************) +(* *) +(* Open Source License *) +(* Copyright (c) 2022 Nomadic Labs, *) +(* *) +(* 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 list of failures. *) +type t + +val encoding : t Data_encoding.t + +(** [no_failures] are planned. *) +val no_failures : t + +(** [make s] parses a list of integers separated by spaces that is a + periodic sequence of triple [level message_index message_tick] + representing a failure that the rollup node is supposed to make. + This function returns [None] if the input string is not syntactically + correct. *) +val make : string -> t option + +(** [is_failure failures ~level ~message_index] returns [message_ticks] + where a failure is supposed to happen at the point + of the rollup node processing of a given inbox [level], a given + [message_index] and for all [message_ticks]. Ticks are sorted by + increasing order. *) +val is_failure : t -> level:int -> message_index:int -> int list diff --git a/src/proto_alpha/bin_sc_rollup_node/main_sc_rollup_node_alpha.ml b/src/proto_alpha/bin_sc_rollup_node/main_sc_rollup_node_alpha.ml index 0f78ec508c7ad88fdbdb90d6f71222f2808a3e76..1267e674af4f39dd6b535f09ccf89504ea943993 100644 --- a/src/proto_alpha/bin_sc_rollup_node/main_sc_rollup_node_alpha.ml +++ b/src/proto_alpha/bin_sc_rollup_node/main_sc_rollup_node_alpha.ml @@ -165,6 +165,17 @@ let burn_cap_arg = | Some t -> return t | None -> failwith "Bad burn cap")) +let loser_mode = + Clic.default_arg + ~long:"loser-mode" + ~placeholder:"mode" + ~default:"" + ~doc:"Set the rollup node failure points (for test only!)." + (Clic.parameter (fun _ s -> + match Loser_mode.make s with + | Some t -> return t + | None -> failwith "Invalid syntax for failure points")) + let group = { Clic.name = "sc_rollup.node"; @@ -176,7 +187,7 @@ let config_init_command = command ~group ~desc:"Configure the smart-contract rollup node." - (args9 + (args10 data_dir_arg rpc_addr_arg rpc_port_arg @@ -185,7 +196,8 @@ let config_init_command = minimal_nanotez_per_gas_unit_arg force_low_fee_arg fee_cap_arg - burn_cap_arg) + burn_cap_arg + loser_mode) (prefixes ["config"; "init"; "on"] @@ sc_rollup_address_param @@ prefixes ["with"; "operator"] @@ -198,7 +210,8 @@ let config_init_command = minimal_nanotez_per_gas_unit, force_low_fee, fee_cap, - burn_cap ) + burn_cap, + loser_mode ) sc_rollup_address sc_rollup_node_operator cctxt -> @@ -219,6 +232,7 @@ let config_init_command = fee_cap; burn_cap; }; + loser_mode; } in save config >>=? fun () -> diff --git a/src/proto_alpha/bin_sc_rollup_node/node_context.ml b/src/proto_alpha/bin_sc_rollup_node/node_context.ml index a72e4895f379f18da37e06833d27f4ebe4e3b69f..e5a7fabd88f0d3f6ec6b02a1d132605b3df29ccd 100644 --- a/src/proto_alpha/bin_sc_rollup_node/node_context.ml +++ b/src/proto_alpha/bin_sc_rollup_node/node_context.ml @@ -36,6 +36,7 @@ type t = { kind : Sc_rollup.Kind.t; fee_parameter : Injection.fee_parameter; protocol_constants : Constants.t; + loser_mode : Loser_mode.t; } let get_operator_keys node_ctxt = @@ -53,7 +54,7 @@ let retrieve_constants cctxt = Protocol.Constants_services.all cctxt (cctxt#chain, cctxt#block) let init (cctxt : Protocol_client_context.full) l1_ctxt rollup_address - genesis_info kind operator fee_parameter = + genesis_info kind operator fee_parameter ~loser_mode = let open Lwt_result_syntax in let+ protocol_constants = retrieve_constants cctxt in { @@ -66,4 +67,5 @@ let init (cctxt : Protocol_client_context.full) l1_ctxt rollup_address block_finality_time = 2; fee_parameter; protocol_constants; + loser_mode; } diff --git a/src/proto_alpha/bin_sc_rollup_node/node_context.mli b/src/proto_alpha/bin_sc_rollup_node/node_context.mli index ed5880e95acf5f3684a3a89a3a029ad879aaeddb..dfb7616bf43585ec8da8d62a5b565089fd6a73ef 100644 --- a/src/proto_alpha/bin_sc_rollup_node/node_context.mli +++ b/src/proto_alpha/bin_sc_rollup_node/node_context.mli @@ -46,6 +46,9 @@ type t = { (** Fee parameter to use when injecting operations in layer 1. *) protocol_constants : Constants.t; (** Protocol constants retrieved from the Tezos node. *) + loser_mode : Loser_mode.t; + (** If different from [Loser_mode.no_failures], the rollup node + issues wrong commitments (for tests). *) } (** [get_operator_keys cctxt] returns a triple [(pkh, pk, sk)] corresponding @@ -69,4 +72,5 @@ val init : Protocol.Alpha_context.Sc_rollup.Kind.t -> Signature.Public_key_hash.t -> Injection.fee_parameter -> + loser_mode:Loser_mode.t -> t tzresult Lwt.t diff --git a/src/proto_alpha/bin_sc_rollup_node/refutation_game.ml b/src/proto_alpha/bin_sc_rollup_node/refutation_game.ml new file mode 100644 index 0000000000000000000000000000000000000000..de09964a71e63e71361dca7f49890a0009286833 --- /dev/null +++ b/src/proto_alpha/bin_sc_rollup_node/refutation_game.ml @@ -0,0 +1,386 @@ +(*****************************************************************************) +(* *) +(* Open Source License *) +(* Copyright (c) 2022 Nomadic Labs, *) +(* *) +(* 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. *) +(* *) +(*****************************************************************************) + +(** This module implements the refutation game logic of the rollup + node. + + When a new L1 block arises, the rollup node asks the L1 node for + the current game it is part of, if any. + + If a game is running and it is the rollup operator turn, the rollup + node injects the next move of the winning strategy. + + If a game is running and it is not the rollup operator turn, the + rollup node asks the L1 node whether the timeout is reached to play + the timeout argument if possible. + + Otherwise, if no game is running, the rollup node asks the L1 node + whether there is a conflict with one of its disputable commitments. If + there is such a conflict with a commitment C', then the rollup node + starts a game to refute C' by starting a game with one of its staker. + +*) +open Protocol + +open Alpha_context + +module type S = sig + module PVM : Pvm.S + + val process : + Layer1.head -> Node_context.t -> PVM.context -> unit tzresult Lwt.t +end + +module Make (PVM : Pvm.S) : S with module PVM = PVM = struct + module PVM = PVM + module Interpreter = Interpreter.Make (PVM) + open Sc_rollup.Game + + let node_role node_ctxt Sc_rollup.Game.Index.{alice; bob} = + let self = node_ctxt.Node_context.operator in + if Sc_rollup.Staker.equal alice self then Alice + else if Sc_rollup.Staker.equal bob self then Bob + else (* By validity of [ongoing_game] RPC. *) + assert false + + type role = Our_turn of {opponent : public_key_hash} | Their_turn + + let turn node_ctxt game players = + let Sc_rollup.Game.Index.{alice; bob} = players in + match (node_role node_ctxt players, game.turn) with + | Alice, Alice -> Our_turn {opponent = bob} + | Bob, Bob -> Our_turn {opponent = alice} + | Alice, Bob -> Their_turn + | Bob, Alice -> Their_turn + + (** [inject_next_move node_ctxt move] submits an L1 operation to + issue the next move in the refutation game. [node_ctxt] provides + the connection to the Tezos node. *) + let inject_next_move node_ctxt ~refutation ~opponent = + let open Node_context in + let open Lwt_result_syntax in + let* source, src_pk, src_sk = Node_context.get_operator_keys node_ctxt in + let {rollup_address; cctxt; _} = node_ctxt in + let* _, _, Manager_operation_result {operation_result; _} = + Client_proto_context.sc_rollup_refute + cctxt + ~chain:cctxt#chain + ~block:cctxt#block + ~refutation + ~opponent + ~source + ~rollup:rollup_address + ~src_pk + ~src_sk + ~fee_parameter:Configuration.default_fee_parameter + () + in + let open Apply_results in + let*! () = + match operation_result with + | Applied (Sc_rollup_refute_result _) -> + Refutation_game_event.refutation_published opponent refutation + | Failed (Sc_rollup_refute_manager_kind, _errors) -> + Refutation_game_event.refutation_failed opponent refutation + | Backtracked (Sc_rollup_refute_result _, _errors) -> + Refutation_game_event.refutation_backtracked opponent refutation + | Skipped Sc_rollup_refute_manager_kind -> + Refutation_game_event.refutation_skipped opponent refutation + in + return_unit + + let generate_proof node_ctxt store game start_state = + let open Lwt_result_syntax in + let*! hash = Layer1.hash_of_level store (Raw_level.to_int32 game.level) in + let* history = Inbox.history_of_hash node_ctxt store hash in + let* inbox = Inbox.inbox_of_hash node_ctxt store hash in + let*! messages_tree = Inbox.find_message_tree store hash in + let*! history, history_proof = + Store.Inbox.form_history_proof store history inbox messages_tree + in + let module P = struct + include PVM + + let context = store + + let state = start_state + + module Inbox_with_history = struct + include Store.Inbox + + let history = history + + let inbox = history_proof + end + end in + let* r = + trace + (Sc_rollup_node_errors.Cannot_produce_proof (inbox, history, game.level)) + @@ (Sc_rollup.Proof.produce (module P) game.level + >|= Environment.wrap_tzresult) + in + let+ check = + Sc_rollup.Proof.valid history_proof game.level ~pvm_name:game.pvm_name r + >|= Environment.wrap_tzresult + in + assert check ; + r + + let new_dissection node_ctxt store last_level ok our_view = + let open Lwt_result_syntax in + let _start_hash, start_tick = ok in + let our_state, stop_tick = our_view in + let Node_context.{protocol_constants; _} = node_ctxt in + (* TODO: #3200 + We should not rely on an hard-coded constant here but instead + introduce a protocol constant for the maximum number of sections + in a dissection. + *) + let max_number_of_sections = + Z.of_int + protocol_constants.parametric.sc_rollup.number_of_sections_in_dissection + in + let trace_length = Z.succ (Sc_rollup.Tick.distance stop_tick start_tick) in + let number_of_sections = Z.min max_number_of_sections trace_length in + let section_length = + Z.(max (of_int 1) (div trace_length number_of_sections)) + in + (* [k] is the number of sections in [rev_dissection]. *) + let rec make rev_dissection k tick = + if Z.equal k (Z.pred number_of_sections) then + return + @@ List.rev + ({state_hash = our_state; tick = stop_tick} :: rev_dissection) + else + let* r = Interpreter.state_of_tick node_ctxt store tick last_level in + let state_hash = Option.map snd r in + let next_tick = Sc_rollup.Tick.jump tick section_length in + make ({state_hash; tick} :: rev_dissection) (Z.succ k) next_tick + in + make [] Z.zero start_tick + + (** [generate_from_dissection node_ctxt store game] + traverses the current [game.dissection] and returns a move which + performs a new dissection of the execution trace or provides a + refutation proof to serve as the next move of the [game]. *) + let generate_next_dissection node_ctxt store game = + let open Lwt_result_syntax in + let rec traverse ok = function + | [] -> + (* The game invariant states that the dissection from the + opponent must contain a tick we disagree with. If the + retrieved game does not respect this, we cannot trust the + Tezos node we are connected to and prefer to stop here. *) + tzfail + Sc_rollup_node_errors + .Unreliable_tezos_node_returning_inconsistent_game + | {state_hash = their_hash; tick} :: dissection -> ( + let open Lwt_result_syntax in + let* our = + Interpreter.state_of_tick node_ctxt store tick game.level + in + match (their_hash, our) with + | None, None -> + (* This case is absurd since: [None] can only occur at the + end and the two players disagree about the end. *) + assert false + | Some _, None | None, Some _ -> + return (ok, (Option.map snd our, tick)) + | Some their_hash, Some (_, our_hash) -> + if Sc_rollup.State_hash.equal our_hash their_hash then + traverse (their_hash, tick) dissection + else return (ok, (Some our_hash, tick))) + in + match game.dissection with + | {state_hash = Some hash; tick} :: dissection -> + let* ok, ko = traverse (hash, tick) dissection in + let choice = snd ok in + let* dissection = new_dissection node_ctxt store game.level ok ko in + let chosen_section_len = Sc_rollup.Tick.distance (snd ko) choice in + return (choice, chosen_section_len, dissection) + | [] | {state_hash = None; _} :: _ -> + (* + By wellformedness of dissection. + A dissection always starts with a tick of the form [(Some hash, tick)]. + A dissection always contains strictly more than one element. + *) + tzfail + Sc_rollup_node_errors + .Unreliable_tezos_node_returning_inconsistent_game + + let next_move node_ctxt store game = + let open Lwt_result_syntax in + let final_move start_tick = + let* start_state = + Interpreter.state_of_tick node_ctxt store start_tick game.level + in + match start_state with + | None -> + tzfail + Sc_rollup_node_errors + .Unreliable_tezos_node_returning_inconsistent_game + | Some (start_state, _start_hash) -> + let* proof = generate_proof node_ctxt store game start_state in + let choice = start_tick in + return {choice; step = Proof proof} + in + let* choice, chosen_section_len, dissection = + generate_next_dissection node_ctxt store game + in + if Z.(equal chosen_section_len one) then final_move choice + else return {choice; step = Dissection dissection} + + let try_ f = + let open Lwt_result_syntax in + let*! _res = f () in + return_unit + + let play_next_move node_ctxt store game opponent = + let open Lwt_result_syntax in + let* refutation = next_move node_ctxt store game in + (* FIXME: #3008 + + We currently do not remember that we already have + injected a refutation move but it is not included yet. + Hence, we ignore errors here temporarily, waiting for + the injector to enter the scene. + *) + try_ @@ fun () -> + inject_next_move node_ctxt ~refutation:(Some refutation) ~opponent + + let play_timeout node_ctxt players = + let Sc_rollup.Game.Index.{alice; bob} = players in + let open Node_context in + let open Lwt_result_syntax in + let* source, src_pk, src_sk = Node_context.get_operator_keys node_ctxt in + let {rollup_address; cctxt; _} = node_ctxt in + let* _, _, Manager_operation_result {operation_result; _} = + Client_proto_context.sc_rollup_timeout + cctxt + ~chain:cctxt#chain + ~block:cctxt#block + ~source + ~alice + ~bob + ~rollup:rollup_address + ~src_pk + ~src_sk + ~fee_parameter:Configuration.default_fee_parameter + () + in + let open Apply_results in + let*! () = + match operation_result with + | Applied (Sc_rollup_timeout_result _) -> + Refutation_game_event.timeout_published players + | Failed (Sc_rollup_timeout_manager_kind, _errors) -> + Refutation_game_event.timeout_failed players + | Backtracked (Sc_rollup_timeout_result _, _errors) -> + Refutation_game_event.timeout_backtracked players + | Skipped Sc_rollup_timeout_manager_kind -> + Refutation_game_event.timeout_skipped players + in + return_unit + + let timeout_reached head_block node_ctxt players = + let open Lwt_result_syntax in + let Node_context.{rollup_address; cctxt; _} = node_ctxt in + let* res = + Plugin.RPC.Sc_rollup.timeout_reached + cctxt + (cctxt#chain, head_block) + rollup_address + players + () + in + let open Sc_rollup.Game in + let index = Index.make (fst players) (snd players) in + let node_player = node_role node_ctxt index in + match res with + | Some player when not (player_equal node_player player) -> return_true + | None -> return_false + | Some _myself -> return_false + + let play head_block node_ctxt store game staker1 staker2 = + let open Lwt_result_syntax in + let players = (staker1, staker2) in + let index = Sc_rollup.Game.Index.make staker1 staker2 in + match turn node_ctxt game index with + | Our_turn {opponent} -> play_next_move node_ctxt store game opponent + | Their_turn -> + let* timeout_reached = timeout_reached head_block node_ctxt players in + unless timeout_reached @@ fun () -> + try_ @@ fun () -> play_timeout node_ctxt index + + let ongoing_game head_block node_ctxt = + let Node_context.{rollup_address; cctxt; operator; _} = node_ctxt in + Plugin.RPC.Sc_rollup.ongoing_refutation_game + cctxt + (cctxt#chain, head_block) + rollup_address + operator + () + + let play_opening_move node_ctxt conflict = + let open Lwt_syntax in + let open Sc_rollup.Refutation_storage in + let* () = Refutation_game_event.conflict_detected conflict in + inject_next_move node_ctxt ~refutation:None ~opponent:conflict.other + + let start_game_if_conflict head_block node_ctxt = + let open Lwt_result_syntax in + let Node_context.{rollup_address; cctxt; operator; _} = node_ctxt in + let* conflicts = + Plugin.RPC.Sc_rollup.conflicts + cctxt + (cctxt#chain, head_block) + rollup_address + operator + () + in + let*! res = + Option.iter_es (play_opening_move node_ctxt) (List.hd conflicts) + in + match res with + | Ok r -> return r + | Error + [ + Environment.Ecoproto_error + Sc_rollup_errors.Sc_rollup_game_already_started; + ] -> + (* The game may already be starting in the meantime. So we + ignore this error. *) + return_unit + | Error errs -> Lwt.return (Error errs) + + let process (Layer1.Head {hash; _}) node_ctxt store = + let head_block = `Hash (hash, 0) in + let open Lwt_result_syntax in + let* res = ongoing_game head_block node_ctxt in + match res with + | Some (game, staker1, staker2) -> + play head_block node_ctxt store game staker1 staker2 + | None -> start_game_if_conflict head_block node_ctxt +end diff --git a/src/proto_alpha/bin_sc_rollup_node/refutation_game.mli b/src/proto_alpha/bin_sc_rollup_node/refutation_game.mli new file mode 100644 index 0000000000000000000000000000000000000000..9cd30306a81d32259bd6b3d5a1bfe4b336e4409f --- /dev/null +++ b/src/proto_alpha/bin_sc_rollup_node/refutation_game.mli @@ -0,0 +1,35 @@ +(*****************************************************************************) +(* *) +(* Open Source License *) +(* Copyright (c) 2022 Nomadic Labs, *) +(* *) +(* 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. *) +(* *) +(*****************************************************************************) + +(** This module implements the refutation game logic of the rollup + node. *) +module type S = sig + module PVM : Pvm.S + + val process : + Layer1.head -> Node_context.t -> PVM.context -> unit tzresult Lwt.t +end + +module Make (PVM : Pvm.S) : S with module PVM = PVM diff --git a/src/proto_alpha/bin_sc_rollup_node/refutation_game_event.ml b/src/proto_alpha/bin_sc_rollup_node/refutation_game_event.ml new file mode 100644 index 0000000000000000000000000000000000000000..0c1bd39d34bd492e2224c73de979ac66e75ef086 --- /dev/null +++ b/src/proto_alpha/bin_sc_rollup_node/refutation_game_event.ml @@ -0,0 +1,147 @@ +(*****************************************************************************) +(* *) +(* Open Source License *) +(* Copyright (c) 2022 Nomadic Labs, *) +(* *) +(* 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. *) +(* *) +(*****************************************************************************) + +open Protocol.Alpha_context + +(* TODO: https://gitlab.com/tezos/tezos/-/issues/2880 + Add corresponding .mli file. *) + +module Simple = struct + include Internal_event.Simple + + let section = ["sc_rollup_node"; "refutation_game"] + + let timeout = + declare_1 + ~section + ~name:"sc_rollup_node_timeout" + ~msg: + "The rollup node has been slashed because of a timeout issued by \ + {address}" + ~level:Notice + ("address", Signature.Public_key_hash.encoding) + + let invalid_move = + declare_0 + ~section + ~name:"sc_rollup_node_invalid_move" + ~msg: + "The rollup node is about to make an invalid move in the refutation \ + game! It is stopped to avoid being slashed. The problem should be \ + reported immediately or the rollup node should be upgraded to have a \ + chance to be back before the timeout is reached." + ~level:Notice + () + + let conflict_detected = + declare_5 + ~name:"sc_rollup_node_conflict_detected" + ~msg: + "A conflict has been found with our commitment {our_commitment_hash} \ + at level {level} with staker {other} that hash issued commitment \ + {their_commitment_hash} both based on {parent_commitment_hash}." + ~level:Notice + ("our_commitment_hash", Sc_rollup.Commitment.Hash.encoding) + ("level", Raw_level.encoding) + ("other", Sc_rollup.Staker.encoding) + ("their_commitment_hash", Sc_rollup.Commitment.Hash.encoding) + ("parent_commitment_hash", Sc_rollup.Commitment.Hash.encoding) + + let refutation_event state = + declare_2 + ~section + ~name:("sc_rollup_node_refutation_" ^ state) + ~msg: + ("Refutation was " ^ state + ^ " - opponent: {opponent}, refutation: {refutation}") + ~level:Notice + ("opponent", Sc_rollup.Staker.encoding) + ("refutation", Data_encoding.option Sc_rollup.Game.refutation_encoding) + + let refutation_published = refutation_event "published" + + let refutation_failed = refutation_event "failed" + + let refutation_backtracked = refutation_event "backtracked" + + let refutation_skipped = refutation_event "skipped" + + let timeout_event state = + declare_1 + ~section + ~name:("sc_rollup_node_timeout_" ^ state) + ~msg:("Timeout was " ^ state ^ " - players: {players}") + ~level:Notice + ("players", Sc_rollup.Game.Index.encoding) + + let timeout_published = timeout_event "published" + + let timeout_failed = timeout_event "failed" + + let timeout_backtracked = timeout_event "backtracked" + + let timeout_skipped = timeout_event "skipped" +end + +let timeout address = Simple.(emit timeout address) + +let invalid_move () = Simple.(emit invalid_move ()) + +let refutation_published opponent refutation = + Simple.(emit refutation_published (opponent, refutation)) + +let refutation_failed opponent refutation = + Simple.(emit refutation_failed (opponent, refutation)) + +let refutation_backtracked opponent refutation = + Simple.(emit refutation_backtracked (opponent, refutation)) + +let refutation_skipped opponent refutation = + Simple.(emit refutation_skipped (opponent, refutation)) + +let timeout_published players = Simple.(emit timeout_published players) + +let timeout_failed players = Simple.(emit timeout_failed players) + +let timeout_backtracked players = Simple.(emit timeout_backtracked players) + +let timeout_skipped players = Simple.(emit timeout_skipped players) + +let conflict_detected (conflict : Sc_rollup.Refutation_storage.conflict) = + let our_commitment_hash = Sc_rollup.Commitment.hash conflict.our_commitment in + let their_commitment_hash = + Sc_rollup.Commitment.hash conflict.their_commitment + in + let parent_commitment_hash = conflict.parent_commitment in + let other = conflict.other in + let level = conflict.our_commitment.inbox_level in + Simple.( + emit + conflict_detected + ( our_commitment_hash, + level, + other, + their_commitment_hash, + parent_commitment_hash )) diff --git a/src/proto_alpha/bin_sc_rollup_node/sc_rollup_node_errors.ml b/src/proto_alpha/bin_sc_rollup_node/sc_rollup_node_errors.ml index 6a333beb03ff7debbc91fde233f199b42b592f40..34191689a88bccebed468ebb85b41a83eabfa83a 100644 --- a/src/proto_alpha/bin_sc_rollup_node/sc_rollup_node_errors.ml +++ b/src/proto_alpha/bin_sc_rollup_node/sc_rollup_node_errors.ml @@ -29,6 +29,11 @@ type error += Bad_minimal_fees of string type error += Commitment_predecessor_should_be_LCC of Sc_rollup.Commitment.t +type error += Unreliable_tezos_node_returning_inconsistent_game + +type error += + | Cannot_produce_proof of Store.Inbox.t * Store.Inbox.history * Raw_level.t + let () = register_error_kind `Permanent @@ -58,4 +63,48 @@ let () = (function | Commitment_predecessor_should_be_LCC commitment -> Some commitment | _ -> None) - (fun commitment -> Commitment_predecessor_should_be_LCC commitment) + (fun commitment -> Commitment_predecessor_should_be_LCC commitment) ; + + register_error_kind + `Permanent + ~id:"internal.unreliable_tezos_node" + ~title:"Internal error: Tezos node seems unreliable" + ~description: + "Internal error: The game invariant states that the dissection from the \ + opponent must contain a tick we disagree with. If the retrieved game \ + does not respect this, we cannot trust the Tezos node we are connected \ + to and prefer to stop here." + ~pp:(fun _ppf () -> ()) + Data_encoding.unit + (function + | Unreliable_tezos_node_returning_inconsistent_game -> Some () | _ -> None) + (fun () -> Unreliable_tezos_node_returning_inconsistent_game) ; + + register_error_kind + `Permanent + ~id:"internal.cannnot_produce_proof" + ~title:"Internal error: Rollup node cannot produce refutation proof" + ~description: + "The rollup node is in a state that prevent it from produce refutation \ + proofs." + ~pp:(fun ppf (inbox, history, level) -> + Format.fprintf + ppf + "cannot produce proof for inbox %a of level %a with history %a" + Store.Inbox.pp + inbox + Raw_level.pp + level + Store.Inbox.pp_history + history) + Data_encoding.( + obj3 + (req "inbox" Store.Inbox.encoding) + (req "history" Store.Inbox.history_encoding) + (req "level" Raw_level.encoding)) + (function + | Cannot_produce_proof (inbox, history, level) -> + Some (inbox, history, level) + | _ -> None) + (fun (inbox, history, level) -> + Cannot_produce_proof (inbox, history, level)) diff --git a/src/proto_alpha/bin_sc_rollup_node/store.ml b/src/proto_alpha/bin_sc_rollup_node/store.ml index d465aee1983e73f7606f4f61913a242bc2d5578e..144775f33a416e998d928be3f85e05f977194a77 100644 --- a/src/proto_alpha/bin_sc_rollup_node/store.ml +++ b/src/proto_alpha/bin_sc_rollup_node/store.ml @@ -232,8 +232,7 @@ module Inbox = struct | Error _ -> assert false let to_inbox_hash kinded_hash = - match kinded_hash with - | `Value h | `Node h -> Hash.of_bytes_exn (Context_hash.to_bytes h) + match kinded_hash with `Value h | `Node h -> Hash.of_context_hash h let from_inbox_hash inbox_hash = let ctxt_hash = Hash.to_context_hash inbox_hash in @@ -252,6 +251,11 @@ module Inbox = struct let produce_proof store tree f = let open Lwt_syntax in + (* TODO: #3381 + Since committing is required for proof production to work + properly, why isn't committing part of the process of proof + production? *) + let* _commit_key = commit store in match IStoreTree.kinded_key tree with | Some k -> let* p = IStoreProof.produce_tree_proof (IStore.repo store) k f in diff --git a/src/proto_alpha/lib_client/operation_result.ml b/src/proto_alpha/lib_client/operation_result.ml index 09938ce70370c07d03406b189da966e3e6105ffb..44ef0de1a80582fe543fcf345b7c0d94fd6795aa 100644 --- a/src/proto_alpha/lib_client/operation_result.ml +++ b/src/proto_alpha/lib_client/operation_result.ml @@ -764,7 +764,7 @@ let pp_manager_operation_contents_result ppf op_result = | Sc_rollup_cement_result _ -> "smart contract rollup commitment cementing" | Sc_rollup_publish_result _ -> "smart contract rollup commitment publishing" - | Sc_rollup_refute_result _ -> "smart contract rollup refutation start" + | Sc_rollup_refute_result _ -> "smart contract rollup refutation move" | Sc_rollup_timeout_result _ -> "smart contract rollup refutation timeout" | Sc_rollup_execute_outbox_message_result _ -> "smart contract output message execution" diff --git a/src/proto_alpha/lib_plugin/RPC.ml b/src/proto_alpha/lib_plugin/RPC.ml index 4ef926e5a978f9ab0d58d94f4707a46313ae590a..306e5fbd0ecbd41f986a681cc94efa657dbbe852 100644 --- a/src/proto_alpha/lib_plugin/RPC.ml +++ b/src/proto_alpha/lib_plugin/RPC.ml @@ -1909,6 +1909,41 @@ module Sc_rollup = struct ~query ~output RPC_path.(path /: Sc_rollup.Address.rpc_arg / "conflicts") + + let timeout_reached = + let query = + let open RPC_query in + query (fun x y -> + Sc_rollup.Staker.(of_b58check_exn x, of_b58check_exn y)) + |+ field "staker1" RPC_arg.string "" (fun (x, _) -> + Format.asprintf "%a" Sc_rollup.Staker.pp x) + |+ field "staker2" RPC_arg.string "" (fun (_, x) -> + Format.asprintf "%a" Sc_rollup.Staker.pp x) + |> seal + in + let output = Data_encoding.option Sc_rollup.Game.player_encoding in + RPC_service.get_service + ~description: + "Returns whether the timeout is reached for the current player." + ~query + ~output + RPC_path.(path /: Sc_rollup.Address.rpc_arg / "timeout_reached") + + let can_be_cemented = + let query = + let open RPC_query in + query Sc_rollup.Commitment.Hash.of_b58check_exn + |+ field "commitment" RPC_arg.string "" (fun x -> + Format.asprintf "%a" Sc_rollup.Commitment.Hash.pp x) + |> seal + in + let output = Data_encoding.bool in + RPC_service.get_service + ~description: + "Returns true if and only if the provided commitment can be cemented." + ~query + ~output + RPC_path.(path /: Sc_rollup.Address.rpc_arg / "can_be_cemented") end let kind ctxt block sc_rollup_address = @@ -2011,6 +2046,32 @@ module Sc_rollup = struct rollup staker) + let register_timeout_reached () = + Registration.register1 + ~chunked:false + S.timeout_reached + (fun context rollup (staker1, staker2) () -> + let open Lwt_tzresult_syntax in + let index = Sc_rollup.Game.Index.make staker1 staker2 in + let*! res = Sc_rollup.Refutation_storage.timeout context rollup index in + match res with + | Ok (outcome, _context) -> return_some outcome.loser + | Error _ -> return_none) + + let register_can_be_cemented () = + Registration.register1 + ~chunked:false + S.can_be_cemented + (fun context rollup commitment_hash () -> + let open Lwt_tzresult_syntax in + let*! res = + Sc_rollup.Stake_storage.cement_commitment + context + rollup + commitment_hash + in + match res with Ok _context -> return_true | Error _ -> return_false) + let register () = register_kind () ; register_inbox () ; @@ -2022,7 +2083,9 @@ module Sc_rollup = struct register_dal_slot_subscriptions () ; register_root () ; register_ongoing_refutation_game () ; - register_conflicts () + register_conflicts () ; + register_timeout_reached () ; + register_can_be_cemented () let list ctxt block = RPC_context.make_call0 S.root ctxt block () () @@ -2061,6 +2124,23 @@ module Sc_rollup = struct let conflicts ctxt block sc_rollup_address staker = RPC_context.make_call1 S.conflicts ctxt block sc_rollup_address staker + + let timeout_reached ctxt block sc_rollup_address staker1 staker2 = + RPC_context.make_call1 + S.timeout_reached + ctxt + block + sc_rollup_address + staker1 + staker2 + + let can_be_cemented ctxt block sc_rollup_address commitment_hash = + RPC_context.make_call1 + S.can_be_cemented + ctxt + block + sc_rollup_address + commitment_hash end module Tx_rollup = struct diff --git a/src/proto_alpha/lib_protocol/alpha_context.mli b/src/proto_alpha/lib_protocol/alpha_context.mli index ef33c165a54e054d83553d0520050dc059c475e4..dfd52cdf52292d95b039c4d8b19e49a8e665da81 100644 --- a/src/proto_alpha/lib_protocol/alpha_context.mli +++ b/src/proto_alpha/lib_protocol/alpha_context.mli @@ -2814,6 +2814,10 @@ module Sc_rollup : sig val to_context_hash : t -> Context_hash.t end + type serialized_proof + + val serialized_proof_encoding : serialized_proof Data_encoding.t + module type MerkelizedOperations = sig type tree @@ -2878,7 +2882,9 @@ module Sc_rollup : sig val pp_proof : Format.formatter -> proof -> unit - val proof_encoding : proof Data_encoding.t + val to_serialized_proof : proof -> serialized_proof + + val of_serialized_proof : serialized_proof -> proof option val verify_proof : Raw_level.t * Z.t -> @@ -3013,6 +3019,8 @@ module Sc_rollup : sig type state + val pp : state -> (Format.formatter -> unit -> unit) Lwt.t + type context type hash = State_hash.t @@ -3063,6 +3071,10 @@ module Sc_rollup : sig val produce_output_proof : context -> state -> output -> (output_proof, error) result Lwt.t + + module Internal_for_tests : sig + val insert_failure : state -> state Lwt.t + end end type t = (module S) @@ -3274,7 +3286,7 @@ module Sc_rollup : sig val wrapped_proof_module : wrapped_proof -> (module PVM_with_proof) module Proof : sig - type t = {pvm_step : wrapped_proof; inbox : Inbox.proof option} + type t = {pvm_step : wrapped_proof; inbox : Inbox.serialized_proof option} module type PVM_with_context_and_state = sig include PVM.S @@ -3282,17 +3294,29 @@ module Sc_rollup : sig val context : context val state : state + + val proof_encoding : proof Data_encoding.t + + module Inbox_with_history : sig + include Inbox.MerkelizedOperations with type inbox_context = context + + val inbox : Inbox.history_proof + + val history : history + end end type error += Sc_rollup_proof_check of string - val produce : - (module PVM_with_context_and_state) -> - Inbox.inbox_context -> - Inbox.history -> + val valid : Inbox.history_proof -> Raw_level.t -> - t tzresult Lwt.t + pvm_name:string -> + t -> + bool tzresult Lwt.t + + val produce : + (module PVM_with_context_and_state) -> Raw_level.t -> t tzresult Lwt.t end module Game : sig @@ -3300,6 +3324,8 @@ module Sc_rollup : sig val player_equal : player -> player -> bool + val player_encoding : player Data_encoding.t + type dissection_chunk = {state_hash : State_hash.t option; tick : Tick.t} type t = { @@ -3316,6 +3342,8 @@ module Sc_rollup : sig module Index : sig type t = private {alice : Staker.t; bob : Staker.t} + val encoding : t Data_encoding.t + val make : Staker.t -> Staker.t -> t end @@ -3327,6 +3355,8 @@ module Sc_rollup : sig type refutation = {choice : Tick.t; step : step} + val refutation_encoding : refutation Data_encoding.t + val pp_refutation : Format.formatter -> refutation -> unit type reason = Conflict_resolved | Invalid_move of string | Timeout 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 9652723225818fb9b2eba6cf733684b124f847c2..aa4e9018e7c6a8be538ae85da339459bb3fe83bf 100644 --- a/src/proto_alpha/lib_protocol/sc_rollup_PVM_sem.ml +++ b/src/proto_alpha/lib_protocol/sc_rollup_PVM_sem.ml @@ -136,6 +136,8 @@ let pp_output fmt {outbox_level; message_index; message} = module type S = sig type state + val pp : state -> (Format.formatter -> unit -> unit) Lwt.t + type context type hash = Sc_rollup_repr.State_hash.t @@ -186,4 +188,8 @@ module type S = sig val produce_output_proof : context -> state -> output -> (output_proof, error) result Lwt.t + + module Internal_for_tests : sig + val insert_failure : state -> state Lwt.t + end end diff --git a/src/proto_alpha/lib_protocol/sc_rollup_PVM_sem.mli b/src/proto_alpha/lib_protocol/sc_rollup_PVM_sem.mli index 840dd31ecb4c58df60e0cf03d5db2cd81a5f7d56..98fa6552ddd71b15eead25c9b136b54685a13d38 100644 --- a/src/proto_alpha/lib_protocol/sc_rollup_PVM_sem.mli +++ b/src/proto_alpha/lib_protocol/sc_rollup_PVM_sem.mli @@ -116,6 +116,8 @@ module type S = sig inbox to be executable. *) type state + val pp : state -> (Format.formatter -> unit -> unit) Lwt.t + (** A state is initialized in a given context. A [context] represents the executable environment needed by the state to exist. Typically, the rollup node storage can be part of this @@ -274,4 +276,10 @@ module type S = sig the fact that [output] is part of [state]'s outbox. *) val produce_output_proof : context -> state -> output -> (output_proof, error) result Lwt.t + + module Internal_for_tests : sig + (** [insert_failure state] corrupts the PVM state. This is used in + the loser mode of the rollup node. *) + val insert_failure : state -> state Lwt.t + end end diff --git a/src/proto_alpha/lib_protocol/sc_rollup_arith.ml b/src/proto_alpha/lib_protocol/sc_rollup_arith.ml index 6df3ffac0caa966c1bf39562c713a6403a554c9c..c9d93a38836b3058efbd5b7c07c2a1f882463ba7 100644 --- a/src/proto_alpha/lib_protocol/sc_rollup_arith.ml +++ b/src/proto_alpha/lib_protocol/sc_rollup_arith.ml @@ -753,13 +753,6 @@ module Make (Context : P) : type state = State.state - let pp state = - let open Lwt_syntax in - let* _, pp = Monad.run pp state in - match pp with - | None -> return @@ fun fmt _ -> Format.fprintf fmt "" - | Some pp -> return pp - open Monad let initial_state ctxt = @@ -787,6 +780,16 @@ module Make (Context : P) : let context_hash = Tree.hash state in Lwt.return @@ State_hash.context_hash_to_state_hash context_hash + let pp state = + let open Lwt_syntax in + let* _, pp = Monad.run pp state in + match pp with + | None -> return @@ fun fmt _ -> Format.fprintf fmt "" + | Some pp -> + let* state_hash = state_hash state in + return (fun fmt () -> + Format.fprintf fmt "@[%a: %a@]" State_hash.pp state_hash pp ()) + let boot = let open Monad.Syntax in let* () = Status.create in @@ -835,6 +838,15 @@ module Make (Context : P) : let get_is_stuck = result_of ~default:None @@ is_stuck + let start_parsing : unit t = + let open Monad.Syntax in + let* () = Status.set Parsing in + let* () = ParsingResult.set None in + let* () = ParserState.set SkipLayout in + let* () = LexerState.set (0, 0) in + let* () = Code.clear in + return () + let set_input_monadic {PS.inbox_level; message_counter; payload} = let open Monad.Syntax in let payload = @@ -853,6 +865,7 @@ module Make (Context : P) : let* () = CurrentLevel.set inbox_level in let* () = MessageCounter.set (Some message_counter) in let* () = NextMessage.set (Some msg) in + let* () = start_parsing in return () | None -> let* () = CurrentLevel.set inbox_level in @@ -904,15 +917,6 @@ module Make (Context : P) : let* s = lexeme in Code.inject (IStore s) - let start_parsing : unit t = - let open Monad.Syntax in - let* () = Status.set Parsing in - let* () = ParsingResult.set None in - let* () = ParserState.set SkipLayout in - let* () = LexerState.set (0, 0) in - let* () = Code.clear in - return () - let start_evaluating : unit t = let open Monad.Syntax in let* () = Status.set Evaluating in @@ -1189,6 +1193,14 @@ module Make (Context : P) : return {output_proof; output_proof_state; output_proof_output} | Some (_, false) -> fail Arith_invalid_claim_about_outbox | None -> fail Arith_output_proof_production_failed + + module Internal_for_tests = struct + let insert_failure state = + let add n = Tree.add state ["failures"; string_of_int n] Bytes.empty in + let open Lwt_syntax in + let* n = Tree.length state ["failures"] in + add n + end end module ProtocolImplementation = Make (struct 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 634c9d717256ac537fd5cdeaf101e606d649f4fc..13f2bc46ee90677ace23462d62ea1e3480d5cb67 100644 --- a/src/proto_alpha/lib_protocol/sc_rollup_game_repr.mli +++ b/src/proto_alpha/lib_protocol/sc_rollup_game_repr.mli @@ -194,6 +194,8 @@ module V1 : sig val player_equal : player -> player -> bool + val player_encoding : player Data_encoding.t + val pp : Format.formatter -> t -> unit end diff --git a/src/proto_alpha/lib_protocol/sc_rollup_inbox_repr.ml b/src/proto_alpha/lib_protocol/sc_rollup_inbox_repr.ml index 942ca0e522bc2e7cef2ba0bf2169fd460b97b541..365055f1cae7b8dfc0a255b6540cec0d1b9ea154 100644 --- a/src/proto_alpha/lib_protocol/sc_rollup_inbox_repr.ml +++ b/src/proto_alpha/lib_protocol/sc_rollup_inbox_repr.ml @@ -133,6 +133,13 @@ end module Skip_list = Skip_list_repr.Make (Skip_list_parameters) +let hash_skip_list_cell cell = + let current_level_hash = Skip_list.content cell in + let back_pointers_hashes = Skip_list.back_pointers cell in + Hash.to_bytes current_level_hash + :: List.map Hash.to_bytes back_pointers_hashes + |> Hash.hash_bytes + module V1 = struct type history_proof = (Hash.t, Hash.t) Skip_list.cell @@ -141,7 +148,15 @@ module V1 = struct let history_proof_encoding : history_proof Data_encoding.t = Skip_list.encoding Hash.encoding Hash.encoding - let pp_history_proof = Skip_list.pp ~pp_content:Hash.pp ~pp_ptr:Hash.pp + let pp_history_proof fmt history = + let history_hash = hash_skip_list_cell history in + Format.fprintf + fmt + "@[hash : %a@;%a@]" + Hash.pp + history_hash + (Skip_list.pp ~pp_content:Hash.pp ~pp_ptr:Hash.pp) + history (* @@ -221,15 +236,14 @@ module V1 = struct } = Format.fprintf fmt - {| - rollup = %a - level = %a - current messages hash = %a - nb_messages_in_commitment_period = %s - starting_level_of_current_commitment_period = %a - message_counter = %a - old_levels_messages = %a - |} + "@[{ rollup = %a@;\ + level = %a@;\ + current messages hash = %a@;\ + nb_messages_in_commitment_period = %s@;\ + starting_level_of_current_commitment_period = %a@;\ + message_counter = %a@;\ + old_levels_messages = %a@;\ + }@]" Sc_rollup_repr.Address.pp rollup Raw_level_repr.pp @@ -338,6 +352,10 @@ let key_of_message ix = let level_key = ["level"] +type serialized_proof = bytes + +let serialized_proof_encoding = Data_encoding.bytes + module type MerkelizedOperations = sig type inbox_context @@ -402,7 +420,9 @@ module type MerkelizedOperations = sig val pp_proof : Format.formatter -> proof -> unit - val proof_encoding : proof Data_encoding.t + val to_serialized_proof : proof -> serialized_proof + + val of_serialized_proof : serialized_proof -> proof option val verify_proof : Raw_level_repr.t * Z.t -> @@ -513,13 +533,6 @@ struct Sc_rollup_inbox_message_repr.unsafe_of_string (Bytes.to_string bs)) bytes - let hash_skip_list_cell cell = - let current_level_hash = Skip_list.content cell in - let back_pointers_hashes = Skip_list.back_pointers cell in - Hash.to_bytes current_level_hash - :: List.map Hash.to_bytes back_pointers_hashes - |> Hash.hash_bytes - module Int64_map = Map.Make (Int64) type history = { @@ -551,16 +564,32 @@ struct let pp_history fmt history = Hash.Map.bindings history.events |> fun bindings -> + Int64_map.bindings history.sequence |> fun sequence_bindings -> let pp_binding fmt (hash, history_proof) = Format.fprintf fmt - "@[%a -> %a@]" + "@[%a -> %a@;@]" Hash.pp hash pp_history_proof history_proof in - Format.pp_print_list pp_binding fmt bindings + let pp_sequence_binding fmt (counter, hash) = + Format.fprintf fmt "@[%s -> %a@;@]" (Int64.to_string counter) Hash.pp hash + in + Format.fprintf + fmt + "@[History:@;\ + \ { bound: %Ld;@;\ + \ counter : %Ld;@;\ + \ bindings: %a;@;\ + \ sequence: %a; }@]" + history.bound + history.counter + (Format.pp_print_list pp_binding) + bindings + (Format.pp_print_list pp_sequence_binding) + sequence_bindings let history_at_genesis ~bound = {events = Hash.Map.empty; sequence = Int64_map.empty; bound; counter = 0L} @@ -912,6 +941,10 @@ struct }); ] + let of_serialized_proof = Data_encoding.Binary.of_bytes_opt proof_encoding + + let to_serialized_proof = Data_encoding.Binary.to_bytes_exn proof_encoding + let proof_error reason = let open Lwt_tzresult_syntax in fail (Inbox_proof_error reason) @@ -1164,7 +1197,7 @@ struct let empty context rollup level = let open Lwt_syntax in - let* initial_level = new_level_tree context level in + let* initial_level = new_level_tree context Raw_level_repr.root in let initial_hash = hash_level_tree initial_level in return { 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 14f82cb37e39305cc8a84aedbf868d8efaddf5b3..c700a5f46e54f5ca8a647d4e667ae7577901bfba 100644 --- a/src/proto_alpha/lib_protocol/sc_rollup_inbox_repr.mli +++ b/src/proto_alpha/lib_protocol/sc_rollup_inbox_repr.mli @@ -207,6 +207,10 @@ end preserve the laziness. *) val current_level_hash : t -> Hash.t +type serialized_proof + +val serialized_proof_encoding : serialized_proof Data_encoding.t + (** The following operations are subject to cross-validation between rollup nodes and the layer 1. *) module type MerkelizedOperations = sig @@ -340,7 +344,7 @@ module type MerkelizedOperations = sig (** [number_of_proof_steps proof] returns the length of [proof]. *) val number_of_proof_steps : inclusion_proof -> int - (** [produce_inclusion_proof history a b] exploits [history] to produce + (** [produce_inclusion_proof history a b] exploits [history] to produce a self-contained proof that [a] is an older version of [b]. *) val produce_inclusion_proof : history -> history_proof -> history_proof -> inclusion_proof option @@ -373,7 +377,9 @@ module type MerkelizedOperations = sig val pp_proof : Format.formatter -> proof -> unit - val proof_encoding : proof Data_encoding.t + val to_serialized_proof : proof -> serialized_proof + + val of_serialized_proof : serialized_proof -> proof option (** See the docstring for the [proof] type for details of proof semantics. diff --git a/src/proto_alpha/lib_protocol/sc_rollup_proof_repr.ml b/src/proto_alpha/lib_protocol/sc_rollup_proof_repr.ml index 27c45d86c695b99cd7435ef06100b6576e343fbe..27852f366b438abd03d96c2612b4a3fed2fe859a 100644 --- a/src/proto_alpha/lib_protocol/sc_rollup_proof_repr.ml +++ b/src/proto_alpha/lib_protocol/sc_rollup_proof_repr.ml @@ -26,7 +26,7 @@ type t = { pvm_step : Sc_rollups.wrapped_proof; - inbox : Sc_rollup_inbox_repr.proof option; + inbox : Sc_rollup_inbox_repr.serialized_proof option; } let encoding = @@ -36,7 +36,7 @@ let encoding = (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))) + (req "inbox" (option Sc_rollup_inbox_repr.serialized_proof_encoding))) let pp ppf _ = Format.fprintf ppf "Refutation game proof" @@ -80,9 +80,20 @@ let check p reason = let open Lwt_tzresult_syntax in if p then return () else proof_error reason +let check_inbox_proof snapshot serialized_inbox_proof (level, counter) = + match Sc_rollup_inbox_repr.of_serialized_proof serialized_inbox_proof with + | None -> return None + | Some inbox_proof -> + Sc_rollup_inbox_repr.verify_proof (level, counter) snapshot inbox_proof + +let pp_proof fmt serialized_inbox_proof = + match Sc_rollup_inbox_repr.of_serialized_proof serialized_inbox_proof with + | None -> Format.pp_print_string fmt "" + | Some proof -> Sc_rollup_inbox_repr.pp_proof fmt proof + let valid snapshot commit_level ~pvm_name proof = - let (module P) = Sc_rollups.wrapped_proof_module proof.pvm_step in let open Lwt_tzresult_syntax in + let (module P) = Sc_rollups.wrapped_proof_module proof.pvm_step 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 @@ -90,22 +101,16 @@ let valid snapshot commit_level ~pvm_name proof = 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.verify_proof - (Raw_level_repr.root, Z.zero) - snapshot - inbox_proof + check_inbox_proof snapshot inbox_proof (Raw_level_repr.root, Z.zero) | Sc_rollup_PVM_sem.First_after (level, counter), Some inbox_proof -> - Sc_rollup_inbox_repr.verify_proof - (level, Z.succ counter) - snapshot - inbox_proof + check_inbox_proof snapshot inbox_proof (level, Z.succ counter) | _ -> proof_error (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.pp_proof) + (Format.pp_print_option pp_proof) proof.inbox) in let* () = @@ -124,6 +129,18 @@ module type PVM_with_context_and_state = sig val context : context val state : state + + val proof_encoding : proof Data_encoding.t + + module Inbox_with_history : sig + include + Sc_rollup_inbox_repr.MerkelizedOperations + with type inbox_context = context + + val inbox : Sc_rollup_inbox_repr.history_proof + + val history : history + end end let of_lwt_result result = @@ -131,31 +148,25 @@ let of_lwt_result result = let*! r = result in match r with Ok x -> return x | Error e -> fail e -let produce pvm_and_state inbox_context inbox_history inbox commit_level = +let produce pvm_and_state commit_level = let open Lwt_tzresult_syntax in let (module P : PVM_with_context_and_state) = pvm_and_state in + let open P in let*! request = 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.produce_proof - inbox_context - inbox_history - inbox - (Raw_level_repr.root, Z.zero) + Inbox_with_history.( + produce_proof context history inbox (Raw_level_repr.root, Z.zero)) in - return (Some p, i) + return (Some (Inbox_with_history.to_serialized_proof p), i) | Sc_rollup_PVM_sem.First_after (l, n) -> let* p, i = - Sc_rollup_inbox_repr.produce_proof - inbox_context - inbox_history - inbox - (l, Z.succ n) + Inbox_with_history.(produce_proof context history inbox (l, Z.succ n)) in - return (Some p, i) + return (Some (Inbox_with_history.to_serialized_proof p), i) in let input_given = Option.bind input_given (cut_at_level commit_level) in let* pvm_step_proof = diff --git a/src/proto_alpha/lib_protocol/sc_rollup_proof_repr.mli b/src/proto_alpha/lib_protocol/sc_rollup_proof_repr.mli index 06e271dd67a759435458d45b8bb6e4acf3623ccf..bf2ec6389f95d0bd8b32f855fc5c8c3b8f9516be 100644 --- a/src/proto_alpha/lib_protocol/sc_rollup_proof_repr.mli +++ b/src/proto_alpha/lib_protocol/sc_rollup_proof_repr.mli @@ -59,7 +59,7 @@ open Sc_rollup_repr 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 option; + inbox : Sc_rollup_inbox_repr.serialized_proof option; } type error += Sc_rollup_proof_check of string @@ -104,6 +104,18 @@ module type PVM_with_context_and_state = sig val context : context val state : state + + val proof_encoding : proof Data_encoding.t + + module Inbox_with_history : sig + include + Sc_rollup_inbox_repr.MerkelizedOperations + with type inbox_context = context + + val inbox : Sc_rollup_inbox_repr.history_proof + + val history : history + end end (** [produce pvm_and_state inbox_context inbox_history commit_level] @@ -122,9 +134,4 @@ end 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.inbox_context -> - Sc_rollup_inbox_repr.history -> - Sc_rollup_inbox_repr.history_proof -> - Raw_level_repr.t -> - t tzresult Lwt.t + (module PVM_with_context_and_state) -> Raw_level_repr.t -> t tzresult Lwt.t diff --git a/src/proto_alpha/lib_protocol/sc_rollup_wasm.ml b/src/proto_alpha/lib_protocol/sc_rollup_wasm.ml index 52f64e3834fca0a4712c2d3ed0bf901e79b1025c..13861ab41e9413a3223c5d7ce0c109ed190b82be 100644 --- a/src/proto_alpha/lib_protocol/sc_rollup_wasm.ml +++ b/src/proto_alpha/lib_protocol/sc_rollup_wasm.ml @@ -202,6 +202,9 @@ module V2_0_0 = struct type state = State.state + let pp _state = + Lwt.return @@ fun fmt () -> Format.pp_print_string fmt "" + open Monad let initial_state ctxt = @@ -429,6 +432,14 @@ module V2_0_0 = struct return {output_proof; output_proof_state; output_proof_output} | Some (_, false) -> fail Wasm_invalid_claim_about_outbox | None -> fail Wasm_output_proof_production_failed + + module Internal_for_tests = struct + let insert_failure state = + let add n = Tree.add state ["failures"; string_of_int n] Bytes.empty in + let open Lwt_syntax in + let* n = Tree.length state ["failures"] in + add n + end end module ProtocolImplementation = Make (struct 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 caad73fc8998cb70d3fdc3a04d91ee553215f669..73cd8732acd829e3eee1bd67ba6551bab49e8e3b 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 @@ -235,6 +235,8 @@ end) : TestPVM with type state = int = struct type state = int + let pp x = Lwt.return @@ fun fmt _ -> Format.pp_print_int fmt x + type hash = State_hash.t type context = unit @@ -304,6 +306,10 @@ end) : TestPVM with type state = int = struct let produce_output_proof _ _ _ = Stdlib.failwith "Dummy PVM can't handle output proof" + + module Internal_for_tests = struct + let insert_failure _ = Stdlib.failwith "Dummy PVM does not insert failures" + end end (** This is a random PVM. Its state is a pair of a string and a @@ -320,6 +326,14 @@ end) : TestPVM with type state = string * int list = struct type state = string * int list + let pp (s, xs) = + Lwt.return @@ fun fmt _ -> + Format.fprintf + fmt + "%s / %s" + s + (String.concat ":" @@ List.map string_of_int xs) + type context = unit type proof = dummy_proof @@ -399,6 +413,10 @@ end) : TestPVM with type state = string * int list = struct let produce_output_proof _ _ _ = Stdlib.failwith "Dummy PVM can't handle output proof" + + module Internal_for_tests = struct + let insert_failure _ = Stdlib.failwith "Dummy PVM does not insert failures" + end end module ContextPVM = ArithPVM.Make (struct diff --git a/src/proto_alpha/lib_protocol/test/unit/test_sc_rollup_inbox.ml b/src/proto_alpha/lib_protocol/test/unit/test_sc_rollup_inbox.ml index dd18010523c9603b6cf9c657bd5bd4af4cdd5b43..7f68fba0bfd9b50869ba99ef6692c4626d7c3cc5 100644 --- a/src/proto_alpha/lib_protocol/test/unit/test_sc_rollup_inbox.ml +++ b/src/proto_alpha/lib_protocol/test/unit/test_sc_rollup_inbox.ml @@ -252,8 +252,11 @@ module Node = MakeHashingScheme (Tree) instances having the same encoding, and use this function to convert. *) let node_proof_to_protocol_proof p = - Data_encoding.Binary.( - to_bytes_exn Node.proof_encoding p |> of_bytes_exn proof_encoding) + let open Data_encoding.Binary in + let enc = serialized_proof_encoding in + let bytes = Node.to_serialized_proof p |> to_bytes_exn enc in + of_bytes_exn enc bytes |> of_serialized_proof + |> WithExceptions.Option.get ~loc:__LOC__ (** This is basically identical to {!setup_inbox_with_messages}, except that it uses the {!Node} instance instead of the protocol instance. *) @@ -399,7 +402,9 @@ let test_empty_inbox_proof (level, n) = let* history, history_proof = Node.form_history_proof ctxt history inbox None in - let* result = Node.produce_proof ctxt history history_proof (level, n) in + let* result = + Node.produce_proof ctxt history history_proof (Raw_level_repr.root, n) + in match result with | Ok (proof, input) -> ( (* We now switch to a protocol inbox for verification. *) @@ -408,7 +413,9 @@ let test_empty_inbox_proof (level, n) = let* inbox = empty ctxt rollup level in let snapshot = take_snapshot inbox in let proof = node_proof_to_protocol_proof proof in - let* verification = verify_proof (level, n) snapshot proof in + let* verification = + verify_proof (Raw_level_repr.root, n) snapshot proof + in match verification with | Ok v_input -> fail_unless diff --git a/tezt/lib_tezos/sc_rollup_node.ml b/tezt/lib_tezos/sc_rollup_node.ml index 8cdac867d2079d3415f17520881978c622770c77..6fc4628295b4f2162db6f2dc36c5390491254846 100644 --- a/tezt/lib_tezos/sc_rollup_node.ml +++ b/tezt/lib_tezos/sc_rollup_node.ml @@ -86,27 +86,28 @@ let layer1_port sc_node = Node.rpc_port sc_node.persistent_state.node let spawn_command sc_node = Process.spawn ~name:sc_node.name ~color:sc_node.color sc_node.path -let spawn_config_init sc_node rollup_address = +let spawn_config_init sc_node ?loser_mode rollup_address = spawn_command sc_node - [ - "config"; - "init"; - "on"; - rollup_address; - "with"; - "operator"; - operator_pkh sc_node; - "--data-dir"; - data_dir sc_node; - "--rpc-addr"; - rpc_host sc_node; - "--rpc-port"; - string_of_int @@ rpc_port sc_node; - ] - -let config_init sc_node rollup_address = - let process = spawn_config_init sc_node rollup_address in + ([ + "config"; + "init"; + "on"; + rollup_address; + "with"; + "operator"; + operator_pkh sc_node; + "--data-dir"; + data_dir sc_node; + "--rpc-addr"; + rpc_host sc_node; + "--rpc-port"; + string_of_int @@ rpc_port sc_node; + ] + @ match loser_mode with None -> [] | Some mode -> ["--loser-mode"; mode]) + +let config_init sc_node ?loser_mode rollup_address = + let process = spawn_config_init sc_node ?loser_mode rollup_address in let* output = Process.check_and_read_stdout process in match output diff --git a/tezt/lib_tezos/sc_rollup_node.mli b/tezt/lib_tezos/sc_rollup_node.mli index e837793e420799049eb0d1120bd911445af2f3ad..1a27ab14e55962ef86bcd2f94b23f58398ef1c36 100644 --- a/tezt/lib_tezos/sc_rollup_node.mli +++ b/tezt/lib_tezos/sc_rollup_node.mli @@ -109,9 +109,9 @@ val wait : t -> Unix.process_status Lwt.t a SIGKILL is sent instead of a SIGTERM. *) val terminate : ?kill:bool -> t -> unit Lwt.t -(** Run [tezos-sc-rollup-node-alpha config init rollup_address]. +(** Run [tezos-sc-rollup-node-alpha config init ?loser_mode rollup_address]. Returns the name of the resulting configuration file. *) -val config_init : t -> string -> string Lwt.t +val config_init : t -> ?loser_mode:string -> string -> string Lwt.t module Config_file : sig (** Sc node configuration files. *) 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 a37f6d0161d5bf5cd8c74153d7731024265f0702..164491fbf207b39bcd64daa0d5352a060eeaea21 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 @@ -34,9 +34,9 @@ This sequence of operations was run: { "level": 2, "commitment_hash": "[SC_ROLLUP_COMMITMENT_HASH]" } -./tezos-client --wait none send sc rollup message 'text:["3130202b"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +./tezos-client --wait none send sc rollup message 'text:["10 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' Node is bootstrapped. -Estimated gas: 1651.650 units (will add 100 for safety) +Estimated gas: 1651.582 units (will add 100 for safety) Estimated storage: no bytes added Operation successfully injected in the node. Operation hash is '[OPERATION_HASH]' @@ -47,33 +47,33 @@ and/or an external block explorer to make sure that it has been included. This sequence of operations was run: Manager signed operations: From: [PUBLIC_KEY_HASH] - Fee to the baker: ꜩ0.000457 + Fee to the baker: ꜩ0.000453 Expected counter: 2 Gas limit: 1752 Storage limit: 0 bytes Balance updates: - [PUBLIC_KEY_HASH] ... -ꜩ0.000457 - payload fees(the block proposer) ....... +ꜩ0.000457 + [PUBLIC_KEY_HASH] ... -ꜩ0.000453 + payload fees(the block proposer) ....... +ꜩ0.000453 Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied - Consumed gas: 1651.778 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 3 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 1 - starting_level_of_current_commitment_period = 2 - message_counter = 1 - old_levels_messages = + Consumed gas: 1651.710 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 3 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 1 + starting_level_of_current_commitment_period = 2 + message_counter = 1 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 1 back_pointers = [SC_ROLLUP_INBOX_HASH] - + } ./tezos-sc-rollup-client-alpha rpc get /global/state_hash -"scs11h9A7VAzxxEkEW6ufnfbPnu717o4mc6hagzqvPLhLvHcXyRQVA" +"scs1371W53YVrt8USjs6PafacnNV6ZoFr4VjvyKP9UYszqdg5v4ZC7" ./tezos-client --wait none originate sc rollup from '[PUBLIC_KEY_HASH]' of kind arith of type string booting with 31 --burn-cap 9999999 Node is bootstrapped. @@ -110,9 +110,9 @@ This sequence of operations was run: { "level": 4, "commitment_hash": "[SC_ROLLUP_COMMITMENT_HASH]" } -./tezos-client --wait none send sc rollup message 'text:["3130202b"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +./tezos-client --wait none send sc rollup message 'text:["10 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' Node is bootstrapped. -Estimated gas: 1651.650 units (will add 100 for safety) +Estimated gas: 1651.582 units (will add 100 for safety) Estimated storage: no bytes added Operation successfully injected in the node. Operation hash is '[OPERATION_HASH]' @@ -123,30 +123,30 @@ and/or an external block explorer to make sure that it has been included. This sequence of operations was run: Manager signed operations: From: [PUBLIC_KEY_HASH] - Fee to the baker: ꜩ0.000457 + Fee to the baker: ꜩ0.000453 Expected counter: 4 Gas limit: 1752 Storage limit: 0 bytes Balance updates: - [PUBLIC_KEY_HASH] ... -ꜩ0.000457 - payload fees(the block proposer) ....... +ꜩ0.000457 + [PUBLIC_KEY_HASH] ... -ꜩ0.000453 + payload fees(the block proposer) ....... +ꜩ0.000453 Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied - Consumed gas: 1651.778 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 5 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 1 - starting_level_of_current_commitment_period = 4 - message_counter = 1 - old_levels_messages = + Consumed gas: 1651.710 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 5 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 1 + starting_level_of_current_commitment_period = 4 + message_counter = 1 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 1 back_pointers = [SC_ROLLUP_INBOX_HASH] - + } ./tezos-sc-rollup-client-alpha rpc get /global/state_hash -"scs11zAjtdXYn7FZqG98exo3UKpcF7NcXSDXdGDZX8mvyoeVUNx7U8" +"scs133L8aujCeqJqKx57baw8LMN3CJM6iPTU1tdV72Y171fZpuofKV" diff --git a/tezt/tests/expected/sc_rollup.ml/Alpha- node advances PVM state with internal messages.out b/tezt/tests/expected/sc_rollup.ml/Alpha- node advances PVM state with internal messages.out index d46f9bc613793c6712c16e9ae92d1691c1fe303e..d146e28fad43522580e3bf93a0ea9a001dae150d 100644 --- a/tezt/tests/expected/sc_rollup.ml/Alpha- node advances PVM state with internal messages.out +++ b/tezt/tests/expected/sc_rollup.ml/Alpha- node advances PVM state with internal messages.out @@ -44,142 +44,142 @@ This sequence of operations was run: "\000\000\000\007" ./tezos-sc-rollup-client-alpha rpc get /global/state_hash -"scs139EB5Ny4fma7o6nS9mGauvHFbwpfvsJijBU4tNjEr9QZ8ZJWQd" +"scs12qBnDaws8qffw6QDktoXqyVnQqsB7ZYta9AeumRrJu46uEXa8s" ./tezos-sc-rollup-client-alpha rpc get /global/total_ticks -"19" +"18" ./tezos-sc-rollup-client-alpha rpc get /global/state_hash -"scs139EB5Ny4fma7o6nS9mGauvHFbwpfvsJijBU4tNjEr9QZ8ZJWQd" +"scs12qBnDaws8qffw6QDktoXqyVnQqsB7ZYta9AeumRrJu46uEXa8s" ./tezos-sc-rollup-client-alpha rpc get /global/total_ticks -"19" +"18" ./tezos-sc-rollup-client-alpha get state value for vars/value "\000\000\000\n" ./tezos-sc-rollup-client-alpha rpc get /global/state_hash -"scs12UMx1ykNkh7mGwph7oc47aPAYSZfSdx6E6gqHdNuD3fWoY5z7V" +"scs132JyuMz3CnpXF3jbe2nJdJ4CbLnwGfUdpwRf9H14oKbLGf6gXY" ./tezos-sc-rollup-client-alpha rpc get /global/total_ticks -"37" +"35" ./tezos-sc-rollup-client-alpha rpc get /global/state_hash -"scs12UMx1ykNkh7mGwph7oc47aPAYSZfSdx6E6gqHdNuD3fWoY5z7V" +"scs132JyuMz3CnpXF3jbe2nJdJ4CbLnwGfUdpwRf9H14oKbLGf6gXY" ./tezos-sc-rollup-client-alpha rpc get /global/total_ticks -"37" +"35" ./tezos-sc-rollup-client-alpha get state value for vars/value "\000\000\000\r" ./tezos-sc-rollup-client-alpha rpc get /global/state_hash -"scs12ssnuPLi7HmVNDsZmAn38HQHQ3Yy7M8iqxALseKWEZjhetGdQj" +"scs13LToVZYSTBF7YCWecXYN2PnbPa1YykGn9k4R5His735aYYqFZ9" ./tezos-sc-rollup-client-alpha rpc get /global/total_ticks -"56" +"53" ./tezos-sc-rollup-client-alpha rpc get /global/state_hash -"scs12ssnuPLi7HmVNDsZmAn38HQHQ3Yy7M8iqxALseKWEZjhetGdQj" +"scs13LToVZYSTBF7YCWecXYN2PnbPa1YykGn9k4R5His735aYYqFZ9" ./tezos-sc-rollup-client-alpha rpc get /global/total_ticks -"56" +"53" ./tezos-sc-rollup-client-alpha get state value for vars/value "\000\000\000\016" ./tezos-sc-rollup-client-alpha rpc get /global/state_hash -"scs11bU88Xg7RJhWwcd6xjATkP9KxurEXizBzGm99Y7f1AuwHSwMFr" +"scs13GPvXsed8QkXQ6BdyqaED7ySSNJyAN8J8c318DpKCUwngmemeX" ./tezos-sc-rollup-client-alpha rpc get /global/total_ticks -"75" +"71" ./tezos-sc-rollup-client-alpha rpc get /global/state_hash -"scs11bU88Xg7RJhWwcd6xjATkP9KxurEXizBzGm99Y7f1AuwHSwMFr" +"scs13GPvXsed8QkXQ6BdyqaED7ySSNJyAN8J8c318DpKCUwngmemeX" ./tezos-sc-rollup-client-alpha rpc get /global/total_ticks -"75" +"71" ./tezos-sc-rollup-client-alpha get state value for vars/value "\000\000\000\019" ./tezos-sc-rollup-client-alpha rpc get /global/state_hash -"scs11deEDoFvXGQjSLah1h2N13p1PJTVQNqm1qxaSHUhX9HnZGK3wZ" +"scs11fsCtryeBMasKPzudhJLnMPMHC1amn2HR88wCvnLcmrUxBcJg2" ./tezos-sc-rollup-client-alpha rpc get /global/total_ticks -"94" +"89" ./tezos-sc-rollup-client-alpha rpc get /global/state_hash -"scs11deEDoFvXGQjSLah1h2N13p1PJTVQNqm1qxaSHUhX9HnZGK3wZ" +"scs11fsCtryeBMasKPzudhJLnMPMHC1amn2HR88wCvnLcmrUxBcJg2" ./tezos-sc-rollup-client-alpha rpc get /global/total_ticks -"94" +"89" ./tezos-sc-rollup-client-alpha get state value for vars/value "\000\000\000\022" ./tezos-sc-rollup-client-alpha rpc get /global/state_hash -"scs13DumkywYF7EtycrHEqToSzBFnYBvJeTA2XUZySvttgXzWWP14d" +"scs13PsZc2DSGRhRrdZKHT9wpeLhLrYN5dkD9XZDPu3mYzPd3N8Piu" ./tezos-sc-rollup-client-alpha rpc get /global/total_ticks -"113" +"107" ./tezos-sc-rollup-client-alpha rpc get /global/state_hash -"scs13DumkywYF7EtycrHEqToSzBFnYBvJeTA2XUZySvttgXzWWP14d" +"scs13PsZc2DSGRhRrdZKHT9wpeLhLrYN5dkD9XZDPu3mYzPd3N8Piu" ./tezos-sc-rollup-client-alpha rpc get /global/total_ticks -"113" +"107" ./tezos-sc-rollup-client-alpha get state value for vars/value "\000\000\000\025" ./tezos-sc-rollup-client-alpha rpc get /global/state_hash -"scs13RfGYbA1saxvGJMLCySU3tja9MNaqG4CRiWofbCuFiwNofAFCt" +"scs12CNZfYDyBvihucTXbD3TLou8WQn55Zk1DrRnLPLHw51Umiku8J" ./tezos-sc-rollup-client-alpha rpc get /global/total_ticks -"132" +"125" ./tezos-sc-rollup-client-alpha rpc get /global/state_hash -"scs13RfGYbA1saxvGJMLCySU3tja9MNaqG4CRiWofbCuFiwNofAFCt" +"scs12CNZfYDyBvihucTXbD3TLou8WQn55Zk1DrRnLPLHw51Umiku8J" ./tezos-sc-rollup-client-alpha rpc get /global/total_ticks -"132" +"125" ./tezos-sc-rollup-client-alpha get state value for vars/value "\000\000\000\028" ./tezos-sc-rollup-client-alpha rpc get /global/state_hash -"scs11vJrzpmNeM3aydKLFC8LN2qzEiLPDW1hYUAWb9aFXKyveoZHGM" +"scs137sVeLTakoSaACKmjZ77uisWL7LBFQmG57mDLfwZUp6ZqMtYgS" ./tezos-sc-rollup-client-alpha rpc get /global/total_ticks -"151" +"143" ./tezos-sc-rollup-client-alpha rpc get /global/state_hash -"scs11vJrzpmNeM3aydKLFC8LN2qzEiLPDW1hYUAWb9aFXKyveoZHGM" +"scs137sVeLTakoSaACKmjZ77uisWL7LBFQmG57mDLfwZUp6ZqMtYgS" ./tezos-sc-rollup-client-alpha rpc get /global/total_ticks -"151" +"143" ./tezos-sc-rollup-client-alpha get state value for vars/value "\000\000\000\031" ./tezos-sc-rollup-client-alpha rpc get /global/state_hash -"scs11daEh8MqwPhDawd8n5frMeRhoASh46rnJYNvFz2eSWiVeUfYwS" +"scs11d3KpHobBBVEH5j4xgC3myHPf8sffSvUZWLHVZH7ZcoqGh41A8" ./tezos-sc-rollup-client-alpha rpc get /global/total_ticks -"170" +"161" ./tezos-sc-rollup-client-alpha rpc get /global/state_hash -"scs11daEh8MqwPhDawd8n5frMeRhoASh46rnJYNvFz2eSWiVeUfYwS" +"scs11d3KpHobBBVEH5j4xgC3myHPf8sffSvUZWLHVZH7ZcoqGh41A8" ./tezos-sc-rollup-client-alpha rpc get /global/total_ticks -"170" +"161" ./tezos-sc-rollup-client-alpha get state value for vars/value "\000\000\000\"" ./tezos-sc-rollup-client-alpha rpc get /global/state_hash -"scs12P2MF8NUnH7BrSuRCuSjpBcYpL3ZGJwwm6N3WYkBxvbbwGhdtz" +"scs11ZmqpAH3wWYnySzqDFUPU8KL1nNSb8gBx4sBwkU9f11FWtAK22" ./tezos-sc-rollup-client-alpha rpc get /global/total_ticks -"190" +"180" 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 ccc952ab887d716cb0ba947ca74b503efc70b0e9..1d93df629d528683553e1fc968f1292b75214314 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 @@ -63,35 +63,35 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1651.829 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 3 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 1 - starting_level_of_current_commitment_period = 2 - message_counter = 1 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 3 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 1 + starting_level_of_current_commitment_period = 2 + message_counter = 1 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 1 back_pointers = [SC_ROLLUP_INBOX_HASH] - + } ./tezos-sc-rollup-client-alpha get state value for vars/value "\000\000\000\007" ./tezos-sc-rollup-client-alpha rpc get /global/state_hash -"scs11brdXnUqwwkqChBy8JsHPVzsS3b6YU9i1PpLczV3tCSnjkTYd1" +"scs13CGfXJuhF7NnAKY7v3TBokPphzCEYPE5n14UHDnpTAMTAC7GzC" ./tezos-sc-rollup-client-alpha rpc get /global/total_ticks -"19" +"18" ./tezos-sc-rollup-client-alpha rpc get /global/state_hash -"scs11brdXnUqwwkqChBy8JsHPVzsS3b6YU9i1PpLczV3tCSnjkTYd1" +"scs13CGfXJuhF7NnAKY7v3TBokPphzCEYPE5n14UHDnpTAMTAC7GzC" ./tezos-sc-rollup-client-alpha rpc get /global/total_ticks -"19" +"18" ./tezos-client --wait none send sc rollup message '["2 8 + value"]' from bootstrap1 to '[SC_ROLLUP_HASH]' Node is bootstrapped. @@ -116,36 +116,36 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1652.051 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 4 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 2 - starting_level_of_current_commitment_period = 2 - message_counter = 1 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 4 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 2 + starting_level_of_current_commitment_period = 2 + message_counter = 1 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 2 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + } ./tezos-sc-rollup-client-alpha get state value for vars/value "\000\000\000\n" ./tezos-sc-rollup-client-alpha rpc get /global/state_hash -"scs12Tgfr71PpKXJqDp8yXnohfSYoTT57KeRMEi1YacXtRyyvMxjZ4" +"scs12BVD7ers632i9FZGzaeT4Zt9jQi13guYDh7yb5HFipfVc13wku" ./tezos-sc-rollup-client-alpha rpc get /global/total_ticks -"37" +"35" ./tezos-sc-rollup-client-alpha rpc get /global/state_hash -"scs12Tgfr71PpKXJqDp8yXnohfSYoTT57KeRMEi1YacXtRyyvMxjZ4" +"scs12BVD7ers632i9FZGzaeT4Zt9jQi13guYDh7yb5HFipfVc13wku" ./tezos-sc-rollup-client-alpha rpc get /global/total_ticks -"37" +"35" ./tezos-client --wait none send sc rollup message '["3 10 + value"]' from bootstrap1 to '[SC_ROLLUP_HASH]' Node is bootstrapped. @@ -170,36 +170,36 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1652.147 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 5 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 3 - starting_level_of_current_commitment_period = 2 - message_counter = 1 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 5 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 3 + starting_level_of_current_commitment_period = 2 + message_counter = 1 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 3 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + } ./tezos-sc-rollup-client-alpha get state value for vars/value "\000\000\000\r" ./tezos-sc-rollup-client-alpha rpc get /global/state_hash -"scs13M1yuX6NMTpdqWgYMx1uAtaLpiCgQAgXK2n93iua2LjfGajSiT" +"scs12nXMLncCoT9SGzJX8CwUEG4D1myYhKGYBY6eGvtPrjwqooCovf" ./tezos-sc-rollup-client-alpha rpc get /global/total_ticks -"56" +"53" ./tezos-sc-rollup-client-alpha rpc get /global/state_hash -"scs13M1yuX6NMTpdqWgYMx1uAtaLpiCgQAgXK2n93iua2LjfGajSiT" +"scs12nXMLncCoT9SGzJX8CwUEG4D1myYhKGYBY6eGvtPrjwqooCovf" ./tezos-sc-rollup-client-alpha rpc get /global/total_ticks -"56" +"53" ./tezos-client --wait none send sc rollup message '["4 12 + value"]' from bootstrap1 to '[SC_ROLLUP_HASH]' Node is bootstrapped. @@ -224,37 +224,37 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1652.275 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 6 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 4 - starting_level_of_current_commitment_period = 2 - message_counter = 1 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 6 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 4 + starting_level_of_current_commitment_period = 2 + message_counter = 1 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 4 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-sc-rollup-client-alpha get state value for vars/value "\000\000\000\016" ./tezos-sc-rollup-client-alpha rpc get /global/state_hash -"scs12iwXS6KpaLNTTaBqxFvkyvZpHLq8H5xp35upZ4Tz7Wqtnv68dd" +"scs11tcLMA9CwjW3K3VuAFp4RiJRujh9msGbyMSHyediDMTfchY2JY" ./tezos-sc-rollup-client-alpha rpc get /global/total_ticks -"75" +"71" ./tezos-sc-rollup-client-alpha rpc get /global/state_hash -"scs12iwXS6KpaLNTTaBqxFvkyvZpHLq8H5xp35upZ4Tz7Wqtnv68dd" +"scs11tcLMA9CwjW3K3VuAFp4RiJRujh9msGbyMSHyediDMTfchY2JY" ./tezos-sc-rollup-client-alpha rpc get /global/total_ticks -"75" +"71" ./tezos-client --wait none send sc rollup message '["5 14 + value"]' from bootstrap1 to '[SC_ROLLUP_HASH]' Node is bootstrapped. @@ -279,37 +279,37 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1652.354 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 7 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 5 - starting_level_of_current_commitment_period = 2 - message_counter = 1 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 7 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 5 + starting_level_of_current_commitment_period = 2 + message_counter = 1 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 5 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-sc-rollup-client-alpha get state value for vars/value "\000\000\000\019" ./tezos-sc-rollup-client-alpha rpc get /global/state_hash -"scs12GyR6dnoCQ3T6NCHe7wCEwzs1FSFdMmKPk8hzvPLMWA9po1vHp" +"scs11eYQany2zXFhZ6q62wfrHQA1CYzskBu8k5pnnWnBaAQ3ZEWBK6" ./tezos-sc-rollup-client-alpha rpc get /global/total_ticks -"94" +"89" ./tezos-sc-rollup-client-alpha rpc get /global/state_hash -"scs12GyR6dnoCQ3T6NCHe7wCEwzs1FSFdMmKPk8hzvPLMWA9po1vHp" +"scs11eYQany2zXFhZ6q62wfrHQA1CYzskBu8k5pnnWnBaAQ3ZEWBK6" ./tezos-sc-rollup-client-alpha rpc get /global/total_ticks -"94" +"89" ./tezos-client --wait none send sc rollup message '["6 16 + value"]' from bootstrap1 to '[SC_ROLLUP_HASH]' Node is bootstrapped. @@ -334,37 +334,37 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1652.354 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 8 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 6 - starting_level_of_current_commitment_period = 2 - message_counter = 1 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 8 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 6 + starting_level_of_current_commitment_period = 2 + message_counter = 1 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 6 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-sc-rollup-client-alpha get state value for vars/value "\000\000\000\022" ./tezos-sc-rollup-client-alpha rpc get /global/state_hash -"scs13QvpMutd3qKfBeqBUbk719sF8sG2S3PCwbm3nuVr9kib5KA9Vz" +"scs11ibk6bxp8XcMmHchNkLxniEMGeuu67FYqjeFgsFaK2nSbaj6v6" ./tezos-sc-rollup-client-alpha rpc get /global/total_ticks -"113" +"107" ./tezos-sc-rollup-client-alpha rpc get /global/state_hash -"scs13QvpMutd3qKfBeqBUbk719sF8sG2S3PCwbm3nuVr9kib5KA9Vz" +"scs11ibk6bxp8XcMmHchNkLxniEMGeuu67FYqjeFgsFaK2nSbaj6v6" ./tezos-sc-rollup-client-alpha rpc get /global/total_ticks -"113" +"107" ./tezos-client --wait none send sc rollup message '["7 18 + value"]' from bootstrap1 to '[SC_ROLLUP_HASH]' Node is bootstrapped. @@ -389,37 +389,37 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1652.354 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 9 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 7 - starting_level_of_current_commitment_period = 2 - message_counter = 1 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 9 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 7 + starting_level_of_current_commitment_period = 2 + message_counter = 1 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 7 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-sc-rollup-client-alpha get state value for vars/value "\000\000\000\025" ./tezos-sc-rollup-client-alpha rpc get /global/state_hash -"scs12d3sxy4uVnARXJi4KWs3cz5DrmR73Y9ZVk2DkLRXNio9i9yyX4" +"scs1271ctQaBTEibVsSeGQDQwFHaHUhd8EZ1V35wT87wwNkZRKuod2" ./tezos-sc-rollup-client-alpha rpc get /global/total_ticks -"132" +"125" ./tezos-sc-rollup-client-alpha rpc get /global/state_hash -"scs12d3sxy4uVnARXJi4KWs3cz5DrmR73Y9ZVk2DkLRXNio9i9yyX4" +"scs1271ctQaBTEibVsSeGQDQwFHaHUhd8EZ1V35wT87wwNkZRKuod2" ./tezos-sc-rollup-client-alpha rpc get /global/total_ticks -"132" +"125" ./tezos-client --wait none send sc rollup message '["8 20 + value"]' from bootstrap1 to '[SC_ROLLUP_HASH]' Node is bootstrapped. @@ -444,38 +444,38 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1652.482 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 10 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 8 - starting_level_of_current_commitment_period = 2 - message_counter = 1 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 10 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 8 + starting_level_of_current_commitment_period = 2 + message_counter = 1 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 8 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-sc-rollup-client-alpha get state value for vars/value "\000\000\000\028" ./tezos-sc-rollup-client-alpha rpc get /global/state_hash -"scs13CsbaoCfv3vCgBWtL78hQ3sPaH7iVhmCWqBd5hvCqfQWhxje7D" +"scs12hefiWoaPQGYvPcuUYHhiU5FAAfpBtHcztGqTj6LqB3PxDQiyG" ./tezos-sc-rollup-client-alpha rpc get /global/total_ticks -"151" +"143" ./tezos-sc-rollup-client-alpha rpc get /global/state_hash -"scs13CsbaoCfv3vCgBWtL78hQ3sPaH7iVhmCWqBd5hvCqfQWhxje7D" +"scs12hefiWoaPQGYvPcuUYHhiU5FAAfpBtHcztGqTj6LqB3PxDQiyG" ./tezos-sc-rollup-client-alpha rpc get /global/total_ticks -"151" +"143" ./tezos-client --wait none send sc rollup message '["9 22 + value"]' from bootstrap1 to '[SC_ROLLUP_HASH]' Node is bootstrapped. @@ -500,38 +500,38 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1652.561 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 11 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 9 - starting_level_of_current_commitment_period = 2 - message_counter = 1 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 11 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 9 + starting_level_of_current_commitment_period = 2 + message_counter = 1 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 9 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-sc-rollup-client-alpha get state value for vars/value "\000\000\000\031" ./tezos-sc-rollup-client-alpha rpc get /global/state_hash -"scs12TkBvyg8cSuoNGfrzwM516T9isZwxAphpo7AnxJYVyPGWDwybq" +"scs11oq2aLp31bKWq7Tp3GccxvZHpaE41PzH7FUQNNKWpYSvUn7Fex" ./tezos-sc-rollup-client-alpha rpc get /global/total_ticks -"170" +"161" ./tezos-sc-rollup-client-alpha rpc get /global/state_hash -"scs12TkBvyg8cSuoNGfrzwM516T9isZwxAphpo7AnxJYVyPGWDwybq" +"scs11oq2aLp31bKWq7Tp3GccxvZHpaE41PzH7FUQNNKWpYSvUn7Fex" ./tezos-sc-rollup-client-alpha rpc get /global/total_ticks -"170" +"161" ./tezos-client --wait none send sc rollup message '["10 24 + value"]' from bootstrap1 to '[SC_ROLLUP_HASH]' Node is bootstrapped. @@ -556,29 +556,29 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1652.578 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 12 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 10 - starting_level_of_current_commitment_period = 2 - message_counter = 1 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 12 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 10 + starting_level_of_current_commitment_period = 2 + message_counter = 1 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 10 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-sc-rollup-client-alpha get state value for vars/value "\000\000\000\"" ./tezos-sc-rollup-client-alpha rpc get /global/state_hash -"scs13GcPbRV1mSUravbXkE3LFT2SgEGu2muVHjNzKumLC91MikErA8" +"scs12z8UFkMz6jxQo5hDNhBz96Pjq31V8fSBz3kH3DPgVhpfQFe6Fk" ./tezos-sc-rollup-client-alpha rpc get /global/total_ticks -"190" +"180" 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 615299b81703b496c130071adca90117b5b2a53c..33e170d5978f64bc9e9109b77272fcff93c07d00 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 @@ -57,19 +57,19 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1651.778 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 3 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 1 - starting_level_of_current_commitment_period = 2 - message_counter = 1 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 3 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 1 + starting_level_of_current_commitment_period = 2 + message_counter = 1 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 1 back_pointers = [SC_ROLLUP_INBOX_HASH] - + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -95,20 +95,20 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1652.596 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 4 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 3 - starting_level_of_current_commitment_period = 2 - message_counter = 2 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 4 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 3 + starting_level_of_current_commitment_period = 2 + message_counter = 2 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 2 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -134,20 +134,20 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1653.271 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 5 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 6 - starting_level_of_current_commitment_period = 2 - message_counter = 3 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 5 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 6 + starting_level_of_current_commitment_period = 2 + message_counter = 3 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 3 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -173,21 +173,21 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1653.995 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 6 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 10 - starting_level_of_current_commitment_period = 2 - message_counter = 4 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 6 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 10 + starting_level_of_current_commitment_period = 2 + message_counter = 4 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 4 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -213,21 +213,21 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1654.670 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 7 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 15 - starting_level_of_current_commitment_period = 2 - message_counter = 5 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 7 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 15 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 5 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -253,21 +253,21 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1655.266 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 8 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 21 - starting_level_of_current_commitment_period = 2 - message_counter = 6 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 8 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 21 + starting_level_of_current_commitment_period = 2 + message_counter = 6 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 6 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -293,21 +293,21 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1655.862 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 9 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 28 - starting_level_of_current_commitment_period = 2 - message_counter = 7 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 9 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 28 + starting_level_of_current_commitment_period = 2 + message_counter = 7 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 7 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -333,22 +333,22 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1656.586 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 10 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 36 - starting_level_of_current_commitment_period = 2 - message_counter = 8 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 10 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 36 + starting_level_of_current_commitment_period = 2 + message_counter = 8 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 8 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -374,22 +374,22 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1657.261 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 11 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 45 - starting_level_of_current_commitment_period = 2 - message_counter = 9 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 11 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 45 + starting_level_of_current_commitment_period = 2 + message_counter = 9 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 9 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -415,22 +415,22 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1657.857 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 12 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 55 - starting_level_of_current_commitment_period = 2 - message_counter = 10 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 12 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 55 + starting_level_of_current_commitment_period = 2 + message_counter = 10 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 10 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -456,22 +456,22 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1658.453 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 13 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 66 - starting_level_of_current_commitment_period = 2 - message_counter = 11 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 13 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 66 + starting_level_of_current_commitment_period = 2 + message_counter = 11 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 11 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -497,22 +497,22 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1659.049 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 14 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 78 - starting_level_of_current_commitment_period = 2 - message_counter = 12 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 14 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 78 + starting_level_of_current_commitment_period = 2 + message_counter = 12 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 12 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -538,22 +538,22 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1659.645 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 15 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 91 - starting_level_of_current_commitment_period = 2 - message_counter = 13 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 15 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 91 + starting_level_of_current_commitment_period = 2 + message_counter = 13 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 13 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -579,22 +579,22 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1660.241 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 16 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 105 - starting_level_of_current_commitment_period = 2 - message_counter = 14 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 16 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 105 + starting_level_of_current_commitment_period = 2 + message_counter = 14 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 14 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -620,22 +620,22 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1660.837 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 17 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 120 - starting_level_of_current_commitment_period = 2 - message_counter = 15 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 17 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 120 + starting_level_of_current_commitment_period = 2 + message_counter = 15 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 15 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -661,23 +661,23 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1661.561 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 18 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 136 - starting_level_of_current_commitment_period = 2 - message_counter = 16 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 18 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 136 + starting_level_of_current_commitment_period = 2 + message_counter = 16 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 16 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -703,23 +703,23 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1662.236 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 19 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 153 - starting_level_of_current_commitment_period = 2 - message_counter = 17 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 19 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 153 + starting_level_of_current_commitment_period = 2 + message_counter = 17 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 17 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -745,23 +745,23 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1662.832 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 20 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 171 - starting_level_of_current_commitment_period = 2 - message_counter = 18 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 20 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 171 + starting_level_of_current_commitment_period = 2 + message_counter = 18 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 18 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -787,23 +787,23 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1663.428 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 21 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 190 - starting_level_of_current_commitment_period = 2 - message_counter = 19 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 21 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 190 + starting_level_of_current_commitment_period = 2 + message_counter = 19 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 19 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -829,23 +829,23 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1664.024 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 22 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 210 - starting_level_of_current_commitment_period = 2 - message_counter = 20 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 22 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 210 + starting_level_of_current_commitment_period = 2 + message_counter = 20 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 20 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -871,23 +871,23 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1664.620 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 23 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 231 - starting_level_of_current_commitment_period = 2 - message_counter = 21 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 23 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 231 + starting_level_of_current_commitment_period = 2 + message_counter = 21 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 21 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -913,23 +913,23 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1665.216 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 24 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 253 - starting_level_of_current_commitment_period = 2 - message_counter = 22 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 24 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 253 + starting_level_of_current_commitment_period = 2 + message_counter = 22 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 22 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -955,23 +955,23 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1665.812 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 25 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 276 - starting_level_of_current_commitment_period = 2 - message_counter = 23 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 25 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 276 + starting_level_of_current_commitment_period = 2 + message_counter = 23 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 23 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -997,23 +997,23 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1666.408 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 26 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 300 - starting_level_of_current_commitment_period = 2 - message_counter = 24 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 26 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 300 + starting_level_of_current_commitment_period = 2 + message_counter = 24 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 24 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -1039,23 +1039,23 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1667.004 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 27 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 325 - starting_level_of_current_commitment_period = 2 - message_counter = 25 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 27 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 325 + starting_level_of_current_commitment_period = 2 + message_counter = 25 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 25 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -1081,23 +1081,23 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1667.600 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 28 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 351 - starting_level_of_current_commitment_period = 2 - message_counter = 26 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 28 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 351 + starting_level_of_current_commitment_period = 2 + message_counter = 26 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 26 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -1123,23 +1123,23 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1668.196 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 29 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 378 - starting_level_of_current_commitment_period = 2 - message_counter = 27 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 29 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 378 + starting_level_of_current_commitment_period = 2 + message_counter = 27 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 27 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -1165,23 +1165,23 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1668.792 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 30 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 406 - starting_level_of_current_commitment_period = 2 - message_counter = 28 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 30 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 406 + starting_level_of_current_commitment_period = 2 + message_counter = 28 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 28 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -1207,23 +1207,23 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1669.388 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 31 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 435 - starting_level_of_current_commitment_period = 2 - message_counter = 29 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 31 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 435 + starting_level_of_current_commitment_period = 2 + message_counter = 29 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 29 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -1249,40 +1249,40 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1669.984 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 32 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 30 - starting_level_of_current_commitment_period = 32 - message_counter = 30 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 32 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 30 + starting_level_of_current_commitment_period = 32 + message_counter = 30 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 30 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-sc-rollup-client-alpha rpc get /global/last_stored_commitment { "commitment": { "compressed_state": - "scs123mHW8JnxvBJvMvySAKp99M3Ekvb5ntV5eLQkRJNVexjgXzTK8", + "scs12A4jtbi39DFb3fzb3EBcJGB6hcsUxugy62zf11pQyk1eMMqWjP", "inbox_level": 32, "predecessor": "[SC_ROLLUP_COMMITMENT_HASH]", - "number_of_ticks": 1396 }, + "number_of_ticks": 931 }, "hash": "[SC_ROLLUP_COMMITMENT_HASH]" } ./tezos-sc-rollup-client-alpha rpc get /local/last_published_commitment { "commitment": { "compressed_state": - "scs123mHW8JnxvBJvMvySAKp99M3Ekvb5ntV5eLQkRJNVexjgXzTK8", + "scs12A4jtbi39DFb3fzb3EBcJGB6hcsUxugy62zf11pQyk1eMMqWjP", "inbox_level": 32, "predecessor": "[SC_ROLLUP_COMMITMENT_HASH]", - "number_of_ticks": 1396 }, + "number_of_ticks": 931 }, "hash": "[SC_ROLLUP_COMMITMENT_HASH]", "published_at_level": 35 } diff --git a/tezt/tests/expected/sc_rollup.ml/Alpha- observing the correct handling of commitments in the rollup node (handles.out b/tezt/tests/expected/sc_rollup.ml/Alpha- observing the correct handling of commitments in the rollup node (handles.out index d1a40926cf08d4a8e96a5f797f639c56aeb01cdc..2968b4194bd4e7465db5d70174845f319ff24184 100644 --- a/tezt/tests/expected/sc_rollup.ml/Alpha- observing the correct handling of commitments in the rollup node (handles.out +++ b/tezt/tests/expected/sc_rollup.ml/Alpha- observing the correct handling of commitments in the rollup node (handles.out @@ -57,19 +57,19 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1651.778 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 32 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 1 - starting_level_of_current_commitment_period = 32 - message_counter = 1 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 32 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 1 + starting_level_of_current_commitment_period = 32 + message_counter = 1 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 1 back_pointers = [SC_ROLLUP_INBOX_HASH] - + } ./tezos-sc-rollup-client-alpha rpc get /global/last_stored_commitment 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 453fb0aa902c1790b48dd261868e43d9c09feade..de98cacc0f2f06006b0fb48710620ef6ca69f4f3 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 @@ -57,19 +57,19 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1651.778 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 3 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 1 - starting_level_of_current_commitment_period = 2 - message_counter = 1 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 3 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 1 + starting_level_of_current_commitment_period = 2 + message_counter = 1 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 1 back_pointers = [SC_ROLLUP_INBOX_HASH] - + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -95,20 +95,20 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1652.596 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 4 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 3 - starting_level_of_current_commitment_period = 2 - message_counter = 2 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 4 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 3 + starting_level_of_current_commitment_period = 2 + message_counter = 2 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 2 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -134,20 +134,20 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1653.271 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 5 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 6 - starting_level_of_current_commitment_period = 2 - message_counter = 3 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 5 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 6 + starting_level_of_current_commitment_period = 2 + message_counter = 3 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 3 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -173,21 +173,21 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1653.995 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 6 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 10 - starting_level_of_current_commitment_period = 2 - message_counter = 4 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 6 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 10 + starting_level_of_current_commitment_period = 2 + message_counter = 4 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 4 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -213,21 +213,21 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1654.670 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 7 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 15 - starting_level_of_current_commitment_period = 2 - message_counter = 5 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 7 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 15 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 5 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -253,21 +253,21 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1655.266 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 8 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 21 - starting_level_of_current_commitment_period = 2 - message_counter = 6 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 8 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 21 + starting_level_of_current_commitment_period = 2 + message_counter = 6 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 6 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -293,21 +293,21 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1655.862 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 9 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 28 - starting_level_of_current_commitment_period = 2 - message_counter = 7 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 9 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 28 + starting_level_of_current_commitment_period = 2 + message_counter = 7 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 7 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -333,22 +333,22 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1656.586 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 10 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 36 - starting_level_of_current_commitment_period = 2 - message_counter = 8 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 10 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 36 + starting_level_of_current_commitment_period = 2 + message_counter = 8 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 8 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -374,22 +374,22 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1657.261 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 11 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 45 - starting_level_of_current_commitment_period = 2 - message_counter = 9 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 11 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 45 + starting_level_of_current_commitment_period = 2 + message_counter = 9 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 9 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -415,22 +415,22 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1657.857 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 12 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 55 - starting_level_of_current_commitment_period = 2 - message_counter = 10 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 12 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 55 + starting_level_of_current_commitment_period = 2 + message_counter = 10 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 10 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -456,22 +456,22 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1658.453 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 13 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 66 - starting_level_of_current_commitment_period = 2 - message_counter = 11 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 13 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 66 + starting_level_of_current_commitment_period = 2 + message_counter = 11 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 11 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -497,22 +497,22 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1659.049 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 14 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 78 - starting_level_of_current_commitment_period = 2 - message_counter = 12 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 14 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 78 + starting_level_of_current_commitment_period = 2 + message_counter = 12 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 12 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -538,22 +538,22 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1659.645 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 15 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 91 - starting_level_of_current_commitment_period = 2 - message_counter = 13 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 15 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 91 + starting_level_of_current_commitment_period = 2 + message_counter = 13 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 13 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -579,22 +579,22 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1660.241 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 16 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 105 - starting_level_of_current_commitment_period = 2 - message_counter = 14 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 16 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 105 + starting_level_of_current_commitment_period = 2 + message_counter = 14 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 14 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -620,22 +620,22 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1660.837 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 17 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 120 - starting_level_of_current_commitment_period = 2 - message_counter = 15 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 17 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 120 + starting_level_of_current_commitment_period = 2 + message_counter = 15 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 15 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -661,23 +661,23 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1661.561 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 18 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 136 - starting_level_of_current_commitment_period = 2 - message_counter = 16 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 18 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 136 + starting_level_of_current_commitment_period = 2 + message_counter = 16 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 16 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -703,23 +703,23 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1662.236 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 19 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 153 - starting_level_of_current_commitment_period = 2 - message_counter = 17 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 19 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 153 + starting_level_of_current_commitment_period = 2 + message_counter = 17 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 17 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -745,23 +745,23 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1662.832 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 20 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 171 - starting_level_of_current_commitment_period = 2 - message_counter = 18 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 20 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 171 + starting_level_of_current_commitment_period = 2 + message_counter = 18 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 18 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -787,23 +787,23 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1663.428 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 21 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 190 - starting_level_of_current_commitment_period = 2 - message_counter = 19 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 21 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 190 + starting_level_of_current_commitment_period = 2 + message_counter = 19 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 19 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -829,23 +829,23 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1664.024 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 22 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 210 - starting_level_of_current_commitment_period = 2 - message_counter = 20 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 22 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 210 + starting_level_of_current_commitment_period = 2 + message_counter = 20 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 20 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -871,23 +871,23 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1664.620 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 23 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 231 - starting_level_of_current_commitment_period = 2 - message_counter = 21 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 23 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 231 + starting_level_of_current_commitment_period = 2 + message_counter = 21 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 21 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -913,23 +913,23 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1665.216 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 24 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 253 - starting_level_of_current_commitment_period = 2 - message_counter = 22 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 24 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 253 + starting_level_of_current_commitment_period = 2 + message_counter = 22 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 22 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -955,23 +955,23 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1665.812 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 25 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 276 - starting_level_of_current_commitment_period = 2 - message_counter = 23 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 25 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 276 + starting_level_of_current_commitment_period = 2 + message_counter = 23 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 23 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -997,23 +997,23 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1666.408 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 26 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 300 - starting_level_of_current_commitment_period = 2 - message_counter = 24 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 26 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 300 + starting_level_of_current_commitment_period = 2 + message_counter = 24 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 24 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -1039,23 +1039,23 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1667.004 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 27 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 325 - starting_level_of_current_commitment_period = 2 - message_counter = 25 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 27 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 325 + starting_level_of_current_commitment_period = 2 + message_counter = 25 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 25 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -1081,23 +1081,23 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1667.600 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 28 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 351 - starting_level_of_current_commitment_period = 2 - message_counter = 26 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 28 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 351 + starting_level_of_current_commitment_period = 2 + message_counter = 26 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 26 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -1123,23 +1123,23 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1668.196 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 29 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 378 - starting_level_of_current_commitment_period = 2 - message_counter = 27 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 29 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 378 + starting_level_of_current_commitment_period = 2 + message_counter = 27 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 27 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -1165,23 +1165,23 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1668.792 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 30 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 406 - starting_level_of_current_commitment_period = 2 - message_counter = 28 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 30 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 406 + starting_level_of_current_commitment_period = 2 + message_counter = 28 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 28 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -1207,23 +1207,23 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1669.388 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 31 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 435 - starting_level_of_current_commitment_period = 2 - message_counter = 29 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 31 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 435 + starting_level_of_current_commitment_period = 2 + message_counter = 29 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 29 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -1249,29 +1249,29 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1669.984 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 32 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 30 - starting_level_of_current_commitment_period = 32 - message_counter = 30 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 32 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 30 + starting_level_of_current_commitment_period = 32 + message_counter = 30 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 30 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-sc-rollup-client-alpha rpc get /global/last_stored_commitment { "commitment": { "compressed_state": - "scs123mHW8JnxvBJvMvySAKp99M3Ekvb5ntV5eLQkRJNVexjgXzTK8", + "scs12A4jtbi39DFb3fzb3EBcJGB6hcsUxugy62zf11pQyk1eMMqWjP", "inbox_level": 62, "predecessor": "[SC_ROLLUP_COMMITMENT_HASH]", "number_of_ticks": 0 }, @@ -1280,7 +1280,7 @@ This sequence of operations was run: ./tezos-sc-rollup-client-alpha rpc get /local/last_published_commitment { "commitment": { "compressed_state": - "scs123mHW8JnxvBJvMvySAKp99M3Ekvb5ntV5eLQkRJNVexjgXzTK8", + "scs12A4jtbi39DFb3fzb3EBcJGB6hcsUxugy62zf11pQyk1eMMqWjP", "inbox_level": 62, "predecessor": "[SC_ROLLUP_COMMITMENT_HASH]", "number_of_ticks": 0 }, diff --git a/tezt/tests/expected/sc_rollup.ml/Alpha- observing the correct handling of commitments in the rollup node (node_us.out b/tezt/tests/expected/sc_rollup.ml/Alpha- observing the correct handling of commitments in the rollup node (node_us.out index ee931e29c544fa63254bdd87fb2d63d985e3d676..f28d40e100e99d2fe5fa5ca08559baa99438be50 100644 --- a/tezt/tests/expected/sc_rollup.ml/Alpha- observing the correct handling of commitments in the rollup node (node_us.out +++ b/tezt/tests/expected/sc_rollup.ml/Alpha- observing the correct handling of commitments in the rollup node (node_us.out @@ -57,19 +57,19 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1651.778 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 3 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 1 - starting_level_of_current_commitment_period = 2 - message_counter = 1 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 3 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 1 + starting_level_of_current_commitment_period = 2 + message_counter = 1 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 1 back_pointers = [SC_ROLLUP_INBOX_HASH] - + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -95,20 +95,20 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1652.596 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 4 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 3 - starting_level_of_current_commitment_period = 2 - message_counter = 2 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 4 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 3 + starting_level_of_current_commitment_period = 2 + message_counter = 2 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 2 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -134,20 +134,20 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1653.271 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 5 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 6 - starting_level_of_current_commitment_period = 2 - message_counter = 3 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 5 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 6 + starting_level_of_current_commitment_period = 2 + message_counter = 3 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 3 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -173,21 +173,21 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1653.995 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 6 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 10 - starting_level_of_current_commitment_period = 2 - message_counter = 4 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 6 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 10 + starting_level_of_current_commitment_period = 2 + message_counter = 4 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 4 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -213,21 +213,21 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1654.670 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 7 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 15 - starting_level_of_current_commitment_period = 2 - message_counter = 5 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 7 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 15 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 5 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -253,21 +253,21 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1655.266 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 8 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 21 - starting_level_of_current_commitment_period = 2 - message_counter = 6 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 8 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 21 + starting_level_of_current_commitment_period = 2 + message_counter = 6 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 6 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -293,21 +293,21 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1655.862 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 9 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 28 - starting_level_of_current_commitment_period = 2 - message_counter = 7 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 9 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 28 + starting_level_of_current_commitment_period = 2 + message_counter = 7 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 7 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -333,22 +333,22 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1656.586 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 10 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 36 - starting_level_of_current_commitment_period = 2 - message_counter = 8 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 10 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 36 + starting_level_of_current_commitment_period = 2 + message_counter = 8 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 8 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -374,22 +374,22 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1657.261 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 11 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 45 - starting_level_of_current_commitment_period = 2 - message_counter = 9 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 11 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 45 + starting_level_of_current_commitment_period = 2 + message_counter = 9 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 9 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -415,22 +415,22 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1657.857 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 12 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 55 - starting_level_of_current_commitment_period = 2 - message_counter = 10 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 12 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 55 + starting_level_of_current_commitment_period = 2 + message_counter = 10 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 10 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -456,22 +456,22 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1658.453 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 13 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 66 - starting_level_of_current_commitment_period = 2 - message_counter = 11 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 13 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 66 + starting_level_of_current_commitment_period = 2 + message_counter = 11 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 11 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -497,22 +497,22 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1659.049 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 14 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 78 - starting_level_of_current_commitment_period = 2 - message_counter = 12 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 14 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 78 + starting_level_of_current_commitment_period = 2 + message_counter = 12 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 12 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -538,22 +538,22 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1659.645 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 15 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 91 - starting_level_of_current_commitment_period = 2 - message_counter = 13 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 15 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 91 + starting_level_of_current_commitment_period = 2 + message_counter = 13 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 13 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -579,22 +579,22 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1660.241 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 16 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 105 - starting_level_of_current_commitment_period = 2 - message_counter = 14 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 16 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 105 + starting_level_of_current_commitment_period = 2 + message_counter = 14 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 14 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -620,39 +620,39 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1660.837 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 17 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 15 - starting_level_of_current_commitment_period = 17 - message_counter = 15 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 17 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 15 + starting_level_of_current_commitment_period = 17 + message_counter = 15 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 15 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-sc-rollup-client-alpha rpc get /global/last_stored_commitment { "commitment": { "compressed_state": - "scs12wTPaomFH2grjoXSuBwnVppABH3RvbaghhnskeG6GYpbEbZ3fg", + "scs128vEZa7hXxUCcuBtKqdMfTCGejmEe5aoxLBS6csdWApTULy4TY", "inbox_level": 17, "predecessor": "[SC_ROLLUP_COMMITMENT_HASH]", - "number_of_ticks": 361 }, + "number_of_ticks": 241 }, "hash": "[SC_ROLLUP_COMMITMENT_HASH]" } ./tezos-sc-rollup-client-alpha rpc get /local/last_published_commitment { "commitment": { "compressed_state": - "scs12wTPaomFH2grjoXSuBwnVppABH3RvbaghhnskeG6GYpbEbZ3fg", + "scs128vEZa7hXxUCcuBtKqdMfTCGejmEe5aoxLBS6csdWApTULy4TY", "inbox_level": 17, "predecessor": "[SC_ROLLUP_COMMITMENT_HASH]", - "number_of_ticks": 361 }, + "number_of_ticks": 241 }, "hash": "[SC_ROLLUP_COMMITMENT_HASH]", "published_at_level": 20 } diff --git a/tezt/tests/expected/sc_rollup.ml/Alpha- observing the correct handling of commitments in the rollup node (non_fin.out b/tezt/tests/expected/sc_rollup.ml/Alpha- observing the correct handling of commitments in the rollup node (non_fin.out index 2b455715acab2f8f459c8b7a16af9ab2936d9a29..0a4860b1b9edda1b9b2928c07a2ce62008087476 100644 --- a/tezt/tests/expected/sc_rollup.ml/Alpha- observing the correct handling of commitments in the rollup node (non_fin.out +++ b/tezt/tests/expected/sc_rollup.ml/Alpha- observing the correct handling of commitments in the rollup node (non_fin.out @@ -57,19 +57,19 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1651.778 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 3 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 1 - starting_level_of_current_commitment_period = 2 - message_counter = 1 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 3 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 1 + starting_level_of_current_commitment_period = 2 + message_counter = 1 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 1 back_pointers = [SC_ROLLUP_INBOX_HASH] - + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -95,20 +95,20 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1652.596 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 4 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 3 - starting_level_of_current_commitment_period = 2 - message_counter = 2 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 4 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 3 + starting_level_of_current_commitment_period = 2 + message_counter = 2 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 2 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -134,20 +134,20 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1653.271 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 5 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 6 - starting_level_of_current_commitment_period = 2 - message_counter = 3 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 5 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 6 + starting_level_of_current_commitment_period = 2 + message_counter = 3 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 3 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -173,21 +173,21 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1653.995 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 6 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 10 - starting_level_of_current_commitment_period = 2 - message_counter = 4 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 6 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 10 + starting_level_of_current_commitment_period = 2 + message_counter = 4 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 4 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -213,21 +213,21 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1654.670 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 7 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 15 - starting_level_of_current_commitment_period = 2 - message_counter = 5 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 7 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 15 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 5 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -253,21 +253,21 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1655.266 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 8 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 21 - starting_level_of_current_commitment_period = 2 - message_counter = 6 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 8 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 21 + starting_level_of_current_commitment_period = 2 + message_counter = 6 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 6 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -293,21 +293,21 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1655.862 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 9 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 28 - starting_level_of_current_commitment_period = 2 - message_counter = 7 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 9 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 28 + starting_level_of_current_commitment_period = 2 + message_counter = 7 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 7 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -333,22 +333,22 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1656.586 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 10 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 36 - starting_level_of_current_commitment_period = 2 - message_counter = 8 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 10 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 36 + starting_level_of_current_commitment_period = 2 + message_counter = 8 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 8 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -374,22 +374,22 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1657.261 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 11 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 45 - starting_level_of_current_commitment_period = 2 - message_counter = 9 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 11 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 45 + starting_level_of_current_commitment_period = 2 + message_counter = 9 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 9 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -415,22 +415,22 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1657.857 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 12 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 55 - starting_level_of_current_commitment_period = 2 - message_counter = 10 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 12 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 55 + starting_level_of_current_commitment_period = 2 + message_counter = 10 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 10 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -456,22 +456,22 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1658.453 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 13 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 66 - starting_level_of_current_commitment_period = 2 - message_counter = 11 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 13 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 66 + starting_level_of_current_commitment_period = 2 + message_counter = 11 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 11 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -497,22 +497,22 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1659.049 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 14 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 78 - starting_level_of_current_commitment_period = 2 - message_counter = 12 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 14 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 78 + starting_level_of_current_commitment_period = 2 + message_counter = 12 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 12 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -538,22 +538,22 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1659.645 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 15 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 91 - starting_level_of_current_commitment_period = 2 - message_counter = 13 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 15 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 91 + starting_level_of_current_commitment_period = 2 + message_counter = 13 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 13 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -579,22 +579,22 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1660.241 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 16 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 105 - starting_level_of_current_commitment_period = 2 - message_counter = 14 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 16 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 105 + starting_level_of_current_commitment_period = 2 + message_counter = 14 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 14 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -620,22 +620,22 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1660.837 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 17 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 120 - starting_level_of_current_commitment_period = 2 - message_counter = 15 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 17 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 120 + starting_level_of_current_commitment_period = 2 + message_counter = 15 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 15 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -661,23 +661,23 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1661.561 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 18 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 136 - starting_level_of_current_commitment_period = 2 - message_counter = 16 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 18 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 136 + starting_level_of_current_commitment_period = 2 + message_counter = 16 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 16 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -703,23 +703,23 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1662.236 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 19 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 153 - starting_level_of_current_commitment_period = 2 - message_counter = 17 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 19 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 153 + starting_level_of_current_commitment_period = 2 + message_counter = 17 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 17 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -745,23 +745,23 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1662.832 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 20 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 171 - starting_level_of_current_commitment_period = 2 - message_counter = 18 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 20 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 171 + starting_level_of_current_commitment_period = 2 + message_counter = 18 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 18 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -787,23 +787,23 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1663.428 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 21 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 190 - starting_level_of_current_commitment_period = 2 - message_counter = 19 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 21 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 190 + starting_level_of_current_commitment_period = 2 + message_counter = 19 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 19 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -829,23 +829,23 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1664.024 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 22 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 210 - starting_level_of_current_commitment_period = 2 - message_counter = 20 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 22 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 210 + starting_level_of_current_commitment_period = 2 + message_counter = 20 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 20 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -871,23 +871,23 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1664.620 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 23 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 231 - starting_level_of_current_commitment_period = 2 - message_counter = 21 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 23 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 231 + starting_level_of_current_commitment_period = 2 + message_counter = 21 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 21 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -913,23 +913,23 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1665.216 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 24 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 253 - starting_level_of_current_commitment_period = 2 - message_counter = 22 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 24 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 253 + starting_level_of_current_commitment_period = 2 + message_counter = 22 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 22 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -955,23 +955,23 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1665.812 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 25 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 276 - starting_level_of_current_commitment_period = 2 - message_counter = 23 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 25 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 276 + starting_level_of_current_commitment_period = 2 + message_counter = 23 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 23 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -997,23 +997,23 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1666.408 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 26 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 300 - starting_level_of_current_commitment_period = 2 - message_counter = 24 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 26 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 300 + starting_level_of_current_commitment_period = 2 + message_counter = 24 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 24 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -1039,23 +1039,23 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1667.004 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 27 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 325 - starting_level_of_current_commitment_period = 2 - message_counter = 25 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 27 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 325 + starting_level_of_current_commitment_period = 2 + message_counter = 25 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 25 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -1081,23 +1081,23 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1667.600 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 28 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 351 - starting_level_of_current_commitment_period = 2 - message_counter = 26 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 28 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 351 + starting_level_of_current_commitment_period = 2 + message_counter = 26 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 26 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -1123,23 +1123,23 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1668.196 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 29 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 378 - starting_level_of_current_commitment_period = 2 - message_counter = 27 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 29 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 378 + starting_level_of_current_commitment_period = 2 + message_counter = 27 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 27 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -1165,23 +1165,23 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1668.792 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 30 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 406 - starting_level_of_current_commitment_period = 2 - message_counter = 28 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 30 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 406 + starting_level_of_current_commitment_period = 2 + message_counter = 28 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 28 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -1207,23 +1207,23 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1669.388 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 31 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 435 - starting_level_of_current_commitment_period = 2 - message_counter = 29 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 31 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 435 + starting_level_of_current_commitment_period = 2 + message_counter = 29 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 29 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -1249,23 +1249,23 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1669.984 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 32 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 30 - starting_level_of_current_commitment_period = 32 - message_counter = 30 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 32 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 30 + starting_level_of_current_commitment_period = 32 + message_counter = 30 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 30 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-sc-rollup-client-alpha rpc get /global/last_stored_commitment diff --git a/tezt/tests/expected/sc_rollup.ml/Alpha- observing the correct maintenance of inbox in the rollup node (basic).out b/tezt/tests/expected/sc_rollup.ml/Alpha- observing the correct maintenance of inbox in the rollup node (basic).out index 1acecb5ff894d28933f334a4d3b2f8737b767a7d..4e74fad0ace4115a757c6a41af26bb3350a868f5 100644 --- a/tezt/tests/expected/sc_rollup.ml/Alpha- observing the correct maintenance of inbox in the rollup node (basic).out +++ b/tezt/tests/expected/sc_rollup.ml/Alpha- observing the correct maintenance of inbox in the rollup node (basic).out @@ -53,19 +53,19 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1651.778 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 3 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 1 - starting_level_of_current_commitment_period = 2 - message_counter = 1 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 3 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 1 + starting_level_of_current_commitment_period = 2 + message_counter = 1 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 1 back_pointers = [SC_ROLLUP_INBOX_HASH] - + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -91,18 +91,18 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1652.596 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 4 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 3 - starting_level_of_current_commitment_period = 2 - message_counter = 2 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 4 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 3 + starting_level_of_current_commitment_period = 2 + message_counter = 2 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 2 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + } diff --git a/tezt/tests/expected/sc_rollup.ml/Alpha- observing the correct maintenance of inbox in the rollup node (handles_ch.out b/tezt/tests/expected/sc_rollup.ml/Alpha- observing the correct maintenance of inbox in the rollup node (handles_ch.out index 4002e11a37aedfa14fa19556188ae110e728c251..17cddea3e292b85d211053da341c85732cb8be49 100644 --- a/tezt/tests/expected/sc_rollup.ml/Alpha- observing the correct maintenance of inbox in the rollup node (handles_ch.out +++ b/tezt/tests/expected/sc_rollup.ml/Alpha- observing the correct maintenance of inbox in the rollup node (handles_ch.out @@ -53,19 +53,19 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1651.778 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 3 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 1 - starting_level_of_current_commitment_period = 2 - message_counter = 1 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 3 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 1 + starting_level_of_current_commitment_period = 2 + message_counter = 1 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 1 back_pointers = [SC_ROLLUP_INBOX_HASH] - + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -91,20 +91,20 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1652 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 4 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 2 - starting_level_of_current_commitment_period = 2 - message_counter = 1 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 4 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 2 + starting_level_of_current_commitment_period = 2 + message_counter = 1 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 2 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -130,20 +130,20 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1652 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 4 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 2 - starting_level_of_current_commitment_period = 2 - message_counter = 1 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 4 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 2 + starting_level_of_current_commitment_period = 2 + message_counter = 1 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 2 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -169,18 +169,18 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1652.079 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 5 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 3 - starting_level_of_current_commitment_period = 2 - message_counter = 1 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 5 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 3 + starting_level_of_current_commitment_period = 2 + message_counter = 1 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 3 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + } diff --git a/tezt/tests/expected/sc_rollup.ml/Alpha- observing the correct maintenance of inbox in the rollup node (stops).out b/tezt/tests/expected/sc_rollup.ml/Alpha- observing the correct maintenance of inbox in the rollup node (stops).out index 9f78bf45a120bed49aa8e40d194099dbc8c4ce02..70aee086aca7a93fbd7085464edc7c7921449762 100644 --- a/tezt/tests/expected/sc_rollup.ml/Alpha- observing the correct maintenance of inbox in the rollup node (stops).out +++ b/tezt/tests/expected/sc_rollup.ml/Alpha- observing the correct maintenance of inbox in the rollup node (stops).out @@ -53,19 +53,19 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1651.778 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 3 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 1 - starting_level_of_current_commitment_period = 2 - message_counter = 1 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 3 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 1 + starting_level_of_current_commitment_period = 2 + message_counter = 1 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 1 back_pointers = [SC_ROLLUP_INBOX_HASH] - + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -91,20 +91,20 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1652.596 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 4 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 3 - starting_level_of_current_commitment_period = 2 - message_counter = 2 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 4 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 3 + starting_level_of_current_commitment_period = 2 + message_counter = 2 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 2 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -130,20 +130,20 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1652.079 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 5 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 4 - starting_level_of_current_commitment_period = 2 - message_counter = 1 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 5 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 4 + starting_level_of_current_commitment_period = 2 + message_counter = 1 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 3 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -169,19 +169,19 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1652.803 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 6 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 6 - starting_level_of_current_commitment_period = 2 - message_counter = 2 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 6 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 6 + starting_level_of_current_commitment_period = 2 + message_counter = 2 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 4 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } diff --git a/tezt/tests/expected/sc_rollup.ml/Alpha- observing the winning strategy of refutation games (inbox_proof).out b/tezt/tests/expected/sc_rollup.ml/Alpha- observing the winning strategy of refutation games (inbox_proof).out new file mode 100644 index 0000000000000000000000000000000000000000..d6454802cfe89f66403d06f96d364c25c6f749c9 --- /dev/null +++ b/tezt/tests/expected/sc_rollup.ml/Alpha- observing the winning strategy of refutation games (inbox_proof).out @@ -0,0 +1,430 @@ + +./tezos-client --wait none originate sc rollup from '[PUBLIC_KEY_HASH]' of kind arith of type string booting with --burn-cap 9999999 +Node is bootstrapped. +Estimated gas: 2909.116 units (will add 100 for safety) +Estimated storage: 6616 bytes added (will add 20 for safety) +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000654 + Expected counter: 1 + Gas limit: 3010 + Storage limit: 6636 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000654 + payload fees(the block proposer) ....... +ꜩ0.000654 + Originate smart contract rollup of kind arith and type string with boot sector '' + This smart contract rollup origination was successfully applied + Consumed gas: 2909.116 + Storage size: 6616 bytes + Address: [SC_ROLLUP_HASH] + Genesis commitment hash: [SC_ROLLUP_COMMITMENT_HASH] + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ1.654 + storage fees ........................... +ꜩ1.654 + + +./tezos-client --wait none send sc rollup message 'text:["3 3 +","1","1 1 x","3 7 8 + * y","2 2 out"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1653.847 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 2 + Gas limit: 1754 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1653.975 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 3 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 5 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 1 + back_pointers = [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","3 3 +","1 1 x","3 7 8 + * y","2 2 out"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.197 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 3 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.197 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 5 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 10 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 2 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 3 +","3 7 8 + * y","2 2 out"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.276 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 4 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.276 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 7 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 15 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 3 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","3 3 +","2 2 out"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.419 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 5 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.419 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 9 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 20 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 4 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.483 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 6 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.483 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 11 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 25 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 5 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.498 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 7 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.498 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 13 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 30 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 6 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.498 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 8 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.498 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 15 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 35 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 7 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.626 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 9 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.626 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 17 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 40 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 8 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.690 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 10 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.690 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 19 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 45 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 9 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.705 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 11 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.705 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 21 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 50 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 10 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + diff --git a/tezt/tests/expected/sc_rollup.ml/Alpha- observing the winning strategy of refutation games (inbox_proof_at_genesi.out b/tezt/tests/expected/sc_rollup.ml/Alpha- observing the winning strategy of refutation games (inbox_proof_at_genesi.out new file mode 100644 index 0000000000000000000000000000000000000000..d6454802cfe89f66403d06f96d364c25c6f749c9 --- /dev/null +++ b/tezt/tests/expected/sc_rollup.ml/Alpha- observing the winning strategy of refutation games (inbox_proof_at_genesi.out @@ -0,0 +1,430 @@ + +./tezos-client --wait none originate sc rollup from '[PUBLIC_KEY_HASH]' of kind arith of type string booting with --burn-cap 9999999 +Node is bootstrapped. +Estimated gas: 2909.116 units (will add 100 for safety) +Estimated storage: 6616 bytes added (will add 20 for safety) +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000654 + Expected counter: 1 + Gas limit: 3010 + Storage limit: 6636 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000654 + payload fees(the block proposer) ....... +ꜩ0.000654 + Originate smart contract rollup of kind arith and type string with boot sector '' + This smart contract rollup origination was successfully applied + Consumed gas: 2909.116 + Storage size: 6616 bytes + Address: [SC_ROLLUP_HASH] + Genesis commitment hash: [SC_ROLLUP_COMMITMENT_HASH] + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ1.654 + storage fees ........................... +ꜩ1.654 + + +./tezos-client --wait none send sc rollup message 'text:["3 3 +","1","1 1 x","3 7 8 + * y","2 2 out"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1653.847 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 2 + Gas limit: 1754 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1653.975 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 3 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 5 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 1 + back_pointers = [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","3 3 +","1 1 x","3 7 8 + * y","2 2 out"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.197 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 3 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.197 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 5 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 10 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 2 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 3 +","3 7 8 + * y","2 2 out"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.276 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 4 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.276 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 7 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 15 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 3 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","3 3 +","2 2 out"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.419 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 5 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.419 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 9 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 20 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 4 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.483 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 6 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.483 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 11 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 25 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 5 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.498 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 7 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.498 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 13 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 30 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 6 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.498 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 8 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.498 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 15 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 35 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 7 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.626 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 9 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.626 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 17 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 40 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 8 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.690 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 10 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.690 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 19 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 45 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 9 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.705 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 11 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.705 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 21 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 50 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 10 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + diff --git a/tezt/tests/expected/sc_rollup.ml/Alpha- observing the winning strategy of refutation games (inbox_proof_many_empt.out b/tezt/tests/expected/sc_rollup.ml/Alpha- observing the winning strategy of refutation games (inbox_proof_many_empt.out new file mode 100644 index 0000000000000000000000000000000000000000..484e84b4584cbd8b4155c6b4440a3e11a9b6610d --- /dev/null +++ b/tezt/tests/expected/sc_rollup.ml/Alpha- observing the winning strategy of refutation games (inbox_proof_many_empt.out @@ -0,0 +1,430 @@ + +./tezos-client --wait none originate sc rollup from '[PUBLIC_KEY_HASH]' of kind arith of type string booting with --burn-cap 9999999 +Node is bootstrapped. +Estimated gas: 2909.116 units (will add 100 for safety) +Estimated storage: 6616 bytes added (will add 20 for safety) +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000654 + Expected counter: 1 + Gas limit: 3010 + Storage limit: 6636 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000654 + payload fees(the block proposer) ....... +ꜩ0.000654 + Originate smart contract rollup of kind arith and type string with boot sector '' + This smart contract rollup origination was successfully applied + Consumed gas: 2909.116 + Storage size: 6616 bytes + Address: [SC_ROLLUP_HASH] + Genesis commitment hash: [SC_ROLLUP_COMMITMENT_HASH] + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ1.654 + storage fees ........................... +ꜩ1.654 + + +./tezos-client --wait none send sc rollup message 'text:["3 3 +","1","1 1 x","3 7 8 + * y","2 2 out"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1653.975 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 2 + Gas limit: 1754 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1653.975 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 6 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 5 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 1 + back_pointers = [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","3 3 +","1 1 x","3 7 8 + * y","2 2 out"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.227 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 3 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.227 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 8 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 10 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 2 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 3 +","3 7 8 + * y","2 2 out"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.291 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 4 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.291 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 10 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 15 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 3 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","3 3 +","2 2 out"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.434 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 5 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.434 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 12 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 20 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 4 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.498 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 6 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.498 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 14 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 25 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 5 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.498 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 7 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.498 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 16 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 30 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 6 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.498 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 8 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.498 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 18 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 35 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 7 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.641 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 9 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.641 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 20 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 40 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 8 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.705 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 10 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.705 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 22 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 45 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 9 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.705 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 11 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.705 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 24 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 50 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 10 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + diff --git a/tezt/tests/expected/sc_rollup.ml/Alpha- observing the winning strategy of refutation games (inbox_proof_one_empty.out b/tezt/tests/expected/sc_rollup.ml/Alpha- observing the winning strategy of refutation games (inbox_proof_one_empty.out new file mode 100644 index 0000000000000000000000000000000000000000..bc721adc30122e10bebd517842e3cc68855a22c2 --- /dev/null +++ b/tezt/tests/expected/sc_rollup.ml/Alpha- observing the winning strategy of refutation games (inbox_proof_one_empty.out @@ -0,0 +1,430 @@ + +./tezos-client --wait none originate sc rollup from '[PUBLIC_KEY_HASH]' of kind arith of type string booting with --burn-cap 9999999 +Node is bootstrapped. +Estimated gas: 2909.116 units (will add 100 for safety) +Estimated storage: 6616 bytes added (will add 20 for safety) +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000654 + Expected counter: 1 + Gas limit: 3010 + Storage limit: 6636 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000654 + payload fees(the block proposer) ....... +ꜩ0.000654 + Originate smart contract rollup of kind arith and type string with boot sector '' + This smart contract rollup origination was successfully applied + Consumed gas: 2909.116 + Storage size: 6616 bytes + Address: [SC_ROLLUP_HASH] + Genesis commitment hash: [SC_ROLLUP_COMMITMENT_HASH] + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ1.654 + storage fees ........................... +ꜩ1.654 + + +./tezos-client --wait none send sc rollup message 'text:["3 3 +","1","1 1 x","3 7 8 + * y","2 2 out"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1653.975 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 2 + Gas limit: 1754 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1653.975 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 4 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 5 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 1 + back_pointers = [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","3 3 +","1 1 x","3 7 8 + * y","2 2 out"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.212 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 3 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.212 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 6 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 10 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 2 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 3 +","3 7 8 + * y","2 2 out"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.291 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 4 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.291 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 8 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 15 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 3 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","3 3 +","2 2 out"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.419 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 5 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.419 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 10 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 20 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 4 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.498 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 6 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.498 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 12 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 25 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 5 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.498 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 7 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.498 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 14 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 30 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 6 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.498 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 8 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.498 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 16 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 35 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 7 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.626 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 9 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.626 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 18 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 40 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 8 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.705 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 10 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.705 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 20 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 45 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 9 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.705 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 11 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.705 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 22 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 50 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 10 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + diff --git a/tezt/tests/expected/sc_rollup.ml/Alpha- observing the winning strategy of refutation games (pvm_proof_0).out b/tezt/tests/expected/sc_rollup.ml/Alpha- observing the winning strategy of refutation games (pvm_proof_0).out new file mode 100644 index 0000000000000000000000000000000000000000..d6454802cfe89f66403d06f96d364c25c6f749c9 --- /dev/null +++ b/tezt/tests/expected/sc_rollup.ml/Alpha- observing the winning strategy of refutation games (pvm_proof_0).out @@ -0,0 +1,430 @@ + +./tezos-client --wait none originate sc rollup from '[PUBLIC_KEY_HASH]' of kind arith of type string booting with --burn-cap 9999999 +Node is bootstrapped. +Estimated gas: 2909.116 units (will add 100 for safety) +Estimated storage: 6616 bytes added (will add 20 for safety) +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000654 + Expected counter: 1 + Gas limit: 3010 + Storage limit: 6636 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000654 + payload fees(the block proposer) ....... +ꜩ0.000654 + Originate smart contract rollup of kind arith and type string with boot sector '' + This smart contract rollup origination was successfully applied + Consumed gas: 2909.116 + Storage size: 6616 bytes + Address: [SC_ROLLUP_HASH] + Genesis commitment hash: [SC_ROLLUP_COMMITMENT_HASH] + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ1.654 + storage fees ........................... +ꜩ1.654 + + +./tezos-client --wait none send sc rollup message 'text:["3 3 +","1","1 1 x","3 7 8 + * y","2 2 out"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1653.847 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 2 + Gas limit: 1754 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1653.975 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 3 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 5 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 1 + back_pointers = [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","3 3 +","1 1 x","3 7 8 + * y","2 2 out"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.197 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 3 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.197 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 5 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 10 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 2 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 3 +","3 7 8 + * y","2 2 out"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.276 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 4 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.276 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 7 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 15 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 3 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","3 3 +","2 2 out"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.419 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 5 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.419 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 9 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 20 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 4 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.483 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 6 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.483 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 11 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 25 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 5 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.498 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 7 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.498 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 13 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 30 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 6 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.498 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 8 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.498 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 15 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 35 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 7 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.626 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 9 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.626 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 17 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 40 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 8 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.690 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 10 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.690 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 19 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 45 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 9 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.705 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 11 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.705 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 21 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 50 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 10 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + diff --git a/tezt/tests/expected/sc_rollup.ml/Alpha- observing the winning strategy of refutation games (pvm_proof_1).out b/tezt/tests/expected/sc_rollup.ml/Alpha- observing the winning strategy of refutation games (pvm_proof_1).out new file mode 100644 index 0000000000000000000000000000000000000000..d6454802cfe89f66403d06f96d364c25c6f749c9 --- /dev/null +++ b/tezt/tests/expected/sc_rollup.ml/Alpha- observing the winning strategy of refutation games (pvm_proof_1).out @@ -0,0 +1,430 @@ + +./tezos-client --wait none originate sc rollup from '[PUBLIC_KEY_HASH]' of kind arith of type string booting with --burn-cap 9999999 +Node is bootstrapped. +Estimated gas: 2909.116 units (will add 100 for safety) +Estimated storage: 6616 bytes added (will add 20 for safety) +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000654 + Expected counter: 1 + Gas limit: 3010 + Storage limit: 6636 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000654 + payload fees(the block proposer) ....... +ꜩ0.000654 + Originate smart contract rollup of kind arith and type string with boot sector '' + This smart contract rollup origination was successfully applied + Consumed gas: 2909.116 + Storage size: 6616 bytes + Address: [SC_ROLLUP_HASH] + Genesis commitment hash: [SC_ROLLUP_COMMITMENT_HASH] + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ1.654 + storage fees ........................... +ꜩ1.654 + + +./tezos-client --wait none send sc rollup message 'text:["3 3 +","1","1 1 x","3 7 8 + * y","2 2 out"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1653.847 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 2 + Gas limit: 1754 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1653.975 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 3 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 5 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 1 + back_pointers = [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","3 3 +","1 1 x","3 7 8 + * y","2 2 out"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.197 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 3 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.197 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 5 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 10 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 2 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 3 +","3 7 8 + * y","2 2 out"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.276 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 4 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.276 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 7 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 15 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 3 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","3 3 +","2 2 out"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.419 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 5 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.419 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 9 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 20 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 4 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.483 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 6 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.483 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 11 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 25 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 5 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.498 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 7 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.498 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 13 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 30 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 6 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.498 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 8 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.498 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 15 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 35 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 7 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.626 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 9 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.626 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 17 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 40 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 8 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.690 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 10 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.690 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 19 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 45 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 9 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.705 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 11 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.705 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 21 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 50 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 10 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + diff --git a/tezt/tests/expected/sc_rollup.ml/Alpha- observing the winning strategy of refutation games (pvm_proof_2).out b/tezt/tests/expected/sc_rollup.ml/Alpha- observing the winning strategy of refutation games (pvm_proof_2).out new file mode 100644 index 0000000000000000000000000000000000000000..1156e11398d29bfbed06f597503e34e7091c2b6f --- /dev/null +++ b/tezt/tests/expected/sc_rollup.ml/Alpha- observing the winning strategy of refutation games (pvm_proof_2).out @@ -0,0 +1,307 @@ + +./tezos-client --wait none originate sc rollup from '[PUBLIC_KEY_HASH]' of kind arith of type string booting with --burn-cap 9999999 +Node is bootstrapped. +Estimated gas: 2909.116 units (will add 100 for safety) +Estimated storage: 6616 bytes added (will add 20 for safety) +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000654 + Expected counter: 1 + Gas limit: 3010 + Storage limit: 6636 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000654 + payload fees(the block proposer) ....... +ꜩ0.000654 + Originate smart contract rollup of kind arith and type string with boot sector '' + This smart contract rollup origination was successfully applied + Consumed gas: 2909.116 + Storage size: 6616 bytes + Address: [SC_ROLLUP_HASH] + Genesis commitment hash: [SC_ROLLUP_COMMITMENT_HASH] + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ1.654 + storage fees ........................... +ꜩ1.654 + + +./tezos-client --wait none send sc rollup message 'text:["3 3 +","1","1 1 x","3 7 8 + * y","2 2 out"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1653.847 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 2 + Gas limit: 1754 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1653.975 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 3 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 5 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 1 + back_pointers = [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","3 3 +","1 1 x","3 7 8 + * y","2 2 out"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.197 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 3 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.197 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 5 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 10 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 2 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 3 +","3 7 8 + * y","2 2 out"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.276 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 4 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.276 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 7 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 15 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 3 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","3 3 +","2 2 out"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.419 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 5 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.419 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 9 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 20 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 4 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.483 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 6 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.483 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 11 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 25 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 5 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.498 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 7 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.498 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 13 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 30 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 6 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.498 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 8 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.498 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 15 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 35 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 7 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + diff --git a/tezt/tests/expected/sc_rollup.ml/Alpha- observing the winning strategy of refutation games (pvm_proof_3).out b/tezt/tests/expected/sc_rollup.ml/Alpha- observing the winning strategy of refutation games (pvm_proof_3).out new file mode 100644 index 0000000000000000000000000000000000000000..07b8795d7d4adba48b2611914ed694e756759ec5 --- /dev/null +++ b/tezt/tests/expected/sc_rollup.ml/Alpha- observing the winning strategy of refutation games (pvm_proof_3).out @@ -0,0 +1,307 @@ + +./tezos-client --wait none originate sc rollup from '[PUBLIC_KEY_HASH]' of kind arith of type string booting with --burn-cap 9999999 +Node is bootstrapped. +Estimated gas: 2909.116 units (will add 100 for safety) +Estimated storage: 6616 bytes added (will add 20 for safety) +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000654 + Expected counter: 1 + Gas limit: 3010 + Storage limit: 6636 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000654 + payload fees(the block proposer) ....... +ꜩ0.000654 + Originate smart contract rollup of kind arith and type string with boot sector '' + This smart contract rollup origination was successfully applied + Consumed gas: 2909.116 + Storage size: 6616 bytes + Address: [SC_ROLLUP_HASH] + Genesis commitment hash: [SC_ROLLUP_COMMITMENT_HASH] + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ1.654 + storage fees ........................... +ꜩ1.654 + + +./tezos-client --wait none send sc rollup message 'text:["3 3 +","1","1 1 x","3 7 8 + * y","2 2 out"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1653.847 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 2 + Gas limit: 1754 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1653.975 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 3 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 5 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 1 + back_pointers = [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","3 3 +","1 1 x","3 7 8 + * y","2 2 out"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.197 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 3 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.197 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 5 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 10 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 2 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 3 +","3 7 8 + * y","2 2 out"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.276 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 4 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.276 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 9 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 15 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 3 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","3 3 +","2 2 out"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.419 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 5 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.419 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 11 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 20 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 4 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.498 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 6 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.498 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 13 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 25 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 5 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.498 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 7 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.498 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 15 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 30 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 6 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.498 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 8 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.498 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 17 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 35 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 7 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + diff --git a/tezt/tests/expected/sc_rollup.ml/Alpha- observing the winning strategy of refutation games (pvm_proof_at_genesis).out b/tezt/tests/expected/sc_rollup.ml/Alpha- observing the winning strategy of refutation games (pvm_proof_at_genesis).out new file mode 100644 index 0000000000000000000000000000000000000000..d6454802cfe89f66403d06f96d364c25c6f749c9 --- /dev/null +++ b/tezt/tests/expected/sc_rollup.ml/Alpha- observing the winning strategy of refutation games (pvm_proof_at_genesis).out @@ -0,0 +1,430 @@ + +./tezos-client --wait none originate sc rollup from '[PUBLIC_KEY_HASH]' of kind arith of type string booting with --burn-cap 9999999 +Node is bootstrapped. +Estimated gas: 2909.116 units (will add 100 for safety) +Estimated storage: 6616 bytes added (will add 20 for safety) +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000654 + Expected counter: 1 + Gas limit: 3010 + Storage limit: 6636 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000654 + payload fees(the block proposer) ....... +ꜩ0.000654 + Originate smart contract rollup of kind arith and type string with boot sector '' + This smart contract rollup origination was successfully applied + Consumed gas: 2909.116 + Storage size: 6616 bytes + Address: [SC_ROLLUP_HASH] + Genesis commitment hash: [SC_ROLLUP_COMMITMENT_HASH] + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ1.654 + storage fees ........................... +ꜩ1.654 + + +./tezos-client --wait none send sc rollup message 'text:["3 3 +","1","1 1 x","3 7 8 + * y","2 2 out"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1653.847 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 2 + Gas limit: 1754 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1653.975 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 3 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 5 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 1 + back_pointers = [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","3 3 +","1 1 x","3 7 8 + * y","2 2 out"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.197 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 3 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.197 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 5 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 10 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 2 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 3 +","3 7 8 + * y","2 2 out"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.276 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 4 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.276 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 7 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 15 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 3 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","3 3 +","2 2 out"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.419 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 5 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.419 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 9 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 20 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 4 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.483 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 6 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.483 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 11 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 25 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 5 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.498 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 7 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.498 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 13 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 30 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 6 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.498 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 8 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.498 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 15 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 35 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 7 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.626 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 9 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.626 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 17 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 40 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 8 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.690 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 10 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.690 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 19 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 45 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 9 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.705 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 11 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.705 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 21 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 50 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 10 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + diff --git a/tezt/tests/expected/sc_rollup.ml/Alpha- observing the winning strategy of refutation games (timeout).out b/tezt/tests/expected/sc_rollup.ml/Alpha- observing the winning strategy of refutation games (timeout).out new file mode 100644 index 0000000000000000000000000000000000000000..d6454802cfe89f66403d06f96d364c25c6f749c9 --- /dev/null +++ b/tezt/tests/expected/sc_rollup.ml/Alpha- observing the winning strategy of refutation games (timeout).out @@ -0,0 +1,430 @@ + +./tezos-client --wait none originate sc rollup from '[PUBLIC_KEY_HASH]' of kind arith of type string booting with --burn-cap 9999999 +Node is bootstrapped. +Estimated gas: 2909.116 units (will add 100 for safety) +Estimated storage: 6616 bytes added (will add 20 for safety) +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000654 + Expected counter: 1 + Gas limit: 3010 + Storage limit: 6636 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000654 + payload fees(the block proposer) ....... +ꜩ0.000654 + Originate smart contract rollup of kind arith and type string with boot sector '' + This smart contract rollup origination was successfully applied + Consumed gas: 2909.116 + Storage size: 6616 bytes + Address: [SC_ROLLUP_HASH] + Genesis commitment hash: [SC_ROLLUP_COMMITMENT_HASH] + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ1.654 + storage fees ........................... +ꜩ1.654 + + +./tezos-client --wait none send sc rollup message 'text:["3 3 +","1","1 1 x","3 7 8 + * y","2 2 out"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1653.847 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 2 + Gas limit: 1754 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1653.975 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 3 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 5 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 1 + back_pointers = [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","3 3 +","1 1 x","3 7 8 + * y","2 2 out"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.197 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 3 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.197 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 5 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 10 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 2 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 3 +","3 7 8 + * y","2 2 out"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.276 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 4 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.276 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 7 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 15 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 3 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","3 3 +","2 2 out"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.419 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 5 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.419 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 9 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 20 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 4 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.483 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 6 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.483 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 11 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 25 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 5 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.498 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 7 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.498 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 13 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 30 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 6 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.498 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 8 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.498 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 15 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 35 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 7 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.626 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 9 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.626 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 17 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 40 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 8 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.690 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 10 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.690 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 19 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 45 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 9 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + + +./tezos-client --wait none send sc rollup message 'text:["1","1 1 x","3 7 8 + * y","2 2 out","3 3 +"]' from bootstrap1 to '[SC_ROLLUP_HASH]' +Node is bootstrapped. +Estimated gas: 1654.705 units (will add 100 for safety) +Estimated storage: no bytes added +Operation successfully injected in the node. +Operation hash is '[OPERATION_HASH]' +NOT waiting for the operation to be included. +Use command + tezos-client wait for [OPERATION_HASH] to be included --confirmations 1 --branch [BLOCK_HASH] +and/or an external block explorer to make sure that it has been included. +This sequence of operations was run: + Manager signed operations: + From: [PUBLIC_KEY_HASH] + Fee to the baker: ꜩ0.000494 + Expected counter: 11 + Gas limit: 1755 + Storage limit: 0 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000494 + payload fees(the block proposer) ....... +ꜩ0.000494 + Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] + This smart contract rollup messages submission was successfully applied + Consumed gas: 1654.705 + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 21 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 50 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + + content = [SC_ROLLUP_INBOX_HASH] + index = 10 + back_pointers = [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + + } + diff --git a/tezt/tests/expected/sc_rollup.ml/Alpha- pushing messages in the inbox - check inbox size.out b/tezt/tests/expected/sc_rollup.ml/Alpha- pushing messages in the inbox - check inbox size.out index 8e756c561af593a9534426bfc2772a2e1c32d407..9c64db6be7bf93da73f74319bbc1ac6d0604aafd 100644 --- a/tezt/tests/expected/sc_rollup.ml/Alpha- pushing messages in the inbox - check inbox size.out +++ b/tezt/tests/expected/sc_rollup.ml/Alpha- pushing messages in the inbox - check inbox size.out @@ -53,19 +53,19 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1651.778 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 3 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 1 - starting_level_of_current_commitment_period = 2 - message_counter = 1 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 3 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 1 + starting_level_of_current_commitment_period = 2 + message_counter = 1 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 1 back_pointers = [SC_ROLLUP_INBOX_HASH] - + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -91,20 +91,20 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1652.596 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 4 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 3 - starting_level_of_current_commitment_period = 2 - message_counter = 2 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 4 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 3 + starting_level_of_current_commitment_period = 2 + message_counter = 2 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 2 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -130,20 +130,20 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1653.271 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 5 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 6 - starting_level_of_current_commitment_period = 2 - message_counter = 3 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 5 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 6 + starting_level_of_current_commitment_period = 2 + message_counter = 3 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 3 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -169,21 +169,21 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1653.995 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 6 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 10 - starting_level_of_current_commitment_period = 2 - message_counter = 4 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 6 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 10 + starting_level_of_current_commitment_period = 2 + message_counter = 4 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 4 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -209,21 +209,21 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1654.670 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 7 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 15 - starting_level_of_current_commitment_period = 2 - message_counter = 5 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 7 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 15 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 5 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -249,21 +249,21 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1655.266 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 8 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 21 - starting_level_of_current_commitment_period = 2 - message_counter = 6 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 8 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 21 + starting_level_of_current_commitment_period = 2 + message_counter = 6 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 6 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -289,21 +289,21 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1655.862 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 9 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 28 - starting_level_of_current_commitment_period = 2 - message_counter = 7 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 9 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 28 + starting_level_of_current_commitment_period = 2 + message_counter = 7 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 7 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -329,22 +329,22 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1656.586 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 10 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 36 - starting_level_of_current_commitment_period = 2 - message_counter = 8 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 10 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 36 + starting_level_of_current_commitment_period = 2 + message_counter = 8 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 8 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -370,22 +370,22 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1657.261 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 11 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 45 - starting_level_of_current_commitment_period = 2 - message_counter = 9 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 11 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 45 + starting_level_of_current_commitment_period = 2 + message_counter = 9 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 9 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } ./tezos-client --wait none send sc rollup message 'text:["CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE","CAFEBABE"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -411,20 +411,20 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1657.857 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 12 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 55 - starting_level_of_current_commitment_period = 2 - message_counter = 10 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 12 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 55 + starting_level_of_current_commitment_period = 2 + message_counter = 10 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 10 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + [SC_ROLLUP_INBOX_HASH] + } diff --git a/tezt/tests/expected/sc_rollup.ml/Alpha- pushing messages in the inbox - current messages hash.out b/tezt/tests/expected/sc_rollup.ml/Alpha- pushing messages in the inbox - current messages hash.out index b3f113e782f9d94a19c0b806783d818d3f88c24e..cebdf413ae176242278cd9365b94c273f512278a 100644 --- a/tezt/tests/expected/sc_rollup.ml/Alpha- pushing messages in the inbox - current messages hash.out +++ b/tezt/tests/expected/sc_rollup.ml/Alpha- pushing messages in the inbox - current messages hash.out @@ -53,19 +53,19 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1655.437 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 3 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 5 - starting_level_of_current_commitment_period = 2 - message_counter = 5 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 3 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 5 + starting_level_of_current_commitment_period = 2 + message_counter = 5 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 1 back_pointers = [SC_ROLLUP_INBOX_HASH] - + } ./tezos-client --wait none send sc rollup message 'text:["hello, message number 5", "hello, message number 6", "hello, message number 7", "hello, message number 8", "hello, message number 9", "hello, message number 10"]' from bootstrap1 to '[SC_ROLLUP_HASH]' @@ -91,18 +91,18 @@ This sequence of operations was run: Add a message to the inbox of the smart contract rollup at address [SC_ROLLUP_HASH] This smart contract rollup messages submission was successfully applied Consumed gas: 1656.527 - Resulting inbox state: - rollup = [SC_ROLLUP_HASH] - level = 4 - current messages hash = [SC_ROLLUP_INBOX_HASH] - nb_messages_in_commitment_period = 11 - starting_level_of_current_commitment_period = 2 - message_counter = 6 - old_levels_messages = + Resulting inbox state: { rollup = [SC_ROLLUP_HASH] + level = 4 + current messages hash = [SC_ROLLUP_INBOX_HASH] + nb_messages_in_commitment_period = 11 + starting_level_of_current_commitment_period = 2 + message_counter = 6 + old_levels_messages = hash : [SC_ROLLUP_INBOX_HASH] + content = [SC_ROLLUP_INBOX_HASH] index = 2 back_pointers = [SC_ROLLUP_INBOX_HASH] - [SC_ROLLUP_INBOX_HASH] - + [SC_ROLLUP_INBOX_HASH] + } diff --git a/tezt/tests/sc_rollup.ml b/tezt/tests/sc_rollup.ml index bc6531344dc9d858be26fe3557fe10f1e111335e..7189103118c93bc4c6ed08ad08386d4a60e4b2fa 100644 --- a/tezt/tests/sc_rollup.ml +++ b/tezt/tests/sc_rollup.ml @@ -108,10 +108,11 @@ let regression_test ~__FILE__ ?(tags = []) title f = let tags = "sc_rollup" :: tags in Protocol.register_regression_test ~__FILE__ ~title ~tags f -let setup ?commitment_period ?challenge_window f ~protocol = +let setup ?commitment_period ?challenge_window ?timeout f ~protocol = let parameters = make_parameter "sc_rollup_commitment_period_in_blocks" commitment_period @ make_parameter "sc_rollup_challenge_window_in_blocks" challenge_window + @ make_parameter "sc_rollup_timeout_period_in_blocks" timeout @ [(["sc_rollup_enable"], Some "true")] in let base = Either.right (protocol, None) in @@ -167,7 +168,7 @@ let with_fresh_rollup f tezos_node tezos_client bootstrap1_key = (* TODO: https://gitlab.com/tezos/tezos/-/issues/2933 Many tests can be refactored using test_scenario. *) -let test_scenario ?commitment_period ?challenge_window +let test_scenario ?commitment_period ?challenge_window ?timeout {variant; tags; description} scenario = let tags = tags @ [variant] in regression_test @@ -175,7 +176,8 @@ let test_scenario ?commitment_period ?challenge_window ~tags (Printf.sprintf "%s (%s)" description variant) (fun protocol -> - setup ?commitment_period ?challenge_window ~protocol @@ fun node client -> + setup ?commitment_period ?challenge_window ?timeout ~protocol + @@ fun node client -> ( with_fresh_rollup @@ fun sc_rollup sc_rollup_node _filename -> scenario protocol sc_rollup_node sc_rollup node client ) node @@ -502,10 +504,7 @@ let send_messages ?batch_size n sc_rollup client = Lwt_list.iter_s (fun msg -> send_message client sc_rollup msg) messages let to_text_messages_arg msgs = - let text_messages = - List.map (fun msg -> Hex.of_string msg |> Hex.show) msgs - in - let json = Ezjsonm.list Ezjsonm.string text_messages in + let json = Ezjsonm.list Ezjsonm.string msgs in "text:" ^ Ezjsonm.to_string ~minify:true json let send_text_messages client sc_rollup msgs = @@ -659,7 +658,7 @@ let test_rollup_inbox_current_messages_hash = Check.((nb_available_messages = 0) int) ~error_msg:"0 messages expected in the inbox" in - let* expected = Sc_rollup_inbox.predict_current_messages_hash 2l [] in + let* expected = Sc_rollup_inbox.predict_current_messages_hash 0l [] in let () = Check.( (Inbox.Hash.to_b58check expected = pristine_hash) @@ -1052,7 +1051,10 @@ let test_rollup_node_advances_pvm_state protocols = trying to publish a commitment. *) -let bake_levels n client = repeat n @@ fun () -> Client.bake_for_and_wait client +let bake_levels ?hook n client = + fold n () @@ fun i () -> + let* () = match hook with None -> return () | Some hook -> hook i in + Client.bake_for_and_wait client let check_eq_commitment (c1 : Sc_rollup_client.commitment) (c2 : Sc_rollup_client.commitment) = @@ -1973,6 +1975,122 @@ let test_consecutive_commitments = in unit) +(* Refutation game scenarios + ------------------------- +*) + +(* + + To check the refutation game logic, we evaluate a scenario with one + honest rollup node and one dishonest rollup node configured as with + a given [loser_mode]. + + For a given sequence of [inputs], distributed amongst several + levels, with some possible [empty_levels]. We check that at some + [final_level], the crime does not pay: the dishonest node has losen + its deposit while the honest one has not. + +*) +let test_refutation_scenario ?commitment_period ?challenge_window variant + (loser_mode, inputs, final_level, empty_levels, stop_loser_at) = + test_scenario + ?commitment_period + ~timeout:10 + ?challenge_window + { + tags = ["refutation"; "node"]; + variant; + description = "observing the winning strategy of refutation games"; + } + @@ fun _protocol sc_rollup_node sc_rollup_address node client -> + let bootstrap1_key = Constant.bootstrap1.public_key_hash in + let bootstrap2_key = Constant.bootstrap2.public_key_hash in + + let sc_rollup_node2 = + Sc_rollup_node.create node client ~operator_pkh:bootstrap2_key + in + let* _configuration_filename = + Sc_rollup_node.config_init ~loser_mode sc_rollup_node2 sc_rollup_address + in + let* () = Sc_rollup_node.run sc_rollup_node + and* () = Sc_rollup_node.run sc_rollup_node2 in + + let start_level = Node.get_level node in + + let stop_loser level = + if List.mem level stop_loser_at then + Sc_rollup_node.terminate sc_rollup_node2 + else return () + in + + let rec consume_inputs i = function + | [] -> return () + | inputs :: next_batches as all -> + let level = start_level + i in + let* () = stop_loser level in + if List.mem level empty_levels then + let* () = Client.bake_for_and_wait client in + consume_inputs (i + 1) all + else + let* () = + Lwt_list.iter_s (send_text_messages client sc_rollup_address) inputs + in + let* () = Client.bake_for_and_wait client in + consume_inputs (i + 1) next_batches + in + let* () = consume_inputs 0 inputs in + let* after_inputs_level = Client.level client in + + let hook i = + let level = after_inputs_level + i in + stop_loser level + in + let* () = bake_levels ~hook (final_level - List.length inputs) client in + + let*! honest_deposit = + RPC.Contracts.get_frozen_bonds ~contract_id:bootstrap1_key client + in + let*! loser_deposit = + RPC.Contracts.get_frozen_bonds ~contract_id:bootstrap2_key client + in + let* {stake_amount; _} = get_sc_rollup_constants client in + + Check.( + (JSON.as_int honest_deposit = Tez.to_mutez stake_amount) + int + ~error_msg:"expecting deposit for honest participant = %R, got %L") ; + Check.( + (JSON.as_int loser_deposit = 0) + int + ~error_msg:"expecting loss for dishonest participant = %R, got %L") ; + return () + +let rec swap i l = + if i <= 0 then l + else match l with [_] | [] -> l | x :: y :: l -> y :: swap (i - 1) (x :: l) + +let inputs_for n = + List.init n @@ fun i -> + [swap i ["3 3 +"; "1"; "1 1 x"; "3 7 8 + * y"; "2 2 out"]] + +let test_refutation protocols = + let challenge_window = 10 in + [ + ("inbox_proof_at_genesis", ("3 0 0", inputs_for 10, 80, [], [])); + ("pvm_proof_at_genesis", ("3 0 1", inputs_for 10, 80, [], [])); + ("inbox_proof", ("5 0 0", inputs_for 10, 80, [], [])); + ("inbox_proof_one_empty_level", ("6 0 0", inputs_for 10, 80, [2], [])); + ( "inbox_proof_many_empty_levels", + ("9 0 0", inputs_for 10, 80, [2; 3; 4], []) ); + ("pvm_proof_0", ("5 0 1", inputs_for 10, 80, [], [])); + ("pvm_proof_1", ("7 1 2", inputs_for 10, 80, [], [])); + ("pvm_proof_2", ("7 2 5", inputs_for 7, 80, [], [])); + ("pvm_proof_3", ("9 2 5", inputs_for 7, 80, [4; 5], [])); + ("timeout", ("5 0 1", inputs_for 10, 80, [], [35])); + ] + |> List.iter (fun (variant, inputs) -> + test_refutation_scenario ~challenge_window variant inputs protocols) + let register ~protocols = test_origination protocols ; test_rollup_node_configuration protocols ; @@ -2023,4 +2141,5 @@ let register ~protocols = test_rollup_node_uses_boot_sector protocols ; test_rollup_client_show_address protocols ; test_rollup_client_generate_keys protocols ; - test_rollup_client_list_keys protocols + test_rollup_client_list_keys protocols ; + test_refutation protocols