1. Why Build a Bot on Hyperliquid EVM
You might ask: “Why not build on existing EVM chains or exchanges?” Here’s why choosing Hyperliquid + EVM is compelling:
Low latency, order-book native execution: Hyperliquid’s HyperCore handles perpetuals and spot order matching on-chain with high speed. The EVM layer (HyperEVM) is tightly integrated.
Unified state: HyperEVM is not a sidechain; it shares consensus with HyperCore, so smart contracts can read from and write to trading primitives seamlessly.
Standard tooling support: HyperEVM supports JSON‑RPC, EIP‑1559, and standard EVM dev tools like Hardhat or Foundry.
Non-custodial automation: Unlike traditional bots tied to exchange APIs, you retain custody, and bots operate via signed transactions. Coinrule supports this model on Hyperliquid.
Better integration for hybrid strategies: Suppose you build a DeFi contract (e.g., lending, LP, vault) and want your bot to interact with it, read price data, or act on order book state—it’s much easier under HyperEVM than cross-chain.
In short, building on Hyperliquid EVM gives you both trading performance and contract flexibility.
2. Architecture Overview: HyperCore + HyperEVM
To build a bot effectively, you need to understand the dual architecture of Hyperliquid:
HyperCore
This is the trading engine. All order book logic, margin, perpetuals, spot matching, liquidations, funding, etc., live here.
Users interact with HyperCore via signed “actions” (not normal RPC calls).
HyperCore is optimized for speed, including very high orders per second and low-latency processing.
HyperEVM
The Ethereum-compatible environment is layered on top. Smart contracts you deploy run here.
Crucially, HyperEVM can access HyperCore state via precompiles / read/write system calls, so contracts can query order books, margins, or issue trades.
It uses standard JSON‑RPC; you can use existing tooling (ethers, web3, Hardhat) with minimal adaptation.
Unique twist: Unlike many EVM chains, both base fees and priority fees are burned in HyperEVM’s design.
Chain ID is 999 on mainnet. RPC endpoint: https://rpc.hyperliquid.xyz/evm
Dual Block / Execution
Hyperliquid uses a dual block architecture: small blocks for frequent transactions, larger blocks for heavier ones (e.g., contract deployments).
Bots must sometimes choose whether their transaction is in a small-block or large-block context.
Understanding this architecture lets you build bots that interact smartly across both the trading engine (HyperCore) and the contract environment (HyperEVM).
3. Prerequisites & Tooling
Before you code, set up:
- A development environment with Node.js or Python (or your preferred language)
- Ethereum tooling: ethers.js, Hardhat or Foundry
- Wallet (MetaMask, Rabby, etc.) with some HYPE and USDC or collateral to trade
- Access to RPC endpoints (e.g., via QuickNode, Alchemy, or public Hyperliquid RPC)
- Understanding of Hyperliquid’s API and “action” format for trading (see Hyperliquid Docs)
For integrating Coinrule’s limits.trade, you should have a Coinrule account configured with Hyperliquid perps. Coinrule’s help docs show how to connect (signing the builder fee and enabling on-chain trading).
If possible, use a testnet version of Hyperliquid EVM first (chain ID 998) to prototype before going to mainnet.
4. Step 1: Choose Strategy & Bot Logic
Deciding on your strategy is crucial. Some categories:
- Breakout / Momentum: Enter when price breaks key levels with volume
- Range / Mean Reversion: Buy near support, sell near resistance repeatedly
- Scalping: Small profit per trade with high frequency
- Liquidity Sweep / Sniping: Jump into price pockets or liquidity gaps
- Contract-Driven / Hedging: React to DeFi or protocol-based signals
For each, define:
- Entry conditions (price, volume, indicators, book depth)
- Risk parameters (max drawdown, position size)
- Exit logic (take profit, stop loss, trailing stop)
- Replacement logic (for limits that don’t fill)
Since we’ll integrate Coinrule’s limits.trade, your strategy should be limit-based (not pure market order) so you can exploit maker advantage and slippage control.
5. Step 2: Environment Setup
a) Create a project
mkdir hyperliquid-bot
cd hyperliquid-bot
npm init -y
npm install ethers @nktkas/hyperliquid # or whichever SDK
b) Configure RPC
const { ethers } = require("ethers");
const rpc = "https://rpc.hyperliquid.xyz/evm";
const provider = new ethers.JsonRpcProvider(rpc);
c) Wallet
Use a wallet instance to sign both EVM transactions and HyperCore actions:
const privateKey = process.env.PRIVATE_KEY;
const wallet = new ethers.Wallet(privateKey, provider);
d) Hyperliquid SDK / API client
Use a Hyperliquid SDK or raw HTTP/REST + action signing. Many community SDKs exist (e.g. @nktkas/hyperliquid), listed in AwesomeHyperEVM.
const hl = require("@nktkas/hyperliquid");
const transport = new hl.HttpTransport();
const exchange = new hl.ExchangeClient({ transport, wallet });
const info = new hl.InfoClient({ transport });
You can query market/context:
const metaCtx = await info.metaAndAssetCtxs();
6. Step 3: Interacting with Hyperliquid via APIs / JSON‑RPC
You will need two types of interactions:
HyperEVM interactions (smart contract/logic)
Sending standard EVM transactions (e.g., reading price data, contract logic)
Deploying contracts or reading state
HyperCore actions (trading, orderbook operations)
Placing orders, canceling, modifying, querying trade state
These use “signed action” rather than standard EVM calls; you must sign with typed data (signTypedData) per Hyperliquid spec.
Use ethers‑v6 signing for EIP‑712 typed actions.
Example for placing an order:
const order = {
a: assetIndex,
b: true, // buy
s: size,
p: price,
r: false,
t: { trigger: { isMarket: false, triggerPx: price } }
};
const response = await exchange.order({ orders: [order], grouping: "na" });
You also query user state, open orders, etc.
7. Step 4: Bot Execution Logic & Order Placement
Here's a simplified pseudocode loop:
while (true) {
const ctx = await info.metaAndAssetCtxs();
const price = ctx[1][assetIndex].markPx;
if (shouldEnter(price, ctx)) {
await exchange.order({ orders: [buildLimitOrder(priceTarget)], grouping: "na" });
}
// Optional: fetch open orders, cancel/replace stale ones
await sleep(intervalMs);
}
Key points:
Use small delay loops (e.g., 500ms or 1s) for responsiveness
Monitor open orders and cancel if stale or price diverges
Use replace logic (if the market moved too far) rather than letting limit orders hang
Add exit logic checks concurrently
But this doesn’t yet incorporate the limits.trade smart logic — that’s next.
8. Step 5: Integrating Coinrule’s limits.trade Logic
Now we combine the bot logic with Coinrule’s automation module. The idea: use limits.trade semantics (maker-only, chase/replace buffer) as your core order mechanism.
a) Connect Hyperliquid in Coinrule
As per Coinrule’s help docs:
Go to “Connect Exchanges” → select Hyperliquid Perps
Approve two wallet signatures (permission and builder fee)
No API keys needed — Coinrule will handle trades via signed smart contract calls.
b) Define rules in Coinrule using limits.trade
In Coinrule’s UI, you design:
Trigger condition: e.g. IF price > X AND volume > Y
Then: Place order using limits.trade (not a simple limit)
Set chase threshold (e.g. ±0.3–0.5%)
Exit logic: stop loss, take profit
Every time your rule fires, Coinrule will enact your order via limits.trade logic — which means a maker limit with adaptive re-placement until filled.
c) Bot vs Rule roles
You have two possible roles:
Bot approach: Your custom bot interacts directly with Hyperliquid. limits.trade is only similar logic you emulate in your bot.
Hybrid approach: Use Coinrule as the execution layer (limits.trade) and your code purely for signal logic. Your code triggers Coinrule rules via webhook or API when conditions align.
The hybrid model is often safer: you outsource execution (order management, replacements) to Coinrule, and focus your code on strategy signals.
d) Example rule logic in Coinrule
IF markPrice(asset) > 2000 AND volumeLast5m > 1000
THEN Place limits.trade Buy order:
asset = BTC,
size = 0.1,
chaseThreshold = 0.4%
Exit:
Take profit = +5%
Stop loss = −3%
Once this rule is live, Coinrule handles replacements until fill, cancellation if conditions fail, etc.
9. Step 6: Deployment, Monitoring & Maintenance
Deployment
If you built your own bot (not just Coinrule), deploy it on a server (VPS, AWS, etc.)
Ensure high-availability; watch RPC latency
For Coinrule rules, simply enable them — Coinrule platform handles distribution and monitoring
Monitoring
Track open orders vs filled orders
Track how many replacements are triggered
Monitor gas usage, transaction latency
Log exceptions (e.g. RPC errors)
Use fallbacks or kill switches if the bot misbehaves
Maintenance & Iteration
Periodically revisit thresholds and buffers based on live performance
Use testnet or small capital for experimentation
Adjust logic to avoid over-trading or costly replacements
As HyperEVM evolves (new features, throughput improvements), upgrade your logic and rules
10. Risks, Pitfalls & Best Practices
Risks / Pitfalls
- Over‑chasing: If your replacement threshold is too tight, you constantly cancel and reissue, burning gas.
- Liquidity gaps: If your target perp has low depth, your limit orders may never fill.
- RPC / latency failures: If your node lags or is congested, your replacement orders may arrive late.
- Contract bugs: Mistakes in bot or contract logic could cause runaway orders or losses.
- Chain changes / upgrades: Hyperliquid is still evolving; features (like write system contracts) might not be fully live.
Best Practices
- Start with conservative parameters (wider chase buffer, slower loops)
- Cap the number of replacements per order
- Monitor and alert on anomalies
- Use multiple RPC endpoints (redundancy)
- Simulate/backtest thoroughly
- Keep separation of signal logic and execution logic (for modular safety)
Conclusion & Next Steps
Building a trading bot on Hyperliquid EVM represents a powerful paradigm shift: you combine the speed and liquidity of a trading-native chain with the flexibility of smart contracts. Integrating Coinrule’s limits.trade logic enables execution discipline (maker-only, adaptive replacements, slippage control) without surrendering custody or building from scratch.
Start building your strategy with Coinrule now
Рубрика: Статьи. Читать весь текст на obukhov.kyiv.ua.