ZIP-0 Part I

docs/changelog_for_devs.md

@@ -5,6 +5,12 @@
   which has three fields: `who` (the account that reserved the bond), `value`
   (the amount reserved), `is_settled` (a flag which determines if the bond was
   already unreserved and/or (partially) slashed).
+- The market dispute mechanisms are now able to control their resolution. The
+  `CorrectionPeriod` parameter determines how long the authorized pallet can
+  call `authorize_market_outcome` again after the first call to it (fat-finger
+  protection). The authority report now includes its resolution block number.
+  This is the time of the first call to `authorize_market_outcome` plus the
+  `CorrectionPeriod`.
 
 # v0.3.7
 

primitives/src/constants/mock.rs

@@ -11,6 +11,7 @@ use orml_traits::parameter_type_with_key;
 // Authorized
 parameter_types! {
     pub const AuthorizedPalletId: PalletId = PalletId(*b"zge/atzd");
+    pub const CorrectionPeriod: BlockNumber = 4;
 }
 
 // Court

primitives/src/market.rs

@@ -264,6 +264,12 @@ pub struct Report<AccountId, BlockNumber> {
     pub outcome: OutcomeReport,
 }
 
+#[derive(Clone, Decode, Encode, Eq, MaxEncodedLen, PartialEq, RuntimeDebug, TypeInfo)]
+pub struct AuthorityReport<BlockNumber> {
+    pub resolve_at: BlockNumber,
+    pub outcome: OutcomeReport,
+}
+
 /// Contains a market id and the market period.
 ///
 /// * `BN`: Block Number

primitives/src/traits.rs

@@ -21,7 +21,7 @@ mod market_id;
 mod swaps;
 mod zeitgeist_multi_reservable_currency;
 
-pub use dispute_api::DisputeApi;
+pub use dispute_api::{DisputeApi, DisputeResolutionApi};
 pub use market_commons_pallet_api::MarketCommonsPalletApi;
 pub use market_id::MarketId;
 pub use swaps::Swaps;

primitives/src/traits/dispute_api.rs

@@ -16,7 +16,7 @@
 // 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;
+use frame_support::{dispatch::DispatchResult, pallet_prelude::Weight, BoundedVec};
 use sp_runtime::DispatchError;
 
 // Abstraction of the market type, which is not a part of `DisputeApi` because Rust doesn't support
@@ -60,4 +60,83 @@ pub trait DisputeApi {
         market_id: &Self::MarketId,
         market: &MarketOfDisputeApi<Self>,
     ) -> Result<Option<OutcomeReport>, DispatchError>;
