Run a Validator

TL;DR

Three ways to run a validator, all producing the same blocks with the same consensus code:

• Desktop app - download Asentum Operator, create a wallet, click Stake. Zero terminal.
• VPS one-liner - curl -fsSL explorer.asentum.com/install/validator | bash on a fresh Ubuntu/Debian box. Fully automated.
• Build from source, a from-source build path is planned for a future release. Method 1 and Method 2 already run the same node software today.

Minimum stake: 500 ASE, which makes you a validator candidate. Signing needs a seat in the 100-seat committee, and those go to the largest stakes (see Staking & bonding). Both the desktop app and the VPS one-liner fund the bond automatically during onboarding; see Get Test ASE for the details.

How Asentum validators work

Asentum produces blocks with Aura (slot-based, one validator assigned per slot) and finalizes them with GRANDPA (stake-weighted, two-thirds). Bonding at least 500 ASE into the staking system contract makes you a validator candidate. Each epoch the chain fills a 100-seat signing committee by stake (top 50 core seats plus reserve seats; ties at the cutoff rotate), and only seated validators produce blocks, sign finality votes and earn signing rewards. The candidate set scales to hundreds.

• Liveness-aware committee. Validators can come and go without halting the chain. A slow or offline validator costs at most a skipped slot, not a stalled chain, so if your laptop sleeps the schedule simply moves on to the next validator and keeps producing.
• Post-quantum signatures. Every block proposal and GRANDPA vote is signed with ML-DSA-65 (Dilithium3). Your validator key is a Dilithium3 keypair, not ECDSA.
• Simple networking. A new node catches up over HTTP from the relay peers, then exchanges blocks and votes with them over one TCP port (9000) that the installer opens only to those peers. No libp2p, nothing to configure by hand.
• ~2-second slots. Aura targets a 2-second slot time. GRANDPA finality trails the head by a few blocks and is stake-weighted, so a small or offline minority cannot freeze finality.

Requirements

Method 1 - Desktop app (macOS / Windows)

The easiest path. No terminal, no config files. Download from the downloads page.

1. Download and install. Open the .dmg (macOS) or run the .exe installer (Windows).
2. Create your wallet. On first launch, set a password. The app generates a Dilithium3 keypair and encrypts it with scrypt + AES-GCM-256.
3. Sync the chain. The app syncs from genesis via the public testnet peers. A progress bar shows live sync state. Typical first sync: 2-10 minutes.
4. Fund your wallet. Click the fund button in the dashboard; the app funds the new validator from within the app. You need at least 500 ASE to bond, and enough stake to clear the committee cutoff to sign.
5. Stake. Enter your password, click "Stake & Start Validating." The app signs a bond(pubKey) transaction and broadcasts it. Your node becomes a candidate within ~10 blocks and takes a signing seat from a following epoch if its stake clears the cutoff.
6. Leave it running. Close the window - the app minimizes to the system tray and keeps producing blocks in the background. Quit from the tray menu to fully stop.

For the full desktop app guide, see Asentum Operator.

Method 2 - VPS one-liner (Ubuntu / Debian)

For headless servers. One command does everything - installs dependencies, downloads the node bundle and a chain snapshot, generates a validator key, sets up systemd, syncs remaining blocks from peers, funds via faucet, and auto-bonds into the active set.

curl -fsSL https://explorer.asentum.com/install/validator | bash

What the installer does, step by step:

1. Installs Node.js 22 if not present.
2. Downloads the validator bundle (~45 MB) to /opt/asentum/chain.
3. Downloads a chain snapshot (~32 MB) to /opt/asentum/data - skips full replay from block 0, only syncs the remaining blocks from peers.
4. Generates a Dilithium3 validator keypair at /opt/asentum/data/validator.key (a hex copy sits next to it in validator.key.hex; back both up).
5. Creates a systemd service (asentum-validator) and starts the node.
6. Shows a live sync progress bar until the node catches up (usually under a minute).
7. Funds the validator address with enough ASE to bond and waits for it to land.
8. Signs and submits a bond(pubKey) transaction.
9. Installs the asentum-validator CLI wrapper on PATH.

After install, use the CLI wrapper to manage your node:

asentum-validator status      # node + validator status
asentum-validator balance     # wallet balance
asentum-validator earnings    # rewards earned
asentum-validator logs        # live log stream
asentum-validator bond 500    # add 500 ASE to your bond (or: bond all)
asentum-validator unstake 500 # queue an unbond (1,296,000 blocks)
asentum-validator withdraw    # claim unbonded ASE after the window
asentum-validator restart     # restart the systemd service
asentum-validator update      # pull latest chain code + snapshot, restart
asentum-validator resync      # fresh snapshot only, when stuck at one height
asentum-validator reset       # switch wallets: --create a new one or --import yours
asentum-validator self-update # update only this command, the node is not touched
asentum-validator rpc status  # who can use your RPC (public, private <ips>, local)
asentum-validator register    # bond a wallet that has no bond yet

