Staking Rate Perpetuals (Staked MON)

This perpetual contract tracks the network APY earned by delegating to Monad validators, allowing traders to speculate on or hedge the staking yield of the Monad network.

Characteristic	Description
What it tracks	This perp tracks the staking multiplier on a reference MON staking position. Given an initial D0 MON staked, the index tracks how much that position would grow to over time due to staking rewards (i.e., Dt = D0 Jt).
Index Definition	rt is the instantaneous annualized MON staking yield (APY, in decimal; e.g. 0.12 for 12%) and Y ≈ 31,536,000 - the number of seconds per (non‑leap) year. The cumulative staking log‑index is then: and the Staking Multiplier Index is: By construction J0 = 1 and a staked principal evolves as Dt = D0 Jt.
Oracle Type	A SEDA-based staking yield oracle that consumes the MON staking APY (from protocol / chain data) and numerically integrates it into a live Kt and Jt path. The oracle maintains a discrete-time log‑index Kk via: updated every few seconds, and then maps Jk into a perp price.
Market Type	Cash-Settled Index Perpetual. The contract is margined and settled in USD terms (or USD‑equivalent), with no on-chain staking or unbonding needed by the trader.
PnL Formula	PNL (Long) = (Exit_Price - Entry_Price) × Position_Size + Total_Funding_Received PNL (Short) = (Entry_Price - Exit_Price) × Position_Size + Total_Funding_Received Where: Entry_Price / Exit_Price: The perp price at which a MON Staking Yield position is opened and closed. Internally this price is an affine transform of the multiplier Jt. Position_Size: The number of MON Staking Yield contracts in the position. Total_Funding_Received (or Total_Funding_Paid): Sum of all perp funding transfers over the life of the position (separate from the staking‑indexed PnL that comes from changes in Jt.
Use Cases	Long (replicate staking / bet on higher yield): • Synthetic staker: Go long MON Staking Yield to replicate the staking rewards of holding and staking MON, without managing validator infrastructure or lockups. • Yield bull: Express a view that MON staking yield will be high or increase over time (e.g., due to protocol incentives or fee growth). Short (hedge staking or bet on lower yield): • Validator / staker hedge: A validator or large staker can short the MON Staking Yield perp with notional N = D0 to hedge out the variability of future staking rewards or to lock in current economics. • Yield bear: Express a view that MON staking yield will fall (e.g., from parameter changes, competition, or lower fees).
Users	• Validators and staking operators running MON infrastructure • Protocol treasuries and DAOs with large MON staking exposure • Structured-product desks building fixed/floating MON yield products • Basis / relative‑value traders between MON spot, staking, and perps
Vol-stat (σ)	Low–medium. The index Jt is driven by the MON staking APY rt, which typically moves more slowly than spot price but can jump on governance changes, fee shifts, or slashing events. Leverage is set more conservatively than high‑volatility price perps, but higher than pure stablecoin rate products.
Margin Numbers	Derived from the Max Leverage tiers for this market. For example, if the risk engine assigns a 4× max leverage, the Initial Margin (IM) is ~25% of notional and Maintenance Margin (MM) ≈ IM/2, with exact values determined by the platform’s dynamic leverage framework.

OraclePx

This is run for the MON Staking Yield SEDA feed. The oracle’s job is to maintain a live estimate of the staking multiplier J_t and convert it into a HIP‑3‑compatible price.

Core steps:

1 - Ingest staking APY:

• The current MON staking APY r_t is pulled from onchain / protocol sources (e.g., reward rates, effective stake, inflation schedule).

• This can be optionally smoothed with a short EMA or TWAP to avoid noise from transient measurement artifacts.

2 - Update log‑index K_t:

• On each tick at time t_k with step Δt_k, update:

$$K_{k+1} = K_k + \frac{r_k}{Y},\Delta t_k.$$

• This numerically approximates the continuous integral:

$$\int_0^t r_s/Y,ds.$$

3 - Exponentiate to multiplier J_t:

$$J_{k+1} = \exp(K_{k+1}), \quad J_0 = 1.$$

4- Affine price mapping:

• Map the multiplier into an oracle price:

$$P^\text{oracle}_t = B_t + S\bigl(J_t - A_t\bigr), ]$$

