WATTx documentation

What WATTx is

WATTx is a hybrid Proof-of-Work / Proof-of-Stake blockchain with a UTXO ledger and a full Ethereum Virtual Machine layered over it, built on a QTUM Core foundation. Three things make it unusual:

• Seven mining algorithms in one chain. SHA256d, Scrypt, Ethash, RandomX, Equihash, X11 and kHeavyHash all produce valid WATTx blocks, each with its own independent difficulty. Whatever hardware you own — ASIC, GPU or CPU — there is a lane for it.
• Merged mining with every one of them. If you already mine Bitcoin, Litecoin, Monero, Dash, Zcash, Kaspa, Ethereum Classic or Altcoinchain, you can point the same work at WATTx and earn on both chains for no additional energy.
• PoW and PoS compete for the same blocks. There is no fixed split. The 50 WTX subsidy goes whole to whoever produced the block, so emission divides between mining and staking exactly in proportion to how much each side actually contributes.

On top of that sit an EVM for Solidity contracts, a UTXO layer that carries ordinal inscriptions, offline staking with delegation, and a trust-tier system that pays reliable validators more.

Network specifications

Activation schedule

Ethereum hard forks — Muir Glacier, London, Shanghai, Cancun and Pectra — plus every QIP and the standard BIPs are all active from genesis, so the EVM is current from block 0.

Public endpoints

Running a node

Download the release for your platform. The Linux and macOS archives contain wattxd (daemon), wattx-cli (RPC client) and wattx-qt (graphical wallet); Windows ships wattx-qt.exe with its DLLs. Android has an APK; iOS is in progress.

# start the daemon
./wattxd -daemon

# follow the sync
./wattx-cli getblockchaininfo
./wattx-cli getconnectioncount

# stop cleanly — always do this rather than killing the process
./wattx-cli stop

What good looks like

$ ./wattx-cli getblockchaininfo
{
  "chain": "main",
  "blocks": 20136,
  "headers": 20136,
  "difficulty": 110063.59,
  "moneysupply": 914595,
  "verificationprogress": 1,
  "initialblockdownload": false,
  "pruned": false
}

blocks == headers and initialblockdownload: false means you are synced. moneysupply is the circulating WTX.

Configuration

~/.wattx/wattx.conf on Linux, %APPDATA%\WATTx\wattx.conf on Windows, ~/Library/Application Support/WATTx/wattx.conf on macOS.

# --- rpc ---
server=1
rpcuser=wattxrpc
rpcpassword=<long random string>
rpcport=3889
rpcbind=127.0.0.1
rpcallowip=127.0.0.1

# --- network ---
listen=1
port=3888

# --- staking ---
staking=1
# reservebalance=0

# --- optional indexes (needed by explorers and some APIs) ---
# txindex=1
# addressindex=1
# logevents=1        # EVM logs — required for eth_getLogs style queries

Addresses and wallets

Address formats

Wallets

All of them derive WTX at m/44'/22356'/0'/0/0 with base58 version 73, so one seed opens the same wallet everywhere.

# create an address
./wattx-cli getnewaddress "label"

# what is its EVM form?
./wattx-cli gethexaddress "WYourAddress…"

# and back
./wattx-cli fromhexaddress "0x…"

# is this address mine?
./wattx-cli validateaddress "WYourAddress…"

Backups

./wattx-cli backupwallet "/path/to/wallet-backup.dat"
./wattx-cli walletpassphrasechange "old" "new"   # encrypt first if you have not

A staking node has to hold its wallet unlocked, so it is a hot wallet by definition. Keep the bulk of your coins in cold storage and delegate — delegation never moves your coins.

Hybrid PoW/PoS consensus

Blocks can be produced by a miner or by a staker. They compete for the same slots and the subsidy is not split — the whole 50 WTX goes to whoever produced that block.

That design choice matters: it means the PoW/PoS emission ratio is not a governance parameter anybody chose, it is an emergent measurement of how much each side actually contributes. If staking participation collapses, miners produce more blocks and earn more; if hashrate leaves, stakers do.

Combined difficulty

Combined = PoW_Difficulty^0.6 × PoS_Difficulty^0.4
           where PoS_Difficulty = 100 / staking participation rate

