Skip to main content

Running a Node

This guide covers running a node-only QoreChain deployment — a full or RPC node that syncs the chain and exposes endpoints for integration, without validator duties. It targets exchanges (CEX), wallet backends, indexers, and integrators who need reliable read/write access to the network but do not sign blocks.

note

For block production, staking, slashing, and pool classification, see Running a Validator instead. A node-only deployment never holds a validator consensus key and never appears in the active set.

warning

Binaries, genesis, and snapshots are published at download.qore.host with SHA-256 checksums. Always verify checksums before installing or extracting, and verify deposits only against your own synced node.

Source of truth: the live manifest

The current binary, genesis, peers, seeds, and a state-sync trust point are published as a JSON manifest, refreshed live — don't hardcode a binary version, checksum, or snapshot filename in your install scripts, since they go stale as soon as a new release ships:

  • Mainnet: https://download.qore.host/mainnet/latest.json
  • Testnet: https://download.qore.host/testnet/latest.json

The manifest's fields include binary (url + sha256), genesis (url + sha256 + sizeBytes), peers, seeds, p2pPort, stateSync (a trust point refreshed hourly), and minCompatible. The install and join steps below fetch this manifest and use its current values.

Use the release the manifest names: v3.2.7 on mainnet, v3.2.8 on the testnet

A node that syncs from genesis or replays from a snapshot crosses several governance upgrades (see Upgrades below), so always install the binary the manifest points to: it carries every upgrade handler. On mainnet the manifest's minCompatible and version are both 3.2.7 (applied at height 4,164,600 on 12 November 2026, governance proposal 16), so a node joining now needs v3.2.7: an older binary stops at an upgrade height it does not know. The release is the bundle qorechaind-v3.2.7-b3-linux-amd64.tar.gz (99,472,930 bytes, SHA-256 d4b2f166a75900d2354759b067b3e21c6fbd96003ac056163791cf4b7fb242b5, read from the manifest on 12 November 2026; the live manifest is the source of truth). The manifest advises that new nodes join through state sync. It contains qorechaind and lib/ with libqorepqc.so, libqoresvm.so and libwasmvm.x86_64.so. A node still on v3.2.6 halted at height 4,164,600 with UPGRADE "v3.2.7" NEEDED: install the bundle and restart, and its state is kept. No further mainnet upgrade is scheduled (current_plan is null, checked 12 November 2026); when the manifest names a newer release, that is the binary to install. On the testnet the manifest's minCompatible and version are both 3.2.8 (v3.2.5 was applied at height 8,890,800 on 26 October 2026, v3.2.6 at height 8,970,638 on 27 October, v3.2.7 at height 9,594,600 on 6 November and v3.2.8 at height 9,929,500 on 12 November), so a node joining the testnet needs the v3.2.8 binary: take the bundle name, size and SHA-256 from the live testnet manifest, which is the source of truth (on 7 November 2026, on v3.2.7, it named qorechaind-v3.2.7-b3-linux-amd64.tar.gz, 99,472,930 bytes, SHA-256 d4b2f166a75900d2354759b067b3e21c6fbd96003ac056163791cf4b7fb242b5). A testnet node still on v3.2.7 stops at height 9,929,500 with UPGRADE "v3.2.8" NEEDED: replace qorechaind and copy the whole lib/ folder of the bundle, then start it again; its state is kept and it does not need to resync. Mainnet stays on v3.2.7, one release behind the testnet; it has not applied v3.2.8, so nothing in the v3.2.8 notes changes for mainnet nodes. Do not run a testnet binary against mainnet or the reverse: each directory carries its own release (see Upgrades). The manifest is promoted deliberately (testnet first, mainnet after a soak period), so check its "version" field against minCompatible before trusting binary.url.

A binary built from the public source (the community build) refuses to start on either public network (v3.2.3 and later): it cannot verify post-quantum signatures and cannot replay the networks' blocks faithfully. Use the release archive only.

