भाग लें

Rand नोड चलाएँ

संदर्भ फ़ुल नोड और उसका वॉलेट Rust में लिखे गए हैं और सोर्स से बिल्ड होते हैं। बिल्ड से दो बाइनरी मिलती हैं: rand-node, यानी नोड और ऑपरेटर टूल, और rand, एक वॉलेट जो शील्डेड स्पेंड कुंजी रखता है, JSON-RPC पर किसी भी नोड से संवाद करता है और हर ट्रांसफ़र तथा हर गोपनीय कॉल के लिए zkVM प्रूवर स्थानीय रूप से चलाता है। एक प्रायोगिक testnet, चेन 21, DigitalOcean droplets पर 26 वैलिडेटरों के साथ लाइव है। इसका ऑडिट नहीं हुआ है और इसका कोई वास्तविक मूल्य नहीं है। दोनों की Linux x86_64 बाइनरी v0.8.0 रिलीज़ के साथ संलग्न हैं, यही वह बिल्ड है जिस पर फ़्लीट को अपडेट किया गया था।

स्थानीय रूप से बिल्ड करें और चलाएँ

bash

# 1. Rust (rustup पिन किया गया 1.98.1 टूलचेन अपने आप ले लेता है) और RocksDB की बिल्ड निर्भरताएँ
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
sudo apt install build-essential clang cmake pkg-config libssl-dev   # Linux

# 2. क्लोन और बिल्ड करें (पहली बार 10–20 मिनट)
git clone https://github.com/randprotocol/fullnode.git
cd fullnode
cargo build --release        # target/release/rand-node, target/release/rand

# 3. इसी मशीन पर दो वैलिडेटरों वाली चेन (RPC 8545 और 8546 पर)
scripts/local-testnet.sh
target/release/rand --rpc http://127.0.0.1:8545 status

# 4. टेस्ट; release मोड में, क्योंकि debug में STARK प्रूविंग धीमी होती है (678 टेस्ट, 2026-09-14 को मापे गए अनुसार लगभग 43 मिनट)
cargo test --workspace --release

सार्वजनिक testnet से ऑब्ज़र्वर के रूप में जुड़ें

चेन 21

# रिलीज़ v0.8.0 (c0878c3f) चेन 21 चलाता है, और इससे पहले की कोई रिलीज़ नहीं चलाती: चेन 21 कंस्ट्रेंट सेट 9 चलाती है, जिसकी verifier कुंजियाँ और प्रूफ़ एन्कोडिंग किसी पुरानी रिलीज़ में नहीं हैं। इसे टैग से बिल्ड करें, या Linux x86_64 पर
# रिलीज़ की बाइनरी लें और उन्हें उसके साथ प्रकाशित SHA256SUMS से जाँचें
git checkout v0.8.0 && cargo build --release
curl -LO https://github.com/randprotocol/fullnode/releases/download/v0.8.0/rand-node -LO https://github.com/randprotocol/fullnode/releases/download/v0.8.0/rand \
     -LO https://github.com/randprotocol/fullnode/releases/download/v0.8.0/msauth-vk-production.bin# पिन की गई मल्टीसिग verifier कुंजी: rand-node इसे अपनी बाइनरी के बगल से लोड करता है और इसके बिना शुरू होने से मना कर देता है
sha256sum rand-node rand msauth-vk-production.bin   # रिलीज़ के मान प्रिंट होने चाहिए (SHA256SUMS, जिस पर SHA256SUMS.sig के रूप में हस्ताक्षर है):
# 324a4ab1029d39e67fc2de36b036341b0f88f13089997d7fe24c596363a58278  rand-node
# e3a38e74ee28743a960fc1c3eb1ac6c538e18dc259411e10afff7f54e268bbf4  rand
# 68facb06c7f321aaf1d4d541acf6b5c0e9d7f17788ed1c9add6c5a8a8f7acd30  msauth-vk-production.bin

