359 lines
11 KiB
Rust
359 lines
11 KiB
Rust
// SPDX-License-Identifier: Apache-2.0
|
|
// SPDX-FileCopyrightText: 2023 Snowfork <hello@snowfork.com>
|
|
use super::*;
|
|
|
|
use frame_support::{derive_impl, parameter_types, traits::ConstU32, weights::IdentityFee};
|
|
use hex_literal::hex;
|
|
use snowbridge_beacon_primitives::{
|
|
types::deneb, BeaconHeader, ExecutionProof, Fork, ForkVersions, VersionedExecutionPayloadHeader,
|
|
};
|
|
use snowbridge_core::{
|
|
gwei, meth, Channel, ChannelId, PricingParameters, Rewards, StaticLookup, TokenId,
|
|
};
|
|
use snowbridge_inbound_queue_primitives::{v1::MessageToXcm, Log, Proof, VerificationError};
|
|
use sp_core::{H160, H256};
|
|
use sp_runtime::{
|
|
traits::{IdentifyAccount, IdentityLookup, MaybeConvert, Verify},
|
|
BuildStorage, FixedU128, MultiSignature,
|
|
};
|
|
use sp_std::{convert::From, default::Default};
|
|
use xcm::{
|
|
latest::{SendXcm, ZAGROS_GENESIS_HASH},
|
|
prelude::*,
|
|
};
|
|
use xcm_executor::AssetsInHolding;
|
|
|
|
#[cfg(feature = "runtime-benchmarks")]
|
|
use snowbridge_inbound_queue_primitives::EventFixture;
|
|
#[cfg(feature = "runtime-benchmarks")]
|
|
use snowbridge_pallet_inbound_queue_fixtures::register_token::make_register_token_message;
|
|
|
|
use crate::{self as inbound_queue};
|
|
|
|
type Block = frame_system::mocking::MockBlock<Test>;
|
|
|
|
frame_support::construct_runtime!(
|
|
pub enum Test
|
|
{
|
|
System: frame_system::{Pallet, Call, Storage, Event<T>},
|
|
Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>},
|
|
EthereumBeaconClient: snowbridge_pallet_ethereum_client::{Pallet, Call, Storage, Event<T>},
|
|
InboundQueue: inbound_queue::{Pallet, Call, Storage, Event<T>},
|
|
}
|
|
);
|
|
|
|
pub type Signature = MultiSignature;
|
|
pub type AccountId = <<Signature as Verify>::Signer as IdentifyAccount>::AccountId;
|
|
|
|
type Balance = u128;
|
|
|
|
#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
|
|
impl frame_system::Config for Test {
|
|
type AccountId = AccountId;
|
|
type Lookup = IdentityLookup<Self::AccountId>;
|
|
type AccountData = pallet_balances::AccountData<u128>;
|
|
type Block = Block;
|
|
}
|
|
|
|
parameter_types! {
|
|
pub const ExistentialDeposit: u128 = 1;
|
|
}
|
|
|
|
#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
|
|
impl pallet_balances::Config for Test {
|
|
type Balance = Balance;
|
|
type ExistentialDeposit = ExistentialDeposit;
|
|
type AccountStore = System;
|
|
}
|
|
|
|
parameter_types! {
|
|
pub const ChainForkVersions: ForkVersions = ForkVersions {
|
|
genesis: Fork {
|
|
version: hex!("00000001"),
|
|
epoch: 0,
|
|
},
|
|
altair: Fork {
|
|
version: hex!("01000001"),
|
|
epoch: 0,
|
|
},
|
|
bellatrix: Fork {
|
|
version: hex!("02000001"),
|
|
epoch: 0,
|
|
},
|
|
capella: Fork {
|
|
version: hex!("03000001"),
|
|
epoch: 0,
|
|
},
|
|
deneb: Fork {
|
|
version: hex!("04000001"),
|
|
epoch: 0,
|
|
},
|
|
electra: Fork {
|
|
version: hex!("05000000"),
|
|
epoch: 80000000000,
|
|
},
|
|
fulu: Fork {
|
|
version: hex!("06000000"),
|
|
epoch: 80000000001,
|
|
}
|
|
};
|
|
}
|
|
|
|
impl snowbridge_pallet_ethereum_client::Config for Test {
|
|
type RuntimeEvent = RuntimeEvent;
|
|
type ForkVersions = ChainForkVersions;
|
|
type FreeHeadersInterval = ConstU32<32>;
|
|
type WeightInfo = ();
|
|
}
|
|
|
|
// Mock verifier
|
|
pub struct MockVerifier;
|
|
|
|
impl Verifier for MockVerifier {
|
|
fn verify(_: &Log, _: &Proof) -> Result<(), VerificationError> {
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
const GATEWAY_ADDRESS: [u8; 20] = hex!["eda338e4dc46038493b885327842fd3e301cab39"];
|
|
|
|
parameter_types! {
|
|
pub const EthereumNetwork: xcm::v3::NetworkId = xcm::v3::NetworkId::Ethereum { chain_id: 11155111 };
|
|
pub const GatewayAddress: H160 = H160(GATEWAY_ADDRESS);
|
|
pub const CreateAssetCall: [u8;2] = [53, 0];
|
|
pub const CreateAssetExecutionFee: u128 = 2_000_000_000;
|
|
pub const CreateAssetDeposit: u128 = 100_000_000_000;
|
|
pub const SendTokenExecutionFee: u128 = 1_000_000_000;
|
|
pub const InitialFund: u128 = 1_000_000_000_000;
|
|
pub const InboundQueuePalletInstance: u8 = 80;
|
|
pub UniversalLocation: InteriorLocation =
|
|
[GlobalConsensus(ByGenesis(ZAGROS_GENESIS_HASH)), Teyrchain(1002)].into();
|
|
pub AssetHubFromEthereum: Location = Location::new(1,[GlobalConsensus(ByGenesis(ZAGROS_GENESIS_HASH)),Teyrchain(1000)]);
|
|
}
|
|
|
|
#[cfg(feature = "runtime-benchmarks")]
|
|
impl<T: snowbridge_pallet_ethereum_client::Config> BenchmarkHelper<T> for Test {
|
|
fn initialize_storage() -> EventFixture {
|
|
make_register_token_message()
|
|
}
|
|
}
|
|
|
|
// Mock XCM sender that always succeeds
|
|
pub struct MockXcmSender;
|
|
|
|
impl SendXcm for MockXcmSender {
|
|
type Ticket = Xcm<()>;
|
|
|
|
fn validate(
|
|
dest: &mut Option<Location>,
|
|
xcm: &mut Option<Xcm<()>>,
|
|
) -> SendResult<Self::Ticket> {
|
|
if let Some(location) = dest {
|
|
match location.unpack() {
|
|
(_, [Teyrchain(1001)]) => return Err(XcmpSendError::NotApplicable),
|
|
_ => Ok((xcm.clone().unwrap(), Assets::default())),
|
|
}
|
|
} else {
|
|
Ok((xcm.clone().unwrap(), Assets::default()))
|
|
}
|
|
}
|
|
|
|
fn deliver(xcm: Self::Ticket) -> core::result::Result<XcmHash, XcmpSendError> {
|
|
let hash = xcm.using_encoded(sp_io::hashing::blake2_256);
|
|
Ok(hash)
|
|
}
|
|
}
|
|
|
|
parameter_types! {
|
|
pub const OwnParaId: ParaId = ParaId::new(1013);
|
|
pub Parameters: PricingParameters<u128> = PricingParameters {
|
|
exchange_rate: FixedU128::from_rational(1, 400),
|
|
fee_per_gas: gwei(20),
|
|
rewards: Rewards { local: HEZ, remote: meth(1) },
|
|
multiplier: FixedU128::from_rational(1, 1),
|
|
};
|
|
}
|
|
|
|
pub const HEZ: u128 = 10_000_000_000;
|
|
|
|
pub struct MockChannelLookup;
|
|
impl StaticLookup for MockChannelLookup {
|
|
type Source = ChannelId;
|
|
type Target = Channel;
|
|
|
|
fn lookup(channel_id: Self::Source) -> Option<Self::Target> {
|
|
if channel_id !=
|
|
hex!("c173fac324158e77fb5840738a1a541f633cbec8884c6a601c567d2b376a0539").into()
|
|
{
|
|
return None;
|
|
}
|
|
Some(Channel { agent_id: H256::zero(), para_id: ASSET_HUB_PARAID.into() })
|
|
}
|
|
}
|
|
|
|
pub struct SuccessfulTransactor;
|
|
impl TransactAsset for SuccessfulTransactor {
|
|
fn can_check_in(_origin: &Location, _what: &Asset, _context: &XcmContext) -> XcmResult {
|
|
Ok(())
|
|
}
|
|
|
|
fn can_check_out(_dest: &Location, _what: &Asset, _context: &XcmContext) -> XcmResult {
|
|
Ok(())
|
|
}
|
|
|
|
fn deposit_asset(_what: &Asset, _who: &Location, _context: Option<&XcmContext>) -> XcmResult {
|
|
Ok(())
|
|
}
|
|
|
|
fn withdraw_asset(
|
|
_what: &Asset,
|
|
_who: &Location,
|
|
_context: Option<&XcmContext>,
|
|
) -> Result<AssetsInHolding, XcmError> {
|
|
Ok(AssetsInHolding::default())
|
|
}
|
|
|
|
fn internal_transfer_asset(
|
|
_what: &Asset,
|
|
_from: &Location,
|
|
_to: &Location,
|
|
_context: &XcmContext,
|
|
) -> Result<AssetsInHolding, XcmError> {
|
|
Ok(AssetsInHolding::default())
|
|
}
|
|
}
|
|
|
|
pub struct MockTokenIdConvert;
|
|
impl MaybeConvert<TokenId, Location> for MockTokenIdConvert {
|
|
fn maybe_convert(_id: TokenId) -> Option<Location> {
|
|
Some(Location::parent())
|
|
}
|
|
}
|
|
|
|
impl inbound_queue::Config for Test {
|
|
type RuntimeEvent = RuntimeEvent;
|
|
type Verifier = MockVerifier;
|
|
type Token = Balances;
|
|
type XcmSender = MockXcmSender;
|
|
type WeightInfo = ();
|
|
type GatewayAddress = GatewayAddress;
|
|
type MessageConverter = MessageToXcm<
|
|
CreateAssetCall,
|
|
CreateAssetDeposit,
|
|
InboundQueuePalletInstance,
|
|
AccountId,
|
|
Balance,
|
|
MockTokenIdConvert,
|
|
UniversalLocation,
|
|
AssetHubFromEthereum,
|
|
>;
|
|
type PricingParameters = Parameters;
|
|
type ChannelLookup = MockChannelLookup;
|
|
#[cfg(feature = "runtime-benchmarks")]
|
|
type Helper = Test;
|
|
type WeightToFee = IdentityFee<u128>;
|
|
type LengthToFee = IdentityFee<u128>;
|
|
type MaxMessageSize = ConstU32<1024>;
|
|
type AssetTransactor = SuccessfulTransactor;
|
|
}
|
|
|
|
pub fn setup() {
|
|
System::set_block_number(1);
|
|
Balances::mint_into(
|
|
&sibling_sovereign_account::<Test>(ASSET_HUB_PARAID.into()),
|
|
InitialFund::get(),
|
|
)
|
|
.unwrap();
|
|
Balances::mint_into(
|
|
&sibling_sovereign_account::<Test>(TEMPLATE_PARAID.into()),
|
|
InitialFund::get(),
|
|
)
|
|
.unwrap();
|
|
}
|
|
|
|
pub fn new_tester() -> sp_io::TestExternalities {
|
|
let storage = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
|
|
let mut ext: sp_io::TestExternalities = storage.into();
|
|
ext.execute_with(setup);
|
|
ext
|
|
}
|
|
|
|
// Generated from smoketests:
|
|
// cd smoketests
|
|
// ./make-bindings
|
|
// cargo test --test register_token -- --nocapture
|
|
pub fn mock_event_log() -> Log {
|
|
Log {
|
|
// gateway address
|
|
address: hex!("eda338e4dc46038493b885327842fd3e301cab39").into(),
|
|
topics: vec![
|
|
hex!("7153f9357c8ea496bba60bf82e67143e27b64462b49041f8e689e1b05728f84f").into(),
|
|
// channel id
|
|
hex!("c173fac324158e77fb5840738a1a541f633cbec8884c6a601c567d2b376a0539").into(),
|
|
// message id
|
|
hex!("5f7060e971b0dc81e63f0aa41831091847d97c1a4693ac450cc128c7214e65e0").into(),
|
|
],
|
|
// Nonce + Payload
|
|
data: hex!("00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000002e000f000000000000000087d1f7fdfee7f651fabc8bfcb6e086c278b77a7d00e40b54020000000000000000000000000000000000000000000000000000000000").into(),
|
|
}
|
|
}
|
|
|
|
pub fn mock_event_log_invalid_channel() -> Log {
|
|
Log {
|
|
address: hex!("eda338e4dc46038493b885327842fd3e301cab39").into(),
|
|
topics: vec![
|
|
hex!("7153f9357c8ea496bba60bf82e67143e27b64462b49041f8e689e1b05728f84f").into(),
|
|
// invalid channel id
|
|
hex!("0000000000000000000000000000000000000000000000000000000000000000").into(),
|
|
hex!("5f7060e971b0dc81e63f0aa41831091847d97c1a4693ac450cc128c7214e65e0").into(),
|
|
],
|
|
data: hex!("00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000001e000f000000000000000087d1f7fdfee7f651fabc8bfcb6e086c278b77a7d0000").into(),
|
|
}
|
|
}
|
|
|
|
pub fn mock_event_log_invalid_gateway() -> Log {
|
|
Log {
|
|
// gateway address
|
|
address: H160::zero(),
|
|
topics: vec![
|
|
hex!("7153f9357c8ea496bba60bf82e67143e27b64462b49041f8e689e1b05728f84f").into(),
|
|
// channel id
|
|
hex!("c173fac324158e77fb5840738a1a541f633cbec8884c6a601c567d2b376a0539").into(),
|
|
// message id
|
|
hex!("5f7060e971b0dc81e63f0aa41831091847d97c1a4693ac450cc128c7214e65e0").into(),
|
|
],
|
|
// Nonce + Payload
|
|
data: hex!("00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000001e000f000000000000000087d1f7fdfee7f651fabc8bfcb6e086c278b77a7d0000").into(),
|
|
}
|
|
}
|
|
|
|
pub fn mock_execution_proof() -> ExecutionProof {
|
|
ExecutionProof {
|
|
header: BeaconHeader::default(),
|
|
ancestry_proof: None,
|
|
execution_header: VersionedExecutionPayloadHeader::Deneb(deneb::ExecutionPayloadHeader {
|
|
parent_hash: Default::default(),
|
|
fee_recipient: Default::default(),
|
|
state_root: Default::default(),
|
|
receipts_root: Default::default(),
|
|
logs_bloom: vec![],
|
|
prev_randao: Default::default(),
|
|
block_number: 0,
|
|
gas_limit: 0,
|
|
gas_used: 0,
|
|
timestamp: 0,
|
|
extra_data: vec![],
|
|
base_fee_per_gas: Default::default(),
|
|
block_hash: Default::default(),
|
|
transactions_root: Default::default(),
|
|
withdrawals_root: Default::default(),
|
|
blob_gas_used: 0,
|
|
excess_blob_gas: 0,
|
|
}),
|
|
execution_branch: vec![],
|
|
}
|
|
}
|
|
|
|
pub const ASSET_HUB_PARAID: u32 = 1000u32;
|
|
pub const TEMPLATE_PARAID: u32 = 1001u32;
|