fix: Resolve cargo clippy errors and add CI workflow plan

## Changes

### Clippy Fixes
- Fixed deprecated `cargo_bin` usage in 27 test files (added #![allow(deprecated)])
- Fixed uninlined_format_args in zombienet-sdk-tests
- Fixed subxt API changes in revive/rpc/tests.rs (fetch signature, StorageValue)
- Fixed dead_code warnings in validator-pool and identity-kyc mocks
- Fixed field name `i` -> `_i` in tasks example

### CI Infrastructure
- Added .claude/WORKFLOW_PLAN.md for tracking CI fix progress
- Updated lychee.toml and taplo.toml configs

### Files Modified
- 27 test files with deprecated cargo_bin fix
- bizinikiwi/pezframe/revive/rpc/src/tests.rs (subxt API)
- pezkuwi/pezpallets/validator-pool/src/{mock,tests}.rs
- pezcumulus/teyrchains/pezpallets/identity-kyc/src/mock.rs
- bizinikiwi/pezframe/examples/tasks/src/tests.rs

## Status
- cargo clippy: PASSING
- Next: cargo fmt, zepter, workspace checks

pezcumulus/teyrchains/pezpallets/presale/Cargo.toml

@@ -15,12 +15,12 @@ targets = ["x86_64-unknown-linux-gnu"]
 
 [dependencies]
 codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false, features = [
-  "derive",
-  "max-encoded-len",
+	"derive",
+	"max-encoded-len",
 ] }
 log = { default-features = false, workspace = true }
 scale-info = { default-features = false, features = [
-  "derive",
+	"derive",
 ], workspace = true }
 serde = { features = ["alloc", "derive"], workspace = true }
 
@@ -41,34 +41,34 @@ pezsp-io = { workspace = true }
 [features]
 default = ["std"]
 std = [
-  "codec/std",
-  "pezframe-benchmarking?/std",
-  "pezframe-support/std",
-  "pezframe-system/std",
-  "log/std",
-  "pezpallet-assets/std",
-  "pezpallet-balances?/std",
-  "scale-info/std",
-  "serde/std",
-  "pezsp-core/std",
-  "pezsp-io/std",
-  "pezsp-runtime/std",
-  "pezsp-std/std",
+	"codec/std",
+	"log/std",
+	"pezframe-benchmarking?/std",
+	"pezframe-support/std",
+	"pezframe-system/std",
+	"pezpallet-assets/std",
+	"pezpallet-balances?/std",
+	"pezsp-core/std",
+	"pezsp-io/std",
+	"pezsp-runtime/std",
+	"pezsp-std/std",
+	"scale-info/std",
+	"serde/std",
 ]
 runtime-benchmarks = [
-  "pezframe-benchmarking/runtime-benchmarks",
-  "pezframe-support/runtime-benchmarks",
-  "pezframe-system/runtime-benchmarks",
-  "pezpallet-assets/runtime-benchmarks",
-  "pezpallet-balances",
-  "pezpallet-balances?/runtime-benchmarks",
-  "pezsp-io/runtime-benchmarks",
-  "pezsp-runtime/runtime-benchmarks",
+	"pezframe-benchmarking/runtime-benchmarks",
+	"pezframe-support/runtime-benchmarks",
+	"pezframe-system/runtime-benchmarks",
+	"pezpallet-assets/runtime-benchmarks",
+	"pezpallet-balances",
+	"pezpallet-balances?/runtime-benchmarks",
+	"pezsp-io/runtime-benchmarks",
+	"pezsp-runtime/runtime-benchmarks",
 ]
 try-runtime = [
-  "pezframe-support/try-runtime",
-  "pezframe-system/try-runtime",
-  "pezpallet-assets/try-runtime",
-  "pezpallet-balances?/try-runtime",
-  "pezsp-runtime/try-runtime",
+	"pezframe-support/try-runtime",
+	"pezframe-system/try-runtime",
+	"pezpallet-assets/try-runtime",
+	"pezpallet-balances?/try-runtime",
+	"pezsp-runtime/try-runtime",
 ]

pezcumulus/teyrchains/pezpallets/presale/src/benchmarking.rs

@@ -6,47 +6,13 @@
 //! - finalize_presale (with O(N) contributor loop)
 //! - refund_cancelled_presale, batch_refund_failed_presale
 
-#![cfg(feature = "runtime-benchmarks")]
-
 use super::*;
 #[allow(unused)]
 use crate::Pezpallet as Presale;
 use pezframe_benchmarking::v2::*;
-use pezframe_support::traits::fungibles::{Create, Mutate};
+use pezframe_support::traits::fungibles::Mutate;
 use pezframe_system::RawOrigin;
 
-/// Helper trait for benchmark asset setup
-pub trait BenchmarkHelper<AssetId, AccountId> {
-	/// Create an asset ID from seed
-	fn create_asset_id(seed: u32) -> AssetId;
-	/// Setup assets for benchmarking (create and mint)
-	fn setup_assets(
-		payment_asset: AssetId,
-		reward_asset: AssetId,
-		admin: &AccountId,
-		accounts: &[AccountId],
-		payment_amount: u128,
-		reward_amount: u128,
-	);
-}
-
-impl<AssetId: From<u32>, AccountId> BenchmarkHelper<AssetId, AccountId> for () {
-	fn create_asset_id(seed: u32) -> AssetId {
-		seed.into()
-	}
-	fn setup_assets(
-		_payment_asset: AssetId,
-		_reward_asset: AssetId,
-		_admin: &AccountId,
-		_accounts: &[AccountId],
-		_payment_amount: u128,
-		_reward_amount: u128,
-	) {
-		// Default implementation does nothing
-		// Runtime should provide actual implementation
-	}
-}
-
 #[benchmarks(
 	where
 		T::AssetId: From<u32>,
@@ -78,28 +44,28 @@ mod benchmarks {
 
 		// Create assets if they don't exist (ignore errors if already created)
 		let min_balance: T::Balance = 1u128.into();
-		let _ = T::Assets::create(payment_asset.clone(), caller.clone(), true, min_balance);
-		let _ = T::Assets::create(reward_asset.clone(), caller.clone(), true, min_balance);
+		let _ = T::Assets::create(payment_asset, caller.clone(), true, min_balance);
+		let _ = T::Assets::create(reward_asset, caller.clone(), true, min_balance);
 
 		// Mint payment tokens to caller for contributions
 		let payment_amount: T::Balance = 100_000_000u128.into();
-		let _ = T::Assets::mint_into(payment_asset.clone(), caller, payment_amount);
+		let _ = T::Assets::mint_into(payment_asset, caller, payment_amount);
 
 		// Mint payment tokens to platform accounts for fee distribution
 		let _ = T::Assets::mint_into(
-			payment_asset.clone(),
+			payment_asset,
 			&T::PlatformTreasury::get(),
 			payment_amount,
 		);
 		let _ = T::Assets::mint_into(
-			payment_asset.clone(),
+			payment_asset,
 			&T::StakingRewardPool::get(),
 			payment_amount,
 		);
 
 		// Mint reward tokens to presale treasury for distribution
 		let reward_amount: T::Balance = 10_000_000_000u128.into();
-		let _ = T::Assets::mint_into(reward_asset.clone(), presale_treasury, reward_amount);
+		let _ = T::Assets::mint_into(reward_asset, presale_treasury, reward_amount);
 
 		(payment_asset, reward_asset)
 	}