Both mechanisms feed the network's security number, with PoW weighted slightly higher to keep mining worthwhile.

What an attacker has to do

Compromise both sides at once. Renting hashrate is not enough while stakers keep producing blocks, and acquiring stake is not enough while miners keep producing them. Add seven independent algorithm difficulties and there is no single hardware market deep enough to rent a majority from.

Block selection

When a PoW and a PoS solution appear together, the first valid block a majority of nodes receives wins. Ordinary nakamoto tie-breaking — but combined with seven algorithms it is also why reorgs are frequent on WATTx.

X25X — seven algorithms, one chain

Active since block 2,000. Each algorithm keeps its own independent difficulty, so hashrate arriving or leaving on one lane never disturbs the others.

Why seven

• Hardware inclusivity. Three hardware classes, seven lanes — no one hardware type can monopolise block production, and a CPU owner is not competing against an ASIC farm.
• Difficulty isolation. Per-algorithm retargeting means a hashrate migration on one lane cannot stall the chain on another.
• Merged-mining reach. Seven algorithms covers virtually every major PoW chain in existence, which is what makes AuxPoW more than a nice idea.

Mining

Solo, from the node

./wattx-cli getnewaddress "mining"
./wattx-cli generatetoaddress 1 "WYourAddress…"
./wattx-cli getmininginfo

wattx-qt has the same thing behind a button. Solo CPU mining will find blocks on a young chain and essentially never on a mature one — use a pool or merge-mine.

Pool mining

Point any miner that speaks the algorithm's usual stratum dialect at a WATTx-compatible pool. The public pool runs the RandomX lane:

# RandomX, e.g. xmrig
xmrig -o pools.wattxchange.app:3333 -u WYourWTXAddress -p x -a rx/0

# generic stratum form
stratum+tcp://pools.wattxchange.app:3333

The stratum speaks the wire protocol each algorithm's miners expect — the XMRig login/job/submit dialect on RandomX, Bitcoin's mining.subscribe / mining.authorize / mining.submit on SHA256d, Scrypt and X11, eth_getWork / eth_submitWork on Ethash, and the nheqminer Zcash-stratum format on Equihash. Existing miners work unmodified.

Which lane should you mine?

If you already mine anything on a supported algorithm, merged mining is strictly better than mining WATTx directly — same hardware, same power, two payouts.

AuxPoW merged mining

Do the work once, get paid on two chains. All seven X25X algorithms support merged mining, and it has been proven end-to-end on real parent chains for every one of them.

How it works

1. Commit. You build a parent-chain block whose coinbase (or, for chains without a spendable coinbase, whose designated commitment field) contains a hash commitment to the WATTx block you want to produce.
2. Mine it normally. Nothing about the parent chain's mining changes. Your hardware, your pool software, your usual work.
3. Find a solution. When you find one good enough for the parent chain, you have also — for free — found one good enough for WATTx, because WATTx's difficulty is lower.
4. Submit both. The parent solution goes to the parent chain. The AuxPoW proof — the parent header, the commitment and the merkle branch linking them — goes to WATTx.
5. WATTx verifies it canonically. It recomputes the parent chain's own proof-of-work with the real algorithm, and checks that the parent block commits to the exact WATTx block being submitted. One share, two blocks.

Proven parent chains

The point of it

WATTx does not want its own dedicated hashrate. It wants a slice of the hashrate that already exists. Every ASIC pointed at Bitcoin, every GPU on Ethereum Classic, every CPU on Monero can add its work to WATTx for zero marginal energy — and in return WATTx pays those miners to keep smaller networks alive rather than concentrating on the largest chain. A miner who merge-mines does not have to choose between the big chain and the small one.

Running a merged-mining pool

The daemon has a merged stratum built in. It polls each configured parent chain for work, builds a combined job, serves it on that algorithm's port in that algorithm's native wire protocol, and submits solutions to both chains.

./wattx-cli startmultimergedstratum '<json config>'
./wattx-cli getmergeminingdashboard
./wattx-cli stopmultimergedstratum

Ports are assigned from a base in algorithm order:

Per-chain share gates

One share difficulty cannot serve a SHA256d ASIC and a RandomX CPU at the same time, so each parent-chain entry takes its own optional share_nbits or share_difficulty overriding the pool-wide value. Set them per lane or your CPU miners will never submit anything and your ASICs will drown you.

