use codec::{Decode, Encode};
#[cfg(feature = "std")]
use serde::{Deserialize, Serialize};
use scale_info::TypeInfo;
use sp_runtime::traits::{AtLeast32BitUnsigned, Zero};
use frame_support::dispatch::DispatchClass;
#[derive(Encode, Decode, Clone, Eq, PartialEq, TypeInfo)]
#[cfg_attr(feature = "std", derive(Debug, Serialize, Deserialize))]
#[cfg_attr(feature = "std", serde(rename_all = "camelCase"))]
pub struct InclusionFee<Balance> {
pub base_fee: Balance,
pub len_fee: Balance,
pub adjusted_weight_fee: Balance,
}
impl<Balance: AtLeast32BitUnsigned + Copy> InclusionFee<Balance> {
pub fn inclusion_fee(&self) -> Balance {
self.base_fee
.saturating_add(self.len_fee)
.saturating_add(self.adjusted_weight_fee)
}
}
#[derive(Encode, Decode, Clone, Eq, PartialEq, TypeInfo)]
#[cfg_attr(feature = "std", derive(Debug, Serialize, Deserialize))]
#[cfg_attr(feature = "std", serde(rename_all = "camelCase"))]
pub struct FeeDetails<Balance> {
pub inclusion_fee: Option<InclusionFee<Balance>>,
#[cfg_attr(feature = "std", serde(skip))]
pub tip: Balance,
}
impl<Balance: AtLeast32BitUnsigned + Copy> FeeDetails<Balance> {
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)
}
}
#[derive(Eq, PartialEq, Encode, Decode, Default, TypeInfo)]
#[cfg_attr(feature = "std", derive(Debug, Serialize, Deserialize, Clone))]
#[cfg_attr(feature = "std", serde(rename_all = "camelCase"))]
#[cfg_attr(
feature = "std",
serde(bound(serialize = "Balance: std::fmt::Display, Weight: Serialize"))
)]
#[cfg_attr(
feature = "std",
serde(bound(deserialize = "Balance: std::str::FromStr, Weight: Deserialize<'de>"))
)]
pub struct RuntimeDispatchInfo<Balance, Weight = frame_support::weights::Weight> {
pub weight: Weight,
pub class: DispatchClass,
#[cfg_attr(feature = "std", serde(with = "serde_balance"))]
pub partial_fee: Balance,
}
#[cfg(feature = "std")]
mod serde_balance {
use serde::{Deserialize, Deserializer, Serializer};
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::*;
use frame_support::weights::Weight;
#[test]
fn should_serialize_and_deserialize_properly_with_string() {
let info = RuntimeDispatchInfo {
weight: Weight::from_parts(5, 0),
class: DispatchClass::Normal,
partial_fee: 1_000_000_u64,
};
let json_str =
r#"{"weight":{"ref_time":5,"proof_size":0},"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);
serde_json::to_value(&info).unwrap();
}
#[test]
fn should_serialize_and_deserialize_properly_large_value() {
let info = RuntimeDispatchInfo {
weight: Weight::from_parts(5, 0),
class: DispatchClass::Normal,
partial_fee: u128::max_value(),
};
let json_str = r#"{"weight":{"ref_time":5,"proof_size":0},"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);
serde_json::to_value(&info).unwrap();
}
}