Six Months Building Block 52: A Build Log

Building a provably fair poker platform is not one project. It is three that have to move in lockstep: the client players actually touch, the game engine that decides what is legal, and the chain that settles the money. Over the first half of 2026 we open-sourced the client, migrated our settlement layer to Ethereum mainnet, replaced our card shuffle with verifiable randomness, shipped real-money tournaments, and rebuilt our entire transport around a WebSocket-first "optimistic gateway." This is the build log.

Three Repositories, One Product

Everything at Block 52 lives across three codebases, and it helps to name them up front because the rest of this article moves between them constantly:

• UI The front-end client — the table, the wallet, deposits and withdrawals, the tournament lobby. Everything a player sees.
• PVM The Poker Virtual Machine — the off-chain game engine that owns the rules. It decides whose turn it is, what actions are legal, who wins the pot, and what a tournament pays out.
• Chain The blockchain layer — a Cosmos-based chain that handles deposits, withdrawals, on-chain state, and final settlement. It is the source of truth for money.

A single feature — say, a Sit & Go payout — touches all three: the UI shows the prize ladder, the PVM computes who finished where, and the chain moves the funds. The story of the last six months is really the story of getting those three layers to agree on who is responsible for what.

January — Foundations and a Single Source of Truth

Jan 2026

The year opened with cleanup that paid off for the rest of it. Across the PVM and chain we did a data-model consolidation: game_type became game_format, a separate game_variant field was introduced, and the definitions were unified across the protobuf schemas, the TypeScript SDK, and every API response so there was exactly one source of truth. On the chain, we shipped a deterministic deposit-sync architecture keyed to a stored Ethereum block height — and fixed a genuinely nasty bug where non-deterministic ETH RPC calls in EndBlock could split validators and halt the chain.

On the engine side we pushed early Sit & Go and tournament support, added fuzzing, and began a multi-variant refactor to make room for Omaha alongside Texas Hold'em. We also enforced determinism by ripping Date.now() out of the PVM — a shuffle you want to prove fair cannot depend on the wall clock. The UI, meanwhile, integrated NOWPayments for multi-crypto deposits and consolidated its sprawl of modals and hooks into a shared structure.

February — Going Open Source and Moving to Mainnet

Feb 2026

February was a big month for direction. We open-sourced the Block 52 UI — public repo, CI/CD for lint, build, and test, and a large styling standardization pass that moved inline styles into CSS Modules with documented visual-parity checks. The deposit and withdrawal modals were rebranded, USDT support and QR-encoded payment amounts landed, and the product was renamed throughout from its old "Cosmos" working name to Block 52.

The headline infrastructure change was migrating our settlement currency from Base-chain USDC to Ethereum-mainnet USDC. That rippled across the proxy, the bridge, and the UI, and came with a hard-nosed reliability push: async IPN handling, gas pricing, transaction timeouts, environment validation, and a manual bridge admin endpoint for when things go wrong. We also codified a strict typing discipline the team still refers to as the "12 Commandments of Types," and used it to sweep out fallback defaults, Wei-conversion hacks, and legacy Base references — standardizing on 6-decimal micro-USDC everywhere.

March — Hardening the Engine, and NFT Avatars

Mar 2026

March was a hardening month for the PVM. We ran a focused campaign on the ugliest corners of poker rules: dealing hole cards to all-in players who had posted blinds, guarding the winner calculation against undefined cards, busting sub-small-blind stacks correctly, and rounding rake to the nearest blind to eliminate dust. We also chased down a game that could lock up at the end of the very first hand. On the platform side, we upgraded to Cosmos SDK v0.53.6 and CometBFT v0.38.21 and spent real effort resolving a persistent AppHash divergence at block 150 — the kind of consensus bug that only shows up in production and only under load.

Player-facing, the marquee feature was NFT avatars, delivered end to end: on-chain registration via ETH signatures, protobuf and SDK support on the chain, and a polished selection modal with local caching in the UI. The UI also shipped hand replay and sharing — a visual replay page with "Share on X" and QR codes — plus a stage-geometry engine that auto-fits 2-, 6-, and 9-max table layouts.

April — Tournaments, Managers, and a Poker Solver

Apr 2026

