> ## Documentation Index > Fetch the complete documentation index at: https://docs.arcus.xyz/llms.txt > Use this file to discover all available pages before exploring further. # Real-world asset perps > How Arcus perps on equities, commodities, and indices give 24/7 leveraged exposure that tracks the total return of the underlying — including dividends, splits, and futures rolls Alongside crypto, Arcus offers perps on **real-world assets (RWAs)** — equities, commodity ETFs, and index ETFs. They work like crypto perps (a CLOB, [margin](/concepts/perpetuals/margin), [funding](/concepts/perpetuals/funding), and [liquidations](/concepts/perpetuals/liquidations)), but they reference assets that trade on a schedule and whose returns come from more than just price. Arcus is designed so an RWA perp tracks the **total return** of its underlying, around the clock. This page is educational and conceptual. The exact risk parameters (margin multipliers, price-band widths, funding intervals) are part of each market's configuration and are read from the API, not documented here. ## Why RWA perps * **24/7 exposure.** The underlying stock or commodity market is open only part of the week; the perp lets you take or adjust a position any time — overnight, weekends, holidays. * **Leverage and shorting.** Go long or short with [leverage](/concepts/perpetuals/margin), from the same USDG collateral you use for crypto. * **One account, many asset classes.** Crypto, equities, commodities, and indices share a single balance and margin system. ## Tracking total return Holding a stock or commodity in the traditional world earns (or costs) more than the change in its quoted price — dividends, corporate actions, and the shape of the futures curve all matter. Arcus passes these through so the perp reflects what a holder of the underlying would actually experience, rather than drifting away from it. The adjustments flow through [funding](/concepts/perpetuals/funding) and the [oracle price](/concepts/perpetuals/prices#oracle-price). ### Dividends When a stock goes ex-dividend, its market price drops by roughly the dividend. On its own that would show up as a loss for a long. Arcus offsets it with a funding payment to longs, so the dividend isn't lost — it's reflected in the position's return. > *Illustrative:* a stock priced at \$100 pays a \$2 dividend and opens at \$98. A long sees -\$2 from the price move and +\$2 from funding — net flat from the dividend itself, exactly as a holder of the stock would experience. ### Splits On a stock split or reverse split, open orders and a position's price reference are adjusted by the split factor so the economics are unchanged. > *Illustrative:* in a 2:1 split, a position of 100 units at \$10 becomes 200 units at \$5 — same exposure, same value. ### Futures rolls For markets built on futures, the contract being referenced changes on a roll schedule. Arcus accounts for the price difference between the contract rolled out of and the one rolled into and passes it through funding ("roll payment"), so your exposure stays continuous instead of jumping on roll dates. ## Trading when the underlying is closed Outside the underlying's regular hours, liquidity is thin and there's no reliable external price to anchor to. Arcus keeps the market open but adds guardrails so off-hours trading stays orderly and positions are not easily liquidated purely because of thin overnight or weekend liquidity: | Guardrail | What it does off-hours | | - | - | | **Fixed funding** | Funding switches from the live, market-driven rate to a fixed base rate (SOFR + 0.5%), set at the close — so carrying a position overnight or over a weekend has a predictable funding cost. | | **Higher initial margin** | Opening or increasing a position requires more collateral; maintenance margin is unchanged. The requirement rises at the close and returns to its in-session value at the reopen. See [Margin](/concepts/perpetuals/margin#crossing-the-session-boundary). | | **Price bands** | Trading and the mark price are limited to a range around the last regular-hours price, widening only gradually under sustained pressure — curbing [liquidation](/concepts/perpetuals/liquidations) cascades in thin markets. | | **Internal mark price** | With no live external quote, the [mark price](/concepts/perpetuals/prices#mark-price) is a 2.5-minute EWMA of the order book's impact mid, bounded by the price bands. | ### How price bands widen When a market leaves its regular-hours window, the engine **seals a settlement anchor** — `currentSettlementPrice`, a VWAP of the closing session — and centers the band on it. The band starts narrow and can only widen in fixed steps, a **`0.5x` → `1x` → `2x` → `4x`** multiplier ladder, under sustained one-directional pressure. Each edge sits at: ``` upperTradingBound = currentSettlementPrice × (1 + initialMarginFraction × bandMultiplier) lowerTradingBound = currentSettlementPrice × (1 − initialMarginFraction × bandMultiplier) ``` Because the width scales with `initialMarginFraction`, how far price can travel inside the band scales **inversely with leverage** — a lower-leverage (better-collateralized) market is allowed a wider move. At the `4x` ceiling, for example: | Max leverage | Allowed move from the settlement anchor | | - | :-: | | 10x | up to ±40% | | 5x | up to ±80% | The anchor is **per session**: a fresh anchor seals at each **weekday RTH close (20:00 ET, Monday–Friday)**, where the previous band is discarded and both sides reset to the `0.5x` rung around it. There is no weekend re-seal — Friday's 20:00 ET close carries the whole weekend, until regular hours reopen Monday at 04:00 ET. Within a session the ladder is **one-way** — an expanded side never contracts, even if price fully recovers; it only resets when the next session's anchor seals. The **upper and lower sides expand independently** — each carries its own multiplier and its own clock, so in a one-sided run one edge can reach `4x` while the other is still at `0.5x`. Each step up is gated by a **1-hour sustained-pressure clock**. A side *enters its expansion zone* when the 1-hour EWMA of that side's impact price **reaches or passes 90% of the distance from the anchor to the edge — including prices beyond the edge itself**. It is a one-sided threshold, not a bounded strip: the zone is everything at or past the 90% mark, with no upper limit (a price already trading through the edge is still in-zone, driving the clock toward expansion). On a 10x market at the first rung, for example, the upper zone starts at `anchor × 1.045` — 90% of the way to the `anchor × 1.05` edge — and extends through the edge and beyond. The zone edges are not separate API fields, but derive directly from the formula: `anchor × (1 ± 0.9 × initialMarginFraction × bandMultiplier)`. Entering the zone starts the clock; if the EWMA stays in the zone for a continuous hour (with resting depth still present), that side widens one rung. If it eases out of the zone first, the clock resets and no expansion happens. There is **no halt state** — the market never stops, and trading inside the band is never restricted. The bound is enforced per order: a crossing order fills as far as the boundary allows, and only the portion that would execute at or beyond it is rejected (`FILL_WILL_EXCEED_TRADING_BOUND`) — so a run can't blow through every level at once. Here is one full off-hours session on a 10x market (anchor `65.71`, first rung ±5%), showing a single lower-side expansion: Price chart of one off-hours session: settlement anchor at 65.71 with trading bounds at ±5% and next bounds at ±10%; price drops into the lower expansion zone (at or past 90% of the way to the lower edge), holds for an hour, and the lower bound steps from −5% to −10% while the next lower bound steps to −20%; price then recovers but the widened bounds remain; the upper side is untouched throughout. The same lifecycle as a state machine — note the two very different ways back from the zone: easing out resets only the *clock*, never the band; rungs are permanent for the session: ```mermaid theme={null} flowchart LR Start([Market exits RTH
anchor seals, both sides at 0.5×]) --> Rest["Band holds at its current rung
(rungs only ever increase)"] Rest -->|"impact-price EWMA enters the zone
→ ZoneEnteredAt stamped, 1h clock starts"| Zone["In expansion zone
clock running"] Zone -->|"EWMA eases out before the hour
→ clock resets — band UNCHANGED,
it does not narrow"| Rest Zone -->|"in zone for the full hour
→ widen one rung, permanent
for the session"| Rest Rest -->|"at the 4× ceiling"| Ceil([No further widening
next…TradingBound == …TradingBound]) ``` The diagram shows **one side**. The upper and lower sides run this state machine independently and can be on different rungs at the same time. The whole machine restarts — new anchor, both sides back at `0.5×` — only when the next session's anchor seals. Crypto perps have **no** off-hours regime — their markets never close. ### Reading the band from the API The band is fully observable. The [`markets` fields](/api-reference/public/get-markets) below are read from `GET /v1/markets` (and the same values ship on the streaming `markets` channel). Off-hours band state and **every off-hours transition** stream on the dedicated `marketAttributes` channel — a per-market snapshot on subscribe, then that market's full updated block on each event: RTH⇄off-hours crossings (`isOutsideRth`; band fields populate on the off-hours exit and return to `null` on the next open), VWAP seals, and the finer bound events (a side entering or leaving its zone, or a bound expanding — `boundEvent`: `expansionZoneEntered`, `expansionZoneExited`, `tradingBoundExpanded`). It supersedes the older per-market `marketAttributes` entries on the `exchangeAttributeUpdates` channel. **These fields carry a value only while the underlying is closed.** The keys are **always present** on every RWA market; each holds a real value only when the market is outside RTH with a sealed anchor (`isOutsideRth` is `true`), and reads **`null`** otherwise — during regular trading hours, and for **24/7 crypto markets**, which have no settlement anchor and no band. Decide whether the band applies by checking `isOutsideRth` (or a non-`null` `currentSettlementPrice`) — do **not** test for the field's absence, as the key is always there. The four zone-timing fields are `null` unless their own side's `is…InExpansionZone` is `true`. Bound values are also **per session**: at every weekday 20:00 ET re-seal, all of them recompute against the fresh anchor. Compare the `is…InExpansionZone` flags only against bounds read in the same snapshot — against bounds cached from an earlier session they will look wrong, and a flag can legitimately flip `true` at the boundary itself if price is already inside the new, narrower band's zone. | Field | Meaning | Non-`null` when | | - | - | - | | `currentSettlementPrice` | Sealed VWAP anchor the band is centered on, fixed at the RTH close. | Off-hours + sealed anchor | | `upperTradingBound` | Current upper edge. Fills at or above it are rejected until the side expands. | Off-hours + sealed anchor | | `lowerTradingBound` | Current lower edge. Fills at or below it are rejected until the side expands. | Off-hours + sealed anchor | | `nextUpperTradingBound` | Where the upper edge moves if it expands one rung; equals `upperTradingBound` at the `4x` ceiling. | Off-hours + sealed anchor | | `nextLowerTradingBound` | Where the lower edge moves if it expands one rung; equals `lowerTradingBound` at the `4x` ceiling. | Off-hours + sealed anchor | | `isUpperInExpansionZone` | Upper side's impact EWMA is at or past 90% of the way to its edge — including beyond the edge (clock running). | Off-hours + sealed anchor | | `isLowerInExpansionZone` | Lower side's impact EWMA is at or past 90% of the way to its edge — including beyond the edge. | Off-hours + sealed anchor | | `upperZoneEnteredAt` | Unix seconds the upper side entered its zone (clock start); constant while in-zone. | `isUpperInExpansionZone` is `true` | | `upperExpectedExpansionAt` | Unix seconds of the **earliest** the upper edge can widen — exactly one hour after entry. Not a guarantee: the EWMA must still be in the zone with depth when the hour completes. | `isUpperInExpansionZone` is `true` | | `lowerZoneEnteredAt` | Unix seconds the lower side entered its zone. | `isLowerInExpansionZone` is `true` | | `lowerExpectedExpansionAt` | Unix seconds of the earliest the lower edge can widen. | `isLowerInExpansionZone` is `true` | There is no single combined `currentTradingBound` / `nextTradingBound` in the API: because the two sides move independently, the "current" and "next" bound are reported per side as the `upper…` / `lower…` pairs above. ## Related concepts How dividends, splits, rolls, and off-hours rates are applied. The mark price that drives risk, and how the oracle is sourced open vs. closed. Collateral, leverage, and the off-hours margin regime. What triggers a liquidation and how off-hours bands help. This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.