Track reserved (non-dispute) bonds (#892)

* Add `bonds` field to `Market`

* Add `bonds` field to `construct_market`

* Abstract unreserving bonds

* Abstract slashing of bonds

* Fix clippy issues

* Introduce `Bond` structure

* Fix code duplication

* Implement storage migration

* Test storage migration

* Fix doc string

* Add `who` field to `Bond`

* Fix runtime benchmarks

* Fix macro invocations

* Fix `market-commons` tests

* Fix clippy issues

* Fix formatting

* Use `CurrencyOf` instead of `AssetManager`

* Add test for `create_market`

* Test that `on_resolution` settles bonds

* Add migration to `Executive`

* Remove unnecessary clone

* Reorder blocks in `create_market`

* Add `debug_asserts!` to catch logic errors

* Consider markets with insufficient subsidy in migration

* Improve trait bounds in `MaxEncodedLen` implementation

* Apply suggestions from code review

Co-authored-by: Chralt <chralt.developer@gmail.com>

* Rename macro parameter for clarity

* Update zrml/prediction-markets/src/migrations.rs

Co-authored-by: Chralt <chralt.developer@gmail.com>

* Add missing documentation

* Add missing `return` statement

* Add docs and order lexicographically

* Make `slash_advisory_bond` private again

* Use id-only approach for slashing/unreserving bonds

* Apply suggestions from code review

Co-authored-by: Harald Heckmann <mail@haraldheckmann.de>

* Replace `advisory`/`validity` field with `creation`

* Fix generic parameter names

Co-authored-by: Chralt <chralt.developer@gmail.com>
Co-authored-by: Harald Heckmann <mail@haraldheckmann.de>

Author: 3 people

docs/changelog_for_devs.md

@@ -1,3 +1,11 @@
+# v0.3.8
+
+- Added the `bonds` field to the `Market` struct, which tracks the status of the
+  advisory, oracle and validity bonds. Each of its members has type `Bond`,
+  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).
+
 # v0.3.7
 
 - Added on-chain arbitrage. See
@@ -11,6 +19,7 @@
   `tokens.Deposited` and `tokens.Transfer` events are also emitted.
 
 - Added new pallet: GlobalDisputes. Dispatchable calls are:
+
   - `add_vote_outcome` - Add voting outcome to a global dispute in exchange for
     a constant fee. Errors if the voting outcome already exists or if the global
     dispute has not started or has already finished.
@@ -38,6 +47,7 @@
   Authorized MDM for resolving market.
 
 - Properly configured reserve asset transfers via XCM:
+
   - Added xTokens pallet to transfer tokens accross chains
   - Added AssetRegistry pallet to register foreign asset
   - Added UnknownTokens pallet to handle unknown foreign assets
@@ -62,7 +72,6 @@
 - `edit_market` extrinsic added, which enables creator of the market to edit
   market. It has same parameters as `create_market` except market_creation, on
   success it returns `MarketEdited` event.
-  
 - `get_spot_price()` RPC from Swaps support `with_fees` boolean parameter to
   include/exclude swap_fees in spot price, Currently this flag only works for
   CPMM.

primitives/src/constants/mock.rs

@@ -55,9 +55,9 @@ parameter_types! {
     pub const ValidityBond: Balance = 50 * CENT;
     pub const MinDisputeDuration: BlockNumber = 2;
     pub const MinOracleDuration: BlockNumber = 2;
-    pub const MaxDisputeDuration: BlockNumber = 5;
-    pub const MaxGracePeriod: BlockNumber = 2;
-    pub const MaxOracleDuration: BlockNumber = 3;
+    pub const MaxDisputeDuration: BlockNumber = 50;
+    pub const MaxGracePeriod: BlockNumber = 20;
+    pub const MaxOracleDuration: BlockNumber = 30;
     pub const MaxEditReasonLen: u32 = 1024;
     pub const MaxRejectReasonLen: u32 = 1024;
 }

primitives/src/market.rs

@@ -24,11 +24,12 @@ use sp_runtime::RuntimeDebug;
 
 /// Types
 ///
-/// * `AI`: Account Id
-/// * `BN`: Block Number
-/// * `M`: Moment (Time moment)
+/// * `AI`: Account id
+/// * `BA`: Balance type for bonds
+/// * `BN`: Block number
+/// * `M`: Moment (time moment)
 #[derive(Clone, Decode, Encode, Eq, PartialEq, RuntimeDebug, TypeInfo)]
