From 35fbf72a78166400713e7e3f3e2079e28388e77d Mon Sep 17 00:00:00 2001 From: Sebastien Mondet Date: Fri, 23 Apr 2021 14:59:47 -0400 Subject: [PATCH 1/3] Florence/plugins: copy and fix Edo's plugins --- src/proto_009_PsFLoren/lib_plugin/plugin.ml | 546 +++++++++++++++++++- 1 file changed, 532 insertions(+), 14 deletions(-) diff --git a/src/proto_009_PsFLoren/lib_plugin/plugin.ml b/src/proto_009_PsFLoren/lib_plugin/plugin.ml index 6eedbcb0848e..f53acb115e49 100644 --- a/src/proto_009_PsFLoren/lib_plugin/plugin.ml +++ b/src/proto_009_PsFLoren/lib_plugin/plugin.ml @@ -234,6 +234,21 @@ end module RPC = struct open Environment + type Environment.Error_monad.error += Cannot_serialize_log_normalized + + let () = + (* Cannot serialize log *) + Environment.Error_monad.register_error_kind + `Temporary + ~id:"michelson_v1.cannot_serialize_log_normalized" + ~title:"Not enough gas to serialize normalized execution trace" + ~description: + "Execution trace with normalized stacks was to big to be serialized \ + with the provided gas" + Data_encoding.empty + (function Cannot_serialize_log_normalized -> Some () | _ -> None) + (fun () -> Cannot_serialize_log_normalized) + module Unparse_types = struct (* Same as the unparsing functions for types in Script_ir_translator but does not consume gas and never folds (pair a (pair b c)) *) @@ -286,12 +301,6 @@ module RPC = struct Prim (-1, T_option, [unparse_comparable_ty t], unparse_type_annot tname) - (* Uncomment when rebasing on top of Baking account *) - (* | Baker_hash_key tname -> - * Prim (-1, T_baker_hash, [], unparse_type_annot tname) - * | Pvss_key_key tname -> - * Prim (-1, T_pvss_key, [], unparse_type_annot tname) *) - let unparse_memo_size memo_size = let z = Alpha_context.Sapling.Memo_size.unparse_to_z memo_size in Int (-1, z) @@ -388,18 +397,71 @@ module RPC = struct ( T_sapling_state, [unparse_memo_size memo_size], unparse_type_annot tname ) - - (* Uncomment when rebasing on top of Baking account *) - (* | Baker_hash_t tname -> - * return (T_baker_hash, [], unparse_type_annot tname) - * | Pvss_key_t tname -> - * return (T_pvss_key, [], unparse_type_annot tname) - * | Baker_operation_t tname -> - * return (T_baker_operation, [], unparse_type_annot tname) *) end let helpers_path = RPC_path.(open_root / "helpers" / "scripts") + let contract_root = + ( RPC_path.(open_root / "context" / "contracts") + : RPC_context.t RPC_path.context ) + + let big_map_root = + ( RPC_path.(open_root / "context" / "big_maps") + : RPC_context.t RPC_path.context ) + + let unparsing_mode_encoding = + let open Data_encoding in + union + ~tag_size:`Uint8 + [ case + (Tag 0) + ~title:"Readable" + (constant "Readable") + (function + | Script_ir_translator.Readable -> + Some () + | Script_ir_translator.Optimized + | Script_ir_translator.Optimized_legacy -> + None) + (fun () -> Script_ir_translator.Readable); + case + (Tag 1) + ~title:"Optimized" + (constant "Optimized") + (function + | Script_ir_translator.Optimized -> + Some () + | Script_ir_translator.Readable + | Script_ir_translator.Optimized_legacy -> + None) + (fun () -> Script_ir_translator.Optimized); + case + (Tag 2) + ~title:"Optimized_legacy" + (constant "Optimized_legacy") + (function + | Script_ir_translator.Optimized_legacy -> + Some () + | Script_ir_translator.Readable | Script_ir_translator.Optimized -> + None) + (fun () -> Script_ir_translator.Optimized_legacy) ] + + let run_code_input_encoding = + let open Data_encoding in + merge_objs + (obj10 + (req "script" Script.expr_encoding) + (req "storage" Script.expr_encoding) + (req "input" Script.expr_encoding) + (req "amount" Tez.encoding) + (req "balance" Tez.encoding) + (req "chain_id" Chain_id.encoding) + (opt "source" Contract.encoding) + (opt "payer" Contract.encoding) + (opt "gas" Gas.Arith.z_integral_encoding) + (dft "entrypoint" string "default")) + (obj1 (req "unparsing_mode" unparsing_mode_encoding)) + let normalize_type = let open Data_encoding in RPC_service.post_service @@ -411,6 +473,119 @@ module RPC = struct ~query:RPC_query.empty RPC_path.(helpers_path / "normalize_type") + let get_storage_normalized = + let open Data_encoding in + RPC_service.post_service + ~description: + "Access the data of the contract and normalize it using the requested \ + unparsing mode." + ~input:(obj1 (req "unparsing_mode" unparsing_mode_encoding)) + ~query:RPC_query.empty + ~output:(option Script.expr_encoding) + RPC_path.(contract_root /: Contract.rpc_arg / "storage" / "normalized") + + let get_script_normalized = + let open Data_encoding in + RPC_service.post_service + ~description: + "Access the script of the contract and normalize it using the \ + requested unparsing mode." + ~input:(obj1 (req "unparsing_mode" unparsing_mode_encoding)) + ~query:RPC_query.empty + ~output:(option Script.encoding) + RPC_path.(contract_root /: Contract.rpc_arg / "script" / "normalized") + + let run_code_normalized = + let open Data_encoding in + RPC_service.post_service + ~description: + "Run a piece of code in the current context, normalize the output \ + using the requested unparsing mode." + ~query:RPC_query.empty + ~input:run_code_input_encoding + ~output: + (conv + (fun (storage, operations, lazy_storage_diff) -> + (storage, operations, lazy_storage_diff, lazy_storage_diff)) + (fun ( storage, + operations, + legacy_lazy_storage_diff, + lazy_storage_diff ) -> + let lazy_storage_diff = + match lazy_storage_diff with + | Some s -> + Some s + | None -> + legacy_lazy_storage_diff + in + (storage, operations, lazy_storage_diff)) + (obj4 + (req "storage" Script.expr_encoding) + (req + "operations" + (list Alpha_context.Operation.internal_operation_encoding)) + (opt "big_map_diff" Lazy_storage.legacy_big_map_diff_encoding) + (opt "lazy_storage_diff" Lazy_storage.encoding))) + RPC_path.(helpers_path / "run_code" / "normalized") + + let trace_encoding = + let open Data_encoding in + def "scripted.trace" @@ list + @@ obj3 + (req "location" Script.location_encoding) + (req "gas" Gas.encoding) + (req + "stack" + (list (obj2 (req "item" Script.expr_encoding) (opt "annot" string)))) + + let trace_code_normalized = + let open Data_encoding in + RPC_service.post_service + ~description: + "Run a piece of code in the current context, keeping a trace, \ + normalize the output using the requested unparsing mode." + ~query:RPC_query.empty + ~input:run_code_input_encoding + ~output: + (conv + (fun (storage, operations, trace, lazy_storage_diff) -> + (storage, operations, trace, lazy_storage_diff, lazy_storage_diff)) + (fun ( storage, + operations, + trace, + legacy_lazy_storage_diff, + lazy_storage_diff ) -> + let lazy_storage_diff = + match lazy_storage_diff with + | Some s -> + Some s + | None -> + legacy_lazy_storage_diff + in + (storage, operations, trace, lazy_storage_diff)) + (obj5 + (req "storage" Script.expr_encoding) + (req + "operations" + (list Alpha_context.Operation.internal_operation_encoding)) + (req "trace" trace_encoding) + (opt "big_map_diff" Lazy_storage.legacy_big_map_diff_encoding) + (opt "lazy_storage_diff" Lazy_storage.encoding))) + RPC_path.(helpers_path / "trace_code" / "normalized") + + let big_map_get_normalized = + let open Data_encoding in + RPC_service.post_service + ~description: + "Access the value associated with a key in a big map, normalize the \ + output using the requested unparsing mode." + ~query:RPC_query.empty + ~input:(obj1 (req "unparsing_mode" unparsing_mode_encoding)) + ~output:Script.expr_encoding + RPC_path.( + big_map_root /: Big_map.Id.rpc_arg /: Script_expr_hash.rpc_arg + / "normalized") + let rpc_services = let patched_services = ref (RPC_directory.empty : Updater.rpc_context RPC_directory.t) @@ -421,6 +596,52 @@ module RPC = struct Services_registration.rpc_init ctxt >>=? fun ctxt -> f ctxt q i) in let register0 s f = register0_fullctxt s (fun {context; _} -> f context) in + let register1_fullctxt s f = + patched_services := + RPC_directory.register !patched_services s (fun (ctxt, arg) q i -> + Services_registration.rpc_init ctxt >>=? fun ctxt -> f ctxt arg q i) + in + let register1 s f = + register1_fullctxt s (fun {context; _} x -> f context x) + in + let _register1_noctxt s f = + patched_services := + RPC_directory.register !patched_services s (fun (_, arg) q i -> + f arg q i) + in + let register2_fullctxt s f = + patched_services := + RPC_directory.register + !patched_services + s + (fun ((ctxt, arg1), arg2) q i -> + Services_registration.rpc_init ctxt + >>=? fun ctxt -> f ctxt arg1 arg2 q i) + in + let register2 s f = + register2_fullctxt s (fun {context; _} a1 a2 q i -> f context a1 a2 q i) + in + let register_field s f = + register1 s (fun ctxt contract () () -> + Contract.exists ctxt contract + >>=? function true -> f ctxt contract | false -> raise Not_found) + in + let _register_opt_field s f = + register_field s (fun ctxt a1 -> + f ctxt a1 >|=? function None -> raise Not_found | Some v -> v) + in + let originate_dummy_contract ctxt script balance = + let ctxt = Contract.init_origination_nonce ctxt Operation_hash.zero in + Lwt.return (Contract.fresh_contract_from_current_nonce ctxt) + >>=? fun (ctxt, dummy_contract) -> + Contract.originate + ctxt + dummy_contract + ~balance + ~delegate:None + ~script:(script, None) + >>=? fun ctxt -> return (ctxt, dummy_contract) + in register0 normalize_type (fun ctxt () typ -> let open Script_ir_translator in let ctxt = Gas.set_unlimited ctxt in @@ -436,8 +657,305 @@ module RPC = struct >>?= fun (Ex_ty typ, _ctxt) -> let normalized = Unparse_types.unparse_ty typ in return @@ Micheline.strip_locations normalized) ; + (* Patched RPC: get_storage *) + register1 get_storage_normalized (fun ctxt contract () unparsing_mode -> + Contract.get_script ctxt contract + >>=? fun (ctxt, script) -> + match script with + | None -> + return_none + | Some script -> + let ctxt = Gas.set_unlimited ctxt in + let open Script_ir_translator in + parse_script ctxt ~legacy:true ~allow_forged_in_storage:true script + >>=? fun (Ex_script script, ctxt) -> + unparse_script ctxt unparsing_mode script + >>=? fun (script, ctxt) -> + Script.force_decode_in_context ctxt script.storage + >>?= fun (storage, _ctxt) -> return_some storage) ; + (* Patched RPC: get_script *) + register1 get_script_normalized (fun ctxt contract () unparsing_mode -> + Contract.get_script ctxt contract + >>=? fun (ctxt, script) -> + match script with + | None -> + return_none + | Some script -> + let ctxt = Gas.set_unlimited ctxt in + let open Script_ir_translator in + parse_script ctxt ~legacy:true ~allow_forged_in_storage:true script + >>=? fun (Ex_script script, ctxt) -> + unparse_script ctxt unparsing_mode script + >>=? fun (script, _ctxt) -> return_some script) ; + register0 + run_code_normalized + (fun ctxt + () + ( ( code, + storage, + parameter, + amount, + balance, + chain_id, + source, + payer, + gas, + entrypoint ), + unparsing_mode ) + -> + let storage = Script.lazy_expr storage in + let code = Script.lazy_expr code in + originate_dummy_contract ctxt {storage; code} balance + >>=? fun (ctxt, dummy_contract) -> + let (source, payer) = + match (source, payer) with + | (Some source, Some payer) -> + (source, payer) + | (Some source, None) -> + (source, source) + | (None, Some payer) -> + (payer, payer) + | (None, None) -> + (dummy_contract, dummy_contract) + in + let gas = + match gas with + | Some gas -> + gas + | None -> + Constants.hard_gas_limit_per_operation ctxt + in + let ctxt = Gas.set_limit ctxt gas in + let step_constants = + let open Script_interpreter in + {source; payer; self = dummy_contract; amount; chain_id} + in + Script_interpreter.execute + ctxt + unparsing_mode + step_constants + ~script:{storage; code} + ~entrypoint + ~parameter + ~internal:true + >|=? fun {Script_interpreter.storage; operations; lazy_storage_diff; _} -> + (storage, operations, lazy_storage_diff)) ; + register0 + trace_code_normalized + (fun ctxt + () + ( ( code, + storage, + parameter, + amount, + balance, + chain_id, + source, + payer, + gas, + entrypoint ), + unparsing_mode ) + -> + let module Traced_interpreter = struct + type log_element = + | Log : + context * Script.location * 'a * 'a Script_typed_ir.stack_ty + -> log_element + + let unparse_stack ctxt (stack, stack_ty) = + (* We drop the gas limit as this function is only used for debugging/errors. *) + let ctxt = Gas.set_unlimited ctxt in + let rec unparse_stack : + type a. + a Script_typed_ir.stack_ty * a -> + (Script.expr * string option) list + Environment.Error_monad.tzresult + Lwt.t = function + | (Empty_t, ()) -> + return_nil + | (Item_t (ty, rest_ty, annot), (v, rest)) -> + Script_ir_translator.unparse_data ctxt unparsing_mode ty v + >>=? fun (data, _ctxt) -> + unparse_stack (rest_ty, rest) + >|=? fun rest -> + let annot = + match Script_ir_annot.unparse_var_annot annot with + | [] -> + None + | [a] -> + Some a + | _ -> + assert false + in + let data = Micheline.strip_locations data in + (data, annot) :: rest + in + unparse_stack (stack_ty, stack) + + module Trace_logger () : Script_interpreter.STEP_LOGGER = struct + let log : log_element list ref = ref [] + + let log_interp ctxt (descr : (_, _) Script_typed_ir.descr) stack = + log := Log (ctxt, descr.loc, stack, descr.bef) :: !log + + let log_entry _ctxt _descr _stack = () + + let log_exit ctxt (descr : (_, _) Script_typed_ir.descr) stack = + log := Log (ctxt, descr.loc, stack, descr.aft) :: !log + + let get_log () = + Environment.Error_monad.map_s + (fun (Log (ctxt, loc, stack, stack_ty)) -> + Environment.Error_monad.trace + Cannot_serialize_log_normalized + (unparse_stack ctxt (stack, stack_ty)) + >>=? fun stack -> return (loc, Gas.level ctxt, stack)) + !log + >>=? fun res -> return (Some (List.rev res)) + end + end in + let storage = Script.lazy_expr storage in + let code = Script.lazy_expr code in + originate_dummy_contract ctxt {storage; code} balance + >>=? fun (ctxt, dummy_contract) -> + let (source, payer) = + match (source, payer) with + | (Some source, Some payer) -> + (source, payer) + | (Some source, None) -> + (source, source) + | (None, Some payer) -> + (payer, payer) + | (None, None) -> + (dummy_contract, dummy_contract) + in + let gas = + match gas with + | Some gas -> + gas + | None -> + Constants.hard_gas_limit_per_operation ctxt + in + let ctxt = Gas.set_limit ctxt gas in + let step_constants = + let open Script_interpreter in + {source; payer; self = dummy_contract; amount; chain_id} + in + let module Logger = Traced_interpreter.Trace_logger () in + let logger = (module Logger : Script_interpreter.STEP_LOGGER) in + Script_interpreter.execute + ~logger + ctxt + unparsing_mode + step_constants + ~script:{storage; code} + ~entrypoint + ~parameter + ~internal:true + >>=? fun {storage; lazy_storage_diff; operations; _} -> + Logger.get_log () + >|=? fun trace -> + let trace = Option.value ~default:[] trace in + (storage, operations, trace, lazy_storage_diff)) ; + register2 big_map_get_normalized (fun ctxt id key () unparsing_mode -> + let open Script_ir_translator in + let ctxt = Gas.set_unlimited ctxt in + Big_map.exists ctxt id + >>=? fun (ctxt, types) -> + match types with + | None -> + raise Not_found + | Some (_, value_type) -> ( + parse_big_map_value_ty + ctxt + ~legacy:true + (Micheline.root value_type) + >>?= fun (Ex_ty value_type, ctxt) -> + Big_map.get_opt ctxt id key + >>=? fun (_ctxt, value) -> + match value with + | None -> + raise Not_found + | Some value -> + parse_data + ctxt + ~legacy:true + ~allow_forged:true + value_type + (Micheline.root value) + >>=? fun (value, ctxt) -> + unparse_data ctxt unparsing_mode value_type value + >|=? fun (value, _ctxt) -> Micheline.strip_locations value )) ; RPC_directory.merge rpc_services !patched_services let normalize_type ctxt block ~ty = RPC_context.make_call0 normalize_type ctxt block () ty + + let get_storage_normalized ctxt block ~contract ~unparsing_mode = + RPC_context.make_call1 + get_storage_normalized + ctxt + block + contract + () + unparsing_mode + + let get_script_normalized ctxt block ~contract ~unparsing_mode = + RPC_context.make_call1 + get_script_normalized + ctxt + block + contract + () + unparsing_mode + + let run_code_normalized ctxt block ?gas ?(entrypoint = "default") ~script + ~storage ~input ~amount ~balance ~chain_id ~source ~payer ~unparsing_mode + = + RPC_context.make_call0 + run_code_normalized + ctxt + block + () + ( ( script, + storage, + input, + amount, + balance, + chain_id, + source, + payer, + gas, + entrypoint ), + unparsing_mode ) + + let trace_code_normalized ctxt block ?gas ?(entrypoint = "default") ~script + ~storage ~input ~amount ~balance ~chain_id ~source ~payer ~unparsing_mode + = + RPC_context.make_call0 + trace_code_normalized + ctxt + block + () + ( ( script, + storage, + input, + amount, + balance, + chain_id, + source, + payer, + gas, + entrypoint ), + unparsing_mode ) + + let big_map_get_normalized ctxt block id key ~unparsing_mode = + RPC_context.make_call2 + big_map_get_normalized + ctxt + block + id + key + () + unparsing_mode end -- GitLab From 641ab586f4521a0256e9ad7650b8d531cb6380cc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rapha=C3=ABl=20Cauderlier?= Date: Thu, 29 Apr 2021 12:06:17 +0200 Subject: [PATCH 2/3] Client (Florence): restore unparsing mode choice in context commands The following Florence Client commands missed the feature introduced in Edo RPC plugin to normalize and choose the unparsing mode for displaying their outputs: - get big map value - get contract storage - get contract script This restores the argument my using the Florence RPC plugin. --- .../lib_client/client_proto_context.ml | 5 ++-- .../lib_client/client_proto_context.mli | 1 + .../client_proto_context_commands.ml | 25 +++++++++++++------ 3 files changed, 21 insertions(+), 10 deletions(-) diff --git a/src/proto_009_PsFLoren/lib_client/client_proto_context.ml b/src/proto_009_PsFLoren/lib_client/client_proto_context.ml index 4b0bfa6d2918..2f145e431787 100644 --- a/src/proto_009_PsFLoren/lib_client/client_proto_context.ml +++ b/src/proto_009_PsFLoren/lib_client/client_proto_context.ml @@ -36,8 +36,9 @@ let get_balance (rpc : #rpc_context) ~chain ~block contract = let get_storage (rpc : #rpc_context) ~chain ~block contract = Alpha_services.Contract.storage_opt rpc (chain, block) contract -let get_big_map_value (rpc : #rpc_context) ~chain ~block id key = - Alpha_services.Contract.big_map_get rpc (chain, block) id key +let get_big_map_value (rpc : #rpc_context) ~chain ~block id key ~unparsing_mode + = + Plugin.RPC.big_map_get_normalized rpc (chain, block) id key ~unparsing_mode let get_contract_big_map_value (rpc : #rpc_context) ~chain ~block contract key = diff --git a/src/proto_009_PsFLoren/lib_client/client_proto_context.mli b/src/proto_009_PsFLoren/lib_client/client_proto_context.mli index d662c3b4ab47..da21870931a4 100644 --- a/src/proto_009_PsFLoren/lib_client/client_proto_context.mli +++ b/src/proto_009_PsFLoren/lib_client/client_proto_context.mli @@ -53,6 +53,7 @@ val get_big_map_value : block:Shell_services.block -> Big_map.Id.t -> Script_expr_hash.t -> + unparsing_mode:Script_ir_translator.unparsing_mode -> Script.expr tzresult Lwt.t val get_script : diff --git a/src/proto_009_PsFLoren/lib_client_commands/client_proto_context_commands.ml b/src/proto_009_PsFLoren/lib_client_commands/client_proto_context_commands.ml index b279afdda657..f630118c65cd 100644 --- a/src/proto_009_PsFLoren/lib_client_commands/client_proto_context_commands.ml +++ b/src/proto_009_PsFLoren/lib_client_commands/client_proto_context_commands.ml @@ -296,12 +296,16 @@ let commands network () = command ~group ~desc:"Get the storage of a contract." - no_options + (args1 (unparsing_mode_arg ~default:"Readable")) ( prefixes ["get"; "contract"; "storage"; "for"] @@ ContractAlias.destination_param ~name:"src" ~desc:"source contract" @@ stop ) - (fun () (_, contract) (cctxt : Protocol_client_context.full) -> - get_storage cctxt ~chain:cctxt#chain ~block:cctxt#block contract + (fun unparsing_mode (_, contract) (cctxt : Protocol_client_context.full) -> + Plugin.RPC.get_storage_normalized + cctxt + (cctxt#chain, cctxt#block) + ~contract + ~unparsing_mode >>=? function | None -> cctxt#error "This is not a smart contract." @@ -337,7 +341,7 @@ let commands network () = command ~group ~desc:"Get a value in a big map." - no_options + (args1 (unparsing_mode_arg ~default:"Readable")) ( prefixes ["get"; "element"] @@ Clic.param ~name:"key" @@ -350,25 +354,30 @@ let commands network () = ~desc:"identifier of the big_map" int_parameter @@ stop ) - (fun () key id (cctxt : Protocol_client_context.full) -> + (fun unparsing_mode key id (cctxt : Protocol_client_context.full) -> get_big_map_value cctxt ~chain:cctxt#chain ~block:cctxt#block (Big_map.Id.parse_z (Z.of_int id)) key + ~unparsing_mode >>=? fun value -> cctxt#answer "%a" Michelson_v1_printer.print_expr_unwrapped value >>= fun () -> return_unit); command ~group ~desc:"Get the code of a contract." - no_options + (args1 (unparsing_mode_arg ~default:"Readable")) ( prefixes ["get"; "contract"; "code"; "for"] @@ ContractAlias.destination_param ~name:"src" ~desc:"source contract" @@ stop ) - (fun () (_, contract) (cctxt : Protocol_client_context.full) -> - get_script cctxt ~chain:cctxt#chain ~block:cctxt#block contract + (fun unparsing_mode (_, contract) (cctxt : Protocol_client_context.full) -> + Plugin.RPC.get_script_normalized + cctxt + (cctxt#chain, cctxt#block) + ~contract + ~unparsing_mode >>=? function | None -> cctxt#error "This is not a smart contract." -- GitLab From 8dc327596f0f64f0526c5d02768a9c4c671fd0a5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rapha=C3=ABl=20Cauderlier?= Date: Fri, 30 Apr 2021 10:07:32 +0200 Subject: [PATCH 3/3] Client (Florence): use RPCs from the plugin instead of the protocol For the `run code` command, the Florence client now uses the same RPCs than the Edo one i.e. it takes the .../normalized version from the RPC plugin instead of the protocol RPC. --- .../lib_client/client_proto_programs.ml | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/proto_009_PsFLoren/lib_client/client_proto_programs.ml b/src/proto_009_PsFLoren/lib_client/client_proto_programs.ml index 6910e290e784..54994ae0dfcc 100644 --- a/src/proto_009_PsFLoren/lib_client/client_proto_programs.ml +++ b/src/proto_009_PsFLoren/lib_client/client_proto_programs.ml @@ -116,12 +116,11 @@ let run (cctxt : #Protocol_client_context.rpc_context) ?entrypoint () = Chain_services.chain_id cctxt ~chain () >>=? fun chain_id -> - Alpha_services.Helpers.Scripts.run_code + Plugin.RPC.run_code_normalized cctxt (chain, block) ?gas ?entrypoint - ~unparsing_mode ~script:program.expanded ~storage:storage.expanded ~input:input.expanded @@ -130,6 +129,7 @@ let run (cctxt : #Protocol_client_context.rpc_context) ~chain_id ~source ~payer + ~unparsing_mode let trace (cctxt : #Protocol_client_context.rpc_context) ~(chain : Chain_services.chain) ~block ?(amount = Tez.fifty_cents) ~balance @@ -140,12 +140,11 @@ let trace (cctxt : #Protocol_client_context.rpc_context) ?entrypoint () = Chain_services.chain_id cctxt ~chain () >>=? fun chain_id -> - Alpha_services.Helpers.Scripts.trace_code + Plugin.RPC.trace_code_normalized cctxt (chain, block) ?gas ?entrypoint - ~unparsing_mode ~script:program.expanded ~storage:storage.expanded ~input:input.expanded @@ -154,6 +153,7 @@ let trace (cctxt : #Protocol_client_context.rpc_context) ~chain_id ~source ~payer + ~unparsing_mode let typecheck_data cctxt ~(chain : Chain_services.chain) ~block ?gas ?legacy ~(data : Michelson_v1_parser.parsed) ~(ty : Michelson_v1_parser.parsed) () -- GitLab