Site icon Chainstack

Elysium vs HyperEVM: fees, speed, finality and RPC

Elysium Vs Hyperevm 1 logo

HyperEVM offers native Layer 1 smart contract execution directly alongside HyperCore‘s order books, while Elysium operates as Kinetiq‘s Arbitrum Orbit Layer 2 built for high-frequency throughput. But choosing between them involves more than block cadence and gas capacity.

How do their RPC surfaces differ when routing between standard EVM calls, system-transaction archives and Nitro debug tracers? How does each network handle transaction ordering, HyperCore state access and withdrawal finality? And what do these trade-offs mean for the way you deploy, index and monitor a live application?

This guide compares Elysium and HyperEVM, covering architecture, fees, speed, RPC infrastructure and ecosystem tooling. This will help you choose the right execution layer for your app.

What do you need to know about Hyperliquid first?

Hyperliquid operates as a Layer 1 blockchain secured by HyperBFT, a deterministic, one-block finality consensus algorithm inspired by HotStuff. Under HyperBFT, two execution environments share the same validator set and block production sequence:

  1. HyperCore: A Rust-based, gas-free state machine managing perpetual futures, spot Central Limit Order Books (CLOBs), margin calculations, vaults and liquidations at up to 200,000 orders per second
  2. HyperEVM: An Ethereum-compatible smart contract layer enabling Solidity contracts to read and compose with HyperCore liquidity

Elysium enters this stack as an Arbitrum Orbit Layer 2 built by Kinetiq (the team behind the kHYPE liquid staking protocol and Markets.xyz). Rather than settling to Ethereum like standard Orbit chains, Elysium settles directly to HyperEVM. For more on the base chain, read What is Hyperliquid.

What should you know before building?

⏭ If you are already familiar with Hyperliquid and Elysium architecture, you can jump directly to the “How do the RPC setups differ?” section below for Chainstack endpoint configurations and supported JSON-RPC methods.

Deploying an application in the Hyperliquid ecosystem requires choosing between two EVM-compatible environments with distinct execution guarantees: HyperEVM, Hyperliquid’s native Layer 1 smart contract layer, and Elysium, Kinetiq’s Arbitrum Orbit Layer 2 that settles to HyperEVM.

📖 Want to learn more about Elysium before diving in? Start with What is Elysium.

Elysium reported that in its first 48 hours since mainnet launch it surpassed $300 million in cumulative DEX trading volume and reached 645,374 total addresses. This early growth marks a strong start for the network as it brings greater EVM execution capacity to the Hyperliquid ecosystem.

Building a production DeFi protocol, market-making bot or indexing pipeline on Hyperliquid comes down to the following requirements:

How do transaction fees compare on Elysium and HyperEVM?

How does gas accounting differ when HYPE pays for execution on an L1 versus an Arbitrum Orbit L2?

On HyperEVM, gas follows standard EIP-1559 mechanics denominated in HYPE. Base fees adjust independently for small blocks (eth_gasPrice) and big blocks (eth_bigBlockGasPrice). Because eth_estimateGas evaluates against the latest block state only, add a 10–20% gas buffer for complex HyperEVM transactions. Moving USDC between HyperCore and HyperEVM costs roughly 100K gas (EVM to Core) and 200K gas (Core to EVM).

On Elysium, HYPE also serves as the native gas currency, bridged 1:1 from HyperEVM without a wrapper token. Because Elysium runs Arbitrum Nitro, every transaction fee includes two components:

⚠️ Do not hard-code 21,000 gas on Elysium. Even a plain native HYPE transfer requires more than 21,000 gas whenever gasUsedForL1 is non-zero, and a hard-coded 21000 returns -32000 intrinsic gas too low. Always let eth_estimateGas (or the viem, ethers.js and Foundry estimators) calculate the total limit.

Elysium also introduces protocol-level fee sharing. According to Kinetiq’s announcement, sequencer revenue is split 25% to builders driving blockspace demand, 25% to the Kinetiq treasury and 50% to buying back and burning KNTQ.

How do speed and finality compare?

Speed in EVM applications breaks down into two distinct metrics: block cadence (how often state updates) and gas throughput (how much computation fits per second).

Performance metricHyperEVMElysium
Block cadence1 second (small blocks), 60 seconds (big blocks)100 ms canonical blocks, ~300 ms perceived receipt
Gas throughput~3 Mgas/s (small blocks), 0.5 Mgas/s on average (big blocks)300 Mgas/s execution target
FinalityDeterministic 1-block finality via HyperBFT~300 ms sequencer soft receipt, ~5.5-day optimistic withdrawal to HyperEVM
HyperCore freshnessReal-time as of EVM block construction point (1 s)~150–350 ms data freshness via co-located node (post-upgrade)

