Answer times
ZK-Sniper is not deployed on any network and has had no audit. Every number on this page comes from a test machine, not from a live game. Where a figure is a budget or a design target rather than a measurement, the page says so.
A shot is only fun to take if the answer comes back quickly. An earlier version of this game expected the hider to prove and sign each answer by hand inside a window of about 27 minutes. That was a design flaw, not a tuning problem: a person cannot be asked to answer every shot of a live game, and a sniper cannot wait minutes to learn whether a guess was a miss. The rules were changed so that answering is automatic and the window is only a safety net.
The model in one paragraph
Before a round goes live, the 64 answers (63 misses and the one hit) are already built, so nothing is proven when a shot arrives; the answer is just a transaction. Either the zk-pad responder (default) or a key held in the hider's browser tab sends that transaction the moment a shot is mined. A normal answer lands in about 1 to 3 seconds. The answer window (267 blocks, about 2 minutes by default) exists only for failures: it is how long the hider's answerer may be down before the sniper can claim the pool by timeout. See the hider guide for the two choices.
What the numbers are
| Value | What kind of number | |
|---|---|---|
| Typical answer, from the shot being mined to the answer being mined | about 1 to 3 blocks, so about 0.45 to 1.35 s of chain time on BSC | Budget (see below). Not measured on BSC |
| Worst normal case | under 3.5 s | Budget |
| Service level the test enforces | p95 under 6 s, every answer under 10 s | Tested on a local chain with 1 s blocks |
| Answer window (failure backstop) | 267 blocks by default, about 2 minutes. Minimum 67 blocks (about 30 s), maximum 28,800 blocks (about 3.6 h) | Contract constants, copied into each round |
| The app calls a shot "slow" | when it is older than 10 s | App rule |
BSC blocks come about every 0.45 s. All times in blocks move with the chain's block time.
The budget, step by step
The budget is the sum of the steps the responder takes between the shot being mined and its own answer being mined:
| Step | Budget |
|---|---|
| Shot mined in block N | t = 0 |
| The responder learns of it | a WebSocket push in roughly 30 to 150 ms, or at most one poll of 250 ms when WebSocket is not available |
| Look up the answer and sign it | under 10 ms. Everything is in memory; nothing is simulated, estimated or read from disk at shot time |
| The node accepts the transaction | about one network round trip, roughly 50 to 150 ms |
| Mined | the next block, sometimes the one after: 0.45 to 0.9 s |
That gives a typical 0.45 to 1.35 s of chain time, and under 3.5 s when one broadcast has to be retried and two blocks are missed. These are the design budget. The round trip and push figures are estimates; they have not been measured against a real BSC node.
What the budget leaves out on purpose: the sniper's own wallet and how long they take to confirm, and the web page's own refresh delay. The page measures answer time from block timestamps, so it shows the chain's view, not how long the browser took to notice.
The service level and how it is tested
The target is written into the code as two constants shared by the test, the responder's health
endpoint and the app: SNIPER_ANSWER_SLO_P95_MS = 6,000 and SNIPER_ANSWER_SLO_MAX_MS = 10,000.
The hard gate is an automated test (services/relayer/test/sniper.latency.slo.test.ts). It starts a
local chain (anvil) with 1 second blocks and a 70 million block gas limit, deploys the real game with
the real zero-knowledge verifier, builds real proofs, and starts the responder. Latency is the time
from the first sighting of the block that holds ShotFired to the first sighting of the block that
holds the answer (ShotMissed or RoundHit), polled every 20 ms. The cases:
| Case | What it checks |
|---|---|
| Single shots | 24 sequential shots at random timing, on the WebSocket feed: p95 under 6 s, maximum under 10 s, median under 2.5 s |
| Burst of 8 | three bursts of 8 pending shots in one block: every answer under 10 s, p95 under 6 s, a whole burst done in under 4 s, in at most 2 distinct blocks |
| Burst of 32 | 32 concurrent pending shots from distinct shooters: all answered under 10 s, answers spread over more than one sender key, no key above its in-flight cap |
| Polling only | the single-shot and burst cases with WebSocket unset (250 ms polling fallback) |
| Hit first | the hit is answered under 6 s and the queued misses of that round are not sent |
| Backup | with the primary never started, the backup (1.5 s delay) answers shots in under 6 s (the delay plus one block); with the primary running, the backup sends no transaction |
| Restart | a shot is fired while the responder is down, and the responder is started again: the answer still lands under 10 s |
| WebSocket drop | the socket is cut mid-test: the feed falls back to polling and answers keep coming, and the socket reconnects |
When the proof builder or anvil is missing, the file is skipped unless REQUIRE_SLO=1 is set, in
which case the missing tool is a failure, so a release check cannot pass by quietly skipping it. On
failure the test prints the raw list of latencies.
The test says what the system does on a local chain with 1 s blocks. It does not say what BSC will do. BSC blocks are faster, so the block floor is lower, but a real RPC provider adds round trips, public endpoints may throttle or refuse WebSocket subscriptions, and none of that is in the test. A deployment should measure itself: the responder publishes its own numbers (below).
Measured before and after
The first version of the responder, run in the same harness, gave these numbers. Latency is from the block that holds the shot to the block that holds its answer, on anvil with 1 s blocks, the real verifier and real proofs, on one developer machine (Apple M3 Max, Node 22). The block floor on this chain is 1 s, so about 1.0 s is the best any answer can do.
| Scenario | Answers | p50 | p95 | Maximum |
|---|---|---|---|---|
| Old responder, poll every 2 s (its default), single shots | 20 | 2.03 s | 3.04 s | 3.04 s |
| Old responder, poll every 2 s, burst of 8 pending shots | 24 | 3.28 s | 5.03 s | 5.03 s |
| Old responder, poll every 250 ms, single shots | 20 | 1.03 s | 1.05 s | 1.05 s |
| Old responder, poll every 250 ms, burst of 8 pending shots | 24 | 3.03 s | 4.09 s | 5.04 s |
Single shots were already close to the block floor once the poll was fast. The burst was the
problem: answers landed two per block, so eight pending shots took four to five seconds. The cause
was measured: the old responder called eth_call (about 20 ms) and then eth_estimateGas (about
407 ms) for every square before sending, roughly 420 ms per square, which alone caps a burst at about
two answers per second. Sending eight pre-built answers with a fixed gas limit and consecutive nonces
took about 3 ms to broadcast and all eight were mined in a single block.
The new responder removes the simulation and estimation from the shot-time path for exactly that
reason: the proofs are checked once when they are loaded (eth_call of the verifier for each of the
64), and at shot time the responder only sends the stored answer with a fixed gas limit.
The same harness, run against the final responder on 2026-10-10 (real verifier, real proofs, anvil with
1 s blocks and a 70M gas limit, same machine, REQUIRE_SLO=1):
| Case | Answers | p50 | p95 | Maximum |
|---|---|---|---|---|
| Single shots, WebSocket feed | 24 | 1.04 s | 1.05 s | 1.05 s |
| Burst of 8 pending shots (3 bursts) | 24 | 1.15 s | 1.16 s | 1.16 s |
| Burst of 32 pending shots (4 sender keys) | 32 | 1.49 s | 2.01 s | 2.01 s |
| Polling only, no WebSocket (250 ms fallback) | 20 | 1.04 s | 1.16 s | 1.16 s |
| Hit square | 1 | 1.06 s | ||
| Backup alone (primary never started, 1.5 s delay) | 4 | 2.02 s | 2.04 s | 2.04 s |
| Backup with the primary running (the backup sent 0 transactions) | 4 | 1.03 s | 1.04 s | 1.04 s |
| Shot fired while the responder was down, then restarted | 1 | 1.02 s | ||
| WebSocket cut mid-test (polling takes over, then it reconnects) | 5 | 1.03 s | 1.05 s | 1.05 s |
Reading it: answers sit at the 1 s block floor of this chain, so the responder itself is not the bottleneck (its own dispatch time is under 10 ms). A burst of 8 is answered in one block (it took four to five blocks with the earlier watcher), and a burst of 32 spread over 4 sender keys is answered in one to two blocks. The polling-only path meets the same bounds as the WebSocket path. These are local-chain figures, not BSC.
Many shots at once
Each answer is about 2.37 million gas (a miss; a hit is about 2.39 million), measured. The BSC block gas limit is currently 70 million (queried on 2026-10-09), so one block holds about 29 answers. If all 63 misses were pending at the same time they would need about 149 million gas, that is about 3 blocks, not one. The 67-block minimum window covers that, but the claim "answered in the next block" does not hold for a very large burst. The responder spreads a burst across several sender keys and caps how many transactions each key has in flight, because public nodes limit how many pending transactions one account may have.
Proving takes place before the round, not during it
Building the 64 proofs is the slow part, and it happens before createRound is sent. Measured in
Node on one developer machine (Apple M3 Max):
| Backend | One proof | All 64 |
|---|---|---|
| WebAssembly, 1 thread (what one browser worker runs) | about 0.5 s | 32.5 s sequential |
| WebAssembly, 2 / 4 / 8 workers | 17.1 s / 9.1 s / 5.2 s | |
Native bb binary (what the House uses) | 85 ms | 5.2 s sequential, 1.9 s with 8 parallel processes |
Each extra WebAssembly worker costs about 400 to 500 MB of memory in these measurements, which is a real risk on phones. Proof times in a browser tab and on a phone have not been measured. Treat the Node numbers as a floor, expect seconds to a few minutes depending on the device, and read the progress screen: the app estimates the time left from the first proofs it finishes instead of promising a number in advance. Proofs are 7,232 bytes each; all 64 are about 0.9 MB as an upload.
How the sniper app shows it
The rules the page follows:
- A shot you fired is a spinner ("Waiting for the hider's proof") for its first 10 seconds. There is no countdown and no deadline shown in that time, because a deadline would suggest the answer is late when it is not.
- When the answer arrives the row says what was measured: "Answered in 1.8 s". If the chain gives block times only in whole seconds (a local test chain), it says "about 1 s".
- A shot still unanswered after 10 s is marked Slow, with a countdown to the point where, if no proof ever arrives, you could claim the pool by timeout. That claim is a failure path, not a plan: see Economics.
- Age is counted on the block clock (the newest block's timestamp minus the shot's block timestamp), not on the browser's clock.
- The round shows an "Answer time" tile (median and 95th percentile) once it has at least 3 answers.
The responder publishes its own numbers
The responder serves GET /v1/sniper/health without authentication. It returns, among other things,
whether it is ready, whether it is on WebSocket or polling, how many rounds it holds, its senders'
balances and whether any is low, whether its peer is up, and a
latency block over the last hour: median, 95th percentile and maximum of chain time, the
responder's own dispatch time, and a count of answers over 10 s. It never returns proofs, squares or
round lists. The app reads it, and so can anyone else: a bot can see an outage there just as an
operator can, which is part of the outage risk.
ok in that response is false when the responder is not ready, its newest block is more than 5 s old,
a sender wallet is low, the 95th percentile of the last answers is over the 6 s target (with at least 5
answers), or any answer in the last hour took over 10 s.
What this does not promise
- No measurement on BSC. The service level is tested on a local chain with 1 s blocks.
- No guarantee for a single shot. An RPC failure, a validator that skips a transaction, a spike in gas price or a bug can delay one answer. The answer window is the backstop for that, and a timeout is the exceptional outcome, not a service the sniper can rely on.
- No promise about how long proofs take to build on any particular phone.
- A responder cannot answer faster than a block. On BSC that is the floor.
Related
- Playing as the hider: choosing who answers, preparing proofs, the session key
- How ZK-Sniper works: answer window and timeout
- Security model: the responder