diff --git a/cumulus/parachains/runtimes/assets/asset-hub-westend/src/lib.rs b/cumulus/parachains/runtimes/assets/asset-hub-westend/src/lib.rs
index 9a60de77a5844d7ff4bbf64942f98d7a3551ef69..adfa2b74df65dd3d1a31dd58cfe9a3a59e223de9 100644
--- a/cumulus/parachains/runtimes/assets/asset-hub-westend/src/lib.rs
+++ b/cumulus/parachains/runtimes/assets/asset-hub-westend/src/lib.rs
@@ -957,7 +957,7 @@ impl pallet_revive::Config for Runtime {
 	type WeightPrice = pallet_transaction_payment::Pallet<Self>;
 	type WeightInfo = pallet_revive::weights::SubstrateWeight<Self>;
 	type ChainExtension = ();
-	type AddressMapper = pallet_revive::DefaultAddressMapper;
+	type AddressMapper = pallet_revive::AccountId32Mapper<Self>;
 	type RuntimeMemory = ConstU32<{ 128 * 1024 * 1024 }>;
 	type PVFMemory = ConstU32<{ 512 * 1024 * 1024 }>;
 	type UnsafeUnstableInterface = ConstBool<false>;
diff --git a/prdoc/pr_6096.prdoc b/prdoc/pr_6096.prdoc
new file mode 100644
index 0000000000000000000000000000000000000000..c77c323a2e08cf9c45cca54e24866bc1ed9fc5be
--- /dev/null
+++ b/prdoc/pr_6096.prdoc
@@ -0,0 +1,15 @@
+title: 'pallet-revive: Add stateful address mapping'
+doc:
+- audience:
+  - Runtime Dev
+  description: |-
+    Fixes #5576
+
+    This allows contracts to be used with an AccountId32 through normal extrinsics and not only through the eth compat layer. It works by adding a new extrinsic `map_account` that lets people register their AccountId32.
+crates:
+- name: pallet-revive-fixtures
+  bump: minor
+- name: pallet-revive-mock-network
+  bump: patch
+- name: pallet-revive
+  bump: major
diff --git a/substrate/bin/node/runtime/src/lib.rs b/substrate/bin/node/runtime/src/lib.rs
index d6a17856e4704726883c611eb56daacb2b7c6c7b..89b5bf26ce75e8e4c22a3c2c0258d9499e6b40b3 100644
--- a/substrate/bin/node/runtime/src/lib.rs
+++ b/substrate/bin/node/runtime/src/lib.rs
@@ -1415,7 +1415,7 @@ impl pallet_revive::Config for Runtime {
 	type WeightPrice = pallet_transaction_payment::Pallet<Self>;
 	type WeightInfo = pallet_revive::weights::SubstrateWeight<Self>;
 	type ChainExtension = ();
-	type AddressMapper = pallet_revive::DefaultAddressMapper;
+	type AddressMapper = pallet_revive::AccountId32Mapper<Self>;
 	type RuntimeMemory = ConstU32<{ 128 * 1024 * 1024 }>;
 	type PVFMemory = ConstU32<{ 512 * 1024 * 1024 }>;
 	type UnsafeUnstableInterface = ConstBool<false>;
diff --git a/substrate/frame/revive/fixtures/contracts/locking_delegate_dependency.rs b/substrate/frame/revive/fixtures/contracts/locking_delegate_dependency.rs
index 2efacb4e683ffedbe1dce29b07130fd2b26fed87..54c7c7f3d5e20ddd9c995dd7f360028cac61409d 100644
--- a/substrate/frame/revive/fixtures/contracts/locking_delegate_dependency.rs
+++ b/substrate/frame/revive/fixtures/contracts/locking_delegate_dependency.rs
@@ -23,7 +23,7 @@
 use common::input;
 use uapi::{HostFn, HostFnImpl as api};
 
-const ETH_ALICE: [u8; 20] = [1u8; 20];
+const ALICE_FALLBACK: [u8; 20] = [1u8; 20];
 
 /// Load input data and perform the action specified by the input.
 /// If `delegate_call` is true, then delegate call into the contract.
@@ -44,7 +44,7 @@ fn load_input(delegate_call: bool) {
 		},
 		// 3 = Terminate
 		3 => {
-			api::terminate(&ETH_ALICE);
+			api::terminate(&ALICE_FALLBACK);
 		},
 		// Everything else is a noop
 		_ => {},
diff --git a/substrate/frame/revive/fixtures/contracts/self_destruct.rs b/substrate/frame/revive/fixtures/contracts/self_destruct.rs
index 524979991ec7ab1020073d48022d773ca809c3b8..2f37706634bd126f465ce6ea579cc0878d951bdd 100644
--- a/substrate/frame/revive/fixtures/contracts/self_destruct.rs
+++ b/substrate/frame/revive/fixtures/contracts/self_destruct.rs
@@ -21,7 +21,7 @@
 use common::input;
 use uapi::{HostFn, HostFnImpl as api};
 
-const ETH_DJANGO: [u8; 20] = [4u8; 20];
+const DJANGO_FALLBACK: [u8; 20] = [4u8; 20];
 
 #[no_mangle]
 #[polkavm_derive::polkavm_export]
@@ -52,6 +52,6 @@ pub extern "C" fn call() {
 		.unwrap();
 	} else {
 		// Try to terminate and give balance to django.
-		api::terminate(&ETH_DJANGO);
+		api::terminate(&DJANGO_FALLBACK);
 	}
 }
diff --git a/substrate/frame/revive/fixtures/contracts/terminate_and_send_to_eve.rs b/substrate/frame/revive/fixtures/contracts/terminate_and_send_to_eve.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c078f9d46c1d71bfe079051bd34a2d01eb270328
--- /dev/null
+++ b/substrate/frame/revive/fixtures/contracts/terminate_and_send_to_eve.rs
@@ -0,0 +1,33 @@
+// This file is part of Substrate.
+
+// Copyright (C) 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.
+
+#![no_std]
+#![no_main]
+
+extern crate common;
+use uapi::{HostFn, HostFnImpl as api};
+
+#[no_mangle]
+#[polkavm_derive::polkavm_export]
+pub extern "C" fn deploy() {}
+
+#[no_mangle]
+#[polkavm_derive::polkavm_export]
+pub extern "C" fn call() {
+	let eve = [5u8; 20];
+	api::terminate(&eve);
+}
diff --git a/substrate/frame/revive/mock-network/src/parachain/contracts_config.rs b/substrate/frame/revive/mock-network/src/parachain/contracts_config.rs
index c13c337d1667077301acef8a8e5d8e5537bc60f1..a2fa7cbf706811657f35c51dde2d473ff759f652 100644
--- a/substrate/frame/revive/mock-network/src/parachain/contracts_config.rs
+++ b/substrate/frame/revive/mock-network/src/parachain/contracts_config.rs
@@ -20,7 +20,7 @@ use frame_support::derive_impl;
 
 #[derive_impl(pallet_revive::config_preludes::TestDefaultConfig)]
 impl pallet_revive::Config for Runtime {
-	type AddressMapper = pallet_revive::DefaultAddressMapper;
+	type AddressMapper = pallet_revive::AccountId32Mapper<Self>;
 	type Currency = Balances;
 	type Time = super::Timestamp;
 	type Xcm = pallet_xcm::Pallet<Self>;
diff --git a/substrate/frame/revive/src/address.rs b/substrate/frame/revive/src/address.rs
index 4633fce1f32718e4a6e5d5355190681f8c3d2fc0..45b5bf822dc91dd94691c00425d6c3ef3f826a2f 100644
--- a/substrate/frame/revive/src/address.rs
+++ b/substrate/frame/revive/src/address.rs
@@ -17,61 +17,173 @@
 
 //! Functions that deal contract addresses.
 
+use crate::{ensure, AddressSuffix, Config, Error, HoldReason};
 use alloc::vec::Vec;
-use sp_core::H160;
+use core::marker::PhantomData;
+use frame_support::traits::{fungible::MutateHold, tokens::Precision};
+use sp_core::{Get, H160};
 use sp_io::hashing::keccak_256;
-use sp_runtime::AccountId32;
+use sp_runtime::{AccountId32, DispatchResult, SaturatedConversion, Saturating};
 
 /// Map between the native chain account id `T` and an Ethereum [`H160`].
 ///
 /// This trait exists only to emulate specialization for different concrete
 /// native account ids. **Not** to make the mapping user configurable. Hence
-/// the trait is `Sealed` and only one mandatory implementor [`DefaultAddressMapper`]
-/// exists.
+/// the trait is `Sealed` and depending on your runtime configuration you need
+/// to pick either [`AccountId32Mapper`] or [`H160Mapper`]. Picking the wrong
+/// one will result in a compilation error. No footguns here.
 ///
 /// Please note that we assume that the native account is at least 20 bytes and
 /// only implement this type for a `T` where this is the case. Luckily, this is the
-/// case for all existing runtimes as of right now. Reasing is that this will allow
+/// case for all existing runtimes as of right now. Reasoning is that this will allow
 /// us to reverse an address -> account_id mapping by just stripping the prefix.
-pub trait AddressMapper<T>: private::Sealed {
-	/// Convert an account id to an ethereum address.
-	///
-	/// This mapping is **not** required to be reversible.
-	fn to_address(account_id: &T) -> H160;
+///
+/// We require the mapping to be reversible. Since we are potentially dealing with types of
+/// different sizes one direction of the mapping is necessarily lossy. This requires the mapping to
+/// make use of the [`AddressSuffix`] storage item to reverse the mapping.
+pub trait AddressMapper<T: Config>: private::Sealed {
+	/// Convert an account id to an ethereum adress.
+	fn to_address(account_id: &T::AccountId) -> H160;
 
 	/// Convert an ethereum address to a native account id.
+	fn to_account_id(address: &H160) -> T::AccountId;
+
+	/// Same as [`Self::to_account_id`] but always returns the fallback account.
+	///
+	/// This skips the query into [`AddressSuffix`] and always returns the stateless
+	/// fallback account. This is useful when we know for a fact that the `address`
+	/// in question is originally a `H160`. This is usually only the case when we
+	/// generated a new contract address.
+	fn to_fallback_account_id(address: &H160) -> T::AccountId;
+
+	/// Create a stateful mapping for `account_id`
+	///
+	/// This will enable `to_account_id` to map back to the original
+	/// `account_id` instead of the fallback account id.
+	fn map(account_id: &T::AccountId) -> DispatchResult;
+
+	/// Remove the mapping in order to reclaim the deposit.
 	///
-	/// This mapping is **required** to be reversible.
-	fn to_account_id(address: &H160) -> T;
+	/// There is no reason why one would unmap their `account_id` except
+	/// for reclaiming the deposit.
+	fn unmap(account_id: &T::AccountId) -> DispatchResult;
 
-	/// Same as [`Self::to_account_id`] but when we know the address is a contract.
+	/// Returns true if the `account_id` is useable as an origin.
 	///
-	/// This is only the case when we just generated the new address.
-	fn to_account_id_contract(address: &H160) -> T;
+	/// This means either the `account_id` doesn't require a stateful mapping
+	/// or a stateful mapping exists.
+	fn is_mapped(account_id: &T::AccountId) -> bool;
 }
 
 mod private {
 	pub trait Sealed {}
-	impl Sealed for super::DefaultAddressMapper {}
+	impl<T> Sealed for super::AccountId32Mapper<T> {}
+	impl<T> Sealed for super::H160Mapper<T> {}
 }
 
-/// The only implementor for `AddressMapper`.
-pub enum DefaultAddressMapper {}
+/// The mapper to be used if the account id is `AccountId32`.
+///
+/// It converts between addresses by either truncating the last 12 bytes or
+/// suffixing them. The suffix is queried from [`AddressSuffix`] and will fall
+/// back to all `0xEE` if no suffix was registered. This means contracts and
+/// plain wallets controlled by an `secp256k1` always have a `0xEE` suffixed
+/// account.
+pub struct AccountId32Mapper<T>(PhantomData<T>);
+
+/// The mapper to be used if the account id is `H160`.
+///
+/// It just trivially returns its inputs and doesn't make use of any state.
+pub struct H160Mapper<T>(PhantomData<T>);
 
-impl AddressMapper<AccountId32> for DefaultAddressMapper {
+impl<T> AddressMapper<T> for AccountId32Mapper<T>
+where
+	T: Config<AccountId = AccountId32>,
+{
 	fn to_address(account_id: &AccountId32) -> H160 {
 		H160::from_slice(&<AccountId32 as AsRef<[u8; 32]>>::as_ref(&account_id)[..20])
 	}
 
 	fn to_account_id(address: &H160) -> AccountId32 {
+		if let Some(suffix) = <AddressSuffix<T>>::get(address) {
+			let mut account_id = Self::to_fallback_account_id(address);
+			let account_bytes: &mut [u8; 32] = account_id.as_mut();
+			account_bytes[20..].copy_from_slice(suffix.as_slice());
+			account_id
+		} else {
+			Self::to_fallback_account_id(address)
+		}
+	}
+
+	fn to_fallback_account_id(address: &H160) -> AccountId32 {
 		let mut account_id = AccountId32::new([0xEE; 32]);
-		<AccountId32 as AsMut<[u8; 32]>>::as_mut(&mut account_id)[..20]
-			.copy_from_slice(address.as_bytes());
+		let account_bytes: &mut [u8; 32] = account_id.as_mut();
+		account_bytes[..20].copy_from_slice(address.as_bytes());
 		account_id
 	}
 
-	fn to_account_id_contract(address: &H160) -> AccountId32 {
-		Self::to_account_id(address)
+	fn map(account_id: &T::AccountId) -> DispatchResult {
+		ensure!(!Self::is_mapped(account_id), <Error<T>>::AccountAlreadyMapped);
+
+		let account_bytes: &[u8; 32] = account_id.as_ref();
+
+		// each mapping entry stores one AccountId32 distributed between key and value
+		let deposit = T::DepositPerByte::get()
+			.saturating_mul(account_bytes.len().saturated_into())
+			.saturating_add(T::DepositPerItem::get());
+
+		let suffix: [u8; 12] = account_bytes[20..]
+			.try_into()
+			.expect("Skipping 20 byte of a an 32 byte array will fit into 12 bytes; qed");
+		T::Currency::hold(&HoldReason::AddressMapping.into(), account_id, deposit)?;
+		<AddressSuffix<T>>::insert(Self::to_address(account_id), suffix);
+		Ok(())
+	}
+
+	fn unmap(account_id: &T::AccountId) -> DispatchResult {
+		// will do nothing if address is not mapped so no check required
+		<AddressSuffix<T>>::remove(Self::to_address(account_id));
+		T::Currency::release_all(
+			&HoldReason::AddressMapping.into(),
+			account_id,
+			Precision::BestEffort,
+		)?;
+		Ok(())
+	}
+
+	fn is_mapped(account_id: &T::AccountId) -> bool {
+		let account_bytes: &[u8; 32] = account_id.as_ref();
+		&account_bytes[20..] == &[0xEE; 12] ||
+			<AddressSuffix<T>>::contains_key(Self::to_address(account_id))
+	}
+}
+
+impl<T> AddressMapper<T> for H160Mapper<T>
+where
+	T: Config,
+	crate::AccountIdOf<T>: AsRef<[u8; 20]> + From<H160>,
+{
+	fn to_address(account_id: &T::AccountId) -> H160 {
+		H160::from_slice(account_id.as_ref())
+	}
+
+	fn to_account_id(address: &H160) -> T::AccountId {
+		Self::to_fallback_account_id(address)
+	}
+
+	fn to_fallback_account_id(address: &H160) -> T::AccountId {
+		(*address).into()
+	}
+
+	fn map(_account_id: &T::AccountId) -> DispatchResult {
+		Ok(())
+	}
+
+	fn unmap(_account_id: &T::AccountId) -> DispatchResult {
+		Ok(())
+	}
+
+	fn is_mapped(_account_id: &T::AccountId) -> bool {
+		true
 	}
 }
 
@@ -102,7 +214,16 @@ pub fn create2(deployer: &H160, code: &[u8], input_data: &[u8], salt: &[u8; 32])
 #[cfg(test)]
 mod test {
 	use super::*;
-	use crate::test_utils::ALICE_ADDR;
+	use crate::{
+		test_utils::*,
+		tests::{ExtBuilder, Test},
+		AddressMapper, Error,
+	};
+	use frame_support::{
+		assert_err,
+		traits::fungible::{InspectHold, Mutate},
+	};
+	use pretty_assertions::assert_eq;
 	use sp_core::{hex2array, H160};
 
 	#[test]
@@ -125,4 +246,123 @@ mod test {
 			H160(hex2array!("7f31e795e5836a19a8f919ab5a9de9a197ecd2b6")),
 		)
 	}
+
+	#[test]
+	fn fallback_map_works() {
+		assert!(<Test as Config>::AddressMapper::is_mapped(&ALICE));
+		assert_eq!(
+			ALICE_FALLBACK,
+			<Test as Config>::AddressMapper::to_fallback_account_id(&ALICE_ADDR)
+		);
+		assert_eq!(ALICE_ADDR, <Test as Config>::AddressMapper::to_address(&ALICE_FALLBACK));
+	}
+
+	#[test]
+	fn map_works() {
+		ExtBuilder::default().build().execute_with(|| {
+			<Test as Config>::Currency::set_balance(&EVE, 1_000_000);
+			// before mapping the fallback account is returned
+			assert!(!<Test as Config>::AddressMapper::is_mapped(&EVE));
+			assert_eq!(EVE_FALLBACK, <Test as Config>::AddressMapper::to_account_id(&EVE_ADDR));
+			assert_eq!(
+				<Test as Config>::Currency::balance_on_hold(
+					&HoldReason::AddressMapping.into(),
+					&EVE
+				),
+				0
+			);
+
+			// when mapped the full account id is returned
+			<Test as Config>::AddressMapper::map(&EVE).unwrap();
+			assert!(<Test as Config>::AddressMapper::is_mapped(&EVE));
+			assert_eq!(EVE, <Test as Config>::AddressMapper::to_account_id(&EVE_ADDR));
+			assert!(
+				<Test as Config>::Currency::balance_on_hold(
+					&HoldReason::AddressMapping.into(),
+					&EVE
+				) > 0
+			);
+		});
+	}
+
+	#[test]
+	fn map_fallback_account_fails() {
+		ExtBuilder::default().build().execute_with(|| {
+			assert!(<Test as Config>::AddressMapper::is_mapped(&ALICE));
+			// alice is an e suffixed account and hence cannot be mapped
+			assert_err!(
+				<Test as Config>::AddressMapper::map(&ALICE),
+				<Error<Test>>::AccountAlreadyMapped,
+			);
+			assert_eq!(
+				<Test as Config>::Currency::balance_on_hold(
+					&HoldReason::AddressMapping.into(),
+					&ALICE
+				),
+				0
+			);
+		});
+	}
+
+	#[test]
+	fn double_map_fails() {
+		ExtBuilder::default().build().execute_with(|| {
+			assert!(!<Test as Config>::AddressMapper::is_mapped(&EVE));
+			<Test as Config>::Currency::set_balance(&EVE, 1_000_000);
+			<Test as Config>::AddressMapper::map(&EVE).unwrap();
+			assert!(<Test as Config>::AddressMapper::is_mapped(&EVE));
+			let deposit = <Test as Config>::Currency::balance_on_hold(
+				&HoldReason::AddressMapping.into(),
+				&EVE,
+			);
+			assert_err!(
+				<Test as Config>::AddressMapper::map(&EVE),
+				<Error<Test>>::AccountAlreadyMapped,
+			);
+			assert!(<Test as Config>::AddressMapper::is_mapped(&EVE));
+			assert_eq!(
+				<Test as Config>::Currency::balance_on_hold(
+					&HoldReason::AddressMapping.into(),
+					&EVE
+				),
+				deposit
+			);
+		});
+	}
+
+	#[test]
+	fn unmap_works() {
+		ExtBuilder::default().build().execute_with(|| {
+			<Test as Config>::Currency::set_balance(&EVE, 1_000_000);
+			<Test as Config>::AddressMapper::map(&EVE).unwrap();
+			assert!(<Test as Config>::AddressMapper::is_mapped(&EVE));
+			assert!(
+				<Test as Config>::Currency::balance_on_hold(
+					&HoldReason::AddressMapping.into(),
+					&EVE
+				) > 0
+			);
+
+			<Test as Config>::AddressMapper::unmap(&EVE).unwrap();
+			assert!(!<Test as Config>::AddressMapper::is_mapped(&EVE));
+			assert_eq!(
+				<Test as Config>::Currency::balance_on_hold(
+					&HoldReason::AddressMapping.into(),
+					&EVE
+				),
+				0
+			);
+
+			// another unmap is a noop
+			<Test as Config>::AddressMapper::unmap(&EVE).unwrap();
+			assert!(!<Test as Config>::AddressMapper::is_mapped(&EVE));
+			assert_eq!(
+				<Test as Config>::Currency::balance_on_hold(
+					&HoldReason::AddressMapping.into(),
+					&EVE
+				),
+				0
+			);
+		});
+	}
 }
diff --git a/substrate/frame/revive/src/benchmarking/mod.rs b/substrate/frame/revive/src/benchmarking/mod.rs
index ebafb6c7054ae7c1208c819f9533eca328d06134..8c9bf2cf70f0201539658e0b2495c243455d630b 100644
--- a/substrate/frame/revive/src/benchmarking/mod.rs
+++ b/substrate/frame/revive/src/benchmarking/mod.rs
@@ -63,6 +63,7 @@ const UNBALANCED_TRIE_LAYERS: u32 = 20;
 struct Contract<T: Config> {
 	caller: T::AccountId,
 	account_id: T::AccountId,
+	address: H160,
 }
 
 impl<T> Contract<T>
@@ -71,11 +72,6 @@ where
 	BalanceOf<T>: Into<U256> + TryFrom<U256>,
 	MomentOf<T>: Into<U256>,
 {
-	/// Returns the address of the contract.
-	fn address(&self) -> H160 {
-		T::AddressMapper::to_address(&self.account_id)
-	}
-
 	/// Create new contract and use a default account id as instantiator.
 	fn new(module: WasmModule, data: Vec<u8>) -> Result<Contract<T>, &'static str> {
 		Self::with_index(0, module, data)
@@ -98,9 +94,12 @@ where
 	) -> Result<Contract<T>, &'static str> {
 		T::Currency::set_balance(&caller, caller_funding::<T>());
 		let salt = Some([0xffu8; 32]);
+		let origin: T::RuntimeOrigin = RawOrigin::Signed(caller.clone()).into();
+
+		Contracts::<T>::map_account(origin.clone()).unwrap();
 
 		let outcome = Contracts::<T>::bare_instantiate(
-			RawOrigin::Signed(caller.clone()).into(),
+			origin,
 			0u32.into(),
 			Weight::MAX,
 			default_deposit_limit::<T>(),
@@ -112,8 +111,8 @@ where
 		);
 
 		let address = outcome.result?.addr;
-		let account_id = T::AddressMapper::to_account_id_contract(&address);
-		let result = Contract { caller, account_id: account_id.clone() };
+		let account_id = T::AddressMapper::to_fallback_account_id(&address);
+		let result = Contract { caller, address, account_id };
 
 		ContractInfoOf::<T>::insert(&address, result.info()?);
 
@@ -143,7 +142,7 @@ where
 			info.write(&Key::Fix(item.0), Some(item.1.clone()), None, false)
 				.map_err(|_| "Failed to write storage to restoration dest")?;
 		}
-		<ContractInfoOf<T>>::insert(T::AddressMapper::to_address(&self.account_id), info);
+		<ContractInfoOf<T>>::insert(&self.address, info);
 		Ok(())
 	}
 
@@ -223,6 +222,7 @@ fn default_deposit_limit<T: Config>() -> BalanceOf<T> {
 		T: Config + pallet_balances::Config,
 		MomentOf<T>: Into<U256>,
 		<T as frame_system::Config>::RuntimeEvent: From<pallet::Event<T>>,
+		<T as Config>::RuntimeCall: From<frame_system::Call<T>>,
 		<pallet_balances::Pallet<T> as Currency<T::AccountId>>::Balance: From<BalanceOf<T>>,
 )]
 mod benchmarks {
@@ -263,13 +263,12 @@ mod benchmarks {
 		let instance =
 			Contract::<T>::with_caller(whitelisted_caller(), WasmModule::sized(c), vec![])?;
 		let value = Pallet::<T>::min_balance();
-		let callee = T::AddressMapper::to_address(&instance.account_id);
 		let storage_deposit = default_deposit_limit::<T>();
 
 		#[extrinsic_call]
 		call(
 			RawOrigin::Signed(instance.caller.clone()),
-			callee,
+			instance.address,
 			value,
 			Weight::MAX,
 			storage_deposit,
@@ -293,9 +292,10 @@ mod benchmarks {
 		T::Currency::set_balance(&caller, caller_funding::<T>());
 		let WasmModule { code, .. } = WasmModule::sized(c);
 		let origin = RawOrigin::Signed(caller.clone());
+		Contracts::<T>::map_account(origin.clone().into()).unwrap();
 		let deployer = T::AddressMapper::to_address(&caller);
 		let addr = crate::address::create2(&deployer, &code, &input, &salt);
-		let account_id = T::AddressMapper::to_account_id_contract(&addr);
+		let account_id = T::AddressMapper::to_fallback_account_id(&addr);
 		let storage_deposit = default_deposit_limit::<T>();
 		#[extrinsic_call]
 		_(origin, value, Weight::MAX, storage_deposit, code, input, Some(salt));
@@ -305,9 +305,14 @@ mod benchmarks {
 		// uploading the code reserves some balance in the callers account
 		let code_deposit =
 			T::Currency::balance_on_hold(&HoldReason::CodeUploadDepositReserve.into(), &caller);
+		let mapping_deposit =
+			T::Currency::balance_on_hold(&HoldReason::AddressMapping.into(), &caller);
 		assert_eq!(
 			T::Currency::balance(&caller),
-			caller_funding::<T>() - value - deposit - code_deposit - Pallet::<T>::min_balance(),
+			caller_funding::<T>() -
+				value - deposit -
+				code_deposit - mapping_deposit -
+				Pallet::<T>::min_balance(),
 		);
 		// contract has the full value
 		assert_eq!(T::Currency::balance(&account_id), value + Pallet::<T>::min_balance());
@@ -323,33 +328,31 @@ mod benchmarks {
 		let caller = whitelisted_caller();
 		T::Currency::set_balance(&caller, caller_funding::<T>());
 		let origin = RawOrigin::Signed(caller.clone());
+		Contracts::<T>::map_account(origin.clone().into()).unwrap();
 		let WasmModule { code, .. } = WasmModule::dummy();
 		let storage_deposit = default_deposit_limit::<T>();
 		let deployer = T::AddressMapper::to_address(&caller);
 		let addr = crate::address::create2(&deployer, &code, &input, &salt);
-		let hash =
-			Contracts::<T>::bare_upload_code(origin.into(), code, storage_deposit)?.code_hash;
-		let account_id = T::AddressMapper::to_account_id_contract(&addr);
+		let hash = Contracts::<T>::bare_upload_code(origin.clone().into(), code, storage_deposit)?
+			.code_hash;
+		let account_id = T::AddressMapper::to_fallback_account_id(&addr);
 
 		#[extrinsic_call]
-		_(
-			RawOrigin::Signed(caller.clone()),
-			value,
-			Weight::MAX,
-			storage_deposit,
-			hash,
-			input,
-			Some(salt),
-		);
+		_(origin, value, Weight::MAX, storage_deposit, hash, input, Some(salt));
 
 		let deposit =
 			T::Currency::balance_on_hold(&HoldReason::StorageDepositReserve.into(), &account_id);
 		let code_deposit =
 			T::Currency::balance_on_hold(&HoldReason::CodeUploadDepositReserve.into(), &account_id);
+		let mapping_deposit =
+			T::Currency::balance_on_hold(&HoldReason::AddressMapping.into(), &account_id);
 		// value was removed from the caller
 		assert_eq!(
 			T::Currency::total_balance(&caller),
-			caller_funding::<T>() - value - deposit - code_deposit - Pallet::<T>::min_balance(),
+			caller_funding::<T>() -
+				value - deposit -
+				code_deposit - mapping_deposit -
+				Pallet::<T>::min_balance(),
 		);
 		// contract has the full value
 		assert_eq!(T::Currency::balance(&account_id), value + Pallet::<T>::min_balance());
@@ -371,11 +374,10 @@ mod benchmarks {
 			Contract::<T>::with_caller(whitelisted_caller(), WasmModule::dummy(), vec![])?;
 		let value = Pallet::<T>::min_balance();
 		let origin = RawOrigin::Signed(instance.caller.clone());
-		let callee = T::AddressMapper::to_address(&instance.account_id);
 		let before = T::Currency::balance(&instance.account_id);
 		let storage_deposit = default_deposit_limit::<T>();
 		#[extrinsic_call]
-		_(origin, callee, value, Weight::MAX, storage_deposit, data);
+		_(origin, instance.address, value, Weight::MAX, storage_deposit, data);
 		let deposit = T::Currency::balance_on_hold(
 			&HoldReason::StorageDepositReserve.into(),
 			&instance.account_id,
@@ -384,10 +386,15 @@ mod benchmarks {
 			&HoldReason::CodeUploadDepositReserve.into(),
 			&instance.caller,
 		);
+		let mapping_deposit =
+			T::Currency::balance_on_hold(&HoldReason::AddressMapping.into(), &instance.caller);
 		// value and value transferred via call should be removed from the caller
 		assert_eq!(
 			T::Currency::balance(&instance.caller),
-			caller_funding::<T>() - value - deposit - code_deposit - Pallet::<T>::min_balance(),
+			caller_funding::<T>() -
+				value - deposit -
+				code_deposit - mapping_deposit -
+				Pallet::<T>::min_balance()
 		);
 		// contract should have received the value
 		assert_eq!(T::Currency::balance(&instance.account_id), before + value);
@@ -447,14 +454,46 @@ mod benchmarks {
 		let storage_deposit = default_deposit_limit::<T>();
 		let hash =
 			<Contracts<T>>::bare_upload_code(origin.into(), code, storage_deposit)?.code_hash;
-		let callee = T::AddressMapper::to_address(&instance.account_id);
 		assert_ne!(instance.info()?.code_hash, hash);
 		#[extrinsic_call]
-		_(RawOrigin::Root, callee, hash);
+		_(RawOrigin::Root, instance.address, hash);
 		assert_eq!(instance.info()?.code_hash, hash);
 		Ok(())
 	}
 
+	#[benchmark(pov_mode = Measured)]
+	fn map_account() {
+		let caller = whitelisted_caller();
+		T::Currency::set_balance(&caller, caller_funding::<T>());
+		let origin = RawOrigin::Signed(caller.clone());
+		assert!(!T::AddressMapper::is_mapped(&caller));
+		#[extrinsic_call]
+		_(origin);
+		assert!(T::AddressMapper::is_mapped(&caller));
+	}
+
+	#[benchmark(pov_mode = Measured)]
+	fn unmap_account() {
+		let caller = whitelisted_caller();
+		T::Currency::set_balance(&caller, caller_funding::<T>());
+		let origin = RawOrigin::Signed(caller.clone());
+		<Contracts<T>>::map_account(origin.clone().into()).unwrap();
+		assert!(T::AddressMapper::is_mapped(&caller));
+		#[extrinsic_call]
+		_(origin);
+		assert!(!T::AddressMapper::is_mapped(&caller));
+	}
+
+	#[benchmark(pov_mode = Measured)]
+	fn dispatch_as_fallback_account() {
+		let caller = whitelisted_caller();
+		T::Currency::set_balance(&caller, caller_funding::<T>());
+		let origin = RawOrigin::Signed(caller.clone());
+		let dispatchable = frame_system::Call::remark { remark: vec![] }.into();
+		#[extrinsic_call]
+		_(origin, Box::new(dispatchable));
+	}
+
 	#[benchmark(pov_mode = Measured)]
 	fn noop_host_fn(r: Linear<0, API_BENCHMARK_RUNS>) {
 		let mut setup = CallSetup::<T>::new(WasmModule::noop());
@@ -636,7 +675,7 @@ mod benchmarks {
 		build_runtime!(runtime, contract, memory: [(len as u32).encode(), vec![0u8; len],]);
 
 		<ImmutableDataOf<T>>::insert::<_, BoundedVec<_, _>>(
-			contract.address(),
+			contract.address,
 			immutable_data.clone().try_into().unwrap(),
 		);
 
@@ -669,10 +708,7 @@ mod benchmarks {
 		}
 
 		assert_ok!(result);
-		assert_eq!(
-			&memory[..],
-			&<ImmutableDataOf<T>>::get(setup.contract().address()).unwrap()[..]
-		);
+		assert_eq!(&memory[..], &<ImmutableDataOf<T>>::get(setup.contract().address).unwrap()[..]);
 	}
 
 	#[benchmark(pov_mode = Measured)]
@@ -835,7 +871,7 @@ mod benchmarks {
 
 		assert_eq!(
 			record.event,
-			crate::Event::ContractEmitted { contract: instance.address(), data, topics }.into(),
+			crate::Event::ContractEmitted { contract: instance.address, data, topics }.into(),
 		);
 	}
 
@@ -1542,7 +1578,7 @@ mod benchmarks {
 		let salt = [42u8; 32];
 		let deployer = T::AddressMapper::to_address(&account_id);
 		let addr = crate::address::create2(&deployer, &code.code, &input, &salt);
-		let account_id = T::AddressMapper::to_account_id_contract(&addr);
+		let account_id = T::AddressMapper::to_fallback_account_id(&addr);
 		let mut memory = memory!(hash_bytes, deposit_bytes, value_bytes, input, salt,);
 
 		let mut offset = {
diff --git a/substrate/frame/revive/src/evm/runtime.rs b/substrate/frame/revive/src/evm/runtime.rs
index 4c3fdeca720cf523fb65712ffdb0ce54c9de96df..80406a49bca2c63b11ed3b5bf10b195431db03c2 100644
--- a/substrate/frame/revive/src/evm/runtime.rs
+++ b/substrate/frame/revive/src/evm/runtime.rs
@@ -290,7 +290,7 @@ pub trait EthExtra {
 		})?;
 
 		let signer =
-			<Self::Config as crate::Config>::AddressMapper::to_account_id_contract(&signer);
+			<Self::Config as crate::Config>::AddressMapper::to_fallback_account_id(&signer);
 		let TransactionLegacyUnsigned { nonce, chain_id, to, value, input, gas, gas_price, .. } =
 			tx.transaction_legacy_unsigned;
 
@@ -419,7 +419,7 @@ mod test {
 		/// Get the [`AccountId`] of the account.
 		pub fn account_id(&self) -> AccountIdOf<Test> {
 			let address = self.address();
-			<Test as crate::Config>::AddressMapper::to_account_id_contract(&address)
+			<Test as crate::Config>::AddressMapper::to_fallback_account_id(&address)
 		}
 
 		/// Get the [`H160`] address of the account.
diff --git a/substrate/frame/revive/src/exec.rs b/substrate/frame/revive/src/exec.rs
index 759fba9f1c6a88cc53cf7d1c0b11b46d4feb0374..9f3a75c0090dd160232ec72c590526c7a1d164f4 100644
--- a/substrate/frame/revive/src/exec.rs
+++ b/substrate/frame/revive/src/exec.rs
@@ -167,6 +167,18 @@ impl<T: Config> Origin<T> {
 			Origin::Root => Err(DispatchError::RootNotAllowed),
 		}
 	}
+
+	/// Make sure that this origin is mapped.
+	///
+	/// We require an origin to be mapped in order to be used in a `Stack`. Otherwise
+	/// [`Stack::caller`] returns an address that can't be reverted to the original address.
+	fn ensure_mapped(&self) -> DispatchResult {
+		match self {
+			Self::Root => Ok(()),
+			Self::Signed(account_id) if T::AddressMapper::is_mapped(account_id) => Ok(()),
+			Self::Signed(_) => Err(<Error<T>>::AccountUnmapped.into()),
+		}
+	}
 }
 
 /// An interface that provides access to the external environment in which the
@@ -752,7 +764,7 @@ where
 		)? {
 			stack.run(executable, input_data).map(|_| stack.first_frame.last_frame_output)
 		} else {
-			Self::transfer_no_contract(&origin, &dest, value)
+			Self::transfer_from_origin(&origin, &dest, value)
 		}
 	}
 
@@ -833,6 +845,7 @@ where
 		value: BalanceOf<T>,
 		debug_message: Option<&'a mut DebugBuffer>,
 	) -> Result<Option<(Self, E)>, ExecError> {
+		origin.ensure_mapped()?;
 		let Some((first_frame, executable)) = Self::new_frame(
 			args,
 			value,
@@ -925,7 +938,7 @@ where
 					*executable.code_hash(),
 				)?;
 				(
-					T::AddressMapper::to_account_id_contract(&address),
+					T::AddressMapper::to_fallback_account_id(&address),
 					contract,
 					executable,
 					None,
@@ -1241,13 +1254,13 @@ where
 	}
 
 	/// Transfer some funds from `from` to `to`.
-	fn transfer(from: &T::AccountId, to: &T::AccountId, value: BalanceOf<T>) -> DispatchResult {
+	fn transfer(from: &T::AccountId, to: &T::AccountId, value: BalanceOf<T>) -> ExecResult {
 		// this avoids events to be emitted for zero balance transfers
 		if !value.is_zero() {
 			T::Currency::transfer(from, to, value, Preservation::Preserve)
 				.map_err(|_| Error::<T>::TransferFailed)?;
 		}
-		Ok(())
+		Ok(Default::default())
 	}
 
 	/// Same as `transfer` but `from` is an `Origin`.
@@ -1255,28 +1268,17 @@ where
 		from: &Origin<T>,
 		to: &T::AccountId,
 		value: BalanceOf<T>,
-	) -> DispatchResult {
+	) -> ExecResult {
 		// If the from address is root there is no account to transfer from, and therefore we can't
 		// take any `value` other than 0.
 		let from = match from {
 			Origin::Signed(caller) => caller,
-			Origin::Root if value.is_zero() => return Ok(()),
-			Origin::Root => return DispatchError::RootNotAllowed.into(),
+			Origin::Root if value.is_zero() => return Ok(Default::default()),
+			Origin::Root => return Err(DispatchError::RootNotAllowed.into()),
 		};
 		Self::transfer(from, to, value)
 	}
 
-	/// Same as `transfer_from_origin` but creates an `ExecReturnValue` on success.
-	fn transfer_no_contract(
-		from: &Origin<T>,
-		to: &T::AccountId,
-		value: BalanceOf<T>,
-	) -> ExecResult {
-		Self::transfer_from_origin(from, to, value)
-			.map(|_| ExecReturnValue::default())
-			.map_err(Into::into)
-	}
-
 	/// Reference to the current (top) frame.
 	fn top_frame(&self) -> &Frame<T> {
 		top_frame!(self)
@@ -1379,12 +1381,7 @@ where
 			)? {
 				self.run(executable, input_data)
 			} else {
-				Self::transfer_no_contract(
-					&Origin::from_account_id(self.account_id().clone()),
-					&dest,
-					value,
-				)?;
-				Ok(())
+				Self::transfer(&self.account_id(), &dest, value).map(|_| ())
 			}
 		};
 
@@ -1488,6 +1485,8 @@ where
 			&T::AddressMapper::to_account_id(to),
 			value.try_into().map_err(|_| Error::<T>::BalanceConversionFailed)?,
 		)
+		.map(|_| ())
+		.map_err(|error| error.error)
 	}
 
 	fn get_storage(&mut self, key: &Key) -> Option<Vec<u8>> {
@@ -2031,7 +2030,7 @@ mod tests {
 		ExtBuilder::default().build().execute_with(|| {
 			place_contract(&BOB, success_ch);
 			set_balance(&ALICE, 100);
-			let balance = get_balance(&BOB_CONTRACT_ID);
+			let balance = get_balance(&BOB_FALLBACK);
 			let origin = Origin::from_account_id(ALICE);
 			let mut storage_meter = storage::meter::Meter::new(&origin, 0, value).unwrap();
 
@@ -2047,7 +2046,7 @@ mod tests {
 			.unwrap();
 
 			assert_eq!(get_balance(&ALICE), 100 - value);
-			assert_eq!(get_balance(&BOB_CONTRACT_ID), balance + value);
+			assert_eq!(get_balance(&BOB_FALLBACK), balance + value);
 		});
 	}
 
@@ -2069,7 +2068,7 @@ mod tests {
 		ExtBuilder::default().build().execute_with(|| {
 			place_contract(&BOB, delegate_ch);
 			set_balance(&ALICE, 100);
-			let balance = get_balance(&BOB_CONTRACT_ID);
+			let balance = get_balance(&BOB_FALLBACK);
 			let origin = Origin::from_account_id(ALICE);
 			let mut storage_meter = storage::meter::Meter::new(&origin, 0, 55).unwrap();
 
@@ -2085,7 +2084,7 @@ mod tests {
 			.unwrap();
 
 			assert_eq!(get_balance(&ALICE), 100 - value);
-			assert_eq!(get_balance(&BOB_CONTRACT_ID), balance + value);
+			assert_eq!(get_balance(&BOB_FALLBACK), balance + value);
 		});
 	}
 
@@ -2326,9 +2325,10 @@ mod tests {
 			// Record the caller for bob.
 			WitnessedCallerBob::mutate(|caller| {
 				let origin = ctx.ext.caller();
-				*caller = Some(<Test as Config>::AddressMapper::to_address(
-					&origin.account_id().unwrap(),
-				));
+				*caller =
+					Some(<<Test as Config>::AddressMapper as AddressMapper<Test>>::to_address(
+						&origin.account_id().unwrap(),
+					));
 			});
 
 			// Call into CHARLIE contract.
@@ -2350,9 +2350,10 @@ mod tests {
 			// Record the caller for charlie.
 			WitnessedCallerCharlie::mutate(|caller| {
 				let origin = ctx.ext.caller();
-				*caller = Some(<Test as Config>::AddressMapper::to_address(
-					&origin.account_id().unwrap(),
-				));
+				*caller =
+					Some(<<Test as Config>::AddressMapper as AddressMapper<Test>>::to_address(
+						&origin.account_id().unwrap(),
+					));
 			});
 			exec_success()
 		});
@@ -2716,10 +2717,11 @@ mod tests {
 					),
 					Ok((address, ref output)) if output.data == vec![80, 65, 83, 83] => address
 				);
-				let instantiated_contract_id =
-					<Test as Config>::AddressMapper::to_account_id_contract(
-						&instantiated_contract_address,
-					);
+				let instantiated_contract_id = <<Test as Config>::AddressMapper as AddressMapper<
+					Test,
+				>>::to_fallback_account_id(
+					&instantiated_contract_address
+				);
 
 				// Check that the newly created account has the expected code hash and
 				// there are instantiation event.
@@ -2771,10 +2773,11 @@ mod tests {
 					Ok((address, ref output)) if output.data == vec![70, 65, 73, 76] => address
 				);
 
-				let instantiated_contract_id =
-					<Test as Config>::AddressMapper::to_account_id_contract(
-						&instantiated_contract_address,
-					);
+				let instantiated_contract_id = <<Test as Config>::AddressMapper as AddressMapper<
+					Test,
+				>>::to_fallback_account_id(
+					&instantiated_contract_address
+				);
 
 				// Check that the account has not been created.
 				assert!(ContractInfo::<Test>::load_code_hash(&instantiated_contract_id).is_none());
@@ -2837,10 +2840,11 @@ mod tests {
 				let instantiated_contract_address =
 					*instantiated_contract_address.borrow().as_ref().unwrap();
 
-				let instantiated_contract_id =
-					<Test as Config>::AddressMapper::to_account_id_contract(
-						&instantiated_contract_address,
-					);
+				let instantiated_contract_id = <<Test as Config>::AddressMapper as AddressMapper<
+					Test,
+				>>::to_fallback_account_id(
+					&instantiated_contract_address
+				);
 
 				// Check that the newly created account has the expected code hash and
 				// there are instantiation event.
@@ -2895,7 +2899,7 @@ mod tests {
 			.build()
 			.execute_with(|| {
 				set_balance(&ALICE, 1000);
-				set_balance(&BOB_CONTRACT_ID, 100);
+				set_balance(&BOB_FALLBACK, 100);
 				place_contract(&BOB, instantiator_ch);
 				let origin = Origin::from_account_id(ALICE);
 				let mut storage_meter = storage::meter::Meter::new(&origin, 200, 0).unwrap();
@@ -3025,7 +3029,8 @@ mod tests {
 	fn recursive_call_during_constructor_is_balance_transfer() {
 		let code = MockLoader::insert(Constructor, |ctx, _| {
 			let account_id = ctx.ext.account_id().clone();
-			let addr = <Test as Config>::AddressMapper::to_address(&account_id);
+			let addr =
+				<<Test as Config>::AddressMapper as AddressMapper<Test>>::to_address(&account_id);
 			let balance = ctx.ext.balance();
 
 			// Calling ourselves during the constructor will trigger a balance
@@ -3086,7 +3091,8 @@ mod tests {
 	fn cannot_send_more_balance_than_available_to_self() {
 		let code_hash = MockLoader::insert(Call, |ctx, _| {
 			let account_id = ctx.ext.account_id().clone();
-			let addr = <Test as Config>::AddressMapper::to_address(&account_id);
+			let addr =
+				<<Test as Config>::AddressMapper as AddressMapper<Test>>::to_address(&account_id);
 			let balance = ctx.ext.balance();
 
 			assert_err!(
@@ -3358,7 +3364,7 @@ mod tests {
 					EventRecord {
 						phase: Phase::Initialization,
 						event: MetaEvent::System(frame_system::Event::Remarked {
-							sender: BOB_CONTRACT_ID,
+							sender: BOB_FALLBACK,
 							hash: remark_hash
 						}),
 						topics: vec![],
@@ -3442,7 +3448,7 @@ mod tests {
 					EventRecord {
 						phase: Phase::Initialization,
 						event: MetaEvent::System(frame_system::Event::Remarked {
-							sender: BOB_CONTRACT_ID,
+							sender: BOB_FALLBACK,
 							hash: remark_hash
 						}),
 						topics: vec![],
@@ -3506,7 +3512,10 @@ mod tests {
 				)
 				.unwrap();
 
-			let account_id = <Test as Config>::AddressMapper::to_account_id_contract(&addr);
+			let account_id =
+				<<Test as Config>::AddressMapper as AddressMapper<Test>>::to_fallback_account_id(
+					&addr,
+				);
 
 			assert_eq!(System::account_nonce(&ALICE), alice_nonce);
 			assert_eq!(System::account_nonce(ctx.ext.account_id()), 1);
@@ -4299,7 +4308,7 @@ mod tests {
 			.build()
 			.execute_with(|| {
 				set_balance(&ALICE, 1000);
-				set_balance(&BOB_CONTRACT_ID, 100);
+				set_balance(&BOB, 100);
 				place_contract(&BOB, instantiator_ch);
 				let origin = Origin::from_account_id(ALICE);
 				let mut storage_meter = storage::meter::Meter::new(&origin, 200, 0).unwrap();
@@ -4484,7 +4493,7 @@ mod tests {
 			.build()
 			.execute_with(|| {
 				set_balance(&ALICE, 1000);
-				set_balance(&BOB_CONTRACT_ID, 100);
+				set_balance(&BOB, 100);
 				place_contract(&BOB, instantiator_ch);
 				let origin = Origin::from_account_id(ALICE);
 				let mut storage_meter = storage::meter::Meter::new(&origin, 200, 0).unwrap();
@@ -4601,7 +4610,7 @@ mod tests {
 			.build()
 			.execute_with(|| {
 				set_balance(&ALICE, 1000);
-				set_balance(&BOB_CONTRACT_ID, 100);
+				set_balance(&BOB, 100);
 				place_contract(&BOB, instantiator_ch);
 				let origin = Origin::from_account_id(ALICE);
 				let mut storage_meter = storage::meter::Meter::new(&origin, 200, 0).unwrap();
@@ -4645,7 +4654,7 @@ mod tests {
 			.build()
 			.execute_with(|| {
 				set_balance(&ALICE, 1000);
-				set_balance(&BOB_CONTRACT_ID, 100);
+				set_balance(&BOB, 100);
 				place_contract(&BOB, instantiator_ch);
 				let origin = Origin::from_account_id(ALICE);
 				let mut storage_meter = storage::meter::Meter::new(&origin, 200, 0).unwrap();
diff --git a/substrate/frame/revive/src/lib.rs b/substrate/frame/revive/src/lib.rs
index 11752e47cf2af1d595a9a2b874d8f33f2985014d..1967f9868d2b5644676ee917fa9376ccdd93fbdb 100644
--- a/substrate/frame/revive/src/lib.rs
+++ b/substrate/frame/revive/src/lib.rs
@@ -48,6 +48,7 @@ use crate::{
 	storage::{meter::Meter as StorageMeter, ContractInfo, DeletionQueueManager},
 	wasm::{CodeInfo, RuntimeCosts, WasmBlob},
 };
+use alloc::boxed::Box;
 use codec::{Codec, Decode, Encode};
 use environmental::*;
 use frame_support::{
@@ -78,7 +79,7 @@ use sp_runtime::{
 };
 
 pub use crate::{
-	address::{create1, create2, AddressMapper, DefaultAddressMapper},
+	address::{create1, create2, AccountId32Mapper, AddressMapper},
 	debug::Tracing,
 	exec::MomentOf,
 	pallet::*,
@@ -160,11 +161,9 @@ pub mod pallet {
 
 		/// The overarching call type.
 		#[pallet::no_default_bounds]
-		type RuntimeCall: Dispatchable<RuntimeOrigin = Self::RuntimeOrigin, PostInfo = PostDispatchInfo>
-			+ GetDispatchInfo
-			+ codec::Decode
-			+ core::fmt::Debug
-			+ IsType<<Self as frame_system::Config>::RuntimeCall>;
+		type RuntimeCall: Parameter
+			+ Dispatchable<RuntimeOrigin = Self::RuntimeOrigin, PostInfo = PostDispatchInfo>
+			+ GetDispatchInfo;
 
 		/// Overarching hold reason.
 		#[pallet::no_default_bounds]
@@ -233,9 +232,9 @@ pub mod pallet {
 		#[pallet::constant]
 		type CodeHashLockupDepositPercent: Get<Perbill>;
 
-		/// Only valid type is [`DefaultAddressMapper`].
-		#[pallet::no_default_bounds]
-		type AddressMapper: AddressMapper<AccountIdOf<Self>>;
+		/// Use either valid type is [`address::AccountId32Mapper`] or [`address::H160Mapper`].
+		#[pallet::no_default]
+		type AddressMapper: AddressMapper<Self>;
 
 		/// Make contract callable functions marked as `#[unstable]` available.
 		///
@@ -361,7 +360,6 @@ pub mod pallet {
 
 			#[inject_runtime_type]
 			type RuntimeCall = ();
-			type AddressMapper = DefaultAddressMapper;
 			type CallFilter = ();
 			type ChainExtension = ();
 			type CodeHashLockupDepositPercent = CodeHashLockupDepositPercent;
@@ -562,6 +560,12 @@ pub mod pallet {
 		/// Immutable data can only be set during deploys and only be read during calls.
 		/// Additionally, it is only valid to set the data once and it must not be empty.
 		InvalidImmutableAccess,
+		/// An `AccountID32` account tried to interact with the pallet without having a mapping.
+		///
+		/// Call [`Pallet::map_account`] in order to create a mapping for the account.
+		AccountUnmapped,
+		/// Tried to map an account that is already mapped.
+		AccountAlreadyMapped,
 	}
 
 	/// A reason for the pallet contracts placing a hold on funds.
@@ -571,6 +575,8 @@ pub mod pallet {
 		CodeUploadDepositReserve,
 		/// The Pallet has reserved it for storage deposit.
 		StorageDepositReserve,
+		/// Deposit for creating an address mapping in [`AddressSuffix`].
+		AddressMapping,
 	}
 
 	/// A mapping from a contract's code hash to its code.
@@ -602,6 +608,14 @@ pub mod pallet {
 	pub(crate) type DeletionQueueCounter<T: Config> =
 		StorageValue<_, DeletionQueueManager<T>, ValueQuery>;
 
+	/// Map a Ethereum address to its original `AccountId32`.
+	///
+	/// Stores the last 12 byte for addresses that were originally an `AccountId32` instead
+	/// of an `H160`. Register your `AccountId32` using [`Pallet::map_account`] in order to
+	/// use it with this pallet.
+	#[pallet::storage]
+	pub(crate) type AddressSuffix<T: Config> = StorageMap<_, Identity, H160, [u8; 12]>;
+
 	#[pallet::extra_constants]
 	impl<T: Config> Pallet<T> {
 		#[pallet::constant_name(ApiVersion)]
@@ -995,6 +1009,51 @@ pub mod pallet {
 				Ok(())
 			})
 		}
+
+		/// Register the callers account id so that it can be used in contract interactions.
+		///
+		/// This will error if the origin is already mapped or is a eth native `Address20`. It will
+		/// take a deposit that can be released by calling [`Self::unmap_account`].
+		#[pallet::call_index(7)]
+		#[pallet::weight(T::WeightInfo::map_account())]
+		pub fn map_account(origin: OriginFor<T>) -> DispatchResult {
+			let origin = ensure_signed(origin)?;
+			T::AddressMapper::map(&origin)
+		}
+
+		/// Unregister the callers account id in order to free the deposit.
+		///
+		/// There is no reason to ever call this function other than freeing up the deposit.
+		/// This is only useful when the account should no longer be used.
+		#[pallet::call_index(8)]
+		#[pallet::weight(T::WeightInfo::unmap_account())]
+		pub fn unmap_account(origin: OriginFor<T>) -> DispatchResult {
+			let origin = ensure_signed(origin)?;
+			T::AddressMapper::unmap(&origin)
+		}
+
+		/// Dispatch an `call` with the origin set to the callers fallback address.
+		///
+		/// Every `AccountId32` can control its corresponding fallback account. The fallback account
+		/// is the `AccountId20` with the last 12 bytes set to `0xEE`. This is essentially a
+		/// recovery function in case an `AccountId20` was used without creating a mapping first.
+		#[pallet::call_index(9)]
+		#[pallet::weight({
+			let dispatch_info = call.get_dispatch_info();
+			(
+				T::WeightInfo::dispatch_as_fallback_account().saturating_add(dispatch_info.call_weight),
+				dispatch_info.class
+			)
+		})]
+		pub fn dispatch_as_fallback_account(
+			origin: OriginFor<T>,
+			call: Box<<T as Config>::RuntimeCall>,
+		) -> DispatchResultWithPostInfo {
+			let origin = ensure_signed(origin)?;
+			let unmapped_account =
+				T::AddressMapper::to_fallback_account_id(&T::AddressMapper::to_address(&origin));
+			call.dispatch(RawOrigin::Signed(unmapped_account).into())
+		}
 	}
 }
 
diff --git a/substrate/frame/revive/src/test_utils.rs b/substrate/frame/revive/src/test_utils.rs
index 92c21297a3ece617175358ef3f95f6d34ba3bff2..acd9a4cda38a808f55aa37bc858f45ecd0484674 100644
--- a/substrate/frame/revive/src/test_utils.rs
+++ b/substrate/frame/revive/src/test_utils.rs
@@ -27,38 +27,35 @@ use frame_support::weights::Weight;
 use sp_core::H160;
 pub use sp_runtime::AccountId32;
 
-const fn ee_suffix(addr: H160) -> AccountId32 {
-	let mut id = [0u8; 32];
-	let mut i = 0;
-	while i < 20 {
-		id[i] = addr.0[i];
+const fn ee_suffix(mut account: [u8; 32]) -> AccountId32 {
+	let mut i = 20;
+	while i < 32 {
+		account[i] = 0xee;
 		i += 1;
 	}
-
-	let mut j = 20;
-	while j < 32 {
-		id[j] = 0xee;
-		j += 1;
-	}
-
-	AccountId32::new(id)
+	AccountId32::new(account)
 }
 
-pub const ALICE: AccountId32 = AccountId32::new([1u8; 32]);
+pub const ALICE: AccountId32 = ee_suffix([1u8; 32]);
 pub const ALICE_ADDR: H160 = H160([1u8; 20]);
-pub const ETH_ALICE: AccountId32 = ee_suffix(ALICE_ADDR);
+pub const ALICE_FALLBACK: AccountId32 = ee_suffix([1u8; 32]);
 
-pub const BOB: AccountId32 = AccountId32::new([2u8; 32]);
+pub const BOB: AccountId32 = ee_suffix([2u8; 32]);
 pub const BOB_ADDR: H160 = H160([2u8; 20]);
-pub const BOB_CONTRACT_ID: AccountId32 = ee_suffix(BOB_ADDR);
+pub const BOB_FALLBACK: AccountId32 = ee_suffix([2u8; 32]);
 
-pub const CHARLIE: AccountId32 = AccountId32::new([3u8; 32]);
+pub const CHARLIE: AccountId32 = ee_suffix([3u8; 32]);
 pub const CHARLIE_ADDR: H160 = H160([3u8; 20]);
-pub const CHARLIE_CONTRACT_ID: AccountId32 = ee_suffix(CHARLIE_ADDR);
+pub const CHARLIE_FALLBACK: AccountId32 = ee_suffix([3u8; 32]);
 
-pub const DJANGO: AccountId32 = AccountId32::new([4u8; 32]);
+pub const DJANGO: AccountId32 = ee_suffix([4u8; 32]);
 pub const DJANGO_ADDR: H160 = H160([4u8; 20]);
-pub const ETH_DJANGO: AccountId32 = ee_suffix(DJANGO_ADDR);
+pub const DJANGO_FALLBACK: AccountId32 = ee_suffix([4u8; 32]);
+
+/// Eve is a non ee account and hence needs a stateful mapping.
+pub const EVE: AccountId32 = AccountId32::new([5u8; 32]);
+pub const EVE_ADDR: H160 = H160([5u8; 20]);
+pub const EVE_FALLBACK: AccountId32 = ee_suffix([5u8; 32]);
 
 pub const GAS_LIMIT: Weight = Weight::from_parts(100_000_000_000, 3 * 1024 * 1024);
 
diff --git a/substrate/frame/revive/src/tests.rs b/substrate/frame/revive/src/tests.rs
index 94af7dbd04d8297ddfed3e4a4e20fc979b108ef1..1b5e64739d88f3ed9ff2df21431c7e8207e0eee0 100644
--- a/substrate/frame/revive/src/tests.rs
+++ b/substrate/frame/revive/src/tests.rs
@@ -39,9 +39,9 @@ use crate::{
 	tests::test_utils::{get_contract, get_contract_checked},
 	wasm::Memory,
 	weights::WeightInfo,
-	BalanceOf, Code, CodeInfoOf, CollectEvents, Config, ContractInfo, ContractInfoOf, DebugInfo,
-	DefaultAddressMapper, DeletionQueueCounter, Error, HoldReason, Origin, Pallet, PristineCode,
-	H160,
+	AccountId32Mapper, BalanceOf, Code, CodeInfoOf, CollectEvents, Config, ContractInfo,
+	ContractInfoOf, DebugInfo, DeletionQueueCounter, Error, HoldReason, Origin, Pallet,
+	PristineCode, H160,
 };
 
 use crate::test_utils::builder::Contract;
@@ -114,7 +114,8 @@ pub mod test_utils {
 	pub fn place_contract(address: &AccountIdOf<Test>, code_hash: sp_core::H256) {
 		set_balance(address, Contracts::min_balance() * 10);
 		<CodeInfoOf<Test>>::insert(code_hash, CodeInfo::new(address.clone()));
-		let address = <Test as Config>::AddressMapper::to_address(&address);
+		let address =
+			<<Test as Config>::AddressMapper as AddressMapper<Test>>::to_address(&address);
 		let contract = <ContractInfo<Test>>::new(&address, 0, code_hash).unwrap();
 		<ContractInfoOf<Test>>::insert(address, contract);
 	}
@@ -508,13 +509,13 @@ parameter_types! {
 #[derive_impl(crate::config_preludes::TestDefaultConfig)]
 impl Config for Test {
 	type Time = Timestamp;
+	type AddressMapper = AccountId32Mapper<Self>;
 	type Currency = Balances;
 	type CallFilter = TestFilter;
 	type ChainExtension =
 		(TestExtension, DisabledExtension, RevertingExtension, TempStorageExtension);
 	type DepositPerByte = DepositPerByte;
 	type DepositPerItem = DepositPerItem;
-	type AddressMapper = DefaultAddressMapper;
 	type UnsafeUnstableInterface = UnstableInterface;
 	type UploadOrigin = EnsureAccount<Self, UploadAccount>;
 	type InstantiateOrigin = EnsureAccount<Self, InstantiateAccount>;
@@ -635,9 +636,9 @@ mod run_tests {
 		ExtBuilder::default().build().execute_with(|| {
 			let _ = <Test as Config>::Currency::set_balance(&ALICE, 100_000_000);
 			assert!(!<ContractInfoOf<Test>>::contains_key(BOB_ADDR));
-			assert_eq!(test_utils::get_balance(&BOB_CONTRACT_ID), 0);
+			assert_eq!(test_utils::get_balance(&BOB_FALLBACK), 0);
 			let result = builder::bare_call(BOB_ADDR).value(42).build_and_unwrap_result();
-			assert_eq!(test_utils::get_balance(&BOB_CONTRACT_ID), 42);
+			assert_eq!(test_utils::get_balance(&BOB_FALLBACK), 42);
 			assert_eq!(result, Default::default());
 		});
 	}
@@ -1302,7 +1303,7 @@ mod run_tests {
 		let (wasm, code_hash) = compile_module("self_destruct").unwrap();
 		ExtBuilder::default().existential_deposit(1_000).build().execute_with(|| {
 			let _ = <Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
-			let _ = <Test as Config>::Currency::set_balance(&ETH_DJANGO, 1_000_000);
+			let _ = <Test as Config>::Currency::set_balance(&DJANGO_FALLBACK, 1_000_000);
 			let min_balance = Contracts::min_balance();
 
 			// Instantiate the BOB contract.
@@ -1330,7 +1331,7 @@ mod run_tests {
 
 			// Check that the beneficiary (django) got remaining balance.
 			assert_eq!(
-				<Test as Config>::Currency::free_balance(ETH_DJANGO),
+				<Test as Config>::Currency::free_balance(DJANGO_FALLBACK),
 				1_000_000 + 100_000 + min_balance
 			);
 
@@ -1382,7 +1383,7 @@ mod run_tests {
 						phase: Phase::Initialization,
 						event: RuntimeEvent::Balances(pallet_balances::Event::Transfer {
 							from: contract.account_id.clone(),
-							to: ETH_DJANGO,
+							to: DJANGO_FALLBACK,
 							amount: 100_000 + min_balance,
 						}),
 						topics: vec![],
@@ -1545,7 +1546,7 @@ mod run_tests {
 
 			// Sending at least the minimum balance should result in success but
 			// no code called.
-			assert_eq!(test_utils::get_balance(&ETH_DJANGO), 0);
+			assert_eq!(test_utils::get_balance(&DJANGO_FALLBACK), 0);
 			let result = builder::bare_call(bob.addr)
 				.data(
 					AsRef::<[u8]>::as_ref(&DJANGO_ADDR)
@@ -1556,7 +1557,7 @@ mod run_tests {
 				)
 				.build_and_unwrap_result();
 			assert_return_code!(result, RuntimeReturnCode::Success);
-			assert_eq!(test_utils::get_balance(&ETH_DJANGO), 55);
+			assert_eq!(test_utils::get_balance(&DJANGO_FALLBACK), 55);
 
 			let django = builder::bare_instantiate(Code::Upload(callee_code))
 				.origin(RuntimeOrigin::signed(CHARLIE))
@@ -3732,7 +3733,7 @@ mod run_tests {
 		// Instantiate the caller contract with the given input.
 		let instantiate = |input: &(u32, H256)| {
 			builder::bare_instantiate(Code::Upload(wasm_caller.clone()))
-				.origin(RuntimeOrigin::signed(ETH_ALICE))
+				.origin(RuntimeOrigin::signed(ALICE_FALLBACK))
 				.data(input.encode())
 				.build()
 		};
@@ -3740,13 +3741,13 @@ mod run_tests {
 		// Call contract with the given input.
 		let call = |addr_caller: &H160, input: &(u32, H256)| {
 			builder::bare_call(*addr_caller)
-				.origin(RuntimeOrigin::signed(ETH_ALICE))
+				.origin(RuntimeOrigin::signed(ALICE_FALLBACK))
 				.data(input.encode())
 				.build()
 		};
 		const ED: u64 = 2000;
 		ExtBuilder::default().existential_deposit(ED).build().execute_with(|| {
-			let _ = Balances::set_balance(&ETH_ALICE, 1_000_000);
+			let _ = Balances::set_balance(&ALICE_FALLBACK, 1_000_000);
 
 			// Instantiate with lock_delegate_dependency should fail since the code is not yet on
 			// chain.
@@ -3760,7 +3761,7 @@ mod run_tests {
 			for code in callee_codes.iter() {
 				let CodeUploadReturnValue { deposit: deposit_per_code, .. } =
 					Contracts::bare_upload_code(
-						RuntimeOrigin::signed(ETH_ALICE),
+						RuntimeOrigin::signed(ALICE_FALLBACK),
 						code.clone(),
 						deposit_limit::<Test>(),
 					)
@@ -3790,7 +3791,7 @@ mod run_tests {
 
 			// Removing the code should fail, since we have added a dependency.
 			assert_err!(
-				Contracts::remove_code(RuntimeOrigin::signed(ETH_ALICE), callee_hashes[0]),
+				Contracts::remove_code(RuntimeOrigin::signed(ALICE_FALLBACK), callee_hashes[0]),
 				<Error<Test>>::CodeInUse
 			);
 
@@ -3848,14 +3849,17 @@ mod run_tests {
 			);
 
 			// Since we unlocked the dependency we should now be able to remove the code.
-			assert_ok!(Contracts::remove_code(RuntimeOrigin::signed(ETH_ALICE), callee_hashes[0]));
+			assert_ok!(Contracts::remove_code(
+				RuntimeOrigin::signed(ALICE_FALLBACK),
+				callee_hashes[0]
+			));
 
 			// Calling should fail since the delegated contract is not on chain anymore.
 			assert_err!(call(&addr_caller, &noop_input).result, Error::<Test>::ContractTrapped);
 
 			// Add the dependency back.
 			Contracts::upload_code(
-				RuntimeOrigin::signed(ETH_ALICE),
+				RuntimeOrigin::signed(ALICE_FALLBACK),
 				callee_codes[0].clone(),
 				deposit_limit::<Test>(),
 			)
@@ -3863,15 +3867,18 @@ mod run_tests {
 			call(&addr_caller, &lock_delegate_dependency_input).result.unwrap();
 
 			// Call terminate should work, and return the deposit.
-			let balance_before = test_utils::get_balance(&ETH_ALICE);
+			let balance_before = test_utils::get_balance(&ALICE_FALLBACK);
 			assert_ok!(call(&addr_caller, &terminate_input).result);
 			assert_eq!(
-				test_utils::get_balance(&ETH_ALICE),
+				test_utils::get_balance(&ALICE_FALLBACK),
 				ED + balance_before + contract.storage_base_deposit() + dependency_deposit
 			);
 
 			// Terminate should also remove the dependency, so we can remove the code.
-			assert_ok!(Contracts::remove_code(RuntimeOrigin::signed(ETH_ALICE), callee_hashes[0]));
+			assert_ok!(Contracts::remove_code(
+				RuntimeOrigin::signed(ALICE_FALLBACK),
+				callee_hashes[0]
+			));
 		});
 	}
 
@@ -4109,13 +4116,13 @@ mod run_tests {
 		let (wasm, _code_hash) = compile_module("balance_of").unwrap();
 		ExtBuilder::default().existential_deposit(200).build().execute_with(|| {
 			let _ = Balances::set_balance(&ALICE, 1_000_000);
-			let _ = Balances::set_balance(&ETH_ALICE, 1_000_000);
+			let _ = Balances::set_balance(&ALICE_FALLBACK, 1_000_000);
 
 			let Contract { addr, .. } =
 				builder::bare_instantiate(Code::Upload(wasm.to_vec())).build_and_unwrap_contract();
 
 			// The fixture asserts a non-zero returned free balance of the account;
-			// The ETH_ALICE account is endowed;
+			// The ALICE_FALLBACK account is endowed;
 			// Hence we should not revert
 			assert_ok!(builder::call(addr).data(ALICE_ADDR.0.to_vec()).build());
 
@@ -4510,4 +4517,64 @@ mod run_tests {
 				.build());
 		});
 	}
+
+	#[test]
+	fn origin_must_be_mapped() {
+		let (code, hash) = compile_module("dummy").unwrap();
+
+		ExtBuilder::default().existential_deposit(100).build().execute_with(|| {
+			<Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
+			<Test as Config>::Currency::set_balance(&EVE, 1_000_000);
+
+			let eve = RuntimeOrigin::signed(EVE);
+
+			// alice can instantiate as she doesn't need a mapping
+			let Contract { addr, .. } =
+				builder::bare_instantiate(Code::Upload(code)).build_and_unwrap_contract();
+
+			// without a mapping eve can neither call nor instantiate
+			assert_err!(
+				builder::bare_call(addr).origin(eve.clone()).build().result,
+				<Error<Test>>::AccountUnmapped
+			);
+			assert_err!(
+				builder::bare_instantiate(Code::Existing(hash))
+					.origin(eve.clone())
+					.build()
+					.result,
+				<Error<Test>>::AccountUnmapped
+			);
+
+			// after mapping eve is usable as an origin
+			<Pallet<Test>>::map_account(eve.clone()).unwrap();
+			assert_ok!(builder::bare_call(addr).origin(eve.clone()).build().result);
+			assert_ok!(builder::bare_instantiate(Code::Existing(hash)).origin(eve).build().result);
+		});
+	}
+
+	#[test]
+	fn mapped_address_works() {
+		let (code, _) = compile_module("terminate_and_send_to_eve").unwrap();
+
+		ExtBuilder::default().existential_deposit(100).build().execute_with(|| {
+			<Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
+
+			// without a mapping everything will be send to the fallback account
+			let Contract { addr, .. } =
+				builder::bare_instantiate(Code::Upload(code.clone())).build_and_unwrap_contract();
+			assert_eq!(<Test as Config>::Currency::total_balance(&EVE_FALLBACK), 0);
+			builder::bare_call(addr).build_and_unwrap_result();
+			assert_eq!(<Test as Config>::Currency::total_balance(&EVE_FALLBACK), 100);
+
+			// after mapping it will be sent to the real eve account
+			let Contract { addr, .. } =
+				builder::bare_instantiate(Code::Upload(code)).build_and_unwrap_contract();
+			// need some balance to pay for the map deposit
+			<Test as Config>::Currency::set_balance(&EVE, 1_000);
+			<Pallet<Test>>::map_account(RuntimeOrigin::signed(EVE)).unwrap();
+			builder::bare_call(addr).build_and_unwrap_result();
+			assert_eq!(<Test as Config>::Currency::total_balance(&EVE_FALLBACK), 100);
+			assert_eq!(<Test as Config>::Currency::total_balance(&EVE), 1_100);
+		});
+	}
 }
diff --git a/substrate/frame/revive/src/weights.rs b/substrate/frame/revive/src/weights.rs
index 9a1b2310b4eb98c3b3e9c7206c5e60414b6ea471..3203a0cba9fb9da6fbd9303fde5107fbc25e4f5d 100644
--- a/substrate/frame/revive/src/weights.rs
+++ b/substrate/frame/revive/src/weights.rs
@@ -18,9 +18,9 @@
 //! Autogenerated weights for `pallet_revive`
 //!
 //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0
-//! DATE: 2024-10-06, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! DATE: 2024-10-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
 //! WORST CASE MAP SIZE: `1000000`
-//! HOSTNAME: `runner-jniz7bxx-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! HOSTNAME: `runner-dr4vwrkf-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
 //! WASM-EXECUTION: `Compiled`, CHAIN: `Some("dev")`, DB CACHE: `1024`
 
 // Executed Command:
@@ -58,6 +58,9 @@ pub trait WeightInfo {
 	fn upload_code(c: u32, ) -> Weight;
 	fn remove_code() -> Weight;
 	fn set_code() -> Weight;
+	fn map_account() -> Weight;
+	fn unmap_account() -> Weight;
+	fn dispatch_as_fallback_account() -> Weight;
 	fn noop_host_fn(r: u32, ) -> Weight;
 	fn seal_caller() -> Weight;
 	fn seal_is_contract() -> Weight;
@@ -126,8 +129,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `109`
 		//  Estimated: `1594`
-		// Minimum execution time: 2_712_000 picoseconds.
-		Weight::from_parts(2_882_000, 1594)
+		// Minimum execution time: 3_053_000 picoseconds.
+		Weight::from_parts(3_150_000, 1594)
 			.saturating_add(T::DbWeight::get().reads(1_u64))
 	}
 	/// Storage: `Skipped::Metadata` (r:0 w:0)
@@ -135,18 +138,20 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// The range of component `k` is `[0, 1024]`.
 	fn on_initialize_per_trie_key(k: u32, ) -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `392 + k * (69 ±0)`
-		//  Estimated: `382 + k * (70 ±0)`
-		// Minimum execution time: 13_394_000 picoseconds.
-		Weight::from_parts(13_668_000, 382)
-			// Standard Error: 2_208
-			.saturating_add(Weight::from_parts(1_340_842, 0).saturating_mul(k.into()))
+		//  Measured:  `425 + k * (69 ±0)`
+		//  Estimated: `415 + k * (70 ±0)`
+		// Minimum execution time: 15_219_000 picoseconds.
+		Weight::from_parts(12_576_960, 415)
+			// Standard Error: 1_429
+			.saturating_add(Weight::from_parts(1_341_896, 0).saturating_mul(k.into()))
 			.saturating_add(T::DbWeight::get().reads(2_u64))
 			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(k.into())))
 			.saturating_add(T::DbWeight::get().writes(2_u64))
 			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(k.into())))
 			.saturating_add(Weight::from_parts(0, 70).saturating_mul(k.into()))
 	}
+	/// Storage: `Revive::AddressSuffix` (r:2 w:0)
+	/// Proof: `Revive::AddressSuffix` (`max_values`: None, `max_size`: Some(32), added: 2507, mode: `Measured`)
 	/// Storage: `Revive::ContractInfoOf` (r:1 w:1)
 	/// Proof: `Revive::ContractInfoOf` (`max_values`: None, `max_size`: Some(1779), added: 4254, mode: `Measured`)
 	/// Storage: `Revive::CodeInfoOf` (r:1 w:0)
@@ -158,21 +163,21 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Storage: `System::Account` (r:1 w:1)
 	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`)
 	/// The range of component `c` is `[0, 262144]`.
-	fn call_with_code_per_byte(c: u32, ) -> Weight {
+	fn call_with_code_per_byte(_c: u32, ) -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `1466`
-		//  Estimated: `4931`
-		// Minimum execution time: 80_390_000 picoseconds.
-		Weight::from_parts(83_627_295, 4931)
-			// Standard Error: 0
-			.saturating_add(Weight::from_parts(1, 0).saturating_mul(c.into()))
-			.saturating_add(T::DbWeight::get().reads(5_u64))
+		//  Measured:  `1519`
+		//  Estimated: `7459`
+		// Minimum execution time: 88_906_000 picoseconds.
+		Weight::from_parts(93_353_224, 7459)
+			.saturating_add(T::DbWeight::get().reads(7_u64))
 			.saturating_add(T::DbWeight::get().writes(2_u64))
 	}
 	/// Storage: `Revive::CodeInfoOf` (r:1 w:1)
 	/// Proof: `Revive::CodeInfoOf` (`max_values`: None, `max_size`: Some(96), added: 2571, mode: `Measured`)
 	/// Storage: `Balances::Holds` (r:2 w:2)
-	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(337), added: 2812, mode: `Measured`)
+	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(355), added: 2830, mode: `Measured`)
+	/// Storage: `Revive::AddressSuffix` (r:1 w:0)
+	/// Proof: `Revive::AddressSuffix` (`max_values`: None, `max_size`: Some(32), added: 2507, mode: `Measured`)
 	/// Storage: `Revive::ContractInfoOf` (r:1 w:1)
 	/// Proof: `Revive::ContractInfoOf` (`max_values`: None, `max_size`: Some(1779), added: 4254, mode: `Measured`)
 	/// Storage: `Timestamp::Now` (r:1 w:0)
@@ -185,19 +190,21 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// The range of component `i` is `[0, 262144]`.
 	fn instantiate_with_code(_c: u32, i: u32, ) -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `303`
-		//  Estimated: `6232`
-		// Minimum execution time: 184_708_000 picoseconds.
-		Weight::from_parts(177_995_416, 6232)
-			// Standard Error: 11
-			.saturating_add(Weight::from_parts(4_609, 0).saturating_mul(i.into()))
-			.saturating_add(T::DbWeight::get().reads(6_u64))
+		//  Measured:  `416`
+		//  Estimated: `6360`
+		// Minimum execution time: 202_688_000 picoseconds.
+		Weight::from_parts(197_366_807, 6360)
+			// Standard Error: 13
+			.saturating_add(Weight::from_parts(4_261, 0).saturating_mul(i.into()))
+			.saturating_add(T::DbWeight::get().reads(7_u64))
 			.saturating_add(T::DbWeight::get().writes(6_u64))
 	}
 	/// Storage: `Revive::CodeInfoOf` (r:1 w:1)
 	/// Proof: `Revive::CodeInfoOf` (`max_values`: None, `max_size`: Some(96), added: 2571, mode: `Measured`)
 	/// Storage: `Revive::PristineCode` (r:1 w:0)
 	/// Proof: `Revive::PristineCode` (`max_values`: None, `max_size`: Some(262180), added: 264655, mode: `Measured`)
+	/// Storage: `Revive::AddressSuffix` (r:1 w:0)
+	/// Proof: `Revive::AddressSuffix` (`max_values`: None, `max_size`: Some(32), added: 2507, mode: `Measured`)
 	/// Storage: `Revive::ContractInfoOf` (r:1 w:1)
 	/// Proof: `Revive::ContractInfoOf` (`max_values`: None, `max_size`: Some(1779), added: 4254, mode: `Measured`)
 	/// Storage: `Timestamp::Now` (r:1 w:0)
@@ -205,19 +212,21 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Storage: `System::Account` (r:1 w:1)
 	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`)
 	/// Storage: `Balances::Holds` (r:1 w:1)
-	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(337), added: 2812, mode: `Measured`)
+	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(355), added: 2830, mode: `Measured`)
 	/// The range of component `i` is `[0, 262144]`.
 	fn instantiate(i: u32, ) -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `1261`
-		//  Estimated: `4706`
-		// Minimum execution time: 150_137_000 picoseconds.
-		Weight::from_parts(136_548_469, 4706)
+		//  Measured:  `1313`
+		//  Estimated: `4779`
+		// Minimum execution time: 169_246_000 picoseconds.
+		Weight::from_parts(149_480_457, 4779)
 			// Standard Error: 16
-			.saturating_add(Weight::from_parts(4_531, 0).saturating_mul(i.into()))
-			.saturating_add(T::DbWeight::get().reads(6_u64))
+			.saturating_add(Weight::from_parts(4_041, 0).saturating_mul(i.into()))
+			.saturating_add(T::DbWeight::get().reads(7_u64))
 			.saturating_add(T::DbWeight::get().writes(4_u64))
 	}
+	/// Storage: `Revive::AddressSuffix` (r:2 w:0)
+	/// Proof: `Revive::AddressSuffix` (`max_values`: None, `max_size`: Some(32), added: 2507, mode: `Measured`)
 	/// Storage: `Revive::ContractInfoOf` (r:1 w:1)
 	/// Proof: `Revive::ContractInfoOf` (`max_values`: None, `max_size`: Some(1779), added: 4254, mode: `Measured`)
 	/// Storage: `Revive::CodeInfoOf` (r:1 w:0)
@@ -230,17 +239,17 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`)
 	fn call() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `1466`
-		//  Estimated: `4931`
-		// Minimum execution time: 83_178_000 picoseconds.
-		Weight::from_parts(84_633_000, 4931)
-			.saturating_add(T::DbWeight::get().reads(5_u64))
+		//  Measured:  `1519`
+		//  Estimated: `7459`
+		// Minimum execution time: 91_129_000 picoseconds.
+		Weight::from_parts(94_220_000, 7459)
+			.saturating_add(T::DbWeight::get().reads(7_u64))
 			.saturating_add(T::DbWeight::get().writes(2_u64))
 	}
 	/// Storage: `Revive::CodeInfoOf` (r:1 w:1)
 	/// Proof: `Revive::CodeInfoOf` (`max_values`: None, `max_size`: Some(96), added: 2571, mode: `Measured`)
 	/// Storage: `Balances::Holds` (r:1 w:1)
-	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(337), added: 2812, mode: `Measured`)
+	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(355), added: 2830, mode: `Measured`)
 	/// Storage: `Revive::PristineCode` (r:0 w:1)
 	/// Proof: `Revive::PristineCode` (`max_values`: None, `max_size`: Some(262180), added: 264655, mode: `Measured`)
 	/// The range of component `c` is `[0, 262144]`.
@@ -248,23 +257,23 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `109`
 		//  Estimated: `3574`
-		// Minimum execution time: 51_526_000 picoseconds.
-		Weight::from_parts(54_565_973, 3574)
+		// Minimum execution time: 54_849_000 picoseconds.
+		Weight::from_parts(57_508_591, 3574)
 			.saturating_add(T::DbWeight::get().reads(2_u64))
 			.saturating_add(T::DbWeight::get().writes(3_u64))
 	}
 	/// Storage: `Revive::CodeInfoOf` (r:1 w:1)
 	/// Proof: `Revive::CodeInfoOf` (`max_values`: None, `max_size`: Some(96), added: 2571, mode: `Measured`)
 	/// Storage: `Balances::Holds` (r:1 w:1)
-	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(337), added: 2812, mode: `Measured`)
+	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(355), added: 2830, mode: `Measured`)
 	/// Storage: `Revive::PristineCode` (r:0 w:1)
 	/// Proof: `Revive::PristineCode` (`max_values`: None, `max_size`: Some(262180), added: 264655, mode: `Measured`)
 	fn remove_code() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `285`
 		//  Estimated: `3750`
-		// Minimum execution time: 41_885_000 picoseconds.
-		Weight::from_parts(42_467_000, 3750)
+		// Minimum execution time: 45_017_000 picoseconds.
+		Weight::from_parts(46_312_000, 3750)
 			.saturating_add(T::DbWeight::get().reads(2_u64))
 			.saturating_add(T::DbWeight::get().writes(3_u64))
 	}
@@ -274,113 +283,153 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Proof: `Revive::CodeInfoOf` (`max_values`: None, `max_size`: Some(96), added: 2571, mode: `Measured`)
 	fn set_code() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `492`
-		//  Estimated: `6432`
-		// Minimum execution time: 24_905_000 picoseconds.
-		Weight::from_parts(25_483_000, 6432)
+		//  Measured:  `529`
+		//  Estimated: `6469`
+		// Minimum execution time: 26_992_000 picoseconds.
+		Weight::from_parts(28_781_000, 6469)
 			.saturating_add(T::DbWeight::get().reads(3_u64))
 			.saturating_add(T::DbWeight::get().writes(3_u64))
 	}
+	/// Storage: `Revive::AddressSuffix` (r:1 w:1)
+	/// Proof: `Revive::AddressSuffix` (`max_values`: None, `max_size`: Some(32), added: 2507, mode: `Measured`)
+	/// Storage: `Balances::Holds` (r:1 w:1)
+	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(355), added: 2830, mode: `Measured`)
+	fn map_account() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `109`
+		//  Estimated: `3574`
+		// Minimum execution time: 44_031_000 picoseconds.
+		Weight::from_parts(45_133_000, 3574)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: `Balances::Holds` (r:1 w:1)
+	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(355), added: 2830, mode: `Measured`)
+	/// Storage: `Revive::AddressSuffix` (r:0 w:1)
+	/// Proof: `Revive::AddressSuffix` (`max_values`: None, `max_size`: Some(32), added: 2507, mode: `Measured`)
+	fn unmap_account() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `56`
+		//  Estimated: `3521`
+		// Minimum execution time: 35_681_000 picoseconds.
+		Weight::from_parts(36_331_000, 3521)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: `SafeMode::EnteredUntil` (r:1 w:0)
+	/// Proof: `SafeMode::EnteredUntil` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `Measured`)
+	/// Storage: `TxPause::PausedCalls` (r:1 w:0)
+	/// Proof: `TxPause::PausedCalls` (`max_values`: None, `max_size`: Some(532), added: 3007, mode: `Measured`)
+	fn dispatch_as_fallback_account() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `145`
+		//  Estimated: `3610`
+		// Minimum execution time: 11_550_000 picoseconds.
+		Weight::from_parts(12_114_000, 3610)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+	}
 	/// The range of component `r` is `[0, 1600]`.
 	fn noop_host_fn(r: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 6_979_000 picoseconds.
-		Weight::from_parts(8_272_348, 0)
-			// Standard Error: 137
-			.saturating_add(Weight::from_parts(172_489, 0).saturating_mul(r.into()))
+		// Minimum execution time: 7_063_000 picoseconds.
+		Weight::from_parts(7_671_454, 0)
+			// Standard Error: 105
+			.saturating_add(Weight::from_parts(175_349, 0).saturating_mul(r.into()))
 	}
 	fn seal_caller() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 251_000 picoseconds.
-		Weight::from_parts(318_000, 0)
+		// Minimum execution time: 266_000 picoseconds.
+		Weight::from_parts(313_000, 0)
 	}
 	/// Storage: `Revive::ContractInfoOf` (r:1 w:0)
 	/// Proof: `Revive::ContractInfoOf` (`max_values`: None, `max_size`: Some(1779), added: 4254, mode: `Measured`)
 	fn seal_is_contract() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `272`
-		//  Estimated: `3737`
-		// Minimum execution time: 6_966_000 picoseconds.
-		Weight::from_parts(7_240_000, 3737)
+		//  Measured:  `306`
+		//  Estimated: `3771`
+		// Minimum execution time: 7_397_000 picoseconds.
+		Weight::from_parts(7_967_000, 3771)
 			.saturating_add(T::DbWeight::get().reads(1_u64))
 	}
 	/// Storage: `Revive::ContractInfoOf` (r:1 w:0)
 	/// Proof: `Revive::ContractInfoOf` (`max_values`: None, `max_size`: Some(1779), added: 4254, mode: `Measured`)
 	fn seal_code_hash() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `369`
-		//  Estimated: `3834`
-		// Minimum execution time: 7_589_000 picoseconds.
-		Weight::from_parts(7_958_000, 3834)
+		//  Measured:  `403`
+		//  Estimated: `3868`
+		// Minimum execution time: 8_395_000 picoseconds.
+		Weight::from_parts(8_863_000, 3868)
 			.saturating_add(T::DbWeight::get().reads(1_u64))
 	}
 	fn seal_own_code_hash() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 235_000 picoseconds.
-		Weight::from_parts(285_000, 0)
+		// Minimum execution time: 265_000 picoseconds.
+		Weight::from_parts(292_000, 0)
 	}
 	fn seal_caller_is_origin() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 283_000 picoseconds.
-		Weight::from_parts(326_000, 0)
+		// Minimum execution time: 298_000 picoseconds.
+		Weight::from_parts(334_000, 0)
 	}
 	fn seal_caller_is_root() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 266_000 picoseconds.
-		Weight::from_parts(298_000, 0)
+		// Minimum execution time: 262_000 picoseconds.
+		Weight::from_parts(274_000, 0)
 	}
 	fn seal_address() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 240_000 picoseconds.
-		Weight::from_parts(290_000, 0)
+		// Minimum execution time: 277_000 picoseconds.
+		Weight::from_parts(297_000, 0)
 	}
 	fn seal_weight_left() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 651_000 picoseconds.
-		Weight::from_parts(714_000, 0)
+		// Minimum execution time: 620_000 picoseconds.
+		Weight::from_parts(706_000, 0)
 	}
 	fn seal_balance() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `103`
+		//  Measured:  `140`
 		//  Estimated: `0`
-		// Minimum execution time: 4_476_000 picoseconds.
-		Weight::from_parts(4_671_000, 0)
+		// Minimum execution time: 5_475_000 picoseconds.
+		Weight::from_parts(5_706_000, 0)
 	}
+	/// Storage: `Revive::AddressSuffix` (r:1 w:0)
+	/// Proof: `Revive::AddressSuffix` (`max_values`: None, `max_size`: Some(32), added: 2507, mode: `Measured`)
 	/// Storage: `System::Account` (r:1 w:0)
 	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`)
 	fn seal_balance_of() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `52`
-		//  Estimated: `3517`
-		// Minimum execution time: 3_800_000 picoseconds.
-		Weight::from_parts(3_968_000, 3517)
-			.saturating_add(T::DbWeight::get().reads(1_u64))
+		//  Measured:  `264`
+		//  Estimated: `3729`
+		// Minimum execution time: 9_141_000 picoseconds.
+		Weight::from_parts(9_674_000, 3729)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
 	}
 	/// Storage: `Revive::ImmutableDataOf` (r:1 w:0)
 	/// Proof: `Revive::ImmutableDataOf` (`max_values`: None, `max_size`: Some(4118), added: 6593, mode: `Measured`)
 	/// The range of component `n` is `[1, 4096]`.
 	fn seal_get_immutable_data(n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `205 + n * (1 ±0)`
-		//  Estimated: `3670 + n * (1 ±0)`
-		// Minimum execution time: 5_845_000 picoseconds.
-		Weight::from_parts(6_473_478, 3670)
-			// Standard Error: 4
-			.saturating_add(Weight::from_parts(651, 0).saturating_mul(n.into()))
+		//  Measured:  `238 + n * (1 ±0)`
+		//  Estimated: `3703 + n * (1 ±0)`
+		// Minimum execution time: 6_443_000 picoseconds.
+		Weight::from_parts(7_252_595, 3703)
+			// Standard Error: 12
+			.saturating_add(Weight::from_parts(915, 0).saturating_mul(n.into()))
 			.saturating_add(T::DbWeight::get().reads(1_u64))
 			.saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into()))
 	}
@@ -391,39 +440,39 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 1_980_000 picoseconds.
-		Weight::from_parts(2_324_567, 0)
-			// Standard Error: 3
-			.saturating_add(Weight::from_parts(512, 0).saturating_mul(n.into()))
+		// Minimum execution time: 2_745_000 picoseconds.
+		Weight::from_parts(3_121_250, 0)
+			// Standard Error: 4
+			.saturating_add(Weight::from_parts(627, 0).saturating_mul(n.into()))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
 	fn seal_value_transferred() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 259_000 picoseconds.
-		Weight::from_parts(285_000, 0)
+		// Minimum execution time: 255_000 picoseconds.
+		Weight::from_parts(274_000, 0)
 	}
 	fn seal_minimum_balance() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 244_000 picoseconds.
-		Weight::from_parts(291_000, 0)
+		// Minimum execution time: 235_000 picoseconds.
+		Weight::from_parts(261_000, 0)
 	}
 	fn seal_block_number() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 252_000 picoseconds.
-		Weight::from_parts(291_000, 0)
+		// Minimum execution time: 249_000 picoseconds.
+		Weight::from_parts(263_000, 0)
 	}
 	fn seal_now() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 245_000 picoseconds.
-		Weight::from_parts(277_000, 0)
+		// Minimum execution time: 287_000 picoseconds.
+		Weight::from_parts(300_000, 0)
 	}
 	/// Storage: `TransactionPayment::NextFeeMultiplier` (r:1 w:0)
 	/// Proof: `TransactionPayment::NextFeeMultiplier` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `Measured`)
@@ -431,8 +480,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `67`
 		//  Estimated: `1552`
-		// Minimum execution time: 5_650_000 picoseconds.
-		Weight::from_parts(5_783_000, 1552)
+		// Minimum execution time: 6_147_000 picoseconds.
+		Weight::from_parts(6_562_000, 1552)
 			.saturating_add(T::DbWeight::get().reads(1_u64))
 	}
 	/// The range of component `n` is `[0, 262140]`.
@@ -440,21 +489,23 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 427_000 picoseconds.
-		Weight::from_parts(351_577, 0)
+		// Minimum execution time: 453_000 picoseconds.
+		Weight::from_parts(548_774, 0)
 			// Standard Error: 0
-			.saturating_add(Weight::from_parts(114, 0).saturating_mul(n.into()))
+			.saturating_add(Weight::from_parts(147, 0).saturating_mul(n.into()))
 	}
 	/// The range of component `n` is `[0, 262140]`.
 	fn seal_return(n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 265_000 picoseconds.
-		Weight::from_parts(746_316, 0)
+		// Minimum execution time: 264_000 picoseconds.
+		Weight::from_parts(490_374, 0)
 			// Standard Error: 0
-			.saturating_add(Weight::from_parts(202, 0).saturating_mul(n.into()))
+			.saturating_add(Weight::from_parts(236, 0).saturating_mul(n.into()))
 	}
+	/// Storage: `Revive::AddressSuffix` (r:1 w:0)
+	/// Proof: `Revive::AddressSuffix` (`max_values`: None, `max_size`: Some(32), added: 2507, mode: `Measured`)
 	/// Storage: `Revive::DeletionQueueCounter` (r:1 w:1)
 	/// Proof: `Revive::DeletionQueueCounter` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`)
 	/// Storage: `Revive::CodeInfoOf` (r:33 w:33)
@@ -466,13 +517,13 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// The range of component `n` is `[0, 32]`.
 	fn seal_terminate(n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `272 + n * (88 ±0)`
-		//  Estimated: `3737 + n * (2563 ±0)`
-		// Minimum execution time: 15_988_000 picoseconds.
-		Weight::from_parts(18_796_705, 3737)
-			// Standard Error: 10_437
-			.saturating_add(Weight::from_parts(4_338_085, 0).saturating_mul(n.into()))
-			.saturating_add(T::DbWeight::get().reads(2_u64))
+		//  Measured:  `323 + n * (88 ±0)`
+		//  Estimated: `3788 + n * (2563 ±0)`
+		// Minimum execution time: 22_833_000 picoseconds.
+		Weight::from_parts(24_805_620, 3788)
+			// Standard Error: 9_498
+			.saturating_add(Weight::from_parts(4_486_714, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads(3_u64))
 			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(n.into())))
 			.saturating_add(T::DbWeight::get().writes(4_u64))
 			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(n.into())))
@@ -484,22 +535,22 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 4_237_000 picoseconds.
-		Weight::from_parts(4_128_112, 0)
-			// Standard Error: 2_947
-			.saturating_add(Weight::from_parts(198_825, 0).saturating_mul(t.into()))
-			// Standard Error: 26
-			.saturating_add(Weight::from_parts(1_007, 0).saturating_mul(n.into()))
+		// Minimum execution time: 4_969_000 picoseconds.
+		Weight::from_parts(4_994_916, 0)
+			// Standard Error: 3_727
+			.saturating_add(Weight::from_parts(188_374, 0).saturating_mul(t.into()))
+			// Standard Error: 33
+			.saturating_add(Weight::from_parts(925, 0).saturating_mul(n.into()))
 	}
 	/// The range of component `i` is `[0, 262144]`.
 	fn seal_debug_message(i: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 292_000 picoseconds.
-		Weight::from_parts(1_297_376, 0)
+		// Minimum execution time: 328_000 picoseconds.
+		Weight::from_parts(928_905, 0)
 			// Standard Error: 1
-			.saturating_add(Weight::from_parts(724, 0).saturating_mul(i.into()))
+			.saturating_add(Weight::from_parts(753, 0).saturating_mul(i.into()))
 	}
 	/// Storage: `Skipped::Metadata` (r:0 w:0)
 	/// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`)
@@ -507,8 +558,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `744`
 		//  Estimated: `744`
-		// Minimum execution time: 7_812_000 picoseconds.
-		Weight::from_parts(8_171_000, 744)
+		// Minimum execution time: 8_612_000 picoseconds.
+		Weight::from_parts(9_326_000, 744)
 			.saturating_add(T::DbWeight::get().reads(1_u64))
 	}
 	/// Storage: `Skipped::Metadata` (r:0 w:0)
@@ -517,8 +568,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `10754`
 		//  Estimated: `10754`
-		// Minimum execution time: 44_179_000 picoseconds.
-		Weight::from_parts(45_068_000, 10754)
+		// Minimum execution time: 44_542_000 picoseconds.
+		Weight::from_parts(45_397_000, 10754)
 			.saturating_add(T::DbWeight::get().reads(1_u64))
 	}
 	/// Storage: `Skipped::Metadata` (r:0 w:0)
@@ -527,8 +578,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `744`
 		//  Estimated: `744`
-		// Minimum execution time: 8_964_000 picoseconds.
-		Weight::from_parts(9_336_000, 744)
+		// Minimum execution time: 10_343_000 picoseconds.
+		Weight::from_parts(10_883_000, 744)
 			.saturating_add(T::DbWeight::get().reads(1_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
@@ -538,8 +589,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `10754`
 		//  Estimated: `10754`
-		// Minimum execution time: 45_606_000 picoseconds.
-		Weight::from_parts(47_190_000, 10754)
+		// Minimum execution time: 46_835_000 picoseconds.
+		Weight::from_parts(47_446_000, 10754)
 			.saturating_add(T::DbWeight::get().reads(1_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
@@ -551,12 +602,12 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `248 + o * (1 ±0)`
 		//  Estimated: `247 + o * (1 ±0)`
-		// Minimum execution time: 9_077_000 picoseconds.
-		Weight::from_parts(9_823_489, 247)
-			// Standard Error: 54
-			.saturating_add(Weight::from_parts(392, 0).saturating_mul(n.into()))
-			// Standard Error: 54
-			.saturating_add(Weight::from_parts(408, 0).saturating_mul(o.into()))
+		// Minimum execution time: 10_604_000 picoseconds.
+		Weight::from_parts(11_282_849, 247)
+			// Standard Error: 48
+			.saturating_add(Weight::from_parts(496, 0).saturating_mul(n.into()))
+			// Standard Error: 48
+			.saturating_add(Weight::from_parts(764, 0).saturating_mul(o.into()))
 			.saturating_add(T::DbWeight::get().reads(1_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 			.saturating_add(Weight::from_parts(0, 1).saturating_mul(o.into()))
@@ -568,10 +619,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `248 + n * (1 ±0)`
 		//  Estimated: `247 + n * (1 ±0)`
-		// Minimum execution time: 8_812_000 picoseconds.
-		Weight::from_parts(9_626_925, 247)
-			// Standard Error: 77
-			.saturating_add(Weight::from_parts(269, 0).saturating_mul(n.into()))
+		// Minimum execution time: 10_081_000 picoseconds.
+		Weight::from_parts(11_186_557, 247)
+			// Standard Error: 68
+			.saturating_add(Weight::from_parts(782, 0).saturating_mul(n.into()))
 			.saturating_add(T::DbWeight::get().reads(1_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 			.saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into()))
@@ -583,10 +634,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `248 + n * (1 ±0)`
 		//  Estimated: `247 + n * (1 ±0)`
-		// Minimum execution time: 8_143_000 picoseconds.
-		Weight::from_parts(9_229_363, 247)
-			// Standard Error: 77
-			.saturating_add(Weight::from_parts(1_198, 0).saturating_mul(n.into()))
+		// Minimum execution time: 8_758_000 picoseconds.
+		Weight::from_parts(9_939_492, 247)
+			// Standard Error: 69
+			.saturating_add(Weight::from_parts(1_703, 0).saturating_mul(n.into()))
 			.saturating_add(T::DbWeight::get().reads(1_u64))
 			.saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into()))
 	}
@@ -597,10 +648,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `248 + n * (1 ±0)`
 		//  Estimated: `247 + n * (1 ±0)`
-		// Minimum execution time: 7_899_000 picoseconds.
-		Weight::from_parts(8_591_860, 247)
-			// Standard Error: 56
-			.saturating_add(Weight::from_parts(461, 0).saturating_mul(n.into()))
+		// Minimum execution time: 8_525_000 picoseconds.
+		Weight::from_parts(9_522_265, 247)
+			// Standard Error: 66
+			.saturating_add(Weight::from_parts(426, 0).saturating_mul(n.into()))
 			.saturating_add(T::DbWeight::get().reads(1_u64))
 			.saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into()))
 	}
@@ -611,10 +662,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `248 + n * (1 ±0)`
 		//  Estimated: `247 + n * (1 ±0)`
-		// Minimum execution time: 9_215_000 picoseconds.
-		Weight::from_parts(10_198_528, 247)
-			// Standard Error: 75
-			.saturating_add(Weight::from_parts(1_521, 0).saturating_mul(n.into()))
+		// Minimum execution time: 10_603_000 picoseconds.
+		Weight::from_parts(11_817_752, 247)
+			// Standard Error: 82
+			.saturating_add(Weight::from_parts(1_279, 0).saturating_mul(n.into()))
 			.saturating_add(T::DbWeight::get().reads(1_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 			.saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into()))
@@ -623,36 +674,36 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 1_406_000 picoseconds.
-		Weight::from_parts(1_515_000, 0)
+		// Minimum execution time: 1_553_000 picoseconds.
+		Weight::from_parts(1_615_000, 0)
 	}
 	fn set_transient_storage_full() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 1_782_000 picoseconds.
-		Weight::from_parts(1_890_000, 0)
+		// Minimum execution time: 1_932_000 picoseconds.
+		Weight::from_parts(2_064_000, 0)
 	}
 	fn get_transient_storage_empty() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 1_380_000 picoseconds.
-		Weight::from_parts(1_422_000, 0)
+		// Minimum execution time: 1_510_000 picoseconds.
+		Weight::from_parts(1_545_000, 0)
 	}
 	fn get_transient_storage_full() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 1_504_000 picoseconds.
-		Weight::from_parts(1_583_000, 0)
+		// Minimum execution time: 1_663_000 picoseconds.
+		Weight::from_parts(1_801_000, 0)
 	}
 	fn rollback_transient_storage() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 1_045_000 picoseconds.
-		Weight::from_parts(1_138_000, 0)
+		// Minimum execution time: 1_026_000 picoseconds.
+		Weight::from_parts(1_137_000, 0)
 	}
 	/// The range of component `n` is `[0, 512]`.
 	/// The range of component `o` is `[0, 512]`.
@@ -660,60 +711,63 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 2_039_000 picoseconds.
-		Weight::from_parts(2_317_406, 0)
-			// Standard Error: 13
-			.saturating_add(Weight::from_parts(283, 0).saturating_mul(n.into()))
-			// Standard Error: 13
-			.saturating_add(Weight::from_parts(347, 0).saturating_mul(o.into()))
+		// Minimum execution time: 2_446_000 picoseconds.
+		Weight::from_parts(2_644_525, 0)
+			// Standard Error: 17
+			.saturating_add(Weight::from_parts(113, 0).saturating_mul(n.into()))
+			// Standard Error: 17
+			.saturating_add(Weight::from_parts(179, 0).saturating_mul(o.into()))
 	}
 	/// The range of component `n` is `[0, 512]`.
 	fn seal_clear_transient_storage(n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 1_880_000 picoseconds.
-		Weight::from_parts(2_251_392, 0)
-			// Standard Error: 17
-			.saturating_add(Weight::from_parts(313, 0).saturating_mul(n.into()))
+		// Minimum execution time: 2_085_000 picoseconds.
+		Weight::from_parts(2_379_853, 0)
+			// Standard Error: 19
+			.saturating_add(Weight::from_parts(366, 0).saturating_mul(n.into()))
 	}
 	/// The range of component `n` is `[0, 512]`.
 	fn seal_get_transient_storage(n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 1_763_000 picoseconds.
-		Weight::from_parts(1_951_912, 0)
-			// Standard Error: 13
-			.saturating_add(Weight::from_parts(268, 0).saturating_mul(n.into()))
+		// Minimum execution time: 1_876_000 picoseconds.
+		Weight::from_parts(2_073_689, 0)
+			// Standard Error: 16
+			.saturating_add(Weight::from_parts(376, 0).saturating_mul(n.into()))
 	}
 	/// The range of component `n` is `[0, 512]`.
 	fn seal_contains_transient_storage(n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 1_536_000 picoseconds.
-		Weight::from_parts(1_779_085, 0)
-			// Standard Error: 14
-			.saturating_add(Weight::from_parts(148, 0).saturating_mul(n.into()))
+		// Minimum execution time: 1_688_000 picoseconds.
+		Weight::from_parts(1_914_470, 0)
+			// Standard Error: 15
+			.saturating_add(Weight::from_parts(125, 0).saturating_mul(n.into()))
 	}
 	/// The range of component `n` is `[0, 512]`.
-	fn seal_take_transient_storage(n: u32, ) -> Weight {
+	fn seal_take_transient_storage(_n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 2_343_000 picoseconds.
-		Weight::from_parts(2_587_750, 0)
-			// Standard Error: 22
-			.saturating_add(Weight::from_parts(30, 0).saturating_mul(n.into()))
+		// Minimum execution time: 2_479_000 picoseconds.
+		Weight::from_parts(2_758_250, 0)
 	}
+	/// Storage: `Revive::AddressSuffix` (r:1 w:0)
+	/// Proof: `Revive::AddressSuffix` (`max_values`: None, `max_size`: Some(32), added: 2507, mode: `Measured`)
 	fn seal_transfer() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `103`
-		//  Estimated: `0`
-		// Minimum execution time: 9_250_000 picoseconds.
-		Weight::from_parts(9_637_000, 0)
+		//  Measured:  `352`
+		//  Estimated: `3817`
+		// Minimum execution time: 15_745_000 picoseconds.
+		Weight::from_parts(16_300_000, 3817)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
 	}
+	/// Storage: `Revive::AddressSuffix` (r:1 w:0)
+	/// Proof: `Revive::AddressSuffix` (`max_values`: None, `max_size`: Some(32), added: 2507, mode: `Measured`)
 	/// Storage: `Revive::ContractInfoOf` (r:1 w:0)
 	/// Proof: `Revive::ContractInfoOf` (`max_values`: None, `max_size`: Some(1779), added: 4254, mode: `Measured`)
 	/// Storage: `Revive::CodeInfoOf` (r:1 w:0)
@@ -724,17 +778,17 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// The range of component `i` is `[0, 262144]`.
 	fn seal_call(t: u32, i: u32, ) -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `1221 + t * (103 ±0)`
-		//  Estimated: `4686 + t * (103 ±0)`
-		// Minimum execution time: 33_333_000 picoseconds.
-		Weight::from_parts(34_378_774, 4686)
-			// Standard Error: 41_131
-			.saturating_add(Weight::from_parts(1_756_626, 0).saturating_mul(t.into()))
+		//  Measured:  `1309 + t * (140 ±0)`
+		//  Estimated: `4774 + t * (140 ±0)`
+		// Minimum execution time: 39_639_000 picoseconds.
+		Weight::from_parts(40_909_376, 4774)
+			// Standard Error: 54_479
+			.saturating_add(Weight::from_parts(1_526_185, 0).saturating_mul(t.into()))
 			// Standard Error: 0
-			.saturating_add(Weight::from_parts(3, 0).saturating_mul(i.into()))
-			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(Weight::from_parts(4, 0).saturating_mul(i.into()))
+			.saturating_add(T::DbWeight::get().reads(4_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
-			.saturating_add(Weight::from_parts(0, 103).saturating_mul(t.into()))
+			.saturating_add(Weight::from_parts(0, 140).saturating_mul(t.into()))
 	}
 	/// Storage: `Revive::CodeInfoOf` (r:1 w:0)
 	/// Proof: `Revive::CodeInfoOf` (`max_values`: None, `max_size`: Some(96), added: 2571, mode: `Measured`)
@@ -742,10 +796,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Proof: `Revive::PristineCode` (`max_values`: None, `max_size`: Some(262180), added: 264655, mode: `Measured`)
 	fn seal_delegate_call() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `1048`
-		//  Estimated: `4513`
-		// Minimum execution time: 27_096_000 picoseconds.
-		Weight::from_parts(27_934_000, 4513)
+		//  Measured:  `1081`
+		//  Estimated: `4546`
+		// Minimum execution time: 29_651_000 picoseconds.
+		Weight::from_parts(31_228_000, 4546)
 			.saturating_add(T::DbWeight::get().reads(2_u64))
 	}
 	/// Storage: `Revive::CodeInfoOf` (r:1 w:1)
@@ -759,12 +813,12 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// The range of component `i` is `[0, 262144]`.
 	fn seal_instantiate(i: u32, ) -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `1257`
-		//  Estimated: `4715`
-		// Minimum execution time: 118_412_000 picoseconds.
-		Weight::from_parts(106_130_041, 4715)
-			// Standard Error: 12
-			.saturating_add(Weight::from_parts(4_235, 0).saturating_mul(i.into()))
+		//  Measured:  `1327`
+		//  Estimated: `4792`
+		// Minimum execution time: 126_995_000 picoseconds.
+		Weight::from_parts(114_028_446, 4792)
+			// Standard Error: 11
+			.saturating_add(Weight::from_parts(3_781, 0).saturating_mul(i.into()))
 			.saturating_add(T::DbWeight::get().reads(4_u64))
 			.saturating_add(T::DbWeight::get().writes(3_u64))
 	}
@@ -773,73 +827,73 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 614_000 picoseconds.
-		Weight::from_parts(4_320_897, 0)
-			// Standard Error: 3
-			.saturating_add(Weight::from_parts(1_371, 0).saturating_mul(n.into()))
+		// Minimum execution time: 653_000 picoseconds.
+		Weight::from_parts(973_524, 0)
+			// Standard Error: 0
+			.saturating_add(Weight::from_parts(1_048, 0).saturating_mul(n.into()))
 	}
 	/// The range of component `n` is `[0, 262144]`.
 	fn seal_hash_keccak_256(n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 1_062_000 picoseconds.
-		Weight::from_parts(4_571_371, 0)
-			// Standard Error: 3
-			.saturating_add(Weight::from_parts(3_572, 0).saturating_mul(n.into()))
+		// Minimum execution time: 1_118_000 picoseconds.
+		Weight::from_parts(795_498, 0)
+			// Standard Error: 1
+			.saturating_add(Weight::from_parts(3_260, 0).saturating_mul(n.into()))
 	}
 	/// The range of component `n` is `[0, 262144]`.
 	fn seal_hash_blake2_256(n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 609_000 picoseconds.
-		Weight::from_parts(4_008_056, 0)
-			// Standard Error: 3
-			.saturating_add(Weight::from_parts(1_497, 0).saturating_mul(n.into()))
+		// Minimum execution time: 647_000 picoseconds.
+		Weight::from_parts(667_024, 0)
+			// Standard Error: 0
+			.saturating_add(Weight::from_parts(1_183, 0).saturating_mul(n.into()))
 	}
 	/// The range of component `n` is `[0, 262144]`.
 	fn seal_hash_blake2_128(n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 608_000 picoseconds.
-		Weight::from_parts(3_839_383, 0)
-			// Standard Error: 3
-			.saturating_add(Weight::from_parts(1_504, 0).saturating_mul(n.into()))
+		// Minimum execution time: 605_000 picoseconds.
+		Weight::from_parts(675_568, 0)
+			// Standard Error: 0
+			.saturating_add(Weight::from_parts(1_181, 0).saturating_mul(n.into()))
 	}
 	/// The range of component `n` is `[0, 261889]`.
 	fn seal_sr25519_verify(n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 43_110_000 picoseconds.
-		Weight::from_parts(31_941_593, 0)
-			// Standard Error: 12
-			.saturating_add(Weight::from_parts(5_233, 0).saturating_mul(n.into()))
+		// Minimum execution time: 42_743_000 picoseconds.
+		Weight::from_parts(26_131_984, 0)
+			// Standard Error: 15
+			.saturating_add(Weight::from_parts(4_867, 0).saturating_mul(n.into()))
 	}
 	fn seal_ecdsa_recover() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 47_798_000 picoseconds.
-		Weight::from_parts(49_225_000, 0)
+		// Minimum execution time: 50_838_000 picoseconds.
+		Weight::from_parts(52_248_000, 0)
 	}
 	fn seal_ecdsa_to_eth_address() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 12_576_000 picoseconds.
-		Weight::from_parts(12_731_000, 0)
+		// Minimum execution time: 12_605_000 picoseconds.
+		Weight::from_parts(12_796_000, 0)
 	}
 	/// Storage: `Revive::CodeInfoOf` (r:1 w:1)
 	/// Proof: `Revive::CodeInfoOf` (`max_values`: None, `max_size`: Some(96), added: 2571, mode: `Measured`)
 	fn seal_set_code_hash() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `266`
-		//  Estimated: `3731`
-		// Minimum execution time: 14_306_000 picoseconds.
-		Weight::from_parts(15_011_000, 3731)
+		//  Measured:  `300`
+		//  Estimated: `3765`
+		// Minimum execution time: 16_377_000 picoseconds.
+		Weight::from_parts(16_932_000, 3765)
 			.saturating_add(T::DbWeight::get().reads(1_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
@@ -847,10 +901,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Proof: `Revive::CodeInfoOf` (`max_values`: None, `max_size`: Some(96), added: 2571, mode: `Measured`)
 	fn lock_delegate_dependency() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `303`
-		//  Estimated: `3768`
-		// Minimum execution time: 10_208_000 picoseconds.
-		Weight::from_parts(10_514_000, 3768)
+		//  Measured:  `338`
+		//  Estimated: `3803`
+		// Minimum execution time: 11_499_000 picoseconds.
+		Weight::from_parts(12_104_000, 3803)
 			.saturating_add(T::DbWeight::get().reads(1_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
@@ -858,10 +912,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Proof: `Revive::CodeInfoOf` (`max_values`: None, `max_size`: Some(96), added: 2571, mode: `MaxEncodedLen`)
 	fn unlock_delegate_dependency() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `303`
+		//  Measured:  `338`
 		//  Estimated: `3561`
-		// Minimum execution time: 9_062_000 picoseconds.
-		Weight::from_parts(9_414_000, 3561)
+		// Minimum execution time: 10_308_000 picoseconds.
+		Weight::from_parts(11_000_000, 3561)
 			.saturating_add(T::DbWeight::get().reads(1_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
@@ -870,10 +924,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 8_074_000 picoseconds.
-		Weight::from_parts(9_646_158, 0)
-			// Standard Error: 58
-			.saturating_add(Weight::from_parts(84_694, 0).saturating_mul(r.into()))
+		// Minimum execution time: 8_162_000 picoseconds.
+		Weight::from_parts(9_180_011, 0)
+			// Standard Error: 63
+			.saturating_add(Weight::from_parts(84_822, 0).saturating_mul(r.into()))
 	}
 }
 
@@ -885,8 +939,8 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `109`
 		//  Estimated: `1594`
-		// Minimum execution time: 2_712_000 picoseconds.
-		Weight::from_parts(2_882_000, 1594)
+		// Minimum execution time: 3_053_000 picoseconds.
+		Weight::from_parts(3_150_000, 1594)
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 	}
 	/// Storage: `Skipped::Metadata` (r:0 w:0)
@@ -894,18 +948,20 @@ impl WeightInfo for () {
 	/// The range of component `k` is `[0, 1024]`.
 	fn on_initialize_per_trie_key(k: u32, ) -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `392 + k * (69 ±0)`
-		//  Estimated: `382 + k * (70 ±0)`
-		// Minimum execution time: 13_394_000 picoseconds.
-		Weight::from_parts(13_668_000, 382)
-			// Standard Error: 2_208
-			.saturating_add(Weight::from_parts(1_340_842, 0).saturating_mul(k.into()))
+		//  Measured:  `425 + k * (69 ±0)`
+		//  Estimated: `415 + k * (70 ±0)`
+		// Minimum execution time: 15_219_000 picoseconds.
+		Weight::from_parts(12_576_960, 415)
+			// Standard Error: 1_429
+			.saturating_add(Weight::from_parts(1_341_896, 0).saturating_mul(k.into()))
 			.saturating_add(RocksDbWeight::get().reads(2_u64))
 			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(k.into())))
 			.saturating_add(RocksDbWeight::get().writes(2_u64))
 			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(k.into())))
 			.saturating_add(Weight::from_parts(0, 70).saturating_mul(k.into()))
 	}
+	/// Storage: `Revive::AddressSuffix` (r:2 w:0)
+	/// Proof: `Revive::AddressSuffix` (`max_values`: None, `max_size`: Some(32), added: 2507, mode: `Measured`)
 	/// Storage: `Revive::ContractInfoOf` (r:1 w:1)
 	/// Proof: `Revive::ContractInfoOf` (`max_values`: None, `max_size`: Some(1779), added: 4254, mode: `Measured`)
 	/// Storage: `Revive::CodeInfoOf` (r:1 w:0)
@@ -917,21 +973,21 @@ impl WeightInfo for () {
 	/// Storage: `System::Account` (r:1 w:1)
 	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`)
 	/// The range of component `c` is `[0, 262144]`.
-	fn call_with_code_per_byte(c: u32, ) -> Weight {
+	fn call_with_code_per_byte(_c: u32, ) -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `1466`
-		//  Estimated: `4931`
-		// Minimum execution time: 80_390_000 picoseconds.
-		Weight::from_parts(83_627_295, 4931)
-			// Standard Error: 0
-			.saturating_add(Weight::from_parts(1, 0).saturating_mul(c.into()))
-			.saturating_add(RocksDbWeight::get().reads(5_u64))
+		//  Measured:  `1519`
+		//  Estimated: `7459`
+		// Minimum execution time: 88_906_000 picoseconds.
+		Weight::from_parts(93_353_224, 7459)
+			.saturating_add(RocksDbWeight::get().reads(7_u64))
 			.saturating_add(RocksDbWeight::get().writes(2_u64))
 	}
 	/// Storage: `Revive::CodeInfoOf` (r:1 w:1)
 	/// Proof: `Revive::CodeInfoOf` (`max_values`: None, `max_size`: Some(96), added: 2571, mode: `Measured`)
 	/// Storage: `Balances::Holds` (r:2 w:2)
-	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(337), added: 2812, mode: `Measured`)
+	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(355), added: 2830, mode: `Measured`)
+	/// Storage: `Revive::AddressSuffix` (r:1 w:0)
+	/// Proof: `Revive::AddressSuffix` (`max_values`: None, `max_size`: Some(32), added: 2507, mode: `Measured`)
 	/// Storage: `Revive::ContractInfoOf` (r:1 w:1)
 	/// Proof: `Revive::ContractInfoOf` (`max_values`: None, `max_size`: Some(1779), added: 4254, mode: `Measured`)
 	/// Storage: `Timestamp::Now` (r:1 w:0)
@@ -944,19 +1000,21 @@ impl WeightInfo for () {
 	/// The range of component `i` is `[0, 262144]`.
 	fn instantiate_with_code(_c: u32, i: u32, ) -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `303`
-		//  Estimated: `6232`
-		// Minimum execution time: 184_708_000 picoseconds.
-		Weight::from_parts(177_995_416, 6232)
-			// Standard Error: 11
-			.saturating_add(Weight::from_parts(4_609, 0).saturating_mul(i.into()))
-			.saturating_add(RocksDbWeight::get().reads(6_u64))
+		//  Measured:  `416`
+		//  Estimated: `6360`
+		// Minimum execution time: 202_688_000 picoseconds.
+		Weight::from_parts(197_366_807, 6360)
+			// Standard Error: 13
+			.saturating_add(Weight::from_parts(4_261, 0).saturating_mul(i.into()))
+			.saturating_add(RocksDbWeight::get().reads(7_u64))
 			.saturating_add(RocksDbWeight::get().writes(6_u64))
 	}
 	/// Storage: `Revive::CodeInfoOf` (r:1 w:1)
 	/// Proof: `Revive::CodeInfoOf` (`max_values`: None, `max_size`: Some(96), added: 2571, mode: `Measured`)
 	/// Storage: `Revive::PristineCode` (r:1 w:0)
 	/// Proof: `Revive::PristineCode` (`max_values`: None, `max_size`: Some(262180), added: 264655, mode: `Measured`)
+	/// Storage: `Revive::AddressSuffix` (r:1 w:0)
+	/// Proof: `Revive::AddressSuffix` (`max_values`: None, `max_size`: Some(32), added: 2507, mode: `Measured`)
 	/// Storage: `Revive::ContractInfoOf` (r:1 w:1)
 	/// Proof: `Revive::ContractInfoOf` (`max_values`: None, `max_size`: Some(1779), added: 4254, mode: `Measured`)
 	/// Storage: `Timestamp::Now` (r:1 w:0)
@@ -964,19 +1022,21 @@ impl WeightInfo for () {
 	/// Storage: `System::Account` (r:1 w:1)
 	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`)
 	/// Storage: `Balances::Holds` (r:1 w:1)
-	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(337), added: 2812, mode: `Measured`)
+	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(355), added: 2830, mode: `Measured`)
 	/// The range of component `i` is `[0, 262144]`.
 	fn instantiate(i: u32, ) -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `1261`
-		//  Estimated: `4706`
-		// Minimum execution time: 150_137_000 picoseconds.
-		Weight::from_parts(136_548_469, 4706)
+		//  Measured:  `1313`
+		//  Estimated: `4779`
+		// Minimum execution time: 169_246_000 picoseconds.
+		Weight::from_parts(149_480_457, 4779)
 			// Standard Error: 16
-			.saturating_add(Weight::from_parts(4_531, 0).saturating_mul(i.into()))
-			.saturating_add(RocksDbWeight::get().reads(6_u64))
+			.saturating_add(Weight::from_parts(4_041, 0).saturating_mul(i.into()))
+			.saturating_add(RocksDbWeight::get().reads(7_u64))
 			.saturating_add(RocksDbWeight::get().writes(4_u64))
 	}
+	/// Storage: `Revive::AddressSuffix` (r:2 w:0)
+	/// Proof: `Revive::AddressSuffix` (`max_values`: None, `max_size`: Some(32), added: 2507, mode: `Measured`)
 	/// Storage: `Revive::ContractInfoOf` (r:1 w:1)
 	/// Proof: `Revive::ContractInfoOf` (`max_values`: None, `max_size`: Some(1779), added: 4254, mode: `Measured`)
 	/// Storage: `Revive::CodeInfoOf` (r:1 w:0)
@@ -989,17 +1049,17 @@ impl WeightInfo for () {
 	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`)
 	fn call() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `1466`
-		//  Estimated: `4931`
-		// Minimum execution time: 83_178_000 picoseconds.
-		Weight::from_parts(84_633_000, 4931)
-			.saturating_add(RocksDbWeight::get().reads(5_u64))
+		//  Measured:  `1519`
+		//  Estimated: `7459`
+		// Minimum execution time: 91_129_000 picoseconds.
+		Weight::from_parts(94_220_000, 7459)
+			.saturating_add(RocksDbWeight::get().reads(7_u64))
 			.saturating_add(RocksDbWeight::get().writes(2_u64))
 	}
 	/// Storage: `Revive::CodeInfoOf` (r:1 w:1)
 	/// Proof: `Revive::CodeInfoOf` (`max_values`: None, `max_size`: Some(96), added: 2571, mode: `Measured`)
 	/// Storage: `Balances::Holds` (r:1 w:1)
-	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(337), added: 2812, mode: `Measured`)
+	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(355), added: 2830, mode: `Measured`)
 	/// Storage: `Revive::PristineCode` (r:0 w:1)
 	/// Proof: `Revive::PristineCode` (`max_values`: None, `max_size`: Some(262180), added: 264655, mode: `Measured`)
 	/// The range of component `c` is `[0, 262144]`.
@@ -1007,23 +1067,23 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `109`
 		//  Estimated: `3574`
-		// Minimum execution time: 51_526_000 picoseconds.
-		Weight::from_parts(54_565_973, 3574)
+		// Minimum execution time: 54_849_000 picoseconds.
+		Weight::from_parts(57_508_591, 3574)
 			.saturating_add(RocksDbWeight::get().reads(2_u64))
 			.saturating_add(RocksDbWeight::get().writes(3_u64))
 	}
 	/// Storage: `Revive::CodeInfoOf` (r:1 w:1)
 	/// Proof: `Revive::CodeInfoOf` (`max_values`: None, `max_size`: Some(96), added: 2571, mode: `Measured`)
 	/// Storage: `Balances::Holds` (r:1 w:1)
-	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(337), added: 2812, mode: `Measured`)
+	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(355), added: 2830, mode: `Measured`)
 	/// Storage: `Revive::PristineCode` (r:0 w:1)
 	/// Proof: `Revive::PristineCode` (`max_values`: None, `max_size`: Some(262180), added: 264655, mode: `Measured`)
 	fn remove_code() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `285`
 		//  Estimated: `3750`
-		// Minimum execution time: 41_885_000 picoseconds.
-		Weight::from_parts(42_467_000, 3750)
+		// Minimum execution time: 45_017_000 picoseconds.
+		Weight::from_parts(46_312_000, 3750)
 			.saturating_add(RocksDbWeight::get().reads(2_u64))
 			.saturating_add(RocksDbWeight::get().writes(3_u64))
 	}
@@ -1033,113 +1093,153 @@ impl WeightInfo for () {
 	/// Proof: `Revive::CodeInfoOf` (`max_values`: None, `max_size`: Some(96), added: 2571, mode: `Measured`)
 	fn set_code() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `492`
-		//  Estimated: `6432`
-		// Minimum execution time: 24_905_000 picoseconds.
-		Weight::from_parts(25_483_000, 6432)
+		//  Measured:  `529`
+		//  Estimated: `6469`
+		// Minimum execution time: 26_992_000 picoseconds.
+		Weight::from_parts(28_781_000, 6469)
 			.saturating_add(RocksDbWeight::get().reads(3_u64))
 			.saturating_add(RocksDbWeight::get().writes(3_u64))
 	}
+	/// Storage: `Revive::AddressSuffix` (r:1 w:1)
+	/// Proof: `Revive::AddressSuffix` (`max_values`: None, `max_size`: Some(32), added: 2507, mode: `Measured`)
+	/// Storage: `Balances::Holds` (r:1 w:1)
+	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(355), added: 2830, mode: `Measured`)
+	fn map_account() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `109`
+		//  Estimated: `3574`
+		// Minimum execution time: 44_031_000 picoseconds.
+		Weight::from_parts(45_133_000, 3574)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: `Balances::Holds` (r:1 w:1)
+	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(355), added: 2830, mode: `Measured`)
+	/// Storage: `Revive::AddressSuffix` (r:0 w:1)
+	/// Proof: `Revive::AddressSuffix` (`max_values`: None, `max_size`: Some(32), added: 2507, mode: `Measured`)
+	fn unmap_account() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `56`
+		//  Estimated: `3521`
+		// Minimum execution time: 35_681_000 picoseconds.
+		Weight::from_parts(36_331_000, 3521)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: `SafeMode::EnteredUntil` (r:1 w:0)
+	/// Proof: `SafeMode::EnteredUntil` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `Measured`)
+	/// Storage: `TxPause::PausedCalls` (r:1 w:0)
+	/// Proof: `TxPause::PausedCalls` (`max_values`: None, `max_size`: Some(532), added: 3007, mode: `Measured`)
+	fn dispatch_as_fallback_account() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `145`
+		//  Estimated: `3610`
+		// Minimum execution time: 11_550_000 picoseconds.
+		Weight::from_parts(12_114_000, 3610)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+	}
 	/// The range of component `r` is `[0, 1600]`.
 	fn noop_host_fn(r: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 6_979_000 picoseconds.
-		Weight::from_parts(8_272_348, 0)
-			// Standard Error: 137
-			.saturating_add(Weight::from_parts(172_489, 0).saturating_mul(r.into()))
+		// Minimum execution time: 7_063_000 picoseconds.
+		Weight::from_parts(7_671_454, 0)
+			// Standard Error: 105
+			.saturating_add(Weight::from_parts(175_349, 0).saturating_mul(r.into()))
 	}
 	fn seal_caller() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 251_000 picoseconds.
-		Weight::from_parts(318_000, 0)
+		// Minimum execution time: 266_000 picoseconds.
+		Weight::from_parts(313_000, 0)
 	}
 	/// Storage: `Revive::ContractInfoOf` (r:1 w:0)
 	/// Proof: `Revive::ContractInfoOf` (`max_values`: None, `max_size`: Some(1779), added: 4254, mode: `Measured`)
 	fn seal_is_contract() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `272`
-		//  Estimated: `3737`
-		// Minimum execution time: 6_966_000 picoseconds.
-		Weight::from_parts(7_240_000, 3737)
+		//  Measured:  `306`
+		//  Estimated: `3771`
+		// Minimum execution time: 7_397_000 picoseconds.
+		Weight::from_parts(7_967_000, 3771)
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 	}
 	/// Storage: `Revive::ContractInfoOf` (r:1 w:0)
 	/// Proof: `Revive::ContractInfoOf` (`max_values`: None, `max_size`: Some(1779), added: 4254, mode: `Measured`)
 	fn seal_code_hash() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `369`
-		//  Estimated: `3834`
-		// Minimum execution time: 7_589_000 picoseconds.
-		Weight::from_parts(7_958_000, 3834)
+		//  Measured:  `403`
+		//  Estimated: `3868`
+		// Minimum execution time: 8_395_000 picoseconds.
+		Weight::from_parts(8_863_000, 3868)
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 	}
 	fn seal_own_code_hash() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 235_000 picoseconds.
-		Weight::from_parts(285_000, 0)
+		// Minimum execution time: 265_000 picoseconds.
+		Weight::from_parts(292_000, 0)
 	}
 	fn seal_caller_is_origin() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 283_000 picoseconds.
-		Weight::from_parts(326_000, 0)
+		// Minimum execution time: 298_000 picoseconds.
+		Weight::from_parts(334_000, 0)
 	}
 	fn seal_caller_is_root() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 266_000 picoseconds.
-		Weight::from_parts(298_000, 0)
+		// Minimum execution time: 262_000 picoseconds.
+		Weight::from_parts(274_000, 0)
 	}
 	fn seal_address() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 240_000 picoseconds.
-		Weight::from_parts(290_000, 0)
+		// Minimum execution time: 277_000 picoseconds.
+		Weight::from_parts(297_000, 0)
 	}
 	fn seal_weight_left() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 651_000 picoseconds.
-		Weight::from_parts(714_000, 0)
+		// Minimum execution time: 620_000 picoseconds.
+		Weight::from_parts(706_000, 0)
 	}
 	fn seal_balance() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `103`
+		//  Measured:  `140`
 		//  Estimated: `0`
-		// Minimum execution time: 4_476_000 picoseconds.
-		Weight::from_parts(4_671_000, 0)
+		// Minimum execution time: 5_475_000 picoseconds.
+		Weight::from_parts(5_706_000, 0)
 	}
+	/// Storage: `Revive::AddressSuffix` (r:1 w:0)
+	/// Proof: `Revive::AddressSuffix` (`max_values`: None, `max_size`: Some(32), added: 2507, mode: `Measured`)
 	/// Storage: `System::Account` (r:1 w:0)
 	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`)
 	fn seal_balance_of() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `52`
-		//  Estimated: `3517`
-		// Minimum execution time: 3_800_000 picoseconds.
-		Weight::from_parts(3_968_000, 3517)
-			.saturating_add(RocksDbWeight::get().reads(1_u64))
+		//  Measured:  `264`
+		//  Estimated: `3729`
+		// Minimum execution time: 9_141_000 picoseconds.
+		Weight::from_parts(9_674_000, 3729)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
 	}
 	/// Storage: `Revive::ImmutableDataOf` (r:1 w:0)
 	/// Proof: `Revive::ImmutableDataOf` (`max_values`: None, `max_size`: Some(4118), added: 6593, mode: `Measured`)
 	/// The range of component `n` is `[1, 4096]`.
 	fn seal_get_immutable_data(n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `205 + n * (1 ±0)`
-		//  Estimated: `3670 + n * (1 ±0)`
-		// Minimum execution time: 5_845_000 picoseconds.
-		Weight::from_parts(6_473_478, 3670)
-			// Standard Error: 4
-			.saturating_add(Weight::from_parts(651, 0).saturating_mul(n.into()))
+		//  Measured:  `238 + n * (1 ±0)`
+		//  Estimated: `3703 + n * (1 ±0)`
+		// Minimum execution time: 6_443_000 picoseconds.
+		Weight::from_parts(7_252_595, 3703)
+			// Standard Error: 12
+			.saturating_add(Weight::from_parts(915, 0).saturating_mul(n.into()))
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 			.saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into()))
 	}
@@ -1150,39 +1250,39 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 1_980_000 picoseconds.
-		Weight::from_parts(2_324_567, 0)
-			// Standard Error: 3
-			.saturating_add(Weight::from_parts(512, 0).saturating_mul(n.into()))
+		// Minimum execution time: 2_745_000 picoseconds.
+		Weight::from_parts(3_121_250, 0)
+			// Standard Error: 4
+			.saturating_add(Weight::from_parts(627, 0).saturating_mul(n.into()))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
 	fn seal_value_transferred() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 259_000 picoseconds.
-		Weight::from_parts(285_000, 0)
+		// Minimum execution time: 255_000 picoseconds.
+		Weight::from_parts(274_000, 0)
 	}
 	fn seal_minimum_balance() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 244_000 picoseconds.
-		Weight::from_parts(291_000, 0)
+		// Minimum execution time: 235_000 picoseconds.
+		Weight::from_parts(261_000, 0)
 	}
 	fn seal_block_number() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 252_000 picoseconds.
-		Weight::from_parts(291_000, 0)
+		// Minimum execution time: 249_000 picoseconds.
+		Weight::from_parts(263_000, 0)
 	}
 	fn seal_now() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 245_000 picoseconds.
-		Weight::from_parts(277_000, 0)
+		// Minimum execution time: 287_000 picoseconds.
+		Weight::from_parts(300_000, 0)
 	}
 	/// Storage: `TransactionPayment::NextFeeMultiplier` (r:1 w:0)
 	/// Proof: `TransactionPayment::NextFeeMultiplier` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `Measured`)
@@ -1190,8 +1290,8 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `67`
 		//  Estimated: `1552`
-		// Minimum execution time: 5_650_000 picoseconds.
-		Weight::from_parts(5_783_000, 1552)
+		// Minimum execution time: 6_147_000 picoseconds.
+		Weight::from_parts(6_562_000, 1552)
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 	}
 	/// The range of component `n` is `[0, 262140]`.
@@ -1199,21 +1299,23 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 427_000 picoseconds.
-		Weight::from_parts(351_577, 0)
+		// Minimum execution time: 453_000 picoseconds.
+		Weight::from_parts(548_774, 0)
 			// Standard Error: 0
-			.saturating_add(Weight::from_parts(114, 0).saturating_mul(n.into()))
+			.saturating_add(Weight::from_parts(147, 0).saturating_mul(n.into()))
 	}
 	/// The range of component `n` is `[0, 262140]`.
 	fn seal_return(n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 265_000 picoseconds.
-		Weight::from_parts(746_316, 0)
+		// Minimum execution time: 264_000 picoseconds.
+		Weight::from_parts(490_374, 0)
 			// Standard Error: 0
-			.saturating_add(Weight::from_parts(202, 0).saturating_mul(n.into()))
+			.saturating_add(Weight::from_parts(236, 0).saturating_mul(n.into()))
 	}
+	/// Storage: `Revive::AddressSuffix` (r:1 w:0)
+	/// Proof: `Revive::AddressSuffix` (`max_values`: None, `max_size`: Some(32), added: 2507, mode: `Measured`)
 	/// Storage: `Revive::DeletionQueueCounter` (r:1 w:1)
 	/// Proof: `Revive::DeletionQueueCounter` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`)
 	/// Storage: `Revive::CodeInfoOf` (r:33 w:33)
@@ -1225,13 +1327,13 @@ impl WeightInfo for () {
 	/// The range of component `n` is `[0, 32]`.
 	fn seal_terminate(n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `272 + n * (88 ±0)`
-		//  Estimated: `3737 + n * (2563 ±0)`
-		// Minimum execution time: 15_988_000 picoseconds.
-		Weight::from_parts(18_796_705, 3737)
-			// Standard Error: 10_437
-			.saturating_add(Weight::from_parts(4_338_085, 0).saturating_mul(n.into()))
-			.saturating_add(RocksDbWeight::get().reads(2_u64))
+		//  Measured:  `323 + n * (88 ±0)`
+		//  Estimated: `3788 + n * (2563 ±0)`
+		// Minimum execution time: 22_833_000 picoseconds.
+		Weight::from_parts(24_805_620, 3788)
+			// Standard Error: 9_498
+			.saturating_add(Weight::from_parts(4_486_714, 0).saturating_mul(n.into()))
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
 			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(n.into())))
 			.saturating_add(RocksDbWeight::get().writes(4_u64))
 			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(n.into())))
@@ -1243,22 +1345,22 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 4_237_000 picoseconds.
-		Weight::from_parts(4_128_112, 0)
-			// Standard Error: 2_947
-			.saturating_add(Weight::from_parts(198_825, 0).saturating_mul(t.into()))
-			// Standard Error: 26
-			.saturating_add(Weight::from_parts(1_007, 0).saturating_mul(n.into()))
+		// Minimum execution time: 4_969_000 picoseconds.
+		Weight::from_parts(4_994_916, 0)
+			// Standard Error: 3_727
+			.saturating_add(Weight::from_parts(188_374, 0).saturating_mul(t.into()))
+			// Standard Error: 33
+			.saturating_add(Weight::from_parts(925, 0).saturating_mul(n.into()))
 	}
 	/// The range of component `i` is `[0, 262144]`.
 	fn seal_debug_message(i: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 292_000 picoseconds.
-		Weight::from_parts(1_297_376, 0)
+		// Minimum execution time: 328_000 picoseconds.
+		Weight::from_parts(928_905, 0)
 			// Standard Error: 1
-			.saturating_add(Weight::from_parts(724, 0).saturating_mul(i.into()))
+			.saturating_add(Weight::from_parts(753, 0).saturating_mul(i.into()))
 	}
 	/// Storage: `Skipped::Metadata` (r:0 w:0)
 	/// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`)
@@ -1266,8 +1368,8 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `744`
 		//  Estimated: `744`
-		// Minimum execution time: 7_812_000 picoseconds.
-		Weight::from_parts(8_171_000, 744)
+		// Minimum execution time: 8_612_000 picoseconds.
+		Weight::from_parts(9_326_000, 744)
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 	}
 	/// Storage: `Skipped::Metadata` (r:0 w:0)
@@ -1276,8 +1378,8 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `10754`
 		//  Estimated: `10754`
-		// Minimum execution time: 44_179_000 picoseconds.
-		Weight::from_parts(45_068_000, 10754)
+		// Minimum execution time: 44_542_000 picoseconds.
+		Weight::from_parts(45_397_000, 10754)
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 	}
 	/// Storage: `Skipped::Metadata` (r:0 w:0)
