בניית משחק HiLo שקוף: Commit-Reveal ואופטימיזציית גז

בניית משחק HiLo שקוף: Commit-Reveal ואופטימיזציית Gas

שחקנים בבתי קזינו מבוססי בלוקצ'יין מטילים לעיתים קרובות ספק בהוגנות התוצאות. כאשר מחולל המספרים האקראיים מוסתר והתוצאה נקבעת בצד השרת, האמון צונח. אנו דוחים מודל זה. במקום RNG סגור, אנו משתמשים בסכמת commit-reveal: ה-seed של השרת נקבע לפני תחילת המשחק ונחשף לאחריו. כל שלב ניתן לאימות ברמת החוזה החכם. גישה זו מבטיחה שגם בעל הקזינו אינו יכול לשנות את התוצאה לאחר תחילת המשחק. השחקן יכול לשחזר את כל הקלפים באמצעות ה-seeds שנחשפו.

ביישום ה-HiLo שלנו, יתרון הבית קבוע על 1% — ללא עמלות נסתרות. המכפיל מחושב דינמית בהתבסס על הסתברות הניחוש, מה שמבטל כל אפשרות למניפולציה. לדוגמה, כאשר הקלף הנוכחי הוא Ace (1) והשחקן מנחש גבוה יותר, ההסתברות היא 92.3%, מה שמוביל למכפיל של כ-1.07x. לעומת זאת, ניחוש גבוה יותר על King נותן סיכוי של 0% והפסד מיידי.

למה אנחנו לא משתמשים ב-Chainlink VRF?

