provably fair dice स्टेप बाय स्टेप समझें

आप क्या कर पाएंगे

इस गाइड के आखिर तक आप किसी dice दांव के सीड और nonce लेकर हाथ से roll निकाल पाएंगे, बिना कुछ छिपा हुआ रहे। नीचे की हर संख्या हमने Python में मानक hmac और hashlib मॉड्यूल से निकाली, और आप इन्हें हमारे वेरिफायर में दोबारा बना सकते हैं।

स्कीम वही आम स्कीम है जिसे कई crypto casinos dice के लिए इस्तेमाल करते हैं:

• रैंडम bytes: HMAC-SHA256(serverSeed, clientSeed:nonce:round)
• Float: हर float के लिए चार bytes, b1/256 + b2/256^2 + b3/256^3 + b4/256^4
• Roll: floor(float x 10001) / 100

casinos अलग हो सकते हैं, इसलिए इस फॉर्मूले पर भरोसा करने से पहले casino का अपना फेयरनेस पेज देखें।

वैल्यू कहां मिलेंगी

ज़्यादातर casinos पर ज़रूरी वैल्यू "Fairness", "Provably fair" या "Seeds" नाम के पैनल में होती हैं, जहां गेम स्क्रीन या आपकी अकाउंट सेटिंग से पहुंचा जा सकता है। अपनी हिस्ट्री में किसी दांव पर क्लिक करने से आमतौर पर उसका क्लाइंट सीड, nonce और उसका इस्तेमाल किया हैश किया गया सर्वर सीड दिखता है। खुद सर्वर सीड सिर्फ सीड पेयर रोटेट करने के बाद दिखता है, अक्सर पिछले या सामने आए सीड की सूची में। हर वैल्यू हूबहू कॉपी करें। खेलने से पहले हैश किया गया सर्वर सीड casino से बाहर कहीं सेव करें, क्योंकि सामने आए सीड को उसी सेव की गई कॉपी से मिलाया जाता है। वेरिफायर इस्तेमाल करने पर हमारा पेज बताता है कि हर वैल्यू आमतौर पर कहां होती है और नतीजा कैसे पढ़ें।

इनपुट

ये इस गाइड के लिए बनाए गए उदाहरण वाले सीड हैं।

चरण 1: commitment जांचें

सर्वर सीड को टेक्स्ट के रूप में SHA-256 से हैश करें:

SHA-256("a7c41e09...4f19c27e") = 3e29712c704eeff2d868f958cf08e44a1a16ecba4c974af0496e13bccdefaff2

यह खेलने से पहले दिखाए गए हैश किए गए सर्वर सीड से मेल खाता है, इसलिए casino ने वही सीड इस्तेमाल किया जिसके लिए उसने प्रतिबद्धता दी थी। अगर यह मेल न खाता, तो नीचे कुछ भी जांचने लायक न होता। सर्वर सीड हैशिंग पर हमारी गाइड झूठे mismatch की आम वजहें बताती है।

चरण 2: मैसेज बनाएं

क्लाइंट सीड, nonce और round को colons से जोड़ें:

maple-leaf-2026:0:0

Dice को सिर्फ एक float चाहिए, और एक HMAC आठ देता है, इसलिए round 0 पर रहता है। nonce इस सीड पेयर के अंदर दांव का नंबर है। कुछ casinos इसे 0 के बजाय 1 से शुरू करते हैं।

चरण 3: HMAC निकालें

सर्वर सीड को key और मैसेज को डेटा बनाकर HMAC-SHA256 निकालें। HMAC RFC 2104 और NIST FIPS 198-1 में परिभाषित है। आउटपुट 32 bytes का है, जो यहां 64 hex अक्षरों में दिखाया गया है:

bea6dafadb325af8baff8145e3bb9406f7734638ecde39e473200c87fabb0ce0

चरण 4: पहले चार bytes लें

hex अक्षरों की हर जोड़ी एक byte है:

चरण 5: bytes को float में बदलें

हर byte को 256 की बढ़ती घात से भाग दें और नतीजे जोड़ें:

इसे दूसरी तरह से देखें: चार bytes मिलकर 32-bit संख्या 3,198,606,074 बनाते हैं, और float उस संख्या को 2^32 (4,294,967,296) से भाग देने पर मिलता है। नतीजा हमेशा कम से कम 0 और 1 से कम होता है।

चरण 6: float को roll में बदलें

10,001 से गुणा करें:

0.744733511004597 x 10001 = 7448.0798...

नीचे की ओर पूर्ण संख्या में राउंड करें: 7448।

100 से भाग दें: 74.48।

यही इस दांव का roll है।

10,001 ही क्यों?

roll 0.01 के अंतर से 0.00 से 100.00 तक कोई भी वैल्यू हो सकता है। ये 10,001 संभावित वैल्यू हैं, 10,000 नहीं, क्योंकि दोनों छोर शामिल हैं। 10,001 से गुणा करके नीचे राउंड करने से 0 से 10,000 तक की पूर्ण संख्या मिलती है, और 100 से भाग देने पर दो दशमलव वाला roll मिलता है।

चरण 7: जीत या हार तय करें

