Refactor get_gas_spent

pallets/gear/rpc/Cargo.toml

@@ -18,4 +18,6 @@ sp-rpc = { version = "6.0.0", git = "https://github.com/gear-tech/substrate.git"
 sp-runtime = { version = "6.0.0", git = "https://github.com/gear-tech/substrate.git", branch = "gear-stable", default-features = false }
 
 # Local packages
+gear-core = { path = "../../../core" }
+gear-common = { path = "../../../common" }
 pallet-gear-rpc-runtime-api = { version = "2.0.0", path = "./runtime-api" }

pallets/gear/rpc/runtime-api/src/lib.rs

@@ -18,12 +18,13 @@
 
 #![cfg_attr(not(feature = "std"), no_std)]
 
-pub use pallet_gear::manager::HandleKind;
+pub use pallet_gear::{manager::HandleKind, GasInfo};
 use sp_core::H256;
 use sp_std::vec::Vec;
 
 sp_api::decl_runtime_apis! {
     pub trait GearApi {
-        fn get_gas_spent(source: H256, kind: HandleKind, payload: Vec<u8>, value: u128) -> Result<u64, Vec<u8>>;
+        #[allow(clippy::too_many_arguments)]
+        fn calculate_gas_info(source: H256, kind: HandleKind, payload: Vec<u8>, value: u128, allow_other_panics: bool,) -> Result<GasInfo, Vec<u8>>;
     }
 }

pallets/gear/rpc/src/lib.rs

@@ -18,22 +18,22 @@
 
 //! RPC interface for the gear module.
 
-use std::{convert::TryInto, sync::Arc};
+#![allow(clippy::too_many_arguments)]
 
+use gear_common::Origin;
+use gear_core::ids::{MessageId, ProgramId};
 use jsonrpsee::{
     core::{async_trait, Error as JsonRpseeError, RpcResult},
     proc_macros::rpc,
     types::error::{CallError, ErrorObject},
 };
-
-pub use pallet_gear_rpc_runtime_api::HandleKind;
+pub use pallet_gear_rpc_runtime_api::GearApi as GearRuntimeApi;
+use pallet_gear_rpc_runtime_api::{GasInfo, HandleKind};
 use sp_api::ProvideRuntimeApi;
 use sp_blockchain::HeaderBackend;
 use sp_core::{Bytes, H256};
-use sp_rpc::number::NumberOrHex;
 use sp_runtime::{generic::BlockId, traits::Block as BlockT};
-
-pub use pallet_gear_rpc_runtime_api::GearApi as GearRuntimeApi;
+use std::sync::Arc;
 
 /// Converts a runtime trap into a [`CallError`].
 fn runtime_error_into_rpc_error(err: impl std::fmt::Debug) -> JsonRpseeError {
@@ -47,36 +47,39 @@ fn runtime_error_into_rpc_error(err: impl std::fmt::Debug) -> JsonRpseeError {
 
 #[rpc(client, server)]
 pub trait GearApi<BlockHash, ResponseType> {
-    #[method(name = "gear_getInitGasSpent")]
+    #[method(name = "gear_calculateInitGas")]
     fn get_init_gas_spent(
         &self,
         source: H256,
         code: Bytes,
         payload: Bytes,
         value: u128,
+        allow_other_panics: bool,
         at: Option<BlockHash>,
-    ) -> RpcResult<NumberOrHex>;
+    ) -> RpcResult<GasInfo>;
 
-    #[method(name = "gear_getHandleGasSpent")]
+    #[method(name = "gear_calculateHandleGas")]
     fn get_handle_gas_spent(
         &self,
         source: H256,
         dest: H256,
         payload: Bytes,
         value: u128,
+        allow_other_panics: bool,
         at: Option<BlockHash>,
-    ) -> RpcResult<NumberOrHex>;
+    ) -> RpcResult<GasInfo>;
 
-    #[method(name = "gear_getReplyGasSpent")]
+    #[method(name = "gear_calculateReplyGas")]
     fn get_reply_gas_spent(
         &self,
         source: H256,
         message_id: H256,
         exit_code: i32,
         payload: Bytes,
         value: u128,
+        allow_other_panics: bool,
         at: Option<BlockHash>,
-    ) -> RpcResult<NumberOrHex>;
+    ) -> RpcResult<GasInfo>;
 }
 
 /// A struct that implements the [`GearApi`].
