From 8e7d4cfe2b8e76e3205d6f0e88bb13f59f0f4321 Mon Sep 17 00:00:00 2001 From: "iguerNL@Functori" Date: Sat, 17 Sep 2022 20:35:35 +0200 Subject: [PATCH 1/7] Proto/Dal: fixup in invariant check before adding an elt to skip list --- src/proto_alpha/lib_protocol/dal_slot_repr.ml | 52 ++++++++++++++----- 1 file changed, 40 insertions(+), 12 deletions(-) diff --git a/src/proto_alpha/lib_protocol/dal_slot_repr.ml b/src/proto_alpha/lib_protocol/dal_slot_repr.ml index af1bbc76fab9..a948984b0d80 100644 --- a/src/proto_alpha/lib_protocol/dal_slot_repr.ml +++ b/src/proto_alpha/lib_protocol/dal_slot_repr.ml @@ -237,7 +237,35 @@ module Slots_history = struct let basis = 2 end - module Skip_list = Skip_list_repr.Make (Skip_list_parameters) + type error += Add_element_in_slots_skip_list_violates_ordering + + let () = + register_error_kind + `Temporary + ~id:"Dal_slot_repr.add_element_in_slots_skip_list_violates_ordering" + ~title:"Add an element in slots skip list that violates ordering" + ~description: + "Attempting to add an element on top of the Dal confirmed slots skip \ + list that violates the ordering." + Data_encoding.unit + (function + | Add_element_in_slots_skip_list_violates_ordering -> Some () + | _ -> None) + (fun () -> Add_element_in_slots_skip_list_violates_ordering) + + module Skip_list = struct + include Skip_list_repr.Make (Skip_list_parameters) + + let next ~compare ~prev_cell ~prev_cell_ptr elt = + let open Tzresult_syntax in + let c = compare elt (content prev_cell) in + let* () = + error_when + Compare.Int.(c <= 0) + Add_element_in_slots_skip_list_violates_ordering + in + return @@ next ~prev_cell ~prev_cell_ptr elt + end module V1 = struct (* The content of a cell is the hash of all the slot headers @@ -299,18 +327,18 @@ module Slots_history = struct let equal = equal_history end) - let add_confirmed_slot (t, cache) slot = - let open Tzresult_syntax in - let* () = - error_when - Raw_level_repr.(slot.published_level <= zero.published_level) - (failwith - "No slot is supposed to be published at level \ - 'Raw_level_repr.root'") + let add_confirmed_slot = + let compare (s1 : slot) s2 = + Raw_level_repr.compare s1.published_level s2.published_level in - let prev_cell_ptr = hash_skip_list_cell t in - let* cache = History_cache.remember prev_cell_ptr t cache in - return (Skip_list.next ~prev_cell:t ~prev_cell_ptr slot, cache) + fun (t, cache) slot -> + let open Tzresult_syntax in + let prev_cell_ptr = hash_skip_list_cell t in + let* cache = History_cache.remember prev_cell_ptr t cache in + let* new_cell = + Skip_list.next ~compare ~prev_cell:t ~prev_cell_ptr slot + in + return (new_cell, cache) let add_confirmed_slots (t : t) cache slots = List.fold_left_e add_confirmed_slot (t, cache) slots -- GitLab From 5a11a6a12f89bf5bb2b6d101d875981649eaaa77 Mon Sep 17 00:00:00 2001 From: "iguerNL@Functori" Date: Mon, 12 Sep 2022 19:59:30 +0200 Subject: [PATCH 2/7] Proto/Dal: add a new RPC to retrieve slots_history skip list --- src/proto_alpha/lib_plugin/RPC.ml | 30 +++++++++++++++++++ src/proto_alpha/lib_protocol/alpha_context.ml | 1 + .../lib_protocol/alpha_context.mli | 4 +++ 3 files changed, 35 insertions(+) diff --git a/src/proto_alpha/lib_plugin/RPC.ml b/src/proto_alpha/lib_plugin/RPC.ml index f03f5b1ce3ec..6dad6da4ee7b 100644 --- a/src/proto_alpha/lib_plugin/RPC.ml +++ b/src/proto_alpha/lib_plugin/RPC.ml @@ -2291,6 +2291,35 @@ module Sc_rollup = struct commitment_hash end +module Dal = struct + module S = struct + let dal_confirmed_slots_history = + let output = Data_encoding.option Dal.Slots_history.encoding in + let query = RPC_query.(seal @@ query ()) in + RPC_service.get_service + ~description: + "Returns the value of the DAL confirmed slots history skip list if \ + DAL is enabled, or [None] otherwise." + ~output + ~query + RPC_path.(open_root / "context" / "dal" / "confirmed_slots_history") + end + + let register_dal_confirmed_slots_history () = + Registration.register0 + ~chunked:false + S.dal_confirmed_slots_history + (fun ctxt () () -> + if (Constants.parametric ctxt).dal.feature_enable then + Dal.Slots_storage.get_slots_history ctxt >|=? Option.some + else return None) + + let register () = register_dal_confirmed_slots_history () + + let dal_confirmed_slots_history ctxt block = + RPC_context.make_call0 S.dal_confirmed_slots_history ctxt block () () +end + module Tx_rollup = struct open Data_encoding @@ -3290,6 +3319,7 @@ let register () = Endorsing_rights.register () ; Validators.register () ; Sc_rollup.register () ; + Dal.register () ; Tx_rollup.register () ; Registration.register0 ~chunked:false S.current_level (fun ctxt q () -> if q.offset < 0l then fail Negative_level_offset diff --git a/src/proto_alpha/lib_protocol/alpha_context.ml b/src/proto_alpha/lib_protocol/alpha_context.ml index 77b3de3910ae..69dae1049e91 100644 --- a/src/proto_alpha/lib_protocol/alpha_context.ml +++ b/src/proto_alpha/lib_protocol/alpha_context.ml @@ -118,6 +118,7 @@ module Dal = struct end module Slots_history = Dal_slot_repr.Slots_history + module Slots_storage = Dal_slot_storage end module Dal_errors = Dal_errors_repr diff --git a/src/proto_alpha/lib_protocol/alpha_context.mli b/src/proto_alpha/lib_protocol/alpha_context.mli index 7e97861bf489..91f1226c6362 100644 --- a/src/proto_alpha/lib_protocol/alpha_context.mli +++ b/src/proto_alpha/lib_protocol/alpha_context.mli @@ -2844,6 +2844,10 @@ module Dal : sig val add_confirmed_slots : t -> History_cache.t -> Slot.t list -> (t * History_cache.t) tzresult end + + module Slots_storage : sig + val get_slots_history : t -> Slots_history.t tzresult Lwt.t + end end (** This module re-exports definitions from {!Dal_errors_repr}. *) -- GitLab From e6c08c084943633b4fbd8e211087f60246091703 Mon Sep 17 00:00:00 2001 From: "iguerNL@Functori" Date: Mon, 12 Sep 2022 20:00:12 +0200 Subject: [PATCH 3/7] Tezt/lib_tezos: bind new RPCs --- tezt/lib_tezos/RPC.ml | 22 ++++++++++++++++++++++ tezt/lib_tezos/RPC.mli | 12 ++++++++++++ 2 files changed, 34 insertions(+) diff --git a/tezt/lib_tezos/RPC.ml b/tezt/lib_tezos/RPC.ml index 902d1b4f5a6c..699e1c6f01c5 100644 --- a/tezt/lib_tezos/RPC.ml +++ b/tezt/lib_tezos/RPC.ml @@ -988,4 +988,26 @@ let get_chain_block_context_delegate_voting_power ?(chain = "main") ] Fun.id +let get_chain_block_context_dal_confirmed_slots_history ?(chain = "main") + ?(block = "head") () = + make + GET + [ + "chains"; + chain; + "blocks"; + block; + "context"; + "dal"; + "confirmed_slots_history"; + ] + Fun.id + +let get_chain_block_context_raw_json ?(chain = "main") ?(block = "head") + ?(path = []) () = + make + GET + (["chains"; chain; "blocks"; block; "context"; "raw"; "json"] @ path) + Fun.id + let make = RPC_core.make diff --git a/tezt/lib_tezos/RPC.mli b/tezt/lib_tezos/RPC.mli index 774f70d6e26d..732e64657902 100644 --- a/tezt/lib_tezos/RPC.mli +++ b/tezt/lib_tezos/RPC.mli @@ -845,3 +845,15 @@ val get_chain_block_context_delegate_voting_info : [block] defaults to ["head"]. *) val get_chain_block_context_delegate_voting_power : ?chain:string -> ?block:string -> string -> JSON.t t + +(** Call RPC /chains/[chain]/blocks/[block]/context/dal/confirmed_slots_history. + [chain] defaults to ["main"]. + [block] defaults to ["head"]. *) +val get_chain_block_context_dal_confirmed_slots_history : + ?chain:string -> ?block:string -> unit -> JSON.t t + +(** Call RPC /chains/[chain]/blocks/[block]/context/raw/json. + [chain] defaults to ["main"]. + [block] defaults to ["head"]. *) +val get_chain_block_context_raw_json : + ?chain:string -> ?block:string -> ?path:string list -> unit -> JSON.t t -- GitLab From 9d170e11ac56ef0819999da82c0a309bb8314c26 Mon Sep 17 00:00:00 2001 From: "iguerNL@Functori" Date: Mon, 12 Sep 2022 20:03:01 +0200 Subject: [PATCH 4/7] Tezt/Dal: add test for RPC context/dal/confirmed_slots_history --- tezt/tests/dal.ml | 45 ++++++++++++++++++++++++++++++--------------- 1 file changed, 30 insertions(+), 15 deletions(-) diff --git a/tezt/tests/dal.ml b/tezt/tests/dal.ml index 47acab5eb83b..67f000cf3029 100644 --- a/tezt/tests/dal.ml +++ b/tezt/tests/dal.ml @@ -218,6 +218,9 @@ let test_feature_flag _protocol _sc_rollup_node sc_rollup_address node client = let* block_metadata = RPC.(call node @@ get_chain_block_metadata ()) in if block_metadata.dal_slot_availability <> None then Test.fail "Did not expect to find \"dal_slot_availibility\"" ; + let* bytes = RPC_legacy.raw_bytes client in + if not JSON.(bytes |-> "dal" |> is_null) then + Test.fail "Unexpected entry dal in the context when DAL is disabled" ; unit let publish_slot ~source ?fee ~index ~message parameters cryptobox node client = @@ -231,6 +234,7 @@ let publish_slot ~source ?fee ~index ~message parameters cryptobox node client = client) let slot_availability ~signer availability client = + (* FIXME/DAL: fetch the constant from protocol parameters. *) let default_size = 256 in let endorsement = Array.make default_size false in List.iter (fun i -> endorsement.(i) <- true) availability ; @@ -277,6 +281,31 @@ let check_manager_operation_status result expected_status oph = status_typ ~error_msg:(prefix_msg ^ " Expected: %L. Got: %R.") +let check_dal_raw_context node = + let* dal_raw_json = + RPC.call node @@ RPC.get_chain_block_context_raw_json ~path:["dal"] () + in + if JSON.is_null dal_raw_json then + Test.fail "Expected the context to contain information under /dal key." + else + let json_to_string j = + JSON.unannotate j |> Ezjsonm.wrap |> Ezjsonm.to_string + in + let* confirmed_slots_opt = + RPC.call node (RPC.get_chain_block_context_dal_confirmed_slots_history ()) + in + if JSON.is_null confirmed_slots_opt then + Test.fail + "confirmed_slots_history RPC is not expected to return None if DAL is \ + enabled" ; + let confirmed_slots = json_to_string confirmed_slots_opt in + let confirmed_slots_from_ctxt = + json_to_string @@ JSON.(dal_raw_json |-> "slots_history") + in + if not (String.equal confirmed_slots confirmed_slots_from_ctxt) then + Test.fail "Confirmed slots history mismatch." ; + unit + let test_slot_management_logic = Protocol.register_test ~__FILE__ @@ -380,21 +409,7 @@ let test_slot_management_logic = (dal_slot_availability.(1) = true) bool ~error_msg:"Expected slot 1 to be available") ; - let* bytes = RPC_legacy.raw_bytes client in - let dal_keys = ["slots_history"] in - match JSON.(bytes |-> "dal" |> as_object_opt) with - | None -> - Test.fail - "Expected the context to contain information about the DAL (%a)." - Format.(pp_print_list (fun fmt -> fprintf fmt "%s")) - dal_keys - | Some l -> - List.iter - (fun (k, _) -> - if not @@ List.mem k dal_keys then - Test.fail "Unexpected entry %s in context/DAL" k) - l ; - unit + check_dal_raw_context node (* Tests for integration between Dal and Scoru *) let rollup_node_subscribes_to_dal_slots _protocol sc_rollup_node -- GitLab From 4c710e5eb120315a88600e3f16ed3bbab6756586 Mon Sep 17 00:00:00 2001 From: "iguerNL@Functori" Date: Fri, 2 Sep 2022 17:51:10 +0200 Subject: [PATCH 5/7] Proto/DAL: save confirmed slots headers & cache in scoru node's store --- src/proto_alpha/bin_sc_rollup_node/store.ml | 32 +++++++++++++++++++ .../lib_protocol/dal_slot_repr.mli | 11 +++++++ 2 files changed, 43 insertions(+) diff --git a/src/proto_alpha/bin_sc_rollup_node/store.ml b/src/proto_alpha/bin_sc_rollup_node/store.ml index 4f65fa49a5bb..6c3f3a50b748 100644 --- a/src/proto_alpha/bin_sc_rollup_node/store.ml +++ b/src/proto_alpha/bin_sc_rollup_node/store.ml @@ -324,3 +324,35 @@ module Dal_confirmed_slots = Make_nested_map (struct include Block_slot_map_parameter end) + +(** Confirmed DAL slots history. See documentation of + {Dal_slot_repr.Slots_history} for more details. *) +module Dal_confirmed_slots_history = Make_append_only_map (struct + let path = ["dal"; "confirmed_slots_history"] + + let keep_last_n_entries_in_memory = 10 + + type key = Block_hash.t + + let string_of_key = Block_hash.to_b58check + + type value = Dal.Slots_history.t + + let value_encoding = Dal.Slots_history.encoding +end) + +(** Confirmed DAL slots histories cache. See documentation of + {Dal_slot_repr.Slots_history} for more details. *) +module Dal_confirmed_slots_histories = Make_append_only_map (struct + let path = ["dal"; "confirmed_slots_histories_cache"] + + let keep_last_n_entries_in_memory = 10 + + type key = Block_hash.t + + let string_of_key = Block_hash.to_b58check + + type value = Dal.Slots_history.Cache.t + + let value_encoding = Dal.Slots_history.Cache.encoding +end) diff --git a/src/proto_alpha/lib_protocol/dal_slot_repr.mli b/src/proto_alpha/lib_protocol/dal_slot_repr.mli index 9f93381aab87..79e0662d7598 100644 --- a/src/proto_alpha/lib_protocol/dal_slot_repr.mli +++ b/src/proto_alpha/lib_protocol/dal_slot_repr.mli @@ -168,6 +168,17 @@ module Slot_market : sig val candidates : t -> slot list end +(** This module provides an abstract data structure (type {!t}) that represents a + skip list used to store successive DAL slots confirmed on L1. There is one + slot per cell in the skip list. The slots are sorted in increasing order by + level, and by slot index, for the slots of the same level. + + This module also defines a bounded history cache (type {History_cache.t}) + that allows to remember recent values of a skip list of type {!t} + (indexed by the skip lists' hashes). This structure is meant to be + maintained and used by the rollup node to produce refutation proofs + involving DAL slot inputs. +*) module Slots_history : sig (** Abstract representation of a skip list specialized for confirmed slot headers. *) -- GitLab From 2caf0104560e7ebd3c2db19013ef39e94d866563 Mon Sep 17 00:00:00 2001 From: "iguerNL@Functori" Date: Fri, 9 Sep 2022 11:13:17 +0200 Subject: [PATCH 6/7] Proto/Dal: remove unused function in Dal_slots_tracker --- src/proto_alpha/bin_sc_rollup_node/dal_slots_tracker.ml | 2 +- src/proto_alpha/bin_sc_rollup_node/dal_slots_tracker.mli | 3 --- 2 files changed, 1 insertion(+), 4 deletions(-) diff --git a/src/proto_alpha/bin_sc_rollup_node/dal_slots_tracker.ml b/src/proto_alpha/bin_sc_rollup_node/dal_slots_tracker.ml index 9d828cb2c43a..ca40dd1abaab 100644 --- a/src/proto_alpha/bin_sc_rollup_node/dal_slots_tracker.ml +++ b/src/proto_alpha/bin_sc_rollup_node/dal_slots_tracker.ml @@ -187,4 +187,4 @@ let process_head node_ctxt head = let* () = fetch_and_save_subscribed_slot_headers node_ctxt head in compute_and_save_confirmed_slot_headers node_ctxt head -let start () = Lwt.return () +let get_slots_history_of_hash = X.State.slots_history_of_hash diff --git a/src/proto_alpha/bin_sc_rollup_node/dal_slots_tracker.mli b/src/proto_alpha/bin_sc_rollup_node/dal_slots_tracker.mli index 78cae8869288..8849542988c5 100644 --- a/src/proto_alpha/bin_sc_rollup_node/dal_slots_tracker.mli +++ b/src/proto_alpha/bin_sc_rollup_node/dal_slots_tracker.mli @@ -44,6 +44,3 @@ type error += Cannot_read_block_metadata of Block_hash.t [Store.Dal_confirmed_slots].} } *) val process_head : Node_context.t -> Layer1.head -> unit tzresult Lwt.t - -(** [start ()] initializes the Dal_slot_tracker to track the dal slot subscriptions. *) -val start : unit -> unit Lwt.t -- GitLab From b1f48a4712009ac43e9f41c52d2f28c608f1372c Mon Sep 17 00:00:00 2001 From: "iguerNL@Functori" Date: Fri, 9 Sep 2022 11:56:53 +0200 Subject: [PATCH 7/7] Proto/Dal: Compute & save slots history&cache in scoru node --- .../bin_sc_rollup_node/dal_slots_tracker.ml | 148 +++++++++++++++--- src/proto_alpha/bin_sc_rollup_node/store.ml | 4 +- 2 files changed, 130 insertions(+), 22 deletions(-) diff --git a/src/proto_alpha/bin_sc_rollup_node/dal_slots_tracker.ml b/src/proto_alpha/bin_sc_rollup_node/dal_slots_tracker.ml index ca40dd1abaab..d8161819b31f 100644 --- a/src/proto_alpha/bin_sc_rollup_node/dal_slots_tracker.ml +++ b/src/proto_alpha/bin_sc_rollup_node/dal_slots_tracker.ml @@ -85,7 +85,7 @@ let common_slot_indexes (l : Dal.Slot_index.t list) (r : Dal.Slot_index.t list) let r_set = Slot_set.of_list r in Slot_set.elements @@ Slot_set.inter l_set r_set -(* [confirmed_slots node_ctxt head] reads the slot indexes that have been +(** [confirmed_slots node_ctxt head] reads the slot indexes that have been declared available from [head]'s block receipt, and returns the list of confirmed slots to which the rollup is subscribed to, with the corresponding slot header. *) @@ -166,25 +166,133 @@ let confirmed_slots node_ctxt (Layer1.Head {hash; _} as head) = return confirmed_slot_indexes_with_header -let compute_and_save_confirmed_slot_headers node_ctxt - (Layer1.Head {hash; _} as head) = - let open Lwt_result_syntax in - let* slots_to_save = confirmed_slots node_ctxt head in - let*! () = - List.iter_s - (fun ({Dal.Slot.index; _} as slot) -> - Store.Dal_confirmed_slots.add - node_ctxt.store - ~primary_key:hash - ~secondary_key:index - slot) - slots_to_save - in - return_unit +let save_confirmed_slot_headers node_ctxt hash slots_to_save = + List.iter_s + (fun ({Dal.Slot.index; _} as slot) -> + Store.Dal_confirmed_slots.add + node_ctxt.Node_context.store + ~primary_key:hash + ~secondary_key:index + slot) + slots_to_save + >|= ok + +module Confirmed_slots_history = struct + let read_slots_history_from_l1 {Node_context.l1_ctxt = {cctxt; _}; _} block = + let open Lwt_result_syntax in + (* We return the empty Slots_history if DAL is not enabled. *) + let* slots_list_opt = + RPC.Dal.dal_confirmed_slots_history cctxt (cctxt#chain, `Hash (block, 0)) + in + return @@ Option.value slots_list_opt ~default:Dal.Slots_history.genesis + + let slots_history_of_hash node_ctxt block_hash = + let open Lwt_result_syntax in + let open Node_context in + let*! confirmed_slots_history_opt = + Store.Dal_confirmed_slots_history.find node_ctxt.store block_hash + in + match confirmed_slots_history_opt with + | Some confirmed_dal_slots -> return confirmed_dal_slots + | None -> + let*! block_level = Layer1.level_of_hash node_ctxt.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 + (* We won't find "dal slots history" for blocks before the + rollup origination level in the node's store. In this case, we get + the value of the skip list form L1 in case DAL is enabled, or the + genesis DAL skip list otherwise. *) + read_slots_history_from_l1 node_ctxt block_hash + else + (* We won't find "dal slots history" for blocks after the rollup + origination level. This should not happen in normal circumstances. *) + failwith + "The confirmed DAL slots history for block hash %a (level = %a) is \ + missing." + Block_hash.pp + block_hash + Raw_level.pp + block_level -let process_head node_ctxt head = + let slots_history_cache_of_hash node_ctxt block_hash = + let open Lwt_result_syntax in + let open Node_context in + let*! confirmed_slots_history_cache_opt = + Store.Dal_confirmed_slots_histories.find node_ctxt.store block_hash + in + match confirmed_slots_history_cache_opt with + | Some cache -> return cache + | None -> + let*! block_level = Layer1.level_of_hash node_ctxt.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 + (* We won't find "dal slots history cache" for blocks before the + rollup origination level. In this case, we initialize with the + empty cache. *) + let num_slots = + node_ctxt.Node_context.protocol_constants.parametric.dal + .number_of_slots + in + (* FIXME/DAL: https://gitlab.com/tezos/tezos/-/issues/3788 + Put an accurate value for capacity. The value + `num_slots * 60000` below is chosen based on: + - The number of remembered L1 inboxes in their corresponding + cache (60000), + - The (max) number of slots (num_slots) that could be attested + per L1 block, + - The way the Slots_history.t skip list is implemented (one slot + per cell). *) + return + @@ Dal.Slots_history.History_cache.empty + ~capacity:(Int64.of_int @@ (num_slots * 60000)) + else + (* We won't find "dal slots history cache" for blocks after the rollup + origination level. This should not happen in normal circumstances. *) + failwith + "The confirmed DAL slots history cache for block hash %a (level = \ + %a) is missing." + Block_hash.pp + block_hash + Raw_level.pp + block_level + + let update (Node_context.{store; _} as node_ctxt) + Layer1.(Head {hash = head_hash; _} as head) slots_to_save = + let open Lwt_result_syntax in + let slots_to_save = + let open Dal in + List.fast_sort + (fun {Slot.index = a; _} {Slot.index = b; _} -> Slot_index.compare a b) + slots_to_save + in + let*! pred = Layer1.predecessor store head in + let* slots_history = slots_history_of_hash node_ctxt pred in + let* slots_cache = slots_history_cache_of_hash node_ctxt pred in + let*? slots_history, slots_cache = + Dal.Slots_history.add_confirmed_slots + slots_history + slots_cache + slots_to_save + |> Environment.wrap_tzresult + in + (* The value of [slots_history] computed here is supposed to be equal to the + one computed stored for block [head_hash] on L1, we basically re-do the + computation here because we need to build/maintain the [slots_cache] + bounded cache in case we need it for refutation game. *) + (* TODO/DAL: https://gitlab.com/tezos/tezos/-/issues/3856 + Attempt to improve this process. *) + let*! () = + Store.Dal_confirmed_slots_history.add store head_hash slots_history + in + let*! () = + Store.Dal_confirmed_slots_histories.add store head_hash slots_cache + in + return () +end + +let process_head node_ctxt (Layer1.Head {hash = head_hash; _} as head) = let open Lwt_result_syntax in let* () = fetch_and_save_subscribed_slot_headers node_ctxt head in - compute_and_save_confirmed_slot_headers node_ctxt head - -let get_slots_history_of_hash = X.State.slots_history_of_hash + let* slots_to_save = confirmed_slots node_ctxt head in + let* () = save_confirmed_slot_headers node_ctxt head_hash slots_to_save in + Confirmed_slots_history.update node_ctxt head slots_to_save diff --git a/src/proto_alpha/bin_sc_rollup_node/store.ml b/src/proto_alpha/bin_sc_rollup_node/store.ml index 6c3f3a50b748..e2d7b770a5d0 100644 --- a/src/proto_alpha/bin_sc_rollup_node/store.ml +++ b/src/proto_alpha/bin_sc_rollup_node/store.ml @@ -352,7 +352,7 @@ module Dal_confirmed_slots_histories = Make_append_only_map (struct let string_of_key = Block_hash.to_b58check - type value = Dal.Slots_history.Cache.t + type value = Dal.Slots_history.History_cache.t - let value_encoding = Dal.Slots_history.Cache.encoding + let value_encoding = Dal.Slots_history.History_cache.encoding end) -- GitLab