feat: pallet_unified_accounts implementation

Cargo.toml

@@ -81,13 +81,14 @@ rlp = "0.5"
 tracing = "0.1.34"
 similar-asserts = { version = "1.1.0" }
 assert_matches = "1.3.0"
-libsecp256k1 = "0.7.0"
+libsecp256k1 = { version = "0.7.0", default-features = false }
 impl-trait-for-tuples = "0.2.2"
 slices = "0.2.0"
 derive_more = { version = "0.99" }
 proc-macro2 = "1.0"
 quote = "1.0"
 syn = { version = "1.0" }
+ethers = { version = "2.0.9", default_features = false }
 
 # Substrate
 # (wasm)
@@ -277,6 +278,7 @@ pallet-xc-asset-config = { path = "./pallets/xc-asset-config", default-features
 pallet-xvm = { path = "./pallets/xvm", default-features = false }
 pallet-xcm = { path = "./pallets/pallet-xcm", default-features = false }
 pallet-ethereum-checked = { path = "./pallets/ethereum-checked", default-features = false }
+pallet-account = { path = "./pallets/account", default-features = false }
 
 astar-primitives = { path = "./primitives", default-features = false }
 

pallets/account/Cargo.toml

@@ -0,0 +1,76 @@
+[package]
+name = "pallet-account"
+version = "0.1.0"
+description = "Pallet for mapping VM accounts with native accounts"
+authors.workspace = true
+edition.workspace = true
+homepage.workspace = true
+repository.workspace = true
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+libsecp256k1 = { workspace = true, optional = true, features = ["hmac", "static-context"] }
+log = { workspace = true }
+parity-scale-codec = { workspace = true }
+scale-info = { workspace = true }
+
+frame-support = { workspace = true }
+frame-system = { workspace = true }
+sp-core = { workspace = true }
+sp-io = { workspace = true }
+sp-runtime = { workspace = true }
+sp-std = { workspace = true }
+
+# Benchmarks
+frame-benchmarking = { workspace = true, optional = true }
+
+precompile-utils = { workspace = true }
+
+# frontier
+pallet-evm = { workspace = true }
+
+# Astar
+astar-primitives = { workspace = true }
+
+[dev-dependencies]
+ethers = { workspace = true }
+hex = { workspace = true }
+pallet-balances = { workspace = true }
+pallet-ethereum = { workspace = true }
+pallet-evm = { workspace = true }
+pallet-timestamp = { workspace = true }
+
+[features]
+default = ["std"]
+std = [
+	"hex/std",
+	"log/std",
+	"libsecp256k1",
+	"libsecp256k1/std",
+	"parity-scale-codec/std",
+	"scale-info/std",
+	"sp-std/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"frame-support/std",
+	"frame-system/std",
+	"astar-primitives/std",
+	"precompile-utils/std",
+	"pallet-evm/std",
+	"pallet-balances/std",
+	"pallet-timestamp/std",
+	"pallet-ethereum/std",
+]
+runtime-benchmarks = [
+	"libsecp256k1/hmac",
+	"frame-benchmarking",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+	"astar-primitives/runtime-benchmarks",
+	"pallet-ethereum/runtime-benchmarks",
+	"pallet-evm/runtime-benchmarks",
+]
+try-runtime = ["frame-support/try-runtime", "pallet-evm/try-runtime"]

pallets/account/src/benchmarking.rs

@@ -0,0 +1,78 @@
+// This file is part of Astar.
+
+// Copyright (C) 2019-2023 Stake Technologies Pte.Ltd.
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+// Astar is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Astar is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Astar. If not, see <http://www.gnu.org/licenses/>.
+
+#![cfg(feature = "runtime-benchmarks")]
+
+use super::*;
+use frame_benchmarking::v2::*;
+use frame_system::RawOrigin;
+
+/// Assert that the last event equals the provided one.
+fn assert_last_event<T: Config>(generic_event: <T as Config>::RuntimeEvent) {
+    frame_system::Pallet::<T>::assert_last_event(generic_event.into());
+}
+
+#[benchmarks(
+    where <<T as Config>::ClaimSignature as ClaimSignature>::Signature: IsType<[u8;65]>
+)]
+mod benchmarks {
+    use super::*;
+
+    #[benchmark]
+    fn claim_evm_account() {
+        let caller: T::AccountId = whitelisted_caller();
+        let eth_secret_key = libsecp256k1::SecretKey::parse(&[0xff; 32]).unwrap();
+        let evm_address = Pallet::<T>::eth_address(&eth_secret_key);
+        let signature = Pallet::<T>::eth_sign_prehash(
+            &T::ClaimSignature::build_signing_payload(&caller),
+            &eth_secret_key,
+        )
+        .into();
+
+        let caller_clone = caller.clone();
+
+        #[extrinsic_call]
+        _(RawOrigin::Signed(caller), evm_address, signature);
+
+        assert_last_event::<T>(
+            Event::<T>::AccountClaimed {
+                account_id: caller_clone,
+                evm_address,
+            }
+            .into(),
+        );
+    }
+
+    #[benchmark]
+    fn claim_default_evm_account() {
+        let caller: T::AccountId = whitelisted_caller();
+        let caller_clone = caller.clone();
+        let evm_address = T::DefaultAccountMapping::into_h160(caller.clone());
+
+        #[extrinsic_call]
+        _(RawOrigin::Signed(caller));
+
+        assert_last_event::<T>(
+            Event::<T>::AccountClaimed {
+                account_id: caller_clone,
+                evm_address,
+            }
+            .into(),
+        );
+    }
+}

