🎯

domain-fintech

🎯Skill

from goooice/rust-skills

What it does

Enables precise financial calculations and modeling for fintech applications using Rust's type-driven design and specialized decimal math.

📦

Part of

goooice/rust-skills(35 items)

domain-fintech

Installation

Add MarketplaceAdd marketplace to Claude Code

/plugin marketplace add ZhangHanDong/rust-skills

Install PluginInstall plugin from marketplace

/plugin install rust-skills@rust-skills

Quick InstallInstall with npx

npx skills add ZhangHanDong/rust-skills

git cloneClone repository

git clone https://github.com/ZhangHanDong/rust-skills.git

📖 Extracted from docs: goooice/rust-skills

Need more details? View full documentation on GitHub →

4Installs

AddedFeb 4, 2026

View on GitHub Back to Skills

Skill Details

SKILL.md

"Use when building fintech apps. Keywords: fintech, trading, decimal, currency, financial, money, transaction, ledger, payment, exchange rate, precision, rounding, accounting, 金融, 交易系统, 货币, 支付"

Overview

# 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 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

```rust

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 {

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 |

More from this repository10

🎯

m10-performance🎯Skill

Optimizes code performance by identifying bottlenecks, measuring impact, and guiding strategic improvements across algorithm, data structure, and memory efficiency.

🎯

m14-mental-model🎯Skill

Applies the M14 mental model framework to enhance decision-making and strategic thinking through structured cognitive analysis.

🎯

m04-zero-cost🎯Skill

Guides developers in choosing zero-cost abstractions by analyzing type system constraints and performance trade-offs in Rust generics and traits.

🎯

meta-cognition-parallel🎯Skill

Performs parallel three-layer meta-cognitive analysis by forking subagents to simultaneously analyze language mechanics, design choices, and domain constraints, then synthesizing results.

🎯

unsafe-checker🎯Skill

Identifies and reviews unsafe Rust code patterns, FFI risks, and potential memory unsafety in Rust projects.

🎯

rust-skill-creator🎯Skill

Dynamically generates Claude skills for Rust crates, standard library modules, and documentation by extracting and processing technical details from specified URLs.

🎯

coding-guidelines🎯Skill

Provides comprehensive Rust coding guidelines covering naming conventions, best practices, error handling, memory management, concurrency, and code style recommendations.

🎯

rust-refactor-helper🎯Skill

Performs safe Rust refactoring by analyzing symbol references, checking conflicts, and applying changes across project files using LSP.

🎯

m03-mutability🎯Skill

Diagnoses and guides resolution of Rust mutability and borrowing conflicts by analyzing ownership, mutation patterns, and thread-safety requirements.

🎯

m05-type-driven🎯Skill

Explores and demonstrates type-driven development techniques in Rust, showcasing advanced type system features and pattern matching strategies.