ZIP-0 Part II

zrml/prediction-markets/src/lib.rs

@@ -534,24 +534,13 @@ mod pallet {
         pub fn dispute(
             origin: OriginFor<T>,
             #[pallet::compact] market_id: MarketIdOf<T>,
-            outcome: OutcomeReport,
         ) -> DispatchResultWithPostInfo {
             let who = ensure_signed(origin)?;
-            let disputes = Disputes::<T>::get(market_id);
+
             let curr_block_num = <frame_system::Pallet<T>>::block_number();
             let market = <zrml_market_commons::Pallet<T>>::market(&market_id)?;
-            ensure!(
-                matches!(market.status, MarketStatus::Reported | MarketStatus::Disputed),
-                Error::<T>::InvalidMarketStatus
-            );
-            let num_disputes: u32 = disputes.len().saturated_into();
-            Self::validate_dispute(&disputes, &market, num_disputes, &outcome)?;
-            T::AssetManager::reserve_named(
-                &Self::reserve_id(),
-                Asset::Ztg,
-                &who,
-                default_dispute_bond::<T>(disputes.len()),
-            )?;
+            ensure!(market.status == MarketStatus::Reported, Error::<T>::InvalidMarketStatus);
+
             match market.dispute_mechanism {
                 MarketDisputeMechanism::Authorized => {
                     T::Authorized::on_dispute(&disputes, &market_id, &market)?
@@ -563,12 +552,10 @@ mod pallet {
                     T::SimpleDisputes::on_dispute(&disputes, &market_id, &market)?
                 }
             }
+
             Self::remove_last_dispute_from_market_ids_per_dispute_block(&disputes, &market_id)?;
             Self::set_market_as_disputed(&market, &market_id)?;
-            let market_dispute = MarketDispute { at: curr_block_num, by: who, outcome };
-            <Disputes<T>>::try_mutate(market_id, |disputes| {
-                disputes.try_push(market_dispute.clone()).map_err(|_| <Error<T>>::StorageOverflow)
-            })?;
+
             // each dispute resets dispute_duration
             let dispute_duration_ends_at_block =
                 curr_block_num.saturating_add(market.deadlines.dispute_duration);
@@ -579,7 +566,6 @@ mod pallet {
             Self::deposit_event(Event::MarketDisputed(
                 market_id,
                 MarketStatus::Disputed,
-                market_dispute,
             ));
             // TODO(#782): add court benchmark
             Ok((Some(T::WeightInfo::dispute_authorized(num_disputes, CacheSize::get()))).into())
@@ -1441,15 +1427,6 @@ mod pallet {
         /// The origin that is allowed to destroy markets.
         type DestroyOrigin: EnsureOrigin<Self::Origin>;
 
-        /// The base amount of currency that must be bonded in order to create a dispute.
-        #[pallet::constant]
-        type DisputeBond: Get<BalanceOf<Self>>;
-
-        /// The additional amount of currency that must be bonded when creating a subsequent
-        /// dispute.
-        #[pallet::constant]
-        type DisputeFactor: Get<BalanceOf<Self>>;
-
         /// Event
         type Event: From<Event<Self>> + IsType<<Self as frame_system::Config>::Event>;
 
@@ -1692,7 +1669,7 @@ mod pallet {
         /// A market has been closed \[market_id\]
         MarketClosed(MarketIdOf<T>),
         /// A market has been disputed \[market_id, new_market_status, new_outcome\]
-        MarketDisputed(MarketIdOf<T>, MarketStatus, MarketDispute<T::AccountId, T::BlockNumber>),
+        MarketDisputed(MarketIdOf<T>, MarketStatus),
         /// An advised market has ended before it was approved or rejected. \[market_id\]
         MarketExpired(MarketIdOf<T>),
         /// A pending market has been rejected as invalid with a reason. \[market_id, reject_reason\]
@@ -1837,17 +1814,6 @@ mod pallet {
     #[pallet::storage_version(STORAGE_VERSION)]
     pub struct Pallet<T>(PhantomData<T>);
 
-    /// For each market, this holds the dispute information for each dispute that's
-    /// been issued.
-    #[pallet::storage]
-    pub type Disputes<T: Config> = StorageMap<
-        _,
-        Blake2_128Concat,
-        MarketIdOf<T>,
-        BoundedVec<MarketDispute<T::AccountId, T::BlockNumber>, T::MaxDisputes>,
-        ValueQuery,
-    >;
-
     #[pallet::storage]
     pub type MarketIdsPerOpenBlock<T: Config> = StorageMap<
         _,
@@ -2149,26 +2115,6 @@ mod pallet {
             }
         }
 
-        fn ensure_can_not_dispute_the_same_outcome(
-            disputes: &[MarketDispute<T::AccountId, T::BlockNumber>],
-            report: &Report<T::AccountId, T::BlockNumber>,
-            outcome: &OutcomeReport,
-        ) -> DispatchResult {
-            if let Some(last_dispute) = disputes.last() {
-                ensure!(&last_dispute.outcome != outcome, Error::<T>::CannotDisputeSameOutcome);
-            } else {
-                ensure!(&report.outcome != outcome, Error::<T>::CannotDisputeSameOutcome);
-            }
-
-            Ok(())
-        }
-
-        #[inline]
-        fn ensure_disputes_does_not_exceed_max_disputes(num_disputes: u32) -> DispatchResult {
-            ensure!(num_disputes < T::MaxDisputes::get(), Error::<T>::MaxDisputesReached);
-            Ok(())
-        }
-
         fn ensure_market_is_active(market: &MarketOf<T>) -> DispatchResult {
             ensure!(market.status == MarketStatus::Active, Error::<T>::MarketIsNotActive);
             Ok(())
@@ -2806,19 +2752,6 @@ mod pallet {
             Ok(T::WeightInfo::start_subsidy(total_assets.saturated_into()))
         }
 
-        fn validate_dispute(
-            disputes: &[MarketDispute<T::AccountId, T::BlockNumber>],
-            market: &MarketOf<T>,
-            num_disputes: u32,
-            outcome_report: &OutcomeReport,
-        ) -> DispatchResult {
-            let report = market.report.as_ref().ok_or(Error::<T>::MarketIsNotReported)?;
-            ensure!(market.matches_outcome_report(outcome_report), Error::<T>::OutcomeMismatch);
-            Self::ensure_can_not_dispute_the_same_outcome(disputes, report, outcome_report)?;
-            Self::ensure_disputes_does_not_exceed_max_disputes(num_disputes)?;
-            Ok(())
-        }
-
         fn construct_market(
             creator: T::AccountId,
             creator_fee: u8,

zrml/simple-disputes/Cargo.toml

@@ -7,6 +7,7 @@ scale-info = { version = "2.1.1", default-features = false, features = ["derive"
 sp-runtime = { branch = "polkadot-v0.9.26", default-features = false, git = "https://github.com/paritytech/substrate" }
 zeitgeist-primitives = { default-features = false, path = "../../primitives" }
 zrml-market-commons = { default-features = false, path = "../market-commons" }
+orml-traits = { branch = "polkadot-v0.9.26", default-features = false, git = "https://github.com/open-web3-stack/open-runtime-module-library" }
 
 [dev-dependencies]
 pallet-balances = { branch = "polkadot-v0.9.26", git = "https://github.com/paritytech/substrate" }

zrml/simple-disputes/src/lib.rs

@@ -31,68 +31,195 @@ pub use simple_disputes_pallet_api::SimpleDisputesPalletApi;
 mod pallet {
     use crate::SimpleDisputesPalletApi;
     use core::marker::PhantomData;
+    use frame_system::pallet_prelude::*;
     use frame_support::{
         dispatch::DispatchResult,
         traits::{Currency, Get, Hooks, IsType},
         PalletId,
+        pallet_prelude::*,
+        transactional,
     };
     use sp_runtime::DispatchError;
     use zeitgeist_primitives::{
         traits::DisputeApi,
-        types::{Market, MarketDispute, MarketDisputeMechanism, MarketStatus, OutcomeReport},
+        types::{Report, Asset, Market, MarketDispute, MarketDisputeMechanism, MarketStatus, OutcomeReport},
     };
+    use sp_runtime::traits::Saturating;
+    use sp_runtime::SaturatedConversion;
+    use zeitgeist_primitives::traits::ZeitgeistAssetManager;
     use zrml_market_commons::MarketCommonsPalletApi;
-
-    type BalanceOf<T> =
-        <CurrencyOf<T> as Currency<<T as frame_system::Config>::AccountId>>::Balance;
-    pub(crate) type CurrencyOf<T> =
-        <<T as Config>::MarketCommons as MarketCommonsPalletApi>::Currency;
-    pub(crate) type MarketIdOf<T> =
-        <<T as Config>::MarketCommons as MarketCommonsPalletApi>::MarketId;
-    pub(crate) type MomentOf<T> = <<T as Config>::MarketCommons as MarketCommonsPalletApi>::Moment;
-    pub(crate) type MarketOf<T> = Market<
-        <T as frame_system::Config>::AccountId,
-        BalanceOf<T>,
-        <T as frame_system::Config>::BlockNumber,
-        MomentOf<T>,
-    >;
-
-    #[pallet::call]
-    impl<T: Config> Pallet<T> {}
+    use orml_traits::currency::NamedMultiReservableCurrency;
 
     #[pallet::config]
     pub trait Config: frame_system::Config {
+        /// Shares of outcome assets and native currency
+        type AssetManager: ZeitgeistAssetManager<
+            Self::AccountId,
+            Balance = <CurrencyOf<Self> as Currency<Self::AccountId>>::Balance,
+            CurrencyId = Asset<MarketIdOf<Self>>,
+            ReserveIdentifier = [u8; 8],
+        >;
+
         /// Event
         type Event: From<Event<Self>> + IsType<<Self as frame_system::Config>::Event>;
 
+        /// The base amount of currency that must be bonded in order to create a dispute.
+        #[pallet::constant]
+        type DisputeBond: Get<BalanceOf<Self>>;
+
+        /// The additional amount of currency that must be bonded when creating a subsequent
+        /// dispute.
+        #[pallet::constant]
+        type DisputeFactor: Get<BalanceOf<Self>>;
+
         /// The identifier of individual markets.
         type MarketCommons: MarketCommonsPalletApi<
             AccountId = Self::AccountId,
             BlockNumber = Self::BlockNumber,
         >;
 
+        /// The maximum number of disputes allowed on any single market.
+        #[pallet::constant]
+        type MaxDisputes: Get<u32>;
+
         /// The pallet identifier.
         #[pallet::constant]
         type PalletId: Get<PalletId>;
+
+        #[pallet::constant]
+        type PredictionMarketsPalletId: Get<PalletId>;
     }
 
+    type BalanceOf<T> =
+    <CurrencyOf<T> as Currency<<T as frame_system::Config>::AccountId>>::Balance;
+    pub(crate) type CurrencyOf<T> =
+        <<T as Config>::MarketCommons as MarketCommonsPalletApi>::Currency;
+    pub(crate) type MarketIdOf<T> =
+        <<T as Config>::MarketCommons as MarketCommonsPalletApi>::MarketId;
+    pub(crate) type MomentOf<T> = <<T as Config>::MarketCommons as MarketCommonsPalletApi>::Moment;
+    pub(crate) type MarketOf<T> = Market<
+        <T as frame_system::Config>::AccountId,
+        BalanceOf<T>,
+        <T as frame_system::Config>::BlockNumber,
+        MomentOf<T>,
+    >;
+
+    #[pallet::pallet]
+    pub struct Pallet<T>(PhantomData<T>);
+
+    /// For each market, this holds the dispute information for each dispute that's
+    /// been issued.
+    #[pallet::storage]
+    pub type Disputes<T: Config> = StorageMap<
+        _,
+        Blake2_128Concat,
+        MarketIdOf<T>,
+        BoundedVec<MarketDispute<T::AccountId, T::BlockNumber>, T::MaxDisputes>,
+        ValueQuery,
+    >;
+
+    #[pallet::event]
+    #[pallet::generate_deposit(fn deposit_event)]
+    pub enum Event<T>
+    where
+        T: Config, {
+            OutcomeReserved { market_id: MarketIdOf<T>, dispute: MarketDispute<T::AccountId, T::BlockNumber> },
+        }
+
     #[pallet::error]
     pub enum Error<T> {
         /// 1. Any resolution must either have a `Disputed` or `Reported` market status
         /// 2. If status is `Disputed`, then at least one dispute must exist
         InvalidMarketStatus,
         /// On dispute or resolution, someone tried to pass a non-simple-disputes market type
         MarketDoesNotHaveSimpleDisputesMechanism,
+        StorageOverflow,
+        OutcomeMismatch,
+        CannotDisputeSameOutcome,
+        MarketIsNotReported,
+        MaxDisputesReached,
     }
 
-    #[pallet::event]
-    pub enum Event<T>
-    where
-        T: Config, {}
-
     #[pallet::hooks]
     impl<T: Config> Hooks<T::BlockNumber> for Pallet<T> {}
 
+    #[pallet::call]
+    impl<T: Config> Pallet<T> {
+        #[pallet::weight(5000)]
+        #[transactional]
+        pub fn reserve_outcome(
+            origin: OriginFor<T>,
+            #[pallet::compact] market_id: MarketIdOf<T>,
+            outcome: OutcomeReport,
+        ) -> DispatchResultWithPostInfo {
+            let who = ensure_signed(origin)?;
+            let market = T::MarketCommons::market(&market_id)?;
+            ensure!(
+                market.dispute_mechanism == MarketDisputeMechanism::SimpleDisputes,
+                Error::<T>::MarketDoesNotHaveSimpleDisputesMechanism
+            );
+            ensure!(
+                market.status == MarketStatus::Disputed,
+                Error::<T>::InvalidMarketStatus
+            );
+            ensure!(market.matches_outcome_report(&outcome), Error::<T>::OutcomeMismatch);
+            let report = market.report.as_ref().ok_or(Error::<T>::MarketIsNotReported)?;
+
+            let now = <frame_system::Pallet<T>>::block_number();
+            let disputes = Disputes::<T>::get(&market_id);
+            let num_disputes: u32 = disputes.len().saturated_into();
+
+            Self::ensure_can_not_dispute_the_same_outcome(&disputes, report, &outcome)?;
+            Self::ensure_disputes_does_not_exceed_max_disputes(num_disputes)?;
+
+            T::AssetManager::reserve_named(
+                &Self::reserve_id(),
+                Asset::Ztg,
+                &who,
+                default_dispute_bond::<T>(disputes.len()),
+            )?;
+
+            let market_dispute = MarketDispute { at: now, by: who, outcome };
+            <Disputes<T>>::try_mutate(market_id, |disputes| {
+                disputes.try_push(market_dispute.clone()).map_err(|_| <Error<T>>::StorageOverflow)
+            })?;
+
+            Self::deposit_event(Event::OutcomeReserved {
+                market_id,
+                dispute: market_dispute,
+            });
+
+            Ok((Some(5000)).into())
+        }
+    }
+
+    impl<T: Config> Pallet<T> {
+        #[inline]
+        pub fn reserve_id() -> [u8; 8] {
+            T::PredictionMarketsPalletId::get().0
+        }
+
+        fn ensure_can_not_dispute_the_same_outcome(
+            disputes: &[MarketDispute<T::AccountId, T::BlockNumber>],
+            report: &Report<T::AccountId, T::BlockNumber>,
+            outcome: &OutcomeReport,
+        ) -> DispatchResult {
+            if let Some(last_dispute) = disputes.last() {
+                ensure!(&last_dispute.outcome != outcome, Error::<T>::CannotDisputeSameOutcome);
+            } else {
+                ensure!(&report.outcome != outcome, Error::<T>::CannotDisputeSameOutcome);
+            }
+
+            Ok(())
+        }
+
+        #[inline]
+        fn ensure_disputes_does_not_exceed_max_disputes(num_disputes: u32) -> DispatchResult {
+            ensure!(num_disputes < T::MaxDisputes::get(), Error::<T>::MaxDisputesReached);
+            Ok(())
+        }
+    }
+
     impl<T> DisputeApi for Pallet<T>
     where
         T: Config,
@@ -137,6 +264,13 @@ mod pallet {
 
     impl<T> SimpleDisputesPalletApi for Pallet<T> where T: Config {}
 
-    #[pallet::pallet]
-    pub struct Pallet<T>(PhantomData<T>);
+    // No-one can bound more than BalanceOf<T>, therefore, this functions saturates
+    pub(crate) fn default_dispute_bond<T>(n: usize) -> BalanceOf<T>
+    where
+        T: Config,
+    {
+        T::DisputeBond::get().saturating_add(
+            T::DisputeFactor::get().saturating_mul(n.saturated_into::<u32>().into()),
+        )
+    }
 }