sc_rollup_inbox_storage.ml
(*****************************************************************************)
(* *)
(* Open Source License *)
(* Copyright (c) 2022 Nomadic Labs <contact@nomadic-labs.com> *)
(* Copyright (c) 2022 TriliTech <contact@trili.tech> *)
(* *)
(* Permission is hereby granted, free of charge, to any person obtaining a *)
(* copy of this software and associated documentation files (the "Software"),*)
(* to deal in the Software without restriction, including without limitation *)
(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *)
(* and/or sell copies of the Software, and to permit persons to whom the *)
(* Software is furnished to do so, subject to the following conditions: *)
(* *)
(* The above copyright notice and this permission notice shall be included *)
(* in all copies or substantial portions of the Software. *)
(* *)
(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*)
(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *)
(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *)
(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*)
(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *)
(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *)
(* DEALINGS IN THE SOFTWARE. *)
(* *)
(*****************************************************************************)
open Sc_rollup_errors
module Store = Storage.Sc_rollup
let update_num_and_size_of_messages ~num_messages ~total_messages_size message =
( num_messages + 1,
total_messages_size
+ String.length
(message : Sc_rollup_inbox_message_repr.serialized :> string) )
let inbox ctxt rollup =
let open Lwt_tzresult_syntax in
let* ctxt, res = Store.Inbox.find ctxt rollup in
match res with
| None -> fail (Sc_rollup_does_not_exist rollup)
| Some inbox -> return (inbox, ctxt)
let assert_inbox_nb_messages_in_commitment_period ctxt inbox extra_messages =
let nb_messages_in_commitment_period =
Int64.add
(Sc_rollup_inbox_repr.number_of_messages_during_commitment_period inbox)
(Int64.of_int extra_messages)
in
let limit =
Constants_storage.sc_rollup_max_number_of_messages_per_commitment_period
ctxt
|> Int64.of_int
in
fail_when
Compare.Int64.(nb_messages_in_commitment_period > limit)
Sc_rollup_max_number_of_messages_reached_for_commitment_period
let add_messages ctxt rollup messages =
let {Level_repr.level; _} = Raw_context.current_level ctxt in
let open Lwt_tzresult_syntax in
let open Raw_context in
let commitment_period =
Constants_storage.sc_rollup_commitment_period_in_blocks ctxt |> Int32.of_int
in
let* inbox, ctxt = inbox ctxt rollup in
let* num_messages, total_messages_size, ctxt =
List.fold_left_es
(fun (num_messages, total_messages_size, ctxt) message ->
let*? ctxt =
Raw_context.consume_gas
ctxt
Sc_rollup_costs.Constants.cost_update_num_and_size_of_messages
in
let num_messages, total_messages_size =
update_num_and_size_of_messages
~num_messages
~total_messages_size
message
in
return (num_messages, total_messages_size, ctxt))
(0, 0, ctxt)
messages
in
let inbox =
Sc_rollup_inbox_repr.refresh_commitment_period
~commitment_period
~level
inbox
in
let* () =
assert_inbox_nb_messages_in_commitment_period ctxt inbox num_messages
in
let inbox_level = Sc_rollup_inbox_repr.inbox_level inbox in
let* ctxt, genesis_info = Storage.Sc_rollup.Genesis_info.get ctxt rollup in
let origination_level = genesis_info.level in
let levels =
Int32.sub
(Raw_level_repr.to_int32 inbox_level)
(Raw_level_repr.to_int32 origination_level)
in
let*? current_messages, ctxt =
Sc_rollup_in_memory_inbox.current_messages ctxt rollup
in
let cost_add_serialized_messages =
Sc_rollup_costs.cost_add_serialized_messages
~num_messages
~total_messages_size
levels
in
let*? ctxt = Raw_context.consume_gas ctxt cost_add_serialized_messages in
(*
Notice that the protocol is forgetful: it throws away the inbox
history. On the contrary, the history is stored by the rollup
node to produce inclusion proofs when needed.
*)
let* current_messages, inbox =
Sc_rollup_inbox_repr.add_messages_no_history
(Raw_context.recover ctxt)
inbox
level
messages
current_messages
in
let*? ctxt =
Sc_rollup_in_memory_inbox.set_current_messages ctxt rollup current_messages
in
let* ctxt, size = Store.Inbox.update ctxt rollup inbox in
return (inbox, Z.of_int size, ctxt)
let serialize_external_messages ctxt external_messages =
let open Sc_rollup_inbox_message_repr in
List.fold_left_map_e
(fun ctxt message ->
let open Tzresult_syntax in
(* Pay gas for serializing an external message. *)
let* ctxt =
let bytes_len = String.length message in
Raw_context.consume_gas
ctxt
(Sc_rollup_costs.cost_serialize_external_inbox_message ~bytes_len)
in
let* serialized_message = serialize @@ External message in
return (ctxt, serialized_message))
ctxt
external_messages
let serialize_internal_message ctxt ~payload ~sender ~source =
let open Result_syntax in
let internal_message =
{Sc_rollup_inbox_message_repr.payload; sender; source}
in
(* Pay gas for serializing an internal message. *)
let* ctxt =
Raw_context.consume_gas
ctxt
(Sc_rollup_costs.cost_serialize_internal_inbox_message internal_message)
in
let* message =
Sc_rollup_inbox_message_repr.(serialize @@ Internal internal_message)
in
return (message, ctxt)
let add_external_messages ctxt rollup external_messages =
let open Lwt_result_syntax in
let*? ctxt, messages = serialize_external_messages ctxt external_messages in
add_messages ctxt rollup messages
let add_internal_message ctxt rollup ~payload ~sender ~source =
let open Lwt_result_syntax in
let*? message, ctxt =
serialize_internal_message ctxt ~payload ~sender ~source
in
add_messages ctxt rollup [message]
module Internal_for_tests = struct
let update_num_and_size_of_messages = update_num_and_size_of_messages
end
