Everything about Neoxa,
in one place.

What is Neoxa

Neoxa is a community-secured Layer 1 with native asset issuance, a smartnode tier, and a play-to-earn gaming layer.

The chain launched in May 2022, runs on KawPoW proof-of-work with 60-second blocks, and is secured by a global pool of GPU miners alongside thousands of incentivized smartnodes.

Every block pays 5,000 NEOX (halving every 2,100,000 blocks, roughly every four years). 45% goes to the miner who finds the block, 45% goes to a smartnode operator via round-robin payment, and the remaining 10% goes to the team's dev wallet. Max supply is capped at 21,000,000,000 NEOX.

Beyond payments, Neoxa includes a native asset protocol so anyone can mint tokens, NFTs, and sub-assets directly on chain without writing a smart contract. The team also runs three companion services around the chain: neoxa.exchange for trading and the wNEOX bridge, neoxagaming.com for play-to-earn games, and neoxanodes.com for managed smartnode hosting.

Quickstart

Three steps puts you on the network in minutes.

1. Get a wallet. Neoxa Core is the official Qt desktop wallet and the only one that supports running a smartnode. The web wallet at webwallet.neoxa.net works in any browser with no install. NeoxEX, the new mobile wallet, ships in Q2 2026.
2. Get NEOX. Three paths: mine with any KawPoW-capable GPU, buy on Neoxa Exchange or CoinEx, or earn through play-to-earn on neoxagaming.com.
3. Use the network. Send NEOX in 60 seconds, mint your own asset, or, if you hold 1,000,000 NEOX, run a smartnode and earn 45% of every block in round-robin payments.

Your first transaction

Sending NEOX is the same flow as any modern crypto wallet.

1. Open your wallet and copy your receiving address. Neoxa addresses begin with the letter G (for example, GfmH3wc9xncwvp9Z6xEhZ8nxC8ub4E6wKh).
2. Share that address with whoever is paying you, or paste a recipient's address into the Send field of your wallet.
3. Enter the amount and confirm. The wallet picks a reasonable fee automatically.
4. The transaction enters the next block in about 60 seconds. One confirmation is enough for most everyday payments.
5. Paste the transaction ID into the block explorer to watch confirmations climb in real time.

Every transaction is permanently recorded on chain and visible on the explorer, so you can always look up what you sent and to whom.

Using the block explorer

The explorer at explorer.neoxa.net is the open window into Neoxa's chain data. No signup, no API key.

What you can do there:

• Look up any block by height or hash to see its miner, reward, timestamp, and full transaction list.
• Track a transaction by ID and watch confirmations roll in.
• Search any address to see its full payment history and current balance.
• Browse the active smartnode list with payee, owner address, and PoSe status for each node.
• Read the chain's live tip, hashrate, difficulty, and circulating supply from the dashboard at the top.

The explorer is built on the open-source eiquidus stack and run by the Neoxa team.

Tokenomics

Fixed cap, automatic halvings, every block reward distributed by chain consensus.

• Max supply: 21,000,000,000 NEOX. The block reward schedule converges to this number geometrically. The chain can never mint more.
• Premine: none. The genesis block on May 1, 2022 paid a single 5,000 NEOX coinbase output, identical to every other block at that point in the schedule. There's no founder allocation.

On-chain split per block (verified against live coinbase outputs):

• 45% to the miner that found the block (1,125 NEOX at the current reward)
• 45% to a smartnode operator via round-robin payment (1,125 NEOX)
• 10% to the team's dev wallet (250 NEOX, paid as a single coinbase output)

Operational allocation of the 10% dev wallet (off chain, run by the team):

• Half funds Neoxa Gaming's play-to-earn rewards, paid out off chain by neoxagaming.com.
• Half funds protocol and platform development.

Live state: 10.54B NEOX in circulation, 4.47B NEOX locked in smartnodes.

Block reward & halving

The block reward starts at 5,000 NEOX and halves every 2,100,000 blocks. At a 60-second block time, that's roughly every four years.

Live state: halving epoch 1, 2,084,303 blocks (~1447 days) until the next halving at block 4,200,000.

Total emission converges geometrically toward 21B but never quite reaches it.

KawPoW algorithm

Neoxa uses KawPoW for proof-of-work, the same algorithm Ravencoin uses. It's a memory-hard, GPU-friendly PoW designed to keep specialized ASIC hardware at a disadvantage and let consumer GPUs compete fairly.

• Target block time: 60 seconds
• Base block reward: 5,000 NEOX (halving every 2,100,000 blocks)
• Difficulty retargets: every block

KawPoW is a customization of ProgPoW. Any standard KawPoW miner works on Neoxa: T-Rex (Nvidia), lolMiner (both vendors), and GMiner (both) are the most commonly used. For pool selection, a recommended miner, and a copy-pasteable command, see the Mining page.

Live state: network hashrate 28.57 GH/s, difficulty 407.86.

InstantSend

InstantSend uses a quorum of smartnodes to lock a transaction so it can't be double-spent before the next block confirms it. Once a quorum signs, the network treats those funds as final.

Paired with ChainLocks (also active on Neoxa), the chain offers two layers of irreversibility:

• InstantSend locks individual transactions before the next block.
• ChainLocks locks every confirmed block so the chain can't be reorged past it. The standard probabilistic "wait N confirmations" model is replaced by an explicit smartnode-quorum signature on the tip.

Both features are enabled at the protocol level (sporks SPORK_2 and SPORK_19). Whether a specific wallet exposes the InstantSend toggle depends on how its developers integrated smartnode quorum signing. Neoxa Core supports both.

Governance

Smartnodes also vote on chain-level proposals through Neoxa's on-chain governance system. Each active smartnode gets one vote.

Anyone can submit a proposal by paying the 5 NEOX fee on chain. Smartnodes vote yes, no, or abstain over the voting window, and the tally is recorded on chain.

The on-chain payment side of the system (automatic funding for passed proposals from a periodic "superblock") is currently disabled at the protocol level via spork SPORK_9. The voting and proposal-tracking layer is live; the funding layer can be activated by the network without a hard fork.

For current proposals or community discussion, the Neoxa Discord is the primary channel.

Neoxa Core (Qt)

Neoxa Core is the official full-node desktop wallet. It validates the chain locally and ships with every protocol feature.

The download package includes:

