From a234560d25c9a41e30c902d28241e28fd1fe04a6 Mon Sep 17 00:00:00 2001 From: "iguerNL@Functori" Date: Tue, 7 Oct 2025 15:34:32 +0200 Subject: [PATCH 1/4] DAL/Tezt: temporarily disable tests that use non legacy attestation lag These tests currently fail on the CI, but they're re-enabled (and succeed) in MR https://gitlab.com/tezos/tezos/-/merge_requests/19509 --- tezt/tests/dal.ml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/tezt/tests/dal.ml b/tezt/tests/dal.ml index 38b188552bf2..83a6ccc301d6 100644 --- a/tezt/tests/dal.ml +++ b/tezt/tests/dal.ml @@ -11488,6 +11488,7 @@ let register ~protocols = ~uses:(fun _protocol -> [Constant.octez_agnostic_baker]) ~attestation_threshold:100 ~attestation_lag:16 + ~tags:[Tag.ci_disabled] ~activation_timestamp:Now ~number_of_slots:8 ~operator_profiles:[0; 1; 2; 3; 4; 5; 6; 7] @@ -11733,6 +11734,7 @@ let register ~protocols = ~slot_size:(1 lsl 15) ~redundancy_factor:8 ~attestation_lag:4 + ~tags:[Tag.ci_disabled] ~page_size:128 test_reveal_dal_page_in_fast_exec_wasm_pvm protocols ; @@ -11747,6 +11749,7 @@ let register ~protocols = ~redundancy_factor:8 ~page_size:128 ~attestation_lag:4 + ~tags:[Tag.ci_disabled] Tx_kernel_e2e.test_tx_kernel_e2e protocols ; scenario_with_all_nodes -- GitLab From ebcdc6dcc3397b2e29f655bbeada57410cc0aa30 Mon Sep 17 00:00:00 2001 From: "iguerNL@Functori" Date: Mon, 6 Oct 2025 11:59:26 +0200 Subject: [PATCH 2/4] DAL/Proto: semantics/hash-preserving refactoring of cells encoding --- src/proto_alpha/lib_protocol/dal_slot_repr.ml | 101 +++++++++--------- 1 file changed, 51 insertions(+), 50 deletions(-) diff --git a/src/proto_alpha/lib_protocol/dal_slot_repr.ml b/src/proto_alpha/lib_protocol/dal_slot_repr.ml index e358b076caaf..bc19c9c89f5c 100644 --- a/src/proto_alpha/lib_protocol/dal_slot_repr.ml +++ b/src/proto_alpha/lib_protocol/dal_slot_repr.ml @@ -417,62 +417,63 @@ module History = struct let encoding = let open Data_encoding in - union - ~tag_size:`Uint8 - [ - case - ~title:"unpublished" - (Tag 2) - (merge_objs - (obj1 (req "kind" (constant "unpublished"))) - Header.id_encoding) - (function - | Unpublished slot_id -> Some ((), slot_id) | Published _ -> None) - (fun ((), slot_id) -> Unpublished slot_id); - case - ~title:"published" - (Tag 3) - (merge_objs - (obj5 - (req "kind" (constant "published")) - (req "publisher" Contract_repr.encoding) - (req "is_proto_attested" bool) - (req "attested_shards" uint16) - (req "total_shards" uint16)) - Header.encoding) - (function - | Unpublished _ -> None - | Published - { - header; - publisher; - is_proto_attested; - attested_shards; - total_shards; - } -> - Some - ( ( (), - publisher, - is_proto_attested, - attested_shards, - total_shards ), - header )) - (fun ( ( (), - publisher, - is_proto_attested, - attested_shards, - total_shards ), - header ) - -> - Published + let legacy_unpublished_case = + case + ~title:"unpublished" + (Tag 2) + (merge_objs + (obj1 (req "kind" (constant "unpublished"))) + Header.id_encoding) + (function + | Unpublished slot_id -> Some ((), slot_id) | Published _ -> None) + (fun ((), slot_id) -> Unpublished slot_id) + in + let legacy_published_case = + case + ~title:"published" + (Tag 3) + (merge_objs + (obj5 + (req "kind" (constant "published")) + (req "publisher" Contract_repr.encoding) + (req "is_proto_attested" bool) + (req "attested_shards" uint16) + (req "total_shards" uint16)) + Header.encoding) + (function + | Unpublished _ -> None + | Published { header; publisher; is_proto_attested; attested_shards; total_shards; - }); - ] + } -> + Some + ( ( (), + publisher, + is_proto_attested, + attested_shards, + total_shards ), + header )) + (fun ( ( (), + publisher, + is_proto_attested, + attested_shards, + total_shards ), + header ) + -> + Published + { + header; + publisher; + is_proto_attested; + attested_shards; + total_shards; + }) + in + union ~tag_size:`Uint8 [legacy_unpublished_case; legacy_published_case] let equal t1 t2 = match (t1, t2) with -- GitLab From 0ebec8770b33bd6cf0c2dcd99e46f230cbb43f7e Mon Sep 17 00:00:00 2001 From: "iguerNL@Functori" Date: Mon, 6 Oct 2025 09:54:54 +0200 Subject: [PATCH 3/4] DAL/Proto: prepare for the extension of skip-list cells with the lag (1) The introduced types will be used in the next commit. The type attestation_lag_kind will be extended in the next MR. --- .../lib_protocol/alpha_context.mli | 11 ++++++++ src/proto_alpha/lib_protocol/dal_slot_repr.ml | 28 +++++++++++++++++++ .../lib_protocol/dal_slot_repr.mli | 16 +++++++++++ 3 files changed, 55 insertions(+) diff --git a/src/proto_alpha/lib_protocol/alpha_context.mli b/src/proto_alpha/lib_protocol/alpha_context.mli index c9e9a404e6c6..73876b4ed104 100644 --- a/src/proto_alpha/lib_protocol/alpha_context.mli +++ b/src/proto_alpha/lib_protocol/alpha_context.mli @@ -3098,6 +3098,17 @@ module Dal : sig module Slots_history : sig type t + type attestation_lag_kind = Legacy + + val attestation_lag_value : attestation_lag_kind -> int + + val legacy_attestation_lag : int + + type cell_id = { + header_id : Slot.Header.id; + attestation_lag : attestation_lag_kind; + } + type cell_content = private | Unpublished of Slot.Header.id | Published of { diff --git a/src/proto_alpha/lib_protocol/dal_slot_repr.ml b/src/proto_alpha/lib_protocol/dal_slot_repr.ml index bc19c9c89f5c..dce895908dec 100644 --- a/src/proto_alpha/lib_protocol/dal_slot_repr.ml +++ b/src/proto_alpha/lib_protocol/dal_slot_repr.ml @@ -335,6 +335,34 @@ module History = struct (* History is represented via a skip list. The content of the cell is the hash of a merkle proof. *) + type attestation_lag_kind = Legacy + + (** The legacy attestation lag used by mainnet, ghostnet and shadownet *) + let legacy_attestation_lag = 8 + + let attestation_lag_value = function Legacy -> legacy_attestation_lag + + let attestation_lag_kind_equal lag1 lag2 = + match (lag1, lag2) with Legacy, Legacy -> true + + let pp_attestation_lag_kind fmt = function + | Legacy -> Format.fprintf fmt "Legacy:%d" legacy_attestation_lag + + type cell_id = {header_id : Header.id; attestation_lag : attestation_lag_kind} + + let _cell_id_equal cid1 cid2 = + attestation_lag_kind_equal cid1.attestation_lag cid2.attestation_lag + && Header.slot_id_equal cid1.header_id cid2.header_id + + let _pp_cell_id fmt {header_id; attestation_lag} = + Format.fprintf + fmt + "{slot_id:%a, lag:%a}" + Header.pp_id + header_id + pp_attestation_lag_kind + attestation_lag + module Content_prefix = struct let (_prefix : string) = "dash1" diff --git a/src/proto_alpha/lib_protocol/dal_slot_repr.mli b/src/proto_alpha/lib_protocol/dal_slot_repr.mli index 36f3ff31e5aa..7f350ef749a3 100644 --- a/src/proto_alpha/lib_protocol/dal_slot_repr.mli +++ b/src/proto_alpha/lib_protocol/dal_slot_repr.mli @@ -279,6 +279,22 @@ module History : sig confirmed slot headers. *) type t + (** Storing attestation lag in the cells of skip-lists in a retro-compatible + way. This first step is to introduce the needed code for the extension. *) + type attestation_lag_kind = Legacy + + (** Returns the value of attestation_lag parameter based on the given + attestation_lag_kind. *) + val attestation_lag_value : attestation_lag_kind -> int + + (** Value of the attestation lag used by protocols prior to T. It's the same + on all the networks we upgrade (e.g., mainnet, ghostnet and shadownet). *) + val legacy_attestation_lag : int + + (** Identify a cell not only by its published_level + slot_index (Header.id), + but also by the attestation lag that applied when it was attested. *) + type cell_id = {header_id : Header.id; attestation_lag : attestation_lag_kind} + (** The content of a cell in the DAL skip list. We have [number_of_slots] new cells per level (one per slot index). For a given slot index in [0..number_of_slots-1], the commitment is either [Unpublished] or -- GitLab From 61940f70c2d4e78c6d9558e23eec3e417fb590b6 Mon Sep 17 00:00:00 2001 From: "iguerNL@Functori" Date: Tue, 7 Oct 2025 11:23:41 +0200 Subject: [PATCH 4/4] DAL/Proto: prepare for the extension of SL cells with attestation lag (2) In this first case, the skip list cells are almost able to store non-legacy attestation lags. But this MR is kept simple to preserve compatiblity: All the code introduced here should be a "no-op" from a semantics point of view --- .../lib_dal/dal_plugin_registration.ml | 64 ++++++++++++-- .../lib_protocol/alpha_context.mli | 5 +- src/proto_alpha/lib_protocol/dal_slot_repr.ml | 84 +++++++++++++------ .../lib_protocol/dal_slot_repr.mli | 12 ++- .../lib_protocol/test/helpers/dal_helpers.ml | 3 +- .../lib_sc_rollup_node/dal_pages_request.ml | 2 +- 6 files changed, 129 insertions(+), 41 deletions(-) diff --git a/src/proto_alpha/lib_dal/dal_plugin_registration.ml b/src/proto_alpha/lib_dal/dal_plugin_registration.ml index 017ffe36f8bd..a9dc8002074f 100644 --- a/src/proto_alpha/lib_dal/dal_plugin_registration.ml +++ b/src/proto_alpha/lib_dal/dal_plugin_registration.ml @@ -42,7 +42,13 @@ module Plugin = struct let tb_slot_to_int tb_slot = Slot.to_int tb_slot - type error += Aggregation_result_size_error + type error += + | Aggregation_result_size_error + | Attested_level_mismatch of { + attested_level : int32; + published_level : int32; + attestation_lag : int; + } let () = Protocol_client_context.register_error_kind @@ -61,6 +67,36 @@ module Plugin = struct (function Aggregation_result_size_error -> Some () | _ -> None) (fun () -> Aggregation_result_size_error) + let () = + Protocol_client_context.register_error_kind + `Permanent + ~id:"Attested_level_mismatch" + ~title:"Mismatch between computed and given attested level" + ~description: + "Mismatch between the given attested level and the computed one from \ + published_level and the lag" + ~pp:(fun ppf (attested_level, published_level, attestation_lag) -> + Format.fprintf + ppf + "Mismatch between the given attested level %ld and the computed one \ + as %ld + %d." + attested_level + published_level + attestation_lag) + Data_encoding.( + obj3 + (req "attested_level" int32) + (req "published_level" int32) + (req "attestation_lag" int8)) + (function + | Attested_level_mismatch + {attested_level; published_level; attestation_lag} -> + Some (attested_level, published_level, attestation_lag) + | _ -> None) + (fun (attested_level, published_level, attestation_lag) -> + Attested_level_mismatch + {attested_level; published_level; attestation_lag}) + let parametric_constants chain block ctxt = let cpctxt = new Protocol_client_context.wrap_rpc_context ctxt in Plugin.Constants_services.parametric cpctxt (chain, block) @@ -361,7 +397,7 @@ module Plugin = struct (* 1. There are no cells for [published_level = 0]. *) if published_level <= 0l then return [] else - let+ cells = + let* cells = Plugin.RPC.Dal.skip_list_cells_of_level cpctxt (`Main, `Level attested_level) @@ -369,14 +405,26 @@ module Plugin = struct in (* 2. For other levels, fetch the cells and retrieve the slot indices from the cells' content. *) - List.map + let module H = Dal.Slots_history in + List.map_es (fun (hash, cell) -> - let slot_index = - Dal.( - Slots_history.(content cell |> content_id).index - |> Slot_index.to_int) + let cell_id = H.(content cell |> content_id) in + let slot_id = cell_id.H.header_id in + let slot_index = Dal.Slot_index.to_int slot_id.index in + let* () = + let attestation_lag = + H.attestation_lag_value cell_id.attestation_lag + in + let expected_attested_level = + Raw_level.( + add slot_id.published_level attestation_lag |> to_int32) + in + fail_unless + (Int32.equal attested_level expected_attested_level) + (Attested_level_mismatch + {attested_level; published_level; attestation_lag}) in - (hash, cell, slot_index)) + return (hash, cell, slot_index)) cells let slot_header_of_cell cell = diff --git a/src/proto_alpha/lib_protocol/alpha_context.mli b/src/proto_alpha/lib_protocol/alpha_context.mli index 73876b4ed104..e7eeb063325f 100644 --- a/src/proto_alpha/lib_protocol/alpha_context.mli +++ b/src/proto_alpha/lib_protocol/alpha_context.mli @@ -3110,9 +3110,10 @@ module Dal : sig } type cell_content = private - | Unpublished of Slot.Header.id + | Unpublished of cell_id | Published of { header : Slot.Header.t; + attestation_lag : attestation_lag_kind; publisher : Contract.t; is_proto_attested : bool; attested_shards : int; @@ -3121,7 +3122,7 @@ module Dal : sig val content : t -> cell_content - val content_id : cell_content -> Slot.Header.id + val content_id : cell_content -> cell_id val pp : Format.formatter -> t -> unit diff --git a/src/proto_alpha/lib_protocol/dal_slot_repr.ml b/src/proto_alpha/lib_protocol/dal_slot_repr.ml index dce895908dec..ccb8f536180a 100644 --- a/src/proto_alpha/lib_protocol/dal_slot_repr.ml +++ b/src/proto_alpha/lib_protocol/dal_slot_repr.ml @@ -350,11 +350,11 @@ module History = struct type cell_id = {header_id : Header.id; attestation_lag : attestation_lag_kind} - let _cell_id_equal cid1 cid2 = + let cell_id_equal cid1 cid2 = attestation_lag_kind_equal cid1.attestation_lag cid2.attestation_lag && Header.slot_id_equal cid1.header_id cid2.header_id - let _pp_cell_id fmt {header_id; attestation_lag} = + let pp_cell_id fmt {header_id; attestation_lag} = Format.fprintf fmt "{slot_id:%a, lag:%a}" @@ -430,9 +430,10 @@ module History = struct kind of DAC using the DAL infra), the skip list will not require a migration. *) type t = - | Unpublished of Header.id + | Unpublished of cell_id | Published of { header : Header.t; + attestation_lag : attestation_lag_kind; publisher : Contract_repr.t; is_proto_attested : bool; attested_shards : int; @@ -440,8 +441,9 @@ module History = struct } let content_id = function - | Unpublished slot_id -> slot_id - | Published {header = {id; _}; _} -> id + | Unpublished cell_id -> cell_id + | Published {attestation_lag; header = {id; _}; _} -> + {attestation_lag; header_id = id} let encoding = let open Data_encoding in @@ -453,8 +455,11 @@ module History = struct (obj1 (req "kind" (constant "unpublished"))) Header.id_encoding) (function - | Unpublished slot_id -> Some ((), slot_id) | Published _ -> None) - (fun ((), slot_id) -> Unpublished slot_id) + | Unpublished {header_id; attestation_lag = Legacy} -> + Some ((), header_id) + | Published _ -> None) + (fun ((), header_id) -> + Unpublished {header_id; attestation_lag = Legacy}) in let legacy_published_case = case @@ -473,6 +478,7 @@ module History = struct | Published { header; + attestation_lag = Legacy; publisher; is_proto_attested; attested_shards; @@ -495,6 +501,7 @@ module History = struct Published { header; + attestation_lag = Legacy; publisher; is_proto_attested; attested_shards; @@ -505,10 +512,11 @@ module History = struct let equal t1 t2 = match (t1, t2) with - | Unpublished sid1, Unpublished sid2 -> Header.slot_id_equal sid1 sid2 + | Unpublished cid1, Unpublished cid2 -> cell_id_equal cid1 cid2 | ( Published { header; + attestation_lag; publisher; is_proto_attested; attested_shards; @@ -516,6 +524,7 @@ module History = struct }, Published sh ) -> Header.equal header sh.header + && attestation_lag_kind_equal attestation_lag sh.attestation_lag && Contract_repr.equal publisher sh.publisher && Compare.Bool.equal is_proto_attested sh.is_proto_attested && Compare.Int.equal attested_shards sh.attested_shards @@ -525,21 +534,33 @@ module History = struct let zero, zero_level = let zero_level = Raw_level_repr.root in let zero_index = Dal_slot_index_repr.zero in - ( Unpublished {published_level = zero_level; index = zero_index}, + ( Unpublished + { + header_id = {published_level = zero_level; index = zero_index}; + attestation_lag = Legacy; + }, zero_level ) let pp fmt = function - | Unpublished slot_id -> - Format.fprintf fmt "Unpublished (%a)" Header.pp_id slot_id + | Unpublished cid -> Format.fprintf fmt "Unpublished (%a)" pp_cell_id cid | Published - {header; publisher; is_proto_attested; attested_shards; total_shards} - -> + { + header; + attestation_lag; + publisher; + is_proto_attested; + attested_shards; + total_shards; + } -> Format.fprintf fmt - "Published { @[header: %a@] @[publisher: %a@] @[is_proto_attested: \ - %b@] @[attested_shards: %d@] @[total_shards: %d@] }" + "Published { @[header: %a@] @[lag: %a@] @[publisher: %a@] \ + @[is_proto_attested: %b@] @[attested_shards: %d@] @[total_shards: \ + %d@] }" Header.pp header + pp_attestation_lag_kind + attestation_lag Contract_repr.pp publisher is_proto_attested @@ -553,7 +574,7 @@ module History = struct module Mk_skip_list (Content : sig type t - val content_id : t -> Header.id + val content_id : t -> cell_id end) = struct include Skip_list.Make (Skip_list_parameters) @@ -574,6 +595,10 @@ module History = struct guarantee that it can only be called with the adequate compare function. *) let next ~prev_cell ~prev_cell_ptr ~number_of_slots elt = + (* When migrating from protocol P1 to P2 and activate non-legacy + attestation lag, we ignore attestation_lag when pushing new + cells. We'll still use the existing invariant, which is expected to + hold after the lag reduction and with the planned migration process. *) let open Result_syntax in let well_ordered = (* For each cell we insert in the skip list, we ensure that it complies @@ -584,10 +609,10 @@ module History = struct * The first inserted slot's index for the current level is 0 - Or, levels are equal, but slot indices are successive. *) let Header.{published_level = l1; index = i1} = - content prev_cell |> Content.content_id + (content prev_cell |> Content.content_id).header_id in let Header.{published_level = l2; index = i2} = - Content.content_id elt + (Content.content_id elt).header_id in (Raw_level_repr.equal l2 (Raw_level_repr.succ l1) && Compare.Int.(Dal_slot_index_repr.to_int i1 = number_of_slots - 1) @@ -603,12 +628,19 @@ module History = struct return @@ next ~prev_cell ~prev_cell_ptr elt let search = + (* When migrating from protocol P1 to P2 and activate non-legacy + attestation lag, we ignore attestation_lag when comparing + values. We'll still use the existing compare, which is expected to + behave as expected after the lag reduction and with the planned + migration process . *) let compare_with_slot_id (target_slot_id : Header.id) (content : Content.t) = let Header.{published_level = target_level; index = target_index} = target_slot_id in - let Header.{published_level; index} = Content.content_id content in + let Header.{published_level; index} = + (Content.content_id content).header_id + in let c = Raw_level_repr.compare published_level target_level in if Compare.Int.(c <> 0) then c else Dal_slot_index_repr.compare index target_index @@ -713,7 +745,7 @@ module History = struct let open Result_syntax in let prev_cell_ptr = hash t in let Header.{published_level; _} = - Skip_list.content t |> Content.content_id + (Skip_list.content t |> Content.content_id).header_id in let* new_head = if Raw_level_repr.equal published_level genesis_level then @@ -740,7 +772,7 @@ module History = struct in [attested_slot_headers], an unattested slot id is inserted in [l], - [l] is well sorted wrt. slots indices. *) - let fill_slot_headers ~number_of_slots ~published_level + let fill_slot_headers ~number_of_slots ~published_level ~attestation_lag slot_headers_with_statuses = let open Result_syntax in let module I = Dal_slot_index_repr in @@ -748,7 +780,8 @@ module History = struct I.slots_range ~number_of_slots ~lower:0 ~upper:(number_of_slots - 1) in let mk_unpublished index = - Content.Unpublished Header.{published_level; index} + Content.Unpublished + {header_id = Header.{published_level; index}; attestation_lag} in (* Hypothesis: both lists are sorted in increasing order w.r.t. slots indices. *) @@ -768,6 +801,7 @@ module History = struct Published { header = s; + attestation_lag; publisher; is_proto_attested; attested_shards; @@ -804,6 +838,7 @@ module History = struct fill_slot_headers ~number_of_slots ~published_level + ~attestation_lag:Legacy slot_headers_with_statuses in List.fold_left_e (add_cell ~number_of_slots) (t, cache) slot_headers @@ -1415,7 +1450,7 @@ module History = struct let cell_content = Skip_list.content target_cell in (* We check that the target cell has the same level and index than the page we're about to prove. *) - let cell_id = Content.content_id cell_content in + let cell_id = (Content.content_id cell_content).header_id in let* () = error_when Raw_level_repr.(cell_id.published_level <> published_level) @@ -1474,9 +1509,10 @@ module History = struct (attestation_threshold_percent, restricted_commitments_publishers) type cell_content = Content_v2.t = - | Unpublished of Header.id + | Unpublished of cell_id | Published of { header : Header.t; + attestation_lag : attestation_lag_kind; publisher : Contract_repr.t; is_proto_attested : bool; attested_shards : int; diff --git a/src/proto_alpha/lib_protocol/dal_slot_repr.mli b/src/proto_alpha/lib_protocol/dal_slot_repr.mli index 7f350ef749a3..8d92d2f4dd5e 100644 --- a/src/proto_alpha/lib_protocol/dal_slot_repr.mli +++ b/src/proto_alpha/lib_protocol/dal_slot_repr.mli @@ -301,11 +301,14 @@ module History : sig [Published]. In this second case, we attach extra information in addition to the id such as the commitment, the publisher, the number of attested shards and whether the commitment is attested from the point of view of - the protocol. *) + the protocol. In both cases, the content carries the attestation lag used + to push the cell into the skip list (as attested, unattested or + unpublished ). *) type cell_content = private - | Unpublished of Header.id + | Unpublished of cell_id | Published of { header : Header.t; + attestation_lag : attestation_lag_kind; publisher : Contract_repr.t; is_proto_attested : bool; attested_shards : int; @@ -317,8 +320,9 @@ module History : sig val pp_content : Format.formatter -> cell_content -> unit - (** Returns the slot id of the cell whose content is given. *) - val content_id : cell_content -> Header.id + (** Returns the slot id and the attestation lag of the cell whose content is + given. *) + val content_id : cell_content -> cell_id module Pointer_hash : S.HASH diff --git a/src/proto_alpha/lib_protocol/test/helpers/dal_helpers.ml b/src/proto_alpha/lib_protocol/test/helpers/dal_helpers.ml index 94b4676fa07e..f516f1987bf8 100644 --- a/src/proto_alpha/lib_protocol/test/helpers/dal_helpers.ml +++ b/src/proto_alpha/lib_protocol/test/helpers/dal_helpers.ml @@ -69,8 +69,7 @@ let derive_dal_parameters (reference : Cryptobox.parameters) ~redundancy_factor number_of_shards = reference.number_of_shards / constants_divider; } -let content_slot_id = function - | Hist.Unpublished id | Published {header = {id; _}; _} -> id +let content_slot_id cell = (Hist.content_id cell).header_id let dal_attestation slot_indexes = let open Alpha_context.Dal in diff --git a/src/proto_alpha/lib_sc_rollup_node/dal_pages_request.ml b/src/proto_alpha/lib_sc_rollup_node/dal_pages_request.ml index 921b7077b475..1166b385e8c1 100644 --- a/src/proto_alpha/lib_sc_rollup_node/dal_pages_request.ml +++ b/src/proto_alpha/lib_sc_rollup_node/dal_pages_request.ml @@ -175,7 +175,7 @@ let dal_skip_list_cell_content_of_slot_id node_ctxt let content = Dal.Slots_history.content cell in Slots_statuses_cache.replace skip_list_cells_content_cache - (Dal.Slots_history.content_id content) + (Dal.Slots_history.content_id content).header_id (content, attested_level_hash)) hash_with_cells ; (* The [find] below validates the fact that we fetched the info of -- GitLab