+
+    /// Query the future resolution block of a disputed market.
+    /// **May** assume that `market.dispute_mechanism` refers to the calling dispute API.
+    ///
+    /// # Returns
+    ///
+    /// 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>;
+
+    /// Returns `true` if the market dispute mechanism
+    /// 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>;
+}
+
+type MarketOfDisputeResolutionApi<T> = Market<
+    <T as DisputeResolutionApi>::AccountId,
+    <T as DisputeResolutionApi>::Balance,
+    <T as DisputeResolutionApi>::BlockNumber,
+    <T as DisputeResolutionApi>::Moment,
+>;
+
+pub trait DisputeResolutionApi {
+    type AccountId;
+    type Balance;
+    type BlockNumber;
+    type MarketId;
+    type MaxDisputes;
+    type Moment;
+
+    /// Resolve a market.
+    ///
+    /// **Should** only be called if the market dispute
+    /// mechanism is ready for the resolution ([`DisputeApi::on_resolution`]).
+    ///
+    /// # Returns
+    ///
+    /// Returns the consumed weight.
+    fn resolve(
+        market_id: &Self::MarketId,
+        market: &MarketOfDisputeResolutionApi<Self>,
+    ) -> Result<Weight, DispatchError>;
+
+    /// Add a future block resolution of a disputed market.
+    ///
+    /// # Returns
+    ///
+    /// Returns the number of elements in the storage structure.
+    fn add_auto_resolve(
+        market_id: &Self::MarketId,
+        resolve_at: Self::BlockNumber,
+    ) -> Result<u32, DispatchError>;
+
+    /// Check if a future block resolution of a disputed market exists.
+    ///
+    /// # Returns
+    ///
+    /// Returns `true` if the future block resolution exists, otherwise `false`.
+    fn auto_resolve_exists(market_id: &Self::MarketId, resolve_at: Self::BlockNumber) -> bool;
+
+    /// Remove a future block resolution of a disputed market.
+    ///
+    /// # Returns
+    ///
+    /// 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

@@ -51,6 +51,7 @@ pub(crate) const FEES_AND_TIPS_BURN_PERCENTAGE: u32 = 0;
 parameter_types! {
     // Authorized
     pub const AuthorizedPalletId: PalletId = AUTHORIZED_PALLET_ID;
+    pub const CorrectionPeriod: BlockNumber = BLOCKS_PER_DAY;
 
     // Authority
     pub const MaxAuthorities: u32 = 32;

runtime/common/src/lib.rs

@@ -58,7 +58,10 @@ macro_rules! decl_common_types {
             frame_system::ChainContext<Runtime>,
             Runtime,
             AllPalletsWithSystem,
-            zrml_prediction_markets::migrations::RecordBonds<Runtime>,
+            (
+                zrml_prediction_markets::migrations::RecordBonds<Runtime>,
+                zrml_prediction_markets::migrations::AddFieldToAuthorityReport<Runtime>,
+            ),
         >;
 
         #[cfg(not(feature = "parachain"))]
@@ -68,7 +71,10 @@ macro_rules! decl_common_types {
             frame_system::ChainContext<Runtime>,
             Runtime,
             AllPalletsWithSystem,
-            zrml_prediction_markets::migrations::RecordBonds<Runtime>,
+            (
+                zrml_prediction_markets::migrations::RecordBonds<Runtime>,
+                zrml_prediction_markets::migrations::AddFieldToAuthorityReport<Runtime>,
+            ),
         >;
 
         pub type Header = generic::Header<BlockNumber, BlakeTwo256>;
@@ -912,15 +918,18 @@ macro_rules! impl_config_traits {
         impl parachain_info::Config for Runtime {}
 
         impl zrml_authorized::Config for Runtime {
+            type AuthorizedDisputeResolutionOrigin = EnsureRootOrHalfAdvisoryCommittee;
+            type CorrectionPeriod = CorrectionPeriod;
+            type DisputeResolution = zrml_prediction_markets::Pallet<Runtime>;
             type Event = Event;
             type MarketCommons = MarketCommons;
-            type AuthorizedDisputeResolutionOrigin = EnsureRootOrHalfAdvisoryCommittee;
             type PalletId = AuthorizedPalletId;
             type WeightInfo = zrml_authorized::weights::WeightInfo<Runtime>;
         }
 
         impl zrml_court::Config for Runtime {
             type CourtCaseDuration = CourtCaseDuration;
+            type DisputeResolution = zrml_prediction_markets::Pallet<Runtime>;
             type Event = Event;
             type MarketCommons = MarketCommons;
             type PalletId = CourtPalletId;
@@ -1033,6 +1042,7 @@ macro_rules! impl_config_traits {
         }
 
         impl zrml_simple_disputes::Config for Runtime {
+            type DisputeResolution = zrml_prediction_markets::Pallet<Runtime>;
             type Event = Event;
             type MarketCommons = MarketCommons;
             type PalletId = SimpleDisputesPalletId;

runtime/zeitgeist/src/parameters.rs

@@ -51,6 +51,7 @@ pub(crate) const FEES_AND_TIPS_BURN_PERCENTAGE: u32 = 0;
 parameter_types! {
     // Authorized
     pub const AuthorizedPalletId: PalletId = AUTHORIZED_PALLET_ID;
+    pub const CorrectionPeriod: BlockNumber = BLOCKS_PER_DAY;
 
     // Authority
     pub const MaxAuthorities: u32 = 32;

zrml/authorized/src/benchmarks.rs

@@ -23,19 +23,77 @@
 
 #[cfg(test)]
 use crate::Pallet as Authorized;
-use crate::{market_mock, Call, Config, Pallet};
+use crate::{market_mock, AuthorizedOutcomeReports, Call, Config, Pallet};
 use frame_benchmarking::benchmarks;
-use frame_support::{dispatch::UnfilteredDispatchable, traits::EnsureOrigin};
-use zeitgeist_primitives::types::OutcomeReport;
+use frame_support::{
+    dispatch::UnfilteredDispatchable,
+    traits::{EnsureOrigin, Get},
+};
+use sp_runtime::traits::Saturating;
+use zeitgeist_primitives::{
+    traits::DisputeResolutionApi,
+    types::{AuthorityReport, OutcomeReport},
+};
 use zrml_market_commons::MarketCommonsPalletApi;
 
 benchmarks! {
-    authorize_market_outcome {
+    authorize_market_outcome_first_report {
+        let m in 1..63;
+
+        let origin = T::AuthorizedDisputeResolutionOrigin::successful_origin();
+        let market_id = 0u32.into();
+        let market = market_mock::<T>();
+        T::MarketCommons::push_market(market).unwrap();
+
+        frame_system::Pallet::<T>::set_block_number(42u32.into());
+        let now = frame_system::Pallet::<T>::block_number();
+        let correction_period_ends_at = now.saturating_add(T::CorrectionPeriod::get());
+        for _ in 1..=m {
+            let id = T::MarketCommons::push_market(market_mock::<T>()).unwrap();
+            T::DisputeResolution::add_auto_resolve(&id, correction_period_ends_at).unwrap();
+        }
+
+        let call = Call::<T>::authorize_market_outcome {
+            market_id,
+            outcome: OutcomeReport::Scalar(1),
+        };
+    }: {
+        call.dispatch_bypass_filter(origin)?
+    } verify {
+        let report = AuthorityReport {
+            resolve_at: correction_period_ends_at,
+            outcome: OutcomeReport::Scalar(1)
+        };
+        assert_eq!(AuthorizedOutcomeReports::<T>::get(market_id).unwrap(), report);
+    }
+
+    authorize_market_outcome_existing_report {
         let origin = T::AuthorizedDisputeResolutionOrigin::successful_origin();
+        let market_id = 0u32.into();
         let market = market_mock::<T>();
         T::MarketCommons::push_market(market).unwrap();
-        let call = Call::<T>::authorize_market_outcome { market_id: 0_u32.into(), outcome: OutcomeReport::Scalar(1) };
-    }: { call.dispatch_bypass_filter(origin)? }
+
+        frame_system::Pallet::<T>::set_block_number(42u32.into());
+
+        let now = frame_system::Pallet::<T>::block_number();
+        let resolve_at = now.saturating_add(T::CorrectionPeriod::get());
+
+        let report = AuthorityReport { resolve_at, outcome: OutcomeReport::Scalar(0) };
+        AuthorizedOutcomeReports::<T>::insert(market_id, report);
+
+        let now = frame_system::Pallet::<T>::block_number();
+        frame_system::Pallet::<T>::set_block_number(now + 42u32.into());
+
+        let call = Call::<T>::authorize_market_outcome {
+            market_id,
+            outcome: OutcomeReport::Scalar(1),
+        };
+    }: {
+        call.dispatch_bypass_filter(origin)?
+    } verify {
+        let report = AuthorityReport { resolve_at, outcome: OutcomeReport::Scalar(1) };
+        assert_eq!(AuthorizedOutcomeReports::<T>::get(market_id).unwrap(), report);
+    }
 
     impl_benchmark_test_suite!(
         Authorized,