@@ -1286,8 +1388,8 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `744`
 		//  Estimated: `744`
-		// Minimum execution time: 8_964_000 picoseconds.
-		Weight::from_parts(9_336_000, 744)
+		// Minimum execution time: 10_343_000 picoseconds.
+		Weight::from_parts(10_883_000, 744)
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
@@ -1297,8 +1399,8 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `10754`
 		//  Estimated: `10754`
-		// Minimum execution time: 45_606_000 picoseconds.
-		Weight::from_parts(47_190_000, 10754)
+		// Minimum execution time: 46_835_000 picoseconds.
+		Weight::from_parts(47_446_000, 10754)
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
@@ -1310,12 +1412,12 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `248 + o * (1 ±0)`
 		//  Estimated: `247 + o * (1 ±0)`
-		// Minimum execution time: 9_077_000 picoseconds.
-		Weight::from_parts(9_823_489, 247)
-			// Standard Error: 54
-			.saturating_add(Weight::from_parts(392, 0).saturating_mul(n.into()))
-			// Standard Error: 54
-			.saturating_add(Weight::from_parts(408, 0).saturating_mul(o.into()))
+		// Minimum execution time: 10_604_000 picoseconds.
+		Weight::from_parts(11_282_849, 247)
+			// Standard Error: 48
+			.saturating_add(Weight::from_parts(496, 0).saturating_mul(n.into()))
+			// Standard Error: 48
+			.saturating_add(Weight::from_parts(764, 0).saturating_mul(o.into()))
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 			.saturating_add(Weight::from_parts(0, 1).saturating_mul(o.into()))
@@ -1327,10 +1429,10 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `248 + n * (1 ±0)`
 		//  Estimated: `247 + n * (1 ±0)`
