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

#[macro_export]

macro_rules! impl_runtime_apis_plus_common {

    ({$($custom:tt)*} {$($bench_custom:tt)*}) => {

    	use ethereum::AuthorizationList;

		#[cfg(feature = "evm-tracing")]

		// Helper function to replay the "on_idle" hook for all pallets, we need this for

		// evm-tracing because some ethereum-xcm transactions might be executed at on_idle.

		//

		// We need to make sure that we replay on_idle exactly the same way as the

		// original block execution, but unfortunatly frame executive diosn't provide a function

		// to replay only on_idle, so we need to copy here some code inside frame executive.

			use frame_system::pallet_prelude::BlockNumberFor;

			use frame_support::traits::OnIdle;

		impl_runtime_apis! {

			$($custom)*

			impl sp_api::Core<Block> for Runtime {

			}

			impl cumulus_primitives_core::RelayParentOffsetApi<Block> for Runtime {

			}

			impl cumulus_primitives_core::GetCoreSelectorApi<Block> for Runtime {

			}

			impl sp_api::Metadata<Block> for Runtime {

			}

			impl sp_block_builder::BlockBuilder<Block> for Runtime {

			}

			impl sp_offchain::OffchainWorkerApi<Block> for Runtime {

			}

			impl sp_session::SessionKeys<Block> for Runtime {

			}

			impl sp_genesis_builder::GenesisBuilder<Block> for Runtime {

				#[cfg(not(feature = "disable-genesis-builder"))]

				#[cfg(feature = "disable-genesis-builder")]

				fn get_preset(id: &Option<sp_genesis_builder::PresetId>) -> Option<Vec<u8>> {

					None

				}

				#[cfg(not(feature = "disable-genesis-builder"))]

				#[cfg(feature = "disable-genesis-builder")]

				fn preset_names() -> Vec<sp_genesis_builder::PresetId> {

					Default::default()

				}

			}

			impl frame_system_rpc_runtime_api::AccountNonceApi<Block, AccountId, Index> for Runtime {

			}

			impl moonbeam_rpc_primitives_debug::DebugRuntimeApi<Block> for Runtime {

					#[cfg(feature = "evm-tracing")]

					{

						use moonbeam_evm_tracer::tracer::{

							EthereumTracingStatus,

							EvmTracer,

							EthereumTracer

						};

						use frame_support::storage::unhashed;

						use frame_system::pallet_prelude::BlockNumberFor;

						// Tell the CallDispatcher we are tracing a specific Transaction.

							// Initialize block: calls the "on_initialize" hook on every pallet

							// in AllPalletsWithSystem.

							// After pallet message queue was introduced, this must be done only after

							// enabling XCM tracing by calling ETHEREUM_TRACING_STATUS::using

							// in the storage

							// Apply the a subset of extrinsics: all the substrate-specific or ethereum

							// transactions that preceded the requested transaction.

										// Reset the previously consumed weight when tracing ethereum transactions.

										// This is necessary because EVM tracing introduces additional

										// (ref_time) overhead, which differs from the production runtime behavior.

										// Without resetting the block weight, the extra tracing overhead could

										// leading to some transactions to incorrectly fail during tracing.

										} else {

										}

									}

								};

							}

								// The transaction was found

							} else {

								// The transaction was not-found

							}

					}

					#[cfg(not(feature = "evm-tracing"))]

					#[cfg(feature = "evm-tracing")]

					{

						use moonbeam_evm_tracer::tracer::{

							EthereumTracingStatus,

							EvmTracer,

							EthereumTracer

						};

						use frame_system::pallet_prelude::BlockNumberFor;

						// Tell the CallDispatcher we are tracing a full Block.

							// Initialize block: calls the "on_initialize" hook on every pallet

							// in AllPalletsWithSystem.

							// After pallet message queue was introduced, this must be done only after

							// enabling XCM tracing by calling ETHEREUM_TRACING_STATUS::using

							// in the storage

							// Apply all extrinsics. Ethereum extrinsics are traced.

										// Reset the previously consumed weight when tracing multiple transactions.

										// This is necessary because EVM tracing introduces additional

										// (ref_time) overhead, which differs from the production runtime behavior.

										// Without resetting the block weight, the extra tracing overhead could

										// leading to some transactions to incorrectly fail during tracing.

											// Each known extrinsic is a new call stack.

														err

													);

										} else {

													err

												);

										}

									}

									_ => {

												err

											);

									}

								};

							}

							// Replay on_idle

							// Some XCM messages with eth-xcm transaction might be executed at on_idle

					}

					#[cfg(not(feature = "evm-tracing"))]

					#[cfg(feature = "evm-tracing")]

					{

						use moonbeam_evm_tracer::tracer::EvmTracer;

						// Initialize block: calls the "on_initialize" hook on every pallet

						// in AllPalletsWithSystem.

							);

					}

					#[cfg(not(feature = "evm-tracing"))]

			}

			impl moonbeam_rpc_primitives_txpool::TxPoolRuntimeApi<Block> for Runtime {

					TxPoolResponse {

					}

			}

			impl fp_rpc::EthereumRuntimeRPCApi<Block> for Runtime {

					} else {

					};

					);

					} else {

					};

					);

					#[allow(clippy::or_fun_call)] // suggestion not helpful here

			}

			impl fp_rpc::ConvertTransactionRuntimeApi<Block> for Runtime {

					)

			}

			impl pallet_transaction_payment_rpc_runtime_api::TransactionPaymentApi<Block, Balance>

			for Runtime {

			}

			impl nimbus_primitives::NimbusApi<Block> for Runtime {

					use pallet_parachain_staking::Config as PalletParachainStakingConfig;

					// The Moonbeam runtimes use an entropy source that needs to do some accounting

					// work during block initialization. Therefore we initialize it here to match

					// the state it will be in when the next block is being executed.

					use frame_support::traits::OnInitialize;

					);

					// Because the staking solution calculates the next staking set at the beginning

					// of the first block in the new round, the only way to accurately predict the

					// authors is to compute the selection during prediction.

						// get author account id

						use nimbus_primitives::AccountLookup;

						} else {

							// return false if author mapping not registered like in can_author impl

						};

							// If there are zero selected candidates, we use the same eligibility

							// as the previous round

						// predict eligibility post-selection by computing selection results now

					} else {

					}

			}

			impl cumulus_primitives_core::CollectCollationInfo<Block> for Runtime {

			}

			impl session_keys_primitives::VrfApi<Block> for Runtime {

					// TODO: remove in future runtime upgrade along with storage item

					use session_keys_primitives::KeysLookup;

			}

			impl xcm_runtime_apis::fees::XcmPaymentApi<Block> for Runtime {

			}

			impl xcm_runtime_apis::dry_run::DryRunApi<Block, RuntimeCall, RuntimeEvent, OriginCaller>

				for Runtime {

				}

			impl xcm_runtime_apis::conversions::LocationToAccountApi<Block, AccountId> for Runtime {

			}

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

			impl frame_benchmarking::Benchmark<Block> for Runtime {

				fn benchmark_metadata(extra: bool) -> (

					Vec<frame_benchmarking::BenchmarkList>,

					Vec<frame_support::traits::StorageInfo>,

				) {

					use frame_benchmarking::{list_benchmark, Benchmarking, BenchmarkList};

					use frame_system_benchmarking::Pallet as SystemBench;

					use frame_support::traits::StorageInfoTrait;

					use pallet_xcm::benchmarking::Pallet as PalletXcmExtrinsicsBenchmark;

					use pallet_transaction_payment::benchmarking::Pallet as TransactionPaymentBenchmark;

					let mut list = Vec::<BenchmarkList>::new();

					list_benchmarks!(list, extra);

					let storage_info = AllPalletsWithSystem::storage_info();

					return (list, storage_info)

				}

				#[allow(non_local_definitions)]

				fn dispatch_benchmark(

					config: frame_benchmarking::BenchmarkConfig,

				) -> Result<Vec<frame_benchmarking::BenchmarkBatch>, alloc::string::String> {

					use frame_benchmarking::{add_benchmark, BenchmarkBatch, Benchmarking};

					use frame_support::traits::TrackedStorageKey;

					use cumulus_primitives_core::ParaId;

					use xcm::latest::prelude::{

						GeneralIndex, Junction, Junctions, Location, Response, NetworkId, AssetId,

						Assets as XcmAssets, Fungible, Asset, ParentThen, Parachain, Parent, WeightLimit

					};

					use xcm_config::SelfReserve;

					use frame_benchmarking::BenchmarkError;

					use frame_system_benchmarking::Pallet as SystemBench;

					// Needed to run `set_code` and `apply_authorized_upgrade` frame_system benchmarks

					// https://github.com/paritytech/cumulus/pull/2766

					impl frame_system_benchmarking::Config for Runtime {

						fn setup_set_code_requirements(code: &Vec<u8>) -> Result<(), BenchmarkError> {

							ParachainSystem::initialize_for_set_code_benchmark(code.len() as u32);

							Ok(())

						}

						fn verify_set_code() {

							System::assert_last_event(cumulus_pallet_parachain_system::Event::<Runtime>::ValidationFunctionStored.into());

						}

					}

					// Needed to run `charge_transaction_payment` benchmark which distributes

					// fees to block author. Moonbeam requires an author to be set for fee distribution.

					use pallet_transaction_payment::benchmarking::Pallet as TransactionPaymentBenchmark;

					impl pallet_transaction_payment::benchmarking::Config for Runtime {

						fn setup_benchmark_environment() {

							// Set a dummy author for the block so fee distribution doesn't panic

							let author: AccountId = frame_benchmarking::whitelisted_caller();

							pallet_author_inherent::Author::<Runtime>::put(author);

						}

					}

					use pallet_xcm::benchmarking::Pallet as PalletXcmExtrinsicsBenchmark;

					parameter_types! {

						pub const RandomParaId: ParaId = ParaId::new(43211234);

					}

					/// Custom delivery helper for Moonbeam that works with H160 accounts.

					/// This is needed because Moonbeam uses AccountKey20 (H160) accounts

					/// instead of AccountId32, and the standard ToParentDeliveryHelper

					/// fails when trying to deposit assets to an origin location.

					pub struct TestDeliveryHelper;

					impl xcm_builder::EnsureDelivery for TestDeliveryHelper {

						fn ensure_successful_delivery(

							origin_ref: &Location,

							dest: &Location,

							_fee_reason: xcm_executor::traits::FeeReason,

						) -> (Option<xcm_executor::FeesMode>, Option<XcmAssets>) {

							use xcm_executor::traits::ConvertLocation;

							// Ensure the XCM sender is properly configured for benchmarks

							// This sets up the HostConfiguration for sending messages

							<xcm_config::XcmRouter as xcm::latest::SendXcm>::ensure_successful_delivery(Some(dest.clone()));

							// Open HRMP channel for sibling parachain destinations

							if let Some(Parachain(para_id)) = dest.interior().first() {

								ParachainSystem::open_outbound_hrmp_channel_for_benchmarks_or_tests(

									(*para_id).into()

								);

							}

							// Deposit existential deposit to the origin account if we can convert it

							if let Some(account) = xcm_config::LocationToH160::convert_location(origin_ref) {

								let balance = ExistentialDeposit::get() * 1000u128;

								let _ = <Balances as frame_support::traits::Currency<_>>::

									make_free_balance_be(&account.into(), balance);

							}

							(None, None)

						}

					}

					impl pallet_xcm::benchmarking::Config for Runtime {

				        type DeliveryHelper = TestDeliveryHelper;

						fn get_asset() -> Asset {

							Asset {

								id: AssetId(SelfReserve::get()),

								fun: Fungible(ExistentialDeposit::get()),

							}

						}

						fn reachable_dest() -> Option<Location> {

							Some(Parent.into())

						}

						fn teleportable_asset_and_dest() -> Option<(Asset, Location)> {

							None

						}

						fn reserve_transferable_asset_and_dest() -> Option<(Asset, Location)> {

							use xcm_config::SelfReserve;

							ParachainSystem::open_outbound_hrmp_channel_for_benchmarks_or_tests(

								RandomParaId::get().into()

							);

							Some((

								Asset {

									fun: Fungible(ExistentialDeposit::get()),

									id: AssetId(SelfReserve::get().into())

								},

								// Moonbeam can reserve transfer native token to

								// some random parachain.

								ParentThen(Parachain(RandomParaId::get().into()).into()).into(),

							))

						}

						fn set_up_complex_asset_transfer(

						) -> Option<(XcmAssets, u32, Location, Box<dyn FnOnce()>)> {

							use xcm_config::SelfReserve;

							let destination: xcm::v5::Location = Parent.into();

							let fee_amount: u128 = <Runtime as pallet_balances::Config>::ExistentialDeposit::get();

							let fee_asset: Asset = (SelfReserve::get(), fee_amount).into();

							// Give some multiple of transferred amount

							let balance = fee_amount * 1000;

							let who = frame_benchmarking::whitelisted_caller();

							let _ =

								<Balances as frame_support::traits::Currency<_>>::make_free_balance_be(&who, balance);

							// verify initial balance

							assert_eq!(Balances::free_balance(&who), balance);

							// set up foreign asset

							let asset_amount: u128 = 10u128;

							let initial_asset_amount: u128 = asset_amount * 10;

							let asset_id = pallet_moonbeam_foreign_assets::default_asset_id::<Runtime>() + 1;

							let (_, location, _) = pallet_moonbeam_foreign_assets::create_default_minted_foreign_asset::<Runtime>(

								asset_id,

								initial_asset_amount,

							);

							let transfer_asset: Asset = (AssetId(location), asset_amount).into();

							let assets: XcmAssets = vec![fee_asset.clone(), transfer_asset].into();

							let fee_index: u32 = 0;

							let verify: Box<dyn FnOnce()> = Box::new(move || {

								// verify balance after transfer, decreased by

								// transferred amount (and delivery fees)

								assert!(Balances::free_balance(&who) <= balance - fee_amount);

							});

							Some((assets, fee_index, destination, verify))

						}

					}

					impl pallet_xcm_benchmarks::Config for Runtime {

						type XcmConfig = xcm_config::XcmExecutorConfig;

						type AccountIdConverter = xcm_config::LocationToAccountId;

						type DeliveryHelper = TestDeliveryHelper;

						fn valid_destination() -> Result<Location, BenchmarkError> {

							Ok(Location::parent())

						}

						fn worst_case_holding(_depositable_count: u32) -> XcmAssets {

						// 100 fungibles

							const HOLDING_FUNGIBLES: u32 = 100;

							let fungibles_amount: u128 = 100;

							let assets = (0..HOLDING_FUNGIBLES).map(|i| {

								let location: Location = GeneralIndex(i as u128).into();

								Asset {

									id: AssetId(location),

									fun: Fungible(fungibles_amount * i as u128),

								}

								.into()

							})

							.chain(

								core::iter::once(

									Asset {

										id: AssetId(Location::parent()),

										fun: Fungible(u128::MAX)

									}

								)

							)

							.collect::<Vec<_>>();

							for (i, asset) in assets.iter().enumerate() {

								if let Asset {

									id: AssetId(location),

									fun: Fungible(_)

								} = asset {

									EvmForeignAssets::set_asset(

										location.clone(),

										i as u128

									);

									XcmWeightTrader::set_asset_price(

										location.clone(),

										1u128.pow(18)

									);

								}

							}

							assets.into()

						}

					}

					impl pallet_xcm_benchmarks::generic::Config for Runtime {

						type RuntimeCall = RuntimeCall;

						type TransactAsset = Balances;

						fn worst_case_response() -> (u64, Response) {

							(0u64, Response::Version(Default::default()))

						}

						fn worst_case_asset_exchange()

							-> Result<(XcmAssets, XcmAssets), BenchmarkError> {

							Err(BenchmarkError::Skip)

						}

						fn universal_alias() -> Result<(Location, Junction), BenchmarkError> {

							Err(BenchmarkError::Skip)

						}

						fn export_message_origin_and_destination()

							-> Result<(Location, NetworkId, Junctions), BenchmarkError> {

							Err(BenchmarkError::Skip)

						}

						fn transact_origin_and_runtime_call()

							-> Result<(Location, RuntimeCall), BenchmarkError> {

							Ok((Location::parent(), frame_system::Call::remark_with_event {

								remark: vec![]

							}.into()))

						}

						fn subscribe_origin() -> Result<Location, BenchmarkError> {

							Ok(Location::parent())

						}

						fn claimable_asset()

							-> Result<(Location, Location, XcmAssets), BenchmarkError> {

							let origin = Location::parent();

							let assets: XcmAssets = (AssetId(Location::parent()), 1_000u128)

								.into();

							let ticket = Location { parents: 0, interior: [].into() /* Here */ };

							Ok((origin, ticket, assets))

						}

						fn worst_case_for_trader() -> Result<(Asset, WeightLimit), BenchmarkError> {

							Err(BenchmarkError::Skip)

						}

						fn unlockable_asset()

							-> Result<(Location, Location, Asset), BenchmarkError> {

							Err(BenchmarkError::Skip)

						}

						fn alias_origin() -> Result<(Location, Location), BenchmarkError> {

							Err(BenchmarkError::Skip)

						}

					}

					$($bench_custom)*

					let whitelist: Vec<TrackedStorageKey> = vec![

						// Block Number

						hex_literal::hex!(  "26aa394eea5630e07c48ae0c9558cef7"

											"02a5c1b19ab7a04f536c519aca4983ac")

							.to_vec().into(),

						// Total Issuance

						hex_literal::hex!(  "c2261276cc9d1f8598ea4b6a74b15c2f"

											"57c875e4cff74148e4628f264b974c80")

							.to_vec().into(),

						// Execution Phase

						hex_literal::hex!(  "26aa394eea5630e07c48ae0c9558cef7"

											"ff553b5a9862a516939d82b3d3d8661a")

							.to_vec().into(),

						// Event Count

						hex_literal::hex!(  "26aa394eea5630e07c48ae0c9558cef7"

											"0a98fdbe9ce6c55837576c60c7af3850")

							.to_vec().into(),

						// System Events

						hex_literal::hex!(  "26aa394eea5630e07c48ae0c9558cef7"

											"80d41e5e16056765bc8461851072c9d7")

							.to_vec().into(),

						// System BlockWeight

						hex_literal::hex!(  "26aa394eea5630e07c48ae0c9558cef7"

											"34abf5cb34d6244378cddbf18e849d96")

							.to_vec().into(),

						// ParachainStaking Round

						hex_literal::hex!(  "a686a3043d0adcf2fa655e57bc595a78"

											"13792e785168f725b60e2969c7fc2552")

							.to_vec().into(),

						// Treasury Account (py/trsry)

						hex_literal::hex!(  "26aa394eea5630e07c48ae0c9558cef7"

											"b99d880ec681799c0cf30e8886371da9"

											"7be2919ac397ba499ea5e57132180ec6"

											"6d6f646c70792f747273727900000000"

											"00000000"

						).to_vec().into(),

						// Treasury Account (pc/trsry)

						hex_literal::hex!(  "26aa394eea5630e07c48ae0c9558cef7"

											"b99d880ec681799c0cf30e8886371da9"

											"7be2919ac397ba499ea5e57132180ec6"

											"6d6f646c70632f747273727900000000"

											"00000000"

						).to_vec().into(),

						// ParachainInfo ParachainId

						hex_literal::hex!(  "0d715f2646c8f85767b5d2764bb27826"

											"04a74d81251e398fd8a0a4d55023bb3f")

							.to_vec().into(),

						// Parameters Parameters

						hex_literal::hex!(  "c63bdd4a39095ccf55623a6f2872bf8a" // Pallet: "Parameters"

											"c63bdd4a39095ccf55623a6f2872bf8a" // Storage Prefix: "Parameters"

											// MoonbaseRuntimeRuntimeParamsRuntimeParametersKey(FeesTreasuryProportion)

											"71d0aacb690b61280d0c97c6b6a666640000"

										)

							.to_vec().into(),

					];

					let mut batches = Vec::<BenchmarkBatch>::new();

					let params = (&config, &whitelist);

					add_benchmarks!(params, batches);

					if batches.is_empty() {

						return Err("Benchmark not found for this pallet.".into());

					}

					Ok(batches)

				}

			}

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

			impl frame_try_runtime::TryRuntime<Block> for Runtime {

				fn on_runtime_upgrade(checks: frame_try_runtime::UpgradeCheckSelect) -> (Weight, Weight) {

					log::info!("try-runtime::on_runtime_upgrade()");

					// NOTE: intentional expect: we don't want to propagate the error backwards,

					// and want to have a backtrace here. If any of the pre/post migration checks

					// fail, we shall stop right here and right now.

					let weight = Executive::try_runtime_upgrade(checks)

						.expect("runtime upgrade logic *must* be infallible");

					(weight, RuntimeBlockWeights::get().max_block)

				}

				fn execute_block(

					block: Block,

					state_root_check: bool,

					signature_check: bool,

					select: frame_try_runtime::TryStateSelect

				) -> Weight {

					log::info!(

						"try-runtime: executing block {:?} / root checks: {:?} / try-state-select: {:?}",

						block.header.hash(),

						state_root_check,

						select,

					);

					// NOTE: intentional unwrap: we don't want to propagate the error backwards,

					// and want to have a backtrace here.

					Executive::try_execute_block(

						block,

						state_root_check,

						signature_check,

						select,

					).expect("execute-block failed")

				}

			}

	};

}