diff --git a/substrate/bin/node-template/runtime/src/lib.rs b/substrate/bin/node-template/runtime/src/lib.rs
index d67a5bde964571336d19b26bae5737ed0c5d48c0..aadfd931cdb507598cbe2683c138c8d7661285f9 100644
--- a/substrate/bin/node-template/runtime/src/lib.rs
+++ b/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.
diff --git a/substrate/bin/node/executor/tests/basic.rs b/substrate/bin/node/executor/tests/basic.rs
index 723e3a7e4ba62fac313614d0dd2ee400cc9ad526..a48efaea2d6958632b72979cd467b8c4ba5fad65 100644
--- a/substrate/bin/node/executor/tests/basic.rs
+++ b/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]
diff --git a/substrate/bin/node/runtime/src/lib.rs b/substrate/bin/node/runtime/src/lib.rs
index bfa412e882031d24fc6195903d4d8646a051351e..3e08b2cf8a6f8408e80d0d3550dc8cca8c92047e 100644
--- a/substrate/bin/node/runtime/src/lib.rs
+++ b/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.
diff --git a/substrate/bin/node/testing/src/bench.rs b/substrate/bin/node/testing/src/bench.rs
index 153a52375c2a9a23d6bb46d34191c25f445beb78..32e4bab9773a5cfb8eba82272171da7b40180de8 100644
--- a/substrate/bin/node/testing/src/bench.rs
+++ b/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,
}
}
diff --git a/substrate/bin/node/testing/src/keyring.rs b/substrate/bin/node/testing/src/keyring.rs
index 3413748563633c2e24fda0e876ed3a34b3273b93..f0b8ff707294eb6bed32daf6d7fa18505b1c2333 100644
--- a/substrate/bin/node/testing/src/keyring.rs
+++ b/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,
}
}
diff --git a/substrate/frame/indices/src/address.rs b/substrate/frame/indices/src/address.rs
deleted file mode 100644
index 0fd89333813289d448f85e50cdf1002b8386e2db..0000000000000000000000000000000000000000
--- a/substrate/frame/indices/src/address.rs
+++ /dev/null
@@ -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][..]);
- }
-}
diff --git a/substrate/frame/indices/src/lib.rs b/substrate/frame/indices/src/lib.rs
index fd2eb956f9231f019d90db11393d55af9bc3791a..6d467aa67344510b480971f51a8e70301a17c5fd 100644
--- a/substrate/frame/indices/src/lib.rs
+++ b/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)
}
}
diff --git a/substrate/primitives/runtime/src/lib.rs b/substrate/primitives/runtime/src/lib.rs
index e6c707e906edce038a4495d6f56fbfde4e137f45..ccd50334af66006e261e03fcd91ee6e21330dadf 100644
--- a/substrate/primitives/runtime/src/lib.rs
+++ b/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};
diff --git a/substrate/primitives/runtime/src/multiaddress.rs b/substrate/primitives/runtime/src/multiaddress.rs
new file mode 100644
index 0000000000000000000000000000000000000000..bb352f7eb5f8ed74470dada90ebb7f828dac9bea
--- /dev/null
+++ b/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())
+ }
+}
diff --git a/substrate/primitives/runtime/src/traits.rs b/substrate/primitives/runtime/src/traits.rs
index 4d2b1f062f7168c701cfdacba939c0511bcc637d..4ce9ac0afa9a3990d63552acd7b7d5dabdd4acf0 100644
--- a/substrate/primitives/runtime/src/traits.rs
+++ b/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.