• Neoxa-Qt: the graphical wallet (the program most users open).
• neoxad: the headless daemon, used by servers and smartnode operators.
• neoxa-cli: the command-line interface for scripting and RPC calls.

What it can do:

• Send, receive, and store NEOX.
• Issue, transfer, and manage native assets (tokens, NFTs, sub-assets) on chain.
• Register and operate a smartnode. This is the only wallet with that capability.
• Use InstantSend for sub-block-time finality.
• Validate the full chain from genesis.

Platforms: Windows, macOS, and Linux. Source and binaries at github.com/NeoxaChain/Neoxa.

First launch performs a chain sync: the wallet downloads and verifies every block since genesis (May 2022). After that it stays current automatically.

Latest release: v5.1.1.4 (Jul 26, 2023). Download from the release page.

Web wallet

The web wallet at webwallet.neoxa.net runs in any browser. No download, no chain sync, no daemon.

Good for:

• Quick balance checks from any device.
• Sending and receiving on the go.
• Using NEOX on a computer where you can't install software.

The web wallet is self-custodial: keys are generated and stored in your browser. Treat it as a hot wallet, convenient for daily use, not for long-term storage of large balances. For smartnode operations, use Neoxa Core.

Mobile wallets

One mobile wallet ships today; the next-generation one ships in Q2 2026.

Neoxa Mobile (Android). The current Android wallet, distributed as a sideloadable APK at neoxa.net/downloads/storage/Neoxa-Mobile.apk. Suitable for everyday send and receive on Android phones.

NeoxEX Mobile (iOS + Android). The next-generation mobile wallet, scheduled to ship in Q2 2026. Native asset support, biometric unlock, and a cleaner UX for daily payments. iOS arrives alongside Android in the same release.

iPhone users today: there is no current iOS build, so the web wallet in Safari is the practical stopgap until NeoxEX lands.

Backup & security

Four habits that save coins.

1. Back up your wallet file or seed phrase. Neoxa Core stores wallet data in wallet.dat inside the data directory. Copy it to an offline backup (encrypted USB, paper printout of the dump, or a hardware backup device). If your wallet exposes a recovery seed phrase, write it down and keep that offline too.
2. Verify every download. Only install Neoxa Core from the official GitHub releases page. Check the SHA-256 of the file against the signed checksums published alongside the release. Skip third-party mirrors and random links from chat.
3. Encrypt your wallet. Set a strong passphrase in Neoxa Core's settings. Even if someone copies your wallet.dat, they can't spend funds without the passphrase.
4. Never share keys. No moderator, dev, or support agent will ever ask for your seed phrase or private keys. Anyone asking is a scammer. Same goes for screen-share requests during a wallet issue.

Smartnode operators take an extra step: the 1,000,000 NEOX collateral lives in its own address. Treat the wallet holding that address with even more care than a daily-use one.

Why mine NEOX

Mining NEOX is the most direct way to earn from the network. 45% of every block goes to the miner that finds it, paid by chain consensus.

• GPU-friendly. KawPoW is memory-hard and ProgPoW-derived, designed to keep specialized ASICs at a disadvantage. Consumer Nvidia and AMD GPUs compete on equal terms.
• No middleman. Block rewards arrive in coinbase outputs straight to your wallet. No foundation cut, no allowlist, no KYC.
• Halving epoch 0. The full 5,000 NEOX per block (so 1,125 NEOX to the miner) is still being paid until the chain reaches block 2,100,000.

Live state: network hashrate 28.57 GH/s, difficulty 407.86, 2,084,303 blocks until the next halving.

Picking a pool

Pool mining smooths out variance. You contribute your hashrate to a pool, the pool finds blocks on behalf of everyone, and payouts are split proportionally minus a small fee.

What to look at when picking one:

• Fee. Usually 0.5% to 2%. Lower is better, all else equal.
• Payout threshold. The minimum balance before the pool pays you out. Smaller miners want a lower threshold.
• Geographic location. Closer stratum servers mean fewer stale shares and slightly higher effective hashrate.
• Hashrate. Bigger pools find blocks more consistently. Smaller pools help keep the network decentralized.
• Reliability. Check uptime, payout history, and Discord/community feedback before pointing serious hashrate at a new pool.

The Neoxa team does not endorse individual pools. MiningPoolStats is the canonical place to see live stats for every NEOX pool: hashrate, miner count, fee, and pool URL.

Mining software

Three KawPoW miners cover essentially every GPU on the market today.

• T-Rex Miner. Nvidia-only. The highest hashrate on most RTX 30 and 40 series cards. Closed source. Releases.
• lolMiner. Nvidia and AMD. Open source, frequent updates, good all-rounder for mixed rigs. Releases.
• GMiner. Nvidia and AMD. Strong on RDNA2 cards. Closed source. Releases.

All three are free. Always download from the official GitHub release page (linked above). Random reuploads on file-sharing sites are common malware vectors.

The Mining page has a copy-pasteable T-Rex KawPoW command.

Setup walkthrough

Getting from zero to mining takes five steps and about fifteen minutes.

1. Get a NEOX address. Use Neoxa Core or the web wallet. Copy your receiving address (begins with G).
2. Pick a pool from MiningPoolStats. Open its connect page to find the stratum host and port.
3. Download a miner from one of the three GitHub release pages above. Unzip into a folder.
4. Run with your config. Sample T-Rex command on Windows:

t-rex.exe \
  -a kawpow \
  -o stratum+tcp://POOL_HOST:PORT \
  -u YOUR_NEOX_ADDRESS \
  -p x \
  -w rig01

5. Watch the pool. After a few minutes your worker shows up on the pool's dashboard with current hashrate, accepted/rejected shares, and balance. Payouts arrive once you hit the threshold.

More detail (per-miner downloads, OS notes) lives on the Mining page.

Solo mining

Solo mining means pointing your miner at your own Neoxa Core node instead of a pool. You keep the full miner share (45% per block, paid directly by the chain) with no pool fee, but variance is high and you need a synced full node running.

At the live network hashrate of 28.57 GH/s, here's how much a solo miner would earn on average at different hashrates:

Those NEOX-per-day numbers are long-run averages. Day to day, a small solo miner might find zero blocks for a week and then find two in an afternoon. Pool mining trades the upside variance for predictable income.

What you need for solo mining: a fully synced Neoxa Core node, RPC enabled, and your miner pointed at the local stratum bridge (some miners support solo mode directly via the --solo flag plus RPC creds; others need a thin stratum-to-RPC proxy).

