Alpha: check hard storage limit in precheck

src/proto_alpha/lib_protocol/src/alpha_context.mli

@@ -902,6 +902,8 @@ module Fees : sig
   type error += Operation_quota_exceeded (* `Temporary *)
   type error += Storage_limit_too_high (* `Permanent *)
 
+  val check_storage_limit: context -> storage_limit:Z.t -> unit tzresult
+
 end
 
 module Operation : sig

src/proto_alpha/lib_protocol/src/apply.ml

@@ -482,8 +482,9 @@ let apply_internal_manager_operations ctxt mode ~payer ops =
 let precheck_manager_contents
     (type kind) ctxt raw_operation (op : kind Kind.manager contents)
   : context tzresult Lwt.t =
-  let Manager_operation { source ; fee ; counter ; operation ; gas_limit } = op in
+  let Manager_operation { source ; fee ; counter ; operation ; gas_limit ; storage_limit } = op in
   Lwt.return (Gas.check_limit ctxt gas_limit) >>=? fun () ->
+  Lwt.return (Fees.check_storage_limit ctxt storage_limit) >>=? fun () ->
   Contract.must_be_allocated ctxt source >>=? fun () ->
   Contract.check_counter_increment ctxt source counter >>=? fun () ->
   begin

src/proto_alpha/lib_protocol/src/fees_storage.ml

@@ -74,13 +74,14 @@ let burn_fees_for_storage c ~storage_limit ~payer =
          Contract_storage.spend_from_script c payer to_burn) >>=? fun c ->
       return c
 
-let with_fees_for_storage c ~storage_limit  ~payer f =
-  begin if Compare.Z.(storage_limit > (Raw_context.constants c).hard_storage_limit_per_operation)
+let check_storage_limit c ~storage_limit =
+  if Compare.Z.(storage_limit > (Raw_context.constants c).hard_storage_limit_per_operation)
   || Compare.Z.(storage_limit < Z.zero)then
-      fail Storage_limit_too_high
+    error Storage_limit_too_high
   else
-      return ()
-  end >>=? fun () ->
+    ok ()
+
+let with_fees_for_storage c ~storage_limit ~payer f =
   Lwt.return (Raw_context.init_storage_space_to_pay c) >>=? fun c ->
   f c >>=? fun (c, ret) ->
   burn_fees_for_storage c ~storage_limit ~payer >>=? fun c ->

src/proto_alpha/lib_protocol/src/fees_storage.mli

@@ -19,6 +19,9 @@ val record_paid_storage_space:
   Raw_context.t -> Contract_repr.t ->
   (Raw_context.t * Z.t * Z.t * Tez_repr.t) tzresult Lwt.t
 
+val check_storage_limit:
+  Raw_context.t -> storage_limit:Z.t -> unit tzresult
+
 val with_fees_for_storage:
   Raw_context.t -> storage_limit:Z.t -> payer:Contract_repr.t ->
   (Raw_context.t -> (Raw_context.t * 'a) tzresult Lwt.t) ->