Make Council use Address for dispatch.

polkadot/runtime/src/lib.rs

@@ -71,7 +71,7 @@ pub const PARACHAINS_SET_POSITION: u32 = 1;
 /// Concrete runtime type used to parameterize the various modules.
 // Workaround for https://github.com/rust-lang/rust/issues/26925 . Remove when sorted.
 #[derive(Clone, Copy, PartialEq, Eq)]
-#[cfg_attr(feature = "std", derive(Debug))]
+#[cfg_attr(feature = "std", derive(Debug, Serialize))]
 pub struct Concrete;
 
 impl HasPublicAux for Concrete {
@@ -85,6 +85,8 @@ impl system::Trait for Concrete {
 	type Hashing = BlakeTwo256;
 	type Digest = generic::Digest<Log>;
 	type AccountId = AccountId;
+	type Address = Address;
+	type Lookup = Staking;
 	type Header = generic::Header<BlockNumber, Hash, Log>;
 }
 /// System module for this concrete runtime.
@@ -110,9 +112,6 @@ impl session::Trait for Concrete {
 /// Session module for this concrete runtime.
 pub type Session = session::Module<Concrete>;
 
-/// The address format for describing accounts.
-pub type Address = staking::Address<AccountId, AccountIndex>;
-
 impl staking::Trait for Concrete {
 	type Balance = Balance;
 	type DetermineContractAddress = BlakeTwo256;
@@ -162,6 +161,8 @@ impl_outer_dispatch! {
 	}
 }
 
+/// The address format for describing accounts.
+pub type Address = staking::Address<Concrete>;
 /// Block header type as expected by this runtime.
 pub type Header = generic::Header<BlockNumber, Hash, Log>;
 /// Block type as expected by this runtime.

substrate/runtime-support/src/dispatch.rs

@@ -79,7 +79,7 @@ macro_rules! decl_module {
 	) => {
 		// Workaround for https://github.com/rust-lang/rust/issues/26925 . Remove when sorted.
 		#[derive(Clone, Copy, PartialEq, Eq)]
-		#[cfg_attr(feature = "std", derive(Debug))]
+		#[cfg_attr(feature = "std", derive(Debug, Serialize))]
 		pub struct $mod_type<$trait_instance: $trait_name>($crate::dispatch::PhantomData<$trait_instance>);
 		decl_dispatch! {
 			impl for $mod_type<$trait_instance: $trait_name>;
@@ -92,7 +92,7 @@ macro_rules! decl_module {
 	) => {
 		// Workaround for https://github.com/rust-lang/rust/issues/26925 . Remove when sorted.
 		#[derive(Clone, Copy, PartialEq, Eq)]
-		#[cfg_attr(feature = "std", derive(Debug))]
+		#[cfg_attr(feature = "std", derive(Debug, Serialize))]
 		struct $mod_type<$trait_instance: $trait_name>($crate::dispatch::PhantomData<$trait_instance>);
 		decl_dispatch! {
 			impl for $mod_type<$trait_instance: $trait_name>;

substrate/runtime/council/src/lib.rs

@@ -35,7 +35,7 @@ extern crate substrate_runtime_staking as staking;
 extern crate substrate_runtime_system as system;
 
 use rstd::prelude::*;
-use primitives::traits::{Zero, One, RefInto, As};
+use primitives::traits::{Zero, One, RefInto, As, Lookup};
 use runtime_support::{StorageValue, StorageMap};
 use runtime_support::dispatch::Result;
 
@@ -103,14 +103,14 @@ decl_module! {
 	pub struct Module<T: Trait>;
 	pub enum Call where aux: T::PublicAux {
 		fn set_approvals(aux, votes: Vec<bool>, index: VoteIndex) -> Result = 0;
-		fn reap_inactive_voter(aux, signed_index: u32, who: T::AccountId, who_index: u32, assumed_vote_index: VoteIndex) -> Result = 1;
+		fn reap_inactive_voter(aux, signed_index: u32, who: staking::Address<T>, who_index: u32, assumed_vote_index: VoteIndex) -> Result = 1;
 		fn retract_voter(aux, index: u32) -> Result = 2;
 		fn submit_candidacy(aux, slot: u32) -> Result = 3;
-		fn present_winner(aux, candidate: T::AccountId, total: T::Balance, index: VoteIndex) -> Result = 4;
+		fn present_winner(aux, candidate: staking::Address<T>, total: T::Balance, index: VoteIndex) -> Result = 4;
 	}
 	pub enum PrivCall {
 		fn set_desired_seats(count: u32) -> Result = 0;
-		fn remove_member(who: T::AccountId) -> Result = 1;
+		fn remove_member(who: staking::Address<T>) -> Result = 1;
 		fn set_presentation_duration(count: T::BlockNumber) -> Result = 2;
 		fn set_term_duration(count: T::BlockNumber) -> Result = 3;
 	}
@@ -251,10 +251,11 @@ impl<T: Trait> Module<T> {
 	fn reap_inactive_voter(
 		aux: &T::PublicAux,
 		signed_index: u32,
-		who: T::AccountId,
+		who: staking::Address<T>,
 		who_index: u32,
 		assumed_vote_index: VoteIndex
 	) -> Result {
+		let who = <staking::Module<T>>::lookup(who)?;
 		ensure!(!Self::presentation_active(), "cannot reap during presentation period");
 		ensure!(Self::voter_last_active(aux.ref_into()).is_some(), "reaper must be a voter");
 		let last_active = Self::voter_last_active(&who).ok_or("target for inactivity cleanup must be active")?;
@@ -336,10 +337,11 @@ impl<T: Trait> Module<T> {
 	/// `signed` should have at least
 	fn present_winner(
 		aux: &T::PublicAux,
-		candidate: T::AccountId,
+		candidate: staking::Address<T>,
 		total: T::Balance,
 		index: VoteIndex
 	) -> Result {
+		let candidate = <staking::Module<T>>::lookup(candidate)?;
 		ensure!(index == Self::vote_index(), "index not current");
 		let (_, _, expiring) = Self::next_finalise().ok_or("cannot present outside of presentation period")?;
 		let stakes = Self::snapshoted_stakes();
@@ -391,7 +393,8 @@ impl<T: Trait> Module<T> {
 	/// Remove a particular member. A tally will happen instantly (if not already in a presentation
 	/// period) to fill the seat if removal means that the desired members are not met.
 	/// This is effective immediately.
-	fn remove_member(who: T::AccountId) -> Result {
+	fn remove_member(who: staking::Address<T>) -> Result {
+		let who = <staking::Module<T>>::lookup(who)?;
 		let new_council: Vec<(T::AccountId, T::BlockNumber)> = Self::active_council()
 			.into_iter()
 			.filter(|i| i.0 != who)

substrate/runtime/primitives/src/generic.rs

@@ -207,7 +207,7 @@ impl<Address, Index, Call, Signature, DoLookup> traits::Checkable for UncheckedE
 		} else {
 			let extrinsic: Extrinsic<<DoLookup as Lookup<Address>>::Target, Index, Call>
 				= Extrinsic {
-					signed: <DoLookup as Lookup<Address>>::lookup(self.extrinsic.signed).ok_or("bad address in extrinsic")?,
+					signed: <DoLookup as Lookup<Address>>::lookup(self.extrinsic.signed)?,
 				 	index: self.extrinsic.index,
 					function: self.extrinsic.function,
 				};

substrate/runtime/primitives/src/traits.rs

@@ -17,7 +17,7 @@
 //! Primitives for the runtime modules.
 
 use rstd::prelude::*;
-use rstd;
+use rstd::{self, result};
 #[cfg(not(feature = "std"))] use runtime_io;
 use substrate_primitives;
 use codec::Slicable;
@@ -38,7 +38,7 @@ pub trait Lookup<Source> {
 	/// Type to lookup into.
 	type Target;
 	/// Attempt a lookup.
-	fn lookup(s: Source) -> Option<Self::Target>;
+	fn lookup(s: Source) -> result::Result<Self::Target, &'static str>;
 }
 
 /// Simple payment making trait, operating on a single generic `AccountId` type.

substrate/runtime/staking/src/lib.rs

@@ -55,7 +55,7 @@ use runtime_support::{StorageValue, StorageMap, Parameter};
 use runtime_support::dispatch::Result;
 use primitives::traits::{Zero, One, Bounded, RefInto, SimpleArithmetic, Executable, MakePayment,
 	As, Lookup};
-use primitives::generic::Member;
+use primitives::generic::{Member, MaybeSerializeDebug};
 
 mod contract;
 #[cfg(test)]
@@ -67,78 +67,84 @@ const ENUM_SET_SIZE: usize = 64;
 /// The byte to identify intention to reclaim an existing account index.
 const RECLAIM_INDEX_MAGIC: usize = 0x69;
 
-/// A vetted and verified extrinsic from the external world.
-#[derive(PartialEq, Eq, Clone)]
-#[cfg_attr(feature = "std", derive(Serialize, Debug))]
-pub enum Address<AccountId, AccountIndex> where
- 	AccountId: Member,
- 	AccountIndex: Member,
-{
-	/// It's an account ID (pubkey).
-	Id(AccountId),
-	/// It's an account index.
-	Index(AccountIndex),
-}
-
-impl<AccountId, AccountIndex> From<AccountId> for Address<AccountId, AccountIndex> where
- 	AccountId: Member,
- 	AccountIndex: Member,
-{
-	fn from(a: AccountId) -> Self {
-		Address::Id(a)
+pub mod address {
+	use super::{Member, Slicable, As, Input};
+
+	/// A vetted and verified extrinsic from the external world.
+	#[derive(PartialEq, Eq, Clone)]
+	#[cfg_attr(feature = "std", derive(Serialize, Debug))]
+	pub enum Address<AccountId, AccountIndex> where
+	 	AccountId: Member,
+	 	AccountIndex: Member,
+	{
+		/// It's an account ID (pubkey).
+		Id(AccountId),
+		/// It's an account index.
+		Index(AccountIndex),
+	}
+
+	impl<AccountId, AccountIndex> From<AccountId> for Address<AccountId, AccountIndex> where
+	 	AccountId: Member,
+	 	AccountIndex: Member,
+	{
+		fn from(a: AccountId) -> Self {
+			Address::Id(a)
+		}
 	}
-}
 
-impl<AccountId, AccountIndex> Slicable for Address<AccountId, AccountIndex> where
-	AccountId: Member + Slicable,
-	AccountIndex: Member + Slicable + PartialOrd<AccountIndex> + Ord + As<u32> + As<u16> + As<u8> + Copy,
-{
-	fn decode<I: Input>(input: &mut I) -> Option<Self> {
-		match input.read_byte()? {
-			255 => Some(Address::Id(Slicable::decode(input)?)),
-			254 => Some(Address::Index(Slicable::decode(input)?)),
-			253 => Some(Address::Index(As::sa(u32::decode(input)?))),
-			252 => Some(Address::Index(As::sa(u16::decode(input)?))),
-			x => Some(Address::Index(As::sa(x))),
+	impl<AccountId, AccountIndex> Slicable for Address<AccountId, AccountIndex> where
+		AccountId: Member + Slicable,
+		AccountIndex: Member + Slicable + PartialOrd<AccountIndex> + Ord + As<u32> + As<u16> + As<u8> + Copy,
+	{
+		fn decode<I: Input>(input: &mut I) -> Option<Self> {
+			match input.read_byte()? {
+				255 => Some(Address::Id(Slicable::decode(input)?)),
+				254 => Some(Address::Index(Slicable::decode(input)?)),
+				253 => Some(Address::Index(As::sa(u32::decode(input)?))),
+				252 => Some(Address::Index(As::sa(u16::decode(input)?))),
+				x => Some(Address::Index(As::sa(x))),
+			}
 		}
-	}
 
-	fn encode(&self) -> Vec<u8> {
-		let mut v = Vec::new();
+		fn encode(&self) -> Vec<u8> {
+			let mut v = Vec::new();
 
-		match *self {
-			Address::Id(ref i) => {
-				v.push(255);
-				i.using_encoded(|s| v.extend(s));
-			}
-			Address::Index(i) if i > As::sa(0xffffffffu32) => {
-				v.push(254);
-				i.using_encoded(|s| v.extend(s));
-			}
-			Address::Index(i) if i > As::sa(0xffffu32) => {
-				v.push(253);
-				As::<u32>::as_(i).using_encoded(|s| v.extend(s));
-			}
-			Address::Index(i) if i >= As::sa(252u32) => {
-				v.push(252);
-				As::<u16>::as_(i).using_encoded(|s| v.extend(s));
+			match *self {
+				Address::Id(ref i) => {
+					v.push(255);
+					i.using_encoded(|s| v.extend(s));
+				}
+				Address::Index(i) if i > As::sa(0xffffffffu32) => {
+					v.push(254);
+					i.using_encoded(|s| v.extend(s));
+				}
+				Address::Index(i) if i > As::sa(0xffffu32) => {
+					v.push(253);
+					As::<u32>::as_(i).using_encoded(|s| v.extend(s));
+				}
+				Address::Index(i) if i >= As::sa(252u32) => {
+					v.push(252);
+					As::<u16>::as_(i).using_encoded(|s| v.extend(s));
+				}
+				Address::Index(i) => v.push(As::<u8>::as_(i)),
 			}
-			Address::Index(i) => v.push(As::<u8>::as_(i)),
-		}
 
-		v
+			v
+		}
 	}
-}
 
-impl<AccountId, AccountIndex> Default for Address<AccountId, AccountIndex> where
-	AccountId: Member + Default,
-	AccountIndex: Member,
-{
-	fn default() -> Self {
-		Address::Id(Default::default())
+	impl<AccountId, AccountIndex> Default for Address<AccountId, AccountIndex> where
+		AccountId: Member + Default,
+		AccountIndex: Member,
+	{
+		fn default() -> Self {
+			Address::Id(Default::default())
+		}
 	}
 }
 
+pub type Address<T> = address::Address<<T as system::Trait>::AccountId, <T as Trait>::AccountIndex>;
+
 #[cfg(test)]
 #[derive(Debug, PartialEq, Clone)]
 pub enum LockStatus<BlockNumber: Debug + PartialEq + Clone> {
@@ -171,7 +177,8 @@ impl<Hashing, AccountId> ContractAddressFor<AccountId> for Hashing where
 	}
 }
 
-pub trait Trait: system::Trait + session::Trait {
+// MaybeSerializeDebug is workaround for https://github.com/rust-lang/rust/issues/26925 . Remove when sorted.
+pub trait Trait: system::Trait + session::Trait + MaybeSerializeDebug {
 	/// The balance of an account.
 	type Balance: Parameter + SimpleArithmetic + Slicable + Default + Copy + As<Self::AccountIndex> + As<usize>;
 	/// Function type to get the contract address given the creator.
@@ -184,7 +191,7 @@ pub trait Trait: system::Trait + session::Trait {
 decl_module! {
 	pub struct Module<T: Trait>;
 	pub enum Call where aux: T::PublicAux {
-		fn transfer(aux, dest: Address<T::AccountId, T::AccountIndex>, value: T::Balance) -> Result = 0;
+		fn transfer(aux, dest: Address<T>, value: T::Balance) -> Result = 0;
 		fn stake(aux) -> Result = 1;
 		fn unstake(aux) -> Result = 2;
 	}
@@ -304,8 +311,8 @@ impl<T: Trait> Module<T> {
 
 	/// Transfer some unlocked staking balance to another staker.
 	/// TODO: probably want to state gas-limit and gas-price.
-	fn transfer(aux: &T::PublicAux, dest: Address<T::AccountId, T::AccountIndex>, value: T::Balance) -> Result {
-		let dest = Self::lookup(dest).ok_or("bad destination")?;
+	fn transfer(aux: &T::PublicAux, dest: Address<T>, value: T::Balance) -> Result {
+		let dest = Self::lookup(dest)?;
 		// commit anything that made it this far to storage
 		if let Some(commit) = Self::effect_transfer(aux.ref_into(), &dest, value, &DirectAccountDb)? {
 			<AccountDb<T>>::merge(&mut DirectAccountDb, commit);
@@ -573,17 +580,16 @@ impl<T: Trait> Executable for Module<T> {
 	}
 }
 
-impl<T: Trait> Lookup<Address<T::AccountId, T::AccountIndex>> for Module<T> {
+impl<T: Trait> Lookup<address::Address<T::AccountId, T::AccountIndex>> for Module<T> {
 	type Target = T::AccountId;
-	fn lookup(a: Address<T::AccountId, T::AccountIndex>) -> Option<T::AccountId> {
+	fn lookup(a: address::Address<T::AccountId, T::AccountIndex>) -> result::Result<T::AccountId, &'static str> {
 		match a {
-			Address::Id(i) => Some(i),
-			Address::Index(i) => <Module<T>>::lookup_index(i),
+			address::Address::Id(i) => Ok(i),
+			address::Address::Index(i) => <Module<T>>::lookup_index(i).ok_or("invalid account index"),
 		}
 	}
 }
 
-
 // Each identity's stake may be in one of three bondage states, given by an integer:
 // - n | n <= <CurrentEra<T>>::get(): inactive: free to be transferred.
 // - ~0: active: currently representing a validator.

substrate/runtime/system/src/lib.rs

@@ -35,7 +35,7 @@ extern crate safe_mix;
 
 use rstd::prelude::*;
 use runtime_io::Hashing;
-use primitives::traits::{self, CheckEqual, SimpleArithmetic, SimpleBitOps, Zero, One, Bounded};
+use primitives::traits::{self, CheckEqual, SimpleArithmetic, SimpleBitOps, Zero, One, Bounded, Lookup};
 use runtime_support::{StorageValue, StorageMap, Parameter};
 use safe_mix::TripletMix;
 
@@ -65,6 +65,8 @@ pub trait Trait {
 	type Hashing: Hashing<Output = Self::Hash>;
 	type Digest: Parameter + Default + traits::Digest;
 	type AccountId: Parameter + Ord + Default;
+	type Address: Parameter + Default;
+	type Lookup: Lookup<Self::Address, Target=Self::AccountId>;
 	type Header: traits::Header<Number = Self::BlockNumber, Hash = Self::Hash, Digest = Self::Digest>;
 }