Sibuna पुस्तक 1.0.0-beta.3 दस्तावेज़
भाषा: हिन्दी
English简体中文한국어日本語EspañolDeutschहिन्दीالعربية
इस पृष्ठ पर

भाग VII: ब्राउज़र का proof-of-work इंजन

हम उस WebAssembly मॉड्यूल को देखते हैं जो सर्वर के अपने सत्यापनकर्ता क्रेट को कंपाइल करता है, Web Worker प्रोटोकॉल को, JavaScript फ़ॉलबैक प्रूवर को, और इंटरस्टिशियल को।

एक स्रोत, दो टारगेट

बिल्ड की व्यवस्था

ब्राउज़र सॉल्वर ठीक उन्हीं स्रोतों को कंपाइल करता है जिनसे सर्वर सत्यापन करता है। cmd/sibuna-pow-wasm cdylib प्रकार का एक no_std लाइब्रेरी क्रेट है, जो wasm32-unknown-unknown के लिए बनता है, और जिसकी निर्भरताएँ केवल वर्कस्पेस के क्रेट sibuna-pow और sibuna-crypto हैं:

# cmd/sibuna-pow-wasm/Cargo.toml
[lib]
crate-type = ["cdylib", "rlib"]

[dependencies]
sibuna-crypto = { workspace = true }
sibuna-pow = { workspace = true }

# Cargo.toml (वर्कस्पेस रूट): मॉड्यूल छोटे आकार के लिए बिल्ड होता है
[profile.release.package.sibuna-pow-wasm]
opt-level = "z"
debug = false
strip = true

डेमन इस मॉड्यूल को एम्बेड करता है। उसकी बिल्ड स्क्रिप्ट (cmd/sibuna/build.rs) वर्कस्पेस की टारगेट डायरेक्टरी (target/wasm32-unknown-unknown/wasm/) में एक नेस्टेड cargo rustc -p sibuna-pow-wasm --target wasm32-unknown-unknown --profile wasm चलाती है। नेस्टेड बिल्ड केवल wasm प्रोफ़ाइल की डायरेक्टरी लॉक करता है, इसलिए वह कभी बाहरी बिल्ड की प्रतीक्षा नहीं करता। अंतिम लिंक को --compress-relocations मिलता है। स्क्रिप्ट जाँचती है कि परिणाम WebAssembly के magic बाइट से शुरू होता है, और उसे बिल्ड आउटपुट डायरेक्टरी में कॉपी करती है। WebAssembly टारगेट के बिना बिल्ड के लिए SIBUNA_POW_WASM=<path> इसके बजाय पहले से बना मॉड्यूल एम्बेड करता है। फिर डेमन इन बाइट को अपनी बाइनरी में शामिल करता है:

/// ब्राउज़र सॉल्वर, जिसे `build.rs` `cmd/sibuna-pow-wasm` से बिल्ड करता है।
pub const WASM_SOLVER: &[u8] =
    include_bytes!(concat!(env!("OUT_DIR"), "/sibuna-pow.wasm"));
/// सॉल्वर का Web Worker।
pub const WORKER_JS: &str = include_str!("../../../web/worker.js");

कोई दूसरा इम्प्लीमेंटेशन है ही नहीं जो धीरे-धीरे अलग हो जाए। मॉड्यूल डेमन से /__sibuna/wasm/sibuna-pow.wasm पर एक घंटे के cache हेडर (Cache-Control: public, max-age=3600) के साथ दिया जाता है। ऊपर की प्रोफ़ाइल से बनने पर दोनों टियर के साथ मॉड्यूल का आकार 14,744 बाइट है (benchmarks/results/primitives-latest.json में wasm_bytes)।

एक्सपोर्ट

मॉड्यूल छह फ़ंक्शन एक्सपोर्ट करता है, और वर्कर स्क्रिप्ट उन्हें नाम से कॉल करती है:

