What is Elysium? Hyperliquid-native L2 by Kinetiq

Pull the latest block from the Elysium testnet RPC and two details stand out. Blocks arrive three to four times a second, and the l1BlockNumber field in the header points to a HyperEVM block, not an Ethereum one. Elysium is an Arbitrum Orbit chain built by Kinetiq that executes on its own fast chain, settles to HyperEVM on Hyperliquid, and uses HYPE as the gas token, with high-frequency trading and market making as the stated target workload.

The testnet has been live since September 22, 2026 (chain ID 99801). Mainnet is still pre-launch as of October 2, 2026, and the Kinetiq docs give no date. This piece covers what the architecture does, why its data availability model changes how you read the chain, how Elysium differs from HyperEVM and from other fast chains, and how to get production RPC access.

⏭ Skip ahead: If you’re mainly here for the RPC and infrastructure angle, jump to Getting RPC access to Elysium.

📝 Naming note: This is not the older Elysium network from Vulcan Forged, which chainid.network lists under chain IDs 1338 (testnet) and 1339 (mainnet) with PYR as its currency. Elysium by Kinetiq uses chain ID 99801 on testnet and HYPE for gas.

What is Elysium?

Kinetiq describes Elysium as “a high-throughput Arbitrum Orbit chain that settles to HyperEVM, runs co-located with HyperCore, and uses HYPE as native gas.” Kinetiq, the team behind the kHYPE liquid staking token and Markets.xyz on Hyperliquid, built it as a general-purpose DeFi chain aligned with the Hyperliquid ecosystem, and the stack is operated with Conduit.

Under the hood it is a standard Arbitrum Nitro chain. Calling ArbSys.arbOSVersion() on the testnet returns 106, which is ArbOS 51 (Nitro reports the ArbOS version plus 55). Kinetiq says the chain launches on stock ArbOS, so Solidity and Vyper contracts compile unchanged, and Foundry, Hardhat, viem, and ethers behave as they do on any Orbit chain. That compatibility is deliberate. The interesting parts of Elysium sit outside the EVM: where it settles, where its data lives, and what it can see of HyperCore.

Why a Hyperliquid-native L2?

HyperEVM is constrained on purpose. According to the Hyperliquid docs, fast blocks last one second with a 3M gas limit, and slow blocks last one minute with a 30M gas limit. That keeps EVM activity composable with HyperCore, but leaves little room for sustained high-frequency flow on the EVM itself, a gap Kinetiq names as the reason Elysium exists.

Elysium targets 300 Mgas/s at 100–200 ms blocks, which Kinetiq puts at roughly two orders of magnitude more gas per second than HyperEVM, without leaving the Hyperliquid ecosystem. The docs name the intended tenants: high-frequency trading and professional market-making AMMs, with a fee environment tuned so a market maker can refresh quotes 5–10 times per second.

Treat those figures as design targets. The chain specifications describe the throughput number as a target “validated in load testing before mainnet,” and a sample of recent testnet blocks shows two or three transactions each. Cadence is easier to check: two samples taken on October 2, 2026 (thirteen consecutive blocks, then a 20-second window) averaged 0.25 and 0.32 seconds per block. That is slower than the 100–200 ms design range, and still three to four times faster than HyperEVM’s one-second fast blocks.

Execute on Elysium, settle on HyperEVM

Most Orbit chains settle to Ethereum or to another Arbitrum chain. Elysium’s parent is HyperEVM: chain ID 999 for mainnet and 998 for testnet. The block headers show it. Every Elysium block carries an l1BlockNumber, and on testnet that number tracks the HyperEVM testnet head. This script checks the chain ID, the ArbOS version, and the parent-chain link in one go:

const rpc = async (url, method, params = []) =>
  (await (await fetch(url, { method: "POST", headers: { "content-type": "application/json" },
    body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params }) })).json()).result;

const ELYSIUM = "https://testnet-rpc.elysium.kinetiq.xyz"; // or your Chainstack endpoint
const HYPEREVM = "https://rpc.hyperliquid-testnet.xyz/evm";

const [chainId, block, parentHead, arbosRaw] = await Promise.all([
  rpc(ELYSIUM, "eth_chainId"),
  rpc(ELYSIUM, "eth_getBlockByNumber", ["latest", false]),
  rpc(HYPEREVM, "eth_blockNumber"),
  // ArbSys.arbOSVersion(): returns the ArbOS version plus 55
  rpc(ELYSIUM, "eth_call", [{ to: "0x0000000000000000000000000000000000000064", data: "0x051038f2" }, "latest"]),
]);

