Contract Address Details

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.28;

import {Hand, Action, CannotCheck, NothingToCall, FacingABet, OpponentAllIn,
        BadAmount, BetBelowMin, NotReopened, RaiseTooSmall, BetTooLarge,
        RaiseBelowMin, BadParam} from "../GameTypes.sol";

/// @title BettingLib — heads-up NLHE betting transitions
/// @notice The exact on-chain mirror of web/js/betting.mjs (the executable
///         betting spec, cross-checked by shared vectors and integration
///         tests). Deployed as an external library to keep the main contract
///         under the EIP-170 size limit.
library BettingLib {
    uint8 internal constant OUT_TURN = 0;    // turn passed to opponent
    uint8 internal constant OUT_CLOSED = 1;  // street closed
    uint8 internal constant OUT_FOLDED = 2;  // actor folded (street closed too)

    /// @notice Initialize per-hand betting state and auto-post the blinds.
    function initHand(Hand storage h, uint8 btn, uint32 sbChips, uint32 bbChips) public {
        h.btn = btn;
        h.folded = 255;
        h.riverAggressor = 255;
        h.pendBy = 255;
        h.board = [255, 255, 255, 255, 255];
        h.inc = bbChips;
        h.reopen = true;
        h.bbOption = true;
        h.street = 0;
        uint8 opp = 1 - btn;
        uint32 sbPost = _min32(sbChips, h.stack[btn]);
        uint32 bbPost = _min32(bbChips, h.stack[opp]);
        h.stack[btn] -= sbPost;
        h.streetBet[btn] = sbPost;
        h.stack[opp] -= bbPost;
        h.streetBet[opp] = bbPost;
        h.currentBet = sbPost > bbPost ? sbPost : bbPost;
        h.toAct = btn;
        h.firstToAct = btn;
        if (_shouldAutoClose(h)) closeStreet(h);
    }

    /// @notice Apply one betting action for seat `me`; reverts if illegal.
    /// @return outcome OUT_TURN / OUT_CLOSED / OUT_FOLDED
    function applyAction(Hand storage h, uint8 me, Action action, uint32 amount, uint32 bbNominal)
        public returns (uint8 outcome)
    {
        uint8 opp = 1 - me;
        uint32 facing = h.currentBet - h.streetBet[me];
        if (h.street == 0 && me == 1 - h.btn) h.bbOption = false; // BB is acting

        if (action == Action.FOLD) {
            h.folded = me;
            closeStreet(h);
            return OUT_FOLDED;
        }
        if (action == Action.CHECK) {
            if (facing != 0) revert CannotCheck();
            if (me != h.firstToAct) {
                closeStreet(h);
                return OUT_CLOSED;
            }
            h.toAct = opp;
            if (_shouldAutoClose(h)) { closeStreet(h); return OUT_CLOSED; }
            return OUT_TURN;
        }
        if (action == Action.CALL) {
            if (facing == 0) revert NothingToCall();
            uint32 pay = _min32(facing, h.stack[me]);
            h.stack[me] -= pay;
            h.streetBet[me] += pay;
            // preflop limp: BB is still owed the option to check or raise
            if (h.street == 0 && me == h.btn && h.bbOption) {
                h.bbOption = false;
                h.toAct = opp;
                if (_shouldAutoClose(h)) { closeStreet(h); return OUT_CLOSED; }
                return OUT_TURN;
            }
            closeStreet(h);
            return OUT_CLOSED;
        }
        if (action == Action.BET) {
            if (h.currentBet != 0) revert FacingABet();
            if (h.stack[opp] == 0) revert OpponentAllIn();
            if (amount == 0 || amount > h.stack[me]) revert BadAmount();
            if (amount < bbNominal && amount != h.stack[me]) revert BetBelowMin();
            h.stack[me] -= amount;
            h.streetBet[me] = amount;
            h.currentBet = amount;
            // short all-in bet does not reopen raising for the opponent
            if (amount >= bbNominal) { h.inc = amount; h.reopen = true; }
            else { h.reopen = false; }
            if (h.street == 3) h.riverAggressor = me;
            h.toAct = opp;
            if (_shouldAutoClose(h)) { closeStreet(h); return OUT_CLOSED; }
            return OUT_TURN;
        }
        if (action == Action.RAISE) {
            if (h.currentBet == 0) revert FacingABet();
            if (!h.reopen) revert NotReopened();
            if (h.stack[opp] == 0) revert OpponentAllIn();
            if (amount <= h.currentBet) revert RaiseTooSmall();
            uint32 newMoney = amount - h.streetBet[me];
            if (newMoney > h.stack[me]) revert BetTooLarge();
            uint32 minTo = h.currentBet + h.inc;
            bool isAllIn = newMoney == h.stack[me];
            if (amount < minTo && !isAllIn) revert RaiseBelowMin();
            h.stack[me] -= newMoney;
            h.streetBet[me] = amount;
            if (amount >= minTo) { h.inc = amount - h.currentBet; h.reopen = true; }
            else { h.reopen = false; } // short all-in raise: call/fold only
            h.currentBet = amount;
            if (h.street == 3) h.riverAggressor = me;
            if (h.street == 0) h.bbOption = false;
            h.toAct = opp;
            if (_shouldAutoClose(h)) { closeStreet(h); return OUT_CLOSED; }
            return OUT_TURN;
        }
        revert BadParam();
    }

    /// @notice Open the next street's betting round (after a board reveal).
    function openStreet(Hand storage h, uint32 bbNominal) public {
        h.currentBet = 0;
        h.inc = bbNominal;
        h.reopen = true;
        h.firstToAct = 1 - h.btn;
        h.toAct = h.firstToAct;
    }

    /// @notice Return the uncalled portion, move matched chips to the pot.
    function closeStreet(Hand storage h) public {
        uint32 m = _min32(h.streetBet[0], h.streetBet[1]);
        h.stack[0] += h.streetBet[0] - m;
        h.stack[1] += h.streetBet[1] - m;
        h.pot += 2 * m;
        h.streetBet[0] = 0;
        h.streetBet[1] = 0;
        if (h.stack[0] == 0 || h.stack[1] == 0) h.allIn = true;
    }

    /// @dev Nobody can act: actor is all-in, or opponent is all-in with
    ///      nothing left to call.
    function _shouldAutoClose(Hand storage h) private view returns (bool) {
        return h.stack[h.toAct] == 0
            || (h.stack[1 - h.toAct] == 0 && h.streetBet[h.toAct] == h.currentBet);
    }

    function _min32(uint32 a, uint32 b) private pure returns (uint32) {
        return a < b ? a : b;
    }
}
        

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.28;