एक्सपोर्ट काम
sibuna_get_buffer_ptr() / sibuna_get_buffer_len() 256-बाइट इनपुट बफ़र, जिसमें वर्कर चैलेंज स्ट्रिंग लिखता है
sibuna_solve_step(ptr, len, bits, start, max_steps) Hashcash: start से max_steps नॉनस खोजता है; नॉनस या all-ones सेंटिनल लौटाता है
sibuna_solve_sha256(ptr, len, bits) नॉनस 0 से एक बैच में Hashcash (u32::MAX कदमों के साथ sibuna_solve_step)
sibuna_posw_solve(len, depth, challenges) अनुक्रमिक कार्य: बफ़र पर प्रूवर चलाता है और प्रमाण की लंबाई लौटाता है, या अमान्य आर्ग्युमेंट के लिए 0
sibuna_posw_proof_ptr() प्रूवर वर्कस्पेस में प्रमाण के बाइट की शुरुआत

प्रूवर का वर्कस्पेस, यानी रखे गए ऊपरी स्तर, सहोदर स्टैक और प्रमाण, लगभग 92 KiB का एक स्टैटिक क्षेत्र है; कोई एलोकेटर लिंक नहीं होता, और मॉड्यूल में कोई import नहीं है। Workspace::new एक const fn है, इसलिए स्टैटिक की लागत केवल शून्य की गई मेमोरी है, मॉड्यूल में प्रारंभ किया गया डेटा नहीं।

#[unsafe(no_mangle)]
pub unsafe extern "C" fn sibuna_solve_step(
    challenge_ptr: *const u8,
    challenge_len: usize,
    difficulty_bits: u32,
    start_nonce: u64,
    max_steps: u32,
) -> u64 {
    let challenge: &[u8] = if challenge_len == 0 {
        &[]
    } else {
        // SAFETY: कॉल करने वाला गारंटी देता है कि `challenge_ptr` पर `challenge_len`
        // पढ़ने योग्य बाइट हैं, जो कॉल के पूरे समय नहीं बदलते।
        unsafe { core::slice::from_raw_parts(challenge_ptr, challenge_len) }
    };
    Search::new(challenge)
        .find(difficulty_bits, start_nonce, u64::from(max_steps))
        .unwrap_or(EXHAUSTED)
}

एक्सपोर्ट क्रेट की foreign function सीमा हैं, और वही एकमात्र स्थान है जहाँ उसका unsafe कोड रहता है। इनपुट बफ़र और प्रूवर वर्कस्पेस एक ExportCell में स्टैटिक हैं, जो UnsafeCell के चारों ओर एक रैपर है और एक बताए गए कारण के साथ Sync घोषित है: shared memory के बिना WebAssembly इंस्टेंस एक थ्रेड चलाता है, और हर एक्सपोर्ट लौटने से पहले अपने संदर्भ बनाता है, उनका उपयोग करता है और उन्हें छोड़ देता है, इसलिए किसी सेल में एक समय पर अधिकतम एक ही संदर्भ जीवित होता है। होस्ट पर, जहाँ परीक्षण एक्सपोर्ट को सीधे कॉल करते हैं, केवल परीक्षण के लिए बना एक mutex उन्हें क्रम में लगाता है। panic संदेश फ़ॉर्मेट करने के बजाय trap करता है (unreachable निर्देश), जिससे मॉड्यूल फ़ॉर्मेटिंग कोड और import से मुक्त रहता है; panic तक पहुँचना बनावट से ही असंभव है, क्योंकि sibuna-pow के फ़ंक्शन total हैं और कभी panic नहीं करते।

प्रीफ़िक्स की पूर्व-हैशिंग

Hashcash का भीतरी लूप चैलेंज और कोलन को एक बार सोख लेता है और प्रति नॉनस SHA-256 अवस्था की प्रति (clone) बनाता है, इसलिए हर उम्मीदवार की लागत दो के बजाय एक compression है। खोज sibuna_pow::hashcash::Search है, जिसे ब्राउज़र मॉड्यूल और नेटिव संदर्भ सॉल्वर साझा करते हैं:

pub fn new(challenge: &[u8]) -> Self {
    let mut prefix = Sha256::new();
    prefix.update(challenge);
    prefix.update(b":");
    Self { prefix }
}

pub fn digest(&self, nonce: u64) -> Digest {
    let mut buf = [0u8; NONCE_DIGITS_MAX];
    let mut hasher = self.prefix.clone(); // सोखे गए प्रीफ़िक्स की value copy
    hasher.update(format_decimal(nonce, &mut buf));
    hasher.finalize()
}

