Blockchess brings absolute skin in the game to fully on-chain chess on Polygon. Every single move demands real capital, collateralized in native POL or allowlisted ERC-20 tokens — no custom project tokens. You are no longer just shuffling pieces; you are committing pure liquidity to prove your technical and tactical edge.

Game economics are governed by cold math: Linear, Compound, or Flat wagering curves scale move costs up to a 10x cap from the base stake. As the match deepens into the middlegame and endgame, a single blunder or hallucination becomes ruinously expensive. Every turn forces you to financially back your conviction — or fold the board.

This is the ultimate stress test for algo-traders, builders, and degens. Mistakes bleed real capital, and victory belongs solely to whoever maintains a cold, calculated advantage under mounting financial pressure.

Blockchess is engineered with zero server primitives — no API routes, server actions, or centralized middleware. Every rule of chess, including move validation, castling, en passant, pawn promotion, the 50-move rule, threefold repetition, checkmate, and stalemate, is verified atomically inside the Polygon PoS smart contract. The frontend is merely an optional presentation layer; the entire state engine runs completely on-chain without intermediate backends or trusted oracles.

Even if the website, domain, or hosting infrastructure disappears, the protocol remains completely autonomous for as long as the Polygon network produces blocks. Every match can be created, played, and finalized directly via raw RPC calls or command-line tools. For step-by-step instructions on bypassing the interface, see the Interact without UI section below.

Real-money chess is fundamentally broken by stealth engine assistance. In a decentralized environment, attempting to enforce anti-cheat detection is pure security theater — an EVM smart contract cannot distinguish a human cursor click from an automated RPC payload. Blockchess strips away this false pretense entirely. Instead of waging a futile arms race against automation, the protocol legalizes bots as native actors, converting on-chain chess into a fully transparent, unfiltered algorithmic battleground.

We explicitly invite developers, quant traders, and degens to weaponize their code. Hook up Stockfish, deploy autonomous agents, or execute custom strategies in raw, permissionless financial combat. The underlying infrastructure is completely open to any script, bot, or smart contract — if your algorithm can evaluate the board state and collateralize its conviction, the protocol will process the move without bias.

From a game-theoretic perspective, the stake-per-move model introduces a dynamic escalation of commitment. In the opening phase, positional entropy is high and move costs are minimal; as the middlegame unfolds and positional information converges, the price of every subsequent action steadily rises. Participants pay not for a hypothetical endgame outcome, but for the immediate right to sustain their line in the current position — forcing both human operators and autonomous agents to ruthlessly re-evaluate positional edge against compounding capital friction under escalating financial pressure.

Frontends are unprivileged clients. Anyone can build a custom UI, bot, or aggregator and monetize traffic permissionlessly. When spawning a table through the factory, you set your frontendRecipient address and choose your own referralFeeBps fee rate — capped at a hardcoded 5% (500 bps) strictly enforced on-chain and frozen permanently for that match.

Upon game resolution, your cut is automatically skimmed from the pot into your balance for instant extraction via withdraw(). No off-chain accounting, no manual claims, no permission needed. You drive the volume, pick your cut up to the 5% cap, and let protocol math execute the settlement.

Duel Mode: Either player can propose a move takeback (proposeTakeback) or a minimum stake hike (proposeStakeIncrease), requiring strict bilateral consensus. An active proposal hard-locks the board — freezing all moves until the opponent explicitly accepts or rejects. For grief-protection, the initiator can cancel at any time, and a 24-hour timeout allows anyone to permissionlessly clear a ghosted proposal so funds never remain trapped.

Crowd Mode: Takebacks and stake increases transition to dual-sided, stake-weighted governance where voting power is proportional to each backer's deposited capital. Proposals require a >50% stake-weight majority on both sides to pass — not a raw headcount. The contract short-circuits dynamically: if remaining uncast stake makes reaching a majority mathematically impossible on either side, the proposal auto-fails immediately without waiting for the clock. Unresolved votes hard-expire after 24 hours.

ChessGameFactory              0x532408070454D13ED7Ef142fb0Fb86247ea3d7E0
ChessEloRegistry              0xFf8AC12617793a41a9Bf392971300F5cbE41e534
ChessGameTable (implementation) 0xEea851487Aacc9FC430a22e7D34Fd6A9bD2eb950

status()(uint8)                                  0=Active, 1=Finished
mode()(uint8)                                    0=Duel, 1=Crowd
whiteToMove()(bool)
whitePlayer()(address) / blackPlayer()(address)
colorOf(address)(uint8)                          0=None, 1=White, 2=Black
board()(uint256)                                 packed position, 4 bits/square
plyCount()(uint32) / pot()(uint256) / currentStake()(uint256)
contribution(address)(uint256)                   Crowd only — your stake on either side
claimableActions()((bool,bool,bool,bool,bool))   checkmate, stalemate, fiftyMoveRule, threefoldRepetition, timeoutVictory
withdrawable(address)(uint256)

makeMove(uint8,uint8,uint8)   from, to, promo · promo: 0=none 2=N 3=B 4=R 5=Q · a1=0 ... h8=63 · castling = 2-square king move
resign()
claimCheckmate() / claimStalemate() / claimFiftyMoveRule() / claimThreefoldRepetition()
claimTimeoutVictory()          permissionless — anyone can call
proposeTakeback() / acceptTakeback() / rejectTakeback() / cancelTakeback()                    Duel
proposeStakeIncrease(uint256) / acceptStakeIncrease() / rejectStakeIncrease() / cancelStakeIncrease()   Duel
voteOnGroupProposal(bool) / cancelGroupProposal()                                             Crowd
claimShare()                   Crowd, after game ends
withdraw()
recordResult(address)          on ChessEloRegistry, permissionless

Example indexer implementation: github.com/bird238/blockchessindexer