13 min read

Overview

HyperEVM lets Solidity developers build right next to Hyperliquid's order books. Its blocks are small by design, though, and that limits what you can build there. A vault or a lending market fits well. An onchain order book, a market maker that requotes several times per second, or a liquidation engine that must act inside one price move does not.

Elysium is Kinetiq's chain for those apps. It is an Arbitrum Orbit Layer 2 (L2) that uses HYPE for gas, produces blocks in about a tenth of a second, and settles to HyperEVM. You deploy with the same EVM tools you already use. The difference is where your contracts run and when a transaction becomes final.

In this guide, you learn how Elysium fits next to HyperEVM and HyperCore, how it works at launch, and what Kinetiq plans after mainnet. Then you send a transaction on Elysium Testnet and follow it from the first receipt to its batch on HyperEVM.

TL;DR

• Elysium is an Arbitrum Orbit L2 built by Kinetiq. It uses HYPE for gas and settles to HyperEVM, not to Ethereum
• Elysium Testnet (chain ID 99801) produces a block every 100 to 150 ms, much faster than the one-second small blocks on HyperEVM
• A receipt arrives in about one second, but a transaction is final only when its batch posts to HyperEVM
• Quicknode provides Elysium Testnet endpoints (HTTPS and WebSocket) and a faucet for testnet HYPE

What You Will Learn

• Why HyperEVM block limits led to Elysium, and which apps gain the most from it
• How HyperCore, HyperEVM, and Elysium split the work between them
• What the sequencer, AnyTrust data availability, and settlement mean for trust and finality at launch
• How to track one Elysium transaction through receipt, batch, and finality with viem
• How Elysium compares with HyperEVM and HyperCore

What You Will Need

• Basic knowledge of the EVM, JSON-RPC, and transactions. Some familiarity with HyperEVM helps
• A Quicknode account with an Elysium Testnet endpoint and a Hyperliquid Testnet endpoint, or one multichain endpoint for both
• Node.js 24 or later, which runs TypeScript files directly
• A testnet wallet with a little Elysium Testnet HYPE from the Quicknode faucet

What is Elysium?

Elysium is an EVM L2 that runs the Arbitrum Nitro stack and settles to HyperEVM. Kinetiq, the liquid staking platform behind kHYPE, builds it and runs its sequencer. It is an L2 from HyperEVM's point of view: HyperEVM is the layer that stores its batches.

Three properties matter most when you build on it:

1. It's fully EVM-compatible. Solidity contracts deploy unchanged. viem, ethers.js, Hardhat, and Foundry work once you give them the chain ID and an endpoint.
2. You pay gas in HYPE. HYPE bridges 1:1 from HyperEVM, with no wrapper token, and testnet fees are low.
3. It settles to HyperEVM. Elysium posts its batches to contracts on HyperEVM, and a transaction is final once its batch lands on the HyperEVM side.

Why Hyperliquid Needs an L2

Hyperliquid has two execution environments. HyperCore runs the native perp and spot order books. HyperEVM runs Solidity contracts on the same chain, so DeFi apps can build next to those order books.

HyperEVM's small blocks come about once per second and hold 3 million gas. Large blocks, for heavy deployments, hold 30 million gas and come about once per minute. That is enough for most DeFi. It is a ceiling for apps that live on speed:

• Order books and perp DEXs update many times per second, and one block per second caps how often a quote can change
• Market makers and keepers compete on reaction time, and a one-second slot is long in a fast market
• Gas-heavy logic, such as matching engines and batch auctions, does not fit well in a small block
• Proprietary AMMs (prop AMMs) update their prices on every move. When gas is scarce and fees rise with activity, those updates cost too much to run profitably

The last point matters most for spot trading. Hyperliquid leads in perps, but a token that wants spot liquidity needs market makers who can quote it cheaply onchain. Elysium takes this load off HyperEVM. Kinetiq targets 300 million gas per second, so contracts that need speed run on Elysium while HyperEVM keeps the record of what happened.

Block space is one limit. Access to HyperCore is the other:

• Reads are shallow. The order book precompile on HyperEVM returns only the best bid and the best ask. The data updates once per HyperEVM block, about once per second, while HyperCore produces a block about every 70 ms.
• Writes are one-way. A contract sends orders to HyperCore through CoreWriter, but it does not get the fill or the rejection back.

