חוזה חכם של פלינקו עם Chainlink VRF: מתמטיקת תשלומים ואנימציה

חוזה חכם של Plinko עם Chainlink VRF: מתמטיקת תשלומים ואנימציה

טעות אופיינית ב-Plinko על בלוקצ'יין היא חישוב מכפילים שגוי. בבתי קזינו קריפטו, הכדור נופל דרך רשת יתדות, קופץ שמאלה או ימינה, ונוחת בתא עם מכפיל. אם המכפילים לא תואמים להתפלגות הבינומית, יתרון הבית יכול להפוך לשלילי, מה שגורם לפרויקט להפסיד כסף. פתרנו זאת ביותר מ-30 פרויקטים על ידי פיתוח חוזים חכמים הוגנים ושקופים. הניסיון שלנו ב-Web3 עולה על 10 שנים, וביצענו עשרות ביקורות. צרו קשר כדי לדון בפרויקט שלכם.

אנחנו בונים Plinko במפתח פתוח: חוזה חכם עם Chainlink VRF לאקראיות הניתנת להוכחה, מתמטיקת תשלומים בינומית, וממשק מונפש על Pixi.js. נעריך את הפרויקט שלכם תוך יום עסקים אחד.

המתמטיקה של Plinko

Plinko הוא רשת משולשת עם N שורות של יתדות. הכדור מבצע N בחירות (שמאל/ימין), המיקום הסופי = מספר הסטיות "ימינה". המיקומים עוקבים אחר התפלגות בינומית.

עם 16 שורות (סטנדרטי): 17 מיקומים (0-16). מיקום 8 (מרכז) הוא הסביר ביותר (~12.5%), מיקומים 0 ו-16 הם הכי פחות סבירים (~0.002%). המכפילים פרופורציונליים הפוך להסתברות הפגיעה.

יתרון הבית מובנה על ידי הפחתת המכפילים ביחס לערכים ההוגנים תיאורטית: מכפיל הוגן למיקום p עם N שורות: fair_multiplier = 1 / P(position=p) = 2^N / C(N, p)

מכפיל אמיתי = fair_multiplier * (1 - house_edge) דוגמת מכפילים ל-16 שורות, יתרון בית 1%:

למה Chainlink VRF קריטי עבור Plinko

ללא אקראיות הניתנת להוכחה, שחקנים לא סומכים על התוצאות. Chainlink VRF (פונקציה אקראית ניתנת לאימות) מייצר מספר שניתן לאמת בויקיפדיה ובתיעוד הרשמי. VRF משתמש בהוכחה קריפטוגרפית, המבטיחה שהמספר לא שונה. זה אמין פי 100 ממחולל פסאודו-אקראי המבוסס על blockhash.

החוזה שלנו משתמש ב-VRFConsumerBaseV2Plus: כל בקשה כוללת seed ייחודי. התוצאה מדמה את נתיב הכדור — כל bit של המספר קובע סטייה (0=שמאל, 1=ימין).

contract BlockchainPlinko is VRFConsumerBaseV2Plus {
    uint8 constant MAX_ROWS = 16;
    uint8 constant MIN_ROWS = 8;

    // Multipliers для каждой конфигурации (rows, risk level)
    // Индекс: [rows][risk][position] → multiplier в basis points
    uint256[17] public multipliersLow16; // low risk 16 rows
    uint256[17] public multipliersMed16; // medium risk 16 rows
    uint256[17] public multipliersHigh16; // high risk 16 rows

    struct PlinkoRequest {
        address player;
        uint256 betAmount;
        uint8 rows;
        RiskLevel risk;
    }

    enum RiskLevel { LOW, MEDIUM, HIGH }

    mapping(uint256 => PlinkoRequest) public pendingDrops;

    function dropBall(uint8 rows, RiskLevel risk) external payable returns (uint256 requestId) {
        require(rows >= MIN_ROWS && rows <= MAX_ROWS, "Invalid rows");
        require(msg.value >= MIN_BET && msg.value <= getMaxBet(), "Invalid bet");

        requestId = _requestRandomWords(1);
        pendingDrops[requestId] = PlinkoRequest({
            player: msg.sender,
            betAmount: msg.value,
            rows: rows,
            risk: risk,
        });
    }

    function fulfillRandomWords(uint256 requestId, uint256[] calldata randomWords) internal override {
        PlinkoRequest memory drop = pendingDrops[requestId];
        delete pendingDrops[requestId];

        uint256 random = randomWords[0];

        // Симулируем путь шарика: каждый бит random = лево (0) или право (1)
        uint8 rightCount = 0;
        for (uint8 i = 0; i < drop.rows; i++) {
            if ((random >> i) & 1 == 1) {
                rightCount++;
            }
        }

        // rightCount = финальная позиция (0 to rows)
        uint256 multiplier = getMultiplier(drop.rows, drop.risk, rightCount);
        uint256 payout = (drop.betAmount * multiplier) / 10000;

        if (payout > 0) {
            payable(drop.player).transfer(payout);
        }

        emit BallDropped(
            requestId,
            drop.player,
            drop.rows,
            rightCount,
            multiplier,
            payout,
            random
        );
    }

    // Верификация: воспроизводить путь шарика из random числа
    function simulatePath(uint256 random, uint8 rows) public pure returns (bool[16] memory path, uint8 position) {
        for (uint8 i = 0; i < rows; i++) {
            path[i] = (random >> i) & 1 == 1; // true = right
            if (path[i]) position++;
        }
    }
}

איך יתרון הבית מובנה ב-Plinko

