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 c88f41f70b72094fc819a8cb9b251f45b294c126..b707417b25206531ee6c6fc81838e17192df1af9 100644 --- a/src/proto_alpha/bin_sc_rollup_node/RPC_server.ml +++ b/src/proto_alpha/bin_sc_rollup_node/RPC_server.ml @@ -27,25 +27,31 @@ open Tezos_rpc open Tezos_rpc_http open Tezos_rpc_http_server -let get_head_exn store = +let get_head store = let open Lwt_result_syntax in let*! head = Layer1.current_head_hash store in match head with None -> failwith "No head" | Some head -> return head let get_state_info_exn store = let open Lwt_result_syntax in - let* head = get_head_exn store in + let* head = get_head store in let*! state = Store.StateInfo.get store head in return state let get_dal_slot_subscriptions_exn store = let open Lwt_result_syntax in - let* head = get_head_exn store in + let* head = get_head store in let*! slot_subscriptions = Store.Dal_slot_subscriptions.find store head in match slot_subscriptions with | None -> failwith "No slot subscriptions" | Some slot_subscriptions -> return slot_subscriptions +let get_dal_slots store = + let open Lwt_result_syntax in + let* head = get_head store in + let*! slot_headers = Store.Dal_slots.list_values store ~primary_key:head in + return slot_headers + let commitment_with_hash commitment = ( Protocol.Alpha_context.Sc_rollup.Commitment.hash_uncarbonated commitment, commitment ) @@ -134,9 +140,9 @@ module Make (PVM : Pvm.S) : S with module PVM = PVM = struct include Common module PVM = PVM - let get_state_exn (node_ctxt : Node_context.t) = + let get_state (node_ctxt : Node_context.t) = let open Lwt_result_syntax in - let* head = get_head_exn node_ctxt.store in + let* head = get_head node_ctxt.store in let* ctxt = Node_context.checkout_context node_ctxt head in let*! state = PVM.State.find ctxt in match state with None -> failwith "No state" | Some state -> return state @@ -147,7 +153,7 @@ module Make (PVM : Pvm.S) : S with module PVM = PVM = struct (Sc_rollup_services.Global.current_total_ticks ()) (fun () () -> let open Lwt_result_syntax in - let* state = get_state_exn node_ctxt in + let* state = get_state node_ctxt in let*! tick = PVM.get_tick state in return tick) @@ -157,7 +163,7 @@ module Make (PVM : Pvm.S) : S with module PVM = PVM = struct (Sc_rollup_services.Global.current_state_hash ()) (fun () () -> let open Lwt_result_syntax in - let* state = get_state_exn node_ctxt in + let* state = get_state node_ctxt in let*! hash = PVM.state_hash state in return hash) @@ -167,7 +173,7 @@ module Make (PVM : Pvm.S) : S with module PVM = PVM = struct (Sc_rollup_services.Local.current_state_value ()) (fun {key} () -> let open Lwt_result_syntax in - let* state = get_state_exn node_ctxt in + let* state = get_state node_ctxt in let path = String.split_on_char '/' key in let*! value = PVM.State.lookup state path in match value with @@ -220,7 +226,7 @@ module Make (PVM : Pvm.S) : S with module PVM = PVM = struct (Sc_rollup_services.Global.current_status ()) (fun () () -> let open Lwt_result_syntax in - let* state = get_state_exn node_ctxt in + let* state = get_state node_ctxt in let*! status = PVM.get_status state in return (PVM.string_of_status status)) @@ -230,6 +236,12 @@ module Make (PVM : Pvm.S) : S with module PVM = PVM = struct (Sc_rollup_services.Global.dal_slot_subscriptions ()) (fun () () -> get_dal_slot_subscriptions_exn store) + let register_dal_slots store dir = + RPC_directory.register0 + dir + (Sc_rollup_services.Global.dal_slots ()) + (fun () () -> get_dal_slots store) + let register (node_ctxt : Node_context.t) configuration = RPC_directory.empty |> register_sc_rollup_address configuration @@ -244,6 +256,7 @@ module Make (PVM : Pvm.S) : S with module PVM = PVM = struct |> register_last_stored_commitment node_ctxt.store |> register_last_published_commitment node_ctxt.store |> register_dal_slot_subscriptions node_ctxt.store + |> register_dal_slots node_ctxt.store let start node_ctxt configuration = Common.start configuration (register node_ctxt configuration) diff --git a/src/proto_alpha/bin_sc_rollup_node/daemon.ml b/src/proto_alpha/bin_sc_rollup_node/daemon.ml index ae1191cf1bf87d7af138c9ffaa1ecc09e240dbe2..e01d160e312b222bfc513485e024d7d3f51b064c 100644 --- a/src/proto_alpha/bin_sc_rollup_node/daemon.ml +++ b/src/proto_alpha/bin_sc_rollup_node/daemon.ml @@ -70,7 +70,7 @@ module Make (PVM : Pvm.S) = struct for the first time. {b Note}: this function does not process inboxes for the rollup, which is done instead by {!Inbox.process_head}. *) let process_included_l1_operation (type kind) (node_ctxt : Node_context.t) - ~source:_ (operation : kind manager_operation) + head ~source:_ (operation : kind manager_operation) (result : kind successful_manager_operation_result) = let open Lwt_syntax in match (operation, result) with @@ -91,18 +91,31 @@ module Make (PVM : Pvm.S) = struct Store.Last_cemented_commitment_level.set node_ctxt.store inbox_level in Store.Last_cemented_commitment_hash.set node_ctxt.store commitment + | Dal_publish_slot_header {slot}, Dal_publish_slot_header_result _ -> + let {Dal.Slot.index; _} = slot in + (* DAL/FIXME: https://gitlab.com/tezos/tezos/-/issues/3510 + We store slot headers for all slots. In practice, + it would be convenient to store only information about + headers of slots to which the rollup node is subscribed to. + We do not have the information about DAL slots subscribed to + at this time. *) + Store.Dal_slots.add + node_ctxt.store + ~primary_key:head + ~secondary_key:index + slot | _, _ -> (* Other manager operations *) return_unit (** Process an L1 SCORU operation (for the node's rollup) which is finalized for the first time. *) - let process_finalized_l1_operation (type kind) _node_ctxt ~source:_ + let process_finalized_l1_operation (type kind) _node_ctxt _head ~source:_ (_operation : kind manager_operation) (_result : kind successful_manager_operation_result) = Lwt.return_unit - let process_l1_operation (type kind) ~finalized node_ctxt ~source + let process_l1_operation (type kind) ~finalized node_ctxt head ~source (operation : kind manager_operation) (result : kind Apply_results.manager_operation_result) = let open Lwt_syntax in @@ -116,14 +129,14 @@ module Make (PVM : Pvm.S) = struct | Sc_rollup_recover_bond {sc_rollup = rollup} | Sc_rollup_dal_slot_subscribe {rollup; _} -> Sc_rollup.Address.(rollup = node_ctxt.Node_context.rollup_address) + | Dal_publish_slot_header _ -> true | Reveal _ | Transaction _ | Origination _ | Delegation _ | Register_global_constant _ | Set_deposits_limit _ | Increase_paid_storage _ | Tx_rollup_origination | Tx_rollup_submit_batch _ | Tx_rollup_commit _ | Tx_rollup_return_bond _ | Tx_rollup_finalize_commitment _ | Tx_rollup_remove_commitment _ | Tx_rollup_rejection _ | Tx_rollup_dispatch_tickets _ | Transfer_ticket _ - | Dal_publish_slot_header _ | Sc_rollup_originate _ - | Zk_rollup_origination _ -> + | Sc_rollup_originate _ | Zk_rollup_origination _ -> false in if not (is_for_my_rollup operation) then return_unit @@ -136,7 +149,7 @@ module Make (PVM : Pvm.S) = struct if finalized then process_finalized_l1_operation else process_included_l1_operation in - process node_ctxt ~source operation success_result + process node_ctxt head ~source operation success_result | _ -> (* No action for non successful operations *) return_unit @@ -148,7 +161,7 @@ module Make (PVM : Pvm.S) = struct result = let open Lwt_syntax in let* () = accu in - process_l1_operation ~finalized node_ctxt ~source operation result + process_l1_operation ~finalized node_ctxt hash ~source operation result in let apply_internal (type kind) accu ~source:_ (_operation : kind Apply_internal_results.internal_operation) diff --git a/src/proto_alpha/bin_sc_rollup_node/store.ml b/src/proto_alpha/bin_sc_rollup_node/store.ml index 3811ac199a33d189dc50eec898b2a6a3b34a8484..634f5adc92fdc2af86df8247ffea55dbbd8409d1 100644 --- a/src/proto_alpha/bin_sc_rollup_node/store.ml +++ b/src/proto_alpha/bin_sc_rollup_node/store.ml @@ -26,6 +26,10 @@ (* TODO: https://gitlab.com/tezos/tezos/-/issues/3471 Use indexed file for append-only instead of Irmin. *) +(* TODO: https://gitlab.com/tezos/tezos/-/issues/3739 + Refactor the store file to have functors in their own + separate module, and return errors within the Error monad. *) + open Protocol open Alpha_context module Maker = Irmin_pack_unix.Maker (Tezos_context_encoding.Context.Conf) @@ -63,8 +67,6 @@ module type Mutable_value = sig val path_key : path - val decode_value : bytes -> value Lwt.t - val set : t -> value -> unit Lwt.t val get : t -> value Lwt.t @@ -97,15 +99,17 @@ module Make_map (P : KeyValue) = struct let mem store key = IStore.mem store (make_key key) let decode_value encoded_value = - Lwt.return - @@ Data_encoding.Binary.of_bytes_exn P.value_encoding encoded_value + Data_encoding.Binary.of_bytes_exn P.value_encoding encoded_value - let get store key = IStore.get store (make_key key) >>= decode_value + let get store key = + let open Lwt_syntax in + let+ e = IStore.get store (make_key key) in + decode_value e let find store key = - let open Lwt_syntax in - let* value = IStore.find store (make_key key) in - Option.map_s decode_value value + let open Lwt_option_syntax in + let+ value = IStore.find store (make_key key) in + decode_value value let find_with_default store key ~on_default = let open Lwt_syntax in @@ -163,8 +167,7 @@ struct let path_key = P.path let decode_value encoded_value = - Lwt.return - @@ Data_encoding.Binary.of_bytes_exn P.value_encoding encoded_value + Data_encoding.Binary.of_bytes_exn P.value_encoding encoded_value let set store value = let encoded_value = @@ -173,12 +176,15 @@ struct let info () = info (String.concat "/" P.path) in IStore.set_exn ~info store path_key encoded_value - let get store = IStore.get store path_key >>= decode_value + let get store = + let open Lwt_syntax in + let+ value = IStore.get store path_key in + decode_value value let find store = - let open Lwt_syntax in - let* value = IStore.find store path_key in - Option.map_s decode_value value + let open Lwt_option_syntax in + let+ value = IStore.find store path_key in + decode_value value end (** Aggregated collection of messages from the L1 inbox *) @@ -387,6 +393,9 @@ module Commitments_published_at_level = Make_updatable_map (struct let value_encoding = Raw_level.encoding end) +(* Slot subscriptions per block hash, saved as a list of + `Dal.Slot_index.t`, which is a bounded integer between `0` and `255` + included. *) module Dal_slot_subscriptions = Make_append_only_map (struct let path = ["dal"; "slot_subscriptions"] @@ -414,3 +423,85 @@ module Contexts = Make_append_only_map (struct let value_encoding = Context.hash_encoding end) + +(* Published slot headers per block hash, + stored as a list of bindings from `Dal_slot_index.t` + to `Dal.Slot.t`. The encoding function converts this + list into a `Dal.Slot_index.t`-indexed map. *) +module Dal_slots = struct + module Dal_slots_map = Map.Make (struct + type t = Dal.Slot_index.t + + let compare = Dal.Slot_index.compare + end) + + include Make_updatable_map (struct + let keep_last_n_entries_in_memory = 10 + + let path = ["dal"; "slot_headers"] + + type key = Block_hash.t + + let string_of_key = Block_hash.to_b58check + + type value = Dal.Slot.t Dal_slots_map.t + + (* DAL/FIXME: https://gitlab.com/tezos/tezos/-/issues/3732 + Use data encodings for maps once they are available in the + `Data_encoding` library. + *) + let value_encoding = + Data_encoding.conv + (fun dal_slots_map -> Dal_slots_map.bindings dal_slots_map) + (fun dal_slots_bindings -> + Dal_slots_map.of_seq @@ List.to_seq dal_slots_bindings) + Data_encoding.( + list + @@ obj2 + (req "slot_index" Dal.Slot_index.encoding) + (req "slot_metadata" Dal.Slot.encoding)) + end) + + let list_secondary_keys_with_values store ~primary_key = + let open Lwt_syntax in + let+ slots_map = find store primary_key in + Option.fold ~none:[] ~some:Dal_slots_map.bindings slots_map + + let list_secondary_keys store ~primary_key = + let open Lwt_syntax in + let+ secondary_keys_with_values = + list_secondary_keys_with_values store ~primary_key + in + secondary_keys_with_values |> List.map fst + + let list_values store ~primary_key = + let open Lwt_syntax in + let+ secondary_keys_with_values = + list_secondary_keys_with_values store ~primary_key + in + secondary_keys_with_values |> List.map snd + + let add store ~primary_key ~secondary_key value = + let open Lwt_syntax in + let* slots_map = find store primary_key in + let slots_map = Option.value ~default:Dal_slots_map.empty slots_map in + let value_can_be_added = + match Dal_slots_map.find secondary_key slots_map with + | None -> true + | Some old_value -> + Data_encoding.Binary.( + Bytes.equal + (to_bytes_exn Dal.Slot.encoding old_value) + (to_bytes_exn Dal.Slot.encoding value)) + in + if value_can_be_added then + let new_slots_map = Dal_slots_map.add secondary_key value slots_map in + add store primary_key new_slots_map + else + Stdlib.failwith + (Printf.sprintf + "A binding for slot index %d under block_hash %s already exists \ + with a different value" + (Dal.Slot_index.to_int secondary_key) + (Block_hash.to_b58check primary_key)) +end diff --git a/src/proto_alpha/lib_protocol/alpha_context.mli b/src/proto_alpha/lib_protocol/alpha_context.mli index 83d837adb7c79108bb4f6cf0a0ab0d1b8b672ed4..0a14bfd1c4818ecafd5ec099dc44aa6908299fa5 100644 --- a/src/proto_alpha/lib_protocol/alpha_context.mli +++ b/src/proto_alpha/lib_protocol/alpha_context.mli @@ -2807,6 +2807,8 @@ module Dal : sig val of_int : int -> t option + val to_int : t -> int + val compare : t -> t -> int end diff --git a/src/proto_alpha/lib_sc_rollup/sc_rollup_services.ml b/src/proto_alpha/lib_sc_rollup/sc_rollup_services.ml index 0aaa6a88f540196f3f1d212fab425151d7300104..8a2e64debb96f3991bd8c431d5b4189441e934e5 100644 --- a/src/proto_alpha/lib_sc_rollup/sc_rollup_services.ml +++ b/src/proto_alpha/lib_sc_rollup/sc_rollup_services.ml @@ -136,6 +136,13 @@ module Global = struct ~description:"Current data availability layer slot subscriptions" ~query:RPC_query.empty ~output:(Data_encoding.list Dal.Slot_index.encoding) + (prefix / "dal" / "slot_subscriptions") + + let dal_slots () = + RPC_service.get_service + ~description:"Data availability slots for a given block hash" + ~query:RPC_query.empty + ~output:(Data_encoding.list Dal.Slot.encoding) (prefix / "dal" / "slots") end diff --git a/tezt/lib_tezos/sc_rollup_client.ml b/tezt/lib_tezos/sc_rollup_client.ml index 15ef51cebefe0033bcc2a349bb2e5b8a3cbc5f14..9bbc867c731114da5c4c1b19668db517eeb66220 100644 --- a/tezt/lib_tezos/sc_rollup_client.ml +++ b/tezt/lib_tezos/sc_rollup_client.ml @@ -38,6 +38,8 @@ type commitment = { number_of_ticks : int; } +type slot_metadata = {level : int; header : string; index : int} + let commitment_from_json json = if JSON.is_null json then None else @@ -145,9 +147,23 @@ let last_published_commitment ?hooks sc_client = let dal_slot_subscriptions ?hooks sc_client = let open Lwt.Syntax in - let+ json = rpc_get ?hooks sc_client ["global"; "dal"; "slots"] in + let+ json = + rpc_get ?hooks sc_client ["global"; "dal"; "slot_subscriptions"] + in JSON.as_list json |> List.map JSON.as_int +let dal_slots_metadata ?hooks sc_client = + let open Lwt.Syntax in + let+ json = rpc_get ?hooks sc_client ["global"; "dal"; "slots"] in + JSON.( + as_list json + |> List.map (fun obj -> + { + level = obj |> get "level" |> as_int; + header = obj |> get "header" |> as_string; + index = obj |> get "index" |> as_int; + })) + let spawn_generate_keys ?hooks ?(force = false) ~alias sc_client = spawn_command ?hooks diff --git a/tezt/lib_tezos/sc_rollup_client.mli b/tezt/lib_tezos/sc_rollup_client.mli index f9e7251db64d4a55c43fa9b50e56f3a8a8fb1032..e6476896eccb5cf8e6ddd4d55a186901840012eb 100644 --- a/tezt/lib_tezos/sc_rollup_client.mli +++ b/tezt/lib_tezos/sc_rollup_client.mli @@ -33,6 +33,8 @@ type commitment = { number_of_ticks : int; } +type slot_metadata = {level : int; header : string; index : int} + (** [create ?name ?path ?base_dir ?path node] returns a fresh client identified by a specified [name], logging in [color], executing the program at [path], storing local information in [base_dir], and @@ -90,6 +92,10 @@ val last_published_commitment : (** [dal_slot_subscriptions client] gets the slots to which the rollup node is subscribed to *) val dal_slot_subscriptions : ?hooks:Process.hooks -> t -> int list Lwt.t +(** [dal_slots_metadata client] returns the dal slots metadata of the last tezos + head seen by the rollup node. *) +val dal_slots_metadata : ?hooks:Process.hooks -> t -> slot_metadata list Lwt.t + (** [generate_keys ~alias client] generates new unencrypted keys for [alias]. *) val generate_keys : ?hooks:Process.hooks -> ?force:bool -> alias:string -> t -> unit Lwt.t diff --git a/tezt/tests/dal.ml b/tezt/tests/dal.ml index 5794bfcfbcb1dc5b376c172ab44e2f2563d895a1..1d6d97b74689dcdaeb22fe43e962ca55b9bb4c88 100644 --- a/tezt/tests/dal.ml +++ b/tezt/tests/dal.ml @@ -236,6 +236,8 @@ let slot_availability ~signer availability client = List.iter (fun i -> endorsement.(i) <- true) availability ; Operation.Consensus.(inject ~signer (slot_availability ~endorsement) client) +let header_of_slot_metadata {Sc_rollup_client.header; _} = header + type status = Applied | Failed of {error_id : string} let pp fmt = function @@ -509,6 +511,69 @@ let test_dal_node_startup = let* () = Dal_node.terminate dal_node in return () +let rollup_node_stores_dal_slots _protocol sc_rollup_node sc_rollup_address node + client = + (* Check that the rollup node stores the slots published in a block, along with slot headers: + + 1. Run rollup node for an originated rollup + 2. Execute a client command to publish a slot header, bake one level + 3. Repeat step two for a second slot header + 4. Get the list of slot headers for the rollup node + 5. Determine that the list contains the two slot headers published. + *) + let* parameters = Rollup.Dal.Parameters.from_client client in + let cryptobox = Rollup.Dal.make parameters in + let* genesis_info = + RPC.Client.call ~hooks client + @@ RPC.get_chain_block_context_sc_rollup_genesis_info sc_rollup_address + in + let init_level = JSON.(genesis_info |-> "level" |> as_int) in + let* () = Sc_rollup_node.run sc_rollup_node in + let sc_rollup_client = Sc_rollup_client.create sc_rollup_node in + let* level = Sc_rollup_node.wait_for_level sc_rollup_node init_level in + Check.(level = init_level) + Check.int + ~error_msg:"Current level has moved past origination level (%L = %R)" ; + let* _ = + publish_slot + ~source:Constant.bootstrap1 + ~fee:1_200 + ~index:0 + ~message:"CAFEBABE" + parameters + cryptobox + node + client + in + let* _ = + publish_slot + ~source:Constant.bootstrap2 + ~fee:1_200 + ~index:1 + ~message:"CAFEDEAD" + parameters + cryptobox + node + client + in + let* () = Client.bake_for_and_wait client in + let* _level = Sc_rollup_node.wait_for_level sc_rollup_node (init_level + 1) in + let* slots_metadata = + Sc_rollup_client.dal_slots_metadata ~hooks sc_rollup_client + in + let slot_headers = slots_metadata |> List.map header_of_slot_metadata in + let expected_slot_headers = + List.map + (fun msg -> + Tezos_crypto_dal.Cryptobox.Commitment.to_b58check + @@ Rollup.Dal.Commitment.dummy_commitment parameters cryptobox msg) + ["CAFEBABE"; "CAFEDEAD"] + in + Check.(slot_headers = expected_slot_headers) + (Check.list Check.string) + ~error_msg:"Unexpected list of slot headers (%L = %R)" ; + return () + let register ~protocols = test_dal_scenario "feature_flag_is_disabled" test_feature_flag protocols ; test_dal_scenario @@ -518,4 +583,9 @@ let register ~protocols = protocols ; test_slot_management_logic protocols ; test_dal_node_slot_management protocols ; - test_dal_node_startup protocols + test_dal_node_startup protocols ; + test_dal_scenario + ~dal_enable:true + "rollup_node_dal_headers_storage" + rollup_node_stores_dal_slots + protocols diff --git a/tezt/tests/expected/dal.ml/Alpha- Testing data availability layer functionality (rollup_node_dal_headers_s.out b/tezt/tests/expected/dal.ml/Alpha- Testing data availability layer functionality (rollup_node_dal_headers_s.out new file mode 100644 index 0000000000000000000000000000000000000000..03c8f113c10e5c702659e4d2a138cff6873f468f --- /dev/null +++ b/tezt/tests/expected/dal.ml/Alpha- Testing data availability layer functionality (rollup_node_dal_headers_s.out @@ -0,0 +1,46 @@ + +./tezos-client --wait none originate sc rollup from '[PUBLIC_KEY_HASH]' of kind arith of type unit booting with --burn-cap 9999999 +Node is bootstrapped. +Estimated gas: 3110.449 units (will add 100 for safety) +Estimated storage: 6655 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.000672 + Expected counter: 1 + Gas limit: 3211 + Storage limit: 6675 bytes + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ0.000672 + payload fees(the block proposer) ....... +ꜩ0.000672 + Smart contract rollup origination: + Kind: arith + Parameter type: unit + Boot sector: '' + This smart contract rollup origination was successfully applied + Consumed gas: 3110.449 + Storage size: 6655 bytes + Address: [SC_ROLLUP_HASH] + Genesis commitment hash: [SC_ROLLUP_COMMITMENT_HASH] + Balance updates: + [PUBLIC_KEY_HASH] ... -ꜩ1.66375 + storage fees ........................... +ꜩ1.66375 + + +./tezos-client rpc get '/chains/main/blocks/head/context/sc_rollup/[SC_ROLLUP_HASH]/genesis_info' +{ "level": 2, + "commitment_hash": "[SC_ROLLUP_COMMITMENT_HASH]" } + +./tezos-sc-rollup-client-alpha rpc get /global/dal/slots +[ { "level": 2, "index": 0, + "header": + "sh1xjHVBc36jYtzCoktBUq1RCin8bFEwXTZxpFoS1RA5MqqBsX5Z5A2CqU7QZZQUuqdKfSsvab" }, + { "level": 2, "index": 1, + "header": + "sh27onybk3L4eVH8khVVk8oKZvMkjGi1YszeTLneRe5ps9LL4oqXxR12DKzTMS8tJa27w5imfP" } ] diff --git a/tezt/tests/expected/dal.ml/Alpha- Testing data availability layer functionality (rollup_node_dal_subscript.out b/tezt/tests/expected/dal.ml/Alpha- Testing data availability layer functionality (rollup_node_dal_subscript.out index eb286bde359c6050b608fc20163b32df91cd8488..d69846c4b1977f049be660a70ef6c851b288e971 100644 --- a/tezt/tests/expected/dal.ml/Alpha- Testing data availability layer functionality (rollup_node_dal_subscript.out +++ b/tezt/tests/expected/dal.ml/Alpha- Testing data availability layer functionality (rollup_node_dal_subscript.out @@ -37,11 +37,11 @@ This sequence of operations was run: { "level": 2, "commitment_hash": "[SC_ROLLUP_COMMITMENT_HASH]" } -./tezos-sc-rollup-client-alpha rpc get /global/dal/slots +./tezos-sc-rollup-client-alpha rpc get /global/dal/slot_subscriptions [] -./tezos-sc-rollup-client-alpha rpc get /global/dal/slots +./tezos-sc-rollup-client-alpha rpc get /global/dal/slot_subscriptions [ 0 ] -./tezos-sc-rollup-client-alpha rpc get /global/dal/slots +./tezos-sc-rollup-client-alpha rpc get /global/dal/slot_subscriptions [ 0, 1 ]