> ## 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.

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

> क्या कमिट किया जाता है, नतीजा कब तय होता है, फ़ॉर्मूला क्या है, और इस व्यवस्था की सीमाएं।

Crash राउंड का मल्टीप्लायर दांव बंद होने से पहले तय हो जाता है और बाद में बदला नहीं जा सकता। दांव खुलने से पहले बैकएंड एक रैंडम गुप्त वैल्यू का SHA-256 हैश ऑन-चेन प्रकाशित करता है, राउंड शुरू होने पर प्रोग्राम उसमें एक Solana स्लॉट हैश मिलाता है, और सेटलमेंट के समय गुप्त वैल्यू रिवील की जाती है ताकि कोई भी क्रैश पॉइंट दोबारा निकालकर उसकी जांच कर सके।

यह पेज हर [Crash](/hi/docs/games/crash) राउंड के पीछे की सटीक व्यवस्था बताता है: क्या कमिट किया जाता है, नतीजा कब तय होता है, सटीक फ़ॉर्मूला, और इस व्यवस्था की ईमानदार सीमाएं। अगर आपने अभी तक नहीं पढ़ा है, तो पहले [प्रूवेबली फेयर का अवलोकन](/hi/docs/provably-fair/overview) पढ़ें; वह कमिट-रिवील को आसान शब्दों में समझाता है।

<h2 id="the-life-of-a-round">
  Crash राउंड के दौरान ऑन-चेन क्या होता है?
</h2>

हर Crash राउंड तीन ऑन-चेन ट्रांज़ैक्शन से बनता है, इसी क्रम में:

1. **कमिट**: दांव खुलने से पहले, बैकएंड एक रैंडम 32-बाइट गुप्त वैल्यू बनाता है और उसका SHA-256 हैश ऑन-चेन प्रकाशित करता है (`start_new_round` इंस्ट्रक्शन)। यही कमिट है: इस पल से सिर्फ़ वही सटीक गुप्त वैल्यू राउंड को सेटल कर सकती है। कमिट ट्रांज़ैक्शन के `CrashRoundPrepared` इवेंट में सार्वजनिक होता है।
2. **दांव**: खिलाड़ी अपने दांव लगाते हैं। गुप्त वैल्यू छिपी रहती है; कमिट यह गारंटी देता है कि उसे बदला नहीं जा सकता।
3. **राउंड की शुरुआत / एंट्रॉपी दर्ज करना**: राउंड शुरू होने पर (`start_game` इंस्ट्रक्शन), प्रोग्राम Solana के `SlotHashes` sysvar से **सबसे हाल का स्लॉट हैश** पढ़ता है और उसे राउंड में सेव करता है। ऐप इस वैल्यू को राउंड का *ब्लॉक हैश* कहता है। **अब क्रैश पॉइंट पूरी तरह तय हो चुका है** (यह सेव किए गए स्लॉट हैश और कमिट की गई गुप्त वैल्यू का शुद्ध फ़ंक्शन है), लेकिन जिसे गुप्त वैल्यू नहीं पता, वह अभी इसे निकाल नहीं सकता। यह वैल्यू `CrashGameStarted` इवेंट में सार्वजनिक होती है।
4. **राउंड चलता है**: मल्टीप्लायर चढ़ता है और खिलाड़ी कैश आउट करते हैं।
5. **रिवील**: बैकएंड गुप्त वैल्यू सबमिट करता है (`crash` इंस्ट्रक्शन)। प्रोग्राम **ऑन-चेन सत्यापित करता है** कि `sha256(secret)` कमिट के बराबर है (मेल न खाने पर ट्रांज़ैक्शन फ़ेल हो जाता है), फिर ख़ुद क्रैश पॉइंट निकालता है और राउंड को अंतिम रूप देता है। `CrashRoundFinalized` इवेंट गुप्त वैल्यू, स्लॉट हैश और अंतिम क्रैश पॉइंट प्रकाशित करता है।

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

क्रैश पॉइंट ठीक इस तरह निकाला जाता है (यही वह गणित है जो ऑन-चेन प्रोग्राम चलाता है: पूर्णांक गणित, राउंडिंग का कोई अचंभा नहीं):

