What Is Elysium? A Developer's Guide to Kinetiq's Arbitrum Orbit L2 on HyperEVM

Import elysiumTestnet from viem/chains and you get chain ID 1338, a gas token called LAVA, and an RPC URL on vulcanforged.com. That is a different chain. The Elysium most Hyperliquid builders are asking about is Kinetiq's, it runs on chain ID 99801, and it pays gas in HYPE. If your client config came from a chain registry, check it before you send a transaction.

Elysium is an Arbitrum Orbit chain built by Kinetiq, the team behind the kHYPE liquid staking token and Markets.xyz. It executes on its own fast chain, settles to HyperEVM instead of Ethereum, and targets high-frequency trading and market-making AMMs. The public testnet opened on September 22, 2026. Mainnet has no confirmed date in the Kinetiq docs; Kinetiq's X account has teased November 9.

This guide covers what Elysium changes for developers: how it settles, how it orders transactions, what the trust model looks like today, what it will be able to read from HyperCore, and what the RPC layer looks like in practice. Every network figure below comes from probes we ran against the public testnet RPC on October 21, 2026.

Why Hyperliquid Needs an L2

HyperEVM is constrained on purpose. It produces fast blocks every second with a 3M gas limit and slow blocks every minute with a 30M gas limit. That keeps EVM activity in step with HyperCore, the order-book engine underneath Hyperliquid, but it leaves little room for sustained high-frequency flow.

An on-chain market maker that refreshes quotes several times per second cannot fit into 3M gas per second alongside every other HyperEVM user. Elysium moves that flow onto a separate chain with a 300 Mgas/s target and 100 to 200 ms blocks, roughly 100 times HyperEVM's gas throughput, while keeping HYPE as the gas token and HyperEVM as the settlement layer.

Kinetiq names two flagship workloads: high-frequency trading and professional market-making AMMs, with fees tuned so a market maker can refresh quotes 5 to 10 times per second. Underneath, Elysium is a general-purpose EVM chain, so any standard DeFi contract deploys unchanged.

Architecture: Arbitrum Nitro on a Hyperliquid Parent

Elysium runs stock Arbitrum Nitro, the same client behind Arbitrum One. The testnet reports ArbOS 61 ("Elara"), the version that activated on Arbitrum One in August 2026. Solidity and Vyper contracts compile unchanged, and Foundry, Hardhat, viem and ethers.js behave as they do on any Orbit chain.

The differences sit outside the EVM.

Settlement to HyperEVM

Every Nitro block header carries an l1BlockNumber field. On Elysium that number is a HyperEVM height, not an Ethereum one. On testnet it tracked the HyperEVM testnet head within about 15 blocks during our probes.

The rollup contracts live on HyperEVM: the SequencerInbox receives batch certificates, the Bridge holds deposited HYPE, and the Outbox processes withdrawals. Kinetiq publishes the full address list on its contract addresses page. SequencerInbox.isUsingFeeToken() returns false, so HYPE is the parent chain's native asset and no custom fee-token wrapper sits in between.

This settlement path has one practical consequence for anyone running a node. A Nitro node follows the chain by reading SequencerBatchDelivered events from the parent chain with eth_getLogs. An Elysium node therefore needs a HyperEVM RPC that serves log queries reliably. The public HyperEVM testnet RPC times out on 100-block eth_getLogs queries against the inbox, so a node cannot sync through it.

Data availability through AnyTrust

Elysium does not post full transaction data to HyperEVM. An AnyTrust data availability committee stores the data and signs a certificate, and only that certificate goes to the parent chain. If the committee fails to sign, the chain falls back to posting full data on HyperEVM, according to Kinetiq's security and data availability page.

AnyTrust is the reason Elysium can run fast blocks without paying HyperEVM gas for every byte. The trade-off is a trust assumption: you rely on at least some committee members to keep the data available. Conduit serves the committee data over a REST endpoint that every follower node reads from.

The node, measured

Here is a short script that confirms the chain, the ArbOS version and the parent-chain link in one pass. It uses a viem chain definition with the correct ID, since the built-in elysiumTestnet points at the wrong network.

import { createPublicClient, defineChain, http, parseAbi } from 'viem'