-pub struct Market<AI, BN, M> {
+pub struct Market<AI, BA, BN, M> {
     /// Creator of this market.
     pub creator: AI,
     /// Creation type.
@@ -56,9 +57,53 @@ pub struct Market<AI, BN, M> {
     pub resolved_outcome: Option<OutcomeReport>,
     /// See [`MarketDisputeMechanism`].
     pub dispute_mechanism: MarketDisputeMechanism,
+    /// The bonds reserved for this market.
+    pub bonds: MarketBonds<AI, BA>,
+}
+
+/// Tracks the status of a bond.
+#[derive(Clone, Decode, Encode, MaxEncodedLen, PartialEq, Eq, RuntimeDebug, TypeInfo)]
+pub struct Bond<AI, BA> {
+    /// The account that reserved the bond.
+    pub who: AI,
+    /// The amount reserved.
+    pub value: BA,
+    /// `true` if and only if the bond is unreserved and/or (partially) slashed.
+    pub is_settled: bool,
+}
+
+impl<AI, BA> Bond<AI, BA> {
+    pub fn new(who: AI, value: BA) -> Bond<AI, BA> {
+        Bond { who, value, is_settled: false }
+    }
+}
+
+/// Tracks bonds associated with a prediction market.
+#[derive(Clone, Decode, Encode, MaxEncodedLen, PartialEq, Eq, RuntimeDebug, TypeInfo)]
+pub struct MarketBonds<AI, BA> {
+    pub creation: Option<Bond<AI, BA>>,
+    pub oracle: Option<Bond<AI, BA>>,
 }
 
-impl<AI, BN, M> Market<AI, BN, M> {
+impl<AI: Ord, BA: frame_support::traits::tokens::Balance> MarketBonds<AI, BA> {
+    /// Return the combined value of the open bonds for `who`.
+    pub fn total_amount_bonded(&self, who: &AI) -> BA {
+        let value_or_default = |bond: &Option<Bond<AI, BA>>| match bond {
+            Some(bond) if bond.who == *who => bond.value,
+            _ => BA::zero(),
+        };
+        value_or_default(&self.creation).saturating_add(value_or_default(&self.oracle))
+    }
+}
+
+// Used primarily for testing purposes.
+impl<AI, BA> Default for MarketBonds<AI, BA> {
+    fn default() -> Self {
+        MarketBonds { creation: None, oracle: None }
+    }
+}
+
+impl<AI, BA, BN, M> Market<AI, BA, BN, M> {
     // Returns the number of outcomes for a market.
     pub fn outcomes(&self) -> u16 {
         match self.market_type {
@@ -84,9 +129,10 @@ impl<AI, BN, M> Market<AI, BN, M> {
     }
 }
 
-impl<AI, BN, M> MaxEncodedLen for Market<AI, BN, M>
+impl<AI, BA, BN, M> MaxEncodedLen for Market<AI, BA, BN, M>
 where
     AI: MaxEncodedLen,
+    BA: MaxEncodedLen,
     BN: MaxEncodedLen,
     M: MaxEncodedLen,
 {
@@ -105,6 +151,7 @@ where
             .saturating_add(<Option<Report<AI, BN>>>::max_encoded_len())
             .saturating_add(<Option<OutcomeReport>>::max_encoded_len())
             .saturating_add(<MarketDisputeMechanism>::max_encoded_len())
+            .saturating_add(<MarketBonds<AI, BA>>::max_encoded_len())
     }
 }
 
@@ -160,7 +207,9 @@ impl<BN: MaxEncodedLen, M: MaxEncodedLen> MaxEncodedLen for MarketPeriod<BN, M>
 }
 
 /// Defines deadlines for market.
-#[derive(Clone, Copy, Decode, Encode, Eq, MaxEncodedLen, PartialEq, RuntimeDebug, TypeInfo)]
+#[derive(
+    Clone, Copy, Decode, Default, Encode, Eq, MaxEncodedLen, PartialEq, RuntimeDebug, TypeInfo,
+)]
 pub struct Deadlines<BN> {
     pub grace_period: BN,
     pub oracle_duration: BN,
@@ -232,7 +281,7 @@ pub struct SubsidyUntil<BN, MO, MI> {
 mod tests {
     use crate::market::*;
     use test_case::test_case;
-    type Market = crate::market::Market<u32, u32, u32>;
+    type Market = crate::market::Market<u32, u32, u32, u32>;
 
     #[test_case(
         MarketType::Categorical(6),
@@ -305,16 +354,19 @@ mod tests {
             report: None,
             resolved_outcome: None,
             dispute_mechanism: MarketDisputeMechanism::Authorized,
+            bonds: MarketBonds::default(),
         };
         assert_eq!(market.matches_outcome_report(&outcome_report), expected);
     }
+
     #[test]
     fn max_encoded_len_market_type() {
         // `MarketType::Scalar` is the largest enum variant.
         let market_type = MarketType::Scalar(1u128..=2);
         let len = parity_scale_codec::Encode::encode(&market_type).len();
         assert_eq!(MarketType::max_encoded_len(), len);
     }
+
     #[test]
     fn max_encoded_len_market_period() {
         let market_period: MarketPeriod<u32, u32> = MarketPeriod::Block(Default::default());

primitives/src/traits/dispute_api.rs

@@ -19,6 +19,15 @@ use crate::{market::MarketDispute, outcome_report::OutcomeReport, types::Market}
 use frame_support::dispatch::DispatchResult;
 use sp_runtime::DispatchError;
 
+// Abstraction of the market type, which is not a part of `DisputeApi` because Rust doesn't support
+// type aliases in traits.
+type MarketOfDisputeApi<T> = Market<
+    <T as DisputeApi>::AccountId,
+    <T as DisputeApi>::Balance,
+    <T as DisputeApi>::BlockNumber,
+    <T as DisputeApi>::Moment,
+>;
+
 pub trait DisputeApi {
     type AccountId;
     type Balance;
@@ -34,7 +43,7 @@ pub trait DisputeApi {
     fn on_dispute(
         previous_disputes: &[MarketDispute<Self::AccountId, Self::BlockNumber>],
         market_id: &Self::MarketId,
-        market: &Market<Self::AccountId, Self::BlockNumber, Self::Moment>,
+        market: &MarketOfDisputeApi<Self>,
     ) -> DispatchResult;
 
     /// Manage market resolution of a disputed market.
@@ -49,6 +58,6 @@ pub trait DisputeApi {
     fn on_resolution(
         disputes: &[MarketDispute<Self::AccountId, Self::BlockNumber>],
         market_id: &Self::MarketId,
-        market: &Market<Self::AccountId, Self::BlockNumber, Self::Moment>,
+        market: &MarketOfDisputeApi<Self>,
     ) -> Result<Option<OutcomeReport>, DispatchError>;
 }

primitives/src/traits/market_commons_pallet_api.rs

@@ -21,13 +21,24 @@ use frame_support::{
     dispatch::{DispatchError, DispatchResult},
     pallet_prelude::{MaybeSerializeDeserialize, Member},
     storage::PrefixIterator,
-    traits::NamedReservableCurrency,
+    traits::{Currency, NamedReservableCurrency},
     Parameter,
 };
 use parity_scale_codec::MaxEncodedLen;
 use sp_runtime::traits::AtLeast32Bit;
 
-/// Simple disputes - Pallet Api
+// Abstraction of the market type, which is not a part of `MarketCommonsPalletApi` because Rust
+// doesn't support type aliases in traits.
+type MarketOf<T> = Market<
+    <T as MarketCommonsPalletApi>::AccountId,
+    <<T as MarketCommonsPalletApi>::Currency as Currency<
+        <T as MarketCommonsPalletApi>::AccountId,
+    >>::Balance,
+    <T as MarketCommonsPalletApi>::BlockNumber,
+    <T as MarketCommonsPalletApi>::Moment,
+>;
+
+/// Abstraction over storage operations for markets
 pub trait MarketCommonsPalletApi {
     type AccountId;
     type BlockNumber: AtLeast32Bit;
@@ -50,23 +61,18 @@ pub trait MarketCommonsPalletApi {
 
     /// Return an iterator over the key-value pairs of markets. Altering market storage during
     /// iteration results in undefined behavior.
-    fn market_iter()
-    -> PrefixIterator<(Self::MarketId, Market<Self::AccountId, Self::BlockNumber, Self::Moment>)>;
+    fn market_iter() -> PrefixIterator<(Self::MarketId, MarketOf<Self>)>;
 
     /// Gets a market from the storage.
-    fn market(
-        market_id: &Self::MarketId,
-    ) -> Result<Market<Self::AccountId, Self::BlockNumber, Self::Moment>, DispatchError>;
+    fn market(market_id: &Self::MarketId) -> Result<MarketOf<Self>, DispatchError>;
 
     /// Mutates a given market storage
     fn mutate_market<F>(market_id: &Self::MarketId, cb: F) -> DispatchResult
     where
-        F: FnOnce(&mut Market<Self::AccountId, Self::BlockNumber, Self::Moment>) -> DispatchResult;
+        F: FnOnce(&mut MarketOf<Self>) -> DispatchResult;
 
     /// Pushes a new market into the storage, returning its related auto-incremented ID.
-    fn push_market(
-        market: Market<Self::AccountId, Self::BlockNumber, Self::Moment>,
-    ) -> Result<Self::MarketId, DispatchError>;
+    fn push_market(market: MarketOf<Self>) -> Result<Self::MarketId, DispatchError>;
 
     /// Removes a market from the storage.
     fn remove_market(market_id: &Self::MarketId) -> DispatchResult;

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>,
         >;
 
         #[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>,
         >;
 
         pub type Header = generic::Header<BlockNumber, BlakeTwo256>;

zrml/authorized/src/lib.rs

@@ -59,6 +59,12 @@ mod pallet {
     pub(crate) type MarketIdOf<T> =
         <<T as Config>::MarketCommons as MarketCommonsPalletApi>::MarketId;
     pub(crate) type MomentOf<T> = <<T as Config>::MarketCommons as MarketCommonsPalletApi>::Moment;
+    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> {
@@ -144,15 +150,15 @@ mod pallet {
         fn on_dispute(
             _: &[MarketDispute<Self::AccountId, Self::BlockNumber>],
             _: &Self::MarketId,
-            _: &Market<Self::AccountId, Self::BlockNumber, Self::Moment>,
+            _: &MarketOf<T>,
         ) -> DispatchResult {
             Ok(())
         }
 
         fn on_resolution(
             _: &[MarketDispute<Self::AccountId, Self::BlockNumber>],
             market_id: &Self::MarketId,
-            _: &Market<Self::AccountId, Self::BlockNumber, MomentOf<T>>,
+            _: &MarketOf<T>,
         ) -> Result<Option<OutcomeReport>, DispatchError> {
             let result = AuthorizedOutcomeReports::<T>::get(market_id);
             if result.is_some() {
@@ -173,13 +179,13 @@ mod pallet {
 
 #[cfg(any(feature = "runtime-benchmarks", test))]
 pub(crate) fn market_mock<T>()
--> zeitgeist_primitives::types::Market<T::AccountId, T::BlockNumber, MomentOf<T>>
+-> zeitgeist_primitives::types::Market<T::AccountId, BalanceOf<T>, T::BlockNumber, MomentOf<T>>
 where
     T: crate::Config,
 {
     use frame_support::traits::Get;
     use sp_runtime::traits::AccountIdConversion;
-    use zeitgeist_primitives::types::ScoringRule;
+    use zeitgeist_primitives::types::{MarketBonds, ScoringRule};
 
     zeitgeist_primitives::types::Market {
         creation: zeitgeist_primitives::types::MarketCreation::Permissionless,
@@ -199,5 +205,6 @@ where
         resolved_outcome: None,
         scoring_rule: ScoringRule::CPMM,
         status: zeitgeist_primitives::types::MarketStatus::Disputed,
+        bonds: MarketBonds::default(),
     }
 }

zrml/court/src/lib.rs

@@ -88,6 +88,12 @@ mod pallet {
     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> {
@@ -498,7 +504,7 @@ mod pallet {
         fn on_dispute(
             disputes: &[MarketDispute<Self::AccountId, Self::BlockNumber>],
             market_id: &Self::MarketId,
-            market: &Market<Self::AccountId, Self::BlockNumber, Self::Moment>,
+            market: &MarketOf<T>,
         ) -> DispatchResult {
             if market.dispute_mechanism != MarketDisputeMechanism::Court {
                 return Err(Error::<T>::MarketDoesNotHaveCourtMechanism.into());
@@ -522,7 +528,7 @@ mod pallet {
         fn on_resolution(
             _: &[MarketDispute<Self::AccountId, Self::BlockNumber>],
             market_id: &Self::MarketId,
-            market: &Market<Self::AccountId, Self::BlockNumber, MomentOf<T>>,
+            market: &MarketOf<T>,
         ) -> Result<Option<OutcomeReport>, DispatchError> {
             if market.dispute_mechanism != MarketDisputeMechanism::Court {
                 return Err(Error::<T>::MarketDoesNotHaveCourtMechanism.into());