> ## Documentation Index
> Fetch the complete documentation index at: https://docs.mycryptocasino.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Dice की निष्पक्षता

> ऑपरेटर की गुप्त वैल्यू की ज़रूरत क्यों नहीं है, और सार्वजनिक इनपुट से पूरी गणना।

Dice रोल में ऑपरेटर की कोई गुप्त वैल्यू इस्तेमाल नहीं होती। यह ऑन-चेन तीन चीज़ों से निकाला जाता है: आपका दांव execute होते समय कैप्चर किया गया Solana स्लॉट हैश, आपके अकाउंट का पता, और आपका निजी दांव काउंटर। फिर उसी ट्रांज़ैक्शन में सेटल होता है जिसमें दांव लगाया गया था। ऐसा कोई सीड नहीं है जिसे ऑपरेटर चुन सके, और बाद में रिवील करने के लिए भी कुछ नहीं है।

यह पेज हर [Dice](/hi/docs/games/dice) रोल के पीछे की सटीक प्रक्रिया बताता है। Dice [प्रूवेबली फेयर (सत्यापन योग्य निष्पक्षता) योजना](/hi/docs/provably-fair/overview) का सबसे सरल मामला है: इसमें **ऑपरेटर की कोई गुप्त वैल्यू है ही नहीं**। रोल सार्वजनिक इनपुट से निकाला जाता है और उसी ट्रांज़ैक्शन में ऑन-चेन सेटल होता है जिसमें दांव लगाया जाता है।

<h2 id="why-there-is-no-commit-step">
  Dice में कमिट चरण क्यों नहीं है?
</h2>

Crash को कमिट की गई गुप्त वैल्यू की ज़रूरत होती है, क्योंकि राउंड चलने के दौरान उसका परिणाम *तय लेकिन छिपा हुआ* रहना चाहिए। Dice रोल में ऐसा कोई चरण नहीं होता: परिणाम उसी इंस्ट्रक्शन में इस्तेमाल हो जाता है जिसमें वह निकाला जाता है। इसलिए किसी गुप्त वैल्यू को कमिट करने के बजाय, गणना में **ऑपरेटर का कोई भी इनपुट होता ही नहीं**: न कुछ कमिट करना है, न कुछ रिवील करना है, और न कोई ऐसा सीड जिसे ऑपरेटर अपने फ़ायदे के लिए चुन सके।

एंट्रॉपी ख़ुद Solana नेटवर्क से आती है, जिसे आपके दांव की पहचान करने वाले मानों के साथ मिलाया जाता है:

* **`slothash`**: जिस क्षण आपका दांव ट्रांज़ैक्शन execute होता है, उस समय Solana के `SlotHashes` sysvar की सबसे ताज़ा एंट्री। यह नेटवर्क द्वारा बनाई गई एंट्रॉपी है, जो ट्रांज़ैक्शन बनाते समय पता नहीं होती (भेजने वाला ठीक-ठीक नहीं जान सकता कि ट्रांज़ैक्शन किस स्लॉट में शामिल होगा)।
* **`user`**: आपके ऑन-चेन यूज़र अकाउंट (आपके वॉलेट से प्रोग्राम द्वारा निकाला गया अकाउंट) का 32-बाइट पता। इससे अलग-अलग खिलाड़ियों के रोल एक-दूसरे से स्वतंत्र रहते हैं: एक ही स्लॉट में आए दो दांवों को अलग-अलग रोल मिलते हैं।
* **`nonce`**: आपका निजी दांव काउंटर, जो ऑन-चेन स्टोर होता है और हर खेल पर बढ़ता है। इससे आपके लगातार दांव भी एक-दूसरे से स्वतंत्र रहते हैं, एक ही स्लॉट के भीतर भी, और यह दोहरे सबमिशन से सुरक्षा का काम भी करता है।

<h2 id="the-exact-formula">
  Dice रोल का सटीक फ़ॉर्मूला क्या है?
</h2>

```text theme={null}
इनपुट
  slothash   32 बाइट   दांव ट्रांज़ैक्शन execute होते समय का नवीनतम Solana स्लॉट हैश
  user       32 बाइट   आपके ऑन-चेन यूज़र अकाउंट का पता
  nonce      8 बाइट    आपका दांव काउंटर, little-endian

गणना
  hash = sha256( "dice" ‖ slothash ‖ user ‖ nonce )   // "dice" = 4 ASCII बाइट 0x64 0x69 0x63 0x65
  roll = u128_be( hash[0..16] ) mod 10000              // पहले 16 बाइट, big-endian unsigned 128-bit

नतीजा
  roll 0..9999 के बीच एक पूर्णांक है, यानी 0.00–99.99, दो दशमलव स्थान
```

दोबारा गणना करते समय ये बातें मायने रखती हैं:

* हैश इनपुट इसी सटीक क्रम में जोड़ा जाता है: ASCII टैग `"dice"`, स्लॉट हैश, यूज़र अकाउंट का पता, फिर **8 बाइट little-endian** में एन्कोड किया गया nonce।
* सैंपल SHA-256 आउटपुट के **पहले 16 बाइट** हैं, जिन्हें **big-endian** unsigned 128-bit पूर्णांक के रूप में पढ़कर 10,000 से mod किया जाता है।
* 128-bit सैंपल को 10,000 से mod करने में सैद्धांतिक पूर्वाग्रह 2⁻¹¹⁴ से कम है, जो हाउस एज से दर्जनों ऑर्डर ऑफ़ मैग्नीट्यूड छोटा है। इसीलिए इसे ठीक करने के बजाय केवल दस्तावेज़ में दर्ज किया गया है।