-		// Minimum execution time: 8_812_000 picoseconds.
-		Weight::from_parts(9_626_925, 247)
-			// Standard Error: 77
-			.saturating_add(Weight::from_parts(269, 0).saturating_mul(n.into()))
+		// Minimum execution time: 10_081_000 picoseconds.
+		Weight::from_parts(11_186_557, 247)
+			// Standard Error: 68
+			.saturating_add(Weight::from_parts(782, 0).saturating_mul(n.into()))
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 			.saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into()))
@@ -1342,10 +1444,10 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `248 + n * (1 ±0)`
 		//  Estimated: `247 + n * (1 ±0)`
-		// Minimum execution time: 8_143_000 picoseconds.
-		Weight::from_parts(9_229_363, 247)
-			// Standard Error: 77
-			.saturating_add(Weight::from_parts(1_198, 0).saturating_mul(n.into()))
+		// Minimum execution time: 8_758_000 picoseconds.
+		Weight::from_parts(9_939_492, 247)
+			// Standard Error: 69
+			.saturating_add(Weight::from_parts(1_703, 0).saturating_mul(n.into()))
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 			.saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into()))
 	}
@@ -1356,10 +1458,10 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `248 + n * (1 ±0)`
 		//  Estimated: `247 + n * (1 ±0)`
