Stablecoins are the settlement layer of decentralized finance. DAI, as the first decentralized, collateral-backed stablecoin, established the foundational design pattern that every subsequent stablecoin has either adopted, extended, or deliberately departed from. Its source code is not merely a product — it is a public specification. The contracts that govern DAI minting, liquidation, surplus accounting, and emergency shutdown constitute a body of work that the entire industry references, audits, and builds upon.

dairef exists to collect, preserve, and express this source code in one place.

The purpose is precise: make the canonical stablecoin reference accessible for study, peer review, and correct building. When an engineer needs to understand how collateralized debt positions work, how flash minting is safely bounded, how proxy patterns delegate authority in a multi-collateral system, or how synthetic asset protocols compose on top of stable units of account — the answer should be one repository away, not scattered across dozens of archived forks and deprecated documentation sites.

Stablecoin infrastructure is safety-critical financial software. A single misunderstanding of how vat.frob() adjusts collateral ratios, or how dog.bark() initiates liquidation, can result in protocol insolvency. Yet the source code for these systems is fragmented:

• Canonical repositories are spread across multiple GitHub organizations
• Critical dependencies (OpenZeppelin, Uniswap, Synthetix) live in separate ecosystems
• Proxy patterns, bridge contracts, and cross-chain wrappers add layers that obscure the core logic
• Audit reports reference specific commit hashes that may no longer be the default branch
• Developers building new stablecoins often work from incomplete mental models because the full reference surface is not consolidated

A reference organization that forks, organizes, and preserves the essential source code in its reviewed, audited state. Not a rewrite. Not an abstraction. The actual contracts, the actual tests, the actual deployment scripts — collected so that the full picture is visible from a single vantage point.

This is how industry standards emerge: not from specification documents alone, but from working, reviewed, battle-tested code that practitioners can read, compile, and verify.

Stablecoin source code occupies a unique position in software engineering. Unlike most open-source projects, where a bug results in degraded functionality, a stablecoin bug results in financial loss — potentially systemic financial loss. The MakerDAO system alone has secured billions of dollars in collateral. The contracts that govern this system must be correct not in the way that a web application must be correct, but in the way that bridge engineering must be correct: failure is not an acceptable outcome.

Peer review of stablecoin source code serves three essential functions:

Every function in the DAI system has a mathematical invariant it must preserve. Vat.frob() must never allow a vault to become undercollateralized. Jug.drip() must accumulate stability fees without rounding errors that compound over time. End.cage() must freeze the system in a state where every DAI holder can redeem their proportional share of collateral. These invariants are not documented in a specification — they are expressed in the source code and enforced by the tests. Peer review is the process of verifying that the code faithfully implements these invariants.

When new stablecoin projects launch, they do not design from first principles. They reference existing implementations. The quality of the reference determines the quality of the derivative. If the reference code is well-organized, thoroughly tested, and accompanied by clear documentation of its design decisions, then projects that build upon it inherit those qualities. If the reference is fragmented, poorly documented, or accessible only through archaeological excavation of old commit histories, then the industry builds on sand.

dairef consolidates the reference so that builders start from solid ground.

The DeFi ecosystem loses institutional knowledge rapidly. Core contributors move between projects. Documentation falls out of sync with deployed contracts. Audit reports reference code that has since been refactored. By preserving the source code in its reviewed state — not the latest commit, but the version that was audited, deployed, and battle-tested — dairef maintains the institutional knowledge that the industry needs to avoid repeating past mistakes.

For reference, the core MakerDAO Multi-Collateral DAI architecture as expressed in dss:

 ┌──────────────────────────┐
│ Governance │
│ (MKR token holders) │
└────────────┬─────────────┘
│
┌──────────────────┼──────────────────┐
│ │ │
┌─────┴─────┐ ┌──────┴──────┐ ┌──────┴──────┐
│ Jug │ │ Spot │ │ End │
│ Stability │ │ Price Feed │ │ Emergency │
│ Fees │ │ + Ratios │ │ Shutdown │
└─────┬──────┘ └──────┬──────┘ └─────────────┘
│ │
┌─────┴──────────────────┴─────┐
│ Vat │
│ Central Accounting Engine │
│ (all collateral + all DAI) │
└──┬───────┬───────┬───────┬───┘
│ │ │ │
┌─────┴──┐ ┌─┴────┐ ┌┴─────┐ ┌┴──────┐
│ Join │ │ Flip │ │ Flap │ │ Flop │
│Adapters │ │Auct. │ │Auct. │ │Auct. │
│(ERC-20 ↔│ │(coll.│ │(surp.│ │(debt │
│ internal)│ │ sale)│ │ sale)│ │ sale) │
└─────────┘ └──────┘ └──────┘ └───────┘

Understanding this architecture is prerequisite to building any system that interacts with DAI — whether minting, liquidating, integrating as collateral, or building derivative instruments on top of it.

The phrase "correct building" is deliberate. In stablecoin development, there is a distinction between code that works and code that is correct:

• Code that works passes its test suite today, on the current compiler version, with the current set of collateral types, under current market conditions.

• Code that is correct preserves its invariants under all conditions the system was designed to handle, including conditions that have not yet occurred — oracle failures, governance attacks, collateral price collapses, flash loan exploits, and emergency shutdown scenarios.

The source code collected in dairef represents systems that have been subjected to this higher standard. They have survived formal verification, multiple independent audits, years of mainnet operation with billions of dollars at stake, and several black swan events. This is the code that defines what "correct" means in stablecoin engineering.

Building correctly means:

1. Reading the reference before writing new code
2. Understanding the invariants before modifying existing patterns
3. Reviewing the tests to understand what edge cases the original authors anticipated
4. Studying the audit reports to understand what edge cases they missed
5. Preserving the design decisions that protect users, even when they add complexity

Each repository in the dairef collection retains the license of its upstream source. The predominant licenses are:

Consult the LICENSE file in each individual repository for the authoritative terms.

All 22 repositories collected under github.com/dairef for quick reference and machine ingestion.

MakerDAO / DAI Core: dss, dss-flash, dss-proxy, dai-plugin-dcent-web, market-maker-keeper

DeFi Protocols: synthetix, v3-core (Uniswap), interface (Aave), defi-Vault

Smart Contract Standards: openzeppelin-contracts, ico, fib

Gold-Backed Assets: cache-contract, cache-crypto-widget, cache-gold-docs, cgt-bridge

Cross-Chain / Bridging: xERC20, delta0mnichain, wrapped-assets, metaplex-program-library

Research / Education: awesome-bonding

Original Work: PAI (payment gateway for agentic economy at scale)

dairef is a reference collection. Contributions should:

• Add forks of audited, deployed stablecoin or DeFi infrastructure source code
• Preserve the upstream commit history and license
• Not modify the source code from its audited state
• Include context (in issues or discussions) about why the addition is relevant to stablecoin peer review

If you have identified source code that belongs in this collection, open an issue describing the repository, its relevance to stablecoin infrastructure, and its audit history.