pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-07-23 00:15:41 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add payment_queryFeeDetails RPC (#7692)

Browse Source 
* 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>
This commit is contained in:
Liu-Cheng Xu
2021-01-14 19:43:53 +08:00
committed by GitHub
parent f7fccb3122
commit 65569620c2
11 changed files with 322 additions and 137 deletions
Download Patch File Download Diff File Expand all files Collapse all files
substrate/frame/transaction-payment/rpc/Cargo.toml
-1
View File
@@ -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
+2 -9
View File
@@ -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
+5 -74
View File
@@ -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
+60 -6
View File
@@ -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(),
})
}
}