Chainlink VRF הוא מחולל אקראיות מבוזר, אבל הוא איטי: כל בקשה לוקחת 1–2 בלוקים (~2 שניות באת'ריום). עבור משחק שבו קלפים חייבים להיחשף באופן מיידי, זה בלתי מתקבל על הדעת. סכמת ה-commit-reveal עם שילוב דטרמיניסטי של גיבובי seed נותנת תוצאה מיידית ללא המתנה ל-oracle.

סכמת ה-commit-reveal זולה פי 500 ומהירה פי 100 — הבחירה המושלמת עבור HiLo.

כיצד שחקן יכול לאמת הוגנות?

לאחר סיום המשחק, הקזינו מפרסם את ה-seed המלא של השרת. השחקן לוקח את ה-seed הזה, מחשב keccak256(serverSeed), ומשווה אותו לגיבוב שפורסם לפני המשחק. אם הגיבובים תואמים, הקזינו לא התעסק עם ה-seed. לאחר מכן, באמצעות פונקציית _deriveCard מהחוזה, השחקן מייצר את רצף הקלפים ומצליב עם ההיסטוריה.

לפי מפרט EIP-1967, שימוש בפונקציות דטרמיניסטיות המבוססות על גיבובים מבטיח את אי-השינוי של התוצאה לאחר שה-seed מחויב.

// Клиентская верификация (JavaScript)
import { keccak256, encodePacked } from "viem";

function verifyGame(
  serverSeed: string,
  serverSeedHash: string,
  clientSeed: string,
  cards: number[]
): boolean {
  const computedHash = keccak256(new TextEncoder().encode(serverSeed));
  if (computedHash !== serverSeedHash) return false;

  for (let i = 0; i < cards.length; i++) {
    const combined = keccak256(
      encodePacked(
        ["bytes32", "bytes32", "uint8"],
        [serverSeedHash, clientSeed as `0x${string}`, i]
      )
    );
    const card = Number(BigInt(combined) % 52n);
    if (card !== cards[i]) return false;
  }
  return true;
}

איך אנחנו עושים את זה: מחסנית ויישום

אנו משתמשים ב-Solidity 0.8.20, Foundry לבדיקות ופריסה, ו-Tenderly לניטור. החוזה מכיל סכמת commit-reveal אופטימלית שבה כל קלף מחושב תוך כדי תנועה ללא אחסון כל החפיסה.

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

contract HiLoGame {
    uint8 constant DECK_SIZE = 52;

    struct Game {
        address player;
        bytes32 serverSeedHash;
        bytes32 clientSeed;
        string serverSeed;
        uint256 betAmount;
        uint8 currentCard;
        uint8 position;
        uint256 multiplier;
        bool active;
        bool cashed;
    }

    mapping(bytes32 => Game) public games;

    uint256 public constant HOUSE_EDGE = 100; // 1%

    event GameStarted(bytes32 indexed gameId, address player, uint8 firstCard);
    event CardRevealed(bytes32 indexed gameId, uint8 card, uint256 multiplier);
    event GameCashed(bytes32 indexed gameId, uint256 payout);
    event GameLost(bytes32 indexed gameId, uint8 card);

    function startGame(
        bytes32 serverSeedHash,
        bytes32 clientSeed
    ) external payable returns (bytes32 gameId) {
        require(msg.value > 0, "Bet required");
        gameId = keccak256(abi.encodePacked(
            msg.sender,
            serverSeedHash,
            clientSeed,
            block.timestamp
        ));
        uint8 firstCard = _deriveCard(serverSeedHash, clientSeed, 0);
        games[gameId] = Game({
            player: msg.sender,
            serverSeedHash: serverSeedHash,
            clientSeed: clientSeed,
            serverSeed: "",
            betAmount: msg.value,
            currentCard: firstCard,
            position: 0,
            multiplier: 100, // 1.0x
            active: true,
            cashed: false
        });
        emit GameStarted(gameId, msg.sender, firstCard);
    }

    function revealNextCard(
        bytes32 gameId,
        string calldata serverSeedPartial,
        bool guessHigher
    ) external {
        Game storage game = games[gameId];
        require(game.active, "Game not active");
        require(msg.sender == owner() || msg.sender == gameServer, "Unauthorized");
        uint8 nextCard = _deriveCard(
            game.serverSeedHash,
            game.clientSeed,
            game.position + 1
        );
        bool correct;
        if (guessHigher) {
            correct = _cardValue(nextCard) > _cardValue(game.currentCard);
        } else {
            correct = _cardValue(nextCard) < _cardValue(game.currentCard);
        }
        if (_cardValue(nextCard) == _cardValue(game.currentCard)) {
            correct = false;
        }
        game.position++;
        game.currentCard = nextCard;
        if (!correct) {
            game.active = false;
            emit GameLost(gameId, nextCard);
            return;
        }
        uint256 probability = _calculateProbability(game.currentCard, guessHigher);
        game.multiplier = (game.multiplier * 9900) / probability;
        emit CardRevealed(gameId, nextCard, game.multiplier);
    }

    function cashout(bytes32 gameId) external {
        Game storage game = games[gameId];
        require(game.active, "Game not active");
        require(msg.sender == game.player, "Not your game");
        game.active = false;
        game.cashed = true;
        uint256 payout = (game.betAmount * game.multiplier) / 100;
        payable(game.player).transfer(payout);
        emit GameCashed(gameId, payout);
    }

    function revealServerSeed(bytes32 gameId, string calldata serverSeed) external {
        Game storage game = games[gameId];
        require(!game.active, "Game still active");
        require(
            keccak256(bytes(serverSeed)) == game.serverSeedHash,
            "Invalid server seed"
        );
        game.serverSeed = serverSeed;
    }

    function _deriveCard(
        bytes32 serverSeedHash,
        bytes32 clientSeed,
        uint8 position
    ) internal pure returns (uint8) {
        bytes32 combined = keccak256(abi.encodePacked(serverSeedHash, clientSeed, position));
        return uint8(uint256(combined) % DECK_SIZE);
    }

    function _cardValue(uint8 card) internal pure returns (uint8) {
        return (card % 13) + 1;
    }

    function _calculateProbability(uint8 currentCard, bool higher) internal pure returns (uint256) {
        uint8 value = _cardValue(currentCard);
        uint256 cardsHigher = 13 - value;
        uint256 cardsLower = value - 1;
        if (higher) return (cardsHigher * 100) / 13;
        return (cardsLower * 100) / 13;
    }

    receive() external payable {}

    address public gameServer;
    address public owner;

    constructor() {
        owner = msg.sender;
        gameServer = msg.sender;
    }

    modifier onlyOwner() {
        require(msg.sender == owner);
        _;
    }
}

אילו בעיות commit-reveal פותר?

ללא commit-reveal, שחקן אינו יכול להיות בטוח שהשרת לא שינה את התוצאה לאחר הימור. Commit-reveal מסיר בעיה זו: גיבוב ה-seed נקבע לפני המשחק, וה-seed עצמו נחשף רק לאחריו. השחקן מקבל ערובה ניתנת להוכחה שהתוצאה לא זויפה. זה חיוני לדרישות רישוי ולאמון המשתמשים.

תהליך העבודה

1. ניתוח: דיון במכניקת המשחק, דרישות RNG, מכפיל, יתרון בית, מגבלות הימור.
2. עיצוב: ארכיטקטורת חוזה חכם, בחירת סכמת commit-reveal, הגדרת ממשקים.
3. פיתוח: כתיבת חוזה ב-Solidity 0.8.20, כתיבת בדיקות ב-Foundry (יחידה + fuzzing).
4. בדיקות: אימות פורמלי עם Slither, Echidna (fuzzing), פריסה ל-testnet.
5. ביקורת: גיוס מבקר חיצוני (אופציונלי).
6. פריסה: פריסה לרשת היעד (Ethereum, Polygon, BNB Chain).
7. תמיכה: ניטור, עדכוני פרמטרים, סיוע לשחקנים.

מה כלול בעבודה

• קוד מקור של החוזה החכם עם הערות
• תיעוד אימות לשחקנים
• אינטגרציית Frontend (React, wagmi, RainbowKit)
• פריסת Testnet
• פריסת Mainnet עם הגדרת ניטור Tenderly
• הדרכת הצוות שלך על אימות תוצאות

ציר זמן ועלות

יישום בסיסי (חוזה + frontend) מתחיל ב-$5,000 ואורך 2–3 שבועות. עם אימות פורמלי מלא וביקורת, העלות נעה בין $10,000 ל-$20,000, וציר הזמן מתארך ל-6–8 שבועות. העלות מחושבת באופן פרטני לפי מורכבות והיקף העבודה.

צור קשר כדי לדון בפרויקט שלך. יש לנו ניסיון של 5+ שנים בפיתוח בלוקצ'יין וסיפקנו למעלה מ-20 משחקים ומוצרי DeFi. אנו מבטיחים יישום הוגן הניתן להוכחה ושקיפות של כל האלגוריתמים.

הזמן פיתוח משחק HiLo משלך — פנה אלינו, נעריך את הפרויקט שלך תוך 24 שעות. קבל ייעוץ על ארכיטקטורה ואופטימיזציית gas.