Hyperliquid - Ultra-Fast Layer 1 with EVM Support

HyperLiquid RPC
With Dwellir, you get access to our global HyperLiquid network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

Get your API key →

Why Build on Hyperliquid?#

Hyperliquid is a high-performance Layer 1 blockchain purpose-built for decentralized trading, offering both EVM compatibility through HyperEVM and specialized L1 features through gRPC streaming.

🚀 Blazing Fast Performance#

Sub-second finality - Near-instant transaction confirmations
200,000 orders/second - Unprecedented throughput for DeFi
Predictable low fees - Stable and minimal transaction costs

🛠️ Dual API Architecture#

HyperEVM - Full EVM compatibility for Solidity smart contracts
L1 gRPC Streaming - Real-time order books and market data
Native Trading Primitives - Built-in support for spot and perpetuals

📊 Trading-Optimized Infrastructure#

Fully on-chain order books - No off-chain components
HyperBFT consensus - Optimized for trading performance
Real-time market data - Stream fills, trades, and order updates

Quick Start with Hyperliquid#

Hyperliquid is available through Dwellir's dedicated nodes, offering both HyperEVM JSON-RPC and L1 gRPC streaming:

Installation & Setup#

Ethers.js (HyperEVM)
gRPC (L1 Streaming)

import { JsonRpcProvider } from 'ethers';

// Connect to HyperEVM via dedicated node
const provider = new JsonRpcProvider(
  'https://YOUR_DEDICATED_NODE.hyperliquid.dwellir.com/YOUR_API_KEY'
);

// Deploy and interact with Solidity contracts
const contract = new Contract(address, abi, provider);
const result = await contract.someMethod();

import (
    "context"
    pb "your-project/hyperliquid_l1_gateway/v1"
    "google.golang.org/grpc"
)

// Connect to L1 Gateway for streaming
conn, err := grpc.Dial(
    "YOUR_DEDICATED_NODE.hyperliquid.dwellir.com:443",
    grpc.WithInsecure(),
)

client := pb.NewHyperliquidL1GatewayClient(conn)

// Get order book snapshot
response, err := client.GetOrderBookSnapshot(
    context.Background(),
    &pb.Timestamp{Timestamp: 0},
)

Network Information#

Chain ID

998

Mainnet

Block Time

< 1 second

Sub-second finality

Gas Token

HYPE

Native token

Consensus

HyperBFT

Trading-optimized

HyperEVM JSON-RPC API#

HyperEVM provides full Ethereum compatibility, supporting all standard JSON-RPC methods for smart contract deployment and interaction.

Available gRPC Methods

HyperLiquid L1 Gateway gRPC API

Real-time streaming methods for trading data

GetOrderBookSnapshot

Get single order book snapshot at timestamp

StreamBlocks

Stream blocks starting from timestamp

StreamBlockTrades

Stream block trades starting from timestamp

StreamBlockFills

Stream block fills for executed orders

Ready to integrate HyperLiquid into your trading application?

Get your API key →

EVM Integration Examples#

Deploy Contracts
Query Data

// Deploy custom trading logic on HyperEVM
contract TradingStrategy {
    function executeTrade(
        address tokenA,
        address tokenB,
        uint256 amount
    ) external {
        // Your trading logic here
        // Access Hyperliquid's native features
    }
}

// Read contract state and market data
const provider = new JsonRpcProvider(HYPERLIQUID_RPC);

// Get current block with trading data
const block = await provider.getBlock('latest');
console.log('Block trades:', block.transactions);

// Query contract for positions
const positions = await contract.getPositions(trader);

L1 gRPC Streaming API#

Access Hyperliquid's native Layer 1 features through our specialized gRPC interface:

📖 View Complete gRPC Reference →

Available gRPC Streams#

Order Book Snapshots - Full depth market data
Block Streaming - Real-time block updates
Trade Streams - Live trade execution data
Fill Streams - Order fill notifications

Quick gRPC Example#

Go
Python

import (
    "context"
    pb "your-project/hyperliquid_l1_gateway/v1"
    "google.golang.org/grpc"
)

// Connect to L1 Gateway for streaming
conn, err := grpc.Dial(
    "YOUR_DEDICATED_NODE.hyperliquid.dwellir.com:443",
    grpc.WithInsecure(),
)

client := pb.NewHyperliquidL1GatewayClient(conn)

// Get order book snapshot
response, err := client.GetOrderBookSnapshot(
    context.Background(),
    &pb.Timestamp{Timestamp: 0},
)

import grpc
import json
from hyperliquid_l1_gateway_pb2 import Timestamp
from hyperliquid_l1_gateway_pb2_grpc import HyperliquidL1GatewayStub

# Create gRPC channel
channel = grpc.insecure_channel(
    'YOUR_DEDICATED_NODE.hyperliquid.dwellir.com:443'
)
stub = HyperliquidL1GatewayStub(channel)

# Get order book snapshot
timestamp = Timestamp(timestamp=0)
response = stub.GetOrderBookSnapshot(timestamp)
data = json.loads(response.data)
print(f"Order book snapshot: {data}")

Common Integration Patterns#

🤖 Algorithmic Trading#

Combine HyperEVM smart contracts with L1 streaming for sophisticated trading:

// Deploy strategy contract via HyperEVM
const strategy = await deployContract(strategyABI, strategyBytecode);

// Stream blocks via gRPC for trading data
const blockStream = grpcClient.StreamBlocks();
blockStream.on('data', async (block) => {
  const signal = analyzeBlockData(block);
  if (signal.shouldTrade) {
    await strategy.executeTrade(signal.params);
  }
});

📊 Market Making#

Provide liquidity using real-time data:

# Monitor block data via gRPC
for block in stub.StreamBlocks(timestamp):
    data = analyze_block(block)
    if data.spread > target_spread:
        # Place orders via HyperEVM
        place_limit_orders(provider, spread)

📈 DeFi Composability#

Build complex DeFi applications:

// Leverage Hyperliquid's native features
contract YieldVault {
    function harvestAndCompound() external {
        // Access perpetuals for hedging
        // Use spot for liquidity
        // Compound yields automatically
    }
}

Use Cases#

🤖 Perpetuals Trading#

Leverage Hyperliquid's native perpetuals with up to 50x leverage, fully on-chain order books, and sub-second execution.

💱 Spot Trading#

Access deep liquidity for spot markets with minimal slippage and predictable fees.

📊 Market Making#

Provide liquidity using HyperEVM smart contracts combined with L1 streaming for optimal spreads.

🔄 Cross-Chain Arbitrage#

Build bridges and arbitrage bots leveraging Hyperliquid's speed advantage over other chains.

Resources & Support#

Developer Resources#

HyperEVM JSON-RPC - Full Ethereum-compatible RPC interface
L1 gRPC API Reference - Streaming API documentation
Proto Files - Available upon request for gRPC integration
Testing Tools - 16MB Go binary for stream verification

API Access#

Dedicated Nodes - Contact support@dwellir.com for setup
Custom Endpoints - Isolated infrastructure for your application
Uncapped Throughput - No rate limits on dedicated nodes

Need Help?#

📧 Email: support@dwellir.com
📚 HyperEVM Docs: Standard Ethereum JSON-RPC methods
📖 L1 Streaming: gRPC API Reference
🎯 Dashboard: dashboard.dwellir.com

Build on Hyperliquid with Dwellir's dedicated nodes - combining HyperEVM smart contracts with L1 streaming data. Request Access →