-		// Minimum execution time: 7_899_000 picoseconds.
-		Weight::from_parts(8_591_860, 247)
-			// Standard Error: 56
-			.saturating_add(Weight::from_parts(461, 0).saturating_mul(n.into()))
+		// Minimum execution time: 8_525_000 picoseconds.
+		Weight::from_parts(9_522_265, 247)
+			// Standard Error: 66
+			.saturating_add(Weight::from_parts(426, 0).saturating_mul(n.into()))
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 			.saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into()))
 	}
@@ -1370,10 +1472,10 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `248 + n * (1 ±0)`
 		//  Estimated: `247 + n * (1 ±0)`
-		// Minimum execution time: 9_215_000 picoseconds.
-		Weight::from_parts(10_198_528, 247)
-			// Standard Error: 75
-			.saturating_add(Weight::from_parts(1_521, 0).saturating_mul(n.into()))
+		// Minimum execution time: 10_603_000 picoseconds.
+		Weight::from_parts(11_817_752, 247)
+			// Standard Error: 82
+			.saturating_add(Weight::from_parts(1_279, 0).saturating_mul(n.into()))
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 			.saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into()))
@@ -1382,36 +1484,36 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 1_406_000 picoseconds.
-		Weight::from_parts(1_515_000, 0)
+		// Minimum execution time: 1_553_000 picoseconds.
+		Weight::from_parts(1_615_000, 0)
 	}
 	fn set_transient_storage_full() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 1_782_000 picoseconds.
