@locker-protocol/agent-wallet-hyperliquid-trader

v2.5.0

Published

10 hours ago

Your private key is nowhere: not on our servers, not on the agent's machine, not with anyone. The agent trades. It holds nothing. Locker Protocol Agentic: the lpa command, an agent wallet for Hyperliquid perps whose keys stay offline in Locker Vault.

@locker-protocol/agent-wallet-hyperliquid-trader

Your private key is nowhere: not on our servers, not on the agent's machine, not with anyone.

The agent trades. It holds nothing.

Where the key is: the account's private key stays in Locker Vault, an offline app on a phone or tablet. This computer only holds an agent key, sealed under a password, that expires on its own (six months by default, the longest Hyperliquid allows).
Who can withdraw: only the vault, by a QR code a person scans and signs. Hyperliquid refuses the agent key every withdrawal and every send; the one movement of funds it accepts from that key is a deposit into a Hyperliquid vault, which lpa never signs (measured on mainnet, 2026-09-28).
What goes where: orders and reads go to Hyperliquid, deposits and balances to Arbitrum nodes, and nothing else unless you turn it on (the list is below). No server of ours, no account, no telemetry.

Documentation: doc.lockerprotocol.com/agent-wallet: install, the setup in steps, how it trades and every command. Website: hyperagentictrader.com.

lpa is an agent wallet for Hyperliquid perps: a command line for people and for AI agents, with a simulation account on the real order book, a local policy checked before every order, and every movement of funds signed by your own wallet, Locker Vault first.

This page is the complete reference: how it works, then every command with its flags, its defaults and an example.

How it works
Words used here
How long things last
Install
The whole way in one command: lpa setup
Quick start in simulation
Set up a real account
Conventions shared by every command
Command reference
- Setup and the guardian: setup, init, unlock, lock, status, doctor, panic
- Market data: perps venues, markets, quote, regime, ranges
- Account reads: perps positions, balance, orders, fills, funding, fees, ledger, wallet address, wallet balances
- Orders: perps open, close, cancel, modify
- Movements of funds: perps deposit, withdraw, transfer, agent revoke, agent show, agent renew
- Simulation mode: paper init, status, on, off, record, replay
- Policy: policy show, policy set
- The mandate: mandate sign, show, revoke, release
- Journal: journal, journal export
- The record: store status, prune, export, backup
- Copy a trader: copy start (in simulation, or --live), stop, status, resume
- The pilot: pilot start, stop, pause, resume, status, ask, notes, rules
- The live page: live
- hyperkeel market data: hyperkeel login, status, logout, brief, leaders, follows, follow, unfollow, alerts, off, on
- Plugins: plugins install, list, inspect, remove, disable, enable, and lpa <plugin> <command>
- Settings page: config
- Running on a server: service ..., console, console password
- Several accounts: profile list, add, use, rename, remove, and --profile <name> on any command
- Housekeeping: reset, uninstall
The interactive session
For AI agents: the switch of the server for assistants, mcp status, off, on, forget
Use it from a program
Write a plugin
Error codes
Files and environment variables
What the agent key can and cannot do
Network
Fees

How it works

Three places, and one rule: the key that owns the money never leaves the phone.

  PHONE (offline)              THIS COMPUTER                              HYPERLIQUID
 +--------------------+      +-----------------------------------+      +----------------+
 | Locker Vault       |      | lpa   <- you, a script, or an AI  |      |                |
 |                    |      |  |       agent (shell or MCP)     |      |  order book    |
 | holds the ACCOUNT  |      |  |                                |      |                |
 | key; it never      |  QR  |  |  1. quote on the live book     |      |  your account  |
 | leaves the phone   |<---->|  |  2. local policy               |      |                |
 |                    |codes |  |  3. your go                    |      |                |
 | signs: the agent's |      |  v                                |      |                |
 | approval, deposits,|      | guardian (background process)     |      |                |
 | withdrawals, dex   |      |   holds the AGENT key in memory,  |----->|  orders,       |
 | transfers, revoke  |      |   checks the policy again, signs  |      |  cancels,      |
 +--------------------+      |   trading actions only            |      |  leverage,     |
                             +-----------------------------------+      |  TP/SL         |
                                                                        +----------------+

Locker Vault is an app on a phone or tablet that stays offline. It holds the account's key and signs by QR code: the computer shows a request as a QR code, the phone's camera reads it, the person reads what it does on the phone and signs, the phone shows the signature as a QR code, the computer's webcam reads it back. Nothing is installed on the computer for this; lpa only shows and reads QR codes.
The agent key is a second key, made on this computer by lpa init, approved once by the vault, and sealed on disk under a password. Hyperliquid lets it trade for the account, and refuses it every withdrawal and every send. It expires on its own, six months by default, the longest Hyperliquid allows: its date is not what protects you, the closed list of what it signs, the mandate you sign on the phone each month and the dedicated account are.
The guardian is a background process that lpa unlock starts. It holds the agent key in memory, checks every order against your policy a second time (and against the mandate you signed on the phone, once there is one), and signs only a closed list of trading actions. It answers only requests that carry the token it writes in ~/.lpa at start. The password and the key never reach the agent that calls lpa.

Who signs what:

| What | Signed by | Where | |---|---|---| | Markets, quotes, positions, balances | nobody | public reads of Hyperliquid and Arbitrum | | Simulated orders | nobody | filled on this computer, on the live book | | Open, close, cancel, modify | the agent key, in the guardian | after the quote, the policy and your go | | Approve the agent (lpa init), revoke it | Locker Vault | QR ceremony, on the phone | | Deposit, withdraw, move margin between dexes | Locker Vault | QR ceremony, on the phone | | The mandate: the agent's limits, signed once | Locker Vault | QR ceremony, on the phone | | A live copy's orders | the agent key, in the guardian | under the policy and the mandate that names the trader | | A live pilot's orders | the agent key, in the guardian | under the policy and a mandate that allows pilot, read again before each opening | | An order the pilot proposes | the agent key, in the guardian, once you confirm it | on the live page: the terminal that serves it asks you, or the console's password | | A plugin's commands | nothing for the real account | a separate process that reads its own folder only |

The life of an order, the same for the real account and for the simulation one:

 lpa perps open --symbol ETH --side long --size 0.03 --leverage 3
   |
   |  1. quote       entry and worst price on the live book,
   |                 fees as one total, liquidation estimate
   |  2. minimum     Hyperliquid refuses under $10 ............ BELOW_MIN_ORDER
   |  3. policy      size, leverage, dex, market, orders a day,
   |                 risk:reward; and the mandate
   |                 signed on the phone, when there is one ... POLICY_REJECTED
   |  4. --dry-run   stops here: nothing is signed
   |  5. your go     [y/N] at the terminal, or --yes ......... CONFIRMATION_REQUIRED
   v
 +-------------------------------+        +------------------------------+
 | real account                  |   or   | simulation account           |
 | the guardian rebuilds the     |        | (--paper, or lpa paper on)   |
 | order, checks the policy      |        | fills on the live book, with |
 | again, signs with the agent   |        | the real fees, funding and   |
 | key, sends it to Hyperliquid  |        | liquidation                  |
 +-------------------------------+        +------------------------------+
   |                                          |
   +------------------> lpa journal <---------+