# आपके नोड की पहचान: Dilithium2 validator कुंजी और p2p peer id एक ही फ़ाइल में। अपनी स्वयं की बनाएँ
# और उसे चेकआउट से बाहर रखें; रिपॉज़िटरी अब कोई कुंजी ट्रैक नहीं करती
rand-node keygen --out node.key.json

# जेनेसिस रिपॉज़िटरी में ही आता है; हर नोड के पास हू-ब-हू वही फ़ाइल होनी चाहिए।
# init उसका हैश प्रिंट करता है, जो नीचे दिए हैश से मेल खाना चाहिए
rand-node init --datadir ./data --genesis deploy/genesis-chain21.json

# सार्वजनिक validators से जुड़ें (चेन 21 ने चेन 14 की कुंजियाँ बनाए रखीं, इसलिए उसकी peer id और IP भी वही हैं)।
# --validator छोड़ दें: आपकी कुंजी validator सेट में नहीं है। validator को NTP भी चाहिए
rand-node run --datadir ./data --key node.key.json \
    --listen /ip4/0.0.0.0/tcp/30303 --rpc 127.0.0.1:8545 --no-mdns \
    --bootstrap /ip4/164.90.239.200/tcp/30303/p2p/12D3KooWEQEbUwZRgqhDPXhW7vNBmcRcnhUDGUADe81VFdv3ALYe \
    --bootstrap /ip4/165.245.173.74/tcp/30303/p2p/12D3KooWJyc5oDHggAr89e9QrRFBy9Tg8TxXh18yzrb1SM6KKLYw \
    --bootstrap /ip4/188.166.235.187/tcp/30303/p2p/12D3KooWSyX84P1DAbWByLHpRBMLRWD53r3Jj4aqVt6tHoF8B2ZQ

# वॉलेट एक अलग, shielded कुंजी है। उसका rand1… पता लगभग 1.6 KB का टेक्स्ट है
rand keygen && rand address

# faucet मिंट पर validator हस्ताक्षर करता है, इसलिए उसे validator का RPC चाहिए: यह स्थानीय
# दो-validator चेन पर जैसा है वैसा चलता है; ऑब्ज़र्वर "ask a validator node" उत्तर देता है। चेन 21 पर
# faucet केवल उन 16 वॉलेट को मिंट करता है जिन्हें उसका जेनेसिस allowlist करता है, और केवल उन validators से जिनका वह नाम लेता है
rand faucet                                  # 100 RAND एक ऐसे नोट में जिसे केवल आप खोल सकते हैं
rand balance                                 # आपकी कुंजी से ट्री को स्कैन करता है; कोई और नहीं कर सकता
rand send <rand1 address> 1.5              # पुष्टि माँगता है, प्रूफ़ बनाता है (~2 मिनट), कमिट की प्रतीक्षा करता है

वैलिडेटर

कोरम

18 of 26

जेनेसिस

ca76c2766ed6090ac6ba5dad86b724dd5d2b80c0edfaed287cd8b129e663ca9a

गोपनीय कॉल करें

rand

# एक बिल्ट-इन गेस्ट असेंबल करें: यदि चार निजी बैलेंस 1000 से ऊपर की अधिशेष राशि को कवर करते हैं तो उसका भुगतान करें
rand program build --guest private_payment --arg 1000 --out pp.json
rand program deploy pp.json                  # प्रोग्राम id (उसका कंटेंट हैश) प्रिंट करता है

# स्थानीय रूप से प्रूफ़ बनाएँ; चेन पर केवल प्रूफ़, आठ आउटपुट वर्ड और एक सील किया हुआ इनपुट ट्रांसक्रिप्ट जाता है
rand call <program id> --input 400 --input 250 --input 300 --input 75
rand receipt <tx>                            # आउटपुट [1, 0, 25, 0, ...]: अधिशेष, डेटा के रूप में प्रकाशित

# बाद में, ट्रांसक्रिप्ट खोलें और उसे प्रूफ़ द्वारा प्रकाशित H_IN से जाँचें
rand open-call <tx>                          # इनपुट: [400, 250, 300, 75] — निर्णय: सत्य

