diff --git a/substrate/Cargo.lock b/substrate/Cargo.lock index 0ea53a0aa7..4d334f5f25 100644 --- a/substrate/Cargo.lock +++ b/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]] diff --git a/substrate/bin/node-template/runtime/src/lib.rs b/substrate/bin/node-template/runtime/src/lib.rs index 0812346779..5efe5492b9 100644 --- a/substrate/bin/node-template/runtime/src/lib.rs +++ b/substrate/bin/node-template/runtime/src/lib.rs @@ -438,6 +438,12 @@ impl_runtime_apis! { ) -> pallet_transaction_payment_rpc_runtime_api::RuntimeDispatchInfo { TransactionPayment::query_info(uxt, len) } + fn query_fee_details( + uxt: ::Extrinsic, + len: u32, + ) -> pallet_transaction_payment::FeeDetails { + TransactionPayment::query_fee_details(uxt, len) + } } #[cfg(feature = "runtime-benchmarks")] diff --git a/substrate/bin/node/runtime/src/lib.rs b/substrate/bin/node/runtime/src/lib.rs index 3e64524658..e88484e472 100644 --- a/substrate/bin/node/runtime/src/lib.rs +++ b/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: ::Extrinsic, len: u32) -> RuntimeDispatchInfo { TransactionPayment::query_info(uxt, len) } + fn query_fee_details(uxt: ::Extrinsic, len: u32) -> FeeDetails { + TransactionPayment::query_fee_details(uxt, len) + } } impl sp_session::SessionKeys for Runtime { diff --git a/substrate/frame/transaction-payment/Cargo.toml b/substrate/frame/transaction-payment/Cargo.toml index 16be1b5fba..1f64ae0399 100644 --- a/substrate/frame/transaction-payment/Cargo.toml +++ b/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", ] diff --git a/substrate/frame/transaction-payment/rpc/Cargo.toml b/substrate/frame/transaction-payment/rpc/Cargo.toml index c459fbcf4a..410827d0ef 100644 --- a/substrate/frame/transaction-payment/rpc/Cargo.toml +++ b/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" } diff --git a/substrate/frame/transaction-payment/rpc/runtime-api/Cargo.toml b/substrate/frame/transaction-payment/rpc/runtime-api/Cargo.toml index a55cec5cfe..64c082b420 100644 --- a/substrate/frame/transaction-payment/rpc/runtime-api/Cargo.toml +++ b/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", ] diff --git a/substrate/frame/transaction-payment/rpc/runtime-api/src/lib.rs b/substrate/frame/transaction-payment/rpc/runtime-api/src/lib.rs index f2c1b2c141..bd05aec303 100644 --- a/substrate/frame/transaction-payment/rpc/runtime-api/src/lib.rs +++ b/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 { - /// 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(t: &T, serializer: S) -> Result { - serializer.serialize_str(&t.to_string()) -} - -#[cfg(feature = "std")] -fn deserialize_from_string<'de, D: Deserializer<'de>, T: std::str::FromStr>(deserializer: D) -> Result { - let s = String::deserialize(deserializer)?; - s.parse::().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 where - Balance: Codec + MaybeDisplay + MaybeFromStr, + Balance: Codec + MaybeDisplay, { fn query_info(uxt: Block::Extrinsic, len: u32) -> RuntimeDispatchInfo; - } -} - -#[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::>(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::>(json_str).unwrap(), info); - - // should not panic - serde_json::to_value(&info).unwrap(); + fn query_fee_details(uxt: Block::Extrinsic, len: u32) -> FeeDetails; } } diff --git a/substrate/frame/transaction-payment/rpc/src/lib.rs b/substrate/frame/transaction-payment/rpc/src/lib.rs index ec06fad08d..b3e892c165 100644 --- a/substrate/frame/transaction-payment/rpc/src/lib.rs +++ b/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 { encoded_xt: Bytes, at: Option ) -> Result; + #[rpc(name = "payment_queryFeeDetails")] + fn query_fee_details( + &self, + encoded_xt: Bytes, + at: Option + ) -> Result>; } /// A struct that implements the [`TransactionPaymentApi`]. @@ -48,7 +56,7 @@ pub struct TransactionPayment { impl TransactionPayment { /// Create new `TransactionPayment` with the given reference to the client. pub fn new(client: Arc) -> Self { - TransactionPayment { client, _marker: Default::default() } + Self { client, _marker: Default::default() } } } @@ -69,13 +77,15 @@ impl From for i64 { } } -impl TransactionPaymentApi<::Hash, RuntimeDispatchInfo> - for TransactionPayment +impl TransactionPaymentApi< + ::Hash, + RuntimeDispatchInfo, +> for TransactionPayment where Block: BlockT, C: 'static + ProvideRuntimeApi + HeaderBackend, C::Api: TransactionPaymentRuntimeApi, - Balance: Codec + MaybeDisplay + MaybeFromStr, + Balance: Codec + MaybeDisplay + Copy + TryInto, { fn query_info( &self, @@ -101,4 +111,48 @@ where data: Some(format!("{:?}", e).into()), }) } + + fn query_fee_details( + &self, + encoded_xt: Bytes, + at: Option<::Hash>, + ) -> Result> { + 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(), + }) + } } diff --git a/substrate/frame/transaction-payment/src/lib.rs b/substrate/frame/transaction-payment/src/lib.rs index 932aaf43dc..c55eb33323 100644 --- a/substrate/frame/transaction-payment/src/lib.rs +++ b/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 Module where RuntimeDispatchInfo { weight, class, partial_fee } } + /// Query the detailed fee of a given `call`. + pub fn query_fee_details( + unchecked_extrinsic: Extrinsic, + len: u32, + ) -> FeeDetails> + where + T::Call: Dispatchable, + { + let dispatch_info = ::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, @@ -357,13 +365,18 @@ impl Module where ) -> BalanceOf where T::Call: Dispatchable, { - 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, + tip: BalanceOf, + ) -> FeeDetails> where + T::Call: Dispatchable, + { + 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 Module where tip: BalanceOf, ) -> BalanceOf where T::Call: Dispatchable, + { + 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, + post_info: &PostDispatchInfoOf, + tip: BalanceOf, + ) -> FeeDetails> where + T::Call: Dispatchable, { Self::compute_fee_raw( len, @@ -393,7 +418,7 @@ impl Module where tip: BalanceOf, pays_fee: Pays, class: DispatchClass, - ) -> BalanceOf { + ) -> FeeDetails> { if pays_fee == Pays::Yes { let len = >::from(len); let per_byte = T::TransactionByteFee::get(); @@ -408,12 +433,19 @@ impl Module 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}, diff --git a/substrate/frame/transaction-payment/src/types.rs b/substrate/frame/transaction-payment/src/types.rs new file mode 100644 index 0000000000..ab771eb8ba --- /dev/null +++ b/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 { + /// 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 InclusionFee { + /// 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 { + /// The minimum fee for a transaction to be included in a block. + pub inclusion_fee: Option>, + // 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 FeeDetails { + /// 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 { + /// 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(t: &T, serializer: S) -> Result { + serializer.serialize_str(&t.to_string()) + } + + pub fn deserialize<'de, D: Deserializer<'de>, T: std::str::FromStr>(deserializer: D) -> Result { + let s = String::deserialize(deserializer)?; + s.parse::().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::>(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::>(json_str).unwrap(), info); + + // should not panic + serde_json::to_value(&info).unwrap(); + } +} diff --git a/substrate/primitives/rpc/src/number.rs b/substrate/primitives/rpc/src/number.rs index 93d64aa2c3..ad19b7f5b4 100644 --- a/substrate/primitives/rpc/src/number.rs +++ b/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 for NumberOrHex { + fn from(n: u32) -> Self { + NumberOrHex::Number(n.into()) + } +} + impl From for NumberOrHex { fn from(n: u64) -> Self { NumberOrHex::Number(n) } } +impl From for NumberOrHex { + fn from(n: u128) -> Self { + NumberOrHex::Hex(n.into()) + } +} + impl From for NumberOrHex { fn from(n: U256) -> Self { NumberOrHex::Hex(n) @@ -66,21 +84,21 @@ pub struct TryFromIntError(pub(crate) ()); impl TryFrom for u32 { type Error = TryFromIntError; - fn try_from(num_or_hex: NumberOrHex) -> Result { + fn try_from(num_or_hex: NumberOrHex) -> Result { num_or_hex.into_u256().try_into().map_err(|_| TryFromIntError(())) } } impl TryFrom for u64 { type Error = TryFromIntError; - fn try_from(num_or_hex: NumberOrHex) -> Result { + fn try_from(num_or_hex: NumberOrHex) -> Result { num_or_hex.into_u256().try_into().map_err(|_| TryFromIntError(())) } } impl TryFrom for u128 { type Error = TryFromIntError; - fn try_from(num_or_hex: NumberOrHex) -> Result { + fn try_from(num_or_hex: NumberOrHex) -> Result { num_or_hex.into_u256().try_into().map_err(|_| TryFromIntError(())) } }