How do the RPC setups differ?

The available RPC methods determine how an application reads state, submits transactions and traces execution. The underlying node infrastructure determines how consistently those methods respond under load and how far back historical queries can reach. Chainstack supports Elysium and Hyperliquid (HyperEVM and HyperCore) with managed Global Nodes (geo-balanced) and Dedicated Nodes (isolated compute and storage) aligned to different production workloads.

Elysium RPC

Elysium exposes standard Ethereum JSON-RPC and WebSocket APIs over Arbitrum Nitro for querying chain state, estimating HYPE gas (including gasUsedForL1), submitting signed transactions and streaming blocks or contract logs. Chainstack provides managed RPC access to Elysium Mainnet and Testnet through Global and Dedicated node deployments.

Deploy an Elysium node in a few steps:

  1. Open the Chainstack console and create a project.
  2. Select Elysium from the available blockchain protocols.
  3. Choose Mainnet or Testnet, then select Global Node or Dedicated Node based on throughput and isolation requirements.
  4. Name the node, review the configuration and click Deploy Node.
  5. Once deployment finishes, the authenticated HTTPS and WebSocket endpoints are ready for API requests.
Step 2: select Elysium in the protocol list.
Step 3: choose Mainnet or Testnet and the node type.
Step 4: name the node and click Deploy Node.

Network details:

ℹ️ Elysium has a single sequencer and no public mempool. Calls to eth_newPendingTransactionFilter and eth_subscribe("newPendingTransactions") return valid IDs, yet deliver zero transactions. In addition, Nitro does not expose Parity-style trace_* or arbtrace_* namespaces (both return -32601). Use debug_* tracers instead.

The Elysium RPC interface supports standard EVM methods alongside Nitro-specific debugging tracers. The complete availability matrix is documented in the Chainstack Elysium methods reference.

Core methods:

For example, eth_getLogs queries contract events such as ERC-20 Transfer emissions across recent blocks. Because Elysium produces 5 to 10 blocks per second, historical backfills should paginate in bounded block windows:

const response = await fetch("YOUR_CHAINSTACK_ENDPOINT", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    jsonrpc: "2.0",
    id: 1,
    method: "eth_getLogs",
    params: [{
      fromBlock: "latest",
      toBlock: "latest",
      topics: ["0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"]
    }]
  })
});

const data = await response.json();
console.log(data.result);

For transaction submission, eth_sendRawTransaction delivers the signed payload directly to the sequencer. Follow submission with eth_getTransactionReceipt or a WebSocket log check to confirm inclusion rather than watching a mempool queue.

WebSocket. The Elysium WebSocket endpoint is wss://elysium-mainnet.core.chainstack.com. Use it to push real-time updates without HTTP polling overhead:

On Chainstack nodes. Elysium Global Nodes serve debug_* tracing back to genesis, including flatCallTracer for traces in the Parity-style flat format. eth_getProof works only for blocks less than 127 behind the tip, and limits counted in blocks cover much less time than on Ethereum, so paginate log backfills by block range. The safe and finalized tags trail latest by minutes because Nitro advances them only after the batch lands on HyperEVM. A transaction receipt is available as soon as the sequencer includes it, so wait for finalized only when your app needs the batch on HyperEVM. See the Elysium methods and Elysium tooling docs.

HyperEVM RPC

HyperEVM provides standard Ethereum JSON-RPC and WebSocket APIs secured by HyperBFT, alongside HyperCore /info endpoints for reading native order-book account state. Chainstack supports Hyperliquid Mainnet and Testnet through Global, Dedicated and Self-Hosted deployments.

Deploy a Hyperliquid node in a few steps:

  1. Open the Chainstack console and create a project.
  2. Select Hyperliquid from the available blockchain protocols.
  3. Choose Mainnet or Testnet, then select Global Node or Dedicated Node according to latency and history requirements.
  4. Name the node, review the configuration and click Deploy Node.
  5. Once deployment completes, a single Chainstack Hyperliquid node exposes three distinct endpoint paths.
Step 2: search for and select Hyperliquid.
Step 3: choose Mainnet or Testnet and the node type.
Step 4: name the node and click Deploy Node.

Network details:

ℹ️ For a detailed breakdown regarding the info endpoint, exchange, API documentation or WebSocket endpoints, refer to the Hyperliquid API guide.

The Hyperliquid RPC surface spans standard Ethereum methods, Hyperliquid-specific EVM extensions, full trace namespaces and HyperCore /info queries. The full availability matrix is listed in the Chainstack Hyperliquid methods reference.

For example, eth_call on /evm can query the total supply of wrapped HYPE (0x5555555555555555555555555555555555555555):

const response = await fetch("YOUR_CHAINSTACK_ENDPOINT/evm", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    jsonrpc: "2.0",
    method: "eth_call",
    id: 1,
    params: [{ to: "0x5555555555555555555555555555555555555555", data: "0x18160ddd" }, "latest"]
  })
});

const data = await response.json();
console.log(data.result);

How do RPC operations differ between HyperEVM and Elysium?

The operational distinction centers on endpoint routing, trace namespaces and public limits:

HyperEVMElysium
Endpoint pathsSeparates standard dApp traffic (/evm), system-transaction-aware indexing (/nanoreth) and HyperCore account reads (/info)Serves all EVM traffic from a single root endpoint
Tracing namespacesdebug_*, Parity trace_* and Otterscan ots_* methods on Chainstack archive nodesNitro debug_* tracers only, trace_* and arbtrace_* are omitted
Public RPC limitsPublic HyperEVM RPC enforces a 100 requests per minute IP capKinetiq’s public RPC gates debug_* behind an API key

Chainstack removes those ceilings across global regions. For Python, TypeScript and Rust SDK configurations, refer to the Hyperliquid tooling documentation.

How do the ecosystems compare?

The ecosystem surrounding an execution layer plays an important role in determining where applications launch and how they attract liquidity and users. DeFi protocols, trading infrastructure, cross-chain connectivity and developer tooling all contribute to the growth of an onchain ecosystem.

Hyperliquid’s ecosystem is expanding across two execution environments with different roles. HyperEVM has developed into a DeFi-focused environment built around lending, liquid staking and stablecoin infrastructure. Elysium extends this ecosystem with an Arbitrum-based execution layer designed to support spot trading, token launches and cross-chain liquidity.

HyperEVM

HyperEVM launched on mainnet in February 2025 and established the foundation for DeFi applications within the Hyperliquid ecosystem. Its early growth has been concentrated around lending markets, liquid staking and collateralized debt position (CDP) stablecoins.

By the first half of 2026, HyperEVM hosted more than 100 protocols and nearly $2 billion in total value locked (TVL). Much of this liquidity is concentrated in a handful of established protocols:

These protocols form much of HyperEVM’s existing DeFi infrastructure, providing users with access to lending, borrowing, liquid staking and collateral management without leaving the Hyperliquid ecosystem.

The broader ecosystem also benefits from Hyperliquid’s underlying trading activity. Its perpetual markets recorded more than $257 billion in 30-day notional trading volume as of November 2026, creating opportunities for applications that build around trading, collateral and liquidity.

Elysium

Elysium’s ecosystem takes a different approach, bringing established Ethereum and Arbitrum infrastructure into the Hyperliquid ecosystem. Rather than starting with an entirely new application stack, Elysium launched with integrations across decentralized trading, cross-chain liquidity and NFT infrastructure.

Its architecture is built on Arbitrum Nitro and developed with Conduit, making it the first dedicated Arbitrum Platform chain to settle to HyperEVM. This gives developers familiar tooling and infrastructure while providing access to the Hyperliquid ecosystem.

Protocols, trading apps and infrastructure on Elysium:

Uniswap’s deployment is particularly relevant to Elysium’s trading infrastructure. Supporting three protocol versions gives developers different approaches to liquidity management, from conventional AMM pools to more customizable pool configurations through v4 Hooks.

Token launches and liquidity expansion. Elysium connects AMM-based token launches with Hyperliquid’s native spot and perpetual markets. Tokens can launch and establish initial liquidity through Elysium-based AMMs, with liquidity deepening through PropAMMs as trading activity grows. Assets can then move back to HyperEVM through the canonical mirror bridge.

Qualifying tokens can graduate to HyperCore spot order books and HIP-3 perpetual markets, creating a path from initial token distribution to deeper liquidity and more advanced trading markets. This connects Elysium’s EVM application layer with Hyperliquid’s native trading infrastructure.

