betex 0.4.0

Betfair / Prediction Market Exchange
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

//! Cross-matching configuration types.

use crate::types::{AccountId, Money};
use rust_decimal::Decimal;

/// Risk tolerance settings for cross-matching.
///
/// Controls how much loss the exchange is willing to accept per cross-match
/// and in aggregate across all unsettled positions.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct RiskTolerance {
    /// Maximum loss as percentage of user's stake.
    /// - 0.0 = risk-free only
    /// - 0.05 = allow up to 5% loss relative to stake
    pub max_loss_pct: Decimal,

    /// Absolute cap on loss per cross-match (regardless of percentage).
    /// Prevents runaway losses on large bets.
    pub max_loss_absolute: Money,

    /// Maximum aggregate exposure across all unsettled cross-matches.
    /// Circuit breaker - reject new cross-matches if breached.
    pub max_total_exposure: Money,
}

impl Default for RiskTolerance {
    /// Default is completely risk-free (no tolerance).
    fn default() -> Self {
        Self {
            max_loss_pct: Decimal::ZERO,
            max_loss_absolute: Money(0),
            max_total_exposure: Money(0),
        }
    }
}

impl RiskTolerance {
    /// Create a risk-free configuration (P&L >= 0 in all outcomes).
    pub fn risk_free() -> Self {
        Self::default()
    }

    /// Conservative preset: tiny tolerance for rounding only.
    ///
    /// - 0.01% of stake
    /// - Max $1 per match
    /// - Max $100 aggregate
    pub fn conservative() -> Self {
        Self {
            max_loss_pct: Decimal::new(1, 4),              // 0.0001 = 0.01%
            max_loss_absolute: Money::from_cents(100),     // $1
            max_total_exposure: Money::from_cents(10_000), // $100
        }
    }

    /// Moderate preset: small tolerance to improve fill rates.
    ///
    /// - 1% of stake
    /// - Max $100 per match
    /// - Max $1,000 aggregate
    pub fn moderate() -> Self {
        Self {
            max_loss_pct: Decimal::new(1, 2),               // 0.01 = 1%
            max_loss_absolute: Money::from_cents(10_000),   // $100
            max_total_exposure: Money::from_cents(100_000), // $1,000
        }
    }

    /// Calculate effective tolerance for a given stake.
    ///
    /// Returns the minimum of (stake * pct) and absolute cap.
    pub fn effective_tolerance(&self, stake: Money) -> Money {
        let pct_tolerance = self.max_loss_pct * Decimal::from(stake.0);
        let pct_money = Money(pct_tolerance.try_into().unwrap_or(i64::MAX));
        Money(pct_money.0.min(self.max_loss_absolute.0))
    }
}

/// Configuration for the cross-matching engine.
#[derive(Debug, Clone)]
pub struct CrossMatchConfig {
    /// Maximum runners supported for cross-matching.
    /// v1 only supports 3-runner markets (e.g., soccer 1X2).
    pub max_runners: usize,

    /// House account used for placing hedge legs.
    /// This account takes the opposite side of user orders and places hedges.
    pub house_account: AccountId,

    /// Risk tolerance settings.
    pub risk: RiskTolerance,

    /// Whether to attempt cross-match when an order partially fills
    /// against direct liquidity and has remaining size.
    pub cross_match_remainder: bool,
}

impl Default for CrossMatchConfig {
    fn default() -> Self {
        Self {
            max_runners: 3,
            house_account: AccountId(0), // Reserved for house
            risk: RiskTolerance::default(),
            cross_match_remainder: true,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn default_is_risk_free() {
        let config = RiskTolerance::default();
        assert_eq!(config.max_loss_pct, Decimal::ZERO);
        assert_eq!(config.max_loss_absolute, Money(0));
        assert_eq!(config.max_total_exposure, Money(0));
    }

    #[test]
    fn effective_tolerance_uses_minimum() {
        let config = RiskTolerance {
            max_loss_pct: Decimal::new(5, 2),            // 5%
            max_loss_absolute: Money::from_cents(1_000), // $10
            max_total_exposure: Money(10_000),
        };

        // Small stake: percentage is limiting factor
        // $100 stake * 5% = $5, which is less than $10 cap
        assert_eq!(
            config.effective_tolerance(Money::from_cents(10_000)),
            Money::from_cents(500)
        );

        // Large stake: absolute cap is limiting factor
        // $1000 stake * 5% = $50, but cap is $10
        assert_eq!(
            config.effective_tolerance(Money::from_cents(100_000)),
            Money::from_cents(1_000)
        );
    }

    #[test]
    fn risk_free_has_zero_tolerance() {
        let config = RiskTolerance::risk_free();
        assert_eq!(config.effective_tolerance(Money(100_000)), Money(0));
    }

    #[test]
    fn default_config_flags() {
        let config = CrossMatchConfig::default();
        assert_eq!(config.max_runners, 3);
        assert_eq!(config.house_account, AccountId(0));
        assert!(config.cross_match_remainder);
    }
}