## जीत की शर्त और पेआउट

```text theme={null}
Under target : roll < target होने पर आप जीतते हैं      जीतने की संभावना = 10000 में से target परिणाम
Over  target : roll > target होने पर आप जीतते हैं      जीतने की संभावना = 10000 में से 9999 − target परिणाम

multiplier_bps = floor( (10000 − edge_bps) × 10000 / win_chance_bps )
```

आपकी चुनी हुई जीतने की संभावना 2% और 98% के बीच होनी चाहिए। मौजूदा 1.5% एज (`edge_bps = 150`) पर:

| दांव | जीतने की संभावना | मल्टीप्लायर |
| - | - | - |
| Under 5000 | 50% | 1.97x |
| Under 200 | 2% | 49.25x |
| Under 9800 | 98% | 1.0051x |

हर target के लिए अपेक्षित रिटर्न एक जैसा है: दांव राशि का `chance × multiplier ≈ 98.5%` (floor राउंडिंग अधिकतम एक बेसिस पॉइंट हाउस के पक्ष में जाती है)। मौजूदा एज और सीमाएं [शुल्क और सीमाएं](/hi/docs/fees-and-limits) में दी गई हैं।

## क्या गारंटीड है, और क्या नहीं

**प्रोग्राम द्वारा लागू:**

* रोल एक ही ऑन-चेन इंस्ट्रक्शन के भीतर निकाला **और** सेटल किया जाता है, उन इनपुट से जिन्हें प्रोग्राम ख़ुद पढ़ता है। बैकएंड रोल नहीं देता और उसे ग़लत तरीके से रिपोर्ट नहीं कर सकता।
* ऑपरेटर गणना में **कोई इनपुट नहीं** देता: अनुकूल परिणाम पाने के लिए बार-बार आज़माने लायक कोई सर्वर सीड नहीं है।
* आपका nonce ठीक-ठीक दोहराया जाना चाहिए, इसलिए एक ही दांव ग़लती से (या दुर्भावना से) दो बार नहीं खेला जा सकता।
* हर खेल गणना के सभी इनपुट और परिणाम प्रकाशित करता है, इसलिए इतिहास का हर रोल कोई भी दोबारा गणना कर सकता है।

**ईमानदार चेतावनी: सबमिशन का समय।** Dice दांव gasless हैं: MCC का बैकएंड आपके लिए ट्रांज़ैक्शन साइन करके सबमिट करता है, इसलिए यह ऑपरेटर के नियंत्रण में है कि वह *कब* सबमिट हो। स्लॉट `N−1` का हैश स्लॉट `N` की शुरुआत में सार्वजनिक हो जाता है, इसलिए बहुत कम latency वाला ऑपरेटर अनुमान लगा सकता है कि *अगर* दांव मौजूदा स्लॉट में शामिल हुआ तो उसे कौन-सा रोल मिलेगा, और दोबारा ड्रॉ के लिए सबमिशन में देरी कर सकता है। यह योजना इसे छिपाने के बजाय स्वीकार करती है (इसे हटाने के लिए एक VRF oracle चाहिए होगा, जिसकी प्रति-दांव लागत छोटे दांवों पर हाउस के अपेक्षित लाभ से ज़्यादा है)। इसे सीमित करने वाली बातें:

* शामिल होना पूरी तरह नियंत्रित नहीं किया जा सकता: ट्रांज़ैक्शन किस सटीक स्लॉट में शामिल होगा, यह भेजने वाला नहीं, नेटवर्क तय करता है।
* हर इनपुट प्रकाशित होता है, इसलिए सबमिशन में देरी के पैटर्न और बताई गई संभावनाओं से कुल जीत दर का कोई भी विचलन सार्वजनिक डेटा से **कोई भी माप सकता है**। व्यवस्थित दुरुपयोग छिपा नहीं रह सकता।

<h2 id="verify-a-roll">
  Dice रोल को कैसे सत्यापित करें?
</h2>

हर खेल दांव के अपने ट्रांज़ैक्शन में एक `DiceBetSettled` इवेंट जारी करता है, जिसमें आपको जो कुछ चाहिए वह सब होता है: `slothash`, `user`, `nonce`, `target_bps`, `direction`, `win_chance_bps`, `roll`, `multiplier_bps` और `is_win`, साथ में पूरा सेटलमेंट ब्रेकडाउन। सत्यापित करने के लिए:

1. दांव का ट्रांज़ैक्शन Solana एक्सप्लोरर पर खोलें और इवेंट फ़ील्ड पढ़ें (ऐप की Dice स्क्रीन आपके सेशन के निष्पक्षता इनपुट दिखाती है, और आपका दांव इतिहास ट्रांज़ैक्शन से लिंक होता है)।
2. `sha256("dice" ‖ slothash ‖ user ‖ nonce)` दोबारा गणना करें, पहले 16 बाइट big-endian लेकर 10,000 से mod करें, और इवेंट के `roll` से मिलाएं।
3. जीत/हार का फ़ैसला (Under के लिए `roll < target`, Over के लिए `roll > target`) और मल्टीप्लायर ऊपर दिए फ़ॉर्मूले से जांचें।

एक्सप्लोरर से इवेंट डेटा पढ़ने के सामान्य सुझावों के लिए [एक राउंड सत्यापित करें](/hi/docs/provably-fair/verify-a-round) देखें।

गेम ख़ुद कैसे खेला जाता है, यह जानने के लिए [Dice गेम गाइड](/hi/docs/games/dice) देखें।