diff --git a/substrate/polkadot/runtime/src/utils.rs b/substrate/polkadot/runtime/src/utils.rs
index 4c16e215bab7e7076355061c524fc18efe6b93dd..1531590ff5fcaea22e8390e28fc6b5a280f5258e 100644
--- a/substrate/polkadot/runtime/src/utils.rs
+++ b/substrate/polkadot/runtime/src/utils.rs
@@ -47,5 +47,5 @@ pub fn inherent_extrinsics(timestamp: ::primitives::Timestamp, parachain_heads:
/// Checks an unchecked extrinsic for validity.
pub fn check_extrinsic(xt: UncheckedExtrinsic) -> bool {
- xt.check(Staking::lookup).is_ok()
+ xt.check_with(Staking::lookup).is_ok()
}
diff --git a/substrate/polkadot/transaction-pool/src/lib.rs b/substrate/polkadot/transaction-pool/src/lib.rs
index 6e0ec39d77bfe9b6b34edea59c3c0c4728d35031..a553afb94c4d0c5414e80f2394180c6c9397cf05 100644
--- a/substrate/polkadot/transaction-pool/src/lib.rs
+++ b/substrate/polkadot/transaction-pool/src/lib.rs
@@ -55,7 +55,7 @@ pub use extrinsic_pool::txpool::{Options, Status, LightStatus, VerifiedTransacti
pub use error::{Error, ErrorKind, Result};
/// Type alias for convenience.
-pub type CheckedExtrinsic = <UncheckedExtrinsic as Checkable>::Checked;
+pub type CheckedExtrinsic = <UncheckedExtrinsic as Checkable<fn(Address) -> std::result::Result<AccountId, &'static str>>>::Checked;
/// A verified transaction which should be includable and non-inherent.
#[derive(Clone, Debug)]
@@ -281,7 +281,7 @@ impl<'a, A> txpool::Verifier<UncheckedExtrinsic> for Verifier<'a, A> where
}
let (encoded_size, hash) = uxt.using_encoded(|e| (e.len(), BlakeTwo256::hash(e)));
- let inner = match uxt.clone().check(|a| self.lookup(a)) {
+ let inner = match uxt.clone().check_with(|a| self.lookup(a)) {
Ok(xt) => Some(xt),
// keep the transaction around in the future pool and attempt to promote it later.
Err(Self::NO_ACCOUNT) => None,
diff --git a/substrate/substrate/runtime/council/src/lib.rs b/substrate/substrate/runtime/council/src/lib.rs
index a40a64b27b84fd9474759c8396c5fa2a2d452386..e6c3c9b4164d49a7b785cb2f5e5b92da7d3f4ec9 100644
--- a/substrate/substrate/runtime/council/src/lib.rs
+++ b/substrate/substrate/runtime/council/src/lib.rs
@@ -549,7 +549,7 @@ impl<T: Trait> Module<T> {
#[serde(rename_all = "camelCase")]
#[serde(deny_unknown_fields)]
pub struct GenesisConfig<T: Trait> {
- // for the voting onto the council
+ // for the voting onto the council
pub candidacy_bond: T::Balance,
pub voter_bond: T::Balance,
pub present_slash_per_voter: T::Balance,
diff --git a/substrate/substrate/runtime/executive/src/lib.rs b/substrate/substrate/runtime/executive/src/lib.rs
index 52cfda24c96018afd296ce84260e9b2e92e9423c..8551580df746769fed83acf48a342af05b3f3811 100644
--- a/substrate/substrate/runtime/executive/src/lib.rs
+++ b/substrate/substrate/runtime/executive/src/lib.rs
@@ -82,14 +82,15 @@ pub struct Executive<
>(PhantomData<(System, Block, Lookup, Payment, Finalisation)>);
impl<
+ Address,
System: system::Trait,
Block: traits::Block<Header=System::Header, Hash=System::Hash>,
- Lookup: AuxLookup<Source=<Block::Extrinsic as Checkable>::Address, Target=System::AccountId>,
+ Lookup: AuxLookup<Source=Address, Target=System::AccountId>,
Payment: MakePayment<System::AccountId>,
Finalisation: Executable,
> Executive<System, Block, Lookup, Payment, Finalisation> where
- Block::Extrinsic: Checkable<AccountId=System::AccountId> + Slicable,
- <Block::Extrinsic as Checkable>::Checked: Applyable<Index=System::Index, AccountId=System::AccountId>
+ Block::Extrinsic: Checkable<fn(Address) -> Result<System::AccountId, &'static str>> + Slicable,
+ <Block::Extrinsic as Checkable<fn(Address) -> Result<System::AccountId, &'static str>>>::Checked: Applyable<Index=System::Index, AccountId=System::AccountId>
{
/// Start the execution of a particular block.
pub fn initialise_block(header: &System::Header) {
@@ -172,7 +173,7 @@ impl<
/// Actually apply an extrinsic given its `encoded_len`; this doesn't note its hash.
fn apply_extrinsic_no_note_with_len(uxt: Block::Extrinsic, encoded_len: usize) -> result::Result<internal::ApplyOutcome, internal::ApplyError> {
// Verify the signature is good.
- let xt = uxt.check(Lookup::lookup).map_err(internal::ApplyError::BadSignature)?;
+ let xt = uxt.check_with(Lookup::lookup).map_err(internal::ApplyError::BadSignature)?;
if xt.sender() != &Default::default() {
// check index
diff --git a/substrate/substrate/runtime/primitives/src/generic.rs b/substrate/substrate/runtime/primitives/src/generic.rs
index 06c700037210b7a05b9c3259c90a79695aacb0ef..863dfb7735464de582d201ff6e8ccc7b4c41f5e8 100644
--- a/substrate/substrate/runtime/primitives/src/generic.rs
+++ b/substrate/substrate/runtime/primitives/src/generic.rs
@@ -96,7 +96,7 @@ impl<Address, AccountId, Index, Call, Signature> UncheckedExtrinsic<Address, Ind
}
}
-impl<Address, AccountId, Index, Call, Signature> traits::Checkable
+impl<Address, AccountId, Index, Call, Signature, ThisLookup> traits::Checkable<ThisLookup>
for UncheckedExtrinsic<Address, Index, Call, ::MaybeUnsigned<Signature>>
where
Address: Member + Default + MaybeDisplay,
@@ -106,18 +106,11 @@ where
AccountId: Member + Default + MaybeDisplay,
::MaybeUnsigned<Signature>: Member,
Extrinsic<AccountId, Index, Call>: Slicable,
+ ThisLookup: FnOnce(Address) -> Result<AccountId, &'static str>,
{
- type Address = Address;
- type AccountId = AccountId;
type Checked = CheckedExtrinsic<AccountId, Index, Call>;
- fn sender(&self) -> &Address {
- &self.extrinsic.signed
- }
-
- fn check<ThisLookup>(self, lookup: ThisLookup) -> Result<Self::Checked, &'static str> where
- ThisLookup: FnOnce(Address) -> Result<AccountId, &'static str>,
- {
+ fn check_with(self, lookup: ThisLookup) -> Result<Self::Checked, &'static str> {
if !self.is_signed() {
Ok(CheckedExtrinsic(Extrinsic {
signed: Default::default(),
diff --git a/substrate/substrate/runtime/primitives/src/testing.rs b/substrate/substrate/runtime/primitives/src/testing.rs
index 7c712b40105e61c8f098beb10e9f1e97c01a7b4c..12e347e1e3a8bff200bf9ad03a94c28173dc343e 100644
--- a/substrate/substrate/runtime/primitives/src/testing.rs
+++ b/substrate/substrate/runtime/primitives/src/testing.rs
@@ -157,12 +157,9 @@ impl<Call: AuxDispatchable + Slicable + Sized + Send + Sync + Serialize + Deseri
self.0.encode()
}
}
-impl<Call: 'static + AuxDispatchable + Slicable + Sized + Send + Sync + Serialize + DeserializeOwned + Clone + Eq + Debug> Checkable for TestXt<Call> {
+impl<Call: Slicable + Sync + Send + Serialize + AuxDispatchable, Context> Checkable<Context> for TestXt<Call> {
type Checked = Self;
- type Address = u64;
- type AccountId = u64;
- fn sender(&self) -> &u64 { &(self.0).0 }
- fn check<ThisLookup: FnOnce(Self::Address) -> Result<Self::AccountId, &'static str>>(self, _lookup: ThisLookup) -> Result<Self::Checked, &'static str> { Ok(self) }
+ fn check_with(self, _: Context) -> Result<Self::Checked, &'static str> { Ok(self) }
}
impl<Call: AuxDispatchable<Aux = u64> + Slicable + Sized + Send + Sync + Serialize + DeserializeOwned + Clone + Eq + Debug> Applyable for TestXt<Call> {
type AccountId = u64;
diff --git a/substrate/substrate/runtime/primitives/src/traits.rs b/substrate/substrate/runtime/primitives/src/traits.rs
index 9f618e4dbc5fb8f9a3d8ceaf33ad3d8c25fa1071..77eaba3fd27777d9fcea643872847b3b24dccb4e 100644
--- a/substrate/substrate/runtime/primitives/src/traits.rs
+++ b/substrate/substrate/runtime/primitives/src/traits.rs
@@ -375,31 +375,32 @@ pub type HashFor<B> = <<B as Block>::Header as Header>::Hashing;
/// A "checkable" piece of information, used by the standard Substrate Executive in order to
/// check the validity of a piece of extrinsic information, usually by verifying the signature.
-pub trait Checkable: Sized + Send + Sync {
- type Address: Member + MaybeDisplay;
- type AccountId: Member + MaybeDisplay;
- type Checked: Member;
- fn sender(&self) -> &Self::Address;
- fn check<ThisLookup: FnOnce(Self::Address) -> Result<Self::AccountId, &'static str>>(self, lookup: ThisLookup) -> Result<Self::Checked, &'static str>;
+/// Implement for pieces of information that require some additional context `Context` in order to be
+/// checked.
+pub trait Checkable<Context>: Sized {
+ /// Returned if `check_with` succeeds.
+ type Checked;
+
+ fn check_with(self, context: Context) -> Result<Self::Checked, &'static str>;
}
/// A "checkable" piece of information, used by the standard Substrate Executive in order to
/// check the validity of a piece of extrinsic information, usually by verifying the signature.
-///
-/// This does that checking without requiring a lookup argument.
-pub trait BlindCheckable: Sized + Send + Sync {
- type Address: Member + MaybeDisplay;
- type Checked: Member;
- fn sender(&self) -> &Self::Address;
+/// Implement for pieces of information that don't require additional context in order to be
+/// checked.
+pub trait BlindCheckable: Sized {
+ /// Returned if `check` succeeds.
+ type Checked;
+
fn check(self) -> Result<Self::Checked, &'static str>;
}
-impl<T: BlindCheckable> Checkable for T {
- type Address = <Self as BlindCheckable>::Address;
- type AccountId = <Self as BlindCheckable>::Address;
+// Every `BlindCheckable` is also a `Checkable` for arbitrary `Context`.
+impl<T: BlindCheckable, Context> Checkable<Context> for T {
type Checked = <Self as BlindCheckable>::Checked;
- fn sender(&self) -> &Self::Address { BlindCheckable::sender(self) }
- fn check<ThisLookup: FnOnce(Self::Address) -> Result<Self::AccountId, &'static str>>(self, _: ThisLookup) -> Result<Self::Checked, &'static str> { BlindCheckable::check(self) }
+ fn check_with(self, _: Context) -> Result<Self::Checked, &'static str> {
+ BlindCheckable::check(self)
+ }
}
/// An "executable" piece of information, used by the standard Substrate Executive in order to
diff --git a/substrate/substrate/test-runtime/src/lib.rs b/substrate/substrate/test-runtime/src/lib.rs
index 1b07035e966e8373da580be754ff4dc623261925..ee4357aaeee76f4b91abb9bf1f4283c9b3884320 100644
--- a/substrate/substrate/test-runtime/src/lib.rs
+++ b/substrate/substrate/test-runtime/src/lib.rs
@@ -119,11 +119,7 @@ impl Slicable for Extrinsic {
impl BlindCheckable for Extrinsic {
type Checked = Self;
- type Address = AccountId;
- fn sender(&self) -> &Self::Address {
- &self.transfer.from
- }
fn check(self) -> Result<Self, &'static str> {
if ::runtime_primitives::verify_encoded_lazy(&self.signature, &self.transfer, &self.transfer.from) {
Ok(self)