const RPC = process.env.ELYSIUM_RPC ?? 'https://testnet-rpc.elysium.kinetiq.xyz'

export const elysiumTestnet = defineChain({
  id: 99801,
  name: 'Elysium Testnet',
  nativeCurrency: { name: 'HYPE', symbol: 'HYPE', decimals: 18 },
  rpcUrls: { default: { http: [RPC] } },
  blockExplorers: {
    default: { name: 'Elysium Explorer', url: 'https://elysium.kinetiq.xyz/testnet-explorer' },
  },
})

const client = createPublicClient({ chain: elysiumTestnet, transport: http() })

// ArbSys precompile: arbOSVersion() returns the ArbOS version plus 55
const arbOS = await client.readContract({
  address: '0x0000000000000000000000000000000000000064',
  abi: parseAbi(['function arbOSVersion() view returns (uint256)']),
  functionName: 'arbOSVersion',
})

// Nitro adds l1BlockNumber to every header; on Elysium it is a HyperEVM height
const raw = await client.request({ method: 'eth_getBlockByNumber', params: ['latest', false] })

console.log('chain ID      ', await client.getChainId())
console.log('ArbOS         ', Number(arbOS) - 55)
console.log('L2 block      ', BigInt(raw.number))
console.log('l1BlockNumber ', BigInt(raw.l1BlockNumber), '(HyperEVM testnet)')
console.log('base fee gwei ', Number(BigInt(raw.baseFeePerGas)) / 1e9)

Output on October 21, 2026 (viem 2.57.7, Node 23):

chain ID       99801
ArbOS          61
L2 block       12719639n
l1BlockNumber  67485055n (HyperEVM testnet)
base fee gwei  0.10001

Sequencing and Transaction Ordering

Elysium has one sequencer, operated by Conduit on its rollup stack. Within each block it orders transactions by priority fee, and Kinetiq's blocks, fees and ordering page is explicit that there are no privileged lanes. A quote update and a swap compete on the same fee basis.

Three details matter for trading code:

1. There is no public mempool. Transactions go straight to the sequencer. eth_newPendingTransactionFilter and pending-transaction subscriptions return an ID and then never deliver anything. Strategies that watch pending flow on Ethereum have nothing to watch here.
2. The base fee floor is 0.1 gwei. We observed base fees between 0.1 and 0.10022 gwei. eth_maxPriorityFeePerGas returned 0, because the chain is not congested enough for tips to matter yet.
3. Ordering will change after launch. Kinetiq's roadmap adds a dedicated trading ("keeper") lane about four weeks after mainnet, then Timeboost later. Code that assumes pure priority-fee ordering should expect to be revisited.

Trust Model: Validation, Withdrawals and Forced Inclusion

Kinetiq describes validation as "permissioned at launch, moving to permissionless fraud proofs (Arbitrum BoLD)". On-chain, the testnet rollup already runs the BoLD contracts: genesisAssertionHash() responds and the legacy latestNodeCreated() reverts. What keeps validation permissioned is the whitelist, with validatorWhitelistDisabled() returning false. The move to permissionless proofs is a configuration change, not a contract migration.

The 10-block confirm period is a testnet setting. Kinetiq has not published the mainnet challenge period, and withdrawal tooling should read it from the rollup contract instead of hardcoding it.

Two guarantees apply regardless of the sequencer. Users can force transactions through the delayed inbox on HyperEVM after the 24-hour window, and anyone can rebuild the chain state from the parent chain plus committee data.

HyperCore Access: Coming After Mainnet

The feature that makes Elysium more than "a faster HyperEVM" is not live yet. About four weeks after mainnet, an ArbOS upgrade adds two pieces, described in Kinetiq's HyperCore market data and trading on HyperCore pages.

A read precompile. Contracts will read HyperCore order books (top of book to full depth), oracle, mark and spot prices, account balances and positions, plus computed aggregates such as depth within a band around mid, flow imbalance and expected slippage. Data arrives at HyperCore block granularity (around 70 ms) and is 150 to 350 ms old by the time it is visible in the EVM. Each response includes the HyperCore block height and timestamp.