```text theme={null}
इनपुट
  blockhash   32 बाइट   राउंड की शुरुआत में सेव किया गया Solana स्लॉट हैश
  secret      32 बाइट   अंत में रिवील की गई ऑपरेटर की गुप्त वैल्यू (sha256(secret) के रूप में कमिट की गई)
  edge_bps    पूर्णांक    बेसिस पॉइंट में हाउस एज (शुल्क और सीमाएं देखें; 150 = 1.5%)

गणना
  hash  = sha256( blockhash ‖ secret )        // 64-बाइट इनपुट: पहले blockhash, फिर secret
  X     = u32_be( hash[0..4] )                // हैश के पहले 4 बाइट, big-endian unsigned 32-bit
  X'    = min( X, 2^32 − 1000 )               // सुरक्षा सीमा: नीचे का हर (denominator) कभी 1000 से कम नहीं होता

  crash_bps = max( 10000, floor( (10000 − edge_bps) × 2^32 / (2^32 − X') ) )

नतीजा
  क्रैश मल्टीप्लायर = crash_bps / 10000        // उदाहरण: 29948 → 2.9948x
```

दोबारा गणना करते समय ध्यान देने लायक बारीकियां:

* जोड़ने का क्रम है **पहले blockhash, फिर secret**।
* `X` को SHA-256 आउटपुट के **पहले 4 बाइट** से **big-endian** में पढ़ा जाता है।
* सभी भाग **floor** (पूर्णांक) भाग हैं।
* `max(10000, …)` की निचली सीमा का मतलब है कि मल्टीप्लायर कभी 1.00x से नीचे नहीं जाता, और `X` पर लगी सीमा बेहद छोटे हर (denominator) को रोकती है।

### हल किया गया उदाहरण

`X = 0xABCD1234` (2,882,343,476) और मौजूदा 1.5% एज (`edge_bps = 150`) के साथ:

```text theme={null}
denominator = 2^32 − 2882343476 = 1412623820
crash_bps   = floor( 9850 × 2^32 / 1412623820 ) = 29948
crash       = 2.9948x
```

### वितरण कैसा दिखता है

यह फ़ॉर्मूला एकसमान `X` को क्लासिक क्रैश कर्व में बदल देता है। किसी राउंड के कम से कम मल्टीप्लायर `m` तक पहुंचने की संभावना लगभग यह है:

```text theme={null}
P(crash ≥ m) ≈ (1 − edge) / m
```

मौजूदा 1.5% एज पर: लगभग 49.25% राउंड 2.00x तक पहुंचते हैं, लगभग 9.85% राउंड 10x तक पहुंचते हैं, और लगभग 1.5% राउंड 1.00x पर तुरंत क्रैश हो जाते हैं (हाउस एज यहीं से आता है)। हर राउंड पर लागू होने वाला एज वह वैल्यू है जो रिवील के समय ऑन-चेन कॉन्फ़िगर है; मौजूदा वैल्यू [शुल्क और सीमाएं](/hi/docs/fees-and-limits) में दी गई है।

## क्या गारंटीशुदा है, और क्या नहीं

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

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

**ईमानदार चेतावनियां** (यह कमिट-रिवील है, VRF नहीं):

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

<h2 id="verify-a-round">
  Crash राउंड को सत्यापित कैसे करें?
</h2>

ऐप में हर ख़त्म हुए राउंड के विवरण में रिवील की गई गुप्त वैल्यू और ब्लॉक हैश दिखते हैं, साथ ही तीनों ट्रांज़ैक्शन के लिंक और एक निष्पक्षता टूल भी, जो आपके लिए मल्टीप्लायर दोबारा निकालता है। क्रैश पॉइंट ख़ुद दोबारा निकालने की एक छोटी स्क्रिप्ट सहित पूरी क़दम-दर-क़दम प्रक्रिया के लिए [किसी राउंड को सत्यापित करें](/hi/docs/provably-fair/verify-a-round) देखें।

गेम ख़ुद कैसे खेला जाता है (कैश आउट, दांव की समय-सीमा, सीमाएं), इसके लिए [Crash गेम गाइड](/hi/docs/games/crash) देखें।