Move transaction payment rpc types to types.rs

frame/transaction-payment/Cargo.toml

@@ -19,7 +19,6 @@ 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 }
@@ -37,7 +36,6 @@ std = [
 	"sp-runtime/std",
 	"frame-support/std",
 	"frame-system/std",
-	"pallet-transaction-payment-rpc-runtime-api/std",
 	"sp-io/std",
 	"sp-core/std",
 ]

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.1", 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",
 ]

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

@@ -19,107 +19,10 @@
 
 #![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};
-use sp_runtime::traits::{AtLeast32BitUnsigned, MaybeDisplay, MaybeFromStr};
+use codec::Codec;
+use sp_runtime::traits::{MaybeDisplay, MaybeFromStr};
 
-/// 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.
-#[derive(Encode, Decode, Clone, Eq, PartialEq)]
-#[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 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`.
-	#[cfg_attr(feature = "std", serde(with = "serde_balance"))]
-	pub base_fee: Balance,
-	/// The length fee, the amount paid for the encoded length (in bytes) of the transaction.
-	#[cfg_attr(feature = "std", serde(with = "serde_balance"))]
-	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
-	#[cfg_attr(feature = "std", serde(with = "serde_balance"))]
-	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 total(&self) -> Balance {
-		self.base_fee
-			.saturating_add(self.len_fee)
-			.saturating_add(self.adjusted_weight_fee)
-	}
-}
-
-/// The `final_fee` is composed of:
-///   - (Optional) `inclusion_fee`: Only the `Pays::Yes` transaction can have the inclusion fee.
-///   - (Optional) `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"))]
-#[cfg_attr(feature = "std", serde(bound(serialize = "Balance: std::fmt::Display")))]
-#[cfg_attr(feature = "std", serde(bound(deserialize = "Balance: std::str::FromStr")))]
-pub struct FeeDetails<Balance> {
-	pub inclusion_fee: Option<InclusionFee<Balance>>,
-	#[cfg_attr(feature = "std", serde(with = "serde_balance"))]
-	pub tip: Balance,
-}
-
-impl<Balance: AtLeast32BitUnsigned + Default + 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.total()).unwrap_or_default().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"))
-	}
-}
+pub use pallet_transaction_payment::{FeeDetails, RuntimeDispatchInfo};
 
 sp_api::decl_runtime_apis! {
 	pub trait TransactionPaymentApi<Balance> where
@@ -129,42 +32,3 @@ sp_api::decl_runtime_apis! {
 		fn query_fee_details(uxt: Block::Extrinsic, len: u32) -> FeeDetails<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();
-	}
-}

frame/transaction-payment/src/lib.rs

@@ -54,10 +54,12 @@ use sp_runtime::{
 		DispatchInfoOf, PostDispatchInfoOf
 	},
 };
-use pallet_transaction_payment_rpc_runtime_api::{FeeDetails, InclusionFee, RuntimeDispatchInfo};
 
 mod payment;
+mod types;
+
 pub use payment::*;
+pub use types::{InclusionFee, FeeDetails, RuntimeDispatchInfo};
 
 /// Fee multiplier.
 pub type Multiplier = FixedU128;

frame/transaction-payment/src/types.rs

@@ -0,0 +1,140 @@
+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;
+
+/// 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.
+#[derive(Encode, Decode, Clone, Eq, PartialEq)]
+#[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 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`.
+	#[cfg_attr(feature = "std", serde(with = "serde_balance"))]
+	pub base_fee: Balance,
+	/// The length fee, the amount paid for the encoded length (in bytes) of the transaction.
+	#[cfg_attr(feature = "std", serde(with = "serde_balance"))]
+	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
+	#[cfg_attr(feature = "std", serde(with = "serde_balance"))]
+	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 total(&self) -> Balance {
+		self.base_fee
+			.saturating_add(self.len_fee)
+			.saturating_add(self.adjusted_weight_fee)
+	}
+}
+
+/// The `final_fee` is composed of:
+///   - (Optional) `inclusion_fee`: Only the `Pays::Yes` transaction can have the inclusion fee.
+///   - (Optional) `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"))]
+#[cfg_attr(feature = "std", serde(bound(serialize = "Balance: std::fmt::Display")))]
+#[cfg_attr(feature = "std", serde(bound(deserialize = "Balance: std::str::FromStr")))]
+pub struct FeeDetails<Balance> {
+	pub inclusion_fee: Option<InclusionFee<Balance>>,
+	#[cfg_attr(feature = "std", serde(with = "serde_balance"))]
+	pub tip: Balance,
+}
+
+impl<Balance: AtLeast32BitUnsigned + Default + 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.total()).unwrap_or_default().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();
+	}
+}