What it is not: a trading strategy. Locker Protocol Agentic runs a loop, bounds it, remembers what it learned and shows everything it does; whether an idea makes money is not something it promises, in simulation or for real.

Words used here

| Word | What it is | |---|---| | Account | Your Hyperliquid account. Its key lives in Locker Vault on the phone, and never on this computer. | | Locker Vault | The offline app on a phone or tablet that holds the account key and signs by QR code. | | Agent, or trading key | The second key lpa makes, approved once by the vault. It places and cancels orders; Hyperliquid refuses it every withdrawal. | | Guardian | The background process that holds the agent key in memory, checks every order again and signs. | | Unlock, lock | Giving the guardian the agent key for a while (your password), and taking it back. | | Service | The guardian run by the system, round the clock, with its console. | | Console | The service's page on 127.0.0.1:7717, behind a password of its own. | | Policy | The limits of this computer, in policy.json: size, leverage, dexes, markets, orders a day, risk to reward. | | Mandate | Limits you sign on the phone, for the agent's life at most (180 days). The guardian applies the narrower of the mandate and the policy. | | Use | What a mandate allows: trade, copy, pilot. | | Quote | What an order would cost before it is signed: entry, worst price, notional, the fees as one total, the liquidation estimate. | | Notional | The value of a position: its size times its price. | | Fees | Hyperliquid's and Locker's, always shown as one total. | | Dex | Hyperliquid's main market, or a builder's (HIP-3), whose markets read dex:TICKER. | | Simulation account, simulation mode | The account that fills on the real book with the real fees; the mode that sends every order there. | | Journal | journal.jsonl: what was done, and the authority on the day's counters. | | Record | activity.db: what every activity did and thought, for the live page. It costs visibility, never money. | | Activity | One session, one service, one copy, one MCP client or one pilot, as the record holds it. | | Session | lpa alone: the interactive screen, with the assistant. | | Assistant | The model that answers in the session, with tools, under your go. | | Pilot | The agent that trades on its own, in the guardian, one deliberation at a time; in simulation first. | | Deliberation | One turn of the pilot, from what woke it to its end_turn: eight steps of tools at most. | | Brief | What a deliberation starts from: positions, orders, equity, the day's counters, the limits, the marks, the last journal lines. | | Memory | The pilot's notes and rules to itself; your lines stand above its own. | | Context | What is sent to a model, measured before it goes, under a ceiling. | | Proposal | An order the pilot asks you to confirm on the live page, instead of placing it. | | Live page | lpa live: every activity of this computer as it happens. | | Copy | Following a trader's orders, in simulation or live. | | MCP client | An outside agent that uses lpa through locker-mcp. | | Plugin | Someone else's command, run in a process of its own that reads its own folder only. | | Panic | lpa panic: every pilot and copy stopped, then the key leaves memory. |

How long things last

| What | How long | Set by | |---|---|---| | The agent key | 180 days at most, the longest Hyperliquid allows | lpa init --days, lpa agent renew | | The mandate | the agent's life, 180 days at most, never past the agent | lpa mandate sign --days | | The key in a terminal's guardian | 8 hours (24 at most) | lpa unlock --hours | | The key in the service | the agent's life, or the hours asked, until lpa lock or a restart of the machine | lpa unlock [--hours], the console | | The key without a signature | as long as its session, or the minutes asked: it then locks itself | lpa unlock --idle-minutes | | A console session | 12 hours | its sign-in | | A quote through MCP | 10 minutes | the MCP server | | A quote on the live page | 120 seconds from when it is shown | the live page | | An order the pilot proposes | offered 30 minutes | the pilot | | The record | 90 days and 512 MB, whichever comes first | lpa store prune --days --max-mb |

Install

npm install -g @locker-protocol/agent-wallet-hyperliquid-trader@latest

Node 22.13 or later (the first to read the record of what lpa does, node:sqlite, without a flag). This installs the command lpa.

Or the one-line installers, which fetch Node when it is missing and put everything in ~/.lpa, with no administrator rights:

On macOS and Linux:

curl -fsSL https://hyperagentictrader.com/agent-wallet-install.sh | sh

On a server, to install and start the guardian as a service in one go (see Running on a server):

curl -fsSL https://hyperagentictrader.com/agent-wallet-install.sh | sh -s -- --service

On Windows (PowerShell):

irm https://hyperagentictrader.com/agent-wallet-install.ps1 | iex

Node is downloaded from nodejs.org only when the machine has no Node 22.13 or later, and checked against the SHA-256 written into the script. Running the installer again updates.

What is installed: the one-line installers put this package and the MCP server, @locker-protocol/agent-wallet-hyperliquid-trader-mcp, in ~/.lpa/lib (with @locker-protocol/agent-wallet-hyperliquid-signer and @locker-protocol/agent-wallet-vault as their dependencies), and two launchers in ~/.lpa/bin: lpa, and locker-mcp for your MCP client (claude mcp add locker -- ~/.lpa/bin/locker-mcp). One copy, one version for both, updated together; the installer checks that locker-mcp answers at the version of lpa. npm install -g installs lpa alone, and an MCP client can then fetch the server with npx, pinned to the same version. A guardian signs nothing for a program of another version (VERSION_MISMATCH). lpa uninstall removes what it installed (see Housekeeping).

Check the install:

lpa --version
lpa doctor

The whole way in one command: lpa setup

lpa setup            # with your phone: about ten minutes
lpa setup --paper    # a simulation account instead, with no phone and no money

lpa setup walks the way in nine steps, each one a command you can also run alone, and says at each one where it is (Step 4 of 9 · Some funds) and what it did:

| # | Step | What it runs | What it asks of you | |---|---|---|---| | 1 | This computer | the checks of lpa doctor | nothing | | 2 | Your model | an explanation, then lpa config | a key from a provider, pasted in the settings page; or "later" | | 3 | Your vault account | lpa init, its first step | the phone, a webcam | | 4 | Some funds | a wait for USDC, then for a little ETH, on Arbitrum, then lpa perps deposit | a transfer, the phone | | 5 | Your password and the trading key | lpa init, the rest | a password of fourteen characters, two signatures | | 6 | Your limits | the policy in force | keep it, or change it in lpa config first | | 7 | The limits you sign on the phone | lpa mandate sign --actions trade,pilot | the phone | | 8 | Round the clock | lpa service install | yes or no; a second password, for the console | | 9 | The daily pilot, in simulation first | lpa paper init, then lpa pilot schedule --on | yes or no, once what a day costs is said |

The model. lpa does not come with an AI model: the pilot, and orders asked in plain words, think with one you bring. Step 2 says so in plain words and gives the three ways: a provider you pay yourself (you open an account at Anthropic, OpenAI or Google, add a few dollars of credit and create an API key, a long password that lets lpa use the model in your name; the step gives the page where a key is made at each), a model on your own computer (LM Studio or Ollama: free, nothing leaves the machine), or later. With the recommended model, claude-sonnet-5 at Anthropic, a day of the daily pilot costs about 9 cents when it deliberates and under one cent when no market is on the table. A no, or a settings page closed with nothing chosen, is a "later": setup goes on, and the last step says the pilot waits for a model.