@@ -117,24 +83,39 @@ mod benchmarks {
 	{
 		let presale_id = NextPresaleId::<T>::get();
 
+		let vesting = if enable_vesting {
+			Some(crate::VestingSchedule {
+				immediate_release_percent: 20u8,
+				vesting_duration_blocks: 100u32.into(),
+				cliff_blocks: 10u32.into(),
+			})
+		} else {
+			None
+		};
+
+		let params = crate::PresaleCreationParams {
+			tokens_for_sale: 10_000_000_000u128,
+			duration: 1000u32.into(),
+			is_whitelist,
+			limits: crate::ContributionLimits {
+				min_contribution: 100u128,
+				max_contribution: 10_000_000u128,
+				soft_cap: 1_000_000u128,
+				hard_cap: 100_000_000u128,
+			},
+			vesting,
+			refund_config: crate::RefundConfig {
+				grace_period_blocks: 10u32.into(),
+				refund_fee_percent: 5u8,
+				grace_refund_fee_percent: 2u8,
+			},
+		};
+
 		let _ = Presale::<T>::create_presale(
 			RawOrigin::Signed(caller.clone()).into(),
 			payment_asset,
 			reward_asset,
-			10_000_000_000u128, // tokens_for_sale (10M)
-			1000u32.into(),     // duration (long enough for tests)
-			is_whitelist,
-			100u128,         // min_contribution
-			10_000_000u128,  // max_contribution
-			1_000_000u128,   // soft_cap
-			100_000_000u128, // hard_cap
-			enable_vesting,
-			if enable_vesting { 20u8 } else { 0u8 }, // 20% immediate if vesting
-			if enable_vesting { 100u32.into() } else { 0u32.into() }, // vesting_duration
-			if enable_vesting { 10u32.into() } else { 0u32.into() }, // cliff
-			10u32.into(),                            // grace_period_blocks
-			5u8,                                     // refund_fee_percent
-			2u8,                                     // grace_refund_fee_percent
+			params,
 		);
 
 		presale_id
@@ -146,26 +127,26 @@ mod benchmarks {
 		let payment_asset = get_asset_id::<T>(1);
 		let reward_asset = get_asset_id::<T>(2);
 
+		let params = crate::PresaleCreationParams {
+			tokens_for_sale: 1_000_000u128,
+			duration: 100u32.into(),
+			is_whitelist: false,
+			limits: crate::ContributionLimits {
+				min_contribution: 100u128,
+				max_contribution: 10_000u128,
+				soft_cap: 500_000u128,
+				hard_cap: 1_000_000u128,
+			},
+			vesting: None,
+			refund_config: crate::RefundConfig {
+				grace_period_blocks: 10u32.into(),
+				refund_fee_percent: 5u8,
+				grace_refund_fee_percent: 10u8,
+			},
+		};
+
 		#[extrinsic_call]
-		create_presale(
-			RawOrigin::Signed(caller),
-			payment_asset,
-			reward_asset,
-			1_000_000u128, // tokens_for_sale
-			100u32.into(), // duration
-			false,         // is_whitelist
-			100u128,       // min_contribution
-			10_000u128,    // max_contribution
-			500_000u128,   // soft_cap
-			1_000_000u128, // hard_cap
-			false,         // enable_vesting
-			0u8,           // vesting_immediate_percent
-			0u32.into(),   // vesting_duration_blocks
-			0u32.into(),   // vesting_cliff_blocks
-			10u32.into(),  // grace_period_blocks
-			5u8,           // refund_fee_percent
-			10u8,          // grace_refund_fee_percent
-		);
+		create_presale(RawOrigin::Signed(caller), payment_asset, reward_asset, params);
 
 		// Verify presale was created
 		assert!(crate::Presales::<T>::contains_key(0));
@@ -270,7 +251,7 @@ mod benchmarks {
 
 		// Mint EXTRA reward tokens to presale treasury to prevent account death
 		let extra_reward: T::Balance = 100_000_000_000u128.into();
-		let _ = T::Assets::mint_into(reward_asset.clone(), &presale_treasury, extra_reward);
+		let _ = T::Assets::mint_into(reward_asset, &presale_treasury, extra_reward);
 
 		// Create presale WITH vesting (will get the presale_id we calculated)
 		let _ = create_test_presale::<T>(&caller, payment_asset, reward_asset, false, true);
@@ -309,7 +290,7 @@ mod benchmarks {
 
 		// Create presale (will get the presale_id we calculated)
 		let _ =
-			create_test_presale::<T>(&caller, payment_asset.clone(), reward_asset, false, false);
+			create_test_presale::<T>(&caller, payment_asset, reward_asset, false, false);
 
 		// Make a contribution
 		let amount: u128 = 10_000u128;
@@ -346,8 +327,8 @@ mod benchmarks {
 		// Create presale (will get the presale_id we calculated)
 		let _ = create_test_presale::<T>(
 			&caller,
-			payment_asset.clone(),
-			reward_asset.clone(),
+			payment_asset,
+			reward_asset,
 			false,
 			false,
 		);
@@ -358,7 +339,7 @@ mod benchmarks {
 
 			// Mint payment tokens to contributor
 			let contribution_amount: T::Balance = 50_000u128.into();
-			let _ = T::Assets::mint_into(payment_asset.clone(), &contributor, contribution_amount);
+			let _ = T::Assets::mint_into(payment_asset, &contributor, contribution_amount);
 
 			// Make contribution
 			let _ = Presale::<T>::contribute(
@@ -394,24 +375,28 @@ mod benchmarks {
 		let (payment_asset, reward_asset) = setup_benchmark_assets::<T>(&caller, &presale_treasury);
 
 		// Create presale with HIGH soft cap (will fail)
+		let params = crate::PresaleCreationParams {
+			tokens_for_sale: 10_000_000_000u128,
+			duration: 1000u32.into(),
+			is_whitelist: false,
+			limits: crate::ContributionLimits {
+				min_contribution: 100u128,
+				max_contribution: 10_000_000u128,
+				soft_cap: 1_000_000_000_000u128,   // very high - will fail
+				hard_cap: 2_000_000_000_000u128,
+			},
+			vesting: None,
+			refund_config: crate::RefundConfig {
+				grace_period_blocks: 10u32.into(),
+				refund_fee_percent: 5u8,
+				grace_refund_fee_percent: 2u8,
+			},
+		};
 		let _ = Presale::<T>::create_presale(
 			RawOrigin::Signed(caller.clone()).into(),
-			payment_asset.clone(),
+			payment_asset,
 			reward_asset,
-			10_000_000_000u128, // tokens_for_sale
-			1000u32.into(),     // duration
-			false,
-			100u128,               // min_contribution
-			10_000_000u128,        // max_contribution
-			1_000_000_000_000u128, // soft_cap (very high - will fail)
-			2_000_000_000_000u128, // hard_cap
-			false,
-			0u8,
-			0u32.into(),
-			0u32.into(),
-			10u32.into(),
-			5u8,
-			2u8,
+			params,
 		);
 
 		// Add n contributors (small amounts that won't reach soft cap)
@@ -420,7 +405,7 @@ mod benchmarks {
 
 			// Mint payment tokens to contributor
 			let contribution_amount: T::Balance = 50_000u128.into();
-			let _ = T::Assets::mint_into(payment_asset.clone(), &contributor, contribution_amount);
+			let _ = T::Assets::mint_into(payment_asset, &contributor, contribution_amount);
 
 			// Make small contribution
 			let _ = Presale::<T>::contribute(
@@ -432,7 +417,7 @@ mod benchmarks {
 
 		// Mint payment tokens to presale treasury for refunds
 		let refund_pool: T::Balance = (n as u128 * 10_000u128).into();
-		let _ = T::Assets::mint_into(payment_asset.clone(), &presale_treasury, refund_pool);
+		let _ = T::Assets::mint_into(payment_asset, &presale_treasury, refund_pool);
 
 		// Advance blocks past presale end
 		pezframe_system::Pezpallet::<T>::set_block_number(2000u32.into());

pezcumulus/teyrchains/pezpallets/presale/src/lib.rs

@@ -45,6 +45,7 @@ extern crate alloc;
 #[pezframe_support::pezpallet]
 pub mod pezpallet {
 	use super::*;
+	use codec::DecodeWithMemTracking;
 	use pezframe_support::{
 		dispatch::DispatchResult,
 		pezpallet_prelude::*,
@@ -59,7 +60,7 @@ pub mod pezpallet {
 
 	pub type PresaleId = u32;
 
-	#[derive(Clone, Copy, Encode, Decode, Eq, PartialEq, RuntimeDebug, MaxEncodedLen, TypeInfo)]
+	#[derive(Clone, Copy, Encode, Decode, DecodeWithMemTracking, Eq, PartialEq, RuntimeDebug, MaxEncodedLen, TypeInfo)]
 	#[cfg_attr(feature = "std", derive(serde::Serialize, serde::Deserialize))]
 	pub enum PresaleStatus {
 		Pending,    // Not started yet
@@ -71,7 +72,7 @@ pub mod pezpallet {
 		Finalized,  // Tokens distributed (after Successful)
 	}
 
-	#[derive(Clone, Copy, Encode, Decode, Eq, PartialEq, RuntimeDebug, MaxEncodedLen, TypeInfo)]
+	#[derive(Clone, Copy, Encode, Decode, DecodeWithMemTracking, Eq, PartialEq, RuntimeDebug, MaxEncodedLen, TypeInfo)]
 	#[cfg_attr(feature = "std", derive(serde::Serialize, serde::Deserialize))]
 	#[codec(dumb_trait_bound)]
 	pub enum AccessControl {
@@ -79,7 +80,7 @@ pub mod pezpallet {
 		Whitelist, // Only whitelisted accounts
 	}
 
-	#[derive(Clone, Copy, Encode, Decode, Eq, PartialEq, RuntimeDebug, MaxEncodedLen, TypeInfo)]
+	#[derive(Clone, Copy, Encode, Decode, DecodeWithMemTracking, Eq, PartialEq, RuntimeDebug, MaxEncodedLen, TypeInfo)]
 	#[cfg_attr(feature = "std", derive(serde::Serialize, serde::Deserialize))]
 	#[codec(dumb_trait_bound)]
 	pub struct BonusTier {
@@ -89,7 +90,7 @@ pub mod pezpallet {
 		pub bonus_percentage: u8,
 	}
 
-	#[derive(Clone, Copy, Encode, Decode, Eq, PartialEq, RuntimeDebug, MaxEncodedLen, TypeInfo)]
+	#[derive(Clone, Copy, Encode, Decode, DecodeWithMemTracking, Eq, PartialEq, RuntimeDebug, MaxEncodedLen, TypeInfo)]
 	#[cfg_attr(feature = "std", derive(serde::Serialize, serde::Deserialize))]
 	#[codec(dumb_trait_bound)]
 	pub struct VestingSchedule<BlockNumber> {
@@ -101,7 +102,7 @@ pub mod pezpallet {
 		pub cliff_blocks: BlockNumber,
 	}
 
-	#[derive(Clone, Copy, Encode, Decode, Eq, PartialEq, RuntimeDebug, MaxEncodedLen, TypeInfo)]
+	#[derive(Clone, Copy, Encode, Decode, DecodeWithMemTracking, Eq, PartialEq, RuntimeDebug, MaxEncodedLen, TypeInfo)]
 	#[cfg_attr(feature = "std", derive(serde::Serialize, serde::Deserialize))]
 	#[codec(dumb_trait_bound)]
 	pub struct ContributionLimits {
@@ -115,7 +116,37 @@ pub mod pezpallet {
 		pub hard_cap: u128,
 	}
 
-	#[derive(Clone, Copy, Encode, Decode, Eq, PartialEq, RuntimeDebug, MaxEncodedLen, TypeInfo)]
+	#[derive(Clone, Copy, Encode, Decode, DecodeWithMemTracking, Eq, PartialEq, RuntimeDebug, MaxEncodedLen, TypeInfo)]
+	#[cfg_attr(feature = "std", derive(serde::Serialize, serde::Deserialize))]
+	#[codec(dumb_trait_bound)]
+	pub struct RefundConfig<BlockNumber> {
+		/// Grace period for refunds (blocks) - low fee
+		pub grace_period_blocks: BlockNumber,
+		/// Normal refund fee percentage (0-100)
+		pub refund_fee_percent: u8,
+		/// Grace period refund fee percentage (0-100)
+		pub grace_refund_fee_percent: u8,
+	}
+
+	#[derive(Clone, Copy, Encode, Decode, DecodeWithMemTracking, Eq, PartialEq, RuntimeDebug, MaxEncodedLen, TypeInfo)]
+	#[cfg_attr(feature = "std", derive(serde::Serialize, serde::Deserialize))]
+	#[codec(dumb_trait_bound)]
+	pub struct PresaleCreationParams<BlockNumber> {
+		/// Total tokens for sale (with decimals)
+		pub tokens_for_sale: u128,
+		/// Presale duration in blocks
+		pub duration: BlockNumber,
+		/// Whether presale requires whitelist
+		pub is_whitelist: bool,
+		/// Contribution limits (min, max, soft cap, hard cap)
+		pub limits: ContributionLimits,
+		/// Optional vesting schedule
+		pub vesting: Option<VestingSchedule<BlockNumber>>,
+		/// Refund configuration
+		pub refund_config: RefundConfig<BlockNumber>,
+	}
+
+	#[derive(Clone, Copy, Encode, Decode, DecodeWithMemTracking, Eq, PartialEq, RuntimeDebug, MaxEncodedLen, TypeInfo)]
 	#[cfg_attr(feature = "std", derive(serde::Serialize, serde::Deserialize))]
 	#[codec(dumb_trait_bound)]
 	pub struct ContributionInfo<BlockNumber> {
@@ -131,7 +162,7 @@ pub mod pezpallet {
 		pub refund_fee_paid: u128,
 	}
 
-	#[derive(Clone, Encode, Decode, Eq, PartialEq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+	#[derive(Clone, Encode, Decode, DecodeWithMemTracking, Eq, PartialEq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
 	#[scale_info(skip_type_params(T, MaxBonusTiers))]
 	#[codec(mel_bound(T: Config, MaxBonusTiers: Get<u32>))]
 	pub struct PresaleConfig<T: Config, MaxBonusTiers: Get<u32>> {
@@ -380,34 +411,26 @@ pub mod pezpallet {
 	#[pezpallet::call]
 	impl<T: Config> Pezpallet<T> {
 		/// Create a new presale
+		///
+		/// Parameters are grouped into structs for cleaner API:
+		/// - `payment_asset`: The asset used for contributions (e.g., wUSDT)
+		/// - `reward_asset`: The token being sold
+		/// - `params`: Creation parameters including limits, vesting, and refund config
 		#[pezpallet::call_index(0)]
 		#[pezpallet::weight(T::PresaleWeightInfo::create_presale())]
 		pub fn create_presale(
 			origin: OriginFor<T>,
 			payment_asset: T::AssetId,
 			reward_asset: T::AssetId,
-			tokens_for_sale: u128,
-			duration: BlockNumberFor<T>,
-			is_whitelist: bool,
-			min_contribution: u128,
-			max_contribution: u128,
-			soft_cap: u128,
-			hard_cap: u128,
-			enable_vesting: bool,
-			vesting_immediate_percent: u8,
-			vesting_duration_blocks: BlockNumberFor<T>,
-			vesting_cliff_blocks: BlockNumberFor<T>,
-			grace_period_blocks: BlockNumberFor<T>,
-			refund_fee_percent: u8,
-			grace_refund_fee_percent: u8,
+			params: PresaleCreationParams<BlockNumberFor<T>>,
 		) -> DispatchResult {
 			let owner = ensure_signed(origin)?;
 
-			ensure!(tokens_for_sale > 0, Error::<T>::InvalidTokensForSale);
-			ensure!(soft_cap > 0, Error::<T>::InvalidTokensForSale);
-			ensure!(soft_cap <= hard_cap, Error::<T>::InvalidTokensForSale);
-			ensure!(refund_fee_percent <= 100, Error::<T>::InvalidFeePercent);
-			ensure!(grace_refund_fee_percent <= 100, Error::<T>::InvalidFeePercent);
+			ensure!(params.tokens_for_sale > 0, Error::<T>::InvalidTokensForSale);
+			ensure!(params.limits.soft_cap > 0, Error::<T>::InvalidTokensForSale);
+			ensure!(params.limits.soft_cap <= params.limits.hard_cap, Error::<T>::InvalidTokensForSale);
+			ensure!(params.refund_config.refund_fee_percent <= 100, Error::<T>::InvalidFeePercent);
+			ensure!(params.refund_config.grace_refund_fee_percent <= 100, Error::<T>::InvalidFeePercent);
 
 			let presale_id = NextPresaleId::<T>::get();
 			let start_block = <pezframe_system::Pezpallet<T>>::block_number();
@@ -416,36 +439,23 @@ pub mod pezpallet {
 			let bounded_bonus_tiers = BoundedVec::<BonusTier, T::MaxBonusTiers>::default();
 
 			let access_control =
-				if is_whitelist { AccessControl::Whitelist } else { AccessControl::Public };
-
-			let limits =
-				ContributionLimits { min_contribution, max_contribution, soft_cap, hard_cap };
-
-			let vesting = if enable_vesting {
-				Some(VestingSchedule {
-					immediate_release_percent: vesting_immediate_percent,
-					vesting_duration_blocks,
-					cliff_blocks: vesting_cliff_blocks,
-				})
-			} else {
-				None
-			};
+				if params.is_whitelist { AccessControl::Whitelist } else { AccessControl::Public };
 
 			let config = PresaleConfig {
 				owner: owner.clone(),
-				payment_asset: payment_asset.clone(),
-				reward_asset: reward_asset.clone(),
-				tokens_for_sale,
+				payment_asset,
+				reward_asset,
+				tokens_for_sale: params.tokens_for_sale,
 				start_block,
-				duration,
+				duration: params.duration,
 				status: PresaleStatus::Active,
 				access_control,
-				limits,
+				limits: params.limits,
 				bonus_tiers: bounded_bonus_tiers,
-				vesting,
-				grace_period_blocks,
-				refund_fee_percent,
-				grace_refund_fee_percent,
+				vesting: params.vesting,
+				grace_period_blocks: params.refund_config.grace_period_blocks,
+				refund_fee_percent: params.refund_config.refund_fee_percent,
+				grace_refund_fee_percent: params.refund_config.grace_refund_fee_percent,
 			};
 
 			Presales::<T>::insert(presale_id, config);
@@ -517,10 +527,9 @@ pub mod pezpallet {
 
 			// Transfer payment asset from user to presale treasury
 			let treasury = Self::presale_account_id(presale_id);
-			let net_amount_balance: T::Balance =
-				net_amount.try_into().map_err(|_| Error::<T>::ArithmeticOverflow)?;
+			let net_amount_balance: T::Balance = net_amount.into();
 			T::Assets::transfer(
-				presale.payment_asset.clone(),
+				presale.payment_asset,
 				&who,
 				&treasury,
 				net_amount_balance,
@@ -528,7 +537,7 @@ pub mod pezpallet {
 			)?;
 
 			// Distribute platform fee
-			Self::distribute_platform_fee(presale.payment_asset.clone(), &who, platform_fee)?;
+			Self::distribute_platform_fee(presale.payment_asset, &who, platform_fee)?;
 
 			// Track contribution with timestamp preservation
 			let contribution = if let Some(existing) = existing_contribution {
@@ -634,10 +643,9 @@ pub mod pezpallet {
 							100;
 
 						if immediate > 0 {
-							let immediate_balance: T::Balance =
-								immediate.try_into().map_err(|_| Error::<T>::ArithmeticOverflow)?;
+							let immediate_balance: T::Balance = immediate.into();
 							T::Assets::transfer(
-								presale.reward_asset.clone(),
+								presale.reward_asset,
 								&treasury,
 								contributor,
 								immediate_balance,
@@ -649,10 +657,9 @@ pub mod pezpallet {
 						VestingClaimed::<T>::insert(presale_id, contributor, immediate);
 					} else {
 						// No vesting - transfer all
-						let total_reward_balance: T::Balance =
-							total_reward.try_into().map_err(|_| Error::<T>::ArithmeticOverflow)?;
+						let total_reward_balance: T::Balance = total_reward.into();
 						T::Assets::transfer(
-							presale.reward_asset.clone(),
+							presale.reward_asset,
 							&treasury,
 							contributor,
 							total_reward_balance,
@@ -731,9 +738,9 @@ pub mod pezpallet {
 
 			// Step 1: Transfer refund amount to user
 			let refund_amount_balance: T::Balance =
-				refund_amount.try_into().map_err(|_| Error::<T>::ArithmeticOverflow)?;
+				refund_amount.into();
 			T::Assets::transfer(
-				presale.payment_asset.clone(),
+				presale.payment_asset,
 				&treasury,
 				&who,
 				refund_amount_balance,
@@ -743,7 +750,7 @@ pub mod pezpallet {
 			// Step 2: Distribute fee from remaining treasury balance
 			// Treasury now has exactly 'fee' amount left from this contribution
 			if fee > 0 {
-				Self::distribute_platform_fee(presale.payment_asset.clone(), &treasury, fee)?;
+				Self::distribute_platform_fee(presale.payment_asset, &treasury, fee)?;
 			}
 
 			// Update contribution info (mark as refunded instead of removing)
@@ -825,7 +832,7 @@ pub mod pezpallet {
 			// Transfer tokens
 			let treasury = Self::presale_account_id(presale_id);
 			let claimable_balance: T::Balance =
-				claimable.try_into().map_err(|_| Error::<T>::ArithmeticOverflow)?;
+				claimable.into();
 			T::Assets::transfer(
 				presale.reward_asset,
 				&treasury,
@@ -921,11 +928,10 @@ pub mod pezpallet {
 						let refund_amount: T::Balance = contribution_info
 							.amount
 							.saturating_sub(non_refundable)
-							.try_into()
-							.map_err(|_| Error::<T>::ArithmeticOverflow)?;
+							.into();
 
 						T::Assets::transfer(
-							presale.payment_asset.clone(),
+							presale.payment_asset,
 							&treasury,
 							contributor,
 							refund_amount,
@@ -1000,11 +1006,10 @@ pub mod pezpallet {
 						let refund_amount: T::Balance = contribution_info
 							.amount
 							.saturating_sub(non_refundable)
-							.try_into()
-							.map_err(|_| Error::<T>::ArithmeticOverflow)?;
+							.into();
 
 						T::Assets::transfer(
-							presale.payment_asset.clone(),
+							presale.payment_asset,
 							&treasury,
 							contributor,
 							refund_amount,
@@ -1078,11 +1083,11 @@ pub mod pezpallet {
 			let to_stakers = total_fee.saturating_mul(25) / 100; // 25%
 
 			let to_treasury_balance: T::Balance =
-				to_treasury.try_into().map_err(|_| Error::<T>::ArithmeticOverflow)?;
+				to_treasury.into();
 			let to_burn_balance: T::Balance =
-				to_burn.try_into().map_err(|_| Error::<T>::ArithmeticOverflow)?;
+				to_burn.into();
 			let to_stakers_balance: T::Balance =
-				to_stakers.try_into().map_err(|_| Error::<T>::ArithmeticOverflow)?;
+				to_stakers.into();
 
 			// Note: Balance check removed - rely on Preservation::Expendable to handle insufficient
 			// balance gracefully The operations below will transfer/burn as much as possible
@@ -1090,7 +1095,7 @@ pub mod pezpallet {
 
 			// 1. Treasury (50%)
 			T::Assets::transfer(
-				asset_id.clone(),
+				asset_id,
 				from,
 				&T::PlatformTreasury::get(),
 				to_treasury_balance,
@@ -1099,7 +1104,7 @@ pub mod pezpallet {
 
 			// 2. Burn (25%)
 			T::Assets::burn_from(
-				asset_id.clone(),
+				asset_id,
 				from,
 				to_burn_balance,
 				Preservation::Expendable,

pezcumulus/teyrchains/pezpallets/presale/src/mock.rs

@@ -94,6 +94,7 @@ impl pezpallet_assets::Config for Test {
 	type RemoveItemsLimit = ConstU32<1000>;
 	type CallbackHandle = ();
 	type Holder = ();
+	type ReserveData = ();
 	#[cfg(feature = "runtime-benchmarks")]
 	type BenchmarkHelper = ();
 }
@@ -109,7 +110,6 @@ parameter_types! {
 }
 
 impl pezpallet_presale::Config for Test {
-	type RuntimeEvent = RuntimeEvent;
 	type AssetId = u32;
 	type Balance = u128;
 	type Assets = Assets;
@@ -174,7 +174,7 @@ pub fn create_assets() {
 pub fn mint_assets(asset_id: u32, account: u64, amount: u128) {
 	use pezframe_support::assert_ok;
 
-	assert_ok!(Assets::mint(RuntimeOrigin::signed(1), asset_id.into(), account, amount));
+	assert_ok!(Assets::mint(RuntimeOrigin::signed(1), asset_id, account, amount));
 }
 
 // Helper to get presale sub-account treasury for a specific presale ID

pezcumulus/teyrchains/pezpallets/presale/src/tests.rs

@@ -1,6 +1,53 @@
-use crate::{mock::*, Error, Event, PresaleStatus};
+use crate::{mock::*, Error, Event, PresaleStatus, ContributionLimits, VestingSchedule, RefundConfig, PresaleCreationParams};
 use pezframe_support::{assert_noop, assert_ok};
 
+/// Helper function to create presale params with common defaults
+#[allow(clippy::too_many_arguments)]
+fn make_presale_params(
+	tokens_for_sale: u128,
+	duration: u64,
+	is_whitelist: bool,
+	min_contribution: u128,
+	max_contribution: u128,
+	soft_cap: u128,
+	hard_cap: u128,
+	enable_vesting: bool,
+	vesting_immediate_percent: u8,
+	vesting_duration_blocks: u64,
+	vesting_cliff_blocks: u64,
+	grace_period_blocks: u64,
+	refund_fee_percent: u8,
+	grace_refund_fee_percent: u8,
+) -> PresaleCreationParams<u64> {
+	let vesting = if enable_vesting {
+		Some(VestingSchedule {
+			immediate_release_percent: vesting_immediate_percent,
+			vesting_duration_blocks,
+			cliff_blocks: vesting_cliff_blocks,
+		})
+	} else {
+		None
+	};
+
+	PresaleCreationParams {
+		tokens_for_sale,
+		duration,
+		is_whitelist,
+		limits: ContributionLimits {
+			min_contribution,
+			max_contribution,
+			soft_cap,
+			hard_cap,
+		},
+		vesting,
+		refund_config: RefundConfig {
+			grace_period_blocks,
+			refund_fee_percent,
+			grace_refund_fee_percent,
+		},
+	}
+}
+
 #[test]
 fn create_presale_works() {
 	new_test_ext().execute_with(|| {
@@ -12,22 +59,24 @@ fn create_presale_works() {
 		// Alice creates a presale
 		assert_ok!(Presale::create_presale(
 			RuntimeOrigin::signed(1),
-			2,                          // wUSDT payment asset
-			1,                          // PEZ reward asset
-			10_000_000_000_000_000_000, // 10,000 PEZ tokens for sale (10^12 decimals)
-			100,                        // 100 blocks duration
-			false,                      // public presale
-			10_000_000,                 // min 10 USDT (10^6 decimals)
-			1_000_000_000,              // max 1000 USDT
-			5_000_000_000,              // soft cap 5,000 USDT
-			10_000_000_000,             // hard cap 10,000 USDT
-			false,                      // no vesting
-			0,
-			0,
-			0,
-			24, // 24 blocks grace period
-			5,  // 5% refund fee
-			2,  // 2% grace refund fee
+			2, // wUSDT payment asset
+			1, // PEZ reward asset
+			make_presale_params(
+				10_000_000_000_000_000_000, // 10,000 PEZ tokens for sale (10^12 decimals)
+				100,                        // 100 blocks duration
+				false,                      // public presale
+				10_000_000,                 // min 10 USDT (10^6 decimals)
+				1_000_000_000,              // max 1000 USDT
+				5_000_000_000,              // soft cap 5,000 USDT
+				10_000_000_000,             // hard cap 10,000 USDT
+				false,                      // no vesting
+				0,
+				0,
+				0,
+				24, // 24 blocks grace period
+				5,  // 5% refund fee
+				2,  // 2% grace refund fee
+			),
 		));
 
 		// Check presale created
@@ -59,44 +108,12 @@ fn create_multiple_presales_works() {
 		// Alice creates first presale
 		assert_ok!(Presale::create_presale(
 			RuntimeOrigin::signed(1),
-			2,
-			1,
-			10_000_000_000_000_000_000,
-			100,
-			false,
-			10_000_000,
-			1_000_000_000,
-			5_000_000_000,
-			10_000_000_000,
-			false,
-			0,
-			0,
-			0,
-			24,
-			5,
-			2,
-		));
+			2, 1, make_presale_params(10_000_000_000_000_000_000, 100, false, 10_000_000, 1_000_000_000, 5_000_000_000, 10_000_000_000, false, 0, 0, 0, 24, 5, 2)));
 
 		// Bob creates second presale
 		assert_ok!(Presale::create_presale(
 			RuntimeOrigin::signed(2),
-			2,
-			1,
-			20_000_000_000_000_000_000,
-			200,
-			false,
-			20_000_000,
-			2_000_000_000,
-			10_000_000_000,
-			20_000_000_000,
-			false,
-			0,
-			0,
-			0,
-			48,
-			10,
-			5,
-		));
+			2, 1, make_presale_params(20_000_000_000_000_000_000, 200, false, 20_000_000, 2_000_000_000, 10_000_000_000, 20_000_000_000, false, 0, 0, 0, 48, 10, 5)));
 
 		// Check both presales exist
 		assert!(Presale::presales(0).is_some());
@@ -120,23 +137,7 @@ fn contribute_works() {
 		mint_assets(1, 1, 100_000_000_000_000_000_000);
 		assert_ok!(Presale::create_presale(
 			RuntimeOrigin::signed(1),
-			2,
-			1,
-			10_000_000_000_000_000_000,
-			100,
-			false,
-			10_000_000,
-			1_000_000_000,
-			5_000_000_000,
-			10_000_000_000,
-			false,
-			0,
-			0,
-			0,
-			24,
-			5,
-			2,
-		));
+			2, 1, make_presale_params(10_000_000_000_000_000_000, 100, false, 10_000_000, 1_000_000_000, 5_000_000_000, 10_000_000_000, false, 0, 0, 0, 24, 5, 2)));
 
 		// Mint wUSDT to Bob
 		mint_assets(2, 2, 1_000_000_000); // 1000 USDT
@@ -169,7 +170,7 @@ fn contribute_works() {
 		// Verify platform fee distribution (50% treasury, 25% staking, 25% burned)
 		let expected_to_treasury = platform_fee * 50 / 100; // 1_000_000
 		let expected_to_staking = platform_fee * 25 / 100; // 500_000
-		let expected_burned = platform_fee * 25 / 100; // 500_000
+		let _expected_burned = platform_fee * 25 / 100; // 500_000
 
 		// Check platform treasury received 50%
 		assert_eq!(Assets::balance(2, 999), expected_to_treasury);
@@ -203,23 +204,7 @@ fn contribute_multiple_times_works() {
 
 		assert_ok!(Presale::create_presale(
 			RuntimeOrigin::signed(1),
-			2,
-			1,
-			10_000_000_000_000_000_000,
-			100,
-			false,
-			10_000_000,
-			1_000_000_000,
-			5_000_000_000,
-			10_000_000_000,
-			false,
-			0,
-			0,
-			0,
-			24,
-			5,
-			2,
-		));
+			2, 1, make_presale_params(10_000_000_000_000_000_000, 100, false, 10_000_000, 1_000_000_000, 5_000_000_000, 10_000_000_000, false, 0, 0, 0, 24, 5, 2)));
 
 		// First contribution
 		assert_ok!(Presale::contribute(RuntimeOrigin::signed(2), 0, 50_000_000));
@@ -249,46 +234,14 @@ fn contribute_to_different_presales_works() {
 		// Create two presales
 		assert_ok!(Presale::create_presale(
 			RuntimeOrigin::signed(1),
-			2,
-			1,
-			10_000_000_000_000_000_000,
-			100,
-			false,
-			10_000_000,
-			1_000_000_000,
-			5_000_000_000,
-			10_000_000_000,
-			false,
-			0,
-			0,
-			0,
-			24,
-			5,
-			2,
-		));
+			2, 1, make_presale_params(10_000_000_000_000_000_000, 100, false, 10_000_000, 1_000_000_000, 5_000_000_000, 10_000_000_000, false, 0, 0, 0, 24, 5, 2)));
 
 		// Fund presale 0 treasury with reward tokens
 		mint_assets(1, presale_treasury(0), 10_000_000_000_000_000_000);
 
 		assert_ok!(Presale::create_presale(
 			RuntimeOrigin::signed(1),
-			2,
-			1,
-			15_000_000_000_000_000_000,
-			100,
-			false,
-			10_000_000,
-			1_000_000_000,
-			5_000_000_000,
-			10_000_000_000,
-			false,
-			0,
-			0,
-			0,
-			24,
-			5,
-			2,
-		));
+			2, 1, make_presale_params(15_000_000_000_000_000_000, 100, false, 10_000_000, 1_000_000_000, 5_000_000_000, 10_000_000_000, false, 0, 0, 0, 24, 5, 2)));
 
 		// Fund presale 1 treasury with reward tokens
 		mint_assets(1, presale_treasury(1), 15_000_000_000_000_000_000);
@@ -326,23 +279,7 @@ fn contribute_below_min_fails() {
 
 		assert_ok!(Presale::create_presale(
 			RuntimeOrigin::signed(1),
-			2,
-			1,
-			10_000_000_000_000_000_000,
-			100,
-			false,
-			10_000_000,
-			1_000_000_000,
-			5_000_000_000,
-			10_000_000_000,
-			false,
-			0,
-			0,
-			0,
-			24,
-			5,
-			2,
-		));
+			2, 1, make_presale_params(10_000_000_000_000_000_000, 100, false, 10_000_000, 1_000_000_000, 5_000_000_000, 10_000_000_000, false, 0, 0, 0, 24, 5, 2)));
 
 		// Try to contribute less than minimum (10 USDT)
 		assert_noop!(
@@ -361,23 +298,7 @@ fn contribute_above_max_fails() {
 
 		assert_ok!(Presale::create_presale(
 			RuntimeOrigin::signed(1),
-			2,
-			1,
-			10_000_000_000_000_000_000,
-			100,
-			false,
-			10_000_000,
-			1_000_000_000,
-			5_000_000_000,
-			10_000_000_000,
-			false,
-			0,
-			0,
-			0,
-			24,
-			5,
-			2,
-		));
+			2, 1, make_presale_params(10_000_000_000_000_000_000, 100, false, 10_000_000, 1_000_000_000, 5_000_000_000, 10_000_000_000, false, 0, 0, 0, 24, 5, 2)));
 
 		// Try to contribute more than maximum (1000 USDT)
 		assert_noop!(
@@ -398,20 +319,22 @@ fn contribute_exceeding_hard_cap_fails() {
 			RuntimeOrigin::signed(1),
 			2,
 			1,
-			10_000_000_000_000_000_000,
-			100,
-			false,
-			10_000_000,
-			1_000_000_000,
-			5_000_000_000,
-			10_000_000_000, // Soft cap: 5,000 USDT, Hard cap: 10,000 USDT
-			false,
-			0,
-			0,
-			0,
-			24,
-			5,
-			2,
+			make_presale_params(
+				10_000_000_000_000_000_000,
+				100,
+				false,
+				10_000_000,
+				1_000_000_000,
+				5_000_000_000,
+				10_000_000_000, // Soft cap: 5,000 USDT, Hard cap: 10,000 USDT
+				false,
+				0,
+				0,
+				0,
+				24,
+				5,
+				2,
+			)
 		));
 
 		// Multiple contributors reach near hard cap (9,000 USDT total)
@@ -446,23 +369,7 @@ fn contribute_after_presale_ended_fails() {
 
 		assert_ok!(Presale::create_presale(
 			RuntimeOrigin::signed(1),
-			2,
-			1,
-			10_000_000_000_000_000_000,
-			100,
-			false,
-			10_000_000,
-			1_000_000_000,
-			5_000_000_000,
-			10_000_000_000,
-			false,
-			0,
-			0,
-			0,
-			24,
-			5,
-			2,
-		));
+			2, 1, make_presale_params(10_000_000_000_000_000_000, 100, false, 10_000_000, 1_000_000_000, 5_000_000_000, 10_000_000_000, false, 0, 0, 0, 24, 5, 2)));
 
 		// Move past presale end (block 1 + 100 = 101)
 		System::set_block_number(102);
@@ -483,23 +390,7 @@ fn finalize_presale_works() {
 		mint_assets(1, 1, 100_000_000_000_000_000_000); // 100,000 PEZ
 		assert_ok!(Presale::create_presale(
 			RuntimeOrigin::signed(1),
-			2,
-			1,
-			10_000_000_000_000_000_000,
-			100,
-			false,
-			10_000_000,
-			1_000_000_000,
-			5_000_000_000,
-			10_000_000_000,
-			false,
-			0,
-			0,
-			0,
-			24,
-			5,
-			2,
-		));
+			2, 1, make_presale_params(10_000_000_000_000_000_000, 100, false, 10_000_000, 1_000_000_000, 5_000_000_000, 10_000_000_000, false, 0, 0, 0, 24, 5, 2)));
 
 		// Mint PEZ to presale treasury for distribution
 		let treasury = presale_treasury(0);
@@ -539,10 +430,7 @@ fn finalize_presale_works() {
 			assert!(
 				contributor_pez >= expected_pez - 10_000_000_000_000_000 &&
 					contributor_pez <= expected_pez + 10_000_000_000_000_000,
-				"Contributor {} PEZ: {} (expected ~{})",
-				i,
-				contributor_pez,
-				expected_pez
+				"Contributor {i} PEZ: {contributor_pez} (expected ~{expected_pez})"
 			);
 		}
 
@@ -561,23 +449,7 @@ fn finalize_presale_before_end_fails() {
 
 		assert_ok!(Presale::create_presale(
 			RuntimeOrigin::signed(1),
-			2,
-			1,
-			10_000_000_000_000_000_000,
-			100,
-			false,
-			10_000_000,
-			1_000_000_000,
-			5_000_000_000,
-			10_000_000_000,
-			false,
-			0,
-			0,
-			0,
-			24,
-			5,
-			2,
-		));
+			2, 1, make_presale_params(10_000_000_000_000_000_000, 100, false, 10_000_000, 1_000_000_000, 5_000_000_000, 10_000_000_000, false, 0, 0, 0, 24, 5, 2)));
 
 		// Try to finalize immediately (use root to test the actual business logic error)
 		assert_noop!(
@@ -595,23 +467,7 @@ fn finalize_presale_non_root_fails() {
 
 		assert_ok!(Presale::create_presale(
 			RuntimeOrigin::signed(1),
-			2,
-			1,
-			10_000_000_000_000_000_000,
-			100,
-			false,
-			10_000_000,
-			1_000_000_000,
-			5_000_000_000,
-			10_000_000_000,
-			false,
-			0,
-			0,
-			0,
-			24,
-			5,
-			2,
-		));
+			2, 1, make_presale_params(10_000_000_000_000_000_000, 100, false, 10_000_000, 1_000_000_000, 5_000_000_000, 10_000_000_000, false, 0, 0, 0, 24, 5, 2)));
 
 		System::set_block_number(101);
 
@@ -632,23 +488,7 @@ fn refund_works() {
 
 		assert_ok!(Presale::create_presale(
 			RuntimeOrigin::signed(1),
-			2,
-			1,
-			10_000_000_000_000_000_000,
-			100,
-			false,
-			10_000_000,
-			1_000_000_000,
-			5_000_000_000,
-			10_000_000_000,
-			false,
-			0,
-			0,
-			0,
-			24,
-			5,
-			2,
-		));
+			2, 1, make_presale_params(10_000_000_000_000_000_000, 100, false, 10_000_000, 1_000_000_000, 5_000_000_000, 10_000_000_000, false, 0, 0, 0, 24, 5, 2)));
 
 		// Bob contributes
 		let contribution = 100_000_000; // 100 USDT
@@ -703,20 +543,22 @@ fn refund_in_grace_period_lower_fee() {
 			RuntimeOrigin::signed(1),
 			2,
 			1,
-			10_000_000_000_000_000_000,
-			100,
-			false,
-			10_000_000,
-			1_000_000_000,
-			5_000_000_000,
-			10_000_000_000,
-			false,
-			0,
-			0,
-			0,
-			24, // 24 blocks grace period (block 1 + 24 = 25)
-			5,  // 5% regular refund fee
-			2,  // 2% grace refund fee
+			make_presale_params(
+				10_000_000_000_000_000_000,
+				100,
+				false,
+				10_000_000,
+				1_000_000_000,
+				5_000_000_000,
+				10_000_000_000,
+				false,
+				0,
+				0,
+				0,
+				24, // 24 blocks grace period (block 1 + 24 = 25)
+				5,  // 5% regular refund fee
+				2,  // 2% grace refund fee
+			)
 		));
 
 		let contribution = 100_000_000; // 100 USDT
@@ -754,23 +596,7 @@ fn refund_with_no_contribution_fails() {
 
 		assert_ok!(Presale::create_presale(
 			RuntimeOrigin::signed(1),
-			2,
-			1,
-			10_000_000_000_000_000_000,
-			100,
-			false,
-			10_000_000,
-			1_000_000_000,
-			5_000_000_000,
-			10_000_000_000,
-			false,
-			0,
-			0,
-			0,
-			24,
-			5,
-			2,
-		));
+			2, 1, make_presale_params(10_000_000_000_000_000_000, 100, false, 10_000_000, 1_000_000_000, 5_000_000_000, 10_000_000_000, false, 0, 0, 0, 24, 5, 2)));
 
 		// Bob tries to refund without contributing
 		assert_noop!(Presale::refund(RuntimeOrigin::signed(2), 0), Error::<Test>::NoContribution);
@@ -786,23 +612,7 @@ fn cancel_presale_works() {
 
 		assert_ok!(Presale::create_presale(
 			RuntimeOrigin::signed(1),
-			2,
-			1,
-			10_000_000_000_000_000_000,
-			100,
-			false,
-			10_000_000,
-			1_000_000_000,
-			5_000_000_000,
-			10_000_000_000,
-			false,
-			0,
-			0,
-			0,
-			24,
-			5,
-			2,
-		));
+			2, 1, make_presale_params(10_000_000_000_000_000_000, 100, false, 10_000_000, 1_000_000_000, 5_000_000_000, 10_000_000_000, false, 0, 0, 0, 24, 5, 2)));
 
 		// Bob contributes
 		assert_ok!(Presale::contribute(RuntimeOrigin::signed(2), 0, 100_000_000));
@@ -827,23 +637,7 @@ fn cancel_presale_non_authorized_fails() {
 
 		assert_ok!(Presale::create_presale(
 			RuntimeOrigin::signed(1),
-			2,
-			1,
-			10_000_000_000_000_000_000,
-			100,
-			false,
-			10_000_000,
-			1_000_000_000,
-			5_000_000_000,
-			10_000_000_000,
-			false,
-			0,
-			0,
-			0,
-			24,
-			5,
-			2,
-		));
+			2, 1, make_presale_params(10_000_000_000_000_000_000, 100, false, 10_000_000, 1_000_000_000, 5_000_000_000, 10_000_000_000, false, 0, 0, 0, 24, 5, 2)));
 
 		// Non-authorized user tries to cancel (needs EmergencyOrigin or Root)
 		assert_noop!(
@@ -861,23 +655,7 @@ fn emergency_cancel_by_root_works() {
 
 		assert_ok!(Presale::create_presale(
 			RuntimeOrigin::signed(1),
-			2,
-			1,
-			10_000_000_000_000_000_000,
-			100,
-			false,
-			10_000_000,
-			1_000_000_000,
-			5_000_000_000,
-			10_000_000_000,
-			false,
-			0,
-			0,
-			0,
-			24,
-			5,
-			2,
-		));
+			2, 1, make_presale_params(10_000_000_000_000_000_000, 100, false, 10_000_000, 1_000_000_000, 5_000_000_000, 10_000_000_000, false, 0, 0, 0, 24, 5, 2)));
 
 		// Root can cancel any presale (emergency)
 		assert_ok!(Presale::cancel_presale(RuntimeOrigin::root(), 0));
@@ -897,23 +675,8 @@ fn whitelist_presale_works() {
 		// Create whitelist presale
 		assert_ok!(Presale::create_presale(
 			RuntimeOrigin::signed(1),
-			2,
-			1,
-			10_000_000_000_000_000_000,
-			100,
-			true, // whitelist enabled
-			10_000_000,
-			1_000_000_000,
-			5_000_000_000,
-			10_000_000_000,
-			false,
-			0,
-			0,
-			0,
-			24,
-			5,
-			2,
-		));
+			2, 1, make_presale_params(10_000_000_000_000_000_000, 100, true, // whitelist enabled
+			10_000_000, 1_000_000_000, 5_000_000_000, 10_000_000_000, false, 0, 0, 0, 24, 5, 2)));
 
 		// Bob tries to contribute (not whitelisted)
 		assert_noop!(
@@ -937,23 +700,7 @@ fn add_to_whitelist_non_owner_fails() {
 
 		assert_ok!(Presale::create_presale(
 			RuntimeOrigin::signed(1),
-			2,
-			1,
-			10_000_000_000_000_000_000,
-			100,
-			true,
-			10_000_000,
-			1_000_000_000,
-			5_000_000_000,
-			10_000_000_000,
-			false,
-			0,
-			0,
-			0,
-			24,
-			5,
-			2,
-		));
+			2, 1, make_presale_params(10_000_000_000_000_000_000, 100, true, 10_000_000, 1_000_000_000, 5_000_000_000, 10_000_000_000, false, 0, 0, 0, 24, 5, 2)));
 
 		// Charlie tries to add Bob to Alice's presale whitelist
 		assert_noop!(
@@ -975,23 +722,7 @@ fn finalize_presale_soft_cap_reached_success() {
 		mint_assets(1, 1, 100_000_000_000_000_000_000); // 100,000 PEZ
 		assert_ok!(Presale::create_presale(
 			RuntimeOrigin::signed(1),
-			2,
-			1,
-			10_000_000_000_000_000_000,
-			100,
-			false,
-			10_000_000,
-			1_000_000_000,
-			5_000_000_000,
-			10_000_000_000,
-			false,
-			0,
-			0,
-			0,
-			24,
-			5,
-			2,
-		));
+			2, 1, make_presale_params(10_000_000_000_000_000_000, 100, false, 10_000_000, 1_000_000_000, 5_000_000_000, 10_000_000_000, false, 0, 0, 0, 24, 5, 2)));
 
 		// Mint PEZ to presale treasury
 		let treasury = presale_treasury(0);
@@ -1023,7 +754,7 @@ fn finalize_presale_soft_cap_reached_success() {
 		// Tokens for sale: 10,000 PEZ (10^12 decimals)
 		// Each contributor's share: (1,000 / 6,000) * 10,000 = 1,666.67 PEZ
 		for i in 2..8 {
-			assert!(Assets::balance(1, i) > 0, "Contributor {} should receive PEZ", i);
+			assert!(Assets::balance(1, i) > 0, "Contributor {i} should receive PEZ");
 		}
 	});
 }
@@ -1038,23 +769,7 @@ fn finalize_presale_soft_cap_not_reached_fails() {
 		mint_assets(1, 1, 100_000_000_000_000_000_000);
 		assert_ok!(Presale::create_presale(
 			RuntimeOrigin::signed(1),
-			2,
-			1,
-			10_000_000_000_000_000_000,
-			100,
-			false,
-			10_000_000,
-			1_000_000_000,
-			5_000_000_000,
-			10_000_000_000,
-			false,
-			0,
-			0,
-			0,
-			24,
-			5,
-			2,
-		));
+			2, 1, make_presale_params(10_000_000_000_000_000_000, 100, false, 10_000_000, 1_000_000_000, 5_000_000_000, 10_000_000_000, false, 0, 0, 0, 24, 5, 2)));
 
 		// Contributors below soft cap (max is 1000 USDT each)
 		// Need to contribute less than soft cap of 5000 USDT
@@ -1096,23 +811,7 @@ fn batch_refund_failed_presale_works() {
 		mint_assets(1, 1, 100_000_000_000_000_000_000);
 		assert_ok!(Presale::create_presale(
 			RuntimeOrigin::signed(1),
-			2,
-			1,
-			10_000_000_000_000_000_000,
-			100,
-			false,
-			10_000_000,
-			1_000_000_000,
-			5_000_000_000,
-			10_000_000_000,
-			false,
-			0,
-			0,
-			0,
-			24,
-			5,
-			2,
-		));
+			2, 1, make_presale_params(10_000_000_000_000_000_000, 100, false, 10_000_000, 1_000_000_000, 5_000_000_000, 10_000_000_000, false, 0, 0, 0, 24, 5, 2)));
 
 		// Fund presale treasury with wUSDT for refunds
 		let treasury = presale_treasury(0);
@@ -1165,23 +864,7 @@ fn batch_refund_successful_presale_fails() {
 		mint_assets(1, 1, 100_000_000_000_000_000_000);
 		assert_ok!(Presale::create_presale(
 			RuntimeOrigin::signed(1),
-			2,
-			1,
-			10_000_000_000_000_000_000,
-			100,
-			false,
-			10_000_000,
-			1_000_000_000,
-			5_000_000_000,
-			10_000_000_000,
-			false,
-			0,
-			0,
-			0,
-			24,
-			5,
-			2,
-		));
+			2, 1, make_presale_params(10_000_000_000_000_000_000, 100, false, 10_000_000, 1_000_000_000, 5_000_000_000, 10_000_000_000, false, 0, 0, 0, 24, 5, 2)));
 
 		let treasury = presale_treasury(0);
 		mint_assets(1, treasury, 100_000_000_000_000_000_000);
@@ -1223,23 +906,7 @@ fn create_presale_with_soft_cap_greater_than_hard_cap_fails() {
 		assert_noop!(
 			Presale::create_presale(
 				RuntimeOrigin::signed(1),
-				2,
-				1,
-				10_000_000_000_000_000_000,
-				100,
-				false,
-				10_000_000,
-				1_000_000_000,
-				15_000_000_000, // soft_cap: 15,000 USDT
-				10_000_000_000, // hard_cap: 10,000 USDT (INVALID!)
-				false,
-				0,
-				0,
-				0,
-				24,
-				5,
-				2,
-			),
+				2, 1, make_presale_params(10_000_000_000_000_000_000, 100, false, 10_000_000, 1_000_000_000, 15_000_000_000, 10_000_000_000, false, 0, 0, 0, 24, 5, 2)),
 			Error::<Test>::InvalidTokensForSale
 		);
 	});
@@ -1247,7 +914,7 @@ fn create_presale_with_soft_cap_greater_than_hard_cap_fails() {
 #[test]
 fn debug_finalize_presale() {
 	use crate::mock::*;
-	use pezframe_support::{assert_ok, traits::fungibles::Mutate};
+	use pezframe_support::assert_ok;
 
 	new_test_ext().execute_with(|| {
 		create_assets();
@@ -1258,23 +925,7 @@ fn debug_finalize_presale() {
 		// Create presale
 		assert_ok!(Presale::create_presale(
 			RuntimeOrigin::signed(1),
-			2,              // payment asset (wUSDT)
-			1,              // reward asset (PEZ)
-			10_000_000_000, // tokens_for_sale
-			100,
-			false,
-			10_000_000,
-			1_000_000_000,
-			5_000_000_000, // soft_cap
-			10_000_000_000,
-			false,
-			0,
-			0,
-			0,
-			24,
-			5,
-			2
-		));
+			2, 1, make_presale_params(10_000_000_000, 100, false, 10_000_000, 1_000_000_000, 5_000_000_000, 10_000_000_000, false, 0, 0, 0, 24, 5, 2)));
 
 		// Fund presale treasury with reward tokens
 		let treasury = presale_treasury(0);
@@ -1296,7 +947,7 @@ fn debug_finalize_presale() {
 
 		// Try to finalize
 		let result = Presale::finalize_presale(RuntimeOrigin::root(), 0);
-		println!("Finalize result: {:?}", result);
+		println!("Finalize result: {result:?}");
 		assert_ok!(result);
 	});
 }