Run a mainnet-beta node

Join the Bloch-SIS-PoW mainnet beta.

This page walks you through building and running a node of the ownerless Bloch-SIS-PoW protocol on its mainnet beta — as a relay, or as a solo miner. The network is nascent and unaudited, and its coins carry no value claim. You are helping run and harden experimental post-quantum PoW research, nothing more.

Read before running anything

Mainnet beta — a designation, not a security claim. The relaxed regime (k=4) currently applies — work is trivially forgeable. The k=8 security hardening of the Module-SIS gate was activated at block 213,000 but reverted: it multiplied mining difficulty ~4096x and the current solo / low hashrate could not find blocks, so the chain stalled. k=8 will re-activate together with a matched difficulty reduction (so block time stays ~30s); until then, no security is claimed. Security is cumulative SHAKE-256 hashcash work; the gate is a structural filter (k=4 today; k=8 on re-activation).
Very few nodes, low hashrate → 51%-attackable. The software is unaudited: a third-party audit is contracted but not done yet, and the concrete-security analysis and IACR ePrint are still outstanding.
The coin is not a security and not an asset. No token sale, no listing effort, no market-making, no price — no value claim. Disclosed in full: a 17% founder premine (10-year cliff, 40-year vest), structurally passive. Full disclaimer.
Run it to evaluate, strengthen, break, and report — not as an investment. Use at your own risk.

Step 1 · Get the source

Clone the protocol repository.

The protocol is not a Postern Labs product and has no official website. It lives in its own ownerless repository — rendered as text on purpose, because the protocol has no official site to link to and this site will not invent one:

gitlab.com/blochsispow-group/BlochSISPoW-project

# Prefix the path above with your git host scheme of choice, then:
git clone <the repository above> bloch
cd bloch

Prerequisites: a Rust toolchain (rustup, stable), plus a C toolchain — clang, cmake, pkg-config — needed by RocksDB, blst, and the PQClean-based crypto crates.

Step 2 · Build

One command, one binary (plus friends).

cargo build --release

Binaries land in target/release/: bloch (the full node), bloch-cli (an RPC client, like bitcoin-cli), and bloch-wallet. Verify the build with cargo test if you like — the suite should pass.

Step 3 · Run a relay node

A non-mining node that validates and relays.

./target/release/bloch --testnet \
  --data-dir ./bloch-data \
  --listen /ip4/0.0.0.0/tcp/16110 \
  --rpc-bind 127.0.0.1 --rpc-port 16210

Always pass --testnet. The flag name is historical: it selects the live network — the chain now designated mainnet beta, which launched under this flag and keeps its network selection until a release renames it. A node started without the flag selects a different network that nobody is running. The flag does not change the PoW regime: the relaxed k=4 regime currently applies either way — the k=8 hardening was activated at block 213,000 but reverted, and will re-activate with a matched difficulty reduction.

The flags shown are also the defaults (except --testnet), spelled out so you can change them deliberately:

--data-dir: Where the chain lives: RocksDB block/UTXO storage, the persisted known-peers list, and node identity keys. Default ./bloch-data, relative to where you launched the node. Delete it to start fresh.
--listen: The libp2p P2P multiaddr your node accepts peers on. Default /ip4/0.0.0.0/tcp/16110. This is the address other testers will use to bootstrap from you.
--rpc-bind / --rpc-port: JSON-RPC over HTTP. Defaults to 127.0.0.1:16210 — local only, on purpose. Exposing RPC publicly (--rpc-public) is dangerous when unauthenticated; if you must, set --rpc-api-key.
Ports: 16110/tcp P2P · 16111/tcp P2P WebSocket · 16210/tcp RPC (keep local) · 16310/tcp Prometheus metrics (only with --metrics).

Step 4 · Or run a miner

Solo-mine on the mainnet beta.

./target/release/bloch --testnet --mine \
  --data-dir ./bloch-data \
  --listen /ip4/0.0.0.0/tcp/16110

Adding --mine makes the node brute-force Module-SIS solutions (in the relaxed k=4 regime that currently applies — the k=8 hardening was reverted and will re-activate with a difficulty fix) and attach the solution vector as each block's PoW witness. Mining is solo only: Stratum V1/V2 pool mining is disabled because the hash-PoW share protocol has no field for a lattice solution vector — a SIS-native pool protocol is future work.

