Run a node

A node keeps a full copy of the chain, checks every block and transaction against the rules, relays what is valid, and serves wallets, miners and explorers over a JSON-RPC interface. Running one is the only way to verify the chain for yourself rather than trusting someone else's explorer, and every extra node makes the network harder to partition.

Requirements

A release archive for your platform, or Go 1.26 or later to build from source. There is no cgo, so it builds anywhere Go does.
Disk: the chain grows by at most about 1 MB per block, 50 GB a year with full blocks. Early on it is far smaller.
Memory: a few hundred megabytes. Mining adds 8 MiB per thread.
A clock within two hours of real time. Run NTP; a node far off the real time rejects valid blocks.
For a public node: the P2P port reachable from the internet.

Install

From source:

git clone <repository>
cd argonmine
go build ./...
go test ./...
go build -o argonmined ./cmd/argonmined

From a release archive: unzip it and run install-windows.ps1 (Windows, Start Menu and Desktop shortcuts, no administrator rights) or install.sh (Linux and macOS). The archive holds argonmined, argonmine-app, argonmine-wallet, argonmine-explorer, argonmine-web and genesis.

Start

argonmined                                   # mainnet, default ports
argonmined -network testnet                  # testnet
argonmined -network regtest -listen none     # private chain on this machine

The data directory is %LOCALAPPDATA%\Argonmine on Windows and ~/.argonmine elsewhere, with one subdirectory per network. On first start the node writes a random RPC token to <datadir>/<network>/rpc.cookie, finds peers through the DNS seeds and the built-in seed list, and syncs headers first, then blocks.

Networks and ports

	mainnet	testnet	regtest
Address prefix	`arg1`	`targ1`	`rarg1`
P2P port	9333	19333	29333
RPC port	9332	19332	29332
Proof-of-work floor	262,144 attempts per block	512	about 2, constant
Genesis hash	`e85ad1e8…3c985f`	`81fa0f3b…7cff32`	`b3682483…97959d`

Genesis time is 2026-10-25 00:00:00 UTC on every network. The difficulty schedule is anchored there, which is why the mainnet genesis is mined for the launch moment and not earlier.

Flags

Flag	Default	Meaning
`-network`	`mainnet`	`mainnet`, `testnet` or `regtest`
`-datadir`	per OS, see above	Data directory; a per-network subdirectory is used
`-listen`	`:<network port>`	P2P listen address; `none` disables inbound connections
`-connect`		Comma-separated peers to stay connected to
`-seeds`		Extra seed peers
`-dnsseed`		Extra DNS seed hostnames
`-rpc`	`127.0.0.1:<rpc port>`	RPC listen address. Keep it on localhost.
`-rpctoken`	random	RPC token; written to `rpc.cookie` when not given
`-mine`		Start the built-in miner paying this address
`-threads`	CPUs − 1	Miner threads
`-tag`		Coinbase text, up to 100 bytes
`-behind-proxy`	off	Inbound P2P connections arrive through a TCP proxy or load balancer (Railway, a cloud load balancer): never ban or cap inbound peers by address. See below
`-ban-local-addrs`	off	Treat loopback, private and carrier-grade NAT inbound addresses as distinct peers, so bans and the per-address cap apply (a private network where every peer has its own address)
`-maxinbound`	125	Inbound P2P connections. When full, an idle inbound peer makes room for a newcomer
`-assetoutputfee`	546	Relay policy: extra fee in units for every asset output beyond the first two in a transaction

Connection limits

Inbound slots. At most -maxinbound inbound connections, accepted at most 10 per second (bursts of 20). When every slot is taken a newcomer is not refused: an inbound peer is evicted instead. A peer that never sent a new block or transaction goes first, then the one least recently useful, the longest connected among equals. The four peers with the best ping, the four that most recently delivered a new block, and the peer the node is syncing from are never evicted.
Per address. At most 3 inbound connections from one address, and a peer that misbehaves has its address banned for 24 hours, but only when the address identifies the peer. Behind a TCP proxy every inbound peer arrives from the proxy's address, so one bad message would lock everyone out: start such a node with -behind-proxy, and misbehaviour then only disconnects the one connection. Loopback, private (10/8, 172.16/12, 192.168/16, fc00::/7), link-local and carrier-grade NAT (100.64/10) sources are treated the same way by default; -ban-local-addrs turns bans and the cap back on for them.
Sync peers. The node prefers to download from peers it dialed. A peer that claims a greater height must answer the first getheaders within 15 seconds and then deliver headers the node lacks; otherwise it is dropped and, when its address identifies it, not chosen again for an hour. Transaction announcements are skipped only while the tip is more than two hours old and the sync peer is really delivering new headers, so a false height claim cannot switch transaction relay off.