rpc, register, self-update, resync and reset came with the 29 Sep 2026 kit. If your install is older and they are missing, re-run the install command; it keeps your existing key.

update is the one-shot upgrade path after we ship a new chain release: it downloads the fresh validator bundle, verifies its integrity, wipes local blocks/ + state/, extracts the latest snapshot, and restarts the systemd service. Your validator.key and on-chain bond are untouched.

To install with a wallet you already have, switch wallets later, or update only the command, see VPS Installation.

Troubleshooting

Method 3 - Build from source

The node software is already live and installable through Method 1 (Operator desktop app) and Method 2 (VPS one-liner). Both run the same client that powers the public testnet. A standalone from-source build path will be published alongside a future release.

Until then, use Method 1 or Method 2 to run a validator. Both use the same node software and connect to the same testnet.

Staking & bonding

Validators bond ASE into the on-chain staking system contract to become validator candidates. The bond transaction calls bond(pubKey) with your Dilithium3 public key and attaches ASE via msg.value.

• Minimum bond: 500 ASE (chain-enforced via the staking contract).
• Maximum bond: 50,000,000 ASE. On top of that, no validator earns more than 10% of a block's rewards; the excess returns to the reward pool.
• Signing committee: 100 seats, chosen each epoch by stake (top 50 core seats plus reserve seats; ties at the cutoff rotate). Bonding the minimum makes you a candidate, not a signer. The cutoff moves as people bond: currently about 1,350 ASE, so check it on the explorer's validators page. Below it your validator stays waiting (dormant) and earns no signing rewards.
• Activation: a candidate ~10 blocks after bonding; a signing seat from a following epoch if your stake clears the cutoff.
• Additional bonds: you can call bond(pubKey) again to increase your stake, up to the max cap.

Unbonding & withdrawing

How it works

1. Unbond. Your stake drops straight away by the amount you unbond, so from the next epoch it no longer counts towards a committee seat or signing rewards. Each unbond becomes its own entry in your unbonding queue, set to unlock at the current block plus 1,296,000.
2. Wait. The unlock is counted in blocks, not days, so how long it takes depends on block speed. To estimate it, take the entry's unlock block, subtract the current block and multiply by the current block time.
3. Claim. Once an entry's unlock block has passed, claim it and the ASE moves back to your wallet. One claim collects every matured entry at once; entries that have not matured stay in the queue.

Where to do it

• Operator app: Unbond ASE (a set amount) or Unbond all, then Claim matured unbond once an entry has matured.
• VPS: asentum-validator unstake <amount> to unbond, asentum-validator withdraw to claim.
• Contract: unbond(amount) and withdraw() on the staking contract.

Rules

• A partial unbond must leave at least 500 ASE bonded. To exit completely, unbond your whole stake.
• Several unbonds make several queue entries, each with its own unlock block.
• Nothing can speed up or reverse an entry. To stake again sooner, bond other ASE from your wallet.

Check your queue

The staking contract's getWithdrawable view lists every entry in your queue with its amount, its unlock block and whether it has matured, plus the totals. If you are not sure what is waiting for you, open a support ticket with your validator address and we will look it up.

Planned change: we intend to make unbonding a fixed 7 days measured in time, so it no longer stretches when blocks are slow. It needs a network update, which will be announced ahead of time along with how entries already in the queue are handled.

Slashing

Double-signing, signing two different blocks at the same height with the same key, is the primary slashable offense. Double-sign evidence is submitted on-chain and results in stake slashing and ejection from the validator set.

Downtime is handled by the liveness-aware committee, not by slashing. If your node goes offline, it simply drops out of the active committee (last 30 blocks). When it comes back online and proposes a block, it re-enters automatically. No penalty, no manual intervention. For full details, see Slashing Risks.

Monitoring your node

• Desktop app: the dashboard shows block height, peer count, consensus quorum, validator status, stake, and wallet balance in real time.
• VPS: use asentum-validator status for a quick health check, or asentum-validator logs for a live log stream.
• Explorer: check your validator address on explorer.asentum.com to see proposed blocks and transaction history.
• RPC: query GET /validators on your local node or the public testnet to see the full validator set and your stake.

For detailed monitoring setup, see Monitoring & Logs.