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>
2026-06-17 03:11:01 +00:00 · 2021-01-14 19:43:53 +08:00
parent f7fccb3122
commit 65569620c2
11 changed files with 322 additions and 137 deletions
@@ -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},
@@ -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();
+	}
+}