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 testnet.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. Get test ASE from the faucet.

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). Every validator who has bonded at least 500 ASE into the staking system contract is eligible for a proposer slot. The validator 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.
• HTTP networking. Nodes sync via HTTP pull-based block fetching and POST-based vote gossip. No libp2p, no TCP sockets to configure.
• ~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 faucet button in the dashboard to request test ASE. You need at least 500 ASE to bond.
5. Stake. Enter your password, click "Stake & Start Validating." The app signs a bond(pubKey) transaction and broadcasts it. Your node enters the active set within ~10 blocks.
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://testnet.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.json.
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. Polls the faucet to fund the validator address with enough ASE to bond.
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 restart     # restart the systemd service
asentum-validator update      # pull latest chain code + snapshot, restart

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.

For the full VPS guide, 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 join the active set. 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: No hard cap. Stake concentration is handled by the 10% per-block reward cap, not by capping bonds.
• Activation: ~10 blocks after bonding (graceful quorum transition).
• Additional bonds: you can call bond(pubKey) again to increase your stake, up to the max cap.

Unbonding & withdrawing

To leave the validator set and retrieve your stake:

1. Unbond. Call unbond(amount) on the staking contract. Your ASE enters a 14-day unbonding queue (604,800 blocks at 2s).
2. Wait. During the unbonding period, your stake is locked. You are removed from the active set but cannot withdraw yet.
3. Withdraw. After the unbonding period, call withdraw() to transfer the matured ASE back to your wallet.

Partial unbonding is supported, but your remaining stake must stay above 500 ASE. To fully exit, unbond your entire stake. Use getWithdrawable(address) to check if you have matured funds ready to withdraw.

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 testnet.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.