Contract Address Details

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

/// @title HandEval — 7-card Texas Hold'em evaluator
/// @notice Mirrors web/js/handeval.mjs exactly (cross-checked by shared and
///         randomized differential test vectors).
/// @dev Card index k = 13*suit + rank; rank 0='2' … 12='A'.
///      Score: uint32 = category << 20 | five 4-bit tiebreak nibbles.
///      Categories: 0 high, 1 pair, 2 two pair, 3 trips, 4 straight,
///      5 flush, 6 full house, 7 quads, 8 straight flush.
library HandEval {
    /// @notice Evaluate 7 distinct cards; larger score = better hand.
    function evaluate7(uint8[7] memory cards) public pure returns (uint32) {
        uint8[13] memory rankCount;
        uint8[4] memory suitCount;
        uint16[4] memory suitMask;
        uint16 rankMask;
        for (uint256 i = 0; i < 7; i++) {
            uint8 k = cards[i];
            require(k < 52, "bad card");
            uint8 r = k % 13;
            uint8 s = k / 13;
            rankCount[r]++;
            suitCount[s]++;
            suitMask[s] |= uint16(1) << r;
            rankMask |= uint16(1) << r;
        }

        // straight flush
        for (uint256 s = 0; s < 4; s++) {
            if (suitCount[s] >= 5) {
                int8 t = straightTop(suitMask[s]);
                if (t >= 0) return score(8, uint8(t), 0, 0, 0, 0);
            }
        }

        // rank groups (descending scan)
        int8 quad = -1;
        int8 trip = -1;
        int8 trip2 = -1;
        int8 pairHi = -1;
        int8 pairLo = -1;
        for (int8 r = 12; r >= 0; r--) {
            uint8 c = rankCount[uint8(r)];
            if (c == 4) quad = r;
            else if (c == 3) {
                if (trip < 0) trip = r;
                else if (trip2 < 0) trip2 = r;
            } else if (c == 2) {
                if (pairHi < 0) pairHi = r;
                else if (pairLo < 0) pairLo = r;
            }
        }

        if (quad >= 0) {
            uint16 rest = rankMask & ~(uint16(1) << uint8(quad));
            return score(7, uint8(quad), top1(rest), 0, 0, 0);
        }
        if (trip >= 0 && (trip2 >= 0 || pairHi >= 0)) {
            uint8 pr = trip2 >= 0 ? uint8(trip2) : uint8(pairHi);
            return score(6, uint8(trip), pr, 0, 0, 0);
        }
        for (uint256 s = 0; s < 4; s++) {
            if (suitCount[s] >= 5) {
                (uint8 a, uint8 b, uint8 c, uint8 d, uint8 e) = top5(suitMask[s]);
                return score(5, a, b, c, d, e);
            }
        }
        {
            int8 t = straightTop(rankMask);
            if (t >= 0) return score(4, uint8(t), 0, 0, 0, 0);
        }
        if (trip >= 0) {
            uint16 rest = rankMask & ~(uint16(1) << uint8(trip));
            (uint8 k1, uint8 k2) = top2(rest);
            return score(3, uint8(trip), k1, k2, 0, 0);
        }
        if (pairHi >= 0 && pairLo >= 0) {
            uint16 rest = rankMask & ~(uint16(1) << uint8(pairHi)) & ~(uint16(1) << uint8(pairLo));
            return score(2, uint8(pairHi), uint8(pairLo), top1(rest), 0, 0);
        }
        if (pairHi >= 0) {
            uint16 rest = rankMask & ~(uint16(1) << uint8(pairHi));
            (uint8 k1, uint8 k2) = top2(rest);
            uint8 k3 = top1(rest & ~(uint16(1) << k1) & ~(uint16(1) << k2));
            return score(1, uint8(pairHi), k1, k2, k3, 0);
        }
        (uint8 h1, uint8 h2, uint8 h3, uint8 h4, uint8 h5) = top5(rankMask);
        return score(0, h1, h2, h3, h4, h5);
    }

    /// @dev Highest straight top-rank in a 13-bit mask, or -1. Wheel top = 3.
    function straightTop(uint16 mask) internal pure returns (int8) {
        for (int8 t = 12; t >= 4; t--) {
            uint16 need = uint16(0x1f) << uint8(t - 4);
            if (mask & need == need) return t;
        }
        // wheel A-2-3-4-5: bits 12,0,1,2,3
        if (mask & 0x100f == 0x100f) return 3;
        return -1;
    }

    function score(uint8 cat, uint8 n1, uint8 n2, uint8 n3, uint8 n4, uint8 n5)
        private pure returns (uint32)
    {
        return (uint32(cat) << 20) | (uint32(n1) << 16) | (uint32(n2) << 12)
            | (uint32(n3) << 8) | (uint32(n4) << 4) | uint32(n5);
    }

    function top1(uint16 mask) private pure returns (uint8) {
        for (int8 r = 12; r >= 0; r--) {
            if (mask & (uint16(1) << uint8(r)) != 0) return uint8(r);
        }
        return 0;
    }

    function top2(uint16 mask) private pure returns (uint8, uint8) {
        uint8 a = top1(mask);
        uint8 b = top1(mask & ~(uint16(1) << a));
        return (a, b);
    }

    function top5(uint16 mask) private pure returns (uint8, uint8, uint8, uint8, uint8) {
        uint8[5] memory o;
        uint256 n = 0;
        for (int8 r = 12; r >= 0 && n < 5; r--) {
            if (mask & (uint16(1) << uint8(r)) != 0) {
                o[n++] = uint8(r);
            }
        }
        return (o[0], o[1], o[2], o[3], o[4]);
    }
}