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

//! This module assembles the Moonbeam service components, executes them, and manages communication

//! between them. This is the backbone of the client-side node implementation.

//!

//! This module can assemble:

//! PartialComponents: For maintence tasks without a complete node (eg import/export blocks, purge)

//! Full Service: A complete parachain node including the pool, rpc, network, embedded relay chain

//! Dev Service: A leaner service without the relay chain backing.

pub mod rpc;

use cumulus_client_cli::CollatorOptions;

use cumulus_client_collator::service::CollatorService;

use cumulus_client_consensus_common::ParachainBlockImport as TParachainBlockImport;

use cumulus_client_consensus_proposer::Proposer;

use cumulus_client_parachain_inherent::{MockValidationDataInherentDataProvider, MockXcmConfig};

use cumulus_client_service::{

	prepare_node_config, start_relay_chain_tasks, CollatorSybilResistance, DARecoveryProfile,

	ParachainHostFunctions, StartRelayChainTasksParams,

};

use cumulus_primitives_core::{

	relay_chain,

	relay_chain::{well_known_keys, CollatorPair},

	ParaId,

};

use cumulus_relay_chain_inprocess_interface::build_inprocess_relay_chain;

use cumulus_relay_chain_interface::{OverseerHandle, RelayChainInterface, RelayChainResult};

use cumulus_relay_chain_minimal_node::build_minimal_relay_chain_node_with_rpc;

use fc_consensus::FrontierBlockImport as TFrontierBlockImport;

use fc_db::DatabaseSource;

use fc_rpc::StorageOverrideHandler;

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

use futures::{FutureExt, StreamExt};

use maplit::hashmap;

#[cfg(feature = "moonbase-native")]

pub use moonbase_runtime;

use moonbeam_cli_opt::{EthApi as EthApiCmd, FrontierBackendConfig, RpcConfig};

#[cfg(feature = "moonbeam-native")]

pub use moonbeam_runtime;

use moonbeam_vrf::VrfDigestsProvider;

#[cfg(feature = "moonriver-native")]

pub use moonriver_runtime;

use nimbus_consensus::NimbusManualSealConsensusDataProvider;

use nimbus_primitives::{DigestsProvider, NimbusId};

use polkadot_primitives::{AbridgedHostConfiguration, AsyncBackingParams, Slot};

use sc_client_api::{

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

	ExecutorProvider,

};

use sc_consensus::ImportQueue;

use sc_executor::{HeapAllocStrategy, WasmExecutor, DEFAULT_HEAP_ALLOC_STRATEGY};

use sc_network::{config::FullNetworkConfiguration, NetworkBackend, NetworkBlock};

use sc_service::config::PrometheusConfig;

use sc_service::{

	error::Error as ServiceError, ChainSpec, Configuration, PartialComponents, TFullBackend,

	TFullClient, TaskManager,

};

use sc_telemetry::{Telemetry, TelemetryHandle, TelemetryWorker, TelemetryWorkerHandle};

use sc_transaction_pool_api::OffchainTransactionPoolFactory;

use session_keys_primitives::VrfApi;

use sp_api::{ConstructRuntimeApi, ProvideRuntimeApi};

use sp_blockchain::{Error as BlockChainError, HeaderBackend, HeaderMetadata};

use sp_consensus::SyncOracle;

use sp_core::{twox_128, ByteArray, Encode, H256};

use sp_keystore::{Keystore, KeystorePtr};

use std::str::FromStr;

use std::sync::atomic::{AtomicU64, Ordering};

use std::sync::Arc;

use std::{collections::BTreeMap, path::Path, sync::Mutex, time::Duration};

use substrate_prometheus_endpoint::Registry;

pub use client::*;

pub mod chain_spec;

mod client;

#[cfg(feature = "lazy-loading")]

pub mod lazy_loading;

type FullClient<RuntimeApi> = TFullClient<Block, RuntimeApi, WasmExecutor<HostFunctions>>;

type FullBackend = TFullBackend<Block>;

type MaybeSelectChain<Backend> = Option<sc_consensus::LongestChain<Backend, Block>>;

type FrontierBlockImport<Client> = TFrontierBlockImport<Block, Arc<Client>, Client>;