-		Weight::from_parts(1_890_000, 0)
+		// Minimum execution time: 1_932_000 picoseconds.
+		Weight::from_parts(2_064_000, 0)
 	}
 	fn get_transient_storage_empty() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 1_380_000 picoseconds.
-		Weight::from_parts(1_422_000, 0)
+		// Minimum execution time: 1_510_000 picoseconds.
+		Weight::from_parts(1_545_000, 0)
 	}
 	fn get_transient_storage_full() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 1_504_000 picoseconds.
-		Weight::from_parts(1_583_000, 0)
+		// Minimum execution time: 1_663_000 picoseconds.
+		Weight::from_parts(1_801_000, 0)
 	}
 	fn rollback_transient_storage() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 1_045_000 picoseconds.
-		Weight::from_parts(1_138_000, 0)
+		// Minimum execution time: 1_026_000 picoseconds.
+		Weight::from_parts(1_137_000, 0)
 	}
 	/// The range of component `n` is `[0, 512]`.
 	/// The range of component `o` is `[0, 512]`.
@@ -1419,60 +1521,63 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 2_039_000 picoseconds.
-		Weight::from_parts(2_317_406, 0)
-			// Standard Error: 13
-			.saturating_add(Weight::from_parts(283, 0).saturating_mul(n.into()))
-			// Standard Error: 13
-			.saturating_add(Weight::from_parts(347, 0).saturating_mul(o.into()))
+		// Minimum execution time: 2_446_000 picoseconds.
+		Weight::from_parts(2_644_525, 0)
+			// Standard Error: 17
+			.saturating_add(Weight::from_parts(113, 0).saturating_mul(n.into()))
+			// Standard Error: 17
+			.saturating_add(Weight::from_parts(179, 0).saturating_mul(o.into()))
 	}
 	/// The range of component `n` is `[0, 512]`.
 	fn seal_clear_transient_storage(n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 1_880_000 picoseconds.
-		Weight::from_parts(2_251_392, 0)
-			// Standard Error: 17
-			.saturating_add(Weight::from_parts(313, 0).saturating_mul(n.into()))
+		// Minimum execution time: 2_085_000 picoseconds.
+		Weight::from_parts(2_379_853, 0)
+			// Standard Error: 19
+			.saturating_add(Weight::from_parts(366, 0).saturating_mul(n.into()))
 	}
 	/// The range of component `n` is `[0, 512]`.
 	fn seal_get_transient_storage(n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 1_763_000 picoseconds.
-		Weight::from_parts(1_951_912, 0)
-			// Standard Error: 13
-			.saturating_add(Weight::from_parts(268, 0).saturating_mul(n.into()))
+		// Minimum execution time: 1_876_000 picoseconds.
+		Weight::from_parts(2_073_689, 0)
+			// Standard Error: 16
+			.saturating_add(Weight::from_parts(376, 0).saturating_mul(n.into()))
 	}
 	/// The range of component `n` is `[0, 512]`.
 	fn seal_contains_transient_storage(n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 1_536_000 picoseconds.
-		Weight::from_parts(1_779_085, 0)
-			// Standard Error: 14
-			.saturating_add(Weight::from_parts(148, 0).saturating_mul(n.into()))
+		// Minimum execution time: 1_688_000 picoseconds.
+		Weight::from_parts(1_914_470, 0)
+			// Standard Error: 15
+			.saturating_add(Weight::from_parts(125, 0).saturating_mul(n.into()))
 	}
 	/// The range of component `n` is `[0, 512]`.
