Add payment_queryFeeDetails RPC (#7692)

* Return FeeDetails in compute_fee_raw()

* Add payment_queryDetails rpc

* Simplify serde attribute a bit

* Fix line width check

* Use saturating_add()

* Move transaction payment rpc types to types.rs

* Add file header

* Fix test

* Update Cargo.lock

* Nit

* Apply the review suggestions

* .

* .

* Fix serde

* Fix rust doc

* .

* Update frame/transaction-payment/src/types.rs

Co-authored-by: Guillaume Thiolliere <gui.thiolliere@gmail.com>

* Use NumberOrHex in fee details RPC

* Address review feedback

* Nits

* Update some docs

* Address review

* Update frame/transaction-payment/src/types.rs

Co-authored-by: Guillaume Thiolliere <gui.thiolliere@gmail.com>

* Happy 2021

* Nit

* Address code review

* Remove needless bound

Co-authored-by: Guillaume Thiolliere <gui.thiolliere@gmail.com>

substrate/Cargo.lock

@@ -5119,9 +5119,9 @@ dependencies = [
  "frame-support",
  "frame-system",
  "pallet-balances",
- "pallet-transaction-payment-rpc-runtime-api",
  "parity-scale-codec",
  "serde",
+ "serde_json",
  "smallvec 1.5.0",
  "sp-core",
  "sp-io",
@@ -5139,7 +5139,6 @@ dependencies = [
  "jsonrpc-derive",
  "pallet-transaction-payment-rpc-runtime-api",
  "parity-scale-codec",
- "serde",
  "sp-api",
  "sp-blockchain",
  "sp-core",
@@ -5151,13 +5150,10 @@ dependencies = [
 name = "pallet-transaction-payment-rpc-runtime-api"
 version = "2.0.1"
 dependencies = [
- "frame-support",
+ "pallet-transaction-payment",
  "parity-scale-codec",
- "serde",
- "serde_json",
  "sp-api",
  "sp-runtime",
- "sp-std",
 ]
 
 [[package]]

substrate/bin/node-template/runtime/src/lib.rs

@@ -438,6 +438,12 @@ impl_runtime_apis! {
 		) -> pallet_transaction_payment_rpc_runtime_api::RuntimeDispatchInfo<Balance> {
 			TransactionPayment::query_info(uxt, len)
 		}
+		fn query_fee_details(
+			uxt: <Block as BlockT>::Extrinsic,
+			len: u32,
+		) -> pallet_transaction_payment::FeeDetails<Balance> {
+			TransactionPayment::query_fee_details(uxt, len)
+		}
 	}
 
 	#[cfg(feature = "runtime-benchmarks")]

substrate/bin/node/runtime/src/lib.rs

@@ -66,7 +66,7 @@ use pallet_grandpa::{AuthorityId as GrandpaId, AuthorityList as GrandpaAuthority
 use pallet_grandpa::fg_primitives;
 use pallet_im_online::sr25519::AuthorityId as ImOnlineId;
 use sp_authority_discovery::AuthorityId as AuthorityDiscoveryId;
-use pallet_transaction_payment_rpc_runtime_api::RuntimeDispatchInfo;
+use pallet_transaction_payment::{FeeDetails, RuntimeDispatchInfo};
 pub use pallet_transaction_payment::{Multiplier, TargetedFeeAdjustment, CurrencyAdapter};
 use pallet_session::{historical as pallet_session_historical};
 use sp_inherents::{InherentData, CheckInherentsResult};
@@ -1259,6 +1259,9 @@ impl_runtime_apis! {
 		fn query_info(uxt: <Block as BlockT>::Extrinsic, len: u32) -> RuntimeDispatchInfo<Balance> {
 			TransactionPayment::query_info(uxt, len)
 		}
+		fn query_fee_details(uxt: <Block as BlockT>::Extrinsic, len: u32) -> FeeDetails<Balance> {
+			TransactionPayment::query_fee_details(uxt, len)
+		}
 	}
 
 	impl sp_session::SessionKeys<Block> for Runtime {

substrate/frame/transaction-payment/Cargo.toml

@@ -19,12 +19,12 @@ sp-std = { version = "2.0.0", default-features = false, path = "../../primitives
 sp-runtime = { version = "2.0.0", default-features = false, path = "../../primitives/runtime" }
 frame-support = { version = "2.0.0", default-features = false, path = "../support" }
 frame-system = { version = "2.0.0", default-features = false, path = "../system" }
-pallet-transaction-payment-rpc-runtime-api = { version = "2.0.0", default-features = false, path = "./rpc/runtime-api" }
 smallvec = "1.4.1"
 sp-io = { version = "2.0.0", path = "../../primitives/io", default-features = false }
 sp-core = { version = "2.0.0", path = "../../primitives/core", default-features = false }
 
 [dev-dependencies]
+serde_json = "1.0.41"
 pallet-balances = { version = "2.0.0", path = "../balances" }
 sp-storage = { version = "2.0.0", path = "../../primitives/storage" }
 
@@ -37,7 +37,6 @@ std = [
 	"sp-runtime/std",
 	"frame-support/std",
 	"frame-system/std",
-	"pallet-transaction-payment-rpc-runtime-api/std",
 	"sp-io/std",
 	"sp-core/std",
 ]

substrate/frame/transaction-payment/rpc/Cargo.toml

@@ -19,7 +19,6 @@ jsonrpc-core-client = "15.1.0"
 jsonrpc-derive = "15.1.0"
 sp-core = { version = "2.0.0", path = "../../../primitives/core" }
 sp-rpc = { version = "2.0.0", path = "../../../primitives/rpc" }
-serde = { version = "1.0.101", features = ["derive"] }
 sp-runtime = { version = "2.0.0", path = "../../../primitives/runtime" }
 sp-api = { version = "2.0.0", path = "../../../primitives/api" }
 sp-blockchain = { version = "2.0.0", path = "../../../primitives/blockchain" }

substrate/frame/transaction-payment/rpc/runtime-api/Cargo.toml

@@ -13,23 +13,16 @@ readme = "README.md"
 targets = ["x86_64-unknown-linux-gnu"]
 
 [dependencies]
-serde = { version = "1.0.101", optional = true, features = ["derive"] }
 sp-api = { version = "2.0.0", default-features = false, path = "../../../../primitives/api" }
 codec = { package = "parity-scale-codec", version = "1.3.6", default-features = false, features = ["derive"] }
-sp-std = { version = "2.0.0", default-features = false, path = "../../../../primitives/std" }
 sp-runtime = { version = "2.0.0", default-features = false, path = "../../../../primitives/runtime" }
-frame-support = { version = "2.0.0", default-features = false, path = "../../../support" }
-
-[dev-dependencies]
-serde_json = "1.0.41"
+pallet-transaction-payment = { version = "2.0.0", default-features = false, path = "../../../transaction-payment" }
 
 [features]
 default = ["std"]
 std = [
-	"serde",
 	"sp-api/std",
 	"codec/std",
-	"sp-std/std",
 	"sp-runtime/std",
-	"frame-support/std",
+	"pallet-transaction-payment/std",
 ]

substrate/frame/transaction-payment/rpc/runtime-api/src/lib.rs

@@ -19,85 +19,16 @@
 
 #![cfg_attr(not(feature = "std"), no_std)]
 
-use sp_std::prelude::*;
-use frame_support::weights::{Weight, DispatchClass};
-use codec::{Encode, Codec, Decode};
-#[cfg(feature = "std")]
-use serde::{Serialize, Deserialize, Serializer, Deserializer};
-use sp_runtime::traits::{MaybeDisplay, MaybeFromStr};
+use codec::Codec;
+use sp_runtime::traits::MaybeDisplay;
 
-/// Information related to a dispatchable's class, weight, and fee that can be queried from the runtime.
-#[derive(Eq, PartialEq, Encode, Decode, Default)]
-#[cfg_attr(feature = "std", derive(Debug, Serialize, Deserialize))]
-#[cfg_attr(feature = "std", serde(rename_all = "camelCase"))]
-pub struct RuntimeDispatchInfo<Balance> {
-	/// Weight of this dispatch.
-	pub weight: Weight,
-	/// Class of this dispatch.
-	pub class: DispatchClass,
-	/// The inclusion fee of this dispatch. This does not include a tip or anything else that
-	/// depends on the signature (i.e. depends on a `SignedExtension`).
-	#[cfg_attr(feature = "std", serde(bound(serialize = "Balance: std::fmt::Display")))]
-	#[cfg_attr(feature = "std", serde(serialize_with = "serialize_as_string"))]
-	#[cfg_attr(feature = "std", serde(bound(deserialize = "Balance: std::str::FromStr")))]
-	#[cfg_attr(feature = "std", serde(deserialize_with = "deserialize_from_string"))]
-	pub partial_fee: Balance,
-}
-
-#[cfg(feature = "std")]
-fn serialize_as_string<S: Serializer, T: std::fmt::Display>(t: &T, serializer: S) -> Result<S::Ok, S::Error> {
-	serializer.serialize_str(&t.to_string())
-}
-
-#[cfg(feature = "std")]
-fn deserialize_from_string<'de, D: Deserializer<'de>, T: std::str::FromStr>(deserializer: D) -> Result<T, D::Error> {
-	let s = String::deserialize(deserializer)?;
-	s.parse::<T>().map_err(|_| serde::de::Error::custom("Parse from string failed"))
-}
+pub use pallet_transaction_payment::{FeeDetails, InclusionFee, RuntimeDispatchInfo};
 
 sp_api::decl_runtime_apis! {
 	pub trait TransactionPaymentApi<Balance> where
-		Balance: Codec + MaybeDisplay + MaybeFromStr,
+		Balance: Codec + MaybeDisplay,
 	{
 		fn query_info(uxt: Block::Extrinsic, len: u32) -> RuntimeDispatchInfo<Balance>;
-	}
-}
-
-#[cfg(test)]
-mod tests {
-	use super::*;
-
-	#[test]
-	fn should_serialize_and_deserialize_properly_with_string() {
-		let info = RuntimeDispatchInfo {
-			weight: 5,
-			class: DispatchClass::Normal,
-			partial_fee: 1_000_000_u64,
-		};
-
-		let json_str = r#"{"weight":5,"class":"normal","partialFee":"1000000"}"#;
-
-		assert_eq!(serde_json::to_string(&info).unwrap(), json_str);
-		assert_eq!(serde_json::from_str::<RuntimeDispatchInfo<u64>>(json_str).unwrap(), info);
-
-		// should not panic
-		serde_json::to_value(&info).unwrap();
-	}
-
-	#[test]
-	fn should_serialize_and_deserialize_properly_large_value() {
-		let info = RuntimeDispatchInfo {
-			weight: 5,
-			class: DispatchClass::Normal,
-			partial_fee: u128::max_value(),
-		};
-
-		let json_str = r#"{"weight":5,"class":"normal","partialFee":"340282366920938463463374607431768211455"}"#;
-
-		assert_eq!(serde_json::to_string(&info).unwrap(), json_str);
-		assert_eq!(serde_json::from_str::<RuntimeDispatchInfo<u128>>(json_str).unwrap(), info);
-
-		// should not panic
-		serde_json::to_value(&info).unwrap();
+		fn query_fee_details(uxt: Block::Extrinsic, len: u32) -> FeeDetails<Balance>;
 	}
 }

substrate/frame/transaction-payment/rpc/src/lib.rs

@@ -18,14 +18,16 @@
 //! RPC interface for the transaction payment module.
 
 use std::sync::Arc;
+use std::convert::TryInto;
 use codec::{Codec, Decode};
 use sp_blockchain::HeaderBackend;
 use jsonrpc_core::{Error as RpcError, ErrorCode, Result};
 use jsonrpc_derive::rpc;
-use sp_runtime::{generic::BlockId, traits::{Block as BlockT, MaybeDisplay, MaybeFromStr}};
+use sp_runtime::{generic::BlockId, traits::{Block as BlockT, MaybeDisplay}};
 use sp_api::ProvideRuntimeApi;
 use sp_core::Bytes;
-use pallet_transaction_payment_rpc_runtime_api::RuntimeDispatchInfo;
+use sp_rpc::number::NumberOrHex;
+use pallet_transaction_payment_rpc_runtime_api::{FeeDetails, InclusionFee, RuntimeDispatchInfo};
 pub use pallet_transaction_payment_rpc_runtime_api::TransactionPaymentApi as TransactionPaymentRuntimeApi;
 pub use self::gen_client::Client as TransactionPaymentClient;
 
@@ -37,6 +39,12 @@ pub trait TransactionPaymentApi<BlockHash, ResponseType> {
 		encoded_xt: Bytes,
 		at: Option<BlockHash>
 	) -> Result<ResponseType>;
+	#[rpc(name = "payment_queryFeeDetails")]
+	fn query_fee_details(
+		&self,
+		encoded_xt: Bytes,
+		at: Option<BlockHash>
+	) -> Result<FeeDetails<NumberOrHex>>;
 }
 
 /// A struct that implements the [`TransactionPaymentApi`].
@@ -48,7 +56,7 @@ pub struct TransactionPayment<C, P> {
 impl<C, P> TransactionPayment<C, P> {
 	/// Create new `TransactionPayment` with the given reference to the client.
 	pub fn new(client: Arc<C>) -> Self {
-		TransactionPayment { client, _marker: Default::default() }
+		Self { client, _marker: Default::default() }
 	}
 }
 
@@ -69,13 +77,15 @@ impl From<Error> for i64 {
 	}
 }
 
-impl<C, Block, Balance> TransactionPaymentApi<<Block as BlockT>::Hash, RuntimeDispatchInfo<Balance>>
-	for TransactionPayment<C, Block>
+impl<C, Block, Balance> TransactionPaymentApi<
+	<Block as BlockT>::Hash,
+	RuntimeDispatchInfo<Balance>,
+> for TransactionPayment<C, Block>
 where
 	Block: BlockT,
 	C: 'static + ProvideRuntimeApi<Block> + HeaderBackend<Block>,
 	C::Api: TransactionPaymentRuntimeApi<Block, Balance>,
-	Balance: Codec + MaybeDisplay + MaybeFromStr,
+	Balance: Codec + MaybeDisplay + Copy + TryInto<NumberOrHex>,
 {
 	fn query_info(
 		&self,
@@ -101,4 +111,48 @@ where
 			data: Some(format!("{:?}", e).into()),
 		})
 	}
+
+	fn query_fee_details(
+		&self,
+		encoded_xt: Bytes,
+		at: Option<<Block as BlockT>::Hash>,
+	) -> Result<FeeDetails<NumberOrHex>> {
+		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
+		));
+
+		let encoded_len = encoded_xt.len() as u32;
+
+		let uxt: Block::Extrinsic = Decode::decode(&mut &*encoded_xt).map_err(|e| RpcError {
+			code: ErrorCode::ServerError(Error::DecodeError.into()),
+			message: "Unable to query fee details.".into(),
+			data: Some(format!("{:?}", e).into()),
+		})?;
+		let fee_details = api.query_fee_details(&at, uxt, encoded_len).map_err(|e| RpcError {
+			code: ErrorCode::ServerError(Error::RuntimeError.into()),
+			message: "Unable to query fee details.".into(),
+			data: Some(format!("{:?}", e).into()),
+		})?;
+
+		let try_into_rpc_balance = |value: Balance| value.try_into().map_err(|_| RpcError {
+			code: ErrorCode::InvalidParams,
+			message: format!("{} doesn't fit in NumberOrHex representation", value),
+			data: None,
+		});
+
+		Ok(FeeDetails {
+			inclusion_fee: if let Some(inclusion_fee) = fee_details.inclusion_fee {
+				Some(InclusionFee {
+					base_fee: try_into_rpc_balance(inclusion_fee.base_fee)?,
+					len_fee: try_into_rpc_balance(inclusion_fee.len_fee)?,
+					adjusted_weight_fee: try_into_rpc_balance(inclusion_fee.adjusted_weight_fee)?,
+				})
+			} else {
+				None
+			},
+			tip: Default::default(),
+		})
+	}
 }

substrate/frame/transaction-payment/src/lib.rs

@@ -19,11 +19,25 @@
 //!
 //! This module provides the basic logic needed to pay the absolute minimum amount needed for a
 //! transaction to be included. This includes:
+//!   - _base fee_: This is the minimum amount a user pays for a transaction. It is declared
+//! 	as a base _weight_ in the runtime and converted to a fee using `WeightToFee`.
 //!   - _weight fee_: A fee proportional to amount of weight a transaction consumes.
 //!   - _length fee_: A fee proportional to the encoded length of the transaction.
 //!   - _tip_: An optional tip. Tip increases the priority of the transaction, giving it a higher
 //!     chance to be included by the transaction queue.
 //!
+//! The base fee and adjusted weight and length fees constitute the _inclusion fee_, which is
+//! the minimum fee for a transaction to be included in a block.
+//!
+//! The formula of final fee:
+//!   ```ignore
+//!   inclusion_fee = base_fee + length_fee + [targeted_fee_adjustment * weight_fee];
+//!   final_fee = inclusion_fee + tip;
+//!   ```
+//!
+//!   - `targeted_fee_adjustment`: This is a multiplier that can tune the final fee based on
+//! 	the congestion of the network.
+//!
 //! Additionally, this module allows one to configure:
 //!   - The mapping between one unit of weight to one unit of fee via [`Config::WeightToFee`].
 //!   - A means of updating the fee for the next block, via defining a multiplier, based on the
@@ -54,10 +68,12 @@ use sp_runtime::{
 		DispatchInfoOf, PostDispatchInfoOf,
 	},
 };