roll दांव का सिर्फ आधा हिस्सा है। आपकी बेट सेटिंग नतीजा तय करती है। मान लें आपने "roll under 50.00" पर दांव लगाया:

• 74.48, 50.00 से कम नहीं है, इसलिए यह दांव हारता है।

अगर आपने "roll over 50.00" पर दांव लगाया होता, तो यह जीतता। casinos आमतौर पर आपके टारगेट के लिए जीत की संभावना और पेआउट multiplier दिखाते हैं। असली संभावना और multiplier के बीच का अंतर हाउस एज है। provably fair साबित करता है कि roll से छेड़छाड़ नहीं हुई; यह उस एज को नहीं बदलता।

उसी session के अगले दांव

सीड वही रखें और हर दांव के लिए nonce एक बढ़ाएं:

"roll under 50.00" के साथ nonces 1 और 2 जीतते हैं और nonces 0 और 3 हारते हैं। हर नतीजा सीड और nonce से तय है, और आप हर एक को दोबारा बना सकते हैं।

हमारा इस्तेमाल किया कोड

ऊपर की संख्याएं बनाने के लिए हमने यह Python चलाया। यह सिर्फ standard library इस्तेमाल करता है।

import hashlib, hmac, math

server_seed = "a7c41e09d5b3f28e6c1d4a90b7e35f12c8d06e4b9a2f71c35e8d0b6a4f19c27e"
client_seed = "maple-leaf-2026"

print(hashlib.sha256(server_seed.encode()).hexdigest())

for nonce in range(4):
    msg = f"{client_seed}:{nonce}:0".encode()
    digest = hmac.new(server_seed.encode(), msg, hashlib.sha256).digest()
    b = digest[:4]
    f = b[0]/256 + b[1]/256**2 + b[2]/256**3 + b[3]/256**4
    roll = math.floor(f * 10001) / 100
    print(nonce, digest.hex(), list(b), f, roll)

अपने दांव जांचने के लिए अपना सामने आया सर्वर सीड, क्लाइंट सीड और nonce डालें। अगर आपका casino nonces 1 से शुरू करता है, तो range 1 से शुरू करें।

क्या बदलने का तरीका biased है?

चार bytes से बने float की 2^32, यानी 4,294,967,296, संभावित वैल्यू हैं। इन्हें 10,001 rolls में बांटना बराबर नहीं बंटता: 4,294,967,296 = 10,001 x 429,453 + 7,843। यानी 7,843 roll वैल्यू 429,454 संभावित byte पैटर्न से आती हैं और बाकी 2,158 वैल्यू 429,453 से। हर roll वैल्यू पर यह अंतर लगभग 429,000 में 1 है, जो किसी खिलाड़ी के लिए मायने रखने के लिहाज़ से बहुत छोटा है और किसी भी हाउस एज से बहुत कम है।

आपका roll मेल न खाने की आम वजहें

1. nonce एक से खिसका हुआ. ऊपर या नीचे वाला nonce आज़माएं।
2. गलत क्लाइंट सीड. अगर आपने session के दौरान इसे बदला, तो पहले के दांवों ने पुराना इस्तेमाल किया। दांव की जानकारी जांचें। अपना क्लाइंट सीड बदलने पर हमारी गाइड इसे कवर करती है।
3. गलत सीड पेयर. पक्का करें कि सामने आया सर्वर सीड दांव की अवधि का है।
4. अलग स्कीम. कुछ casinos अलग मैसेज फॉर्मेट इस्तेमाल करते हैं, क्लाइंट सीड को key में रखते हैं, या अलग dice फॉर्मूला इस्तेमाल करते हैं।
5. कॉपी की गलतियां. क्लाइंट सीड के आखिर में एक स्पेस HMAC को पूरी तरह बदल देता है।

अगर हर इनपुट सही है, casino यह स्कीम दस्तावेज़ित करता है, और roll फिर भी अलग है, तो दांव, सीड और दस्तावेज़ों के स्क्रीनशॉट सेव करें और casino से संपर्क करें। दांव वेरिफाई करने की हमारी गाइड बताती है कि आगे क्या करें।

सीमा में खेलें

Dice तेज़ है। हर सेकंड कई दांवों पर हाउस एज बहुत जल्दी एक बड़ी कुल दांव राशि पर लागू हो जाता है। शुरू करने से पहले सीमा तय करें और अगर मज़ा न रहे तो हमारा ज़िम्मेदार जुआ पेज देखें।

स्रोत

• RFC 2104, HMAC: Keyed-Hashing for Message Authentication: https://datatracker.ietf.org/doc/html/rfc2104
• NIST FIPS 198-1, The Keyed-Hash Message Authentication Code (HMAC): https://csrc.nist.gov/pubs/fips/198-1/final
• NIST FIPS 180-4, Secure Hash Standard: https://csrc.nist.gov/pubs/fips/180-4/upd1/final
• Python दस्तावेज़, hmac मॉड्यूल: https://docs.python.org/3/library/hmac.html
• Python दस्तावेज़, hashlib मॉड्यूल: https://docs.python.org/3/library/hashlib.html