Skip to main content

Answer times

Not deployed

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​

ValueWhat kind of number
Typical answer, from the shot being mined to the answer being minedabout 1 to 3 blocks, so about 0.45 to 1.35 s of chain time on BSCBudget (see below). Not measured on BSC
Worst normal caseunder 3.5 sBudget
Service level the test enforcesp95 under 6 s, every answer under 10 sTested 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 sApp 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:

StepBudget
Shot mined in block Nt = 0
The responder learns of ita 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 itunder 10 ms. Everything is in memory; nothing is simulated, estimated or read from disk at shot time
The node accepts the transactionabout one network round trip, roughly 50 to 150 ms
Minedthe 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:

CaseWhat it checks
Single shots24 sequential shots at random timing, on the WebSocket feed: p95 under 6 s, maximum under 10 s, median under 2.5 s
Burst of 8three 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 3232 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 onlythe single-shot and burst cases with WebSocket unset (250 ms polling fallback)
Hit firstthe hit is answered under 6 s and the queued misses of that round are not sent
Backupwith 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
Restarta shot is fired while the responder is down, and the responder is started again: the answer still lands under 10 s
WebSocket dropthe 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.

ScenarioAnswersp50p95Maximum
Old responder, poll every 2 s (its default), single shots202.03 s3.04 s3.04 s
Old responder, poll every 2 s, burst of 8 pending shots243.28 s5.03 s5.03 s
Old responder, poll every 250 ms, single shots201.03 s1.05 s1.05 s
Old responder, poll every 250 ms, burst of 8 pending shots243.03 s4.09 s5.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):

CaseAnswersp50p95Maximum
Single shots, WebSocket feed241.04 s1.05 s1.05 s
Burst of 8 pending shots (3 bursts)241.15 s1.16 s1.16 s
Burst of 32 pending shots (4 sender keys)321.49 s2.01 s2.01 s
Polling only, no WebSocket (250 ms fallback)201.04 s1.16 s1.16 s
Hit square11.06 s
Backup alone (primary never started, 1.5 s delay)42.02 s2.04 s2.04 s
Backup with the primary running (the backup sent 0 transactions)41.03 s1.04 s1.04 s
Shot fired while the responder was down, then restarted11.02 s
WebSocket cut mid-test (polling takes over, then it reconnects)51.03 s1.05 s1.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):

BackendOne proofAll 64
WebAssembly, 1 thread (what one browser worker runs)about 0.5 s32.5 s sequential
WebAssembly, 2 / 4 / 8 workers17.1 s / 9.1 s / 5.2 s
Native bb binary (what the House uses)85 ms5.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.