DEV Community

Cover image for Opening the Playbook: Why We're Open-Sourcing Casper's Core DeFi Infrastructure
Casper Blockchain profile image Michael Steuer
Michael Steuer for Casper Blockchain

Posted on

Opening the Playbook: Why We're Open-Sourcing Casper's Core DeFi Infrastructure

#blockchain #web3 #opensource

Four production systems, security-audited by Halborn, open-sourced in one week. A naming service, a decentralized exchange, liquid staking, and EIP-712 typed signatures. All live on mainnet. All yours now.

Earlier this week, I open-sourced casper-eip-712, a Rust crate that brings Ethereum's typed signing standard to Casper. I wrote about why we did it, what it unlocks, and how it started with a security auditor telling us we had a gap.

That was yesterday. We weren't done.

Today I'm announcing that we've open-sourced three additional contract repositories that power core DeFi infrastructure on Casper Network:

These aren't proofs of concept. They're not hackathon projects gathering dust. Each of these repositories powers a live product with real users on Casper mainnet right now. And critically, each has been independently security-audited by Halborn, one of the leading blockchain security firms in the industry:

Production-deployed, battle-tested, and security-audited. That's the bar we're setting for what "open source" means on Casper.

Why Open-Source, Why Now

Let me be direct about the motivation. Casper Network is an open-source Layer 1 blockchain with decentralized community governance. The protocol is open. The node software is open. The SDK is open. But until now, the production-grade application contracts, the ones that actually demonstrate how to build real things on Casper, weren't.

That's a gap. And it's the kind of gap that makes life harder for builders.

If you wanted to build a naming service on Casper, you'd start from scratch. If you wanted to build a DEX, you'd reverse-engineer how AMMs work on EVM chains and figure out how to translate that to Casper's architecture. If you wanted to implement liquid staking, you'd be pioneering patterns that someone had already solved, just behind closed doors.

We're opening those doors.

The timing matters, too. Casper's v2.2.0 mainnet upgrade launches on March 23rd. Validators are already staging, with 83% of stake staged and climbing. The protocol is evolving. Upgradeable smart contracts, improved developer ergonomics, a maturing DeFi stack. But none of that matters if builders don't have the reference material, the production-tested patterns, and the working code to build on.

Open-sourcing these repositories isn't an act of charity. It's infrastructure investment. It's saying: "Here's how we solved naming, liquidity, staking, and typed signatures on Casper. Take it. Learn from it. Build on it. Make it better."

Three Teams, One Commons

One thing worth highlighting: these four repositories come from three different organizations.

This is how we operate. The Casper Association doesn't build everything in-house. It functions as an ecosystem orchestrator, ensuring that different teams across the ecosystem contribute to, collaborate on, and benefit from shared infrastructure. MAKE, Odra, WiseLending: each team brings deep expertise in their domain. The Association's job is to make sure that expertise compounds instead of staying siloed.

Open-sourcing these repositories is a concrete expression of that philosophy. Three teams, four repos, one ecosystem commons.

The Framework That Runs the Stack

Three of the four repositories are built entirely with Odra, the Rust-native smart contract framework for Casper. The fourth, casper-eip-712, is a vanilla Rust crate by design (it needs to work in any environment, including no_std). But we built its demo project, a full CEP-18 token with gasless permit/approve, in Odra specifically to demonstrate how the vanilla crate integrates with the framework.

If you're not familiar with Odra: think of it as what OpenZeppelin provides for the EVM ecosystem, but more comprehensive and designed from the ground up for Casper's architecture. Odra handles the contract lifecycle, testing infrastructure, deployment tooling, and factory patterns, so you can focus on your application logic rather than blockchain plumbing.

The fact that three production DeFi systems were built with Odra, and the fourth integrates seamlessly, is itself a strong signal. A naming protocol, a full Uniswap V2 port, and a liquid staking system with protocol-level integration, all built, tested, audited, deployed, and running in production using the same framework.