type ParachainBlockImport<Client, Backend> =

	TParachainBlockImport<Block, FrontierBlockImport<Client>, Backend>;

type PartialComponentsResult<Client, Backend> = Result<

	PartialComponents<

		Client,

		Backend,

		MaybeSelectChain<Backend>,

		sc_consensus::DefaultImportQueue<Block>,

		sc_transaction_pool::FullPool<Block, Client>,

		(

			BlockImportPipeline<FrontierBlockImport<Client>, ParachainBlockImport<Client, Backend>>,

			Option<FilterPool>,

			Option<Telemetry>,

			Option<TelemetryWorkerHandle>,

			Arc<fc_db::Backend<Block, Client>>,

			FeeHistoryCache,

		),

	>,

	ServiceError,

>;

const RELAY_CHAIN_SLOT_DURATION_MILLIS: u64 = 6_000;

static TIMESTAMP: AtomicU64 = AtomicU64::new(0);

/// Provide a mock duration starting at 0 in millisecond for timestamp inherent.

/// Each call will increment timestamp by slot_duration making Aura think time has passed.

struct MockTimestampInherentDataProvider;

#[async_trait::async_trait]

impl sp_inherents::InherentDataProvider for MockTimestampInherentDataProvider {

	async fn provide_inherent_data(

		&self,

		inherent_data: &mut sp_inherents::InherentData,

	async fn try_handle_error(

		&self,

		_identifier: &sp_inherents::InherentIdentifier,

		_error: &[u8],

		// The pallet never reports error.

}

#[cfg(feature = "runtime-benchmarks")]

pub type HostFunctions = (

	frame_benchmarking::benchmarking::HostFunctions,

	ParachainHostFunctions,

	moonbeam_primitives_ext::moonbeam_ext::HostFunctions,

);

#[cfg(not(feature = "runtime-benchmarks"))]

pub type HostFunctions = (

	ParachainHostFunctions,

	moonbeam_primitives_ext::moonbeam_ext::HostFunctions,

);

/// Block Import Pipeline used.

pub enum BlockImportPipeline<T, E> {

	/// Used in dev mode to import new blocks as best blocks.

	Dev(T),

	/// Used in parachain mode.

	Parachain(E),

}

/// A trait that must be implemented by all moon* runtimes executors.

///

/// This feature allows, for instance, to customize the client extensions according to the type

/// of network.

/// For the moment, this feature is only used to specify the first block compatible with

/// ed25519-zebra, but it could be used for other things in the future.

pub trait ClientCustomizations {

	/// The host function ed25519_verify has changed its behavior in the substrate history,

	/// because of the change from lib ed25519-dalek to lib ed25519-zebra.

	/// Some networks may have old blocks that are not compatible with ed25519-zebra,

	/// for these networks this function should return the 1st block compatible with the new lib.

	/// If this function returns None (default behavior), it implies that all blocks are compatible

	/// with the new lib (ed25519-zebra).

}

#[cfg(feature = "moonbeam-native")]

pub struct MoonbeamCustomizations;

#[cfg(feature = "moonbeam-native")]

impl ClientCustomizations for MoonbeamCustomizations {

}

#[cfg(feature = "moonriver-native")]

pub struct MoonriverCustomizations;

#[cfg(feature = "moonriver-native")]

impl ClientCustomizations for MoonriverCustomizations {

}

#[cfg(feature = "moonbase-native")]

pub struct MoonbaseCustomizations;

#[cfg(feature = "moonbase-native")]

impl ClientCustomizations for MoonbaseCustomizations {

}

/// Trivial enum representing runtime variant

#[derive(Clone)]

pub enum RuntimeVariant {

	#[cfg(feature = "moonbeam-native")]

	Moonbeam,

	#[cfg(feature = "moonriver-native")]

	Moonriver,

	#[cfg(feature = "moonbase-native")]

	Moonbase,

	Unrecognized,

}

impl RuntimeVariant {

			#[cfg(feature = "moonbeam-native")]

			#[cfg(feature = "moonriver-native")]

			#[cfg(feature = "moonbase-native")]

		}

}

/// Can be called for a `Configuration` to check if it is a configuration for

/// the `Moonbeam` network.

pub trait IdentifyVariant {

