# Elysium network

Elysium is Kinetiq's Arbitrum Orbit chain. It settles on HyperEVM and uses HYPE for gas.

| | |
|---|---|
| Chain ID | `99901` |
| Parent chain | HyperEVM (`999`) |
| Native asset | HYPE, 18 decimals |
| Block time | a few hundred milliseconds |
| Base fee | floor of about 0.1 gwei |
| Tartarus RPC | `https://api.tartarus.world/v1/rpc` |
| Explorer | [tartarus.world/explorer](/explorer), until Kinetiq publishes one |

The testnet is chain `99801`, with RPC `https://testnet-rpc.elysium.kinetiq.xyz`. It runs its own
deployment, and none of the addresses in these docs apply there.

## Which RPC to use

Elysium has no open public sequencer endpoint yet. Community RPCs serve reads, but most only relay
transactions for their own apps, and will refuse or silently drop yours. A wallet pointed at the wrong
one can fail with a generic error, or show a transaction as pending forever.

**Use the Tartarus RPC.** It serves everything a wallet needs and gets Tartarus transactions onto the
chain. If your wallet already has Elysium added with another RPC, change it there: wallets keep their
own network settings and ignore what a site suggests.

| Rule | Value |
|---|---|
| Requests | 60 per second per IP |
| Batch size | up to 25 calls |
| `eth_getLogs` | up to 2,000 blocks, or by `blockHash` |
| Errors | always JSON-RPC over HTTP 200: `-32005` rate limited, `-32603` upstream failure |

### Sending transactions

`eth_sendRawTransaction` tries the sequencer relay first. If that refuses, the transaction goes through
Elysium's delayed inbox on HyperEVM instead. This takes about **15 to 30 seconds** rather than under
a second. The same hash is returned either way, so your code does not change: just wait for the receipt.

That fallback is paid for by Tartarus, so it only carries transactions to Tartarus contracts,
UniversalRouter, Permit2, launched tokens, approved quote tokens and rewards distributors. Other
transactions, including plain HYPE transfers, may be declined with `notAllowed`.

## Gas

Gas costs very little: a swap costs a fraction of a cent. There are two things to get right.

- **Set `maxFeePerGas` above the base fee.** A transaction priced below it is dropped with no error,
  and never appears on chain. `eth_gasPrice` on the Tartarus RPC returns double the base fee to leave
  headroom, and wallets on an unrecognized network tend to use that value directly.
- **Tips are not paid.** Arbitrum Orbit chains have no priority auction, so `maxPriorityFeePerGas` of
  `0` is fine.

`eth_estimateGas` is reliable on every Tartarus path, since no swap can trigger a migration or any
other hidden work. A plain launch uses about 1.55M gas.

## Bridging HYPE

The [Bridge](/bridge) page calls Elysium's canonical rollup contracts directly, and nothing is held by
Tartarus. HYPE moves 1:1 to the same address, with no bridge fee beyond network gas.

| Direction | How | Time |
|---|---|---|
| HyperEVM to Elysium | `Inbox.depositEth()` | About a minute |
| Elysium to HyperEVM | `ArbSys.withdrawEth(address)`, then a claim on HyperEVM | About 6 days |

**A withdrawal is two transactions.** The first leaves Elysium straight away. The second pays out on
HyperEVM once the rollup confirms it, after a challenge period of 483,840 HyperEVM blocks plus the wait
for the next assertion. Nothing can shorten it or cancel it, and the claim needs a little HYPE for gas
on HyperEVM. The wait is read from the rollup, since Kinetiq has not published the mainnet figure.

**Use a regular wallet.** `depositEth` credits a contract at an aliased address it cannot spend from,
which includes Safes, smart accounts and EIP-7702 delegated accounts. The Bridge page refuses them.

To claim from your own code, `GET /bridge/withdrawals/:address` returns each withdrawal with the
`Outbox.executeTransaction` arguments, proof included, once it is ready. See
[API](/documentation/api).

Bridging only moves HYPE. Tartarus tokens do not bridge yet. See [HyperCore](/documentation/hypercore).

## Indexing

Start from block `701345`, where the factory was deployed. `TokenLaunched` gives you the token, pool and
terms; `LaunchSalt` fires just before it in the same transaction. `Swap` on the PoolManager, filtered by
`poolId`, gives you trades. The [Events](/documentation/events) page has every `topic0`.

The node behind the RPC is pruned, so state older than a few minutes is unavailable, and calls pinned
to an old block return a "missing trie node" error. Logs remain available. If you need historical
state, you will need your own archive node. Or use the [API](/documentation/api), which indexes
everything for you.