-use pallet_transaction_payment_rpc_runtime_api::RuntimeDispatchInfo;
 
 mod payment;
+mod types;
+
 pub use payment::*;
+pub use types::{InclusionFee, FeeDetails, RuntimeDispatchInfo};
 
 /// Fee multiplier.
 pub type Multiplier = FixedU128;
@@ -329,27 +345,19 @@ impl<T: Config> Module<T> where
 		RuntimeDispatchInfo { weight, class, partial_fee }
 	}
 
+	/// Query the detailed fee of a given `call`.
+	pub fn query_fee_details<Extrinsic: GetDispatchInfo>(
+		unchecked_extrinsic: Extrinsic,
+		len: u32,
+	) -> FeeDetails<BalanceOf<T>>
+	where
+		T::Call: Dispatchable<Info=DispatchInfo>,
+	{
+		let dispatch_info = <Extrinsic as GetDispatchInfo>::get_dispatch_info(&unchecked_extrinsic);
+		Self::compute_fee_details(len, &dispatch_info, 0u32.into())
+	}
+
 	/// Compute the final fee value for a particular transaction.
-	///
-	/// The final fee is composed of:
-	///   - `base_fee`: This is the minimum amount a user pays for a transaction. It is declared
-	///     as a base _weight_ in the runtime and converted to a fee using `WeightToFee`.
-	///   - `len_fee`: The length fee, the amount paid for the encoded length (in bytes) of the
-	///     transaction.
-	///   - `weight_fee`: This amount is computed based on the weight of the transaction. Weight
-	///     accounts for the execution time of a transaction.
-	///   - `targeted_fee_adjustment`: This is a multiplier that can tune the final fee based on
-	///     the congestion of the network.
-	///   - (Optional) `tip`: If included in the transaction, the tip will be added on top. Only
-	///     signed transactions can have a tip.
-	///
-	/// The base fee and adjusted weight and length fees constitute the _inclusion fee,_ which is
-	/// the minimum fee for a transaction to be included in a block.
-	///
-	/// ```ignore
-	/// inclusion_fee = base_fee + len_fee + [targeted_fee_adjustment * weight_fee];
-	/// final_fee = inclusion_fee + tip;
-	/// ```
 	pub fn compute_fee(
 		len: u32,
 		info: &DispatchInfoOf<T::Call>,
@@ -357,13 +365,18 @@ impl<T: Config> Module<T> where
 	) -> BalanceOf<T> where
 		T::Call: Dispatchable<Info=DispatchInfo>,
 	{
-		Self::compute_fee_raw(
-			len,
-			info.weight,
-			tip,
-			info.pays_fee,
-			info.class,
-		)
+		Self::compute_fee_details(len, info, tip).final_fee()
+	}
+
+	/// Compute the fee details for a particular transaction.
+	pub fn compute_fee_details(
+		len: u32,
+		info: &DispatchInfoOf<T::Call>,
+		tip: BalanceOf<T>,
+	) -> FeeDetails<BalanceOf<T>> where
+		T::Call: Dispatchable<Info=DispatchInfo>,
+	{
+		Self::compute_fee_raw(len, info.weight, tip, info.pays_fee, info.class)
 	}
 
 	/// Compute the actual post dispatch fee for a particular transaction.
