Hyperliquid: The Engine Powering DeFi's Fastest Exchange

Origins and Founding

Hyperliquid is a decentralized exchange built on its own Layer-1, created to match centralized-exchange performance while keeping trades and funds fully on-chain. It was founded by Jeff Yan and a team with backgrounds in high-frequency trading, who ran a crypto market-making firm before growing frustrated with the inefficiencies of existing DeFi venues. FTX's 2022 collapse reinforced the case for trustless infrastructure — existing L2s couldn't hit the throughput needed for a fully on-chain order book, so the team built a custom L1 instead.

Architecture: HyperCore + HyperEVM

Hyperliquid's chain is really two tightly-coupled parts sharing one state and one consensus (HyperBFT, a Proof-of-Stake protocol derived from HotStuff): HyperCore, the order book engine, and HyperEVM, an Ethereum-compatible execution layer. Because they're the same chain, not separate networks, there's no bridge between the exchange layer and the smart contract layer.

HyperCore: the trading engine

HyperCore processes every order, cancel, trade, and liquidation on-chain — there's no off-chain matching engine.

HyperEVM: the smart contract layer

HyperEVM runs standard Solidity/Vyper contracts with the usual Ethereum tooling (Hardhat, Foundry, ethers.js) and JSON-RPC — add it to MetaMask with chain ID 999, gas paid in HYPE. Its one structural twist is a dual-block design that decouples confirmation latency from block size:

That gives two very different sustained gas budgets:

A dApp can flip a flag to deploy on a slow block, then switch back to fast blocks for everyday calls.

Reading HyperCore from EVM: precompiles

HyperEVM exposes read-only HyperCore state through precompiled contracts at reserved addresses, callable via staticcall from within the same transaction — no oracle, no off-chain fetch:

Hyperliquid's L1Read.sol wraps these in human-readable functions. From TypeScript, reading a live oracle price looks like any other view call:

import { Contract, JsonRpcProvider, formatUnits } from 'ethers';

const L1_READ_ADDRESS = '0x0000000000000000000000000000000000000807';
const abi = ['function oraclePx(uint32 index) view returns (uint64)'];

const provider = new JsonRpcProvider('https://rpc.hyperliquid.xyz/evm');
const l1Read = new Contract(L1_READ_ADDRESS, abi, provider);

// HyperCore prices are fixed-point — check the asset's decimals before formatting,
// the same way you'd check ERC-20 decimals (see "Mastering EVM Numbers in TypeScript").
const rawPrice: bigint = await l1Read.oraclePx(0); // e.g. BTC-PERP
console.log(formatUnits(rawPrice, 6));

A lending protocol can call this in the same transaction it checks collateral, with no oracle-latency window between price and decision.

Writing to HyperCore: CoreWriter

Contracts (and users) send HyperCore actions — place an order, transfer funds, trigger a liquidation — by calling a fixed system contract, which emits a log that HyperCore interprets as an action:

const CORE_WRITER_ADDRESS = '0x3333333333333333333333333333333333333333';

Matching/clearing still runs in HyperCore's native code — the EVM side only requests the action. CoreWriter went live on mainnet on July 5, 2025, unlocking atomic on-chain trading: arbitrage bots, automated liquidations, and full DeFi protocols that read a price and act on it in one transaction.

Moving assets between layers

Core and EVM aren't bridged — they're two views of the same balance. A Core spot asset gets linked to an ERC-20 on HyperEVM via a two-step, deployer-driven process (requestEvmContract, then finalizeEvmContract), after which supply is conserved across both representations:

Sending a Core asset to its system address (0x20…) mints the ERC-20 side; sending the ERC-20 back to that address burns it and credits the Core balance — both applied within the same or next block, no external bridge involved. HYPE itself skips the ERC-20 wrapper entirely and is treated as EVM-native currency. Hyperliquid doesn't enforce ERC-20 correctness or supply consistency automatically during linking, so that part is on the deployer to get right.

Building on Hyperliquid

If you know Solidity and TypeScript, the entry cost is low — HyperEVM is a standard EVM chain. The learning curve is entirely in Hyperliquid-specific extensions, not in the base programming model:

Because contracts can read live prices and hit the order book atomically, the interesting DeFi patterns are the ones that need synchronous price + execution:

General-purpose dApps (NFTs, games, social) work fine too, but the ecosystem — liquidity, users, tooling, oracles beyond Hyperliquid's own markets — is currently DeFi-heavy. As of mid-2025, HyperEVM had roughly $2B TVL and 175+ teams building on it, so tooling gaps are closing quickly but aren't gone.

Bottom line: the hard part isn't Solidity or TypeScript, it's the paradigm — order books, precompiles, and dual-blocks as first-class primitives instead of things you bolt on. Once that clicks, you're deploying on a chain with CEX-level speed and Ethereum-level composability in the same transaction.