pallets/account/src/impls.rs

@@ -0,0 +1,174 @@
+// This file is part of Astar.
+
+// Copyright (C) 2019-2023 Stake Technologies Pte.Ltd.
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+// Astar is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Astar is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Astar. If not, see <http://www.gnu.org/licenses/>.
+
+use astar_primitives::ethereum_checked::AccountMapping;
+use astar_primitives::evm::EvmAddress;
+use astar_primitives::AccountId;
+use frame_support::traits::OnKilledAccount;
+use frame_support::{pallet_prelude::*, traits::Get};
+use pallet_evm::AddressMapping;
+use precompile_utils::keccak256;
+use sp_core::{Hasher, H160, H256, U256};
+use sp_io::hashing::keccak_256;
+use sp_runtime::traits::{LookupError, StaticLookup, Zero};
+use sp_runtime::MultiAddress;
+use sp_std::marker::PhantomData;
+
+use crate::*;
+
+/// AddressManager implementation
+impl<T: Config> AddressManager<T::AccountId, EvmAddress> for Pallet<T> {
+    fn to_account_id(address: &EvmAddress) -> Option<T::AccountId> {
+        NativeAccounts::<T>::get(address)
+    }
+
+    fn to_account_id_or_default(address: &EvmAddress) -> T::AccountId {
+        NativeAccounts::<T>::get(address).unwrap_or_else(|| {
+            // fallback to default account_id
+            T::DefaultAddressMapping::into_account_id(address.clone())
+        })
+    }
+
+    fn to_default_account_id(address: &EvmAddress) -> T::AccountId {
+        T::DefaultAddressMapping::into_account_id(address.clone())
+    }
+
+    fn to_address(account_id: &T::AccountId) -> Option<EvmAddress> {
+        EvmAccounts::<T>::get(account_id)
+    }
+
+    fn to_address_or_default(account_id: &T::AccountId) -> EvmAddress {
+        EvmAccounts::<T>::get(account_id).unwrap_or_else(|| {
+            // fallback to default account_id
+            T::DefaultAccountMapping::into_h160(account_id.clone())
+        })
+    }
+
+    fn to_default_address(account_id: &T::AccountId) -> EvmAddress {
+        T::DefaultAccountMapping::into_h160(account_id.clone())
+    }
+}
+
+/// AccountMapping wrapper implementation over AddressManager
+impl<T: Config> AccountMapping<T::AccountId> for Pallet<T> {
+    fn into_h160(account: T::AccountId) -> H160 {
+        <Self as AddressManager<T::AccountId, EvmAddress>>::to_address_or_default(&account)
+    }
+}
+
+/// Hashed derive mapping for converting account id to evm address
+pub struct HashedAccountMapping<H>(sp_std::marker::PhantomData<H>);
+impl<H: Hasher<Out = H256>> AccountMapping<AccountId> for HashedAccountMapping<H> {
+    fn into_h160(account: AccountId) -> H160 {
+        let payload = (b"evm:", account);
+        H160::from_slice(&payload.using_encoded(H::hash)[0..20])
+    }
+}
+
+/// AddresstMapping wrapper implementation over AddressManager
+impl<T: Config> AddressMapping<T::AccountId> for Pallet<T> {
+    fn into_account_id(address: H160) -> T::AccountId {
+        <Self as AddressManager<T::AccountId, EvmAddress>>::to_account_id_or_default(&address)
+    }
+}
+
+/// OnKilledAccout hooks implementation for removing storage mapping
+/// for killed accounts
+pub struct KillAccountMapping<T>(PhantomData<T>);
+impl<T: Config> OnKilledAccount<T::AccountId> for KillAccountMapping<T> {
+    fn on_killed_account(who: &T::AccountId) {
+        // remove mapping created by `claim_account` or `get_or_create_evm_address`
+        if let Some(evm_addr) = EvmAccounts::<T>::get(who) {
+            NativeAccounts::<T>::remove(evm_addr);
+            EvmAccounts::<T>::remove(who);
+        }
+    }
+}
+
+/// A lookup implementation returning the `AccountId` from `MultiAddress::Address20` (EVM Address).
+impl<T: Config> StaticLookup for Pallet<T> {
+    type Source = MultiAddress<T::AccountId, ()>;
+    type Target = T::AccountId;
+
+    fn lookup(a: Self::Source) -> Result<Self::Target, LookupError> {
+        match a {
+            MultiAddress::Address20(i) => Ok(
+                <Self as AddressManager<T::AccountId, EvmAddress>>::to_account_id_or_default(
+                    &EvmAddress::from_slice(&i),
+                ),
+            ),
+            _ => Err(LookupError),
+        }
+    }
+
+    fn unlookup(a: Self::Target) -> Self::Source {
+        MultiAddress::Id(a)
+    }
+}
+
+/// EIP-712 compatible signature scheme for verifying ownership of EVM Address
+///
+/// Raw Data = Domain Separator + Type Hash + keccak256(AccountId)
+pub struct EIP712Signature<T: Config, ChainId: Get<u64>>(PhantomData<(T, ChainId)>);
+impl<T: Config, ChainId: Get<u64>> ClaimSignature for EIP712Signature<T, ChainId> {
+    type AccountId = T::AccountId;
+    /// EVM address type
+    type Address = EvmAddress;
+    /// A signature (a 512-bit value, plus 8 bits for recovery ID).
+    type Signature = [u8; 65];
+
+    fn build_signing_payload(who: &Self::AccountId) -> [u8; 32] {
+        let domain_separator = Self::build_domain_separator();
+        let args_hash = Self::build_args_hash(who);
+
+        let mut payload = b"\x19\x01".to_vec();
+        payload.extend_from_slice(&domain_separator);
+        payload.extend_from_slice(&args_hash);
+        keccak_256(&payload)
+    }
+
+    fn verify_signature(who: &Self::AccountId, sig: &Self::Signature) -> Option<EvmAddress> {
+        let payload_hash = Self::build_signing_payload(who);
+
+        sp_io::crypto::secp256k1_ecdsa_recover(sig, &payload_hash)
+            .map(|pubkey| H160::from(H256::from_slice(&keccak_256(&pubkey))))
+            .ok()
+    }
+}
+
+impl<T: Config, ChainId: Get<u64>> EIP712Signature<T, ChainId> {
+    /// TODO: minor, use hardcoded bytes, configurable via generics
+    fn build_domain_separator() -> [u8; 32] {
+        let mut hash =
+            keccak256!("EIP712Domain(string name,string version,uint256 chainId,bytes32 salt)")
+                .to_vec();
+        hash.extend_from_slice(&keccak256!("Astar EVM Claim")); // name
+        hash.extend_from_slice(&keccak256!("1")); // version
+        hash.extend_from_slice(&(<[u8; 32]>::from(U256::from(ChainId::get())))); // chain id
+        hash.extend_from_slice(
+            frame_system::Pallet::<T>::block_hash(T::BlockNumber::zero()).as_ref(),
+        ); // genesis block hash
+        keccak_256(hash.as_slice())
+    }
+
+    fn build_args_hash(account: &T::AccountId) -> [u8; 32] {
+        let mut args_hash = keccak256!("Claim(bytes substrateAddress)").to_vec();
+        args_hash.extend_from_slice(&keccak_256(&account.encode()));
+        keccak_256(args_hash.as_slice())
+    }
+}