The 1 % pool fee

Merged-mining pools in the WATTx ecosystem contribute a 1 % fee that funds the Mining Game economy. That is what makes the game's rewards backed by real mining revenue rather than by token emission — and it is why the game exists at all.

Solo staking

1. Hold WTX in a wallet you control. Any amount stakes; more stakes proportionally more often.
2. Wait for maturity. A UTXO must have 500 confirmations and must not have moved during that window. At 120-second blocks that is about 16.7 hours. The threshold halves at every reward halving.
3. Unlock for staking only.

   ./wattx-cli walletpassphrase "YOUR_PASSPHRASE" 99999999 true

   The trailing true is what makes it staking-only: the wallet can sign coinstakes but cannot sendtoaddress. That is the flag you want on an always-on node.
4. Check it is working.

   ./wattx-cli getstakinginfo

   Look for staking: true and a non-zero weight. Compare weight to netstakeweight — that ratio is roughly your share of PoS blocks.
5. Stay online. A staking node that is offline when its coin's turn comes simply misses it.

Stake weight = Σ (mature UTXO values)
A UTXO is mature when confirmations ≥ 500 and it has not moved in that window.

Delegation and super stakers

Offline staking has been active since block 1. You delegate your staking rights to a super staker; your coins never move and never leave your wallet.

As a delegator

# delegate to a super staker, agreeing to their fee (percent)
./wattx-cli setdelegateforaddress "<superStakerAddress>" <fee> "<yourAddress>" <gasLimit> <gasPrice>

# check it landed
./wattx-cli getdelegationinfoforaddress "<yourAddress>"

# undo it
./wattx-cli removedelegationforaddress "<yourAddress>" <gasLimit> <gasPrice>

• Non-custodial. The delegation is a contract record, not a transfer. Nobody can spend your coins.
• Any amount. There is no delegator minimum.
• Cold-storage compatible. Your keys can stay air-gapped; only the hot super staker node is online.
• Rewards land on your address, minus the super staker's fee.

As a super staker

./wattx-cli setsuperstaker "<yourAddress>" true
./wattx-cli listsuperstakercustomconfig
./wattx-cli getstakinginfo

• 20,000 WTX minimum self-stake (nMinValidatorStake).
• Run 24/7. Uptime is what your trust tier — and therefore your multiplier — is measured on.
• Publish your fee and keep it stable. Delegators can leave in one transaction.

Trust tiers

PoS networks have a lazy-validator problem: a node that is offline half the time still earns roughly in proportion to its stake, so there is no economic pressure to be reliable. Trust tiers add that pressure.

Uptime is measured over rolling windows and tiers move dynamically — this is a continuously earned status, not a badge you keep. A Platinum validator earns double a Bronze one on the same stake, which is a large enough gap to justify real infrastructure: a UPS, a monitored host, an automatic restart. That is exactly the intent.

Tokenomics

The dual halving

Every halving does two things at once. It halves the block reward, controlling inflation — and it halves the staking maturity requirement, widening access.

The reasoning is progressive decentralisation. Early on, a high barrier selects for committed stakers and gives the young chain its security. Later, as the reward per block shrinks, the barrier shrinks with it and security comes from breadth of participation instead of depth of individual commitment. In the final eras maturity is near-instant.

Fair launch

Zero premine. No ICO, IEO or IDO. No founder allocation. Every WTX in existence was mined or staked, starting at block 0.

Smart contracts (EVM)

Full EVM, Solidity up to 0.8.x, QRC-20 and QRC-721 tokens that are byte-compatible with ERC-20 and ERC-721. Every Ethereum hard fork through Pectra is active from genesis. What is different is how a transaction reaches the EVM.

The Account Abstraction Layer

A WATTx contract transaction is a UTXO transaction carrying a special output script. Three opcodes carry the EVM payload:

The sender is recovered from the input scriptSig, which is why contract calls must spend legacy P2PKH inputs — and why the contract's view of "who called me" is HASH160(pubkey), your legacy address as 20 bytes.

From the CLI

# deploy
./wattx-cli createcontract "<bytecode-hex>" [gasLimit] [gasPrice] [senderAddress]