The distinction between the two environments comes down to their application focus. HyperEVM provides an established DeFi foundation built around lending, liquid staking and CDP stablecoins with direct HyperCore integration. Elysium extends this ecosystem with greater EVM execution capacity, AMM trading, token launches and cross-chain liquidity, giving developers access to familiar tooling and infrastructure such as Uniswap and LI.FI.

For development teams, these ecosystems offer different starting points within the same broader network. HyperEVM provides access to native HyperCore integration and established DeFi liquidity, while Elysium offers greater EVM execution capacity and an expanding application infrastructure for trading and asset distribution.

Which one should you deploy on?

Choosing between HyperEVM and Elysium depends on the application’s throughput profile, latency tolerance and trust model for HyperCore data.

Deploy on HyperEVM if the application needs:

Deploy on Elysium if the application needs:

Which tools help you build on both?

The SDKs, RPC infrastructure and contract verification tooling available across Elysium and HyperEVM determine how quickly teams move from local testing to production deployment.

Conclusion

So where should the next app deploy? HyperEVM and Elysium solve different parts of the same problem. HyperEVM provides the settlement environment with direct HyperCore integration through precompiles and CoreWriter. Elysium provides the execution headroom for workloads like PropAMM quoting, with 100–200 ms blocks, a 300 Mgas/s target, HYPE gas and a path to native HyperCore reads and writes. The trade-offs are documented plainly: a single sequencer, a single data availability server, a 5.5-day withdrawal window and HyperCore features that ship after launch.

For production teams, the practical steps are short. Test on Elysium Testnet, build confirmation logic around block inclusion, size infrastructure for archive-depth reads and re-read the docs when the HyperCore upgrade lands. Chainstack provides Elysium nodes and Hyperliquid nodes with debug and trace access, WebSocket support and Global or Dedicated deployment, so one provider covers the full path. Elysium mainnet is also available, making it possible to move from testnet to mainnet deployment on the same infrastructure when ready.

Frequently asked questions

What is the main difference between Elysium and HyperEVM?

HyperEVM is the native EVM execution layer of Hyperliquid Layer 1, secured by HyperBFT and directly composable with HyperCore through precompiles and CoreWriter. Elysium is an Arbitrum Orbit Layer 2 built by Kinetiq that settles to HyperEVM. It prioritizes higher EVM throughput, targeting 100–200 ms block times and 300 Mgas/s execution capacity. HyperEVM is better suited to applications requiring direct HyperCore access, while Elysium targets high-frequency DeFi applications and transaction-heavy workloads.

Is Elysium faster and cheaper than HyperEVM?

Elysium targets approximately 300 Mgas/s throughput and 100–200 ms block times, compared with HyperEVM’s 3M gas per second in 1-second small blocks and 30M gas per 60-second big blocks. Elysium also targets low transaction fees through its Arbitrum Nitro execution and AnyTrust data availability model. However, actual costs depend on network utilization and parent-chain data posting fees. Developers should benchmark representative transactions on both networks before choosing.

Can Elysium smart contracts access HyperCore liquidity and market data?

Elysium’s native HyperCore read and write capabilities are planned through a post-launch ArbOS upgrade. These features are designed to support access to HyperCore prices, order book data, balances and positions, alongside order submission through a keeper-based execution path. However, unlike HyperEVM’s native precompiles and CoreWriter, Elysium’s integration introduces sequencer-attestation and asynchronous execution assumptions. Developers requiring synchronous, consensus-level HyperCore access today should deploy on HyperEVM.

What are the main security and finality differences between Elysium and HyperEVM?

HyperEVM operates directly under HyperBFT consensus, providing deterministic one-block finality alongside HyperCore. Elysium relies on an Arbitrum Nitro rollup architecture with a single sequencer and a Conduit-operated data availability server at launch. Transactions can receive sequencer confirmations in approximately 300 ms, but withdrawals to HyperEVM are subject to an optimistic challenge period of approximately 5.5 days. Developers should account for these additional trust assumptions and withdrawal delays when designing applications that handle user funds.

How do developers connect to Elysium and HyperEVM using Chainstack?

Chainstack provides managed RPC infrastructure for both networks through Global and Dedicated Nodes with HTTPS and WebSocket connectivity. Elysium uses a single root RPC endpoint for standard Ethereum JSON-RPC methods, Nitro debugging and WebSocket subscriptions. HyperEVM provides separate /evm, /nanoreth and /info paths for standard EVM operations, archive and system-transaction indexing and HyperCore state queries, respectively. Developers can deploy either network through the Chainstack console and use familiar tools such as Foundry, Hardhat, ethers.js and viem to build and monitor applications.

Exit mobile version