More Extensible Multiaddress Format (paritytech#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

Author: shawntabrizi

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.

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]

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.
@@ -944,7 +944,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.

bin/node/testing/src/bench.rs

@@ -317,15 +317,15 @@ 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,
 							)
 						)
 					},
 					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,
 				}
 			}

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,
 			}
 		}

frame/indices/src/address.rs

@@ -21,24 +21,22 @@
 #![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
 };
 use frame_support::{Parameter, decl_module, decl_error, decl_event, decl_storage, ensure};
 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,24 +285,25 @@ 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> {
 		Self::lookup_address(a).ok_or(LookupError)
 	}
 
 	fn unlookup(a: Self::Target) -> Self::Source {
-		address::Address::Id(a)
+		MultiAddress::Id(a)
 	}
 }

frame/indices/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};
 

primitives/runtime/src/lib.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())
+	}
+}