# read-only call — free, no transaction
./wattx-cli callcontract "<contractAddr>" "<data-hex>"

# state-changing call, optionally sending WTX
./wattx-cli sendtocontract "<contractAddr>" "<data-hex>" <amount> [gasLimit] [gasPrice] [senderAddress]

# what happened?
./wattx-cli gettransactionreceipt "<txid>"
./wattx-cli searchlogs <fromBlock> <toBlock>      # needs -logevents=1

wattx-qt has a built-in Solidity compiler and a contract UI; you can also compile with solc and deploy the bytecode from the CLI.

EVM from the browser

The WATTx Wallet extension is the answer to "MetaMask cannot do WATTx". It already holds UTXO keys and signs UTXO transactions, so it can build the AAL output itself.

It injects a window.wattx provider. Install it, then:

// connect — returns UTXO addresses and the derived EVM address
const acct = await window.wattx.connect();
//  { addresses: {...}, evm: "0x…" }

// the caller identity a contract will see
const from = await window.wattx.getEvmAddress();

// a state-changing contract call
const txid = await window.wattx.sendToContract({
  to:       "0xContractAddress",
  data:     "0xa9059cbb…",       // abi-encoded calldata
  value:    0,                    // WTX in satoshi
  gasLimit: 250000,               // default
  gasPrice: 40                    // satoshi, default
});

// deploy
const { txid, address } = await window.wattx.deployContract({ bytecode: "0x60806040…" });

// ordinals
await window.wattx.inscribe({ contentType: "image/png", dataBase64, toAddress });

// plain coins
await window.wattx.sendWTX({ to: "wx1q…", amount: 100000000 });

Security model

• Per-origin connect grants are persisted; every inscription raises a fresh confirmation window showing content type, size and estimated cost.
• Every contract transaction raises its own approval screen.
• createWallet, importWallet and exportBackup are locked to chrome-extension:// senders — a web page can never call them.
• The origin is taken from the browser's sender, never from the page's claim about itself.
• Keys are BIP-39; the create flow forces you through writing the phrase down before it shows you the wallet. Encryption at rest is still on the list.

Ordinals and the UTXO API

WATTx carries ordinal inscriptions on its UTXO layer, using the same commit/reveal envelope shape as Bitcoin ordinals. Inscribe from the wallet extension, from nft.wattxchange.app, or from the wattx-ord CLI.

The public API

GET  https://ord-api.wattxchange.app/health
GET  /address/:addr/utxo          # works for W…, wx1q… and wx1p…
GET  /address/:addr/balance
GET  /tx/:txid                    # includes raw hex (needed for nonWitnessUtxo)
POST /tx            {"hex":"…"}   # broadcast

GET  /inscription/:id             # raw content, served with its own content-type
GET  /inscriptions                # block-scan discovery
GET  /ord/inscriptions            # rich index: owner, transfers, size
GET  /ord/inscription/:id
GET  /ord/address/:addr
GET  /ord/content/:id
GET  /ord/status

CORS is open, so a browser dApp can call it directly. It uses scantxoutset rather than the address index, which means it works against any node with no reindex — at the cost of scanning the UTXO set per query, which is fine on a chain this young.

Privacy

FCMP privacy transactions Block 210,000

Full-chain membership proofs bring shielded transactions to the base layer, with shielded coinbase following at block 210,100. Shielded outputs mature after 10 blocks; shielded coinbase outputs after 100.

Stealth addresses

The sender derives a one-time address from the recipient's public key. Only the recipient can detect and spend it, and every payment lands on a distinct, unlinked address — so a published address never becomes a public transaction history.

Cross-chain privacy pools

Deposit USDT on Ethereum, BSC or Polygon in fixed denominations (100, 1K, 10K, 100K). The deposit locks in that chain's pool contract; a LayerZero message creates a shielded commitment on WATTx in a 20-level incremental merkle tree. You generate a zero-knowledge proof off-chain and withdraw to any supported chain. Fixed denominations defeat amount correlation, the proof establishes validity without revealing the deposit, and withdrawing on a different chain breaks single-chain analysis outright.

WATTxSecret Live

secret.wattxchain.org — AES-256-GCM encryption performed entirely in your browser, self-destructing messages with configurable expiry (1–30 days) and view limits (1–10 views), no server-side storage, no cookies, no analytics. The key never leaves your machine, which means we could not read your messages even if we were asked to.