console.log("chain ID      ", parseInt(chainId, 16));              // 99801
console.log("ArbOS version ", parseInt(arbosRaw, 16) - 55);        // 51
console.log("l1BlockNumber ", parseInt(block.l1BlockNumber, 16));  // a HyperEVM block number
console.log("HyperEVM head ", parseInt(parentHead, 16));           // a few blocks ahead

Run on October 2, 2026, it printed chain ID 99801, ArbOS 51, and an l1BlockNumber a short distance behind the HyperEVM head (4 to 15 blocks across two runs).

Sequencing is simple at launch. The security page lists a single sequencer with “neutral priority-fee ordering,” and the Building on Elysium page spells out what that means: “Transactions are ordered by priority fee within each block, with no privileged lanes.” A quote update and a swap compete on the same fee basis, and the protocol favors neither.

The trust model is the standard Nitro posture with a staged path forward. Validation is permissioned at launch and moves to permissionless fraud proofs through Arbitrum BoLD as the chain matures, and withdrawals are optimistic, finalizing after a challenge period. Two guarantees hold regardless of the sequencer: transactions can be forced through the delayed inbox on HyperEVM if the sequencer censors them, and withdrawals stay protected by the challenge period. The hardening roadmap adds MEV telemetry, native Timeboost, block-time tuning toward the ≈100 ms Nitro block floor, permissionless proving, and audits.

Data availability: a certificate instead of the data

Elysium uses AnyTrust data availability, the Arbitrum design that moves transaction data off the parent chain and onto a committee in exchange for lower fees. The security page puts it this way: “A k-of-n committee stores the full transaction data and attests to it with a compact certificate posted to HyperEVM. A single honest committee member is enough to keep the data available.” If the committee ever disappears, “the chain automatically posts full data to HyperEVM instead. That raises costs but never halts the chain.”

What does that look like on chain? A scan of the testnet’s batch history on HyperEVM (the first 489 batches, as of September 26, 2026) found that every batch payload was a 178-byte AnyTrust certificate and none carried transaction data. The committee keyset registered on the parent chain listed a single member counted as honest, a 1-of-1 setup. That is a testnet configuration: the docs describe a k-of-n committee without naming its size or the mainnet membership.

The practical consequence is that you cannot rebuild Elysium’s history from HyperEVM alone. The parent chain holds receipts, and the data those receipts attest to lives with the committee, so reading old state, logs, and traces depends on an RPC provider that has synced the chain. The upside is cost: Kinetiq notes that data availability is “committee-based rather than priced per byte on-chain, so the parent-chain cost per transaction is minimal.”

HYPE as gas, bridging, and HyperCore

HYPE is the native gas token (“native (msg.value), bridged 1:1 from HyperEVM”) and withdraws 1:1, with no wrapper asset. Fees are “paid in HYPE and are low by construction.” On the testnet, eth_gasPrice returned 0x989680 on October 2, which is 0.01 gwei, and eth_maxPriorityFeePerGas returned 0x0.

Assets move in three legs, per the bridging architecture page. HyperEVM ERC-20s reach Elysium through the canonical bridge, built on upstream Arbitrum Orbit gateways. Elysium-native tokens reach HyperEVM, and from there HyperCore, through a mirror bridge. The HyperEVM-to-HyperCore link uses deposit wallets.

The feature that sets Elysium apart arrives about four weeks after mainnet, in an ArbOS upgrade: a HyperCore market-data precompile and the ElysiumCoreWriter predeploy. The precompile lets contracts read orderbooks, prices, balances, and positions directly, with HyperCore data available at block granularity (≈70 ms) and ≈150–350 ms freshness inside the EVM. The chain does this by running its own Hyperliquid node, co-located with it. The write side is a keeper lane: a contract emits order intents, a keeper signs them as a trade-only agent on the user’s own HyperCore account, and orders reach HyperCore in ≈100–200 ms from intent to resting order. HyperCore itself enforces that such agents can place and cancel orders but never withdraw or transfer funds.

The docs state the trust model plainly: “The data is attested by the sequencer, not proven by HyperCore.” HyperCore does not publish state roots or proofs today, so reads anchor to Elysium’s archived copy of HyperCore inputs, with fraud-provable attestation as the long-term plan. Treat HyperCore reads as sequencer-attested data, not as a proof.

What’s different from HyperEVM

Method names match Ethereum and HyperEVM, but several behaviors differ in ways that change how you build:

Property	HyperEVM	Elysium
Block cadence	1 s fast blocks, 1 min slow blocks	100–200 ms design target; about 0.25–0.32 s observed on testnet (Oct 2, 2026)
Gas capacity	3M gas per fast block, 30M per slow block	300 Mgas/s execution target
Gas token	HYPE	HYPE, bridged 1:1 from HyperEVM
Chain ID	999 (mainnet), 998 (testnet)	99801 (testnet); mainnet not yet published

• No observable mempool. Elysium has a single sequencer and no public mempool. On the public testnet RPC, eth_newPendingTransactionFilter returns a filter ID, but polling it for 16 seconds while blocks were carrying transactions returned zero hashes. The Chainstack docs describe the same behavior for eth_subscribe("newPendingTransactions"), which subscribes and then delivers nothing. Build confirmation logic around block inclusion.
• Tracing is debug_* only. The Parity-style arbtrace_* and trace_* namespaces are not exposed. Chainstack Global Nodes serve debug_traceTransaction, debug_traceBlockByNumber, debug_traceBlockByHash, and debug_traceCall back to genesis, while flatCallTracer, muxTracer, and erc7562Tracer return the disabled-tracer error. The public Kinetiq endpoint answers debug_* calls with a 401 and “authenticated API key required for method.”
• The arb namespace is empty today. arb_getRawBlockMetadata returns -32601 on the public RPC and null on Chainstack Global Nodes, so don’t build on it yet.
• Proofs only near the tip. eth_getProof works only near the tip on Chainstack Global Nodes: proofs come back for blocks fewer than 127 behind it, per the Elysium methods docs. At three to four blocks per second, that window is roughly 30 to 40 seconds of chain time.
• Subscriptions add up fast. On Global Nodes, requests 127 or more blocks behind the tip bill as archive (2 RUs), and every WebSocket push notification counts as a request. At three to four blocks per second, an eth_subscribe("newHeads") stream delivers roughly 270,000 to 345,000 notifications a day, so sustained subscriptions fit the flat-fee Unlimited Node add-on or a Dedicated Node better. The request units docs have the rules.

Elysium vs. other fast chains

Kinetiq publishes its own reference points in the chain specifications. The figures below are Kinetiq’s, not an independent benchmark:

Chain	Block or slot time	Notes
Elysium	100–200 ms real canonical blocks	≈300 ms perceived receipt
Robinhood Chain	≈100–141 ms	Same Nitro execution engine, with Ethereum blobs for data availability
Base	200 ms preconfirmations	≈300–500 ms perceived end to end
Solana	≈400 ms slots	—
HyperEVM	1 s small blocks	3M gas per small block

The architecture comparison that matters is Robinhood Chain: the same Nitro engine, but Ethereum blobs for data availability. Elysium swaps that for a committee and HyperEVM settlement, trading a trust assumption for cheaper parent-chain costs and a native path to HyperCore. Preconfirmations, slots, and canonical blocks measure different things, so the rows are not strictly comparable.

📖 Related read: for the Ethereum-blob counterpart on the same Nitro stack, see What is Robinhood Chain? A full builder’s guide (2026).

Who’s behind Elysium

Kinetiq builds Elysium. Its homepage describes the company as “powering liquid staking and Markets.xyz on Hyperliquid,” with kHYPE as its liquid staking token, and the docs route integration questions and early-access requests to the Kinetiq team. The chain stack is listed as “Arbitrum Orbit (Nitro/ArbOS), operated with Conduit.” Economics are only sketched: a builders allocation of sequencer revenue is reserved for ecosystem incentive programs for applications on the chain.

The docs describe Elysium as pre-launch: “Specifications, parameters, and timelines may be refined before mainnet.” Kinetiq doesn’t publish a mainnet date. A third-party events calendar lists a target of October 20, 2026, which the docs do not confirm.

Getting RPC access to Elysium