	/// Returns `true` if this is a configuration for the `Moonbase` network.

	fn is_moonbase(&self) -> bool;

	/// Returns `true` if this is a configuration for the `Moonbeam` network.

	fn is_moonbeam(&self) -> bool;

	/// Returns `true` if this is a configuration for the `Moonriver` network.

	fn is_moonriver(&self) -> bool;

	/// Returns `true` if this is a configuration for a dev network.

	fn is_dev(&self) -> bool;

}

impl IdentifyVariant for Box<dyn ChainSpec> {

}

// TODO This is copied from frontier. It should be imported instead after

// https://github.com/paritytech/frontier/issues/333 is solved

		FrontierBackendConfig::KeyValue => {

			fc_db::Backend::KeyValue(Arc::new(fc_db::kv::Backend::<Block, C>::new(

						_ => {

						}

					},

				},

		}

		FrontierBackendConfig::Sql {

		}

	};

use sp_runtime::{traits::BlakeTwo256, DigestItem, Percent};

pub const SOFT_DEADLINE_PERCENT: Percent = Percent::from_percent(100);

/// Builds a new object suitable for chain operations.

#[allow(clippy::type_complexity)]

		#[cfg(feature = "moonriver-native")]

		#[cfg(feature = "moonbeam-native")]

		#[cfg(feature = "moonbase-native")]

		#[cfg(not(feature = "moonbase-native"))]

		_ => panic!("invalid chain spec"),

	}

#[allow(clippy::type_complexity)]

	let PartialComponents {

		..

// If we're using prometheus, use a registry with a prefix of `moonbeam`.

		} else {

		};

/// Builds the PartialComponents for a parachain or development service

///

/// Use this function if you don't actually need the full service, but just the partial in order to

/// be able to perform chain operations.

#[allow(clippy::type_complexity)]

	// Use ethereum style for subscription ids

	} else {

	};

		(

		)

	} else {

		} else {

		};

		(

		)

	};

	{

	} else {

	}

/// Start a node with the given parachain `Configuration` and relay chain `Configuration`.

///

/// This is the actual implementation that is abstract over the executor and the runtime api.

async fn start_node_impl<RuntimeApi, Customizations, Net>(

	parachain_config: Configuration,

	polkadot_config: Configuration,

	collator_options: CollatorOptions,

	para_id: ParaId,

	rpc_config: RpcConfig,

	async_backing: bool,

	block_authoring_duration: Duration,

	hwbench: Option<sc_sysinfo::HwBench>,

	legacy_block_import_strategy: bool,

	nimbus_full_pov: bool,

) -> sc_service::error::Result<(TaskManager, Arc<FullClient<RuntimeApi>>)>

where

	RuntimeApi: ConstructRuntimeApi<Block, FullClient<RuntimeApi>> + Send + Sync + 'static,

	RuntimeApi::RuntimeApi: RuntimeApiCollection,

	Customizations: ClientCustomizations + 'static,

	Net: NetworkBackend<Block, Hash>,