• where:

  • S is a fixed scale factor (e.g., 1,000,000)

  • A_t is an anchor level (piecewise constant)

  • B_t is a positive baseline chosen to keep the price far from zero.

5 - Re‑anchoring:

• When |J_t - A_t| exceeds a target threshold (e.g., corresponding to a few % cumulative yield), the oracle re‑centers:

$$A_{t^+} = J_t,\quad B_{t^+} = B_{t^-} + S\bigl(A_{t^+} - A_{t^-}\bigr),$$

• which preserves price continuity while allowing J_t to grow over time.

The final oraclePx is this quantized:

$$P^\text{oracle}_t$$

It is updated every few seconds and clamped to the allowed per‑update percentage move (e.g., ≤ 1%).

$$K_{k+1} = K_k + \frac{r_k}{Y},\Delta t_k.$$

MarkPx

This is a feed based on our live MON Staking Yield perp market.

The markPx is constructed to be robust and manipulation‑resistant while tracking the oracle multiplier closely. A typical construction:

• MarkPx0: direct transformed oraclePx (after quantization and 1% clamp).

• MarkPx1: short-horizon EMA / TWAP of recent MON Staking Yield perp trades, clamped to remain within a tight band around oraclePx.

• MarkPx2: a conservative band-limited value that leans heavily on the external staking index (from oraclePx) and ignores outlier prints.

The median of (MarkPx0, MarkPx1, MarkPx2) is taken as markPx, then:

• quantized to the venue’s tick size / decimals,

• clamped to move at most 1% per update relative to the previous mark,

• validated against open interest caps to avoid pathological marks in stressed conditions.

This yields a mark that:

• reflects actual trading in the MON Staking Yield market,

• remains tightly anchored to the true multiplier J_t, and

• is resilient to short‑lived manipulation or illiquidity.

ExternalPerpPx

This is the MON Staking Yield SEDA index. The externalPerpPx is set equal to the external composite staking multiplier price and acts as a band‑limiter for markPx:

• If markPx drifts too far from externalPerpPx (beyond configured percentage or absolute bands), tighter clamps, additional funding pressure, or circuit‑breaker logic can be applied to pull the market back toward the reference.

This ensures the perp remains a good proxy for actual MON staking rewards, while still allowing some flexibility for exchange-specific supply/demand and liquidity.

Worked Example

This example shows how the MON Staking Yield index and perp PnL behave under a simple constant‑rate scenario.

Setup

• Constant MON staking APY: r_t = 12% (0.12 in decimal).

• Horizon: 30 days.

• Seconds per year: Y = 31,536,000.

• Notional on the perp: N = $1,000,000) (choose q so qS = N).

• Assume no perp funding for simplicity (just the staking index effect).

1 - Compute the log‑index increment

30 days is T = 30 x 86,400 = 2,592,000 seconds.

The cumulative log‑index over this period is:

$$K_T = \int_0^T \frac{r_s}{Y},ds \approx \frac{0.12}{Y} \times T = 0.12 \times \frac{2{,}592{,}000}{31{,}536{,}000} \approx 0.00986.$$

2 - Convert to multiplier

$$J_T = e^{K_T} \approx e^{0.00986} \approx 1.0099.$$

So after 30 days at a constant 12% APY, the staking multiplier is about 1.0099, i.e. ~0.99% growth in the staked position.

3 - Staking vs perp PnL

If you had actually staked D₀ = $1,000,000 worth of MON, your position would grow to:

for a staking reward of roughly:

On the MON Staking Yield Perpetual, with notional N = D₀ = $1,000,000, your PnL over the same period is:

So:

• A long MON Staking Yield position of notional N replicates the staking reward on a MON principal D₀ = N.

• A short position of notional N perfectly hedges the staking rewards of actually staking D₀ = N MON, pathwise:

$$d\text{PnL}_t = N,dJ_t = dD_t.$$

In practice, this staking‑indexed PnL is combined with standard perp funding and trading PnL via the usual formula:

• Long: (Exit_Price - Entry_Price) × Position_Size + Total_Funding_Received

• Short: (Entry_Price - Exit_Price) × Position_Size + Total_Funding_Received,

with Exit_Price and Entry_Price being affine transforms of the multiplier J_t.