FinTech Domain

Layer 3: Domain Constraints

Domain Constraints → Design Implications

Domain Rule Design Constraint Rust Implication

Audit trail Immutable records Arc, no mutation

Precision No floating point rust_decimal

Consistency Transaction boundaries Clear ownership

Compliance Complete logging Structured tracing

Reproducibility Deterministic execution No race conditions

Critical Constraints

Financial Precision

RULE: Never use f64 for money WHY: Floating point loses precision RUST: Use rust_decimal::Decimal

Audit Requirements

RULE: All transactions must be immutable and traceable WHY: Regulatory compliance, dispute resolution RUST: Arc<T> for sharing, event sourcing pattern

Consistency

RULE: Money can't disappear or appear WHY: Double-entry accounting principles RUST: Transaction types with validated totals

Trace Down ↓

From constraints to design (Layer 2):

"Need immutable transaction records" ↓ m09-domain: Model as Value Objects ↓ m01-ownership: Use Arc for shared immutable data

"Need precise decimal math" ↓ m05-type-driven: Newtype for Currency/Amount ↓ rust_decimal: Use Decimal type

"Need transaction boundaries" ↓ m12-lifecycle: RAII for transaction scope ↓ m09-domain: Aggregate boundaries

Key Crates

Purpose Crate

Decimal math rust_decimal

Date/time chrono, time

UUID uuid

Serialization serde

Validation validator

Design Patterns

Pattern Purpose Implementation

Currency newtype Type safety struct Amount(Decimal);

Transaction Atomic operations Event sourcing

Audit log Traceability Structured logging with trace IDs

Ledger Double-entry Debit/credit balance

Code Pattern: Currency Type

use rust_decimal::Decimal;

#[derive(Clone, Debug, PartialEq)] pub struct Amount { value: Decimal, currency: Currency, }

impl Amount { pub fn new(value: Decimal, currency: Currency) -> Self { Self { value, currency } }

pub fn add(&self, other: &Amount) -> Result<Amount, CurrencyMismatch> {
    if self.currency != other.currency {
        return Err(CurrencyMismatch);
    }
    Ok(Amount::new(self.value + other.value, self.currency))
}

}

Common Mistakes

Mistake Domain Violation Fix

Using f64 Precision loss rust_decimal

Mutable transaction Audit trail broken Immutable + events

String for amount No validation Validated newtype

Silent overflow Money disappears Checked arithmetic

Trace to Layer 1

Constraint Layer 2 Pattern Layer 1 Implementation

Immutable records Event sourcing Arc, Clone

Transaction scope Aggregate Owned children

Precision Value Object rust_decimal newtype

Thread-safe sharing Shared immutable Arc (not Rc)

Related Skills

When See

Value Object design m09-domain

Ownership for immutable m01-ownership

Arc for sharing m02-resource

Error handling m13-domain-error