From 8fe5ebbc00a12e4eae860a30771b75abb3aa6a92 Mon Sep 17 00:00:00 2001 From: Giles Cope Date: Sun, 19 Sep 2021 10:49:24 +0100 Subject: [PATCH] cargo fmt --- src/error.rs | 10 +++++-- src/events.rs | 75 +++++++++++++++++++++++++++++++++++-------------- src/metadata.rs | 70 +++++++++++++++++++++++++++++---------------- 3 files changed, 108 insertions(+), 47 deletions(-) diff --git a/src/error.rs b/src/error.rs index 0ba578b14b..9e60fc1557 100644 --- a/src/error.rs +++ b/src/error.rs @@ -16,10 +16,16 @@ use jsonrpsee_types::Error as RequestError; use sp_core::crypto::SecretStringError; -use sp_runtime::{transaction_validity::TransactionValidityError, DispatchError}; +use sp_runtime::{ + transaction_validity::TransactionValidityError, + DispatchError, +}; use thiserror::Error; -use crate::metadata::{Metadata, MetadataError}; +use crate::metadata::{ + Metadata, + MetadataError, +}; /// Error enum. #[derive(Debug, Error)] diff --git a/src/events.rs b/src/events.rs index 737fb9732a..95d530d14c 100644 --- a/src/events.rs +++ b/src/events.rs @@ -14,22 +14,46 @@ // You should have received a copy of the GNU General Public License // along with substrate-subxt. If not, see . -use codec::{Codec, Compact, Decode, Encode, Input, Output}; +use codec::{ + Codec, + Compact, + Decode, + Encode, + Input, + Output, +}; use dyn_clone::DynClone; -use sp_runtime::{DispatchError, DispatchResult}; +use sp_runtime::{ + DispatchError, + DispatchResult, +}; use std::{ collections::{ - hash_map::{Entry, HashMap}, + hash_map::{ + Entry, + HashMap, + }, HashSet, }, fmt, - marker::{PhantomData, Send}, + marker::{ + PhantomData, + Send, + }, }; use crate::{ - error::{Error, RuntimeError}, - metadata::{EventArg, Metadata}, - Phase, Runtime, System, + error::{ + Error, + RuntimeError, + }, + metadata::{ + EventArg, + Metadata, + }, + Phase, + Runtime, + System, }; /// Raw bytes for an Event @@ -182,18 +206,20 @@ impl EventsDecoder { 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)? + 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(), + )) + } } - _ => { - return Err(Error::Other( - "unexpected first byte decoding Option".into(), - )) - } - }, + } EventArg::Tuple(args) => { self.decode_raw_bytes(args, input, output, errors)? } @@ -208,7 +234,7 @@ impl EventsDecoder { output.write(&buf); Ok(()) } else { - return Err(Error::TypeSizeUnavailable(name.to_owned())); + return Err(Error::TypeSizeUnavailable(name.to_owned())) } } }; @@ -328,8 +354,15 @@ pub enum Raw { mod tests { use super::*; use frame_metadata::{ - DecodeDifferent, ErrorMetadata, EventMetadata, ExtrinsicMetadata, ModuleMetadata, - RuntimeMetadata, RuntimeMetadataPrefixed, RuntimeMetadataV13, META_RESERVED, + DecodeDifferent, + ErrorMetadata, + EventMetadata, + ExtrinsicMetadata, + ModuleMetadata, + RuntimeMetadata, + RuntimeMetadataPrefixed, + RuntimeMetadataV13, + META_RESERVED, }; use std::convert::TryFrom; diff --git a/src/metadata.rs b/src/metadata.rs index f6873f3302..c3c3645bbe 100644 --- a/src/metadata.rs +++ b/src/metadata.rs @@ -14,13 +14,27 @@ // You should have received a copy of the GNU General Public License // along with substrate-subxt. If not, see . -use std::{collections::HashMap, convert::TryFrom, marker::PhantomData, str::FromStr}; +use std::{ + collections::HashMap, + convert::TryFrom, + marker::PhantomData, + str::FromStr, +}; -use codec::{Decode, Encode, Error as CodecError}; +use codec::{ + Decode, + Encode, + Error as CodecError, +}; use frame_metadata::{ - DecodeDifferent, RuntimeMetadata, RuntimeMetadataPrefixed, StorageEntryModifier, - StorageEntryType, StorageHasher, META_RESERVED, + DecodeDifferent, + RuntimeMetadata, + RuntimeMetadataPrefixed, + StorageEntryModifier, + StorageEntryType, + StorageHasher, + META_RESERVED, }; use sp_core::storage::StorageKey; @@ -278,11 +292,13 @@ impl StorageMetadata { StorageHasher::Blake2_256 => sp_core::blake2_256(bytes).to_vec(), StorageHasher::Twox128 => sp_core::twox_128(bytes).to_vec(), StorageHasher::Twox256 => sp_core::twox_256(bytes).to_vec(), - StorageHasher::Twox64Concat => sp_core::twox_64(bytes) - .iter() - .chain(bytes) - .cloned() - .collect(), + StorageHasher::Twox64Concat => { + sp_core::twox_64(bytes) + .iter() + .chain(bytes) + .cloned() + .collect() + } } } @@ -292,20 +308,24 @@ impl StorageMetadata { pub fn plain(&self) -> Result { match &self.ty { - StorageEntryType::Plain(_) => Ok(StoragePlain { - prefix: self.prefix().0, - }), + StorageEntryType::Plain(_) => { + Ok(StoragePlain { + prefix: self.prefix().0, + }) + } _ => Err(MetadataError::StorageTypeError), } } pub fn map(&self) -> Result, MetadataError> { match &self.ty { - StorageEntryType::Map { hasher, .. } => Ok(StorageMap { - _marker: PhantomData, - prefix: self.prefix().0, - hasher: hasher.clone(), - }), + StorageEntryType::Map { hasher, .. } => { + Ok(StorageMap { + _marker: PhantomData, + prefix: self.prefix().0, + hasher: hasher.clone(), + }) + } _ => Err(MetadataError::StorageTypeError), } } @@ -318,12 +338,14 @@ impl StorageMetadata { hasher, key2_hasher, .. - } => Ok(StorageDoubleMap { - _marker: PhantomData, - prefix: self.prefix().0, - hasher1: hasher.clone(), - hasher2: key2_hasher.clone(), - }), + } => { + Ok(StorageDoubleMap { + _marker: PhantomData, + prefix: self.prefix().0, + hasher1: hasher.clone(), + hasher2: key2_hasher.clone(), + }) + } _ => Err(MetadataError::StorageTypeError), } } @@ -504,7 +526,7 @@ impl TryFrom for Metadata { fn try_from(metadata: RuntimeMetadataPrefixed) -> Result { if metadata.0 != META_RESERVED { - return Err(ConversionError::InvalidPrefix.into()); + return Err(ConversionError::InvalidPrefix.into()) } let meta = match metadata.1 { RuntimeMetadata::V13(meta) => meta,