[PM] Reserve OutsiderBond for report, when the oracle fails to report

primitives/src/constants/mock.rs

@@ -51,6 +51,7 @@ parameter_types! {
     pub const MaxSubsidyPeriod: Moment = 2_678_400_000;
     pub const MaxMarketPeriod: Moment = u64::MAX / 2;
     pub const OracleBond: Balance = 50 * CENT;
+    pub const OutsiderBond: Balance = 25 * CENT;
     pub const PmPalletId: PalletId = PalletId(*b"zge/pred");
     pub const ValidityBond: Balance = 50 * CENT;
     pub const MinDisputeDuration: BlockNumber = 2;

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 outsider: 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.outsider))
     }
 }
 
 // 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, outsider: None }
     }
 }
 

runtime/battery-station/src/parameters.rs

@@ -183,6 +183,9 @@ parameter_types! {
     /// (Slashable) The orcale bond. Slashed in case the final outcome does not match the
     /// outcome the oracle reported.
     pub const OracleBond: Balance = 50 * CENT;
+    /// (Slashable) A bond for an outcome reporter, who is not the oracle.
+    /// Slashed in case the final outcome does not match the outcome by the outsider.
+    pub const OutsiderBond: Balance = 25 * CENT;
     /// Pallet identifier, mainly used for named balance reserves.
     pub const PmPalletId: PalletId = PM_PALLET_ID;
     /// (Slashable) A bond for creation markets that do not require approval. Slashed in case

runtime/common/src/lib.rs

@@ -58,7 +58,7 @@ macro_rules! decl_common_types {
             frame_system::ChainContext<Runtime>,
             Runtime,
             AllPalletsWithSystem,
-            zrml_prediction_markets::migrations::RecordBonds<Runtime>,
+            zrml_prediction_markets::migrations::AddOutsiderBond<Runtime>,
         >;
 
         #[cfg(not(feature = "parachain"))]
@@ -68,7 +68,7 @@ macro_rules! decl_common_types {
             frame_system::ChainContext<Runtime>,
             Runtime,
             AllPalletsWithSystem,
-            zrml_prediction_markets::migrations::RecordBonds<Runtime>,
+            zrml_prediction_markets::migrations::AddOutsiderBond<Runtime>,
         >;
 
         pub type Header = generic::Header<BlockNumber, BlakeTwo256>;
@@ -1002,6 +1002,7 @@ macro_rules! impl_config_traits {
             type MaxEditReasonLen = MaxEditReasonLen;
             type MaxRejectReasonLen = MaxRejectReasonLen;
             type OracleBond = OracleBond;
+            type OutsiderBond = OutsiderBond;
             type PalletId = PmPalletId;
             type RejectOrigin = EnsureRootOrHalfAdvisoryCommittee;
             type RequestEditOrigin = EitherOfDiverse<

runtime/zeitgeist/src/parameters.rs

@@ -183,6 +183,9 @@ parameter_types! {
     /// (Slashable) The orcale bond. Slashed in case the final outcome does not match the
     /// outcome the oracle reported.
     pub const OracleBond: Balance = 200 * BASE;
+    /// (Slashable) A bond for an outcome reporter, who is not the oracle.
+    /// Slashed in case the final outcome does not match the outcome by the outsider.
+    pub const OutsiderBond: Balance = 100 * BASE;
     /// Pallet identifier, mainly used for named balance reserves. DO NOT CHANGE.
     pub const PmPalletId: PalletId = PM_PALLET_ID;
     /// (Slashable) A bond for creation markets that do not require approval. Slashed in case

zrml/court/src/tests.rs

@@ -51,7 +51,7 @@ const DEFAULT_MARKET: MarketOf<Runtime> = Market {
     resolved_outcome: None,
     status: MarketStatus::Closed,
     scoring_rule: ScoringRule::CPMM,
-    bonds: MarketBonds { creation: None, oracle: None },
+    bonds: MarketBonds { creation: None, oracle: None, outsider: None },
 };
 const DEFAULT_SET_OF_JURORS: &[(u128, Juror)] = &[
     (7, Juror { status: JurorStatus::Ok }),

zrml/market-commons/src/tests.rs

@@ -45,7 +45,7 @@ const MARKET_DUMMY: Market<AccountIdTest, Balance, BlockNumber, Moment> = Market
     resolved_outcome: None,
     scoring_rule: ScoringRule::CPMM,
     status: MarketStatus::Disputed,
-    bonds: MarketBonds { creation: None, oracle: None },
+    bonds: MarketBonds { creation: None, oracle: None, outsider: None },
 };
 
 #[test]

zrml/prediction-markets/src/lib.rs

@@ -40,8 +40,8 @@ mod pallet {
         pallet_prelude::{ConstU32, StorageMap, StorageValue, ValueQuery},
         storage::{with_transaction, TransactionOutcome},
         traits::{
-            Currency, EnsureOrigin, Get, Hooks, Imbalance, IsType, NamedReservableCurrency,
-            OnUnbalanced, StorageVersion,
+            tokens::BalanceStatus, Currency, EnsureOrigin, Get, Hooks, Imbalance, IsType,
+            NamedReservableCurrency, OnUnbalanced, StorageVersion,
         },
         transactional,
         weights::Pays,
@@ -190,6 +190,45 @@ mod pallet {
         };
     }
 
+    macro_rules! impl_repatriate_bond {
+        ($fn_name:ident, $bond_type:ident) => {
+            /// Settle the $bond_type bond by repatriating it to free balance of beneficiary.
+            ///
+            /// This function **should** only be called if the bond is not yet settled, and calling
+            /// it if the bond is settled is most likely a logic error. If the bond is already
+            /// settled, storage is not changed, a warning is raised and `Ok(())` is returned.
+            fn $fn_name(
+                market_id: &MarketIdOf<T>,
+                beneficiary: &T::AccountId,
+            ) -> Result<BalanceOf<T>, DispatchError> {
+                let market = <zrml_market_commons::Pallet<T>>::market(market_id)?;
+                let bond = market.bonds.$bond_type.as_ref().ok_or(Error::<T>::MissingBond)?;
+                if bond.is_settled {
+                    let warning = format!(
+                        "Attempting to settle the {} bond of market {:?} multiple times",
+                        stringify!($bond_type),
+                        market_id,
+                    );
+                    log::warn!("{}", warning);
+                    debug_assert!(false, "{}", warning);
+                    return Ok(Zero::zero());
+                }
+                let missing = <CurrencyOf<T>>::repatriate_reserved_named(
+                    &Self::reserve_id(),
+                    &bond.who,
+                    beneficiary,
+                    bond.value,
+                    BalanceStatus::Free,
+                )?;
+                <zrml_market_commons::Pallet<T>>::mutate_market(market_id, |m| {
+                    m.bonds.$bond_type = Some(Bond { is_settled: true, ..bond.clone() });
+                    Ok(())
+                })?;
+                Ok(missing)
+            }
+        };
+    }
+
     #[pallet::call]
     impl<T: Config> Pallet<T> {
         /// Destroy a market, including its outcome assets, market account and pool account.
@@ -238,6 +277,11 @@ mod pallet {
                     Self::slash_oracle_bond(&market_id, None)?;
                 }
             }
+            if let Some(bond) = market.bonds.outsider {
+                if !bond.is_settled {
+                    Self::slash_outsider_bond(&market_id, None)?;
+                }
+            }
 
             if market_status == MarketStatus::Proposed {
                 MarketIdsForEdit::<T>::remove(market_id);
@@ -692,10 +736,12 @@ mod pallet {
                 MarketCreation::Advised => MarketBonds {
                     creation: Some(Bond::new(sender.clone(), T::AdvisoryBond::get())),
                     oracle: Some(Bond::new(sender.clone(), T::OracleBond::get())),
+                    ..Default::default()
                 },
                 MarketCreation::Permissionless => MarketBonds {
                     creation: Some(Bond::new(sender.clone(), T::ValidityBond::get())),
                     oracle: Some(Bond::new(sender.clone(), T::OracleBond::get())),
+                    ..Default::default()
                 },
             };
 
@@ -1220,13 +1266,26 @@ mod pallet {
                     }
                 }
 
+                let sender_is_oracle = sender == market.oracle;
+                let origin_has_permission = T::ResolveOrigin::ensure_origin(origin).is_ok();
+                let sender_is_outsider = !sender_is_oracle && !origin_has_permission;
+
                 if should_check_origin {
-                    let sender_is_oracle = sender == market.oracle;
-                    let origin_has_permission = T::ResolveOrigin::ensure_origin(origin).is_ok();
                     ensure!(
                         sender_is_oracle || origin_has_permission,
                         Error::<T>::ReporterNotOracle
                     );
+                } else if sender_is_outsider {
+                    let outsider_bond = T::OutsiderBond::get();
+
+                    market.bonds.outsider = Some(Bond::new(sender.clone(), outsider_bond));
+
+                    T::AssetManager::reserve_named(
+                        &Self::reserve_id(),
+                        Asset::Ztg,
+                        &sender,
+                        outsider_bond,
+                    )?;
                 }
 
                 market.report = Some(market_report.clone());
@@ -1528,6 +1587,9 @@ mod pallet {
         #[pallet::constant]
         type MaxEditReasonLen: Get<u32>;
 
+        #[pallet::constant]
+        type OutsiderBond: Get<BalanceOf<Self>>;
+
         /// The module identifier.
         #[pallet::constant]
         type PalletId: Get<PalletId>;
@@ -1930,8 +1992,11 @@ mod pallet {
     impl<T: Config> Pallet<T> {
         impl_unreserve_bond!(unreserve_creation_bond, creation);
         impl_unreserve_bond!(unreserve_oracle_bond, oracle);
+        impl_unreserve_bond!(unreserve_outsider_bond, outsider);
         impl_slash_bond!(slash_creation_bond, creation);
         impl_slash_bond!(slash_oracle_bond, oracle);
+        impl_slash_bond!(slash_outsider_bond, outsider);
+        impl_repatriate_bond!(repatriate_oracle_bond, oracle);
 
         pub fn outcome_assets(
             market_id: MarketIdOf<T>,
@@ -2347,6 +2412,12 @@ mod pallet {
                         err
                     );
                 }
+
+                if let Some(bond) = &market.bonds.outsider {
+                    if !bond.is_settled {
+                        Self::unreserve_outsider_bond(market_id)?;
+                    }
+                }
             }
 
             Ok(report.outcome.clone())
@@ -2390,11 +2461,56 @@ mod pallet {
             // If the oracle reported right, return the OracleBond, otherwise slash it to
             // pay the correct reporters.
             let mut overall_imbalance = NegativeImbalanceOf::<T>::zero();
-            if report.by == market.oracle && report.outcome == resolved_outcome {
-                Self::unreserve_oracle_bond(market_id)?;
+
+            let report_by_oracle = report.by == market.oracle;
+            let is_correct = report.outcome == resolved_outcome;
+
+            // TODO: this wrapper (if let Some and !settled) can be removed
+            // TODO: if there are only markets with outsiders, who all reserved OutsiderBond
+            let outsider_bond_pending = || -> bool {
+                if let Some(bond) = &market.bonds.outsider {
+                    if !bond.is_settled {
+                        return true;
+                    }
+                }
+                false
+            };
+
+            let unreserve_outsider = || -> DispatchResult {
+                if outsider_bond_pending() {
+                    Self::unreserve_outsider_bond(market_id)?;
+                }
+                Ok(())
+            };
+
+            let slash_outsider = || -> Result<NegativeImbalanceOf<T>, DispatchError> {
+                if outsider_bond_pending() {
+                    let imbalance = Self::slash_outsider_bond(market_id, None)?;
+                    return Ok(imbalance);
+                }
+                Ok(NegativeImbalanceOf::<T>::zero())
+            };
+
+            if report_by_oracle {
+                if is_correct {
+                    Self::unreserve_oracle_bond(market_id)?;
+                } else {
+                    let negative_imbalance = Self::slash_oracle_bond(market_id, None)?;
+                    overall_imbalance.subsume(negative_imbalance);
+                }
             } else {
-                let imbalance = Self::slash_oracle_bond(market_id, None)?;
-                overall_imbalance.subsume(imbalance);
+                // outsider report
+                if is_correct {
+                    // reward outsider reporter with oracle bond
+                    let missing = Self::repatriate_oracle_bond(market_id, &report.by)?;
+                    debug_assert!(missing.is_zero(), "Could not deduct all of the value.");
+                    unreserve_outsider()?;
+                } else {
+                    let oracle_imbalance = Self::slash_oracle_bond(market_id, None)?;
+                    let outsider_imbalance = slash_outsider()?;
+                    overall_imbalance.subsume(oracle_imbalance);
+                    overall_imbalance.subsume(outsider_imbalance);
+                }
             }
 
             for (i, dispute) in disputes.iter().enumerate() {