Transaction relay limits

Fetching. At most 500 transactions per getdata and 1,000 outstanding per peer. A transaction is asked of one peer at a time; if it does not arrive within 60 seconds, or arrives with a bad witness, the next peer that announced it is asked.
Serving. Answers to getdata come from a separate worker per peer, in order, at most 4 MB ahead of the connection, so a peer asking for a lot slows down only its own answers and two busy nodes cannot stall each other. Blocks are always served. A transaction is served to a peer only after it was announced to that peer, and once per announcement.
Pending transactions. On connect, and when a caught-up peer sends mempool, the node announces up to 10,000 pending transactions, parents before children and the best fee rate first, in inv messages of at most 1,000. A mempool request is answered once per 2 minutes per address (per connection when the address is shared, and then at most ten at once and one every 10 seconds after that across all such connections). Transactions fetched from these announcements count against 64 MB per address per 10 minutes (256 MB shared by all connections from shared addresses).
Orphans. A transaction that arrives before its parent waits in an orphan pool (100 transactions, 5 MB, 5 minutes, random eviction) and enters the mempool when the parent arrives or a new block confirms its inputs.

The mempool's own rules (fees, dust, asset outputs, chains of unconfirmed transactions) are in SPEC §10.

The RPC

JSON-RPC 2.0 over HTTP. Every request carries the token, either as Authorization: Bearer <token> or as HTTP basic auth with any user name and the token as the password.

curl -s -H "Authorization: Bearer $(cat ~/.argonmine/mainnet/rpc.cookie)" \
  -d '{"jsonrpc":"2.0","id":1,"method":"getblockchaininfo","params":[]}' \
  http://127.0.0.1:9332/

Method	Returns
`help`	The method list
`uptime`	Seconds since start
`getblockchaininfo`	Chain name, height, best hash, sync state, genesis
`getblockcount`	Height of the tip
`getbestblockhash`	Hash of the tip
`getdifficulty`	Current difficulty relative to the proof-of-work floor
`getblockhash <height>`	Block hash at a height on the main chain
`getblockheader <hash>`	Decoded header with confirmations and work
`getblock <hash> [verbosity]`	Block as hex (0), decoded (1), or decoded with transactions (2)
`getrawtransaction <txid> [verbose]`	Transaction as hex or decoded, with its block and confirmations
`decoderawtransaction <hex>`	Decode without broadcasting
`gettxout <txid> <index>`	An unspent output, or null
`getrawmempool`	Transaction ids waiting for a block
`getmempoolinfo`	Count and bytes in the mempool
`sendrawtransaction <hex>`	Validate, add to the mempool and relay; returns the txid
`getblocktemplate`	Everything a miner needs for the next block
`submitblock <hex>`	Validate and connect a mined block
`getmininginfo`	Height, difficulty, mempool size, network
`getpeerinfo`	Connected peers
`getnetworkinfo`	Version, network, listening addresses
`validateaddress <address>`	Whether an address is valid on this network
`generatetoaddress <n> <address>`	Mine n blocks now (regtest only)

Decoded transactions include each output's type, address and amount, each input's previous output, and for version-2 transactions the asset id of every non-ARG output and any issuance.

The wallet

argonmine-wallet is a command-line wallet that talks to a node over the RPC. Keys are derived from a 24-word phrase and stored encrypted under a password in <datadir>/<network>/wallet.json.