Apps that react to every trade, such as prop AMMs and launchpads, need both. Elysium fixes block space at launch. Kinetiq plans to fix HyperCore access after mainnet, as covered in What Changes After Mainnet.

Three Layers, Three Jobs

Elysium does not replace HyperEVM or HyperCore. Each layer does one job:

• HyperCore is the trading engine. It holds the perp and spot order books, margin, and positions. It is not an EVM.
• HyperEVM is the EVM on the Hyperliquid L1. It shares consensus with HyperCore and can read and write HyperCore state. For Elysium, it is the settlement layer: it stores Elysium's batches and holds its inbox and bridge contracts.
• Elysium is the execution layer, where contracts that need fast blocks and a lot of gas run.

To pick where to deploy, ask what your contract needs most. If it needs direct access to HyperCore today, deploy on HyperEVM. If it needs speed and gas, deploy on Elysium.

Network Parameters

Kinetiq plans to launch mainnet on November 9, 2026. Until then, this table lists testnet values only:

Parameter	Elysium Testnet
Chain ID	99801
Native currency	HYPE (18 decimals)
Public RPC	https://testnet-rpc.elysium.kinetiq.xyz
Block explorer	elysium.kinetiq.xyz/testnet-explorer
Settles to	HyperEVM Testnet (chain ID 998)
Stack	Arbitrum Orbit (Nitro)

note

Public chain lists also show an unrelated chain named "Elysium" with chain IDs 1338 and 1339. That chain is not Kinetiq's Elysium. Always check for chain ID 99801 when you add Elysium Testnet to a wallet or a tool.

How Elysium Works

Elysium follows the standard Orbit pipeline: a sequencer orders transactions, batches go to a parent chain, and finality follows the batch. The difference is that HyperEVM takes the place Ethereum has for most Orbit chains. If sequencers and batches are new to you, read Essential Rollup Fundamentals first.

The Sequencer and Ordering

Elysium has one sequencer. Transactions go straight to it, and it orders them by priority fee within each block, with no privileged lanes. Kinetiq covers fees and ordering on its blocks, fees, and ordering page.

A receipt is a soft confirmation. You get one within about a second. It means the sequencer has committed to an order, but HyperEVM has not seen your transaction yet.

The sequencer cannot block you forever. If it ignores your transaction, the delayed inbox on HyperEVM lets you force its inclusion, as on other Orbit chains.

Batches and Data Availability

Batches go to HyperEVM. The sequencer groups thousands of Elysium blocks into one batch and posts it to the sequencer inbox contract on HyperEVM.

AnyTrust keeps data costs low. Elysium uses Arbitrum AnyTrust for data availability. A committee of data availability servers stores the full batch data and signs a certificate, and only that small certificate goes to HyperEVM. If the committee fails to sign, the chain falls back to posting full data on HyperEVM. On testnet, the committee has one member, and its signature alone is enough (1-of-1). Kinetiq plans a larger committee. Its security and data availability page covers the rest of the trust model.

Finality

Finality comes with the batch. The safe and finalized block tags point to the same block, and both move forward when a batch posts to HyperEVM. In our testnet runs, batches posted about every 15 minutes. A transaction that lands just before a post is final in under a minute, and one that lands just after a post waits about 15 minutes.

Validation is permissioned at launch. Kinetiq plans permissionless validation with BoLD, the larger committee, and audits after mainnet. Until then, treat a receipt as a promise, and wait for finalized before any action you cannot undo.

Withdrawals wait for a challenge period. Deposits from HyperEVM arrive through the Orbit inbox. Withdrawals to HyperEVM take the reverse path and complete only after the rollup's challenge period, as on other optimistic rollups. The period is set in confirmPeriodBlocks on the rollup contract, so read it there, because the mainnet value can differ from testnet.

What Changes After Mainnet

Kinetiq plans an ArbOS upgrade after mainnet that connects Elysium contracts to HyperCore. Elysium will run its own Hyperliquid node next to the sequencer to serve these reads and writes. None of this is live on testnet, and the details can change before release. See What is Elysium for the roadmap.