-	fn seal_take_transient_storage(n: u32, ) -> Weight {
+	fn seal_take_transient_storage(_n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 2_343_000 picoseconds.
-		Weight::from_parts(2_587_750, 0)
-			// Standard Error: 22
-			.saturating_add(Weight::from_parts(30, 0).saturating_mul(n.into()))
+		// Minimum execution time: 2_479_000 picoseconds.
+		Weight::from_parts(2_758_250, 0)
 	}
+	/// Storage: `Revive::AddressSuffix` (r:1 w:0)
+	/// Proof: `Revive::AddressSuffix` (`max_values`: None, `max_size`: Some(32), added: 2507, mode: `Measured`)
 	fn seal_transfer() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `103`
-		//  Estimated: `0`
-		// Minimum execution time: 9_250_000 picoseconds.
-		Weight::from_parts(9_637_000, 0)
+		//  Measured:  `352`
+		//  Estimated: `3817`
+		// Minimum execution time: 15_745_000 picoseconds.
+		Weight::from_parts(16_300_000, 3817)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
 	}
+	/// Storage: `Revive::AddressSuffix` (r:1 w:0)
+	/// Proof: `Revive::AddressSuffix` (`max_values`: None, `max_size`: Some(32), added: 2507, mode: `Measured`)
 	/// Storage: `Revive::ContractInfoOf` (r:1 w:0)
 	/// Proof: `Revive::ContractInfoOf` (`max_values`: None, `max_size`: Some(1779), added: 4254, mode: `Measured`)
 	/// Storage: `Revive::CodeInfoOf` (r:1 w:0)
