Skip to main content

qualia_core_db/specialized_libs/financial_modeling/
settlement.rs

1use super::*;
2
3/// Settlement engine
4pub struct SettlementEngine {
5    settlement_methods: HashMap<String, SettlementMethod>,
6    clearing_house: ClearingHouse,
7    settlement_validator: SettlementValidator,
8}
9
10/// Settlement methods
11#[derive(Debug, Clone)]
12pub struct SettlementMethod {
13    pub method_id: String,
14    pub method_name: String,
15    pub method_type: SettlementMethodType,
16    pub settlement_cycle: u32,
17}
18
19/// Settlement method types
20#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
21pub enum SettlementMethodType {
22    TPlus0,
23    TPlus1,
24    TPlus2,
25    TPlus3,
26    Continuous,
27}
28
29/// Clearing house
30pub struct ClearingHouse {
31    pub house_id: String,
32    pub house_name: String,
33    pub margin_requirements: MarginRequirements,
34    pub risk_management: RiskManagement,
35}
36
37/// Margin requirements
38#[derive(Debug, Clone)]
39pub struct MarginRequirements {
40    pub initial_margin: f64,
41    pub maintenance_margin: f64,
42    pub variation_margin: f64,
43}
44
45/// Risk management
46#[derive(Debug, Clone)]
47pub struct RiskManagement {
48    pub position_limits: HashMap<String, f64>,
49    pub stress_scenarios: Vec<String>,
50    pub collateral_requirements: CollateralRequirements,
51}
52
53/// Collateral requirements
54#[derive(Debug, Clone)]
55pub struct CollateralRequirements {
56    pub haircuts: HashMap<String, f64>,
57    pub concentration_limits: HashMap<String, f64>,
58    pub eligible_collateral: Vec<String>,
59}
60
61/// Settlement validator
62pub struct SettlementValidator {
63    validation_rules: Vec<SettlementValidationRule>,
64    compliance_checker: SettlementComplianceChecker,
65}
66
67/// Settlement validation rules
68#[derive(Debug, Clone)]
69pub struct SettlementValidationRule {
70    pub rule_id: String,
71    pub rule_type: SettlementValidationRuleType,
72    pub condition: String,
73    pub action: SettlementValidationAction,
74}
75
76/// Settlement validation rule types
77#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
78pub enum SettlementValidationRuleType {
79    Funds,
80    Securities,
81    Timing,
82    Compliance,
83}
84
85/// Settlement validation actions
86#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
87pub enum SettlementValidationAction {
88    Approve,
89    Reject,
90    Hold,
91    Escalate,
92}
93
94/// Settlement compliance checker
95pub struct SettlementComplianceChecker {
96    compliance_rules: Vec<SettlementComplianceRule>,
97    regulatory_requirements: Vec<RegulatoryRequirement>,
98}
99
100/// Settlement compliance rules
101#[derive(Debug, Clone)]
102pub struct SettlementComplianceRule {
103    pub rule_id: String,
104    pub rule_name: String,
105    pub conditions: Vec<SettlementComplianceCondition>,
106    pub actions: Vec<SettlementComplianceAction>,
107}
108
109/// Settlement compliance conditions
110#[derive(Debug, Clone)]
111pub struct SettlementComplianceCondition {
112    pub condition_id: String,
113    pub field: String,
114    pub operator: ComparisonOperator,
115    pub value: SettlementComplianceValue,
116}
117
118/// Settlement compliance values
119#[derive(Debug, Clone)]
120pub enum SettlementComplianceValue {
121    String(String),
122    Number(f64),
123    Boolean(bool),
124}
125
126/// Settlement compliance actions
127#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
128pub enum SettlementComplianceAction {
129    Approve,
130    Reject,
131    Flag,
132    Escalate,
133}
134
135impl SettlementEngine {
136    /// Creates a `SettlementEngine` with empty registries / default configuration.
137    pub fn new() -> Self {
138        Self {
139            settlement_methods: HashMap::new(),
140            clearing_house: ClearingHouse::new(),
141            settlement_validator: SettlementValidator::new(),
142        }
143    }
144
145    /// Readies the `SettlementEngine` sub-components; registers/populates any built-in defaults.
146    pub fn initialize(&mut self) -> Result<(), FinancialError> {
147        Ok(())
148    }
149
150    /// Registers `settlement method` in the registry (keyed by its id).
151    pub fn add_settlement_method(&mut self, method: SettlementMethod) {
152        self.settlement_methods
153            .insert(method.method_id.clone(), method);
154    }
155
156    /// Looks up `settlement method` by id; `None` if not registered.
157    pub fn get_settlement_method(&self, method_id: &str) -> Option<&SettlementMethod> {
158        self.settlement_methods.get(method_id)
159    }
160
161    /// Iterates over all registered `settlement methods` entries.
162    pub fn list_settlement_methods(&self) -> Vec<String> {
163        self.settlement_methods.keys().cloned().collect()
164    }
165
166    /// Returns a reference to the inner `clearing_house` sub-component.
167    pub fn clearing_house(&self) -> &ClearingHouse {
168        &self.clearing_house
169    }
170
171    /// Mutable access to the inner `clearing_house` sub-component.
172    pub fn clearing_house_mut(&mut self) -> &mut ClearingHouse {
173        &mut self.clearing_house
174    }
175
176    /// Returns a reference to the inner `settlement_validator` sub-component.
177    pub fn settlement_validator(&self) -> &SettlementValidator {
178        &self.settlement_validator
179    }
180
181    /// Mutable access to the inner `settlement_validator` sub-component.
182    pub fn settlement_validator_mut(&mut self) -> &mut SettlementValidator {
183        &mut self.settlement_validator
184    }
185}
186
187impl ClearingHouse {
188    /// Creates a `ClearingHouse` with empty registries / default configuration.
189    pub fn new() -> Self {
190        Self {
191            house_id: "default".to_string(),
192            house_name: "Default Clearing House".to_string(),
193            margin_requirements: MarginRequirements::new(),
194            risk_management: RiskManagement::new(),
195        }
196    }
197}
198
199impl MarginRequirements {
200    /// Creates a `MarginRequirements` with empty registries / default configuration.
201    pub fn new() -> Self {
202        Self {
203            initial_margin: 0.5,
204            maintenance_margin: 0.25,
205            variation_margin: 0.1,
206        }
207    }
208}
209
210impl RiskManagement {
211    /// Creates a `RiskManagement` with empty registries / default configuration.
212    pub fn new() -> Self {
213        Self {
214            position_limits: HashMap::new(),
215            stress_scenarios: Vec::new(),
216            collateral_requirements: CollateralRequirements::new(),
217        }
218    }
219}
220
221impl CollateralRequirements {
222    /// Creates a `CollateralRequirements` with empty registries / default configuration.
223    pub fn new() -> Self {
224        Self {
225            haircuts: HashMap::new(),
226            concentration_limits: HashMap::new(),
227            eligible_collateral: Vec::new(),
228        }
229    }
230}
231
232impl SettlementValidator {
233    /// Creates a `SettlementValidator` with empty registries / default configuration.
234    pub fn new() -> Self {
235        Self {
236            validation_rules: Vec::new(),
237            compliance_checker: SettlementComplianceChecker::new(),
238        }
239    }
240
241    /// Registers `validation rule` in the registry (keyed by its id).
242    pub fn add_validation_rule(&mut self, rule: SettlementValidationRule) {
243        self.validation_rules.push(rule);
244    }
245
246    /// Iterates over all registered `validation rules` entries.
247    pub fn list_validation_rules(&self) -> &[SettlementValidationRule] {
248        &self.validation_rules
249    }
250
251    /// Returns a reference to the inner `compliance_checker` sub-component.
252    pub fn compliance_checker(&self) -> &SettlementComplianceChecker {
253        &self.compliance_checker
254    }
255
256    /// Mutable access to the inner `compliance_checker` sub-component.
257    pub fn compliance_checker_mut(&mut self) -> &mut SettlementComplianceChecker {
258        &mut self.compliance_checker
259    }
260}
261
262impl SettlementComplianceChecker {
263    /// Creates a `SettlementComplianceChecker` with empty registries / default configuration.
264    pub fn new() -> Self {
265        Self {
266            compliance_rules: Vec::new(),
267            regulatory_requirements: Vec::new(),
268        }
269    }
270
271    /// Registers `compliance rule` in the registry (keyed by its id).
272    pub fn add_compliance_rule(&mut self, rule: SettlementComplianceRule) {
273        self.compliance_rules.push(rule);
274    }
275
276    /// Iterates over all registered `compliance rules` entries.
277    pub fn list_compliance_rules(&self) -> &[SettlementComplianceRule] {
278        &self.compliance_rules
279    }
280
281    /// Registers `regulatory requirement` in the registry (keyed by its id).
282    pub fn add_regulatory_requirement(&mut self, requirement: RegulatoryRequirement) {
283        self.regulatory_requirements.push(requirement);
284    }
285
286    /// Iterates over all registered `regulatory requirements` entries.
287    pub fn list_regulatory_requirements(&self) -> &[RegulatoryRequirement] {
288        &self.regulatory_requirements
289    }
290}
291
292impl SettlementMethod {
293    /// Creates a `SettlementMethod` with empty registries / default configuration.
294    pub fn new() -> Self {
295        Self {
296            method_id: "settle_1".to_string(),
297            method_name: "T+2".to_string(),
298            method_type: SettlementMethodType::TPlus2,
299            settlement_cycle: 2,
300        }
301    }
302}
303
304impl SettlementValidationRule {
305    /// Creates a `SettlementValidationRule` with empty registries / default configuration.
306    pub fn new() -> Self {
307        Self {
308            rule_id: "rule_1".to_string(),
309            rule_type: SettlementValidationRuleType::Funds,
310            condition: "sufficient_funds".to_string(),
311            action: SettlementValidationAction::Approve,
312        }
313    }
314}
315
316impl SettlementComplianceCondition {
317    /// Creates a `SettlementComplianceCondition` with empty registries / default configuration.
318    pub fn new() -> Self {
319        Self {
320            condition_id: "cond_1".to_string(),
321            field: "funds".to_string(),
322            operator: ComparisonOperator::GreaterThan,
323            value: SettlementComplianceValue::Number(0.0),
324        }
325    }
326}
327
328impl SettlementComplianceRule {
329    /// Creates a `SettlementComplianceRule` with empty registries / default configuration.
330    pub fn new() -> Self {
331        Self {
332            rule_id: "rule_1".to_string(),
333            rule_name: "Funds validation".to_string(),
334            conditions: vec![SettlementComplianceCondition::new()],
335            actions: vec![SettlementComplianceAction::Approve],
336        }
337    }
338}