Two settings matter from v3.2.1 on: keep the system clock synchronised with NTP (the node stops when its clock is more than 60 seconds out), and set evm-chain-id in app.toml (see Node limits).


Node vs Validator​

AspectNode-only (this guide)Validator
Consensus keyNoneed25519 consensus key (must be secured)
Block productionNoYes — proposes and signs blocks
Staking / slashingNot applicableSelf-delegation, slashing risk
Primary purposeServe RPC/REST/gRPC/EVM (and read-only SVM) to integrationsSecure the network (staking rewards apply)
Public exposureRPC/EVM endpoints typically exposedValidator hidden behind sentry nodes

Target Networks​

NetworkChain IDEVM chain IDNotes
Mainnetqorechain-vladi9801 (hex 0x2649)Primary — live since 7 Jun 2026; node release v3.2.7 (since 12 Nov 2026)
Testnetqorechain-diana9800Rehearse integrations here first; node release v3.2.8 (since 12 Nov 2026)

Substitute the appropriate --chain-id for your target network throughout this guide. The examples default to mainnet.


ProfileCPURAMDisk (NVMe SSD)Network
Pruned RPC node4 cores16 GB500 GB+100 Mbps+
Full/archive node8 cores32 GB2 TB+ (grows over time)1 Gbps
Exchange integration8 cores32 GB2 TB+ with headroom1 Gbps

NVMe SSD is strongly recommended: chain state and the EVM/SVM stores are I/O intensive. The disk figures above are generous. Measured on mainnet (27 October 2026): a validator that joined by state sync with pruning = "custom" (keep-recent 100000) and indexer = "null" holds about 10 GB after two months, and a node on default pruning that has run since genesis holds about 100 to 130 GB after four months. Validator sizing is in Running a Validator: Hardware. Archive nodes (no pruning, full tx indexing) grow continuously; provision disk with headroom and monitoring.


Deployment​

Docker Compose​

