Implement DecisionMarketOracle using scoreboard

Author: maltekliemann

runtime/common/src/lib.rs

@@ -2287,7 +2287,7 @@ macro_rules! create_common_tests {
                 };
                 use zrml_futarchy::types::Proposal;
                 use zrml_market_commons::types::MarketBuilder;
-                use zrml_neo_swaps::types::DecisionMarketOracle;
+                use zrml_neo_swaps::types::{DecisionMarketOracle, DecisionMarketOracleScoreboard};
 
                 #[test]
                 fn futarchy_schedules_and_executes_call() {
@@ -2361,10 +2361,13 @@ macro_rules! create_common_tests {
                         };
                         let call =
                             Preimage::bound(RuntimeCall::from(remark_dispatched_as)).unwrap();
+                        let scoreboard =
+                            DecisionMarketOracleScoreboard::new(40_000, 10_000, one / 7, one);
                         let oracle = DecisionMarketOracle::new(
                             market_id,
                             Asset::CategoricalOutcome(market_id, 0),
                             Asset::CategoricalOutcome(market_id, 1),
+                            scoreboard,
                         );
                         let when = duration + 10;
                         let proposal = Proposal { when, call, oracle };

zrml/futarchy/src/mock/types/oracle.rs

@@ -20,8 +20,7 @@ use frame_support::pallet_prelude::Weight;
 use parity_scale_codec::{Decode, Encode, MaxEncodedLen};
 use scale_info::TypeInfo;
 use sp_runtime::traits::Zero;
-use zeitgeist_primitives::traits::FutarchyOracle;
-use zeitgeist_primitives::types::BlockNumber;
+use zeitgeist_primitives::{traits::FutarchyOracle, types::BlockNumber};
 
 #[derive(Clone, Debug, Decode, Encode, Eq, MaxEncodedLen, PartialEq, TypeInfo)]
 pub struct MockOracle {

zrml/futarchy/src/proposal_storage.rs

@@ -2,12 +2,11 @@ use crate::{
     traits::ProposalStorage, types::Proposal, Config, Error, Pallet, ProposalCount, Proposals,
     ProposalsOf,
 };
-use alloc::{collections::BTreeMap, vec::Vec};
+use alloc::{collections::BTreeMap, vec, vec::Vec};
 use frame_support::{ensure, require_transactional, traits::Get};
 use frame_system::pallet_prelude::BlockNumberFor;
 use sp_runtime::{DispatchError, SaturatedConversion};
 use zeitgeist_primitives::math::checked_ops_res::{CheckedIncRes, CheckedSubRes};
-use alloc::vec;
 
 impl<T> ProposalStorage<T> for Pallet<T>
 where
@@ -51,7 +50,9 @@ where
         Proposals::<T>::get(block_number)
     }
 
-    fn mutate_all<R, F>(mut mutator: F) -> Result<BTreeMap<BlockNumberFor<T>, Vec<R>>, DispatchError>
+    fn mutate_all<R, F>(
+        mut mutator: F,
+    ) -> Result<BTreeMap<BlockNumberFor<T>, Vec<R>>, DispatchError>
     where
         F: FnMut(&mut Proposal<T>) -> R,
     {

zrml/neo-swaps/src/benchmarking.rs

@@ -21,7 +21,7 @@ use super::*;
 use crate::{
     liquidity_tree::{traits::LiquidityTreeHelper, types::LiquidityTree},
     traits::{LiquiditySharesManager, PoolOperations, PoolStorage},
-    types::DecisionMarketOracle,
+    types::{DecisionMarketOracle, DecisionMarketOracleScoreboard},
     AssetOf, BalanceOf, MarketIdOf, Pallet as NeoSwaps, Pools, MIN_SPOT_PRICE,
 };
 use alloc::{vec, vec::Vec};
@@ -671,7 +671,13 @@ mod benchmarks {
         let pool = Pools::<T>::get(market_id).unwrap();
         let assets = pool.assets();
 
-        let oracle = DecisionMarketOracle::<T>::new(market_id, assets[0], assets[1]);
+        let scoreboard = DecisionMarketOracleScoreboard::<T>::new(
+            Zero::zero(),
+            Zero::zero(),
+            Zero::zero(),
+            Zero::zero(),
+        );
+        let oracle = DecisionMarketOracle::<T>::new(market_id, assets[0], assets[1], scoreboard);
 
         #[block]
         {

zrml/neo-swaps/src/types/decision_market_benchmark_helper.rs

@@ -19,7 +19,7 @@
 
 use crate::{
     liquidity_tree::types::LiquidityTree,
-    types::{DecisionMarketOracle, Pool, PoolType},
+    types::{DecisionMarketOracle, DecisionMarketOracleScoreboard, Pool, PoolType},
     BalanceOf, Config, MarketIdOf, Pallet, Pools,
 };
 use alloc::{collections::BTreeMap, vec};
@@ -58,6 +58,13 @@ where
             reserves.insert(negative_outcome, one);
         }
 
+        let scoreboard = DecisionMarketOracleScoreboard::new(
+            Zero::zero(),
+            Zero::zero(),
+            Zero::zero(),
+            Zero::zero(),
+        );
+
         let account_id: T::AccountId = Pallet::<T>::pool_account_id(&pool_id);
         let pool = Pool {
             account_id: account_id.clone(),
@@ -72,6 +79,6 @@ where
 
         Pools::<T>::insert(pool_id, pool);
 
-        DecisionMarketOracle::new(pool_id, positive_outcome, negative_outcome)
+        DecisionMarketOracle::new(pool_id, positive_outcome, negative_outcome, scoreboard)
     }
 }

zrml/neo-swaps/src/types/decision_market_oracle.rs

@@ -15,14 +15,21 @@
 // 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::{traits::PoolOperations, weights::WeightInfoZeitgeist, AssetOf, Config, Error, Pools};
+use crate::{
+    traits::PoolOperations, types::DecisionMarketOracleScoreboard, weights::WeightInfoZeitgeist,
+    AssetOf, BalanceOf, Config, Error, Pools,
+};
 use frame_support::pallet_prelude::Weight;
 use frame_system::pallet_prelude::BlockNumberFor;
 use parity_scale_codec::{Decode, Encode, MaxEncodedLen};
 use scale_info::TypeInfo;
-use sp_runtime::{traits::Zero, DispatchError};
+use sp_runtime::DispatchError;
 use zeitgeist_primitives::traits::FutarchyOracle;
 
+/// Struct that implements `FutarchyOracle` using price measurements from liquidity pools.
+///
+/// The oracle evaluates to `true` if and only if the `positive_outcome` is more valuable than the
+/// `negative_outcome` in the liquidity pool specified by `pool_id`.
 #[derive(Clone, Debug, Decode, Encode, Eq, MaxEncodedLen, PartialEq, TypeInfo)]
 pub struct DecisionMarketOracle<T>
 where
@@ -31,6 +38,7 @@ where
     pool_id: T::PoolId,
     positive_outcome: AssetOf<T>,
     negative_outcome: AssetOf<T>,
+    scoreboard: DecisionMarketOracleScoreboard<T>,
 }
 
 impl<T> DecisionMarketOracle<T>
@@ -41,22 +49,19 @@ where
         pool_id: T::PoolId,
         positive_outcome: AssetOf<T>,
         negative_outcome: AssetOf<T>,
+        scoreboard: DecisionMarketOracleScoreboard<T>,
     ) -> Self {
-        Self { pool_id, positive_outcome, negative_outcome }
+        Self { pool_id, positive_outcome, negative_outcome, scoreboard }
     }
 
