pezkuwichain/pezkuwi-sdk
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

fix: Resolve cargo clippy errors and add CI workflow plan

Browse Source 
## 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
This commit is contained in:
Kurdistan Tech Ministry
2025-12-22 16:36:14 +03:00
parent 8acf59c6aa
commit 65b7f5e640
1393 changed files with 17834 additions and 179151 deletions
Download Patch File Download Diff File Expand all files Collapse all files
pezcumulus/teyrchains/pezpallets/presale/src/benchmarking.rs
+81 -96
View File
@@ -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
+79 -74
View File
@@ -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
+2 -2
View File
@@ -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
+129 -478
View File
@@ -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);
});
}