
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:
- 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
- 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.
- HyperEVM runs directly under HyperBFT consensus alongside HyperCore (Hyperliquid’s native Central Limit Order Book). Smart contracts synchronously read HyperCore oracle prices, spot balances and perpetual positions via native precompiles and submit actions via
CoreWriter. Its dual-block architecture pairs 1-second small blocks (2M–3M gas) with 60-second big blocks (30M gas), prioritizing L1 order-book composability over raw EVM throughput. - Elysium launched on public mainnet on November 9, 2026. Built on Arbitrum Nitro (ArbOS 61) and operated with Conduit, it targets 100 ms canonical blocks and 300 Mgas/s using
HYPEas native gas. It trades synchronous HyperCore precompiles at launch for two orders of magnitude more EVM gas capacity, with sequencer-attested HyperCore read and write paths scheduled for a post-launch ArbOS upgrade.
📖 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:
- Predictable blockspace for the target workload: A lending protocol executing periodic liquidations has different gas needs than a proprietary AMM (PropAMM) refreshing quotes 5 to 10 times per second
- Verifiable HyperCore state access: Applications require clarity on whether smart contracts need synchronous, consensus-level reads of HyperCore order books and margin states or whether asynchronous, sequencer-attested market data fits the risk model
- Deterministic transaction confirmation: With sub-second block times and zero public mempool visibility on L2 sequencers, confirmation logic must rely on block inclusion and receipts
- Complete historical and trace visibility: Indexers, security engineers and analytics backends need
debug_*traces, archive state and protocol-injected system transactions - Production-grade RPC throughput: Public endpoints enforce strict rate limits. Hyperliquid’s public HyperEVM RPC caps traffic at 100 requests per minute per IP, which makes managed RPC infrastructure essential for a live production app
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:
- L2 execution gas: Priced against Elysium’s 300 Mgas/s target capacity, which keeps base fees minimal (testnet probes recorded
0.01–0.1 gweibase fees with a0priority tip under light load) - Parent-chain data posting (
gasUsedForL1): Nitro charges a small L1 component to cover posting AnyTrust batch certificates to HyperEVM
⚠️ Do not hard-code 21,000 gas on Elysium. Even a plain native
HYPEtransfer requires more than21,000gas whenevergasUsedForL1is non-zero, and a hard-coded21000returns-32000 intrinsic gas too low. Always leteth_estimateGas(or theviem,ethers.jsand 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 metric | HyperEVM | Elysium |
|---|---|---|
| Block cadence | 1 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 |
| Finality | Deterministic 1-block finality via HyperBFT | ~300 ms sequencer soft receipt, ~5.5-day optimistic withdrawal to HyperEVM |
| HyperCore freshness | Real-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:
- Open the Chainstack console and create a project.
- Select Elysium from the available blockchain protocols.
- Choose Mainnet or Testnet, then select Global Node or Dedicated Node based on throughput and isolation requirements.
- Name the node, review the configuration and click Deploy Node.
- Once deployment finishes, the authenticated HTTPS and WebSocket endpoints are ready for API requests.
Network details:
- Network name: Elysium Mainnet
- Mainnet chain ID:
99901 - Testnet chain ID:
99801 - Native currency:
HYPE - RPC endpoint:
https://elysium-mainnet.core.chainstack.com/
ℹ️ Elysium has a single sequencer and no public mempool. Calls to
eth_newPendingTransactionFilterandeth_subscribe("newPendingTransactions")return valid IDs, yet deliver zero transactions. In addition, Nitro does not expose Parity-styletrace_*orarbtrace_*namespaces (both return-32601). Usedebug_*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:
eth_chainId: Returns the network chain ID (0x1863d/99901on Mainnet,0x185d9/99801on Testnet) to verify client configurationeth_call: Executes a read-only smart contract call against current or historical state without broadcasting a transactioneth_estimateGas: Estimates total gas required for execution, accounting for L2 execution gas andgasUsedForL1parent-chain posting costseth_getLogs: Retrieves event logs matching contract addresses, topics and bounded block rangeseth_sendRawTransaction/eth_sendRawTransactionSync: Broadcasts a locally signed EIP-1559 transaction directly to the sequencereth_getTransactionReceipt: Retrieves execution status, gas used,gasUsedForL1and emitted logs for a confirmed transaction hasheth_simulateV1: Simulates transaction bundles against specified block states before submissioneth_getProof: Returns Merkle account and storage proofs for blocks fewer than 127 blocks behind the chain tip (~13–25 seconds at 100–200 ms block cadence)debug_traceTransaction/debug_traceCall/debug_traceBlockByNumber: Replays execution back to genesis using native tracers (callTracer,prestateTracer,4byteTracer), extended tracers (flatCallTracerincludingbeforeEVMTransfersandafterEVMTransfers,muxTracer,erc7562Tracer) andstylusTracerfor WebAssembly host I/O calls
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:
eth_subscribe("newHeads"): Streams new block headers as the sequencer produces them every 100–200 mseth_subscribe("logs"): Streams contract event logs filtered by address and topic in real time
On Chainstack nodes. Elysium Global Nodes serve
debug_*tracing back to genesis, includingflatCallTracerfor traces in the Parity-style flat format.eth_getProofworks 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. Thesafeandfinalizedtags traillatestby 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 forfinalizedonly 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:
- Open the Chainstack console and create a project.
- Select Hyperliquid from the available blockchain protocols.
- Choose Mainnet or Testnet, then select Global Node or Dedicated Node according to latency and history requirements.
- Name the node, review the configuration and click Deploy Node.
- Once deployment completes, a single Chainstack Hyperliquid node exposes three distinct endpoint paths.
Network details:
- Network name: Hyperliquid Mainnet
- Mainnet chain ID:
999 - Testnet chain ID:
998 - Native currency:
HYPE - RPC endpoint:
https://hyperliquid-mainnet.core.chainstack.com/
ℹ️ 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:
| HyperEVM | Elysium | |
|---|---|---|
| Endpoint paths | Separates standard dApp traffic (/evm), system-transaction-aware indexing (/nanoreth) and HyperCore account reads (/info) | Serves all EVM traffic from a single root endpoint |
| Tracing namespaces | debug_*, Parity trace_* and Otterscan ots_* methods on Chainstack archive nodes | Nitro debug_* tracers only, trace_* and arbtrace_* are omitted |
| Public RPC limits | Public HyperEVM RPC enforces a 100 requests per minute IP cap | Kinetiq’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:
- Kinetiq: liquid staking infrastructure with more than $1.2 billion in TVL through kHYPE
- HyperLend: lending and borrowing markets with over $480 million in TVL, including liquidations connected to Hyperliquid’s L1 Central Limit Order Book
- Morpho: lending infrastructure with approximately $128.62 million in TVL as of 13 Nov 2026
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: deployed v2, v3 and v4 on Elysium. This brings established AMM infrastructure to the network, including customizable liquidity pools and Uniswap v4 Hooks.
- LI.FI: provides cross-chain bridging and routing infrastructure, allowing users to move assets into Elysium from supported networks.
- Pump.fun: integrated Elysium trading into its app on mainnet launch, allowing users to discover and trade tokens, projects and protocols across the Elysium ecosystem.
- Fomo: a trading application that supports Elysium from day one and serves as its exclusive trading partner, providing another retail-facing entry point into Elysium’s token markets.
- OpenSea: launched native Elysium collection support, including the Enter Elysium launch collection, extending NFT infrastructure to the network.
- Arbitrum and Conduit: provide the underlying rollup technology and chain infrastructure, connecting Elysium to the broader Arbitrum development ecosystem.
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:
- Trust-minimized, synchronous HyperCore reads: Lending markets, CDP protocols and liquidation engines (such as HyperLend and Felix) that require HyperBFT-verified, same-block reads of HyperCore oracle prices, margin states and positions via native precompiles without sequencer attestation.
- Immediate L1 finality and canonical collateral: Protocols holding core TVL, liquid staking tokens (kHYPE) or canonical stablecoins where deterministic 1-block finality and zero rollup challenge periods outweigh sub-second EVM block cadence.
- Moderate gas consumption: Applications fitting within 1-second 2M–3M gas blocks or 60-second 30M big blocks.
Deploy on Elysium if the application needs:
- Sustained high-frequency EVM throughput: Spot DEXs, Uniswap v4 Hooks pools, PropAMMs and onchain market makers refreshing quotes 5–10 times per second within a 300 Mgas/s execution budget and 100 ms blocks.
- Arbitrum Orbit and Nitro compatibility: Teams migrating existing Arbitrum or Robinhood Chain Solidity and Stylus architectures that want familiar Nitro
debug_*tracers, lowHYPEL2 gas fees and the 25% builder share of sequencer revenue. - Token launch and graduation pipelines: Launchpads and consumer trading apps onboarding assets on high-throughput AMMs before graduating liquidity to HyperEVM and HyperCore spot markets.
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.
- Elysium tooling: Configuration guides and code examples for connecting MetaMask,
ethers.js,viem,web3.py, Foundry and Hardhat 3 to Elysium Mainnet and Testnet, including Blockscout verification commands. - Hyperliquid tooling: Integration documentation for connecting Python, TypeScript and Rust SDKs alongside standard EVM frameworks to Hyperliquid’s
/evm,/nanorethand/infoendpoints. - Elysium methods: Per-method JSON-RPC availability matrix covering
eth_*,debug_*tracers,eth_getProofblock windows and WebSocket subscriptions. - Hyperliquid methods: Complete method reference spanning HyperEVM JSON-RPC, Hyperliquid-specific big-block methods (
eth_bigBlockGasPrice,eth_usingBigBlocks) and supported HyperCore/infoqueries. - Hyperliquid Python SDK: Official Python library for querying HyperCore market data, managing sub-accounts and executing order-book actions alongside HyperEVM workflows.
- Hyperliquid TypeScript SDK: Community-maintained, type-safe TypeScript SDK compatible with
viemandethers.jswallets across major JavaScript runtimes. - Hyperliquid Rust SDK: Official Rust library for building low-latency trading engines, market-making bots and backend services against Hyperliquid APIs.
- HyperEVM
/evmvs/nanorethguide: Technical breakdown of Chainstack’s two HyperEVM endpoint paths, detailing when dApps should route to/evmand when indexers require/nanorethfor system transaction visibility. - HyperEVM precompiles and CoreWriter guide: Implementation guide for reading HyperCore state, static calls, handling
szDecimalsscaling and encodingCoreWriterintents. - Elysium docs and explorer: Official Kinetiq documentation, Blockscout-based block explorer, canonical bridge and contract verification API.
- Chainstack testnet faucet: Faucet portal dispensing free testnet
HYPE(up to 1 testHYPEevery 24 hours) for HyperEVM Testnet deployments and bridging to Elysium Testnet. - Chainstack MCP server: Unified Model Context Protocol server enabling AI coding environments such as Claude, Cursor, Codex and Gemini to provision Elysium and Hyperliquid nodes, search documentation and request testnet funds.
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
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.
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.
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.
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.
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.
Related reading
- What is Elysium
- What is Hyperliquid
- Chainstack introduces Elysium support
- Elysium methods (Chainstack docs)
- Hyperliquid methods (Chainstack docs)