@@ -377,6 +390,18 @@ impl<T: Config> Module<T> where
 		tip: BalanceOf<T>,
 	) -> BalanceOf<T> where
 		T::Call: Dispatchable<Info=DispatchInfo,PostInfo=PostDispatchInfo>,
+	{
+		Self::compute_actual_fee_details(len, info, post_info, tip).final_fee()
+	}
+
+	/// Compute the actual post dispatch fee details for a particular transaction.
+	pub fn compute_actual_fee_details(
+		len: u32,
+		info: &DispatchInfoOf<T::Call>,
+		post_info: &PostDispatchInfoOf<T::Call>,
+		tip: BalanceOf<T>,
+	) -> FeeDetails<BalanceOf<T>> where
+		T::Call: Dispatchable<Info=DispatchInfo,PostInfo=PostDispatchInfo>,
 	{
 		Self::compute_fee_raw(
 			len,
@@ -393,7 +418,7 @@ impl<T: Config> Module<T> where
 		tip: BalanceOf<T>,
 		pays_fee: Pays,
 		class: DispatchClass,
-	) -> BalanceOf<T> {
+	) -> FeeDetails<BalanceOf<T>> {
 		if pays_fee == Pays::Yes {
 			let len = <BalanceOf<T>>::from(len);
 			let per_byte = T::TransactionByteFee::get();
@@ -408,12 +433,19 @@ impl<T: Config> Module<T> where
 			let adjusted_weight_fee = multiplier.saturating_mul_int(unadjusted_weight_fee);
 
 			let base_fee = Self::weight_to_fee(T::BlockWeights::get().get(class).base_extrinsic);
-			base_fee
-				.saturating_add(fixed_len_fee)
-				.saturating_add(adjusted_weight_fee)
-				.saturating_add(tip)
+			FeeDetails {
+				inclusion_fee: Some(InclusionFee {
+					base_fee,
+					len_fee: fixed_len_fee,
+					adjusted_weight_fee
+				}),
+				tip
+			}
 		} else {
-			tip
+			FeeDetails {
+				inclusion_fee: None,
+				tip
+			}
 		}
 	}
 
@@ -578,7 +610,6 @@ mod tests {
 		traits::Currency,
 	};
 	use pallet_balances::Call as BalancesCall;
-	use pallet_transaction_payment_rpc_runtime_api::RuntimeDispatchInfo;
 	use sp_core::H256;
 	use sp_runtime::{
 		testing::{Header, TestXt},

substrate/frame/transaction-payment/src/types.rs

@@ -0,0 +1,155 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2021 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Types for transaction-payment RPC.
+
+use sp_std::prelude::*;
+use frame_support::weights::{Weight, DispatchClass};
+use codec::{Encode, Decode};
+#[cfg(feature = "std")]
+use serde::{Serialize, Deserialize};
+use sp_runtime::traits::{AtLeast32BitUnsigned, Zero};
+
+/// The base fee and adjusted weight and length fees constitute the _inclusion fee_.
+#[derive(Encode, Decode, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "std", derive(Debug, Serialize, Deserialize))]
+#[cfg_attr(feature = "std", serde(rename_all = "camelCase"))]
+pub struct InclusionFee<Balance> {
+	/// This is the minimum amount a user pays for a transaction. It is declared
+	/// as a base _weight_ in the runtime and converted to a fee using `WeightToFee`.
+	pub base_fee: Balance,
+	/// The length fee, the amount paid for the encoded length (in bytes) of the transaction.
+	pub len_fee: Balance,
+	/// - `targeted_fee_adjustment`: This is a multiplier that can tune the final fee based on
+	///     the congestion of the network.
+	/// - `weight_fee`: This amount is computed based on the weight of the transaction. Weight
+	/// accounts for the execution time of a transaction.
+	///
+	/// adjusted_weight_fee = targeted_fee_adjustment * weight_fee
+	pub adjusted_weight_fee: Balance,
+}
+
+impl<Balance: AtLeast32BitUnsigned + Copy> InclusionFee<Balance> {
+	/// Returns the total of inclusion fee.
+	///
+	/// ```ignore
+	/// inclusion_fee = base_fee + len_fee + adjusted_weight_fee
+	/// ```
+	pub fn inclusion_fee(&self) -> Balance {
+		self.base_fee
+			.saturating_add(self.len_fee)
+			.saturating_add(self.adjusted_weight_fee)
+	}
+}
+
+/// The `FeeDetails` is composed of:
+///   - (Optional) `inclusion_fee`: Only the `Pays::Yes` transaction can have the inclusion fee.
+///   - `tip`: If included in the transaction, the tip will be added on top. Only
+///     signed transactions can have a tip.
+#[derive(Encode, Decode, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "std", derive(Debug, Serialize, Deserialize))]
+#[cfg_attr(feature = "std", serde(rename_all = "camelCase"))]
+pub struct FeeDetails<Balance> {
+	/// The minimum fee for a transaction to be included in a block.
+	pub inclusion_fee: Option<InclusionFee<Balance>>,
+	// Do not serialize and deserialize `tip` as we actually can not pass any tip to the RPC.
+	#[cfg_attr(feature = "std", serde(skip))]
+	pub tip: Balance,
+}
+
+impl<Balance: AtLeast32BitUnsigned + Copy> FeeDetails<Balance> {
+	/// Returns the final fee.
+	///
+	/// ```ignore
+	/// final_fee = inclusion_fee + tip;
+	/// ```
+	pub fn final_fee(&self) -> Balance {
+		self.inclusion_fee.as_ref().map(|i| i.inclusion_fee()).unwrap_or_else(|| Zero::zero()).saturating_add(self.tip)
+	}
+}
+
+/// Information related to a dispatchable's class, weight, and fee that can be queried from the runtime.
+#[derive(Eq, PartialEq, Encode, Decode, Default)]
+#[cfg_attr(feature = "std", derive(Debug, Serialize, Deserialize))]
+#[cfg_attr(feature = "std", serde(rename_all = "camelCase"))]
+#[cfg_attr(feature = "std", serde(bound(serialize = "Balance: std::fmt::Display")))]
+#[cfg_attr(feature = "std", serde(bound(deserialize = "Balance: std::str::FromStr")))]
+pub struct RuntimeDispatchInfo<Balance> {
+	/// Weight of this dispatch.
+	pub weight: Weight,
+	/// Class of this dispatch.
+	pub class: DispatchClass,
+	/// The inclusion fee of this dispatch.
+	///
+	/// This does not include a tip or anything else that
+	/// depends on the signature (i.e. depends on a `SignedExtension`).
+	#[cfg_attr(feature = "std", serde(with = "serde_balance"))]
+	pub partial_fee: Balance,
+}
+
+#[cfg(feature = "std")]
+mod serde_balance {
+	use serde::{Deserialize, Serializer, Deserializer};
+
+	pub fn serialize<S: Serializer, T: std::fmt::Display>(t: &T, serializer: S) -> Result<S::Ok, S::Error> {
+		serializer.serialize_str(&t.to_string())
+	}
+
+	pub fn deserialize<'de, D: Deserializer<'de>, T: std::str::FromStr>(deserializer: D) -> Result<T, D::Error> {
+		let s = String::deserialize(deserializer)?;
+		s.parse::<T>().map_err(|_| serde::de::Error::custom("Parse from string failed"))
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn should_serialize_and_deserialize_properly_with_string() {
+		let info = RuntimeDispatchInfo {
+			weight: 5,
+			class: DispatchClass::Normal,
+			partial_fee: 1_000_000_u64,
+		};
+
+		let json_str = r#"{"weight":5,"class":"normal","partialFee":"1000000"}"#;
+
+		assert_eq!(serde_json::to_string(&info).unwrap(), json_str);
+		assert_eq!(serde_json::from_str::<RuntimeDispatchInfo<u64>>(json_str).unwrap(), info);
+
+		// should not panic
+		serde_json::to_value(&info).unwrap();
+	}
+
+	#[test]
+	fn should_serialize_and_deserialize_properly_large_value() {
+		let info = RuntimeDispatchInfo {
+			weight: 5,
+			class: DispatchClass::Normal,
+			partial_fee: u128::max_value(),
+		};
+
+		let json_str = r#"{"weight":5,"class":"normal","partialFee":"340282366920938463463374607431768211455"}"#;
+
+		assert_eq!(serde_json::to_string(&info).unwrap(), json_str);
+		assert_eq!(serde_json::from_str::<RuntimeDispatchInfo<u128>>(json_str).unwrap(), info);
+
+		// should not panic
+		serde_json::to_value(&info).unwrap();
+	}
+}

substrate/primitives/rpc/src/number.rs

@@ -39,6 +39,12 @@ pub enum NumberOrHex {
 	Hex(U256),
 }
 
+impl Default for NumberOrHex {
+	fn default() -> Self {
+		Self::Number(Default::default())
+	}
+}
+
 impl NumberOrHex {
 	/// Converts this number into an U256.
 	pub fn into_u256(self) -> U256 {
@@ -49,12 +55,24 @@ impl NumberOrHex {
 	}
 }
 
+impl From<u32> for NumberOrHex {
+	fn from(n: u32) -> Self {
+		NumberOrHex::Number(n.into())
+	}
+}
+
 impl From<u64> for NumberOrHex {
 	fn from(n: u64) -> Self {
 		NumberOrHex::Number(n)
 	}
 }
 
+impl From<u128> for NumberOrHex {
+	fn from(n: u128) -> Self {
+		NumberOrHex::Hex(n.into())
+	}
+}
+
 impl From<U256> for NumberOrHex {
 	fn from(n: U256) -> Self {
 		NumberOrHex::Hex(n)
@@ -66,21 +84,21 @@ pub struct TryFromIntError(pub(crate) ());
 
 impl TryFrom<NumberOrHex> for u32 {
 	type Error = TryFromIntError;
-	fn try_from(num_or_hex: NumberOrHex) -> Result<u32, TryFromIntError> {
+	fn try_from(num_or_hex: NumberOrHex) -> Result<u32, Self::Error> {
 		num_or_hex.into_u256().try_into().map_err(|_| TryFromIntError(()))
 	}
 }
 
 impl TryFrom<NumberOrHex> for u64 {
 	type Error = TryFromIntError;
-	fn try_from(num_or_hex: NumberOrHex) -> Result<u64, TryFromIntError> {
+	fn try_from(num_or_hex: NumberOrHex) -> Result<u64, Self::Error> {
 		num_or_hex.into_u256().try_into().map_err(|_| TryFromIntError(()))
 	}
 }
 
 impl TryFrom<NumberOrHex> for u128 {
 	type Error = TryFromIntError;
-	fn try_from(num_or_hex: NumberOrHex) -> Result<u128, TryFromIntError> {
+	fn try_from(num_or_hex: NumberOrHex) -> Result<u128, Self::Error> {
 		num_or_hex.into_u256().try_into().map_err(|_| TryFromIntError(()))
 	}
 }