Ecosystem

ANS — WATTx Name Service Planned

Human-readable .wtx names mapping to addresses, contracts and IPFS content, resolved natively in wallets and dApps.

Bridges

WTX moves to and from the EVM world through a bridge desk, and WATT — the Mining Game's token — moves between EVM chains over a self-hosted LayerZero mesh.

Use them at bridge.wattxchange.app. The desk publishes live quotes and a route finder:

GET https://bridge.wattxchange.app/api/info
GET https://bridge.wattxchange.app/api/prices
GET https://bridge.wattxchange.app/api/quote?direction=WTX_TO_WATT&amount=100&dest=0x…
GET https://bridge.wattxchange.app/api/route?from=WTX&to=POL&amount=100

Full bridge documentation, including every contract address, lives in the Mining Game docs.

The Mining Game

The Mining Game is where WATTx's mining economy becomes something you can hold. It is an NFT mining-rig builder whose rewards are funded by real node income — including the 1 % fee from merged mining pools.

• Collect component NFTs — cases, processors, GPUs, ASICs, frames — and assemble them into rigs.
• Point a rig at a pool. The pool is backed by a real validator, masternode or staking node; whatever that node earns is split among the pool's miners by effective power and paid out on-chain.
• Components you are not mining with can be staked powered-off to mint WATT; rigs that are mining burn WATT as fuel, 99 % destroyed and 1 % to the pool host.
• Lock 100,000 WATT and you can host your own pool, turning your node's income into a game economy — and your own rigs then mine for free.
• WTX is a first-class payout coin (target id 1), and WTX bridges to WATT through the desk.

RPC reference

Everything below is wattx-cli <command>, or a JSON-RPC POST to http://127.0.0.1:3889 with your rpcuser / rpcpassword.

curl -s --user "$RPCUSER:$RPCPASS" -H 'content-type: application/json' \
  http://127.0.0.1:3889/ \
  --data '{"jsonrpc":"2.0","id":1,"method":"getblockchaininfo","params":[]}'

Chain and blocks

Mining

Staking and delegation

Smart contracts

Wallet

EVM JSON-RPC

https://rpc-wtx.wattxchange.app speaks Ethereum JSON-RPC — eth_blockNumber, eth_call, eth_getBalance, eth_getTransactionReceipt and friends — so ethers.js and web3.js can read WATTx contracts normally. It cannot sign for your key; see Smart contracts.

curl -s https://rpc-wtx.wattxchange.app \
  -H 'content-type: application/json' \
  --data '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}'

Troubleshooting

The daemon exits immediately

Missing librandomx.so. Run it from its own directory with LD_LIBRARY_PATH=..

getstakinginfo says staking: false

The wallet is locked, or unlocked without the staking-only flag. Run walletpassphrase "<pass>" 99999999 true — the trailing true is the whole point.

A staking node cannot send

Correct, and deliberate. A staking-only unlock signs coinstakes and nothing else. A full unlock is needed at send time.

getaddressbalance returns "No information available"

addressindex=1 in the config does not backfill. Reindex, or use scantxoutset.

My indexer says it is synced but shows nothing

Its reorg path wiped the state without rewinding far enough. See Ordinals.

My EIP-712 signature is rejected as a bad signature

You signed with chain id 22356. The EVM's block.chainid is 81. Read the contract's real domain with eip712Domain().

provider.getSigner() throws "accounts is not iterable"

The adapter's eth_accounts returns null. Construct the signer explicitly against a known address.

tx.wait() hangs or resolves on the wrong transaction

The adapter re-hashes transactions and can synthesise phantom replacements from change outputs. Confirm a deploy by scanning blocks for your exact creation calldata.

"bad address checksum" from a receipt

Receipts can carry badly checksummed addresses. Re-checksum from lowercase before use.

An NFT I minted cannot be transferred

It went to an Ethereum-derived address. That address is unsignable on WATTx and there is no rescue. See Addresses — this is the one mistake with no undo.

The node is stuck on a corrupt block index

One-shot -reindex. The chain is small; it takes seconds.

Merged-mining config changes do not take effect

Stopping and starting the stratum does not reload configuration. Restart the daemon.

Glossary