mock.rs

// Copyright 2019-2025 PureStake Inc.
// This file is part of Moonbeam.

// Moonbeam is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// Moonbeam is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with Moonbeam.  If not, see <http://www.gnu.org/licenses/>.

//! Test utilities
use crate as erc20_xcm_bridge;

use frame_support::traits::Everything;
use frame_support::{construct_runtime, pallet_prelude::*, parameter_types};
use frame_system::EnsureRoot;
use pallet_evm::{
	AddressMapping, EnsureAddressTruncated, FrameSystemAccountProvider, SubstrateBlockHashMapping,
};
use sp_core::{H160, H256, U256};
use sp_runtime::traits::{BlakeTwo256, IdentityLookup};
use sp_runtime::AccountId32;

pub type Balance = u128;

type Block = frame_system::mocking::MockBlock<Test>;

construct_runtime!(
	pub enum Test
	{
		System: frame_system,
		Balances: pallet_balances,
		Timestamp: pallet_timestamp,
		EVM: pallet_evm,
		Erc20XcmBridge: erc20_xcm_bridge::{Pallet, Call, Storage, Event<T>},
	}
);

parameter_types! {
	pub const BlockHashCount: u32 = 250;
}

impl frame_system::Config for Test {
	type BaseCallFilter = Everything;
	type DbWeight = ();
	type RuntimeOrigin = RuntimeOrigin;
	type RuntimeTask = RuntimeTask;
	type Nonce = u64;
	type Block = Block;
	type RuntimeCall = RuntimeCall;
	type Hash = H256;
	type Hashing = BlakeTwo256;
	type AccountId = AccountId32;
	type Lookup = IdentityLookup<Self::AccountId>;
	type RuntimeEvent = RuntimeEvent;
	type BlockHashCount = BlockHashCount;
	type Version = ();
	type PalletInfo = PalletInfo;
	type AccountData = pallet_balances::AccountData<Balance>;
	type OnNewAccount = ();
	type OnKilledAccount = ();
	type SystemWeightInfo = ();
	type BlockWeights = ();
	type BlockLength = ();
	type SS58Prefix = ();
	type OnSetCode = ();
	type MaxConsumers = frame_support::traits::ConstU32<16>;
	type SingleBlockMigrations = ();
	type MultiBlockMigrator = ();
	type PreInherents = ();
	type PostInherents = ();
	type PostTransactions = ();
	type ExtensionsWeightInfo = ();
}

parameter_types! {
	pub const ExistentialDeposit: u128 = 0;
}
impl pallet_balances::Config for Test {
	type MaxReserves = ();
	type ReserveIdentifier = [u8; 4];
	type MaxLocks = ();
	type Balance = Balance;
	type RuntimeEvent = RuntimeEvent;
	type DustRemoval = ();
	type ExistentialDeposit = ExistentialDeposit;
	type AccountStore = System;
	type WeightInfo = ();
	type RuntimeHoldReason = ();
	type FreezeIdentifier = ();
	type MaxFreezes = ();
	type RuntimeFreezeReason = ();
	type DoneSlashHandler = ();
}

parameter_types! {
	pub const MinimumPeriod: u64 = 6000 / 2;
}

impl pallet_timestamp::Config for Test {
	type Moment = u64;
	type OnTimestampSet = ();
	type MinimumPeriod = MinimumPeriod;
	type WeightInfo = ();
}

const MAX_POV_SIZE: u64 = 5 * 1024 * 1024;
/// Block storage limit in bytes. Set to 40 KB.
const BLOCK_STORAGE_LIMIT: u64 = 40 * 1024;

parameter_types! {
	pub BlockGasLimit: U256 = U256::from(u64::MAX);
	// Non-zero proof_size component so `pallet_evm`'s runner has a budget large enough
	// to record `ACCOUNT_CODES_METADATA_PROOF_SIZE` (~76 bytes) at the start of a call.
	// Without this the runner returns `GasLimitTooLow` for any contract call.
	pub const WeightPerGas: Weight = Weight::from_parts(1, 1);
	pub GasLimitPovSizeRatio: u64 = {
		let block_gas_limit = BlockGasLimit::get().min(u64::MAX.into()).low_u64();
		block_gas_limit.saturating_div(MAX_POV_SIZE)
	};
	pub GasLimitStorageGrowthRatio: u64 = {
		let block_gas_limit = BlockGasLimit::get().min(u64::MAX.into()).low_u64();
		block_gas_limit.saturating_div(BLOCK_STORAGE_LIMIT)
	};
}

