pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-06-09 20:11:09 +00:00
Code Issues Packages Projects Releases Wiki Activity

Adds force_origin support (#13845)

Browse Source 
* Adds force_origin support

* Moves a couple of tests to showcase v2 with force_origin

* Adds remaining tests

* adds documentation

* minor

* adds test for invalid origin

* ".git/.scripts/commands/fmt/fmt.sh"

* updates param to use MaxCalls

* Fixes compilation error

* Updates doc comment

* Fixes test outputs

* Fixes test output

* ".git/.scripts/commands/fmt/fmt.sh"

---------

Co-authored-by: command-bot <>
This commit is contained in:
gupnik
2023-04-24 17:34:15 +05:30
committed by GitHub
parent b8d94bfad1
commit 3688575fd0
5 changed files with 141 additions and 61 deletions
Download Patch File Download Diff File Expand all files Collapse all files
substrate/frame/lottery/src/benchmarking.rs
+85 -42
View File
@@ -21,7 +21,12 @@
use super::*;
use frame_benchmarking::v1::{account, benchmarks, whitelisted_caller, BenchmarkError};
use crate::Pallet as Lottery;
use frame_benchmarking::{
impl_benchmark_test_suite,
v1::{account, whitelisted_caller, BenchmarkError},
v2::*,
};
use frame_support::{
storage::bounded_vec::BoundedVec,
traits::{EnsureOrigin, OnInitialize},
@@ -29,8 +34,6 @@ use frame_support::{
use frame_system::RawOrigin;
use sp_runtime::traits::{Bounded, Zero};
use crate::Pallet as Lottery;
// Set up and start a lottery
fn setup_lottery<T: Config>(repeat: bool) -> Result<(), &'static str> {
let price = T::Currency::minimum_balance();
@@ -50,72 +53,100 @@ fn setup_lottery<T: Config>(repeat: bool) -> Result<(), &'static str> {
Ok(())
}
benchmarks! {
buy_ticket {
#[benchmarks]
mod benchmarks {
use super::*;
#[benchmark]
fn buy_ticket() -> Result<(), BenchmarkError> {
let caller = whitelisted_caller();
T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value());
setup_lottery::<T>(false)?;
// force user to have a long vec of calls participating
let set_code_index: CallIndex = Lottery::<T>::call_to_index(
&frame_system::Call::<T>::set_code{ code: vec![] }.into()
&frame_system::Call::<T>::set_code { code: vec![] }.into(),
)?;
let already_called: (u32, BoundedVec<CallIndex, T::MaxCalls>) = (
LotteryIndex::<T>::get(),
BoundedVec::<CallIndex, T::MaxCalls>::try_from(vec![
set_code_index;
T::MaxCalls::get().saturating_sub(1) as usize
]).unwrap(),
T::MaxCalls::get().saturating_sub(1)
as usize
])
.unwrap(),
);
Participants::<T>::insert(&caller, already_called);
let call = frame_system::Call::<T>::remark { remark: vec![] };
}: _(RawOrigin::Signed(caller), Box::new(call.into()))
verify {
#[extrinsic_call]
_(RawOrigin::Signed(caller), Box::new(call.into()));
assert_eq!(TicketsCount::<T>::get(), 1);
Ok(())
}
set_calls {
let n in 0 .. T::MaxCalls::get() as u32;
#[benchmark]
fn set_calls(n: Linear<0, { T::MaxCalls::get() }>) -> Result<(), BenchmarkError> {
let calls = vec![frame_system::Call::<T>::remark { remark: vec![] }.into(); n as usize];
let origin =
T::ManagerOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
assert!(CallIndices::<T>::get().is_empty());
}: _<T::RuntimeOrigin>(origin, calls)
verify {
#[extrinsic_call]
_(origin as T::RuntimeOrigin, calls);
if !n.is_zero() {
assert!(!CallIndices::<T>::get().is_empty());
}
Ok(())
}
start_lottery {
#[benchmark]
fn start_lottery() -> Result<(), BenchmarkError> {
let price = BalanceOf::<T>::max_value();
let end = 10u32.into();
let payout = 5u32.into();
let origin =
T::ManagerOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
}: _<T::RuntimeOrigin>(origin, price, end, payout, true)
verify {
#[extrinsic_call]
_(origin as T::RuntimeOrigin, price, end, payout, true);
assert!(crate::Lottery::<T>::get().is_some());
Ok(())
}
stop_repeat {
#[benchmark]
fn stop_repeat() -> Result<(), BenchmarkError> {
setup_lottery::<T>(true)?;
assert_eq!(crate::Lottery::<T>::get().unwrap().repeat, true);
let origin =
T::ManagerOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
}: _<T::RuntimeOrigin>(origin)
verify {
#[extrinsic_call]
_(origin as T::RuntimeOrigin);
assert_eq!(crate::Lottery::<T>::get().unwrap().repeat, false);
Ok(())
}
on_initialize_end {
#[benchmark]
fn on_initialize_end() -> Result<(), BenchmarkError> {
setup_lottery::<T>(false)?;
let winner = account("winner", 0, 0);
// User needs more than min balance to get ticket
T::Currency::make_free_balance_be(&winner, T::Currency::minimum_balance() * 10u32.into());
// Make sure lottery account has at least min balance too
let lottery_account = Lottery::<T>::account_id();
T::Currency::make_free_balance_be(&lottery_account, T::Currency::minimum_balance() * 10u32.into());
T::Currency::make_free_balance_be(
&lottery_account,
T::Currency::minimum_balance() * 10u32.into(),
);
// Buy a ticket
let call = frame_system::Call::<T>::remark { remark: vec![] };
Lottery::<T>::buy_ticket(RawOrigin::Signed(winner.clone()).into(), Box::new(call.into()))?;
@@ -124,29 +155,37 @@ benchmarks! {
// Assert that lotto is set up for winner
assert_eq!(TicketsCount::<T>::get(), 1);
assert!(!Lottery::<T>::pot().1.is_zero());
}: {
// Generate `MaxGenerateRandom` numbers for worst case scenario
for i in 0 .. T::MaxGenerateRandom::get() {
Lottery::<T>::generate_random_number(i);
#[block]
{
// Generate `MaxGenerateRandom` numbers for worst case scenario
for i in 0..T::MaxGenerateRandom::get() {
Lottery::<T>::generate_random_number(i);
}
// Start lottery has block 15 configured for payout
Lottery::<T>::on_initialize(15u32.into());
}
// Start lottery has block 15 configured for payout
Lottery::<T>::on_initialize(15u32.into());
}
verify {
assert!(crate::Lottery::<T>::get().is_none());
assert_eq!(TicketsCount::<T>::get(), 0);
assert_eq!(Lottery::<T>::pot().1, 0u32.into());
assert!(!T::Currency::free_balance(&winner).is_zero())
assert!(!T::Currency::free_balance(&winner).is_zero());
Ok(())
}
on_initialize_repeat {
#[benchmark]
fn on_initialize_repeat() -> Result<(), BenchmarkError> {
setup_lottery::<T>(true)?;
let winner = account("winner", 0, 0);
// User needs more than min balance to get ticket
T::Currency::make_free_balance_be(&winner, T::Currency::minimum_balance() * 10u32.into());
// Make sure lottery account has at least min balance too
let lottery_account = Lottery::<T>::account_id();
T::Currency::make_free_balance_be(&lottery_account, T::Currency::minimum_balance() * 10u32.into());
T::Currency::make_free_balance_be(
&lottery_account,
T::Currency::minimum_balance() * 10u32.into(),
);
// Buy a ticket
let call = frame_system::Call::<T>::remark { remark: vec![] };
Lottery::<T>::buy_ticket(RawOrigin::Signed(winner.clone()).into(), Box::new(call.into()))?;
@@ -155,20 +194,24 @@ benchmarks! {
// Assert that lotto is set up for winner
assert_eq!(TicketsCount::<T>::get(), 1);
assert!(!Lottery::<T>::pot().1.is_zero());
}: {
// Generate `MaxGenerateRandom` numbers for worst case scenario
for i in 0 .. T::MaxGenerateRandom::get() {
Lottery::<T>::generate_random_number(i);
#[block]
{
// Generate `MaxGenerateRandom` numbers for worst case scenario
for i in 0..T::MaxGenerateRandom::get() {
Lottery::<T>::generate_random_number(i);
}
// Start lottery has block 15 configured for payout
Lottery::<T>::on_initialize(15u32.into());
}
// Start lottery has block 15 configured for payout
Lottery::<T>::on_initialize(15u32.into());
}
verify {
assert!(crate::Lottery::<T>::get().is_some());
assert_eq!(LotteryIndex::<T>::get(), 2);
assert_eq!(TicketsCount::<T>::get(), 0);
assert_eq!(Lottery::<T>::pot().1, 0u32.into());
assert!(!T::Currency::free_balance(&winner).is_zero())
assert!(!T::Currency::free_balance(&winner).is_zero());
Ok(())
}
impl_benchmark_test_suite!(Lottery, crate::mock::new_test_ext(), crate::mock::Test);