For developers considering Casper, these repos serve as a real-world Odra curriculum:

  • cspr-name-contracts demonstrates domain registration, resolution, and the tradable NFT-like ownership model
  • casper-trade shows how to port a battle-tested EVM design (Uniswap V2) to Casper, including Odra's factory pattern for runtime contract deployment, which is a genuinely different approach from EVM's create2
  • liquid-staking-contracts illustrates protocol-level integration, the sCSPR liquid token pattern, and Gherkin-style BDD tests
  • casper-eip-712 demonstrates how standalone Rust crates integrate with Odra contracts in production

Under the Hood

CSPR.name: Decentralized Naming for Casper

Repository: make-software/cspr-name-contracts | Halborn audit
Live product: CSPR.name

14c8b2f09ad2ef34c23bff91d52e6f48cbd714ea1fa8b3e71d26547ebfd1229c

That's a Casper account hash. Try sending tokens to it from memory. Now try sending tokens to michael.cspr. That's the problem CSPR.name solves.

CSPR.name is Casper's official naming service. It replaces cryptographic account hashes with human-readable .cspr names, making the entire ecosystem more navigable. Register a name, and it becomes your on-chain identity, recognized across CSPR.live, Casper Wallet, dApps, and the broader ecosystem.

But CSPR.name goes beyond simple name-to-address resolution. As of the latest release, names are fully tradable on CSPR.market. You can buy, sell, and make purchase offers for names. Your .cspr name isn't just a convenience. It's a digital asset.

What developers can learn from this repo:

  • Name registration and resolution contract architecture using Odra
  • Tradable naming rights: turning registered names into transferable assets
  • Integration with marketplace contracts
  • Using cargo odra build and cargo odra test for the full development lifecycle 
# Clone and run tests locally
git clone https://github.com/make-software/cspr-name-contracts
cd cspr-name-contracts
cp .env.example .env
cargo odra test
Enter fullscreen mode Exit fullscreen mode

CSPR.trade: Native Decentralized Exchange

Repository: odradev/casper-trade | Halborn audit
Live product: CSPR.trade

CSPR.trade is Casper's native DEX, a Uniswap V2-style automated market maker built specifically for Casper's architecture. It provides token swaps, liquidity pools, and yield farming. With deterministic finality and non-custodial execution, every swap, pool rebalance, and fee distribution is verifiable on-chain.

What makes this repo particularly interesting for developers is how faithfully it ports the Uniswap V2 architecture while handling the fundamental differences between EVM and Casper:

The factory pattern: On Ethereum, Uniswap's factory deploys Pair contracts using create2 with the Pair bytecode stored in the Factory. Casper doesn't have create2. Instead, Odra provides a factory=on directive that auto-generates a PairFactory contract. The PairFactory's sole purpose is managing deployments and upgrades of Pair contracts. Factory calls factory() on PairFactory, which deploys a new Pair and returns its address.

This is one of those architectural differences that would take a team weeks to figure out from scratch. Now it's documented, tested, audited, and open.

Test parity: The tests are based directly on the original Uniswap V2 test suites (UniswapV2Router01.spec.ts, UniswapV2Router02.spec.ts, UniswapV2Factory.spec.ts, and UniswapV2Pair.spec.ts). This isn't a loose reimplementation; it's a faithful port with behavioral verification against the original.

Contract architecture:

  • Pair: The AMM pair contract (deployed by PairFactory, not directly). Corresponds to UniswapV2Pair.
  • PairFactory: Auto-generated by Odra. Responsible for deploying and upgrading Pair contracts.
  • Router: Corresponds to UniswapV2Router. Entry point for swaps and liquidity operations.
  • Factory: Pair management. Corresponds to UniswapV2Factory.
  • WrappedNativeToken: From Odra modules, wraps native CSPR for use in AMM pools. 
