Technical overview

What Elysium is

Elysium is a general-purpose, high-performance DeFi EVM chain — an Arbitrum Orbit (Nitro/ArbOS) Layer 2 that settles to HyperEVM and is co-located with HyperCore, with HYPE as its native gas token.

HyperEVM is a deliberately constrained environment: its small blocks (3M gas / 1s, with 30M gas only on 60-second big blocks) are designed to keep activity composing with HyperCore, not to host sustained high-frequency activity on the EVM itself. Elysium supplies the throughput that workload needs — a 300 Mgas/s execution target at 100–200 ms blocks, roughly two orders of magnitude more gas per second — while staying inside the Hyperliquid ecosystem: assets, settlement, and market structure all remain Hyperliquid-native. High-frequency trading and professional market-making AMMs are the flagship tenants; the chain itself is general-purpose DeFi, and anything that runs on an EVM runs here.

HYPE is the gas token. HYPE is HyperEVM's own native coin, and it is Elysium's native gas token end to end: it bridges in 1:1 as native gas, withdraws 1:1, and there is no wrapper asset, no staking hop, and no new token to hold just to transact.

Chain specifications

Architecture in ten lines

traders / prop AMMs ─► Elysium L2 (Arbitrum Orbit/Nitro, operated with Conduit;

│ real 100–200 ms canonical blocks, 300 Mgas/s target)

│ READ (phase two): HyperCore state via a chain-native precompile, fed by a

│ co-located Hyperliquid node — each read commits to the bytes it serves

│ WRITE (phase two): dapp ─► ElysiumCoreWriter predeploy (emits intent) ─► keeper

│ ─► trade-only agent on the user's own HyperCore account (≈100–200 ms)

▼

HyperEVM (chain 999) — settlement + AnyTrust DA anchor (~100-byte certificate

│ on-chain, full-data fallback); native HYPE bridges 1:1 as gas;

│ token bridges: canonical (HyperEVM ─► Elysium, lock/mint) +

│ mirror (Elysium ─► HyperEVM, the exact reverse)

▼

HyperCore (≈100 ms HyperBFT) — spot books, prices, HIP-3 perps — tokens reach a

real order book via the deposit-wallet linkage

Unmarked layers are live at launch; the read/write lanes land in phase two, approximately four weeks after mainnet.

HyperCore composability — phase one: tokens & bridging

Token bridging is the first phase of Elysium's HyperCore composability and the launch emphasis: the contracts are built and tested, and the HyperCore linkage layer is live on Hyperliquid mainnet today.

• HYPE moves as native value in both directions — deposit HYPE on HyperEVM, receive native gas on Elysium 1:1; burn native, withdraw HYPE 1:1.
• Any HyperEVM ERC-20 bridges to Elysium permissionlessly. The canonical Arbitrum bridge locks the token on HyperEVM and mints a 1:1 representation on Elysium, auto-deployed on first deposit — no registration, no issuer action, no permission from anyone.
• Elysium-native tokens bridge to HyperEVM through the mirror bridge — the exact reverse of the canonical leg: the native token locks on Elysium and a 1:1 mirror is minted on HyperEVM. The native token needs zero bridge code — no special interfaces, no supply discipline; a token launched yesterday bridges the same as one designed for it. Setup is a single permissionless issuer transaction through a factory that deploys the mirror and registers it on both chains atomically.
• Tokens graduate onto HyperCore. A linked HyperEVM token reaches a real HyperCore spot order book through the deposit-wallet flow — an escrow contract that HyperCore itself credits and debits. This linkage layer is deployed, in use on Hyperliquid mainnet, and carries a strict solvency invariant: escrowed balance always equals circulating Core supply.

Put together, a token can traverse its entire lifecycle without leaving the Hyperliquid ecosystem:

HyperCore composability — phase two: the read/write edge

Approximately four weeks after mainnet, Elysium adds native read and write access to HyperCore itself. The chain launches on stock ArbOS; the read precompile and the ElysiumCoreWriter predeploy are delivered together as a scheduled ArbOS network upgrade.