The trust assumption is specific: the sequencer attests the data, and nothing proves it. HyperCore publishes no state roots, so a contract cannot verify a precompile response against a commitment. Elysium runs its own co-located Hyperliquid node to source the data.

A write path. Contracts emit order intents through an ElysiumCoreWriter predeploy. A keeper signs each intent as a trade-only HyperCore API agent on the user's own account, landing in roughly 100 to 200 ms, with optional result callbacks paid from a HYPE escrow. Actions on Elysium and HyperCore are not atomic. Your contract must handle the case where the Elysium side succeeds and the HyperCore order does not fill.

Neither the precompile address nor the predeploy address is published yet.

HYPE and Bridging

HYPE moves 1:1 between HyperEVM and Elysium as native value, with no wrapped representation on the Elysium side. The token bridging docs describe three routes:

• The canonical bridge, the stock Nitro token bridge, for HyperEVM tokens moving to Elysium.
• The mirror bridge for Elysium-native tokens, which lock on Elysium while a 1:1 mirror mints on HyperEVM. Use expectedL1Mirror(token) to find the canonical mirror address.
• A HyperCore link through deposit-wallet escrow.

Fee-on-transfer and rebasing tokens are not supported. Deposits create retryable tickets, and a ticket that is never redeemed can expire after several days, so bridge UIs need a redeem path.

Targets vs Measured Performance

The headline numbers are design targets. Kinetiq says the throughput figure will be "validated in load testing before mainnet". Here is what the testnet showed on October 21, 2026:

Block time is inside the target range. Throughput is about 1% of the target, which reflects how little traffic the testnet carries. Nothing on testnet stresses the chain yet.

Measure block time against the wall clock, not block timestamps. Timestamps have one-second resolution, so 6 to 8 consecutive Elysium blocks share the same value:

// blocktime.mjs (ES module, uses top-level await)
const RPC = process.env.ELYSIUM_RPC ?? 'https://testnet-rpc.elysium.kinetiq.xyz'
const call = async (method, params = []) => {
  const res = await fetch(RPC, {
    method: 'POST',
    headers: { 'content-type': 'application/json' },
    body: JSON.stringify({ jsonrpc: '2.0', id: 1, method, params }),
  })
  return (await res.json()).result
}

// Sample the head twice, 10 seconds apart, and divide wall-clock time by blocks produced.
// Block timestamps have 1-second resolution, so they cannot measure 100-200 ms blocks.
const start = Number(await call('eth_blockNumber'))
const t0 = Date.now()
await new Promise((r) => setTimeout(r, 10_000))
const end = Number(await call('eth_blockNumber'))
const ms = Date.now() - t0

console.log(`${end - start} blocks in ${ms} ms = ${(ms / (end - start)).toFixed(0)} ms per block`)
// 81 blocks in 10443 ms = 129 ms per block

The same rule applies to application code. Order events by block number and log index, never by timestamp.

Network Details

The public endpoint is fine for a first deployment and runs out of road quickly after that:

• eth_getLogs without an address filter is capped at 2,000 blocks, about 4 minutes of chain history at current block times.
• With an address filter, results stop at 10,000 logs per query.
• debug_* and trace_* return "authenticated API key required".
• WebSocket upgrades return 401, so eth_subscribe is unavailable.
• Batches of 100 or more calls fail with a rate-limit error.

At 7 to 8 blocks per second, Elysium produces about 670,000 blocks a day. An indexer that queries without an address filter works in 2,000-block windows and needs more than 300 eth_getLogs calls to cover one day of history. A trading system that polls eth_blockNumber instead of subscribing over WebSocket falls behind within seconds.

Connecting to Elysium

The public RPC covers the first afternoon of development. After that you need an endpoint with WebSocket, debug tracing, archive state and a log range that does not force 300 calls per day of history.

Dwellir is bringing up an archive Elysium endpoint with WebSocket and debug tracing, billed at one credit per response like every other Dwellir network. Create a Dwellir account to get access when it goes live, or contact the Dwellir team about dedicated Elysium infrastructure.

If you are building on the Hyperliquid side as well, Hyperliquid RPC Providers and The Hyperliquid Infrastructure Stack cover HyperEVM and HyperCore access.