How the $1 Peg Works

You Are the Minter

UPD has no issuer. When you mint UPD, you are not buying it from a company or being issued it by a regulated entity — you are depositing stETH into a smart contract and the contract mints UPD to you in return. The protocol is your counterparty.

This is the mechanism that makes UPD censorship-resistant. There is no issuer to compel. There is no corporation holding reserves that can be seized. The collateral is locked in a smart contract and governed entirely by code.

Non-Rebasing Design

UPD is non-rebasing — 1 UPD is always worth exactly $1 USD. stETH yield does NOT increase the token supply. Instead, yield accrues as collateral, increasing the collateralization ratio over time.

Day 0: 1 ETH deposited, worth $3,000 → 3,000 UPD minted
       Collateralization: 100%

Day 365: stETH yield = 4% → collateral worth $3,120
         UPD supply unchanged: still 3,000 UPD
         Collateralization: 104%

This eliminates the complexity of rebasing tokens. Every wallet, DEX, lending protocol, and bridge handles UPD as a standard fixed-supply ERC20.

Mint Mechanism

UPD is always overcollateralized. The user's deposit covers par value; a Stabilizer adds the buffer above par from their own unallocated stETH. Both sides are locked into a PositionEscrow and the user receives UPD priced at par.

For a Stabilizer with the default 125% minimum collateralization ratio:

User mints with 1 ETH at $2,300/ETH:
  1. ETH → stETH via Lido                                           (user side)
  2. Stabilizer escrow contributes 0.25 stETH                       (overcollateral)
  3. PositionEscrow now holds 1.25 stETH backing the user's UPD
  4. UPDToken mints 2,300 UPD to the user                           (par × user share)
  5. PositionEscrow records 2,300 UPD as the position's liability

The pairing math (from AllocationLib):

stabilizer_steth_needed = user_steth × (ratio - 10000) / 10000

At 125% (ratio = 12500): the stabilizer adds 0.25 stETH per 1 stETH from the user. At 150%: 0.50 stETH per 1 stETH.

If the lowest-ID Stabilizer's escrow runs out mid-mint, the allocation loop spills into the next-lowest ID, and so on. If no Stabilizer has unallocated funds, the mint reverts. See StabilizerNFT System for the full priority model.

Burn Mechanism

burnUPD redeems UPD for stETH at par. It iterates allocated positions from highest NFT ID → lowest (LIFO — last allocated, first unallocated). For each position slice:

• The user receives par value in stETH (updSlice / ethPrice)
• The Stabilizer's overcollateral above par is returned to their StabilizerEscrow
• If the position is undercollateralized, the InsuranceEscrow covers the user's shortfall (best-effort)

burn(2,300 UPD) at $2,300/ETH against a healthy 125% position:
→ user receives  1.00 stETH                         (par)
→ stabilizer gets 0.25 stETH back to their escrow   (excess overcollateral)
→ position liability decreases by 2,300 UPD

If the entire updAmount cannot be processed (e.g. gas runs out mid-loop, or no allocated positions remain), burnUPD refunds the unprocessed UPD to the caller and emits a BurnPartialRefund event.

Price Oracle

The PriceOracle provides the ETH/USD price used for mint and burn calculations. It validates signed price attestations from Chainlink and Uniswap V3:

• Multi-source validation: Requires agreement between multiple price sources
• Freshness check: Rejects stale attestations (> 5 minutes old)
• UUPS upgradeable: Can be upgraded to support new price sources

Overcollateralization

The system maintains a collateralization ratio above 100% through:

1. Accumulating yield: stETH rebase increases collateral value over time
2. Liquidation: Undercollateralized positions are liquidated via the StabilizerNFT priority system

The OvercollateralizationReporter tracks system-wide collateral health on-chain using stETH share-based accounting. Because stETH rebases daily, a simple balance snapshot would go stale between updates. Instead, the reporter stores the total stETH shares held across all escrows. When you call getTotalStEthCollateral(), it converts those shares to the current stETH value — automatically reflecting any yield that has accrued since the last snapshot.

This means yield is reflected in the system's health metric at read time, not just when positions are modified.

For periodic reconciliation, anyone can call syncFromChain() — a permissionless function that iterates all PositionEscrow contracts, reads their actual stETH share balances, and resets the snapshot to ground truth. This corrects any drift that may have accumulated between incremental updateSnapshot() calls.

Price Peg Stability

Unlike algorithmic stablecoins, UPD's peg is maintained by:

• Hard 1:1 collateral at mint: You can always get $1 of stETH per UPD burned (at oracle price)
• Arbitrage: If UPD trades below $1, arbitrageurs buy UPD and burn it for $1 of stETH
• No algorithmic supply adjustment: No death spiral risk