diff --git a/src/proto_alpha/lib_client/client_proto_context.ml b/src/proto_alpha/lib_client/client_proto_context.ml index 789965ed87d8ca3a9d443e9b794bcb145ac05651..93b52823d4370e314166417306467017838cd9f3 100644 --- a/src/proto_alpha/lib_client/client_proto_context.ml +++ b/src/proto_alpha/lib_client/client_proto_context.ml @@ -1269,24 +1269,24 @@ let sc_rollup_publish (cctxt : #full) ~chain ~block ?confirmations ?dry_run | Apply_results.Single_and_result ((Manager_operation _ as op), result) -> return (oph, op, result) -let sc_rollup_atomic_batch (cctxt : #full) ~chain ~block ?confirmations ?dry_run - ?verbose_signing ?simulation ?fee ?gas_limit ?storage_limit ?counter ~source - ~rollup ~cemented_commitment ~outbox_level ~message_index ~inclusion_proof - ~atomic_transaction_batch ~src_pk ~src_sk ~fee_parameter () = +let sc_rollup_execute_outbox_message (cctxt : #full) ~chain ~block + ?confirmations ?dry_run ?verbose_signing ?simulation ?fee ?gas_limit + ?storage_limit ?counter ~source ~rollup ~cemented_commitment ~outbox_level + ~message_index ~inclusion_proof ~message ~src_pk ~src_sk ~fee_parameter () = let op = Annotated_manager_operation.Single_manager (Injection.prepare_manager_operation ~fee:(Limit.of_option fee) ~gas_limit:(Limit.of_option gas_limit) ~storage_limit:(Limit.of_option storage_limit) - (Sc_rollup_atomic_batch + (Sc_rollup_execute_outbox_message { rollup; cemented_commitment; outbox_level; message_index; inclusion_proof; - atomic_transaction_batch; + message; })) in Injection.inject_manager_operation diff --git a/src/proto_alpha/lib_client/client_proto_context.mli b/src/proto_alpha/lib_client/client_proto_context.mli index 89a40d5cc456d91434571722835ec5a98a601515..48946cf1eb05ac7bd2e0fff39f3f04d36cec62e9 100644 --- a/src/proto_alpha/lib_client/client_proto_context.mli +++ b/src/proto_alpha/lib_client/client_proto_context.mli @@ -766,7 +766,7 @@ val sc_rollup_publish : tzresult Lwt.t -val sc_rollup_atomic_batch : +val sc_rollup_execute_outbox_message : #Protocol_client_context.full -> chain:Chain_services.chain -> block:Block_services.block -> @@ -784,14 +784,15 @@ val sc_rollup_atomic_batch : outbox_level:Raw_level.t -> message_index:int -> inclusion_proof:string -> - atomic_transaction_batch:string -> + message:string -> src_pk:public_key -> src_sk:Client_keys.sk_uri -> fee_parameter:Injection.fee_parameter -> unit -> ( Operation_hash.t - * Kind.sc_rollup_atomic_batch Kind.manager contents - * Kind.sc_rollup_atomic_batch Kind.manager Apply_results.contents_result, + * Kind.sc_rollup_execute_outbox_message Kind.manager contents + * Kind.sc_rollup_execute_outbox_message Kind.manager + Apply_results.contents_result, tztrace ) result Lwt.t diff --git a/src/proto_alpha/lib_client/injection.ml b/src/proto_alpha/lib_client/injection.ml index 6ad982bb5a27a552d351a05b53d172a07788498a..22feba65f1e74cd8e594c3a9221e08d5ef117d72 100644 --- a/src/proto_alpha/lib_client/injection.ml +++ b/src/proto_alpha/lib_client/injection.ml @@ -332,7 +332,8 @@ let estimated_gas_single (type kind) | Sc_rollup_publish_result {consumed_gas; _} -> Ok consumed_gas | Sc_rollup_refute_result {consumed_gas; _} -> Ok consumed_gas | Sc_rollup_timeout_result {consumed_gas; _} -> Ok consumed_gas - | Sc_rollup_atomic_batch_result {consumed_gas; _} -> Ok consumed_gas + | Sc_rollup_execute_outbox_message_result {consumed_gas; _} -> + Ok consumed_gas | Sc_rollup_return_bond_result {consumed_gas; _} -> Ok consumed_gas) | Skipped _ -> Ok Gas.Arith.zero (* there must be another error for this to happen *) @@ -389,7 +390,7 @@ let estimated_storage_single (type kind) ~tx_rollup_origination_size | Set_deposits_limit_result _ -> Ok Z.zero | Tx_rollup_origination_result _ -> Ok tx_rollup_origination_size | Tx_rollup_submit_batch_result {paid_storage_size_diff; _} - | Sc_rollup_atomic_batch_result {paid_storage_size_diff; _} -> + | Sc_rollup_execute_outbox_message_result {paid_storage_size_diff; _} -> Ok paid_storage_size_diff | Tx_rollup_commit_result _ -> Ok Z.zero | Tx_rollup_return_bond_result _ -> Ok Z.zero @@ -502,7 +503,7 @@ let originated_contracts_single (type kind) | Sc_rollup_publish_result _ -> Ok [] | Sc_rollup_refute_result _ -> Ok [] | Sc_rollup_timeout_result _ -> Ok [] - | Sc_rollup_atomic_batch_result _ -> Ok [] + | Sc_rollup_execute_outbox_message_result _ -> Ok [] | Sc_rollup_return_bond_result _ -> Ok []) | Skipped _ -> Ok [] (* there must be another error for this to happen *) | Failed (_, errs) -> Error (Environment.wrap_tztrace errs) diff --git a/src/proto_alpha/lib_client/operation_result.ml b/src/proto_alpha/lib_client/operation_result.ml index bf7586459ec595324fd49cdd9d61e508f92f7e5e..62e95b72d8e55b085ff70f98e693469df3154a86 100644 --- a/src/proto_alpha/lib_client/operation_result.ml +++ b/src/proto_alpha/lib_client/operation_result.ml @@ -332,14 +332,14 @@ let pp_manager_operation_content (type kind) source pp_result ppf bob Sc_rollup.Address.pp rollup - | Sc_rollup_atomic_batch + | Sc_rollup_execute_outbox_message { rollup; cemented_commitment; outbox_level; message_index; inclusion_proof; - atomic_transaction_batch; + message; } -> (* TODO #3125 Improve pretty-printing of this content and sc operations above. @@ -347,9 +347,9 @@ let pp_manager_operation_content (type kind) source pp_result ppf *) Format.fprintf ppf - "Execute the atomic transaction batch from the smart contract rollup \ - at address %a, with cemented commit %a, outbox level %a, message \ - index %d, inclusion proof %s for the atomic batch of transactions %s" + "Execute the outbox message of the smart contract rollup at address \ + %a, with cemented commit %a, outbox level %a, message index %d, \ + inclusion proof %s and message %s" Sc_rollup.Address.pp rollup Sc_rollup.Commitment.Hash.pp @@ -358,7 +358,7 @@ let pp_manager_operation_content (type kind) source pp_result ppf outbox_level message_index inclusion_proof - atomic_transaction_batch + message | Sc_rollup_return_bond {sc_rollup} -> Format.fprintf ppf @@ -752,8 +752,8 @@ let pp_manager_operation_contents_and_result ppf status ; pp_balance_updates_opt ppf balance_updates in - let pp_sc_rollup_atomic_batch_result - (Sc_rollup_atomic_batch_result + let pp_sc_rollup_execute_outbox_message_result + (Sc_rollup_execute_outbox_message_result {balance_updates; consumed_gas; paid_storage_size_diff}) = if paid_storage_size_diff <> Z.zero then Format.fprintf @@ -1017,23 +1017,25 @@ let pp_manager_operation_contents_and_result ppf rollup by timeout was BACKTRACKED, its expected effects (as follow) \ were NOT applied.@]" ; pp_sc_rollup_timeout_result op - | Applied (Sc_rollup_atomic_batch_result _ as op) -> + | Applied (Sc_rollup_execute_outbox_message_result _ as op) -> Format.fprintf ppf - "This sc rollup atomic batch operation was successfully applied." ; - pp_sc_rollup_atomic_batch_result op + "This operation executing a smart contract rollup outbox message was \ + successfully applied." ; + pp_sc_rollup_execute_outbox_message_result op + | Backtracked ((Sc_rollup_execute_outbox_message_result _ as op), _err) -> + Format.fprintf + ppf + "@[This operation operation executing a smart contract rollup \ + outbox message was BACKTRACKED, its expected effects (as follow) \ + were NOT applied.@]" ; + pp_sc_rollup_execute_outbox_message_result op | Applied (Sc_rollup_return_bond_result _ as op) -> Format.fprintf ppf "This sc rollup return commitment bond operation was successfully \ applied" ; pp_sc_rollup_return_bond_result op - | Backtracked ((Sc_rollup_atomic_batch_result _ as op), _err) -> - Format.fprintf - ppf - "@[This sc rollup atomic batch operation was BACKTRACKED, its \ - expected effects (as follow) were NOT applied.@]" ; - pp_sc_rollup_atomic_batch_result op | Backtracked ((Sc_rollup_return_bond_result _ as op), _err) -> Format.fprintf ppf diff --git a/src/proto_alpha/lib_client_commands/client_proto_context_commands.ml b/src/proto_alpha/lib_client_commands/client_proto_context_commands.ml index b5a914174bb8e5cccd39f773980ad21546c03743..8a7f2d2cd809c9a6147447020ac81b67f5b973a3 100644 --- a/src/proto_alpha/lib_client_commands/client_proto_context_commands.ml +++ b/src/proto_alpha/lib_client_commands/client_proto_context_commands.ml @@ -2779,8 +2779,8 @@ let commands_rw () = command ~group ~desc: - "Execute an atomic batch of transactions. The transactions are part of \ - the smart-contract rollup's outbox of a cemented commitment." + "Execute a message from a smart-contract rollup's outbox of a cemented \ + commitment." (args7 fee_arg dry_run_switch @@ -2789,21 +2789,21 @@ let commands_rw () = fee_parameter_args storage_limit_arg counter_arg) - (prefixes ["execute"; "transactions"; "of"; "sc"; "rollup"] + (prefixes ["execute"; "outbox"; "message"; "of"; "sc"; "rollup"] @@ param ~name:"rollup" ~desc: - "The address of the sc rollup where the atomic batch of \ - transactions resides." + "The address of the smart-contract rollup where the message \ + resides." rollup_address_param @@ prefix "from" @@ ContractAlias.destination_param ~name:"source" - ~desc:"The account used for executing the batch of transactions." + ~desc:"The account used for executing the outbox message." @@ prefixes ["for"; "commitment"; "hash"] @@ param - ~name:"last cemented commitment" - ~desc:"The hash of the last cemented commitment of the rollup." + ~name:"cemented commitment" + ~desc:"The hash of the cemented commitment of the rollup." commitment_hash_param @@ prefixes ["for"; "the"; "outbox"; "level"] @@ param @@ -2813,19 +2813,17 @@ let commands_rw () = @@ prefixes ["for"; "the"; "message"; "at"; "index"] @@ param ~name:"message index" - ~desc: - "The index of the rollup's outbox message containing the batch of \ - transactions." + ~desc:"The index of the rollup's outbox containing the message." non_negative_param @@ prefixes ["and"; "inclusion"; "proof"] @@ param ~name:"inclusion proof" - ~desc:"The inclusion proof for the atomic batch of transactions." + ~desc:"The inclusion proof for the message." unchecked_payload_param - @@ prefixes ["and"; "atomic"; "transaction"; "batch"] + @@ prefixes ["and"; "message"] @@ param - ~name:"atomic transaction batch" - ~desc:"The atomic batch of transactions to be executed." + ~name:"message" + ~desc:"The message to be executed." unchecked_payload_param @@ stop) (fun ( fee, @@ -2841,7 +2839,7 @@ let commands_rw () = outbox_level message_index inclusion_proof - atomic_transaction_batch + message cctxt -> (match source with | Originated _ -> @@ -2851,7 +2849,7 @@ let commands_rw () = | Implicit source -> return source) >>=? fun source -> Client_keys.get_key cctxt source >>=? fun (_, src_pk, src_sk) -> - sc_rollup_atomic_batch + sc_rollup_execute_outbox_message cctxt ~chain:cctxt#chain ~block:cctxt#block @@ -2868,7 +2866,7 @@ let commands_rw () = ~outbox_level ~message_index ~inclusion_proof - ~atomic_transaction_batch + ~message ~src_pk ~src_sk ~fee_parameter diff --git a/src/proto_alpha/lib_injector/l1_operation.ml b/src/proto_alpha/lib_injector/l1_operation.ml index 769dc6f007c2fbfc447222b86582120d9c72eb17..177744b0e228fb5c1f16faaffd6429db5d8af425 100644 --- a/src/proto_alpha/lib_injector/l1_operation.ml +++ b/src/proto_alpha/lib_injector/l1_operation.ml @@ -66,7 +66,7 @@ module Manager_operation = struct make sc_rollup_publish_case; make sc_rollup_refute_case; make sc_rollup_timeout_case; - make sc_rollup_atomic_batch_case; + make sc_rollup_execute_outbox_message_case; ] let get_case : @@ -97,7 +97,8 @@ module Manager_operation = struct | Sc_rollup_publish _ -> sc_rollup_publish_case | Sc_rollup_refute _ -> sc_rollup_refute_case | Sc_rollup_timeout _ -> sc_rollup_timeout_case - | Sc_rollup_atomic_batch _ -> sc_rollup_atomic_batch_case + | Sc_rollup_execute_outbox_message _ -> + sc_rollup_execute_outbox_message_case | Sc_rollup_return_bond _ -> sc_rollup_return_bond_case let pp_kind ppf op = diff --git a/src/proto_alpha/lib_protocol/alpha_context.mli b/src/proto_alpha/lib_protocol/alpha_context.mli index 9d24201b85df98a86f25b872b3b94c2a5cf85052..298615bc4005641b83b50c244d0f2785b997e2e4 100644 --- a/src/proto_alpha/lib_protocol/alpha_context.mli +++ b/src/proto_alpha/lib_protocol/alpha_context.mli @@ -3251,7 +3251,8 @@ module Kind : sig type sc_rollup_timeout = Sc_rollup_timeout_kind - type sc_rollup_atomic_batch = Sc_rollup_atomic_batch_kind + type sc_rollup_execute_outbox_message = + | Sc_rollup_execute_outbox_message_kind type sc_rollup_return_bond = Sc_rollup_return_bond_kind @@ -3281,7 +3282,8 @@ module Kind : sig | Sc_rollup_publish_manager_kind : sc_rollup_publish manager | Sc_rollup_refute_manager_kind : sc_rollup_refute manager | Sc_rollup_timeout_manager_kind : sc_rollup_timeout manager - | Sc_rollup_atomic_batch_manager_kind : sc_rollup_atomic_batch manager + | Sc_rollup_execute_outbox_message_manager_kind + : sc_rollup_execute_outbox_message manager | Sc_rollup_return_bond_manager_kind : sc_rollup_return_bond manager end @@ -3495,15 +3497,15 @@ and _ manager_operation = stakers : Sc_rollup.Game.Index.t; } -> Kind.sc_rollup_timeout manager_operation - | Sc_rollup_atomic_batch : { + | Sc_rollup_execute_outbox_message : { rollup : Sc_rollup.t; cemented_commitment : Sc_rollup.Commitment.Hash.t; outbox_level : Raw_level.t; message_index : int; inclusion_proof : string; - atomic_transaction_batch : string; + message : string; } - -> Kind.sc_rollup_atomic_batch manager_operation + -> Kind.sc_rollup_execute_outbox_message manager_operation | Sc_rollup_return_bond : { sc_rollup : Sc_rollup.t; } @@ -3679,8 +3681,8 @@ module Operation : sig val sc_rollup_timeout_case : Kind.sc_rollup_timeout Kind.manager case - val sc_rollup_atomic_batch_case : - Kind.sc_rollup_atomic_batch Kind.manager case + val sc_rollup_execute_outbox_message_case : + Kind.sc_rollup_execute_outbox_message Kind.manager case val sc_rollup_return_bond_case : Kind.sc_rollup_return_bond Kind.manager case @@ -3743,7 +3745,8 @@ module Operation : sig val sc_rollup_timeout_case : Kind.sc_rollup_timeout case - val sc_rollup_atomic_batch_case : Kind.sc_rollup_atomic_batch case + val sc_rollup_execute_outbox_message_case : + Kind.sc_rollup_execute_outbox_message case val sc_rollup_return_bond_case : Kind.sc_rollup_return_bond case end diff --git a/src/proto_alpha/lib_protocol/apply.ml b/src/proto_alpha/lib_protocol/apply.ml index 6d7a25c7228dca1d1aa88a5931ee78b3817201a4..72275869376afa3e8072073f6f6cbe2e8563726e 100644 --- a/src/proto_alpha/lib_protocol/apply.ml +++ b/src/proto_alpha/lib_protocol/apply.ml @@ -1835,23 +1835,23 @@ let apply_external_manager_operation_content : Sc_rollup_timeout_result {status; consumed_gas; balance_updates} in return (ctxt, result, []) - | Sc_rollup_atomic_batch + | Sc_rollup_execute_outbox_message { rollup; cemented_commitment; outbox_level; message_index; inclusion_proof; - atomic_transaction_batch; + message; } -> - Sc_rollup_operations.atomic_batch + Sc_rollup_operations.execute_outbox_message ctxt rollup cemented_commitment ~outbox_level ~message_index ~inclusion_proof - ~atomic_transaction_batch + ~message >>=? fun _ctxt -> failwith "Sc_rolup_atomic_batch operation is not yet supported." | Sc_rollup_return_bond {sc_rollup} -> @@ -2060,7 +2060,7 @@ let precheck_manager_contents (type kind) ctxt (op : kind Kind.manager contents) >>?= fun () -> return ctxt | Sc_rollup_originate _ | Sc_rollup_add_messages _ | Sc_rollup_cement _ | Sc_rollup_publish _ | Sc_rollup_refute _ | Sc_rollup_timeout _ - | Sc_rollup_atomic_batch _ -> + | Sc_rollup_execute_outbox_message _ -> assert_sc_rollup_feature_enabled ctxt >|=? fun () -> ctxt | Sc_rollup_return_bond _ -> (* TODO: https://gitlab.com/tezos/tezos/-/issues/3063 @@ -2241,7 +2241,7 @@ let burn_manager_storage_fees : | Sc_rollup_publish_result _ -> return (ctxt, storage_limit, smopr) | Sc_rollup_refute_result _ -> return (ctxt, storage_limit, smopr) | Sc_rollup_timeout_result _ -> return (ctxt, storage_limit, smopr) - | Sc_rollup_atomic_batch_result + | Sc_rollup_execute_outbox_message_result ({paid_storage_size_diff; balance_updates; _} as payload) -> let consumed = paid_storage_size_diff in Fees.burn_storage_fees ctxt ~storage_limit ~payer consumed @@ -2249,7 +2249,8 @@ let burn_manager_storage_fees : let balance_updates = storage_bus @ balance_updates in ( ctxt, storage_limit, - Sc_rollup_atomic_batch_result {payload with balance_updates} ) + Sc_rollup_execute_outbox_message_result {payload with balance_updates} + ) | Sc_rollup_return_bond_result _ -> return (ctxt, storage_limit, smopr) (** [burn_internal_storage_fees ctxt smopr storage_limit payer] burns the diff --git a/src/proto_alpha/lib_protocol/apply_results.ml b/src/proto_alpha/lib_protocol/apply_results.ml index 2b07e65765e0c042ea7209ce90347f1a90f9a4af..1296590166736a51677e4c5f12fa661c10d66257 100644 --- a/src/proto_alpha/lib_protocol/apply_results.ml +++ b/src/proto_alpha/lib_protocol/apply_results.ml @@ -252,12 +252,13 @@ type _ successful_manager_operation_result = balance_updates : Receipt.balance_updates; } -> Kind.sc_rollup_timeout successful_manager_operation_result - | Sc_rollup_atomic_batch_result : { + | Sc_rollup_execute_outbox_message_result : { balance_updates : Receipt.balance_updates; consumed_gas : Gas.Arith.fp; paid_storage_size_diff : Z.t; } - -> Kind.sc_rollup_atomic_batch successful_manager_operation_result + -> Kind.sc_rollup_execute_outbox_message + successful_manager_operation_result | Sc_rollup_return_bond_result : { balance_updates : Receipt.balance_updates; consumed_gas : Gas.Arith.fp; @@ -1112,9 +1113,11 @@ module Manager_result = struct Sc_rollup_timeout_result {consumed_gas = consumed_milligas; status; balance_updates}) - let sc_rollup_atomic_batch_case = + let sc_rollup_execute_outbox_message_case = make - ~op_case:Operation.Encoding.Manager_operations.sc_rollup_atomic_batch_case + ~op_case: + Operation.Encoding.Manager_operations + .sc_rollup_execute_outbox_message_case ~encoding: Data_encoding.( obj4 @@ -1123,12 +1126,13 @@ module Manager_result = struct (dft "consumed_milligas" Gas.Arith.n_fp_encoding Gas.Arith.zero) (dft "paid_storage_size_diff" z Z.zero)) ~select:(function - | Successful_manager_result (Sc_rollup_atomic_batch_result _ as op) -> + | Successful_manager_result + (Sc_rollup_execute_outbox_message_result _ as op) -> Some op | _ -> None) - ~kind:Kind.Sc_rollup_atomic_batch_manager_kind + ~kind:Kind.Sc_rollup_execute_outbox_message_manager_kind ~proj:(function - | Sc_rollup_atomic_batch_result + | Sc_rollup_execute_outbox_message_result {balance_updates; consumed_gas; paid_storage_size_diff} -> ( balance_updates, Gas.Arith.ceil consumed_gas, @@ -1140,7 +1144,7 @@ module Manager_result = struct consumed_milligas, paid_storage_size_diff ) -> assert (Gas.Arith.(equal (ceil consumed_milligas) consumed_gas)) ; - Sc_rollup_atomic_batch_result + Sc_rollup_execute_outbox_message_result { balance_updates; consumed_gas = consumed_milligas; @@ -1673,10 +1677,10 @@ let equal_manager_kind : | Kind.Sc_rollup_timeout_manager_kind, Kind.Sc_rollup_timeout_manager_kind -> Some Eq | Kind.Sc_rollup_timeout_manager_kind, _ -> None - | ( Kind.Sc_rollup_atomic_batch_manager_kind, - Kind.Sc_rollup_atomic_batch_manager_kind ) -> + | ( Kind.Sc_rollup_execute_outbox_message_manager_kind, + Kind.Sc_rollup_execute_outbox_message_manager_kind ) -> Some Eq - | Kind.Sc_rollup_atomic_batch_manager_kind, _ -> None + | Kind.Sc_rollup_execute_outbox_message_manager_kind, _ -> None | ( Kind.Sc_rollup_return_bond_manager_kind, Kind.Sc_rollup_return_bond_manager_kind ) -> Some Eq @@ -2231,13 +2235,14 @@ module Encoding = struct Some (op, res) | _ -> None) - let[@coq_axiom_with_reason "gadt"] sc_rollup_atomic_batch_case = + let[@coq_axiom_with_reason "gadt"] sc_rollup_execute_outbox_message_case = make_manager_case - Operation.Encoding.sc_rollup_atomic_batch_case - Manager_result.sc_rollup_atomic_batch_case + Operation.Encoding.sc_rollup_execute_outbox_message_case + Manager_result.sc_rollup_execute_outbox_message_case (function | Contents_and_result - ( (Manager_operation {operation = Sc_rollup_atomic_batch _; _} as op), + ( (Manager_operation + {operation = Sc_rollup_execute_outbox_message _; _} as op), res ) -> Some (op, res) | _ -> None) @@ -2305,7 +2310,7 @@ let contents_result_encoding = make sc_rollup_publish_case; make sc_rollup_refute_case; make sc_rollup_timeout_case; - make sc_rollup_atomic_batch_case; + make sc_rollup_execute_outbox_message_case; make sc_rollup_return_bond_case; ] @@ -3085,32 +3090,42 @@ let kind_equal : } ) -> Some Eq | Manager_operation {operation = Sc_rollup_timeout _; _}, _ -> None - | ( Manager_operation {operation = Sc_rollup_atomic_batch _; _}, + | ( Manager_operation {operation = Sc_rollup_execute_outbox_message _; _}, Manager_operation_result - {operation_result = Applied (Sc_rollup_atomic_batch_result _); _} ) -> + { + operation_result = Applied (Sc_rollup_execute_outbox_message_result _); + _; + } ) -> Some Eq - | ( Manager_operation {operation = Sc_rollup_atomic_batch _; _}, + | ( Manager_operation {operation = Sc_rollup_execute_outbox_message _; _}, Manager_operation_result - {operation_result = Backtracked (Sc_rollup_atomic_batch_result _, _); _} - ) -> + { + operation_result = + Backtracked (Sc_rollup_execute_outbox_message_result _, _); + _; + } ) -> Some Eq - | ( Manager_operation {operation = Sc_rollup_atomic_batch _; _}, + | ( Manager_operation {operation = Sc_rollup_execute_outbox_message _; _}, Manager_operation_result { operation_result = - Failed (Alpha_context.Kind.Sc_rollup_atomic_batch_manager_kind, _); + Failed + ( Alpha_context.Kind.Sc_rollup_execute_outbox_message_manager_kind, + _ ); _; } ) -> Some Eq - | ( Manager_operation {operation = Sc_rollup_atomic_batch _; _}, + | ( Manager_operation {operation = Sc_rollup_execute_outbox_message _; _}, Manager_operation_result { operation_result = - Skipped Alpha_context.Kind.Sc_rollup_atomic_batch_manager_kind; + Skipped + Alpha_context.Kind.Sc_rollup_execute_outbox_message_manager_kind; _; } ) -> Some Eq - | Manager_operation {operation = Sc_rollup_atomic_batch _; _}, _ -> None + | Manager_operation {operation = Sc_rollup_execute_outbox_message _; _}, _ -> + None let rec kind_equal_list : type kind kind2. diff --git a/src/proto_alpha/lib_protocol/apply_results.mli b/src/proto_alpha/lib_protocol/apply_results.mli index 4e9db1f35de21f1315b2cedef2d193af2bf3da23..adb9ddf6d6c68f2eb1b7c723c7d15ab2041e094c 100644 --- a/src/proto_alpha/lib_protocol/apply_results.mli +++ b/src/proto_alpha/lib_protocol/apply_results.mli @@ -318,12 +318,13 @@ and _ successful_manager_operation_result = balance_updates : Receipt.balance_updates; } -> Kind.sc_rollup_timeout successful_manager_operation_result - | Sc_rollup_atomic_batch_result : { + | Sc_rollup_execute_outbox_message_result : { balance_updates : Receipt.balance_updates; consumed_gas : Gas.Arith.fp; paid_storage_size_diff : Z.t; } - -> Kind.sc_rollup_atomic_batch successful_manager_operation_result + -> Kind.sc_rollup_execute_outbox_message + successful_manager_operation_result | Sc_rollup_return_bond_result : { balance_updates : Receipt.balance_updates; consumed_gas : Gas.Arith.fp; diff --git a/src/proto_alpha/lib_protocol/operation_repr.ml b/src/proto_alpha/lib_protocol/operation_repr.ml index 616fd20326c57073a3125f35dc311722c6610761..ab82ccbab8e929c5cecb43df73c31e0e2b04f531 100644 --- a/src/proto_alpha/lib_protocol/operation_repr.ml +++ b/src/proto_alpha/lib_protocol/operation_repr.ml @@ -106,7 +106,8 @@ module Kind = struct type sc_rollup_timeout = Sc_rollup_timeout_kind - type sc_rollup_atomic_batch = Sc_rollup_atomic_batch_kind + type sc_rollup_execute_outbox_message = + | Sc_rollup_execute_outbox_message_kind type sc_rollup_return_bond = Sc_rollup_return_bond_kind @@ -136,7 +137,8 @@ module Kind = struct | Sc_rollup_publish_manager_kind : sc_rollup_publish manager | Sc_rollup_refute_manager_kind : sc_rollup_refute manager | Sc_rollup_timeout_manager_kind : sc_rollup_timeout manager - | Sc_rollup_atomic_batch_manager_kind : sc_rollup_atomic_batch manager + | Sc_rollup_execute_outbox_message_manager_kind + : sc_rollup_execute_outbox_message manager | Sc_rollup_return_bond_manager_kind : sc_rollup_return_bond manager end @@ -417,15 +419,15 @@ and _ manager_operation = stakers : Sc_rollup_game_repr.Index.t; } -> Kind.sc_rollup_timeout manager_operation - | Sc_rollup_atomic_batch : { + | Sc_rollup_execute_outbox_message : { rollup : Sc_rollup_repr.t; cemented_commitment : Sc_rollup_commitment_repr.Hash.t; outbox_level : Raw_level_repr.t; message_index : int; inclusion_proof : string; - atomic_transaction_batch : string; + message : string; } - -> Kind.sc_rollup_atomic_batch manager_operation + -> Kind.sc_rollup_execute_outbox_message manager_operation | Sc_rollup_return_bond : { sc_rollup : Sc_rollup_repr.t; } @@ -459,7 +461,8 @@ let manager_kind : type kind. kind manager_operation -> kind Kind.manager = | Sc_rollup_publish _ -> Kind.Sc_rollup_publish_manager_kind | Sc_rollup_refute _ -> Kind.Sc_rollup_refute_manager_kind | Sc_rollup_timeout _ -> Kind.Sc_rollup_timeout_manager_kind - | Sc_rollup_atomic_batch _ -> Kind.Sc_rollup_atomic_batch_manager_kind + | Sc_rollup_execute_outbox_message _ -> + Kind.Sc_rollup_execute_outbox_message_manager_kind | Sc_rollup_return_bond _ -> Kind.Sc_rollup_return_bond_manager_kind type packed_manager_operation = @@ -1088,11 +1091,11 @@ module Encoding = struct inj = (fun (rollup, stakers) -> Sc_rollup_timeout {rollup; stakers}); } - let[@coq_axiom_with_reason "gadt"] sc_rollup_atomic_batch_case = + let[@coq_axiom_with_reason "gadt"] sc_rollup_execute_outbox_message_case = MCase { tag = sc_rollup_operation_atomic_batch_tag; - name = "sc_rollup_atomic_batch"; + name = "sc_rollup_execute_outbox_message"; encoding = obj6 (req "rollup" Sc_rollup_repr.encoding) @@ -1102,42 +1105,43 @@ module Encoding = struct (req "outbox_level" Raw_level_repr.encoding) (req "message_index" Data_encoding.int31) (req "inclusion proof" Data_encoding.string) - (req "atomic_transaction_batch" Data_encoding.string); + (req "message" Data_encoding.string); select = (function - | Manager (Sc_rollup_atomic_batch _ as op) -> Some op | _ -> None); + | Manager (Sc_rollup_execute_outbox_message _ as op) -> Some op + | _ -> None); proj = (function - | Sc_rollup_atomic_batch + | Sc_rollup_execute_outbox_message { rollup; cemented_commitment; outbox_level; message_index; inclusion_proof; - atomic_transaction_batch; + message; } -> ( rollup, cemented_commitment, outbox_level, message_index, inclusion_proof, - atomic_transaction_batch )); + message )); inj = (fun ( rollup, cemented_commitment, outbox_level, message_index, inclusion_proof, - atomic_transaction_batch ) -> - Sc_rollup_atomic_batch + message ) -> + Sc_rollup_execute_outbox_message { rollup; cemented_commitment; outbox_level; message_index; inclusion_proof; - atomic_transaction_batch; + message; }); } @@ -1551,10 +1555,10 @@ module Encoding = struct sc_rollup_operation_timeout_tag Manager_operations.sc_rollup_timeout_case - let sc_rollup_atomic_batch_case = + let sc_rollup_execute_outbox_message_case = make_manager_case sc_rollup_operation_atomic_batch_tag - Manager_operations.sc_rollup_atomic_batch_case + Manager_operations.sc_rollup_execute_outbox_message_case let sc_rollup_return_bond_case = make_manager_case @@ -1606,7 +1610,7 @@ module Encoding = struct make sc_rollup_publish_case; make sc_rollup_refute_case; make sc_rollup_timeout_case; - make sc_rollup_atomic_batch_case; + make sc_rollup_execute_outbox_message_case; make sc_rollup_return_bond_case; ] @@ -1832,8 +1836,9 @@ let equal_manager_operation_kind : | Sc_rollup_refute _, _ -> None | Sc_rollup_timeout _, Sc_rollup_timeout _ -> Some Eq | Sc_rollup_timeout _, _ -> None - | Sc_rollup_atomic_batch _, Sc_rollup_atomic_batch _ -> Some Eq - | Sc_rollup_atomic_batch _, _ -> None + | Sc_rollup_execute_outbox_message _, Sc_rollup_execute_outbox_message _ -> + Some Eq + | Sc_rollup_execute_outbox_message _, _ -> None | Sc_rollup_return_bond _, Sc_rollup_return_bond _ -> Some Eq | Sc_rollup_return_bond _, _ -> None diff --git a/src/proto_alpha/lib_protocol/operation_repr.mli b/src/proto_alpha/lib_protocol/operation_repr.mli index 53091cca0b430d69b20c29e2a48ea5af3a18bf43..245f8d0171ffa385bb119054b1f78e4eea6bcbbe 100644 --- a/src/proto_alpha/lib_protocol/operation_repr.mli +++ b/src/proto_alpha/lib_protocol/operation_repr.mli @@ -135,7 +135,8 @@ module Kind : sig type sc_rollup_timeout = Sc_rollup_timeout_kind - type sc_rollup_atomic_batch = Sc_rollup_atomic_batch_kind + type sc_rollup_execute_outbox_message = + | Sc_rollup_execute_outbox_message_kind type sc_rollup_return_bond = Sc_rollup_return_bond_kind @@ -165,7 +166,8 @@ module Kind : sig | Sc_rollup_publish_manager_kind : sc_rollup_publish manager | Sc_rollup_refute_manager_kind : sc_rollup_refute manager | Sc_rollup_timeout_manager_kind : sc_rollup_timeout manager - | Sc_rollup_atomic_batch_manager_kind : sc_rollup_atomic_batch manager + | Sc_rollup_execute_outbox_message_manager_kind + : sc_rollup_execute_outbox_message manager | Sc_rollup_return_bond_manager_kind : sc_rollup_return_bond manager end @@ -483,11 +485,10 @@ and _ manager_operation = stakers : Sc_rollup_game_repr.Index.t; } -> Kind.sc_rollup_timeout manager_operation - (* [Sc_rollup_atomic_batch] executes an atomic batch of transactions - corresponding to a message in the rollup's outbox. Transactions are - smart-contract calls and may include any valid payload including ticket - transfers. *) - | Sc_rollup_atomic_batch : { + (* [Sc_rollup_execute_outbox_message] executes a message from the rollup's + outbox. Messages may involve transactions to smart contract accounts on + Layer 1. *) + | Sc_rollup_execute_outbox_message : { rollup : Sc_rollup_repr.t; (** The smart-contract rollup. *) cemented_commitment : Sc_rollup_commitment_repr.Hash.t; (** The hash of the last cemented commitment that the proof refers to. *) @@ -497,10 +498,10 @@ and _ manager_operation = (** The index of the message in the outbox at that level. *) inclusion_proof : string; (** A proof that the message is included in the outbox. *) - atomic_transaction_batch : string; + message : string; (** The bytes corresponding to a serialized batch of transactions. *) } - -> Kind.sc_rollup_atomic_batch manager_operation + -> Kind.sc_rollup_execute_outbox_message manager_operation | Sc_rollup_return_bond : { sc_rollup : Sc_rollup_repr.t; } @@ -655,8 +656,8 @@ module Encoding : sig val sc_rollup_timeout_case : Kind.sc_rollup_timeout Kind.manager case - val sc_rollup_atomic_batch_case : - Kind.sc_rollup_atomic_batch Kind.manager case + val sc_rollup_execute_outbox_message_case : + Kind.sc_rollup_execute_outbox_message Kind.manager case val sc_rollup_return_bond_case : Kind.sc_rollup_return_bond Kind.manager case @@ -717,7 +718,8 @@ module Encoding : sig val sc_rollup_timeout_case : Kind.sc_rollup_timeout case - val sc_rollup_atomic_batch_case : Kind.sc_rollup_atomic_batch case + val sc_rollup_execute_outbox_message_case : + Kind.sc_rollup_execute_outbox_message case val sc_rollup_return_bond_case : Kind.sc_rollup_return_bond case end diff --git a/src/proto_alpha/lib_protocol/sc_rollup_operations.ml b/src/proto_alpha/lib_protocol/sc_rollup_operations.ml index 7fb0efb0f6d1462b25527703ffacb3e6780b2173..74d469570a150cf39a87f0c5120ea9995f405498 100644 --- a/src/proto_alpha/lib_protocol/sc_rollup_operations.ml +++ b/src/proto_alpha/lib_protocol/sc_rollup_operations.ml @@ -155,8 +155,8 @@ let originate ctxt ~kind ~boot_sector ~parameters_ty = in ({address; size}, ctxt) -let atomic_batch _ctx _rollup _last_cemented_commitment ~outbox_level:_ - ~message_index:_ ~inclusion_proof:_ ~atomic_transaction_batch:_ = +let execute_outbox_message _ctx _rollup _last_cemented_commitment + ~outbox_level:_ ~message_index:_ ~inclusion_proof:_ ~message:_ = (* TODO: 3106 Implement business logic. Involves validate inclusion proofs, transferring tickets and outputting diff --git a/src/proto_alpha/lib_protocol/sc_rollup_operations.mli b/src/proto_alpha/lib_protocol/sc_rollup_operations.mli index 814114f58ebcbadecc231b0cc75ab1c3545ac8aa..52ba55d8d162019b3edc3d68ca240eb49787e2f9 100644 --- a/src/proto_alpha/lib_protocol/sc_rollup_operations.mli +++ b/src/proto_alpha/lib_protocol/sc_rollup_operations.mli @@ -41,12 +41,12 @@ val originate : parameters_ty:Script_repr.lazy_expr -> (origination_result * context) tzresult Lwt.t -val atomic_batch : +val execute_outbox_message : context -> Sc_rollup.t -> Sc_rollup.Commitment.Hash.t -> outbox_level:Raw_level.t -> message_index:int -> inclusion_proof:string -> - atomic_transaction_batch:string -> + message:string -> context tzresult Lwt.t diff --git a/src/proto_alpha/lib_protocol/test/helpers/block.ml b/src/proto_alpha/lib_protocol/test/helpers/block.ml index a764db602b0f4d0f300a8680aa4c113f33c681ca..b40c5e018755b9ed64ea7d49eecaac7ed236838c 100644 --- a/src/proto_alpha/lib_protocol/test/helpers/block.ml +++ b/src/proto_alpha/lib_protocol/test/helpers/block.ml @@ -756,7 +756,8 @@ let bake_n_with_all_balance_updates ?(baking_mode = Application) ?policy | Dal_publish_slot_header_result _ | Sc_rollup_originate_result _ | Sc_rollup_add_messages_result _ | Sc_rollup_cement_result _ | Sc_rollup_publish_result _ | Sc_rollup_refute_result _ - | Sc_rollup_timeout_result _ | Sc_rollup_atomic_batch_result _ + | Sc_rollup_timeout_result _ + | Sc_rollup_execute_outbox_message_result _ | Sc_rollup_return_bond_result _ -> balance_updates_rev | Transaction_result @@ -804,7 +805,8 @@ let bake_n_with_origination_results ?(baking_mode = Application) ?policy n b = | Successful_manager_result (Sc_rollup_publish_result _) | Successful_manager_result (Sc_rollup_refute_result _) | Successful_manager_result (Sc_rollup_timeout_result _) - | Successful_manager_result (Sc_rollup_atomic_batch_result _) + | Successful_manager_result + (Sc_rollup_execute_outbox_message_result _) | Successful_manager_result (Sc_rollup_return_bond_result _) -> origination_results_rev | Successful_manager_result (Origination_result x) -> diff --git a/src/proto_alpha/lib_protocol/test/helpers/op.ml b/src/proto_alpha/lib_protocol/test/helpers/op.ml index f97a761475f9129c8a85979eb2ff5a6da8a5c419..502233975337bd34a1369022dcbdec5e6e7b4499 100644 --- a/src/proto_alpha/lib_protocol/test/helpers/op.ml +++ b/src/proto_alpha/lib_protocol/test/helpers/op.ml @@ -781,9 +781,9 @@ let sc_rollup_cement ?force_reveal ?counter ?fee ?gas_limit ?storage_limit ctxt Context.Contract.manager ctxt src >|=? fun account -> sign account.sk ctxt to_sign_op -let sc_rollup_atomic_batch ?counter ?fee ?gas_limit ?storage_limit ctxt - (src : Contract.t) rollup cemented_commitment ~outbox_level ~message_index - ~inclusion_proof ~atomic_transaction_batch = +let sc_rollup_execute_outbox_message ?counter ?fee ?gas_limit ?storage_limit + ctxt (src : Contract.t) rollup cemented_commitment ~outbox_level + ~message_index ~inclusion_proof ~message = manager_operation ?counter ?fee @@ -791,14 +791,14 @@ let sc_rollup_atomic_batch ?counter ?fee ?gas_limit ?storage_limit ctxt ?storage_limit ~source:src ctxt - (Sc_rollup_atomic_batch + (Sc_rollup_execute_outbox_message { rollup; cemented_commitment; outbox_level; message_index; inclusion_proof; - atomic_transaction_batch; + message; }) >>=? fun to_sign_op -> Context.Contract.manager ctxt src >|=? fun account -> diff --git a/src/proto_alpha/lib_protocol/test/helpers/op.mli b/src/proto_alpha/lib_protocol/test/helpers/op.mli index df044f633a6ed9d63819319e4fc063931d834456..207292acfb9f1b4884bdb3042a33d751dfb00811 100644 --- a/src/proto_alpha/lib_protocol/test/helpers/op.mli +++ b/src/proto_alpha/lib_protocol/test/helpers/op.mli @@ -529,7 +529,7 @@ val sc_rollup_cement : Sc_rollup.Commitment.Hash.t -> Operation.packed tzresult Lwt.t -val sc_rollup_atomic_batch : +val sc_rollup_execute_outbox_message : ?counter:counter -> ?fee:Tez.t -> ?gas_limit:Gas.Arith.integral -> @@ -541,7 +541,7 @@ val sc_rollup_atomic_batch : outbox_level:Raw_level.t -> message_index:int -> inclusion_proof:string -> - atomic_transaction_batch:string -> + message:string -> (packed_operation, tztrace) result Lwt.t (** [sc_rollup_return_bond ctxt source sc_rollup] returns a commitment bond. *) diff --git a/src/proto_alpha/lib_protocol/test/integration/operations/test_sc_rollup.ml b/src/proto_alpha/lib_protocol/test/integration/operations/test_sc_rollup.ml index 7eca03403fbe14da6f4c1bd66569792f18b2ab77..44e8a0f86f5909ffd69d3791fa1af94083c2113c 100644 --- a/src/proto_alpha/lib_protocol/test/integration/operations/test_sc_rollup.ml +++ b/src/proto_alpha/lib_protocol/test/integration/operations/test_sc_rollup.ml @@ -484,7 +484,7 @@ let test_atomic_batch_fails () = let* cement_op = Op.sc_rollup_cement (I i) contract rollup hash in let* _ = Incremental.add_operation i cement_op in let* batch_op = - Op.sc_rollup_atomic_batch + Op.sc_rollup_execute_outbox_message (I i) contract rollup @@ -492,7 +492,7 @@ let test_atomic_batch_fails () = ~outbox_level:(Raw_level.of_int32_exn 0l) ~message_index:0 ~inclusion_proof:"xyz" - ~atomic_transaction_batch:"xyz" + ~message:"xyz" in let expect_apply_failure = function | Environment.Ecoproto_error diff --git a/tezt/tests/expected/RPC_test.ml/Alpha- (mode client) RPC regression tests- mempool.out b/tezt/tests/expected/RPC_test.ml/Alpha- (mode client) RPC regression tests- mempool.out index dc708871c7c296db1b72daede540f0075c54569e..faa098c39d38b4a8e1d5ef16d854201935852aa1 100644 --- a/tezt/tests/expected/RPC_test.ml/Alpha- (mode client) RPC regression tests- mempool.out +++ b/tezt/tests/expected/RPC_test.ml/Alpha- (mode client) RPC regression tests- mempool.out @@ -6085,13 +6085,13 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "additionalProperties": false }, { - "title": "Sc_rollup_atomic_batch", + "title": "Sc_rollup_execute_outbox_message", "type": "object", "properties": { "kind": { "type": "string", "enum": [ - "sc_rollup_atomic_batch" + "sc_rollup_execute_outbox_message" ] }, "source": { @@ -6128,12 +6128,12 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "inclusion proof": { "$ref": "#/definitions/unistring" }, - "atomic_transaction_batch": { + "message": { "$ref": "#/definitions/unistring" } }, "required": [ - "atomic_transaction_batch", + "message", "inclusion proof", "message_index", "outbox_level", @@ -10441,7 +10441,7 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "size": "Uint30" }, { - "name": "atomic_transaction_batch", + "name": "message", "layout": { "kind": "String" }, @@ -10451,7 +10451,7 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" } ], - "name": "Sc_rollup_atomic_batch" + "name": "Sc_rollup_execute_outbox_message" }, { "tag": 207, @@ -21557,13 +21557,13 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "additionalProperties": false }, { - "title": "Sc_rollup_atomic_batch", + "title": "Sc_rollup_execute_outbox_message", "type": "object", "properties": { "kind": { "type": "string", "enum": [ - "sc_rollup_atomic_batch" + "sc_rollup_execute_outbox_message" ] }, "source": { @@ -21600,12 +21600,12 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "inclusion proof": { "$ref": "#/definitions/unistring" }, - "atomic_transaction_batch": { + "message": { "$ref": "#/definitions/unistring" } }, "required": [ - "atomic_transaction_batch", + "message", "inclusion proof", "message_index", "outbox_level", diff --git a/tezt/tests/expected/RPC_test.ml/Alpha- (mode proxy) RPC regression tests- mempool.out b/tezt/tests/expected/RPC_test.ml/Alpha- (mode proxy) RPC regression tests- mempool.out index 190541fe1c9e55ae86b17be09b5738575bc89cde..c9086a55e0e995271c3ec8bae5530f2018ae701d 100644 --- a/tezt/tests/expected/RPC_test.ml/Alpha- (mode proxy) RPC regression tests- mempool.out +++ b/tezt/tests/expected/RPC_test.ml/Alpha- (mode proxy) RPC regression tests- mempool.out @@ -6106,13 +6106,13 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "additionalProperties": false }, { - "title": "Sc_rollup_atomic_batch", + "title": "Sc_rollup_execute_outbox_message", "type": "object", "properties": { "kind": { "type": "string", "enum": [ - "sc_rollup_atomic_batch" + "sc_rollup_execute_outbox_message" ] }, "source": { @@ -6149,12 +6149,12 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "inclusion proof": { "$ref": "#/definitions/unistring" }, - "atomic_transaction_batch": { + "message": { "$ref": "#/definitions/unistring" } }, "required": [ - "atomic_transaction_batch", + "message", "inclusion proof", "message_index", "outbox_level", @@ -10462,7 +10462,7 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "size": "Uint30" }, { - "name": "atomic_transaction_batch", + "name": "message", "layout": { "kind": "String" }, @@ -10472,7 +10472,7 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "kind": "named" } ], - "name": "Sc_rollup_atomic_batch" + "name": "Sc_rollup_execute_outbox_message" }, { "tag": 207, @@ -21578,13 +21578,13 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "additionalProperties": false }, { - "title": "Sc_rollup_atomic_batch", + "title": "Sc_rollup_execute_outbox_message", "type": "object", "properties": { "kind": { "type": "string", "enum": [ - "sc_rollup_atomic_batch" + "sc_rollup_execute_outbox_message" ] }, "source": { @@ -21621,12 +21621,12 @@ curl -s 'http://localhost:[PORT]/describe/chains/main/mempool?recurse=yes' "inclusion proof": { "$ref": "#/definitions/unistring" }, - "atomic_transaction_batch": { + "message": { "$ref": "#/definitions/unistring" } }, "required": [ - "atomic_transaction_batch", + "message", "inclusion proof", "message_index", "outbox_level",