ZIP-0 Part II

primitives/src/constants/mock.rs

@@ -40,8 +40,7 @@ parameter_types! {
 // Prediction Market parameters
 parameter_types! {
     pub const AdvisoryBond: Balance = 25 * CENT;
-    pub const DisputeBond: Balance = 5 * BASE;
-    pub const DisputeFactor: Balance = 2 * BASE;
+    pub const DisputeBond: Balance = 20 * BASE;
     pub const GlobalDisputePeriod: BlockNumber = 7 * BLOCKS_PER_DAY;
     pub const MaxCategories: u16 = 10;
     pub const MaxDisputes: u16 = 6;
@@ -66,6 +65,8 @@ parameter_types! {
 // Simple disputes parameters
 parameter_types! {
     pub const SimpleDisputesPalletId: PalletId = PalletId(*b"zge/sedp");
+    pub const OutcomeBond: Balance = 5 * BASE;
+    pub const OutcomeFactor: Balance = 2 * BASE;
 }
 
 // Swaps parameters

primitives/src/market.rs

@@ -83,6 +83,7 @@ impl<AI, BA> Bond<AI, BA> {
 pub struct MarketBonds<AI, BA> {
     pub creation: Option<Bond<AI, BA>>,
     pub oracle: Option<Bond<AI, BA>>,
+    pub dispute: Option<Bond<AI, BA>>,
 }
 
 impl<AI: Ord, BA: frame_support::traits::tokens::Balance> MarketBonds<AI, BA> {
@@ -92,14 +93,16 @@ impl<AI: Ord, BA: frame_support::traits::tokens::Balance> MarketBonds<AI, BA> {
             Some(bond) if bond.who == *who => bond.value,
             _ => BA::zero(),
         };
-        value_or_default(&self.creation).saturating_add(value_or_default(&self.oracle))
+        value_or_default(&self.creation)
+            .saturating_add(value_or_default(&self.oracle))
+            .saturating_add(value_or_default(&self.dispute))
     }
 }
 
 // Used primarily for testing purposes.
 impl<AI, BA> Default for MarketBonds<AI, BA> {
     fn default() -> Self {
-        MarketBonds { creation: None, oracle: None }
+        MarketBonds { creation: None, oracle: None, dispute: None }
     }
 }
 
@@ -166,13 +169,22 @@ pub enum MarketCreation {
     Advised,
 }
 
+// TODO to remove, when Disputes storage item is removed
 #[derive(Clone, Decode, Encode, Eq, MaxEncodedLen, PartialEq, RuntimeDebug, TypeInfo)]
-pub struct MarketDispute<AccountId, BlockNumber> {
+pub struct OldMarketDispute<AccountId, BlockNumber> {
     pub at: BlockNumber,
     pub by: AccountId,
     pub outcome: OutcomeReport,
 }
 
+#[derive(Clone, Decode, Encode, Eq, MaxEncodedLen, PartialEq, RuntimeDebug, TypeInfo)]
+pub struct MarketDispute<AccountId, BlockNumber, Balance> {
+    pub at: BlockNumber,
+    pub by: AccountId,
+    pub outcome: OutcomeReport,
+    pub bond: Balance,
+}
+
 /// How a market should resolve disputes
 #[derive(Clone, Decode, Encode, Eq, MaxEncodedLen, PartialEq, RuntimeDebug, TypeInfo)]
 pub enum MarketDisputeMechanism {

primitives/src/traits/dispute_api.rs

@@ -15,8 +15,8 @@
 // You should have received a copy of the GNU General Public License
 // along with Zeitgeist. If not, see <https://www.gnu.org/licenses/>.
 
-use crate::{market::MarketDispute, outcome_report::OutcomeReport, types::Market};
-use frame_support::{dispatch::DispatchResult, pallet_prelude::Weight, BoundedVec};
+use crate::{outcome_report::OutcomeReport, types::Market};
+use frame_support::{dispatch::DispatchResult, pallet_prelude::Weight};
 use sp_runtime::DispatchError;
 
 // Abstraction of the market type, which is not a part of `DisputeApi` because Rust doesn't support
@@ -40,11 +40,7 @@ pub trait DisputeApi {
     ///
     /// Further interaction with the dispute API (if necessary) **should** happen through an
     /// associated pallet. **May** assume that `market.dispute_mechanism` refers to the calling dispute API.
-    fn on_dispute(
-        previous_disputes: &[MarketDispute<Self::AccountId, Self::BlockNumber>],
-        market_id: &Self::MarketId,
-        market: &MarketOfDisputeApi<Self>,
-    ) -> DispatchResult;
+    fn on_dispute(market_id: &Self::MarketId, market: &MarketOfDisputeApi<Self>) -> DispatchResult;
 
     /// Manage market resolution of a disputed market.
     ///
@@ -56,7 +52,6 @@ pub trait DisputeApi {
     /// Returns the dispute mechanism's report if available, otherwise `None`. If `None` is
     /// returned, this means that the dispute could not be resolved.
     fn on_resolution(
-        disputes: &[MarketDispute<Self::AccountId, Self::BlockNumber>],
         market_id: &Self::MarketId,
         market: &MarketOfDisputeApi<Self>,
     ) -> Result<Option<OutcomeReport>, DispatchError>;
@@ -68,7 +63,6 @@ pub trait DisputeApi {
     ///
     /// Returns the future resolution block if available, otherwise `None`.
     fn get_auto_resolve(
-        disputes: &[MarketDispute<Self::AccountId, Self::BlockNumber>],
         market_id: &Self::MarketId,
         market: &MarketOfDisputeApi<Self>,
     ) -> Result<Option<Self::BlockNumber>, DispatchError>;
@@ -77,10 +71,20 @@ pub trait DisputeApi {
     /// was unable to come to a conclusion.
     /// **May** assume that `market.dispute_mechanism` refers to the calling dispute API.
     fn has_failed(
-        disputes: &[MarketDispute<Self::AccountId, Self::BlockNumber>],
         market_id: &Self::MarketId,
         market: &MarketOfDisputeApi<Self>,
     ) -> Result<bool, DispatchError>;
+
+    /// Called, when a global dispute is started.
+    /// **May** assume that `market.dispute_mechanism` refers to the calling dispute API.
+    fn on_global_dispute(
+        market_id: &Self::MarketId,
+        market: &MarketOfDisputeApi<Self>,
+    ) -> DispatchResult;
+
+    /// Called, when a market is destroyed.
+    /// **May** assume that `market.dispute_mechanism` refers to the calling dispute API.
+    fn clear(market_id: &Self::MarketId, market: &MarketOfDisputeApi<Self>) -> DispatchResult;
 }
 
 type MarketOfDisputeResolutionApi<T> = Market<
@@ -134,9 +138,4 @@ pub trait DisputeResolutionApi {
     ///
     /// Returns the number of elements in the storage structure.
     fn remove_auto_resolve(market_id: &Self::MarketId, resolve_at: Self::BlockNumber) -> u32;
-
-    /// Get the disputes of a market.
-    fn get_disputes(
-        market_id: &Self::MarketId,
-    ) -> BoundedVec<MarketDispute<Self::AccountId, Self::BlockNumber>, Self::MaxDisputes>;
 }

runtime/battery-station/src/parameters.rs

@@ -149,11 +149,9 @@ parameter_types! {
     pub const AdvisoryBond: Balance = 25 * CENT;
     pub const AdvisoryBondSlashPercentage: Percent = Percent::from_percent(0);
     /// (Slashable) Bond that is provided for disputing the outcome.
-    /// Slashed in case the final outcome does not match the dispute for which the `DisputeBond`
-    /// was deposited.
-    pub const DisputeBond: Balance = 5 * BASE;
-    /// `DisputeBond` is increased by this factor after every dispute.
-    pub const DisputeFactor: Balance = 2 * BASE;
+    /// Unreserved in case the dispute was justified otherwise slashed.
+    /// This is when the resolved outcome is different to the default (reported) outcome.
+    pub const DisputeBond: Balance = 25 * BASE;
     /// Maximum Categories a prediciton market can have (excluding base asset).
     pub const MaxCategories: u16 = MAX_CATEGORIES;
     /// Maximum number of disputes.
@@ -217,6 +215,12 @@ parameter_types! {
     // Simple disputes parameters
     /// Pallet identifier, mainly used for named balance reserves.
     pub const SimpleDisputesPalletId: PalletId = SD_PALLET_ID;
+    /// (Slashable) Bond that is provided for overriding the last outcome addition.
+    /// Slashed in case the final outcome does not match the dispute for which the `OutcomeBond`
+    /// was deposited.
+    pub const OutcomeBond: Balance = 5 * BASE;
+    /// `OutcomeBond` is increased by this factor after every new outcome addition.
+    pub const OutcomeFactor: Balance = 2 * BASE;
 
     // Swaps parameters
     /// A precentage from the withdrawal amount a liquidity provider wants to withdraw

runtime/common/src/lib.rs

@@ -987,7 +987,6 @@ macro_rules! impl_config_traits {
             type CloseOrigin = EnsureRootOrTwoThirdsAdvisoryCommittee;
             type DestroyOrigin = EnsureRootOrAllAdvisoryCommittee;
             type DisputeBond = DisputeBond;
-            type DisputeFactor = DisputeFactor;
             type Event = Event;
             #[cfg(feature = "with-global-disputes")]
             type GlobalDisputes = GlobalDisputes;
@@ -1042,10 +1041,19 @@ macro_rules! impl_config_traits {
         }
 
         impl zrml_simple_disputes::Config for Runtime {
+            type AssetManager = AssetManager;
+            type OutcomeBond = OutcomeBond;
+            type OutcomeFactor = OutcomeFactor;
             type DisputeResolution = zrml_prediction_markets::Pallet<Runtime>;
             type Event = Event;
+            #[cfg(feature = "with-global-disputes")]
+            type GlobalDisputes = GlobalDisputes;
             type MarketCommons = MarketCommons;
+            type MaxDisputes = MaxDisputes;
             type PalletId = SimpleDisputesPalletId;
+            type PredictionMarketsPalletId = PmPalletId;
+            type Slash = Treasury;
+            type WeightInfo = zrml_simple_disputes::weights::WeightInfo<Runtime>;
         }
 
         #[cfg(feature = "with-global-disputes")]

runtime/zeitgeist/src/parameters.rs

@@ -149,11 +149,9 @@ parameter_types! {
     pub const AdvisoryBond: Balance = 200 * BASE;
     pub const AdvisoryBondSlashPercentage: Percent = Percent::from_percent(0);
     /// (Slashable) Bond that is provided for disputing the outcome.
-    /// Slashed in case the final outcome does not match the dispute for which the `DisputeBond`
-    /// was deposited.
-    pub const DisputeBond: Balance = 2_000 * BASE;
-    /// `DisputeBond` is increased by this factor after every dispute.
-    pub const DisputeFactor: Balance = 2 * BASE;
+    /// Unreserved in case the dispute was justified otherwise slashed.
+    /// This is when the resolved outcome is different to the default (reported) outcome.
+    pub const DisputeBond: Balance = 5_000 * BASE;
     /// Maximum Categories a prediciton market can have (excluding base asset).
     pub const MaxCategories: u16 = MAX_CATEGORIES;
     /// Maximum number of disputes.
@@ -217,6 +215,12 @@ parameter_types! {
     // Simple disputes parameters
     /// Pallet identifier, mainly used for named balance reserves. DO NOT CHANGE.
     pub const SimpleDisputesPalletId: PalletId = SD_PALLET_ID;
+    /// (Slashable) Bond that is provided for overriding the last outcome addition.
+    /// Slashed in case the final outcome does not match the dispute for which the `OutcomeBond`
+    /// was deposited.
+    pub const OutcomeBond: Balance = 2_000 * BASE;
+    /// `OutcomeBond` is increased by this factor after every new outcome addition.
+    pub const OutcomeFactor: Balance = 2 * BASE;
 
     // Swaps parameters
     /// A precentage from the withdrawal amount a liquidity provider wants to withdraw

zrml/authorized/src/lib.rs

@@ -46,10 +46,7 @@ mod pallet {
     use sp_runtime::{traits::Saturating, DispatchError};
     use zeitgeist_primitives::{
         traits::{DisputeApi, DisputeResolutionApi},
-        types::{
-            AuthorityReport, Market, MarketDispute, MarketDisputeMechanism, MarketStatus,
-            OutcomeReport,
-        },
+        types::{AuthorityReport, Market, MarketDisputeMechanism, MarketStatus, OutcomeReport},
     };
     use zrml_market_commons::MarketCommonsPalletApi;
 
@@ -99,16 +96,21 @@ mod pallet {
 
             let report_opt = AuthorizedOutcomeReports::<T>::get(market_id);
             let (report, ids_len) = match &report_opt {
-                Some(report) => (AuthorityReport { resolve_at: report.resolve_at, outcome }, 0u32),
+                Some(report) => (
+                    AuthorityReport { resolve_at: report.resolve_at, outcome: outcome.clone() },
+                    0u32,
+                ),
                 None => {
                     let resolve_at = now.saturating_add(T::CorrectionPeriod::get());
                     let ids_len = T::DisputeResolution::add_auto_resolve(&market_id, resolve_at)?;
-                    (AuthorityReport { resolve_at, outcome }, ids_len)
+                    (AuthorityReport { resolve_at, outcome: outcome.clone() }, ids_len)
                 }
             };
 
             AuthorizedOutcomeReports::<T>::insert(market_id, report);
 
+            Self::deposit_event(Event::AuthorityReported { market_id, outcome });
+
             if report_opt.is_none() {
                 Ok(Some(T::WeightInfo::authorize_market_outcome_first_report(ids_len)).into())
             } else {
@@ -156,16 +158,19 @@ mod pallet {
         MarketDoesNotHaveDisputeMechanismAuthorized,
         /// An account attempts to submit a report to an undisputed market.
         MarketIsNotDisputed,
-        /// Only one dispute is allowed.
-        OnlyOneDisputeAllowed,
         /// The report does not match the market's type.
         OutcomeMismatch,
     }
 
     #[pallet::event]
+    #[pallet::generate_deposit(pub(crate) fn deposit_event)]
     pub enum Event<T>
     where
-        T: Config, {}
+        T: Config,
+    {
+        /// The Authority reported.
+        AuthorityReported { market_id: MarketIdOf<T>, outcome: OutcomeReport },
+    }
 
     #[pallet::hooks]
     impl<T: Config> Hooks<T::BlockNumber> for Pallet<T> {}
@@ -195,21 +200,15 @@ mod pallet {
         type Moment = MomentOf<T>;
         type Origin = T::Origin;
 
-        fn on_dispute(
-            disputes: &[MarketDispute<Self::AccountId, Self::BlockNumber>],
-            _: &Self::MarketId,
-            market: &MarketOf<T>,
-        ) -> DispatchResult {
+        fn on_dispute(_: &Self::MarketId, market: &MarketOf<T>) -> DispatchResult {
             ensure!(
                 market.dispute_mechanism == MarketDisputeMechanism::Authorized,
                 Error::<T>::MarketDoesNotHaveDisputeMechanismAuthorized
             );
-            ensure!(disputes.is_empty(), Error::<T>::OnlyOneDisputeAllowed);
             Ok(())
         }
 
         fn on_resolution(
-            _: &[MarketDispute<Self::AccountId, Self::BlockNumber>],
             market_id: &Self::MarketId,
             market: &MarketOf<T>,
         ) -> Result<Option<OutcomeReport>, DispatchError> {
@@ -222,7 +221,6 @@ mod pallet {
         }
 
         fn get_auto_resolve(
-            _: &[MarketDispute<Self::AccountId, Self::BlockNumber>],
             market_id: &Self::MarketId,
             market: &MarketOf<T>,
         ) -> Result<Option<Self::BlockNumber>, DispatchError> {
@@ -233,18 +231,33 @@ mod pallet {
             Ok(Self::get_auto_resolve(market_id))
         }
 
-        fn has_failed(
-            _: &[MarketDispute<Self::AccountId, Self::BlockNumber>],
-            _: &Self::MarketId,
-            market: &MarketOf<T>,
-        ) -> Result<bool, DispatchError> {
+        fn has_failed(_: &Self::MarketId, market: &MarketOf<T>) -> Result<bool, DispatchError> {
             ensure!(
                 market.dispute_mechanism == MarketDisputeMechanism::Authorized,
                 Error::<T>::MarketDoesNotHaveDisputeMechanismAuthorized
             );
 
             Ok(false)
         }
+
+        fn on_global_dispute(_: &Self::MarketId, market: &MarketOf<T>) -> DispatchResult {
+            ensure!(
+                market.dispute_mechanism == MarketDisputeMechanism::Authorized,
+                Error::<T>::MarketDoesNotHaveDisputeMechanismAuthorized
+            );
+
+            Ok(())
+        }
+
+        fn clear(market_id: &Self::MarketId, market: &MarketOf<T>) -> DispatchResult {
+            ensure!(
+                market.dispute_mechanism == MarketDisputeMechanism::Authorized,
+                Error::<T>::MarketDoesNotHaveDisputeMechanismAuthorized
+            );
+
+            AuthorizedOutcomeReports::<T>::remove(market_id);
+            Ok(())
+        }
     }
 
     impl<T> AuthorizedPalletApi for Pallet<T> where T: Config {}