The public testnet endpoint from Kinetiq (https://testnet-rpc.elysium.kinetiq.xyz) is shared and free, and it gates debug_* methods behind an API key. That is fine for poking around, and not something to build a trading system on.

Chainstack serves Elysium RPC on testnet today as a Global Node, listed in the docs in Archive mode with debug and trace available, and as a Dedicated Node in Full or Archive mode (the console shows Dedicated Nodes as requiring a Pro plan). The flat-fee Unlimited Node add-on, available from the Growth plan upward, works with any Chainstack RPC node. Elysium Mainnet is not deployable yet because Kinetiq hasn’t published a mainnet chain ID.

How to get an Elysium RPC endpoint on Chainstack

1. Log in to the Chainstack console (or create an account).
2. Create a new project.
3. Select Elysium as your blockchain protocol.
4. Choose Testnet, the only network available until Kinetiq publishes mainnet details.
5. Pick Global Node for shared, geo-balanced access or Dedicated Node for isolated resources, then deploy.
6. Open Access and credentials and copy your HTTPS and WebSocket endpoints.

Because Elysium runs Nitro, standard EVM tooling connects unchanged. Here’s a viem chain definition for the testnet, with the 18-decimal HYPE currency and the testnet chain ID:

import { createPublicClient, http, defineChain, formatEther } from "viem";

export const elysiumTestnet = defineChain({
  id: 99801, // testnet; Kinetiq has not published a mainnet chain ID
  name: "Elysium Testnet",
  testnet: true,
  nativeCurrency: { name: "HYPE", symbol: "HYPE", decimals: 18 },
  rpcUrls: { default: { http: ["YOUR_CHAINSTACK_ENDPOINT"] } },
  blockExplorers: {
    default: { name: "Elysium Explorer", url: "https://elysium.kinetiq.xyz/testnet-explorer" },
  },
});

const client = createPublicClient({ chain: elysiumTestnet, transport: http() });
console.log("Block:", await client.getBlockNumber());
console.log("Balance:", formatEther(await client.getBalance({ address: "0xYourAddress" })), "HYPE");

📖 Related reads: for the launch details, see Chainstack introduces Elysium Testnet support; for a fact sheet on the chain, see the Elysium protocol page.

For method-level detail, including exact error behavior and the full debug_* list, the reference docs are the source of truth: Elysium methods and Debug and trace APIs.

Conclusion

The pitch behind Elysium is narrow on purpose. It takes HyperEVM’s one-second, 3M-gas fast blocks as the problem and answers with a Nitro chain that targets 100–200 ms blocks, settles back to HyperEVM, and will eventually read HyperCore from inside the execution layer. The design choices that matter most to integrators are the ones that look least like Ethereum: a certificate on the parent chain instead of the data, a sequencer that orders by fee with no privileged lanes, and HyperCore reads that are attested by the sequencer rather than proven.

The caution is just as plain. Everything above is testnet: no mainnet date, throughput that is a target rather than a measurement, a committee whose mainnet shape is unpublished, and HyperCore features that ship weeks after launch. If you build on it now, build against block inclusion rather than the mempool, keep an archive-capable endpoint for history, and re-read the docs at mainnet.

If you are building against the testnet today, start with an endpoint that serves archive-depth state and debug traces, because the public RPC gates debug methods behind an API key.

FAQs

What is Elysium’s chain ID?

On testnet, 99801 (0x185d9). Kinetiq hasn’t published a mainnet chain ID yet. Don’t confuse it with the older Elysium network from Vulcan Forged, which uses 1338 and 1339.

Is Elysium live on mainnet yet?

Not as of October 2, 2026. Testnet has been live since September 22, 2026, and the docs mark mainnet as pre-launch with no date.

Why can’t I see pending transactions on Elysium?

Elysium has a single sequencer and no public mempool. eth_newPendingTransactionFilter returns a filter ID and the newPendingTransactions subscription succeeds, but neither delivers transactions. Build confirmation logic around block inclusion instead.

Does Elysium post transaction data to HyperEVM?

No, not in the normal case. Elysium uses AnyTrust data availability: a committee stores the full data and a compact certificate is posted to HyperEVM. If the committee is unavailable, the chain automatically falls back to posting full data to HyperEVM.

What token pays for gas on Elysium?

HYPE, bridged 1:1 from HyperEVM. On the testnet the gas price was 0.01 gwei when this article was written.

Do I need an archive node for Elysium?

On Chainstack, requests for blocks 127 or more behind the tip bill as archive (2 RUs), as do all debug and trace calls. With blocks arriving three to four times a second, that threshold is only 30 to 40 seconds of chain time, so most indexers and analytics jobs end up in archive territory.

Additional resources

• What is Elysium, Chain specifications, Security and data availability, HyperCore market data, and Token bridging architecture in the Kinetiq docs
• Elysium RPC nodes on Chainstack and the Elysium protocol page
• Chainstack introduces Elysium Testnet support
• Chainstack docs: Elysium methods, Clients, Debug and trace APIs, and Request units
• HyperEVM dual-block architecture in the Hyperliquid docs
• Why choose AnyTrust for data availability in the Arbitrum docs