Implement Parimutuel markets

Cargo.toml

@@ -12,6 +12,7 @@ default-members = [
     "zrml/market-commons",
     "zrml/neo-swaps",
     "zrml/orderbook-v1",
+    "zrml/parimutuel",
     "zrml/prediction-markets",
     "zrml/prediction-markets/runtime-api",
     "zrml/rikiddo",
@@ -35,6 +36,7 @@ members = [
     "zrml/neo-swaps",
     "zrml/orderbook-v1",
     "zrml/orderbook-v1/fuzz",
+    "zrml/parimutuel",
     "zrml/prediction-markets",
     "zrml/prediction-markets/fuzz",
     "zrml/prediction-markets/runtime-api",
@@ -233,6 +235,7 @@ zrml-liquidity-mining = { path = "zrml/liquidity-mining", default-features = fal
 zrml-market-commons = { path = "zrml/market-commons", default-features = false }
 zrml-neo-swaps = { path = "zrml/neo-swaps", default-features = false }
 zrml-orderbook-v1 = { path = "zrml/orderbook-v1", default-features = false }
+zrml-parimutuel = { path = "zrml/parimutuel", default-features = false }
 zrml-prediction-markets = { path = "zrml/prediction-markets", default-features = false }
 zrml-prediction-markets-runtime-api = { path = "zrml/prediction-markets/runtime-api", default-features = false }
 zrml-rikiddo = { path = "zrml/rikiddo", default-features = false }

README.md

@@ -36,6 +36,8 @@ _anything_.
 - [orderbook-v1](./zrml/orderbook-v1) - A naive orderbook implementation that's
   only part of Zeitgeist's PoC. Will be replaced by a v2 orderbook that uses
   0x-style hybrid on-chain and off-chain trading.
+- [parimutuel](./zrml/parimutuel) - A straightforward parimutuel market maker
+  for categorical markets.
 - [prediction-markets](./zrml/prediction-markets) - The core implementation of
   the prediction market logic for creating and resolving markets.
 - [simple-disputes](./zrml-simple-disputes) - Simple disputes selects the last

docs/changelog_for_devs.md

@@ -15,6 +15,27 @@ APIs/RPC interface.
 ## v0.4.2
 
 [#1148]: https://github.com/zeitgeistpm/zeitgeist/pull/1148
+[#1138]: https://github.com/zeitgeistpm/zeitgeist/pull/1138
+
+### Added
+
+- Implement parimutuel market ([#1138]) maker to allow markets without liquidity
+  provision. The new pallet has the following dispatchables:
+
+  - `buy`: Buy outcome tokens.
+  - `claim_rewards`: Claim the winner outcome tokens.
+  - `claim_refunds`: Claim the refunds in case there was no winner.
+
+  The new pallet has the following events:
+
+  - `OutcomeBought { market_id, buyer, asset, amount_minus_fees, fees }`:
+    Informant bought a position.
+  - `RewardsClaimed { market_id, asset, balance, actual_payoff, sender }`:
+    Informant claimed rewards.
+  - `RefundsClaimed { market_id, asset, refunded_balance, sender }`: Informant
+    claimed refunds.
+
+  For details, please refer to the `README.md` and the in-file documentation.
 
 ### Changed
 

primitives/src/asset.rs

@@ -1,4 +1,4 @@
-// Copyright 2022 Forecasting Technologies LTD.
+// Copyright 2022-2023 Forecasting Technologies LTD.
 // Copyright 2021-2022 Zeitgeist PM LLC.
 //
 // This file is part of Zeitgeist.
@@ -50,6 +50,7 @@ pub enum Asset<MI: MaxEncodedLen> {
     #[default]
     Ztg,
     ForeignAsset(u32),
+    ParimutuelShare(MI, CategoryIndex),
 }
 
 /// In a scalar market, users can either choose a `Long` position,

primitives/src/constants.rs

@@ -120,6 +120,9 @@ pub const SWAPS_PALLET_ID: PalletId = PalletId(*b"zge/swap");
 // Orderbook
 pub const ORDERBOOK_PALLET_ID: PalletId = PalletId(*b"zge/ordb");
 
+// Parimutuel
+pub const PARIMUTUEL_PALLET_ID: PalletId = PalletId(*b"zge/prmt");
+
 // Treasury
 /// Pallet identifier, used to derive treasury account
 pub const TREASURY_PALLET_ID: PalletId = PalletId(*b"zge/tsry");

primitives/src/constants/mock.rs

@@ -132,6 +132,12 @@ parameter_types! {
     pub const OrderbookPalletId: PalletId = PalletId(*b"zge/ordb");
 }
 
+// Parimutuel parameters
+parameter_types! {
+    pub const ParimutuelPalletId: PalletId = PalletId(*b"zge/prmt");
+    pub const MinBetSize: Balance = BASE;
+}
+
 // Shared within tests
 // Balance
 parameter_types! {

primitives/src/market.rs

@@ -66,6 +66,22 @@ pub struct Market<AI, BA, BN, M, A> {
     pub bonds: MarketBonds<AI, BA>,
 }
 
+impl<AI, BA, BN, M, A> Market<AI, BA, BN, M, A> {
+    pub fn resolution_mechanism(&self) -> ResolutionMechanism {
+        match self.scoring_rule {
+            ScoringRule::CPMM
+            | ScoringRule::Lmsr
+            | ScoringRule::Orderbook
+            | ScoringRule::RikiddoSigmoidFeeMarketEma => ResolutionMechanism::RedeemTokens,
+            ScoringRule::Parimutuel => ResolutionMechanism::Noop,
+        }
+    }
+
+    pub fn is_redeemable(&self) -> bool {
+        matches!(self.resolution_mechanism(), ResolutionMechanism::RedeemTokens)
+    }
+}
+
 /// Tracks the status of a bond.
 #[derive(Clone, Decode, Encode, MaxEncodedLen, PartialEq, Eq, RuntimeDebug, TypeInfo)]
 pub struct Bond<AI, BA> {
@@ -303,6 +319,11 @@ pub struct AuthorityReport<BlockNumber> {
     pub outcome: OutcomeReport,
 }
 
+pub enum ResolutionMechanism {
+    RedeemTokens,
+    Noop,
+}
+
 /// Contains a market id and the market period.
 ///
 /// * `BN`: Block Number

primitives/src/math/fixed.rs

@@ -54,12 +54,24 @@ pub fn bmul(a: u128, b: u128) -> Result<u128, DispatchError> {
     c1.check_div_rslt(&BASE)
 }
 
+pub fn bmul_floor(a: u128, b: u128) -> Result<u128, DispatchError> {
+    // checked_mul already rounds down
+    let c0 = a.check_mul_rslt(&b)?;
+    c0.check_div_rslt(&BASE)
+}
+
 pub fn bdiv(a: u128, b: u128) -> Result<u128, DispatchError> {
     let c0 = a.check_mul_rslt(&BASE)?;
     let c1 = c0.check_add_rslt(&b.check_div_rslt(&2)?)?;
     c1.check_div_rslt(&b)
 }
 
+pub fn bdiv_floor(a: u128, b: u128) -> Result<u128, DispatchError> {
+    let c0 = a.check_mul_rslt(&BASE)?;
+    // checked_div already rounds down
+    c0.check_div_rslt(&b)
+}
+
 pub fn bpowi(a: u128, n: u128) -> Result<u128, DispatchError> {
     let mut z = if n % 2 != 0 { a } else { BASE };
 
@@ -353,6 +365,18 @@ mod tests {
         };
     }
 
+    #[test]
+    fn bmul_rounding_behaviours() {
+        assert_eq!(bmul(3u128, 33_333_333_333u128).unwrap(), 10u128);
+        assert_eq!(bmul_floor(3u128, 33_333_333_333u128).unwrap(), 9u128);
+    }
+
+    #[test]
+    fn bdiv_rounding_behaviors() {
+        assert_eq!(bdiv(14u128, 3u128).unwrap(), 46_666_666_667u128);
+        assert_eq!(bdiv_floor(14u128, 3u128).unwrap(), 46_666_666_666u128);
+    }
+
     #[test]
     fn bdiv_has_minimum_set_of_correct_values() {
         create_tests!(

primitives/src/pool.rs

@@ -86,4 +86,5 @@ pub enum ScoringRule {
     RikiddoSigmoidFeeMarketEma,
     Lmsr,
     Orderbook,
+    Parimutuel,
 }

primitives/src/traits.rs

@@ -19,6 +19,7 @@
 mod complete_set_operations_api;
 mod deploy_pool_api;
 mod dispute_api;
+mod distribute_fees;
 mod market_commons_pallet_api;
 mod market_id;
 mod swaps;
@@ -27,6 +28,7 @@ mod zeitgeist_multi_reservable_currency;
 pub use complete_set_operations_api::CompleteSetOperationsApi;
 pub use deploy_pool_api::DeployPoolApi;
 pub use dispute_api::{DisputeApi, DisputeMaxWeightApi, DisputeResolutionApi};
+pub use distribute_fees::DistributeFees;
 pub use market_commons_pallet_api::MarketCommonsPalletApi;
 pub use market_id::MarketId;
 pub use swaps::Swaps;

zrml/neo-swaps/src/traits/distribute_fees.rs → primitives/src/traits/distribute_fees.rs

@@ -37,7 +37,7 @@ pub trait DistributeFees {
     fn distribute(
         market_id: Self::MarketId,
         asset: Self::Asset,
-        account: Self::AccountId,
+        account: &Self::AccountId,
         amount: Self::Balance,
     ) -> Self::Balance;
 }

runtime/battery-station/Cargo.toml

@@ -114,6 +114,7 @@ zrml-liquidity-mining = { workspace = true }
 zrml-market-commons = { workspace = true }
 zrml-neo-swaps = { workspace = true }
 zrml-orderbook-v1 = { workspace = true }
+zrml-parimutuel = { workspace = true }
 zrml-prediction-markets = { workspace = true }
 zrml-rikiddo = { workspace = true }
 zrml-simple-disputes = { workspace = true }
@@ -211,6 +212,7 @@ runtime-benchmarks = [
     "zrml-court/runtime-benchmarks",
     "zrml-liquidity-mining/runtime-benchmarks",
     "zrml-neo-swaps/runtime-benchmarks",
+    "zrml-parimutuel/runtime-benchmarks",
     "zrml-prediction-markets/runtime-benchmarks",
     "zrml-simple-disputes/runtime-benchmarks",
     "zrml-global-disputes/runtime-benchmarks",
@@ -325,6 +327,7 @@ std = [
     "zrml-liquidity-mining/std",
     "zrml-market-commons/std",
     "zrml-neo-swaps/std",
+    "zrml-parimutuel/std",
     "zrml-prediction-markets/std",
     "zrml-rikiddo/std",
     "zrml-simple-disputes/std",
@@ -380,6 +383,7 @@ try-runtime = [
     "zrml-liquidity-mining/try-runtime",
     "zrml-market-commons/try-runtime",
     "zrml-neo-swaps/try-runtime",
+    "zrml-parimutuel/try-runtime",
     "zrml-prediction-markets/try-runtime",
     "zrml-rikiddo/try-runtime",
     "zrml-simple-disputes/try-runtime",

runtime/battery-station/src/lib.rs

@@ -48,10 +48,7 @@ use frame_support::{
 use frame_system::{EnsureRoot, EnsureWithSuccess};
 use orml_currencies::Call::transfer;
 use pallet_collective::{EnsureProportionAtLeast, PrimeDefaultVote};
-use sp_runtime::{
-    traits::{AccountIdConversion, AccountIdLookup, BlakeTwo256},
-    DispatchError,
-};
+use sp_runtime::traits::{AccountIdConversion, AccountIdLookup, BlakeTwo256};
 #[cfg(feature = "std")]
 use sp_version::NativeVersion;
 use substrate_fixed::{types::extra::U33, FixedI128, FixedU128};

runtime/battery-station/src/parameters.rs

@@ -312,6 +312,10 @@ parameter_types! {
     // Orderbook parameters
     pub const OrderbookPalletId: PalletId = ORDERBOOK_PALLET_ID;
 
+    // Parimutuel parameters
+    pub const MinBetSize: Balance = 50 * CENT;
+    pub const ParimutuelPalletId: PalletId = PARIMUTUEL_PALLET_ID;
+
     // System
     pub const BlockHashCount: u64 = 250;
     pub const SS58Prefix: u8 = 73;
@@ -466,6 +470,7 @@ parameter_type_with_key! {
             #[cfg(not(feature = "parachain"))]
             Asset::ForeignAsset(_) => ExistentialDeposit::get(),
             Asset::Ztg => ExistentialDeposit::get(),
+            Asset::ParimutuelShare(_,_) => ExistentialDeposit::get(),
         }
     };
 }

runtime/common/src/fees.rs

@@ -237,6 +237,53 @@ macro_rules! impl_foreign_fees {
     };
 }
 
+#[macro_export]
+macro_rules! impl_market_creator_fees {
+    () => {
+        pub struct MarketCreatorFee;
+
+        /// Uses the `creator_fee` field defined by the specified market to deduct a fee for the market's
+        /// creator. Calling `distribute` is noop if the market doesn't exist or the transfer fails for any
+        /// reason.
+        impl DistributeFees for MarketCreatorFee {
+            type Asset = Asset<MarketId>;
+            type AccountId = AccountId;
+            type Balance = Balance;
+            type MarketId = MarketId;
+
+            fn distribute(
+                market_id: Self::MarketId,
+                asset: Self::Asset,
+                account: &Self::AccountId,
+                amount: Self::Balance,
+            ) -> Self::Balance {
+                Self::do_distribute(market_id, asset, account, amount)
+                    .unwrap_or_else(|_| 0u8.saturated_into())
+            }
+        }
+
+        impl MarketCreatorFee {
+            fn do_distribute(
+                market_id: MarketId,
+                asset: Asset<MarketId>,
+                account: &AccountId,
+                amount: Balance,
+            ) -> Result<Balance, DispatchError> {
+                let market = MarketCommons::market(&market_id)?; // Should never fail
+                let fee_amount = market.creator_fee.mul_floor(amount);
+                // Might fail if the transaction is too small
+                <AssetManager as MultiCurrency<_>>::transfer(
+                    asset,
+                    account,
+                    &market.creator,
+                    fee_amount,
+                )?;
+                Ok(fee_amount)
+            }
+        }
+    };
+}
+
 #[macro_export]
 macro_rules! fee_tests {
     () => {