Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Remove admin_destroy_market #1145

Merged
merged 1 commit into from
Oct 17, 2023
Merged

Remove admin_destroy_market #1145

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
137 changes: 0 additions & 137 deletions zrml/prediction-markets/src/benchmarks.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -227,143 +227,6 @@ benchmarks! {
From<<T as zrml_market_commons::Config>::MarketId>,
}

admin_destroy_disputed_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::<T>(
a,
OutcomeReport::Categorical(0u16),
)?;

<zrml_market_commons::Pallet::<T>>::mutate_market(&market_id, |market| {
market.dispute_mechanism = Some(MarketDisputeMechanism::Authorized);
Ok(())
})?;

let pool_id = <zrml_market_commons::Pallet::<T>>::market_pool(&market_id)?;

let disputor = account("disputor", 1, 0);
<T as pallet::Config>::AssetManager::deposit(
Asset::Ztg,
&disputor,
u128::MAX.saturated_into(),
).unwrap();
let _ = Pallet::<T>::dispute(RawOrigin::Signed(disputor).into(), market_id)?;

let market = <zrml_market_commons::Pallet::<T>>::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 {
// shift of 1 to avoid collisions with first market id 0
MarketIdsPerOpenTimeFrame::<T>::try_mutate(
Pallet::<T>::calculate_time_frame_of_moment(range_start),
|ids| ids.try_push((i + 1).into()),
).unwrap();
}

for i in 0..c {
// shift of 65 to avoid collisions with `o`
MarketIdsPerCloseTimeFrame::<T>::try_mutate(
Pallet::<T>::calculate_time_frame_of_moment(range_end),
|ids| ids.try_push((i + 65).into()),
).unwrap();
}

AuthorizedPallet::<T>::authorize_market_outcome(
T::AuthorizedDisputeResolutionOrigin::try_successful_origin().unwrap(),
market_id.into(),
OutcomeReport::Categorical(0u16),
)?;

let now = <frame_system::Pallet<T>>::block_number();
let resolves_at = now.saturating_add(<T as zrml_authorized::Config>::CorrectionPeriod::get());
for i in 0..r {
// shift of 129 to avoid collisions with `o` and `c`
MarketIdsPerDisputeBlock::<T>::try_mutate(
resolves_at,
|ids| ids.try_push((i + 129).into()),
).unwrap();
}