What the daily pilot asks of the account. The funds step says it before you send anything: with the default charter the pilot opens nothing below $120 (its first step would be under Hyperliquid's smallest order of $10), and with claude-sonnet-5 it trades from about $324, since the charter keeps the model's cost under a tenth of what a trade aims at. Orders you place yourself need $10 each. A program that reads lpa setup --facts gets what each figure is made of under facts.floorParts: venue (minOrderUsd, Hyperliquid's smallest order; of, first-step or grid-level; sharePct, the share of the equity that step or level takes as notional; floorUsd, the one over the other), and model and recommended, for the model in use and the recommended one at its public price (dayUsd; modelSharePct, the share of a trade's target the model may take; targetPct, the target as a share of the base stake; stakePct, the base stake as a share of the equity; floorUsd, the day over the product of the three). Each is null where the charter has no such floor (a strategy with a stop or a range, a grid's model) or the model no price. facts.modelPace says how long the model in use takes to deliberate on this computer, measured on its own deliberations here and never estimated: deliberations (how many) and secondsPerDeliberation (their median, the calls of one deliberation together; the pilot's choice of the day, a draft and a failed call left out); null before the first one.

The last step opens a simulation account of $1,000 when there is none and has the service play the daily pilot on it every day (lpa pilot schedule --on, which asks its own question, with what a day costs). Nothing of your real account moves and simulation mode stays as it was; lpa pilot schedule --on --live moves the pilot to your real account once you have seen it work. Setup no longer arms the continuous pilot, which thinks every fifteen minutes and costs accordingly: lpa pilot start is yours to run. Without the service nothing plays a day on its own, and the step says so.

It reads where things stand before each step and skips what is done: cut anywhere (a closed terminal, Esc in a wait, a refusal), lpa setup again takes it up where it stopped, and on a computer set up whole it changes nothing; a "no" you gave (the service, the service fee, the model, the pilot) is kept and not asked again. It never offers a deposit below 5 USDC, since the bridge loses less. On a machine with no screen (over SSH), the phone's pages go through the service's console, so the service comes first, right before the model. It ends on what is, from where things stand: the schedule or its absence, a model still missing, a simulation mode left on. --paper opens a simulation account and turns simulation mode on, and leaves out the account, the funds, the key and the signed limits. It is the person's: an agent's shell is refused.

Quick start in simulation

The simulation account fills on Hyperliquid's real book, with the real fees, and needs no key, no vault and no deposit. The sizes below fit the default policy ($100 per order at most, leverage 3 at most).

lpa paper init --budget 1000
lpa perps quote --symbol ETH --side long --size 0.03 --leverage 3
lpa perps open  --symbol ETH --side long --size 0.03 --leverage 3 --paper
lpa paper status
lpa perps close --symbol ETH --paper
lpa journal

In a terminal, open and close show the quote and ask [y/N] before they fill. Without a terminal (a script, an agent), they answer CONFIRMATION_REQUIRED until you add --yes.

To send every perps command to the simulation account without typing --paper:

lpa paper on      # orders fill in simulation; positions, balance and orders read from it
lpa paper off     # back to the real account

Set up a real account

Three ways to sign for your account, chosen once by lpa setup (or lpa init --with vault|browser|mobile) and kept with the account:

| Way | What you need | What leaves this computer | |---|---|---| | Locker Vault, the safest, recommended | Locker Vault on a phone or tablet kept offline, a webcam | nothing: requests and answers travel as QR codes | | Your browser extension (MetaMask, Rabby) | the extension, in the browser that opens the page of this computer (http://127.0.0.1:7718) | nothing more: the extension signs on that page | | Your mobile wallet (MetaMask, Rabby, Coinbase Wallet...) | the wallet on your phone: you scan a WalletConnect QR once, then approve each request there | the requests, end-to-end encrypted, through WalletConnect's relay, which sees this computer's IP address and the time; the link lasts seven days, lpa signer forget closes it |

With an extension or a mobile wallet, the account is proven first, before any money: one signature that moves nothing, checked here and sent nowhere; an address that is a contract (a smart wallet) is refused. Every signature, whatever signs it, is checked to come from the account before anything is sent. A hardware wallet behind your extension or your mobile wallet may show only a fingerprint of a typed signature. The trading key and the mandate are bound to the address: changing how you sign (lpa signer use) keeps them.

The rest of this section follows Locker Vault. You need Locker Vault on a phone or tablet (free, from https://vault.lockerprotocol.com), an account created from a secret phrase in it, and a computer with a webcam.

1. A funded account. Hyperliquid refuses every action of an account it has never seen funded, so lpa init reads the account first and stops there if it is empty:

Account 0x3f5CE5FBFe3E9af3971dD833D26bA9b5C936f0bE saved. It has nothing on Hyperliquid yet: deposit first, at least 5 USDC (the bridge loses less), with `lpa perps deposit --amount 10`, then run `lpa init` again.

Then send USDC and a little ETH for gas (0.0005 ETH is plenty) to that address on Arbitrum One, deposit (the phone signs it), and run lpa init again:

lpa perps deposit --amount 20
lpa init

An account already funded on Hyperliquid goes straight to the next step.

2. Approve an agent: lpa init.

 lpa init                          local page, 127.0.0.1               Locker Vault (phone)
   |                                                                  
   |  opens the page  --------->   1. the webcam reads     <--------  Accounts > the account
   |                                  the sync QR                      > Extension Sync
   |                                  (public address only)            > Show the sync QR
   |
   |  2. you type a password (14 characters or more, twice):
   |     the new agent key is sealed on this computer first
   |
   |                               3. approveAgent shown   --------->  Sign > Scan QR Code
   |                                  as a QR code                     > Start QR Scanner
   |                                  the webcam reads     <--------  review the card, sign
   |                                  the answer
   |
   |                               4. "Authorize the Locker  ------->  review, sign or refuse
   |                                  service fee" (optional)
   v
 Ready: agent 0x... until <date>.  Next: lpa unlock

The page tells you, at every step, exactly what the phone must show before you sign; anything different, tap Refuse on the phone. The account key never leaves the phone: only its public address travels, and only signatures come back.

3. Unlock, trade, lock.

lpa unlock                     # asks the password, starts the guardian for 8 hours
lpa perps quote --symbol ETH --side long --size 0.03 --leverage 3
lpa perps open  --symbol ETH --side long --size 0.03 --leverage 3 --tp 2750 --sl 2600
lpa perps positions
lpa perps close --symbol ETH
lpa lock                       # the agent key leaves memory

When the agent expires, lpa init approves a new one with one more scan.

Conventions shared by every command

Writing a command. lpa <group> <command> --flag value. --flag=value works too. A flag the command does not know, or a word that is not a flag, is refused with BAD_ARGUMENTS.

| Kind of value | How to write it | Example | |---|---|---| | Market | the name Hyperliquid uses; a HIP-3 dex market is dex:TICKER | BTC, ETH, xyz:GOLD | | Size | in the base asset, not in dollars | --size 0.03 is 0.03 ETH | | Leverage | a whole number | --leverage 3 | | Price | a plain decimal | --tp 2750 | | Amount | USDC, a plain decimal | --amount 25 | | Dex | its name, main for the main dex | --dex xyz, --to-dex main | | Address | 0x and 40 hex characters | --address 0x5b5d...c060 | | Moment | a duration back from now, a day, a date or a timestamp in ms | 24h, 7d, 30m, 20260929, 2026-09-29 |

Output. Text for a person on stdout, progress lines on stderr. --json (or --format json) prints the same result as JSON, which is what the MCP server returns too. On the command line, these global flags go anywhere on the line (the interactive session takes neither --json nor --format: see below):

| Flag | Effect | |---|---| | --json, --format json | the result as JSON | | --format human | the default | | --profile <name> | the account the line runs for: the profile of that name (see Several accounts); without it, LPA_HOME, then the profile lpa profile use chose, then ~/.lpa | | --help, -h | the command's usage; lpa --help lists every command | | --version, -v | the version |

-- ends the reading of these flags: what follows it is the command line as written. Written where an option waits for its value, -h or -v is that value, refused by the option, rather than the help.

Errors. A refusal exits with code 1 and carries a stable code, a sentence and, most of the time, what to do next:

$ lpa perps open --symbol ETH --side long --size 0.05 --leverage 3 --paper
Error [POLICY_REJECTED]: The policy refuses this order: $133.47 is above the $100 per order.
Hint: See `lpa policy show`. Closing and cancelling are always allowed.

$ lpa perps open --symbol ETH --side long --size 0.03 --leverage 3 --paper --json
{
  "error": {
    "code": "CONFIRMATION_REQUIRED",
    "message": "Simulated long 0.03 ETH at 3x needs the user's go.",
    "hint": "Show the quote to the user; once they agree, run the same command with --yes."
  }
}

Every code is listed under Error codes.

The refusals a window can meet carry, beside the sentence, their cause as a stable word (reason) and the figures the sentence holds by name (facts), so that a program says them in its own words and its own language: LOCKED is guardian-not-running, no-key, wrong-password, too-many-attempts (with waitSeconds) or needs-terminal, NEEDS_DEPOSIT is arbitrum-usdc-short (with usdc and amount) or arbitrum-gas-short, BELOW_MIN_ORDER is below-minimum (with notionalUsd, px and minUsd), NO_MODEL is no-model (with missing: provider, key, address or model) or no-price, and so on for CONFIRMATION_REQUIRED, MANDATE_INVALID, MANDATE_OUTDATED (outdated), INSUFFICIENT_MARGIN, MARKET_HALTED, AGENT_NOT_APPROVED, AGENT_EXPIRED, NOT_INITIALIZED, QUOTE_STALE and SPEND_CEILING (day-ceiling, with spentUsd and ceilingUsd). A word is never renamed; a refusal without a known cause has neither field. The console's and the live page's refusals carry the same two.

{ "error": { "code": "NEEDS_DEPOSIT", "message": "The account holds 3.0 USDC on Arbitrum, less than 25.", "hint": "Send USDC to 0x8c1f...9a2e on Arbitrum One first.", "reason": "arbitrum-usdc-short", "facts": { "usdc": 3, "amount": 25 } } }

Confirmation. Every command that signs, fills or removes something asks the person at the terminal ([y/N]). Where there is no terminal, it refuses with CONFIRMATION_REQUIRED unless the line carries --yes, which says the user already agreed. --dry-run (on perps open and perps close) runs the quote and the policy and stops before any signature.

Typed by the person. A few commands need a person at a real terminal and refuse to run in an agent's shell: lpa init, lpa unlock and lpa console password (they ask a password), lpa config and lpa hyperkeel login (the person's settings and sign-in), lpa uninstall.

Simulation or real. --paper sends one command to the simulation account; lpa paper on sends every perps command there until lpa paper off. --address always reads that account on Hyperliquid, never the simulation one.

--venue. The perps commands accept --venue hyperliquid, so that recipes written for other agent wallets carry over. Hyperliquid is the only venue.

Command reference

The market data, quotes and simulation-account outputs below were captured on 2026-09-30, and yours will differ with the market. Outputs that need a vault account or a phone show the shape of the answer, with addresses shortened.

lpa help lists every command, and a group word alone lists the commands of its group under two sentences on what the group is for: lpa perps, lpa mandate, lpa service, lpa copy, lpa paper, lpa policy, lpa wallet, lpa agent, lpa console, lpa hyperkeel, lpa plugins, lpa store, lpa profile. lpa help <command> is lpa <command> --help.

$ lpa mandate
Usage: lpa mandate <command>

The limits you sign on your phone. The guardian applies the narrower of them and this computer's own policy, and nothing here can widen them.

  sign     Sign on the phone the limits the agent trades within; the guardian applies them before every order.
  show     The mandate signed on the phone: its limits, and whether it is in force.
  revoke   Revoke the mandate, durably: no guardian opens anything under it until the phone signs a new one.
  release  Drop the mandate and what this computer remembers of it, after your password: the local policy alone bounds the agent again.

Help on one of them: lpa mandate <command> --help

Setup and the guardian

`lpa setup`

The whole way in, step by step, taken up where it stopped: see The whole way in one command. Typed by the person.

lpa setup [--paper]

Step 1 of 9 · This computer
Node 24.21.0, ~/.lpa in 700, clock 0.6 s from Hyperliquid.
Step 2 of 9 · Your model: done. The pilot thinks with claude-sonnet-5 (anthropic): about $0.09 a day of the daily pilot when it deliberates, paid to the provider.
Step 3 of 9 · Your vault account: done. Account 0x3f5C...f0bE saved. The phone holds its key; this computer never will.
Step 4 of 9 · Some funds
$320.00 are on Hyperliquid. Below $5 a deposit is lost, so setup never offers less.
...
Setup complete.
The daily pilot is scheduled in simulation: `lpa pilot status` says where it is, `lpa live` shows it think.
To place an order yourself    lpa          then plain words, or /quote BTC long 0.001 3x

A step that stops says where lpa setup takes it up (`lpa setup` takes it up at step 4, some funds.), with the error's own code.

`lpa init`

Sets up the account and approves a trading agent, through the QR ceremony described in Set up a real account. Typed by the person: it asks a password and opens a page that uses the webcam.

lpa init [--with vault|browser|mobile] [--days <n>] [--account <index|0x...>] [--from-sync]

| Flag | Default | Meaning | |---|---|---| | --with | vault | how the account signs: Locker Vault, the safest; browser, your extension on a page of this computer; mobile, your mobile wallet by a WalletConnect QR. With the last two, the account is linked and proven first (a signature that moves nothing) | | --days | 180 | how long the agent may trade, from 1 to 180 whole days (180 is written an hour short of Hyperliquid's ceiling, so a clock a little ahead is never refused) | | --account | the first no other profile holds | which account of the vault's sync QR: its index (0, 1, ...) or its address; with --with browser or mobile, the only address the wallet may link | | --from-sync | off | with Locker Vault, takes the account from the vault's sync this computer read last, without a scan (the sync QR carries every account of the vault, and is kept beside the profiles, public addresses only) |

An account another profile of this computer holds is refused, whichever way it is named and whatever the way of signing: one account has one profile on a computer, never two agents, two mandates or two pilots on it. The way of signing (--with) is the account's, so each profile has its own.

lpa init
lpa init --days 90
lpa init --account 1
lpa init --account 0x3f5CE5FBFe3E9af3971dD833D26bA9b5C936f0bE

Ready: agent 0x8c1f...9a2e until 2026-10-07T09:12.
Next: `lpa unlock` (asks the password), then trade.

What it does, in the order Hyperliquid imposes:

reads the account's public address from the vault's sync QR, and saves it;
checks that Hyperliquid has seen the account funded; if not, it stops there and says how to deposit;
makes a new agent key, seals it under the password you type (twice), then shows its approval (approveAgent, named with its expiry) for the phone to sign;
shows "Authorize the Locker service fee" (approveBuilderFee, 0.05 % at most) for the phone to sign; refused or skipped, orders simply go out without it;
sets the referral code LOCKERPROTOCOL once (an account that already has a referrer keeps it).

Running it again approves a new agent under the same name, which replaces the old one. If the terminal is cut after the phone signed, nothing is lost: the key was sealed first, and lpa unlock adopts the agent once Hyperliquid lists it.

`lpa signer show`, `lpa signer use`, `lpa signer forget`

How the account signs, kept with it in config.json.

lpa signer show
lpa signer use vault|browser|mobile
lpa signer forget

show says the way and, for a mobile wallet, the state of its link, read on this computer. use changes the way for the same address: the new one proves it signs for it first (Locker Vault: its sync QR must name it), anything else is refused. forget closes the link with a mobile wallet at the relay, so the phone no longer reaches this computer, and removes it here; the next signature shows a new QR. lpa reset and lpa uninstall --all close it too.

Signed with MetaMask on your phone (WalletConnect), linked until 2026-10-21 09:30 UTC.

`lpa unlock`

Starts the guardian with the agent key. Typed by the person: it asks the password, input hidden.

The password is the one you chose when the trading key was made (lpa init, or the last lpa agent renew). If you forgot it, the key sealed under it cannot be opened, and your funds are not in it: lpa agent renew approves a new key with your phone, under a new password. A wrong password says so.

lpa unlock [--hours <n>] [--idle-minutes <n>]

| Flag | Default | Meaning | |---|---|---| | --hours | 8 for a terminal, the agent's life for the service | how long the key is held: from 0.1 to 24 in a terminal, from 0.1 to 4320 (the agent's 180 days) when a service holds it; lpa lock ends it sooner | | --idle-minutes | none | the key locks itself once nothing has been signed for that long, from 1 to 10080; each signature puts the wait back to its full length |

lpa unlock
lpa unlock --hours 2
lpa unlock --hours 12 --idle-minutes 60

Password:
Unlocked: the guardian signs for 0x8c1f...9a2e until 30/09/2026, 18:40:00 (or `lpa lock`).

Widening the policy (lpa policy set) takes effect here: the guardian loads the policy when it is unlocked. When a service runs (see Running on a server), unlock sends it the password instead, and the service keeps the key for the agent's whole life, never past the agent's date, or for the hours --hours asks; --idle-minutes holds for it too, and the console's unlock takes the same two (hours, idleMinutes). lpa status says the lock on inactivity on the key's line, and --json gives it as guardian.idle: minutes, and lockAt, the instant the key locks if nothing is signed before. One term for everything: the agent, the mandate and the service's hold end together, and the countdown of the agent's end (from thirty days before) is the one to watch. A restart of the machine always locks the service: lpa unlock, or the console, opens it again.

`lpa lock`

The agent key leaves memory: nothing can be signed until the next lpa unlock. Copies in simulation keep running.

lpa lock

Locked: the agent key left memory, nothing can be signed. The guardian stopped.

`lpa panic`

Stop everything now: every pilot and every copy, then the key leaves memory; the daily pilot's schedule plays no new day (it keeps its account, lpa pilot schedule --on turns it on again), and each grid it holds is named with the gesture that cancels its orders. It closes no position, cancels no order and revokes nothing; it prints how to revoke the agent with the phone. It holds when the rest is broken: with no guardian, it stops on disk the pilot and the copies a guardian would take up.

lpa panic

The pilot: stopped. The positions it opened stay yours.
Copies: 1 stopped.
The key: locked, it left memory: nothing can be signed.
Nothing was closed and nothing was cancelled: your positions and orders stay as they are (`lpa perps positions`; `lpa perps close --all` closes them).
To take the agent's right to trade away for good, revoke it with your phone: run `lpa agent revoke` in your own terminal.

`lpa status`

The whole state at a glance, and what to do next. Signs nothing; it asks Hyperliquid, within a few seconds, whether the key is listed, and says nothing of it offline.

lpa status

account    0x3f5CE5FBFe3E9af3971dD833D26bA9b5C936f0bE
agent      0x8c1f4e2b7d3a9c6f0e1b5a4d3c2b1a0f9e8d9a2e, until 2026-10-07T09:12, 6 days left
key        unlocked until 2026-09-30T16:40, held by the guardian of this terminal
policy     $100 an order, 3x, the main dex, 20 orders a day, no end
mandate    no mandate: the local policy alone bounds the agent
copies     1 trader copied (lpa copy status)
service    not running here
assistant  anthropic claude-opus-4-6
today      2 of 20 orders, $180.00 opened
mode       real
next       Nothing to do: 'lpa' opens the session, and 'lpa journal' says what was done.

The line of the day says the opening orders of the UTC day on the book of the mode in use (the simulation account in simulation mode), the day's cap and the notional opened; with --json it is today: orders, maxOrders, notionalUsd. Since 2.4.0 no share of the day's loss stops anything, and the status says none: today.loss and today.lossError are gone.

What the model has cost is spend (the day, every activity together) and, in detail, spendDetail, read from this computer's record and never estimated: today.pilot and today.assistant, the day by activity (the daily pilot with its choice and its drafts; the session, the console's chat and every other activity), each usd, tokens and unpriced (part of it had no price, the dollars then a floor); month, the UTC month in progress (from, its first day, and days, those with a spend); last7Days, the seven UTC days before today (from, to, activeDays, and averageUsd, their dollars over seven, a typical day); and perCall.choice and perCall.draft, what one priced call of the pilot's choice of the day or of a strategy's draft has cost here on average (calls, averageUsd), null before the first one; lastCall, the last call to the model on this computer (at, when it started, ms, how long it took, ok, whether it answered, provider, model), null before the first; and failures24h, the calls that failed over the twenty-four hours before now. spendDetail is null when the record does not read.

The last line is the step to take, and it is the same sentence lpa doctor ends with and the session's banner shows. On a fresh computer it reads 'lpa setup' walks the whole way, with your phone: about five minutes. 'lpa setup --paper' opens a simulation account instead, with no phone and no money.; with a key that ended, a locked guardian, a mandate that opens nothing or simulation mode on, it names the command that moves things on. With --json, journey names where you stand (fresh, practice, account, pending, expired, expiring, locked, mandate, paper, ready) and next carries the sentence.

The guardian in figures, with --json, under guardian: startedAt, when it started serving; lastError, the last request it refused or failed (at, code, op: an order the guardian's own limit refuses reads POLICY_REJECTED and open), null when none since it started; and, while it holds the key, unlockedAt, when it took it, and signedSinceUnlock, the operations that signed under it since (an order, a close, a cancel, a change, an order of a live copy or of the pilot). A guardian of an earlier version says none of them.

A guardian started by another version of lpa (one still running from before an update) is named on the key's line, because it signs nothing for this one:

key        locked: nothing can be signed; it runs version 2.0.0 and this lpa is 0.2.0, so it signs nothing for it: lpa lock, then lpa unlock (the service: lpa service restart)

`lpa doctor`

Checks the setup, signs nothing. Each check reads ok, FAIL or - (not set up yet), with what to do. The exit code is 1 when a check fails, so a script can rely on it.

lpa doctor
lpa doctor --egress [--limit <n>]
lpa doctor --files
lpa doctor --fix-modes

ok  node         Node 24.21.0
ok  home         ~/.lpa mode 700
ok  config       config.json mode 600
ok  files        9 kept private
ok  hyperliquid  api.hyperliquid.xyz answers in 180 ms; clock drift 42 ms
ok  account      0x3f5CE5FBFe3E9af3971dD833D26bA9b5C936f0bE (m/44'/60'/0'/0/0)
ok  agent        0x8c1f...9a2e, 161 h left
-   mandate      none: the local policy alone bounds the agent (lpa mandate sign signs one on the phone)
ok  setup        complete
ok  funds        equity $55.78
ok  guardian     a terminal, unlocked until 2026-09-30T16:40
-   service      not installed: nothing runs once this terminal closes (lpa service install)
-   console      no password yet: lpa service install asks for one (lpa console password)
ok  policy       $100 an order, 3x, the main dex, 20 orders a day, no end
ok  assistant    anthropic claude-opus-4-6, its key in the keys file
-   hyperkeel    not connected, and optional: lpa hyperkeel login
-   paper        no simulation account (lpa paper init --budget 1000)
Everything that is set up works.
Next: Nothing to do: 'lpa' opens the session, and 'lpa journal' says what was done.

The checks: Node 22.13 or later; the ~/.lpa folder at mode 700 and every file in it at 600; Hyperliquid reachable with a clock within 10 seconds of yours (it refuses nonces too far off); the account; an agent left pending by an interrupted lpa init; the agent listed by Hyperliquid and not expired; the mandate and its standing; the last signature of lpa init given; funds on Hyperliquid; the guardian (running, locked or unlocked, its version); the service of this folder and its console; the policy and whether it ended; the assistant and where its key comes from; hyperkeel; the plugins installed and whether their files are the ones approved; the simulation account. The last line is the step to take, the same one lpa status says.

lpa doctor --egress reads the register of the calls that left this computer. The process of lpa, and that of the MCP server, write each request that leaves the machine as one line under egress/<UTC day>.jsonl: the host, the method, the path without its query (a segment of 24 characters or more masked as *, where a node's address can hold a key), the moment, the bytes of the body sent, the status and the time. Never the body, a header or the query. A call to this computer itself (127.0.0.1, localhost, ::1: a model on this machine, the console) is not written. The register keeps thirty days, today included, stays on this computer and is sent nowhere; lpa reset takes it with the rest. --json gives hosts (each host, calls, bytes, failed, firstAt, lastAt, and how long its calls took, medianMs and maxMs), last (the last calls, the most recent first, --limit, 100 by default), calls, from, to and unread (lines that do not read). A program that calls the library with its own fetch writes nothing here.

lpa doctor --files measures the folder: the space its disk has left (freeBytes, totalBytes) and every path lpa keeps there (paths: each path, kind (file, folder, link or other), mode as measured, expected (600 for a file, 700 for a folder, null for a link or a socket), ok and bytes), with open, the paths wider than private. A link is named and never followed. lpa doctor --fix-modes, typed by you, puts each file back to 600 and each folder to 700, leaves a link as it is, and says each change (fixed: path, from, to) before the folder measured again. One view at a time: --egress, --files or --fix-modes.

Market data

Public reads: no account, no key, nothing signed.

`lpa perps venues`

lpa perps venues

hyperliquid (mainnet)

`lpa perps markets`

Markets by 24 h volume, with mark price, 24 h change, hourly funding and maximum leverage; halted ones marked HALTED.

lpa perps markets [--dex <name> | --all-dexes] [--search <text>] [--limit <n>]

| Flag | Default | Meaning | |---|---|---| | --dex | the main dex | a HIP-3 dex by name | | --all-dexes | off | the main dex and every HIP-3 dex; not with --dex | | --search | none | only the names that contain this text | | --limit | 25 | how many rows, largest volume first |

lpa perps markets --limit 6

SYMBOL  MARK      24H     FUNDING/H      VOLUME 24H   MAX LEV
BTC     83133.0   -1.19%  -0.0000056166  $2084373976  40x
ETH     2669.3    -2.02%  0.0000125      $1114565592  25x
ZEC     1401.7    -1.26%  0.0000125      $454331915   10x
HYPE    86.02     -2.93%  -0.000000687   $424295586   10x
NEAR    5.0785    5.69%   0.0000125      $293323668   10x
PUMP    0.005741  13.91%  0.0000534942   $270334612   10x

lpa perps markets --search eth
lpa perps markets --dex xyz --limit 5
lpa perps markets --all-dexes --search gold

SYMBOL        MARK     24H     FUNDING/H      VOLUME 24H  MAX LEV
xyz:BRENTOIL  96.449   -1.79%  -0.0000201841  $278378633  20x
xyz:CL        89.627   -3.57%  0.00000625     $240679459  20x
xyz:XYZ100    30396.0  0.23%   0.00000625     $180937909  30x
xyz:SP500     7692.2   0.12%   0.00000625     $171897063  50x
xyz:SKHX      1319.9   0.52%   0.0000356958   $122178252  10x

In JSON each row carries symbol, dex, markPx, change24hPct, fundingHourly, volume24hUsd, openInterestUsd, maxLeverage and halted.

`lpa perps quote`

What an order would cost, before anything is signed: the entry price the order would fill at by walking the live book, the worst price it accepts, the fees as one total, the margin and a liquidation estimate. Needs no account.

lpa perps quote --symbol <S> --side long|short --size <base> --leverage <n>
                [--usd <dollars>, in place of --size]
                [--type market|limit|trigger] [--limit-px <p>] [--trigger-px <p>] [--max-slippage-bps <n>]
                [--tp <p>] [--sl <p>] [--tif gtc|ioc|alo] [--reduce-only] [--margin cross|isolated]

| Flag | Default | Meaning | |---|---|---| | --symbol | required | the market | | --side | required | long or short | | --size | required, unless --usd | in the base asset | | --usd | none | the size in dollars instead, never with --size: lpa turns it into the token at the price it quotes and rounds it down to the market's grid | | --leverage | required | a whole number, 1 or more | | --type | market | market, limit or trigger | | --limit-px | none | the limit price; required with --type limit, refused without it | | --trigger-px | none | the entry trigger: a market order that waits off the book until the price reaches it, a long's above the mid and a short's below; required with --type trigger, refused without it, and taking no --tp or --sl (the position exists only once it fires: set them then, with lpa perps modify) | | --max-slippage-bps | 300 | the worst price accepted, in basis points from the mid (from the trigger for --type trigger), 1 to 5000 | | --tp | none | a take-profit price | | --sl | none | a stop-loss price | | --tif | gtc | with --type limit, how long the limit stays: gtc rests until it fills or is cancelled, ioc fills what the book holds up to the limit at once and the rest is cancelled, alo is posted to the book only; refused with a market order (always immediate or cancel) and a trigger. A limit alo that crosses the book, and a limit ioc that does not, are refused before anything is signed, since Hyperliquid would refuse the first and cancel the second at once | | --reduce-only | off | the order only reduces the position held: its side is the other way, its size never more than the position, no --tp, --sl or trigger with it; no leverage is set (the position keeps its own), no margin is taken, and the policy lets it through as every close | | --margin | the position's, or the market's | cross or isolated, the margin the leverage is set in; a market that takes isolated only refuses cross, and a market where a position is open keeps that position's margin (Hyperliquid changes it only once nothing is held there) |

The quote says the validity (tif: ioc for a market order, the limit's otherwise, none for a trigger), reduceOnly when asked, and the margin (marginMode). Hyperliquid sets a leverage for the whole market: when a position is held there, the quote says so in a note (code leverage-whole-market), with the leverage it has and the one it takes. The notes of the controls have their codes: alo-crosses, ioc-no-fill, leverage-whole-market, reduce-only.

lpa perps quote --symbol ETH --side long --size 0.05 --leverage 3

LONG 0.05 ETH at 3x (market)
  entry        2669.6   (mid 2669.55, worst accepted 2749.6)
  notional     $133.48   margin $44.49
  fees         0.095% ($0.1268)   (base tier)
  liquidation  1816.0544   (estimate, this order alone, cross margin)

With a take-profit and a stop-loss, the quote shows the risk:reward the policy checks (the stop's distance from the entry, over the take-profit's):

lpa perps quote --symbol ETH --side long --size 0.05 --leverage 3 --tp 2800 --sl 2600

LONG 0.05 ETH at 3x (market)
  entry        2669.6   (mid 2669.55, worst accepted 2749.6)
  notional     $133.48   margin $44.49
  fees         0.095% ($0.1268)   (base tier)
  liquidation  1816.0544   (estimate, this order alone, cross margin)
  take profit  2800
  stop loss    2600
  risk:reward  0.53x   (the stop's distance from the entry, over the take profit's)

Each note of a quote has its code beside its words, in the same order (noteCodes: isolated-only, limit-crosses, entry-trigger, partial-fill, below-minimum, or other), its figures being the quote's own (triggerPx, worstPx, minOrderUsd).

A limit order, and an order below Hyperliquid's $10 minimum:

lpa perps quote --symbol BTC --side short --size 0.001 --leverage 2 --type limit --limit-px 84000
lpa perps quote --symbol ETH --side long --size 0.001 --leverage 3

SHORT 0.001 BTC at 2x (limit)
  entry        84000   (mid 83133.5, worst accepted 84000)
  notional     $84.00   margin $42.00
  fees         0.065% ($0.0546)   (base tier)
  liquidation  124444.44   (estimate, this order alone, cross margin)

LONG 0.001 ETH at 3x (market)
  entry        2669.6   (mid 2669.55, worst accepted 2749.6)
  notional     $2.67   margin $0.89
  fees         0.095% ($0.0025)   (base tier)
  liquidation  1816.0544   (estimate, this order alone, cross margin)
  note: Below Hyperliquid's $10 minimum at the 2749.6 this order signs: it would be refused.

The fee rate is your account's own Hyperliquid tier once lpa init has run (base tier before that), plus the Locker fee when the account approved it. A quote is only a quote: --size 0.05 here costs $133, above the default policy, which perps open would refuse.

A size in dollars: --usd 100 in place of --size. The dollars are turned into the token at the price the order is quoted at (the limit of a limit order, the trigger of a trigger, the mid of a market order, or the estimated fill when walking the book makes the size at the mid cost more), then rounded down to the market's grid, so the notional the quote says is never above the dollars asked. The quote says it on its second line, and with --json under fromUsd: usd (the dollars asked) and px (the price they were turned at). perps check and perps open take --usd too, and the order goes out at the size the quote said. Dollars under Hyperliquid's $10 minimum at the price the order signs are refused with the dollars that would do.

lpa perps quote --symbol ETH --side long --usd 100 --leverage 3

LONG 0.0374 ETH at 3x (market)
  sized from   $100.00 at 2669.55   (rounded down to the market's grid)
  entry        2669.6   (mid 2669.55, worst accepted 2749.6)
  notional     $99.84   margin $33.28
  fees         0.095% ($0.0949)   (base tier)
  liquidation  1816.0544   (estimate, this order alone, cross margin)

`lpa perps regime`

How one market is trading, read on its 1 h, 4 h and 5 m candles: strong bull, weak bull, range, weak bear or strong bear, with the figures behind it.

lpa perps regime --symbol <S>

lpa perps regime --symbol BTC

BTC: range, trend score -0.16
  EMA stack     -0.32, leaning down
  structure     range: no run of higher highs or lower lows on the 4 h candles
  momentum      5 m micro -1.00, slope -0.0007 %/min
  RSI           14: 37.4, 6: 40.1
  volatility    ATR 4 h 1.01% of price, expanding (+46.2%); 1 h over 4 h 0.36
  volume        0.72x the 24 h average, falling (-54.7%)
  age           this regime has held 21 h

`lpa perps ranges`

Which markets are trading in a range now, over the last 4 hours: the range's width, the volatility, their ratio (ranginess), a score from 0 to 10 (0 outside 0.5 to 5 % wide), support and resistance. A market whose candles cannot be read is skipped and counted.

lpa perps ranges [--limit <n>] [--dex <name> | --all-dexes]

| Flag | Default | Meaning | |---|---|---| | --limit | 20 | how many markets to scan, largest 24 h volume first | | --dex, --all-dexes | the main dex | as for perps markets |

lpa perps ranges --limit 8

SYMBOL  RANGE%  VOL%  RANGINESS  SCORE  SUPPORT  RESISTANCE
PUMP    2.96    0.59  5.06       5.06   0.00564  0.005807
HYPE    1.48    0.31  4.81       4.81   85.1     86.362
ETH     0.84    0.18  4.56       4.56   2657.8   2680
BTC     0.69    0.16  4.33       4.33   82914    83483
ZEC     1.80    0.43  4.21       4.21   1390.2   1415.2
SOL     1.49    0.36  4.17       4.17   117.84   119.6
LIT     5.54    0.91  6.12       0.00   3.65     3.8523
NEAR    5.44    1.23  4.42       0.00   4.8274   5.09
In a range now: PUMP, HYPE, ETH, BTC, ZEC, SOL (6 of 8 scanned).

`lpa perps analyze`

One market investigated as the daily pilot reads it, the read the assistant makes before it gives an opinion on a coin: the pilot's dossier of that market, built by the same collector and the same builder as a day of the pilot (every horizon from 5 m to 1 w, the regime and its scores, the funding and its 7-day average, the open interest, the highs and lows of a day, a week, a month and a quarter, the EMAs and the ATR, the flow and the top accounts on it, the leaders, the calendar and the fear and greed index), then the horizons asked laid apart, the book's best prices and its largest resting orders, the headlines of the last day and the climate the pilot's reader wrote last when it is under a day old. A source that does not answer is said in its section; the web's pages come through the copy the pilot keeps under pilot/cache, read at most once an hour. Nothing is signed and no model is called.

lpa perps analyze --symbol <S> [--horizons 5m,15m,1h,4h,1d,1w]

| Flag | Default | Meaning | |---|---|---| | --horizons | 1h,4h,1d | the horizons the question is about, comma separated; a scalp reads 5m,15m,1h |

`lpa perps scan`

The coins of the moment ranked for a long or a short: the daily pilot's universe filter on Hyperliquid's main dex (the volume, the open interest, the funding), the largest by 24 h volume read on the regime of perps regime and placed in the week's range, the five strongest trends up and the five strongest down with their figures, a coin your policy does not allow marked as such, and the pilot's own screen of its measured universe, or why it has none. A market whose candles cannot be read is named.

lpa perps scan [--side long|short|both] [--limit <n>]

| Flag | Default | Meaning | |---|---|---| | --side | both | the side to rank | | --limit | 10 | how many markets to read, largest 24 h volume first, 25 at most |

Account reads

These read the vault account set up by lpa init, another account with --address, or the simulation account with --paper (or while lpa paper on). Nothing is signed.

| Flag | Meaning | |---|---| | --dex <name> | one HIP-3 dex instead of the main dex | | --all-dexes | the main dex and every dex the account is funded on; not with --dex | | --address <0x...> | another account, read on Hyperliquid; not with --paper | | --paper | the simulation account |

`lpa perps positions`

lpa perps positions
lpa perps positions --all-dexes
lpa perps positions --paper
lpa perps positions --address 0x5b5d51203a0f9079f8aeb098a6523a13f298c060 --all-dexes

SYMBOL      SIZE           ENTRY      VALUE               PNL                  LIQUIDATION     LEV
BTC         -2788.43486    75949.4    $231720331.08       $-19940375.72        137421.99       5x
ETH         -104540.5025   2304.06    $278997693.07       $-38129499.52        4106.04         5x
xyz:GOLD    -6936.2962     4191.43    $29138686.70        $-65625.72           26145.53        4x
...

In simulation:

Simulated positions, on the simulation account:
SYMBOL  SIZE    ENTRY     VALUE   PNL     LIQUIDATION  LEV
BTC     -0.001  83109.94  $83.12  $-0.01  -            2x

The PNL is Hyperliquid's latent result: before the fees of closing, the funding left out. With --json each position of the real account also carries fundingSinceOpen, the funding it has paid since it opened as Hyperliquid gives it (cumFunding.sinceOpen: positive when paid, negative when received), and pnlWithFundingUsd, the latent result less that funding; they are read from the same answers as the rows, and absent when an answer does not carry them. A simulated position has neither: the simulation account keeps its funding for the whole account (lpa paper status). Each position also says marginMode, cross (its margin shared with every cross position of its dex) or isolated (its own), as Hyperliquid's leverage.type gives it; a simulated position reads cross, the simulation account being one pot.

`lpa perps balance`

Equity and withdrawable margin, per dex.

lpa perps balance
lpa perps balance --all-dexes
lpa perps balance --paper

DEX   EQUITY   WITHDRAWABLE  PNL    POSITIONS
main  $55.78   $55.78        $0.00  0

Simulation account: one cross-margin pot, no dex of its own.
DEX    EQUITY   WITHDRAWABLE  PNL    POSITIONS
paper  $999.92  $958.37       $0.00  1

With --json each dex also gives its margin, each figure absent when Hyperliquid's answer does not carry it: marginUsedUsd, what its positions hold, maintenanceMarginUsd, the maintenance margin of its cross positions, notionalUsd, their value together, and maintenanceRatioPct, the share of the cross account's value that maintenance takes (the cross positions are liquidated at 100). They are read from the same answer as the equity. The simulation account gives its own, as its liquidation judges it.

`lpa perps portfolio`

The account as Hyperliquid values it, whole: its perps on every dex, its spot holdings, its vaults and its staking, and its value and its result over Hyperliquid's own windows, as Hyperliquid's own pages show them.

lpa perps portfolio
lpa perps portfolio --address 0x5b5d51203a0f9079f8aeb098a6523a13f298c060
lpa perps portfolio --json
lpa perps portfolio --paper

TOTAL   PERPS  SPOT    VAULTS  STAKED
$25.58  $4.07  $16.49  $5.01   $0.00 (0 HYPE)

WINDOW    PNL     PERPS PNL
24h       $0.06   $0.06
7d        $-0.22  $-0.23
30d       $-0.20  $-0.26
all time  $15.59  $15.51
On Hyperliquid since 2026-07-29.

The total is the sum of the four parts. The perps are the value of the account on the main dex and on each builder dex, latent results included; the spot is every token held at its price against USDC (its mid, or its mark without one), USDC at 1, and on a unified account what is left of it once the margin of the main dex, which Hyperliquid counts in both, is taken out; the vaults are the equity of each vault the account is in; the staking is the HYPE delegated, not delegated yet and on its way out, at the price of HYPE. The PnL of a window is its last point less its first, the result of the account (or of its perps alone) over that window, latent and realized together.

With --json: address, totalUsd, perpsUsd, spotUsd, vaultsUsd, stakedHype, stakedUsd, firstAt (the first point of the all-time window where the value or the result is not zero, in ms; null for an account that never held anything) and windows, Hyperliquid's eight windows (day, week, month, allTime, and the same of the perps alone, perpDay, perpWeek, perpMonth, perpAllTime), each with accountValueHistory and pnlHistory, lists of [time in ms, "figure"] as Hyperliquid gives them. A read that fails leaves its field null, and the total with it: a part is never counted as zero because it did not read. windows is null when the history did not read.

{ "address": "0x...", "totalUsd": "25.58", "perpsUsd": "4.07", "spotUsd": "16.49", "vaultsUsd": "5.01",
  "stakedHype": "0", "stakedUsd": "0.00", "firstAt": 1785366840026,
  "windows": { "day": { "accountValueHistory": [[1792338840052, "25.518583"]], "pnlHistory": [[1792338840052, "0.0"]] } } }

The simulation account has no history on Hyperliquid: --paper gives its equity alone, { "address": "paper", "paper": true, "totalUsd": "1000.00", "windows": {} }.

`lpa perps orders`

Open orders, triggers (TP/SL) included. The OID column is what lpa perps cancel takes.

lpa perps orders
lpa perps orders --al

Published

Vulnerabilities

Links

Maintainers

Keywords

Readme

@locker-protocol/agent-wallet-hyperliquid-trader

Contents

How it works

Words used here

How long things last

Install

The whole way in one command: lpa setup

Quick start in simulation

Set up a real account

Conventions shared by every command

Command reference

Setup and the guardian

lpa setup

lpa init

lpa signer show, lpa signer use, lpa signer forget

lpa unlock

lpa lock

lpa panic

lpa status

lpa doctor

Market data

lpa perps venues

lpa perps markets

lpa perps quote

lpa perps regime

lpa perps ranges

lpa perps analyze

lpa perps scan

Account reads

lpa perps positions

lpa perps balance

lpa perps portfolio

lpa perps orders

`lpa setup`

`lpa init`

`lpa signer show`, `lpa signer use`, `lpa signer forget`

`lpa unlock`

`lpa lock`

`lpa panic`

`lpa status`

`lpa doctor`

`lpa perps venues`

`lpa perps markets`

`lpa perps quote`

`lpa perps regime`

`lpa perps ranges`

`lpa perps analyze`

`lpa perps scan`

`lpa perps positions`

`lpa perps balance`

`lpa perps portfolio`

`lpa perps orders`