1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

use parity_scale_codec::Codec;
use scale_info::StaticTypeInfo;
use sp_core::hexdisplay::HexDisplay;
use sp_runtime::{
	traits::{LookupError, StaticLookup},
	MultiAddress,
};
use sp_std::{fmt::Debug, marker::PhantomData};

/// A lookup implementation returning the `AccountId` from a `MultiAddress`.
pub struct EthereumCompatibleAccountIdLookup<AccountId, AccountIndex>(
	PhantomData<(AccountId, AccountIndex)>,
);
impl<AccountId, AccountIndex> StaticLookup
	for EthereumCompatibleAccountIdLookup<AccountId, AccountIndex>
where
	AccountId: Codec + Clone + PartialEq + Debug,
	AccountIndex: Codec + Clone + PartialEq + Debug,
	MultiAddress<AccountId, AccountIndex>: Codec + StaticTypeInfo,
{
	type Source = MultiAddress<AccountId, AccountIndex>;
	type Target = AccountId;
	fn lookup(x: Self::Source) -> Result<Self::Target, LookupError> {
		match x {
			MultiAddress::Id(i) => Ok(i),
			MultiAddress::Address20(acc20) => {
				log::debug!(target: "ETHEREUM", "lookup 0x{:?}", HexDisplay::from(&acc20));
				let mut buffer = [0u8; 32];
				buffer[12..].copy_from_slice(&acc20);
				let decoded = Self::Target::decode(&mut &buffer[..]).map_err(|_| LookupError)?;
				Ok(decoded)
			},
			_ => Err(LookupError),
		}
	}
	fn unlookup(x: Self::Target) -> Self::Source {
		// We are not converting back to 20 bytes since everywhere we are using Id
		MultiAddress::Id(x)
	}
}

#[cfg(test)]
mod tests {
	use crate::ethereum::EthereumCompatibleAccountIdLookup;
	use sp_core::{bytes::from_hex, crypto::AccountId32};
	use sp_runtime::{traits::StaticLookup, MultiAddress};

	#[test]
	fn address20_should_get_decoded_correctly() {
		let lookup =
			EthereumCompatibleAccountIdLookup::<AccountId32, ()>::lookup(MultiAddress::Address20(
				from_hex("0x19a701d23f0ee1748b5d5f883cb833943096c6c4")
					.expect("should convert")
					.try_into()
					.expect("invalid size"),
			));
		assert!(lookup.is_ok());

		let converted = lookup.unwrap();
		let expected = AccountId32::new(
			from_hex("0x00000000000000000000000019a701d23f0ee1748b5d5f883cb833943096c6c4")
				.expect("should convert")
				.try_into()
				.expect("invalid size"),
		);
		assert_eq!(converted, expected)
	}
}