fn adapt_request(mut request: TransactionRequest) -> TransactionRequest {

		// Redirect any call to batch precompile:

		// force usage of batchAll method for estimation

		use sp_core::H160;

		const BATCH_PRECOMPILE_ADDRESS: H160 = H160(hex_literal::hex!(

			"0000000000000000000000000000000000000808"

		));

		const BATCH_PRECOMPILE_BATCH_ALL_SELECTOR: [u8; 4] = hex_literal::hex!("96e292b8");

		if request.to == Some(BATCH_PRECOMPILE_ADDRESS) {

			match (&mut request.data.input, &mut request.data.data) {

				(None, Some(ref mut data)) => {

					if data.0.len() >= 4 {

						data.0[..4].copy_from_slice(&BATCH_PRECOMPILE_BATCH_ALL_SELECTOR);

					}

		}

		request

	}

pub fn create_full<C, P, BE, A>(

	deps: FullDeps<C, P, A, BE>,

	subscription_task_executor: SubscriptionTaskExecutor,

	maybe_tracing_config: Option<TracingConfig>,

	pubsub_notification_sinks: Arc<

		fc_mapping_sync::EthereumBlockNotificationSinks<

			fc_mapping_sync::EthereumBlockNotification<Block>,

		>,

	>,

	pending_consenus_data_provider: Box<dyn ConsensusDataProvider<Block>>,

) -> Result<RpcModule<()>, Box<dyn std::error::Error + Send + Sync>>

where

	BE: Backend<Block> + 'static,

	BE::State: StateBackend<BlakeTwo256>,

	BE::Blockchain: BlockchainBackend<Block>,

	C: ProvideRuntimeApi<Block> + StorageProvider<Block, BE> + AuxStore,

	C: BlockchainEvents<Block>,

	C: HeaderBackend<Block> + HeaderMetadata<Block, Error = BlockChainError> + 'static,

	C: CallApiAt<Block>,

	C: Send + Sync + 'static,

	A: ChainApi<Block = Block> + 'static,

	C::Api: RuntimeApiCollection,

	P: TransactionPool<Block = Block> + 'static,

{

	use fc_rpc::{

		Eth, EthApiServer, EthFilter, EthFilterApiServer, EthPubSub, EthPubSubApiServer, Net,

		NetApiServer, Web3, Web3ApiServer,

	};

	use moonbeam_dev_rpc::{DevApiServer, DevRpc};

	use moonbeam_finality_rpc::{MoonbeamFinality, MoonbeamFinalityApiServer};

	use moonbeam_rpc_debug::{Debug, DebugServer};

	use moonbeam_rpc_trace::{Trace, TraceServer};

	use moonbeam_rpc_txpool::{TxPool, TxPoolServer};

	use pallet_transaction_payment_rpc::{TransactionPayment, TransactionPaymentApiServer};

	use substrate_frame_rpc_system::{System, SystemApiServer};

	let mut io = RpcModule::new(());

	let FullDeps {

		client,

		pool,

		graph,

		deny_unsafe,

		is_authority,

		network,

		sync,

		filter_pool,

		ethapi_cmd,

		command_sink,

		frontier_backend,

		backend: _,

		max_past_logs,

		fee_history_limit,

		fee_history_cache,

		dev_rpc_data,

		overrides,

		block_data_cache,

		forced_parent_hashes,

	} = deps;

	io.merge(System::new(Arc::clone(&client), Arc::clone(&pool), deny_unsafe).into_rpc())?;

	io.merge(TransactionPayment::new(Arc::clone(&client)).into_rpc())?;

	let signers = Vec::new();

	enum Never {}

	impl<T> fp_rpc::ConvertTransaction<T> for Never {

		fn convert_transaction(&self, _transaction: pallet_ethereum::Transaction) -> T {

		}

	}

	let convert_transaction: Option<Never> = None;

	let pending_create_inherent_data_providers = move |_, _| async move {

		let timestamp = sp_timestamp::InherentDataProvider::from_system_time();

		// Create a dummy parachain inherent data provider which is required to pass

		// the checks by the para chain system. We use dummy values because in the 'pending context'

		// neither do we have access to the real values nor do we need them.

		let (relay_parent_storage_root, relay_chain_state) =

			RelayStateSproofBuilder::default().into_state_root_and_proof();

		let vfp = PersistedValidationData {

			// This is a hack to make `cumulus_pallet_parachain_system::RelayNumberStrictlyIncreases`

			// happy. Relay parent number can't be bigger than u32::MAX.

			relay_parent_number: u32::MAX,

			relay_parent_storage_root,

			..Default::default()

		};

		let parachain_inherent_data = ParachainInherentData {

			validation_data: vfp,

			relay_chain_state,

			downward_messages: Default::default(),

			horizontal_messages: Default::default(),

		};

		Ok((timestamp, parachain_inherent_data))

	};

	io.merge(

		Eth::<_, _, _, _, _, _, _, MoonbeamEthConfig<_, _>>::new(

			Arc::clone(&client),

			Arc::clone(&pool),

			graph.clone(),

			convert_transaction,

			Arc::clone(&sync),

			signers,

			Arc::clone(&overrides),

			Arc::clone(&frontier_backend),

			is_authority,

			Arc::clone(&block_data_cache),

			fee_history_cache,

			fee_history_limit,

			10,

			forced_parent_hashes,

			pending_create_inherent_data_providers,

			Some(pending_consenus_data_provider),

		)

		.replace_config::<MoonbeamEthConfig<C, BE>>()

		.into_rpc(),

	)?;

	if let Some(filter_pool) = filter_pool {

		io.merge(

			EthFilter::new(

				client.clone(),

				frontier_backend.clone(),

				graph.clone(),

				filter_pool,

				500_usize, // max stored filters

				max_past_logs,

				block_data_cache,

			)

			.into_rpc(),

		)?;

	io.merge(

		Net::new(

			Arc::clone(&client),

			network.clone(),

			// Whether to format the `peer_count` response as Hex (default) or not.

			true,

		)

		.into_rpc(),

	)?;

	io.merge(Web3::new(Arc::clone(&client)).into_rpc())?;

	io.merge(

		EthPubSub::new(

			pool,

			Arc::clone(&client),

			sync.clone(),

			subscription_task_executor,

			overrides,

			pubsub_notification_sinks.clone(),

		)

		.into_rpc(),

	)?;

	if ethapi_cmd.contains(&EthApiCmd::Txpool) {

		io.merge(TxPool::new(Arc::clone(&client), graph).into_rpc())?;

	io.merge(MoonbeamFinality::new(client.clone(), frontier_backend.clone()).into_rpc())?;

	if let Some(command_sink) = command_sink {

		io.merge(

			// We provide the rpc handler with the sending end of the channel to allow the rpc

			// send EngineCommands to the background block authorship task.

			ManualSeal::new(command_sink).into_rpc(),

		)?;

	if let Some((downward_message_channel, hrmp_message_channel, additional_relay_offset)) =

		dev_rpc_data

		io.merge(

			DevRpc {

				downward_message_channel,

				hrmp_message_channel,

				additional_relay_offset,

			}

			.into_rpc(),

		)?;

	if let Some(tracing_config) = maybe_tracing_config {

	}

	Ok(io)

}

pub fn spawn_essential_tasks<B, C, BE>(

	params: SpawnTasksParams<B, C, BE>,

	sync: Arc<SyncingService<B>>,

	pubsub_notification_sinks: Arc<

		fc_mapping_sync::EthereumBlockNotificationSinks<

			fc_mapping_sync::EthereumBlockNotification<B>,

		>,

	>,

) where

	C: ProvideRuntimeApi<B> + BlockOf,

	C: HeaderBackend<B> + HeaderMetadata<B, Error = BlockChainError> + 'static,

	C: BlockchainEvents<B> + StorageProvider<B, BE>,

	C: Send + Sync + 'static,

	C::Api: EthereumRuntimeRPCApi<B>,

	C::Api: BlockBuilder<B>,

	B: BlockT<Hash = H256> + Send + Sync + 'static,

	B::Header: HeaderT<Number = u32>,

	BE: Backend<B> + 'static,

	BE::State: StateBackend<BlakeTwo256>,

{

	// Frontier offchain DB task. Essential.

	// Maps emulated ethereum data to substrate native data.

	match *params.frontier_backend {

		fc_db::Backend::KeyValue(ref b) => {

			params.task_manager.spawn_essential_handle().spawn(

				"frontier-mapping-sync-worker",

				Some("frontier"),

				MappingSyncWorker::new(

					params.client.import_notification_stream(),

					Duration::new(6, 0),

					params.client.clone(),

					params.substrate_backend.clone(),

					params.overrides.clone(),

					b.clone(),

					3,

					0,

					SyncStrategy::Parachain,

					sync.clone(),

					pubsub_notification_sinks.clone(),

				)

				.for_each(|()| futures::future::ready(())),

			);

		}

	if let Some(filter_pool) = params.filter_pool {

		// Each filter is allowed to stay in the pool for 100 blocks.

		const FILTER_RETAIN_THRESHOLD: u64 = 100;

		params.task_manager.spawn_essential_handle().spawn(

			"frontier-filter-pool",

			Some("frontier"),

			EthTask::filter_pool_task(

				Arc::clone(&params.client),

				filter_pool,

				FILTER_RETAIN_THRESHOLD,

			),

		);

	}

	params.task_manager.spawn_essential_handle().spawn(

		"frontier-fee-history",

		Some("frontier"),

		EthTask::fee_history_task(

			Arc::clone(&params.client),

			Arc::clone(&params.overrides),

			params.fee_history_cache,

			params.fee_history_limit,

		),

	);

}