idn_runtime/configs/

mod.rs

/*
 * Copyright 2025 by Ideal Labs, LLC
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#[path = "xcm.rs"]
pub(crate) mod xcm_config;

mod contracts;
mod xcm_weights;

// Substrate and Polkadot dependencies
use bp_idn::{
	impls,
	types::{self},
};
use cumulus_pallet_parachain_system::RelayNumberMonotonicallyIncreases;
use cumulus_primitives_core::AggregateMessageOrigin;
use frame_support::{
	derive_impl,
	dispatch::DispatchClass,
	parameter_types,
	traits::{
		tokens::imbalance::ResolveTo, ConstBool, ConstU32, ConstU64, ConstU8, EitherOfDiverse,
		VariantCountOf,
	},
	weights::{ConstantMultiplier, Weight},
	PalletId,
};
use frame_system::{
	limits::{BlockLength, BlockWeights},
	EnsureRoot,
};
#[cfg(not(feature = "runtime-benchmarks"))]
use pallet_idn_manager::primitives::AllowSiblingsOnly;
use pallet_idn_manager::{BalanceOf, SubscriptionOf};
use pallet_xcm::{EnsureXcm, IsVoiceOfBody};
use polkadot_runtime_common::{BlockHashCount, SlowAdjustingFeeUpdate};
use sp_consensus_aura::sr25519::AuthorityId as AuraId;
use sp_version::RuntimeVersion;
use xcm::prelude::BodyId;

// Local module imports
#[cfg(not(feature = "runtime-benchmarks"))]
use super::PolkadotXcm;
use super::{
	weights::{
		BalancesWeightInfo, BlockExecutionWeight, CollatorSelectionWeightInfo,
		CumulusParachainSystemWeightInfo, ExtrinsicBaseWeight, IdnManagerWeightInfo,
		RandomnessBeaconWeightInfo, RocksDbWeight, SessionWeightInfo, SudoWeightInfo,
		SystemWeightInfo, TimestampWeightInfo, TransactionPaymentWeightInfo,
	},
	AccountId, Aura, Balance, Balances, Block, BlockNumber, CollatorSelection, ConsensusHook, Hash,
	MessageQueue, Nonce, PalletInfo, RandomnessCollectiveFlip, Runtime, RuntimeCall, RuntimeEvent,
	RuntimeFreezeReason, RuntimeHoldReason, RuntimeOrigin, RuntimeTask, Session, SessionKeys,
	System, WeightToFee, XcmpQueue, AVERAGE_ON_INITIALIZE_RATIO, EXISTENTIAL_DEPOSIT, HOURS,
	MAXIMUM_BLOCK_WEIGHT, MICROUNIT, NORMAL_DISPATCH_RATIO, SLOT_DURATION, VERSION,
};
use xcm_config::RelayLocation;

parameter_types! {
	pub const Version: RuntimeVersion = VERSION;

	// This part is copied from Substrate's `bin/node/runtime/src/lib.rs`.
	//  The `RuntimeBlockLength` and `RuntimeBlockWeights` exist here because the
	// `DeletionWeightLimit` and `DeletionQueueDepth` depend on those to parameterize
	// the lazy contract deletion.
	pub RuntimeBlockLength: BlockLength =
		BlockLength::max_with_normal_ratio(5 * 1024 * 1024, NORMAL_DISPATCH_RATIO);
	pub RuntimeBlockWeights: BlockWeights = BlockWeights::builder()
		.base_block(BlockExecutionWeight::get())
		.for_class(DispatchClass::all(), |weights| {
			weights.base_extrinsic = ExtrinsicBaseWeight::get();
		})
		.for_class(DispatchClass::Normal, |weights| {
			weights.max_total = Some(NORMAL_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT);
		})
		.for_class(DispatchClass::Operational, |weights| {
			weights.max_total = Some(MAXIMUM_BLOCK_WEIGHT);
			// Operational transactions have some extra reserved space, so that they
			// are included even if block reached `MAXIMUM_BLOCK_WEIGHT`.
			weights.reserved = Some(
				MAXIMUM_BLOCK_WEIGHT - NORMAL_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT
			);
		})
		.avg_block_initialization(AVERAGE_ON_INITIALIZE_RATIO)
		.build_or_panic();
	pub const SS58Prefix: u16 = 0;
}

/// The default types are being injected by [`derive_impl`](`frame_support::derive_impl`) from
/// [`ParaChainDefaultConfig`](`struct@frame_system::config_preludes::ParaChainDefaultConfig`),
/// but overridden as needed.
#[derive_impl(frame_system::config_preludes::ParaChainDefaultConfig)]
impl frame_system::Config for Runtime {
	/// The data to be stored in an account.
	type AccountData = pallet_balances::AccountData<Balance>;
	/// The identifier used to distinguish between accounts.
	type AccountId = AccountId;
	/// The block type.
	type Block = Block;
	/// Maximum number of block number to block hash mappings to keep (oldest pruned first).
	type BlockHashCount = BlockHashCount;
	/// The maximum length of a block (in bytes).
	type BlockLength = RuntimeBlockLength;
	/// Block & extrinsics weights: base values and limits.
	type BlockWeights = RuntimeBlockWeights;
	/// The weight of database operations that the runtime can invoke.
	type DbWeight = RocksDbWeight;
	/// The type for hashing blocks and tries.
	type Hash = Hash;
	type MaxConsumers = frame_support::traits::ConstU32<16>;
	/// The index type for storing how many extrinsics an account has signed.
	type Nonce = Nonce;
	/// The action to take on a Runtime Upgrade
	type OnSetCode = cumulus_pallet_parachain_system::ParachainSetCode<Self>;
	/// This is used as an identifier of the chain. 42 is the generic substrate prefix.
	type SS58Prefix = SS58Prefix;
	type SystemWeightInfo = SystemWeightInfo<Runtime>;
	/// Runtime version.
	type Version = Version;
}

impl pallet_timestamp::Config for Runtime {
	type MinimumPeriod = ConstU64<0>;
	/// A timestamp: milliseconds since the unix epoch.
	type Moment = u64;
	type OnTimestampSet = Aura;
	type WeightInfo = TimestampWeightInfo<Runtime>;
}

impl pallet_authorship::Config for Runtime {
	type EventHandler = (CollatorSelection,);
	type FindAuthor = pallet_session::FindAccountFromAuthorIndex<Self, Aura>;
}

parameter_types! {
	pub const ExistentialDeposit: Balance = EXISTENTIAL_DEPOSIT;
}

impl pallet_balances::Config for Runtime {
	type AccountStore = System;
	/// The type for recording an account's balance.
	type Balance = Balance;
	type DoneSlashHandler = ();
	type DustRemoval = ResolveTo<types::TreasuryAccount, Balances>;
	type ExistentialDeposit = ExistentialDeposit;
	type FreezeIdentifier = RuntimeFreezeReason;
	type MaxFreezes = VariantCountOf<RuntimeFreezeReason>;
	type MaxLocks = ConstU32<50>;
	type MaxReserves = ConstU32<50>;
	type ReserveIdentifier = [u8; 8];
	/// The ubiquitous event type.
	type RuntimeEvent = RuntimeEvent;
	type RuntimeFreezeReason = RuntimeFreezeReason;
	type RuntimeHoldReason = RuntimeHoldReason;
	type WeightInfo = BalancesWeightInfo<Runtime>;
}

parameter_types! {
	/// Relay Chain `TransactionByteFee` / 10
	pub const TransactionByteFee: Balance = 10 * MICROUNIT;
}

impl pallet_transaction_payment::Config for Runtime {
	type FeeMultiplierUpdate = SlowAdjustingFeeUpdate<Self>;
	type LengthToFee = ConstantMultiplier<Balance, TransactionByteFee>;
	type OnChargeTransaction = pallet_transaction_payment::FungibleAdapter<
		Balances,
		ResolveTo<types::TreasuryAccount, Balances>,
	>;
	type OperationalFeeMultiplier = ConstU8<5>;
	type RuntimeEvent = RuntimeEvent;
	type WeightInfo = TransactionPaymentWeightInfo<Runtime>;
	type WeightToFee = WeightToFee;
}

impl pallet_sudo::Config for Runtime {
	type RuntimeCall = RuntimeCall;
	type RuntimeEvent = RuntimeEvent;
	type WeightInfo = SudoWeightInfo<Runtime>;
}

parameter_types! {
	pub const ReservedXcmpWeight: Weight = MAXIMUM_BLOCK_WEIGHT.saturating_div(4);
	pub const ReservedDmpWeight: Weight = MAXIMUM_BLOCK_WEIGHT.saturating_div(4);
	pub const RelayOrigin: AggregateMessageOrigin = AggregateMessageOrigin::Parent;
}

impl cumulus_pallet_parachain_system::Config for Runtime {
	type WeightInfo = CumulusParachainSystemWeightInfo<Runtime>;
	type RuntimeEvent = RuntimeEvent;
	type OnSystemEvent = ();
	type SelfParaId = parachain_info::Pallet<Runtime>;
	type OutboundXcmpMessageSource = XcmpQueue;
	type DmpQueue = frame_support::traits::EnqueueWithOrigin<MessageQueue, RelayOrigin>;
	type ReservedDmpWeight = ReservedDmpWeight;
	type XcmpMessageHandler = XcmpQueue;
	type ReservedXcmpWeight = ReservedXcmpWeight;
	type CheckAssociatedRelayNumber = RelayNumberMonotonicallyIncreases;
	type ConsensusHook = ConsensusHook;
	type SelectCore = cumulus_pallet_parachain_system::DefaultCoreSelector<Runtime>;
}

impl parachain_info::Config for Runtime {}

impl cumulus_pallet_aura_ext::Config for Runtime {}

parameter_types! {
	pub const Period: u32 = 6 * HOURS;
	pub const Offset: u32 = 0;
}

impl pallet_session::Config for Runtime {
	type DisablingStrategy = ();
	type Keys = SessionKeys;
	type NextSessionRotation = pallet_session::PeriodicSessions<Period, Offset>;
	type RuntimeEvent = RuntimeEvent;
	// Essentially just Aura, but let's be pedantic.
	type SessionHandler = <SessionKeys as sp_runtime::traits::OpaqueKeys>::KeyTypeIdProviders;
	type SessionManager = CollatorSelection;
	type ShouldEndSession = pallet_session::PeriodicSessions<Period, Offset>;
	type ValidatorId = <Self as frame_system::Config>::AccountId;
	// we don't have stash and controller, thus we don't need the convert as well.
	type ValidatorIdOf = pallet_collator_selection::IdentityCollator;
	type WeightInfo = SessionWeightInfo<Runtime>;
}

impl pallet_aura::Config for Runtime {
	type AllowMultipleBlocksPerSlot = ConstBool<true>;
	type AuthorityId = AuraId;
	type DisabledValidators = ();
	type MaxAuthorities = ConstU32<100_000>;
	type SlotDuration = ConstU64<SLOT_DURATION>;
}

parameter_types! {
	pub const PotId: PalletId = PalletId(*b"PotStake");
	pub const SessionLength: BlockNumber = 6 * HOURS;
	// StakingAdmin pluralistic body.
	pub const StakingAdminBodyId: BodyId = BodyId::Defense;
}

/// We allow root and the StakingAdmin to execute privileged collator selection operations.
pub type CollatorSelectionUpdateOrigin = EitherOfDiverse<
	EnsureRoot<AccountId>,
	EnsureXcm<IsVoiceOfBody<RelayLocation, StakingAdminBodyId>>,
>;

impl pallet_collator_selection::Config for Runtime {
	type Currency = Balances;
	// should be a multiple of session or things will get inconsistent
	type KickThreshold = Period;
	type MaxCandidates = ConstU32<100>;
	type MaxInvulnerables = ConstU32<20>;
	type MinEligibleCollators = ConstU32<4>;
	type PotId = PotId;
	type RuntimeEvent = RuntimeEvent;
	type UpdateOrigin = CollatorSelectionUpdateOrigin;
	type ValidatorId = <Self as frame_system::Config>::AccountId;
	type ValidatorIdOf = pallet_collator_selection::IdentityCollator;
	type ValidatorRegistration = Session;
	type WeightInfo = CollatorSelectionWeightInfo<Runtime>;
}

/// This function helps to keep benchmarks in line with the test mock
/// environment. When running benchmarks without this mock, when a request is made
/// that matches the sibling account id, the id is translated to that of the
/// sibling's account on the IDN.
#[cfg(feature = "runtime-benchmarks")]
mod bench_sibling_conversion {
	use sp_runtime::AccountId32;
	use xcm::prelude::{Junction::Parachain, Location};
	use xcm_executor::traits::ConvertLocation;
	pub struct MockSiblingConversion;
	pub const SIBLING_PARA_ID: u32 = 88;
	pub const SIBLING_PARA_ACCOUNT: AccountId32 = AccountId32::new([88u8; 32]);
	impl ConvertLocation<AccountId32> for MockSiblingConversion {
		fn convert_location(location: &Location) -> Option<AccountId32> {
			match location.unpack() {
				(1, [Parachain(SIBLING_PARA_ID)]) => Some(SIBLING_PARA_ACCOUNT),
				_ => None,
			}
		}
	}
}

#[cfg(feature = "runtime-benchmarks")]
mod bench_ensure_origin {
	use crate::RuntimeOrigin;
	use frame_support::pallet_prelude::EnsureOrigin;
	use frame_system::ensure_signed;
	use sp_runtime::AccountId32;
	use xcm::prelude::{Junction, Location};

	pub const SIBLING_PARA_ACCOUNT: AccountId32 = AccountId32::new([88u8; 32]);
	pub const SIBLING_PARA_ID: u32 = 88;

	pub struct BenchEnsureOrigin;
	impl EnsureOrigin<RuntimeOrigin> for BenchEnsureOrigin {
		type Success = Location;

		fn try_origin(origin: RuntimeOrigin) -> Result<Self::Success, RuntimeOrigin> {
			let caller: AccountId32 = ensure_signed(origin.clone()).unwrap();

			if caller == SIBLING_PARA_ACCOUNT {
				return Ok(Location::new(1, Junction::Parachain(SIBLING_PARA_ID)));
			}
			Err(origin)
		}
		fn try_successful_origin() -> Result<RuntimeOrigin, ()> {
			Ok(RuntimeOrigin::root())
		}
	}
}

parameter_types! {
	pub const BaseFee: u64 = 2_900_000u64;
	pub const MaxXcmFees: u128 = 1_000_000_000_000;
}

impl pallet_idn_manager::Config for Runtime {
	type Credits = types::Credits;
	type Currency = Balances;
	type DepositCalculator = impls::DepositCalculatorImpl<types::SDMultiplier, BalanceOf<Runtime>>;
	type DiffBalance = impls::DiffBalanceImpl<BalanceOf<Runtime>>;
	type FeesManager = impls::FeesManagerImpl<
		types::TreasuryAccount,
		SubscriptionOf<Runtime>,
		Balances,
		BlockNumber,
		BlockNumber,
		BaseFee,
	>;
	type LocalOriginToLocation = xcm_config::LocalOriginToLocation;
	type MaxCallDataLen = types::MaxCallDataLen;
	type MaxMetadataLen = types::MaxMetadataLen;
	type MaxSubscriptions = types::MaxSubscriptions;
	type MaxTerminatableSubs = types::MaxTerminatableSubs;
	type MaxXcmFees = MaxXcmFees;
	type Pulse = types::RuntimePulse;
	type RuntimeEvent = RuntimeEvent;
	type RuntimeHoldReason = RuntimeHoldReason;
	type SubscriptionId = types::SubscriptionId;
	type WeightInfo = IdnManagerWeightInfo<Runtime>;
	#[cfg(not(feature = "runtime-benchmarks"))]
	type Xcm = PolkadotXcm;
	#[cfg(feature = "runtime-benchmarks")]
	type Xcm = ();
	#[cfg(not(feature = "runtime-benchmarks"))]
	type XcmLocationToAccountId = xcm_config::LocationToAccountId;
	#[cfg(feature = "runtime-benchmarks")]
	type XcmLocationToAccountId = bench_sibling_conversion::MockSiblingConversion;
	#[cfg(not(feature = "runtime-benchmarks"))]
	type XcmOriginFilter = EnsureXcm<AllowSiblingsOnly>;
	#[cfg(feature = "runtime-benchmarks")]
	type XcmOriginFilter = bench_ensure_origin::BenchEnsureOrigin;
}

parameter_types! {
	pub const MaxSigsPerBlock: u8 = 6;
}

impl pallet_randomness_beacon::Config for Runtime {
	type Dispatcher = crate::IdnManager;
	type FallbackRandomness = RandomnessCollectiveFlip;
	type MaxSigsPerBlock = MaxSigsPerBlock;
	type Pulse = types::RuntimePulse;
	type RuntimeEvent = RuntimeEvent;
	type SignatureVerifier = sp_idn_crypto::verifier::QuicknetVerifier;
	type WeightInfo = RandomnessBeaconWeightInfo<Runtime>;
	type Signature = sp_runtime::MultiSignature;
	type AccountIdentifier = sp_runtime::MultiSigner;
	type FindAuthor = pallet_session::FindAccountFromAuthorIndex<Self, Aura>;
}

impl pallet_insecure_randomness_collective_flip::Config for Runtime {}