Implement Production Court

primitives/src/constants.rs

@@ -66,6 +66,8 @@ pub const AUTHORIZED_PALLET_ID: PalletId = PalletId(*b"zge/atzd");
 // Court
 /// Pallet identifier, mainly used for named balance reserves.
 pub const COURT_PALLET_ID: PalletId = PalletId(*b"zge/cout");
+/// Lock identifier, mainly used for the locks on the accounts.
+pub const COURT_LOCK_ID: [u8; 8] = *b"zge/colk";
 
 // Global Disputes
 pub const GLOBAL_DISPUTES_PALLET_ID: PalletId = PalletId(*b"zge/gldp");

primitives/src/constants/mock.rs

@@ -7,6 +7,7 @@ use crate::{
 };
 use frame_support::{parameter_types, traits::LockIdentifier, PalletId};
 use orml_traits::parameter_type_with_key;
+use sp_runtime::Percent;
 
 // Authorized
 parameter_types! {
@@ -16,9 +17,23 @@ parameter_types! {
 
 // Court
 parameter_types! {
+    pub const AppealBond: Balance = 5 * BASE;
+    pub const AppealBondFactor: Balance = 2 * BASE;
     pub const CourtCaseDuration: u64 = BLOCKS_PER_DAY;
     pub const CourtPalletId: PalletId = PalletId(*b"zge/cout");
-    pub const StakeWeight: u128 = 2 * BASE;
+    pub const RequestInterval: BlockNumber = 50;
+    pub const CourtVotePeriod: BlockNumber = 34;
+    pub const CourtAggregationPeriod: BlockNumber = 34;
+    pub const CourtAppealPeriod: BlockNumber = 34;
+    pub const CourtLockId: LockIdentifier = *b"zge/cloc";
+    pub const DenounceSlashPercentage: Percent = Percent::from_percent(100);
+    pub const IterationLimit: u32 = 100;
+    pub const MaxAppeals: u32 = 6;
+    pub const MaxDraws: u32 = 191;
+    pub const MaxJurors: u32 = 1000;
+    pub const MinJurorStake: Balance = 50 * CENT;
+    pub const RedistributionPercentage: Percent = Percent::from_percent(10);
+    pub const TardySlashPercentage: Percent = Percent::from_percent(20);
 }
 
 // Global disputes parameters
@@ -40,8 +55,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 MaxDisputeDuration: BlockNumber = 50;
@@ -67,6 +81,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

@@ -87,6 +87,7 @@ pub struct MarketBonds<AI, BA> {
     pub creation: Option<Bond<AI, BA>>,
     pub oracle: Option<Bond<AI, BA>>,
     pub outsider: Option<Bond<AI, BA>>,
+    pub dispute: Option<Bond<AI, BA>>,
 }
 
 impl<AI: Ord, BA: frame_support::traits::tokens::Balance> MarketBonds<AI, BA> {
@@ -99,13 +100,14 @@ impl<AI: Ord, BA: frame_support::traits::tokens::Balance> MarketBonds<AI, BA> {
         value_or_default(&self.creation)
             .saturating_add(value_or_default(&self.oracle))
             .saturating_add(value_or_default(&self.outsider))
+            .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, outsider: None }
+        MarketBonds { creation: None, oracle: None, outsider: None, dispute: None }
     }
 }
 
@@ -174,13 +176,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

@@ -16,11 +16,10 @@
 // along with Zeitgeist. If not, see <https://www.gnu.org/licenses/>.
 
 use crate::{
-    market::MarketDispute,
     outcome_report::OutcomeReport,
     types::{Asset, Market},
 };
-use frame_support::{dispatch::DispatchResult, pallet_prelude::Weight, BoundedVec};
+use frame_support::{dispatch::DispatchResult, pallet_prelude::Weight};
 use parity_scale_codec::MaxEncodedLen;
 use sp_runtime::DispatchError;
 
@@ -37,6 +36,7 @@ type MarketOfDisputeApi<T> = Market<
 pub trait DisputeApi {
     type AccountId;
     type Balance;
+    type NegativeImbalance;
     type BlockNumber;
     type MarketId: MaxEncodedLen;
     type Moment;
@@ -46,11 +46,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.
     ///
@@ -61,20 +57,30 @@ 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>],
+    fn get_resolution_outcome(
         market_id: &Self::MarketId,
         market: &MarketOfDisputeApi<Self>,
     ) -> Result<Option<OutcomeReport>, DispatchError>;
 
+    /// Allow the flow of funds to the market dispute mechanism.
+    /// **May** assume that `market.dispute_mechanism` refers to the calling dispute API.
+    ///
+    /// # Returns
+    /// Returns the negative imbalance which is meant to be used for the treasury.
+    fn maybe_pay(
+        market_id: &Self::MarketId,
+        market: &MarketOfDisputeApi<Self>,
+        resolved_outcome: &OutcomeReport,
+        overall_imbalance: Self::NegativeImbalance,
+    ) -> Result<Self::NegativeImbalance, 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>;
@@ -83,10 +89,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<
@@ -102,7 +118,6 @@ pub trait DisputeResolutionApi {
     type Balance;
     type BlockNumber;
     type MarketId: MaxEncodedLen;
-    type MaxDisputes;
     type Moment;
 
     /// Resolve a market.
@@ -141,9 +156,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

@@ -24,6 +24,7 @@
 use super::VERSION;
 use frame_support::{
     parameter_types,
+    traits::LockIdentifier,
     weights::{
         constants::{BlockExecutionWeight, ExtrinsicBaseWeight, WEIGHT_PER_SECOND},
         DispatchClass, Weight,
@@ -40,9 +41,6 @@ use sp_runtime::{
 use sp_version::RuntimeVersion;
 use zeitgeist_primitives::{constants::*, types::*};
 
-#[cfg(feature = "with-global-disputes")]
-use frame_support::traits::LockIdentifier;
-
 pub(crate) const AVERAGE_ON_INITIALIZE_RATIO: Perbill = Perbill::from_percent(10);
 pub(crate) const MAXIMUM_BLOCK_WEIGHT: Weight =
     Weight::from_ref_time(WEIGHT_PER_SECOND.ref_time() / 2);
@@ -77,13 +75,42 @@ parameter_types! {
     pub const TechnicalCommitteeMotionDuration: BlockNumber = 7 * BLOCKS_PER_DAY;
 
     // Court
+    /// (Slashable) Bond that is provided for overriding the last appeal.
+    /// Slashed in case the final outcome does match the appealed outcome for which the `AppealBond`
+    /// was deposited.
+    pub const AppealBond: Balance = 5 * BASE;
+    /// `OutcomeBond` is increased by this factor after every new appeal.
+    pub const AppealBondFactor: Balance = 2 * BASE;
     /// Duration of a single court case.
     pub const CourtCaseDuration: u64 = BLOCKS_PER_DAY;
     /// Pallet identifier, mainly used for named balance reserves.
     pub const CourtPalletId: PalletId = COURT_PALLET_ID;
-    /// This value is multiplied by the current number of jurors to determine the stake
-    /// the juror has to pay.
-    pub const StakeWeight: u128 = 2 * BASE;
+    /// The time in which the jurors can cast their secret vote.
+    pub const CourtVotePeriod: BlockNumber = 2 * BLOCKS_PER_DAY;
+    /// The time in which the jurors should reveal their secret vote.
+    pub const CourtAggregationPeriod: BlockNumber = 2 * BLOCKS_PER_DAY;
+    /// The time in which a court case can get appealed.
+    pub const CourtAppealPeriod: BlockNumber = 3 * BLOCKS_PER_DAY;
+    /// The court lock identifier.
+    pub const CourtLockId: LockIdentifier = COURT_LOCK_ID;
+    /// The slash percentage if a secret vote gets revealed during the voting period.
+    pub const DenounceSlashPercentage: Percent = Percent::from_percent(100);
+    /// The iteration limit over all markets for the randomly selected jurors.
+    pub const IterationLimit: u32 = 100;
+    /// The maximum number of appeals until the court fails.
+    pub const MaxAppeals: u32 = 6;
+    /// The maximum number of randomly selected jurors for a dispute.
+    pub const MaxDraws: u32 = 191;
+    /// The maximum number of jurors that can be registered.
+    pub const MaxJurors: u32 = 10_000;
+    /// The minimum stake a user needs to reserve to become a juror.
+    pub const MinJurorStake: Balance = 1000 * BASE;
+    /// The percentage that is slashed if a juror did not vote for the plurality outcome.
+    pub const RedistributionPercentage: Percent = Percent::from_percent(10);
+    /// The interval for requesting multiple court votes at once.
+    pub const RequestInterval: BlockNumber = 7 * BLOCKS_PER_DAY;
+    /// The percentage that is being slashed from the juror's stake.
+    pub const TardySlashPercentage: Percent = Percent::from_percent(20);
 
     // Democracy
     /// How often (in blocks) new public referenda are launched.
@@ -152,11 +179,9 @@ parameter_types! {
     /// The percentage of the advisory bond that gets slashed when a market is rejected.
     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 block period for a dispute.
@@ -223,6 +248,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