@@ -1483,17 +1588,17 @@ impl WeightInfo for () {
 	/// The range of component `i` is `[0, 262144]`.
 	fn seal_call(t: u32, i: u32, ) -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `1221 + t * (103 ±0)`
-		//  Estimated: `4686 + t * (103 ±0)`
-		// Minimum execution time: 33_333_000 picoseconds.
-		Weight::from_parts(34_378_774, 4686)
-			// Standard Error: 41_131
-			.saturating_add(Weight::from_parts(1_756_626, 0).saturating_mul(t.into()))
+		//  Measured:  `1309 + t * (140 ±0)`
+		//  Estimated: `4774 + t * (140 ±0)`
+		// Minimum execution time: 39_639_000 picoseconds.
+		Weight::from_parts(40_909_376, 4774)
+			// Standard Error: 54_479
+			.saturating_add(Weight::from_parts(1_526_185, 0).saturating_mul(t.into()))
 			// Standard Error: 0
-			.saturating_add(Weight::from_parts(3, 0).saturating_mul(i.into()))
-			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(Weight::from_parts(4, 0).saturating_mul(i.into()))
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
-			.saturating_add(Weight::from_parts(0, 103).saturating_mul(t.into()))
+			.saturating_add(Weight::from_parts(0, 140).saturating_mul(t.into()))
 	}
 	/// Storage: `Revive::CodeInfoOf` (r:1 w:0)
 	/// Proof: `Revive::CodeInfoOf` (`max_values`: None, `max_size`: Some(96), added: 2571, mode: `Measured`)