@@ -127,29 +130,26 @@ where
         code: Bytes,
         payload: Bytes,
         value: u128,
+        allow_other_panics: bool,
         at: Option<<Block as BlockT>::Hash>,
-    ) -> RpcResult<NumberOrHex> {
+    ) -> RpcResult<GasInfo> {
         let api = self.client.runtime_api();
         let at = BlockId::hash(at.unwrap_or_else(||
-			// If the block hash is not supplied assume the best block.
-			self.client.info().best_hash));
+            // If the block hash is not supplied assume the best block.
+            self.client.info().best_hash));
 
         let runtime_api_result = api
-            .get_gas_spent(
+            .calculate_gas_info(
                 &at,
                 source,
                 HandleKind::Init(code.to_vec()),
                 payload.to_vec(),
                 value,
+                allow_other_panics,
             )
             .map_err(runtime_error_into_rpc_error)?;
 
-        match runtime_api_result {
-            Ok(gas) => Ok(gas.try_into().map_err(runtime_error_into_rpc_error)?),
-            Err(message) => Err(runtime_error_into_rpc_error(String::from_utf8_lossy(
-                &message,
-            ))),
-        }
+        runtime_api_result.map_err(|e| runtime_error_into_rpc_error(String::from_utf8_lossy(&e)))
     }
 
     fn get_handle_gas_spent(
@@ -158,29 +158,26 @@ where
         dest: H256,
         payload: Bytes,
         value: u128,
+        allow_other_panics: bool,
         at: Option<<Block as BlockT>::Hash>,
-    ) -> RpcResult<NumberOrHex> {
+    ) -> RpcResult<GasInfo> {
         let api = self.client.runtime_api();
         let at = BlockId::hash(at.unwrap_or_else(||
-			// If the block hash is not supplied assume the best block.
-			self.client.info().best_hash));
+            // If the block hash is not supplied assume the best block.
+            self.client.info().best_hash));
 
         let runtime_api_result = api
-            .get_gas_spent(
+            .calculate_gas_info(
                 &at,
                 source,
-                HandleKind::Handle(dest),
+                HandleKind::Handle(ProgramId::from_origin(dest)),
                 payload.to_vec(),
                 value,
+                allow_other_panics,
             )
             .map_err(runtime_error_into_rpc_error)?;
 
-        match runtime_api_result {
-            Ok(gas) => Ok(gas.try_into().map_err(runtime_error_into_rpc_error)?),
-            Err(message) => Err(runtime_error_into_rpc_error(String::from_utf8_lossy(
-                &message,
-            ))),
-        }
+        runtime_api_result.map_err(|e| runtime_error_into_rpc_error(String::from_utf8_lossy(&e)))
     }
 
     fn get_reply_gas_spent(
@@ -190,28 +187,25 @@ where
         exit_code: i32,
         payload: Bytes,
         value: u128,
+        allow_other_panics: bool,
         at: Option<<Block as BlockT>::Hash>,
-    ) -> RpcResult<NumberOrHex> {
+    ) -> RpcResult<GasInfo> {
         let api = self.client.runtime_api();
         let at = BlockId::hash(at.unwrap_or_else(||
-			// If the block hash is not supplied assume the best block.
-			self.client.info().best_hash));
+            // If the block hash is not supplied assume the best block.
+            self.client.info().best_hash));
 
         let runtime_api_result = api
-            .get_gas_spent(
+            .calculate_gas_info(
                 &at,
                 source,
-                HandleKind::Reply(message_id, exit_code),
+                HandleKind::Reply(MessageId::from_origin(message_id), exit_code),
                 payload.to_vec(),
                 value,
+                allow_other_panics,
             )
             .map_err(runtime_error_into_rpc_error)?;
 
-        match runtime_api_result {
-            Ok(gas) => Ok(gas.try_into().map_err(runtime_error_into_rpc_error)?),
-            Err(message) => Err(runtime_error_into_rpc_error(String::from_utf8_lossy(
-                &message,
-            ))),
-        }
+        runtime_api_result.map_err(|e| runtime_error_into_rpc_error(String::from_utf8_lossy(&e)))
     }
 }