Dwellir Adds Elysium RPC Support: Archive, Debug and WebSocket for Kinetiq's Hyperliquid L2

Elysium blocks arrive every 130 ms or so, and the public RPC gives you no WebSocket, no debug tracing and a 2,000-block cap on eth_getLogs. That is enough to deploy a contract and not enough to run a market-making bot or an indexer against it.

Dwellir now serves Elysium testnet RPC. The endpoint runs Arbitrum Nitro in archive mode with the eth, net, web3, debug and arb namespaces over HTTPS and WebSocket. Billing follows the rest of the Dwellir platform: one RPC response is one API credit, whether the call is eth_blockNumber or debug_traceTransaction.

What You Get

Endpoint format:

https://api-elysium-testnet-archive.n.dwellir.com/<YOUR_API_KEY>
wss://api-elysium-testnet-archive.n.dwellir.com/<YOUR_API_KEY>

Why Elysium Needs More Than the Public RPC

Elysium is an Arbitrum Orbit chain built by Kinetiq. It settles to HyperEVM, uses HYPE for gas, and targets high-frequency trading and market-making AMMs with 100 to 200 ms blocks. What Is Elysium? covers the architecture in depth. Here is what that design means for your RPC layer.

Fast blocks make polling expensive. At ~130 ms per block, Elysium produces about 670,000 blocks a day. A bot that polls eth_blockNumber five times a second still misses intermediate heads. WebSocket newHeads subscriptions are the only clean way to follow the chain, and the public endpoint rejects WebSocket upgrades without a key.

Indexing is log-heavy. The public RPC caps unfiltered eth_getLogs at 2,000 blocks, which is about four minutes of chain history. Backfilling one day of events takes more than 300 calls. On an archive endpoint billed per response, a wider range and a flat price per call keep that backfill cheap and predictable.

There is no mempool to watch. Elysium has a single sequencer that orders transactions by priority fee. Pending-transaction filters return an ID and never deliver. Your trading system learns about transactions when they land in a block, which puts more weight on head latency and less on mempool tricks.

Reverts need traces. Elysium runs stock Nitro, so debug_traceTransaction with callTracer or flatCallTracer is how you diagnose a failed swap or quote update. Some providers serving Elysium do not offer debug at all, and others charge archive or debug calls at a multiple. On Dwellir a trace costs the same credit as any other call.

Quickstart

Check the connection

export ELYSIUM_RPC="https://api-elysium-testnet-archive.n.dwellir.com/<YOUR_API_KEY>"

curl -s "$ELYSIUM_RPC" \
  -H 'content-type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_chainId","params":[]}'
# {"jsonrpc":"2.0","id":1,"result":"0x185d9"}

0x185d9 is 99801, the Elysium testnet chain ID.

viem: define the chain yourself

Do not import elysiumTestnet from viem/chains. In viem 2.57.7 that export is a different, older network from Vulcan Forged: chain ID 1338, gas token LAVA. Define Kinetiq's Elysium explicitly:

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

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

const http_ = createPublicClient({ chain: elysiumTestnet, transport: http() })
const ws = createPublicClient({ chain: elysiumTestnet, transport: webSocket() })

console.log('chain ID', await http_.getChainId())

// Follow every head over WebSocket instead of polling
const unwatch = ws.watchBlocks({
  onBlock: (block) => console.log(block.number, block.transactions.length, 'txs'),
})
setTimeout(unwatch, 5_000)

Expect 35 to 40 blocks in those five seconds.

Foundry

# foundry.toml
[rpc_endpoints]
elysium_testnet = "${ELYSIUM_RPC}"

cast chain-id --rpc-url elysium_testnet        # 99801
forge script script/Deploy.s.sol --rpc-url elysium_testnet --broadcast

Hardhat

// hardhat.config.js
module.exports = {
  solidity: '0.8.28',
  networks: {
    elysiumTestnet: {
      url: process.env.ELYSIUM_RPC,
      chainId: 99801,
      accounts: [process.env.PRIVATE_KEY],
    },
  },
}

Testnet HYPE comes from the Elysium faucet.

Trace a transaction

curl -s "$ELYSIUM_RPC" \
  -H 'content-type: application/json' \
  -d '{
    "jsonrpc": "2.0", "id": 1,
    "method": "debug_traceTransaction",
    "params": ["<TX_HASH>", { "tracer": "callTracer" }]
  }'

trace_* and arbtrace_* are not available on Elysium on any provider. Nitro does not implement Parity-style trace_*, and arbtrace_* only serves pre-Nitro Arbitrum One history, which Elysium does not have. Use debug_traceTransaction or debug_traceBlockByNumber with callTracer or flatCallTracer instead. flatCallTracer returns output in the same flat shape as Parity-style trace_transaction, which helps if your tooling was built for Arbitrum One.

What Running Elysium Involves

Every Elysium node follows the chain by reading batch events from HyperEVM. The node calls eth_getLogs against the SequencerInbox contract on HyperEVM, fetches batch data from the AnyTrust committee, and replays it. During initial sync that means thousands of consecutive log queries against the parent chain.

The public HyperEVM testnet RPC times out on 100-block eth_getLogs queries against the inbox, so an Elysium node cannot sync through it. Dwellir runs its own HyperEVM testnet node next to the Elysium backend and feeds the Nitro inbox reader from it over the local network. When the HyperEVM parent is slow, every Elysium node built on it falls behind, so the Elysium endpoint depends on the HyperEVM node being healthy too.

This is the same stack Dwellir already operates for Hyperliquid. Dwellir runs HyperEVM and HyperCore infrastructure in Tokyo, including gRPC streaming and order-book servers, and Nitro-based chains such as Arbitrum and Robinhood Chain. Elysium sits at the intersection of the two.

Pricing

Elysium uses the standard Dwellir plans. There are no compute units and no method multipliers.

That works out to about $2 per million responses on every paid plan, for eth_call, eth_getLogs and debug_traceTransaction alike. For steady high-RPS workloads such as quote bots, talk to the Dwellir team about flat-rate capacity.

Mainnet

Kinetiq has not published a mainnet chain ID or a confirmed launch date; the Elysium X account has teased November 9. Dwellir will add the Elysium mainnet endpoint once the chain is live, with the same archive, debug and WebSocket coverage. The HyperCore read precompile and trading lane, planned for about four weeks after mainnet, will need no change on the RPC side. Contracts reach them through eth_call and ordinary transactions.

Get Started

1. Create a Dwellir account and copy your API key.
2. Find Elysium testnet in the dashboard's endpoint list.
3. Point ELYSIUM_RPC and ELYSIUM_WS at the endpoint and run the quickstart above.

Comparing options first? Top Elysium RPC Providers puts Dwellir, Conduit, Chainstack, Hypedexer, Alchemy and QuickNode side by side on pricing, archive and debug support. For a dedicated Elysium node or a high-RPS trading setup, contact the Dwellir team.