-    // Utility implementation that uses the question mark operator to implement a fallible version
-    // of `evaluate`.
-    fn try_evaluate(&self) -> Result<bool, DispatchError> {
+    fn try_get_prices(&self) -> Result<(BalanceOf<T>, BalanceOf<T>), DispatchError> {
         let pool = Pools::<T>::get(self.pool_id)
             .ok_or::<DispatchError>(Error::<T>::PoolNotFound.into())?;
 
         let positive_value = pool.calculate_spot_price(self.positive_outcome)?;
         let negative_value = pool.calculate_spot_price(self.negative_outcome)?;
 
-        let success = positive_value > negative_value;
-
-        Ok(success)
+        Ok((positive_value, negative_value))
     }
 }
 
@@ -67,14 +72,18 @@ where
     type BlockNumber = BlockNumberFor<T>;
 
     fn evaluate(&self) -> (Weight, bool) {
-        // Err on the side of caution if the pool is not found or a calculation fails by not
-        // enacting the policy.
-        let value = self.try_evaluate().unwrap_or(false);
-
-        (T::WeightInfo::decision_market_oracle_evaluate(), value)
+        (T::WeightInfo::decision_market_oracle_evaluate(), self.scoreboard.evaluate())
     }
 
-    fn update(&mut self, _: Self::BlockNumber) -> Weight {
-        Zero::zero()
+    fn update(&mut self, now: Self::BlockNumber) -> Weight {
+        if let Ok((positive_outcome_price, negative_outcome_price)) = self.try_get_prices() {
+            self.scoreboard.update(now, positive_outcome_price, negative_outcome_price);
+        } else {
+            // Err on the side of caution if the pool is not found or a calculation fails by not
+            // enacting the policy.
+            self.scoreboard.skip_update(now);
+        }
+
+        Weight::zero() // TODO
     }
 }

