Irium (IRM)

Settlement-first SHA-256d proof-of-work blockchain for trustless commerce.

Download the Irium Core desktop app: https://github.com/iriumlabs/irium-core/releases/latest

Bundles iriumd, irium-wallet, and the CPU/GPU miners. Builds for Windows, macOS, and Linux. Handles wallet creation, marketplace, pool mining, settlement, and explorer in one window. No terminal required.

Use the command-line tooling below if you need a server install, automation, or want to build from source.

The chain activates Bitcoin-standard block-header serialization at block 23,500. Every node must run iriumd v1.9.28 or newer before block 23,500 is mined. Older nodes will compute the wrong header hash for post-fork blocks and fork off from the canonical chain. Mainnet tip is currently ~22,500; activation is days away at the current cadence.

The desktop app's auto-update prompt will surface the same warning. Server / pool / ASIC operators should git pull && cargo build --release (or pull the v1.9.28 release binary) and restart iriumd before activation.

At block height 66,400, Irium mainnet switched to a single-payee reward model: the full 50 IRM block reward is now paid to one VRF-selected proposer instead of being split 55/22/13/10 across four roles. This was a hard fork — the old and new coinbase rules are mutually exclusive.

A node without this gate stops following the chain at block 66,399 while still showing itself as connected. No tagged release contains the gate yet — the latest release, v1.9.191, predates it. Build from main (commit d57d22a5 or later) until a release is cut:

git pull && cargo build --release --bin iriumd
strings target/release/iriumd | grep -c IRIUM_POAWX_SINGLE_PAYEE_REWARD_ACTIVATION_HEIGHT   # must be 1

Selection is unchanged and remains hardware-neutral: any device (CPU, GPU or ASIC) still has the same random chance of being selected by VRF sortition, and extra hashrate still does not improve those odds. Only the distribution of the reward after selection changed. Full guide: docs/POAWX.md.

At block height 50,000, Irium mainnet activates PoAW-X, its block-proposer consensus layer (VRF-selected proposers, anti-domination, and — until block 66,400 — a multi-role reward split). Blocks before 50,000 are unaffected. All node operators and miners must upgrade before block 50,000, or they will reject post-activation blocks and fall off the canonical chain. From block 50,000, mining requires a full iriumd node, not just a pool/stratum connection. Full guide: docs/POAWX.md.

From block 50,000, Irium layers PoAW-X on top of its SHA-256d proof of work (the PoW and LWMA-144 difficulty are unchanged):

• VRF proposer selection — each block's proposer is verifiably chosen by a VRF (ECVRF / RFC-9381), not just first-to-find-PoW.
• Single-payee reward — from block 66,400 the full block reward is paid to the VRF-selected proposer as one coinbase output. (Between 62,236 and 66,399 it was split 55% proposer / 22% compute / 13% verify / 10% support across four outputs.)
• Anti-domination — per-identity weighting over a rolling 2016-block window discourages single-identity dominance.
• Distributed finality — a registered committee provides 2/3-threshold finality.

See docs/POAWX.md for the complete guide and docs/WHITEPAPER.md Section 4 for the specification.

Irium is a proof-of-work blockchain built for trustless escrow and proof-based commerce. Instead of smart contracts, it uses a deterministic settlement layer: buyer and seller lock funds on-chain, an attestor submits a cryptographic proof of delivery, and the chain enforces release or refund automatically. No lawyers, no chargebacks, no intermediaries.

SHA-256d consensus. No premine. No admin keys. 100,000,000 IRM total supply (96.5M from mining + 3.5M genesis CLTV vesting). Mainnet live since January 5, 2026.

Verified against the running chain on 2026-08-05 (tip 66,435). Activation heights below are mainnet constants; anything not listed with a height is not deployed.