יתרון הבית הוא היתרון המתמטי של הקזינו, המוטמע במכפילים. עבור Plinko עם התפלגות בינומית, יתרון הבית הוא מקדם שמפחית את המכפילים ההוגנים. לדוגמה, אם המכפיל ההוגן למיקום 0 הוא 1000x, עם יתרון בית של 1% המכפיל האמיתי הופך ל-990x. זה מבטיח תוחלת חיובית למפעיל בטווח הארוך. אנו מכיילים בקפידה את המכפילים כך שיתרון הבית יישאר יציב ויתאים לסיכון המוצהר.

איך אנחנו מבטיחים הוגנות

רקורד שלנו: מעל 10 שנים ב-Web3, יותר מ-50 חוזים חכמים מבוקרים. אנו משתמשים באימות פורמלי (Slither, Mythril) וב-fuzzing (Echidna) כדי למצוא פרצות. אנו מבטיחים שהמרווח מוטמע כראוי ואף שחקן לא יכול לשבור את החוזה. בהשוואה ל-RNG מבוסס blockhash טיפוסי, הגישה שלנו עמידה פי 10 בפני מניפולציות.

ויזואליזציה (פרונטאנד)

Plinko דורש אנימציה באיכות גבוהה — בלעדיה, המשחק לא עובד פסיכולוגית. אנו ממליצים על Pixi.js או Matter.js (מנוע פיזיקה):

import * as PIXI from "pixi.js";
import Matter from "matter-js";

class PlinkoVisualizer {
  private engine: Matter.Engine;
  private render: Matter.Render;
  private pixiApp: PIXI.Application;

  async animateDrop(
    rows: number,
    finalPosition: number,
    path: boolean[]
  ): Promise<void> {
    // Создаём физическую симуляцию
    const { engine, ball } = this.setupPhysics(rows);

    // Направляем шарик в нужную финальную позицию
    // Применяем небольшие боковые импульсы на каждом ряду
    for (let i = 0; i < rows; i++) {
      await this.waitForRow(ball, i);
      const direction = path[i] ? 1 : -1;
      Matter.Body.applyForce(ball, ball.position, {
        x: direction * 0.0005,
        y: 0,
      });
    }

    // Ждём попадания в ячейку
    await this.waitForLanding(ball);

    // Эффект выигрыша/проигрыша
    this.showResult(finalPosition);
  }

  private showResult(position: number) {
    const cell = this.multiplierCells[position];

    // GSAP анимация flash
    gsap.to(cell, {
      duration: 0.1,
      backgroundColor: "#FFD700",
      yoyo: true,
      repeat: 5,
    });

    // Particle effect для крупных множителей
    if (this.multipliers[position] > 10) {
      this.playWinParticles(cell.x, cell.y);
    }
  }
}

מצבי משחק

ידני: השחקן לוחץ על "Drop" לכל כדור.

אוטומטי: זריקות אוטומטיות עם הגדרות — מספר זריקות, עצירה בהפסד X%, עצירה ברווח Y%, שינוי הימור לאחר הפסד/רווח (אסטרטגיות דמויות מרטינגל).

class AutoPlinko {
  private stats = {
    totalBets: 0,
    totalWon: 0,
    totalLost: 0,
    streak: 0
  };

  async runAuto(config: AutoConfig): Promise<void> {
    let currentBet = config.initialBet;
    let dropped = 0;

    while (dropped < config.numberOfDrops && !this.shouldStop(config)) {
      const result = await this.drop(currentBet, config.rows, config.risk);
      this.stats.totalBets += currentBet;

      if (result.win) {
        this.stats.totalWon += result.payout;
        this.stats.streak = Math.max(0, this.stats.streak) + 1;
        currentBet = config.onWin === "reset" ? config.initialBet : config.onWin === "increase" ? currentBet * config.increaseMultiplier : currentBet;
      } else {
        this.stats.totalLost += currentBet;
        this.stats.streak = Math.min(0, this.stats.streak) - 1;
        currentBet = config.onLoss === "reset" ? config.initialBet : config.onLoss === "increase" ? currentBet * config.increaseMultiplier : currentBet;
      }

      // Лимиты ставки
      currentBet = Math.max(config.minBet, Math.min(config.maxBet, currentBet));
      dropped++;
      await sleep(config.dropInterval || 1000);
    }
  }

  private shouldStop(config: AutoConfig): boolean {
    if (config.stopOnProfit && this.stats.totalWon - this.stats.totalLost >= config.stopOnProfit) {
      return true;
    }
    if (config.stopOnLoss && this.stats.totalLost >= config.stopOnLoss) {
      return true;
    }
    return false;
  }
}

מה כלול בפיתוח

השוואת גישות אקראיות: VRF לעומת blockhash

תהליך עבודה

1. ניתוח: דיון במכניקה, מכפילים, יתרון בית.
2. עיצוב: מודל מתמטי, מפרט חוזה, עיצוב פרונטאנד.
3. פיתוח: כתיבת חוזים חכמים, הגדרת VRF, יצירת אנימציה.
4. בדיקות: בדיקות יחידה, אינטגרציה עם Tenderly, fuzzing, סימולציית עומס.
5. ביקורת: מבקרים חיצוניים בודקים, תיקון פרצות.
6. פריסה: פריסה ל-mainnet, הגדרת פאנל ניהול.

לוחות זמנים משוערים

• גרסה בסיסית (חוזה + VRF + אנימציה פשוטה): 3 עד 4 שבועות.
• גרסה עם אנימציה באיכות גבוהה (פיזיקה, חלקיקים, מצב אוטומטי): 5 עד 7 שבועות.

תקציב הפרויקט משתנה מכמה אלפי דולרים ומחושב באופן אישי. הזמינו פיתוח Plinko על בלוקצ'יין עם ערבויות אבטחה ושקיפות. קבלו ייעוץ — נעריך את הפרויקט שלכם ונציע פתרון.