To be blunt about the economics: the coins you mine carry no value claim — no price, no market, no listing — on a nascent, low-hashrate network that is 51%-attackable, and under the relaxed k=4 regime that currently applies the work itself remains trivially forgeable (the k=8 hardening was reverted; it will re-activate with a matched difficulty reduction). Mine to exercise the machinery and add hashrate to a young network, not as an investment.

Step 5 · Check it's alive

Query the node over RPC.

# with the bundled CLI (defaults to 127.0.0.1:16210):
./target/release/bloch-cli getnetworkinfo
./target/release/bloch-cli getblockcount

# or raw JSON-RPC over HTTP:
curl -s -X POST http://127.0.0.1:16210/ \
  -H 'content-type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"getnetworkinfo","params":[]}'

getnetworkinfo reports version, network (current builds still report the legacy string testnet for the live mainnet-beta chain — a rename ships in a later release), peer count, and sync state. Other read methods include getblockcount, getdaginfo, getmempoolinfo, getpeerinfo, getblockbyheight, and getbalance. Optional Prometheus metrics: add --metrics and scrape 127.0.0.1:16310.

Step 6 · Peering

Every node is a seed. No node is privileged.

The shipped seed list is empty — literally DEFAULT_SEEDS = [] in the source. That is the ethos, honestly applied: no foundation-run bootstrap servers, no DNS seeds yet (a TODO in the code), no node with a special role. The flip side, stated just as honestly: your node will sit alone until you give it a peer.

Bootstrap by supplying the multiaddr of any node already on the network — a friend's, one from a forum thread, or your own second machine:

./target/release/bloch --testnet \
  --peer /ip4/203.0.113.7/tcp/16110 \
  --peer /dns4/some-bloch-peer.example/tcp/16110

The address you dial is simply the other node's --listen address as seen from your side of the network. --peer repeats; DNS names are resolved. Once connected, peer exchange (PEX) takes over: your node learns more peers, persists them in the data dir, and redials them on restart — after the first contact, your node is a seed for the next person. For LAN or single-machine experiments, add --allow-private-peers so RFC1918/loopback addresses are accepted.

No peer to dial? Then start an island: run one miner and one relay pointing at each other. On a network this young — very few nodes, stated plainly — every new peer measurably matters.

Alternative · Docker & Fly.io

Containerized, if you prefer.

The repository ships a Dockerfile (digest-pinned base images, non-root user, core dumps disabled) exposing 16110, 16111, 16210, and 16310. Build and run from the repo root:

docker build -t bloch-sis .

docker run -d --name bloch \
  -p 16110:16110 -p 127.0.0.1:16210:16210 \
  -v bloch-data:/bloch-data \
  bloch-sis \
  --testnet \
  --rpc-bind 0.0.0.0 --rpc-port 16210 \
  --listen /ip4/0.0.0.0/tcp/16110 \
  --data-dir /bloch-data

Inside the container RPC must bind 0.0.0.0 to be reachable; the -p 127.0.0.1:16210:16210 mapping keeps it local to your host. Add --mine to the arguments to mine, and --peer <multiaddr> to bootstrap.

The repo also carries a fly.toml for Fly.io (it runs the node with --testnet --mine on a persistent volume). From the repo root:

flyctl launch --copy-config --no-deploy   # first time: creates the app
flyctl volumes create bloch_data --size 30 --region <your-region>
flyctl deploy

See deploy/fly/README.md in the protocol repo for the full walkthrough — and remember what the machine will be doing: mining coins that carry no value claim, on unaudited mainnet-beta research software.

What to do with what you find

Break it, then tell everyone.

Useful contributions, in rough order of value: attacks on the Module-SIS PoW design (even on-paper, against the canonical regime), consensus and reorg edge cases, difficulty (ASERT-Lattice) manipulation, IBD and networking failures, build failures on your platform. File issues in the protocol repository — publicly, since there is no private steward to whisper to.

One last time

Mainnet beta — unaudited. The relaxed regime (k=4) currently applies — work is trivially forgeable. The k=8 security hardening was activated at block 213,000 but reverted (it multiplied mining difficulty ~4096x and the low-hashrate chain stalled); it will re-activate together with a matched difficulty reduction. Until then, no security is claimed. Very few nodes / low hashrate → 51%-attackable. Not a security, not an asset — no sale, no listing, no price. 17% founder premine disclosed. You are running research, not joining an economy. If anyone tells you otherwise, they are not us — the disclaimer wins.