{

	let mut parachain_config = prepare_node_config(parachain_config);

	let params = new_partial::<RuntimeApi, Customizations>(

		&mut parachain_config,

		&rpc_config,

		false,

		legacy_block_import_strategy,

	)?;

	let (

		block_import,

		filter_pool,

		mut telemetry,

		telemetry_worker_handle,

		frontier_backend,

		fee_history_cache,

	) = params.other;

	let client = params.client.clone();

	let backend = params.backend.clone();

	let mut task_manager = params.task_manager;

	let (relay_chain_interface, collator_key) = build_relay_chain_interface(

		polkadot_config,

		&parachain_config,

		telemetry_worker_handle,

		&mut task_manager,

		collator_options.clone(),

		hwbench.clone(),

	)

	.await

	let force_authoring = parachain_config.force_authoring;

	let collator = parachain_config.role.is_authority();

	let prometheus_registry = parachain_config.prometheus_registry().cloned();

	let transaction_pool = params.transaction_pool.clone();

	let import_queue_service = params.import_queue.service();

	let net_config = FullNetworkConfiguration::<_, _, Net>::new(

		&parachain_config.network,

		prometheus_registry.clone(),

	);

	let (network, system_rpc_tx, tx_handler_controller, start_network, sync_service) =

		cumulus_client_service::build_network(cumulus_client_service::BuildNetworkParams {

			parachain_config: &parachain_config,

			client: client.clone(),

			transaction_pool: transaction_pool.clone(),

			spawn_handle: task_manager.spawn_handle(),

			import_queue: params.import_queue,

			para_id,

			relay_chain_interface: relay_chain_interface.clone(),

			net_config,

			sybil_resistance_level: CollatorSybilResistance::Resistant,

		})

		.await?;

	let overrides = Arc::new(StorageOverrideHandler::new(client.clone()));

	let fee_history_limit = rpc_config.fee_history_limit;

	// Sinks for pubsub notifications.

	// Everytime a new subscription is created, a new mpsc channel is added to the sink pool.

	// The MappingSyncWorker sends through the channel on block import and the subscription emits a

	// notification to the subscriber on receiving a message through this channel.

	// This way we avoid race conditions when using native substrate block import notification

	// stream.

	let pubsub_notification_sinks: fc_mapping_sync::EthereumBlockNotificationSinks<

		fc_mapping_sync::EthereumBlockNotification<Block>,

	> = Default::default();

	let pubsub_notification_sinks = Arc::new(pubsub_notification_sinks);

	rpc::spawn_essential_tasks(

		rpc::SpawnTasksParams {

			task_manager: &task_manager,

			client: client.clone(),

			substrate_backend: backend.clone(),

			frontier_backend: frontier_backend.clone(),

			filter_pool: filter_pool.clone(),

			overrides: overrides.clone(),

			fee_history_limit,

			fee_history_cache: fee_history_cache.clone(),

		},

		sync_service.clone(),

		pubsub_notification_sinks.clone(),

	);

	let ethapi_cmd = rpc_config.ethapi.clone();

	let tracing_requesters =

		if ethapi_cmd.contains(&EthApiCmd::Debug) || ethapi_cmd.contains(&EthApiCmd::Trace) {

			rpc::tracing::spawn_tracing_tasks(

				&rpc_config,

				prometheus_registry.clone(),

				rpc::SpawnTasksParams {

					task_manager: &task_manager,

					client: client.clone(),

					substrate_backend: backend.clone(),

					frontier_backend: frontier_backend.clone(),

					filter_pool: filter_pool.clone(),

					overrides: overrides.clone(),

					fee_history_limit,

					fee_history_cache: fee_history_cache.clone(),

				},

			)

		} else {

			rpc::tracing::RpcRequesters {

				debug: None,

				trace: None,

			}

		};

	let block_data_cache = Arc::new(fc_rpc::EthBlockDataCacheTask::new(

		task_manager.spawn_handle(),

		overrides.clone(),

		rpc_config.eth_log_block_cache,

		rpc_config.eth_statuses_cache,

		prometheus_registry.clone(),

	));

	let rpc_builder = {

		let client = client.clone();

		let pool = transaction_pool.clone();

		let network = network.clone();

		let sync = sync_service.clone();

		let filter_pool = filter_pool.clone();

		let frontier_backend = frontier_backend.clone();

		let backend = backend.clone();

		let ethapi_cmd = ethapi_cmd.clone();

		let max_past_logs = rpc_config.max_past_logs;

		let overrides = overrides.clone();

		let fee_history_cache = fee_history_cache.clone();

		let block_data_cache = block_data_cache.clone();

		let pubsub_notification_sinks = pubsub_notification_sinks.clone();

		let keystore = params.keystore_container.keystore();

			};

			#[cfg(not(feature = "moonbase-native"))]

			let forced_parent_hashes = None;

				},

			} else {

			}

	};

	sc_service::spawn_tasks(sc_service::SpawnTasksParams {

		rpc_builder: Box::new(rpc_builder),

		client: client.clone(),

		transaction_pool: transaction_pool.clone(),

		task_manager: &mut task_manager,

		config: parachain_config,

		keystore: params.keystore_container.keystore(),

		backend: backend.clone(),

		network: network.clone(),

		sync_service: sync_service.clone(),

		system_rpc_tx,

		tx_handler_controller,

		telemetry: telemetry.as_mut(),

	})?;

	if let Some(hwbench) = hwbench {

		sc_sysinfo::print_hwbench(&hwbench);

		if let Some(ref mut telemetry) = telemetry {

			let telemetry_handle = telemetry.handle();

			task_manager.spawn_handle().spawn(

				"telemetry_hwbench",

				None,

				sc_sysinfo::initialize_hwbench_telemetry(telemetry_handle, hwbench),

			);

		}

	}

	let announce_block = {

		let sync_service = sync_service.clone();

	};

	let relay_chain_slot_duration = Duration::from_secs(6);

	let overseer_handle = relay_chain_interface

		.overseer_handle()

	start_relay_chain_tasks(StartRelayChainTasksParams {

		client: client.clone(),

		announce_block: announce_block.clone(),

		para_id,

		relay_chain_interface: relay_chain_interface.clone(),

		task_manager: &mut task_manager,

		da_recovery_profile: if collator {

			DARecoveryProfile::Collator

		} else {

			DARecoveryProfile::FullNode

		},

		import_queue: import_queue_service,

		relay_chain_slot_duration,

		recovery_handle: Box::new(overseer_handle.clone()),

		sync_service: sync_service.clone(),

	})?;

	let BlockImportPipeline::Parachain(block_import) = block_import else {

		return Err(sc_service::Error::Other(

			"Block import pipeline is not for parachain".into(),

		));

	};

	if collator {

		start_consensus::<RuntimeApi, _>(

			async_backing,

			backend.clone(),

			client.clone(),

			block_import,

			prometheus_registry.as_ref(),

			&task_manager,

			relay_chain_interface.clone(),

			transaction_pool,

			params.keystore_container.keystore(),

			para_id,

			collator_key.expect("Command line arguments do not allow this. qed"),

			overseer_handle,

			announce_block,

			force_authoring,

			relay_chain_slot_duration,

			block_authoring_duration,

			sync_service.clone(),

			nimbus_full_pov,

		)?;

		/*let parachain_consensus = build_consensus(

			client.clone(),

			backend,

			block_import,

			prometheus_registry.as_ref(),

			telemetry.as_ref().map(|t| t.handle()),

			&task_manager,

			relay_chain_interface.clone(),

			transaction_pool,

			sync_service.clone(),

			params.keystore_container.keystore(),

			force_authoring,

		)?;

		let spawner = task_manager.spawn_handle();

		let params = StartCollatorParams {

			para_id,

			block_status: client.clone(),

			announce_block,

			client: client.clone(),

			task_manager: &mut task_manager,

			relay_chain_interface,

			spawner,

			parachain_consensus,

			import_queue: import_queue_service,

			recovery_handle: Box::new(overseer_handle),

			collator_key: collator_key.ok_or(sc_service::error::Error::Other(

				"Collator Key is None".to_string(),

			))?,

			relay_chain_slot_duration,

			sync_service,

		};

		#[allow(deprecated)]

		start_collator(params).await?;*/

	}

	start_network.start_network();

	Ok((task_manager, client))

}

	} else {

	};

/// Start a normal parachain node.

// Rustfmt wants to format the closure with space identation.

#[rustfmt::skip]

/// Builds a new development service. This service uses manual seal, and mocks

/// the parachain inherent.

	use async_io::Timer;

	use futures::Stream;

	use sc_consensus_manual_seal::{run_manual_seal, EngineCommand, ManualSealParams};

	let sc_service::PartialComponents {

			),

	} else {

	};

		// TODO: Need to cherry-pick

		//

		// https://github.com/moonbeam-foundation/substrate/commit/

		// d59476b362e38071d44d32c98c32fb35fd280930#diff-a1c022c97c7f9200cab161864c

		// 06d204f0c8b689955e42177731e232115e9a6f

		//

		// env.enable_ensure_proof_size_limit_after_each_extrinsic();

				moonbeam_cli_opt::Sealing::Instant => {

				}

				moonbeam_cli_opt::Sealing::Manual => {

				}

			};