// 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/>.

//! A collection of node-specific RPC extensions and related background tasks.

pub mod tracing;

use std::{sync::Arc, time::Duration};

use fp_rpc::EthereumRuntimeRPCApi;

use sp_block_builder::BlockBuilder;

use crate::client::RuntimeApiCollection;

use crate::RELAY_CHAIN_SLOT_DURATION_MILLIS;

use cumulus_primitives_core::{ParaId, PersistedValidationData};

use cumulus_primitives_parachain_inherent::ParachainInherentData;

use cumulus_test_relay_sproof_builder::RelayStateSproofBuilder;

use fc_mapping_sync::{kv::MappingSyncWorker, SyncStrategy};

use fc_rpc::{pending::ConsensusDataProvider, EthBlockDataCacheTask, EthTask, StorageOverride};

use fc_rpc_core::types::{FeeHistoryCache, FilterPool, TransactionRequest};

use futures::StreamExt;

use jsonrpsee::RpcModule;

use moonbeam_cli_opt::EthApi as EthApiCmd;

use moonbeam_core_primitives::{Block, Hash};

use parity_scale_codec::Encode;

use sc_client_api::{

	backend::{AuxStore, Backend, StateBackend, StorageProvider},

	client::BlockchainEvents,

	BlockOf,

};

use sc_client_db::PruningMode;

use sc_consensus_manual_seal::rpc::{EngineCommand, ManualSeal, ManualSealApiServer};

use sc_network::service::traits::NetworkService;

use sc_network_sync::SyncingService;

use sc_rpc::SubscriptionTaskExecutor;

use sc_service::TaskManager;

use sc_transaction_pool_api::TransactionPool;

use sp_api::{CallApiAt, ProvideRuntimeApi};

use sp_blockchain::{

	Backend as BlockchainBackend, Error as BlockChainError, HeaderBackend, HeaderMetadata,

};

use sp_core::H256;

use sp_runtime::traits::{BlakeTwo256, Block as BlockT, Header as HeaderT};

use sp_timestamp::Timestamp;

use std::collections::BTreeMap;

pub struct MoonbeamEGA;

impl fc_rpc::EstimateGasAdapter for MoonbeamEGA {

		// 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");

				}

				}

			};

}

pub struct MoonbeamEthConfig<C, BE>(std::marker::PhantomData<(C, BE)>);

impl<C, BE> fc_rpc::EthConfig<Block, C> for MoonbeamEthConfig<C, BE>

where

	C: sc_client_api::StorageProvider<Block, BE> + Sync + Send + 'static,

	BE: Backend<Block> + 'static,

{

	type EstimateGasAdapter = MoonbeamEGA;

	type RuntimeStorageOverride =

		fc_rpc::frontier_backend_client::SystemAccountId20StorageOverride<Block, C, BE>;

}

/// Full client dependencies.

pub struct FullDeps<C, P, BE> {

	/// The client instance to use.

	pub client: Arc<C>,

	/// Transaction pool instance.

	pub pool: Arc<P>,

	/// Graph pool instance.

	pub graph: Arc<P>,

	/// The Node authority flag

	pub is_authority: bool,

	/// Network service

	pub network: Arc<dyn NetworkService>,

	/// Chain syncing service

	pub sync: Arc<SyncingService<Block>>,

	/// EthFilterApi pool.

	pub filter_pool: Option<FilterPool>,

	/// The list of optional RPC extensions.

	pub ethapi_cmd: Vec<EthApiCmd>,

	/// Frontier Backend.

	pub frontier_backend: Arc<dyn fc_api::Backend<Block>>,

	/// Backend.

	pub backend: Arc<BE>,

	/// Manual seal command sink

	pub command_sink: Option<futures::channel::mpsc::Sender<EngineCommand<Hash>>>,

	/// Maximum number of logs in a query.

	pub max_past_logs: u32,

	/// Maximum block range in a query.

	pub max_block_range: u32,

	/// Maximum fee history cache size.

	pub fee_history_limit: u64,

	/// Fee history cache.

	pub fee_history_cache: FeeHistoryCache,

	/// Channels for manual xcm messages (downward, hrmp)

	pub dev_rpc_data: Option<(

		flume::Sender<Vec<u8>>,

		flume::Sender<(ParaId, Vec<u8>)>,

		Arc<std::sync::atomic::AtomicU32>,

	)>,

	/// Ethereum data access overrides.

	pub overrides: Arc<dyn StorageOverride<Block>>,

	/// Cache for Ethereum block data.

	pub block_data_cache: Arc<EthBlockDataCacheTask<Block>>,

	/// Mandated parent hashes for a given block hash.

	pub forced_parent_hashes: Option<BTreeMap<H256, H256>>,

}

pub struct TracingConfig {

	pub tracing_requesters: crate::rpc::tracing::RpcRequesters,

	pub trace_filter_max_count: u32,

	pub max_block_range: u32,

}

/// Instantiate all Full RPC extensions.

{

	use fc_rpc::{

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

		NetApiServer, TxPool, TxPoolApiServer, 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 pallet_transaction_payment_rpc::{TransactionPayment, TransactionPaymentApiServer};

	use substrate_frame_rpc_system::{System, SystemApiServer};

	let FullDeps {

		backend: _,

	// TODO: are we supporting signing?

	enum Never {}

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

			// The Never type is not instantiable, but this method requires the type to be

			// instantiated to be called (`&self` parameter), so if the code compiles we have the

			// guarantee that this function will never be called.

		}

	}

	// Need to clone it to avoid moving of `client` variable in closure below.

		// Use timestamp in the future

		);

			));

			// 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.

	{

pub struct SpawnTasksParams<'a, B: BlockT, C, BE> {

	pub task_manager: &'a TaskManager,

	pub client: Arc<C>,

	pub substrate_backend: Arc<BE>,

	pub frontier_backend: Arc<fc_db::Backend<B, C>>,

	pub filter_pool: Option<FilterPool>,

	pub overrides: Arc<dyn StorageOverride<B>>,

	pub fee_history_limit: u64,

	pub fee_history_cache: FeeHistoryCache,

	pub state_pruning: Option<PruningMode>,

}

/// Spawn the tasks that are required to run Moonbeam.

{

	// Frontier offchain DB task. Essential.

	// Maps emulated ethereum data to substrate native data.

				"frontier-mapping-sync-worker",

					3,

					0,

						} else {

						}

				)

			);

		}

	}

	// Frontier `EthFilterApi` maintenance.

	// Manages the pool of user-created Filters.

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

		const FILTER_RETAIN_THRESHOLD: u64 = 100;

			"frontier-filter-pool",

				FILTER_RETAIN_THRESHOLD,

			),

		);

	// Spawn Frontier FeeHistory cache maintenance task.

		"frontier-fee-history",

		),

	);