# Bloxwap — full documentation > The easiest way to trade. Bloxwap is a mobile-first, non-custodial trading app for crypto perpetual futures and 24/7 tokenized stocks — a one-tap front-end on Hyperliquid, a decentralized perpetuals exchange. You trade from your own embedded wallet, fund with Cash App, Bitcoin, or an on-ramp, and every position settles on-chain on Hyperliquid; Bloxwap never holds your funds. This file concatenates the full text of the Bloxwap documentation, guides, Season 01 rules, and blog. The terse index is at https://bloxwap.app/llms.txt. Platform: Bloxwap is a native iOS and Android app in early access. iOS is distributed through TestFlight and Android through Google Play closed testing. There is no public unrestricted App Store or Play Store listing. If you cannot join the test, join the waitlist at https://bloxwap.com/. Availability: Eligibility limits still apply. Restricted jurisdictions stay blocked. See https://bloxwap.com/docs/faq#availability and https://bloxwap.com/docs/terms#restricted-jurisdictions. A store test or the waitlist does not override those rules. --- # Bloxwap API > Public REST reads need no key; MCP authentication depends on the tool. Bloxwap publishes a small public REST API describing its markets, its token and its treasury. Every REST operation is a GET that needs no key, no token and no account, so an agent can call all of it directly. - MCP server (Model Context Protocol, Streamable HTTP): https://bloxwap.app/mcp — 16 tools: - Public (8; no authentication): search_docs, get_doc, quote_fees (address-based Genesis verification), list_markets, get_market_prices, get_candles, get_trend_signals, get_swing_signals. - Account reads (3; verified Privy session and controlled address required, arbitrary API keys do not authenticate): get_account_summary, get_positions (includes funding since open), get_orders (open orders only). - Write schemas (5; execution currently unavailable): market_long, market_short, set_stop_loss, close_position, adjust_leverage. - OpenAPI 3.1 specification: https://bloxwap.app/openapi.json - Developer overview: https://bloxwap.app/developers - Versioning and deprecation policy: https://bloxwap.app/developers/deprecation Integrate against https://bloxwap.app/api/v1/. MCP trade execution is currently unavailable. Bloxwap is non-custodial: positions are signed by the user's own embedded wallet and settle on Hyperliquid. Never share wallet secrets with MCP. To trade programmatically, talk to Hyperliquid directly. --- # Markets > Available markets and maximum leverage, grouped by asset class. Source: https://bloxwap.com/docs/assets Leverage limits are set by Hyperliquid and may change. Check the market in the app before opening a position. ## Crypto ## Commodities ## Stocks ## Indices ## Pre-IPO ## Papertrade markets Where available, Bloxwap also offers Bitcoin and Ethereum markets on [Papertrade](https://papertrade.xyz), a third-party venue on HyperEVM. **Papertrade markets trade real USDC.** They are not Demo mode, which is Bloxwap's practice trading with virtual funds. | Market | Tracks | Max leverage | Minimum | | ------ | ------------- | ------------ | ---------------------------- | | pt-BTC | Bitcoin (BTC) | 1000× | $10 margin and $500 position | | pt-ETH | Ether (ETH) | 1000× | $10 margin and $500 position | - **Counterparty:** every trade settles against Papertrade's liquidity pool (the LP) at Hyperliquid's best bid and offer midpoint. There is no order book and no funding. - **Leverage:** Bloxwap offers 10×, 50×, 100×, 250×, 500×, and 1000×, starting at 100×. Papertrade sets the cap, and a lower cap removes the top steps. - **Isolated margin:** each position has its own margin. A position is liquidated about 5 bps before its equity reaches zero and loses all of its margin. - **Costs:** winning closes pay a deadband, an impact haircut, and a 2% fee; see [Fees](/docs/fees#papertrade-markets). - **Availability:** mainnet only. Papertrade can pause a market, take it close-only, or queue payouts while its pool is short of funds. Its contracts are upgradeable after a 7-day timelock. - **Where to find them:** open the market list and pick Bitcoin or Ethereum under **Papertrade**, the section after Pre-IPO. Their icons carry the leverage cap. Papertrade is a third-party venue with its own risks; read the [Terms](/docs/terms) before trading it. --- # Cluster > Six Mac minis. Two printed rows. One compact Bloxwap cluster. Source: https://bloxwap.com/docs/cluster The Bloxwap cluster brings six Apple M6 Mac minis together in a DeskPi RackMate T1/2 Plus. Two 3D-printed mounts from Print3DSteve hold three computers each, with short power cords and rack accessories to keep the build organized. ## Parts list **This build requires purchases from both Amazon and Etsy.** Order the computers, rack, panels, power strip, and power cords from the Amazon section, plus two printed Mac mini mounts from the Etsy section. Amazon links include our `bloxwap-20` referral tag. As an Amazon Associate, Bloxwap earns from qualifying purchases. ## How it fits together Each Mac mini measures **127 × 127 × 50 mm**, according to [Apple’s specifications](https://www.apple.com/mac-mini/specs/). The explorer uses Apple’s detailed enclosure model, with its aluminum finish, ports, and vented base. Each printed row occupies 3U. Two rows fill the 6U front of the rack, with three Mac minis standing vertically in each row. The [Print3DSteve listing](https://www.etsy.com/listing/1867907942/mac-mini-m4-2024-x3-10in-mini-rack-3u) describes the mount and supported Mac mini enclosures. The [DeskPi rack specifications](https://wiki.deskpi.com/rackmate/rackmate-t1-2-plus/) give an outer size of 281 × 260 × 330 mm, or 363 mm tall with handles. The rear uses the full 6U, arranged from top to bottom: | Rear position | Component | Height | | --- | --- | --- | | U5–U6 | Vented grid panel | 2U | | U3–U4 | Vented grid panel | 2U | | U2 | ElecVoztile eight-outlet power strip | 1U | | U1 | Brush cable-entry panel | 1U | The ElecVoztile PDU has eight short outlet leads facing into the rack. Six connect through the 0.3 m Goalfish power cords to the figure-eight inlet on the back of each Mac mini; the other two outlet leads remain free. The PDU’s switch faces outward at the rear, and its input cable passes through the brush panel below. Its Amazon link and specifications are included in the Amazon parts list above. The PDU is rated **125 V / 15 A / 1875 W**, with a 1.8 m, 16 AWG input cord. The model follows its 254 mm mounting width, 208 mm chassis width, and 1U height. Cable bends, chassis depth, and the shortened input lead are illustrative; confirm working clearance on the physical rack. Network hardware, memory and storage configurations, and software deployment details are not specified in this parts list. ## Explore every component Use the explorer at the top of this page to rotate the assembled rack, separate its parts, or inspect each component on its own. You can also [open the dedicated 3D page](/docs/cluster/3d). Hover over the hardware or parts list to identify a component; click to inspect it. Explode removes the rear panels, disconnects the power harness from the Macs, then slides the computers and printed rows forward. Auto rotate pauses while you interact and respects reduced-motion preferences. The Mac mini geometry comes from [Apple’s AR model](/docs/cluster/mac-mini-source.json), scaled to its published dimensions. The printed mounts are modeled from the Etsy photos, including their shaped front openings and open cradles. Mount details and accessory placement are illustrative, not manufacturing CAD or printable files. --- # Cluster in 3D > Take the Bloxwap cluster apart, one component at a time. Source: https://bloxwap.com/docs/cluster/3d [Back to the cluster guide and full parts list](/docs/cluster). The Mac mini uses Apple’s detailed AR geometry at its published 127 × 127 × 50 mm dimensions. The printed cradles are modeled from Print3DSteve’s Etsy photos; the other accessories are simplified illustrations based on the linked listings. The rear is arranged as 2U grid, 2U grid, 1U ElecVoztile PDU, and 1U cable entry. Six power cords connect the PDU outlet leads to the Macs; two PDU leads remain free. Cable bends and the shortened input lead are illustrative. These are not manufacturing dimensions or downloadable print files. --- # Why Bloxwap > How Bloxwap connects a simple trading interface to Hyperliquid. Source: https://bloxwap.com/docs/compare Bloxwap is a mobile-first interface for trading on [Hyperliquid](https://hyperliquid.xyz). Orders execute on Hyperliquid from your wallet. ## How Bloxwap works - **Trade controls.** Choose a market, size, and leverage, then use UP or DOWN to open a long or short. Manage stops and targets from the position controls. - **Embedded wallet.** Sign in with email or a passkey. You can export your wallet keys from Settings. - **Markets.** Trade perpetuals tracking crypto, stocks, commodities, indices, and pre-IPO names. See [Markets](/docs/assets) for available listings and leverage limits. - **Fees.** Each fill carries a Bloxwap builder fee in addition to Hyperliquid's exchange fee. [Genesis](/docs/genesis) reduces the builder fee. See the [fee breakdown](/docs/fees). ## Choosing an interface Hyperliquid is available through its own interface, wallet integrations, and dedicated trading apps. Compare the controls, supported markets, wallet setup, and total fees that matter to you. An interface's features and fees can change even when it uses the same underlying exchange. Start with the [guides](/docs/how-to) or [FAQ](/docs/faq) to learn how Bloxwap works. --- # Developer resources > Build trading agents and integrate with Bloxwap and Hyperliquid. Source: https://bloxwap.com/docs/developers Build trading agents and automated strategies with Bloxwap's SDK and agent tools. These guides cover signing, optimization, permissions, and templates. ## Safety first Always start with testnet. Use position sizing, stop losses, and never trade with funds you can't afford to lose. Review our [agent safety guidelines](/developers/agents#safety-guidelines) before deploying to mainnet. ## Additional resources - [Hyperliquid SDK](/open-source/hyperliquid) — TypeScript client for market data and exchange actions - [MCP server](/developers/agents#mcp) — Model Context Protocol integration for AI agents - [Open source projects](/open-source) — Charts, sounds, fonts, and more --- # Low-latency recipes > Optimize signing performance with WASM secp256k1 and fast local wallets. Source: https://bloxwap.com/docs/developers/low-latency Reduce order latency for high-frequency trading agents with these optimization techniques. ## WASM secp256k1 signing The `@bloxwap/hyperliquid` SDK automatically uses WASM-accelerated crypto when available. The SDK includes optional dependencies for: - `tiny-secp256k1` — WASM secp256k1 signing (3-5x faster than pure JavaScript) - `hash-wasm` — WASM hashing for signature operations These are installed automatically with the SDK. No additional configuration needed. ### Installation ```sh npm install @bloxwap/hyperliquid ``` The SDK will automatically use WASM implementations when available, falling back to JavaScript if WASM is unavailable. ### Verify WASM acceleration Check if WASM modules loaded successfully: ```ts import { HttpTransport, ExchangeClient } from '@bloxwap/hyperliquid'; import { createFastLocalWallet } from '@bloxwap/hyperliquid/signing'; // Create a fast local wallet (automatically uses WASM when available) const wallet = await createFastLocalWallet(privateKey); // Benchmark signing performance const start = performance.now(); const client = new ExchangeClient({ transport: new HttpTransport(), wallet: wallet, }); // Place a test order (testnet recommended) await client.limitOrder({ coin: 'BTC', isBuy: true, sz: 0.001, limitPx: 50000, orderType: { limit: { tif: 'Gtc' } }, }); const elapsed = performance.now() - start; console.log(`Order latency: ${elapsed.toFixed(2)}ms`); ``` Expected latency (local signing only, excludes network): - **With WASM:** 5-15ms for signature generation - **Without WASM:** 20-50ms for signature generation ## Fast local wallets Use `createFastLocalWallet` instead of viem's `privateKeyToAccount` for optimal performance. ```ts import { createFastLocalWallet } from '@bloxwap/hyperliquid/signing'; // ✅ Fast: Direct secp256k1 signing const fastWallet = await createFastLocalWallet(privateKey); // ❌ Slower: JSON-RPC overhead import { privateKeyToAccount } from 'viem/accounts'; const slowWallet = privateKeyToAccount(privateKey); ``` `createFastLocalWallet` signs directly with secp256k1, bypassing viem's JSON-RPC layer. This reduces signature latency by 50-70%. ## Signature warm-up Pre-warm the signing path to eliminate first-signature overhead. ```ts import { warmupSigning } from '@bloxwap/hyperliquid/signing'; const wallet = await createFastLocalWallet(privateKey); // Warm up once at startup await warmupSigning(wallet); // First signature is now fast ``` `warmupSigning` pre-initializes: - WASM modules (if available) - Signature buffers - Crypto contexts This eliminates 50-200ms of cold-start overhead on the first order. ## Connection pooling Reuse HTTP connections for multiple orders. ```ts import { HttpTransport, ExchangeClient } from '@bloxwap/hyperliquid'; // Create one transport for the lifetime of your agent const transport = new HttpTransport({ isTestnet: false, // Optional: custom fetch with connection pooling fetch: customFetch, }); // Reuse transport across orders const client = new ExchangeClient({ transport: transport, wallet: wallet, }); // Place multiple orders without reconnecting for (const order of orders) { await client.limitOrder(order); } ``` ## Batch order placement Place multiple orders in one request when possible. ```ts // ❌ Slower: Multiple HTTP requests for (const order of orders) { await client.limitOrder(order); } // ✅ Faster: Batch request (if SDK supports) // Check SDK documentation for batch order methods ``` ## Network optimization ### Use low-latency hosting - **Co-location:** Host agents in the same AWS region as Hyperliquid's API - **Geographic proximity:** Choose the region closest to Hyperliquid's servers - **Dedicated servers:** Avoid shared hosting for consistent network performance ### DNS caching Pre-resolve DNS to eliminate lookup latency: ```ts import dns from 'node:dns'; // Pre-resolve Hyperliquid API domains at startup dns.resolve('api.hyperliquid.xyz', (err, addresses) => { console.log('Hyperliquid API IPs:', addresses); }); ``` ### HTTP/2 and keep-alive Modern Node.js (20+) enables HTTP/2 by default. Ensure your fetch implementation supports it: ```ts import { fetch } from 'undici'; const transport = new HttpTransport({ fetch: fetch, // undici supports HTTP/2 and connection pooling }); ``` ## Order type optimization Choose order types that minimize latency: ### Limit orders with IOC Immediate-or-cancel orders execute or cancel immediately, reducing state management: ```ts await client.limitOrder({ coin: 'BTC', isBuy: true, sz: 0.1, limitPx: 50000, orderType: { limit: { tif: 'Ioc' } }, // Immediate-or-cancel }); ``` ### Market orders for speed Market orders execute immediately at the best available price: ```ts await client.marketOrder({ coin: 'BTC', isBuy: true, sz: 0.1, slippage: 0.01, // 1% max slippage }); ``` ## Benchmarking Measure and log latency for each component: ```ts async function placeOrderWithBenchmark() { const t0 = performance.now(); // Signing latency const signStart = performance.now(); // ... sign order ... const signEnd = performance.now(); console.log(`Sign: ${(signEnd - signStart).toFixed(2)}ms`); // Network latency const netStart = performance.now(); const response = await client.limitOrder(/* ... */); const netEnd = performance.now(); console.log(`Network: ${(netEnd - netStart).toFixed(2)}ms`); const total = performance.now() - t0; console.log(`Total: ${total.toFixed(2)}ms`); return response; } ``` Track these metrics over time to identify regressions or optimization opportunities. ## Monitoring and alerts Set up alerts for latency degradation: ```ts const LATENCY_THRESHOLD_MS = 100; if (latency > LATENCY_THRESHOLD_MS) { // Alert: Latency spike detected console.warn(`Order latency ${latency}ms exceeds threshold`); // Send to monitoring service (Datadog, Prometheus, etc.) } ``` ## Limitations and trade-offs - **WASM support:** WASM modules require modern runtimes (Node.js 18+, modern browsers) - **Cold starts:** First signature after idle may be slower (use warm-up) - **Memory:** Persistent connections and caches increase memory usage - **Testnet latency:** Testnet may be slower than mainnet; benchmark on mainnet for production estimates ## Next steps - [Agent permissions](/developers/permissions) — Risk management for automated trading - [Agent templates](/developers/templates) — Reference implementations - [Signing flows](/developers/signing) — Wallet integration options --- # Agent permissions > Delegated wallet scopes and risk management for automated trading agents. Source: https://bloxwap.com/docs/developers/permissions Agent wallets enable automated trading without exposing user private keys. This guide covers Hyperliquid's built-in agent system and proposes an additional permission layer for risk management. ## Hyperliquid agent wallets Hyperliquid supports agent wallet delegation at the protocol level. Users can approve an agent address for prompt-free trading. ### Current capabilities Agent approval on Hyperliquid is **binary:** an agent is either fully approved or not approved. Once approved, an agent can: - Place limit and market orders on any listed asset - Modify or cancel orders - Update leverage settings - Close positions **Limitations:** - ❌ No max notional limits - ❌ No leverage restrictions - ❌ No required stop losses - ❌ No per-market permissions - ❌ No time-based restrictions The agent has the same trading permissions as the user wallet that approved it. ### Approve an agent ```ts import { ExchangeClient, HttpTransport } from '@bloxwap/hyperliquid'; import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts'; import { createFastLocalWallet } from '@bloxwap/hyperliquid/signing'; // 1. Generate agent key (do this once, store securely) const agentKey = generatePrivateKey(); const agentAccount = privateKeyToAccount(agentKey); console.log('Agent address:', agentAccount.address); console.log('Agent key (store securely):', agentKey); // 2. User approves the agent const userWallet = /* ... user's wallet ... */; const userClient = new ExchangeClient({ transport: new HttpTransport(), wallet: userWallet, }); await userClient.approveAgent({ agentAddress: agentAccount.address, agentName: 'MyTradingBot', // Optional label for tracking }); // 3. Agent can now trade on behalf of user const agentWallet = await createFastLocalWallet(agentKey); const agentClient = new ExchangeClient({ transport: new HttpTransport(), wallet: agentWallet, }); await agentClient.limitOrder({ coin: 'BTC', isBuy: true, sz: 0.1, limitPx: 50000, orderType: { limit: { tif: 'Gtc' } }, }); ``` ### Revoke an agent Users can revoke agent approval at any time: ```ts await userClient.revokeAgent({ agentAddress: agentAccount.address, }); ``` After revocation, the agent can no longer place new orders or modify existing ones. ### Check agent status Verify if an agent is currently approved: ```ts const agents = await info.agents(userAddress); const isApproved = agents.some( (agent) => agent.address.toLowerCase() === agentAddress.toLowerCase() && agent.validUntil != null && agent.validUntil > Date.now() ); ``` ## Proposed permission layer For agents that need risk controls beyond Hyperliquid's binary approval, implement an application-level permission layer. **Design goals:** 1. Enforce max notional exposure per position 2. Limit leverage multipliers 3. Require stop losses on every position 4. Support per-market allowlists/denylists 5. Time-based trading windows 6. Emergency circuit breakers **Implementation approach:** This layer lives in your application code, not on-chain. The agent checks permissions before submitting orders to Hyperliquid. ### Permission schema ```ts interface AgentPermissions { agentAddress: string; userAddress: string; // Position limits maxNotionalPerPosition?: number; // USD maxTotalNotional?: number; // USD maxLeverage?: number; // e.g., 10x // Required risk controls requireStopLoss: boolean; maxStopLossDistance?: number; // % from entry // Market restrictions allowedMarkets?: string[]; // ['BTC', 'ETH', ...] deniedMarkets?: string[]; // ['MEME', ...] // Time restrictions tradingHours?: { start: string; // HH:mm UTC end: string; // HH:mm UTC days: number[]; // [1,2,3,4,5] = Mon-Fri }; // Circuit breakers maxDailyLoss?: number; // USD maxConsecutiveLosses?: number; // Metadata createdAt: number; expiresAt?: number; enabled: boolean; } ``` ### Permission enforcement Wrap your trading logic with permission checks: ```ts async function placeOrderWithPermissions( permissions: AgentPermissions, order: OrderRequest, ) { // 1. Check if agent is enabled if (!permissions.enabled) { throw new Error('Agent is disabled'); } // 2. Check expiry if (permissions.expiresAt && Date.now() > permissions.expiresAt) { throw new Error('Agent permissions expired'); } // 3. Check market allowlist if (permissions.allowedMarkets && !permissions.allowedMarkets.includes(order.coin)) { throw new Error(`Market ${order.coin} not in allowlist`); } // 4. Check market denylist if (permissions.deniedMarkets && permissions.deniedMarkets.includes(order.coin)) { throw new Error(`Market ${order.coin} is denied`); } // 5. Check notional limit const notional = order.sz * order.limitPx; if (permissions.maxNotionalPerPosition && notional > permissions.maxNotionalPerPosition) { throw new Error( `Notional ${notional} exceeds limit ${permissions.maxNotionalPerPosition}` ); } // 6. Check leverage limit if (permissions.maxLeverage && order.leverage > permissions.maxLeverage) { throw new Error( `Leverage ${order.leverage}x exceeds limit ${permissions.maxLeverage}x` ); } // 7. Check stop loss requirement if (permissions.requireStopLoss && !order.stopLoss) { throw new Error('Stop loss required but not provided'); } // 8. Check trading hours if (permissions.tradingHours && !isWithinTradingHours(permissions.tradingHours)) { throw new Error('Outside allowed trading hours'); } // 9. Check circuit breakers const dailyLoss = await getDailyLoss(permissions.userAddress); if (permissions.maxDailyLoss && dailyLoss >= permissions.maxDailyLoss) { throw new Error('Daily loss limit reached'); } // All checks passed - place order return await client.limitOrder(order); } function isWithinTradingHours(hours: AgentPermissions['tradingHours']): boolean { if (!hours) return true; const now = new Date(); const day = now.getUTCDay(); const time = now.getUTCHours() * 100 + now.getUTCMinutes(); const [startHour, startMin] = hours.start.split(':').map(Number); const [endHour, endMin] = hours.end.split(':').map(Number); const start = startHour * 100 + startMin; const end = endHour * 100 + endMin; return hours.days.includes(day) && time >= start && time <= end; } ``` ### Storage Store permissions in a database, not in code: ```ts // Example with PostgreSQL async function getAgentPermissions( agentAddress: string, userAddress: string, ): Promise { const result = await db.query( `SELECT * FROM agent_permissions WHERE agent_address = $1 AND user_address = $2 AND enabled = true`, [agentAddress, userAddress] ); return result.rows[0] || null; } async function updateAgentPermissions( agentAddress: string, userAddress: string, updates: Partial, ) { await db.query( `UPDATE agent_permissions SET ${Object.keys(updates).map((k, i) => `${k} = $${i + 3}`).join(', ')} WHERE agent_address = $1 AND user_address = $2`, [agentAddress, userAddress, ...Object.values(updates)] ); } ``` ### Circuit breakers Implement automatic safety shutoffs: ```ts async function checkCircuitBreakers( permissions: AgentPermissions, userAddress: string, ) { // 1. Daily loss limit const dailyLoss = await getDailyLoss(userAddress); if (permissions.maxDailyLoss && dailyLoss >= permissions.maxDailyLoss) { await disableAgent(permissions.agentAddress, userAddress); await notifyUser(userAddress, 'Agent disabled: daily loss limit reached'); return false; } // 2. Consecutive losses const losses = await getRecentLosses(userAddress); const consecutive = countConsecutive(losses); if (permissions.maxConsecutiveLosses && consecutive >= permissions.maxConsecutiveLosses) { await disableAgent(permissions.agentAddress, userAddress); await notifyUser(userAddress, `Agent disabled: ${consecutive} consecutive losses`); return false; } return true; } async function disableAgent(agentAddress: string, userAddress: string) { await db.query( `UPDATE agent_permissions SET enabled = false WHERE agent_address = $1 AND user_address = $2`, [agentAddress, userAddress] ); } ``` ## Safety best practices ### Start small - Begin with conservative limits (e.g., max $100 notional) - Gradually increase as the agent proves reliable - Use testnet extensively before mainnet ### Always require stops Never allow naked positions without stop losses: ```ts const permissions: AgentPermissions = { // ... requireStopLoss: true, maxStopLossDistance: 5, // Max 5% stop loss distance }; ``` ### Monitor continuously Track agent performance and alert on anomalies: ```ts setInterval(async () => { const positions = await client.positions(userAddress); const totalNotional = positions.reduce((sum, p) => sum + p.notional, 0); if (totalNotional > permissions.maxTotalNotional * 0.9) { await notifyUser(userAddress, 'Warning: approaching notional limit'); } }, 60_000); // Check every minute ``` ### User control Provide an emergency stop button: ```ts async function emergencyStop(userAddress: string) { // 1. Disable all agents await db.query( `UPDATE agent_permissions SET enabled = false WHERE user_address = $1`, [userAddress] ); // 2. Close all positions (optional) const positions = await client.positions(userAddress); for (const position of positions) { await client.marketClose({ coin: position.coin, sz: position.szi, }); } // 3. Notify user await notifyUser(userAddress, 'Emergency stop activated'); } ``` ## Regulatory considerations If building a permission layer that manages user funds, consult legal counsel. Automated trading services may require: - Money transmitter licenses - Securities dealer registration - Customer account segregation - Audit trails and reporting **This guide provides technical patterns, not legal advice.** ## Next steps - [Signing flows](/developers/signing) — Wallet integration options - [Low-latency recipes](/developers/low-latency) — Performance optimization - [Agent templates](/developers/templates) — Reference implementations --- # Signing flows > Use revocable agent wallets for bots and hardware/software wallet signing for interactive apps. Source: https://bloxwap.com/docs/developers/signing Hyperliquid orders require signatures. Use a dedicated agent (API) wallet for bots and templates, or let users approve each signature in their hardware/software wallet for interactive apps. > Never put your wallet private key, seed phrase, or mnemonic in code, env files, configs, or tool arguments. Bloxwap will never ask for them. ## Dedicated agent wallets for bots Generate a dedicated Hyperliquid agent wallet for your bot, then approve its public address from your own wallet in the Bloxwap app or Hyperliquid's API-wallet page. The agent can trade on your account but cannot withdraw. Revoke its access on the same page at any time. Never use your main wallet key or seed phrase as the agent key. The bot's `HYPERLIQUID_AGENT_KEY` is only the agent wallet's own generated key. `HYPERLIQUID_ACCOUNT_ADDRESS` is your public account address, not the agent address. Store the generated agent key in a secrets manager or local environment file excluded from source control; never log it. Approve a separate agent for each network and rotate it by approving a replacement and revoking the old agent. ```ts import { createFastLocalWallet } from '@bloxwap/hyperliquid/signing'; import { ExchangeClient, HttpTransport } from '@bloxwap/hyperliquid'; // Only the dedicated agent's generated key belongs here. const agentKey = process.env.HYPERLIQUID_AGENT_KEY; const accountAddress = process.env.HYPERLIQUID_ACCOUNT_ADDRESS; if (!agentKey || !/^0x[0-9a-fA-F]{64}$/.test(agentKey)) { throw new Error('HYPERLIQUID_AGENT_KEY must be a generated agent key'); } if (!accountAddress || !/^0x[0-9a-fA-F]{40}$/.test(accountAddress)) { throw new Error('HYPERLIQUID_ACCOUNT_ADDRESS must be your public account address'); } // Approve this agent for accountAddress before running the bot. const agentWallet = await createFastLocalWallet(agentKey as `0x${string}`); const client = new ExchangeClient({ transport: new HttpTransport({ isTestnet: true }), wallet: agentWallet, }); // Hyperliquid resolves the approved user's account from the agent signature. await client.limitOrder({ coin: 'BTC', isBuy: true, sz: 0.1, limitPx: 50000, orderType: { limit: { tif: 'Gtc' } }, }); ``` Public MCP tools work without authentication. For authenticated MCP account reads, send a **verified Privy session token** as `Authorization: Bearer YOUR_VERIFIED_PRIVY_SESSION_TOKEN`; the requested wallet address must be controlled by that Privy user. Privy tokens expire and must be refreshed. Arbitrary API keys and argument-supplied credentials are not accepted, and MCP trade execution is currently unavailable. Never send an agent key or wallet secrets as MCP credentials or tool arguments. ## Agent wallets (session keys) Delegate trading permission from a user wallet to an automated agent without exposing the user's private key. The agent can trade but cannot withdraw, and can be revoked in the Bloxwap app or Hyperliquid's API-wallet page. ```ts import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts'; import { createFastLocalWallet } from '@bloxwap/hyperliquid/signing'; import { ExchangeClient, HttpTransport } from '@bloxwap/hyperliquid'; // 1. Generate an agent key (one-time) const agentKey = generatePrivateKey(); const agentAccount = privateKeyToAccount(agentKey); // 2. User approves the agent (signed by user's wallet) const userWallet = /* ... your user's wallet ... */; const userClient = new ExchangeClient({ transport: new HttpTransport(), wallet: userWallet, }); await userClient.approveAgent({ agentAddress: agentAccount.address, agentName: 'MyTradingBot', // optional label }); // 3. Agent trades on behalf of user const agentWallet = await createFastLocalWallet(agentKey); const agentClient = new ExchangeClient({ transport: new HttpTransport(), wallet: agentWallet, }); // Orders are signed by agent but execute in user's account await agentClient.limitOrder({ coin: 'ETH', isBuy: true, sz: 1.0, limitPx: 3000, orderType: { limit: { tif: 'Gtc' } }, }); // 4. User can revoke agent permission at any time await userClient.revokeAgent({ agentAddress: agentAccount.address, }); ``` ## Hardware wallets For higher-value accounts, integrate hardware wallet signing. Bloxwap uses Ledger for on-chain settlement. ```ts import { createWalletClient, http } from 'viem'; import { arbitrum } from 'viem/chains'; import { ExchangeClient, HttpTransport } from '@bloxwap/hyperliquid'; // Connect to Ledger (requires user interaction) const walletClient = createWalletClient({ chain: arbitrum, transport: http(), }); const [address] = await walletClient.getAddresses(); // Use hardware wallet for signing const client = new ExchangeClient({ transport: new HttpTransport(), wallet: walletClient, }); // Each order requires hardware confirmation await client.limitOrder({ coin: 'SOL', isBuy: true, sz: 10, limitPx: 100, orderType: { limit: { tif: 'Gtc' } }, }); ``` ### Hardware wallet considerations - **Latency:** Each signature requires hardware confirmation (~2-5 seconds) - **User presence:** Hardware wallets require physical button presses - **Not suitable for:** High-frequency trading or fully automated agents - **Best for:** Manual trading with enhanced security, or infrequent rebalancing bots ## Browser wallets Integrate with MetaMask, Privy, or other injected wallets for interactive apps. Users approve each signature in their wallet; never request their wallet key or seed phrase. ```ts import { createWalletClient, custom } from 'viem'; import { arbitrum } from 'viem/chains'; import { ExchangeClient, HttpTransport } from '@bloxwap/hyperliquid'; // Connect to browser wallet (e.g., MetaMask) if (typeof window !== 'undefined' && window.ethereum) { const walletClient = createWalletClient({ chain: arbitrum, transport: custom(window.ethereum), }); await walletClient.requestAddresses(); const [address] = await walletClient.getAddresses(); const client = new ExchangeClient({ transport: new HttpTransport(), wallet: walletClient, }); // User approves each transaction in browser await client.limitOrder({ coin: 'BTC', isBuy: false, sz: 0.05, limitPx: 55000, orderType: { limit: { tif: 'Gtc' } }, }); } ``` ## Testnet vs. mainnet Always test on testnet first. Pass `isTestnet: true` to the transport. ```ts // Testnet const testnetTransport = new HttpTransport({ isTestnet: true }); // Mainnet const mainnetTransport = new HttpTransport({ isTestnet: false }); ``` ## Signature warm-up Pre-warm the signing path to reduce first-signature latency. Useful for agents that trade infrequently. ```ts import { warmupSigning } from '@bloxwap/hyperliquid/signing'; // Use the dedicated agent key loaded above. const wallet = await createFastLocalWallet(agentKey as `0x${string}`); // Warm up the signing path (once at startup) await warmupSigning(wallet); // First signature is now faster ``` ## Next steps - [Low-latency recipes](/developers/low-latency) — Optimize signing performance - [Agent permissions](/developers/permissions) — Risk management and scopes - [Agent templates](/developers/templates) — Reference implementations --- # Agent templates > Reference agent implementations using LangGraph, CrewAI, and custom frameworks. Source: https://bloxwap.com/docs/developers/templates These templates demonstrate automated trading agents that consume market signals and execute orders through Hyperliquid. All examples default to **testnet and dry-run mode** for safety. ## Prerequisites All templates require: ```sh npm install @bloxwap/hyperliquid viem ``` Generate a dedicated Hyperliquid agent (API) wallet for your bot. Approve its public address from your own wallet in the Bloxwap app or Hyperliquid's API-wallet page, on testnet first. The agent can trade but cannot withdraw; revoke it on the same page at any time. See [Signing flows](/developers/signing) for agent key generation and signer setup. > Never put your wallet private key, seed phrase, or mnemonic in code, env files, configs, or tool arguments. Bloxwap will never ask for them. Configure only the agent wallet's own generated key and your public account address. The agent key is never your main wallet key or seed phrase. Store it securely, exclude local env files from source control, and never log it. Interactive apps should instead have users approve each signature in their hardware/software wallet. ```sh # Optional for authenticated MCP account reads; Privy session tokens expire. # MCP header: Authorization: Bearer YOUR_VERIFIED_PRIVY_SESSION_TOKEN export PRIVY_SESSION_TOKEN="YOUR_VERIFIED_PRIVY_SESSION_TOKEN" ``` Public MCP market, signal, documentation, and fee tools work without a key. Authenticated account reads also require a wallet controlled by the verified Privy user. MCP trade execution is currently unavailable; the bot examples below trade through the Hyperliquid SDK with the dedicated agent wallet. Never use the agent key as an MCP credential or tool argument. For the bot: ```sh export HYPERLIQUID_AGENT_KEY="0x..." # Dedicated agent's generated key only export HYPERLIQUID_ACCOUNT_ADDRESS="0x..." # Your public account address export HYPERLIQUID_TESTNET=true ``` ## Custom agent (minimal) A standalone trading agent without dependencies on LangGraph or CrewAI. ```ts import { HttpTransport, ExchangeClient, InfoClient } from '@bloxwap/hyperliquid'; import { createFastLocalWallet } from '@bloxwap/hyperliquid/signing'; interface Signal { coin: string; action: 'buy' | 'sell' | 'close'; confidence: number; // 0-1 reason: string; } class TradingAgent { private client?: ExchangeClient; private ready: Promise; private info: InfoClient; private dryRun: boolean; constructor(agentKey: `0x${string}`, private accountAddress: `0x${string}`, isTestnet = true, dryRun = true) { this.dryRun = dryRun; const transport = new HttpTransport({ isTestnet }); this.info = new InfoClient({ transport }); // Sign only with the dedicated agent approved for accountAddress. this.ready = dryRun ? Promise.resolve() : createFastLocalWallet(agentKey).then(wallet => { this.client = new ExchangeClient({ transport, wallet }); }); } async generateSignal(coin: string): Promise { // Example: Simple momentum signal const mids = await this.info.allMids(); const currentPrice = parseFloat(mids[coin]); // Get historical prices (simplified - use real data in production) const ma20 = await this.getMA(coin, 20); const ma50 = await this.getMA(coin, 50); if (!ma20 || !ma50) return null; // Golden cross if (ma20 > ma50 && currentPrice > ma20) { return { coin, action: 'buy', confidence: 0.7, reason: 'Golden cross: MA20 > MA50 and price > MA20', }; } // Death cross if (ma20 < ma50 && currentPrice < ma20) { return { coin, action: 'sell', confidence: 0.7, reason: 'Death cross: MA20 < MA50 and price < MA20', }; } return null; } async executeSignal(signal: Signal) { console.log(`[${this.dryRun ? 'DRY RUN' : 'LIVE'}] Signal:`, signal); if (this.dryRun) { console.log('Dry run - order not placed'); return; } // Real order execution (requires low confidence threshold for safety) if (signal.confidence < 0.8) { console.log('Confidence too low, skipping'); return; } await this.ready; if (!this.client) throw new Error('Agent signer is not initialized'); const price = await this.getCurrentPrice(signal.coin); const notional = 100; // $100 position size const size = notional / price; if (signal.action === 'buy') { await this.client.limitOrder({ coin: signal.coin, isBuy: true, sz: size, limitPx: price * 1.001, // 0.1% above market orderType: { limit: { tif: 'Ioc' } }, }); } else if (signal.action === 'sell') { await this.client.limitOrder({ coin: signal.coin, isBuy: false, sz: size, limitPx: price * 0.999, // 0.1% below market orderType: { limit: { tif: 'Ioc' } }, }); } } private async getCurrentPrice(coin: string): Promise { const mids = await this.info.allMids(); return parseFloat(mids[coin]); } private async getMA(coin: string, periods: number): Promise { // Implement using historical data source // This is a placeholder return null; } async run() { const markets = ['BTC', 'ETH', 'SOL']; console.log(`Starting agent (${this.dryRun ? 'DRY RUN' : 'LIVE MODE'})`); console.log('Account:', this.accountAddress); console.log('Press Ctrl+C to stop'); setInterval(async () => { for (const market of markets) { try { const signal = await this.generateSignal(market); if (signal) { await this.executeSignal(signal); } } catch (error) { console.error(`Error processing ${market}:`, error); } } }, 60_000); // Check every minute } } // Validate the dedicated agent key and public account address. const agentKey = process.env.HYPERLIQUID_AGENT_KEY; const accountAddress = process.env.HYPERLIQUID_ACCOUNT_ADDRESS; if (!agentKey || !/^0x[0-9a-fA-F]{64}$/.test(agentKey)) { throw new Error('HYPERLIQUID_AGENT_KEY must be a generated agent key'); } if (!accountAddress || !/^0x[0-9a-fA-F]{40}$/.test(accountAddress)) { throw new Error('HYPERLIQUID_ACCOUNT_ADDRESS must be your public account address'); } // Run in dry-run mode by default. Approval links the agent to the user's account. const agent = new TradingAgent( agentKey as `0x${string}`, accountAddress as `0x${string}`, process.env.HYPERLIQUID_TESTNET !== 'false', process.env.DRY_RUN !== 'false', // Defaults to true ); agent.run(); ``` ## LangGraph agent Use LangGraph for complex decision-making workflows. First, install dependencies: ```sh npm install @langchain/core @langchain/openai langgraph ``` ```ts import { StateGraph, END, Annotation } from "@langchain/langgraph"; import { ChatOpenAI } from "@langchain/openai"; import { HttpTransport, InfoClient } from '@bloxwap/hyperliquid'; // Define agent state const AgentState = Annotation.Root({ market: Annotation, price: Annotation, signal: Annotation<'buy' | 'sell' | 'hold' | null>, confidence: Annotation, reasoning: Annotation, dryRun: Annotation, }); // Node: Fetch market data async function fetchMarketData(state: typeof AgentState.State) { const transport = new HttpTransport({ isTestnet: process.env.HYPERLIQUID_TESTNET === 'true' }); const info = new InfoClient({ transport }); const mids = await info.allMids(); const price = parseFloat(mids[state.market]); return { price }; } // Node: Analyze with LLM async function analyzeMarket(state: typeof AgentState.State) { const llm = new ChatOpenAI({ modelName: "gpt-4", temperature: 0.7, }); const prompt = ` Analyze the following market data and provide a trading signal. Market: ${state.market} Current Price: $${state.price} Respond in JSON format: { "signal": "buy" | "sell" | "hold", "confidence": 0.0-1.0, "reasoning": "Brief explanation" } `; const response = await llm.invoke(prompt); const analysis = JSON.parse(response.content as string); return { signal: analysis.signal, confidence: analysis.confidence, reasoning: analysis.reasoning, }; } // Node: Execute trade (or log in dry-run) async function executeTrade(state: typeof AgentState.State) { if (state.dryRun) { console.log('[DRY RUN] Would execute:', { market: state.market, signal: state.signal, confidence: state.confidence, reasoning: state.reasoning, }); return {}; } // Real execution (requires additional setup) if (state.confidence > 0.8 && state.signal !== 'hold') { // Place order via Hyperliquid console.log('Executing live trade:', state.signal, state.market); } return {}; } // Build the graph const workflow = new StateGraph(AgentState) .addNode("fetchData", fetchMarketData) .addNode("analyze", analyzeMarket) .addNode("execute", executeTrade) .addEdge("fetchData", "analyze") .addEdge("analyze", "execute") .addEdge("execute", END) .setEntryPoint("fetchData"); const app = workflow.compile(); // Run the agent async function runLangGraphAgent() { const markets = ['BTC', 'ETH', 'SOL']; for (const market of markets) { const result = await app.invoke({ market, dryRun: process.env.DRY_RUN !== 'false', }); console.log(`${market} analysis complete:`, result); } } runLangGraphAgent(); ``` ## CrewAI agent Use CrewAI for multi-agent collaboration. First, install dependencies: ```sh npm install crewai-js @langchain/openai ``` ```ts import { Agent, Task, Crew } from 'crewai-js'; import { ChatOpenAI } from '@langchain/openai'; import { HttpTransport, InfoClient } from '@bloxwap/hyperliquid'; const llm = new ChatOpenAI({ modelName: "gpt-4" }); // Agent 1: Market researcher const researcher = new Agent({ role: 'Market Researcher', goal: 'Analyze market data and identify trading opportunities', backstory: 'Expert in technical analysis and market trends', llm: llm, verbose: true, }); // Agent 2: Risk manager const riskManager = new Agent({ role: 'Risk Manager', goal: 'Evaluate risk and position sizing for trades', backstory: 'Conservative risk manager focused on capital preservation', llm: llm, verbose: true, }); // Agent 3: Trade executor const executor = new Agent({ role: 'Trade Executor', goal: 'Execute approved trades with optimal timing', backstory: 'Experienced trader focused on execution quality', llm: llm, verbose: true, }); // Task 1: Research const researchTask = new Task({ description: ` Analyze BTC market conditions and provide a trading recommendation. Consider: price trends, volume, and market sentiment. `, agent: researcher, expectedOutput: 'Trading signal with reasoning', }); // Task 2: Risk assessment const riskTask = new Task({ description: ` Review the trading signal and assess: - Position size - Stop loss placement - Risk/reward ratio Approve or reject the trade. `, agent: riskManager, expectedOutput: 'Risk assessment and approval decision', }); // Task 3: Execution const executeTask = new Task({ description: ` If approved, execute the trade with: - Optimal entry timing - Stop loss and take profit orders - Position size as recommended DRY RUN: Log the order without executing. `, agent: executor, expectedOutput: 'Execution report', }); // Create the crew const tradingCrew = new Crew({ agents: [researcher, riskManager, executor], tasks: [researchTask, riskTask, executeTask], verbose: true, }); // Run the crew async function runCrewAI() { console.log('[DRY RUN] Starting CrewAI trading analysis'); const result = await tradingCrew.kickoff(); console.log('Crew result:', result); } runCrewAI(); ``` ## Signal integration Integrate external signals (e.g., from Bloxwap analytics): ```ts interface BloxwapSignal { market: string; signal: 'bullish' | 'bearish' | 'neutral'; strength: number; // 0-100 indicators: { rsi?: number; macdCross?: boolean; volumeSpike?: boolean; }; } async function fetchBloxwapSignals(): Promise { // Example: Fetch from Bloxwap API or analytics service const response = await fetch('https://bloxwap.app/api/v1/signals', { headers: { 'X-API-Key': process.env.BLOXWAP_API_KEY! }, }); return await response.json(); } async function processSignals() { const signals = await fetchBloxwapSignals(); for (const signal of signals) { if (signal.strength > 80) { console.log('Strong signal detected:', signal); // Execute via your agent } } } ``` ## Safety checklist Before deploying any agent: 1. ✅ **Test on testnet** — Run for at least 48 hours 2. ✅ **Dry-run mode** — Log orders without executing 3. ✅ **Position limits** — Implement max notional caps 4. ✅ **Stop losses** — Required on every position 5. ✅ **Circuit breakers** — Auto-disable on large losses 6. ✅ **Monitoring** — Real-time alerts and logs 7. ✅ **Emergency stop** — Manual kill switch 8. ✅ **Gradual ramp** — Start with tiny positions ## Environment variables Configure these environment variables as needed for each template: ```sh # Required HYPERLIQUID_AGENT_KEY=0x... # Dedicated agent's generated key, never your main wallet key HYPERLIQUID_ACCOUNT_ADDRESS=0x... # Your public account address # Optional HYPERLIQUID_TESTNET=true # Use testnet (default: true) DRY_RUN=true # Log orders without executing (default: true) MAX_POSITION_SIZE=100 # Max notional USD per position (default: 100) BLOXWAP_API_KEY=... # Optional separate Bloxwap API access, if issued; not MCP auth PRIVY_SESSION_TOKEN=... # Optional authenticated MCP reads; expires; never an agent key # LLM providers (for LangGraph/CrewAI) OPENAI_API_KEY=... # OpenAI API key ANTHROPIC_API_KEY=... # Anthropic API key ``` ## Production deployment When moving to production: 1. Generate a **dedicated mainnet agent wallet** and approve its public address from your own wallet in the Bloxwap app or Hyperliquid's API-wallet page. Set `HYPERLIQUID_AGENT_KEY` to that agent's generated key and `HYPERLIQUID_ACCOUNT_ADDRESS` to your public account address. Never use your main wallet key or seed phrase; the agent cannot withdraw and can be revoked there. 2. Set `HYPERLIQUID_TESTNET=false` 3. Set `DRY_RUN=false` 4. Start with minimum position sizes 5. Monitor continuously for 24 hours 6. Gradually increase position sizes ## Next steps - [Signing flows](/developers/signing) — Wallet integration options - [Low-latency recipes](/developers/low-latency) — Performance optimization - [Agent permissions](/developers/permissions) — Risk management --- # FAQ > Answers about wallets, trading, funding, fees, and rewards. Source: https://bloxwap.com/docs/faq _Last updated: October 16, 2026_ For walkthroughs, see the [guides](/docs/how-to). For trading terms, see the [glossary](/docs/glossary). --- # Fees > What it costs to trade: builder fees, Hyperliquid exchange fees, and a worked example. Source: https://bloxwap.com/docs/fees **As of October 20, 2026.** The trading fees below apply to filled perpetual orders on position value (margin × leverage), including opening and closing fills. This is a base-tier taker example; actual rates vary by market and account. | Fee per fill | Standard | Genesis | | --------------------------------------- | -------------------: | ----------------: | | Bloxwap builder fee | 0.05% (5 bps) | 0.025% (2.5 bps) | | Hyperliquid taker fee (base tier) | 0.045% (4.5 bps) | 0.045% (4.5 bps) | | **Total per fill** | **0.095% (9.5 bps)** | **0.07% (7 bps)** | | Open + close a $1,000 position | $1.90 | $1.40 | | Share of hourly funding kept by Bloxwap | $0 | $0 | Hyperliquid’s first higher tier starts above $5M of weighted 14-day trading volume. Higher volume lowers it, staking HYPE takes 5% to 40% off, and HIP-3 markets add a fee set by the market's deployer ([Hyperliquid fee schedule](https://hyperliquid.gitbook.io/hyperliquid-docs/trading/fees)). The current Bloxwap builder rate does not vary with volume, position count, or trading speed. Rates and Genesis availability may change or end under the Terms. ## The Bloxwap builder fee Each filled order pays Hyperliquid's exchange fee plus the Bloxwap builder fee: **5 bps (0.05%)**, or **2.5 bps (0.025%)** for [Genesis](/docs/genesis) traders. Genesis applies automatically to the trading address bound to a qualifying burn. ## Worked example With **100 USDC at 10× leverage**, your position is worth **$1,000**. At the base taker rate in the table: - **Standard:** $0.50 builder fee + $0.45 exchange fee = **$0.95 per fill**, or **$1.90** to open and close. - **Genesis:** $0.25 builder fee + $0.45 exchange fee = **$0.70 per fill**, or **$1.40** to open and close. The example assumes the position value stays at $1,000. An unfilled order pays no trading fee. ## Other costs - **Funding:** longs and shorts pay each other on Hyperliquid. Bloxwap keeps none of it. - **Transfers:** network, bridge, swap, sponsorship, and Bloxwap app fees may be included in the route quote. Relay app fees are configurable and may apply to deposits, withdrawals, and sponsored sends. Review the quoted output and costs before confirming. - **Demo trades:** no exchange or builder fees apply. ## Papertrade markets [Papertrade markets](/docs/assets#papertrade-markets) are a third-party venue that trades real USDC. Trades settle against Papertrade's liquidity pool instead of Hyperliquid's order book, so the fee table above does not apply to them: - **Bloxwap fee:** none. Bloxwap charges no builder fee on Papertrade trades. If Papertrade launches builder codes, any Bloxwap fee will be shown before you trade. - **Opening a position:** no fee, no Hyperliquid exchange fee, and no funding. - **Losing closes:** nothing extra. A loss costs only the margin it uses. - **Winning closes:** Papertrade applies three costs, in order: - a **deadband** that measures your exit as if the price were entry ÷ 50,000 (0.2 bps) less favourable; - an **impact haircut** that keeps part of the profit for the pool. At launch values it takes at least 10% of the profit, and more on small price moves; - a **2% fee** on the profit that remains. - **Liquidation:** a position is liquidated about 5 bps before its equity reaches zero, and the whole margin is lost. - **Payout queue:** while Papertrade's pool is short of funds, part of a win can wait in a first-in, first-out queue and is paid as the pool refills. Your margin comes back right away. - **Deposits:** the first deposit to your Papertrade address pays a 1 USDC Hyperliquid account activation fee. Deposits and withdrawals have a 10 USDC minimum. **Example at launch values:** $10 of margin at 100× is a $1,000 position. If BTC rises 1% and you close, the raw profit is $10.00. The deadband removes $0.02, the impact haircut about $1.17, and the 2% fee about $0.18, so you receive about $8.64 of profit plus your $10 margin. Live parameters come from Papertrade and can change. Bloxwap does not charge escalation or borrow fees. Tables describing a 10% base fee, tick-distance borrowing, or higher fees after four positions refer to the retired product. --- # Genesis > Burn 1,000,000 $BLOXWAP to unlock a 50% builder-fee discount. Source: https://bloxwap.com/docs/genesis _Last updated: October 13, 2026_ Burn a cumulative **1,000,000 $BLOXWAP** to unlock Genesis: - A gold badge on your profile and the leaderboards. - A current **2.5 bps (0.025%) builder fee**, half the standard 5 bps rate. Burns take place on Solana. A locked transaction memo binds the discount to your trading address. Multiple burns count toward the threshold. Hyperliquid exchange fees still apply; see [Fees](/docs/fees). Burned tokens are removed from supply and cannot be recovered. Check the amount and linked trading address before confirming. Genesis rates, eligibility, badges, and availability may change or end under the [Terms of Use](/docs/terms#16-bloxwap-and-genesis). Burns cannot be refunded if Genesis changes or ends. ## How to enable Genesis ### Fund your Bloxwap wallet Send $BLOXWAP to the user-controlled Solana embedded wallet you access through Bloxwap and Privy. You need a cumulative burn of 1,000,000 tokens to qualify. In **Accounts → Wallet**, select **Bloxwap** once the tokens arrive. ![Bloxwap token balance in the Accounts wallet section](/genesis/2-select-wallet-bloxwap.png) ### Enter the burn amount Select **Burn** and enter the amount. Type `1000000` to burn one million tokens, or use **MAX** to select your entire token balance. Check the amount before continuing. The locked memo links the burn to your trading address automatically. ![Burn form with an amount of 1,000,000 BLOXWAP](/genesis/5-select-burn.png) ### Confirm and wait Tap **Burn** to submit the transaction. The **Burn submitted** message confirms submission; wait for on-chain confirmation and verification. Once your verified cumulative burn reaches the threshold, the Genesis badge appears next to your handle. ![Profile with the gold Genesis badge](/genesis/7-genesis.png) ### Check your Genesis rate Open **Builder fee** and look for **Genesis Rate: 2.5 bps (0.025%)**. On a $1,000 fill, the Bloxwap builder fee is $0.25, plus the applicable Hyperliquid exchange fee. ![Builder-fee dialog showing the Genesis rate](/genesis/8-genesis-rate.png) --- # Glossary > Trading and wallet terms used in Bloxwap. Source: https://bloxwap.com/docs/glossary _Last updated: October 16, 2026_ --- # Links > Official Bloxwap apps, developer resources, and community channels. Source: https://bloxwap.com/docs/links ChartCandlestick, ChartColumn, Braces, Code2, } from 'lucide-react'; XLogo, TelegramLogo, DiscordLogo, RedditLogo, TikTokLogo, InstagramLogo, YoutubeLogo, LinkedinLogo, } from '@/components/brand-icons'; ## Product } title="Bloxwap" href="https://bloxwap.app" description="Trade perpetuals powered by Hyperliquid." /> } title="Analytics" href="https://analytics.bloxwap.com" description="Trading activity and platform metrics." /> ## Developers } title="Open source" href="/docs/open-source" description="The Hyperliquid SDK, charts, interface sounds, and fonts." /> } title="Bloxwap API" href="https://bloxwap.app/developers" description="Public data endpoints. No API key required." /> } title="OpenAPI specification" href="https://bloxwap.app/openapi.json" description="The API’s machine-readable reference." /> ## Community } title="X" href="https://x.com/bloxwap" /> } title="Telegram" href="https://t.me/bloxwap" /> } title="Discord" href="https://discord.com/invite/cEfkcg6JHT" /> } title="X Community" href="https://x.com/i/communities/1970606123842711887" /> } title="Reddit" href="https://www.reddit.com/r/Bloxwap/" /> } title="LinkedIn" href="https://www.linkedin.com/company/bloxwap" /> ## Videos } title="TikTok" href="https://www.tiktok.com/@taptradetv" /> } title="Instagram" href="https://www.instagram.com/taptradetv" /> } title="YouTube" href="https://www.youtube.com/@taptradetv" /> Making Bloxwap content? Start with the [creator program](/docs/creators), [video scripts](/docs/explainers), and [brand assets](/docs/brand). --- # Listing criteria > How markets qualify for listing and quarterly review. Source: https://bloxwap.com/docs/listing Every listed market must meet all five criteria below. There are no paid listings or exceptions. ## 1. The venue has to be on-chain Markets must trade and settle on-chain from the trader's wallet. Centralized custodial venues are ineligible. Stocks, commodities, and indices on Bloxwap are perpetual contracts, not brokerage holdings. ## 2. $1M average daily volume over the trailing 7 days The asset must average **more than $1,000,000 in daily trading volume** over the preceding seven days. ## 3. Open interest to volume ratio of 2.0 or lower Volume alone can hide a crowded market. We also divide the asset's **open interest by its 24-hour trading volume**, averaged over the same trailing seven days. A low ratio means positions turn over often, so there are active traders on both sides of the book. A high ratio means a lot of open positions sit on thin daily activity, which makes exits harder. We list only assets with **moderate to very high turnover: a ratio of 2.0 or lower.** | OI / 24h volume | Assessment | Listed | | --------------- | --------------------------- | :-----: | | < 0.25 | Very high turnover | Yes | | 0.25–0.5 | High activity | Yes | | **0.5–1.0** | **Good starting target** | **Yes** | | 1.0–2.0 | Moderate turnover | Yes | | 2.0–5.0 | Low turnover | No | | > 5.0 | Potential liquidity concern | No | ## 4. We list from the deepest book When several venues offer the same asset, Bloxwap selects the source with the **deepest liquidity** and lists only that source. ## 5. The source has to carry five category-defining markets The venue must offer at least **five category-defining markets**: benchmark assets for its category, rather than five arbitrary listings. ## Quarterly re-evaluation Every listing is reviewed against all five criteria once a quarter. Volume and the open interest to volume ratio are measured over the same seven-day window, and liquidity is compared with other available sources. Markets that no longer qualify are removed. If a deeper source becomes available, the listing moves to it. Previously declined assets are reviewed on the same schedule and can qualify at the next review. See [Markets](/docs/assets) for current listings and leverage limits. --- # Open source > Bloxwap's open source libraries for trading, charts, interface sounds, haptics, and fonts. Source: https://bloxwap.com/docs/open-source Build with Bloxwap's open source libraries. Each project has a dedicated site with documentation, setup guides, and examples. Hyperliquid SDK, Chart, SFX, and Haptic use the MIT license. Font uses the SIL Open Font License 1.1. Each project's page links to its source and license. --- # Chart > Install @bloxwap/chart and render your first financial chart. Source: https://bloxwap.com/docs/open-source/chart `@bloxwap/chart` is Bloxwap's TypeScript library for financial charts. It renders to canvas, with built-in indicators and drawing tools, WebAssembly acceleration, and a JavaScript fallback. [Project site](https://bloxwap.github.io/chart/) · [Documentation](https://bloxwap.github.io/chart/docs/) · [GitHub](https://github.com/bloxwap/chart) · [npm](https://www.npmjs.com/package/@bloxwap/chart) ## Install ```sh npm install @bloxwap/chart ``` `0.0.1` is an early developer preview; expect breaking changes before `1.0`. ## Render a chart Your app supplies the canvas and the candles. One config object describes the data and series: ```ts // 1. Import module import { createChart, defineConfig } from '@bloxwap/chart'; // 2. Describe the chart in one config object const config = defineConfig({ data: candles, // [{ time, open, high, low, close, volume? }] — UNIX seconds series: { type: 'candlestick', upColor: '#26a69a', downColor: '#ef5350' }, }); // 3. Create the chart on a canvas const chart = createChart({ container: document.querySelector('canvas')!, config }); await chart.ready; // WASM kernels live (or JS fallback chosen) // Add an indicator chart.addIndicator({ name: 'sma', params: { period: 20 } }); ``` ## Try the chart Open the [interactive playground](https://bloxwap.github.io/chart/docs/playground/) to try drawing tools, indicators, timeframes, and simulated live data in your browser. ## Go further The [documentation site](https://bloxwap.github.io/chart/docs/) has the full guides and API reference: - [React integration](https://bloxwap.github.io/chart/docs/guides/react/) — mount, resize, and clean up a chart component. - [Data and updates](https://bloxwap.github.io/chart/docs/guides/data/) — provide candles and update the series. - [Toolbar and settings](https://bloxwap.github.io/chart/docs/guides/toolbar-settings/) — add drawing tools and chart controls. - [Configuration reference](https://bloxwap.github.io/chart/docs/api/configuration/) — configure series, scales, indicators, and appearance. Chart is released under the [MIT license](https://github.com/bloxwap/chart/blob/main/LICENSE). --- # Font > Install @bloxwap/font and use Bloxwap's typefaces in your app. Source: https://bloxwap.com/docs/open-source/font `@bloxwap/font` packages Bloxwap Sans, Mono, and Pixel as variable web fonts. Sans and Mono include script companions that load only when your text needs them. [Project site](https://bloxwap.github.io/font/) · [Documentation](https://bloxwap.github.io/font/docs/) · [GitHub](https://github.com/bloxwap/font) · [npm](https://www.npmjs.com/package/@bloxwap/font) ## Install ```sh npm install @bloxwap/font ``` ## Use CSS Import the stylesheet once in your app: ```ts import '@bloxwap/font/css'; ``` Then assign the font families: ```css body { font-family: 'Bloxwap Sans', system-ui, sans-serif; } code, pre { font-family: 'Bloxwap Mono', ui-monospace, monospace; } .score { font-family: 'Bloxwap Pixel', monospace; } ``` | Family | Use it for | | --- | --- | | Bloxwap Sans | Interface copy and text | | Bloxwap Mono | Code, terminals, and data | | Bloxwap Pixel | Displays, tickers, and game interfaces | Each family supports weights from 100 to 900. Pixel also has a roundness axis: set `font-variation-settings: 'ROND' 60` to try it. ## Use Next.js Next.js 15 or later can use the package's `next/font/local` exports: ```tsx title="app/layout.tsx" import type { ReactNode } from 'react'; import { BloxwapSans } from '@bloxwap/font/sans'; import { BloxwapMono } from '@bloxwap/font/mono'; export default function RootLayout({ children }: { children: ReactNode }) { return ( {children} ); } ``` Next.js self-hosts the fonts. The variable classes expose `--font-bloxwap-sans` and `--font-bloxwap-mono`; use `font-family: var(--font-bloxwap-mono), monospace` for code and data. ## Go further - [Type tester](https://bloxwap.github.io/font/) — preview families, weights, and sample text. - [Installation guide](https://bloxwap.github.io/font/docs/installation/) — desktop downloads, self-hosting, and Tailwind CSS setup. - [Multiple scripts](https://bloxwap.github.io/font/docs/multi-script/) — use script companions under the same family names. - [Brand assets](/docs/brand) — Bloxwap's typography, logos, and colors. Font is released under the [SIL Open Font License 1.1](https://github.com/bloxwap/font/blob/main/LICENSE). --- # Haptic > Install @bloxwap/haptic and add haptic feedback to your React interface. Source: https://bloxwap.com/docs/open-source/haptic `@bloxwap/haptic` adds haptic feedback to a React target without replacing its behavior. Wrap one element and it keeps its handlers, ref, focus, and accessibility, with eleven vibration presets and custom patterns. [Project site](https://bloxwap.github.io/haptic/) · [Documentation](https://bloxwap.github.io/haptic/docs/) · [GitHub](https://github.com/bloxwap/haptic) · [npm](https://www.npmjs.com/package/@bloxwap/haptic) ## Install ```sh npm install @bloxwap/haptic ``` React and React DOM are peer dependencies; use matching versions, React 18 or newer. The package ships ES modules and CommonJS with TypeScript declarations, and renders safely through server rendering. ## Add feedback to a control Wrap a single target with the `Haptic` component: ```tsx 'use client'; import { Haptic } from '@bloxwap/haptic'; export function SaveButton() { return ( ); } ``` `feedback` accepts a preset name such as `selection`, `light`, `heavy`, `success`, or `error`, a duration in milliseconds, an alternating on/off `number[]` pattern, or vibration event objects with delay and intensity. The default is `selection`. ## Control feedback Suppress feedback while leaving the action available: ```tsx ``` Targets with `disabled` or `aria-disabled="true"` are detected automatically. The wrapper defaults to `inline-grid`; pass `className` and `style` to control its layout. ## Platform behavior On supported physical iOS devices, a tap uses the native system tick. Vibration-capable browsers play the selected preset or pattern through the Vibration API. On a desktop without vibration hardware, `webHapticsOptions={{ debug: true }}` enables an opt-in audio preview. ## Go further - [API reference](https://bloxwap.github.io/haptic/docs/) — presets, patterns, trigger options, and platform detection. - [GitHub](https://github.com/bloxwap/haptic) — source, release plan, and device certification status. Haptic is released under the [MIT license](https://github.com/bloxwap/haptic/blob/main/LICENSE). --- # Hyperliquid SDK > Install @bloxwap/hyperliquid and read your first market price. Source: https://bloxwap.com/docs/open-source/hyperliquid `@bloxwap/hyperliquid` is Bloxwap's TypeScript SDK for the Hyperliquid API. Use it to query market and account data, subscribe to live updates, or submit signed exchange actions. [Project site](https://bloxwap.github.io/hyperliquid/) · [Documentation](https://bloxwap.github.io/hyperliquid/docs/) · [GitHub](https://github.com/bloxwap/hyperliquid) · [npm](https://www.npmjs.com/package/@bloxwap/hyperliquid) ## Install Use Node.js 22.12 or later, or Bun 1.3.3 or later. ```sh npm install @bloxwap/hyperliquid ``` ## Read a price Create an HTTP client and request market data. This example uses mainnet and needs no wallet or API key. ```ts // 1. Import module import { HttpTransport, InfoClient } from '@bloxwap/hyperliquid'; // 2. Set up client with transport const transport = new HttpTransport(); const info = new InfoClient({ transport }); // 3. Query data const mids = await info.allMids(); // mid-prices for all coins console.log(mids.BTC); const book = await info.l2Book({ coin: 'BTC' }); // L2 order book snapshot ``` For testnet, use `new HttpTransport({ isTestnet: true })`. ## Choose a client | Client | Use it for | | --- | --- | | `InfoClient` | Market data, balances, positions, and open orders | | `SubscriptionClient` | Live data over WebSocket | | `ExchangeClient` | Signed actions, including orders and cancellations | ## Go further The [SDK site](https://bloxwap.github.io/hyperliquid/) brings setup, guides, and API documentation together: - [Installation and quick start](https://bloxwap.github.io/hyperliquid/docs/) — runtime requirements, React Native setup, and client examples. - [Guides](https://bloxwap.github.io/hyperliquid/docs/guides/) — market orders, agent wallets, vaults, and browser wallets. - [Clients](https://bloxwap.github.io/hyperliquid/docs/clients/) — HTTP requests, exchange actions, and WebSocket subscriptions. - [Known documentation drift](https://bloxwap.github.io/hyperliquid/docs/reference/known-drift/) — verified differences between official documentation, live API behavior, and SDK types. The SDK is a fork of [nktkas/hyperliquid](https://github.com/nktkas/hyperliquid), released under the [MIT license](https://github.com/bloxwap/hyperliquid/blob/main/LICENSE). --- # SFX > Install @bloxwap/sfx and add sounds to your interface. Source: https://bloxwap.com/docs/open-source/sfx `@bloxwap/sfx` provides 19 interface sounds synthesized with Web Audio. Use it for presses, toggles, confirmations, errors, and notifications, with no audio downloads or runtime dependencies in the core package. [Project site](https://bloxwap.github.io/sfx/) · [Documentation](https://bloxwap.github.io/sfx/docs/) · [GitHub](https://github.com/bloxwap/sfx) · [npm](https://www.npmjs.com/package/@bloxwap/sfx) ## Install ```sh npm install @bloxwap/sfx ``` The package uses ES modules and runs in modern browsers. Imports are safe during server rendering; playback runs in the browser after a user interaction. ## Add sounds to controls Add sound attributes to your HTML: ```html ``` Then bind them from your browser code: ```ts import { bind } from '@bloxwap/sfx'; const unbind = bind(); // Call unbind() when you remove the binding. ``` `bind()` handles pointer and keyboard input, including controls added later. Disabled controls stay silent. Set an attribute's value to choose a sound, such as `data-sound-press="tick"`. ## Use React Bind a component after it mounts and remove the listeners when it unmounts: ```tsx 'use client'; import { useEffect, useRef } from 'react'; import { bind } from '@bloxwap/sfx'; export function SaveButton() { const ref = useRef(null); useEffect(() => { if (!ref.current) return; return bind(ref.current); }, []); return ; } ``` Use `play('success')` from `@bloxwap/sfx` for feedback from your own event handlers, and `setEnabled()` and `setVolume()` to control sound preferences. ## Go further - [Sound board](https://bloxwap.github.io/sfx/) — listen to the sounds before choosing them. - [API reference](https://bloxwap.github.io/sfx/docs/api/) — playback, volume, mute, and offline rendering. - [Native apps and WAV export](https://bloxwap.github.io/sfx/docs/guides/native/) — export sounds with `sfx-wav` and the optional `node-web-audio-api` dependency. SFX is released under the [MIT license](https://github.com/bloxwap/sfx/blob/main/LICENSE). --- # Referral leaderboard > Status of this leaderboard page. Source: https://bloxwap.com/docs/referral-leaderboard _Last updated: October 13, 2026_ This page no longer presents a signup leaderboard or participation instructions. For trading rewards, see [Season 01](/docs/season-01) and its [official rules](/docs/season-01/rules). --- # Resources > Community, brand, and company information in one place. Source: https://bloxwap.com/docs/resources _Last updated: October 13, 2026_ ## Community - [Official links](/docs/links) — apps, social accounts, and support channels. - [Follow Bloxwap](/docs/subscribe) — product updates and announcements. - [Creators](/docs/creators) — recording, publishing, and creator rewards. - [Explainers](/docs/explainers) — feature summaries and ideas for product demos. ## Rewards - [Genesis](/docs/genesis) — eligibility and reduced trading fees. - [Season 01](/docs/season-01) — competition details, standings, and rules. ## Bloxwap - [Brand assets](/docs/brand) — logos, colors, typography, and downloads. - [Team](/docs/team) — the people building Bloxwap. - [Press](/docs/press) — coverage, press kit, and media contact. - [$BLOXWAP](/docs/token) — token details and official contract address. - [Listing criteria](/docs/listing) — how markets qualify and are reviewed. - [Compare trading apps](/docs/compare) — how Bloxwap fits into the Hyperliquid ecosystem. ## Legal [Privacy policy](/docs/privacy) · [Terms of service](/docs/terms) --- # $BLOXWAP > The token, Genesis fee discount, and planned buyback program. Source: https://bloxwap.com/docs/token _Last updated: October 13, 2026_ $BLOXWAP is a Solana SPL token. It gives no ownership, equity, profit share, dividend, governance rights, or claim on Bloxwap’s revenue or assets. Do not buy it as an investment. Its price can fall to zero and liquidity or listings may disappear. ## Fee discount Burn a cumulative **1,000,000 $BLOXWAP** to unlock [Genesis](/docs/genesis): a reduction in the Bloxwap builder fee from **5 bps (0.05%) to 2.5 bps (0.025%)**. Burns are verified on Solana and bound to your trading address. The discount applies to the builder fee; Hyperliquid exchange fees still apply. See [Fees](/docs/fees) for the full breakdown. Burned tokens are removed from supply and cannot be recovered. Follow the [Genesis guide](/docs/genesis) to check the amount and linked trading address before confirming. Genesis rates and availability may change or end under the [Terms of Use](/docs/terms#16-bloxwap-and-genesis). Burns cannot be refunded if the program changes or ends. ## Buyback and burn We plan to begin after Bloxwap reaches **$1,000,000 in cumulative revenue**, using about **5% of monthly revenue** to buy back and burn $BLOXWAP on-chain, with a target of burning **50% of total supply**. This is a plan, not a commitment. We may change, pause, or end it for legal, operational, or financial reasons. It does not promise a token price or return. The program reduces supply; it does not distribute revenue to token holders. ## Verify the token Use the contract address to identify $BLOXWAP: Contract address: 2u3ufZ5defxwPXMixvvQpSs68PDNzHTdE52t9Crspump - [Solscan](https://solscan.io/token/2u3ufZ5defxwPXMixvvQpSs68PDNzHTdE52t9Crspump): token, supply, and transactions. - [RugCheck](https://rugcheck.xyz/tokens/2u3ufZ5defxwPXMixvvQpSs68PDNzHTdE52t9Crspump): authority and liquidity information. - [DexScreener](https://dexscreener.com/solana/2u3ufZ5defxwPXMixvvQpSs68PDNzHTdE52t9Crspump): markets and liquidity. --- # Guides > Fund your account, manage a trade, and withdraw. Source: https://bloxwap.com/docs/how-to _Last updated: October 13, 2026_ } title="Fund from Solana" href="/how-to/fund-from-solana" description="Deposit SOL or USDC into your trading balance." /> } title="Deposit Bitcoin from Cash App" href="/how-to/deposit-bitcoin-cash-app" description="Send Bitcoin using a deposit QR code." /> } title="Set a stop-loss" href="/how-to/set-a-stop-loss" description="Choose a target and review the trigger price." /> } title="Withdraw to Base" href="/how-to/withdraw-to-base" description="Review a quote and withdraw USDC." /> } title="Qualify for Season 01" href="/how-to/qualify-for-season-01" description="Check eligibility and track your score." /> --- # Deposit Bitcoin from Cash App > Send Bitcoin from Cash App to your USDC trading balance. Source: https://bloxwap.com/docs/how-to/deposit-bitcoin-cash-app _Last updated: October 13, 2026_ The Bitcoin deposit QR opens Cash App’s send flow with the address filled in. The deposit is routed into USDC for trading. The transfer uses a third-party conversion and bridge route into USDC. Confirm the network, address, output estimate, and fees. Transfers can fail or be delayed; Bloxwap cannot reverse a confirmed transaction. For another funding route, see [Fund from Solana](/docs/how-to/fund-from-solana). --- # Fund from Solana > Deposit SOL or USDC from a Solana wallet into your trading balance. Source: https://bloxwap.com/docs/how-to/fund-from-solana _Last updated: October 13, 2026_ Choose SOL or USDC on Solana. Relay converts native SOL into USDC as part of its third-party swap and bridge route. Bloxwap requests and displays the route. See the [deposit FAQ](/docs/faq#deposits) for other funding options. --- # Qualify for Season 01 > Check eligibility, enable the builder fee, and track your score. Source: https://bloxwap.com/docs/how-to/qualify-for-season-01 _Last updated: October 13, 2026_ Season 01 rewards the top 100 eligible traders from a pool capped at $250,000 USDC. Read the [official rules](/docs/season-01/rules) before participating. See the [Season 01 leaderboard](/docs/season-01) for current standings. Eligibility, scoring, season close, and payout terms are governed by the [official rules](/docs/season-01/rules). --- # Set a stop-loss > Choose a loss target, review the trigger price, and enable the stop. Source: https://bloxwap.com/docs/how-to/set-a-stop-loss _Last updated: October 13, 2026_ A stop-loss submits a closing order when the market reaches your trigger. The trigger price is not a guaranteed execution price. Learn about [liquidation](/docs/glossary#liquidation) or practice with [demo mode](/docs/faq#demo-mode). --- # Withdraw to Base > Review a quote and withdraw USDC to Base. Source: https://bloxwap.com/docs/how-to/withdraw-to-base _Last updated: October 13, 2026_ Withdraw USDC through a quoted route to Base. Gas sponsorship covers specified network costs; bridge, swap, sponsorship, and Bloxwap app fees may still be included in the route quote. Review all costs and the output estimate before confirming. Other supported destinations are available in the same picker. See the [withdrawal FAQ](/docs/faq#withdrawals). --- # Season 01 > Leaderboard for the Season 01 prize pool of up to $250,000 USDC. Source: https://bloxwap.com/docs/season-01 _Last updated: October 13, 2026_ The top 100 eligible traders share a pool funded by Eligible Revenue (builder fees plus applicable Hyperliquid rebates paid to Bloxwap), capped at **$250,000 USDC**. Rankings use the same Eligible Revenue measure: $1 earns 1 point. Trading fees and losses may exceed any prize. Standings are provisional until eligibility and final score checks are completed. Read the [qualification guide](/docs/how-to/qualify-for-season-01) and [official rules](/docs/season-01/rules) for eligibility, scoring, season close, and payout terms. --- # Season 01 rules > Official eligibility, scoring, and prize-delivery rules. Source: https://bloxwap.com/docs/season-01/rules _Last updated: October 16, 2026_ These rules (the "**Rules**") govern the Bloxwap "Season 01" prize-pool promotion (the "**Promotion**"). The Promotion is offered by Bloxwap, Inc. ("**Bloxwap**", "**we**", "**us**") and is separate from the [Hyperliquid](https://hyperliquid.xyz) protocol itself. By entering the Promotion you agree to these Rules and to our [Terms of Use](/docs/terms) and [Privacy Policy](/docs/privacy), all of which form part of these Rules. The Services and Protocol have the meanings given in the Terms. If anything in these Rules conflicts with the Terms of Use, the Terms of Use control. > **Apple and Google are not sponsors.** Apple Inc. and Google LLC are not sponsors of the Promotion and are not involved in it in any manner. See [section 13](#13-independence-of-hyperliquid-apple-and-google). > **How winners are chosen.** The top 100 eligible wallets are ranked by points earned from revenue paid to Bloxwap. There is no random drawing. Earning points requires paying trading fees. Trading losses may exceed any prize. ## 1. Promotion at a glance **Eligible Revenue** means builder fees from eligible trades carrying Bloxwap's builder fee, plus any Hyperliquid rebates attributable to those trades and paid to Bloxwap. It excludes deposits, trading volume, user profits, and unrelated Bloxwap revenue. This same measure governs scoring, Pool funding, and the close trigger. - **Pool:** up to USD 250,000, paid in USDC on Hyperliquid Core ("**HyperCore**"). The Pool is Eligible Revenue actually collected, capped at USD 250,000. - **Winners:** the top 100 eligible wallets at season close. - **Scoring:** USD 1 of Eligible Revenue earns 1 point. The [public leaderboard](/docs/season-01) is the canonical scoreboard. - **Season close:** when collected Eligible Revenue reaches USD 250,000, or on an earlier close date we publish in advance. - Viewing the Services or leaderboard requires no deposit. Trading is required to earn points and can cause loss; see the [risk disclosure](/docs/terms#3-risk-disclosure). ## 2. Eligibility You are eligible to participate in the Promotion only if **all** of the following are true throughout the season: 1. You are a registered Hyperliquid user with an active wallet that can trade on Hyperliquid. 2. You have **builder fees enabled** on Hyperliquid for Bloxwap's builder address (`0x71b09A08257078A4d642F7Dd7315e656c837329a`) and **keep them enabled throughout the season**. Trades that do not carry the Bloxwap builder fee do not count toward your score. Revoking or reducing the approval below Bloxwap's required rate at any point removes the wallet from the leaderboard immediately and forfeits all accumulated points; re-enabling does not restore them. 3. You appear in the public leaderboard at [bloxwap.com/docs/season-01](/docs/season-01). Your wallet is added to the leaderboard automatically when you complete the in-app builder-fee approval, and remains there as long as the approval is active. 4. You are at least **18 years of age** (or the age of majority in your jurisdiction, whichever is greater) and have legal capacity to enter into these Rules. 5. You are **not** a citizen, resident, or located in any **Restricted Jurisdiction** (defined below), and you are not entering on behalf of a person or entity that is. 6. You are **not** subject to sanctions administered by the United Nations, the United States (including OFAC), the European Union, the United Kingdom, or any other applicable sanctions authority, and you are not on any sanctions or denied-persons list. 7. Your participation does not violate any law, regulation, or third- party agreement. 8. You are **not** a director, officer, employee, contractor, or immediate family member (parent, spouse, child, sibling, or member of the same household) of Bloxwap or any of its affiliates. ### Restricted Jurisdictions The [Terms of Use eligibility section](/docs/terms#2-eligibility) defines Restricted Jurisdictions and the watchlist. That same list applies here and may change without prior notice. Do not bypass it with a VPN, proxy, or false location information. You also cannot participate where derivatives or promotions of this kind are unlawful or require a license Bloxwap has not obtained. If you become ineligible during the season, you are disqualified. Your wallet remains yours; managing funds through the Protocol or another interface is subject to law and provider availability. ## 3. How to qualify 1. Open Bloxwap (web, mobile web, or the installed app). 2. Connect a wallet that meets the eligibility requirements in Section 2. 3. Confirm builder fees are enabled for the Bloxwap builder address when prompted by the Services or by Hyperliquid. 4. Trade. Each USD 1 of Eligible Revenue earns 1 point. The leaderboard is sorted by points, descending. 5. Wash, self-matched, sub-second toggle, or otherwise non-economic trading does not count and may result in disqualification (see Section 7). ## 4. The leaderboard - The leaderboard at [bloxwap.com/docs/season-01](/docs/season-01) is the **canonical scoreboard** for the Promotion. - The leaderboard is fed by Hyperliquid public fee, rebate, and fills data, refreshed on a regular cadence and cached for short windows. Brief delays in updates are normal and not grounds for dispute. - Wallet addresses are pseudonymous on-chain identifiers; the leaderboard shows truncated addresses, address-derived avatars, Genesis badges, scores, and rankings. Other app views may show chosen usernames or avatars. - Bloxwap reserves the right to correct leaderboard data at any time, including to remove ineligible entries, recompute scores, or apply anti-abuse adjustments. ## 5. Prize pool, scoring, and payout ### 5.1 Pool funding The Pool is Eligible Revenue actually collected during the season, capped at **USD 250,000**. The season closes when that amount reaches the cap or on an earlier published close date. If the season closes below the cap, the Pool is the Eligible Revenue collected as of that date, subject to corrections for ineligible or abusive trades under Section 7. ### 5.2 Winner selection At season close, the **top 100 eligible participants** on the leaderboard, ranked by total points, are the "**Winners**". Tie- breaking is performed by onboarding timestamp ascending — the wallet that approved Bloxwap's builder fee earlier wins the tie. Bloxwap's determination of the ranking, including all anti-abuse adjustments, is subject to corrections and any rights that cannot be excluded by law. ### 5.3 Distribution The full Pool is distributed across the top 100 finishers on the following weighted tiers (totals to USD 250,000 / 100% of the Pool): | Rank | Prize each | Subtotal | Share of Pool | | ------ | ---------- | -------- | ------------- | | 1 | $50,000 | $50,000 | 20% | | 2 | $25,000 | $25,000 | 10% | | 3 | $25,000 | $25,000 | 10% | | 4–10 | $10,000 | $70,000 | 28% | | 11–50 | $1,500 | $60,000 | 24% | | 51–100 | $400 | $20,000 | 8% | If the Pool is short of USD 250,000 at season close (Section 5.1), each prize is **scaled by the Pool’s share of USD 250,000** — the rank-share percentages above are the controlling values, not the dollar amounts. Example: a Pool of USD 200,000 (80% of cap) pays the rank-1 finisher USD 40,000 (20% × USD 200,000), and so on through rank 100. ### 5.4 Payout - Prizes are paid in **USDC on Hyperliquid Core (HyperCore)** to the same wallet address that earned the points on the leaderboard. - We aim to pay Winners within **30 calendar days** after season close, but on-chain operational delays, KYC review, or sanctions screening may extend this period. Bloxwap makes no commitment to any specific payout date. - Bloxwap is **not responsible** for any fees, network costs, or losses associated with you receiving, holding, or withdrawing the prize after it is delivered to the winning wallet. - Failure of a Winner to claim or accept a prize within 90 days of notification (or, where no notification is required, of payout attempt) results in forfeiture of that prize. Forfeited prizes may be redistributed to remaining Winners, rolled into a future promotion, or used in any other manner Bloxwap elects. ### 5.5 Pre-payout verification Before paying any prize, Bloxwap may at its sole discretion require a Winner to: - Verify control of the winning wallet (e.g., by signing a message); - Complete identity verification ("**KYC**") through a third-party provider, including providing a government-issued ID and proof of address, sufficient to satisfy Bloxwap's sanctions-screening, anti-money-laundering, and tax-reporting obligations; - Sign a brief eligibility declaration confirming compliance with these Rules; and / or - Provide tax-reporting information required for the applicable jurisdiction where Bloxwap reasonably believes it is required. A Winner who refuses or fails to complete reasonable verification within 30 days of being asked is disqualified, their prize is forfeited, and the Pool may be redistributed as described above. ## 6. Taxes **Winners are solely responsible for any and all taxes, withholdings, duties, levies, or governmental charges that apply to their prize.** Prizes may be reported to tax authorities where Bloxwap reasonably believes such reporting is required. Bloxwap does not provide tax advice; consult your own tax advisor about the implications of participating in or winning the Promotion. ## 7. Fair play and anti-abuse The following are strictly prohibited and constitute grounds for **immediate disqualification, forfeiture of any prize, and recoupment** of any prize already paid: - **Wash trading.** Trades executed primarily to inflate volume, including self-matched trades, trades between accounts under common control, or trades coordinated with another participant for the purpose of accumulating points. - **Sybil entries.** Operating multiple wallets that are controlled by, beneficially owned by, or acting in concert with the same person or entity. Bloxwap may at its discretion consolidate or disqualify Sybil entries, even if they appear on the leaderboard under different addresses. - **Bot or automated abuse** that exceeds reasonable use of the public Hyperliquid or Bloxwap APIs. Normal algorithmic trading through the Hyperliquid protocol is **not** prohibited so long as it complies with the rest of these Rules and the Hyperliquid terms of service. - **Misrepresentation** of identity, age, jurisdiction, or eligibility under Section 2. - **Violation of Hyperliquid's terms of service** or any other rule applicable to your trading activity. - **Any conduct intended to defraud, harm, or unfairly disadvantage** Bloxwap, Hyperliquid, or any other participant. Bloxwap reserves the right to investigate suspected violations, including by reviewing on-chain activity, third-party data, and any other information lawfully available to it. **Bloxwap's determinations on fair-play matters are subject to corrections and applicable legal rights.** ## 8. Privacy - The wallet addresses on the public leaderboard are pseudonymous on-chain identifiers and are visible to anyone with the URL. - Personal information you provide for KYC, sanctions screening, or tax reporting (Section 5.5) is processed in accordance with our [Privacy Policy](/docs/privacy). Bloxwap may share that information with third-party verification providers as necessary to complete the checks. - Public display includes the address, score, rank, and profile elements described in Section 4. Verification documents and tax information are not published on the leaderboard. ## 9. Changes, suspension, and cancellation We may change these Rules without prior notice by posting an update here. Changes take effect on posting. Continued participation after posting means you accept the updated Rules. We may suspend, shorten, extend, or cancel the Promotion for legal, Protocol, security, operational, or financial reasons. We may correct scores and remove ineligible or abusive entries under Sections 2 and 7. Changes will not reduce points already validly earned or prizes already determined, except as required by law or for an eligibility, sanctions, abuse, or data-correction finding. If we close or cancel the season early, Eligible Revenue collected at close forms the Pool and the distribution percentages in Section 5 apply, unless law prohibits payout. Verification and payout requirements still apply. Current leaderboard positions are provisional until the season closes and eligibility and score checks are completed. ## 10. Disclaimers **The Promotion and leaderboard are provided "as is" and "as available", to the extent the law allows.** Scores can be delayed or corrected. Current rank does not establish a prize entitlement. The Promotion rewards fee-generating trading. It is not investment advice or a recommendation to trade more. You can lose more in trading than any prize you receive. ## 11. Limitation of liability **To the extent the law allows, Bloxwap's total liability under these Rules is limited to USD $100, within the same aggregate limit in the [Terms of Use](/docs/terms#10-limitation-of-liability).** This is a shared aggregate limit, including claims about prizes. The Terms' exclusions of indirect losses and exceptions for liability that cannot lawfully be limited also apply here. Your mandatory legal rights remain in place. ## 12. Your responsibility to us You will cover our reasonable losses and legal costs from third-party claims caused by your breach of these Rules, violation of law or another person's rights, or misconduct. This does not cover losses caused by our misconduct. ## 13. Independence of Hyperliquid, Apple and Google The Promotion is operated **solely by Bloxwap**. The Hyperliquid protocol, the Hyperliquid Foundation, and any other Hyperliquid- related entity are **not sponsors, administrators, or guarantors** of the Promotion. **Apple Inc. is not a sponsor of the Promotion and is not involved in it in any manner.** The same is true of Google LLC. Offering the Bloxwap app through the App Store or Google Play does not make Apple or Google a sponsor, administrator, or guarantor of the Promotion. Direct any questions, comments, or complaints about the Promotion to Bloxwap, not to Apple or Google. Nothing in these Rules creates any obligation on, or liability of, any of those parties. ## 14. Governing law and disputes The [governing law, dispute procedure, and 30-day email arbitration opt-out in the Terms](/docs/terms#13-governing-law-and-disputes) apply to these Rules. You and Bloxwap, Inc. are the parties. Opting out under the Terms also opts you out for this Promotion. ## 15. Severability and interpretation If any provision of these Rules is held unenforceable, the remaining provisions remain in full force and effect, and the unenforceable provision will be modified to the minimum extent necessary to make it enforceable while preserving its intent. Headings are for convenience only and do not affect interpretation. ## 16. Contact Questions about the Promotion or these Rules can be sent to [support@bloxwap.com](mailto:support@bloxwap.com). --- **A note on these Rules.** They are written for clarity and to be fair to participants while protecting Bloxwap from foreseeable risks. They are not a substitute for legal advice in your jurisdiction. If anything above is unclear, contact us before entering. --- # Bloxwap blog > Simple guides to the markets, the app, and what happens when you tap. Source: https://bloxwap.com/blog A clearer take on trading. --- # Inside Season 01 > How the prize pool works, who can qualify, and how rewards are paid. Source: https://bloxwap.com/blog/bloxwap-250k-prize-pool Bloxwap is running a **Season 01 prize pool**: up to **$250,000**, paid in USDC to the top 100 eligible traders on the Bloxwap leaderboard. Rankings depend on the revenue each trader generates for Bloxwap. This is a plain-language summary. The full, binding details live in the [official rules](https://bloxwap.com/docs/season-01/rules), which always control if anything here is unclear or out of date. ## What it is The prize pool is capped at **$250,000**, paid in **USDC**, a stablecoin designed to track the US dollar. Prizes arrive on **Hyperliquid Core**, or **HyperCore**, where your trading balance is held. Entry requires trading activity. Winners are ranked by points, not selected through a random drawing. ## Where the money comes from The pool is funded entirely by **builder fees**, the portion of each trading fee paid to Bloxwap for routing the order. Viewing the app or leaderboard requires no purchase or deposit. Qualifying requires trading, which incurs fees and carries a risk of loss. ## How scoring works Your rank is based on **points**: > You earn **1 point for every $1 of revenue your trading generates for > Bloxwap.** That revenue is mostly the builder fees you pay through Bloxwap, plus any referral rebates Hyperliquid routes to Bloxwap for your trades. More trading volume means more fees, which means more points. The [public leaderboard](https://bloxwap.com/docs/season-01) is the official scoreboard. It updates on a regular schedule (small delays are normal) and ranks everyone by points, highest first. ## The prizes At season close, the **top 100 eligible traders** share the pool on these tiers: | Rank | Prize each | | ------ | ---------- | | 1 | $50,000 | | 2 | $25,000 | | 3 | $25,000 | | 4-10 | $10,000 | | 11-50 | $1,500 | | 51-100 | $400 | Those add up to the full $250,000. If the pool ends below $250,000, every prize is scaled down by the same percentage. For example, if the pool reaches $200,000 (80% of the cap), first place pays $40,000 instead of $50,000, and so on down the list. The **percentages** are fixed, not the exact dollar figures. ## How to qualify To be eligible you need to meet these essentials (the [rules](https://bloxwap.com/docs/season-01/rules) have the full list): 1. Be a registered Hyperliquid user with a wallet that can trade. 2. **Enable builder fees** for Bloxwap when the app asks, and keep them on for the whole season. Trades without the Bloxwap builder fee don't count. If you revoke approval or reduce it below the required rate, your wallet is removed and its points are forfeited. Re-enabling does not restore them. 3. Be **18 or older**, or the age of majority where you live, whichever is greater. 4. Not be a citizen or resident of, or located in, a restricted jurisdiction, including the United States. You must also meet the rules' sanctions, affiliation, and other eligibility requirements. The in-app builder-fee approval adds your wallet to the leaderboard. Wash, self-matched, and other non-economic trading does not count and may result in disqualification. Using Bloxwap's referral code is encouraged. It gives you a discount on Hyperliquid's trading fees, but it isn't required. New to the app? Start with [What is Bloxwap?](https://bloxwap.com/blog/what-is-bloxwap). ## When the season ends The season closes when **one of two things happens first**: - Bloxwap collects $250,000 in eligible builder fees, or - a closing date that Bloxwap announces in advance. ## How and when you get paid Prizes are paid in **USDC on HyperCore**, sent to the same wallet that earned your points. Bloxwap aims to pay within **30 days** of season close, though identity or sanctions checks can take longer. Before paying, Bloxwap may ask you to prove you control the wallet and to complete identity verification (KYC). ## A word on risk Climbing the leaderboard means trading, and **trading carries real risk.** Leverage magnifies losses as easily as gains. You can lose more from trading than you'd win in the pool. Only trade what you can afford to lose, and read the [Risk Disclosure](https://bloxwap.com/docs/terms#3-risk-disclosure) first. Check your standing on the [leaderboard](https://bloxwap.com/docs/season-01). The [official rules](https://bloxwap.com/docs/season-01/rules) govern eligibility, final rankings, verification, and payouts, and may change. --- # What it costs to trade > A clear breakdown of trading fees, funding, and a $1,000 position. Source: https://bloxwap.com/blog/bloxwap-fee-guide **As of October 20, 2026.** The trading fees below apply to filled perpetual orders on position value (margin × leverage), including opening and closing fills. This is a base-tier taker example; actual rates vary by market and account. | Fee per fill | Standard | Genesis | | --------------------------------------- | -------------------: | ----------------: | | Bloxwap builder fee | 0.05% (5 bps) | 0.025% (2.5 bps) | | Hyperliquid taker fee (base tier) | 0.045% (4.5 bps) | 0.045% (4.5 bps) | | **Total per fill** | **0.095% (9.5 bps)** | **0.07% (7 bps)** | | Open + close a $1,000 position | $1.90 | $1.40 | | Share of hourly funding kept by Bloxwap | $0 | $0 | Hyperliquid’s first higher tier starts above $5M of weighted 14-day trading volume. Higher volume lowers it, staking HYPE takes 5% to 40% off, and HIP-3 markets add a fee set by the market's deployer ([Hyperliquid fee schedule](https://hyperliquid.gitbook.io/hyperliquid-docs/trading/fees)). The current Bloxwap builder rate does not vary with volume, position count, or trading speed. Rates and Genesis availability may change or end under the Terms. Each filled trade has two costs: Hyperliquid's exchange fee and Bloxwap's builder fee. They apply when you open and again when you close. [Genesis](https://bloxwap.com/docs/genesis) halves the builder portion. The table gives the base-tier rates. Your market, trading volume, and staking discounts can affect the exchange portion; review the app's estimate before placing an order. ## The two fees on a normal trade A **fill** happens when your order matches with another trader's order. A normal tap order takes available liquidity, so its fills pay Hyperliquid's **taker fee**. A taker accepts a price already offered in the market. 1. **Hyperliquid exchange fee.** The base taker rate for a regular perp is **4.5 basis points (0.045%)**. It applies below $5M of 14-day volume; higher volume and staked HYPE lower it, and HIP-3 markets add a fee set by the market's deployer. 2. **Bloxwap builder fee.** A builder fee pays the app that sends an order to Hyperliquid. Bloxwap adds **5 basis points (0.05%)** to each fill. A verified Genesis wallet pays **2.5 basis points (0.025%)** instead. A **basis point**, shortened to **bps**, is one hundredth of one percent. So 5 bps means 0.05%, not 5%. The [Bloxwap fee table](https://bloxwap.com/docs/fees) lists the rates and links to Hyperliquid's full schedule. ## A full $1,000 position example Suppose you deposit **100 USDC** as margin and choose 10x leverage. Margin is the money backing your trade. Leverage makes your position larger, so your $100 controls a **$1,000 position**. Fees use the $1,000 position value, not the $100 margin: - Hyperliquid base taker fee: $1,000 × 0.045% = **$0.45**. - Standard Bloxwap builder fee: $1,000 × 0.05% = **$0.50**. - Total fee to open: **$0.95**. If you later close at the same $1,000 value, closing costs another **$0.95**. The round trip is **$1.90**. A Genesis trader pays **$0.70** to open and **$0.70** to close, or **$1.40** total. The close fee can change because your position value and Hyperliquid rate can change. A full **FLIP** uses one order for twice your current position size. For example, reversing a $1,000 long into a $1,000 short trades about $2,000 of value. Fees apply to the amount that actually fills, so a partial fill costs less and may not complete the flip. An order that never fills does not pay a trading fee. ## Funding is not a Bloxwap fee **Funding** is an hourly payment between traders that helps keep a perpetual's price aligned with its underlying market. Bloxwap does not collect it. When the funding rate is positive, long traders pay short traders. When it is negative, shorts pay longs. Hyperliquid values the position using a reference price called the **oracle price**, and the rate changes over time. If the rate is 0.001% and the oracle values your position at $1,000 at an hourly settlement, the payment is **$0.01**. Hold through six settlements while both numbers stay the same, and the paying side pays **$0.06**. The other side receives it. Learn how funding affects your final result in [How Bloxwap payouts work](https://bloxwap.com/blog/bloxwap-payouts-explained). ## There is no spam-escalation fee Current Bloxwap does not raise your fee because you trade quickly or hold several positions. Each filled order pays its normal fees, but the rate does not climb with your position count. If you find an old Bloxwap table showing a 10% base fee, a tick-distance borrow fee, or a fee increase after four positions, it describes the retired product. Those charges do **not** apply to today's Bloxwap app on Hyperliquid. Demo trades use virtual funds and do not pay exchange or builder fees. Deposits and withdrawals can have separate app, sponsorship, network, or bridge costs, shown before you confirm the transfer. --- # Understanding profit and loss > Follow a trade from opening to closing, including fees, funding, and liquidation. Source: https://bloxwap.com/blog/bloxwap-payouts-explained Your trading result depends on the price move, position size, and direction you chose. Closing a position realizes its profit or loss. Trading fees and funding also affect the final result. Bloxwap trades [perpetual futures](https://bloxwap.com/blog/what-are-perpetual-futures) on Hyperliquid. The examples below follow a position from entry to exit in **USDC**, a stablecoin designed to track the US dollar. ## How a position settles You open a trade in one direction: - **Tap UP** to go **long**. You think the price will rise. - **Tap DOWN** to go **short**. You think the price will fall. The collateral backing your position is its **margin**. **Leverage** multiplies the position size: at 10× leverage, 50 USDC of margin supports a $500 position. Price gains and losses remain **unrealized** while the position is open. Closing realizes that result. Fees are charged on fills, and funding can change your balance while you hold the position. ## Closing in profit You go long on Bitcoin with **50 USDC** margin at 10x leverage. That controls a **$500** position. Bitcoin rises **4%**. Your $500 position gains 4% → **+$20**. Before costs, that's **$70**: your $50 margin plus the $20 gain. Bitcoin moved 4%, while the gain is **40% of your starting margin**. The $20 is **gross profit**, before costs. At the standard base-tier rate of **0.095% per fill** in the [fee guide](/bloxwap-fee-guide): - Opening $500 costs **$0.475**. - Closing at $520 costs **$0.494**. - Net profit after these fees is **$19.031**, or about **$19.03**, before funding. Live net P&L in the app includes trading fees and available funding data. It remains an estimate until the closing order fills. ## Closing at a loss Same setup: **50 USDC** margin, long Bitcoin, 10x leverage, $500 position. This time Bitcoin **falls 4%**. Your position loses **$20** (−40% on your margin). Before fees and funding, **$50 − $20 = $30** remains. With cross margin, a position can draw on other collateral in the trading account. The amount selected for one trade is not necessarily a cap on the funds exposed to liquidation. ## Liquidation **Liquidation** is the forced closing of a position that no longer meets Hyperliquid's margin requirements. Suppose you go long on Bitcoin at **$100,000**, using **50 USDC** at 10× leverage, and that is all the collateral in your account. The position is worth $500. A 10% drop would produce a $50 price loss, consuming the initial margin before costs. Liquidation can happen earlier because the exchange requires maintenance margin. Check the app's estimated liquidation price rather than treating a 10% move as a fixed threshold. Fees, funding, margin mode, and other collateral affect it. Extra collateral can move liquidation further away while exposing more funds to the position's losses. ## Funding **Funding** is a recurring payment between long and short holders that helps align a perpetual's price with its underlying market. Hyperliquid settles it hourly. Depending on the rate and your position, you pay or receive it. Funding can accumulate while a position remains open. ## Fees You pay fees when you open and when you close. There are two parts: 1. **Hyperliquid's exchange fee:** the standard rate every trade on the exchange pays. 2. **The Bloxwap builder fee:** a flat **5 bps (0.05%)** of your trade, or **2.5 bps** for [Genesis](https://bloxwap.com/docs/genesis) traders. Subtract trading fees and add any funding received, or subtract funding paid, to move from gross to net P&L. See the full [fee breakdown](https://bloxwap.com/docs/fees). ## FAQ **Is only the margin I selected at risk?** With cross margin, other collateral in the trading account can also support the position and be exposed to losses. **What's the difference between gross and net?** Gross is your raw price gain or loss. Net accounts for trading fees and funding paid or received. **When does my balance change?** Fees apply when orders fill, and funding payments occur while positions are open. Closing or liquidation realizes the position's price gain or loss. --- Practice the flow in [Demo](https://bloxwap.app) with virtual funds before trading live. If the terminology is new, start with the [guide to perpetual futures](/what-are-perpetual-futures). Leverage magnifies losses as well as gains. --- # Bloxwap Signals: how Swing and Trend work > Read Trend's recent market moves and Swing's trade setups, including entry, stop-loss, and take-profit levels. Source: https://bloxwap.com/blog/bloxwap-signals Bloxwap has two kinds of signals. **Trend** highlights markets that have just moved. **Swing** brings together a direction, leverage, and price levels for a trade setup. Understanding what each signal tells you helps you decide what to look at and whether to act. ## Trend: see what just moved Trend describes recent market activity. Its directional marks look for a large, efficient 15-minute move while volatility is expanding. An efficient move makes progress in one direction with less back-and-forth along the way. The three Trend states, shown with real app explanation cards. The drawn price path is illustrative. View full-size image. The three states have different meanings: - **UP:** a large, efficient move up on expanding volatility. - **DOWN:** a large, efficient move down on expanding volatility. - **WATCH:** volatility is expanding, but there is no clear direction yet. Open **Markets → Trend** to look for markets with these marks. You can also enable the **Live Activity Feed** in **Profile → Signals** for a rolling feed of signal fires. A Trend mark describes a move that has already happened. It does not predict that the move will continue. An UP mark can be followed by a pullback; a DOWN mark can be followed by a rebound. Use the mark to find something worth inspecting, then look at the chart and your trade controls before making a decision. WATCH gives you activity to investigate without choosing a side. ## Swing: read the whole setup A Swing signal includes the market, **LONG or SHORT** direction, leverage, confidence, and three price levels: **entry**, **stop-loss**, and **take-profit**. LONG benefits from a rise in price; SHORT benefits from a fall. The in-app alert puts the market, leverage, direction, and confidence bars in a compact card. Confidence runs from **1 to 5 bars**, from lowest to highest. A four-bar reading displays the signal's confidence score; it does not mean an 80% chance of profit. A real Swing example card paired with hypothetical BTC price levels. These prices are an illustration, not a live signal. View full-size image. For the illustrated LONG setup, the levels mean: | Level | Example price | What it tells you | | ----------- | ------------- | ------------------------------------------------------ | | Entry | $60,000 | The reference price for entering the setup. | | Stop-loss | $59,400 | The intended exit if price moves against the position. | | Take-profit | $61,200 | The intended exit if price reaches the target. | For a SHORT setup, the stop is above entry and the target is below it. Entry is a reference level, and the actual fill can differ. Stop-loss and take-profit prices are triggers, not guaranteed execution prices. See [Hyperliquid's explanation of TP/SL orders](https://hyperliquid.gitbook.io/hyperliquid-docs/trading/take-profit-and-stop-loss-orders-tp-sl) for how those exits execute. ## Turn on Swing and understand the Open action Swing is a **Genesis** feature. Sign in with an eligible wallet, open **Profile → Signals**, and enable **Swing**. For device alerts, enable push notifications and Swing notifications under **Settings → Notifications**. Device support and setup vary; the [notifications guide](/docs/subscribe) walks through the requirements. A Swing push notification includes the entry, stop, and target. On devices that support notification actions, it offers **Open** and **Dismiss**. **Open is a trade action.** It can submit a live position using the signal's direction, leverage, and exit levels, together with your currently selected trade amount. Opening a Swing push can switch the app from Demo to Live. Check your amount and wallet before using it. Dismiss closes the notification without opening a trade. The app checks the signal's expiry, the current price against its permitted entry range, and whether your wallet is ready. An expired setup or a price that has already crossed an exit can prevent the trade from opening. After opening, check your position to confirm the fill and attached exits. ## Keep the risk in view Neither signal guarantees a profitable trade. Leverage magnifies losses as well as gains, and fees, funding, and liquidation risk still apply. A stop-loss helps define an exit plan, but cannot guarantee a maximum loss. [Open Bloxwap](https://bloxwap.app) to explore Signals in your profile. If you're new to the controls, start with the [trading screen tour](/how-it-works), review the [fees](/docs/fees), and learn how to [set a stop-loss](/docs/how-to/set-a-stop-loss). --- # Bloxwap and Hyperliquid > How the app and the exchange work together, and what each provides. Source: https://bloxwap.com/blog/bloxwap-vs-hyperliquid **Hyperliquid is the exchange. Bloxwap is an app for trading on it.** Hyperliquid matches and settles orders; Bloxwap provides the controls you use to place them. ## At a glance | Aspect | Hyperliquid | Bloxwap | | ------ | ----------- | ------- | | What it is | The exchange (the "protocol") | An app to trade on it (the "interface") | | Its job | Holds the order book, matches trades, settles them | Gives you a one-tap way to place those trades | | You interact with | A full trading screen | Two buttons: **UP** and **DOWN** | | Where trades settle | On Hyperliquid | On Hyperliquid, from your wallet | | Runs on | Its own blockchain | Hyperliquid | | Best for | Advanced traders who want every tool | Anyone who wants to trade fast from their phone | ## What Hyperliquid is Hyperliquid is a **decentralized exchange** running on its own blockchain. It maintains the **order book**, a live list of buy and sell offers, matches orders, and records the resulting trades and balances. Hyperliquid specializes in **perpetuals**, or "perps." A perp is a trade on whether a price goes up or down, without owning the thing itself. You're not buying Bitcoin; you're trading on which way its price moves. A perp has no fixed expiry date, but an open position must continue to meet margin requirements. Hyperliquid is powerful, but its screen is built for experienced traders: order types, charts, margins, and a lot of numbers. ## What Bloxwap is Bloxwap is a **trading interface** designed for a phone. Set your market, size, and leverage, then choose a direction: - **Tap UP** if you think the price will rise (this is called going **long**). - **Tap DOWN** if you think it will fall (going **short**). You fund trades with **USDC**, a digital dollar worth about $1. You can add **leverage**, which magnifies gains and losses. At 10× leverage, a 1% price move means roughly a 10% gain or loss on starting margin, before fees and funding. Bloxwap doesn't run an exchange and never holds your money. It hands your trade to Hyperliquid, where it settles. For the full walkthrough, read [What is Bloxwap?](https://bloxwap.com/blog/what-is-bloxwap) ## Where they overlap, and where they differ Bloxwap orders reach **Hyperliquid's order books**. Execution still depends on your order, its size, and available liquidity. The main differences concern controls, wallet setup, and interface fees: - **Custody (who holds your money):** Both are **non-custodial**. Your funds stay in your own wallet. On Bloxwap you approve a trading-only permission once, which can place trades for you but can't withdraw your funds. - **Settlement:** Every Bloxwap trade settles on Hyperliquid. - **Controls:** Hyperliquid's own interface exposes more order-entry tools. Bloxwap emphasizes compact controls for opening, closing, and managing positions. - **Fees:** You pay Hyperliquid's normal trading fees either way. Bloxwap adds a small builder fee on top. See the exact numbers on the [fees page](https://bloxwap.com/docs/fees). ## When to use each - **Use Bloxwap** if you want to trade quickly from your phone, you like the simplicity of two buttons, and you don't need advanced order tools. - **Use Hyperliquid directly** if you're an experienced trader who wants limit orders, detailed charts, and fine control over every setting. You don't have to pick forever. Because both are non-custodial and use the same markets, your positions live on Hyperliquid no matter which app you place them from. ## FAQ **Is Bloxwap a competitor to Hyperliquid?** No. Bloxwap sends orders to Hyperliquid and uses its settlement system. **Does Bloxwap hold my money?** No. Bloxwap is non-custodial. Your USDC stays in your wallet, every trade settles on Hyperliquid, and Bloxwap can't withdraw your funds. **Do I trade on the same order books?** Yes. Your fill price still depends on market movement, order size, and liquidity. Using the same market does not guarantee identical fills. **What can I trade?** The Hyperliquid markets Bloxwap supports: crypto like Bitcoin and Ethereum, plus perpetuals tracking stocks, commodities, and indices. Availability depends on the market and your region. See the [assets page](https://bloxwap.com/docs/assets). **Is it risky?** Yes. Trading perps can lose money, and leverage increases that risk. Try the flow in Demo first, and if perps are new to you, start with [What are perpetual futures?](https://bloxwap.com/blog/what-are-perpetual-futures) Only trade what you can afford to lose. --- # Tap-to-trade or a full trading terminal? > Compare a quick mobile trade with the controls of a traditional order form. Source: https://bloxwap.com/blog/bloxwap-vs-traditional-perp-trading A traditional trading screen gives you an order form with controls for price, size, and order type. Bloxwap keeps your core choices in a compact mobile setup, then lets you tap **UP** to go long or **DOWN** to go short. Both approaches can place a **perpetual**, or **perp**: a contract tracking a price without a fixed expiry. Bloxwap orders route to and settle on Hyperliquid. If perps are new to you, start with [What are perpetual futures?](/what-are-perpetual-futures). ## What a traditional perp screen asks you to do A full perp exchange is designed to expose nearly every choice. You may see an **order book**, the live list of prices where people want to buy and sell. You choose an order type, enter a price, set a position size, select leverage, and decide whether the order should stay open if it cannot trade right away. That control is useful. A **limit order**, for example, lets you choose a price and wait for the market to reach it. The screen also shows the **liquidation price**. Liquidation is the exchange's automatic closing of a position that no longer meets its margin requirements. The same risk applies whichever interface you use. ## What Bloxwap changes Bloxwap is a non-custodial, mobile-first interface for the same kind of perp. **Non-custodial** means you keep control of your wallet and its keys. Bloxwap does not take possession of your money. You choose a market, your USDC amount, leverage, stop loss, and take profit in a compact setup. **USDC** is a digital dollar worth about $1. Once those choices are ready, direction becomes one gesture: - Tap **UP** to open a long, which gains when the market rises. - Tap **DOWN** to open a short, which gains when the market falls. Bloxwap submits the order to Hyperliquid. A successful fill opens the position; its profit or loss then changes with the market. Fees, funding, and liquidation risk apply just as they do when using a larger trading screen. ## Side-by-side comparison | Question | Traditional perp interface | Bloxwap tap-to-trade | | -------------------- | ----------------------------------- | --------------------------------- | | How do you enter? | Complete an order ticket | Set up once, then tap UP or DOWN | | Main strength | Detailed control | Speed and clarity on a phone | | Order choices | Market, limit, and advanced types | Tap entry with position controls | | Price and settlement | Exchange order book | The same Hyperliquid order books | | Custody | Depends on the platform | Non-custodial; you keep your keys | | Best fit | Precise execution and complex plans | Fast directional trades | ## A 50 USDC example Suppose you have **50 USDC** and choose 5x leverage. Leverage multiplies the size of a trade, so your $50 backs a **$250 position**. On a traditional screen, you might choose "market," type $50, select 5x, pick long, review the estimated liquidation price, and submit. On Bloxwap, you set the same size and leverage in its mobile controls, then tap **UP**. If the asset rises 2%, the $250 position gains about $5 before fees and funding. That is a 10% gain on your $50. If the asset falls 2%, the position loses about $5. Bloxwap makes the entry shorter, but it does not change that math. Read [How Bloxwap payouts work](/bloxwap-payouts-explained) for complete profit, loss, funding, and liquidation examples. ## Simplicity versus control Tap-to-trade keeps repeated actions close at hand. You can open, close, or flip a position from the trading controls. See the [trading-screen tour](/how-it-works) for a walkthrough. The trade-off is control. A full terminal is better when an exact entry price, a resting limit order, or a complex plan matters more than speed. Bloxwap focuses on immediate directional trades. Neither approach removes risk. Leverage makes gains and losses larger. Fast entry can also make it easier to trade before thinking through the downside. Check the liquidation estimate, use a size you can afford to lose, and review the current [fees](https://bloxwap.com/docs/fees) and [available markets](https://bloxwap.com/docs/assets) before you tap. Try the flow in Demo first to see how size and leverage behave without real money at risk. ## Which one is for you? Bloxwap suits traders who prefer compact mobile controls for directional positions. A full terminal offers more room for detailed market data, resting orders, and complex order entry. Choose the interface whose controls you understand. In either case, review the position size, leverage, and costs before placing an order. --- # Build a trading agent with the Bloxwap SDK and MCP > A step-by-step TypeScript tutorial: read Bloxwap Swing signals over MCP, check each setup against your own risk limits, and trade it on Hyperliquid with the Bloxwap builder code through a revocable agent wallet. Source: https://bloxwap.com/blog/build-a-trading-agent-with-the-bloxwap-sdk-and-mcp This tutorial builds a small trading agent in TypeScript. It reads Bloxwap **Swing** signals, checks each setup against limits you set, and trades the ones that pass on Hyperliquid, with a stop and a target attached. Every order carries the **Bloxwap builder code**, so it's priced exactly like a trade placed in the app. The agent uses two tools, each for what it does well: - **The [Bloxwap MCP server](/connect-your-ai-agent-to-bloxwap)** for signals. The agent connects to `https://bloxwap.app/mcp` and calls `get_swing_signals`, which needs no sign-in. - **The [`@bloxwap/hyperliquid`](https://bloxwap.github.io/hyperliquid/docs/) SDK** for prices, positions, and orders, signed in your own process by an **agent wallet**: a key that can trade for your account but can't withdraw from it. The MCP server doesn't place trades. Its order tools turn away every call until an agent can sign with a narrowly scoped key of its own. So in this tutorial, signing happens in your code, with a key that only you hold. **This agent trades real money.** It runs as a dry run until you switch that off, and the defaults risk $20 of margin per trade. Leverage magnifies losses as well as gains, and no signal guarantees a profit. Read [Keep the risk in view](#keep-the-risk-in-view) before you go live. ## What you'll build Once a minute, the agent: 1. Calls `get_swing_signals` on the Bloxwap MCP server. 2. Reads live prices and your open positions from Hyperliquid. 3. Runs each setup through a **risk gate**: your limits on margin, leverage, stop distance, and expiry. 4. Opens a position for each setup that passes, using an immediate-or-cancel order with the builder code attached. 5. Attaches a stop-loss and a take-profit sized to the actual fill. The whole agent is one file, about 350 lines with comments. This guide builds it in seven parts. Paste each block into `agent.ts` in order and you'll have the complete program. ## Before you start You'll need: - **Node.js 22.18 or later, or Bun 1.3.3 or later.** Both run TypeScript files directly. - **A Hyperliquid account with USDC in it.** If you trade on Bloxwap, that's the account you already have. - **One trade on Bloxwap from that account.** Your first trade approves the Bloxwap builder fee. The agent checks the approval before it starts. [Approve the builder fee](#approve-the-builder-fee) explains why it matters. ## 1. Set up the project Create a folder and install the SDK and the MCP client: ```sh mkdir swing-agent && cd swing-agent npm init -y && npm pkg set type=module npm install @bloxwap/hyperliquid @modelcontextprotocol/sdk ``` With Bun, run `bun init -y` and `bun add` instead. The SDK installs two optional packages, `tiny-secp256k1` and `hash-wasm`, which give it WebAssembly signing and hashing. There's nothing to configure. ## 2. Create an agent wallet The agent signs orders with its own key, never with your main wallet's. Hyperliquid calls this an **agent wallet** (or API wallet). Once you approve it, it can place and cancel orders for your account, but it can't withdraw or transfer funds. You can revoke it at any time. Generate a key and store it in a `.env` file, which you keep out of version control: ```sh echo "HYPERLIQUID_AGENT_KEY=0x$(openssl rand -hex 32)" >> .env echo "HYPERLIQUID_ACCOUNT_ADDRESS=0xYourAccountAddress" >> .env echo ".env" >> .gitignore ``` `HYPERLIQUID_ACCOUNT_ADDRESS` is the **public address** of the account you trade with. Replace the placeholder with it. To approve the agent, you need its address. This script prints it: ```ts title="address.ts" import { getWalletAddress } from '@bloxwap/hyperliquid/signing'; console.log(await getWalletAddress(process.env.HYPERLIQUID_AGENT_KEY as `0x${string}`)); ``` ```sh node --env-file=.env address.ts # or: bun address.ts ``` Open [Hyperliquid's API page](https://app.hyperliquid.xyz/API), connect the wallet you trade with, and authorize the printed address as an API wallet. Give it a name you'll recognize, such as `swing-agent`. **Never put your main wallet's private key or seed phrase in this file, in code, or in a prompt.** The agent doesn't need either one, and Bloxwap will never ask for them. If the agent key ever leaks, revoke it on the same page. Your funds stay where they are. ### Approve the builder fee A **builder code** is how an app gets credit for the orders it routes to Hyperliquid. Each order names a builder address and a fee, and Hyperliquid charges that fee only if the account has approved it for that builder. Bloxwap's builder fee is **0.05%** of the order's value per fill, or 0.025% for [Genesis](/docs/genesis) traders. That's the same fee you pay in the app. The [fees page](/docs/fees) has the full breakdown, including Hyperliquid's own exchange fee. Only your main wallet can approve a builder fee. An agent wallet can't. Your first trade on Bloxwap asks for that approval, so if you've traded here, you're set. The agent checks the approval at startup and stops with a clear message if it's missing. ## 3. Configure the agent Start `agent.ts` with the imports: ```ts title="agent.ts" // agent.ts: trade Bloxwap Swing signals on Hyperliquid with the Bloxwap builder code. import { Client } from '@modelcontextprotocol/sdk/client/index.js'; import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js'; import { ExchangeClient, HttpTransport, InfoClient } from '@bloxwap/hyperliquid'; import { buildOrder } from '@bloxwap/hyperliquid/api/exchange'; import { getWalletAddress, warmupSigning } from '@bloxwap/hyperliquid/signing'; import { formatPrice, formatSize } from '@bloxwap/hyperliquid/utils'; ``` Then the configuration. `LIMITS` holds the rules the agent will never break, whatever a signal suggests. The defaults are deliberately small: ```ts title="agent.ts" // ---------- 1. Configuration ---------- function hexEnv(name: string, length: number, hint: string): `0x${string}` { const value = process.env[name]?.toLowerCase(); if (!value || !new RegExp(`^0x[0-9a-f]{${length}}$`).test(value)) { throw new Error(`Set ${name} to ${hint}`); } return value as `0x${string}`; } const DRY_RUN = process.env.DRY_RUN !== 'false'; // dry run unless you opt out const ACCOUNT = hexEnv('HYPERLIQUID_ACCOUNT_ADDRESS', 40, 'your public account address'); const AGENT_KEY = hexEnv('HYPERLIQUID_AGENT_KEY', 64, 'your agent wallet key'); // Bloxwap's builder address, and the standard builder fee in tenths of a basis point (50 = 0.05%). const BUILDER = '0x71b09a08257078a4d642f7dd7315e656c837329a'; const BUILDER_FEE = 50; // Your limits. The agent never trades outside them, whatever a signal suggests. const LIMITS = { marginUsd: 20, // collateral per trade, at the planned entry price maxLeverage: 3, // your own cap, below the signal's and the market's maxStopPct: 2, // furthest the stop may sit from the live price, in percent minMinutesLeft: 10, // skip setups that expire sooner than this slippageBps: 50, // entry limit sits 0.5% through the mid }; const POLL_MS = 60_000; const ENTRY_TTL_MS = 5_000; // Hyperliquid drops an entry that hasn't run within this window ``` A few notes: - **`DRY_RUN` is on unless you set it to `false`.** In a dry run the agent does everything except sign and send orders. - **`BUILDER_FEE` is in tenths of a basis point.** A basis point is 0.01%, so 50 tenths is 5 basis points, or 0.05%. If you hold Genesis, set it to 25. - **`maxLeverage` caps leverage below the signal's suggestion and the market's maximum.** Both of those are ceilings, not targets. ## 4. Connect the clients Next, the clients. There's one HTTP transport for Hyperliquid, which keeps its connection warm, and one connection to the Bloxwap MCP server: ```ts title="agent.ts" // ---------- 2. Clients ---------- // One transport for the life of the process keeps the HTTPS connection warm. const transport = new HttpTransport(); const info = new InfoClient({ transport }); // Passing the raw key string makes the SDK sign with WASM secp256k1. const exchange = new ExchangeClient({ transport, wallet: AGENT_KEY }); const mcp = new Client({ name: 'swing-agent', version: '1.0.0' }); await mcp.connect(new StreamableHTTPClientTransport(new URL('https://bloxwap.app/mcp'))); ``` `ExchangeClient` accepts the raw key string as its wallet. Given a key string, the SDK signs with `tiny-secp256k1`, a WebAssembly build of the same secp256k1 library Bitcoin uses, and falls back to pure JavaScript where WebAssembly can't load. ## 5. Read Swing signals over MCP The MCP client calls `get_swing_signals` like any other tool. Passing `tradableOnly: true` leaves out test signals. The server returns the setups as structured data under `structuredContent`: ```ts title="agent.ts" // ---------- 3. Signals from the Bloxwap MCP server ---------- type SwingSignal = { coin: string; signalId: string; direction: 'LONG' | 'SHORT'; entryPrice: number; stopLoss: number; takeProfit: number; leverage: number; confidence: number | null; expiresAt: number; tradable: boolean; entryPriceMin?: number | null; entryPriceMax?: number | null; }; async function getSwingSignals(): Promise { const result = await mcp.callTool({ name: 'get_swing_signals', arguments: { tradableOnly: true }, }); if (result.isError) { throw new Error(`get_swing_signals failed: ${JSON.stringify(result.content)}`); } const data = result.structuredContent as { signals?: SwingSignal[] } | undefined; return data?.signals ?? []; } ``` Each setup has a direction, an entry price with an optional entry range, a stop, a target, a suggested leverage, and an expiry time. [Let your AI agent read Trend and Swing signals](/let-your-agent-read-trend-and-swing-signals) explains every field. ## 6. Read markets and positions from Hyperliquid Hyperliquid identifies each perpetual market by its position in the exchange's market list, its **asset ID**. `szDecimals` sets how finely a size can be split, and it also limits how many decimals a price can have: ```ts title="agent.ts" // ---------- 4. Market data and positions from Hyperliquid ---------- type Market = { assetId: number; szDecimals: number; maxLeverage: number }; async function loadMarkets(): Promise> { const meta = await info.meta(); const markets = new Map(); meta.universe.forEach((m, assetId) => { if (m.isDelisted) return; markets.set(m.name, { assetId, szDecimals: m.szDecimals, maxLeverage: m.maxLeverage }); }); return markets; } async function openCoins(): Promise> { const state = await info.clearinghouseState({ user: ACCOUNT }); return new Set(state.assetPositions.filter((p) => Number(p.position.szi) !== 0).map((p) => p.position.coin)); } ``` `openCoins` reads your account by its public address, so it doesn't need a signature. The agent uses it to keep to one position per market. ## 7. Write the risk gate The gate turns a signal into an exact order, or explains why it won't. Every check reads the live price, not the price when the signal was made: ```ts title="agent.ts" // ---------- 5. The risk gate ---------- type Plan = { coin: string; market: Market; isBuy: boolean; leverage: number; size: string; entryPx: string; stopPx: string; targetPx: string; }; // Returns a plan, or the reason the setup was skipped. function plan(s: SwingSignal, market: Market | undefined, mid: number, held: Set): Plan | string { if (!market) return 'market not listed'; if (held.has(s.coin)) return 'already holding a position'; if (s.expiresAt - Date.now() < LIMITS.minMinutesLeft * 60_000) return 'expires too soon'; if (!(mid > 0)) return 'no live price'; if (s.entryPriceMin != null && mid < s.entryPriceMin) return 'price below the entry range'; if (s.entryPriceMax != null && mid > s.entryPriceMax) return 'price above the entry range'; // Round prices to the market's rules first, then check what will actually be sent. const px = (n: number) => formatPrice(n, market.szDecimals); const isBuy = s.direction === 'LONG'; const stopPx = px(s.stopLoss); const targetPx = px(s.takeProfit); const stop = Number(stopPx); const target = Number(targetPx); const stopOnRightSide = isBuy ? stop < mid : stop > mid; const targetOnRightSide = isBuy ? target > mid : target < mid; if (!stopOnRightSide || !targetOnRightSide) return 'price has moved past a level'; const stopPct = (Math.abs(mid - stop) / mid) * 100; if (stopPct > LIMITS.maxStopPct) return `stop is ${stopPct.toFixed(2)}% away`; const leverage = Math.floor(Math.min(s.leverage, LIMITS.maxLeverage, market.maxLeverage)); if (leverage < 1) return 'leverage below 1x'; const slip = LIMITS.slippageBps / 10_000; const entryPx = isBuy ? px(mid * (1 + slip)) : roundUpPx(mid * (1 - slip), market.szDecimals); const entrySlip = Math.abs(Number(entryPx) - mid) / mid; if (entrySlip > slip) return 'price too coarse for the slippage limit'; // Size from the worse of the mid and the entry limit: a long that fills at its limit // still uses no more than marginUsd. const notional = LIMITS.marginUsd * leverage; const rawSize = notional / Math.max(mid, Number(entryPx)); const size = rawSize >= 10 ** -market.szDecimals ? formatSize(rawSize, market.szDecimals) : '0'; if (Number(size) * mid < 10) return 'below the $10 minimum order'; return { coin: s.coin, market, isBuy, leverage, size, entryPx, stopPx, targetPx }; } // formatPrice truncates, which moves a sell limit away from the mid. Step it back up a tick. function roundUpPx(target: number, szDecimals: number): string { const down = formatPrice(target, szDecimals); if (Number(down) >= target) return down; // One tick: five significant figures, at most 6 - szDecimals decimals, never coarser than 1. const exp = Math.floor(Math.log10(Number(down))) + 1; const tick = 10 ** Math.min(Math.max(exp - 5, szDecimals - 6), 0); return formatPrice(Number(down) + 1.5 * tick, szDecimals); } ``` In order, the gate skips a setup when: - **The market isn't listed**, or you already hold a position in it. - **It expires within 10 minutes.** A setup that's about to expire leaves no room to manage the trade. - **Price has left the entry range.** If the market has already run, the setup's levels no longer describe the trade you'd get. - **Price has moved past the stop or the target.** Opening then would trigger an exit right away. - **The stop is more than 2% away.** At 3× leverage, a 2% move against you costs about 6% of your margin, plus fees. - **The order would be under $10.** That's Hyperliquid's minimum order value. The entry is a limit order 0.5% through the mid price. It fills right away at the best prices available inside that band, and any part it can't fill is cancelled. The size is worked out from the worse of the mid and that limit price, so a long that fills at the top of the band still uses no more than `marginUsd`. A short can fill above the mid if price rises first. That uses a little more margin, but with the stop fixed, the loss at the stop is smaller. `formatPrice` and `formatSize` round values to the market's rules: at most five significant figures for a price, and no more decimals than `szDecimals` allows for a size. Hyperliquid rejects orders that break those rules. Both helpers round down, and the gate checks the rounded prices, not the originals. Rounding down would push a short's entry limit further from the mid, so `roundUpPx` rounds it up instead. If a market's price steps are too coarse to fit inside the slippage limit, the gate skips it. ## 8. Place orders with the builder code The order fields are terse. `a` is the asset ID, `b` is buy or sell, `p` is the price, `s` is the size, `r` marks the order reduce-only, and `t` is the order type. The `builder` object carries the Bloxwap builder address and fee on every order: ```ts title="agent.ts" // ---------- 6. Execution ---------- // Every order carries the Bloxwap builder code. const builder = { b: BUILDER, f: BUILDER_FEE } as const; // a = asset, b = is buy, p = price, s = size, r = reduce only, t = order type. function entryOrder(p: Plan) { // Keys in schema order, normalized decimal strings, a lowercase builder address: // the canonical wire form that lets the live path skip validation. return { orders: [ { a: p.market.assetId, b: p.isBuy, p: p.entryPx, s: p.size, r: false, t: { limit: { tif: 'Ioc' as const } }, }, ], grouping: 'na' as const, builder, }; } function protectionOrder(p: Plan, size: string) { const close = { a: p.market.assetId, b: !p.isBuy }; return { orders: [ // Stop: becomes a market order once the mark price reaches the trigger. { ...close, p: p.stopPx, s: size, r: true, t: { trigger: { isMarket: true, triggerPx: p.stopPx, tpsl: 'sl' as const } }, }, // Target: a limit order at the target price, so it never fills worse than planned. { ...close, p: p.targetPx, s: size, r: true, t: { trigger: { isMarket: false, triggerPx: p.targetPx, tpsl: 'tp' as const } }, }, ], grouping: 'positionTpsl' as const, builder, }; } async function execute(p: Plan) { if (DRY_RUN) { // Validate both actions exactly as the SDK would before signing; nothing is signed or sent. buildOrder(entryOrder(p)); buildOrder(protectionOrder(p, p.size)); console.log( `[dry run] ${p.isBuy ? 'LONG' : 'SHORT'} ${p.size} ${p.coin} @ ${p.entryPx} limit,`, `${p.leverage}x isolated, stop ${p.stopPx}, target ${p.targetPx}`, ); return; } // Isolated margin caps the loss on this position at its own margin. await exchange.updateLeverage({ asset: p.market.assetId, isCross: false, leverage: p.leverage, }); const t0 = performance.now(); const expiresAfter = Date.now() + ENTRY_TTL_MS; try { const entry = await exchange.order(entryOrder(p), { skipValidation: true, expiresAfter }); const status = JSON.stringify(entry.response.data.statuses[0]); console.log(`${p.coin}: entry ${status} in ${(performance.now() - t0).toFixed(0)} ms`); } catch (error) { // A rejected entry throws, but so does a lost response to an entry that filled. // Wait out the expiry: after it, an entry that hasn't run never will. console.error(`${p.coin}: entry request failed`, error); await new Promise((resolve) => setTimeout(resolve, expiresAfter - Date.now() + 1_000)); } try { await protect(p); } catch (error) { // Never leave a position without its stop: close it at once. console.error(`${p.coin}: could not protect the position, closing`, error); await closeOrHalt(p); } } // The account, not the entry's response, says what filled. Protect exactly that size. async function protect(p: Plan) { const size = await positionSize(p.coin); if (Number(size) === 0) { console.log(`${p.coin}: no position opened`); return; } await exchange.order(protectionOrder(p, size)); console.log(`${p.coin}: holding ${size}, stop ${p.stopPx}, target ${p.targetPx}`); } // The open size as Hyperliquid reports it, already at the market's size precision. async function positionSize(coin: string): Promise { const state = await info.clearinghouseState({ user: ACCOUNT }); const position = state.assetPositions.find((a) => a.position.coin === coin); return position ? position.position.szi.replace('-', '') : '0'; } // Close the position with reduce-only orders until it's flat. If that can't be confirmed, // stop the agent: an unprotected position needs a person. async function closeOrHalt(p: Plan) { try { for (let attempt = 1; attempt <= 3; attempt++) { const size = await positionSize(p.coin); if (Number(size) === 0) return; const mid = Number((await info.allMids())[p.coin]); await exchange .order({ orders: [ { a: p.market.assetId, b: !p.isBuy, p: formatPrice(p.isBuy ? mid * 0.95 : mid * 1.05, p.market.szDecimals), s: size, r: true, t: { limit: { tif: 'Ioc' } }, }, ], grouping: 'na', builder, }) .catch((error) => console.error(`${p.coin}: close attempt ${attempt} failed`, error)); } if (Number(await positionSize(p.coin)) === 0) return; } catch (error) { console.error(`${p.coin}: could not confirm the close`, error); } console.error(`${p.coin}: POSITION MAY BE OPEN WITHOUT A STOP. Check the Bloxwap app now.`); process.exit(1); } ``` The agent works in two steps: 1. **Open the position.** It sets the market to isolated margin at the planned leverage, then sends the entry with the builder code. **Isolated margin** keeps this position's losses within its own margin instead of drawing on the rest of your account. 2. **Protect what filled.** It reads the open size from your account and attaches a stop and a target for exactly that size, grouped as `positionTpsl`, so they close the position they belong to. The agent reads the size from the account, not from the order's response, on purpose. If the network drops the response to an entry that filled, the request fails, but the position is still there and still gets its stop. The entry also carries `expiresAfter`, a deadline five seconds out. Hyperliquid rejects the order if it hasn't run by then. When an entry request fails, the agent waits out that deadline before reading the account, so a request that was only delayed can't open a position after the agent has looked. This relies on your computer's clock being roughly right. Why not send the entry and its exits in one request? Hyperliquid can bundle them, but if the entry fills only partly, it cancels the bundled exits. Sizing the exits from the account avoids that. An open position without a stop is the outcome the agent exists to avoid. If the agent can't read the position, or Hyperliquid rejects the stop and target, `closeOrHalt` closes the position with reduce-only orders, checking the account after each attempt. If it can't confirm the position is flat after three tries, it prints a warning and stops the whole agent, because that position now needs a person. The stop becomes a market order when Hyperliquid's mark price reaches the trigger. The target is a limit order at the target price, so it never fills worse than planned, but it can be left unfilled if price touches the level and turns. Neither one guarantees an exit price in a fast market. ## 9. Run the loop The last part checks the setup before it trades, then polls once a minute: ```ts title="agent.ts" // ---------- 7. The loop ---------- async function main() { // Preflight: the agent wallet is approved for your account, and the builder fee is approved. const agentAddress = await getWalletAddress(AGENT_KEY); const role = await info.userRole({ user: agentAddress }); if (role.role !== 'agent' || role.data.user.toLowerCase() !== ACCOUNT) { throw new Error(`Agent wallet ${agentAddress} is not approved for ${ACCOUNT}`); } const approvedFee = await info.maxBuilderFee({ user: ACCOUNT, builder: BUILDER }); if (approvedFee < BUILDER_FEE) { throw new Error('Approve the Bloxwap builder fee: trade once in Bloxwap with this account'); } // Load WASM and compile the signing path now, not on the first order. await warmupSigning(AGENT_KEY); const markets = await loadMarkets(); const acted = new Set(); // signals already acted on in this run const lastSkip = new Map(); // log each skip reason once per signal console.log(`swing agent running (${DRY_RUN ? 'dry run' : 'LIVE'}) for ${ACCOUNT}`); const tick = async () => { const [signals, mids, held] = await Promise.all([getSwingSignals(), info.allMids(), openCoins()]); for (const s of signals) { if (acted.has(s.signalId)) continue; let result: Plan | string; try { result = plan(s, markets.get(s.coin), Number(mids[s.coin]), held); } catch (error) { result = `could not price the order (${(error as Error).message})`; } if (typeof result === 'string') { if (lastSkip.get(s.signalId) !== result) { console.log(`skip ${s.coin} ${s.direction}: ${result}`); } lastSkip.set(s.signalId, result); continue; } acted.add(s.signalId); await execute(result); held.add(s.coin); } }; for (;;) { await tick().catch((error) => console.error('tick failed', error)); await new Promise((resolve) => setTimeout(resolve, POLL_MS)); } } await main(); ``` Before it does anything else, the agent confirms three things: - **The agent wallet is approved for your account.** `userRole` returns the account an agent wallet belongs to. - **The builder fee is approved.** `maxBuilderFee` returns the highest fee your account allows for the Bloxwap builder. - **The signing path is warm.** `warmupSigning` loads the WebAssembly modules and signs a throwaway action, so the first real order doesn't pay that start-up cost. Nothing is sent. The agent acts on each signal at most once per run, and logs each skip reason once per signal, so the log stays readable. It keeps that memory only while it runs. A restart forgets it, though the one-position-per-market check still applies. ## Run it Start with a dry run: ```sh node --env-file=.env agent.ts # or: bun agent.ts ``` The agent runs every check, builds and validates every order with the SDK's `buildOrder`, and prints what it would do. The output looks like this (illustrative, not a live signal): ``` swing agent running (dry run) for 0x… skip ETH SHORT: already holding a position skip SOL LONG: stop is 3.00% away [dry run] LONG 0.00081 BTC @ 73563 limit, 3x isolated, stop 72465, target 74661 ``` There may be no Swing setups at the moment you start. The agent just waits for the next one. When the dry run looks right, go live with the same small limits: ```sh DRY_RUN=false node --env-file=.env agent.ts ``` Live positions appear in the Bloxwap app like any other trade, with their stop and target. Stop the agent with Ctrl+C. Open positions keep their stop and target on Hyperliquid after the agent stops. ## Low-latency recipes A Swing setup plays out over minutes, so this agent doesn't need to be fast. If you adapt it for faster strategies, the SDK has four levers. The agent already uses the first three. The figures come from the [SDK's own benchmarks](https://bloxwap.github.io/hyperliquid/docs/signing/), measured with Bun on one Linux server, and will vary on your machine: - **Sign with WebAssembly.** Passing the key string as `wallet` signs with WebAssembly secp256k1. In those benchmarks a signed order took about 118 microseconds this way, against about 159 with a pure-JavaScript viem account. - **Warm up before the first order.** A cold process's first order took about 5.5 milliseconds to sign, against about 0.1 once warm. After `warmupSigning`, the first order took about 1.3. - **Skip validation on trusted input.** By default the SDK validates and normalizes every action before signing it. `{ skipValidation: true }` skips that pass, so the input must already be in Hyperliquid's exact wire form: keys in schema order, decimals as normalized strings, and lowercase addresses. The agent uses it only for the entry, whose shape its own code controls. The dry run checks that same shape with `buildOrder`, so an error shows up before any money is involved. - **Batch orders.** One `order()` call can carry many orders under a single signature. In the benchmarks, 100 orders in one call cost about 3.2 microseconds each. Signing takes microseconds. The network round trip to Hyperliquid's API takes far longer, so keep one transport for the life of the process, as the agent does, and run the agent close to the API. The [low-latency recipes](/docs/developers/low-latency) cover more. ## Where an LLM fits This agent has no language model in it, on purpose. The decisions that move money are plain code you can read and test. If you build with LangGraph, CrewAI, or your own loop, keep that split: - **Let the model read.** It can call the Bloxwap MCP server, summarize setups, compare them, or explain one in plain language. - **Let the model veto, never add.** A model step can drop a setup the gate passed. It can't raise a limit or create an order the gate didn't plan. - **Keep the key out of the model's reach.** The agent key belongs to the process that runs `execute`, never in a prompt, a tool argument, or a model's context. In a graph framework, that means a model node between fetching signals and running the gate, and `execute` reachable only from the gate's output. ## Keep the risk in view An agent trades faster than you can watch. These habits keep it inside the lines: - **Start small.** Keep `marginUsd` low until you've watched the agent through many signals, not one good day. - **Watch the first live trades.** Confirm in the app that each position has its stop and target. - **Know how to stop it.** Ctrl+C stops new trades. Revoking the agent wallet on Hyperliquid's API page makes Hyperliquid reject anything it signs. - **Remember that signals can be wrong.** Swing describes a setup, not an outcome. Funding, fees, and liquidation risk still apply. [Agent permissions](/docs/developers/permissions) covers more guardrails, such as daily loss limits. - **Check where you live.** Bloxwap isn't available in every country. Running your own agent doesn't change the [terms](/docs/terms) that apply to you. ## Go further - **[The /agents page](https://bloxwap.app/developers/agents)** has MCP setup for each client, SDK quickstarts, and example prompts. - **[llms.txt](https://bloxwap.app/llms.txt)** and **[llms-full.txt](https://bloxwap.app/llms-full.txt)** give your coding assistant Bloxwap's docs in one file. Point it there before asking it to extend this agent. - **[Signing flows](/docs/developers/signing)** covers agent wallets, hardware wallets, and browser wallets. - **[The SDK documentation](https://bloxwap.github.io/hyperliquid/docs/)** documents every client, method, and utility. New to the signals themselves? Read [Bloxwap Signals: how Swing and Trend work](/bloxwap-signals). --- # Connect your AI agent to Bloxwap with MCP > Give Claude, Cursor, or Grok live Hyperliquid prices, leverage caps, fee quotes, and Bloxwap signals through one URL, and see what an agent can and cannot do. Source: https://bloxwap.com/blog/connect-your-ai-agent-to-bloxwap An AI agent can explain what a perpetual future is, but it can't see what Bitcoin is trading at right now. The **Bloxwap MCP server** closes that gap. It gives an agent live market data from Hyperliquid, Bloxwap's fee math, our documentation, and the Trend and Swing signals, all through one URL: ``` https://bloxwap.app/mcp ``` MCP stands for [Model Context Protocol](https://modelcontextprotocol.io), an open standard for connecting AI agents to outside tools. You add the server once, and the agent decides which tool to call when you ask a question. **One thing to know up front:** the agent can read, but it cannot place trades. Order tools are listed on the server, and every call to them is turned away. You still place each trade yourself in the Bloxwap app. The reasons are in [Why the agent can't trade yet](#why-the-agent-cant-trade-yet). ## What the agent can do The server has 16 tools in three groups. | Group | Sign-in needed | Tools | | ------------- | --------------------------- | ---------------------------------------------------------------------------------------------------------------------------- | | Public | None | `search_docs`, `get_doc`, `quote_fees`, `list_markets`, `get_market_prices`, `get_candles`, `get_trend_signals`, `get_swing_signals` | | Account reads | Your Bloxwap session | `get_account_summary`, `get_positions`, `get_orders` | | Order tools | Not available at this time | `market_long`, `market_short`, `set_stop_loss`, `close_position`, `adjust_leverage` | The eight public tools work the moment you connect. They cover most of what you'd want to ask before a trade: - **Markets and leverage:** every tradable market and the maximum leverage on each. - **Prices:** the current mid price, which is the midpoint between the best bid and best ask. - **Candles:** price history at intervals from one minute upward. - **Fees:** what a round trip costs for a given margin and leverage. - **Signals:** current Trend marks and active Swing setups. - **Docs:** search and read Bloxwap's guides, including this blog. ## Set it up Each setup below uses the public tools, so there's nothing to sign in to. ### Claude In Claude Code, run one command: ```sh claude mcp add --transport http bloxwap https://bloxwap.app/mcp ``` In the Claude desktop or web app, open **Settings → Connectors**, choose **Add custom connector**, and paste the server URL. ### Cursor Add the server to `~/.cursor/mcp.json`, or to `.cursor/mcp.json` inside a project: ```json { "mcpServers": { "bloxwap": { "url": "https://bloxwap.app/mcp" } } } ``` ### Grok Grok connects to remote MCP servers through the xAI API. Add the server to the `tools` list of your request: ```json { "tools": [ { "type": "mcp", "server_url": "https://bloxwap.app/mcp", "server_label": "bloxwap" } ] } ``` Any other client that supports MCP over Streamable HTTP can use the same URL. ## Your first prompt Once the server is connected, ask something that needs live data: > What's BTC trading at, and what's the most leverage I can use on it? The agent calls `get_market_prices` for the price and `list_markets` for the leverage cap, then answers in plain language. Behind the answer, the tools return structured data like this: ```json { "prices": [{ "coin": "BTC", "mid": 75271.5, "timestamp": 1794268326808 }] } ``` ```json { "coin": "BTC", "name": "BTC", "szDecimals": 5, "maxLeverage": 40 } ``` The price is an example from the day we wrote this. The agent's answer will use the price at the moment you ask. A natural follow-up is the cost of the trade: > What would a round trip cost with $100 of margin at 5× leverage? `quote_fees` works it out. Margin is the money you put up, and leverage multiplies it into the position size, so $100 at 5× is a $500 position: | Fee | Rate per side | Per side | Round trip | | ---------------------------------- | ------------- | -------- | ---------- | | Bloxwap builder fee | 0.05% | $0.25 | $0.50 | | Hyperliquid taker fee (estimated) | 0.045% | $0.23 | $0.45 | | **Total** | | | **$0.95** | The Bloxwap fee is exact. The Hyperliquid fee is an estimate, because it depends on your trading volume and the market. Treat the total as an upper bound. The [fees page](/docs/fees) has the full breakdown. ## Let the agent read your account The three account tools show your balances, open positions (including funding paid or received since each one opened), and open orders. They need proof that the account is yours. That proof is your **Bloxwap session token**, sent in the `Authorization` header of the connection. The server checks the token, then checks that the wallet address you asked about belongs to the same signed-in user. It refuses to read anyone else's account. Two limits apply: - **Session tokens expire.** When account reads stop working, replace the token with a fresh one. - **The token goes in the header only.** Never put it in a prompt, a URL, or a tool argument. **Never give an agent a wallet private key or seed phrase.** Bloxwap will never ask for one, and nothing on this server needs one. If a guide or a prompt tells you to paste one, stop. ## Why the agent can't trade yet The server lists five order tools so that clients can see their shape, but every call is turned away. That holds even with a valid session and the `_writeEnabled` flag the tools ask for. We built it this way on purpose. Placing a trade means signing it, and an agent needs its own narrowly scoped key to do that safely. Until that signing path is ready, the alternative would be handing an agent a credential that can do far more than place one order. We won't ship that. Until then, there are two ways to act on what your agent finds: - **Trade in the app.** Ask the agent for the price, the leverage cap, and the fees, then place the trade yourself in [Bloxwap](https://bloxwap.app). - **Build a bot with the SDK.** Developers can trade through the Hyperliquid SDK with a dedicated agent wallet. Start with the [agent templates](/docs/developers/templates) and read [agent permissions](/docs/developers/permissions) first. ## Keep the risk in view An agent makes it faster to look things up. It does not make a trade safer. - **Check the numbers.** An agent can misread a result or answer from memory instead of calling a tool. Confirm the price and your position in the app before you act. - **Size small.** Leverage magnifies losses as well as gains. The maximum leverage on a market is a limit, not a suggestion. - **Set a stop.** A stop-loss gives you a planned exit, though it can't guarantee a maximum loss. See [how to set a stop-loss](/docs/how-to/set-a-stop-loss). - **Check where you live.** Bloxwap isn't available in every country. Connecting an agent doesn't change the [terms](/docs/terms) that apply to you. Next, read [how an agent can use Trend and Swing signals](/let-your-agent-read-trend-and-swing-signals). If you're new to Bloxwap, start with [what Bloxwap is](/what-is-bloxwap). --- # What's the easiest trading app for beginners? > An app that turns a trade into one clear choice and lets you practice first. Here's how Bloxwap does it. Source: https://bloxwap.com/blog/easiest-trading-app-for-beginners **The easiest trading app for a beginner is one that turns a trade into a single, clear choice and lets you practice before real money is involved.** Bloxwap is built around that idea: pick a market, then tap **UP** if you think the price will rise or **DOWN** if you think it will fall. Demo mode uses practice funds, so your first trades cost nothing. ## Why "easy" matters A lot of people are new to this. About one in five U.S. adults (19%) say they've invested in or used a cryptocurrency, according to a [Pew Research Center survey](https://www.pewresearch.org/short-reads/2026/06/08/about-1-in-5-americans-have-used-crypto-republicans-use-has-ticked-up/) of 8,512 adults conducted January 20–26, 2026. Most apps still greet newcomers with an order form built for professionals. ## What makes a trading app easy - **One decision per trade.** You should only have to answer "up or down?", not choose between order types first. - **Practice first.** A demo with play money lets you learn how gains, losses, and leverage feel before anything is at stake. - **No wallet setup.** Signing in should be enough to start. - **Clear exits.** Closing a position should be as simple as opening it. ## Bloxwap compared with a traditional order form | | Bloxwap | Traditional exchange order form | | --- | --- | --- | | Placing a trade | Tap **UP** or **DOWN** | Choose order type, price, size, and side | | Closing a trade | Tap **CLOSE** | Enter an opposite order | | Practice | Demo with practice funds | Varies by platform | | Wallet | Created when you sign in | Often a separate setup step | | Your funds | Stay in your own wallet | Often held by the exchange | A full trading terminal still has its place: it gives experienced traders detailed order entry and more tools. For a first trade, fewer choices make it easier to understand what you're doing. ## How to make your first trade 1. Open [bloxwap.app](https://bloxwap.app) and sign in. Your wallet is created for you. 2. Start in **Demo** to trade with practice funds. 3. Pick a market, such as Bitcoin or Ethereum. 4. Set your size and leverage, then tap **UP** or **DOWN**. 5. Watch your profit and loss, and tap **CLOSE** when you're done. New to how these trades work? Read [what perpetual futures are](/what-are-perpetual-futures) and [what it costs to trade](/bloxwap-fee-guide). ## Is it safe for beginners? Easy doesn't mean risk-free. Bloxwap is non-custodial: it never holds your funds, and trades settle on Hyperliquid. The permission you approve for one-tap trading can place trades but can't withdraw your money. Trading with leverage can still lose money quickly. Read [how custody and trading risk work](/is-bloxwap-safe) before you trade live. ## FAQ Eligibility depends on your age and jurisdiction; check the [Terms of Use](https://bloxwap.com/docs/terms) before trading live. --- # A tour of the trading screen > Find your way around markets, trade controls, and your account. Source: https://bloxwap.com/blog/how-it-works The trading screen brings together a live chart, your account, and the controls for opening and managing positions. Here's where to find each part and what the main buttons do. ## The screen at a glance Three bands, top to bottom: - **Top:** your account and the market you're looking at. - **Middle:** a live price chart for that market. - **Bottom:** the action buttons. These change depending on whether you have a trade open. ## Opening a trade: UP and DOWN Choose a market, position size, and leverage before selecting a direction: - **UP** opens a **long**. You profit if the price goes up, and lose if it goes down. - **DOWN** opens a **short**. You profit if the price goes down, and lose if it goes up. Bloxwap sends your order to Hyperliquid. Check the resulting position to confirm the fill. ## Managing an open position: FLIP and CLOSE The moment you have a trade open, the two buttons at the bottom change. Now they manage the position you're in: - **FLIP** reverses your position in one tap. If you're long, FLIP closes the long and opens a short in its place, or the reverse. Both the closing and opening portions incur trading fees; a partial fill may not complete the reversal. - **CLOSE** exits the trade and locks in the result. Closing settles the position on Hyperliquid and returns your funds, plus or minus whatever the trade made. That's your realized profit or loss. ## Getting around: Markets, Position, and Profile Three more pieces tie the screen together: - **Markets** is the market picker. Open it to browse and switch between the markets you can trade, including perpetuals tracking crypto, stocks, and commodities. Pick a market to switch its chart and controls into view. - **Position** is your open-position readout. It shows the trade you're in at a glance: its size, your entry price, and your live profit or loss as the market moves. When you're flat, with no trade open, there's nothing to show here. - **Profile** is your account. Your wallet, balance, trade history, and settings all live here. It's also where you add funds and manage how the app behaves. ## Try the controls [Open Demo](https://bloxwap.app) to practice with virtual funds. Try choosing a market, setting a size, opening a position, and closing it. Before trading live, review the [fees](https://bloxwap.com/docs/fees) and learn how to [set a stop-loss](https://bloxwap.com/docs/how-to/set-a-stop-loss). --- # How to paper trade on Bloxwap: practice trading with no real money > Bloxwap's Demo mode is paper trading: $1,000 in practice funds, live prices, and the same UP/DOWN controls as real trading, with no sign-up. Source: https://bloxwap.com/blog/how-to-paper-trade **Paper trading means placing practice trades with pretend money so you can learn without risking your own.** On Bloxwap, that's Demo mode. You get $1,000 in practice funds, the same markets and live prices as real trading, and the same **UP** and **DOWN** buttons. It costs nothing, and you don't need an account to start. Everything you do in Demo stays in Demo. Your practice trades have their own balance and their own history, separate from any real money you add later. **Papertrade is not paper trading.** Where Bloxwap offers Papertrade markets, they are a third-party venue that trades real USDC, despite the name. Demo can simulate those markets with practice funds, but a live Papertrade trade uses real money. Practice trading on Bloxwap is always Demo mode. ## Step 1: Open Bloxwap in Demo [#step-1] Go to [bloxwap.app](https://bloxwap.app) on your phone. You don't need to sign up: new visitors start in Demo with **$1,000 in practice funds**. On the welcome card, tap **Let me try it**. If you're already signed in, switch to Demo from your profile. ## Step 2: Pick a market and set your size [#step-2] Choose a market, such as Bitcoin, from the market picker. Set how much of your practice balance to use and your **leverage**, which multiplies the size of the trade. At 10× leverage, $100 controls a $1,000 position, so a 1% price move is about a 10% gain or loss on your $100. Start small, the way you would with real money. ## Step 3: Add a stop-loss [#step-3] A **stop-loss** closes the position automatically if the price moves against you by the amount you choose. It works in Demo exactly as it does live. The [stop-loss guide](https://bloxwap.com/docs/how-to/set-a-stop-loss) shows how to set one. ## Step 4: Tap UP or DOWN [#step-4] Tap **UP** if you think the price will rise (going **long**), or **DOWN** if you think it will fall (going **short**). The trade opens at the live price on your screen. ## Step 5: Watch it and tap CLOSE [#step-5] Your entry price and profit or loss update live while the trade is open. Tap **CLOSE** whenever you want to exit. The result lands in your practice balance. ## Step 6: Review and repeat [#step-6] Open **History (Demo)** from your profile to see what worked. Run out of practice funds? Add more with **Deposit** in Demo; practice funds are unlimited. ## What to practice - **Sizing.** Try the same trade at different sizes and watch how much the result swings. - **Leverage.** Compare 2× and 10× on the same move. Higher leverage leaves less room before [liquidation](https://bloxwap.com/docs/glossary#liquidation), when the exchange closes a position whose margin runs too low. - **Stop-losses.** Set one on every trade until it's a habit. - **Both directions.** Practice shorts as well as longs. The [guide to shorting Bitcoin](/how-to-short-bitcoin) walks through one. - **Closing on a plan.** Decide your exit before you tap, then stick to it. ## What paper trading can't teach you Demo is built to teach the controls, not to copy every cost of real trading: - **Fees.** Demo trades don't charge fees. Real trades pay a fee when they open and again when they close, on the full position size. The [fee guide](/bloxwap-fee-guide) shows the numbers. - **Fills.** Demo opens at the price on your screen. A real order fills on Hyperliquid's order book, so the price you get depends on how the market moves and on liquidity. - **Feelings.** Losing practice money doesn't feel like losing your own. Expect to be more cautious, or more impulsive, once it's real. ## When to switch to live You're ready to try a small live trade when you can say yes to each of these: - You can open, manage, and close a trade without hunting for buttons. - You set a stop-loss without thinking about it. - You can explain how leverage changes your gain or loss on a 1% move. - You know what a round trip costs in fees. - You've picked an amount you could lose entirely without it affecting your bills or savings. When you switch, keep the size small and the leverage low. [How to start trading on your phone](/how-to-start-trading-on-your-phone) covers funding your account and placing that first real trade. If perps are new to you, start with [What are perpetual futures?](/what-are-perpetual-futures) ## FAQ **Is paper trading on Bloxwap free?** Yes. Demo mode costs nothing and uses practice funds only. **Do I need an account to paper trade?** No. Open [bloxwap.app](https://bloxwap.app) and you start in Demo. **Does Demo use real prices?** Yes. Demo trades open and close at live market prices. **Can I lose real money in Demo?** No. Demo only uses practice funds. Real money is only at risk after you add funds and switch to live trading. **Is Papertrade the same as paper trading?** No. Papertrade markets are a third-party venue that trades real USDC, with up to 1000× leverage and a liquidity pool as your counterparty. Practice trading on Bloxwap is Demo mode. See [Papertrade markets](https://bloxwap.com/docs/assets#papertrade-markets) for how they work and what they cost. Live trading involves real risk. You can lose money, especially with leverage. Only trade what you can afford to lose. --- # How to short Bitcoin from your phone > Pick BTC, set a size, and tap DOWN to short (or UP to go long), with a worked example of fees, funding, and liquidation. Source: https://bloxwap.com/blog/how-to-short-bitcoin **Shorting Bitcoin means opening a position that gains if the price falls and loses if it rises.** On Bloxwap you pick BTC, set a size, and tap **DOWN**. Think it's headed up instead? Tap **UP** to go long. Tap **CLOSE** when you're done. You don't own or borrow any Bitcoin. You trade a **perpetual future** ("perp"), a contract that tracks Bitcoin's price with no expiry date. Orders route to Hyperliquid; Bloxwap is the interface on your phone. New to perps? Read [A beginner's guide to perpetual futures](/what-are-perpetual-futures). ## Step 1: Start in Demo [#step-1] Open [bloxwap.app](https://bloxwap.app) in your phone's browser. Until you sign in, you trade in **Demo** with practice funds: no real money, no fees. Run the whole flow there, including a losing trade, before you switch to **Live**. ## Step 2: Pick BTC [#step-2] Open the market picker and choose BTC. The chart and controls switch to Bitcoin. [A tour of the trading screen](/how-it-works) shows where everything lives. ## Step 3: Set your size and leverage [#step-3] Tap the size and leverage readout on the chart. **Size** is your **margin**, the USDC you put behind the trade. Pick a preset ($10 up to $1,000), enter a custom amount, or tap **Max** to use your available balance. **Leverage** sets the position value: 50 USDC at 5x controls a $250 position. It magnifies gains and losses equally. The sheet also shows the position value, an estimated round-trip fee, and an estimated liquidation distance. Keep leverage low while you learn. ## Step 4: Tap DOWN to short, or UP to go long [#step-4] Tap **DOWN** to open a short, or **UP** to open a long, which gains if the price rises. Your live profit and loss (P&L) appears once the order fills. You can also add a stop-loss, an order that closes the position at a price you choose ([here's how](https://bloxwap.com/docs/how-to/set-a-stop-loss)). ## Step 5: Exit with CLOSE, or protect a gain with LOCK [#step-5] With a short open, **DOWN** becomes **CLOSE**. Tap it to exit and realize the result. The other button becomes **LOCK**, which works only while the trade is in profit after estimated fees. It sets a trailing stop based on recent price swings: for a short, the stop starts at or below your break-even price and moves down as Bitcoin falls, so a bounce closes the trade with part of the gain. It's a stop order, so a fast market can fill it at a worse price. ## A worked example: 50 USDC short at 5x Bitcoin is at $100,000. You short with **50 USDC** at **5x**, a **$250** position. Fees are 9.5 bps (0.095%) per fill on the full position value, on open and again on close ([fee guide](/bloxwap-fee-guide)). | | Bitcoin falls 4% | Bitcoin rises 4% | | --- | ---: | ---: | | Exit price | $96,000 | $104,000 | | Position value at close | $240 | $260 | | Gross P&L | +$10.00 | −$10.00 | | Fees (open + close) | $0.47 | $0.48 | | **Net P&L, before funding** | **+$9.53** | **−$10.48** | | Left of your 50 USDC | $59.53 | $39.52 | Opening costs 0.095% × $250 = $0.2375. Closing the win costs 0.095% × $240 = $0.228 ($0.4655 total). Closing the loss costs 0.095% × $260 = $0.247 ($0.4845 total). A 4% price move changed your margin by about 20% either way. That's 5x leverage at work. Going long swaps the columns: the rise is the win. **Funding** is a payment between longs and shorts that Hyperliquid settles hourly. When the rate is positive, longs pay shorts; when it's negative, shorts pay. At Hyperliquid's baseline of 0.00125% per hour, this $250 short would receive about $0.003 an hour, roughly 8 cents a day. Rates change and can turn against you. Bloxwap keeps none of it. ## How a short gets liquidated A short loses as the price rises, and Bitcoin's price has no ceiling. **Liquidation** is Hyperliquid closing your position because its margin can no longer support it. In the example, a 20% rise (to $120,000) would cost the whole 50 USDC. Liquidation comes sooner, because the exchange requires maintenance margin and fees and funding eat into the cushion. At 10x, a rise of under 10% could do it. With cross margin, other collateral in your account can absorb losses too. See the [glossary](https://bloxwap.com/docs/glossary#liquidation) and [how payouts, funding, and liquidation work](/bloxwap-payouts-explained). ## Frequently asked questions ### Can you short Bitcoin on your phone? Yes. On Bloxwap you pick BTC, set a size, and tap **DOWN**, right in your phone's browser. Try it in Demo first with practice funds. ### Do I need to own Bitcoin to short it? No. A Bitcoin perp tracks the price without anyone lending you coins. Your margin is USDC. ### Is shorting riskier than going long? The mechanics match; only the direction flips. But a price can rise without limit, so nothing caps a short's loss except a stop-loss or liquidation. Leverage magnifies gains and losses either way. Live trading involves real risk. You can lose money, especially with leverage. Only trade what you can afford to lose. You must be 18 or the age of majority where you live, and restricted jurisdictions include the United States; see the [Terms of Use](https://bloxwap.com/docs/terms). --- # How to start trading on your phone with no experience > Seven steps from your first sign-in to your first small trade, with practice first. Source: https://bloxwap.com/blog/how-to-start-trading-on-your-phone You don't need a trading background to start. You need a clear idea of what you're trading, a way to practice without real money, and a plan for how much you're willing to lose. This guide walks through each step on your phone using Bloxwap, from checking that you're eligible to closing your first trade. One thing to know up front: on Bloxwap you trade **perpetual futures** ("perps") that track the price of crypto, stocks, and commodities. You don't buy shares or coins. You trade on which way the price moves. ## Step 1: Check that you can use Bloxwap [#step-1] You must be at least 18, or the age of majority where you live if that's higher. Bloxwap isn't available to citizens or residents of, or people located in, restricted jurisdictions, which include the United States. The [Terms of Use](https://bloxwap.com/docs/terms) list every restricted region. Check this before you add any money. ## Step 2: Learn what a perpetual future is [#step-2] A perp lets you take a position on a price without owning the asset. Going **long** means you profit if the price rises. Going **short** means you profit if it falls. The money backing a trade is your **margin**, and **leverage** multiplies the position size, so it magnifies both gains and losses. Read [A beginner’s guide to perpetual futures](/what-are-perpetual-futures) for a worked example with the numbers. ## Step 3: Open the app and sign in [#step-3] On your phone, go to [bloxwap.app](https://bloxwap.app) and sign in with email, Google, Apple, or X. Signing in creates an **embedded wallet** for you, so there's no seed phrase to write down. The wallet is yours: Bloxwap never holds your funds, and you can export its private key from **Advanced** in the account menu ([here's how](/trade-crypto-without-a-seed-phrase)). ## Step 4: Practice in Demo [#step-4] Start in Demo. It gives you a virtual balance, uses no real money, and charges no trading fees. Pick a market such as Bitcoin, set a size, tap **UP** or **DOWN**, then tap **CLOSE**. Repeat until opening, watching, and closing a position feels routine. [A tour of the trading screen](/how-it-works) explains each control. ## Step 5: Learn what a trade costs [#step-5] Every trade pays a fee when it opens and again when it closes, charged on the full position value (margin × leverage), not just your margin. Positions also pay or receive **funding** while they're open. The [fee guide](/bloxwap-fee-guide) breaks down each cost with a $1,000 example. ## Step 6: Add a small amount of money [#step-6] When you're ready to trade live, open **Add Funds**. You can deposit USDC, USDT, ETH, BTC, or SOL on supported networks, and the app converts the deposit into **USDC**, a stablecoin designed to track the US dollar. That USDC is your trading balance. Start with an amount you could lose entirely without it affecting your bills or savings. ## Step 7: Place a small first trade with a stop-loss [#step-7] Choose a market, keep the size small, and use low leverage. Set a **stop-loss**, an order that closes the position if the price reaches a level you choose; you can add it while setting up the trade or from Manage Position afterward. The [stop-loss guide](https://bloxwap.com/docs/how-to/set-a-stop-loss) shows how. Tap **UP** or **DOWN** to open the trade, then tap **CLOSE** whenever you want to exit and lock in the result. ## Habits worth keeping - **Size down.** A small trade teaches you as much as a big one. - **Keep leverage low.** Higher leverage leaves less room before [liquidation](https://bloxwap.com/docs/glossary#liquidation), when the exchange closes a position whose margin runs too low. - **Go back to Demo** whenever you want to try something new. - **Count fees in your result.** A trade that ends slightly up can still lose money after fees. Live trading involves real risk. You can lose money, especially with leverage. Only trade what you can afford to lose. --- # Trading Hyperliquid on your phone: the mobile apps compared > An honest roundup of the Hyperliquid apps that work on a phone, what each is best at, and where Bloxwap fits. Source: https://bloxwap.com/blog/hyperliquid-mobile-apps-compared **The best app for trading Hyperliquid on your phone depends on what you want: every tool, a wallet you already use, social trading, or the fastest path from an idea to a position.** Hyperliquid has an Android app and a web app but no iPhone app in the App Store, so many phone traders use a third-party front-end. Bloxwap is a native iOS and Android app in early access: TestFlight on iOS and Play closed testing on Android, with no public App Store or Play listing. If you cannot join the test, the waitlist is at [bloxwap.com](https://bloxwap.com/). Tap **UP** or **DOWN**, and start in Demo with practice funds. Every app below routes orders to Hyperliquid. What differs is the controls, the wallet, the market list, and the **builder fee**, a fee the app adds to each fill on top of Hyperliquid's own trading fee. ## The apps at a glance | App | Where it runs | Sign-in and wallet | Markets | Fee on top of Hyperliquid | Best for | | ----------------------------- | -------------------------------------------------------------------------------------------------- | ------------------------------------------------------ | ---------------------------------------------------------------- | ------------------------------------ | --------------------------------------------------- | | Hyperliquid | Android app; mobile web; no iOS app | Email or an existing wallet | Crypto perps and spot; stocks, commodities, FX | None | Every tool, no interface fee | | Phantom | iOS, Android (inside the wallet) | Your Phantom wallet | Crypto perps; stocks, commodities, FX | 0.05% on perps | Funds you already hold in Phantom | | Based | iOS, Android, web | Email or Google creates a wallet, or connect yours | 150+ assets: perps, spot, HIP-3 | 0.025% on perps; 0.1% on spot sells | A full mobile terminal with spot | | Dexari | iOS, Android | Email, Google, or Apple plus a passkey; no seed phrase | 300+: crypto perps and spot; stocks, indexes, commodities, forex | 0.10% on perps at the entry tier | Pro charts and order types, native | | Dreamcash | iOS, Android, web, macOS | Email creates a wallet, or connect yours | Crypto perps and spot; HIP-3 stocks, commodities, indices | 0.045% in the app; 0.025% on web | Rewards seasons and AI market signals | | [Farao](https://getfarao.com) | iOS, Android | Embedded self-custodial wallet | 100+: crypto, stocks, pre-IPO, indexes, commodities | Not published | Copying other traders | | Legend | iOS, Android, mobile web | Social, email, passkey, or wallet; embedded wallet | Crypto, stock, and commodity perps | 0.05% on perps; 0.10% on copy trades | Leaderboards, clans, copy trading | | Bloxwap | Native iOS via TestFlight and Android via Play closed testing; no public App Store or Play listing | Email, Google, Apple, X, or wallet; embedded wallet | 70+: crypto perps; HIP-3 stocks, commodities, indices | 0.05% (5 bps) | Shortest path from a view to a position, Demo first | Checked September 2026 against each app's website, docs, and store listing. Fees and markets change, and availability depends on where you live for every app here, Bloxwap included. A **perp** (perpetual future) tracks a price with no expiry date; you don't own the asset. **HIP-3** markets are perps other teams deploy on Hyperliquid, which is how stocks and commodities get there. They add a fee set by the deployer. ## Where other apps are stronger - **A public store listing.** Every app above except Bloxwap (and Hyperliquid on iPhone) has a public App Store and Google Play listing. Bloxwap’s iOS and Android apps are in early access through TestFlight and Play closed testing, not a public unrestricted listing. If you can’t join the test, the waitlist is at [bloxwap.com](https://bloxwap.com/). - **Spot trading.** Hyperliquid, Based, Dexari, and Dreamcash let you buy the actual tokens. Bloxwap trades perps only. - **Order types.** Hyperliquid, Based, and Dexari offer limit and TWAP orders. If a pro terminal works for you, use it. - **A wallet you already use.** Phantom puts perps next to your existing funds. - **Social trading.** Legend and Farao are built around following and copying traders. - **Fees.** Hyperliquid's own app adds no interface fee, and Based and Dreamcash publish lower perp fees than Bloxwap's 5 bps. ## Where Bloxwap fits Bloxwap is for the moment you want the shortest path from a view to a position. Pick a market, set a size, and tap **UP** to open a long (you gain if the price rises) or **DOWN** to open a short (you gain if it falls). Tap **CLOSE** to exit. - **Demo first.** If you're not signed in, you trade with practice funds: no real money, no fees. - **No seed phrase.** Signing in creates an embedded wallet, and you can - **Trading-only permission.** It can place and close trades but can't withdraw your funds. - **Same controls everywhere.** Perps tracking Bitcoin, Nvidia, gold, and the S&P 500 all trade from one screen. Each fill pays the 5 bps builder fee plus Hyperliquid's fee, on open and on close, charged on the full position value. The [fee guide](/bloxwap-fee-guide) works through a $1,000 example, and [Bloxwap and Hyperliquid](/bloxwap-vs-hyperliquid) explains who does what. ## How to choose - **Every tool, no extra fee:** Hyperliquid's own app. - **Your money is already in Phantom:** Phantom. - **Spot, perps, and pro order types together:** Based or Dexari. - **Copying or competing with other traders:** Legend or Farao. - **One tap to a position, with practice first:** Bloxwap. See [tap-to-trade vs a full terminal](/bloxwap-vs-traditional-perp-trading). ## Frequently asked questions ### Is there an official Hyperliquid app for iPhone? Not in the App Store. Hyperliquid Corp publishes an Android app on Google Play. On iPhone, open app.hyperliquid.xyz in the browser or use a third-party front-end, and be wary of any iOS app claiming to be the official one. ### Do these apps all trade on the same exchange? Yes. Each routes orders to Hyperliquid, where trades match and settle. Your fill still depends on the market, order size, and liquidity, and the app's fee changes your total cost. ### Which Hyperliquid app has the lowest fees? Hyperliquid's own app adds no interface fee. Among front-ends, Based publishes 0.025% on perps and Dreamcash 0.045% in its app; Phantom, Legend, and Bloxwap add 0.05%. Funding payments and HIP-3 deployer fees apply in any app. ### Can I use one Hyperliquid account in several apps? Yes, if each app can use the same wallet. Positions live on Hyperliquid under your address. With an embedded wallet, that means exporting the key and importing it elsewhere, so keep it private. Trading perps involves real risk. Leverage magnifies gains and losses, and you can lose the money you put in. Only trade what you can afford to lose. You must be 18 or older, or the age of majority where you live, and Bloxwap isn't available in restricted jurisdictions, which include the United States. See the [Terms of Use](https://bloxwap.com/docs/terms). --- # Understanding custody and trading risk > What control of your wallet means, and which risks remain. Source: https://bloxwap.com/blog/is-bloxwap-safe Bloxwap is **non-custodial**: it does not hold your funds or private keys. You control the wallet, and trades settle on Hyperliquid. That arrangement changes who controls your assets, but it cannot eliminate trading, software, network, or wallet risks. ## What "non-custodial" means A custodial exchange holds assets for its customers. Access to those funds depends on the custodian's systems and ability to return them. Bloxwap works the other way. It's a **trading interface**, an app that sits on top of an exchange and makes it easy to use, but it never takes your money. Your funds live in **your own wallet**. A **wallet** uses a private key to authorize transactions. Bloxwap provides an **embedded wallet** through sign-in, so no browser extension is required. You can export its key from Settings. Keep exported keys private and secure. To make one-tap trading work, you approve a **trading-only permission** once. It lets the app place and close trades for you without a signature on every tap. It can't withdraw or send your funds anywhere. ## Where your money actually lives Bloxwap doesn't run an exchange. It places your trades on **Hyperliquid**, a **decentralized exchange** that records trading activity on its blockchain. Trades settle **on-chain**, meaning their records are written to the blockchain. Your wallet controls the trading account on Hyperliquid. Collateral is held in **USDC**, a stablecoin designed to track the US dollar. An open Hyperliquid position continues to exist if the Bloxwap interface is unavailable. Managing it through another interface requires access to the same wallet, and still depends on Hyperliquid and the network being available. ## What Bloxwap can and can't do with your assets **Bloxwap can:** - Show you markets and live prices. - Place a trade when you tap **UP** (a long, which gains if the price rises) or **DOWN** (a short, which gains if it falls). - Close or flip a position when you tap **CLOSE** or **FLIP**, using the trading-only permission you approved. **Bloxwap cannot:** - Use a trading-only approval to withdraw your funds. Transfers require a separate authorization. - See or copy your key. - Freeze the funds in your wallet. You decide every trade, and you control where your money goes. ## The real risks to understand Wallet control is one part of the risk picture. Consider these risks before placing a trade: - **Leverage cuts both ways.** Leverage magnifies gains and losses. With 10x leverage, a 1% price move produces roughly a 10% change in starting margin, before fees and funding. - **Liquidation.** If the price moves against a leveraged trade far enough, the exchange closes it automatically. For example: you put **50 USDC** into Bitcoin going up at 10× leverage. A 10% decline represents $50 of price losses on that $500 position, but liquidation can occur earlier because maintenance margin and fees also matter. Cross-margin positions can put other collateral in the trading account at risk. - **Market risk.** Prices can move sharply, and an order may fill at a different price from the one you expected. - **Software and network risk.** Interface errors, protocol failures, and network outages can affect access and execution. - **Wallet access.** Protect your sign-in and any exported keys. Lost or compromised wallet access can put funds at risk. ## Start safely - Try the flow in Demo first. Demo uses practice funds, so you can learn how size, leverage, and profit and loss behave before any real money is at risk. - New to any of this? Read [What is Bloxwap?](/what-is-bloxwap) and [What are perpetual futures?](/what-are-perpetual-futures) first. - See how money moves (profit, loss, liquidation, and fees) in [How Bloxwap payouts work](/bloxwap-payouts-explained). - Check the [fees](https://bloxwap.com/docs/fees) and the [terms](https://bloxwap.com/docs/terms) before you trade. Understand the position and its costs before trading live, and only commit funds you can afford to lose. --- # Let your AI agent read Bloxwap Trend and Swing signals > How an agent pulls Trend marks and Swing setups through the Bloxwap MCP server, what each field means, and how to turn a setup into a trade plan with your own risk limits. Source: https://bloxwap.com/blog/let-your-agent-read-trend-and-swing-signals Bloxwap's signals are available to AI agents. Through the [Bloxwap MCP server](/connect-your-ai-agent-to-bloxwap), an agent can read the same **Trend** marks and **Swing** setups you see in the app, as structured data it can filter, compare, and explain. This guide covers the two signal tools, what each field means, and how to have an agent turn a signal into a trade plan that respects limits you set. **The agent reads signals. It does not trade on them.** The server's order tools are not available at this time, so you place every trade yourself. See [When a signal fires](#when-a-signal-fires) for the ways to act. If you haven't connected an agent yet, the [setup guide](/connect-your-ai-agent-to-bloxwap) takes a minute. Both signal tools are public, so there's nothing to sign in to. ## The two signal tools | Tool | What it returns | | ------------------- | ---------------------------------------------------------------------------- | | `get_trend_signals` | The current Trend state for each market with a recent reading. | | `get_swing_signals` | Every active Swing setup, with direction, leverage, and three price levels. | For how the signals themselves work, read [Bloxwap Signals: how Swing and Trend work](/bloxwap-signals). In short, Trend describes a move that has already happened, and Swing lays out a complete trade setup. ## What a Trend signal contains `get_trend_signals` takes no arguments. Each entry looks like this: ```json { "coin": "BTC", "state": "UP", "timestamp": 1794268200000 } ``` | Field | Meaning | | ------------ | -------------------------------------------------------------------------- | | `coin` | The market symbol. | | `state` | `UP`, `DOWN`, `WATCH`, or `NO_SIGNAL`. | | `timestamp` | When the state was observed, in milliseconds since 1 January 1970 (UTC). | | `confidence` | An optional score from 0 to 1. It is not always present. | `UP` and `DOWN` mark a large, efficient 15-minute move on expanding volatility. `WATCH` means volatility is expanding with no clear direction yet. `NO_SIGNAL` means none of those conditions hold. The tool returns only readings from the last five minutes. A market that's missing from the list has no fresh reading, which is different from a `NO_SIGNAL` state. ## What a Swing signal contains `get_swing_signals` accepts three optional filters: `coin`, `direction` (`LONG` or `SHORT`), and `tradableOnly`. Each setup looks like this: ```json { "coin": "BTC", "signalId": "example-signal-id", "family": "example-family", "direction": "LONG", "entryPrice": 60000, "stopLoss": 59400, "takeProfit": 61200, "leverage": 10, "confidence": 0.8, "edgeScore": null, "timestamp": 1794268200000, "expiresAt": 1794269100000, "tradable": true, "entryPriceMin": 59950, "entryPriceMax": 60050 } ``` These values are an illustration, not a live signal. | Field | Meaning | | --------------------------------- | --------------------------------------------------------------------------- | | `direction` | `LONG` benefits from a rise in price; `SHORT` benefits from a fall. | | `entryPrice` | The reference price for entering the setup. | | `stopLoss` | The intended exit if price moves against the position. | | `takeProfit` | The intended exit if price reaches the target. | | `leverage` | The leverage the setup suggests. | | `confidence` | A score from 0 to 1, or `null`. It is not a probability of profit. | | `expiresAt` | When the setup stops being valid, in milliseconds since 1 January 1970 (UTC). | | `tradable` | `false` marks a test signal. Pass `tradableOnly: true` to leave these out. | | `entryPriceMin`, `entryPriceMax` | The price range in which the entry still applies, when the setup has one. | | `signalId`, `family` | Identifiers for the setup and the strategy that produced it. | | `edgeScore` | An optional internal ranking score, or `null`. | In the app, Swing is a Genesis feature and confidence appears as one to five bars. ## Example: watch Trend on BTC Here's a prompt that puts the Trend tool to work: > Check Trend on BTC every few minutes. When it flips to UP, tell me the > current price and the most leverage I could use. When the agent checks, it calls `get_trend_signals` and finds the BTC entry. If the state is `UP`, it calls `get_market_prices` for the price and `list_markets` for the leverage cap, then reports back. Two things matter here: - **The agent has to be running.** A chat agent checks only when you ask. To check on a schedule, use an agent or client that supports recurring tasks. For alerts that reach you on their own, turn on signal notifications in the app with the [notifications guide](/docs/subscribe). - **UP describes the past.** A Trend mark says a strong move just happened. It doesn't predict that the move will continue, and a pullback can follow. Treat the alert as a reason to look, not a reason to buy. ## Turn a Swing setup into a trade plan A Swing setup already has an entry, a stop, and a target. Your agent's job is to check the setup against the live market and against your limits: > Get the tradable Swing setups for BTC. For each one, tell me whether it has > expired, whether the current price is still inside the entry range, the > distance to the stop and to the target as a percentage, and what a round > trip would cost with $50 of margin. For the illustrated setup above, the agent would work through it like this: 1. **Is it still valid?** Compare `expiresAt` with the current time. An expired setup is history. 2. **Is the price still in range?** Compare the live price with `entryPriceMin` and `entryPriceMax`. If price has already run past the range, the setup's levels no longer describe the trade you'd get. 3. **Where are the exits?** The stop at $59,400 is 1% below the $60,000 entry. The target at $61,200 is 2% above it. 4. **What does the leverage do to that?** At 10× leverage, a 1% move against you is about 10% of your margin, before fees. With $50 of margin, that's roughly $5 lost at the stop and $10 gained at the target. 5. **What does it cost?** `quote_fees` gives the round-trip fees for that margin and leverage. For a `SHORT` setup the stop sits above the entry and the target sits below. Stop-loss and take-profit prices are triggers, not guaranteed fill prices. In a fast market the exit can fill at a worse price than the level you set. ## Give your agent risk limits An agent follows the rules you write down. Put your limits in the prompt, or in the agent's standing instructions, so every plan gets checked against them: > Only show me setups that fit these rules: no more than $50 of margin per > trade, leverage at or below 5× even if the signal suggests more, a stop no > further than 1.5% from entry, and nothing that expires in under ten minutes. > Skip any market where I already have a position. A few limits worth setting: - **Margin per trade:** the most you're willing to put up on one idea. - **Your own leverage cap:** a signal's suggested leverage and the market's maximum are both ceilings. You can always use less. - **Stop distance:** how far price can move against you before you're out. - **One position per market:** with a signed-in connection, the agent can call `get_positions` to see what you already hold. These limits shape what the agent tells you. They don't bind your account, because the agent can't place or block a trade. You're the last check. ## When a signal fires The agent can find and vet a setup. Acting on it is up to you, and there are three ways to do that today: - **Place the trade in the app.** Open the market in [Bloxwap](https://bloxwap.app), set your amount and leverage, and add the stop and target from the plan. - **Use the Swing push notification.** On supported devices, a Swing notification offers an **Open** action that can submit a live position with the signal's direction, leverage, and exits, using your selected trade amount. It's opt-in: you enable Swing and its notifications first. [The Signals guide](/bloxwap-signals) explains exactly what Open does. - **Build a bot.** Developers who want fully automated execution can trade through the Hyperliquid SDK with a dedicated agent wallet. Read [agent permissions](/docs/developers/permissions) first: an approved agent wallet can trade without per-order limits, so the risk rules have to live in your own code. Automatic execution through the MCP server is not available at this time. We'll turn the order tools on only when an agent can sign with a narrowly scoped key of its own. ## Keep the risk in view No signal guarantees a profitable trade, and an agent reading a signal doesn't change that. Leverage magnifies losses as well as gains. Fees, funding, and liquidation risk still apply, and a stop-loss can't guarantee a maximum loss. Agents also make mistakes. They can misread a field, do the arithmetic wrong, or describe a setup that has since expired. Check the price, the levels, and your position in the app before you act. If you're new to these ideas, start with [what perpetual futures are](/what-are-perpetual-futures), review the [fees](/docs/fees), and learn how to [set a stop-loss](/docs/how-to/set-a-stop-loss). --- # Building Bloxwap's Mac mini server cluster > The parts and layout for a compact three-Mac build rack, from the 6U frame to the mount, cable management, and power cords. Source: https://bloxwap.com/blog/mac-mini-server-cluster Bloxwap ships on iOS, Android, and the web. Behind those apps is a fleet of Mac minis running our GitHub Actions jobs: tests, production bundles, native exports, and release tooling. Those machines need a home. A compact rack gives each Mac a fixed place, keeps cables accessible, and makes it easier to add another group of build machines. Here's a three-Mac rack layout using the parts in our cluster build list. **Affiliate disclosure:** As an Amazon Associate I earn from qualifying purchases. The Amazon product links below are affiliate links using our `bloxwap-20` tag. The Etsy mount is a separate purchase. ## The parts for one three-Mac rack These quantities describe one rack module, so you can scale the layout to your own build queue. **This build requires purchases from both Amazon and Etsy.** Order the hardware in the Amazon section and the printed mount in the Etsy section. ### Amazon parts View Amazon parts wishlist, or use the individual product links below. Use the quantities in this table for one three-Mac rack. | Part | Quantity | Role | | --- | --- | --- | | Apple Mac mini (M6) on Amazon | 3 computers | Independent build machines | | GeeekPi 6U 10-inch rack on Amazon | 1 rack | The frame for the build | | GeeekPi 1U brush cable manager on Amazon | 1 panel | A pass-through for cables | | GeeekPi vented 2U panels on Amazon | 1 two-pack; use 1 panel | Fills the remaining 2U; keep the second panel as a spare | | Goalfish 1-foot power cord on Amazon | 3 cords | Short power runs, one per Mac | ### Etsy parts Order the printed mount separately from Print3DSteve on Etsy to complete the three-Mac rack. | Part | Quantity | Role | | --- | --- | --- | | [Print3DSteve three-Mac 3U mount on Etsy](https://www.etsy.com/listing/1867907942/mac-mini-m4-2024-x3-10in-mini-rack-3u) | 1 mount | Holds the three computers in the rack | ### Additional hardware You'll also need Ethernet cables, a network connection or switch, suitable power distribution, and rack fasteners. Choose the Mac's memory and storage for the jobs you plan to run; the link is a starting point for selecting a configuration. ## How the rack fits together The frame is the **DeskPi RackMate T1/2 Plus**, a 6U rack for 10-inch equipment with a listed depth of 10.23 inches (260 mm). Keep the mounting accessories at the same 10-inch width when choosing parts. The height allocation is straightforward: **3U for the Mac mount + 1U for the brush panel + 2U for one vented panel = 6U**. The panel listing supplies two 2U pieces, but this layout uses only one. ### Give the Macs a fixed place Print3DSteve's Etsy mount holds three Mac minis in a single 3U assembly. The seller lists compatibility with the 2024 and 2026 machines and prints the mount in PETG. Rack fasteners are supplied separately. Install the mount securely, then check access to each computer's ports and power button. Leave the computers' ventilation openings clear and enough space behind the rack for connectors and cable bends. ### Keep the cable runs short and accessible The brush panel gives cables a defined path through the rack. Label both ends of each Ethernet cable and power cord with the machine's name so you can disconnect one node without tracing every cable. The linked Goalfish power cord is 1 foot (0.3 m) long, with an 18 AWG cable and a 7 A, 125 V rating. Measure the route to your power outlets before choosing a length, and confirm the connector and electrical rating match your equipment and local supply. Short cables help only when they reach without tension. ### Leave room for air to move The vented panel fills the remaining rack space without a solid blank face. Its listing also provides mounting positions for 7 cm or 8 cm fans. A fan requires a separate selection and power connection; the panel alone provides no powered airflow. Check the layout under a sustained build workload, with cables in their final positions, before treating it as finished. ## Turn the computers into a build fleet Each Mac executes jobs independently from a shared queue. More nodes give the queue more places to run work; each individual job still needs enough memory, storage, and CPU capacity on its assigned machine. For our workflows, the useful setup is: 1. **Prepare each Mac consistently.** Install the tools your jobs need, including Xcode for native iOS work, and give every machine a clear name. 2. **Register the GitHub Actions runners in a dedicated group.** Route the workflows to that group so machines can join or leave the fleet without editing every job. 3. **Pin the build tools.** Select Node, Bun, and other tool versions in the workflow rather than depending on whichever version happens to be global. 4. **Manage the persistent state.** Give jobs separate scratch directories, clean up after them, and cap concurrent builds that compete for resources. Measure the whole job as well as its individual stages: dependency restores, compilation, tests, and artifact uploads. A fast build can still leave you waiting on a large transfer. Use those measurements to decide whether the next improvement is another Mac, more storage, a cache change, or less work in the pipeline. The parts tables above are the starting point for building the rack. Open the Amazon links to choose the right variants and quantities for your setup, and order the three-Mac mount separately from Print3DSteve on Etsy. --- # How to trade crypto without a seed phrase (and still control your money) > How an embedded wallet skips the 12-word backup at sign-up, who controls the funds, and how to export your key. Source: https://bloxwap.com/blog/trade-crypto-without-a-seed-phrase **You can trade crypto without writing down a seed phrase by using an app that creates an embedded wallet when you sign in.** On Bloxwap, you sign in with email, Google, Apple, or X, and a wallet is created for you. There's no seed phrase at sign-up, your funds stay in your wallet, and you can export the private key whenever you want. The tradeoff: your login now protects your wallet, so keep that account secure. ## Why people skip the seed phrase A **seed phrase** is a list of 12 or 24 words that can rebuild a wallet. Lose it along with your device and the funds may be gone. Anyone who sees it can take everything in the wallet. That's a lot of responsibility before a first trade, so many people leave their money on an exchange instead. An embedded wallet sits between the two. ## How an embedded wallet works Bloxwap uses [Privy](https://www.privy.io) for sign-in and wallets. Signing in creates two wallets: an Ethereum-style wallet, which controls your Hyperliquid trading account, and a Solana wallet. - **Where the key lives.** Per [Privy's architecture docs](https://docs.privy.io/security/wallet-infrastructure/architecture), the key is split into encrypted shares. No single share opens the wallet, and neither Privy nor the app holds the complete key. - **How you get back in.** Your login unlocks the wallet. Sign in the same way on a new phone and, per [Privy's new-device docs](https://docs.privy.io/wallets/advanced-topics/new-devices), the wallet usually becomes available with no extra steps. - **How trades happen.** You approve a **trading-only permission** once. It can place and close trades for you but can't withdraw or send your funds. Orders route to Hyperliquid, where they settle. ## Seed-phrase wallet vs. exchange account vs. embedded wallet | | Seed-phrase wallet | Exchange account | Embedded wallet (Bloxwap) | | --- | --- | --- | --- | | Who controls the funds | You | The exchange holds them | You | | Setup | Store 12 to 24 words | Sign up, often with ID checks | Sign in with email, Google, Apple, or X | | Lose your phone | Restore from the phrase | Log in again | Log in again | | Lose your login | Not applicable | Exchange's recovery process | Access can be lost unless you exported the key | | Can a company freeze withdrawals | No | Yes | Bloxwap can't | No option removes risk. Each puts it somewhere different: a paper backup, a company, or your login. ## How to export your private key An exported key is a backup that works without Bloxwap. Most wallet apps can 1. Open [bloxwap.app](https://bloxwap.app) on your phone and sign in. 2. Tap your avatar at the top of the screen, then tap **Advanced**. 3. Tap **Export Ethereum** or **Export Solana**. 4. Copy the key from the window that opens and store it offline. [Privy's export docs](https://docs.privy.io/wallets/wallets/export) say the key is assembled on a separate origin, so neither the app nor Privy can see it. Once you copy it, anyone with that key controls every asset in the wallet. Never paste it into a website or share it, even with someone claiming to be support. ## The risks that remain "Your funds stay in your wallet" describes control. It isn't a promise that nothing can go wrong. - **Your login is the front door.** Someone who takes over your email or social account may reach your wallet. - **Losing that account can lock you out.** An exported key is your way back. - **Deleting your Bloxwap account destroys the embedded wallets' keys.** The app warns you first; withdraw or export before you confirm. - **Trading risk is separate.** Leverage magnifies gains and losses, and **liquidation** can close a position automatically when its margin runs too low. See [Understanding custody and trading risk](/is-bloxwap-safe). ## Account-security checklist - Turn on two-factor authentication for the account you sign in with. - Use a unique, strong password for it. - Store your exported key offline, not in a screenshot or cloud note. - Ignore any message asking for your key or login code. - Try the flow in **Demo**, with practice funds, before adding real money. Next, follow [How to start trading on your phone](/how-to-start-trading-on-your-phone) or read how [Bloxwap and Hyperliquid](/bloxwap-vs-hyperliquid) fit together. ## Frequently asked questions ### Is a wallet without a seed phrase safe? It's a different risk, not zero risk. There's no paper backup to lose, but your login protects the wallet. Secure that account with two-factor authentication and export your key as an independent backup. ### Does Bloxwap hold my money? No. Bloxwap is non-custodial. Your funds stay in your wallet, and the trading-only permission can place trades but can't withdraw funds. ### What if I lose access to my email or social login? You may lose access to the embedded wallet. If you exported the key, you can ### Can I move my wallet to another app? Yes. Export the key from **Advanced** and import it into a wallet that supports private-key import. Your Hyperliquid positions and balances belong to the Ethereum wallet's address, not to the app. Live trading involves real risk. You can lose money, especially with leverage. Only trade what you can afford to lose. You must be at least 18, or the age of majority where you live, and restricted jurisdictions include the United States; check the [Terms of Use](https://bloxwap.com/docs/terms) before trading live. --- # How to trade oil or the S&P 500 from your phone > Bloxwap lists perps that track oil, gold, and US index prices, and you trade them with the same UP and DOWN tap as Bitcoin. Source: https://bloxwap.com/blog/trade-oil-and-the-sp-500-on-your-phone **You can trade oil, gold, and the S&P 500 from your phone with Bloxwap, using perps that track their prices.** Open [bloxwap.app](https://bloxwap.app) in your phone's browser, pick Crude Oil or S&P 500, and tap **UP** if you think the price will rise or **DOWN** if you think it will fall. It's the same tap as Bitcoin. No futures account needed, and leverage magnifies losses as well as gains. ## Which markets you can trade trade.xyz lists these on Hyperliquid, and the market picker shows them under Commodities and Indices. The list can change. | In the app | Ticker | What the price tracks | | --- | --- | --- | | Crude Oil | CL | 1 barrel of WTI crude, the main US benchmark | | Brent Oil | BRENTOIL | 1 barrel of Brent crude, the main global benchmark | | Gold | GOLD | Spot price of 1 troy ounce of gold | | Silver | SILVER | Spot price of 1 troy ounce of silver | | Copper | COPPER | 1 pound of high-grade copper | | S&P 500 | SP500 | The S&P 500 index of 500 large US companies | | Nasdaq 100 | XYZ100 | trade.xyz's tech-heavy index of 100 large non-financial US companies (not the official Nasdaq-100) | | MSCI South Korea | EWY | 1 share of the iShares MSCI South Korea ETF | | DRAM | DRAM | 1 share of the Roundhill Memory ETF (memory-chip companies) | Availability depends on the market and your region. Bloxwap doesn't try to match a broker's full list; it's the shortest path from a view to a position. ## A perp, not a barrel or a fund share Each market is a **perpetual future**, or **perp**: a contract that tracks a price with no expiry date. It isn't a futures contract, an ETF share, or physical oil or gold. You own nothing, and nothing gets delivered. **UP** opens a **long** (you gain if the price rises), **DOWN** a **short** (you gain if it falls). **Margin** is the USDC behind the trade; **leverage** sets the position size. More in [A beginner's guide to perpetual futures](/what-are-perpetual-futures). ## Where the prices come from Each market follows an **oracle**, a price feed trade.xyz publishes to Hyperliquid, built from outside data while those markets are open: - **Gold and silver** use spot prices. - **Oil and copper** reference designated futures contracts, rolled on a set schedule. - **S&P 500 and XYZ100** combine the official index level during US stock hours with index futures quotes around them. trade.xyz licenses the S&P 500 from S&P Dow Jones Indices. The oracle also anchors **funding**, an hourly payment between longs and shorts that keeps a perp near the price it tracks. ## Worked example: going long oil on a supply headline You read about a supply cut and think oil will climb. You put **30 USDC** on Crude Oil at **5x** leverage and tap **UP**, opening a **$150** long. - **Oil rises 4%:** the position gains **$6**, or 20% of your margin. - **Oil falls 4%:** it loses **$6**, or 20% of your margin. Headlines can reverse fast. Costs are charged on the full $150: - **Trading fees:** 9.5 bps (0.095%) per fill, about $0.14 to open and $0.14 to close. These markets add a fee set by the market's deployer on top. See the [fee guide](/bloxwap-fee-guide). - **Funding:** at an example rate of 0.005% an hour, the long pays about $0.18 a day. The rate changes hourly and can flip so longs receive it. After a day, the win nets roughly **$5.50** and the loss costs roughly **$6.50**, before the deployer fee. At 5x, a fall of about 20% would erase the margin, and **liquidation** (the exchange closing a position whose margin runs too low) comes sooner. A [stop-loss](https://bloxwap.com/docs/how-to/set-a-stop-loss) can exit first at a level you choose. ## Trading hours and off-session pricing These perps keep trading on Hyperliquid outside regular market hours, but the price behaves differently when the outside markets are closed. - **The badge.** Commodities and Indices show **Open** during the regular US stock session (9:30 AM to 4 PM ET, weekdays, excluding market holidays) and an **Opens in** countdown otherwise. - **Outside prices.** For oil, metals, and US indices, trade.xyz uses outside prices from Sunday 6 PM ET to Friday 5 PM ET, minus a daily 5 PM to 6 PM ET break. - **Off-session.** On weekends, holidays, and that daily break, the price moves on Hyperliquid trading alone and can jump when the outside market reopens. Thinner order books can also mean worse fills. ## Try it first Start in **Demo**: practice funds, no fees. Pick Crude Oil, tap **UP** or **DOWN**, then **CLOSE**. For **Live**, follow [how to start trading on your phone](/how-to-start-trading-on-your-phone), or see [trading stocks in a crypto app](/trade-stocks-in-a-crypto-app). ## Frequently asked questions ### Can I trade oil on my phone without a futures account? Yes. Bloxwap lists WTI and Brent oil perps that track the price of a barrel. You trade them in your phone's browser with USDC margin; orders route to Hyperliquid. ### Is the S&P 500 market the same as buying an index fund? No. SP500 is a perp that tracks the index level. You don't own shares or receive dividends, and leverage magnifies every index move on your margin. Live trading involves real risk. You can lose money, especially with leverage. Only trade what you can afford to lose. You must be 18 or older (or the age of majority where you live), and restricted jurisdictions include the United States. Check the [Terms of Use](https://bloxwap.com/docs/terms) before trading live. --- # Can you trade stocks like Nvidia in a crypto app? > Yes: Bloxwap lists perps that track NVIDIA, Tesla, Apple, and more next to Bitcoin, with the same UP and DOWN tap. Source: https://bloxwap.com/blog/trade-stocks-in-a-crypto-app **Yes. Bloxwap lists perpetual futures that track the price of stocks like NVIDIA, right next to Bitcoin, and you trade them with the same tap: UP if you think the price will rise, DOWN if you think it will fall.** You don't buy shares. You trade a contract that follows the stock's price, so you get no dividends and no voting rights. ## What you're actually trading A **perpetual future**, or "perp," is a contract that tracks a price and has no expiry date. Going **long** means you gain if the price rises; going **short** means you gain if it falls. The USDC you put behind the trade is your **margin**. So the NVIDIA market on Bloxwap is a perp that tracks NVIDIA's share price, one of Bloxwap's **supported tokenized stock markets**. [A beginner's guide to perpetual futures](/what-are-perpetual-futures) walks through the mechanics with numbers. ## Stock perp vs owning the stock | | Stock perp on Bloxwap | Owning the stock | | --- | --- | --- | | Ownership | None. You hold a contract that tracks the price | You own shares of the company | | Dividends | None | Paid if the company pays them | | Voting | None | Shareholder votes | | Direction | Long or short with one tap | Buying gains only on a rise; shorting usually needs a margin account | | Leverage | Optional, up to a per-market limit; magnifies gains and losses | None in a cash account | | Trading hours | Trades outside the NYSE session, with different pricing and liquidity | Mainly the exchange's regular session, plus extended hours at some brokers | | Funding | Longs and shorts pay each other while a position is open | None | | Where it settles | On Hyperliquid, in USDC, from your own wallet | At a broker, in your brokerage account | ## Which stocks can you trade? Bloxwap lists more than 30 supported tokenized stock markets, including **NVIDIA** (NVDA), **Tesla** (TSLA), **Apple** (AAPL), **Microsoft** (MSFT), **Amazon** (AMZN), **Alphabet** (GOOGL), **Meta** (META), **Coinbase** (COIN), **Robinhood** (HOOD), and **Palantir** (PLTR). Tap the **Stocks** filter in the market picker for the full list, or see the [markets page](https://bloxwap.com/docs/assets). The S&P 500 and Nasdaq 100 sit under **Indices**; see [how to trade oil and the S&P 500 on your phone](/trade-oil-and-the-sp-500-on-your-phone). The list can change, and availability depends on route and region. ## Who runs these markets The stock markets come from **trade.xyz**, a market deployer on Hyperliquid. It uses [HIP-3](https://bloxwap.com/docs/glossary#hip-3), a Hyperliquid upgrade that lets independent operators list their own perp markets. Orders still route to Hyperliquid's order books; Bloxwap is the interface. [Bloxwap and Hyperliquid](/bloxwap-vs-hyperliquid) explains who does what. ## What happens when the stock market is closed These perps keep trading when the New York Stock Exchange is closed: evenings, weekends, and holidays. The market picker shows the NYSE regular session (9:30 AM to 4:00 PM ET on trading days) as a badge on the Stocks section. It reads **Open** during the session and **Opens in** with a countdown when it's closed. After hours isn't the same market. Outside the session the price leans on overnight quotes, and on weekends trade.xyz [steers it with trading on Hyperliquid itself](https://docs.trade.xyz/perp-mechanics/oracle-price). Liquidity can be thinner, fills can be worse, and the price can jump when the stock market reopens. A position held over a weekend is exposed to that gap. ## How to trade Nvidia on Bloxwap 1. Open [bloxwap.app](https://bloxwap.app) in your phone's browser. 2. Start in **Demo**. It uses practice funds, no real money, and no fees. 3. Open the market picker, tap **Stocks**, and choose **NVIDIA**. 4. Set your size and keep leverage low. Each market has its own leverage limit, and larger names like NVIDIA usually allow more than smaller ones. At 10x, a 1% move changes your margin by about 10%, before fees and funding. 5. Tap **UP** or **DOWN**. Tap **CLOSE** when you want out. Before going **Live**, add a [stop loss](https://bloxwap.com/docs/how-to/set-a-stop-loss). If the price moves far enough against a leveraged position, Hyperliquid closes it through [liquidation](https://bloxwap.com/docs/glossary#liquidation), and you can lose the margin behind it. ## What it costs Each open and each close pays the Bloxwap builder fee plus Hyperliquid's trading fee on the full position value, and HIP-3 markets add a fee set by the market's deployer. [Funding](https://bloxwap.com/docs/glossary#funding-rate) passes between traders while a position is open; Bloxwap keeps none of it. The [fee guide](/bloxwap-fee-guide) has the numbers. ## Frequently asked questions ### Can I trade Nvidia in a crypto app? Yes. Bloxwap lists a perp that tracks NVIDIA's share price next to Bitcoin. You trade it with the same UP and DOWN tap, funded with USDC, and you don't own NVIDIA shares. ### Is a stock perp the same as owning the stock? No. Bloxwap's supported tokenized stock markets are perps that track the price of a stock. You get price exposure, long or short, but no shares, dividends, or votes. ### Can I trade stock perps from the United States? No. The United States is a restricted jurisdiction, so Bloxwap isn't available there. Live trading involves real risk. Leverage magnifies gains and losses, and you can lose the money you put in. Only trade what you can afford to lose. You must be at least 18, or the age of majority where you live, and not in a restricted jurisdiction, which includes the United States. See the [Terms of Use](https://bloxwap.com/docs/terms). --- # A trading app that feels like a game > Why Bloxwap plays fast and fun, and why the money is still real. Source: https://bloxwap.com/blog/trading-app-that-feels-like-a-game Looking for a trading app that feels like a game? **Bloxwap** is built to feel that way: pick a market, tap **UP** or **DOWN**, and watch your position move live on your phone. There's no order ticket to fill out and no terminal to learn. But it isn't a game. Live positions use real money, leverage magnifies losses as well as gains, and you can lose what you put in. ## Why Bloxwap feels like a game Most trading apps look like work: order books, dropdowns, and a dozen numbers competing for your attention. Bloxwap keeps the moment simple. - **One tap to a position.** Set your size and leverage once. Then tap **UP** to go long (you gain if the price rises) or **DOWN** to go short (you gain if it falls). - **Fast moves.** Tap **CLOSE** to exit, or **FLIP** to switch sides in one gesture. - **A score you can read.** Your profit and loss updates live on screen, so you always know where you stand. - **Every market, same tap.** Crypto and other markets all use the same controls. See the [assets page](https://bloxwap.com/docs/assets) for what's available. - **Proof worth posting.** A trade you called can become a share card. - **A practice mode.** Demo uses practice funds, so you can learn the controls before any real money is involved. ## Be the superhero, not the follower A game feels good when *you* make the play. Bloxwap is built around that idea. You read the chart, you pick a side, and you own the call. You don't copy someone else's trade or wait for a signal to tell you what to do. That's also what makes it honest. A superhero knows the stakes before they jump. So before your first live trade, understand exactly what you're risking. ## The part that isn't a game The controls are simple. The math underneath is the same as on any perpetual futures exchange. A **perpetual**, or **perp**, lets you trade the direction of a price without owning the asset. Bloxwap routes your orders to **Hyperliquid**, where they execute and settle. - **Leverage cuts both ways.** At 10× leverage, a 1% price move changes your starting margin by roughly 10%, before fees and funding. - **Liquidation.** If the price moves far enough against a leveraged position, the exchange closes it automatically, and you can lose the margin behind it. - **Most retail traders of leveraged products lose money.** When the European Securities and Markets Authority (ESMA) reviewed contracts for difference (another leveraged derivative), it found that **74–89% of retail accounts typically lose money** ([ESMA, March 27, 2018](https://www.esma.europa.eu/press-news/esma-news/esma-agrees-prohibit-binary-options-and-restrict-cfds-protect-retail-investors)). Perps on Hyperliquid aren't the same product, but the lesson carries over: leverage is hard, and a simple interface doesn't change the odds. - **Fees add up.** Every open and every close pays a fee. Trading often, the way a game encourages you to, costs more. See the [fee guide](/bloxwap-fee-guide). For worked examples of profit, loss, funding, and liquidation, read [How Bloxwap payouts work](/bloxwap-payouts-explained). ## How to play it smart 1. **Start in Demo.** Learn how size and leverage change your profit and loss with practice funds. 2. **Pick a size you can afford to lose.** Treat your deposit as money that could go to zero. 3. **Keep leverage low at first.** Lower leverage gives a position more room before liquidation. 4. **Use risk controls.** Set a stop loss and take profit when you set up the trade. 5. **Take a break after a loss.** Chasing a loss with a bigger trade is how a bad day gets worse. Bloxwap is **non-custodial**: your funds stay in your own wallet, and the app can't withdraw them. Read [Understanding custody and trading risk](/is-bloxwap-safe) for how that works. ## Frequently asked questions ### Is there a trading app that feels like a game? Yes. Bloxwap turns a trade into one tap: pick a market, then tap UP or DOWN, and your profit and loss updates live. It feels quick and fun, but live trading uses real money and carries real risk of loss. ### Is Bloxwap gambling? No. It's leveraged trading on real markets, and it involves real risk. Bloxwap makes the interface simpler. It doesn't make outcomes more certain. ### Can I try Bloxwap without real money? Yes. Demo uses practice funds, so you can learn the controls and see how size and leverage behave before trading live. ### Can I lose more than I deposit on Bloxwap? You can lose all of the money you put in. Leverage can wipe out the margin behind a position quickly, and liquidation closes it automatically. With cross margin, other collateral in your trading account can also be at risk. Only trade money you can afford to lose. ### Who can use Bloxwap? Eligibility depends on your age and where you live. Check the [Terms of Use](https://bloxwap.com/docs/terms) before trading live. ## Risk disclosure Trading perpetual futures with leverage involves a high risk of loss and isn't suitable for everyone. You can lose some or all of the money you put in. Bloxwap is an interface and does not give financial advice. Past results and share cards don't predict future returns. Read the full [Risk Disclosure](https://bloxwap.com/docs/terms#3-risk-disclosure) before trading, and only trade what you can afford to lose. --- # A beginner’s guide to perpetual futures > Longs, shorts, leverage, and funding, explained with a simple example. Source: https://bloxwap.com/blog/what-are-perpetual-futures A **perpetual future**, or "perp" for short, is a contract that lets you trade on whether a price will go up or down, without owning the thing itself and without a fixed expiry date. Your gain or loss depends on the direction and size of the price move. A Bitcoin perpetual gives you exposure to Bitcoin's price without buying Bitcoin. The same principle applies to perpetuals tracking stocks or commodities: the contract does not grant ownership of the underlying asset. ## How perps work When you open a perp, you pick a direction: - **Long** means you think the price will go **up**. - **Short** means you think the price will go **down**. You put down some money to back the trade. That deposit is called **margin**. On Bloxwap, margin is held in **USDC**, a stablecoin designed to track the US dollar. Most perps let you use **leverage**, which multiplies the size of your trade. With 10x leverage, 50 USDC of your own money controls a $500 position. A small price move then becomes a bigger gain, or a bigger loss. Leverage magnifies gains and losses. Here's a worked example. You go long on Bitcoin with **50 USDC** at 10x leverage: - Bitcoin rises 2%: the $500 position gains **$10**, or **20% of your margin**. - Bitcoin falls 2%: the position loses **$10**, or **20% of your margin**. These figures exclude fees and funding. If the position no longer meets the exchange's minimum margin requirement, the exchange can close it through **liquidation**. This can consume the margin backing the trade. At higher leverage, a smaller adverse price move can reach that threshold. The **funding rate** determines recurring payments between long and short holders. Those payments help keep a perpetual's price aligned with its underlying market. Depending on the rate and your direction, you may pay or receive funding while a position is open. ## How perps differ from regular futures A normal ("dated") future has an **expiry date**, a day when the contract ends and settles. A perpetual has no scheduled expiry to roll over, but you must continue to meet margin requirements and account for funding costs. The funding rate is the trade-off. A dated future doesn't need one; a perp uses it to stay anchored to the real price. ## Why people trade perps - **No expiry to manage:** open and close on your own schedule. - **Trade both directions:** you can profit when a price falls, not only when it rises. - **Capital efficiency:** leverage lets a small deposit control a larger position (with matching risk). - **No ownership needed:** you don't have to hold the actual coin or asset. ## Where Bloxwap fits [Bloxwap](https://bloxwap.app) provides a mobile trading interface for **Hyperliquid**. Choose your market, margin, and leverage, then: - **Tap UP** to go long. - **Tap DOWN** to go short. Bloxwap is **non-custodial**: you control your wallet and trades settle on Hyperliquid. Trading approvals do not grant permission to withdraw funds. New to the app itself? Start with [What is Bloxwap?](https://bloxwap.com/blog/what-is-bloxwap). To see what you can trade, browse the [assets page](https://bloxwap.com/docs/assets). ## A note on risk Leverage magnifies losses as well as gains, and liquidation can close your position. Demo mode uses practice funds so you can learn the controls before trading live. Review [fees](https://bloxwap.com/docs/fees) and [eligibility](https://bloxwap.com/docs/terms), and only trade money you can afford to lose. --- # What happens after you tap: who holds your money, and who takes the other side? > The path a Bloxwap order takes from your tap to a fill on Hyperliquid, who fills it, and how to check it yourself. Source: https://bloxwap.com/blog/what-happens-after-you-tap **Bloxwap doesn't hold your money, and it doesn't take the other side of your trade.** When you tap **UP** or **DOWN**, your order is signed on your device and sent to Hyperliquid's public order book, where other traders fill it. The position lives on Hyperliquid, in an account your wallet controls. Bloxwap earns a disclosed builder fee on each fill. That doesn't mean you'll win, or that every fill lands at the price you saw. It means the path is public, and you can check it. ## The path from tap to fill | Step | What happens | Who does it | | --- | --- | --- | | 1. Sign | A buy (**UP**) or sell (**DOWN**) order is signed | A trading-only key on your device | | 2. Send | The order goes to Hyperliquid with the builder fee attached | Your phone, directly | | 3. Match | The order fills against resting offers on the book | Other traders and market makers | | 4. Settle | The position is recorded under your wallet address | Hyperliquid | **1. Your device signs the order.** The first time you trade live, your wallet signs one-time approvals on Hyperliquid. The key one is a **trading-only permission**: a separate key created in your browser and kept on your device. It can place and close trades, but it can't withdraw your funds. Another sets the most Bloxwap can charge as a builder fee. After that, the trading-only key signs each tap, so you don't approve every trade. **2. The order goes straight to Hyperliquid.** Bloxwap is the interface, not the exchange. Your phone sends the signed order to Hyperliquid's API, with no Bloxwap order book in between. A tap sends an **immediate-or-cancel** order: it fills right away at up to 0.5% worse than the latest price, and any part that can't fill within that limit is canceled. **3. Other traders take the other side.** Hyperliquid's **order book** is a live list of buy and sell offers, matched by price, then by time. Tap **UP** and you buy from whoever offers the best price: another trader or a market maker (a trader who keeps offers posted on both sides). Bloxwap doesn't choose your counterparty and has no book of its own to route you into. **4. The position settles on Hyperliquid.** Your position, margin (the USDC backing it), and profit and loss are recorded under your wallet address. Tap **CLOSE** and Bloxwap sends a **reduce-only** order, which can only shrink your position, never open a new one the other way. Stop loss and take profit orders are reduce-only too. ## How Bloxwap makes money Bloxwap earns a **builder fee**, a fee Hyperliquid lets an interface add to the orders it sends, capped by the approval you signed. Every fill, open and close, is charged on position value (margin × leverage): - **Bloxwap builder fee:** 5 bps (0.05%), or 2.5 bps for [Genesis](https://bloxwap.com/docs/genesis) traders. - **Hyperliquid taker fee:** 4.5 bps at the base tier. - **Total:** 9.5 bps per fill, about $1.90 to open and close a $1,000 position. Stock, commodity, and index markets add a deployer fee. Bloxwap keeps none of your funding payments (the periodic payments between longs and shorts), and the fee rate is the same whether you win or lose. The [fee guide](/bloxwap-fee-guide) has the dated table. ## How to check it yourself 1. In Bloxwap, open the account sheet, tap **Receive**, and copy your Ethereum wallet address. 2. Paste it into the [Hyperliquid explorer](https://app.hyperliquid.xyz/explorer). 3. Read the list: orders placed for your address, each with its hash, block, and time. Every trade on Hyperliquid records the addresses on both sides. Developers can pull your fills (price, size, fee, and builder fee) and your approved maximum builder fee from Hyperliquid's public [info API](https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint). ## What this doesn't promise A public path isn't a promise of a good result. - **Prices can slip.** In a fast or thin market, your fill can land worse than the price on screen, or only partly fill. - **Liquidity varies.** Stock, commodity, and index markets can have fewer offers, especially outside regular US trading hours. - **Venue and software risk remain.** Exchange bugs, smart contract flaws, outages, and interface errors can all affect trades. - **Leverage cuts both ways.** It magnifies gains and losses, and a position can be liquidated (closed automatically when its margin runs too low). For custody and what the trading-only permission can do, read [Understanding custody and trading risk](/is-bloxwap-safe). For how the app and the exchange split the work, read [Bloxwap and Hyperliquid](/bloxwap-vs-hyperliquid). ## Frequently asked questions ### Does Bloxwap hold my money? No. Your funds stay in your own wallet and your Hyperliquid trading account, which your wallet controls. The trading-only permission can place and close trades but can't withdraw your funds. ### Is Bloxwap betting against me? No. Bloxwap doesn't act as the counterparty to your orders. Every live order goes to Hyperliquid's public order book, where other traders and market makers fill it. ### Is Bloxwap rigged? Bloxwap can't promise any market is fair, but its part is public: your orders, fills, and fees are recorded on Hyperliquid, and anyone can look up your address. Fills still depend on liquidity and can slip. Trading perpetual futures with leverage involves a high risk of loss. You can lose some or all of the money you put in. Try the flow in **Demo** first, and only trade what you can afford to lose. You must be 18 or the age of majority where you live, and restricted jurisdictions include the United States; see the [Terms of Use](https://bloxwap.com/docs/terms). --- # What is Bloxwap? > Meet the app, learn the basics, and take your first look at trading. Source: https://bloxwap.com/blog/what-is-bloxwap Bloxwap lets you trade on the direction of a price. Tap **UP** to open a long position or **DOWN** to open a short. Your orders go to **Hyperliquid**, the exchange where the trades execute. ## What Bloxwap is Bloxwap is a **trading interface**: an app that sits on top of an exchange and makes it easy to use. The exchange underneath is **Hyperliquid**, a decentralized platform where people trade **perpetuals** (more on that word in a moment). Bloxwap doesn't run the exchange or hold your money. It gives you a one-tap way to place trades on it. Bloxwap ([bloxwap.com](https://bloxwap.com)) is not affiliated with BLOX (weareblox), the Dutch crypto app; BloxSwaps, the Roblox trading site; or BLOX Digital. ## What "perpetuals" means A **perpetual** (or "perp" for short) is a kind of trade on whether a price goes up or down, without ever owning the thing itself. You're not buying Bitcoin; you're trading on which way its price moves. A perp has no fixed expiry date. You can hold a position while it meets the exchange's margin requirements, and submit an order to close it when you choose. You can also use **leverage**, which magnifies gains and losses. With 10× leverage, a 1% price move produces roughly a 10% gain or loss on your starting margin, before fees and funding. ## How it works 1. **Pick a market**, such as Bitcoin, Ethereum, or a perpetual tracking a stock. 2. **Set your size and leverage.** Bloxwap uses **USDC**, a stablecoin designed to track the US dollar, as trading collateral. 3. **Choose a direction.** Tap **UP** to go long or **DOWN** to go short. 4. **Manage the position.** Watch its profit and loss, adjust risk controls, or tap **CLOSE** to submit an exit order. For example: you put **50 USDC** on Bitcoin going up with 10x leverage. If Bitcoin rises 2%, your position gains about 20% of your 50 USDC, roughly **$10**. If it falls 2% instead, you lose about $10. These examples exclude fees and funding. ## Who it's for Bloxwap is designed for people who prefer compact trading controls on their phone. A full trading terminal may be a better fit for detailed order entry or more advanced tools. Eligibility depends on your age and jurisdiction; check the [Terms of Use](https://bloxwap.com/docs/terms) before trading live. ## How it's different from using Hyperliquid directly You *can* trade on Hyperliquid without Bloxwap. The difference is the experience: - **Simpler:** one tap to open or close, instead of filling out an order form. - **Mobile-first:** the chart and trade controls fit a phone screen. - **Non-custodial:** Bloxwap never holds your funds. Your money stays in your own wallet, and every trade settles on Hyperliquid. You approve a trading-only permission once, so taps don't need a signature each time. That permission can place trades but can't withdraw your funds. ("Non-custodial" just means no one takes custody of your money but you.) Orders use Hyperliquid's markets and settlement. Fill prices depend on the order and available liquidity. Bloxwap also adds a builder fee; see the [fee breakdown](https://bloxwap.com/docs/fees). ## Where to start - Open [bloxwap.app](https://bloxwap.app) and try your first position in Demo. Demo uses practice funds, so nothing real is at risk. - Browse what you can trade on the [assets page](https://bloxwap.com/docs/assets). - Read the full [docs](https://bloxwap.com/docs) for fees, networks, and more. Live trading involves real risk. You can lose money, especially with leverage. Only trade what you can afford to lose.