• HyperCore market data in contracts. A planned read precompile gives Elysium contracts the full depth of HyperCore order books, not only the best bid and ask, plus prices and positions. Each response carries the HyperCore block it came from. A contract can then price assets from Hyperliquid's own books without an external oracle. The sequencer attests to this data, so it is not a proof. See HyperCore market data.
• Orders on HyperCore from Elysium. A planned ElysiumCoreWriter lane lets a keeper place orders on the user's own HyperCore account through a trade-only agent, with a target delay of about 100 to 200 ms. Unlike CoreWriter on HyperEVM, the order result comes back onchain, so the contract knows when its order fills. See Trading on HyperCore from Elysium.
• A path for tokens. A token can start on an Elysium AMM, move to a proprietary AMM, then list on HyperCore spot (HIP-1) and later as a perp (HIP-3). Once a perp exists, market makers on Elysium can hedge their spot exposure on HyperCore. Three bridge routes support this: HyperEVM to Elysium, Elysium-native tokens to HyperEVM, and a link to HyperCore. Mainnet bridge addresses come at launch. See Token bridging architecture.

Follow a Transaction to HyperEVM

You now know how a transaction moves through Elysium on paper. Now it's time to watch it happen on testnet.

Every Elysium developer meets the same question early: "My transaction has a receipt. Is it final?" In this section, you send one transaction and watch it go through three stages:

You build one file, follow-tx.ts, in four parts: 1) the setup, 2) the receipt, 3) the batch on HyperEVM, and 4) the finality check with the batch transaction on HyperEVM.

Connect to Elysium with Quicknode

Elysium speaks standard Ethereum JSON-RPC, so all you need is a chain ID and an endpoint. To create one, sign in to the Quicknode dashboard, create an endpoint, and select Elysium and Testnet. You get an HTTPS URL and a WebSocket URL.

The script also reads HyperEVM, where Elysium settles. Create a second endpoint and select Hyperliquid and Testnet. HyperEVM JSON-RPC uses the /evm path of the endpoint URL. See the Hyperliquid docs for the other paths.

Use one endpoint for both chains

A multichain endpoint reaches several networks with the same endpoint name and token. Turn on Multichain for your Elysium Testnet endpoint, then select Hyperliquid Testnet to get its URL. This is useful when your plan allows only one endpoint.

For the full method list, including the Arbitrum methods used below, see the Elysium RPC docs and the Elysium chain page.

To get testnet HYPE, use the Quicknode faucet. You can claim once every 12 hours per network, and the wallet must hold some HYPE on Hyperliquid mainnet, on HyperEVM or HyperCore. One claim is enough for this guide, because the script sends a zero-value transaction and only pays gas.

Set Up the Project

Create the project and install viem:

mkdir elysium-follow-tx && cd elysium-follow-tx
npm init -y
npm pkg set type=module
npm i viem

Create a .env file with your two endpoints and the private key of your throwaway testnet wallet. Add .env to your .gitignore file if you use git:

.env

ELYSIUM_RPC_URL=https://your-endpoint-name.elysium-testnet.quiknode.pro/your-token/
HYPEREVM_TESTNET_RPC_URL=https://your-endpoint-name.hype-testnet.quiknode.pro/your-token/evm
PRIVATE_KEY=YOUR_TESTNET_PRIVATE_KEY

Define the Chain and Clients

At the time of writing, viem has a built-in chain for HyperEVM Testnet (hyperliquidEvmTestnet) but not for Elysium, so the script defines Elysium with defineChain. It then creates a public client for each chain and a wallet client for Elysium.

The SEQUENCER_INBOX address is the Elysium Testnet inbox contract on HyperEVM Testnet, from Kinetiq's contract addresses page. Create follow-tx.ts and add:

follow-tx.ts

import { createPublicClient, createWalletClient, defineChain, http, parseAbiItem, type Hex } from 'viem';
import { privateKeyToAccount } from 'viem/accounts';
import { hyperliquidEvmTestnet } from 'viem/chains';

const elysiumTestnet = defineChain({
  id: 99801,
  name: 'Elysium Testnet',
  nativeCurrency: { name: 'HYPE', symbol: 'HYPE', decimals: 18 },
  rpcUrls: { default: { http: [process.env.ELYSIUM_RPC_URL!] } },
});

const account = privateKeyToAccount(process.env.PRIVATE_KEY as Hex);
const elysium = createPublicClient({ chain: elysiumTestnet, transport: http() });
const hyperEvm = createPublicClient({ chain: hyperliquidEvmTestnet, transport: http(process.env.HYPEREVM_TESTNET_RPC_URL) });
const wallet = createWalletClient({ account, chain: elysiumTestnet, transport: http() });

