// 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 maintenance 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_parachain_inherent::{MockValidationDataInherentDataProvider, MockXcmConfig};

use cumulus_client_service::{

	prepare_node_config, start_relay_chain_tasks, CollatorSybilResistance, DARecoveryProfile,

	ParachainHostFunctions, ParachainTracingExecuteBlock, StartRelayChainTasksParams,

};

use cumulus_primitives_core::{

	relay_chain::{self, well_known_keys, CollatorPair},

	CollectCollationInfo, 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::{

	AuthoringPolicy, EthApi as EthApiCmd, FrontierBackendConfig, NodeExtraArgs, RpcConfig,

};

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

pub use moonbeam_runtime;

use moonbeam_vrf::VrfDigestsProvider;

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

pub use moonriver_runtime;

use nimbus_consensus::collators::slot_based::SlotBasedBlockImportHandle;

use nimbus_consensus::{

	collators::slot_based::SlotBasedBlockImport, NimbusManualSealConsensusDataProvider,

};

use nimbus_primitives::{DigestsProvider, NimbusId};

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

use sc_client_api::{

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

	ExecutorProvider,

};

use sc_consensus::{BlockImport, ImportQueue};

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

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

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, TransactionPool};

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::{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 PartialComponentsResult<Client, Backend> = Result<

	PartialComponents<

		Client,

		Backend,

		MaybeSelectChain<Backend>,

		sc_consensus::DefaultImportQueue<Block>,

		sc_transaction_pool::TransactionPoolHandle<Block, Client>,

		(

			MoonbeamBlockImport<Client>,

			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;

impl MockTimestampInherentDataProvider {

}

#[async_trait::async_trait]

impl sp_inherents::InherentDataProvider for MockTimestampInherentDataProvider {

	async fn provide_inherent_data(

		&self,

		inherent_data: &mut sp_inherents::InherentData,

		inherent_data.put_data(

			sp_timestamp::INHERENT_IDENTIFIER,

			&TIMESTAMP.load(Ordering::SeqCst),

		)

	async fn try_handle_error(

		&self,

		_identifier: &sp_inherents::InherentIdentifier,

		_error: &[u8],

		// The pallet never reports error.

		None

}

#[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,

);

pub enum MoonbeamBlockImport<Client> {

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

	Dev(FrontierBlockImport<Client>),

	/// Used in parachain mode with lookahead authoring policy.

	ParachainLookahead(FrontierBlockImport<Client>),

	/// Used in parachain mode with slot-based authoring policy.

	ParachainSlotBased(

		SlotBasedBlockImport<Block, FrontierBlockImport<Client>, Client>,

		SlotBasedBlockImportHandle<Block>,

	),

}

impl<Client> MoonbeamBlockImport<Client>

where

	Client: Send + Sync + 'static,

	Client: ProvideRuntimeApi<Block>,

	Client::Api: sp_block_builder::BlockBuilder<Block> + fp_rpc::EthereumRuntimeRPCApi<Block>,

	FrontierBlockImport<Client>: BlockImport<Block>,

	SlotBasedBlockImport<Block, FrontierBlockImport<Client>, Client>: BlockImport<Block, Error = <FrontierBlockImport<Client> as BlockImport<Block>>::Error>

		+ 'static,

{

		} else {

				AuthoringPolicy::Lookahead => {

				}

				AuthoringPolicy::SlotBased => {

				}

			}

		}

}

/// 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::kv::DatabaseSettings {

						_ => {

						}

					},

				},

		}

		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

			true,

	} else {

	};

	)

	);

				} else {

				}

			}

				} else {

				}

			}

		};

			false,

	};

	{

	} else {

		)

	};

	// Extract only the first two elements from the 4-tuple

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

#[sc_tracing::logging::prefix_logs_with("🌗")]

async fn start_node_impl<RuntimeApi, Customizations, Net>(

	parachain_config: Configuration,

	polkadot_config: Configuration,

	collator_options: CollatorOptions,

	para_id: ParaId,

	rpc_config: RpcConfig,

	block_authoring_duration: Duration,

	hwbench: Option<sc_sysinfo::HwBench>,

	node_extra_args: NodeExtraArgs,

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

where

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

	RuntimeApi::RuntimeApi:

		RuntimeApiCollection + cumulus_primitives_core::RelayParentOffsetApi<Block>,

	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,

		node_extra_args.clone(),

	)?;

	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, 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: para_id.clone(),

			relay_chain_interface: relay_chain_interface.clone(),

			net_config,

			sybil_resistance_level: CollatorSybilResistance::Resistant,

			metrics: Net::register_notification_metrics(

				parachain_config

					.prometheus_config

					.as_ref()

					.map(|config| &config.registry),

			),

		})

		.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 max_block_range = rpc_config.max_block_range;

		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(feature = "moonbase-native")]

				// Fixes for https://github.com/paritytech/frontier/pull/570

				// #1648995

					)

					)

				);

			};

			#[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(),

		tracing_execute_block: Some(Arc::new(ParachainTracingExecuteBlock::new(client.clone()))),

	})?;

	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(),

		prometheus_registry: prometheus_registry.as_ref(),

	})?;

	if matches!(block_import, MoonbeamBlockImport::Dev(_)) {

		return Err(sc_service::Error::Other(

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

		));

	}

	if collator {

		start_consensus::<RuntimeApi, _>(

			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"),

			network.local_peer_id(),

			overseer_handle,

			announce_block,

			force_authoring,

			relay_chain_slot_duration,

			block_authoring_duration,

			sync_service.clone(),

			node_extra_args,

		)?;

	}

	Ok((task_manager, client))

}

{

	);

	);

			)

			} else {

			};

				"nimbus",

			);

		}

			} else {

			};

				],

				reinitialize: false,

			});

		}

		MoonbeamBlockImport::Dev(_) => {

		}

	}

/// Start a normal parachain node.

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

#[rustfmt::skip]

			sc_network::config::NetworkBackendType::Libp2p =>

			sc_network::config::NetworkBackendType::Litep2p =>

		}

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

		other:

			(

			),

	} else {

	};