pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-04-24 04:17:57 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add hooks to register event types for decoding (#227)

Browse Source 
* Global registration of type segmenters for event decoding

* Perform type sizes check when building client

* Introduce EventTypeRegistry for global runtime type sizes

* Fmt

* Register runtime type sizes on creation of EventTypeRegistry

* Register more default dispatch types

* Add missing type sizes

* fmt

* Fix up register_type_size builder method

* Update doc comments

* Make register_default_type_sizes public

* Don't allow duplicate registered types

* Remove call to supertraits type registration, done manually in Runtime

* Fix tests and warnings

* Fix duplicate type registration

* Fmt

* review: use is_empty()

Co-authored-by: Niklas Adolfsson <niklasadolfsson1@gmail.com>

* Add panic docs

Co-authored-by: Niklas Adolfsson <niklasadolfsson1@gmail.com>
This commit is contained in:
Andrew Jones
2021-02-18 10:28:40 +00:00
committed by GitHub
parent 2c8e5211aa
commit de859e7396
19 changed files with 436 additions and 280 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.rustfmt.toml
+1 -1
View File
@@ -19,7 +19,7 @@ fn_single_line = false
where_single_line = false
imports_indent = "Block"
imports_layout = "Vertical" # changed
imports_granularity= "Crate" # changed
imports_granularity = "Crate" # changed
reorder_imports = true
reorder_modules = true
reorder_impl_items = false
Cargo.toml
+1
View File
@@ -36,6 +36,7 @@ codec = { package = "parity-scale-codec", version = "2.0.0", default-features =
# temporarily pinning funty via codec -> bitvec until https://github.com/myrrlyn/funty/issues/3
# and https://github.com/bitvecto-rs/bitvec/issues/105 are resolved
funty = "=1.1.0"
dyn-clone = "1.0.4"
frame-metadata = "13.0.0"
frame-support = "3.0.0"
examples/transfer_subscribe.rs
+1 -4
View File
@@ -17,7 +17,6 @@
use sp_keyring::AccountKeyring;
use substrate_subxt::{
balances::{
BalancesEventsDecoder,
TransferCallExt,
TransferEvent,
},
@@ -25,7 +24,6 @@ use substrate_subxt::{
ClientBuilder,
DefaultNodeRuntime,
EventSubscription,
EventsDecoder,
PairSigner,
};
@@ -38,8 +36,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
let client = ClientBuilder::<DefaultNodeRuntime>::new().build().await?;
let sub = client.subscribe_events().await?;
let mut decoder = EventsDecoder::<DefaultNodeRuntime>::new(client.metadata().clone());
decoder.with_balances();
let decoder = client.events_decoder();
let mut sub = EventSubscription::<DefaultNodeRuntime>::new(sub, decoder);
sub.filter_event::<TransferEvent<_>>();
client.transfer(&signer, &dest, 10_000).await?;
proc-macro/src/call.rs
-14
View File
@@ -32,10 +32,6 @@ pub fn call(s: Structure) -> TokenStream {
let generics = &s.ast().generics;
let params = utils::type_params(generics);
let module = utils::module_name(generics);
let with_module = format_ident!(
"with_{}",
utils::path_to_ident(module).to_string().to_snake_case()
);
let call_name = utils::ident_to_name(ident, "Call").to_snake_case();
let bindings = utils::bindings(&s);
let fields = utils::fields(&bindings);
@@ -51,11 +47,6 @@ pub fn call(s: Structure) -> TokenStream {
impl#generics #subxt::Call<T> for #ident<#(#params),*> {
const MODULE: &'static str = MODULE;
const FUNCTION: &'static str = #call_name;
fn events_decoder(
decoder: &mut #subxt::EventsDecoder<T>,
) {
decoder.#with_module();
}
}
/// Call extension trait.
@@ -118,11 +109,6 @@ mod tests {
impl<'a, T: Balances> substrate_subxt::Call<T> for TransferCall<'a, T> {
const MODULE: &'static str = MODULE;
const FUNCTION: &'static str = "transfer";
fn events_decoder(
decoder: &mut substrate_subxt::EventsDecoder<T>,
) {
decoder.with_balances();
}
}
/// Call extension trait.
proc-macro/src/lib.rs
+4 -5
View File
@@ -62,17 +62,16 @@ use synstructure::{
///
/// const MODULE: &str = "Herd";
///
/// // `EventsDecoder` extension trait.
/// pub trait HerdEventsDecoder {
/// // `EventTypeRegistry` extension trait.
/// pub trait HerdEventTypeRegistry {
/// // Registers this modules types.
/// fn with_herd(&mut self);
/// }
///
/// impl<T: Herd> HerdEventsDecoder for
/// substrate_subxt::EventsDecoder<T>
/// impl<T: Herd + Runtime> EventTypeRegistry for
/// substrate_subxt::EventTypeRegistry<T>
/// {
/// fn with_herd(&mut self) {
/// self.with_husbandry();
/// self.register_type_size::<T::Hooves>("Hooves");
/// self.register_type_size::<T::Wool>("Wool");
/// }
proc-macro/src/module.rs
+15 -29
View File
@@ -62,8 +62,8 @@ fn ignore(attrs: &[syn::Attribute]) -> bool {
false
}
fn events_decoder_trait_name(module: &syn::Ident) -> syn::Ident {
format_ident!("{}EventsDecoder", module.to_string())
fn event_type_registry_trait_name(module: &syn::Ident) -> syn::Ident {
format_ident!("{}EventTypeRegistry", module.to_string())
}
fn with_module_ident(module: &syn::Ident) -> syn::Ident {
@@ -128,20 +128,9 @@ pub fn module(_args: TokenStream, tokens: TokenStream) -> TokenStream {
let subxt = utils::use_crate("substrate-subxt");
let module = &input.ident;
let module_name = module.to_string();
let module_events_decoder = events_decoder_trait_name(module);
let module_events_type_registry = event_type_registry_trait_name(module);
let with_module = with_module_ident(module);
let bounds = input.supertraits.iter().filter_map(|bound| {
if let syn::TypeParamBound::Trait(syn::TraitBound { path, .. }) = bound {
let module = utils::path_to_ident(path);
let with_module = with_module_ident(module);
Some(quote! {
self.#with_module();
})
} else {
None
}
});
let associated_types = input.items.iter().filter_map(|item| {
if let syn::TraitItem::Type(ty) = item {
if ignore(&ty.attrs) {
@@ -168,17 +157,16 @@ pub fn module(_args: TokenStream, tokens: TokenStream) -> TokenStream {
const MODULE: &str = #module_name;
/// `EventsDecoder` extension trait.
pub trait #module_events_decoder {
/// `EventTypeRegistry` extension trait.
pub trait #module_events_type_registry {
/// Registers this modules types.
fn #with_module(&mut self);
}
impl<T: #module> #module_events_decoder for
#subxt::EventsDecoder<T>
impl<T: #module + #subxt::Runtime> #module_events_type_registry for
#subxt::EventTypeRegistry<T>
{
fn #with_module(&mut self) {
#(#bounds)*
#(#associated_types)*
#(#types)*
}
@@ -221,17 +209,16 @@ mod tests {
const MODULE: &str = "Balances";
/// `EventsDecoder` extension trait.
pub trait BalancesEventsDecoder {
/// `EventTypeRegistry` extension trait.
pub trait BalancesEventTypeRegistry {
/// Registers this modules types.
fn with_balances(&mut self);
}
impl<T: Balances> BalancesEventsDecoder for
substrate_subxt::EventsDecoder<T>
impl<T: Balances + substrate_subxt::Runtime> BalancesEventTypeRegistry for
substrate_subxt::EventTypeRegistry<T>
{
fn with_balances(&mut self) {
self.with_system();
self.register_type_size::<T::Balance>("Balance");
}
}
@@ -262,17 +249,16 @@ mod tests {
const MODULE: &str = "Herd";
/// `EventsDecoder` extension trait.
pub trait HerdEventsDecoder {
/// `EventTypeRegistry` extension trait.
pub trait HerdEventTypeRegistry {
/// Registers this modules types.
fn with_herd(&mut self);
}
impl<T: Herd> HerdEventsDecoder for
substrate_subxt::EventsDecoder<T>
impl<T: Herd + substrate_subxt::Runtime> HerdEventTypeRegistry for
substrate_subxt::EventTypeRegistry<T>
{
fn with_herd(&mut self) {
self.with_husbandry();
self.register_type_size::<T::Hoves>("Hoves");
self.register_type_size::<T::Wool>("Wool");
}
proc-macro/tests/balances.rs
+1 -4
View File
@@ -30,10 +30,7 @@ use substrate_subxt::{
MaybeSerialize,
Member,
},
system::{
System,
SystemEventsDecoder,
},
system::System,
ClientBuilder,
KusamaRuntime,
PairSigner,
src/error.rs
+7
View File
@@ -57,6 +57,13 @@ pub enum Error {
/// Metadata error.
#[error("Metadata error: {0}")]
Metadata(#[from] MetadataError),
/// Unregistered type sizes.
#[error(
"The following types do not have a type size registered: \
{0:?} \
Use `ClientBuilder::register_type_size` to register missing type sizes."
)]
MissingTypeSizes(Vec<String>),
/// Type size unavailable.
#[error("Type size unavailable while decoding event: {0:?}")]
TypeSizeUnavailable(String),
src/events.rs
+191 -148
View File
@@ -22,14 +22,17 @@ use codec::{
Input,
Output,
};
use frame_support::dispatch::DispatchInfo;
use dyn_clone::DynClone;
use sp_runtime::{
DispatchError,
DispatchResult,
};
use std::{
collections::{
HashMap,
hash_map::{
Entry,
HashMap,
},
HashSet,
},
fmt,
@@ -49,6 +52,7 @@ use crate::{
Metadata,
},
Phase,
Runtime,
System,
};
@@ -72,16 +76,18 @@ impl std::fmt::Debug for RawEvent {
}
}
trait TypeSegmenter: Send {
pub trait TypeSegmenter: DynClone + Send + Sync {
/// Consumes an object from an input stream, and output the serialized bytes.
fn segment(&self, input: &mut &[u8], output: &mut Vec<u8>) -> Result<(), Error>;
}
#[derive(Default)]
// derive object safe Clone impl for `Box<dyn TypeSegmenter>`
dyn_clone::clone_trait_object!(TypeSegmenter);
struct TypeMarker<T>(PhantomData<T>);
impl<T> TypeSegmenter for TypeMarker<T>
where
T: Codec + Send,
T: Codec + Send + Sync,
{
fn segment(&self, input: &mut &[u8], output: &mut Vec<u8>) -> Result<(), Error> {
T::decode(input).map_err(Error::from)?.encode_to(output);
@@ -89,158 +95,41 @@ where
}
}
impl<T> Clone for TypeMarker<T> {
fn clone(&self) -> Self {
Self(Default::default())
}
}
impl<T> Default for TypeMarker<T> {
fn default() -> Self {
Self(Default::default())
}
}
/// Events decoder.
#[derive(Debug)]
pub struct EventsDecoder<T> {
metadata: Metadata,
type_segmenters: HashMap<String, Box<dyn TypeSegmenter>>,
marker: PhantomData<fn() -> T>,
event_type_registry: EventTypeRegistry<T>,
}
impl<T> fmt::Debug for EventsDecoder<T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("EventsDecoder<T>")
.field("metadata", &self.metadata)
.field(
"type_segmenters",
&self.type_segmenters.keys().cloned().collect::<String>(),
)
.finish()
impl<T> Clone for EventsDecoder<T> {
fn clone(&self) -> Self {
Self {
metadata: self.metadata.clone(),
event_type_registry: self.event_type_registry.clone(),
}
}
}
impl<T: System> EventsDecoder<T> {
impl<T: Runtime + System> EventsDecoder<T> {
/// Creates a new `EventsDecoder`.
pub fn new(metadata: Metadata) -> Self {
let mut decoder = Self {
pub fn new(metadata: Metadata, event_type_registry: EventTypeRegistry<T>) -> Self {
Self {
metadata,
type_segmenters: HashMap::new(),
marker: PhantomData,
};
// register default event arg type sizes for dynamic decoding of events
decoder.register_type_size::<()>("PhantomData");
decoder.register_type_size::<DispatchInfo>("DispatchInfo");
decoder.register_type_size::<bool>("bool");
decoder.register_type_size::<u32>("ReferendumIndex");
decoder.register_type_size::<[u8; 16]>("Kind");
decoder.register_type_size::<[u8; 32]>("AuthorityId");
decoder.register_type_size::<u8>("u8");
decoder.register_type_size::<u32>("u32");
decoder.register_type_size::<u64>("u64");
decoder.register_type_size::<u128>("u128");
decoder.register_type_size::<u32>("AccountIndex");
decoder.register_type_size::<u32>("SessionIndex");
decoder.register_type_size::<u32>("PropIndex");
decoder.register_type_size::<u32>("ProposalIndex");
decoder.register_type_size::<u32>("AuthorityIndex");
decoder.register_type_size::<u64>("AuthorityWeight");
decoder.register_type_size::<u32>("MemberCount");
decoder.register_type_size::<T::AccountId>("AccountId");
decoder.register_type_size::<T::BlockNumber>("BlockNumber");
decoder.register_type_size::<T::Hash>("Hash");
decoder.register_type_size::<u8>("VoteThreshold");
// Additional types
decoder.register_type_size::<(T::BlockNumber, u32)>("TaskAddress<BlockNumber>");
decoder
}
/// Register a type.
pub fn register_type_size<U>(&mut self, name: &str) -> usize
where
U: Default + Codec + Send + 'static,
{
let size = U::default().encode().len();
// A segmenter decodes a type from an input stream (&mut &[u8]) and returns the serialized
// type to the output stream (&mut Vec<u8>).
self.type_segmenters
.insert(name.to_string(), Box::new(TypeMarker::<U>::default()));
size
}
/// Check missing type sizes.
pub fn check_missing_type_sizes(&self) {
let mut missing = HashSet::new();
for module in self.metadata.modules_with_events() {
for event in module.events() {
for arg in event.arguments() {
for primitive in arg.primitives() {
if !self.type_segmenters.contains_key(&primitive) {
missing.insert(format!(
"{}::{}::{}",
module.name(),
event.name,
primitive
));
}
}
}
}
event_type_registry,
}
if !missing.is_empty() {
log::warn!(
"The following primitive types do not have registered sizes: {:?} \
If any of these events are received, an error will occur since we cannot decode them",
missing
);
}
}
fn decode_raw_bytes<W: Output>(
&self,
args: &[EventArg],
input: &mut &[u8],
output: &mut W,
errors: &mut Vec<RuntimeError>,
) -> Result<(), Error> {
for arg in args {
match arg {
EventArg::Vec(arg) => {
let len = <Compact<u32>>::decode(input)?;
len.encode_to(output);
for _ in 0..len.0 {
self.decode_raw_bytes(&[*arg.clone()], input, output, errors)?
}
}
EventArg::Option(arg) => {
match input.read_byte()? {
0 => output.push_byte(0),
1 => {
output.push_byte(1);
self.decode_raw_bytes(&[*arg.clone()], input, output, errors)?
}
_ => {
return Err(Error::Other(
"unexpected first byte decoding Option".into(),
))
}
}
}
EventArg::Tuple(args) => {
self.decode_raw_bytes(args, input, output, errors)?
}
EventArg::Primitive(name) => {
let result = match name.as_str() {
"DispatchResult" => DispatchResult::decode(input)?,
"DispatchError" => Err(DispatchError::decode(input)?),
_ => {
if let Some(seg) = self.type_segmenters.get(name) {
let mut buf = Vec::<u8>::new();
seg.segment(input, &mut buf)?;
output.write(&buf);
Ok(())
} else {
return Err(Error::TypeSizeUnavailable(name.to_owned()))
}
}
};
if let Err(error) = result {
// since the input may contain any number of args we propagate
// runtime errors to the caller for handling
errors.push(RuntimeError::from_dispatch(&self.metadata, error)?);
}
}
}
}
Ok(())
}
/// Decode events.
@@ -290,7 +179,7 @@ impl<T: System> EventsDecoder<T> {
Err(err) => return Err(err),
};
if event_errors.len() == 0 {
if event_errors.is_empty() {
r.push((phase.clone(), raw));
}
@@ -300,6 +189,156 @@ impl<T: System> EventsDecoder<T> {
}
Ok(r)
}
fn decode_raw_bytes<W: Output>(
&self,
args: &[EventArg],
input: &mut &[u8],
output: &mut W,
errors: &mut Vec<RuntimeError>,
) -> Result<(), Error> {
for arg in args {
match arg {
EventArg::Vec(arg) => {
let len = <Compact<u32>>::decode(input)?;
len.encode_to(output);
for _ in 0..len.0 {
self.decode_raw_bytes(&[*arg.clone()], input, output, errors)?
}
}
EventArg::Option(arg) => {
match input.read_byte()? {
0 => output.push_byte(0),
1 => {
output.push_byte(1);
self.decode_raw_bytes(&[*arg.clone()], input, output, errors)?
}
_ => {
return Err(Error::Other(
"unexpected first byte decoding Option".into(),
))
}
}
}
EventArg::Tuple(args) => {
self.decode_raw_bytes(args, input, output, errors)?
}
EventArg::Primitive(name) => {
let result = match name.as_str() {
"DispatchResult" => DispatchResult::decode(input)?,
"DispatchError" => Err(DispatchError::decode(input)?),
_ => {
if let Some(seg) = self.event_type_registry.resolve(name) {
let mut buf = Vec::<u8>::new();
seg.segment(input, &mut buf)?;
output.write(&buf);
Ok(())
} else {
return Err(Error::TypeSizeUnavailable(name.to_owned()))
}
}
};
if let Err(error) = result {
// since the input may contain any number of args we propagate
// runtime errors to the caller for handling
errors.push(RuntimeError::from_dispatch(&self.metadata, error)?);
}
}
}
}
Ok(())
}
}
/// Registry for event types which cannot be directly inferred from the metadata.
#[derive(Default)]
pub struct EventTypeRegistry<T> {
segmenters: HashMap<String, Box<dyn TypeSegmenter>>,
marker: PhantomData<fn() -> T>,
}
impl<T> Clone for EventTypeRegistry<T> {
fn clone(&self) -> Self {
Self {
segmenters: self.segmenters.clone(),
marker: PhantomData,
}
}
}
impl<T> fmt::Debug for EventTypeRegistry<T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("EventTypeRegistry")
.field(
"segmenters",
&self.segmenters.keys().cloned().collect::<String>(),
)
.finish()
}
}
impl<T: Runtime> EventTypeRegistry<T> {
/// Create a new [`EventTypeRegistry`].
pub fn new() -> Self {
let mut registry = Self {
segmenters: HashMap::new(),
marker: PhantomData,
};
T::register_type_sizes(&mut registry);
registry
}
/// Register a type.
///
/// # Panics
///
/// If there is already a type size registered with this name.
pub fn register_type_size<U>(&mut self, name: &str)
where
U: Codec + Send + Sync + 'static,
{
// A segmenter decodes a type from an input stream (&mut &[u8]) and returns te serialized
// type to the output stream (&mut Vec<u8>).
match self.segmenters.entry(name.to_string()) {
Entry::Occupied(_) => panic!("Already a type registered with key {}", name),
Entry::Vacant(entry) => entry.insert(Box::new(TypeMarker::<U>::default())),
};
}
/// Check missing type sizes.
pub fn check_missing_type_sizes(
&self,
metadata: &Metadata,
) -> Result<(), HashSet<String>> {
let mut missing = HashSet::new();
for module in metadata.modules_with_events() {
for event in module.events() {
for arg in event.arguments() {
for primitive in arg.primitives() {
if !self.segmenters.contains_key(&primitive) {
missing.insert(format!(
"{}::{}::{}",
module.name(),
event.name,
primitive
));
}
}
}
}
}
if !missing.is_empty() {
Err(missing)
} else {
Ok(())
}
}
/// Resolve a segmenter for a type by its name.
pub fn resolve(&self, name: &str) -> Option<&Box<dyn TypeSegmenter>> {
self.segmenters.get(name)
}
}
/// Raw event or error event
@@ -331,7 +370,10 @@ mod tests {
#[test]
fn test_decode_option() {
let decoder = EventsDecoder::<TestRuntime>::new(Metadata::default());
let decoder = EventsDecoder::<TestRuntime>::new(
Metadata::default(),
EventTypeRegistry::new(),
);
let value = Some(0u8);
let input = value.encode();
@@ -419,6 +461,7 @@ mod tests {
}),
))
.unwrap(),
EventTypeRegistry::new(),
);
// [(ApplyExtrinsic(0), Event(RawEvent { module: "System", variant: "ExtrinsicSuccess", data: "482d7c09000000000200" })), (ApplyExtrinsic(1), Error(Module(ModuleError { module: "System", error: "NonDefaultComposite" }))), (ApplyExtrinsic(2), Error(Module(ModuleError { module: "System", error: "NonDefaultComposite" })))]
src/frame/balances.rs
+3 -8
View File
@@ -16,10 +16,7 @@
//! Implements support for the pallet_balances module.
use crate::frame::system::{
System,
SystemEventsDecoder,
};
use crate::frame::system::System;
use codec::{
Decode,
Encode,
@@ -159,7 +156,6 @@ mod tests {
ModuleError,
RuntimeError,
},
events::EventsDecoder,
extrinsic::{
PairSigner,
Signer,
@@ -301,9 +297,8 @@ mod tests {
let bob_addr = bob.clone().into();
let (client, _) = test_client().await;
let sub = client.subscribe_events().await.unwrap();
let mut decoder = EventsDecoder::<TestRuntime>::new(client.metadata().clone());
decoder.with_balances();
let mut sub = EventSubscription::<TestRuntime>::new(sub, decoder);
let decoder = client.events_decoder();
let mut sub = EventSubscription::<TestRuntime>::new(sub, &decoder);
sub.filter_event::<TransferEvent<_>>();
client.transfer(&alice, &bob_addr, 10_000).await.unwrap();
let raw = sub.next().await.unwrap().unwrap();
src/frame/contracts.rs
+2 -8
View File
@@ -17,14 +17,8 @@
//! Implements support for the pallet_contracts module.
use crate::frame::{
balances::{
Balances,
BalancesEventsDecoder,
},
system::{
System,
SystemEventsDecoder,
},
balances::Balances,
system::System,
};
use codec::{
Decode,
src/frame/mod.rs
+3 -8
View File
@@ -16,12 +16,9 @@
//! Implements support for built-in runtime modules.
use crate::{
events::EventsDecoder,
metadata::{
Metadata,
MetadataError,
},
use crate::metadata::{
Metadata,
MetadataError,
};
use codec::{
Decode,
@@ -63,8 +60,6 @@ pub trait Call<T>: Encode {
const MODULE: &'static str;
/// Function name.
const FUNCTION: &'static str;
/// Load event decoder.
fn events_decoder(_decoder: &mut EventsDecoder<T>) {}
}
/// Event trait.
src/frame/session.rs
+2 -8
View File
@@ -16,14 +16,8 @@
//! Session support
use crate::frame::{
balances::{
Balances,
BalancesEventsDecoder as _,
},
system::{
System,
SystemEventsDecoder as _,
},
balances::Balances,
system::System,
};
use codec::Encode;
use frame_support::Parameter;
src/frame/staking.rs
+1 -12
View File
@@ -16,10 +16,7 @@
//! Implements support for the pallet_staking module.
use super::balances::{
Balances,
BalancesEventsDecoder as _,
};
use super::balances::Balances;
use codec::{
Decode,
Encode,
@@ -62,20 +59,12 @@ pub struct SetPayeeCall<T: Staking> {
pub _runtime: PhantomData<T>,
}
/// Identity of a Grandpa authority.
pub type AuthorityId = crate::runtimes::app::grandpa::Public;
/// The weight of an authority.
pub type AuthorityWeight = u64;
/// A list of Grandpa authorities with associated weights.
pub type AuthorityList = Vec<(AuthorityId, AuthorityWeight)>;
/// The subset of the `frame::Trait` that a client must implement.
#[module]
#[rustfmt::skip]
pub trait Staking: Balances {
#![event_alias(ElectionCompute = u8)]
#![event_type(EraIndex)]
#![event_type(AuthorityList)]
}
/// Number of eras to keep in history.
src/frame/sudo.rs
+1 -4
View File
@@ -17,10 +17,7 @@
//! Implements support for the frame_sudo module.
use crate::{
frame::system::{
System,
SystemEventsDecoder,
},
frame::system::System,
Encoded,
};
use codec::Encode;
src/lib.rs
+63 -15
View File
@@ -49,7 +49,10 @@ pub use substrate_subxt_client as client;
pub use sp_core;
pub use sp_runtime;
use codec::Decode;
use codec::{
Codec,
Decode,
};
use futures::future;
use jsonrpsee::client::Subscription;
use sp_core::{
@@ -76,6 +79,7 @@ mod subscription;
pub use crate::{
error::Error,
events::{
EventTypeRegistry,
EventsDecoder,
RawEvent,
},
@@ -115,20 +119,22 @@ use crate::{
/// ClientBuilder for constructing a Client.
#[derive(Default)]
pub struct ClientBuilder<T: Runtime> {
_marker: std::marker::PhantomData<T>,
url: Option<String>,
client: Option<jsonrpsee::Client>,
page_size: Option<u32>,
event_type_registry: EventTypeRegistry<T>,
skip_type_sizes_check: bool,
}
impl<T: Runtime> ClientBuilder<T> {
/// Creates a new ClientBuilder.
pub fn new() -> Self {
Self {
_marker: std::marker::PhantomData,
url: None,
client: None,
page_size: None,
event_type_registry: EventTypeRegistry::new(),
skip_type_sizes_check: false,
}
}
@@ -150,8 +156,30 @@ impl<T: Runtime> ClientBuilder<T> {
self
}
/// Register a custom type segmenter, for consuming types in events where the size cannot
/// be inferred from the metadata.
///
/// # Panics
///
/// If there is already a type size registered with this name.
pub fn register_type_size<U>(mut self, name: &str) -> Self
where
U: Codec + Send + Sync + 'static,
{
self.event_type_registry.register_type_size::<U>(name);
self
}
/// Disable the check for missing type sizes on `build`.
///
/// *WARNING* can lead to runtime errors if receiving events with unknown types.
pub fn skip_type_sizes_check(mut self) -> Self {
self.skip_type_sizes_check = false;
self
}
/// Creates a new Client.
pub async fn build(self) -> Result<Client<T>, Error> {
pub async fn build<'a>(self) -> Result<Client<T>, Error> {
let client = if let Some(client) = self.client {
client
} else {
@@ -170,10 +198,33 @@ impl<T: Runtime> ClientBuilder<T> {
rpc.system_properties(),
)
.await;
let metadata = metadata?;
if let Err(missing) = self.event_type_registry.check_missing_type_sizes(&metadata)
{
if self.skip_type_sizes_check {
log::warn!(
"The following types do not have registered type segmenters: {:?} \
If any events containing these types are received, this can cause a \
`TypeSizeUnavailable` error and prevent decoding the actual event \
being listened for.\
\
Use `ClientBuilder::register_type_size` to register missing type sizes.",
missing
);
} else {
return Err(Error::MissingTypeSizes(missing.into_iter().collect()))
}
}
let events_decoder =
EventsDecoder::new(metadata.clone(), self.event_type_registry);
Ok(Client {
rpc,
genesis_hash: genesis_hash?,
metadata: metadata?,
metadata,
events_decoder,
properties: properties.unwrap_or_else(|_| Default::default()),
runtime_version: runtime_version?,
_marker: PhantomData,
@@ -187,6 +238,7 @@ pub struct Client<T: Runtime> {
rpc: Rpc<T>,
genesis_hash: T::Hash,
metadata: Metadata,
events_decoder: EventsDecoder<T>,
properties: SystemProperties,
runtime_version: RuntimeVersion,
_marker: PhantomData<(fn() -> T::Signature, T::Extra)>,
@@ -199,6 +251,7 @@ impl<T: Runtime> Clone for Client<T> {
rpc: self.rpc.clone(),
genesis_hash: self.genesis_hash,
metadata: self.metadata.clone(),
events_decoder: self.events_decoder.clone(),
properties: self.properties.clone(),
runtime_version: self.runtime_version.clone(),
_marker: PhantomData,
@@ -466,12 +519,9 @@ impl<T: Runtime> Client<T> {
Ok(signed)
}
/// Returns an events decoder for a call.
pub fn events_decoder<C: Call<T>>(&self) -> EventsDecoder<T> {
let metadata = self.metadata().clone();
let mut decoder = EventsDecoder::new(metadata);
C::events_decoder(&mut decoder);
decoder
/// Returns the events decoder.
pub fn events_decoder(&self) -> &EventsDecoder<T> {
&self.events_decoder
}
/// Create and submit an extrinsic and return corresponding Hash if successful
@@ -486,10 +536,9 @@ impl<T: Runtime> Client<T> {
pub async fn submit_and_watch_extrinsic(
&self,
extrinsic: UncheckedExtrinsic<T>,
decoder: EventsDecoder<T>,
) -> Result<ExtrinsicSuccess<T>, Error> {
self.rpc
.submit_and_watch_extrinsic(extrinsic, decoder)
.submit_and_watch_extrinsic(extrinsic, &self.events_decoder)
.await
}
@@ -518,8 +567,7 @@ impl<T: Runtime> Client<T> {
Send + Sync,
{
let extrinsic = self.create_signed(call, signer).await?;
let decoder = self.events_decoder::<C>();
self.submit_and_watch_extrinsic(extrinsic, decoder).await
self.submit_and_watch_extrinsic(extrinsic).await
}
/// Insert a key into the keystore.
src/rpc.rs
+3 -3
View File
@@ -423,10 +423,10 @@ impl<T: Runtime> Rpc<T> {
}
/// Create and submit an extrinsic and return corresponding Event if successful
pub async fn submit_and_watch_extrinsic<E: Encode + 'static>(
pub async fn submit_and_watch_extrinsic<'a, E: Encode + 'static>(
&self,
extrinsic: E,
decoder: EventsDecoder<T>,
decoder: &'a EventsDecoder<T>,
) -> Result<ExtrinsicSuccess<T>, Error> {
let ext_hash = T::Hashing::hash_of(&extrinsic);
log::info!("Submitting Extrinsic `{:?}`", ext_hash);
@@ -465,7 +465,7 @@ impl<T: Runtime> Rpc<T> {
ext_hash,
))
})?;
let mut sub = EventSubscription::new(events_sub, decoder);
let mut sub = EventSubscription::new(events_sub, &decoder);
sub.filter_extrinsic(block_hash, ext_index);
let mut events = vec![];
while let Some(event) = sub.next().await {
src/runtimes.rs
+133 -5
View File
@@ -147,13 +147,30 @@ use crate::{
balances::{
AccountData,
Balances,
BalancesEventTypeRegistry,
},
contracts::{
Contracts,
ContractsEventTypeRegistry,
},
session::{
Session,
SessionEventTypeRegistry,
},
staking::{
Staking,
StakingEventTypeRegistry,
},
sudo::{
Sudo,
SudoEventTypeRegistry,
},
system::{
System,
SystemEventTypeRegistry,
},
contracts::Contracts,
session::Session,
staking::Staking,
sudo::Sudo,
system::System,
},
EventTypeRegistry,
};
/// Runtime trait.
@@ -162,6 +179,9 @@ pub trait Runtime: System + Sized + Send + Sync + 'static {
type Signature: Verify + Encode + Send + Sync + 'static;
/// Transaction extras.
type Extra: SignedExtra<Self> + Send + Sync + 'static;
/// Register type sizes for this runtime
fn register_type_sizes(event_type_registry: &mut EventTypeRegistry<Self>);
}
/// Concrete type definitions compatible with those in the default substrate `node_runtime`
@@ -178,6 +198,15 @@ impl Staking for DefaultNodeRuntime {}
impl Runtime for DefaultNodeRuntime {
type Signature = MultiSignature;
type Extra = DefaultExtra<Self>;
fn register_type_sizes(event_type_registry: &mut EventTypeRegistry<Self>) {
event_type_registry.with_system();
event_type_registry.with_balances();
event_type_registry.with_session();
event_type_registry.with_contracts();
event_type_registry.with_sudo();
register_default_type_sizes(event_type_registry);
}
}
impl System for DefaultNodeRuntime {
@@ -217,6 +246,14 @@ pub struct NodeTemplateRuntime;
impl Runtime for NodeTemplateRuntime {
type Signature = MultiSignature;
type Extra = DefaultExtra<Self>;
fn register_type_sizes(event_type_registry: &mut EventTypeRegistry<Self>) {
event_type_registry.with_system();
event_type_registry.with_balances();
event_type_registry.with_session();
event_type_registry.with_sudo();
register_default_type_sizes(event_type_registry);
}
}
impl System for NodeTemplateRuntime {
@@ -253,6 +290,14 @@ pub struct ContractsTemplateRuntime;
impl Runtime for ContractsTemplateRuntime {
type Signature = <NodeTemplateRuntime as Runtime>::Signature;
type Extra = DefaultExtra<Self>;
fn register_type_sizes(event_type_registry: &mut EventTypeRegistry<Self>) {
event_type_registry.with_system();
event_type_registry.with_balances();
event_type_registry.with_contracts();
event_type_registry.with_sudo();
register_default_type_sizes(event_type_registry);
}
}
impl System for ContractsTemplateRuntime {
@@ -287,6 +332,14 @@ pub struct KusamaRuntime;
impl Runtime for KusamaRuntime {
type Signature = MultiSignature;
type Extra = DefaultExtra<Self>;
fn register_type_sizes(event_type_registry: &mut EventTypeRegistry<Self>) {
event_type_registry.with_system();
event_type_registry.with_balances();
event_type_registry.with_session();
event_type_registry.with_staking();
register_default_type_sizes(event_type_registry);
}
}
impl System for KusamaRuntime {
@@ -311,3 +364,78 @@ impl Staking for KusamaRuntime {}
impl Balances for KusamaRuntime {
type Balance = u128;
}
/// Identity of a Grandpa authority.
pub type AuthorityId = crate::runtimes::app::grandpa::Public;
/// The weight of an authority.
pub type AuthorityWeight = u64;
/// A list of Grandpa authorities with associated weights.
pub type AuthorityList = Vec<(AuthorityId, AuthorityWeight)>;
/// Register default common runtime type sizes
pub fn register_default_type_sizes<T: Runtime>(
event_type_registry: &mut EventTypeRegistry<T>,
) {
// primitives
event_type_registry.register_type_size::<bool>("bool");
event_type_registry.register_type_size::<u8>("u8");
event_type_registry.register_type_size::<u32>("u32");
event_type_registry.register_type_size::<u64>("u64");
event_type_registry.register_type_size::<u128>("u128");
event_type_registry.register_type_size::<()>("PhantomData");
// frame_support types
event_type_registry
.register_type_size::<frame_support::dispatch::DispatchInfo>("DispatchInfo");
event_type_registry
.register_type_size::<frame_support::dispatch::DispatchResult>("DispatchResult");
event_type_registry
.register_type_size::<frame_support::dispatch::DispatchError>("DispatchError");
event_type_registry
.register_type_size::<frame_support::traits::BalanceStatus>("Status");
// aliases etc.
event_type_registry.register_type_size::<u32>("ReferendumIndex");
event_type_registry.register_type_size::<[u8; 16]>("Kind");
event_type_registry.register_type_size::<u32>("AccountIndex");
event_type_registry.register_type_size::<u32>("PropIndex");
event_type_registry.register_type_size::<u32>("ProposalIndex");
event_type_registry.register_type_size::<u32>("AuthorityIndex");
event_type_registry.register_type_size::<u32>("MemberCount");
event_type_registry.register_type_size::<u8>("VoteThreshold");
event_type_registry
.register_type_size::<(T::BlockNumber, u32)>("TaskAddress<BlockNumber>");
event_type_registry.register_type_size::<AuthorityId>("AuthorityId");
event_type_registry.register_type_size::<AuthorityWeight>("AuthorityWeight");
event_type_registry
.register_type_size::<Vec<(AuthorityId, AuthorityWeight)>>("AuthorityList");
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn can_register_default_runtime_type_sizes() {
EventTypeRegistry::<DefaultNodeRuntime>::new();
}
#[test]
fn can_register_node_template_runtime_type_sizes() {
EventTypeRegistry::<NodeTemplateRuntime>::new();
}
#[test]
fn can_register_contracts_template_runtime_type_sizes() {
EventTypeRegistry::<ContractsTemplateRuntime>::new();
}
#[test]
fn can_register_kusama_runtime_type_sizes() {
EventTypeRegistry::<KusamaRuntime>::new();
}
}
src/subscription.rs
+4 -4
View File
@@ -34,9 +34,9 @@ use crate::{
/// Event subscription simplifies filtering a storage change set stream for
/// events of interest.
pub struct EventSubscription<T: Runtime> {
pub struct EventSubscription<'a, T: Runtime> {
subscription: Subscription<StorageChangeSet<T::Hash>>,
decoder: EventsDecoder<T>,
decoder: &'a EventsDecoder<T>,
block: Option<T::Hash>,
extrinsic: Option<usize>,
event: Option<(&'static str, &'static str)>,
@@ -44,11 +44,11 @@ pub struct EventSubscription<T: Runtime> {
finished: bool,
}
impl<T: Runtime> EventSubscription<T> {
impl<'a, T: Runtime> EventSubscription<'a, T> {
/// Creates a new event subscription.
pub fn new(
subscription: Subscription<StorageChangeSet<T::Hash>>,
decoder: EventsDecoder<T>,
decoder: &'a EventsDecoder<T>,
) -> Self {
Self {
subscription,