/// @title GameTypes — shared structs, enums and errors for PLSHoldem
/// @notice File-level definitions so the main contract and external game
///         libraries share one source of truth.

enum TableStatus { NONE, OPEN, PLAYING, SETTLED, CANCELLED }

enum Phase {
    NONE,          // between hands: waiting for creator to post D1
    SHUF1,         // (never stored: D1 post transitions NONE->SHUF2)
    SHUF2,         // joiner must post D2
    LOCK1,         // creator must post D3
    LOCK2,         // joiner must post D4
    DEAL,          // both must post hole-card exponents
    BET_PREFLOP,
    REVEAL_FLOP,
    BET_FLOP,
    REVEAL_TURN,
    BET_TURN,
    REVEAL_RIVER,
    BET_RIVER,
    SHOWDOWN_1,    // first revealer must show
    SHOWDOWN_2,    // second player shows or mucks
    BLAME_J,       // joiner must submit blame data
    BLAME_C        // creator must submit blame data
}

enum Action { FOLD, CHECK, CALL, BET, RAISE }

struct Table {
    address creator;
    uint96 chipValue;        // wei per chip
    address joiner;
    uint8 status;            // TableStatus
    uint8 creatorAvatar;
    uint8 joinerAvatar;
    uint16 rakeBps;
    uint32 buyInChips;
    uint32 sbChips;
    uint32 bbChips;
    uint32 penaltyChips;
    uint32 actTimeout;       // seconds, betting actions
    uint32 cryptoTimeout;    // seconds, crypto steps / reveals / next hand
    uint32 handId;           // next / current hand number
    uint32 rakeChips;        // accrued rake
    uint32 stackC;           // creator session stack (between hands)
    uint32 stackJ;           // joiner session stack
    uint64 lastSettleTime;   // anchor for the next-hand (no-show) clock
}

struct Hand {
    uint8 phase;             // Phase
    uint8 btn;               // 0 = creator has the button, 1 = joiner
    uint64 deadline;         // current actor(s) must move before this
    // betting state (mirrors web/js/betting.mjs)
    uint32[2] stack;         // chips behind, [creator, joiner]
    uint32[2] streetBet;
    uint32 pot;
    uint32 currentBet;
    uint32 inc;              // last full raise increment
    uint8 street;            // 0..3
    uint8 toAct;
    uint8 firstToAct;
    bool reopen;
    bool bbOption;
    bool allIn;
    uint8 folded;            // 255 = none
    uint8 riverAggressor;    // 255 = none
    // dealing / reveals
    bytes32[4] roots;        // D1..D4 Merkle roots
    uint256[4] holeExp;      // per-card exps for positions 0..3 (0,1 by J; 2,3 by C)
    uint8 dealMask;          // bit0 = joiner posted, bit1 = creator posted
    uint8[5] board;          // card indices, 255 = unset
    uint256[3] pendExp;      // first poster's exps for the current reveal
    uint8 pendBy;            // 255 = none
    // showdown
    uint8 firstShower;
    uint8 shownMask;         // bit per seat
    uint256[2][2] shownExp;  // [seat][slot]
    uint8[2][2] shownCards;  // [seat][slot]
    uint32[2] shownScore;
    // blame
    uint8 blamePos;
    uint8 blameClaimIdx;     // disputed claimed card (255 = "garbage" claim)
    uint8 blameClaimBy;      // seat whose claim/accusation opened blame
    uint256 blameGJ;         // J's pinned global exponent
    uint256 blameCJ;         // J's pinned per-card exponent
    uint256 blamePostedC;    // C's per-card exponent as posted during play
    uint256 blamePostedJ;    // J's per-card exponent as posted during play
    bytes32[4] blameVals;    // keccak of Merkle-proven D1[j], D2..D4[pos]
}

// Custom errors (compact reverts), shared by contract + libraries
error AlreadyPosted();
error BadAmount();
error BadData();
error BadInverse();
error BadParam();
error BadPhase();
error BadProof();
error BadScalar();
error BetBelowMin();
error BetTooLarge();
error Bust();
error CannotCheck();
error CardMismatch();
error FacingABet();
error NotAPlayer();
error NotCreator();
error NotExpired();
error NotJoiner();
error NotOpen();
error NotOwner();
error NotPlaying();
error NotReopened();
error NotYourHole();
error NotYourReveal();
error NotYourTurn();
error NothingToCall();
error NothingToDo();
error NothingToRaise();
error OpponentAllIn();
error PostYoursFirst();
error RaiseBelowMin();
error RaiseTooSmall();
error RakeCap();
error TransferFailed();
error WrongDeposit();
error WrongHand();
error YouAreTheStaller();