pub struct HashedAddressMapping;

impl AddressMapping<AccountId32> for HashedAddressMapping {
	fn into_account_id(address: H160) -> AccountId32 {
		let mut data = [0u8; 32];
		data[0..20].copy_from_slice(&address[..]);
		AccountId32::from(Into::<[u8; 32]>::into(data))
	}
}

impl pallet_evm::Config for Test {
	type FeeCalculator = ();
	type GasWeightMapping = pallet_evm::FixedGasWeightMapping<Self>;
	type WeightPerGas = WeightPerGas;
	type CallOrigin = EnsureAddressTruncated;
	type WithdrawOrigin = EnsureAddressTruncated;
	type AddressMapping = HashedAddressMapping;
	type Currency = Balances;
	type PrecompilesType = ();
	type PrecompilesValue = ();
	type Runner = pallet_evm::runner::stack::Runner<Self>;
	type ChainId = ();
	type BlockGasLimit = BlockGasLimit;
	type TransactionGasLimit = ();
	type OnChargeTransaction = ();
	type FindAuthor = ();
	type BlockHashMapping = SubstrateBlockHashMapping<Self>;
	type OnCreate = ();
	// `()` resolves to `0` for these `Get<u64>` ratios — that disables the PoV / storage
	// growth checks in the EVM runner, which would otherwise reject our small-gas
	// `erc20_transfer` test calls because the mock's `BlockGasLimit = u64::MAX`
	// makes the computed ratios astronomical.
	type GasLimitPovSizeRatio = ();
	type GasLimitStorageGrowthRatio = ();
	type Timestamp = Timestamp;
	type WeightInfo = pallet_evm::weights::SubstrateWeight<Test>;
	type AccountProvider = FrameSystemAccountProvider<Test>;
	type CreateOriginFilter = ();
	type CreateInnerOriginFilter = ();
}

parameter_types! {
	pub Erc20XcmBridgeTransferGasLimit: u64 = 200_000;
	pub Erc20MultilocationPrefix: xcm::latest::Location = xcm::latest::Location {
		parents: 0,
		interior: [xcm::latest::Junction::PalletInstance(42u8)].into(),
	};
	pub TeleportCheckingAccount: H160 = H160(*b"erc20-teleport-check");
	/// Mock counterparty: stand-in for AssetHub at para 1001. Tests use this to verify
	/// `IsTeleportableErc20` admits this exact location and rejects everything else.
	pub TeleportTrustedLocation: xcm::latest::Location = xcm::latest::Location::new(
		1,
		[xcm::latest::Junction::Parachain(1001)],
	);
}
/// Minimal `Location → H160` converter for the unit-test ext: matches the leaf
/// `AccountKey20 { key, .. }` and returns `H160(key)`. Pattern matches any number of
/// preceding junctions so both `(0, [AccountKey20])` and richer locations work.
pub struct H160FromAccountKey20Junction;

impl xcm_executor::traits::ConvertLocation<H160> for H160FromAccountKey20Junction {
	fn convert_location(loc: &xcm::latest::Location) -> Option<H160> {
		use xcm::latest::Junction;
		match loc.interior().last() {
			Some(Junction::AccountKey20 { key, .. }) => Some(H160::from(*key)),
			_ => None,
		}
	}
}

impl crate::Config for Test {
	type AccountIdConverter = H160FromAccountKey20Junction;
	type Erc20MultilocationPrefix = Erc20MultilocationPrefix;
	type Erc20TransferGasLimit = Erc20XcmBridgeTransferGasLimit;
	type EvmRunner = pallet_evm::runner::stack::Runner<Self>;
	type TeleportAdminOrigin = EnsureRoot<AccountId32>;
	type TeleportCheckingAccount = TeleportCheckingAccount;
	type TeleportTrustedLocation = TeleportTrustedLocation;
}