चेन को प्रोग्राम id, गैस टियर और आठ आउटपुट वर्ड दिखते हैं। उसे बैलेंस कभी नहीं दिखते, और चूँकि शुल्क एक शील्डेड बंडल से चुकाया जाता है, उसे यह भी पता नहीं चलता कि कॉल किसने किया; आउटपुट केवल डेटा हैं, और कोई भी भुगतान कॉलर द्वारा बनाया गया एक बंडल होता है। Apple Silicon पर मापे गए आँकड़े: टियर 10 पर प्रूविंग लगभग 7 s, 80-क्वेरी FRI प्रोफ़ाइल पर लगभग 1.2 MB का प्रूफ़, और वार्म सत्यापनकर्ता कुंजी के साथ सत्यापन लगभग 16 ms में; यह कुंजी नोड प्रति टियर एक बार गणना करता है और सभी प्रोग्रामों में पुनः उपयोग करता है।

आवश्यकताएँ

OS: Linux x86_64 या macOS arm64
Rust: 1.98.1, rust-toolchain.toml द्वारा पिन किया गया; rustup इसे इंस्टॉल करता है
बिल्ड निर्भरताएँ: C++ कंपाइलर, cmake, pkg-config, OpenSSL हेडर (RocksDB)
पहला बिल्ड: 10 से 20 मिनट: RocksDB और Plonky3 सोर्स से
पोर्ट: सार्वजनिक नोड पर TCP 30303 इनबाउंड; RPC 127.0.0.1:8545 पर
सर्वर: 1 से 2 vCPU वाला क्लाउड इंस्टेंस एक testnet वैलिडेटर चला लेता है
घड़ी: वैलिडेटर पर NTP (chrony): वह अपनी घड़ी से 15 s से अधिक आगे के ब्लॉक पर अपना वोट रोक लेता है, इसलिए पीछे चल रही घड़ी चुपचाप वोटिंग बंद कर देती है
प्रूविंग: फ़िलहाल केवल CPU: लैपटॉप पर एक शील्डेड ट्रांसफ़र में लगभग दो मिनट लगते हैं (7 s का प्राधिकरण प्रूफ़ और लगभग 110 s का बंडल प्रूफ़) और लगभग 6 GB मेमोरी; एक छोटा कॉल लगभग 30 s और जोड़ता है

भूमिका चुनें

ऑब्ज़र्वर सभी के लिए खुला

वही बाइनरी, --validator के बिना। चेन को सिंक करता है, हर सर्टिफ़िकेट और हर बंडल तथा कॉल प्रूफ़ का सत्यापन करता है, हर ब्लॉक को पुनः निष्पादित करता है, रसीदों की तुलना करता है, और JSON-RPC सेवा देता है। सार्वजनिक testnet पर एक नई कुंजी यही चलाती है।
वैलिडेटर बॉन्डेड

chained HotStuff के अंतर्गत वोट करता है और प्रस्ताव रखता है। चेन 21 पर, चेन 20 की ही तरह, नए validator को पहले वोट से प्रवेश दिया जाता है: कुल स्टेक के दो-तिहाई से अधिक के धारक validators उसकी कुंजी के लिए एक AdmitValidator action पर हस्ताक्षर करते हैं। फिर वह नोड कुंजी पंजीकृत करता है (rand-node register --v2), किसी वॉलेट से कम से कम 1,000 RAND बॉन्ड करता है, और बॉन्ड के बाद तीसरी 1,000-ब्लॉक epoch सीमा पर सेट में प्रवेश करता है (चेन 18 की दो-epoch बॉन्ड देरी)। चेन 18 की शुरुआत 26 validators से हुई थी, प्रत्येक के पास 1,000 RAND थे; कमिट करने के लिए स्टेक के दो-तिहाई से अधिक, यानी 26 में से 18, का ऑनलाइन रहना और वोट करना आवश्यक है। अपनी स्वयं की कुंजी बनाएँ: अब रिपॉज़िटरी में कोई validator कुंजी नहीं रखी जाती, और पहले की चेनों के लिए कमिट की गई कुंजी फ़ाइलें प्रकाशित सीड हैं।
वॉलेट और प्रूवर स्थानीय