@@ -1501,10 +1606,10 @@ impl WeightInfo for () {
 	/// Proof: `Revive::PristineCode` (`max_values`: None, `max_size`: Some(262180), added: 264655, mode: `Measured`)
 	fn seal_delegate_call() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `1048`
-		//  Estimated: `4513`
-		// Minimum execution time: 27_096_000 picoseconds.
-		Weight::from_parts(27_934_000, 4513)
+		//  Measured:  `1081`
+		//  Estimated: `4546`
+		// Minimum execution time: 29_651_000 picoseconds.
+		Weight::from_parts(31_228_000, 4546)
 			.saturating_add(RocksDbWeight::get().reads(2_u64))
 	}
 	/// Storage: `Revive::CodeInfoOf` (r:1 w:1)
@@ -1518,12 +1623,12 @@ impl WeightInfo for () {
 	/// The range of component `i` is `[0, 262144]`.
 	fn seal_instantiate(i: u32, ) -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `1257`
-		//  Estimated: `4715`
-		// Minimum execution time: 118_412_000 picoseconds.
-		Weight::from_parts(106_130_041, 4715)
-			// Standard Error: 12
-			.saturating_add(Weight::from_parts(4_235, 0).saturating_mul(i.into()))
+		//  Measured:  `1327`
+		//  Estimated: `4792`
+		// Minimum execution time: 126_995_000 picoseconds.
+		Weight::from_parts(114_028_446, 4792)
+			// Standard Error: 11
+			.saturating_add(Weight::from_parts(3_781, 0).saturating_mul(i.into()))
 			.saturating_add(RocksDbWeight::get().reads(4_u64))
 			.saturating_add(RocksDbWeight::get().writes(3_u64))
 	}
@@ -1532,73 +1637,73 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 614_000 picoseconds.
-		Weight::from_parts(4_320_897, 0)
-			// Standard Error: 3
-			.saturating_add(Weight::from_parts(1_371, 0).saturating_mul(n.into()))
+		// Minimum execution time: 653_000 picoseconds.
+		Weight::from_parts(973_524, 0)
+			// Standard Error: 0
+			.saturating_add(Weight::from_parts(1_048, 0).saturating_mul(n.into()))
 	}
 	/// The range of component `n` is `[0, 262144]`.
 	fn seal_hash_keccak_256(n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 1_062_000 picoseconds.
-		Weight::from_parts(4_571_371, 0)
-			// Standard Error: 3
-			.saturating_add(Weight::from_parts(3_572, 0).saturating_mul(n.into()))
+		// Minimum execution time: 1_118_000 picoseconds.
+		Weight::from_parts(795_498, 0)
+			// Standard Error: 1
+			.saturating_add(Weight::from_parts(3_260, 0).saturating_mul(n.into()))
 	}
 	/// The range of component `n` is `[0, 262144]`.
 	fn seal_hash_blake2_256(n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 609_000 picoseconds.
-		Weight::from_parts(4_008_056, 0)
-			// Standard Error: 3
-			.saturating_add(Weight::from_parts(1_497, 0).saturating_mul(n.into()))
+		// Minimum execution time: 647_000 picoseconds.
+		Weight::from_parts(667_024, 0)
+			// Standard Error: 0
+			.saturating_add(Weight::from_parts(1_183, 0).saturating_mul(n.into()))
 	}
 	/// The range of component `n` is `[0, 262144]`.
 	fn seal_hash_blake2_128(n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 608_000 picoseconds.
-		Weight::from_parts(3_839_383, 0)
-			// Standard Error: 3
-			.saturating_add(Weight::from_parts(1_504, 0).saturating_mul(n.into()))
+		// Minimum execution time: 605_000 picoseconds.
+		Weight::from_parts(675_568, 0)
+			// Standard Error: 0
+			.saturating_add(Weight::from_parts(1_181, 0).saturating_mul(n.into()))
 	}
 	/// The range of component `n` is `[0, 261889]`.
 	fn seal_sr25519_verify(n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 43_110_000 picoseconds.
-		Weight::from_parts(31_941_593, 0)
-			// Standard Error: 12
-			.saturating_add(Weight::from_parts(5_233, 0).saturating_mul(n.into()))
+		// Minimum execution time: 42_743_000 picoseconds.
+		Weight::from_parts(26_131_984, 0)
+			// Standard Error: 15
+			.saturating_add(Weight::from_parts(4_867, 0).saturating_mul(n.into()))
 	}
 	fn seal_ecdsa_recover() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 47_798_000 picoseconds.
-		Weight::from_parts(49_225_000, 0)
+		// Minimum execution time: 50_838_000 picoseconds.
+		Weight::from_parts(52_248_000, 0)
 	}
 	fn seal_ecdsa_to_eth_address() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 12_576_000 picoseconds.
-		Weight::from_parts(12_731_000, 0)
+		// Minimum execution time: 12_605_000 picoseconds.
+		Weight::from_parts(12_796_000, 0)
 	}
 	/// Storage: `Revive::CodeInfoOf` (r:1 w:1)
 	/// Proof: `Revive::CodeInfoOf` (`max_values`: None, `max_size`: Some(96), added: 2571, mode: `Measured`)
 	fn seal_set_code_hash() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `266`
-		//  Estimated: `3731`
-		// Minimum execution time: 14_306_000 picoseconds.
-		Weight::from_parts(15_011_000, 3731)
+		//  Measured:  `300`
+		//  Estimated: `3765`
+		// Minimum execution time: 16_377_000 picoseconds.
+		Weight::from_parts(16_932_000, 3765)
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
@@ -1606,10 +1711,10 @@ impl WeightInfo for () {
 	/// Proof: `Revive::CodeInfoOf` (`max_values`: None, `max_size`: Some(96), added: 2571, mode: `Measured`)
 	fn lock_delegate_dependency() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `303`
-		//  Estimated: `3768`
-		// Minimum execution time: 10_208_000 picoseconds.
-		Weight::from_parts(10_514_000, 3768)
+		//  Measured:  `338`
+		//  Estimated: `3803`
+		// Minimum execution time: 11_499_000 picoseconds.
+		Weight::from_parts(12_104_000, 3803)
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
@@ -1617,10 +1722,10 @@ impl WeightInfo for () {
 	/// Proof: `Revive::CodeInfoOf` (`max_values`: None, `max_size`: Some(96), added: 2571, mode: `MaxEncodedLen`)
 	fn unlock_delegate_dependency() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `303`
+		//  Measured:  `338`
 		//  Estimated: `3561`
-		// Minimum execution time: 9_062_000 picoseconds.
-		Weight::from_parts(9_414_000, 3561)
+		// Minimum execution time: 10_308_000 picoseconds.
+		Weight::from_parts(11_000_000, 3561)
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
@@ -1629,9 +1734,9 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 8_074_000 picoseconds.
-		Weight::from_parts(9_646_158, 0)
-			// Standard Error: 58
-			.saturating_add(Weight::from_parts(84_694, 0).saturating_mul(r.into()))
+		// Minimum execution time: 8_162_000 picoseconds.
+		Weight::from_parts(9_180_011, 0)
+			// Standard Error: 63
+			.saturating_add(Weight::from_parts(84_822, 0).saturating_mul(r.into()))
 	}
 }