Everything in this section is deployed and enforcing on mainnet today. Whenever mining is active, the chain produces and validates blocks, selects proposers by VRF, enforces the anti-domination and sortition caps, and pays the full block reward to the selected proposer. Everything below this line is roadmap — designed, partly proven, or deliberately deferred — and none of it is required for the network to operate as described above.

Caveat on the fork-choice comparator: deployed and armed, but not behaviourally proven. It engages only when competing branches of unequal length exist; none have occurred since activation, so the corrected path has not yet executed in production.

Third-party onboarding works. An independent key with no operator setup, no allow-list and no manual step registered on chain, became eligible on both nodes, and was paid in mainnet block 65,351. Bound: that key ran on operator hardware against a local node, so this proves the mechanism has no gatekeeping — not that a miner across the internet has joined. Two real operators are active today.

One gap affects users today: a registered key that stops producing for ~2,016 blocks cannot currently renew its eligibility (da166f0c, written but not deployed). Keys that produce continuously are unaffected, since producing a block refreshes registration automatically.

Option 0 — Irium Core desktop app (recommended for most users)

Download the latest installer for Windows, macOS, or Linux from https://github.com/iriumlabs/irium-core/releases/latest. The app bundles the v1.9.49 sidecars, runs the node + wallet + miner in one window, and ships pool client + marketplace + settlement Hub.

The CLI options below are for power users, server operators, and developers.

Option 1 — Pre-built binary (Linux/macOS)

curl -fsSL https://raw.githubusercontent.com/iriumlabs/irium/main/install.sh | bash

Installs iriumd, irium-wallet, irium-miner, and irium-miner-gpu to /usr/local/bin.

Option 2 — Docker

cp .env.example .env   # fill in your wallet address
docker-compose up -d

Option 3 — Build from source

git clone https://github.com/iriumlabs/irium.git && cd irium
cargo build --release

GPU miner:

cargo build --release --features gpu --bin irium-miner-gpu

Web developers can integrate Irium settlement into their apps using the official TypeScript SDK:

npm install irium-js

Full documentation and examples at sdk/irium-js/. Covers agreement lifecycle, proof submission, offer feed, real-time WebSocket events, and chain queries.

iriumd                              # start the node (syncs automatically)
curl http://127.0.0.1:38300/status  # confirm it is running
irium-wallet new-address            # generate your first address
irium-wallet list-addresses         # see your addresses
irium-wallet balance <YOUR_ADDRESS> # check balance once synced

The node connects to the Irium network automatically. On first run it uses the signed seed list bundled with the software. After the first connection it caches peer addresses locally and never needs the seed nodes again. No configuration needed for a basic setup. Default P2P port: 38291. Default RPC port: 38300.

Public pool stats live at https://pool.irium.org/stats and at the raw proxy http://pool.irium.org:3337/stats (CORS-enabled JSON with active miners, accepted shares, blocks found, current share difficulty, and a rolling-window hashrate estimate per profile).

After block 23,500 activates Fix 2a, every SHA-256d miner (ASIC, GPU, CPU) that submits valid work earns real block rewards directly to the IRM address used as the Stratum worker name — the pool runs in SOLO payout mode (no fee, no aggregation).

⚠️ Read this before pointing an ASIC at mainnet

Since PoW demotion activated at block 61,414, ASIC hashrate no longer wins mainnet blocks. A validly-selected PoAW-X proposer only has to beat a constant anti-spam floor, so a commodity CPU produces blocks as fast as any amount of SHA-256d hashrate. Every recent mainnet block has been produced by PoAW-X CPU producers; the ASIC pool currently reports 0 connected sessions, 0 accepted shares and 0 blocks found.

The Stratum endpoints above are still running and the table is kept for completeness, but pointing mining hardware at them today will not earn block rewards. If you want to mine mainnet, use the PoAW-X producer path below, which is what actually wins blocks.

This is a consequence of hardware-neutral block production, not an outage.