const SEQUENCER_INBOX = '0xb5B1a0AebfFeF819Ec3F8c39a17b5C4E70A001E3'; // Elysium testnet, on HyperEVM testnet
const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
const start = Date.now();
const elapsed = () => `${((Date.now() - start) / 1000).toFixed(1)}s`;

Stage 1: Get the Receipt from the Sequencer

The script sends a zero-value transaction to your own address and waits for the receipt. Testnet blocks come every 100 to 150 ms, so the script polls every 100 ms. Add:

follow-tx.ts

// Stage 1: soft confirmation from the sequencer
const hash = await wallet.sendTransaction({ to: account.address, value: 0n });
const receipt = await elysium.waitForTransactionReceipt({ hash, pollingInterval: 100 });
const blockNumber = Number(receipt.blockNumber);
console.log(`[${elapsed()}] receipt: block ${blockNumber}, status ${receipt.status}`);

The transaction now has a block and a status, but only the sequencer knows about it. HyperEVM does not.

Stage 2: Find the Batch on HyperEVM

Two Arbitrum methods tell you when the block reaches HyperEVM:

• arb_findBatchContainingBlock returns the batch number that holds the block. Before the batch posts, it returns the error block not yet found on any batch.
• arb_getL1Confirmations returns how many HyperEVM blocks have passed since the batch posted. Before the post, it returns 0.

Both methods take the block number as a plain decimal number, not a hex string. That is why stage 1 converts the receipt's bigint with Number(). The script retries every 10 seconds until it finds the batch. Add:

follow-tx.ts

// Stage 2: the block lands in a batch on HyperEVM
let batch: number | undefined;
while (batch === undefined) {
  try {
    batch = await elysium.request<{ Method: 'arb_findBatchContainingBlock'; Parameters: [number]; ReturnType: number }>({
      method: 'arb_findBatchContainingBlock',
      params: [blockNumber],
    });
  } catch {
    await sleep(10_000); // "block not yet found on any batch"
  }
}
const confirmations = await elysium.request<{ Method: 'arb_getL1Confirmations'; Parameters: [number]; ReturnType: number }>({
  method: 'arb_getL1Confirmations',
  params: [blockNumber],
});
console.log(`[${elapsed()}] batch ${batch}, ${confirmations} HyperEVM confirmations`);

Stage 3: Check Finality and Find the Batch Transaction

The last part reads the finalized block on Elysium and compares it with your block. Then it finds the transaction on HyperEVM that posted the batch. The sequencer inbox emits a SequencerBatchDelivered event with the batch number as an indexed topic, so getLogs can filter on it. Because the batch has just posted, the script only searches the last 1,000 HyperEVM blocks, about 16 minutes. Add:

follow-tx.ts

// Stage 3: finalized on Elysium
const finalized = await elysium.getBlock({ blockTag: 'finalized' });
console.log(`[${elapsed()}] finalized head ${finalized.number}, our block final: ${finalized.number >= receipt.blockNumber}`);

// Find the batch-posting transaction on HyperEVM
const batchDelivered = parseAbiItem(
  'event SequencerBatchDelivered(uint256 indexed batchSequenceNumber, bytes32 indexed beforeAcc, bytes32 indexed afterAcc, bytes32 delayedAcc, uint256 afterDelayedMessagesRead, (uint64 minTimestamp, uint64 maxTimestamp, uint64 minBlockNumber, uint64 maxBlockNumber) timeBounds, uint8 dataLocation)',
);
const head = await hyperEvm.getBlockNumber();
const [log] = await hyperEvm.getLogs({
  address: SEQUENCER_INBOX,
  event: batchDelivered,
  args: { batchSequenceNumber: BigInt(batch) },
  fromBlock: head - 999n,
  toBlock: head,
});
console.log(`[${elapsed()}] batch posted on HyperEVM in tx ${log?.transactionHash} (block ${log?.blockNumber})`);

The script prints the finality check instead of assuming it. In practice, finalized has already passed your block by the time the batch number is available.

Run the Script

Run the file with Node.js. Node 24 runs TypeScript directly and loads the .env file with --env-file:

node --env-file=.env follow-tx.ts

The output looks like this. This run took 2 minutes and 32 seconds:

[1.3s] receipt: block 12983907, status success
[148.5s] batch 3079, 9 HyperEVM confirmations
[148.7s] finalized head 12984856, our block final: true
[151.8s] batch posted on HyperEVM in tx 0x02ccacfbd908f826c47f7cf74393464481750fa6152b212b5b49bd6d5639e21d (block 67519174)

Your timing will differ. The receipt always comes in about a second, but the wait for stage 2 depends on where your transaction falls in the batch window. It can be under a minute or close to 15 minutes.

The batch transaction on HyperEVM is small, because it carries the AnyTrust certificate, not your transaction data.

tip

Use this pattern in your own app. Show the receipt in your interface right away, and wait for the finalized tag before you credit a deposit, release funds, or settle against an offchain ledger.

Elysium vs HyperEVM vs HyperCore

Elysium values in this table are testnet values:

Area	Elysium	HyperEVM	HyperCore
What it is	Orbit L2 for fast EVM execution	EVM on the Hyperliquid L1	Native trading engine on the Hyperliquid L1
Runs Solidity	Yes	Yes	No
Block time	100 to 150 ms	About 1 s (small blocks)	About 70 ms
Gas per block	No practical cap	3M (small), 30M (large)	No EVM gas
Gas token	HYPE	HYPE	No EVM gas
Settles to	HyperEVM	Hyperliquid L1 consensus	Hyperliquid L1 consensus
Data availability	AnyTrust certificate on HyperEVM	Onchain	Onchain
Ordering	Priority fee, one sequencer	Hyperliquid L1 consensus	Hyperliquid L1 consensus
Finality	When the batch posts (about every 15 min on testnet)	Hyperliquid L1 block finality	Hyperliquid L1 block finality
HyperCore access	Planned after mainnet	Best bid and ask reads, one-way writes	Native

If you move contracts from HyperEVM to Elysium, plan for two changes. A higher priority fee moves your transaction ahead in the block. And because finality follows the batch, waiting a fixed number of blocks tells you nothing, so check the finalized tag instead.

Conclusion

Elysium gives high-frequency DeFi on Hyperliquid what HyperEVM small blocks cannot: blocks in about a tenth of a second and room for gas-heavy logic, with HYPE for gas and HyperEVM as the settlement layer. The trade-off is finality. A receipt comes in about a second, but your transaction is final only when its batch reaches HyperEVM, and you have now watched that happen on testnet. Use that model to decide which parts of your app belong on Elysium, which stay on HyperEVM, and when your code can treat a transaction as final.

Next Steps

• Explore the Elysium RPC docs for the full list of supported methods, including eth_subscribe for live blocks and logs
• Read Kinetiq's Building on Elysium page before you deploy contracts
• Compare with another Orbit chain in What is Robinhood Chain?
• Learn more about HyperEVM and HyperCore in the Hyperliquid docs

Frequently Asked Questions

What is Elysium on Hyperliquid?

Elysium is an EVM-compatible Layer 2 built by Kinetiq on Arbitrum Orbit. It uses HYPE as its gas token and settles to HyperEVM. It gives high-frequency DeFi apps faster blocks and more gas than HyperEVM small blocks, which come about once per second with a 3 million gas limit.

What is the Elysium chain ID and RPC endpoint?

Elysium Testnet uses chain ID 99801, and its public RPC is https://testnet-rpc.elysium.kinetiq.xyz. Kinetiq plans to launch mainnet on November 9, 2026. For WebSocket subscriptions and higher rate limits, create an Elysium Testnet endpoint on Quicknode.

Is Elysium the same as the chain with chain ID 1338 or 1339?

No. Chain IDs 1338 and 1339 belong to an unrelated chain that also uses the name Elysium. Kinetiq's Elysium Testnet uses chain ID 99801. Check the chain ID before you add the network to a wallet or a tool.

How long does an Elysium transaction take to become final?

The sequencer returns a receipt in about one second. The transaction becomes final when its batch posts to HyperEVM. On testnet, batches post about every 15 minutes, so finality takes from under a minute to about 15 minutes. Use the finalized block tag before any action you cannot undo.

How is Elysium different from HyperEVM?

HyperEVM is the EVM on the Hyperliquid L1 and shares consensus with HyperCore. Elysium is a separate Orbit L2 that settles to HyperEVM. Elysium has faster blocks and no practical gas cap, but its finality follows the batch cadence, and its direct access to HyperCore is planned for after mainnet.