fn validate(

        network: NetworkId,

        _channel: u32,

        universal_source: &mut Option<InteriorLocation>,

        destination: &mut Option<InteriorLocation>,

        message: &mut Option<Xcm<()>>,

    ) -> SendResult<Self::Ticket> {

        let expected_network = EthereumNetwork::get();

        let universal_location = UniversalLocation::get();

        log::info!("validate params: network={network:?}, _channel={_channel:?}, universal_source={universal_source:?}, destination={destination:?}, message={message:?}, ");

        if network != expected_network {

            log::trace!(target: "xcm::ethereum_blob_exporter", "skipped due to unmatched bridge network {network:?}.");

            return Err(NotApplicable);

        }

        let dest = destination.clone().take().ok_or(MissingArgument)?;

        if dest != Here {

            log::trace!(target: "xcm::ethereum_blob_exporter", "skipped due to unmatched remote destination {dest:?}.");

            return Err(NotApplicable);

        }

        let (local_net, local_sub) = universal_source.clone()

            .take()

            .ok_or_else(|| {

                log::error!(target: "xcm::ethereum_blob_exporter", "universal source not provided.");

                MissingArgument

            })?

            .split_global()

            .map_err(|()| {

                log::error!(target: "xcm::ethereum_blob_exporter", "could not get global consensus from universal source '{universal_source:?}'.");

                NotApplicable

            })?;

        if Ok(local_net) != universal_location.global_consensus() {

        }

        let para_id = match local_sub.as_slice() {

            [Parachain(para_id)] => *para_id,

                log::error!(target: "xcm::ethereum_blob_exporter", "could not get parachain id from universal source '{local_sub:?}'.");

                return Err(NotApplicable);

        let message = message.take().ok_or_else(|| {

            log::error!(target: "xcm::ethereum_blob_exporter", "xcm message not provided.");

            MissingArgument

        })?;

        let mut converter =

            XcmConverter::<ConvertAssetId, UniversalLocation, EthereumLocation, ()>::new(

                &message,

                expected_network,

                para_id,

            );

        let (command, message_id) = converter.convert().map_err(|err|{

            log::error!(target: "xcm::ethereum_blob_exporter", "unroutable due to pattern matching error '{err:?}'.");

            Unroutable

        })?;

        let (channel_id, _) = BridgeChannelInfo::get().ok_or_else(|| {

        })?;

        let outbound_message = Message {

            id: Some(message_id.into()),

            channel_id,

            command,

        };

        let (ticket, fee) = OutboundQueue::validate(&outbound_message).map_err(|err| {

        })?;

        let fee = Asset::from((Location::new(0, []), fee.total())).into();

        Ok(((ticket.encode(), message_id), fee))

    }

    fn new(message: &'a Xcm<Call>, ethereum_network: NetworkId, para_id: u32) -> Self {

        Self {

            iter: message.inner().iter().peekable(),

            ethereum_network,

            para_id,

            _marker: Default::default(),

        }

    }

    fn convert(&mut self) -> Result<(Command, [u8; 32]), XcmConverterError> {

        let result = match self.peek() {

            Ok(ReserveAssetDeposited { .. }) => self.make_mint_foreign_token_command(),

            _ => return Err(XcmConverterError::UnexpectedInstruction),

        }?;

        if self.next().is_ok() {

            return Err(XcmConverterError::EndOfXcmMessageExpected);

        }

        Ok(result)

    }

    fn next(&mut self) -> Result<&'a Instruction<Call>, XcmConverterError> {

        self.iter

            .next()

            .ok_or(XcmConverterError::UnexpectedEndOfXcm)

    }

    fn peek(&mut self) -> Result<&&'a Instruction<Call>, XcmConverterError> {

        self.iter

            .peek()

            .ok_or(XcmConverterError::UnexpectedEndOfXcm)

    }

    fn network_matches(&self, network: &Option<NetworkId>) -> bool {

        if let Some(network) = network {

            *network == self.ethereum_network

            true

    }

    fn check_reserve_asset_para_id(&self, location: &Location) -> Result<(), ()> {

        if location.parents != 1 {

        }

        match &location.interior {

            Junctions::X3(arc) => {

                let [j1, j2, _] = arc.as_ref();

                if let GlobalConsensus(_) = j1 {

                    if let Parachain(id) = j2 {

                        if *id == self.para_id {

                            return Ok(());

            _ => Err(()),

    }

    fn make_mint_foreign_token_command(

        &mut self,

    ) -> Result<(Command, [u8; 32]), XcmConverterError> {

        let reserve_assets = match_expression!(

            self.next()?,

            ReserveAssetDeposited(reserve_assets),

            reserve_assets

        .ok_or(ReserveAssetDepositedExpected)?;

        match_expression!(self.next(), Ok(ClearOrigin), ()).ok_or(ClearOriginExpected)?;

        let fee_asset = match_expression!(self.next(), Ok(BuyExecution { fees, .. }), fees)

            .ok_or(BuyExecutionExpected)?;

        let (deposit_assets, beneficiary) = match self.next()? {

                assets,

                beneficiary,

            } => (assets, beneficiary),

        let (parents, interior) = beneficiary.unpack();

        let recipient = match (parents, interior) {

            (0, [AccountKey20 { network, key }]) if self.network_matches(network) => H160(*key),

        if reserve_assets.len() == 0 {

            return Err(NoReserveAssets);

        }

        // Check the the deposit asset filter matches what was reserved.

        if reserve_assets

            .inner()

            .iter()

            .any(|asset| !deposit_assets.matches(asset))

            return Err(FilterDoesNotConsumeAllAssets);

        }

        // We only support a single asset at a time.

        ensure!(reserve_assets.len() == 1, TooManyAssets);

        let reserve_asset = reserve_assets.get(0).ok_or(AssetResolutionFailed)?;

        if fee_asset.id != reserve_asset.id || fee_asset.fun > reserve_asset.fun {

            return Err(InvalidFeeAsset);

        }

        let (asset_id, amount) = match reserve_asset {

                id: AssetId(inner_location),

                fun: Fungible(amount),

            } => Some((inner_location.clone(), *amount)),

            _ => None,

        .ok_or(AssetResolutionFailed)?;

        self.check_reserve_asset_para_id(&asset_id)

            .map_err(|_| ParaIdMismatch)?;

        ensure!(amount > 0, ZeroAssetTransfer);

        let asset_location = Location {

            parents: 0,

            interior: Junctions::X2([Parachain(self.para_id), PalletInstance(10)].into()),

        };

        let reanchored_location = asset_location

            .reanchored(&EthereumLocation::get(), &UniversalLocation::get())

            .map_err(|_| AssetReanchorFailed)?;

        log::info!("reanchored_location={reanchored_location:?}");

        let token_id = ConvertAssetId::convert_back(&reanchored_location).ok_or(InvalidAsset)?;

        let topic_id = match_expression!(self.next()?, SetTopic(id), id).ok_or(SetTopicExpected)?;

        Ok((

            Command::MintForeignToken {

                token_id,

                recipient,

                amount,

            },

            *topic_id,

        ))

    }

        fn convert_back(_loc: &Location) -> Option<TokenId> {

            Some(H256::from_low_u64_be(123))

        }

        fn validate(_: &Message) -> Result<(Self::Ticket, Fee<Self::Balance>), SendError> {

            Ok((

                (),

                Fee {

                    local: 1,

                    remote: 1,

                },

            ))

        }

    fn exporter_validate_with_unknown_network_yields_not_applicable() {

        let network = Ethereum { chain_id: 12345 };

        let channel: u32 = 0;

        let mut universal_source: Option<InteriorLocation> = None;

        let mut destination: Option<InteriorLocation> = None;

        let mut message: Option<Xcm<()>> = None;

        let result = ContainerEthereumBlobExporter::<

            UniversalLocation,

            EthereumNetwork,

            EthereumLocation,

            MockOkOutboundQueue,

            MockTokenIdConvert,

            BridgeChannelInfo,

        >::validate(

            network,

            channel,

            &mut universal_source,

            &mut destination,

            &mut message,

        );

        assert_eq!(result, Err(NotApplicable));

    }

    fn exporter_validate_with_empty_destination_yields_missing_argument() {

        let network = Ethereum { chain_id: 11155111 };

        let channel: u32 = 0;

        let mut universal_source: Option<InteriorLocation> = None;

        let mut destination: Option<InteriorLocation> = None;

        let mut message: Option<Xcm<()>> = None;

        let result = ContainerEthereumBlobExporter::<

            UniversalLocation,

            EthereumNetwork,

            EthereumLocation,

            MockOkOutboundQueue,

            MockTokenIdConvert,

            BridgeChannelInfo,

        >::validate(

            network,

            channel,

            &mut universal_source,

            &mut destination,

            &mut message,

        );

        assert_eq!(result, Err(MissingArgument));

    }

    fn exporter_validate_with_incorrect_destination_yields_not_applicable() {

        let network = Ethereum { chain_id: 11155111 };

        let channel: u32 = 0;

        let mut universal_source: Option<InteriorLocation> = None;

        let mut destination: Option<InteriorLocation> = Some(

            [

                OnlyChild, OnlyChild, OnlyChild, OnlyChild, OnlyChild, OnlyChild, OnlyChild,

                OnlyChild,

            ]

            .into(),

        );

        let mut message: Option<Xcm<()>> = None;

        let result = ContainerEthereumBlobExporter::<

            UniversalLocation,

            EthereumNetwork,

            EthereumLocation,

            MockOkOutboundQueue,

            MockTokenIdConvert,

            BridgeChannelInfo,

        >::validate(

            network,

            channel,

            &mut universal_source,

            &mut destination,

            &mut message,

        );

        assert_eq!(result, Err(NotApplicable));

    }

    fn exporter_validate_with_incorrect_universal_source_yields_validation_error() {

        let network = Ethereum { chain_id: 11155111 };

        let channel: u32 = 0;

        let mut universal_source: Option<InteriorLocation> = None;

        let mut destination: Option<InteriorLocation> = Here.into();

        let mut message: Option<Xcm<()>> = None;

        let result = ContainerEthereumBlobExporter::<

            UniversalLocation,

            EthereumNetwork,

            EthereumLocation,

            MockOkOutboundQueue,

            MockTokenIdConvert,

            BridgeChannelInfo,

        >::validate(

            network,

            channel,

            &mut universal_source,

            &mut destination,

            &mut message,

        );

        assert_eq!(result, Err(MissingArgument));

        let mut universal_source: Option<InteriorLocation> = Here.into();

        let result = ContainerEthereumBlobExporter::<

            UniversalLocation,

            EthereumNetwork,

            EthereumLocation,

            MockOkOutboundQueue,

            MockTokenIdConvert,

            BridgeChannelInfo,

        >::validate(

            network,

            channel,

            &mut universal_source,

            &mut destination,

            &mut message,

        );

        assert_eq!(result, Err(NotApplicable));

    }

    fn exporter_validate_with_missing_para_id_universal_source_yields_validation_error() {

        let network = Ethereum { chain_id: 11155111 };

        let channel: u32 = 0;

        let mut universal_source: Option<InteriorLocation> = Some(

            [GlobalConsensus(ByGenesis([

                152, 58, 26, 114, 80, 61, 108, 195, 99, 103, 118, 116, 126, 198, 39, 23, 43, 81,

                39, 43, 244, 94, 80, 163, 85, 52, 143, 172, 182, 122, 130, 10,

            ]))]

            .into(),

        );

        let mut destination: Option<InteriorLocation> = Here.into();

        let mut message: Option<Xcm<()>> = None;

        let result = ContainerEthereumBlobExporter::<

            UniversalLocation,

            EthereumNetwork,

            EthereumLocation,

            MockOkOutboundQueue,

            MockTokenIdConvert,

            BridgeChannelInfo,

        >::validate(

            network,

            channel,

            &mut universal_source,

            &mut destination,

            &mut message,

        );

        assert_eq!(result, Err(NotApplicable));

    }

    fn exporter_validate_with_empty_message_yields_missing_argument() {

        let network = Ethereum { chain_id: 11155111 };

        let channel: u32 = 0;

        let mut universal_source: Option<InteriorLocation> = Some(

            [

                GlobalConsensus(ByGenesis([

                    152, 58, 26, 114, 80, 61, 108, 195, 99, 103, 118, 116, 126, 198, 39, 23, 43,

                    81, 39, 43, 244, 94, 80, 163, 85, 52, 143, 172, 182, 122, 130, 10,

                ])),

                Parachain(2001),

            ]

            .into(),

        );

        let mut destination: Option<InteriorLocation> = Here.into();

        let mut message: Option<Xcm<()>> = None;

        let result = ContainerEthereumBlobExporter::<

            UniversalLocation,

            EthereumNetwork,

            EthereumLocation,

            MockOkOutboundQueue,

            MockTokenIdConvert,

            BridgeChannelInfo,

        >::validate(

            network,

            channel,

            &mut universal_source,

            &mut destination,

            &mut message,

        );

        assert_eq!(result, Err(MissingArgument));

    }

    fn exporter_incorrect_message_yields_incorrect_instruction() {

        let network = Ethereum { chain_id: 11155111 };

        let channel: u32 = 0;

        let mut universal_source: Option<InteriorLocation> = Some(

            [

                GlobalConsensus(ByGenesis([

                    152, 58, 26, 114, 80, 61, 108, 195, 99, 103, 118, 116, 126, 198, 39, 23, 43,

                    81, 39, 43, 244, 94, 80, 163, 85, 52, 143, 172, 182, 122, 130, 10,

                ])),

                Parachain(2001),

            ]

            .into(),

        );

        let mut destination: Option<InteriorLocation> = Here.into();

        let mut message: Option<Xcm<()>> = Some(vec![SetTopic([0; 32])].into());

        let result = ContainerEthereumBlobExporter::<

            UniversalLocation,

            EthereumNetwork,

            EthereumLocation,

            MockOkOutboundQueue,

            MockTokenIdConvert,

            BridgeChannelInfo,

        >::validate(

            network,

            channel,

            &mut universal_source,

            &mut destination,

            &mut message,

        );

        assert_eq!(result, Err(Unroutable));

    }

    fn exporter_incorrect_clear_origin_yields_incorrect_instruction() {

        let network = Ethereum { chain_id: 11155111 };

        let channel: u32 = 0;

        let mut universal_source: Option<InteriorLocation> = Some(

            [

                GlobalConsensus(ByGenesis([

                    152, 58, 26, 114, 80, 61, 108, 195, 99, 103, 118, 116, 126, 198, 39, 23, 43,

                    81, 39, 43, 244, 94, 80, 163, 85, 52, 143, 172, 182, 122, 130, 10,

                ])),

                Parachain(2001),

            ]

            .into(),

        );

        let mut destination: Option<InteriorLocation> = Here.into();

        let asset_location = Location::new(

            1,

            [GlobalConsensus(ByGenesis([

                152, 58, 26, 114, 80, 61, 108, 195, 99, 103, 118, 116, 126, 198, 39, 23, 43, 81,

                39, 43, 244, 94, 80, 163, 85, 52, 143, 172, 182, 122, 130, 10,

            ]))],

        );

        let assets: Assets = vec![Asset {

            id: AssetId(asset_location),

            fun: Fungible(123321000000000000),

        }]

        .into();

        let mut message: Option<Xcm<()>> = Some(

            vec![

                ReserveAssetDeposited(assets.clone()),

                BuyExecution {

                    fees: assets.get(0).unwrap().clone(),

                    weight_limit: Unlimited,

                },

            ]

            .into(),

        );

        let result = ContainerEthereumBlobExporter::<

            UniversalLocation,

            EthereumNetwork,

            EthereumLocation,

            MockOkOutboundQueue,

            MockTokenIdConvert,

            BridgeChannelInfo,

        >::validate(

            network,

            channel,

            &mut universal_source,

            &mut destination,

            &mut message,

        );

        assert_eq!(result, Err(Unroutable));

    }

    fn exporter_incorrect_buy_execution_yields_unroutable() {

        let network = Ethereum { chain_id: 11155111 };

        let channel: u32 = 0;

        let mut universal_source: Option<InteriorLocation> = Some(

            [

                GlobalConsensus(ByGenesis([

                    152, 58, 26, 114, 80, 61, 108, 195, 99, 103, 118, 116, 126, 198, 39, 23, 43,

                    81, 39, 43, 244, 94, 80, 163, 85, 52, 143, 172, 182, 122, 130, 10,

                ])),

                Parachain(2001),

            ]

            .into(),

        );

        let mut destination: Option<InteriorLocation> = Here.into();

        let asset_location = Location::new(

            1,

            [GlobalConsensus(ByGenesis([

                152, 58, 26, 114, 80, 61, 108, 195, 99, 103, 118, 116, 126, 198, 39, 23, 43, 81,

                39, 43, 244, 94, 80, 163, 85, 52, 143, 172, 182, 122, 130, 10,

            ]))],

        );

        let assets: Assets = vec![Asset {

            id: AssetId(asset_location),

            fun: Fungible(123321000000000000),

        }]

        .into();

        let mut message: Option<Xcm<()>> = Some(

            vec![

                ReserveAssetDeposited(assets.clone()),

                ClearOrigin,

                ClearOrigin,

            ]

            .into(),

        );

        let result = ContainerEthereumBlobExporter::<

            UniversalLocation,

            EthereumNetwork,

            EthereumLocation,

            MockOkOutboundQueue,

            MockTokenIdConvert,

            BridgeChannelInfo,

        >::validate(

            network,

            channel,

            &mut universal_source,

            &mut destination,

            &mut message,

        );

        assert_eq!(result, Err(Unroutable));

    }

    fn exporter_lack_of_deposit_asset_yields_unroutable() {

        let network = Ethereum { chain_id: 11155111 };

        let channel: u32 = 0;

        let mut universal_source: Option<InteriorLocation> = Some(

            [

                GlobalConsensus(ByGenesis([

                    152, 58, 26, 114, 80, 61, 108, 195, 99, 103, 118, 116, 126, 198, 39, 23, 43,

                    81, 39, 43, 244, 94, 80, 163, 85, 52, 143, 172, 182, 122, 130, 10,

                ])),

                Parachain(2001),

            ]

            .into(),

        );

        let mut destination: Option<InteriorLocation> = Here.into();

        let asset_location = Location::new(

            1,

            [GlobalConsensus(ByGenesis([

                152, 58, 26, 114, 80, 61, 108, 195, 99, 103, 118, 116, 126, 198, 39, 23, 43, 81,

                39, 43, 244, 94, 80, 163, 85, 52, 143, 172, 182, 122, 130, 10,

            ]))],

        );

        let assets: Assets = vec![Asset {

            id: AssetId(asset_location),

            fun: Fungible(123321000000000000),

        }]

        .into();

        let mut message: Option<Xcm<()>> = Some(

            vec![

                ReserveAssetDeposited(assets.clone()),

                ClearOrigin,

                BuyExecution {

                    fees: assets.get(0).unwrap().clone(),

                    weight_limit: Unlimited,

                },

            ]

            .into(),

        );

        let result = ContainerEthereumBlobExporter::<

            UniversalLocation,

            EthereumNetwork,

            EthereumLocation,

            MockOkOutboundQueue,

            MockTokenIdConvert,

            BridgeChannelInfo,

        >::validate(

            network,

            channel,

            &mut universal_source,

            &mut destination,

            &mut message,

        );

        assert_eq!(result, Err(Unroutable));

    }

    fn exporter_incorrect_beneficiary_yields_unroutable() {

        let network = Ethereum { chain_id: 11155111 };

        let channel: u32 = 0;

        let mut universal_source: Option<InteriorLocation> = Some(

            [

                GlobalConsensus(ByGenesis([

                    152, 58, 26, 114, 80, 61, 108, 195, 99, 103, 118, 116, 126, 198, 39, 23, 43,

                    81, 39, 43, 244, 94, 80, 163, 85, 52, 143, 172, 182, 122, 130, 10,

                ])),

                Parachain(2001),

            ]

            .into(),

        );

        let mut destination: Option<InteriorLocation> = Here.into();

        let asset_location = Location::new(

            1,

            [GlobalConsensus(ByGenesis([

                152, 58, 26, 114, 80, 61, 108, 195, 99, 103, 118, 116, 126, 198, 39, 23, 43, 81,

                39, 43, 244, 94, 80, 163, 85, 52, 143, 172, 182, 122, 130, 10,

            ]))],

        );

        let assets: Assets = vec![Asset {

            id: AssetId(asset_location),

            fun: Fungible(123321000000000000),

        }]

        .into();

        let beneficiary_address: [u8; 20] = hex!("2000000000000000000000000000000000000000");

        let filter: AssetFilter = assets.clone().into();

        let mut message: Option<Xcm<()>> = Some(

            vec![

                ReserveAssetDeposited(assets.clone()),

                ClearOrigin,

                BuyExecution {

                    fees: assets.get(0).unwrap().clone(),

                    weight_limit: Unlimited,

                },

                DepositAsset {

                    assets: filter,

                    beneficiary: AccountKey20 {

                        network: None,

                        key: beneficiary_address,

                    }

                    .into(),

                },

            ]

            .into(),

        );

        let result = ContainerEthereumBlobExporter::<

            UniversalLocation,

            EthereumNetwork,

            EthereumLocation,

            MockOkOutboundQueue,

            MockTokenIdConvert,

            BridgeChannelInfo,

        >::validate(

            network,

            channel,

            &mut universal_source,

            &mut destination,

            &mut message,

        );

        assert_eq!(result, Err(Unroutable));

    }

    fn exporter_empty_reserve_assets_yields_unroutable() {

        let network = Ethereum { chain_id: 11155111 };

        let channel: u32 = 0;

        let mut universal_source: Option<InteriorLocation> = Some(

            [

                GlobalConsensus(ByGenesis([

                    152, 58, 26, 114, 80, 61, 108, 195, 99, 103, 118, 116, 126, 198, 39, 23, 43,

                    81, 39, 43, 244, 94, 80, 163, 85, 52, 143, 172, 182, 122, 130, 10,

                ])),

                Parachain(2001),

            ]

            .into(),

        );

        let mut destination: Option<InteriorLocation> = Here.into();

        let asset_location = Location::new(

            1,

            [GlobalConsensus(ByGenesis([

                152, 58, 26, 114, 80, 61, 108, 195, 99, 103, 118, 116, 126, 198, 39, 23, 43, 81,

                39, 43, 244, 94, 80, 163, 85, 52, 143, 172, 182, 122, 130, 10,

            ]))],

        );

        let assets: Assets = vec![Asset {

            id: AssetId(asset_location),

            fun: Fungible(123321000000000000),

        }]

        .into();

        let beneficiary_address: [u8; 20] = hex!("2000000000000000000000000000000000000000");

        let filter: AssetFilter = assets.clone().into();

        let mut message: Option<Xcm<()>> = Some(

            vec![

                ReserveAssetDeposited(vec![].into()),

                ClearOrigin,

                BuyExecution {

                    fees: assets.get(0).unwrap().clone(),

                    weight_limit: Unlimited,

                },

                DepositAsset {

                    assets: filter,

                    beneficiary: AccountKey20 {

                        network: Some(Ethereum { chain_id: 11155111 }),

                        key: beneficiary_address,

                    }

                    .into(),

                },

            ]

            .into(),

        );

        let result = ContainerEthereumBlobExporter::<

            UniversalLocation,

            EthereumNetwork,

            EthereumLocation,

            MockOkOutboundQueue,

            MockTokenIdConvert,

            BridgeChannelInfo,

        >::validate(

            network,

            channel,

            &mut universal_source,

            &mut destination,

            &mut message,

        );

        assert_eq!(result, Err(Unroutable));

    }

    fn exporter_reserve_not_match_deposit_yields_unroutable() {

        let network = Ethereum { chain_id: 11155111 };

        let channel: u32 = 0;

        let mut universal_source: Option<InteriorLocation> = Some(

            [

                GlobalConsensus(ByGenesis([

                    152, 58, 26, 114, 80, 61, 108, 195, 99, 103, 118, 116, 126, 198, 39, 23, 43,

                    81, 39, 43, 244, 94, 80, 163, 85, 52, 143, 172, 182, 122, 130, 10,

                ])),

                Parachain(2001),

            ]

            .into(),

        );

        let mut destination: Option<InteriorLocation> = Here.into();

        let asset_location = Location::new(

            1,

            [GlobalConsensus(ByGenesis([

                152, 58, 26, 114, 80, 61, 108, 195, 99, 103, 118, 116, 126, 198, 39, 23, 43, 81,

                39, 43, 244, 94, 80, 163, 85, 52, 143, 172, 182, 122, 130, 10,

            ]))],

        );

        let assets: Assets = vec![Asset {

            id: AssetId(asset_location.clone()),

            fun: Fungible(123321000000000000),

        }]

        .into();

        let beneficiary_address: [u8; 20] = hex!("2000000000000000000000000000000000000000");

        let assets1: Assets = vec![Asset {

            id: AssetId(asset_location),

            fun: Fungible(999),

        }]

        .into();

        let filter: AssetFilter = assets1.clone().into();

        let mut message: Option<Xcm<()>> = Some(

            vec![

                ReserveAssetDeposited(assets.clone()),

                ClearOrigin,

                BuyExecution {

                    fees: assets.get(0).unwrap().clone(),

                    weight_limit: Unlimited,

                },

                DepositAsset {

                    assets: filter,

                    beneficiary: AccountKey20 {

                        network: Some(Ethereum { chain_id: 11155111 }),

                        key: beneficiary_address,

                    }

                    .into(),

                },

            ]

            .into(),

        );

        let result = ContainerEthereumBlobExporter::<

            UniversalLocation,

            EthereumNetwork,

            EthereumLocation,

            MockOkOutboundQueue,

            MockTokenIdConvert,

            BridgeChannelInfo,

        >::validate(

            network,

            channel,

            &mut universal_source,

            &mut destination,

            &mut message,

        );

        assert_eq!(result, Err(Unroutable));

    }

    fn exporter_reserve_assets_more_then_one_yields_unroutable() {

        let network = Ethereum { chain_id: 11155111 };

        let channel: u32 = 0;

        let mut universal_source: Option<InteriorLocation> = Some(

            [

                GlobalConsensus(ByGenesis([

                    152, 58, 26, 114, 80, 61, 108, 195, 99, 103, 118, 116, 126, 198, 39, 23, 43,

                    81, 39, 43, 244, 94, 80, 163, 85, 52, 143, 172, 182, 122, 130, 10,

                ])),

                Parachain(2001),

            ]

            .into(),

        );

        let mut destination: Option<InteriorLocation> = Here.into();

        let asset_location = Location::new(

            1,

            [GlobalConsensus(ByGenesis([

                152, 58, 26, 114, 80, 61, 108, 195, 99, 103, 118, 116, 126, 198, 39, 23, 43, 81,

                39, 43, 244, 94, 80, 163, 85, 52, 143, 172, 182, 122, 130, 10,

            ]))],

        );

        let assets: Assets = vec![

            Asset {

                id: AssetId(asset_location.clone()),

                fun: Fungible(123321000000000000),

            },

            Asset {

                id: AssetId(asset_location.clone()),

                fun: Fungible(123321000000000000),

            },

        ]

        .into();

        let beneficiary_address: [u8; 20] = hex!("2000000000000000000000000000000000000000");

        let filter: AssetFilter = Wild(WildAsset::AllCounted(1));

        let mut message: Option<Xcm<()>> = Some(

            vec![

                ReserveAssetDeposited(assets.clone()),

                ClearOrigin,

                BuyExecution {

                    fees: assets.get(0).unwrap().clone(),

                    weight_limit: Unlimited,

                },

                DepositAsset {

                    assets: filter,

                    beneficiary: AccountKey20 {

                        network: Some(Ethereum { chain_id: 11155111 }),

                        key: beneficiary_address,

                    }

                    .into(),

                },

            ]

            .into(),

        );

        let result = ContainerEthereumBlobExporter::<

            UniversalLocation,

            EthereumNetwork,

            EthereumLocation,

            MockOkOutboundQueue,

            MockTokenIdConvert,

            BridgeChannelInfo,

        >::validate(

            network,

            channel,

            &mut universal_source,

            &mut destination,

            &mut message,

        );

        assert_eq!(result, Err(Unroutable));

    }

    fn exporter_fee_id_does_not_equal_to_reserve_id_yields_unroutable() {

        let network = Ethereum { chain_id: 11155111 };

        let channel: u32 = 0;

        let mut universal_source: Option<InteriorLocation> = Some(

            [

                GlobalConsensus(ByGenesis([

                    152, 58, 26, 114, 80, 61, 108, 195, 99, 103, 118, 116, 126, 198, 39, 23, 43,

                    81, 39, 43, 244, 94, 80, 163, 85, 52, 143, 172, 182, 122, 130, 10,

                ])),

                Parachain(2001),

            ]

            .into(),

        );

        let mut destination: Option<InteriorLocation> = Here.into();

        let asset_location = Location::new(

            1,

            [GlobalConsensus(ByGenesis([

                152, 58, 26, 114, 80, 61, 108, 195, 99, 103, 118, 116, 126, 198, 39, 23, 43, 81,

                39, 43, 244, 94, 80, 163, 85, 52, 143, 172, 182, 122, 130, 10,

            ]))],

        );

        let assets: Assets = vec![Asset {

            id: AssetId(asset_location.clone()),

            fun: Fungible(123321000000000000),

        }]

        .into();

        let asset_location1 = Location::new(

            2,

            [GlobalConsensus(ByGenesis([

                152, 58, 26, 114, 80, 61, 108, 195, 99, 103, 118, 116, 126, 198, 39, 23, 43, 81,

                39, 43, 244, 94, 80, 163, 85, 52, 143, 172, 182, 122, 130, 10,

            ]))],

        );

        let assets1: Assets = vec![Asset {

            id: AssetId(asset_location1.clone()),

            fun: Fungible(123321000000000000),

        }]

        .into();

        let beneficiary_address: [u8; 20] = hex!("2000000000000000000000000000000000000000");

        let filter: AssetFilter = Wild(WildAsset::AllCounted(1));

        let mut message: Option<Xcm<()>> = Some(

            vec![

                ReserveAssetDeposited(assets.clone()),

                ClearOrigin,

                BuyExecution {

                    fees: assets1.get(0).unwrap().clone(),

                    weight_limit: Unlimited,

                },

                DepositAsset {

                    assets: filter,

                    beneficiary: AccountKey20 {

                        network: Some(Ethereum { chain_id: 11155111 }),

                        key: beneficiary_address,

                    }

                    .into(),

                },

            ]

            .into(),

        );

        let result = ContainerEthereumBlobExporter::<

            UniversalLocation,

            EthereumNetwork,

            EthereumLocation,

            MockOkOutboundQueue,

            MockTokenIdConvert,

            BridgeChannelInfo,

        >::validate(

            network,

            channel,

            &mut universal_source,

            &mut destination,

            &mut message,

        );

        assert_eq!(result, Err(Unroutable));

    }

    fn exporter_fee_amount_greater_then_reserve_amount_yields_unroutable() {

        let network = Ethereum { chain_id: 11155111 };

        let channel: u32 = 0;

        let mut universal_source: Option<InteriorLocation> = Some(

            [

                GlobalConsensus(ByGenesis([

                    152, 58, 26, 114, 80, 61, 108, 195, 99, 103, 118, 116, 126, 198, 39, 23, 43,

                    81, 39, 43, 244, 94, 80, 163, 85, 52, 143, 172, 182, 122, 130, 10,

                ])),

                Parachain(2001),

            ]

            .into(),

        );

        let mut destination: Option<InteriorLocation> = Here.into();

        let asset_location = Location::new(

            1,

            [GlobalConsensus(ByGenesis([

                152, 58, 26, 114, 80, 61, 108, 195, 99, 103, 118, 116, 126, 198, 39, 23, 43, 81,

                39, 43, 244, 94, 80, 163, 85, 52, 143, 172, 182, 122, 130, 10,

            ]))],

        );

        let assets: Assets = vec![Asset {

            id: AssetId(asset_location.clone()),

            fun: Fungible(123321000000000000),

        }]

        .into();

        let asset_location1 = Location::new(

            1,

            [GlobalConsensus(ByGenesis([

                152, 58, 26, 114, 80, 61, 108, 195, 99, 103, 118, 116, 126, 198, 39, 23, 43, 81,

                39, 43, 244, 94, 80, 163, 85, 52, 143, 172, 182, 122, 130, 10,

            ]))],

        );

        let assets1: Assets = vec![Asset {

            id: AssetId(asset_location1.clone()),

            fun: Fungible(123321000000000001),

        }]

        .into();

        let beneficiary_address: [u8; 20] = hex!("2000000000000000000000000000000000000000");

        let filter: AssetFilter = Wild(WildAsset::AllCounted(1));

        let mut message: Option<Xcm<()>> = Some(

            vec![

                ReserveAssetDeposited(assets.clone()),

                ClearOrigin,

                BuyExecution {

                    fees: assets1.get(0).unwrap().clone(),

                    weight_limit: Unlimited,

                },

                DepositAsset {

                    assets: filter,

                    beneficiary: AccountKey20 {

                        network: Some(Ethereum { chain_id: 11155111 }),

                        key: beneficiary_address,

                    }

                    .into(),

                },

            ]

            .into(),

        );

        let result = ContainerEthereumBlobExporter::<

            UniversalLocation,

            EthereumNetwork,

            EthereumLocation,

            MockOkOutboundQueue,

            MockTokenIdConvert,

            BridgeChannelInfo,

        >::validate(

            network,

            channel,

            &mut universal_source,

            &mut destination,

            &mut message,

        );

        assert_eq!(result, Err(Unroutable));

    }

    fn exporter_reserve_assets_incorrect_resolution_yields_unroutable() {

        let network = Ethereum { chain_id: 11155111 };

        let channel: u32 = 0;

        let mut universal_source: Option<InteriorLocation> = Some(

            [

                GlobalConsensus(ByGenesis([

                    152, 58, 26, 114, 80, 61, 108, 195, 99, 103, 118, 116, 126, 198, 39, 23, 43,

                    81, 39, 43, 244, 94, 80, 163, 85, 52, 143, 172, 182, 122, 130, 10,

                ])),

                Parachain(2001),

            ]

            .into(),

        );

        let mut destination: Option<InteriorLocation> = Here.into();

        let asset_location = Location::new(