sUPD — Staked UPD
Staked UPD share-token mechanics, time-based yield accrual, four redemption paths, and how yield is funded.
sUPD — Staked UPD
Architecture in motion
sUPD is implemented and deployed on Sepolia, but a few function signatures may shift before mainnet as code reviews come back. Treat the API surface here as illustrative; pin to a specific SDK version once you integrate.
What is sUPD?
sUPD is a yield-bearing share token wrapping UPD. Users stake UPD to mint sUPD shares that appreciate against UPD over time at a configurable APY.
Stake 1,000 UPD → receive ~1,000 sUPD shares (depending on current shareValue)
After 1 year at 8% APY:
Each sUPD is worth ~1.08 UPD
1,000 sUPD → 1,080 UPD on unstakeArchitecture
sUPD does not custody UPD. Instead:
- On stake, sUPD calls
StabilizerNFT.burnUPD()to convert the user's UPD into stETH - That stETH is deposited as unallocated overcollateral into a Stabilizer position that sUPD itself owns (its own
stabilizerTokenId) - On unstake, sUPD gathers stETH from its escrows and calls
mintUPDWithStETH()to mint fresh UPD via the normal allocation path
The sUPD contract is a StabilizerNFT owner. Its position behaves like any other Stabilizer — it accrues stETH yield, it can be allocated against by other minters, it can be liquidated.
Yield Accrual
shareValue accrues linearly per-second at a configurable annual rate (capped at 50% APY by setAnnualYield):
currentShareValue = shareValue + (shareValue × annualYieldBps × elapsed) / (10000 × 365 days)The accrual is time-based, not asset-based — the share value increases on the clock, regardless of whether the underlying hedging strategy is currently profitable. Funding the accrual is the responsibility of the off-chain rebalancer.
| Mechanism | Where it lives |
|---|---|
| Time-based share appreciation | On-chain (currentShareValue) |
| Yield generation (delta-neutral hedge on stETH) | Off-chain, executed by REBALANCER_ROLE |
| Yield delivery into the vault | depositCollateral() (ETH) called by REBALANCER_ROLE |
| stETH rebase | Stays as collateral, improves position health |
sUPD owns its own Stabilizer NFT, so the rebalancer is doing exactly what every Stabilizer does (hedge the long-ETH exposure off-chain) — just programmatically. REBALANCER_ROLE operates within the same per-position invariants as any other Stabilizer: it can withdraw stETH that's already unallocated in sUPD's StabilizerEscrow (withdrawExcessCollateral), and it can shrink sUPD's allocated position by burning UPD against it (unallocateCollateral). It cannot release collateral below the minimum ratio, cannot freeze stakers, and cannot reach into the par-backing portion of any position without burning the matching UPD first.
This means sUPD's solvency depends on the rebalancer keeping pace with the configured APY. If the strategy underperforms, the share value still accrues, but the position's collateralization ratio declines until either the rebalancer tops up via depositCollateral() or the APY is lowered.
Staking & Unstaking
The actual API requires a price attestation on every call:
// Stake UPD → receive sUPD shares
sUPD.stakeUPD(updAmount, priceQuery);
// Standard unstake — reverts if system lacks overcollateral
sUPD.unstakeToUPD(shares, priceQuery);Four Redemption Paths
If the system doesn't have enough free overcollateral to mint fresh UPD for a redeemer, unstakeToUPD will revert. Three fallback paths exist:
| Path | Mechanism | When to use |
|---|---|---|
unstakeToUPD | Mints fresh UPD via normal allocation. Reverts if the system can't cover. | Default path. |
unstakeWithExtraUPD | User provides extra UPD which sUPD burns via unallocateMyself to free locked collateral. User receives updOwed + extraUPD back. | Liquidity-tight regime where the user is willing to round-trip extra UPD. |
unstakeProRata | Accept whatever UPD can be minted from currently available stETH. Records the shortfall in an event, no partial credit kept. | User wants out immediately at any price. |
unstakeQueued + processQueue | Burns shares immediately, queues the request at the current shareValue. Anyone can call processQueue once collateral becomes available. FIFO. | User is willing to wait. Queue clears as new mints/redemptions free overcollateral. |
Liquidity Risk
Liquidity Risk
Like a fractional-reserve bank, sUPD can be temporarily illiquid. If the system's overcollateral is fully utilized (every Stabilizer's escrow is empty), unstakeToUPD reverts and stakers must use one of the fallback paths.
This risk is mitigated by:
- The system-wide overcollateralization buffer (default 25% above par per position)
- The four-path redemption design
- Stabilizer arbitrage incentives (high utilization → more demand for new Stabilizers to deposit)
Share Token vs Rebasing
sUPD uses the share token model (like wstETH or cTokens), not rebasing:
- Your sUPD balance stays constant after staking
- The exchange rate (sUPD → UPD via
currentShareValue) increases over time - Compatible with any ERC20-native protocol that doesn't understand rebasing tokens