When the Answer Goes Missing
You buy something from Petru. The server spends the coins and puts the item in your bag. Then your connection closes before the answer reaches you.
Did the purchase fail? Not necessarily. Did it succeed? The client doesn’t know yet. Pressing the button again mustn’t turn that uncertainty into a second purchase.
This second networking post is about correctness when the wire goes quiet. The first explained movement prediction; this one concerns consequences that must survive a lost reply.

An offline scene using current game assets, not evidence of a reconnect or load test.
A timeout means we don’t know
Vatra’s connection adapter distinguishes a confirmed outcome from an unknown one. When a command times out or its connection ends, it reports uncertainty. It doesn’t tell the game that the server definitely refused the action.
There are two different identifiers involved. A transport request number matches a reply on the current connection. An application request key identifies the intended operation across retries. Reconnecting resets transport numbering; it mustn’t invent a new purchase intention for an unresolved old one.
For receipt-backed commands, the server looks up the application key together with the actor’s identity. A repeated key returns the recorded outcome instead of running the operation again. That includes recorded failures: retrying a refused command doesn’t silently turn it into a fresh attempt after circumstances change. A genuinely new attempt needs a new key.
The useful guarantee is narrow: the receipt-backed operation is applied at most once for that actor and key. It isn’t a blanket claim of exactly-once network delivery, and movement uses its own sequence contract rather than purchase receipts.
Amazon’s Making retries safe with idempotent APIs is a good explanation of why identifying caller intent matters more than merely repeating the same-looking message.
Reconnect means rebuild the picture
A stale screen isn’t a reliable account of what happened while a client was away. After authentication, subscriptions supply an initial snapshot before the connection becomes ready. Typed caches and their consumers handle that replacement state, including removals, rather than treating every returning row as a brand-new reward or event.
Identity also matters. Reconnecting as the same authenticated actor allows the server to find the relevant character and receipts; creating an unrelated identity isn’t recovery. Ordinary disconnects currently leave the client waiting for an explicit Reconnect action, not an invisible automatic reconnect loop.
We also avoid treating a changed position as proof of corruption. If a character died and respawned during the gap, the spawn point can be the correct result. A useful recovery test must check the character and gameplay context, not just compare two coordinates.
A trade reserves before it transfers
A trade offer can’t spend the same coins or items somewhere else while the other player considers it. Vatra tracks reservations separately from balances and quantities. Settlement transfers the agreed resources through the authoritative economy path; cancellation releases what was reserved.
Disconnect handling cancels the relevant open trades and releases their reservations. The audit question isn’t simply whether both players can reconnect. It’s whether every remaining reservation still belongs to a real open offer, and whether balances and item totals agree with the economy ledger.
Nor is hiding a panel a privacy boundary. Private economy and party data are reached through identity-scoped server views. Clients receive the permitted projection; the interface isn’t responsible for keeping an already-downloaded secret.
The digits have to survive too
One surprisingly practical networking problem is large integers. Some JSON number paths cannot represent every 64-bit integer exactly. Our wire adapter retains raw row strings, and schema-bound decoders preserve the full decimal value where needed. A rounded identifier can point at the wrong thing; a rounded balance is not cosmetic.
What we’ve tested, and what that proves
The September 13, 2026 network checks used real native and browser clients with roughly 130-millisecond round-trip shaping, jitter, delay spikes and forced disconnects. The corrected desktop run recorded seven clean reconnect cycles; the browser recorded three. Inventory, wallet, party, quest and reservation audits passed in those test worlds.
These are historical measurements of a specific build, not certification of every later change. The shaping used delayed traffic over TCP, not a simulation of arbitrary UDP packet loss. Android evidence came from an emulator, not a physical phone. New schema and combat changes still need their own checks.
The standard remains simple: smooth walking doesn’t excuse duplicated supplies, lost committed progress or a trade that leaves somebody’s bag locked.
In the implementation
- Explicit unknown outcomes and actor-scoped receipts for safe application retries.
- Authenticated reconnect snapshots, not blind reuse of stale caches.
- Trade reservations, disconnect cleanup and ledger-based audits.
- Identity-scoped private views and lossless handling of large decimal values.