# ROPES docs

> One minute of Hyperliquid, on a rope. A one-minute prediction game on the HYPE price, on Elysium.

## Start here
- [Overview](https://ropes.nerom.site/docs/overview): One minute of Hyperliquid, on a rope. What ROPES is, what works today, and what doesn't yet.
- [Quickstart](https://ropes.nerom.site/docs/quickstart): Play your first round in two minutes, with or without a wallet.
- [How a round works](https://ropes.nerom.site/docs/how-a-round-works): One minute, from the strike to the bell, and what happens on-chain at each step.

## The market
- [Pricing](https://ropes.nerom.site/docs/pricing): How the contract quotes UP and DOWN on every trade, and why there's always a price.
- [BAIL](https://ropes.nerom.site/docs/bail): Selling your position back to the contract, at any second, up to the bell.
- [The bell & settlement](https://ropes.nerom.site/docs/the-bell): How a round ends, and why the closing price is also the next round's strike.
- [Voids & refunds](https://ropes.nerom.site/docs/voids): When a round can't be settled honestly, nobody wins or loses on it.
- [The house vault](https://ropes.nerom.site/docs/vault): The liquidity on the other side of every trade, and how it's protected.
- [Risk limits](https://ropes.nerom.site/docs/risk-limits): Every number the contract enforces, in one place.

## Trust
- [Price source & audit](https://ropes.nerom.site/docs/price-source): Where every strike and close comes from, and how anyone can check them.
- [Trust model & admin keys](https://ropes.nerom.site/docs/trust-model): Who can do what, what they can't do, and what changes before real money.
- [Threat model](https://ropes.nerom.site/docs/threat-model): What could go wrong, and what stops it.
- [Contracts & addresses](https://ropes.nerom.site/docs/contracts): Everything deployed, where it lives, and how to read it.

## Elysium
- [Why Elysium](https://ropes.nerom.site/docs/why-elysium): A one-minute market is only possible on a chain like this one.
- [The HyperCore precompile](https://ropes.nerom.site/docs/hypercore-precompile): What changes when Elysium contracts can read Hyperliquid directly.

## Playing
- [Seats, tables & stacks](https://ropes.nerom.site/docs/game-rules): The rules of the game around the market.
- [Wallet & bankroll](https://ropes.nerom.site/docs/wallet): Playing with your own wallet: deposits, seats, payouts and withdrawals.

## Token & roadmap
- [$ROPES](https://ropes.nerom.site/docs/token): The plan for the ROPES token. Not launched yet.
- [Roadmap](https://ropes.nerom.site/docs/roadmap): From testnet to an open market.

## More
- [FAQ](https://ropes.nerom.site/docs/faq): Short answers to the questions people ask first.
- [Brand kit](https://ropes.nerom.site/docs/brand): How to write and show ROPES.

---

# Overview
> One minute of Hyperliquid, on a rope. What ROPES is, what works today, and what doesn't yet.

ROPES is a one-minute prediction game on the **HYPE** price, running on **Elysium**, Kinetiq's Hyperliquid L2.

Every minute a new round opens. You pick **UP** or **DOWN**, and your climber's height on the wall *is* your position's live value, second by second. **BAIL** at any second and the contract buys your position back at the live price. Ride to the bell: if your side is right, your stack multiplies and rolls straight into the next minute. If it's wrong, you fall.

There is no order book. **The contract itself is the market maker.** On every trade it prices the round from the Hyperliquid mark, so you're in from the first second and you can always get out.

## Why this exists

Hyperliquid has prediction markets, but the shortest native recurring one lasts **a day**, and listing a new one takes a 500k HYPE stake. Nothing in the ecosystem trades at the speed of a minute, because a one-minute market is a binary option that has to be re-priced every time the price moves. That only works on a chain with ~100 ms blocks and near-zero gas. That chain is Elysium.

## What works today

On Elysium testnet (chain 99801), at [ropes.nerom.site](https://ropes.nerom.site):

- A round opens every minute, struck at the open of Hyperliquid's own 1-minute candle.
- Buy UP or DOWN, BAIL at any second, settle at the bell, redeem. All on-chain, against `RopeMarket`.
- The price of every trade is computed by the contract: `fair(UP) = Φ(ln(S/K) ÷ σ√τ)` plus a 1% spread.
- A house vault takes the other side, with a per-round risk cap.
- The scoreboard (`ArenaRegistry`) settles inside the same transaction as the money.
- A missed bell voids the round and refunds every player exactly what they paid.
- Free seats with no wallet, or your own wallet with a test-dollar bankroll.
- A public audit: every strike and close equals Hyperliquid's published candle open. See the live check on [/transparency](/transparency).
- 37 contract tests. Sources verified on the Elysium explorer.

## What does not work yet

- **Mainnet and real USDC.** Elysium mainnet goes live **Nov 9, 2026**. ROPES follows once a security review is done.
- **Per-player custody.** On testnet, players' stakes sit in one pooled house wallet run by the game server, with a ledger of who owns what. Per-player on-chain positions come before real money.
- **Reading Hyperliquid directly.** Until the HyperCore precompile ships (about four weeks after mainnet), a keeper relays the price. See [Price source & audit](/docs/price-source).
- **Open trading.** Only the operator can trade today, so nobody can front-run the relay.
- **More markets.** HYPE only for now. BTC, SOL and the 24/7 S&P are next.
- **$ROPES.** The token launches through Ascend after mainnet. See [$ROPES](/docs/token).

## Read next

- [Quickstart](/docs/quickstart): play in two minutes
- [How a round works](/docs/how-a-round-works)
- [Pricing](/docs/pricing)
- [Trust model & admin keys](/docs/trust-model)


---

# Quickstart
> Play your first round in two minutes, with or without a wallet.

## Free seat (no wallet)

1. Open [ropes.nerom.site/play](https://ropes.nerom.site/play).
2. Choose a climber and type a name.
3. Tap **PLAY FREE**. The house stakes 10 tUSDC for you.
4. When the clock says **BETS OPEN**, tap **▲ UP** or **▼ DOWN**. Entries close 35 seconds into the minute.
5. Watch your climber. Tap **BAIL** at any second to take what the market pays right now, or ride to the bell.

Free seats play the same real on-chain market. Their winnings count on the leaderboard but don't credit a balance.

## With your own wallet

1. Add **Elysium Testnet** to your wallet:

| Field | Value |
|---|---|
| Network name | Elysium Testnet |
| RPC | `https://testnet-rpc.elysium.kinetiq.xyz` |
| Chain ID | `99801` |
| Currency | HYPE |
| Explorer | `https://elysium.kinetiq.xyz/testnet-explorer` |

2. Get a little testnet HYPE for gas from the [Elysium faucet](https://elysium.kinetiq.xyz/testnet-faucet). A transaction costs about 0.00001 HYPE.
3. On the **Wallet** page, tap **GET TEST tUSDC**. That mints 10,000 test dollars to your wallet.
4. **Deposit** what you want to play with. Seats are 10 tUSDC each and come out of your bankroll with no wallet popup.
5. Play as above. Winnings go back to your bankroll. **WITHDRAW ALL** sends everything back to your wallet.

> tUSDC is test money with no value. It exists only on Elysium testnet.


---

# How a round works
> One minute, from the strike to the bell, and what happens on-chain at each step.

| Time | What happens | On-chain |
|---|---|---|
| **00:00 + ~2 s** | The round opens, struck at the open of Hyperliquid's 1-minute candle for this minute. | `openRound(opensAt, expiresAt, strike, sourceMs)` |
| **00:00 – 00:35** | Entries. Each pick is filled at the contract's live quote. | `buy(round, side, budget, maxPrice, mark, sourceMs)` |
| **any second** | BAIL. The contract buys your shares back at the live bid. | `sell(round, side, shares, minPrice, mark, sourceMs)` |
| **00:55 – 01:00** | No new buys in the last 5 seconds. Selling stays open to the bell. | |
| **01:00 + ~3 s** | The bell. The round settles on the open of the next minute's candle, which also becomes the next round's strike. The scoreboard settles in the same transaction. | `settle(round, close, sourceMs)` → `ArenaRegistry.onRoundSettled` |
| **then** | Winners redeem, and surviving stacks roll into the next minute. | `redeem(round)` |

## What "your climber's height" means

Height is the live value of your position against what you put in, drawn on a log scale so equal relative moves are equal distances on the wall. The number on the BAIL button is exactly what a sale would pay right now: the bid for your side, not the price to buy it.

## Winning, losing, compounding

- A winning share pays **1 tUSDC**. If you bought UP at 0.51, each share cost 0.51 and pays 1. That's about 1.96× on the stake.
- A losing share pays nothing. You can never lose more than your seat.
- If you survive, your whole stack rides the next round. That's how a run compounds: 10 → 19.5 → 38…
- If HYPE closes exactly on the strike, nobody beat the line and the round voids. See [Voids & refunds](/docs/voids).


---

# Pricing
> How the contract quotes UP and DOWN on every trade, and why there's always a price.

ROPES doesn't match buyers with sellers. `RopeMarket` is the market maker: it quotes both sides itself, from the Hyperliquid mark, at the moment each trade lands.

## The formula

```
fair(UP) = Φ( ln(S / K) ÷ (σ · √τ) )
```

| Symbol | Meaning |
|---|---|
| `S` | the latest Hyperliquid mark, carried in with the trade |
| `K` | the strike: the open of Hyperliquid's 1-minute candle for this round |
| `τ` | seconds left until the bell |
| `σ` | HYPE's volatility of ln(price) per √second |
| `Φ` | the standard normal CDF |

This is the fair price of a binary option: the probability that HYPE finishes above the strike, given where it is now and how much time is left. A DOWN share is worth `1 − fair(UP)`.

## The quote

| | UP | DOWN |
|---|---|---|
| **Buy at** | `fair + 1%` | `1 − (fair − 1%)` |
| **Sell (BAIL) at** | `fair − 1%` | `1 − (fair + 1%)` |

- The half-spread is **1%** (`halfSpread = 10000`, in units of 1e6).
- It **doubles in the last 10 seconds** (`lateSecs = 10`), when prices swing fastest.
- Quotes are clamped to [0, 1]. A side that has lost all its value sells for 0.
- The game won't enter a side priced above **0.90**. At that price you risk the whole stack to make 11%.

## Volatility

`σ` is measured from the last ~65 one-minute Hyperliquid closes, floored at 0.04% a minute so a quiet hour can't price the next minute as a certainty. The keeper re-measures it every hour and pushes it on-chain when it moves more than 10%. The contract only accepts `σ` between `1e13` and `5e15` (wad per √second), roughly a 0.008% to 3.9% one-minute move.

## How it's computed on-chain

`fairUpAt(s, k, tau, sigma)` is a public pure function, so anyone can check a quote:

- `ln(S/K)` uses Solady's `lnWad`.
- `√τ` uses Solady's `sqrt`.
- `Φ` uses the Abramowitz & Stegun 7.1.26 approximation of `erf` (max error 1.5e-7, below one probability unit of 1e-6) with Solady's `expWad`.

The test suite checks `Φ` against reference values (Φ(1) = 0.841345, Φ(2) = 0.977250, Φ(0.5) = 0.691462) to within 2 units of 1e-6.

## Why this needs Elysium

A one-minute binary moves fast: one $0.01 tick on HYPE can move fair value by 10 points near the bell. Pricing it fairly means re-quoting on every trade, which is only practical on a chain with ~115 ms blocks and gas around 0.1 gwei.


---

# BAIL
> Selling your position back to the contract, at any second, up to the bell.

**BAIL** sells your whole position back to `RopeMarket` at the live bid for your side: fair value at this moment, minus half the spread. There's no order book to wait on, so a bail always fills.

## When you can bail

- Any time from your entry until the bell.
- Buying stops 5 seconds before the bell. Selling does not.
- The bail is placed on the game server's next tick, about one second after you tap. The leap animation plays instantly and the money follows.

## What you get

`proceeds = shares × bid` (rounded down), where `bid = fair − half-spread` for UP, or `1 − (fair + half-spread)` for DOWN.

The **KEEP** number on the BAIL button is exactly this: the bid for your side, at the current mark.

## Example from testnet

A seat picked DOWN at 2.18×. HYPE moved against it, and the position was worth 0.94× of the stake. BAIL sold it back on-chain and banked **9.39** of the 10 staked, instead of riding to zero.

## Auto-bail

Set a target multiple and the game bails for you the tick your position's *sellable* value crosses it. The target is a trigger, not a promised price: the sale still goes through at the live bid.


---

# The bell & settlement
> How a round ends, and why the closing price is also the next round's strike.

At the top of every minute the round that just ended settles, and a new one opens.

## One price, two jobs

The **close** of round N is the **open of Hyperliquid's 1-minute candle** that starts at the bell. That same price is the **strike** of round N+1. One read serves both, so the two can never disagree, and neither can be sampled late.

## Winner

- `close > strike`: UP wins.
- `close < strike`: DOWN wins.
- `close == strike`: nobody beat the line. The round voids and everyone is refunded. See [Voids & refunds](/docs/voids).

## Same-transaction scoreboard

`settle()` calls `ArenaRegistry.onRoundSettled()` inside the same transaction. The public scoreboard can't land on a different price, or in a different block, from the result that caused it.

The hook gets a fixed gas budget (`HOOK_GAS = 1,500,000`). If a caller tries to settle with less gas than that, `settle` reverts (`HookGas`). Gas estimation therefore can't find a limit where the money settles and the scoreboard silently doesn't. A hook that fails *with* its full budget can never block the money.

## Redeem

After settlement, winning shares redeem for 1 tUSDC each (`redeem(round)`). Surviving runs roll their stack into the next round.


---

# Voids & refunds
> When a round can't be settled honestly, nobody wins or loses on it.

A round **voids** when:

1. **No price at the bell.** The close must be sampled within 8 seconds after the bell (`sampleWindowSecs = 8`), on the Hyperliquid clock. A keeper that was down for the bell can't settle on a later price.
2. **A tie.** HYPE closes exactly on the strike.
3. **An abandoned round.** If a round is still unsettled 120 seconds after its bell, **anyone** can call `voidStale(round)`. A dead keeper can't freeze money.

## What a void pays

A void **refunds every holder exactly what they paid** for the shares they still hold, their cost basis. It isn't "half a share each side", which would move money between UP and DOWN players.

If you bailed part of a position before the void, the refund follows: the cost basis leaves with the shares you sold, pro rata, and you get back the basis of what's left.

The test suite covers both a full refund and a refund after a partial bail.


---

# The house vault
> The liquidity on the other side of every trade, and how it's protected.

`RopeMarket` is the counterparty to every trade. Its liquidity comes from a **house vault**: collateral deposited by LPs in exchange for vault shares.

## How it earns

The vault's edge is the **spread**. Every buy pays fair + 1% and every sell receives fair − 1%, so on average the vault earns the spread on the volume it makes a market for. On mainnet, that spread income funds [$ROPES](/docs/token) buybacks.

## Depositing and withdrawing

- `deposit(assets)` mints vault shares at the vault's conservative value.
- `withdraw(shares)` pays out at the conservative value, **and only from the free balance**.
- The conservative value assumes every open round is lost by the vault. LPs can never withdraw money a round might owe.

## Liability accounting

The contract tracks `liability`: everything the vault currently owes or holds back.

- For an open round: its worst case, whichever side would owe more if it won.
- For a settled round: the unredeemed winnings.
- For a voided round: the unredeemed refunds.

`freeBalance() = balance − liability`. On testnet the vault is seeded with 100,000 tUSDC. Live numbers are on [/transparency](/transparency).


---

# Risk limits
> Every number the contract enforces, in one place.

| Limit | Value | What it does |
|---|---|---|
| Round risk cap | **25%** of the vault's free balance at the open (`roundCapBps = 2500`) | The most one round can ever owe its winning side. Buys that would exceed it revert (`OverCap`). |
| Buy lock | last **5 s** (`buyLockSecs`) | No new positions just before the bell. |
| Stale mark | **3 s** (`maxStaleSecs`) | A trade needs a mark at most 3 seconds old. |
| Sample window | **8 s** (`sampleWindowSecs`) | A strike must be read within 8 s of the open, a close within 8 s after the bell. |
| Late spread | doubles in the last **10 s** (`lateSecs`) | Wider quotes when price moves fastest. |
| Spread bounds | 0.2% – 10% half-spread | The owner can't set a spread outside this. |
| Round cap bounds | ≤ 50% | The owner can't let a round risk more than half the vault. |
| Volatility bounds | `1e13` – `5e15` per √s | A bad σ can't give quotes away. |
| Entry price cap | 0.90 | The game won't buy a side priced above 90%. |
| Stale-round void | 120 s after the bell | Anyone can void a round the keeper abandoned. |
| Scoreboard gas | 1,500,000 | `settle` refuses to run without it. |

The current values are read live on [/transparency](/transparency).


---

# Price source & audit
> Where every strike and close comes from, and how anyone can check them.

## Two prices, two jobs

| Price | Source | Used for |
|---|---|---|
| **Candle open** | the open of Hyperliquid's own 1-minute candle (`candleSnapshot`), the first trade of the minute | every **strike** and every **close** |
| **Live mid** | Hyperliquid's book mid (`allMids`) | pricing every **trade** between bells |

A book mid is the middle of the order book at one instant. It's the right input for a live quote, but nobody can look it up later. A candle open is a permanent, public Hyperliquid number. Settling on it makes every result checkable.

## Why we changed it

The first testnet rounds were struck at the book mid. A full-history audit of those 40 rounds found **18 of 81** strikes and closes outside Hyperliquid's trade candle for that minute, by up to $0.036. Measured at one boundary, the mid sat at 78.7135 for about 10 seconds while the minute's first trade printed 78.706. From round 47 (Oct 18, 2026) every strike and close is the candle open.

## The audit

`scripts/audit.ts` takes every `RoundOpened` (strike) and `RoundSettled` (close) event from `RopeMarket` and checks each one for **exact equality** with Hyperliquid's published candle open:

```bash
npx tsx scripts/audit.ts <fromBlock> 47 -v
```

Since the candle-open rule: **27 of 27 exact** (rounds 47–60, Oct 18). The live check of the latest rounds is on [/transparency](/transparency).

## What the relay is trusted for

Until the [HyperCore precompile](/docs/hypercore-precompile) ships, a keeper reads Hyperliquid's public API and carries the price on-chain with each open, trade and settle. The contract limits what it can do with that:

- A strike must be sampled within 8 s of the open, a close within 8 s after the bell, or the round voids.
- Hyperliquid-side timestamps must only move forward, and can't be from the future.
- Every relayed price is an event (`MarkPushed`, `RoundOpened`, `RoundSettled`), so the audit can replay all of them.


---

# Trust model & admin keys
> Who can do what, what they can't do, and what changes before real money.

## Keys

| Key | Address (testnet) | Can | Can't |
|---|---|---|---|
| **Owner** | `0xD6B5Adf4eE823f5B77917022742f2CA0e239CF01` | rotate the operator; set the scoreboard hook; adjust parameters **within fixed bounds** (spread 0.2–10%, round cap ≤ 50%, σ bounds) | move user or vault funds; change a settled round |
| **Operator** (keeper) | `0x1fABaEb15bcdf03f87A2821e46f182A401C9dD60` | relay Hyperliquid prices; open and settle rounds; place buys and sells; update σ (bounded) | settle on a price sampled outside the window; settle before the bell; withdraw the vault |
| **Anyone** | — | redeem their shares; deposit to or withdraw from the vault (free balance only); void a round abandoned for 120 s | trade (operator-only in this version) |

The contracts are **not upgradeable**. The operator's key was generated inside the hosting environment and has never been in the repo. The owner can replace it with `setOperator` if it's ever compromised.

## Custody today (testnet)

Players' stakes sit in **one pooled house wallet** run by the game server, with a Postgres ledger of whose money is whose. The on-chain scoreboard mirrors every round, entry and elimination, so the ledger can be checked against it. **This changes before mainnet:** per-player positions on-chain.

## Price trust

The keeper is trusted for prices until the HyperCore precompile ships. That trust is bounded by the contract's sample windows and checkable through the [audit](/docs/price-source).

## Why trading is operator-only

A market fed by a relay can be picked off by anyone with a faster Hyperliquid feed than the relay. Keeping trading operator-only removes that until prices come straight from HyperCore. Then trading opens to everyone.


---

# Threat model
> What could go wrong, and what stops it.

| Threat | Mitigation |
|---|---|
| The keeper relays a false price | The price must be sampled within the window; every strike and close must equal Hyperliquid's public candle open, and the [audit](/docs/price-source) checks every one. The owner can rotate the keeper. |
| The keeper settles late on a better price | A close sampled more than 8 s after the bell isn't accepted; the round voids and everyone is refunded. |
| The keeper goes down | Rounds stop opening; any round left open 120 s past its bell can be voided by anyone. Nobody's money is stuck. |
| Latency arbitrage on the quote | Trading is operator-only until prices come from HyperCore; trades carry a fresh mark; stale marks (> 3 s) block trading; no buys in the last 5 s; the spread doubles in the last 10 s. |
| A round drains the vault | Each round can risk at most 25% of the free balance; LPs can't withdraw what open rounds may owe. |
| Gas estimation starves the scoreboard | `settle` requires `HOOK_GAS` left for the hook, or reverts. |
| Nonce races between two keepers | Railway deploys the keeper with no overlap; all writes go through one signer, in sequence. |
| Rounding leaks value | Buy costs round up, sell proceeds round down; refunds never underflow `reserved`. |
| A fake ROPES account or token | Only trust **@PlayRopes** and **ropes.nerom.site**. $ROPES isn't launched yet: any "ROPES token" today is a scam. We never DM first. |

## Not yet covered

- **A professional security review.** This is the first milestone before mainnet.
- **Per-player custody.** Testnet uses a pooled house wallet.
- **Single sequencer.** Elysium launches with one sequencer; this is Elysium's own trust assumption.


---

# Contracts & addresses
> Everything deployed, where it lives, and how to read it.

**Network:** Elysium testnet · chain ID `99801` · RPC `https://testnet-rpc.elysium.kinetiq.xyz` · explorer [elysium.kinetiq.xyz/testnet-explorer](https://elysium.kinetiq.xyz/testnet-explorer). Sources are verified.

| Contract | Address | Role |
|---|---|---|
| `RopeMarket` (HYPE) | [`0x62C4b522Bf76422E77CEdA22E94e0540f9422d1D`](https://elysium.kinetiq.xyz/testnet-explorer/address/0x62C4b522Bf76422E77CEdA22E94e0540f9422d1D) | pricing, rounds, trades, settlement, redemption, house vault |
| `ArenaRegistry` | [`0xDBd28A7AacD7228edDef44c177C195878DfCa858`](https://elysium.kinetiq.xyz/testnet-explorer/address/0xDBd28A7AacD7228edDef44c177C195878DfCa858) | public scoreboard, settled inside `RopeMarket.settle` |
| `MockUSDC` (tUSDC) | [`0x46397dA50c05AfA43cBfcA712215eD1E02A9F57d`](https://elysium.kinetiq.xyz/testnet-explorer/address/0x46397dA50c05AfA43cBfcA712215eD1E02A9F57d) | test dollars, 6 decimals, open mint (10,000 per call) |

## Key functions

```solidity
// pricing (anyone)
function fairUpAt(uint256 s, uint256 k, uint256 tau, uint256 sigma) external pure returns (uint256);
function quote(uint64 id) external view returns (uint256 yesBid, uint256 yesAsk, uint256 fair);

// rounds (operator)
function openRound(uint64 opensAt, uint64 expiresAt, uint128 strikeMark, uint64 sourceMs) external returns (uint64);
function settle(uint64 id, uint128 closeMark, uint64 sourceMs) external;

// trades (operator, this version)
function buy(uint64 id, uint8 side, uint256 budget, uint256 maxPrice, uint128 mark, uint64 sourceMs) external returns (uint256 shares, uint256 cost, uint256 price);
function sell(uint64 id, uint8 side, uint256 shares, uint256 minPrice, uint128 mark, uint64 sourceMs) external returns (uint256 proceeds, uint256 price);

// anyone
function redeem(uint64 id) external returns (uint256);
function voidStale(uint64 id) external;
function deposit(uint256 assets) external returns (uint256 shares);
function withdraw(uint256 shares) external returns (uint256 assets);
```

## Events

`MarkPushed(mark, sourceMs)` · `RoundOpened(roundId, opensAt, expiresAt, strike, cap)` · `Traded(roundId, trader, side, isBuy, shares, price, amount)` · `RoundSettled(roundId, close, winner, voided)` · `Redeemed(roundId, holder, amount)`

## Code

[github.com/neromtoobad/ropes-elysium](https://github.com/neromtoobad/ropes-elysium): contracts in `contracts/src`, 37 tests in `contracts/test` (`forge test`).


---

# Why Elysium
> A one-minute market is only possible on a chain like this one.

Elysium is Kinetiq's L2 for Hyperliquid: an Arbitrum Orbit chain that settles to HyperEVM and uses **HYPE** for gas. Mainnet goes live **Nov 9, 2026**.

## What ROPES needs from a chain

| Need | Why | Elysium |
|---|---|---|
| Fast blocks | Fair value moves every tick near the bell; a trade must land before its quote is stale | ~115 ms blocks (measured on testnet) |
| Cheap writes | Every open, trade and settle is a transaction, every minute | ~0.1 gwei gas; a live minute costs ≈ 0.00003 HYPE |
| Hyperliquid prices | Rounds are on Hyperliquid's own markets | The HyperCore read precompile (≈ 4 weeks after mainnet) |
| A launch path | A token backed by game volume | Ascend, Elysium's launchpad |

On HyperEVM's small blocks, re-quoting an option on every trade isn't practical. On Elysium it costs a fraction of a cent.

## Builder share

Elysium returns 25% of sequencer fees to apps that use the blockspace. A busy wall writes several transactions a minute.


---

# The HyperCore precompile
> What changes when Elysium contracts can read Hyperliquid directly.

Kinetiq is shipping a **HyperCore read precompile** in an ArbOS upgrade about **four weeks after Elysium mainnet**. It lets an Elysium contract read Hyperliquid's order books, oracle, mark and spot prices directly, at HyperCore block granularity, attested by the sequencer.

## What it means for ROPES

| Today (keeper) | With the precompile |
|---|---|
| A keeper reads Hyperliquid's API and carries the price on-chain | `RopeMarket` reads the price itself |
| Trust in the relay, bounded by sample windows and the audit | No relay to trust |
| Trading is operator-only to stop relay front-running | **Trading opens to everyone** |
| The keeper strikes and settles | Anyone can strike and settle, with the price read on-chain |

After that, Elysium's CoreWriter keeper lane lets the vault hedge its net exposure on HyperCore, so it can offer deeper rounds without carrying more directional risk.


---

# Seats, tables & stacks
> The rules of the game around the market.

## Seats

- A seat is **10 tUSDC**: free on the house, or from your own bankroll.
- Your **stack** starts at 10. Each round your whole stack rides your pick. Win and it multiplies at the price you took; lose and you fall. You can never lose more than your seat.
- If part of a budget can't be filled, that remainder stays in your stack. It was never at risk.

## Tables

- Seats are grouped into **tables** of up to **8**. A table fills for 15 seconds, then seals, and plays until one run is left standing.
- A table with one player is a solo climb.

## Picking

- Pick **UP** or **DOWN** in the first **35 seconds** of a round. A pick made while you're already riding queues for the next round, so there's no dead time between minutes.
- No pick means you sit the round out and your stack is untouched.

## When a run ends

- **You bail:** you keep your stack.
- **You fall:** your side was wrong at the bell.
- **The sweep:** a stack under **1 tUSDC** can't climb back, so it's cashed out.
- **You walk away:** a seat with no pick for **10 rounds** is banked automatically. Its stack is cash, so you keep all of it.

## Free play limits

Free seats share the house bankroll, so there are caps: at most 12 free runs alive at once, and free seats pause if the house balance runs low. Free-play winnings count on the leaderboard but never credit a balance.

## The wall goes to sleep

If nobody is seated and nobody has the page open for 10 minutes, the game stops opening rounds to save gas. The first visitor wakes it, and the next round strikes at the top of the minute.


---

# Wallet & bankroll
> Playing with your own wallet: deposits, seats, payouts and withdrawals.

Your wallet is used for exactly two things: funding your bankroll and receiving withdrawals. There are no signatures during play. The one-minute cadence runs through the game server on testnet.

## Bankroll

1. **Mint test dollars.** **GET TEST tUSDC** calls `mint` on the tUSDC contract from your own wallet: 10,000 per call, free.
2. **Deposit.** Send tUSDC to the house and sign a message proving the deposit is yours. The deposit is verified by its on-chain receipt and credits your bankroll exactly once.
3. **Play.** Seats come out of your bankroll with no wallet popup.
4. **Payouts.** When a run ends, what's left of the stack goes back to your bankroll at once.
5. **Withdraw.** **WITHDRAW ALL** sends your whole balance back on-chain on the server's next tick.

## Safety rules

- Your **withdrawal address is the wallet that made your first deposit**, never anything the browser says.
- A deposit can only be credited once (a database-level unique on the transaction).
- A bankroll that withdraws to one wallet doesn't accept deposits from another.

## Gas

You need a little **testnet HYPE** in your wallet for the mint and deposit transactions. Get it from the [Elysium faucet](https://elysium.kinetiq.xyz/testnet-faucet). A transaction costs about 0.00001 HYPE.


---

# $ROPES
> The plan for the ROPES token. Not launched yet.

> **$ROPES has not launched.** Any "ROPES token" you see today is not ours. It will launch through **Ascend** after Elysium mainnet, and the only announcement will come from **@PlayRopes** and **ropes.nerom.site**.

## Role

- **Backed by game volume.** House-vault spread income funds $ROPES buybacks. The vault's edge is the spread, so more rounds played means more buybacks.
- **Holders pick the next rope.** Which Hyperliquid market gets a ROPES wall next: BTC, SOL, the weekend S&P.
- **Seasons and skins.** Seasonal leaderboards and climber skins use $ROPES.

## Launch

- **Where:** Ascend, the launchpad for Elysium projects.
- **When (approximate):** after ROPES is live on Elysium mainnet with real USDC and a completed security review. Target: December 2026 to January 2027.
- **Why Ascend:** ROPES is a game with many small repeat players and steady volume, the kind of "PVE coin" Ascend's holder and volume metrics reward.

Supply, launch-pool size and the exact buyback routing are still being designed.

The full plan, with the road to launch, is on [/token](/token). The mainnet countdown is on [/mainnet](/mainnet).


---

# Roadmap
> From testnet to an open market.

| When | Milestone | Done when |
|---|---|---|
| **Now** | Live on Elysium testnet | ✓ Rounds every minute, public audit, verified contracts |
| **Nov 9, 2026** | Elysium mainnet goes live | Elysium's date |
| **Before real money** | Security review and per-player custody | Review report published; positions held on-chain per player |
| **Mainnet** | ROPES on real USDC | One-minute HYPE rounds on mainnet with a seeded vault |
| **Launch** | $ROPES on Ascend | Token live; vault income funding buybacks |
| **≈ 4 weeks after mainnet** | HyperCore precompile | No keeper: prices read on-chain; trading open to everyone |
| **Then** | Hedged vault | Net exposure hedged on HyperCore through CoreWriter |
| **Then** | More ropes | BTC, SOL, and the 24/7 S&P for weekends, when TradFi is shut |


---

# FAQ
> Short answers to the questions people ask first.

**Is this real money?**
Not yet. Testnet uses tUSDC, a test dollar with no value. Mainnet with real USDC follows Elysium mainnet (Nov 9) and a security review.

**Do I need a wallet?**
No. Take a free seat and play the same on-chain market on the house.

**Can I lose more than my seat?**
No. The most you can lose is the stake you put in.

**Who sets the price?**
The contract, on every trade, from the Hyperliquid mark. See [Pricing](/docs/pricing).

**Where do the strike and close come from?**
The open of Hyperliquid's own 1-minute candle. Anyone can check them. See [Price source & audit](/docs/price-source) and [/transparency](/transparency).

**What happens if the price feed fails at the bell?**
The round voids and everyone gets back exactly what they paid.

**What's the house edge?**
The spread: you buy at fair value + 1% and sell at fair value − 1%. There's no other fee.

**Why can't I trade the contract directly?**
Until prices come straight from HyperCore, trading is operator-only so nobody can front-run the price relay. It opens to everyone after the precompile ships.

**Is there a token?**
Not yet. $ROPES launches on Ascend after mainnet. Anything else claiming to be ROPES is a scam.

**Who builds ROPES?**
[neromtoobad](https://nerom.site), solo. Code is open: [github.com/neromtoobad/ropes-elysium](https://github.com/neromtoobad/ropes-elysium).


---

# Brand kit
> How to write and show ROPES.

## Name

**ROPES**, in capitals. The tagline is *one minute of Hyperliquid, on a rope*. The token is **$ROPES**.

## Official channels

- X: [@PlayRopes](https://x.com/PlayRopes)
- Site: [ropes.nerom.site](https://ropes.nerom.site)
- Code: [github.com/neromtoobad/ropes-elysium](https://github.com/neromtoobad/ropes-elysium)

We never DM first and never ask for keys or seed phrases.

## Colours

| Name | Hex | Use |
|---|---|---|
| Night | `#0d0a1c` | background |
| Panel | `#161329` | cards |
| UP | `#00e58a` | UP, winning, live |
| DOWN | `#ff2f52` | DOWN, falling |
| Gold | `#ffc94d` | the line to beat, money, highlights |
| Text | `#eeecf5` | body |
| Dim | `#8d8ab0` | secondary text |

UP is always green, DOWN is always red, and the line to beat is always gold.

## Type

- **Russo One** for headlines, in capitals.
- **Chakra Petch** for body text.
- **JetBrains Mono** for numbers, addresses and labels.

## Signature art

![The ROPES climber at the top of the minute](/brand/signature.png)

The hooded climber at the top of a rope, as the minute dial reaches 60 and the bell is about to ring. It's the key art for posts, link previews and the anti-scam closer. Download: [`/brand/signature.png`](/brand/signature.png).

## Post frame

Every ROPES image uses the same frame: the logo top-left, a tag chip top-right (green for announcements and proof, gold for build logs and roadmaps, violet for explainers, red for safety), and the rope footer strip with ropes.nerom.site and @PlayRopes. Headlines are Russo One in capitals; one word in green, gold or red carries the point.

## Logo

The knot on a rope with a candle in its heart. Files are in the repo under `public/` (`logo-full.png`, `mark.webp`, `icon.png`).