Native HyperCore market data (the read edge). A chain-native precompile serves live HyperCore state to any contract for ordinary call gas: order books up to full depth, oracle/mark/spot prices, balances, and positions, plus computed aggregates (depth within ±bps, flow imbalance, expected slippage) — at ≈100 ms core-block granularity, with ≈150–350 ms in-EVM freshness. There are no oracle contracts, no relay hops, and no per-update push costs: Elysium runs its own co-located Hyperliquid node and serves the data from inside the execution layer, so quote-fresh market data is simply there for every contract. Each response is stamped with the HyperCore block height and timestamp it was derived from, and every read commits to the exact bytes it serves — deterministic under replay and auditable against public HyperCore data. For comparison: HyperEVM's own L1Read precompiles resolve at 1-second granularity and best-bid/offer at most, and on other venues market makers pay gas continuously to push oracle updates.

Fast HyperCore writes (the keeper lane). Contracts on Elysium can drive orders on HyperCore's books at ≈100–200 ms from intent to resting order. The mechanism keeps custody with the user: trading happens on the user's own HyperCore account via a trade-only API agent — HyperCore itself enforces that agents can place and cancel orders but can never withdraw or transfer funds. Setup is an on-chain handshake: the dapp's contract binds its trading account once on the ElysiumCoreWriter predeploy and designates a registrar (Kinetiq's managed signing service, or bring-your-own-agent with your own key and listener — the intent event stream is the open interface, and switching providers is a rebind). Intents emitted on Elysium are executed as signed HyperCore actions within about one core block; fills attribute to the user's account at the user's own fee tier, and the user can revoke the agent with one native HyperCore action at any time. Dapps can additionally opt in — by prefunding a small gas escrow — to an on-chain callback that reports each action's HyperCore outcome back to the originating contract, so intents never fail silently. For comparison: HyperEVM's CoreWriter interface is asynchronous and gated to the 1-second block cadence, with no execution guarantee and no failure feedback.

Building on Elysium

Elysium is a standard EVM. Solidity and Vyper compile unchanged; Foundry, Hardhat, viem, ethers, and standard JSON-RPC all work exactly as on any Arbitrum chain; deploying is forge create / hardhat deploy against an RPC URL. There are no required custom interfaces — the Elysium-specific surfaces (the HyperCore read precompile and the ElysiumCoreWriter predeploy) are opt-in capabilities, not obligations.

• Fees are paid in HYPE and are low by construction: data availability costs are committee-based rather than per-byte-on-chain, so parent-chain fees per transaction are minimal. The fee environment is tuned so that a market maker refreshing quotes 5–10 times per second is cheap and sustainable.
• Market data is free at the point of use (phase two): strategies that would pay continuous oracle-update gas elsewhere read fresh HyperCore state here for ordinary call gas.
• A builders allocation of sequencer revenue is reserved for ecosystem incentive programs for applications building on the chain.
• Network details — chain ID, public RPC endpoints, block explorer, testnet and faucet — will be published at launch.

Security & data availability

• Optimistic rollup settling to HyperEVM. Single sequencer and permissioned validation at launch, with a staged path to permissionless fraud proofs (Arbitrum BoLD) as the chain matures — the standard launch posture for Nitro chains.
• AnyTrust data availability. A k-of-n data availability committee stores full transaction data and attests to it on-chain with a compact certificate; a single honest committee member preserves data availability. If the committee is ever unavailable, the chain automatically posts full data to HyperEVM instead — degraded cost, never a halt.
• What users keep unconditionally: transaction inclusion can be forced through the delayed inbox even if the sequencer censors; withdrawals are protected by the challenge period; and all HyperCore-side assets sit in users' own Core accounts — revoking a trading agent or acting with the master key directly never involves Elysium at all.
• The keeper adds no custodial trust: agents are trade-only by HyperCore's own enforcement, and the service is substitutable (bring-your-own-agent).
• Core data reads are auditable: every precompile response is verifiable against public HyperCore data, and the data path fails visibly stale rather than silently wrong.

Roadmap

1. Launch — the chain live on stock ArbOS with native HYPE gas, 100–200 ms blocks, AnyTrust DA, HyperEVM settlement, and the full token-bridging surface (canonical bridge, mirror bridge, HyperCore graduation path).
2. ≈4 weeks post-mainnet — the read/write edge, delivered as an ArbOS network upgrade: the native HyperCore data precompile and the keeper fast-write lane.
3. Hardening — MEV telemetry and native Timeboost, block-time tuning toward HyperCore's ≈100 ms parity, permissionless proving (BoLD), and audits.

This document is informational and pre-launch; parameters and timelines may be refined. For integration questions or early access, contact the Kinetiq team.