zrml/neo-swaps/src/types/decision_market_oracle_scoreboard.rs

@@ -0,0 +1,100 @@
+use crate::{BalanceOf, Config};
+use frame_system::pallet_prelude::BlockNumberFor;
+use parity_scale_codec::{Decode, Encode, MaxEncodedLen};
+use scale_info::TypeInfo;
+use sp_runtime::{traits::Zero, Saturating};
+use zeitgeist_primitives::math::fixed::FixedDiv;
+
+/// Records until the end of time.
+#[derive(Clone, Debug, Decode, Encode, Eq, MaxEncodedLen, PartialEq, TypeInfo)]
+pub struct DecisionMarketOracleScoreboard<T>
+where
+    T: Config,
+{
+    /// The block at which the oracle records its first tick.
+    start: BlockNumberFor<T>,
+
+    /// The number of ticks the positive outcome requires to have
+    victory_margin: u128,
+
+    /// The absolute minimum difference in prices required for the positive outcome to receive a
+    /// point.
+    price_margin_abs: BalanceOf<T>,
+
+    /// The relative minimum difference in prices required for the positive outcome to receive a
+    /// point, specified as fractional (i.e. 0.1 represents 10%).
+    price_margin_rel: BalanceOf<T>,
+
+    /// The number of ticks for the positive outcome.
+    pass_score: u128,
+
+    /// The number of ticks for the negative outcome.
+    reject_score: u128,
+}
+
+impl<T> DecisionMarketOracleScoreboard<T>
+where
+    T: Config,
+{
+    pub fn new(
+        start: BlockNumberFor<T>,
+        victory_margin: u128,
+        price_margin_abs: BalanceOf<T>,
+        price_margin_rel: BalanceOf<T>,
+    ) -> DecisionMarketOracleScoreboard<T> {
+        DecisionMarketOracleScoreboard {
+            start,
+            victory_margin,
+            price_margin_abs,
+            price_margin_rel,
+            pass_score: 0,
+            reject_score: 0,
+        }
+    }
+
+    pub fn update(
+        &mut self,
+        now: BlockNumberFor<T>,
+        positive_outcome_price: BalanceOf<T>,
+        negative_outcome_price: BalanceOf<T>,
+    ) {
+        if now < self.start {
+            return;
+        }
+
+        // Saturation is fine as that just means that the negative outcome is more valuable than the
+        // positive outcome.
+        let margin_abs = positive_outcome_price.saturating_sub(negative_outcome_price);
+        // In case of error, we're using zero here as a defensive default value.
+        let margin_rel = margin_abs.bdiv(negative_outcome_price).unwrap_or(Zero::zero());
+
+        if margin_abs >= self.price_margin_abs && margin_rel >= self.price_margin_rel {
+            // Saturation is fine as that would mean the oracle has been collecting data for
+            // hundreds of years.
+            self.pass_score.saturating_inc();
+        } else {
+            // Saturation is fine as that would mean the oracle has been collecting data for
+            // hundreds of years.
+            self.reject_score.saturating_inc();
+        }
+    }
+
+    pub fn evaluate(&self) -> bool {
+        // Saturating is fine as that just means that the `reject_score` is higher than `pass_score`
+        // anyways.
+        let score_margin = self.pass_score.saturating_sub(self.reject_score);
+
+        score_margin >= self.victory_margin
+    }
+
+    /// Skips update on this block and awards a point to the negative outcome.
+    pub fn skip_update(&mut self, now: BlockNumberFor<T>) {
+        if now < self.start {
+            return;
+        }
+
+        // Saturation is fine as that would mean the oracle has been collecting data for
+        // hundreds of years.
+        self.reject_score.saturating_inc();
+    }
+}

zrml/neo-swaps/src/types/mod.rs

@@ -17,6 +17,7 @@
 
 mod decision_market_benchmark_helper;
 mod decision_market_oracle;
+mod decision_market_oracle_scoreboard;
 mod fee_distribution;
 mod max_assets;
 mod pool;
@@ -25,6 +26,7 @@ mod pool_type;
 #[cfg(feature = "runtime-benchmarks")]
 pub use decision_market_benchmark_helper::*;
 pub use decision_market_oracle::*;
+pub use decision_market_oracle_scoreboard::*;
 pub(crate) use fee_distribution::*;
 pub(crate) use max_assets::*;
 pub(crate) use pool::*;