parallax-wallet - Parallax Technical Documentation

parallax-wallet is the offline wallet management tool for the Parallax client suite. It consolidates the keystore-directory operations previously offered by parallaxd account … and the single-keyfile tool previously shipped as parallaxkey into a single binary, modeled after Bitcoin Core’s bitcoin-wallet. parallax-wallet never talks to a running node. Every command operates directly on files on disk, which makes it safe to run on air-gapped machines for cold-signing workflows. For commands that require a running daemon (newaccount, unlock, sign, sendtx against a live IPC socket), use parallax-cli instead.

Installation

parallax-wallet ships alongside parallaxd and parallax-cli in every release bundle. Building from source:

make parallax-wallet

or, for the whole suite:

make parallax

Subcommands

Keystore-directory operations

These commands operate on the keystore directory at <datadir>/keystore (override with --keystore).

Command	Purpose
`list`	Enumerate accounts in the keystore.
`new`	Create a new, encrypted account.
`update <address>`	Change an account’s password or migrate to the latest keyfile format.
`import <keyfile>`	Import a raw, hex-encoded private key and store it encrypted.
`info`	Print keystore metadata (path, account count, KDF parameters).
`dump`	Serialise the keystore into a single JSON backup (keys stay encrypted).
`createfromdump`	Restore a keystore directory from a `dump` file.

Single-keyfile operations

These commands operate on a single keyfile path — useful when you want a portable, self-contained key outside the keystore.

Command	Purpose
`generate [keyfile]`	Create a new, encrypted standalone keyfile.
`inspect <keyfile>`	Print a keyfile’s public metadata (add `--private` to reveal the private key).
`changepassword <keyfile>`	Re-encrypt a keyfile with a new password.
`signmessage <keyfile> <message>`	Sign an EIP-191 personal message.
`verifymessage <address> <signature> <message>`	Verify a signature against an address (hex, with or without `0x`; `v` may be 0/1 or 27/28).
`signtx <keyfile>`	Build, sign and print a raw transaction offline (submit via `parallax-cli sendraw`).
`signrequest <keyfile> <request.json>`	Sign a Parallax Desktop offline signing request (a transfer or a message) and emit the signed document.

Passwords

For every command that decrypts a keyfile, parallax-wallet either prompts interactively or reads the password from the file passed with --passwordfile (for keyfile commands) or --password (for keystore-directory commands). The first non-empty line of the file is used as the password.

JSON output

Where applicable, the --json flag switches output to structured JSON.

Examples

Create a new account

parallax-wallet new

Cold-sign a transaction on an air-gapped machine

Given the account’s current nonce (looked up on a live node: parallax-cli nonce 0x…), the current gas price, and the target chain ID (2110 for mainnet):

parallax-wallet signtx \
  --chainid 2110 --nonce 42 \
  --gas 21000 --gasprice 1000000000 \
  --to 0xabc… --value 0x1 \
  ~/keystore/UTC--...keyfile

Copy the resulting 0x… raw transaction to an internet-connected host and broadcast it with parallax-cli sendraw.

Sign a Parallax Desktop offline signing request

signrequest is the command-line counterpart of Parallax Desktop’s offline signer. The desktop app (on the online, watch-only machine) exports a signing request; signrequest validates and signs it on the air-gapped machine and writes a signed-transaction document for the desktop app to broadcast. A request looks like this (all integers are decimal strings; id is the EIP-155 signing hash of the unsigned transaction and binds every signed field; createdAt and memo are informational and not signed):

{
  "type": "parallax-sign-request",
  "version": 1,
  "id": "0x…",
  "chainId": "2110",
  "from": "0x…",
  "to": "0x…",
  "nonce": "7",
  "valueWei": "1000000000000000000",
  "gasLimit": "21000",
  "gasPriceWei": "1000000000",
  "createdAt": 1791965000,
  "memo": "rent"
}

Before the key is used, the request must pass every check: plain LAX transfers only (no data), chain 2110 unless --chainid names another, 21000 ≤ gasLimit ≤ 30000000, a non-zero gas price, a maximum fee (gasLimit × gasPriceWei) no higher than --feecap, checksummed addresses, an id that matches the recomputed signing hash, and a from that matches the keyfile. A summary with a fingerprint (the first eight hex digits of id, e.g. 3FA2-91C0) is printed to stderr; compare it with the fingerprint shown in Parallax Desktop before answering the Sign this transaction? [y/N] prompt.

parallax-wallet signrequest --out signed.json \
  ~/keystore/UTC--...keyfile request.json

Flag	Purpose
`--passwordfile <file>`	Read the keyfile password from a file instead of prompting.
`--chainid <n>`	Allow chain `<n>` instead of mainnet; the request’s `chainId` must equal it (transfers only).
`--feecap <LAX>`	Maximum fee to sign, in LAX (default `1`; transfers only).
`--yes`	Sign without the confirmation prompt (required when the request is read from stdin with `-`, together with `--passwordfile`).
`--out <file>`	Write the signed document to a file (mode 0600) instead of stdout.

The output is the document Parallax Desktop imports:

{
  "type": "parallax-signed-tx",
  "version": 1,
  "id": "0x<the request's id>",
  "hash": "0x<transaction hash>",
  "raw": "0x<signed transaction>",
  "from": "0x…",
  "nonce": "7",
  "chainId": "2110"
}

raw is an ordinary signed transaction, so it can also be broadcast with parallax-cli sendraw.

Message requests

signrequest also signs a message request, as an EIP-191 personal message (the same hash signmessage signs). id is the message’s EIP-191 hash, 0x + keccak256("\x19Ethereum Signed Message:\n" + byte length + message); there is no chain ID, so --chainid and --feecap are ignored.

{
  "type": "parallax-sign-message-request",
  "version": 1,
  "id": "0x…",
  "from": "0x…",
  "message": "I control this address. 2026-10-14",
  "createdAt": 1791965000
}

The message must be valid UTF-8, 1 to 1024 bytes, with no control characters other than line feed and tab (no \r, NUL or escape sequences), so what is shown is everything that is signed. from must be a checksummed, non-zero address matching the keyfile, and id must match the message. The whole message is printed to stderr, one line per message line, with tabs, backslashes and invisible characters escaped, followed by its byte length and fingerprint; confirm with Sign this message? [y/N] (or --yes). The output:

{
  "type": "parallax-signed-message",
  "version": 1,
  "id": "0x<the request's id>",
  "address": "0x…",
  "message": "I control this address. 2026-10-14",
  "signature": "0x<65 bytes r‖s‖v, v = 27 or 28>"
}

The signature can be checked anywhere with parallax-wallet verifymessage <address> <signature> <message>, which accepts it as is as well as the signmessage form (no 0x, v 0/1).

Back up and restore a keystore

parallax-wallet dump --outfile backup.json
parallax-wallet createfromdump --keystore /new/location --infile backup.json

The dump contains every keyfile in its encrypted JSON form — the dump itself is safe to move between machines so long as the account passwords are handled independently.

parallax-cli — talks to a running daemon over IPC (JSON-RPC). Hosts the live newaccount, unlock, sign and sendtx sugar commands, all of which require a node.
clef — long-running external signer daemon with a rule engine and interactive approval UI. Different problem domain from parallax-wallet: it’s a service called by other processes, not a one-shot CLI.

​Installation

​Subcommands

​Keystore-directory operations

​Single-keyfile operations

​Passwords

​JSON output

​Examples

​Create a new account

​Cold-sign a transaction on an air-gapped machine

​Sign a Parallax Desktop offline signing request

​Message requests

​Back up and restore a keystore

​Related tools