pub fn find(&self, bits: u32, start: u64, steps: u64) -> Option<u64> {
    let mut nonce = start;
    for _ in 0..steps {
        if meets_bits(&self.digest(nonce), bits) {
            return Some(nonce);
        }
        nonce = nonce.wrapping_add(1);
    }
    None
}

hasher की अवस्था लगभग 110 बाइट का एक साधारण मान है, इसलिए clone सस्ता है। अनुक्रमिक कार्य का प्रूवर भी यही तरकीब उपयोग करता है, जिसमें स्टेटमेंट \(\chi\) को base_hasher में एक बार सोखा जाता है और हर नोड के लिए clone किया जाता है, और अब सत्यापनकर्ता भी ऐसा करता है: वह हर चैलेंज की गई लीफ़ को उस अवस्था से निकालता है जिसने स्टेटमेंट को एक बार सोख लिया है, जिससे समान डाइजेस्ट के साथ सत्यापन \(t\) compression सस्ता हो जाता है।

सर्वर पर compression फ़ंक्शन x86-64 SHA extension या ARMv8 SHA-2 निर्देशों का उपयोग करता है, जिनका पता रन टाइम पर लगाया जाता है। ब्राउज़र में ऐसे कोई निर्देश नहीं होते, और सॉल्वर लगभग सारा समय पोर्टेबल compression फ़ंक्शन (crates/crypto/src/sha256/portable.rs) में बिताता है। वह फ़ंक्शन WebAssembly के लिए लिखा गया है: 64 राउंड unrolled हैं, message schedule 16 शब्दों की एक विंडो में रहता है जिसमें 16 से आगे का हर राउंड उस शब्द को अधिलेखित करता है जिसकी उसे अब ज़रूरत नहीं, और आठ कार्यकारी चरों को खिसकाने के बजाय राउंड दर राउंड नया नाम दिया जाता है:

fn compress_block(state: &mut State, block: &Block) {
    let mut w = [0u32; 16];
    for (word, bytes) in w.iter_mut().zip(block.as_chunks::<4>().0) {
        *word = u32::from_be_bytes(*bytes);
    }
    let [mut a, mut b, mut c, mut d, mut e, mut f, mut g, mut h] = *state;
    eight_rounds!(w, 0, a, b, c, d, e, f, g, h);
    eight_rounds!(w, 8, a, b, c, d, e, f, g, h);
    // ... राउंड 16 से 55
    eight_rounds!(w, 56, a, b, c, d, e, f, g, h);
    for (word, value) in state.iter_mut().zip([a, b, c, d, e, f, g, h]) {
        *word = word.wrapping_add(value);
    }
}

/// schedule शब्द W(i) लौटाता है; राउंड 16 और आगे के लिए उसकी गणना उसी जगह करता है।
#[inline(always)]
fn schedule(w: &mut [u32; 16], i: usize) -> u32 {
    if i >= 16 {
        let w15 = w[(i + 1) % 16];
        let w2 = w[(i + 14) % 16];
        let s0 = w15.rotate_right(7) ^ w15.rotate_right(18) ^ (w15 >> 3);
        let s1 = w2.rotate_right(17) ^ w2.rotate_right(19) ^ (w2 >> 10);
        w[i % 16] = w[i % 16]
            .wrapping_add(s0)
            .wrapping_add(w[(i + 9) % 16])
            .wrapping_add(s1);
    }
    w[i % 16]
}

हर eight_rounds! चरों के नामों का एक पूरा चक्कर है: मैक्रो उन्हें प्रति राउंड एक स्थान घुमाकर देता है, इसलिए एक राउंड उनमें से केवल दो लिखता है और बाकी छह को कभी नहीं हिलाता। लिटरल राउंड इंडेक्स के साथ हर schedule स्थान एक स्थिरांक है, और पूरा ब्लॉक सीधी रेखा वाला कोड बन जाता है जिसके मान WebAssembly locals में रहते हैं। यह लेआउट V8 में rolled लूप वाले 64-शब्द schedule से लगभग 20% तेज़ चलता है, और नेटिव रूप से लगभग 14% तेज़ (Rust इम्प्लीमेंटेशन पर मापा गया, अक्टूबर 2026)।

वर्कर प्रोटोकॉल