April was the busiest month of the half, and it had three distinct threads. First, Sit & Go tournaments became a real product: chip-based blind selectors, blind-level countdown timers, chip-denominated betting distinct from USDC, and mobile-responsive auto-join. Second, we refactored the PVM's internals into a clean manager architecture — extracting PotManager, RakeManager, SidePotManager, and a showdown evaluator into injectable, interface-driven components behind a format factory. This is the plumbing that lets cash games and tournaments share an engine while behaving differently where they must.

Third, and most fun: we built a poker solver from scratch in Go. A native Cactus Kev hand evaluator, range-vs-range board equity, and a CFR-based solver working across the 1,755 canonical flops, wired into our Telegram bot so it plays chart-driven poker instead of flipping a coin. On the chain, the first stage of our verifiable-randomness initiative landed — a VRF wrapper with a bias-free shuffle — setting up the big May push.

May — Verifiable Randomness Goes Live

May 2026

May's defining achievement was completing the multi-part VRF consensus work on the chain, replacing the legacy block-hash shuffle with proposer-side verifiable randomness. The seed is generated in PrepareProposal, verified in ProcessProposal, and the deck seed is recorded and checked as part of consensus — with VRF transactions injected as system transactions that bypass the normal ante and are locked down so nothing else can forge them.

Alongside VRF, tournaments matured into a settleable product. The chain gained on-chain prize payouts, entry-fee skimming to the table creator, validator-signed NFT claim signatures for winners, and a MsgForceCloseGame that lets a creator close a cash table and refund everyone. The PVM finalized Sit & Go payout math and fixed a class of min-raise and heads-up all-in edge cases, while the UI shipped the result modal, the payout-positions panel, and a reliability pattern that holds action spinners until the chain actually confirms. Under the hood we benchmarked Bun against Node and moved the production RPC server to Bun.serve.

June — The Optimistic Gateway

Jun 2026

June was an architectural turning point. We introduced the optimistic gateway: a WebSocket-first transport where player actions are signed on the client, relayed over WebSockets for fast play, and settled to the chain behind the scenes — making the chain the opt-out path rather than the hot path for every keystroke. On the chain, this meant a new Go WebSocket gateway with per-viewer state masking (the deck is always hidden, your hole cards are yours alone), Redis-backed persistent state, real PVM-backed action application, and a settlement relay that forwards signed transactions to the chain.

Critically, money-movers — deposits, withdrawals, buy-ins — were deliberately kept on the direct-to-chain path. Speed where it is safe, chain where it matters. In parallel we began porting the engine to Go for the gateway's needs, validated against a parity corpus so the Go and TypeScript engines agree action for action. The UI got a matching optimistic-transport layer and a visible banner when gateway mode is active, plus a performance campaign that split its game-state context into slices and killed redundant polling to stop full-tree re-renders.

July — Trustless Settlement and the Action Bus

Jul 2026

July was about making the new architecture trustworthy and making the client keep up. On the settlement side we converged on a trustless, unordered, serially-drained model: a settlement drain worker on the gateway with no-drop retry of recoverable rejects, resync on sequence mismatch, and unordered signing in the SDK so transactions no longer depend on a fragile account-sequence counter. The chain became the authoritative settlement layer for tournaments by delegating result computation entirely to the PVM — a new MsgRecordHandEnd pushes hand-end state to the chain, which now settles purely from PVM-authored results and no longer runs its own payout math.

In the UI, we rebuilt event handling around a WS Action Bus — a message bus with paced draining, backpressure, and animation-acknowledgment gates so the table stays in sync even when the socket delivers frames out of order or in bursts. Sit & Go got a dedicated claim-winnings flow reading authoritative payouts, and we stood up a local PVM-stub backend with a Playwright gameplay suite on CI. On the engine, we deprecated and removed the ALL_IN action entirely: a shove is now just a raise for a player's whole stack, with "all-in" treated purely as a front-end label — a small change that deletes a whole category of edge cases.

The Arc of the Half

Step back and the six months trace a clear line. We started with an open-sourced client on Base-chain USDC and a monolithic request/response transport. We finished on Ethereum mainnet, with verifiable VRF-backed shuffling, real-money Sit & Go tournaments settled trustlessly on-chain, and a WebSocket-first architecture where the PVM is the authoritative game engine and the chain is a clean settlement backstop.

The consistent theme was drawing sharp lines of responsibility between the three layers — the client presents, the PVM rules, the chain settles — and then rebuilding the connections between them so each does its job and nothing else. That is not glamorous work. But it is exactly the work that lets us make the one promise that matters: every hand is provably fair, and you don't have to take our word for it.