A node-only deployment with Docker Compose. There is no publicly published qorechaind image to pull (nothing is published under the project's Docker Hub organisation). The Dockerfile in the public repository builds the community binary (no post-quantum library, stub keepers): that is suitable for local development but it cannot follow mainnet or testnet, and since v3.2.3 it refuses to start on them. For a network node, build your own image from the release archive named in latest.json, tag it to the release version (v3.2.6 on both mainnet and the testnet, at the time of writing), then mount a persistent volume for chain data:

# Fetch and verify the release archive (see "Joining the Network" below for the manifest steps)
curl -s https://download.qore.host/mainnet/latest.json -o latest.json
curl -fsSL "$(jq -r .binary.url latest.json)" -o qore.tgz
echo "$(jq -r .binary.sha256 latest.json) qore.tgz" | sha256sum -c -
mkdir release && tar xzf qore.tgz -C release

cat > release/Dockerfile <<'EOF'
FROM debian:bookworm-slim
RUN apt-get update && apt-get install -y ca-certificates curl jq && rm -rf /var/lib/apt/lists/*
COPY qorechaind /usr/local/bin/qorechaind
COPY lib/ /opt/qorechain/lib/
ENV LD_LIBRARY_PATH=/opt/qorechain/lib
ENTRYPOINT ["qorechaind"]
EOF
docker build -t qorechain-node:v3.2.7 release/

The archive contains qorechaind and a lib/ directory with its shared libraries (libqorepqc.so, libqoresvm.so, libwasmvm.x86_64.so and, from v3.2.8, libwasmvmqore_v1.x86_64.so). Copy the whole lib/ directory, not individual files; the image above is linux/amd64 only, like the release archive.

# docker-compose.yml
services:
qorechain-node:
image: qorechain-node:v3.2.7
container_name: qorechain-node
restart: unless-stopped
command: ["start", "--home", "/root/.qorechaind"]
volumes:
- qorechain-data:/root/.qorechaind
ports:
- "26657:26657" # RPC
- "26656:26656" # P2P
- "1317:1317" # REST
- "9090:9090" # gRPC
- "8545:8545" # EVM JSON-RPC
- "8546:8546" # EVM WebSocket
- "8899:8899" # SVM RPC (read-only: SVM transactions are disabled)
- "26660:26660" # Prometheus

volumes:
qorechain-data:

Initialize the data directory once (for example docker compose run --rm qorechain-node init my-node --chain-id qorechain-vladi --home /root/.qorechaind; genesis and peer configuration are covered below), then start:

docker compose up -d
docker compose logs -f qorechain-node

systemd​

For a bare-metal install, run qorechaind under systemd:

# /etc/systemd/system/qorechaind.service
[Unit]
Description=QoreChain node
After=network-online.target
Wants=network-online.target

[Service]
User=qorechain
ExecStart=/usr/local/bin/qorechaind start --home /var/lib/qorechaind
Restart=on-failure
RestartSec=5
LimitNOFILE=65535

[Install]
WantedBy=multi-user.target
sudo systemctl daemon-reload
sudo systemctl enable --now qorechaind
sudo journalctl -u qorechaind -f

Joining the Network​

1. Initialize​

qorechaind init my-node --chain-id qorechain-vladi

2. Fetch the manifest​

curl -s https://download.qore.host/mainnet/latest.json -o latest.json
# testnet: https://download.qore.host/testnet/latest.json

Use this file as the source for the binary, genesis, and peer values in the steps below — check jq -r .minCompatible latest.json and run at least that release (the recommended one is jq -r .version latest.json).

3. Download and verify genesis​

GENESIS_URL=$(jq -r .genesis.url latest.json)
GENESIS_SHA256=$(jq -r .genesis.sha256 latest.json)

curl -fsSL "$GENESIS_URL" -o ~/.qorechaind/config/genesis.json
echo "${GENESIS_SHA256} $HOME/.qorechaind/config/genesis.json" | sha256sum -c -

# Cross-verify against the genesis served live by the chain:
curl -s https://rpc.qore.host/genesis | jq '.result.genesis' > /tmp/genesis-live.json

4. Configure peers and the fee floor​

Read the current peers and seeds from the manifest rather than hardcoding node IDs and hosts — these rotate:

PEERS=$(jq -r '.peers | join(",")' latest.json)
SEEDS=$(jq -r '.seeds | join(",")' latest.json)

Open ~/.qorechaind/config/config.toml and set persistent_peers (and seeds) to those values:

persistent_peers = "<value of $PEERS>"
seeds = "<value of $SEEDS>"

Then set the minimum gas price in ~/.qorechaind/config/app.toml (network fee floor: 0.1uqor):

minimum-gas-prices = "0.1uqor"

qorechaind init <moniker> --chain-id qorechain-vladi also writes the network's EVM chain id into app.toml (see Node limits); check it on a home that was initialised long ago.

5. Start syncing​

qorechaind start --minimum-gas-prices=0.1uqor

Fast Bootstrap​

Syncing from genesis can take a long time. Use state sync as the default way to join; a snapshot is a fallback only (the mainnet snapshot is from 21 August 2026 and the testnet publishes none).

State sync​

State sync fetches a recent application state snapshot from trusted RPC servers instead of replaying every block. Configure the [statesync] section in config.toml:

[statesync]
enable = true
rpc_servers = "https://rpc.qore.host:443,https://<a second RPC you run or trust>:26657"
trust_height = <TRUSTED_BLOCK_HEIGHT>
trust_hash = "<TRUSTED_BLOCK_HASH>"
trust_period = "168h0m0s"

Take trust_height / trust_hash from the manifest's stateSync field. It is refreshed hourly, so it is the preferred source:

TRUST_HEIGHT=$(jq -r .stateSync.trustHeight latest.json)
TRUST_HASH=$(jq -r .stateSync.trustHash latest.json)
Two different RPC servers

State sync cross-checks the trust point against two RPC servers. The manifest's stateSync.rpcServers lists https://rpc.qore.host twice on mainnet (and https://rpc-testnet.qore.host twice on the testnet): two identical entries satisfy the count but defeat the cross-check. Add a second RPC that you run or trust independently, and compare the trust hash with a second source, for example curl -s "https://<second-rpc>/block?height=$TRUST_HEIGHT" | jq -r .result.block_id.hash, which must equal $TRUST_HASH.

As a fallback/alternative, you can derive a trusted height and hash yourself from the public RPC:

curl -s https://rpc.qore.host/block | jq -r '.result.block.header.height, .result.block_id.hash'

Snapshot restore​

Alternatively, download the published chain-data snapshot, verify its checksum, and extract it over your data directory. On mainnet the manifest's snapshot object gives the URL, the block height, the size and the SHA-256. The testnet manifest's snapshot URL currently returns 404 (no testnet snapshot is published), so use state sync there. Read snapshot.height before using the mainnet one: it is a single archive of about 27 GB, and an old one means a long catch-up. The mainnet snapshot currently published is from 21 August 2026 (height 1,966,629): it predates the v3.1.94, v3.2.0, v3.2.2, v3.2.3 and v3.2.4 upgrade heights, so a node restored from it replays about two months of blocks with the release binary the manifest names. State sync is almost always the better choice.

SNAP_URL=$(jq -r .snapshot.url latest.json)
SNAP_SHA256=$(jq -r .snapshot.sha256 latest.json)
curl -fsSL "$SNAP_URL" -o snapshot.tar.gz
echo "${SNAP_SHA256} snapshot.tar.gz" | sha256sum -c -

tar xzf snapshot.tar.gz -C ~/.qorechaind/
qorechaind start --minimum-gas-prices=0.1uqor
note

The manifest's snapshot.height and snapshot.ts fields say how fresh the archive is, and state sync (above) is usually faster than a 27 GB download. Always verify the checksum before extracting, and use a node release that carries every upgrade handler (see the caution at the top of this page) when replaying from a snapshot.


Upgrades​

Consensus changes arrive as coordinated governance upgrades: a passed proposal names a plan (for example v3.2.3) and a block height. The release binary carries the upgrade handlers; at the plan height every node must be running it, and a node still on the previous binary halts at that height (this is the intended behaviour of the upgrade module). The manifest tells you which kind a release is: upgradeType is height for a coordinated upgrade (with upgradeHeight set) and rolling for a node-local release that can be swapped node by node. Install the new binary before the height; if your node halted first, swap the binary and restart (see the rollback note under Troubleshooting).

ReleaseMainnet qorechain-vladiTestnet qorechain-diana
v3.1.94height 2,122,074not applied
v3.2.0height 2,981,742height 5,920,000
v3.2.1node-local, no heightnode-local
v3.2.2height 3,556,788 (16 Oct 2026)height 6,905,034 (2 Oct 2026)
v3.2.3height 3,662,051 (20 Oct 2026, governance proposal 11)height 8,003,746 (15 Oct 2026)
v3.2.4height 3,742,566 (23 Oct 2026, governance proposal 13)height 8,337,253 (19 Oct 2026, governance proposal 13)
v3.2.5height 3,906,833 (29 Oct 2026, governance proposal 14)height 8,890,800 (26 Oct 2026)
v3.2.6height 4,020,000 (4 Nov 2026, governance proposal 15)height 8,970,638 (27 Oct 2026)
v3.2.7height 4,164,600 (12 Nov 2026, governance proposal 16)height 9,594,600 (6 Nov 2026, governance proposal 33)
v3.2.8not appliedheight 9,929,500 (12 Nov 2026)

What a node operator did for v3.2.4 (mainnet height 3,742,566). Governance proposal 13 named the plan v3.2.4 at height 3,742,566 (applied on 23 October 2026): nodes stayed on v3.2.3 until that height, halted there, and restarted on v3.2.4. For the next coordinated upgrade the steps are the same:

  1. Watch the manifest (https://download.qore.host/mainnet/latest.json): until it names the new release there is nothing to install, and a binary from the testnet directory is not the mainnet release.
  2. When the manifest names the release, download the archive from its binary.url, verify the sha256 (the proposal text also publishes the binary's sha256), and stage it before the height. Check GET /cosmos/upgrade/v1beta1/current_plan for the pending plan (name and height) and the current height with GET /status on the RPC.
  3. At the plan height a node still on the old binary halts (this is the intended behaviour of the upgrade module, not a failure); a node already on the new binary applies the upgrade handler and continues. If yours halted first, swap the binary and restart. After the upgrade, GET /cosmos/upgrade/v1beta1/applied_plan/v3.2.4 returns the height instead of 0 (3742566 on mainnet, 8337253 on the testnet).
  4. A node that joins mainnet now installs the release the manifest names (v3.2.7 at the time of writing; check version against minCompatible).

Transaction signing, addresses, decimals, memos and fees are unchanged by v3.2.4.

v3.2.5 on mainnet (height 3,906,833, 29 October 2026, governance proposal 14). The same steps applied: the manifest named 3.2.5 as both version and minCompatible, and a node still on v3.2.4 halted at the plan height with UPGRADE "v3.2.5" NEEDED. The fix is to install the v3.2.5 bundle (it ships qorechaind and the lib/ shared libraries together; keep them side by side) and restart; the node's state is kept.

v3.2.6 on mainnet (height 4,020,000, 4 November 2026, governance proposal 15). The same steps applied: the manifest names 3.2.6 as both version and minCompatible, and a node still on v3.2.5 halts at the plan height with UPGRADE "v3.2.6" NEEDED; install the v3.2.6 bundle and restart. Signing (sign-bytes v2), addresses, decimals, memos and fees are unchanged, and the manifest asks operators to keep the clock NTP-synchronised. GET /cosmos/upgrade/v1beta1/applied_plan/v3.2.6 returns {"height":"4020000"} on mainnet. No further mainnet upgrade is scheduled.

v3.2.7 on mainnet (height 4,164,600, 12 November 2026, governance proposal 16). The same steps applied: the manifest names 3.2.7 as both version and minCompatible, and a node still on v3.2.6 halts at the plan height with UPGRADE "v3.2.7" NEEDED; install the v3.2.7 bundle and restart. GET /cosmos/upgrade/v1beta1/applied_plan/v3.2.7 returns {"height":"4164600"} on mainnet. The upgrade switched on eleven protocol features (hybrid post-quantum multisig, a flat 2,000 gas per post-quantum verification, the EVM window event, RDK verification-key messages and several SVM address and cross-VM fixes), 101 in total. The SVM lane, the cross-VM call and CosmWasm upload and instantiate stay off on mainnet.

Read the live record with GET /cosmos/upgrade/v1beta1/applied_plan/<name> (0 = not applied) and any pending plan with GET /cosmos/upgrade/v1beta1/current_plan. v3.2.2 raised the consensus engine, Cosmos SDK (v0.53.8) and IBC dependencies, and the SDK's stricter transaction checks make that release replace the previous binary at the upgrade height rather than node by node. Transaction signing, addresses, decimals, memos and fees did not change in v3.2.2 or v3.2.3.

State sync and the clock. State sync takes its trust point from the manifest's stateSync block (trustHeight, trustHash, refreshed hourly); the RPC server it lists is the project's own, so for a production node add RPC servers you trust and check the trust hash against another source. Keep the clock NTP-synchronised: the node stops when it is more than 60 seconds out of step with the network.


Pruning and Indexing​

Tune pruning and transaction indexing to match your integration. Exchanges that need full transaction history should run with minimal pruning and a transaction indexer enabled.

Pruning (app.toml)​

# Keep recent state only — smallest disk footprint
pruning = "default"

# Keep everything — required for archive / full historical queries
# pruning = "nothing"
pruningBehaviourUse case
defaultKeeps recent state, prunes the restRPC node, balance/state lookups
nothingKeeps all historical stateArchive node, full history
customOperator-defined keep/interval valuesTuned retention

Contract runtime in v3.2.8​

A node on release v3.2.8 (testnet only until a later mainnet upgrade) needs: the whole lib/ directory of the bundle (it carries libwasmvmqore next to libwasmvm, libqorepqc and libqoresvm); a [wasm] memory_cache_size of at least 256 MiB (a smaller value is raised to 256 with a warning, so plan for the memory); and the contract code directory at <home>/wasm (an existing code directory elsewhere keeps working with a warning). A new app.toml also sets simulation_gas_limit = 50000000 and serves the JSON-RPC namespaces eth,net,web3.

Node limits (app.toml)​

From node release v3.2.1, init writes a [qorechain] section with three node-local limits. They change only what this node keeps in memory and what it puts into the blocks it proposes, never what a block must contain to be valid:

[qorechain]
# Maximum number of Cosmos transactions held in the app-side mempool (default 5000).
# When full, a new transaction that pays more per gas evicts the lowest-paying one; otherwise it is refused.
cosmos-mempool-max-txs = 5000

# Time the node may spend selecting transactions for a proposal before it proposes what it has ("0s" disables the budget).
prepare-proposal-budget = "1s"

# Stop after this many candidates in a row that do not fit in the remaining block space (0 disables the cap).
prepare-proposal-max-skips = 64

init also writes the network's EVM chain id into the [evm] evm-chain-id setting of app.toml (9801 for --chain-id qorechain-vladi, 9800 for qorechain-diana). A node whose app.toml carries a different value still starts, but logs an error at startup, and its own JSON-RPC (eth_chainId, signing against that node) answers with the wrong chain id until you correct the file; consensus is unaffected. Older binaries wrote the testnet value (9800) regardless of --chain-id, so a mainnet node initialised long ago should check this setting. Do not set QORE_EVM_CHAIN_ID to a value other than the network's: such a node refuses to start.

Transaction indexing (config.toml)​

[tx_index]
indexer = "kv"

Set indexer = "kv" (or a richer indexer) so transactions are queryable by hash and event — essential for exchanges reconciling deposits and withdrawals. Set indexer = "null" only if you do not need historical tx queries.


Exposing Endpoints for Integration​

Enable and bind the API servers integrators need in app.toml:

[api]
enable = true
address = "tcp://0.0.0.0:1317"

[grpc]
enable = true
address = "0.0.0.0:9090"

[json-rpc]
enable = true
address = "0.0.0.0:8545"
ws-address = "0.0.0.0:8546"
api = "eth,net,web3,txpool"

JSON-RPC limits in node release v3.2.4. A node running the v3.2.4 binary (testnet since 19 October 2026; mainnet since 23 October 2026) bounds its own JSON-RPC server. These are node-local settings in the [json-rpc] section of app.toml and do not affect consensus: http-body-limit (default 262144 bytes, 256 KiB; a larger request body is refused with HTTP 413 before it is read), max-concurrent-requests (default 256; requests beyond it get HTTP 503 at once) and max-open-connections (a missing or zero value now means 1000, not unlimited). In addition, the filter argument of eth_getLogs and eth_newFilter is refused when it lists more than 4 topic positions, more than 1000 alternatives in one position or more than 1000 addresses. An integrator that sends very large batched or contract-deployment requests to its own node should check that its largest request fits the body limit and raise it if needed.

The public endpoints serve the eth_, net_, web3_ and txpool_ (status only) namespaces; a node initialised by v3.2.3 or later defaults to eth,net,web3 and leaves txpool out (it publishes the node's pending transactions), so add it only if you need it. The qor_ namespace is not served by any released node build, so do not add it (see the qor_ namespace).

And the RPC listener in config.toml:

[rpc]
laddr = "tcp://0.0.0.0:26657"
EndpointPortUse for
RPC26657Broadcasting transactions, querying blocks/status
REST1317HTTP queries of chain state
gRPC9090High-throughput programmatic access
EVM JSON-RPC8545Ethereum-compatible integrations (chain ID 9801)
EVM WS8546EVM event subscriptions
SVM RPC8899Solana-compatible reads (SVM transactions are disabled)
warning

Never expose RPC, EVM JSON-RPC, or gRPC directly to the public internet without a reverse proxy, rate limiting, authentication, and a firewall. Bind to 0.0.0.0 only behind a controlled ingress layer.


Health and Sync Monitoring​

Sync status​

curl -s localhost:26657/status | jq '.result.sync_info.catching_up'
  • true — still syncing.
  • false — fully synced and serving current state.
# Latest height and network
curl -s localhost:26657/status | jq '.result.sync_info.latest_block_height, .result.node_info.network'

The network field should report qorechain-vladi (mainnet) or qorechain-diana (testnet).

Prometheus and Grafana​

The node can expose Prometheus metrics on port 26660 (set prometheus = true in the [instrumentation] section of config.toml):

http://localhost:26660/metrics

Scrape these with any Prometheus-compatible collector. If you run the Docker Compose monitoring stack, Grafana is available at http://localhost:3001 — set your own credentials on first login. Track block height lag, peer count, and resource usage; alert when catching_up stays true or peer count drops to zero.

EVM endpoint check​

curl -s -X POST http://localhost:8545 \
-H "Content-Type: application/json" \
-d '{"jsonrpc":"2.0","method":"eth_chainId","params":[],"id":1}'
# Expect "0x2649" (9801) on mainnet

Operational Best Practices​

  1. Pin the chain version. Run the release the manifest recommends (v3.2.7 on mainnet and v3.2.8 on the testnet at the time of writing), track official releases for coordinated upgrades, and keep the system clock NTP-synchronised.

  2. Run redundant nodes. Operate at least two nodes behind a load balancer so a single restart or resync does not interrupt integration traffic.

  3. Verify genesis and snapshots. Always validate the genesis SHA-256 and any snapshot checksum against the official release before starting.

  4. Protect public endpoints. Front RPC/EVM/gRPC with a reverse proxy, rate limiting, and a firewall. Never expose unauthenticated write RPC to the internet.

  5. Match pruning to need. Use pruning = "nothing" plus tx_index = "kv" for exchanges that reconcile full deposit/withdrawal history; use default for lightweight lookups.

  6. Monitor sync continuously. Alert on block-height lag, zero peers, and a node stuck in catching_up.

A node-only deployment never signs. Transactions that your integration broadcasts through it must already carry the hybrid post-quantum signature (and, for the EVM lane, the sender needs a registered key and an open authorisation window); see Exchange Integration and Post-Quantum Signing.

To observe the network without running a full node, see the Light Node documentation.


Troubleshooting​

The node stops with a clock error​

From node release v3.2.1 the consensus engine stops when the system clock is more than 60 seconds out of step with the network. Run an NTP client (chrony or systemd-timesyncd), confirm the clock is synchronised with timedatectl status, then restart the node.

A node halted before the upgrade doesn't resume after a binary swap​

If your node was already halted or stuck before you upgraded its binary, simply dropping in the new binary and restarting is not enough — the node has stale ABCI results cached from the old run and won't re-execute the block that caused the halt. Roll back explicitly before restarting:

qorechaind rollback --home <HOME>
systemctl restart <unit>

The command is qorechaind rollback (a top-level subcommand) — there is no comet rollback subcommand and no --hard flag for it.

Snapshot restore crash-loops on a missing priv_validator_state.json​

A published archive/snapshot does not include data/priv_validator_state.json, and the node refuses to start without it. If it's missing after a snapshot restore, create it — but only if it doesn't already exist. Never overwrite a real one: on a validator this file is the anti-double-signing guard, and clobbering it risks a double-sign.

echo '{"height":"0","round":0,"step":0}' > <HOME>/data/priv_validator_state.json

Next Steps​