> ## Documentation Index
> Fetch the complete documentation index at: https://docs.parallaxprotocol.org/llms.txt
> Use this file to discover all available pages before exploring further.

# parallax-wallet

`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:

```sh theme={null}
make parallax-wallet
```

or, for the whole suite:

```sh theme={null}
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 Wallet 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

```sh theme={null}
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):

```sh theme={null}
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 Wallet offline signing request

`signrequest` is the command-line counterpart of Parallax Wallet'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):

```json theme={null}
{
  "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 Wallet before
answering the `Sign this transaction? [y/N]` prompt.

```sh theme={null}
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 Wallet imports:

```json theme={null}
{
  "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.

```json theme={null}
{
  "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:

```json theme={null}
{
  "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

```sh theme={null}
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.

## Related tools

* `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.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.