How to mine
- Paste your Robinhood Chain addressAny EVM address you control works (MetaMask, Rabby, Rainbow, a hardware wallet…). Robinhood Chain is chain id 4663; ETH is its gas coin, and that is what the vault pays. No wallet connection, no signature: the address is only where the ETH goes. It is stored in this browser so you do not have to paste it again.
- Stake a claimDrag the wooden stake onto one of the four claims (or press 1–4). Each claim is a 24 × 24 × 12 block of 6,912 voxels with 3–5 nuggets buried in it. The claim board shows, per claim, how many miners are on it, the current difficulty, the nuggets still buried and how much of the block is dug, so you can pick a crowd or go solo.
- Pick your CPU shareThe slider (10–100%) sets how many of your cores hash. Half is a good default: the tab stays responsive and the laptop stays cool. Mining uses your CPU; you pay for the electricity, nobody else does.
- Leave the tab openPress Start digging. Each accepted proof removes one voxel from your claim (amber flash) and you watch the block get eaten in real time. Mining stops the moment the tab closes or you press stop; nothing runs in the background.
- Get paidNuggets pay instantly: dig the voxel that holds one and the vault sends that nugget's ETH to your address within about a minute (tx in the feed and on the ledger). Dust pays at ≥ 0.0005 ETH: your share of the round's 25% dust is added to your balance at the end of every hour and sent once it reaches the threshold; below that it carries over.
Before launch and whenever the pool is empty, rounds are dry: digging works, nuggets are pyrite (0 ETH), and your work only counts for the leaderboard. The vault pays only what Pons fees have actually filled.
What you are digging
The founder launches $SLUICE on Pons and forwards the Pons creator fees to the vault by public ETH transfer; every transfer is a public transaction on the vault address. Anyone can then call harvest() on the SluiceVault to split whatever arrived 80% pool / 20% infra. Every hour the settler takes a budget from the pool (up to 2 ETH), buries 75% of it as nuggets inside the four claims and keeps 25% as dust for everyone who dug.
The nugget positions come from a secret seed. Its hash is written on-chain before the round starts (commitRound) and the seed is revealed after it ends (revealRound), so the server cannot move a nugget once digging has begun. Where your proof digs is read from the proof's own hash, so nobody can aim. The rules have the exact bytes and the ledger lets you recompute any round yourself.
FAQ
Do I need to connect a wallet or sign anything?
No. You paste an address, that is all. There is no login, no session, no signature, no approval. The only wallet interaction on the whole site is the optional Harvest now button on the ledger, which sends a public harvest() call from your own wallet if you feel like paying the gas.
Do I need to hold $SLUICE?
No. Holding the token changes nothing about mining: no boost, no larger share, no access. The token's role is to generate Pons creator fees when it trades; those fees are what the vault buries.
What is a dry round?
A round with a budget of 0 ETH: before the vault exists (preview mode) or when the pool is empty at the hour boundary. The claims look and dig the same, but every nugget is pyrite (worth 0) and the dust is 0. Work in a dry round counts only for the season leaderboard. The pool refills when the next harvest() brings in fees.
Why does difficulty rise when a claim is crowded?
Each claim retargets every 30 s so that it is roughly dug out by the end of the hour. More miners on a claim means more hashrate, so the server raises the difficulty (20–48 bits) and each miner digs fewer voxels. A busy claim gets eaten fast but its nuggets are shared among many; a quiet claim is slow but yours alone. That trade-off is the game. Formula in the rules.
How do I know the server did not move a nugget?
Because it cannot: the hash of the seed that fixes every position is on-chain before the round opens, and the vault refuses any reveal that does not match it. After the reveal, open the verify box, paste the round and seed, and your browser recomputes the commitment and all positions.
Is there a GPU miner?
Optional, phase 2: a WebGPU worker (WGSL SHA-256 with a precomputed midstate) can replace the CPU workers in browsers that support WebGPU. Every GPU hit is re-verified in JavaScript before it is submitted. The message format is designed for it (64-byte prefix = one SHA-256 block).
Does it work on mobile?
Yes, with less hashrate. The game page is single-screen and the claim board becomes a horizontal strip. Phones throttle background tabs hard, so keep the screen on and the tab in front. Expect warmth and battery drain at high CPU shares.
What is the smallest payout?
0.0005 ETH, for both nuggets (no nugget is ever smaller) and dust (the balance threshold). Dust below the threshold is kept on your balance and paid later; it is never lost.
My address is a smart contract and the payout failed. Now what?
If the vault's push fails, the amount is recorded as owed[you]. Call pull() on the vault from that address to collect it.
Can a proof be stolen?
No. Your address is part of the hashed message, so a proof is only valid for the address it was found for. Each nonce counts once.
Parameters
Start values; the live ones are in the ledger and GET /api/state.
| Parameter | Value | Where enforced |
|---|---|---|
| Round length | 3,600 s, aligned to the UTC hour | server |
| Claims per round | 4 · North Bar, Bench, Bedrock, Tailrace | server |
| Claim size | 24 × 24 × 12 = 6,912 voxels | server |
| Nuggets per claim | 3 + (round mod 3) → 3 to 5 | server, replayable |
| Budget split | 75% nuggets · 25% dust | server, replayable |
| Minimum nugget | 0.0005 ETH | server, replayable |
| Dust payout threshold | 0.0005 ETH balance | server |
| Round budget | min(poolFree, maxRoundBudget); maxRoundBudget 2 ETH (owner may set 0.001–100 ETH) | vault |
| Pool / infra split | 8000 / 2000 bps (pool share can only be raised, max 9500) | vault |
| Per-round payout cap | Σ paid ≤ round budget | vault |
| Close delay | 24 h after reveal, then anyone may closeRound; 7 d after commit if never revealed | vault |
| Admin timelock | 48 h public queue for settler / infra changes and emergency withdraw | vault |
| Challenge TTL | 30 s · 8 proofs per challenge | server |
| Difficulty | 20–48 bits, per claim, retarget every 30 s | server |
| Credit per proof | 2^difficulty hash-equivalents | server |
| Nugget payout batches | every 60 s, ≤ 200 recipients per tx | server · vault |
| Fee in | founder forwards Pons creator fees to the vault by public ETH transfer; harvest() (anyone) splits what arrived | founder · vault |
| Default CPU share | 50% (10–100%) | your browser |
Risks
Not financial advice. Unaudited contracts. Nugget positions are committed on-chain before each round and revealed after it.
- Unaudited code. The vault, the server and the miner were written for this launch and have not been audited. The vault holds ETH; a bug could lock or lose it.
- The settler is trusted for honesty of the seed, not for the money. What the vault enforces: the budget comes only from the pool, a round cannot pay more than its budget, the reveal must match the commitment, ETH leaves only through
payout,withdrawInfraandpull. What it cannot enforce: that the seed was random (a dishonest settler could grind seeds before committing), that proofs are verified correctly, that dust is computed fairly, or that nuggets are paid to the right digger. The log of accepted proofs and the ledger make all of this checkable after the fact, and the ledger's verify box checks the positions, but it is a trust assumption. - The server can stop. If the server is down there are no challenges and no digging; committed budgets are not lost (they return to the pool via
closeRound), but nobody is paid until it is back. - Admin keys. The owner (deployer) can change the settler and the infra address and can queue an emergency withdrawal, each only through a 48-hour public timelock (
queue…thenexecute…, visible on-chain). The emergency withdrawal can take only from the free pool, never from a committed round budget, from ETH owed to a digger or from the infra share. The owner can also set the max round budget within 0.001–100 ETH and raise (never lower) the pool share. There is no upgrade path and nodelegatecall. - The founder forwards the fees. The vault is not wired to Pons: Pons pays the creator fees to the founder, who forwards them to the vault by plain ETH transfer, and anyone calls
harvest()to split them 80/20 into the pool. Every transfer is a public tx on the vault address, so the ledger shows exactly what came in and when. If the founder stops forwarding, the pool stops refilling and rounds go dry; nothing else changes and nothing already in the pool can be taken back except through the 48 h timelock above. Treat it as a key trust assumption. - Pool pace follows trading. There is no manual pace and no promise of volume: the vault pays only what Pons fees have actually filled. If nobody trades
$SLUICE, rounds are dry. - Your hardware. Mining uses your CPU at the share you choose, stops when the tab closes, and can run a laptop hot. Nothing is installed.
- Payout failures. A recipient that rejects ETH is credited to
owedand mustpull(). Payouts cost gas paid by the settler; if the settler runs out of gas ETH, payouts pause until it is refilled. - $SLUICE is a Pons coin. Nothing on this site is a promise about its price, and holding it gives no share of anything.
Addresses
Robinhood Chain · chain id 4663 · explorer robinhoodchain.blockscout.com. The vault and token addresses fill in from contracts.json / token.json at launch; only trust the addresses on this site, pinned on our X and Telegram.
| What | Address |
|---|---|
| SluiceVault | deploys at launch |
| $SLUICE token | drops at launch |
| Settler (commits, reveals, pays) | |
| Owner / infra (founder; forwards the fees) | |
| Pons factory (PonsV2LaunchFactory) | |
| Pons fee escrow (PonsV2FeeEscrow) |
Site sluicebox.xyz · X · Telegram · Pons launchpad