From block 50,000, producing a block means running your own full iriumd node as a PoAW-X producer — and PoAW-X blocks are produced at a CPU-reachable floor difficulty, so a commodity CPU can produce them with no ASIC or GPU required. Onboarding is permissionless: you register a proposer key, your node gossips it, and by consensus every producer must include it — the registration queue is force-drained in first-in-first-out order, so no producer can gatekeep who joins. After a 16-block freeze your key is eligible and wins ~1/n of blocks by fair VRF sortition. From block 66,400 each block you propose pays you the full 50 IRM reward.

cargo build --release --bin iriumd --bin irium-miner
./target/release/iriumd                                    # run a full node, let it sync
openssl rand -hex 32 > ~/.irium/producer.secret && chmod 600 ~/.irium/producer.secret
IRIUM_POAWX_MINER_SECRET_HEX="$(cat ~/.irium/producer.secret)" \
IRIUM_NODE_RPC=http://127.0.0.1:38300 \
  ./target/release/irium-miner --poawx --threads 1         # registration is automatic

Full step-by-step guide, including how the permissionless, no-gatekeeper design works: docs/run-your-own-producer.md.

If your node has a public IP address, you can help new users bootstrap by advertising your address. Two complementary mechanisms exist:

Coinbase peer-discovery embed — your miner stamps the listen address into every coinbase transaction so new nodes scanning the chain discover you without DNS or a central seed server:

export IRIUM_ADVERTISE_ADDR=<your-public-ip>:38291

P2P handshake external endpoint — your node tells each peer the IP they should record as your dialable address. This is the CGNAT escape hatch: without it, peers infer your address from the TCP source IP, which under carrier-grade NAT (RFC 6598, 100.64.0.0/10) is the carrier's NAT address rather than your real public IP. Set this when you know your real external IPv4:

export IRIUM_EXTERNAL_ENDPOINT=<your-public-ip>:38291

iriumd validates the value (rejects RFC1918 private, RFC6598 CGNAT, loopback, link-local, multicast, documentation, and IPv6) before advertising it. Old peers without the field simply fall back to the TCP-source-IP behavior, so this is fully backwards compatible.

To add your node as a seed for a running node without restarting:

curl -X POST http://localhost:38300/admin/add-seed \
  -H 'Authorization: Bearer <token>' \
  -H 'Content-Type: application/json' \
  -d '{"addr": "<your-public-ip>:38291"}'

If your ISP gives you a 100.64.0.0/10 address rather than a real public IP, peers that observe your TCP source IP record an unroutable address and gossip it onwards. Symptoms: 0 inbound peers indefinitely, even with port forwarding configured on the local router.

Fixes, in order of impact:

1. Ask your ISP for a public IPv4 (many offer it free on request) — then set IRIUM_EXTERNAL_ENDPOINT=<that-public-ip>:38291.
2. Run a small relay on a VPS and forward port 38291 to your home node.
3. Accept outbound-only operation: iriumd still syncs and submits transactions, you just don't accept inbound connections.

The desktop wallet (irium-core) auto-detects your public IPv4 via an external IP-echo service before launching iriumd, and only sets IRIUM_EXTERNAL_ENDPOINT when the result validates as globally routable. Manual CLI users on cloud servers should set the env var explicitly.

The minimum commands for a complete buyer–seller trade:

# Seller: create an offer
irium-wallet offer-create \
  --seller <YOUR_ADDRESS> \
  --amount 1.0 \
  --description "Software licence delivery" \
  --policy-template software_delivery

# Buyer: list open offers and take one
irium-wallet offer-list --status open
irium-wallet offer-take --offer <OFFER_ID> --buyer <BUYER_ADDRESS>

# Attestor or seller: submit delivery proof
irium-wallet agreement-proof-submit --proof proof.json

# Check release eligibility (true after 6-block finality)
irium-wallet agreement-release-eligibility <AGREEMENT_HASH>

Full walkthrough: QUICKSTART.md | API reference: docs/API.md

MIT