When people talk about stablecoins “losing their peg,” they’re describing a gap between the token’s market price and its target price — usually $1.00. That gap is the market telling you that supply and demand are out of balance. A peg stability vault (PSV) is a mechanism designed to close that gap automatically, using arbitrage as the forcing function.
I built one for eUSD — Telcoin Digital Asset Bank’s stablecoin — and the core design is worth walking through, because the concept is simple but the edge cases are not.
The Basic Mechanism
A PSV offers a guaranteed 1:1 exchange rate between the stablecoin and a backing asset — typically a more established stable like USDC. The contract holds reserves of both assets and allows anyone to swap between them at par, minus a small fee.
Here’s why that matters for the peg:
If eUSD trades below $1.00 on the open market:
- An arbitrageur buys eUSD cheaply (say at $0.98)
- They bring it to the PSV and swap it for $1.00 of USDC
- Profit: $0.02 per token, minus gas
- Side effect: eUSD supply decreases, USDC reserve decreases, price pressure upward
If eUSD trades above $1.00:
- An arbitrageur brings USDC to the PSV and receives eUSD at $1.00
- They sell eUSD on the open market at the premium
- Profit: the spread, minus gas
- Side effect: eUSD supply increases, price pressure downward
The arbitrageurs don’t care about the peg — they care about profit. But the mechanism harnesses that profit motive to enforce price stability. It’s elegant because it’s self-correcting without requiring active management.
The Solidity Implementation
The core contract is straightforward:
function swapStableForEUSD(uint256 usdcAmount) external {
require(usdcAmount > 0, "Zero amount");
uint256 fee = (usdcAmount * feeBps) / 10_000;
uint256 eusdOut = usdcAmount - fee;
usdc.transferFrom(msg.sender, address(this), usdcAmount);
eusd.mint(msg.sender, eusdOut);
emit Swap(msg.sender, usdcAmount, eusdOut);
}
function swapEUSDForStable(uint256 eusdAmount) external {
require(eusdAmount > 0, "Zero amount");
uint256 fee = (eusdAmount * feeBps) / 10_000;
uint256 usdcOut = eusdAmount - fee;
eusd.burnFrom(msg.sender, eusdAmount);
usdc.transfer(msg.sender, usdcOut);
emit Swap(msg.sender, eusdAmount, usdcOut);
}The complexity lives elsewhere.
Where It Actually Gets Hard
Reserve management
The PSV is only useful if it has reserves. If the USDC reserve is empty, you can’t arbitrage eUSD back up when it depresses. Maintaining adequate reserves on both sides requires either protocol-owned liquidity or incentivized depositors — and that’s a tokenomics problem, not a contract problem.
Reentrancy
Any contract that moves tokens is a reentrancy target. The pattern above uses a check-effects-interaction order, but the mint/burn calls on the stablecoin contract add a layer of complexity. I added explicit reentrancy guards on both swap functions, and the stablecoin itself is non-reentrant.
Oracle independence
A key design decision: the PSV doesn’t use a price oracle. It enforces a hard 1:1 rate by contract. This is intentional — oracles introduce manipulation risk and latency. The tradeoff is that the PSV can’t handle cases where USDC itself depegs, but that’s an acceptable assumption given USDC’s reserve backing.
Fee calibration
Too low a fee and the PSV becomes a free service for high-frequency traders with no benefit to the protocol. Too high and the arbitrage spread required to trigger stabilization becomes wide — the peg can deviate further before it’s profitable to correct. We landed on a 4bps fee after modeling expected arbitrage frequency.
What This Looks Like on Solana
I also built a Solana version of the same mechanism. The conceptual model is identical, but the implementation is completely different — Rust, Anchor framework, account-based model instead of contract state, and Program Derived Addresses instead of mappings.
The interesting thing about porting this to Solana is that the constraints are different. Solana’s compute budget means you need to be more deliberate about instruction complexity, and the account model requires you to think about state layout upfront in a way that EVM contracts don’t demand.
Takeaways
Peg stability vaults are a good example of a mechanism that looks simple but has real depth. The basic arbitrage logic is a few dozen lines of Solidity. The production-ready version — with proper access control, reserve management, fee logic, reentrancy protection, and a full test suite covering edge cases — is a different scope of work entirely.
If you’re building a stablecoin and thinking about peg maintenance, a PSV is worth including. The arbitrage mechanism is reliable because it’s incentive-aligned, not trust-dependent. That’s the right kind of robustness for financial infrastructure.