How to launch a token on Elysium and trade it on Hyperliquid
Written by Uttam Singh
Elysium is Kinetiq's Layer 2 for Hyperliquid, and its mainnet went live on November 9. It is an EVM chain with 100 ms blocks that uses HYPE for gas and settles to HyperEVM. An Elysium token can trade on Hyperliquid's own order books. This guide walks the full path. You deploy an ERC-20 on Elysium with Foundry and our Elysium RPC, mirror it to HyperEVM, and then run the HyperCore listing that puts it on a spot order book against USDC.
Deploying and mirroring are cheap and permissionless, though the first mirror mint waits out a challenge period of about 5.5 days. The HyperCore listing is a one-time issuer ceremony on Hyperliquid, and it starts with a ticker auction whose price never drops below 500 HYPE. Everything after that ceremony is open to every holder, who can move the token between Elysium, HyperEVM, and HyperCore through the bridges.
What should you know about Elysium before you launch?
Elysium is an Arbitrum Orbit chain built by Kinetiq that settles to HyperEVM and runs co-located with HyperCore. HyperCore is Hyperliquid's exchange layer, where its spot and perpetual order books live. HyperEVM is the EVM environment that runs alongside it on the same Hyperliquid L1. Our post on going all-in on Hyperliquid explains how the two halves fit together, and our guide to trading on Elysium covers the chain itself in more depth, from why Hyperliquid needs an L2 to the apps launching on it.
HyperEVM caps throughput on purpose. Its small blocks carry 3M gas every second, with 30M gas only on one-minute big blocks. Kinetiq built Elysium for workloads that need more, such as market makers refreshing quotes several times a second. It targets 300 Mgas/s (million gas per second) of execution, roughly two orders of magnitude more than HyperEVM, while keeping HYPE as the only token you need to transact.
Elysium's blocks are real canonical blocks, so latest and transaction receipts have their usual meaning, with no preconfirmation layer on top. Solidity, Foundry, Hardhat, and viem work unchanged. Kinetiq has also committed 25% of sequencer fees to builders whose apps drive activity on the chain.
We're the primary RPC provider for Elysium, and Kinetiq's docs list us as the recommended infrastructure provider for Elysium. Our Elysium RPC page and Elysium API quickstart have the mainnet endpoints. Two details from our Elysium API FAQ save debugging time:
- The
elysiumTestnetexport inviem/chainsis a different chain. It belongs to an unrelated project, so define Kinetiq's Elysium yourself withdefineChain. - A plain HYPE transfer costs slightly more than 21,000 gas. Arbitrum chains add a small amount for parent-chain data, so a hard-coded
21000gas limit fails withintrinsic gas too low.
How does a token get from Elysium to a HyperCore order book?
A token makes two bridge hops, and each hop has its own setup:
Elysium your ERC-20
| mirror bridge: lock on Elysium, mint a 1:1 mirror on HyperEVM
v
HyperEVM the mirror, a plain ERC-20
| deposit wallet: escrow on HyperEVM that HyperCore credits and debits
v
HyperCore a spot token with an order book against USDCThe mirror bridge needs no code in your token. It locks the original on Elysium in an escrow wallet and mints a 1:1 mirror on HyperEVM, so the mirror's supply always equals what is locked.
HyperCore links each spot token to one EVM contract, and the deployer has to prove control of that contract. A contract deployed straight from a wallet proves it with its deployment nonce. Your mirror is deployed by the bridge factory, so that check can't work for it. A deposit wallet solves this, following the pattern Circle uses to link USDC. It holds the mirror in escrow, stores your signing address in the storage slot HyperCore reads for factory-deployed contracts, and becomes the contract HyperCore links to.
Three choices in this path can't be undone, so settle them before you spend anything. These are the token's HyperCore decimals (fixed when you win the ticker), its genesis supply, and the link between the HyperCore token and the deposit wallet.
How do you deploy the token on Elysium?
You need three things before anything touches the chain:
- An Elysium endpoint. Create an app in the Alchemy dashboard and select Elysium.
- HYPE on Elysium. HYPE bridges in 1:1 from HyperEVM through Kinetiq's bridge and arrives as native gas, with no wrapped token in between.
- Foundry. Every command below uses
forgeandcast, and the same deployer key signs on Elysium, HyperEVM, and HyperCore.
The mirror bridge accepts any standard ERC-20 with three properties. It must expose name(), symbol(), and decimals(), because that metadata is how the bridge pairs the token with its mirror. The metadata should never change. Transfers must also move the exact amount requested, which rules out fee-on-transfer and rebasing tokens. A plain OpenZeppelin ERC-20 meets all three. Our guide to ERC-20 tokens in Solidity covers what each function does.
Plan the supply against HyperCore's limits now. HyperCore stores balances as 64-bit integers and allows at most 8 wei decimals, which caps a token with 8 decimals at roughly 184 billion whole units. A fixed supply of one billion fits comfortably:
// SPDX-License-Identifier: MIT
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
contract ExampleToken is ERC20 {
constructor() ERC20("Example Token", "EXMPL") {
_mint(msg.sender, 1_000_000_000 * 10 ** decimals());
}
}OpenZeppelin's ERC-20 sets the name and symbol once in the constructor, and with no mint function the supply is fixed at deploy. Save the contract as src/ExampleToken.sol and deploy it:
forge init example-token && cd example-token
forge install OpenZeppelin/openzeppelin-contracts
# Save the contract above as src/ExampleToken.sol, then import your deployer key once.
cast wallet import deployer --interactive
export ELYSIUM_RPC="https://elysium-mainnet.g.alchemy.com/v2/$ALCHEMY_API_KEY"
forge create src/ExampleToken.sol:ExampleToken \
--rpc-url "$ELYSIUM_RPC" \
--account deployer \
--broadcastcast wallet import stores the key in an encrypted keystore, and --account unlocks it at signing time, so the raw key never appears in your shell history. Our Robinhood Chain token guide uses the same flow on another Arbitrum Orbit chain.
To see the block rate for yourself, subscribe to new blocks over the WebSocket endpoint. HTTP polling skips blocks between polls at this rate, so use the WebSocket URL here:
import { createPublicClient, defineChain, webSocket } from "viem";
const wssUrl = process.env.ELYSIUM_WSS;
if (!wssUrl) throw new Error("Set ELYSIUM_WSS to your Alchemy Elysium WebSocket URL");
// viem/chains exports an unrelated chain called elysiumTestnet, so define Elysium yourself.
const elysium = defineChain({
id: 99901, // Elysium mainnet
name: "Elysium",
nativeCurrency: { name: "HYPE", symbol: "HYPE", decimals: 18 },
rpcUrls: { default: { http: [], webSocket: [wssUrl] } },
});
const client = createPublicClient({ chain: elysium, transport: webSocket(wssUrl) });
let previous;
client.watchBlocks({
onBlock: (block) => {
const now = Date.now();
if (previous) console.log(`block ${block.number} arrived ${now - previous} ms after the last one`);
previous = now;
},
onError: (error) => console.error(error.message),
});Set ELYSIUM_WSS to the wss://elysium-mainnet.g.alchemy.com/v2/ URL with your key. You can look up your token and its transactions on the Elysium explorer.
How do you mirror the token to HyperEVM?
The mirror bridge has two parts. An escrow wallet on Elysium holds locked tokens, and a mirror ERC-20 on HyperEVM is minted and burned only by the bridge. Setup is permissionless and takes one transaction on each chain, in either order. The addresses below are Elysium mainnet's, from Kinetiq's contract addresses page. Check them there before you send funds:
export HYPEREVM_RPC="https://hyperliquid-mainnet.g.alchemy.com/v2/$ALCHEMY_API_KEY"
export TOKEN=<your token's address on Elysium>
export BRIDGE_FACTORY=0x209B0476ec33841c661f41C0C260A3b8aF94164A # ElysiumBridgeFactory, on Elysium
export MIRROR_FACTORY=0x473D61817Da6ce1a97aDC010FF1e96048504643B # ElysiumMirrorFactory, on HyperEVM
export ELYSIUM_ROUTER=0x61EbbC3A29f1970aF2Ce862bA9c5364832E14d17 # gateway router, on Elysium
export DEPLOYER=$(cast wallet address --account deployer)
# Elysium: deploy the escrow wallet that will hold locked tokens.
cast send "$BRIDGE_FACTORY" "createL2Wallet(address)" "$TOKEN" \
--rpc-url "$ELYSIUM_RPC" --account deployer
# The one mirror address the factory derived from your token's name, symbol, and decimals.
export MIRROR=$(cast call "$BRIDGE_FACTORY" "expectedL1Mirror(address)(address)" "$TOKEN" --rpc-url "$ELYSIUM_RPC")The HyperEVM transaction deploys the mirror at that address and registers the pair with the bridge on both chains. It pays for two delivery messages to Elysium in HYPE, and the value you send must equal the two message budgets exactly. Kinetiq recommends bidding twice Elysium's current gas price, with a 0.5 gwei minimum, so both messages execute on arrival. Anything you over-provision is refunded to your address on Elysium:
GAS_PRICE_BID=$(( $(cast gas-price --rpc-url "$ELYSIUM_RPC") * 2 )) # 2x the current Elysium gas price
(( GAS_PRICE_BID < 500000000 )) && GAS_PRICE_BID=500000000 # at least 0.5 gwei
MAX_GAS=300000
MAX_SUBMISSION=400000000000000 # 0.0004 HYPE per message
VALUE_EACH=$(( MAX_SUBMISSION + MAX_GAS * GAS_PRICE_BID ))
cast send "$MIRROR_FACTORY" \
"createAndRegisterL1Mirror(address,string,string,uint8,(uint256,uint256,uint256,uint256,uint256,uint256,uint256,address))" \
"$TOKEN" "Example Token" "EXMPL" 18 \
"($MAX_SUBMISSION,$MAX_SUBMISSION,$MAX_GAS,$MAX_GAS,$GAS_PRICE_BID,$VALUE_EACH,$VALUE_EACH,$DEPLOYER)" \
--value $(( 2 * VALUE_EACH )) \
--rpc-url "$HYPEREVM_RPC" --account deployerPass the token's exact live name, symbol, and decimals. The factory accepts any metadata, but only the mirror that matches your token can ever receive supply, and a mismatched one stays empty forever. The two messages normally land on Elysium within a minute. If one fails to execute, rerun the same registration with the same arguments to resend both.
Bridging is now open to every holder. To move tokens across, approve the escrow wallet on Elysium and send them through the router. The router takes the mirror's address as the token argument in both directions:
export WALLET=$(cast call "$BRIDGE_FACTORY" "l2WalletFor(address)(address)" "$TOKEN" --rpc-url "$ELYSIUM_RPC")
AMOUNT=$(cast to-wei 1000000) # 1,000,000 tokens, converted to 18-decimal base units
cast send "$TOKEN" "approve(address,uint256)" "$WALLET" "$AMOUNT" \
--rpc-url "$ELYSIUM_RPC" --account deployer
cast send "$ELYSIUM_ROUTER" "outboundTransfer(address,address,uint256,uint256,uint256,bytes)" \
"$MIRROR" "$DEPLOYER" "$AMOUNT" 0 0 0x \
--rpc-url "$ELYSIUM_RPC" --account deployerThe lock happens immediately. The mirror becomes claimable on HyperEVM once Elysium's challenge period has passed, which is the waiting window for messages leaving an optimistic rollup and lasts about 5.5 days on mainnet. Anyone can claim it, and Kinetiq's bridge shows the transfer as claimable when it is ready. Plan the first mirror mint around that wait. Once the claim lands, read the mirror's supply with the Alchemy CLI:
alchemy evm contract read "$MIRROR" "totalSupply()(uint256)" -n hyperliquid-mainnetThe return trip is faster. Burning the mirror on HyperEVM releases the original on Elysium, typically within a minute.
Integrators who list the mirror should verify it through the factory rather than trusting the address alone. Kinetiq's check pairs two reads. elysiumTokenOf(mirror) on the mirror factory must return the original token, and the mirror's supply must be above zero, which a mismatched mirror can never reach.
How do you list the token on a HyperCore spot order book?
Listing is an issuer ceremony on HyperCore with five parts. You buy a ticker, create the deposit wallet, run genesis, link the token to the wallet, and register the spot pair. Kinetiq's spot deployment guide documents the full ceremony. Only the address that wins the ticker can sign the HyperCore actions, and no allowlist or review sits between buying the ticker and a live order book. In practice the ceremony spans days, because the auction runs on its own schedule.
What does the ticker auction cost?
Tickers are sold in a 31-hour Dutch auction. The price falls linearly toward a floor of 500 HYPE, and each new auction opens at twice the previous sale price, or at the floor if the last auction didn't sell. Hyperliquid's docs ask deployers to rehearse the exact deployment on testnet first, because the auction payment can't be refunded if a deployment gets stuck.
The HyperCore actions below use the Hyperliquid Python SDK and sign with the same Foundry keystore as the EVM transactions:
import getpass
import json
import pathlib
import eth_account
from hyperliquid.exchange import Exchange
from hyperliquid.info import Info
from hyperliquid.utils import constants
from hyperliquid.utils.signing import get_timestamp_ms, sign_l1_action
keystore = json.loads(pathlib.Path("~/.foundry/keystores/deployer").expanduser().read_text())
deployer = eth_account.Account.from_key(
eth_account.Account.decrypt(keystore, getpass.getpass("Keystore password: "))
)
exchange = Exchange(deployer, base_url=constants.MAINNET_API_URL)
info = Info(constants.MAINNET_API_URL, skip_ws=True)
def ok(response):
if response.get("status") != "ok":
raise RuntimeError(response)
return response
auction = info.post("/info", {"type": "spotDeployState", "user": deployer.address})["gasAuction"]
print("Current ticker price in HYPE:", auction["currentGas"])Our HyperCore Data API, now in early access, serves the same auction state.
When the price is acceptable, buy the ticker. This call fixes the HyperCore decimal spec for good. The example uses 8 wei decimals and 2 size decimals, which meets HyperCore's rule that wei decimals be at least size decimals plus 5. The bid ceiling is in HyperCore units, where HYPE has 8 decimals:
MAX_GAS = 600 * 10**8 # refuse to pay more than 600 HYPE
result = ok(exchange.spot_deploy_register_token("EXMPL", 2, 8, MAX_GAS, "Example Token"))
TOKEN_INDEX = result["response"]["data"]
print("Ticker index:", TOKEN_INDEX)How do the deposit wallet, genesis, and link fit together?
Create the deposit wallet on HyperEVM while the ticker is still unlinked. The last argument is the address that will sign the link, which the wallet writes into the storage slot HyperCore checks:
export DEPOSIT_WALLET_FACTORY=0x9aD2639eB48FD7dd0f6F310F04aF5A9f7937cf6c # HyperCoreDepositFactory, on HyperEVM
export TOKEN_INDEX=<ticker index from the purchase>
cast send "$DEPOSIT_WALLET_FACTORY" "createWallet(address,uint64,address)" "$MIRROR" "$TOKEN_INDEX" "$DEPLOYER" \
--rpc-url "$HYPEREVM_RPC" --account deployer
cast call "$DEPOSIT_WALLET_FACTORY" "walletFor(address,uint64,address)(address)" "$MIRROR" "$TOKEN_INDEX" "$DEPLOYER" \
--rpc-url "$HYPEREVM_RPC"Genesis creates the token's entire HyperCore supply. For a bridged token, all of it goes to the token's system address, a reserved HyperCore address made of 0x20 followed by the ticker index. Supply leaves the system address only when someone deposits mirror tokens into escrow, so HyperCore's circulating supply always matches what the deposit wallet holds. Genesis is one-shot. A bridged token also turns off Hyperliquidity, the HIP-2 strategy that seeds a new book with protocol-run orders:
MAX_SUPPLY_WEI = str(1_000_000_000 * 10**8) # one billion tokens at 8 HyperCore decimals
SYSTEM_ADDRESS = "0x20" + format(TOKEN_INDEX, "038x") # 0x20, then the index in the remaining 19 bytes
ok(exchange.spot_deploy_user_genesis(TOKEN_INDEX, [(SYSTEM_ADDRESS, MAX_SUPPLY_WEI)], []))
ok(exchange.spot_deploy_genesis(TOKEN_INDEX, MAX_SUPPLY_WEI, True)) # True = no HyperliquidityThe link is two HyperCore actions, a request naming the deposit wallet and a finalize signed by the address stored in it. The decimal offset is the difference between the ERC-20's 18 decimals and the HyperCore token's 8. The SDK has no helper for these actions, so sign and post them directly. The link is permanent:
DEPOSIT_WALLET = "<deposit wallet address from walletFor>"
def submit(action):
nonce = get_timestamp_ms()
signature = sign_l1_action(deployer, action, None, nonce, None, True) # True = mainnet
return ok(exchange.post("/exchange", {
"action": action, "nonce": nonce, "signature": signature, "vaultAddress": None,
}))
submit({"type": "spotDeploy", "requestEvmContract": {
"token": TOKEN_INDEX, "address": DEPOSIT_WALLET.lower(), "evmExtraWeiDecimals": 10,
}})
submit({"type": "finalizeEvmContract", "token": TOKEN_INDEX, "input": "customStorageSlot"})Deposits work from this point, even before the token has an order book.
How do you open the order book?
Registering the spot pair against USDC (token index 0) and then registering Hyperliquidity creates the market. The second call is required even with Hyperliquidity turned off, in which case it places zero orders and only sets the opening price:
pair = ok(exchange.spot_deploy_register_spot(TOKEN_INDEX, 0)) # 0 = USDC
SPOT_INDEX = pair["response"]["data"]
START_PX = 0.01 # opening price in USDC; set it to a real price, not a placeholder
ok(exchange.spot_deploy_register_hyperliquidity(SPOT_INDEX, START_PX, 1, 0, None)) # 0 ordersHolders can now move tokens onto HyperCore. They approve the deposit wallet for the mirror and call deposit with HyperCore spot as the destination. With 18 EVM decimals and 8 on HyperCore, amounts must be a multiple of 10^10 base units, and whole-token amounts always are:
export DEPOSIT_WALLET=<deposit wallet address>
AMOUNT=$(cast to-wei 1000) # 1,000 tokens
cast send "$MIRROR" "approve(address,uint256)" "$DEPOSIT_WALLET" "$AMOUNT" \
--rpc-url "$HYPEREVM_RPC" --account deployer
cast send "$DEPOSIT_WALLET" "deposit(uint256,uint32)" "$AMOUNT" 4294967295 \
--rpc-url "$HYPEREVM_RPC" --account deployer # 4294967295 routes to HyperCore spotHyperCore credits the balance in its next block. Going back is a sendAsset action to the system address, which pays the mirror out of escrow on HyperEVM. With Hyperliquidity off, the new book starts empty. Your team or a market maker has to quote it, using spot asset ID 10000 + SPOT_INDEX for orders.
Can a coding agent run this for you?
Most of the EVM side is scriptable. An agent can deploy the token, set up the mirror, and bridge supply with Foundry, then confirm each step with the Alchemy CLI. Every CLI command takes --json --no-interactive, so the agent can parse the output. If your agent works through skills or MCP instead of a shell, Agent Skills and the Alchemy MCP server cover the same reads. Use -n hyperliquid-mainnet for HyperEVM reads, and point Foundry at your Elysium endpoint for everything on Elysium.
Keep a human signing the HyperCore ceremony. It spends at least 500 HYPE at the auction and fixes decimals, supply, and the link permanently, so an agent should prepare those actions and a person should sign them. A prompt for the EVM side:
Run `alchemy --json --no-interactive agent-prompt` to load the CLI's command contract, then help me launch a token on Elysium mainnet and mirror it to HyperEVM.
Start by asking me for the token name, symbol, and total supply. Do not invent them. Confirm them back before writing any code.
Then:
- Sign everything with my Foundry keystore account `deployer`. If it doesn't exist, stop and tell me to run `cast wallet import`.
- Get my deployer address with `cast wallet address --account deployer`, then check its HYPE balance on Elysium with `cast balance <deployer-address> --rpc-url <my Alchemy Elysium endpoint>` before each transaction, and stop if it can't cover gas.
- Write a fixed-supply ERC-20 with no owner and no mint function, and deploy it with `forge create --rpc-url <my Alchemy Elysium endpoint>`.
- Run the mirror-bridge setup from Kinetiq's docs, taking every contract address from https://elysium.kinetiq.xyz/docs/contract-addresses. Show me each `cast send` command, with the value in HYPE, before running it.
- Verify the mirror with `alchemy evm contract read <mirror> "totalSupply()(uint256)" -n hyperliquid-mainnet`.
Ask before every transaction that spends HYPE. Do not buy a HyperCore ticker or run any HyperCore deploy action. Stop after the mirror and hand me the addresses.Start building on Elysium
Create an app in the Alchemy dashboard, select Elysium, and you have a mainnet RPC and WebSocket endpoint in a few minutes. No contracts, no waitlist, no minimum commitment. Teams building on Elysium can also apply for credits through the Alchemy Elysium credit program. Add Hyperliquid's HyperEVM to the same app for the mirror leg, and request HyperCore early access to stream the order book your token lands on.
Related Overviews
BlockchainNovember 6, 2026
How to trade on Elysium, the Hyperliquid L2
Elysium is Kinetiq's Hyperliquid L2 with 100 ms blocks and HYPE gas. See how it compares to HyperEVM, which apps launch on it, and how to start trading.
TechnicalOctober 20, 2026
Hyperliquid orders vs trades vs fills
On Hyperliquid, orders, trades, and fills are three different records. Here's each HyperCore payload, how they join on oid and tid, and how to reconcile them.
EthereumJuly 28, 2026
Launch a memecoin on Robinhood Chain
Write and deploy a fixed-supply ERC20 on Robinhood Chain mainnet with Foundry and Alchemy RPC, or hand the whole launch to a coding agent with the Alchemy CLI.
Build blockchain magic
Alchemy combines the most powerful web3 developer products and tools with resources, community and legendary support.