rand क्लाइंट 256-बिट स्पेंड कुंजी रखता है और किसी चीज़ पर हस्ताक्षर नहीं करता: दो प्रूफ़ ही प्राधिकरण हैं, एक छोटा प्रूफ़ जो स्पेंड कुंजी से बनता है और 4-इन-4-आउट बंडल प्रूफ़। यह अपने नोटों के लिए ट्री को स्कैन करता है, दोनों प्रूफ़ आपकी मशीन पर बनाता है, RAND और किसी भी RPL टोकन के लिए एक ही स्वरूप में, और गोपनीय कॉल के लिए प्रोग्राम का प्रूफ़ भी बनाता है। चेन तक केवल प्रूफ़, कमिटमेंट, नलीफ़ायर और सील किए हुए एनवेलप पहुँचते हैं।

नोड नहीं चला रहे? वही वॉलेट iOS, Android, Chrome और Firefox के लिए ऐप के रूप में उपलब्ध है: वॉलेट।

सोर्स

randprotocol/fullnode

GPL-3.0-only · testnet v0.8.0 चलाता है, जो नवीनतम रिलीज़ है

सत्यापन

हर नोड सब कुछ जाँचता है

सिंक करने वाला नोड स्वीकार करने से पहले हर सर्टिफ़िकेट का पुनः सत्यापन करता है, प्रूफ़ सहित हर ब्लॉक को पुनः निष्पादित करता है, और रसीदों की तुलना करता है। स्टार्टअप पर वह अपने डेटाबेस की जाँच करता है, अपनी वोट-सुरक्षा स्थिति को बनाए रखते हुए असंगत हिस्से को काट देता है, और छूटे हुए हिस्से को पीयरों से फिर से प्राप्त करता है।

# नोड रुका हुआ: हैश, QC, हस्ताक्षर, प्रूफ़, रीप्ले
rand-node verify --datadir ./data --mode full
rand-node verify --datadir ./data --repair

लाइव testnet पर चलाए गए फ़ॉल्ट टेस्ट

›चार में से एक वैलिडेटर रोकें: चेन कमिट करती रहती है और लौटने पर नोड कुछ ही सेकंड में बराबरी पर आ जाता है।
›चार में से दो रोकें: कोरम के बिना चेन रुक जाती है और उनके लौटने पर बिना फ़ोर्क के फिर से चल पड़ती है।
›किसी नोड का डेटाबेस भ्रष्ट करें: स्टार्टअप पर पता चलता है, काटा जाता है, पीयरों से पुनः सिंक होता है, और बाद में बाइट-दर-बाइट समान होता है।
›अलग-अलग नोडों से ट्रांसफ़र: सभी कमिट हुए, बैलेंस हर जगह समान, आपूर्ति अपरिवर्तित।
›टूटा हुआ पीयर लिंक रीडायल लॉजिक द्वारा लगभग 30 सेकंड के भीतर फिर से स्थापित हो जाता है।

अभी लागू नहीं

यहाँ इसलिए सूचीबद्ध है ताकि पेपर और नोड के बीच का अंतर अनुमान पर नहीं, स्पष्ट रूप से पढ़ा जा सके।

›प्रति-प्रोग्राम स्थायी स्टेट और क्रॉस-प्रोग्राम कॉल
›वॉलेट में ही एक कंपाइलर: कोई प्रोग्राम या तो अंतर्निहित असेंबल किया गया guest होता है या अलग rand-guest टूलचेन से बनाई गई इमेज
›स्लैशिंग और जेलिंग, ब्लॉक पुरस्कार, शुल्क बाज़ार, hash-sortition लीडर बीकन
›nullifier संचायक, अंतिमता के बाद प्रूफ़ की छँटाई, प्रूफ़ बैचिंग
›SPL Token हस्तांतरण का tier-20 प्रूफ़, और पेपर में वर्णित GPU प्रूवर बाज़ार