# Clone, install, and test
git clone https://github.com/odradev/casper-trade
cd casper-trade
cargo install cargo-odra
just test
Enter fullscreen mode Exit fullscreen mode

Liquid Staking: The StakedCSPR Protocol

Repository: casper-ecosystem/liquid-staking-contracts | Halborn audit
Live product: casper.wiselending.com

Here's the staking dilemma every Proof-of-Stake network faces: users who stake their tokens to secure the network get their capital locked up. They earn rewards, but they lose liquidity. They can't use those tokens in DeFi. They can't respond to market conditions without waiting through unbonding periods. So they face a choice: security or liquidity.

Liquid staking removes that choice.

When you stake CSPR through the liquid staking protocol, you receive sCSPR, a liquid token that represents your staked position. Your original CSPR stays staked and continues earning network rewards. Meanwhile, sCSPR is freely transferable. You can use it in CSPR.trade pools. You can use it as collateral. Your capital works in two places at once.

On Casper, this isn't a third-party bolt-on. It's built with protocol-level awareness, in collaboration with WiseLending. No custodians, no synthetic wrappers, no workarounds that bypass the base layer.

What makes this repo especially valuable for developers:

  • The StakedCSPR token contract implementation, a real-world example of a liquid representation token
  • Gherkin-style BDD test specifications in the tests/features folder, showing how to write readable, verifiable test suites for complex DeFi logic
  • Full CLI tooling for deployment and interaction
  • Protocol-level staking integration patterns 
# Clone and test
git clone https://github.com/casper-ecosystem/liquid-staking-contracts
cd liquid-staking-contracts
just test

# Deploy to testnet (configure .env first)
just build-contracts
just cli deploy
Enter fullscreen mode Exit fullscreen mode

What This Means for Builders

Let me be concrete about what you can do with these repositories today:

If you want to build a naming service on another domain, fork cspr-name-contracts. The architecture handles registration, resolution, renewal, and marketplace integration. Adapt the domain logic to your use case.

If you want to build a DEX or AMM on Casper, casper-trade gives you a production-tested, Halborn-audited Uniswap V2 implementation. Add new pool types, modify fee structures, build a frontend. The hard contract work is done.

If you want to incorporate liquid staking functionality in your dApp, liquid-staking-contracts shows you the pattern. Whether you're building a lending protocol, a yield optimizer, or anything that benefits from compounding staking rewards alongside your application's native functionality, the sCSPR token design, the staking/unstaking flow, and the reward distribution logic are all there.

If you need typed signatures for any cross-chain, gasless, or multi-party signing use case, casper-eip-712 handles encoding, hashing, domain separation, and verification. Drop it in as a crate dependency.

If you're learning Odra, these repos are your graduate-level coursework. Registration systems, AMMs, staking protocols, cryptographic primitives. Each demonstrates different Odra patterns in production context, with Halborn audits that serve as implicit code quality benchmarks.

The Broader Picture

When I wrote about building CSPR.guru a few months ago, I made the case that Casper's developer experience, powered by Odra, CSPR.click, CSPR.cloud, and the rest of MAKE's toolchain, is genuinely best-in-class. I built a full prediction market, solo, in my spare evenings, using only Casper ecosystem tools.

But I also know that "best-in-class tools" means nothing if builders can't see what production-grade code looks like on your platform. Documentation gets you started. Tutorials teach you patterns. But nothing replaces reading real code that runs in production, serving real users, handling real money, and surviving a Halborn audit.

That's what these repositories provide. Not examples. Not templates. Production systems with the security receipts to prove it.

Four repos. Three teams. Three Halborn audits. One ecosystem.

As we approach the v2.2.0 mainnet upgrade on March 23rd, with 83% of stake already staged, we're not just upgrading the protocol. We're opening the entire application layer. The code that powers Casper's DeFi infrastructure is now the same code you can fork, study, extend, and deploy.

Build something.

Repositories:

Security audits:

Live products:

Learn more:

Top comments (0)