argonmine-wallet create                          # prints the 24 words once
argonmine-wallet restore "<24 words>"
argonmine-wallet address                         # a new receive address
argonmine-wallet balance                         # spendable, immature, pending
argonmine-wallet send arg1… 1.25                 # amount in ARG; optional fee rate and memo
argonmine-wallet history
argonmine-wallet utxos
argonmine-wallet mnemonic                        # prints the phrase; needs the password

Flags: -network, -datadir, -wallet <file>, -rpc <url>, -token, -password (or the ARGONMINE_WALLET_PASSWORD variable; prompted otherwise), -passphrase for an optional BIP-39 passphrase at create or restore time.

A phrase created in the browser app restores here with the same address (the first receive address), so the same coins can be spent from either.

The explorer and work server

argonmine-explorer -network mainnet -listen 127.0.0.1:8380

The explorer follows its node over the RPC, keeps an address index beside the node's data directory, and serves blocks, transactions, addresses, mempool and charts. It is also the work server for the browser app (Mining).

Flag	Default	Meaning
`-network`	`mainnet`	Which network
`-datadir`	per OS	Node data directory (for `rpc.cookie`); the index lives beside it
`-rpc`	`http://127.0.0.1:<rpc port>`	Node RPC URL
`-token`	from `rpc.cookie`	RPC token
`-listen`	`127.0.0.1:8380`	HTTP listen address
`-referral-share`	`5`	Percent of a block reward a browser miner gives to the inviter named in their invite link; `0` disables referrals

JSON API

Endpoint	Returns
`GET /api/stats`	Network, indexed and node height, hashrate, supply, blocks submitted by browser miners
`GET /api/charts?n=288`	Hashrate, difficulty, block interval and supply over the last n blocks
`GET /api/address/{address}`	Balance, spendable, maturing, totals, referral totals and the recent history with coinbase and referral flags
`GET /api/utxos/{address}`	The address's unspent coins (at most 1,000) with height, asset and coinbase flag; `spentBy` for a coin a waiting transaction spends; `pending`, its unconfirmed outputs (`own` when every input was its own coin, its change); `mempool`, the waiting transactions that touch it. What the browser wallet spends from
`POST /api/tx`	Body `{"hex": signed transaction}`: checked and handed to the node; returns `{"txid"}`. A transaction spending a coin that a waiting one already spends is refused (409), so a payment never quietly replaces another. Any origin may call it; one a second per client, bursts of 10
`GET /api/work?address=…[&ref=…]`	A block template for a browser miner
`POST /api/work/submit`	Submit a solved block
`GET /qr.svg?d=…`	A QR code as SVG

Every API response allows cross-origin requests, so the app can run on a different host.

The app and documentation server

argonmine-web serves the browser app and this documentation. With -app and -site it serves the app on one hostname and the docs on another from the same process.

argonmine-web -listen 127.0.0.1:8370 -app https://app.example.com -site https://example.com \
  -explorer https://explorer.example.com -bridge https://bridge.example.com -hrp arg

Flag	Default	Meaning
`-listen`	`127.0.0.1:8370`	HTTP listen address
`-app`		Public URL of the app; requests for that host get the app
`-site`		Public URL of the documentation site
`-explorer`	`http://127.0.0.1:8380`	Explorer URL the app uses for work, balances and history
`-bridge`		Bridge URL (empty hides the link)
`-hrp`	`arg`	Address prefix of the network the app is for
`-repo`	`.`	Repository root, where the Markdown sources live
`-export <dir>`		Write the site as static files and exit

The static export can be hosted anywhere that serves files, with the explorer as the only moving part behind it.

Operations

Seed nodes. New nodes find the network through DNS seeds and a built-in list. The Seed nodes guide covers Docker, systemd and hosted platforms.
Monitoring. getpeerinfo and getblockchaininfo are enough: alert when peers drop to zero or the height stalls for two hours.
Backups. The 24 words are the backup. The wallet file is convenient, not essential.
Upgrades. Stop the node, replace the binary, start it. The database format is forward-compatible within a release line; the release notes say when it is not.
Security. Keep the RPC on localhost or behind an authenticated proxy. The token grants full control of the node, including the ability to broadcast transactions, but never gives access to wallet keys, which live only in the wallet file and the desktop app.