diff --git a/zrml/prediction-markets/src/benchmarks.rs b/zrml/prediction-markets/src/benchmarks.rs index d841ae9e3..9c7c5f5ff 100644 --- a/zrml/prediction-markets/src/benchmarks.rs +++ b/zrml/prediction-markets/src/benchmarks.rs @@ -37,15 +37,19 @@ use orml_traits::MultiCurrency; use sp_runtime::traits::{One, SaturatedConversion, Zero}; use zeitgeist_primitives::{ constants::mock::{MaxSwapFee, MinLiquidity, MinWeight, BASE, MILLISECS_PER_BLOCK}, - traits::{DisputeApi, Swaps}, + traits::Swaps, types::{ Asset, Deadlines, MarketCreation, MarketDisputeMechanism, MarketPeriod, MarketStatus, - MarketType, MaxRuntimeUsize, MultiHash, OutcomeReport, PoolStatus, ScalarPosition, - ScoringRule, SubsidyUntil, + MarketType, MaxRuntimeUsize, MultiHash, OutcomeReport, PoolStatus, ScoringRule, + SubsidyUntil, }, }; use zrml_market_commons::MarketCommonsPalletApi; +fn assert_last_event(generic_event: ::Event) { + frame_system::Pallet::::assert_last_event(generic_event.into()); +} + // Get default values for market creation. Also spawns an account with maximum // amount of native currency fn create_market_common_parameters( @@ -124,48 +128,6 @@ fn create_close_and_report_market( Ok((caller, market_id)) } -// Generates `acc_total` accounts, of which `acc_asset` account do own `asset` -fn generate_accounts_with_assets( - acc_total: u32, - acc_asset: u32, - asset: Asset>, -) -> Result<(), &'static str> { - let min_liquidity: BalanceOf = MinLiquidity::get().saturated_into(); - let fake_asset = Asset::CategoricalOutcome::>(u128::MAX.saturated_into(), 0); - let mut mut_acc_asset = acc_asset; - - for i in 0..acc_total { - let acc = account("AssetHolder", i, 0); - if mut_acc_asset > 0 { - T::AssetManager::deposit(asset, &acc, min_liquidity)?; - mut_acc_asset -= 1; - } else { - T::AssetManager::deposit(fake_asset, &acc, min_liquidity)?; - } - } - - Ok(()) -} - -// Setup a reported categorical market and create accounts with outcome assets. -fn setup_resolve_common_categorical( - acc_total: u32, - acc_asset: u32, - categories: u16, -) -> Result<(T::AccountId, MarketIdOf), &'static str> { - let (caller, market_id) = create_close_and_report_market::( - MarketCreation::Permissionless, - MarketType::Categorical(categories), - OutcomeReport::Categorical(categories.saturating_sub(1)), - )?; - generate_accounts_with_assets::( - acc_total, - acc_asset, - Asset::CategoricalOutcome(market_id, categories.saturating_sub(1)), - )?; - Ok((caller, market_id)) -} - // Setup a categorical market for fn `internal_resolve` fn setup_redeem_shares_common( market_type: MarketType, @@ -211,26 +173,9 @@ fn setup_redeem_shares_common( Ok((caller, market_id)) } -// Setup a reported scalar market and create accounts with outcome assets. -fn setup_resolve_common_scalar( - acc_total: u32, - acc_asset: u32, -) -> Result<(T::AccountId, MarketIdOf), &'static str> { - let (caller, market_id) = create_close_and_report_market::( - MarketCreation::Permissionless, - MarketType::Scalar(0u128..=u128::MAX), - OutcomeReport::Scalar(u128::MAX), - )?; - generate_accounts_with_assets::( - acc_total, - acc_asset, - Asset::ScalarOutcome(market_id, ScalarPosition::Long), - )?; - Ok((caller, market_id)) -} - fn setup_reported_categorical_market_with_pool( categories: u32, + report_outcome: OutcomeReport, ) -> Result<(T::AccountId, MarketIdOf), &'static str> { let (caller, market_id) = create_market_common::( MarketCreation::Permissionless, @@ -265,8 +210,7 @@ fn setup_reported_categorical_market_with_pool() + 1) * MILLISECS_PER_BLOCK; pallet_timestamp::Pallet::::set_timestamp((end + grace_period).into()); - let outcome = OutcomeReport::Categorical(1u16); - Call::::report { market_id, outcome } + Call::::report { market_id, outcome: report_outcome } .dispatch_bypass_filter(RawOrigin::Signed(caller.clone()).into())?; Ok((caller, market_id)) @@ -278,27 +222,126 @@ benchmarks! { } admin_destroy_disputed_market{ - let categories = T::MaxCategories::get(); - let (caller, market_id) = setup_resolve_common_categorical::(0, 0, categories)?; + // The number of assets. + let a in (T::MinCategories::get().into())..T::MaxCategories::get().into(); + // The number of disputes. + let d in 1..T::MaxDisputes::get(); + // The number of market ids per open time frame. + let o in 0..63; + // The number of market ids per close time frame. + let c in 0..63; + // The number of market ids per dispute block. + let r in 0..63; - let categories : u32 = categories.saturated_into(); - for i in 0..categories.min(T::MaxDisputes::get()) { - let origin = caller.clone(); - let disputes = crate::Disputes::::get(market_id); - let market = T::MarketCommons::market(&Default::default())?; - T::SimpleDisputes::on_dispute(&disputes, &market_id, &market)?; + let (caller, market_id) = setup_reported_categorical_market_with_pool::( + a, + OutcomeReport::Categorical(0u16), + )?; + + let pool_id = T::MarketCommons::market_pool(&market_id)?; + + for i in 1..=d { + let outcome = OutcomeReport::Categorical((i % a).saturated_into()); + let disputor = account("disputor", i, 0); + let dispute_bond = crate::pallet::default_dispute_bond::(i as usize); + T::AssetManager::deposit(Asset::Ztg, &disputor, dispute_bond)?; + let _ = Pallet::::dispute(RawOrigin::Signed(disputor).into(), market_id, outcome)?; + } + + let market = T::MarketCommons::market(&market_id)?; + + let (range_start, range_end) = match market.period { + MarketPeriod::Timestamp(range) => (range.start, range.end), + _ => panic!("admin_destroy_reported_market: Unsupported market period"), + }; + + for i in 0..o { + MarketIdsPerOpenTimeFrame::::try_mutate( + Pallet::::calculate_time_frame_of_moment(range_start), + |ids| ids.try_push(i.into()), + ).unwrap(); + } + + for i in 0..c { + MarketIdsPerCloseTimeFrame::::try_mutate( + Pallet::::calculate_time_frame_of_moment(range_end), + |ids| ids.try_push(i.into()), + ).unwrap(); + } + + let disputes = Disputes::::get(market_id); + let last_dispute = disputes.last().unwrap(); + let dispute_at = last_dispute.at; + for i in 0..r { + MarketIdsPerDisputeBlock::::try_mutate( + dispute_at, + |ids| ids.try_push(i.into()), + ).unwrap(); } let destroy_origin = T::DestroyOrigin::successful_origin(); let call = Call::::admin_destroy_market { market_id }; - }: { call.dispatch_bypass_filter(destroy_origin)? } + }: { + call.dispatch_bypass_filter(destroy_origin)? + } verify { + assert_last_event::(Event::MarketDestroyed::(market_id).into()); + } + + admin_destroy_reported_market { + // The number of assets. + let a in (T::MinCategories::get().into())..T::MaxCategories::get().into(); + // The number of market ids per open time frame. + let o in 0..63; + // The number of market ids per close time frame. + let c in 0..63; + // The number of market ids per dispute block. + let r in 0..63; + + let (caller, market_id) = setup_reported_categorical_market_with_pool::( + a, + OutcomeReport::Categorical(0u16), + )?; + + let pool_id = T::MarketCommons::market_pool(&market_id)?; + + let market = T::MarketCommons::market(&market_id)?; + + let (range_start, range_end) = match market.period { + MarketPeriod::Timestamp(range) => (range.start, range.end), + _ => panic!("admin_destroy_reported_market: Unsupported market period"), + }; + + for i in 0..o { + MarketIdsPerOpenTimeFrame::::try_mutate( + Pallet::::calculate_time_frame_of_moment(range_start), + |ids| ids.try_push(i.into()), + ).unwrap(); + } + + for i in 0..c { + MarketIdsPerCloseTimeFrame::::try_mutate( + Pallet::::calculate_time_frame_of_moment(range_end), + |ids| ids.try_push(i.into()), + ).unwrap(); + } + + let report_at = market.report.unwrap().at; + for i in 0..r { + MarketIdsPerReportBlock::::try_mutate( + report_at, + |ids| ids.try_push(i.into()), + ).unwrap(); + } - admin_destroy_reported_market{ - let categories :u16 = T::MaxCategories::get().saturated_into(); - let (caller, market_id) = setup_resolve_common_categorical::(0, 0, categories)?; let destroy_origin = T::DestroyOrigin::successful_origin(); let call = Call::::admin_destroy_market { market_id }; - }: { call.dispatch_bypass_filter(destroy_origin)? } + }: { + call.dispatch_bypass_filter(destroy_origin)? + } verify { + assert_last_event::(Event::MarketDestroyed::( + market_id, + ).into()); + } admin_move_market_to_closed { let o in 0..63; @@ -331,15 +374,180 @@ benchmarks! { let call = Call::::admin_move_market_to_closed { market_id }; }: { call.dispatch_bypass_filter(close_origin)? } - // This benchmark measures the cost of fn `admin_move_market_to_resolved` - // and assumes a scalar market is used. The default cost for this function - // is the resulting weight from this benchmark minus the weight for - // fn `internal_resolve` of a reported and non-disputed scalar market. - admin_move_market_to_resolved_overhead { - let (_, market_id) = setup_resolve_common_scalar::(0, 0)?; + admin_move_market_to_resolved_scalar_reported { + let r in 0..63; + + let (_, market_id) = create_close_and_report_market::( + MarketCreation::Permissionless, + MarketType::Scalar(0u128..=u128::MAX), + OutcomeReport::Scalar(u128::MAX), + )?; + + let market = T::MarketCommons::market(&market_id)?; + + let report_at = market.report.unwrap().at; + for i in 0..r { + MarketIdsPerReportBlock::::try_mutate( + report_at, + |ids| ids.try_push(i.into()), + ).unwrap(); + } + let close_origin = T::CloseOrigin::successful_origin(); let call = Call::::admin_move_market_to_resolved { market_id }; - }: { call.dispatch_bypass_filter(close_origin)? } + }: { + call.dispatch_bypass_filter(close_origin)? + } verify { + assert_last_event::(Event::MarketResolved::( + market_id, + MarketStatus::Resolved, + OutcomeReport::Scalar(u128::MAX), + ).into()); + } + + admin_move_market_to_resolved_categorical_reported { + let r in 0..63; + + let categories = T::MaxCategories::get(); + let (_, market_id) = setup_reported_categorical_market_with_pool::( + categories.into(), + OutcomeReport::Categorical(0u16), + )?; + T::MarketCommons::mutate_market(&market_id, |market| { + let admin = account("admin", 0, 0); + market.dispute_mechanism = MarketDisputeMechanism::Authorized(admin); + Ok(()) + })?; + + let market = T::MarketCommons::market(&market_id)?; + + let report_at = market.report.unwrap().at; + for i in 0..r { + MarketIdsPerReportBlock::::try_mutate( + report_at, + |ids| ids.try_push(i.into()), + ).unwrap(); + } + + let close_origin = T::CloseOrigin::successful_origin(); + let call = Call::::admin_move_market_to_resolved { market_id }; + }: { + call.dispatch_bypass_filter(close_origin)? + } verify { + assert_last_event::(Event::MarketResolved::( + market_id, + MarketStatus::Resolved, + OutcomeReport::Categorical(0u16), + ).into()); + } + + admin_move_market_to_resolved_scalar_disputed { + let r in 0..63; + let d in 1..T::MaxDisputes::get(); + + let (_, market_id) = create_close_and_report_market::( + MarketCreation::Permissionless, + MarketType::Scalar(0u128..=u128::MAX), + OutcomeReport::Scalar(u128::MAX), + )?; + + T::MarketCommons::mutate_market(&market_id, |market| { + let admin = account("admin", 0, 0); + market.dispute_mechanism = MarketDisputeMechanism::Authorized(admin); + Ok(()) + })?; + + let market = T::MarketCommons::market(&market_id)?; + if let MarketType::Scalar(range) = market.market_type { + assert!((d as u128) < *range.end()); + } else { + panic!("Must create scalar market"); + } + + for i in 1..=d { + let outcome = OutcomeReport::Scalar(i.saturated_into()); + let disputor = account("disputor", i, 0); + let dispute_bond = crate::pallet::default_dispute_bond::(i as usize); + T::AssetManager::deposit( + Asset::Ztg, + &disputor, + dispute_bond, + )?; + Pallet::::dispute(RawOrigin::Signed(disputor).into(), market_id, outcome)?; + } + let disputes = Disputes::::get(market_id); + + let last_dispute = disputes.last().unwrap(); + let dispute_at = last_dispute.at; + for i in 0..r { + MarketIdsPerDisputeBlock::::try_mutate( + dispute_at, + |ids| ids.try_push(i.into()), + ).unwrap(); + } + + let close_origin = T::CloseOrigin::successful_origin(); + let call = Call::::admin_move_market_to_resolved { market_id }; + }: { + call.dispatch_bypass_filter(close_origin)? + } verify { + assert_last_event::(Event::MarketResolved::( + market_id, + MarketStatus::Resolved, + OutcomeReport::Scalar(u128::MAX), + ).into()); + } + + admin_move_market_to_resolved_categorical_disputed { + let r in 0..63; + let d in 1..T::MaxDisputes::get(); + + let categories = T::MaxCategories::get(); + let (caller, market_id) = + setup_reported_categorical_market_with_pool::( + categories.into(), + OutcomeReport::Categorical(0u16) + )?; + + T::MarketCommons::mutate_market(&market_id, |market| { + let admin = account("admin", 0, 0); + market.dispute_mechanism = MarketDisputeMechanism::Authorized(admin); + Ok(()) + })?; + + for i in 1..=d { + let outcome = OutcomeReport::Categorical((i % 2).saturated_into::()); + let disputor = account("disputor", i, 0); + let dispute_bond = crate::pallet::default_dispute_bond::(i as usize); + T::AssetManager::deposit( + Asset::Ztg, + &disputor, + dispute_bond, + )?; + Pallet::::dispute(RawOrigin::Signed(disputor).into(), market_id, outcome)?; + } + let disputes = Disputes::::get(market_id); + + let last_dispute = disputes.last().unwrap(); + let dispute_at = last_dispute.at; + for i in 0..r { + MarketIdsPerDisputeBlock::::try_mutate( + dispute_at, + |ids| ids.try_push(i.into()), + ).unwrap(); + } + + let close_origin = T::CloseOrigin::successful_origin(); + let call = Call::::admin_move_market_to_resolved { market_id }; + }: { + call.dispatch_bypass_filter(close_origin)? + } verify { + assert_last_event::(Event::MarketResolved::( + market_id, + MarketStatus::Resolved, + OutcomeReport::Categorical(0u16), + ).into()); + } approve_market { let (_, market_id) = create_market_common::( @@ -545,7 +753,10 @@ benchmarks! { internal_resolve_categorical_reported { let categories = T::MaxCategories::get(); - let (_, market_id) = setup_reported_categorical_market_with_pool::(categories.into())?; + let (_, market_id) = setup_reported_categorical_market_with_pool::( + categories.into(), + OutcomeReport::Categorical(1u16), + )?; T::MarketCommons::mutate_market(&market_id, |market| { let admin = account("admin", 0, 0); market.dispute_mechanism = MarketDisputeMechanism::Authorized(admin); @@ -565,14 +776,16 @@ benchmarks! { let categories = T::MaxCategories::get(); let (caller, market_id) = - setup_reported_categorical_market_with_pool::(categories.into())?; + setup_reported_categorical_market_with_pool::( + categories.into(), + OutcomeReport::Categorical(1u16) + )?; T::MarketCommons::mutate_market(&market_id, |market| { let admin = account("admin", 0, 0); market.dispute_mechanism = MarketDisputeMechanism::Authorized(admin); Ok(()) })?; - let categories : u32 = categories.saturated_into(); for i in 0..d { let origin = caller.clone(); Pallet::::dispute( @@ -604,8 +817,6 @@ benchmarks! { } internal_resolve_scalar_disputed { - let total_accounts = 10u32; - let asset_accounts = 10u32; let d in 0..T::MaxDisputes::get(); let (caller, market_id) = create_close_and_report_market::( @@ -661,7 +872,7 @@ benchmarks! { Pallet::::process_subsidy_collecting_markets( T::BlockNumber::zero(), MomentOf::::zero() - ) + ); } redeem_shares_categorical { diff --git a/zrml/prediction-markets/src/lib.rs b/zrml/prediction-markets/src/lib.rs index 88e1f53ac..e6eadfacd 100644 --- a/zrml/prediction-markets/src/lib.rs +++ b/zrml/prediction-markets/src/lib.rs @@ -89,9 +89,21 @@ mod pallet { /// Must be called by `DestroyOrigin`. Bonds (unless already returned) are slashed without /// exception. Can currently only be used for destroying CPMM markets. #[pallet::weight(( - T::WeightInfo::admin_destroy_reported_market() - .max(T::WeightInfo::admin_destroy_disputed_market()), - Pays::No))] + T::WeightInfo::admin_destroy_reported_market( + T::MaxCategories::get().into(), + CacheSize::get(), + CacheSize::get(), + CacheSize::get(), + ) + .max(T::WeightInfo::admin_destroy_disputed_market( + T::MaxCategories::get().into(), + T::MaxDisputes::get(), + CacheSize::get(), + CacheSize::get(), + CacheSize::get(), + )), + Pays::No, + ))] #[transactional] pub fn admin_destroy_market( origin: OriginFor, @@ -135,14 +147,17 @@ mod pallet { &market_account, T::AssetManager::free_balance(Asset::Ztg, &market_account), ); + let mut category_count = 0u32; if let Ok(pool_id) = T::MarketCommons::market_pool(&market_id) { - T::Swaps::destroy_pool(pool_id)?; + let pool = T::Swaps::pool(pool_id)?; + category_count = pool.assets.len().saturated_into(); + let _ = T::Swaps::destroy_pool(pool_id)?; T::MarketCommons::remove_market_pool(&market_id)?; } - Self::clear_auto_open(&market_id)?; - Self::clear_auto_close(&market_id)?; - Self::clear_auto_resolve(&market_id)?; + let open_ids_len = Self::clear_auto_open(&market_id)?; + let close_ids_len = Self::clear_auto_close(&market_id)?; + let (ids_len, disputes_len) = Self::clear_auto_resolve(&market_id)?; T::MarketCommons::remove_market(&market_id)?; Disputes::::remove(market_id); @@ -151,9 +166,28 @@ mod pallet { // Weight correction // The DestroyOrigin should not pay fees for providing this service if market_status == MarketStatus::Reported { - Ok((Some(T::WeightInfo::admin_destroy_reported_market()), Pays::No).into()) + Ok(( + Some(T::WeightInfo::admin_destroy_reported_market( + category_count, + open_ids_len, + close_ids_len, + ids_len, + )), + Pays::No, + ) + .into()) } else if market_status == MarketStatus::Disputed { - Ok((Some(T::WeightInfo::admin_destroy_disputed_market()), Pays::No).into()) + Ok(( + Some(T::WeightInfo::admin_destroy_disputed_market( + category_count, + disputes_len, + open_ids_len, + close_ids_len, + ids_len, + )), + Pays::No, + ) + .into()) } else { Ok((None, Pays::No).into()) } @@ -199,10 +233,28 @@ mod pallet { /// Allows the `ResolveOrigin` to immediately move a reported or disputed /// market to resolved. - #[pallet::weight((T::WeightInfo::admin_move_market_to_resolved_overhead() - .saturating_add(T::WeightInfo::internal_resolve_categorical_reported() - .saturating_sub(T::WeightInfo::internal_resolve_scalar_reported()) - ), Pays::No))] + /// + /// # Weight + /// + /// Complexity: `O(n + m)`, where `n` is the number of market ids + /// per dispute / report block, m is the number of disputes. + #[pallet::weight(( + T::WeightInfo::admin_move_market_to_resolved_scalar_reported(CacheSize::get()) + .max( + T::WeightInfo::admin_move_market_to_resolved_categorical_reported(CacheSize::get()) + ).max( + T::WeightInfo::admin_move_market_to_resolved_scalar_disputed( + CacheSize::get(), + T::MaxDisputes::get() + ) + ).max( + T::WeightInfo::admin_move_market_to_resolved_categorical_disputed( + CacheSize::get(), + T::MaxDisputes::get() + ) + ), + Pays::No, + ))] #[transactional] pub fn admin_move_market_to_resolved( origin: OriginFor, @@ -215,9 +267,35 @@ mod pallet { market.status == MarketStatus::Reported || market.status == MarketStatus::Disputed, Error::::InvalidMarketStatus, ); - Self::clear_auto_resolve(&market_id)?; + let (ids_len, disputes_len) = Self::clear_auto_resolve(&market_id)?; let market = T::MarketCommons::market(&market_id)?; - let weight = Self::on_resolution(&market_id, &market)?; + let _ = Self::on_resolution(&market_id, &market)?; + let weight = match market.market_type { + MarketType::Scalar(_) => match market.status { + MarketStatus::Reported => { + T::WeightInfo::admin_move_market_to_resolved_scalar_reported(ids_len) + } + MarketStatus::Disputed => { + T::WeightInfo::admin_move_market_to_resolved_scalar_disputed( + ids_len, + disputes_len, + ) + } + _ => return Err(Error::::InvalidMarketStatus.into()), + }, + MarketType::Categorical(_) => match market.status { + MarketStatus::Reported => { + T::WeightInfo::admin_move_market_to_resolved_categorical_reported(ids_len) + } + MarketStatus::Disputed => { + T::WeightInfo::admin_move_market_to_resolved_categorical_disputed( + ids_len, + disputes_len, + ) + } + _ => return Err(Error::::InvalidMarketStatus.into()), + }, + }; Ok((Some(weight), Pays::No).into()) } @@ -1267,6 +1345,8 @@ mod pallet { MarketIsNotProposed, /// A reported market was expected. MarketIsNotReported, + /// A disputed market was expected. + MarketIsNotDisputed, /// A resolved market was expected. MarketIsNotResolved, /// The point in time when the market becomes active is too soon. @@ -1647,28 +1727,40 @@ mod pallet { } /// Clears this market from being stored for automatic resolution. - fn clear_auto_resolve(market_id: &MarketIdOf) -> DispatchResult { + fn clear_auto_resolve(market_id: &MarketIdOf) -> Result<(u32, u32), DispatchError> { let market = T::MarketCommons::market(market_id)?; - if market.status == MarketStatus::Reported { - let report = market.report.ok_or(Error::::MarketIsNotReported)?; - let dispute_duration_ends_at_block = - report.at.saturating_add(market.deadlines.dispute_duration); - MarketIdsPerReportBlock::::mutate(dispute_duration_ends_at_block, |ids| { - remove_item::, _>(ids, market_id); - }); - } - if market.status == MarketStatus::Disputed { - let disputes = Disputes::::get(market_id); - if let Some(last_dispute) = disputes.last() { + let (ids_len, disputes_len) = match market.status { + MarketStatus::Reported => { + let report = market.report.ok_or(Error::::MarketIsNotReported)?; + let dispute_duration_ends_at_block = + report.at.saturating_add(market.deadlines.dispute_duration); + MarketIdsPerReportBlock::::mutate( + dispute_duration_ends_at_block, + |ids| -> (u32, u32) { + let ids_len = ids.len() as u32; + remove_item::, _>(ids, market_id); + (ids_len, 0u32) + }, + ) + } + MarketStatus::Disputed => { + let disputes = Disputes::::get(market_id); + let last_dispute = disputes.last().ok_or(Error::::MarketIsNotDisputed)?; let dispute_duration_ends_at_block = last_dispute.at.saturating_add(market.deadlines.dispute_duration); - MarketIdsPerDisputeBlock::::mutate(dispute_duration_ends_at_block, |ids| { - remove_item::, _>(ids, market_id); - }); + MarketIdsPerDisputeBlock::::mutate( + dispute_duration_ends_at_block, + |ids| -> (u32, u32) { + let ids_len = ids.len() as u32; + remove_item::, _>(ids, market_id); + (ids_len, disputes.len() as u32) + }, + ) } - } + _ => (0u32, 0u32), + }; - Ok(()) + Ok((ids_len, disputes_len)) } pub(crate) fn do_buy_complete_set( @@ -2417,7 +2509,7 @@ mod pallet { } // No-one can bound more than BalanceOf, therefore, this functions saturates - pub fn default_dispute_bond(n: usize) -> BalanceOf + pub(crate) fn default_dispute_bond(n: usize) -> BalanceOf where T: Config, { diff --git a/zrml/prediction-markets/src/weights.rs b/zrml/prediction-markets/src/weights.rs index 84e80d76b..24cc760ba 100644 --- a/zrml/prediction-markets/src/weights.rs +++ b/zrml/prediction-markets/src/weights.rs @@ -45,10 +45,13 @@ use frame_support::{traits::Get, weights::Weight}; /// Trait containing the required functions for weight retrival within /// zrml_prediction_markets (automatically generated) pub trait WeightInfoZeitgeist { - fn admin_destroy_disputed_market() -> Weight; - fn admin_destroy_reported_market() -> Weight; + fn admin_destroy_disputed_market(a: u32, d: u32, o: u32, c: u32, r: u32) -> Weight; + fn admin_destroy_reported_market(a: u32, o: u32, c: u32, r: u32) -> Weight; fn admin_move_market_to_closed(o: u32, c: u32) -> Weight; - fn admin_move_market_to_resolved_overhead() -> Weight; + fn admin_move_market_to_resolved_scalar_reported(r: u32) -> Weight; + fn admin_move_market_to_resolved_categorical_reported(r: u32) -> Weight; + fn admin_move_market_to_resolved_scalar_disputed(r: u32, d: u32) -> Weight; + fn admin_move_market_to_resolved_categorical_disputed(r: u32, d: u32) -> Weight; fn approve_market() -> Weight; fn buy_complete_set(a: u32) -> Weight; fn create_market(m: u32) -> Weight; @@ -80,26 +83,50 @@ impl WeightInfoZeitgeist for WeightInfo { // Storage: unknown [0x3a7472616e73616374696f6e5f6c6576656c3a] (r:1 w:1) // Storage: MarketCommons Markets (r:1 w:1) // Storage: Balances Reserves (r:1 w:1) - // Storage: System Account (r:1 w:0) - // Storage: MarketCommons MarketPool (r:1 w:0) - // Storage: PredictionMarkets MarketIdsPerReportBlock (r:1 w:1) - // Storage: PredictionMarkets Disputes (r:0 w:1) - fn admin_destroy_disputed_market() -> Weight { - (95_370_000 as Weight) - .saturating_add(T::DbWeight::get().reads(6 as Weight)) - .saturating_add(T::DbWeight::get().writes(5 as Weight)) + // Storage: System Account (r:2 w:2) + // Storage: MarketCommons MarketPool (r:1 w:1) + // Storage: Swaps Pools (r:1 w:1) + // Storage: Tokens Accounts (r:2 w:2) + // Storage: Tokens TotalIssuance (r:2 w:2) + // Storage: PredictionMarkets Disputes (r:1 w:1) + // Storage: PredictionMarkets MarketIdsPerDisputeBlock (r:1 w:1) + fn admin_destroy_disputed_market(a: u32, d: u32, o: u32, c: u32, _r: u32) -> Weight { + (0 as Weight) + // Standard Error: 318_000 + .saturating_add((31_645_000 as Weight).saturating_mul(a as Weight)) + // Standard Error: 9_694_000 + .saturating_add((144_955_000 as Weight).saturating_mul(d as Weight)) + // Standard Error: 312_000 + .saturating_add((9_290_000 as Weight).saturating_mul(o as Weight)) + // Standard Error: 312_000 + .saturating_add((3_632_000 as Weight).saturating_mul(c as Weight)) + .saturating_add(T::DbWeight::get().reads(9 as Weight)) + .saturating_add(T::DbWeight::get().reads((2 as Weight).saturating_mul(a as Weight))) + .saturating_add(T::DbWeight::get().writes(9 as Weight)) + .saturating_add(T::DbWeight::get().writes((2 as Weight).saturating_mul(a as Weight))) } // Storage: unknown [0x3a7472616e73616374696f6e5f6c6576656c3a] (r:1 w:1) // Storage: MarketCommons Markets (r:1 w:1) // Storage: Balances Reserves (r:1 w:1) - // Storage: System Account (r:1 w:0) - // Storage: MarketCommons MarketPool (r:1 w:0) + // Storage: System Account (r:2 w:2) + // Storage: MarketCommons MarketPool (r:1 w:1) + // Storage: Swaps Pools (r:1 w:1) + // Storage: Tokens Accounts (r:2 w:2) + // Storage: Tokens TotalIssuance (r:2 w:2) // Storage: PredictionMarkets MarketIdsPerReportBlock (r:1 w:1) // Storage: PredictionMarkets Disputes (r:0 w:1) - fn admin_destroy_reported_market() -> Weight { - (92_194_000 as Weight) - .saturating_add(T::DbWeight::get().reads(6 as Weight)) - .saturating_add(T::DbWeight::get().writes(5 as Weight)) + fn admin_destroy_reported_market(a: u32, o: u32, c: u32, _r: u32) -> Weight { + (123_003_000 as Weight) + // Standard Error: 31_000 + .saturating_add((21_899_000 as Weight).saturating_mul(a as Weight)) + // Standard Error: 31_000 + .saturating_add((26_000 as Weight).saturating_mul(o as Weight)) + // Standard Error: 31_000 + .saturating_add((43_000 as Weight).saturating_mul(c as Weight)) + .saturating_add(T::DbWeight::get().reads(8 as Weight)) + .saturating_add(T::DbWeight::get().reads((2 as Weight).saturating_mul(a as Weight))) + .saturating_add(T::DbWeight::get().writes(9 as Weight)) + .saturating_add(T::DbWeight::get().writes((2 as Weight).saturating_mul(a as Weight))) } // Storage: unknown [0x3a7472616e73616374696f6e5f6c6576656c3a] (r:1 w:1) // Storage: MarketCommons Markets (r:1 w:1) @@ -121,13 +148,64 @@ impl WeightInfoZeitgeist for WeightInfo { // Storage: Balances Reserves (r:1 w:1) // Storage: PredictionMarkets Disputes (r:1 w:1) // Storage: MarketCommons MarketPool (r:1 w:0) - fn admin_move_market_to_resolved_overhead() -> Weight { - (76_394_000 as Weight) + fn admin_move_market_to_resolved_scalar_reported(r: u32) -> Weight { + (60_876_000 as Weight) + // Standard Error: 0 + .saturating_add((24_000 as Weight).saturating_mul(r as Weight)) .saturating_add(T::DbWeight::get().reads(6 as Weight)) .saturating_add(T::DbWeight::get().writes(5 as Weight)) } // Storage: unknown [0x3a7472616e73616374696f6e5f6c6576656c3a] (r:1 w:1) // Storage: MarketCommons Markets (r:1 w:1) + // Storage: PredictionMarkets MarketIdsPerReportBlock (r:1 w:1) + // Storage: Balances Reserves (r:1 w:1) + // Storage: PredictionMarkets Disputes (r:1 w:1) + // Storage: MarketCommons MarketPool (r:1 w:0) + // Storage: Swaps Pools (r:1 w:1) + fn admin_move_market_to_resolved_categorical_reported(_r: u32) -> Weight { + (89_856_000 as Weight) + .saturating_add(T::DbWeight::get().reads(7 as Weight)) + .saturating_add(T::DbWeight::get().writes(6 as Weight)) + } + // Storage: unknown [0x3a7472616e73616374696f6e5f6c6576656c3a] (r:1 w:1) + // Storage: MarketCommons Markets (r:1 w:1) + // Storage: PredictionMarkets Disputes (r:1 w:1) + // Storage: PredictionMarkets MarketIdsPerDisputeBlock (r:1 w:1) + // Storage: Balances Reserves (r:7 w:7) + // Storage: Authorized AuthorizedOutcomeReports (r:1 w:0) + // Storage: System Account (r:6 w:6) + // Storage: MarketCommons MarketPool (r:1 w:0) + fn admin_move_market_to_resolved_scalar_disputed(_r: u32, d: u32) -> Weight { + (74_775_000 as Weight) + // Standard Error: 19_000 + .saturating_add((21_503_000 as Weight).saturating_mul(d as Weight)) + .saturating_add(T::DbWeight::get().reads(7 as Weight)) + .saturating_add(T::DbWeight::get().reads((2 as Weight).saturating_mul(d as Weight))) + .saturating_add(T::DbWeight::get().writes(5 as Weight)) + .saturating_add(T::DbWeight::get().writes((2 as Weight).saturating_mul(d as Weight))) + } + // Storage: unknown [0x3a7472616e73616374696f6e5f6c6576656c3a] (r:1 w:1) + // Storage: MarketCommons Markets (r:1 w:1) + // Storage: PredictionMarkets Disputes (r:1 w:1) + // Storage: PredictionMarkets MarketIdsPerDisputeBlock (r:1 w:1) + // Storage: Balances Reserves (r:7 w:7) + // Storage: Authorized AuthorizedOutcomeReports (r:1 w:0) + // Storage: System Account (r:6 w:6) + // Storage: MarketCommons MarketPool (r:1 w:0) + // Storage: Swaps Pools (r:1 w:1) + fn admin_move_market_to_resolved_categorical_disputed(r: u32, d: u32) -> Weight { + (93_717_000 as Weight) + // Standard Error: 1_000 + .saturating_add((46_000 as Weight).saturating_mul(r as Weight)) + // Standard Error: 18_000 + .saturating_add((23_705_000 as Weight).saturating_mul(d as Weight)) + .saturating_add(T::DbWeight::get().reads(8 as Weight)) + .saturating_add(T::DbWeight::get().reads((2 as Weight).saturating_mul(d as Weight))) + .saturating_add(T::DbWeight::get().writes(6 as Weight)) + .saturating_add(T::DbWeight::get().writes((2 as Weight).saturating_mul(d as Weight))) + } + // Storage: unknown [0x3a7472616e73616374696f6e5f6c6576656c3a] (r:1 w:1) + // Storage: MarketCommons Markets (r:1 w:1) // Storage: Balances Reserves (r:1 w:1) fn approve_market() -> Weight { (43_342_000 as Weight)