Mechanics

The AMM: Logarithmic Pricing

Echelon's AMM uses a logarithmic pricing curve.

The Math (Simplified)

The exchange rate between PT and SY is determined by:

exchange_rate = e^(ln_implied_rate * time_to_expiry)

Where ln_implied_rate is tracked by Echelon's Fixed Yield oracle and updates with each trade.

Key Parameters

Scalar Root: Controls capital efficiency vs. tradeable range

• Higher scalar = more capital efficient, narrower range

• Lower scalar = less efficient, wider range

Initial Anchor: The reference rate used for fee calculations

• Acts as a "neutral" point

• Fees increase as rates deviate from anchor

Rate Anchor: The current market-implied rate

• Updates with each trade

• Used to calculate dynamic fees

Dynamic Fees

Fees are calculated from a ln_fee_rate_root parameter set at market creation. The fee rate scales with time to expiry:

fee_rate = e^(ln_fee_rate_root * time_to_expiry / seconds_per_year)

Where ln_fee_rate_root is derived from the initial fee rate when the market is created. The fee rate decreases as the market approaches expiry (since time_to_expiry decreases).

Token Mechanics: SY, PT, YT

SY (Standardized Yield)

SY is a wrapper around yield-bearing assets. It maintains a 1:1 relationship with the underlying asset.

How it works:

• Deposit 1000 sUSDe → Get 1000 SY-sUSDe

• Redeem 1000 SY-sUSDe → Get 1000 sUSDe

SY Exchange Rate (for PY index):

The protocol uses an oracle-based exchange rate (underlying_price / base_price) to checkpoint the PY index. This is NOT the redemption rate - SY always redeems 1:1. The exchange rate is used to track how the underlying asset's value changes relative to its base asset (e.g., sUSDe vs USDe price).

Key Properties:

• 1:1 with underlying (always)

• Can be redeemed for underlying at any time

• Can be split into PT + YT

• PY index uses SY exchange rate as a checkpoint for yield tracking

PT (Principal Token)

PT represents a claim on SY at expiry. The relationship is simple:

1 PT (at expiry) = 1 SY

Before expiry, PT typically trades at a discount to SY when there's positive implied yield. The discount represents the locked-in yield rate.

Pricing: PT price is determined by the market AMM. The exchange rate is calculated as:

PT/SY_exchange_rate = e^(ln_implied_rate * time_to_expiry / seconds_per_year)

Because implied APYs are positive, you'll need more than 1 PT to get 1 SY (meaning 1 PT < 1 SY, i.e., discount).

Key Properties:

• Fixed expiry date

• Redeemable 1:1 for SY at expiry (guaranteed)

• Typically trades at discount before expiry (when implied yield is positive)

• Price converges to SY price as expiry approaches

• Market-determined pricing

YT (Yield Token)

YT represents all yield from SY until expiry. It uses a PY index to track yield accrual.

PY Index: The PY index starts at 1.0 and increases as yield accrues:

py_index = max(sy_exchange_rate, previous_py_index)

Yield Claim: YT holders can claim yield proportional to the PY index increase:

claimable_yield = yt_amount * (py_index_current - py_index_when_minted)

Key Properties:

• Accrues yield continuously

• Can claim yield anytime before expiry

• Becomes worthless at expiry

• Leveraged yield exposure

Liquidity: Constant Sum AMM

How It Works

Liquidity providers add PT + SY in a specific ratio. The AMM maintains:

PT_balance + SY_balance = constant (for LP purposes)

LP Token Minting:

lpt_amount = sqrt(PT_added * SY_added) - minimum_liquidity

Yield Accrual: The PY Index

The PY index tracks how much yield has accrued since market creation. It's what actually increases over time, not the SY exchange rate.

Calculation

The PY index is updated using the SY exchange rate (from oracle) as a checkpoint:

py_index = max(sy_exchange_rate, previous_py_index)

The SY exchange rate (underlying_price / base_price) reflects how the underlying asset's value has changed. For rebasing assets like sUSDe, this increases as yield accrues. The PY index is the maximum of the current SY exchange rate and the previous PY index, ensuring it only increases (monotonic).

Why monotonic? This ensures that YT holders always see their yield increase.

Distribution

When YT holders claim yield:

1. Calculate their share: yt_amount / total_yt_supply

2. Calculate total yield: (py_index_current - py_index_claim_time) * total_sy

3. Distribute: user_share * total_yield

---

Market Expiry: The Finale

When a market expires:

1. Trading stops: No more swaps allowed

2. PT redemption: 1 PT → 1 SY (guaranteed)

3. YT expiry: YT becomes worthless (all yield distributed)

4. Liquidity withdrawal: LPs can remove liquidity

5. Market closes: State is finalized

After expiry:

• PT holders: Redeem for SY

• YT holders: Nothing (already got all yield)

• LPs: Remove remaining liquidity

---

Security: Rate Limiting

Echelon includes rate limiting on liquidity withdrawals to prevent:

• Flash loan attacks

• Sudden liquidity drains

• Market manipulation

How it works:

• Each LP token has a rate limiter

• Limits withdrawals to max_qty per window_duration

• Exempt addresses can bypass (for integrations)

---

Integration Points

For Protocols

• Lending protocols: Use PT as collateral (it has fixed value at expiry)

• DEXs: List PT/YT/SY for trading

• Yield aggregators: Automate yield strategies

For Users

• Wallets: Display PT/YT positions

• Portfolio trackers: Track yield positions

• Analytics: Monitor market data

• Automation: Set up yield strategies