पेज web/worker.js को एक संदेश पोस्ट करता है और प्रगति, फ़ॉलबैक और परिणाम के संदेश प्राप्त करता है:

// पेज -> वर्कर
{ challenge: spec.id, algorithm: spec.algorithm, difficulty: spec.difficulty,
    challenges: spec.challenges }

// वर्कर -> पेज
{ type: 'progress', iterations: 40000 }
{ type: 'fallback', message: 'Wasm unavailable; running JS prover' }
{ type: 'solved', challenge: spec.id, solution: { nonce: '90766' } }  // hashcash
{ type: 'solved', challenge: spec.id, solution: { proof: '<base64url>' } } // posw
{ type: 'error', message: '...' }

वर्कर पहले WebAssembly आज़माता है और जब WebAssembly अनुपस्थित हो, नीति द्वारा ब्लॉक हो, या इंस्टेंशिएट न हो पाए, तब शुद्ध JavaScript पर लौट आता है। JavaScript प्रूवर sibuna-pow के Rust प्रूवर का लेबल दर लेबल अनुकरण करते हैं और byte-identical आउटपुट देते हैं। परीक्षण दोनों टियर के लिए निश्चित नॉनस और प्रमाण तय करते हैं, और SID 0010 की माँग है कि सॉल्वर headless ब्राउज़र में WebAssembly के साथ और JavaScript फ़ॉलबैक के साथ, दोनों तरह पास हो। JavaScript प्रूवर बहुत धीमे हैं, लेकिन वे गारंटी देते हैं कि हर ब्राउज़र पास हो सकता है।

कैलिब्रेशन

किसी एक लैपटॉप के औसत हल से कठिनाई न चुनें। Hashcash की ज्यामितीय टेल होती है; ब्राउज़र के समय में शेड्यूलिंग, तापीय अवस्था, स्टार्टअप और कंपाइलेशन शामिल होते हैं। डिप्लॉयमेंट के कैलिब्रेशन में ब्राउज़र संस्करण, डिवाइस, एल्गोरिदम, पैरामीटर और बार-बार किए गए हलों का वितरण दर्ज होना चाहिए। मॉड्यूल लाने और कंपाइल करने को स्थिर अवस्था की हैशिंग से अलग रखें।

रिपॉज़िटरी के नेटिव प्रिमिटिव मापन किसी फ़ोन या ब्राउज़र पर वादा किए गए हल-समय का साक्ष्य नहीं हैं। एक WASM मॉड्यूल वही अंकगणित चला सकता है जबकि उसकी स्टार्टअप, निष्पादन और मेमोरी लागतें अलग हों: नेटिव रूप से सर्वर SHA-NI से हैश करता है, जबकि ब्राउज़र ऊपर वाला पोर्टेबल compression फ़ंक्शन चलाता है। वर्कर के संदेश वह सीमा बनाते हैं जहाँ इन लागतों को सर्वर के अनुरोध हैंडलर में टाइमर जोड़े बिना मापा जा सकता है।

इंटरस्टिशियल

पेज (web/challenge.html, डेमन में एम्बेडेड) एक अकेली HTML फ़ाइल है जिसमें एक कार्ड, एक अनिश्चित प्रगति पट्टी और एक स्टेटस पंक्ति है। यह अपने ही स्थान (?path=) के लिए चैलेंज माँगता है, वर्कर शुरू करता है, fetch से समाधान पोस्ट करता है, और सफलता पर दोबारा लोड होता है; fetch कॉल jitter वाले घातीय backoff के साथ रीट्राई करते हैं, और 4xx सत्यापन उत्तर उसके निदान शीर्षक के साथ दिखाया जाता है। पेज की Content-Security-Policy ठीक एक स्क्रिप्ट, सॉल्वर ब्लॉक, को उसके SHA-256 हैश से अनुमति देती है, जिसकी गणना डेमन एम्बेडेड पेज से एक बार करता है। स्क्रीन से बाहर रखा एक हनीपॉट लिंक (/__sibuna/honeypot) लोगों और स्क्रिप्ट चलाने वाले ब्राउज़र के लिए अदृश्य है; हर href का अनुसरण करने वाले अंधे क्रॉलर स्वयं पर प्रतिबंध लगवा लेते हैं।