More Extensible Multiaddress Format (#7380)

* More extensible multiaddress format

* update name

* Don't depend on indices to define multiaddress type

* Use MultiAddress in Node Template too!

* reduce traits, fix build

* support multiple `StaticLookup`

* bump tx version

* feedback

substrate/bin/node-template/runtime/src/lib.rs

@@ -13,7 +13,7 @@ use sp_runtime::{
 	transaction_validity::{TransactionValidity, TransactionSource},
 };
 use sp_runtime::traits::{
-	BlakeTwo256, Block as BlockT, IdentityLookup, Verify, IdentifyAccount, NumberFor, Saturating,
+	BlakeTwo256, Block as BlockT, AccountIdLookup, Verify, IdentifyAccount, NumberFor, Saturating,
 };
 use sp_api::impl_runtime_apis;
 use sp_consensus_aura::sr25519::AuthorityId as AuraId;
@@ -148,7 +148,7 @@ impl frame_system::Trait for Runtime {
 	/// The aggregated dispatch type that is available for extrinsics.
 	type Call = Call;
 	/// The lookup mechanism to get account ID from whatever is passed in dispatchers.
-	type Lookup = IdentityLookup<AccountId>;
+	type Lookup = AccountIdLookup<AccountId, ()>;
 	/// The index type for storing how many extrinsics an account has signed.
 	type Index = Index;
 	/// The index type for blocks.
@@ -293,7 +293,7 @@ construct_runtime!(
 );
 
 /// The address format for describing accounts.
-pub type Address = AccountId;
+pub type Address = sp_runtime::MultiAddress<AccountId, ()>;
 /// Block header type as expected by this runtime.
 pub type Header = generic::Header<BlockNumber, BlakeTwo256>;
 /// Block type as expected by this runtime.

substrate/bin/node/executor/tests/basic.rs

@@ -621,7 +621,7 @@ fn deploying_wasm_contract_should_work() {
 				signed: Some((charlie(), signed_extra(2, 0))),
 				function: Call::Contracts(
 					pallet_contracts::Call::call::<Runtime>(
-						pallet_indices::address::Address::Id(addr.clone()),
+						sp_runtime::MultiAddress::Id(addr.clone()),
 						10,
 						500_000_000,
 						vec![0x00, 0x01, 0x02, 0x03]

substrate/bin/node/runtime/src/lib.rs

@@ -111,7 +111,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
 	spec_version: 260,
 	impl_version: 0,
 	apis: RUNTIME_API_VERSIONS,
-	transaction_version: 1,
+	transaction_version: 2,
 };
 
 /// Native version.
@@ -931,7 +931,7 @@ construct_runtime!(
 );
 
 /// The address format for describing accounts.
-pub type Address = <Indices as StaticLookup>::Source;
+pub type Address = sp_runtime::MultiAddress<AccountId, AccountIndex>;
 /// Block header type as expected by this runtime.
 pub type Header = generic::Header<BlockNumber, BlakeTwo256>;
 /// Block type as expected by this runtime.

substrate/bin/node/testing/src/bench.rs

@@ -317,7 +317,7 @@ impl<'a> Iterator for BlockContentIterator<'a> {
 					BlockType::RandomTransfersKeepAlive => {
 						Call::Balances(
 							BalancesCall::transfer_keep_alive(
-								pallet_indices::address::Address::Id(receiver),
+								sp_runtime::MultiAddress::Id(receiver),
 								node_runtime::ExistentialDeposit::get() + 1,
 							)
 						)
@@ -325,7 +325,7 @@ impl<'a> Iterator for BlockContentIterator<'a> {
 					BlockType::RandomTransfersReaping => {
 						Call::Balances(
 							BalancesCall::transfer(
-								pallet_indices::address::Address::Id(receiver),
+								sp_runtime::MultiAddress::Id(receiver),
 								// Transfer so that ending balance would be 1 less than existential deposit
 								// so that we kill the sender account.
 								100*DOLLARS - (node_runtime::ExistentialDeposit::get() - 1),
@@ -591,7 +591,7 @@ impl BenchKeyring {
 					}
 				}).into();
 				UncheckedExtrinsic {
-					signature: Some((pallet_indices::address::Address::Id(signed), signature, extra)),
+					signature: Some((sp_runtime::MultiAddress::Id(signed), signature, extra)),
 					function: payload.0,
 				}
 			}

substrate/bin/node/testing/src/keyring.rs

@@ -94,7 +94,7 @@ pub fn sign(xt: CheckedExtrinsic, spec_version: u32, tx_version: u32, genesis_ha
 				}
 			}).into();
 			UncheckedExtrinsic {
-				signature: Some((pallet_indices::address::Address::Id(signed), signature, extra)),
+				signature: Some((sp_runtime::MultiAddress::Id(signed), signature, extra)),
 				function: payload.0,
 			}
 		}

substrate/frame/indices/src/address.rs

@@ -1,159 +0,0 @@
-// This file is part of Substrate.
-
-// Copyright (C) 2017-2020 Parity Technologies (UK) Ltd.
-// SPDX-License-Identifier: Apache-2.0
-
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// 	http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-//! Address type that is union of index and id for an account.
-
-#[cfg(feature = "std")]
-use std::fmt;
-use sp_std::convert::TryInto;
-use crate::Member;
-use codec::{Encode, Decode, Input, Output, Error};
-
-/// An indices-aware address, which can be either a direct `AccountId` or
-/// an index.
-#[derive(PartialEq, Eq, Clone, sp_runtime::RuntimeDebug)]
-#[cfg_attr(feature = "std", derive(Hash))]
-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),
-}
-
-#[cfg(feature = "std")]
-impl<AccountId, AccountIndex> fmt::Display for Address<AccountId, AccountIndex> where
-	AccountId: Member,
-	AccountIndex: Member,
-{
-	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-		write!(f, "{:?}", self)
-	}
-}
-
-impl<AccountId, AccountIndex> From<AccountId> for Address<AccountId, AccountIndex> where
-	AccountId: Member,
-	AccountIndex: Member,
-{
-	fn from(a: AccountId) -> Self {
-		Address::Id(a)
-	}
-}
-
-fn need_more_than<T: PartialOrd>(a: T, b: T) -> Result<T, Error> {
-	if a < b { Ok(b) } else { Err("Invalid range".into()) }
-}
-
-impl<AccountId, AccountIndex> Decode for Address<AccountId, AccountIndex> where
-	AccountId: Member + Decode,
-	AccountIndex: Member + Decode + PartialOrd<AccountIndex> + Ord + From<u32> + Copy,
-{
-	fn decode<I: Input>(input: &mut I) -> Result<Self, Error> {
-		Ok(match input.read_byte()? {
-			x @ 0x00..=0xef => Address::Index(AccountIndex::from(x as u32)),
-			0xfc => Address::Index(AccountIndex::from(
-				need_more_than(0xef, u16::decode(input)?)? as u32
-			)),
-			0xfd => Address::Index(AccountIndex::from(
-				need_more_than(0xffff, u32::decode(input)?)?
-			)),
-			0xfe => Address::Index(
-				need_more_than(0xffffffffu32.into(), Decode::decode(input)?)?
-			),
-			0xff => Address::Id(Decode::decode(input)?),
-			_ => return Err("Invalid address variant".into()),
-		})
-	}
-}
-
-impl<AccountId, AccountIndex> Encode for Address<AccountId, AccountIndex> where
-	AccountId: Member + Encode,
-	AccountIndex: Member + Encode + PartialOrd<AccountIndex> + Ord + Copy + From<u32> + TryInto<u32>,
-{
-	fn encode_to<T: Output>(&self, dest: &mut T) {
-		match *self {
-			Address::Id(ref i) => {
-				dest.push_byte(255);
-				dest.push(i);
-			}
-			Address::Index(i) => {
-				let maybe_u32: Result<u32, _> = i.try_into();
-				if let Ok(x) = maybe_u32 {
-					if x > 0xffff {
-						dest.push_byte(253);
-						dest.push(&x);
-					}
-					else if x >= 0xf0 {
-						dest.push_byte(252);
-						dest.push(&(x as u16));
-					}
-					else {
-						dest.push_byte(x as u8);
-					}
-
-				} else {
-					dest.push_byte(254);
-					dest.push(&i);
-				}
-			},
-		}
-	}
-}
-
-impl<AccountId, AccountIndex> codec::EncodeLike for Address<AccountId, AccountIndex> where
-	AccountId: Member + Encode,
-	AccountIndex: Member + Encode + PartialOrd<AccountIndex> + Ord + Copy + From<u32> + TryInto<u32>,
-{}
-
-impl<AccountId, AccountIndex> Default for Address<AccountId, AccountIndex> where
-	AccountId: Member + Default,
-	AccountIndex: Member,
-{
-	fn default() -> Self {
-		Address::Id(Default::default())
-	}
-}
-
-#[cfg(test)]
-mod tests {
-	use codec::{Encode, Decode};
-
-	type Address = super::Address<[u8; 8], u32>;
-	fn index(i: u32) -> Address { super::Address::Index(i) }
-	fn id(i: [u8; 8]) -> Address { super::Address::Id(i) }
-
-	fn compare(a: Option<Address>, d: &[u8]) {
-		if let Some(ref a) = a {
-			assert_eq!(d, &a.encode()[..]);
-		}
-		assert_eq!(Address::decode(&mut &d[..]).ok(), a);
-	}
-
-	#[test]
-	fn it_should_work() {
-		compare(Some(index(2)), &[2][..]);
-		compare(None, &[240][..]);
-		compare(None, &[252, 239, 0][..]);
-		compare(Some(index(240)), &[252, 240, 0][..]);
-		compare(Some(index(304)), &[252, 48, 1][..]);
-		compare(None, &[253, 255, 255, 0, 0][..]);
-		compare(Some(index(0x10000)), &[253, 0, 0, 1, 0][..]);
-		compare(Some(id([42, 69, 42, 69, 42, 69, 42, 69])), &[255, 42, 69, 42, 69, 42, 69, 42, 69][..]);
-	}
-}

substrate/frame/indices/src/lib.rs

@@ -21,13 +21,13 @@
 #![cfg_attr(not(feature = "std"), no_std)]
 
 mod mock;
-pub mod address;
 mod tests;
 mod benchmarking;
 pub mod weights;
 
 use sp_std::prelude::*;
 use codec::Codec;
+use sp_runtime::MultiAddress;
 use sp_runtime::traits::{
 	StaticLookup, Member, LookupError, Zero, Saturating, AtLeast32Bit
 };
@@ -35,10 +35,8 @@ use frame_support::{Parameter, decl_module, decl_error, decl_event, decl_storage
 use frame_support::dispatch::DispatchResult;
 use frame_support::traits::{Currency, ReservableCurrency, Get, BalanceStatus::Reserved};
 use frame_system::{ensure_signed, ensure_root};
-use self::address::Address as RawAddress;
 pub use weights::WeightInfo;
 
-pub type Address<T> = RawAddress<<T as frame_system::Trait>::AccountId, <T as Trait>::AccountIndex>;
 type BalanceOf<T> = <<T as Trait>::Currency as Currency<<T as frame_system::Trait>::AccountId>>::Balance;
 
 /// The module's config trait.
@@ -287,17 +285,18 @@ impl<T: Trait> Module<T> {
 
 	/// Lookup an address to get an Id, if there's one there.
 	pub fn lookup_address(
-		a: address::Address<T::AccountId, T::AccountIndex>
+		a: MultiAddress<T::AccountId, T::AccountIndex>
 	) -> Option<T::AccountId> {
 		match a {
-			address::Address::Id(i) => Some(i),
-			address::Address::Index(i) => Self::lookup_index(i),
+			MultiAddress::Id(i) => Some(i),
+			MultiAddress::Index(i) => Self::lookup_index(i),
+			_ => None,
 		}
 	}
 }
 
 impl<T: Trait> StaticLookup for Module<T> {
-	type Source = address::Address<T::AccountId, T::AccountIndex>;
+	type Source = MultiAddress<T::AccountId, T::AccountIndex>;
 	type Target = T::AccountId;
 
 	fn lookup(a: Self::Source) -> Result<Self::Target, LookupError> {
@@ -305,6 +304,6 @@ impl<T: Trait> StaticLookup for Module<T> {
 	}
 
 	fn unlookup(a: Self::Target) -> Self::Source {
-		address::Address::Id(a)
+		MultiAddress::Id(a)
 	}
 }

substrate/primitives/runtime/src/lib.rs

@@ -56,9 +56,13 @@ pub mod traits;
 pub mod transaction_validity;
 pub mod random_number_generator;
 mod runtime_string;
+mod multiaddress;
 
 pub use crate::runtime_string::*;
 
+// Re-export Multiaddress
+pub use multiaddress::MultiAddress;
+
 /// Re-export these since they're only "kind of" generic.
 pub use generic::{DigestItem, Digest};
 

substrate/primitives/runtime/src/multiaddress.rs

@@ -0,0 +1,66 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2017-2020 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! MultiAddress type is a wrapper for multiple downstream account formats.
+
+use codec::{Encode, Decode};
+use sp_std::vec::Vec;
+
+/// A multi-format address wrapper for on-chain accounts.
+#[derive(Encode, Decode, PartialEq, Eq, Clone, crate::RuntimeDebug)]
+#[cfg_attr(feature = "std", derive(Hash))]
+pub enum MultiAddress<AccountId, AccountIndex> {
+	/// It's an account ID (pubkey).
+	Id(AccountId),
+	/// It's an account index.
+	Index(#[codec(compact)] AccountIndex),
+	/// It's some arbitrary raw bytes.
+	Raw(Vec<u8>),
+	/// It's a 32 byte representation.
+	Address32([u8; 32]),
+	/// Its a 20 byte representation.
+	Address20([u8; 20]),
+}
+
+#[cfg(feature = "std")]
+impl<AccountId, AccountIndex> std::fmt::Display for MultiAddress<AccountId, AccountIndex>
+where
+	AccountId: std::fmt::Debug,
+	AccountIndex: std::fmt::Debug,
+{
+	fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+		use sp_core::hexdisplay::HexDisplay;
+		match self {
+			MultiAddress::Raw(inner) => write!(f, "MultiAddress::Raw({})", HexDisplay::from(inner)),
+			MultiAddress::Address32(inner) => write!(f, "MultiAddress::Address32({})", HexDisplay::from(inner)),
+			MultiAddress::Address20(inner) => write!(f, "MultiAddress::Address20({})", HexDisplay::from(inner)),
+			_ => write!(f, "{:?}", self),
+		}
+	}
+}
+
+impl<AccountId, AccountIndex> From<AccountId> for MultiAddress<AccountId, AccountIndex> {
+	fn from(a: AccountId) -> Self {
+		MultiAddress::Id(a)
+	}
+}
+
+impl<AccountId: Default, AccountIndex> Default for MultiAddress<AccountId, AccountIndex> {
+	fn default() -> Self {
+		MultiAddress::Id(Default::default())
+	}
+}

substrate/primitives/runtime/src/traits.rs

@@ -209,6 +209,44 @@ impl<T> Lookup for IdentityLookup<T> {
 	fn lookup(&self, x: T) -> Result<T, LookupError> { Ok(x) }
 }
 
+/// A lookup implementation returning the `AccountId` from a `MultiAddress`.
+pub struct AccountIdLookup<AccountId, AccountIndex>(PhantomData<(AccountId, AccountIndex)>);
+impl<AccountId, AccountIndex> StaticLookup for AccountIdLookup<AccountId, AccountIndex>
+where
+	AccountId: Codec + Clone + PartialEq + Debug,
+	AccountIndex: Codec + Clone + PartialEq + Debug,
+	crate::MultiAddress<AccountId, AccountIndex>: Codec,
+{
+	type Source = crate::MultiAddress<AccountId, AccountIndex>;
+	type Target = AccountId;
+	fn lookup(x: Self::Source) -> Result<Self::Target, LookupError> {
+		match x {
+			crate::MultiAddress::Id(i) => Ok(i),
+			_ => Err(LookupError),
+		}
+	}
+	fn unlookup(x: Self::Target) -> Self::Source {
+		crate::MultiAddress::Id(x)
+	}
+}
+
+/// Perform a StaticLookup where there are multiple lookup sources of the same type.
+impl<A, B> StaticLookup for (A, B)
+where
+	A: StaticLookup,
+	B: StaticLookup<Source = A::Source, Target = A::Target>,
+{
+	type Source = A::Source;
+	type Target = A::Target;
+
+	fn lookup(x: Self::Source) -> Result<Self::Target, LookupError> {
+		A::lookup(x.clone()).or_else(|_| B::lookup(x))
+	}
+	fn unlookup(x: Self::Target) -> Self::Source {
+		A::unlookup(x)
+	}
+}
+
 /// Extensible conversion trait. Generic over both source and destination types.
 pub trait Convert<A, B> {
 	/// Make conversion.