let destroy_origin = T::DestroyOrigin::try_successful_origin().unwrap();
let call = Call::<T>::admin_destroy_market { market_id };
}: {
call.dispatch_bypass_filter(destroy_origin)?
} verify {
assert_last_event::<T>(Event::MarketDestroyed::<T>(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::<T>(
a,
OutcomeReport::Categorical(0u16),
)?;

let pool_id = <zrml_market_commons::Pallet::<T>>::market_pool(&market_id)?;

let market = <zrml_market_commons::Pallet::<T>>::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 {
// shift of 1 to avoid collisions with first market id 0
MarketIdsPerOpenTimeFrame::<T>::try_mutate(
Pallet::<T>::calculate_time_frame_of_moment(range_start),
|ids| ids.try_push((i + 1).into()),
).unwrap();
}

for i in 0..c {
// shift of 65 to avoid collisions with `o`
MarketIdsPerCloseTimeFrame::<T>::try_mutate(
Pallet::<T>::calculate_time_frame_of_moment(range_end),
|ids| ids.try_push((i + 65).into()),
).unwrap();
}

let report_at = market.report.unwrap().at;
let resolves_at = report_at.saturating_add(market.deadlines.dispute_duration);
for i in 0..r {
// shift of 129 to avoid collisions with `o` and `c`
MarketIdsPerReportBlock::<T>::try_mutate(
resolves_at,
|ids| ids.try_push((i + 129).into()),
).unwrap();
}

let destroy_origin = T::DestroyOrigin::try_successful_origin().unwrap();
let call = Call::<T>::admin_destroy_market { market_id };
}: {
call.dispatch_bypass_filter(destroy_origin)?
} verify {
assert_last_event::<T>(Event::MarketDestroyed::<T>(
market_id,
).into());
}

admin_move_market_to_closed {
let o in 0..63;
let c in 0..63;
Expand Down
138 changes: 1 addition & 137 deletions zrml/prediction-markets/src/lib.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -271,6 +271,7 @@ mod pallet {
/// in case the bond is not present or already settled.
///
/// Return `true` if the bond is present and not settled, `false` otherwise.
#[allow(unused)]
fn $fn_name(
market_id: &MarketIdOf<T>,
market: &MarketOf<T>,
Expand Down Expand Up @@ -305,110 +306,6 @@ mod pallet {

#[pallet::call]
impl<T: Config> Pallet<T> {
/// Destroy a market, including its outcome assets, market account and pool account.
///
/// Must be called by `DestroyOrigin`. Bonds (unless already returned) are slashed without
/// exception. Can currently only be used for destroying CPMM markets.
#[pallet::call_index(0)]
#[pallet::weight((
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(),
CacheSize::get(),
CacheSize::get(),
CacheSize::get(),
)),
Pays::No,
))]
#[transactional]
pub fn admin_destroy_market(
origin: OriginFor<T>,
#[pallet::compact] market_id: MarketIdOf<T>,
) -> DispatchResultWithPostInfo {
// TODO(#618): Not implemented for Rikiddo!
T::DestroyOrigin::ensure_origin(origin)?;

let market = <zrml_market_commons::Pallet<T>>::market(&market_id)?;
ensure!(
matches!(market.scoring_rule, ScoringRule::CPMM | ScoringRule::Orderbook),
Error::<T>::InvalidScoringRule
);
let market_status = market.status;
let market_account = <zrml_market_commons::Pallet<T>>::market_account(market_id);

// Slash outstanding bonds; see
// https://github.com/zeitgeistpm/runtime-audit-1/issues/34#issuecomment-1120187097 for
// details.
Self::slash_pending_bonds(&market_id, &market)?;

if market_status == MarketStatus::Proposed {
MarketIdsForEdit::<T>::remove(market_id);
}

if T::GlobalDisputes::is_active(&market_id) {
T::GlobalDisputes::destroy_global_dispute(&market_id)?;
}

// NOTE: Currently we don't clean up outcome assets.
// TODO(#792): Remove outcome assets for accounts! Delete "resolved" assets of `orml_tokens` with storage migration.
T::AssetManager::slash(
market.base_asset,
&market_account,
T::AssetManager::free_balance(market.base_asset, &market_account),
);
let mut category_count = 0u32;
if let Ok(pool_id) = <zrml_market_commons::Pallet<T>>::market_pool(&market_id) {
let pool = T::Swaps::pool(pool_id)?;
category_count = pool.assets.len().saturated_into();
let _ = T::Swaps::destroy_pool(pool_id)?;
<zrml_market_commons::Pallet<T>>::remove_market_pool(&market_id)?;
}

let open_ids_len = Self::clear_auto_open(&market_id)?;
let close_ids_len = Self::clear_auto_close(&market_id)?;
// Note: This is noop if the market is trusted.
let (ids_len, _) = Self::clear_auto_resolve(&market_id)?;
if market.dispute_mechanism.is_some() {
Self::clear_dispute_mechanism(&market_id)?;
}
<zrml_market_commons::Pallet<T>>::remove_market(&market_id)?;

Self::deposit_event(Event::MarketDestroyed(market_id));

// 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(
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(
category_count,
open_ids_len,
close_ids_len,
ids_len,
)),
Pays::No,
)
.into())
} else {
Ok((Option::<Weight>::None, Pays::No).into())
}
}

/// Allows the `CloseOrigin` to immediately move an open market to closed.
///
/// # Weight
Expand Down Expand Up @@ -2039,22 +1936,6 @@ mod pallet {
impl_is_bond_pending!(is_outsider_bond_pending, outsider);
impl_is_bond_pending!(is_dispute_bond_pending, dispute);

fn slash_pending_bonds(market_id: &MarketIdOf<T>, market: &MarketOf<T>) -> DispatchResult {
if Self::is_creation_bond_pending(market_id, market, false) {
Self::slash_creation_bond(market_id, None)?;
}
if Self::is_oracle_bond_pending(market_id, market, false) {
Self::slash_oracle_bond(market_id, None)?;
}
if Self::is_outsider_bond_pending(market_id, market, false) {
Self::slash_outsider_bond(market_id, None)?;
}
if Self::is_dispute_bond_pending(market_id, market, false) {
Self::slash_dispute_bond(market_id, None)?;
}
Ok(())
}

#[require_transactional]
fn do_create_market(
who: T::AccountId,
Expand Down Expand Up @@ -2272,23 +2153,6 @@ mod pallet {
Ok((ids_len, mdm_len))
}

/// The dispute mechanism is intended to clear its own storage here.
fn clear_dispute_mechanism(market_id: &MarketIdOf<T>) -> DispatchResult {
let market = <zrml_market_commons::Pallet<T>>::market(market_id)?;
let dispute_mechanism =
market.dispute_mechanism.as_ref().ok_or(Error::<T>::NoDisputeMechanism)?;

// TODO(#782): use multiple benchmarks paths for different dispute mechanisms
match dispute_mechanism {
MarketDisputeMechanism::Authorized => T::Authorized::clear(market_id, &market)?,
MarketDisputeMechanism::Court => T::Court::clear(market_id, &market)?,
MarketDisputeMechanism::SimpleDisputes => {
T::SimpleDisputes::clear(market_id, &market)?
}
};
Ok(())
}

#[require_transactional]
pub(crate) fn do_sell_complete_set(
who: T::AccountId,
Expand Down
Loading
Loading