Bottom line: solo is for hobbyists with a full node already running, or for farms with enough hashrate to find a block within an hour or two. For most cards, the pool route smooths out the curve and pays the rent.

What is a smartnode

A smartnode is an always-on Neoxa node backed by 1,000,000 NEOX in collateral. It provides network services miners can't provide on their own, and earns 45% of every block in round-robin payments.

What smartnodes do for the network:

• InstantSend quorums. Sign transaction locks so payments can be treated as final before the next block.
• ChainLocks quorums. Sign the chain tip so confirmed blocks can't be reorged.
• Governance. Cast one vote per node on chain-level proposals.
• Validator set membership. Form the rotating set that orders network-level signing duties.

The system is inherited from the Dash codebase (Deterministic Masternode List, or DIP-3). Every smartnode is identified by a unique proTxHash registered on chain.

Live state: 4,475 enabled, 1,555 PoSe-banned, out of 6,030 registered.

Collateral & registration

The 1,000,000 NEOX collateral never leaves your wallet. Registration proves you control it; deregistration happens automatically the moment you spend it.

The collateral itself:

• Exactly 1,000,000 NEOX in a single unspent transaction output (UTXO) you control.
• Stays in your own wallet. It is locked by software (so the wallet doesn't accidentally spend it), not by the chain.
• Spending the UTXO automatically deregisters the smartnode. There's no exit timer.

A smartnode uses five separate addresses or keys, on purpose:

• Collateral address. Holds the 1M NEOX UTXO.
• Owner address. The on-chain governance owner. Can update or revoke the registration.
• Voting address. Casts votes on governance proposals. Can be delegated separately from owner.
• Payee address. Where round-robin block rewards are paid. Can be different from collateral.
• Operator BLS key. Used by the running node to sign network messages. Lives on the server.

Registration submits a special transaction (a ProTx) that ties all five together. In Neoxa Core, protx quick_setup does the prepare, sign, and submit steps in one go. The full protx command family supports each step separately if you want cold-storage signing.

Live state: 4.47B NEOX locked across all enabled smartnodes.

Hosting on neoxanodes.com

For most operators, neoxanodes.com is the simplest path: $0.60 per month, fully managed.

What the service handles:

• Linux VPS provisioning and OS-level setup.
• Neoxa Core daemon installation and updates.
• Sentinel watchdog (the process that keeps the node visible to the network).
• Monitoring and uptime alerts.

What you keep:

• The 1,000,000 NEOX collateral, in your own wallet.
• The owner key (you can change voting/payee delegation at any time).
• The voting key (you cast your own governance votes).

The service runs the operator-side BLS key and the daemon on a VPS the team maintains. Because the collateral and owner keys stay with you, the worst case is the host going offline; your funds are unaffected.

Sign up at neoxanodes.com.

Self-hosting

Setting up a Neoxa smartnode on your own VPS. About 30 to 45 minutes of work once you have a server, most of which is waiting for the desktop wallet to sync.

What you need

• 1,000,000 NEOX in a wallet you control on a desktop machine.
• A Linux VPS with a static public IPv4 (IPv6 is optional but supported).
• Neoxa Core (Qt) running on your desktop. This is the "control" wallet that holds the collateral and signs the registration.

VPS specs

The daemon settles around 1.1 to 1.3 GB of RAM per node, with brief spikes to ~1.7 GB during sync. 4 GB of RAM plus 4 GB of swap leaves comfortable headroom for one smartnode.

VPS picks

Any VPS that matches the specs above works. Providers known to work well with Neoxa:

• Hetzner Cloud CX22 (2 vCPU, 4 GB RAM). EU and US locations.
• Contabo VPS S (generous specs for the price).
• OVH VPS Starter (good EU/CA network, reliable long-term).
• Vultr Cloud Compute (many regions, hourly billing).
• DigitalOcean Premium Intel (pricier than EU peers but reliable).
• Hetzner dedicated AX41 if you plan many nodes. Bare metal at VPS prices.

One node per VPS is the simplest setup and what this guide assumes. Running many nodes per host needs containers, network isolation, and careful memory tuning, which is out of scope here.

01Initial server setup

SSH into your VPS as root (or use sudo) and update the system.

sudo su
apt update && sudo apt upgrade -y && sudo apt install -y unzip fail2ban

02Add 4 GB swap

Even with 4 GB of RAM, swap protects against OOM kills during chain sync.

swapon --show
sudo fallocate -l 4G /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile
echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab

03Configure UFW firewall

Lock down everything except SSH and the smartnode P2P port (8788).

sudo apt install ufw -y
sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow ssh
sudo ufw allow 8788/tcp
sudo ufw enable

04Set up fail2ban

Protect SSH from brute-force attempts.

sudo nano /etc/fail2ban/jail.local

Paste:

[sshd]
enabled = true
port = 22
logpath = /var/log/auth.log
maxretry = 3

Save (Ctrl+O, Enter, Ctrl+X) then reboot so swap, firewall, and fail2ban are all applied.

sudo reboot

Reconnect via SSH after about 30 seconds.

05Create the Neoxa user and install the daemon

Run the daemon as a non-root user. Replace new_username with whatever you want (e.g. neoxa).

sudo adduser new_username
sudo su new_username
mkdir neoxa
cd neoxa
wget https://github.com/NeoxaChain/Neoxa/releases/download/v5.1.1.4/neoxad-5.1.1.4-linux64.zip
unzip neoxad-5.1.1.4-linux64.zip
sudo chmod +x neoxad neoxa-cli
mkdir ~/.neoxacore && touch ~/.neoxacore/neoxa.conf

Latest release: v5.1.1.4. The commands above pull this version. When a newer release ships, substitute its tag/filename or check the releases page.

06Set up the local control wallet

The control wallet runs on your desktop, not the VPS. It holds the 1M NEOX collateral and signs the registration. Download the Qt build for your platform from the releases page: neoxaqt-5.1.1.4-linux64.zip (Linux), neoxaqt-5.1.1.4-osx.zip (macOS), or the Windows .exe.

In Neoxa Core Qt:

1. Wait for full sync. None of this works until the wallet is fully caught up.
2. Settings → Encrypt Wallet. Set a strong passphrase and write it down.
3. Generate a receiving address (File → Receiving addresses → New).
4. Backup wallet.dat (File → Backup Wallet) to two safe locations.
5. Send exactly 1,000,000 NEOX to the address from step 3. Send to yourself; do not send less, do not split.
6. Wait for at least 1 confirmation on the collateral transaction.

Critical: never spend, send, or move the 1,000,000 NEOX after this point. Doing so deregisters the smartnode immediately.

07Run protx quick_setup

Open the Debug Console in Qt (Tools → Debug Console). You need four pieces of info.

1. Collateral txid. In the Qt main wallet, go to Transactions, right-click the 1M NEOX transaction, and copy Transaction ID.

2. Collateral output index. In the Debug Console:

smartnode outputs

You'll see something like { "abc123...": "0" }. The number after the colon is the output index (usually 0 or 1).

3. Your VPS public IPv4. On the VPS:

curl -4 ifconfig.co

Use the returned IP with port 8788.

4. A fee address. In the Qt Debug Console:

listaddressbalances

Pick any address that holds at least 0.005 NEOX. The registration transaction pays a tiny fee from this address.

Then in the Qt Debug Console, substitute the four values you collected:

protx quick_setup <txid> <collateralIndex> <ip>:8788 <feeAddress>

Qt prints a configuration block: BLS keys, owner / voting / payout addresses, and a ready-made neoxa.conf. Copy the entire block. The BLS private key in particular cannot be recovered later.

08Apply the config and start the node

Back on the VPS, stop the daemon if it's already running:

~/neoxa/neoxa-cli stop

Open the config file and paste the block from quick_setup:

nano ~/.neoxacore/neoxa.conf

Save (Ctrl+O, Enter, Ctrl+X). Start the daemon:

~/neoxa/neoxad

It forks into the background. Wait for it to sync to the chain tip (10 to 30 minutes from a fresh server).

~/neoxa/neoxa-cli getblockchaininfo | grep -E '"blocks|verificationprogress'

Once verificationprogress is at 1.0:

~/neoxa/neoxa-cli smartnode status

You'll see "status": "Ready" within a few blocks. It takes a few blocks for your smartnode to be confirmed on the network.

Monitoring

Three commands to keep handy:

# am I synced and registered?
~/neoxa/neoxa-cli smartnode status

# what's my PoSe score? lower is better, 0 = perfect
~/neoxa/neoxa-cli protx info <your-proTxHash> | grep -E 'PoSeScore|PoSeBan'

# when was my last paid block?
~/neoxa/neoxa-cli smartnode status | grep -E 'lastpaidblock|lastpaidtime'

If PoSeScore climbs above 0, the network missed a heartbeat from your node. Persistent score growth leads to a ban. Restart the daemon, confirm port 8788 is reachable from outside, and check the BLS public key matches what was registered.

Auto-restart on crash

Wrap the daemon in a systemd service so it always comes back.

sudo nano /etc/systemd/system/neoxa.service

Paste (replace new_username):

[Unit]
Description=Neoxa daemon
After=network.target

[Service]
User=new_username
Type=forking
ExecStart=/home/new_username/neoxa/neoxad
ExecStop=/home/new_username/neoxa/neoxa-cli stop
Restart=on-failure
RestartSec=15
TimeoutStartSec=120

[Install]
WantedBy=multi-user.target

sudo systemctl daemon-reload
sudo systemctl enable neoxa
sudo systemctl start neoxa
sudo systemctl status neoxa

Service-info updates

If you change VPS, IP, or BLS keys, register the change on chain. From the Qt Debug Console (the wallet that owns the collateral):

protx update_service <proTxHash> <newIp>:8788 <newBlsKey> "" <feeAddress>

• The 4th argument is the operator payout script. Pass "" when there's no separate operator reward.
• Get your proTxHash via ~/neoxa/neoxa-cli smartnode status on the VPS.
• To get a new BLS keypair: ~/neoxa/neoxa-cli bls generate.

Upgrade the daemon

~/neoxa/neoxa-cli stop
cd ~/neoxa
wget https://github.com/NeoxaChain/Neoxa/releases/download/v<NEW_VERSION>/neoxad-<NEW_VERSION>-linux64.zip
unzip -o neoxad-<NEW_VERSION>-linux64.zip
sudo chmod +x neoxad neoxa-cli
sudo systemctl restart neoxa     # if using systemd
~/neoxa/neoxa-cli getblockchaininfo

Troubleshooting

"smartnode status: Failed". Almost always means the node can't be reached on port 8788. Check from another machine:

nc -zv <your-vps-ip> 8788

If it fails, confirm ufw status shows 8788/tcp ALLOW, and that your VPS provider's network firewall (Hetzner, OVH, Vultr all have one) also allows it.

PoSeBan set to true. The network has banned your node for repeated heartbeat failures. Fix the underlying issue, then from Qt:

protx update_service <proTxHash> <ip>:8788 <blsKey> "" <feeAddress>

This re-announces the node and clears the ban.

Daemon won't start: "Cannot obtain a lock on data directory". Another neoxad process is already running. Kill it:

pkill -9 neoxad
sleep 2
~/neoxa/neoxad

Out of memory during sync. Either you skipped the swap step (do it) or your VPS has less than 4 GB. Add more swap or upgrade.

Sync stuck at the same block for 10+ minutes. Restart the daemon. If it persists, check ~/.neoxacore/debug.log for errors. Often a peer issue; the daemon picks new peers on restart.

What's next

Once your node is Ready:

• Payment cadence. The pay queue rotates by registration order. With the live count of 4,475 enabled smartnodes and 1,440 blocks per day, expect a payment every 3.11 days on average.
• Verify on chain. Look up your proTxHash on the block explorer and confirm the registered IP, BLS key, and payout address match what you intended.
• Watch your PoSe score. 0 means the network is happy with your node. Anything else, investigate before it bans.
• Don't touch the collateral. Withdrawing or sending the 1M NEOX deregisters instantly and you lose your queue position.

Payments & PoSe

Smartnode payments are deterministic, not luck-based. Every block, the chain picks one specific smartnode for the 45% payout.

• The 45% miner share and the 45% smartnode share are both written into the block's coinbase. There's no separate payout mechanism.
• Selection prioritizes smartnodes that haven't been paid recently, so the queue cycles through every active node before anyone gets paid twice.
• You can preview the next paid smartnode at any time with smartnode current in Neoxa Core or smartnode winners for the upcoming list.

Live state: with 4,475 enabled smartnodes and 1,440 blocks per day, the average wait between payments to any one node is about 3.11 days.

PoSe (Proof of Service). Smartnodes accumulate a penalty score when they fail to respond to the network's consistency checks (missed quorum signings, missed heartbeats). When the score crosses the threshold, the node is marked POSE_BANNED and stops being eligible for payments.

Currently 1,555 smartnodes are PoSe-banned out of 6,030 registered. Most operators recover by fixing the underlying problem (a stuck daemon, a closed port, an out-of-sync chain) and submitting a protx update_service transaction to clear the ban.

The asset protocol

Neoxa includes a native asset protocol imported from Ravencoin and integrated into the Dash-based core. Every asset is a first-class chain-level object. No smart contract, no tokens-on-tokens layer.

Issuance, transfer, and reissuance all happen via consensus rules at the protocol level. The chain enforces uniqueness of asset names and the supply schedule of each asset directly, the same way it enforces NEOX balances.

Each asset has the same set of properties:

• Name. Unique on chain. Uppercase letters, digits, and a few separators (., _, /, #).
• Total supply. Set at issuance.
• Decimal precision (units). 0 to 8. Same role as NEOX's 8 decimals.
• Reissuable flag. If true, the issuer can mint more later. If false, the supply is locked forever.
• IPFS hash (optional). Attaches a content reference for metadata, art, or documents.
• Owner token. Every issued asset NAME generates a single NAME! token sent to the issuer. Holding it is what proves authority to reissue, mint sub-assets, or mint unique assets under that name.

Asset types, distinguished by name syntax:

• Main asset: MYTOKEN. Top-level. Fungible.
• Sub-asset: MYTOKEN/CHILD. Requires holding the parent's owner token. Fungible.
• Unique asset (NFT): MYTOKEN#item001. Each is non-fungible, quantity 1, non-reissuable.
• Message channel: MYTOKEN~channel. Used to broadcast messages to holders of the parent asset.

Live state: 1,503 named assets on chain (560 main, 79 sub, 857 unique, 7 messages).

Issuing a token

Issuing a token is a single transaction from Neoxa Core. The chain charges a NEOX burn fee that varies by asset type.

Burn fees (verified on chain from past issuance transactions):

The burn is a real on-chain payment to a known burn address. No one receives the NEOX; it's permanently removed from circulating supply.

Issuance from the Neoxa Core Qt Debug Console:

issue "MYTOKEN" 1000000 "GtoAddress" "" 8 true false ""

Positional arguments:

1. asset_name: 3 to 32 chars, uppercase + digits + ._.
2. qty: total supply at issuance.
3. to_address (optional): where the tokens go. Leave "" to auto-generate.
4. change_address (optional): where NEOX change is returned.
5. units: decimal precision, 0 to 8.
6. reissuable: true or false.
7. has_ipfs: true or false.
8. ipfs_hash: IPFS CID, required if has_ipfs=true.

After confirmation, the tokens land at to_address and a single MYTOKEN! owner token also lands there. Keep that owner token safe: losing it means losing reissue and sub-asset rights.

NFTs & sub-assets

NFTs on Neoxa are unique assets minted under a parent name, with the # separator. Each is non-fungible, quantity 1, non-reissuable. 5 NEOX burned per item.

You must own the parent asset's owner token (e.g. COLLECTION!) to mint COLLECTION#item001. That gates an NFT collection behind a real on-chain identity.

Mint one or many at once via issueunique:

issueunique "COLLECTION" '["item001","item002","item003"]'

With per-item IPFS hashes for art or metadata:

issueunique "COLLECTION" '["item001","item002"]' '["QmHash1...","QmHash2..."]'

What an NFT carries on chain:

• Unique name: COLLECTION#item001
• Quantity: exactly 1
• Decimals: 0 (whole only)
• Reissuable: false (fixed forever at issuance)
• IPFS hash (optional): points at the media or metadata

Sub-assets are different. A sub-asset (MYTOKEN/PARTNER) is its own fungible token class with its own supply and owner token, costing 100 NEOX to issue. Use sub-assets when you want a child token, unique assets when you want a single item.

Live state: 857 unique assets minted on chain.

Trading assets

Today: peer-to-peer transfers wallet to wallet. Coming Q3 2026: native asset trading via the Neoxa DEX and the asset creation platform's instant trading.

Asset transfers happen with the transfer command in Neoxa Core. They settle in the next block, same as a NEOX send.

transfer "MYTOKEN" 100 "GrecipientAddress"

Optional fields let you attach a message, expire time, and explicit change addresses:

transfer "MYTOKEN" 100 "GrecipientAddress" "optional message" 0 "" ""

There's no on-chain order book yet. Trades happen either by direct peer-to-peer transfer or off chain on platforms that support NEOX assets.

The roadmap entry "Neoxa asset creation platform with instant trading availability" is scheduled for Q3 2026 (see the home page roadmap). When it ships, issued assets will get a built-in trading venue from day one.

Until then: use transfer for direct sends, listmyassets to see what your wallet holds, and the block explorer to audit any address's asset holdings.

What is wNEOX

wNEOX is a wrapped representation of NEOX. It exists on other blockchains so NEOX can be moved, held, and traded in environments outside the Neoxa chain.

Bridging in either direction happens through neoxa.exchange. The exchange is the custodian of the system: it holds the wNEOX supply that gets distributed when you bridge in, and it holds the NEOX reserves that back every wNEOX in circulation 1:1.

Net effect: 1 NEOX on the Neoxa chain always equals 1 wNEOX elsewhere. The peg holds because the only way wNEOX gets minted into circulation is by depositing NEOX, and the only way wNEOX leaves circulation is by being burned during a redemption.

Bridging NEOX to wNEOX

Bridging from NEOX to wNEOX is one swap on neoxa.exchange/swap.

1. Open the swap page and pick the direction NEOX to wNEOX.
2. Enter the amount of NEOX you want to wrap and the destination wallet address on the chain where you want to receive wNEOX.
3. Send the NEOX to the deposit address the page shows you.
4. Once the NEOX deposit confirms on the Neoxa chain, the exchange transfers an equal amount of wNEOX from its reserve to your destination wallet.

What happens to the NEOX you sent. It stays in the exchange's custody as backing for the wNEOX now in your possession. The exchange does not spend it on anything else; it sits there until someone redeems an equivalent amount of wNEOX back to NEOX.

What happens to the wNEOX. It transfers out of the exchange's held supply and into your wallet. The exchange's holdings drop by the same amount that's now in circulation with you.

Redeeming wNEOX to NEOX

Redeeming wNEOX back to native NEOX is the reverse swap on the same neoxa.exchange/swap page. wNEOX is burned during the swap.

1. Open the swap page and pick the direction wNEOX to NEOX.
2. Enter the amount of wNEOX you want to redeem and the Neoxa receiving address (starts with G).
3. Send the wNEOX from your wallet to the address the swap page provides.
4. The exchange burns the incoming wNEOX, permanently removing it from circulation.
5. It then releases the equivalent amount of NEOX from its reserves to your Neoxa address.

Why the burn matters. Burning the redeemed wNEOX is what keeps the peg honest. The exchange isn't re-issuing or recirculating already-redeemed wNEOX; once it's burned, that unit of wrapped supply is gone. The total wNEOX outstanding can only equal the NEOX still held in reserve, because every redemption simultaneously destroys wNEOX and releases NEOX in the same amount.

That's the assurance for anyone holding wNEOX: at any moment, the total wNEOX in circulation is backed 1:1 by NEOX held by the exchange, and the only path to remove NEOX from the reserve is via a burn-and-release pair.

Game servers (Rust, Palworld, CS)

Neoxa Gaming runs community game servers for Palworld, Rust, and Counter-Strike 2. Free to play, open to anyone with an account at neoxagaming.com.

Register first at neoxagaming.com so payouts can be credited to your account, then connect using the address for your region and game.

Palworld

Paste the address into Palworld's multiplayer "Connect by IP" field.

Rust

Open Rust's in-game console (F1) and paste:

client.connect 148.251.140.18:28015

EU server, hosted by Neoxa Gaming.

Counter-Strike 2

Open the CS2 console (~ key, enable from Settings if needed) and paste:

connect 148.251.140.18:27115

EU server, hosted by Neoxa Gaming.

Heads up: these servers are operated off chain by the Neoxa Gaming team. Play sessions, rankings, and reward eligibility are tracked through your neoxagaming.com account, not the Neoxa chain itself.

Arcade games

Over 100 browser-playable arcade games at neoxagaming.com. No download, no install, no wallet integration required to start.

The arcade is part of the Neoxa Gaming platform. Sign in to your neoxagaming.com account, pick a game, and play. Rewards are credited to your account balance and can be withdrawn from there.

How the rewards are funded. Gaming payouts come from the team's allocation of the 10% dev portion of every Neoxa block (roughly half of that, i.e. 5% of every block, is earmarked for gaming). The chain pays the 10% to a single dev wallet; the team then funds neoxagaming.com's reward pool from that wallet. Rewards are off chain, paid by the platform, not by chain consensus.

For the full game catalogue, current rewards, and account setup, visit neoxagaming.com directly.

Card Quest

Card Quest is a Neoxa Gaming title. A mobile build ships in Q2 2026 alongside the NeoxEX wallet.

The mobile version is on the roadmap (see Q2 2026, "Add Card Quest to mobile"). Until then, follow neoxagaming.com and the Neoxa community channels for launch details.

What is cBay

Crypto Bay (cBay) is a marketplace that lets users buy and sell goods using multiple cryptocurrencies, including Neoxa.

By integrating cBay into the Neoxa ecosystem, NEOX gets a direct real-world use case. The token moves beyond a purely digital asset and into practical, everyday transactions for physical goods.

The pitch is simple: a blockchain focused on real usage, not just speculation. cBay extends Neoxa's utility layer past mining rewards, smartnodes, gaming, and asset issuance into commerce that anyone can participate in.

cBay is on the Q2 2026 roadmap (see "Launch cBay"). More details about the marketplace, supported currencies, and integration with the rest of the Neoxa stack will be shared as development progresses.

Freelancer marketplace

Alongside the goods marketplace, cBay will host a freelancer section where users can offer their services and get paid in NEOX or other supported cryptocurrencies.

Same platform, different listing type: instead of physical goods, the freelancer side lists services. Buyers and sellers settle in the cryptocurrency they agree on.

The freelancer feature ships as part of the cBay launch. Full details on listing flow, fees, and dispute handling will be published closer to release.

What is Neoxa DEX

Neoxa DEX is the upcoming on-chain trading venue for Neoxa native assets. Launching Q3 2026.

What it covers:

• Asset trading. Trade NEOX against any issued asset, and assets against each other. The same native asset protocol described in The asset protocol provides the underlying tokens.
• Cross-chain bridging. Bring tokens from other networks into the Neoxa DEX for trading alongside native Neoxa assets.

Neoxa DEX is on the Q3 2026 roadmap, alongside the asset creation platform with instant trading availability. Supported chains, fees, and listing rules will be published as the launch approaches.

RPC reference

Neoxa Core exposes the chain's full state and every wallet operation through a JSON-RPC interface. It's the same API Neoxa-Qt uses internally and the foundation for every external tool, explorer, or bot built on Neoxa.

Connecting

• Default RPC port: 15419 on mainnet (commonly overridden in deployment, as in the example below)
• Auth: rpcuser and rpcpassword set in ~/.neoxacore/neoxa.conf
• Transport: HTTP POST with JSON-RPC body, or use the bundled neoxa-cli

Minimal neoxa.conf for local RPC access:

server=1
rpcuser=neoxa
rpcpassword=CHANGE_ME_TO_A_LONG_RANDOM_STRING
rpcallowip=127.0.0.1
rpcport=8888

Restart neoxad after changing the config. Then either:

# bundled CLI
~/neoxa/neoxa-cli getblockcount

# raw HTTP / JSON-RPC
curl --user neoxa:PASS \
  --data-binary '{"jsonrpc":"1.0","id":"x","method":"getblockcount","params":[]}' \
  -H 'content-type: text/plain;' \
  http://127.0.0.1:8888/

Wallet

• getnewaddress ["label"]: generate a fresh receiving address.
• getbalance: total confirmed balance.
• sendtoaddress "address" amount: send NEOX to an address.
• listtransactions ["label"] [count] [skip]: recent wallet activity.
• walletpassphrase "pass" timeout: unlock an encrypted wallet for spending.
• encryptwallet "passphrase": encrypt the wallet (one-time setup).
• dumpprivkey "address": export an address's private key. Handle with care.
• importprivkey "privkey": import a key into the wallet.

neoxa-cli getnewaddress "savings"
neoxa-cli sendtoaddress "Grecipient..." 100
neoxa-cli walletpassphrase "yourpass" 60   # unlock for 60s

Blockchain

• getblockchaininfo: chain tip, headers, difficulty, sync progress, softfork status.
• getblockcount: current block height.
• getblockhash height: hash for a given height.
• getblock "hash" [verbosity]: block details. Verbosity 2 includes full tx data.
• getrawtransaction "txid" 1: transaction details, including inputs and outputs.
• getmempoolinfo: current mempool size and fee stats.
• getbestblockhash: current chain tip hash.

Assets

• issue "name" qty [...]: issue a new asset (500 NEOX burn for main, 100 for sub).
• issueunique "root" [tags] [ipfs]: mint unique assets / NFTs (5 NEOX per item).
• reissue "name" qty "to" "change" [...]: mint additional supply of a reissuable asset.
• transfer "name" qty "to_address": send asset.
• listmyassets [name] [verbose]: assets currently held in your wallet.
• listassets [name] [verbose] [count] [start]: all assets on chain.
• getassetdata "name": asset metadata (supply, units, reissuable, IPFS).
• listaddressesbyasset "name": every address holding a given asset.

Smartnodes

• smartnode status: your node's registration and sync status.
• smartnode count: network counts: total, enabled.
• smartnode current: the next smartnode scheduled to be paid.
• smartnodelist [mode] [filter]: full smartnode list with status, payee, IP, last paid info.
• protx list [type] [detailed]: DIP-3 registered ProTx list.
• protx info "proTxHash": full registration details including PoSe score.
• protx quick_setup "txid" idx "ip:port" "feeAddress": register a smartnode in one call.
• protx update_service "proTxHash" "ip:port" "blsKey" "" "feeAddress": update IP or operator key.
• bls generate: generate a new operator BLS keypair.

Governance

• getgovernanceinfo: system parameters (proposal fee, quorum, voting cycle).
• gobject list: current proposals on chain.
• gobject get "hash": full proposal details.
• gobject vote-many "hash" funding yes: vote across all smartnodes you control.

Mining

• getmininginfo: current hashrate, difficulty, mempool tx count.
• getnetworkhashps [nblocks] [height]: network hashrate averaged over a window.
• getblocktemplate: for solo mining or pool implementations.

Discovery

To explore the full surface:

# list every command, grouped by category
neoxa-cli help

# usage and arguments for one command
neoxa-cli help getblock

Reference scope: Neoxa Core v5.1.1.4 exposes 188 RPC commands across 16 categories (Addressindex, Assets, Blockchain, Control, Evo, Generating, Messages, Mining, Neoxa, Network, Rawtransactions, Restricted assets, Restricted, Rewards, Util, Wallet). The commands above are the most commonly used; use neoxa-cli help for the complete list.

Neoxa SDK

The Neoxa SDK is a JavaScript library for building Neoxa-powered apps without writing raw RPC plumbing. It targets browsers, Node, and React Native. It's in active development today; a public release is on the Q2 2026 roadmap.

What it is

A real wallet library, not just a thin HTTP wrapper. The SDK runs key generation, derivation, signing, and transaction construction locally, then broadcasts the signed payload to the chain. Apps using it can stay client-side without trusting a remote signer.

What it does

• Wallet primitives. BIP39 mnemonics, BIP44 HD derivation, P2PKH address encoding for Neoxa's G-prefix addresses, message signing and verification.
• NEOX payments. Build, sign, and broadcast plain NEOX transactions, including multi-recipient sends (one transaction, many payouts) and OP_RETURN data anchoring.
• Native asset operations. Issue main assets, sub-assets, and unique assets (NFTs), reissue existing assets to increase supply, transfer assets between addresses, attach IPFS hashes or TXID notifiers. Uses the chain's official burn addresses for the issuance fees.
• InstantSend. Flag transactions for smartnode-locked sub-block-time confirmations.
• Agent facade. A higher-level object that bundles a wallet and an HTTP client into one handle, designed for game backends, payment processors, AI agents, and any non-interactive process that owns a key and needs to act on chain.
• Hosted indexer client. Talks to Neoxa's indexer service for read-only chain queries: address inventory, asset holders, ownership verification, payment checks, signed-message verification, and signed-transaction broadcasting.
• Real-time event stream. WebSocket subscriptions for asset-transfer events filtered by asset name, with automatic reconnect.

Status and release

The SDK is currently in development with an internal preview shipping. The public release is tracked under the Q2 2026 roadmap entry for "Launch Neoxa SDK." Until then, applications can integrate directly via the JSON-RPC interface.

Release announcements happen in the Neoxa Discord and on the home page roadmap.

GitHub & source

Neoxa Core is open source and MIT-licensed. The canonical repository lives at github.com/NeoxaChain/Neoxa.

What's in the repo:

• Full Neoxa Core source in C++.
• The Qt wallet GUI source.
• The daemon (neoxad) and command-line (neoxa-cli) source.
• Build scripts and Docker configurations.
• Documentation in doc/ and contrib/.
• Asset protocol implementation (imported from Ravencoin).
• Smartnode protocol implementation (DIP-3 and related, from the Dash lineage).

Latest release: v5.1.1.4 ( Jul 26, 2023). Default branch: main. License: MIT.

Building from source

Standard Bitcoin-derived build flow on Linux: install the depends, autogen, configure, make. The repo's doc/build-unix.md has the dependency list and exact steps. macOS and Windows builds use the cross-compile scripts in depends/.

Contributing

• Fork the repo, make your change on a branch, open a pull request.
• Discuss design in an issue first for non-trivial changes.
• Code style follows the Bitcoin Core conventions (clang-format config is in the repo).
• Real-time discussion happens in the Neoxa Discord.

FAQ

The questions that come up most often in Discord and Telegram. If yours isn't here, ask there.

What is Neoxa?

A community-secured Layer 1 with native asset issuance, smartnodes, play-to-earn gaming, and a wNEOX bridge. KawPoW mining, 60-second blocks, 21B NEOX max supply. Launched May 2022. See What is Neoxa for the full overview.

Can I mine with a CPU?

No. KawPoW is memory-hard and optimized for GPU compute. CPU hashrate is so low it won't cover its own power cost. Use a modern Nvidia or AMD GPU.

Are ASICs allowed?

KawPoW is designed to keep ASICs at a disadvantage by being memory-hard and tied to a frequently-updating DAG. Specialized hardware exists for KawPoW but doesn't dominate the way SHA-256 ASICs do for Bitcoin. GPUs remain competitive.

What's the minimum to run a smartnode?

Exactly 1,000,000 NEOX in a single unspent output you control, plus a Linux VPS running neoxad. See Collateral and registration.

Where do I buy NEOX?

Neoxa Exchange (NEOX/USDC) or CoinEx (NEOX/USDT and NEOX/BTC). You can also mine directly with a KawPoW GPU or earn through play-to-earn at neoxagaming.com.

Does Neoxa have smart contracts?

Not in the EVM sense. Neoxa instead has a native asset protocol baked into the chain: anyone can issue tokens, NFTs, and sub-assets directly with consensus-level rules. See The asset protocol.

What backs wNEOX?

Real NEOX held by neoxa.exchange, 1:1. When you bridge in, NEOX is deposited and wNEOX is released from the exchange's held supply. When you redeem, wNEOX is burned and the equivalent NEOX is released from the reserve. The peg holds because every redemption simultaneously destroys wNEOX and releases NEOX. Full mechanics in What is wNEOX.

Are gaming rewards on chain?

No. The chain pays 10% of every block reward to a single dev wallet. The team operationally allocates roughly half of that to fund Neoxa Gaming's play-to-earn rewards, which are paid off chain by the gaming platform. Your neoxagaming.com balance tracks earnings; withdrawals settle on chain.

Is NEOX deflationary?

The total supply is capped at 21,000,000,000 NEOX and approaches that cap asymptotically through halvings. Issuance fees for assets burn NEOX (500 for main assets, 100 for sub-assets, 5 per NFT), which is mildly deflationary on issued supply. So: fixed cap, with a small ongoing burn for asset operations.

When's the next halving?

Every 2,100,000 blocks, roughly every four years at the 60-second target block time. The live block-by-block countdown is in Block reward & halving and in the banner at the top of every page.

Is Neoxa a fork of something?

Yes. Neoxa is a fork of the Dash codebase, with KawPoW mining and the native asset protocol imported from Ravencoin. From Dash it keeps the smartnode tier, InstantSend, ChainLocks, and governance. From Ravencoin it gets the work function and the assets.

Glossary

Plain-language definitions for the terms you'll run into across this site, the chain RPC, and the community.

BLS key. The operator's signing key on a smartnode. Lives on the running node and signs network-level messages (quorum participation, payments). Different from the collateral and owner keys, which stay on your local wallet.

ChainLocks. A smartnode-quorum signature on the chain tip that makes confirmed blocks unreorgable. Active on Neoxa via SPORK_19. See InstantSend.

Coinbase (transaction). The first transaction in every block. It creates new NEOX out of nothing (the block reward) and distributes it to the miner (45%), smartnode (45%), and dev wallet (10%).

Collateral. The 1,000,000 NEOX a smartnode operator locks (in their own wallet) to register a node. Spending it deregisters the node automatically.

DIP-3. Dash Improvement Proposal 3, the standard for deterministic masternode lists. Neoxa uses DIP-3 ProTx registrations for smartnodes.

InstantSend. A smartnode-quorum signature on a transaction that locks it before the next block, treating it as final immediately. Active on Neoxa via SPORK_2.

IPFS hash. A content-addressed identifier on the InterPlanetary File System. Neoxa assets can optionally carry an IPFS hash pointing at art, metadata, or documents.

KawPoW. Neoxa's mining algorithm. Memory-hard, GPU-friendly, derived from ProgPoW. Same algorithm Ravencoin uses.

NEOX. The native coin of the Neoxa chain.

wNEOX. A wrapped representation of NEOX on other chains, backed 1:1 by NEOX held by neoxa.exchange. Bridge at neoxa.exchange/swap.

OP_RETURN. A Bitcoin-family transaction opcode that stores up to 80 bytes of arbitrary data on chain. Used for timestamping, asset metadata, and message anchoring.

Owner token (NAME!). A single unique token automatically generated when you issue an asset. Holding it grants the right to reissue, mint sub-assets, and mint unique assets under that name.

PoSe (Proof of Service). The penalty score a smartnode accumulates when it misses network-level checks. Above a threshold the node is marked POSE_BANNED and stops earning until the operator clears the ban with a service update.

ProTx. The on-chain transaction that registers, updates, or revokes a smartnode under DIP-3. Submitted via the protx family of RPC commands.

Reissue. Minting additional supply of an existing asset. Requires holding the asset's owner token. Costs 100 NEOX burn per reissue.

Round-robin (smartnode payments). The deterministic schedule that picks one smartnode per block to receive the 45% smartnode share. Selection prioritizes nodes that haven't been paid recently, so the queue cycles through every active node.

Sentinel. A watchdog process that runs alongside neoxad on a smartnode VPS. Keeps the network aware that the node is alive and pings status updates back to the chain.

Smartnode. Neoxa's name for a Dash-style masternode: an always-on node backed by 1,000,000 NEOX collateral that provides network services (InstantSend, ChainLocks, governance) and earns 45% of every block.

Spork. A chain-level feature flag that can be flipped on or off without a hard fork. Used to gate InstantSend, ChainLocks, superblocks, and other quorum features.

Sub-asset. A child asset under a parent name (e.g. PARENT/CHILD). 100 NEOX burn, requires owning the parent's owner token. A full fungible token in its own right.

Superblock. A periodic block where on-chain governance pays out funded proposals. Cycle is 16,616 blocks (~12 days). Currently disabled at the protocol level via SPORK_9.

Unique asset (NFT). A non-fungible asset minted under a parent name (e.g. PARENT#tag). Quantity 1, non-reissuable. 5 NEOX burn per item.

Community channels

Where the Neoxa community lives. Discord is the front door; everything else is more specific.

Third-party resources

Outside the official channels, the community uses:

• MiningPoolStats for live pool stats.
• WhatToMine for KawPoW profitability estimates.
• masternodes.online for smartnode earnings history.
• CoinMarketCap and CoinGecko for market data.