तीन बाइनरी cargo build --release से बनती हैं: rand-node (नोड और ऑपरेटर कमांड), rand (परिरक्षित वॉलेट) और rand-prover (प्रत्यायोजित प्रूवर)। हर कमांड -h/--help स्वीकार करती है। यह पृष्ठ v0.6.8 रिलीज़ (c9c9bd3c) का वर्णन करता है, वही बिल्ड जिस पर chain 20 चलती है; जहाँ v0.6.7 का व्यवहार भिन्न था, वहाँ यह उल्लेख किया गया है। v0.6.8 से पुराना rand वॉलेट chain 20 पर भेज नहीं सकता, क्योंकि उसका genesis हर प्रूफ़ और हर हस्ताक्षरित संदेश को अपने हैश से बाँधता है। पहली दो बाइनरी अलग-अलग प्रकार की कुंजी रखती हैं: नोड कुंजी एक Dilithium2 कुंजी-युग्म है जो ब्लॉकों पर हस्ताक्षर करती है; वॉलेट कुंजी एक परिरक्षित व्यय कुंजी है जो चेन पर किसी चीज़ पर हस्ताक्षर नहीं करती।
rand-node
rand-node <COMMAND>
keygen Generate a new Dilithium2 key file (refuses to overwrite an existing one)
address Print the address, public key, and libp2p peer id of a key file
genesis Write a genesis.json: every validator key is staked, each --alloc becomes a deposit note
alloc-note Print one genesis alloc note as JSON, RAND or a listed token, for splicing into a genesis
init Initialise a data directory from a genesis file
run Run the node
verify Verify the chain in a data directory without running the node
db Database maintenance on a stopped node's data directory
safety status | clear-halt | release-lock: a stopped validator's consensus safety state
status Show node status
register Print this node's Registration, for the wallet that bonds it in
admit sign | submit: the validator set's vote to admit a new key (admission by vote)
unbond Move bonded stake into unbonding
withdraw Pay released stake and rewards into a note at the payout address
bridge-gov rotate-pq | rotate-pause | cancel-rotation: the bridge's post-quantum rotations
vesting status | claim | revoke | bond | unbond: genesis vesting (chains with a vesting section)
aggregator register | unbond | withdraw — the aggregator role (aggregation chains only)
aggregate The aggregate daemon (aggregation chains only)safety, admit और bridge-gov v0.6.8 में नई हैं। कोई balance और कोई transfer नहीं है: ट्रांसफ़र के लिए परिरक्षित व्यय कुंजी चाहिए, जो केवल वॉलेट के पास होती है।
एक वैश्विक फ़्लैग, --allow-test-fri-profile (या RAND_ALLOW_TEST_FRI_PROFILE=1), init, run और verify को ऐसा genesis स्वीकार करने देता है जिसका fri_profile test हो। यह प्रोफ़ाइल लगभग 17 बिट की साउंडनेस देती है, और genesis फ़ाइल लिखने वाला कोई भी व्यक्ति इसे नामित कर सकता है, इसलिए v0.6.8 से नोड इस फ़्लैग के बिना ऐसा genesis अस्वीकार कर देता है। टेस्ट सूट इसे सेट करते हैं; और किसी को इसे सेट नहीं करना चाहिए।
keygen, address
| कमांड | आर्गुमेंट | डिफ़ॉल्ट |
|---|---|---|
keygen | --out <OUT> | node.key.json |
address | --key <KEY> | अनिवार्य |
keygen मोड 0600 के साथ { "seed": <32-byte hex>, "address": <base58>, "public_key": <hex> } लिखता है। यह फ़ाइल seed की एकमात्र प्रति है। v0.6.8 से keygen पहले से मौजूद --out को अस्वीकार करता है (… already exists or cannot be created; refusing to overwrite a key file) और उसे अछूता छोड़ देता है; कोई --force नहीं है, इसलिए किसी पुरानी फ़ाइल को बदलने के लिए उसे पहले कहीं और हटा दें। v0.6.7 और उससे पहले के संस्करण बिना पूछे उसे अधिलेखित कर देते थे। address, address, public_key (1,312 बाइट hex) और peer_id प्रिंट करता है।
genesis
| आर्गुमेंट | डिफ़ॉल्ट | अर्थ |
|---|---|---|
--chain-id <CHAIN_ID> | 1 | चेन id; ट्रांज़ैक्शन और gossip टॉपिक इससे बँधे होते हैं |
--validator <KEY,STAKE,PAYOUT> | अनिवार्य, दोहराने योग्य | रजिस्टर की एक प्रविष्टि: कुंजी फ़ाइल का पथ या hex सार्वजनिक कुंजी, RAND में स्टेक (कम से कम 1,000), rand1… भुगतान पता |
--epoch-blocks <N> | 1000 | प्रति epoch ब्लॉक |
--alloc <ALLOCS> | कोई नहीं, दोहराने योग्य | एक जमा नोट: rand1<address>=<amount in RAND> |
--out <OUT> | genesis.json | आउटपुट पथ |
--faucet | बंद | केवल testnet: Mint सक्षम करता है। bridge अनुभाग के साथ इसे --testnet चाहिए |
--testnet | बंद | v0.6.8: "testnet": true लिखता है, वह चिह्न जो फ़ॉसेट को bridge अनुभाग के साथ रहने देता है। दिए जाने पर genesis हैश का भाग |
--no-confidential | बंद | Deploy और Call को अक्षम करता है |
--fri-profile <production|test> | production | test असुरक्षित है और टेस्ट सूट के लिए है; init, run और verify ऐसी फ़ाइल को --allow-test-fri-profile के बिना अस्वीकार करते हैं |
--max-program-words <N> | कोई नहीं (4096) | एक deploy जितना बड़ा प्रोग्राम ले जा सकता है, 1..=65535। केवल दिए जाने पर लिखा जाता है; मौजूद होने पर हमेशा genesis हैश का भाग होता है, इसलिए --max-program-words 4096 इसे छोड़ देने से भिन्न चेन है। ऐसी फ़ाइल पर init से पहले हर नोड को v0.4 बाइनरी चाहिए |
--max-proof-bytes <N> | कोई नहीं (2,097,152) | एक ट्रांज़ैक्शन जितना बड़ा प्रूफ़ ले जा सकता है, 1048576..=33554432। हर प्रूफ़ सीमा इसी का अनुसरण करती है |
--max-block-bytes <N> | कोई नहीं (4,194,304) | सबसे बड़ा ब्लॉक, और इसलिए सबसे बड़ा ट्रांज़ैक्शन, 4194304..=67108864, और कम से कम 2 × max_proof_bytes + 1 MiB, या --auth-guest के साथ 3 × max_proof_bytes + 1 MiB, जहाँ एक call तीन प्रूफ़ (bundle, auth, call) ले जाता है |
--max-call-envelope-bytes <N> | कोई नहीं (18,432) | सबसे बड़ा call इनपुट envelope, 18432..=1048576 |
--max-program-public-words <N> | कोई नहीं (0) | एक deploy जितना बड़ा सार्वजनिक इनपुट तय कर सकता है, 0..=65535; 0 किसी को अनुमति नहीं देता |
--tokens <TOKENS.JSON> | कोई नहीं | RPL tokens अनुभाग, JSON फ़ाइल {"registration_fee": …, "mint_cap_per_day": …, "tokens": [...]} के रूप में। छोड़ दिए जाने पर फ़ाइल में ऐसा कोई अनुभाग नहीं होता और उसका हैश पहले जैसा रहता है। bridge अनुभाग को शून्येतर mint_cap_per_day (प्रति बैकिंग, प्रति UTC दिन, टोकन की आठ-दशमलव इकाइयों में) वाला यह अनुभाग चाहिए; सूचीबद्ध टोकन को bridge अनुभाग चाहिए |
--envelope-bytes <N> | कोई नहीं (पुराना 1,348-बाइट envelope) | हर नोट envelope का सटीक आकार: bundle आउटपुट, फ़ॉसेट mint, withdraw, bridge जमा, genesis alloc। केवल 1860 स्वीकार्य है, वह आकार जो हर envelope को एन्क्रिप्टेड memo ले जाने देता है। दिए जाने पर genesis हैश का भाग, और इस कमांड के अपने --alloc नोट सील किए जाने से पहले सेट होता है |
--vesting <VESTING.JSON> | कोई नहीं | vesting अनुभाग: समयबद्ध आवंटन, {"entries": [{"id", "class", "beneficiary", "amount", "start_ms", "cliff_ms", "linear_ms", "step_ms"?, …}]}। v0.6.8 से एक प्रतिसंहरणीय प्रविष्टि revokers (1 से 5 कुंजियाँ), एक threshold और वह treasury सूचीबद्ध करती है जिसे revoke भुगतान करता है, और जो फ़ाइल इनमें से कोई एक छोड़ देती है वह अस्वीकार की जाती है |
--staking <STAKING.JSON> | कोई नहीं | v0.6.8: staking अनुभाग JSON फ़ाइल के रूप में (faucet_budget_per_epoch, bond_activation_epochs, max_weight_bps, max_stake_entry_per_epoch या max_stake_entry_bps_per_epoch, registration_v2, faucet_recipients, faucet_minters, admission_by_vote, slashing), जिसे बिल्ड सत्यापित करता है |
--consensus-domain <0|1> | कोई नहीं (0) | v0.6.8: 1 हर vote, new-view और proposal को इस genesis से बाँधता है |
--bundle-guest <v1|v2|v3> | v1 | hc_bundle के रूप में पिन किया गया bundle guest: v1 (hidden-asset guest जिस पर chain 14 और 15 चलीं), v2 (chain 16 का branch-free guest) या v3 (विभाजित प्राधिकरण: guest व्यय कुंजी के बजाय nk और एक salt लेता है)। v3 को --auth-guest चाहिए |
--auth-guest | बंद | इस बिल्ड के auth guest को hc_auth के रूप में पिन करता है: तब हर bundle व्यय कुंजी पर एक auth प्रूफ़ ले जाता है, जो उसके ट्रांज़ैक्शन से बँधा होता है और जिसका आउटपुट bundle के auth_commit के बराबर होता है। --bundle-guest v3 के साथ अनिवार्य और v1 या v2 के साथ किसी भी फ़ाइल के लिखे जाने से पहले अस्वीकार। अनुपस्थित होने पर फ़ाइल में कोई hc_auth फ़ील्ड नहीं होता |
--hardening-v6 | बंद | v0.6 नियमों को वैधता नियमों (hardening_v6) में बदलता है: pc विंडो, अकॉल करने योग्य deploy, मानक प्रूफ़ आकार और proof-of-work शब्द, call बाइंडिंग और प्रोग्राम-तालिका की न्यूनतम सीमा। अनुपस्थित होने पर भी नोड नीति के रूप में इन्हें अपने पूल में अस्वीकार करता है |
--gas-price <UNITS> | कोई नहीं (कोई gas अनुभाग नहीं) | प्रति gas इकाइयाँ (10⁻⁹ RAND) जो चेन स्वयं किसी call से लेती है। यही फ़्लैग gas अनुभाग (metering: "circuit") लिखता है; नीचे के तीन फ़्लैग इसके बिना अस्वीकार किए जाते हैं। genesis हैश का भाग |
--byte-price <UNITS> | 800, केवल --gas-price के साथ | call प्रूफ़ और इनपुट envelope के प्रति KiB, या उसके किसी अंश, की इकाइयाँ, बाइट 0 से |
--bundle-gas-limit <N> | 20479, केवल --gas-price के साथ | वह सटीक GAS_LIMIT जो हर bundle प्रूफ़ को घोषित करना होता है; कोई अन्य मान घोषित करने वाला bundle प्रूफ़ अस्वीकार किया जाता है। genesis केवल 20479 स्वीकार करता है, जो tier-14 bundle guest के लिए gas_max(14, 0, 0) है |
--gas-dynamic <TARGET_BYTES,TARGET_GAS,ADJUST_BPS> | कोई नहीं (स्थिर मूल्य) | प्रति-ब्लॉक मूल्य नियंत्रक चालू करता है, जिसकी न्यूनतम सीमा अनुभाग के अपने प्रारंभिक gas_price और byte_price हैं। --aggregation के साथ अस्वीकार |
--max-gas-price <UNITS>, --max-byte-price <UNITS> | कोई नहीं (कोई ऊपरी सीमा नहीं) | v0.6.8: वे ऊपरी सीमाएँ जिनसे ऊपर नियंत्रक किसी मूल्य को कभी नहीं उठाता, प्रत्येक कम से कम प्रारंभिक मूल्य के बराबर। --gas-dynamic के बिना अस्वीकार |
--gas-byte-load paying | कोई नहीं (हर ट्रांज़ैक्शन के बाइट) | v0.6.8: केवल call का प्रूफ़ और इनपुट envelope byte_price को बदलते हैं, इसलिए ट्रांसफ़र का ब्लॉक इसे बिल्कुल नहीं बदलता। --gas-dynamic के बिना अस्वीकार; paying एकमात्र मान है |
--binding-domain <0|1> | कोई नहीं (कोई फ़ील्ड नहीं) | v0.6.8: 1 genesis हैश को हर ट्रांज़ैक्शन बाइंडिंग और हर हस्ताक्षरित action संदेश (फ़ॉसेट mint, unbond, withdraw, RPL टोकन संदेश, एग्रीगेटर actions, bridge गवर्नेंस संदेश) में बाँधता है, ताकि इस चेन का प्रूफ़ या हस्ताक्षर किसी अन्य चेन पर सत्यापित न हो। छोड़ दिए जाने पर कमांड चेतावनी देती है: v0.6.8 वॉलेट 14 से 19 के बाहर हर chain id पर genesis-बद्ध रूप सिद्ध करता है, इसलिए 20 से आगे की हर चेन 1 के साथ बनाई जाती है |
--proof-window-blocks <N> | कोई नहीं (256) | v0.6.8: एक विंडो, 256 से 4,096 ब्लॉक, जो तय करती है कि bundle का anchor और उसका time कितना पुराना हो सकता है। rand_getLimits.proof_window_blocks के रूप में प्रदान की जाती है |
--program-state-cell-fee <UNITS> | कोई नहीं (कोई program_state अनुभाग नहीं) | v0.6.8, RPL-2: प्रोग्राम cells, प्रोग्राम vaults और Invoke action चालू करता है, RAND इकाइयों में इस cell शुल्क (अधिकतम 1,000 RAND) के साथ, जो invoke द्वारा बनाए गए प्रत्येक cell के लिए उसकी न्यूनतम शुल्क सीमा में जुड़ता है। इसे --tokens, --gas-price, --hardening-v6 और --auth-guest चाहिए, और किसी के न होने पर किसी भी फ़ाइल के लिखे जाने से पहले उसका नाम लेकर अस्वीकार किया जाता है |
--aggregation <BOND,MAX_COVERS,SUBSIDY,HALVING,WINDOW>, --admitted-shape <…> | कोई नहीं | aggregation अनुभाग; v0.6.8 बिल्ड ऐसे genesis पर शुरू होने से इनकार करता है जिसमें यह हो |
प्रत्येक --alloc के लिए एक alloc पंक्ति प्रिंट करता है, फिर genesis हैश, वैलिडेटर और नोट की संख्या, epoch की लंबाई, पाँच सीमाएँ, hc_bundle और hc_auth (--auth-guest के बिना none), फिर gas पंक्ति: gas: price P/gas, B/KiB, bundle limit N, dynamic: target … B / … gas, adjust … bps, floor …/…, ceiling …/…, byte load all|paying, या --gas-price के बिना gas: none, और --program-state-cell-fee के साथ एक program_state: cell fee N RAND पंक्ति। init वही gas पंक्ति प्रिंट करता है। पाँचों सीमा फ़्लैग एक जैसा व्यवहार करते हैं: छोड़ दिए जाने पर फ़ाइल में ऐसा कोई फ़ील्ड नहीं होता और चेन डिफ़ॉल्ट पर चलती है; दिए जाने पर फ़ील्ड genesis हैश का भाग होता है, भले ही उसका मान डिफ़ॉल्ट हो। chain 20 इन फ़्लैग के साथ बनाई गई थी (deploy/cut-chain20-genesis.sh):
--max-program-words 65535 --max-proof-bytes 4194304 --max-block-bytes 20971520 \
--max-call-envelope-bytes 65536 --max-program-public-words 32768 \
--tokens tokens.json \
--bundle-guest v3 --auth-guest --hardening-v6 \
--gas-price 100 --byte-price 800 --bundle-gas-limit 20479 --gas-dynamic 10485760,262144,1250 \
--max-gas-price 10000 --max-byte-price 80000 --gas-byte-load paying \
--envelope-bytes 1860 \
--testnet --binding-domain 1 --proof-window-blocks 1024 --program-state-cell-fee 10000000 \
--epoch-blocks 1000 --faucet --fri-profile productionचेन 18 और 19 को --envelope-bytes 1860 तक के समान फ़्लैग के साथ कट किया गया था, और v0.6.8 के किसी भी फ़्लैग के बिना। प्रूफ़ की सीमा 4 MiB है, जो चेन 13 से 16 के 8 MiB से कम है: स्प्लिट-ऑथराइज़ेशन ट्रांज़ैक्शन में अधिकतम तीन प्रूफ़ होते हैं, और 3 × 4 MiB + 1 MiB 20 MiB के ब्लॉक में समा जाता है। tokens.json में 1 RAND का registration_fee, 10000000000000 का mint_cap_per_day, max_tokens 4096, burn_registration_fee और bound_note_value होते हैं, तथा zUSD अपने सात बैकिंग के साथ सूचीबद्ध है। कोई --bridge फ़्लैग नहीं है, और कट स्क्रिप्ट अब भी bridge, staking और consensus_domain सेक्शन बाद में फ़ाइल में जोड़ती है (चेन 20 पर: आठ PQ गार्डियन कुंजियों के साथ गार्डियन सेट 1 पर ब्रिज, पॉज़ कुंजी, rules_v2, rotation और fees; फ़ॉसेट अनुमति-सूची, admission_by_vote और 2,500 bps के प्रवेश बजट वाला staking सेक्शन; consensus_domain: 1; और zUSD के जेनेसिस नोट, जो alloc-note --asset 1 --envelope-bytes 1860 से बनाए गए)। मान्य जेनेसिस हैश वही है जो init तैयार फ़ाइल पर प्रिंट करता है।
प्रत्येक --alloc नई कमिटमेंट रैंडमनेस के साथ एक डिपॉज़िट नोट बनाता है, इसलिए दो बार कट करने पर दो अलग हैश मिलते हैं। यह कमांड हमेशा नोट का ओपनिंग cm और amount के साथ लिखता है, जो tokens सेक्शन वाली चेन के लिए आवश्यक है:
"alloc": [
{ "cm": "<64 hex>",
"envelope": { "kem_ct": "<hex>", "to_receiver": "<hex>", "to_sender": "<hex>", "body": "<hex>" },
"amount": 1000000000000,
"opening": { "pk": "<64 hex>", "time": 0, "r": "<64 hex>" } }
]इसलिए फ़ाइल प्रकाशित होते ही जेनेसिस नोट का स्वामी और राशि डिज़ाइन से सार्वजनिक होते हैं; केवल यह निजी रहता है कि उसे बाद में कब और किसमें खर्च किया गया। जेनेसिस एक बार कट करें और फ़ाइल सँभालकर रखें।
alloc-note
--to <rand1…> (आवश्यक), --amount <N> (आवश्यक), --asset <INDEX> (डिफ़ॉल्ट 0), --envelope-bytes <N> (डिफ़ॉल्ट: पुराना फ़ॉर्मेट)। एक alloc नोट को JSON के रूप में प्रिंट करता है, जो --to के लिए उसी तरह सील किया जाता है जैसे genesis --alloc किसी नोट को सील करता है। जो जेनेसिस envelope_bytes सेट करता है, वह मेल खाते --envelope-bytes के बिना सील किए गए नोट को अस्वीकार करता है। --amount एसेट की पूर्ण इकाइयों में है: RAND के लिए नौ दशमलव, ब्रिज किए गए टोकन के लिए आठ (एसेट 1 पर 10 का अर्थ 10 zUSD है)। किसी सूचीबद्ध टोकन के नोट के लिए आवश्यक है कि उस टोकन के बैकिंग में ऐसी locked राशियाँ हों जिनका योग ठीक उसके नोटों के बराबर हो।
init
| आर्गुमेंट | अर्थ |
|---|---|
--datadir <DATADIR> | बनाई जाने वाली डेटा डायरेक्टरी |
--genesis <GENESIS> | जेनेसिस फ़ाइल; <datadir>/genesis.json में कॉपी की जाती है |
जेनेसिस हैश और genesis वाली ही gas: पंक्ति प्रिंट करता है।
run
| आर्गुमेंट | डिफ़ॉल्ट | अर्थ |
|---|---|---|
--datadir <DATADIR> | आवश्यक | इनिशियलाइज़ की गई डेटा डायरेक्टरी |
--key <KEY> | आवश्यक | कुंजी फ़ाइल: वैलिडेटर पहचान, p2p पहचान, शुल्क प्राप्तकर्ता |
--listen <LISTEN> | /ip4/0.0.0.0/tcp/30303 | libp2p का listen multiaddr, दोहराने योग्य |
--bootstrap <BOOTSTRAP> | कोई नहीं, दोहराने योग्य | /ip4/<ip>/tcp/<port>/p2p/<peer-id>, शुरुआत में और डिस्कनेक्ट रहने पर हर 30 s पर डायल किया जाता है। v0.6.8 से इसकी पीयर id आरक्षित होती है |
--reserved-peer <PEER_ID> | कोई नहीं, दोहराने योग्य | v0.6.8: ऐसा पीयर जिसे इनबाउंड कनेक्शन सीमा के पार प्रवेश दिया जाता है और जिसे सिंक बजट में वैलिडेटरों के हिस्से से सेवा दी जाती है। बूटस्ट्रैप और हर वह वैलिडेटर जिसकी हस्ताक्षरित पीयर बाइंडिंग यह नोड देख चुका है, इसके बिना ही आरक्षित होते हैं; नई कट की गई चेन पर, जिसके स्टोर में अभी कोई बाइंडिंग नहीं है, फ़्लीट के वैलिडेटरों को यहाँ सूचीबद्ध करें |
--strict-gossip | बंद | v0.6.8: gossipsub का सख़्त सत्यापन, जो केवल वैध लेखक हस्ताक्षर, अनुक्रम संख्या और स्रोत वाले संदेश स्वीकार करता है। सख़्त और अनुमतिशील नोड आपस में काम करते हैं, इसलिए इसे एक-एक नोड करके लागू किया जा सकता है |
--rpc <RPC> | 127.0.0.1:8545 | ऑपरेटर का JSON-RPC लिसनर: हर मेथड, और यह loopback पर भरोसा करता है। इसे loopback पर ही रखें और कभी कोई सार्वजनिक एंडपॉइंट इसकी ओर फ़ॉरवर्ड न करें |
--public-rpc <ADDR> | बंद | v0.6.8: एक दूसरा, सार्वजनिक लिसनर जिसमें निश्चित मेथड सेट है (कोई व्यूइंग-की मेथड, rand_mint या rand_getPeers नहीं), कोई बैच नहीं, कोई WebSocket नहीं और सभी कॉलरों के लिए एक ही मीटर; रिवर्स प्रॉक्सी या SSH फ़ॉरवर्ड को इसी की ओर इंगित करना चाहिए (JSON-RPC) |
--rpc-viewing-token-file <PATH> | बंद | v0.6.8: --rpc के व्यूइंग-की मेथड पर Authorization: Bearer <first line of the file> (32 या अधिक अक्षर) अनिवार्य करें |
--validator | बंद | इस कुंजी के साथ कंसेंसस में भाग लें |
--no-mdns | बंद | LAN डिस्कवरी अक्षम करें |
--block-interval-ms <MS> | 1000 | प्रस्तावों के बीच न्यूनतम अंतराल |
--view-timeout-ms <MS> | 3000 | आधार व्यू टाइमआउट; हर लगातार टाइमआउट पर दोगुना होता है, अधिकतम 8× तक |
--verify-chain <MODE> | quick | off, quick, full |
--keep-raw-proofs | बंद | एग्रीगेशन चेन पर आर्काइव मोड |
--prune-history <WINDOW> | कोई नहीं (सब कुछ रखें) | केवल इतना ब्लॉक इतिहास रखें, <n>m, <n>h या <n>d, कम से कम 1h: पुराने ब्लॉकों का ब्लॉक, QC, ट्रांज़ैक्शन और रसीदें हट जाती हैं; लेजर बना रहता है। चेन 20 पर 26 में से 24 वैलिडेटर 24h चलाते हैं और दो नोड आर्काइव हैं; आर्काइव और मेननेट नोड इसे कभी सेट नहीं करते। इस सीमा से नीचे की ऊँचाई के लुकअप -32010 लौटाते हैं (JSON-RPC) |
--min-free-disk-mb <MB> | 1024 | डेटा डायरेक्टरी के फ़ाइलसिस्टम पर इससे कम खाली स्थान होने पर शुरू होने से इनकार करता है; इसके चार गुने से कम होने पर rand_getHealth disk_low बताता है। 0 इस सुरक्षा जाँच को अक्षम करता है |
--rpc-viewing-open | बंद | non-loopback कॉलरों को व्यूइंग-की मेथड उपयोग करने दें; केवल किसी प्रमाणीकरण करने वाली परत के पीछे |
--gas-price <UNITS> | 100 | प्रति गैस इकाइयाँ (10⁻⁹ RAND), जो इस नोड का पूल किसी कॉल से उसके प्रूफ़ हेडर के gas_max पर माँगता है। यह प्रवेश नीति है, चेन का नियम नहीं: सस्ती कॉल वाला ब्लॉक फिर भी वैध है। --byte-price 0 के साथ 0 कोई नीति नहीं चलाता। जिस चेन के जेनेसिस में gas सेक्शन है, जैसा चेन 20 में है, वहाँ चेन की अपनी कीमतें ही वैधता का नियम हैं |
--byte-price <UNITS> | 800 | किसी कॉल के प्रूफ़ और इनपुट एनवेलप के प्रति KiB, या उसके किसी अंश, पर इकाइयाँ, बाइट 0 से, उसी नीति के अंतर्गत |
--prover <ADDR> | बंद | डेलीगेटेड प्रूवर (prover_* JSON-RPC) को इस पते पर होस्ट करें: इसका अपना लिसनर, जो --rpc से भिन्न होना चाहिए। <prover-home>/prover.key.json के बिना नोड शुरू होने से इनकार करता है; यह फ़ाइल rand-prover keygen से बनती है |
--prover-home <DIR> | <datadir>/prover | प्रूवर की prover.key.json और pairings.json |
--prover-accept-spend-key | हटाया गया | v0.6.8 से स्टार्टअप पर अस्वीकृत: यह फ़्लैग मिलने पर run नोड कुंजी पढ़ने से पहले ही फ़्लैग का नाम बताते हुए बाहर निकल जाता है। अब कोई प्रूवर स्पेंड-की विटनेस स्वीकार नहीं करता; इसे यूनिट फ़ाइल से हटा दें। v0.6.7 पर यह बंडल गेस्ट v1 या v2 वाली चेनों के लिए स्पेंड-की विटनेस स्वीकार करता था |
--prover-max-parallel <N> | 1 | होस्ट किया गया प्रूवर एक साथ जितने प्रूफ़ चलाता है; जब तक 5.74 GB × N + 1 GiB मेमोरी उपलब्ध न हो, शुरुआत अस्वीकार की जाती है |
--prover-max-queue <N> | 8 | चल रहे जॉब के अतिरिक्त कतार में रखे जाने वाले जॉब |
--prover-cuda | बंद | CUDA बैकएंड पर प्रूफ़ बनाएँ (--features cuda वाला बिल्ड); कोई CPU फ़ॉलबैक नहीं |
--prover-skip-memory-check | बंद | खाली मेमोरी की जाँच छोड़ें |
--prover-fee <RAND>, --prover-fee-address <rand1…> | कोई नहीं | होस्ट किए गए प्रूवर को भेजे गए हर जॉब को चुकाया जाने वाला शुल्क, RAND में अधिकतम नौ दशमलव तक: उस पते के लिए RAND का एक आउटपुट, जो प्रूव किए गए बंडल के भीतर हो। प्रत्येक फ़्लैग के लिए दूसरा आवश्यक है |
--prover-allow-origin <ORIGIN> | ब्राउज़र एक्सटेंशन और loopback पेज | एक ब्राउज़र ऑरिजिन जिसके पेज प्रूवर के उत्तर पढ़ सकते हैं, दोहराने योग्य; एक या अधिक बार दिए जाने पर ये मान ही पूरी सूची होते हैं। * हर वेबसाइट को अनुमति देता है और चेतावनी प्रिंट करता है |
एनवायरनमेंट: RUST_LOG (डिफ़ॉल्ट info,libp2p=warn,libp2p_mdns=off)। Ctrl-C या SIGTERM नोड को सुव्यवस्थित ढंग से बंद करता है।
सार्वजनिक एंडपॉइंट https://rpc.randprotocol.org एक आर्काइव नोड के सामने स्थित अनुमति-सूची प्रॉक्सी है; 2026-10-01 से इसकी अनुमति-सूची सार्वजनिक लिसनर का मेथड सेट है।
safety
रुके हुए वैलिडेटर की कंसेंसस सुरक्षा स्थिति (v0.6.8)। प्रत्येक कमांड डेटा डायरेक्टरी को स्वयं खोलता है, इसलिए कोई भी कमांड चालू नोड के साथ नहीं चलता।
rand-node safety status --datadir <dir>
rand-node safety clear-halt --datadir <dir> --i-have-compared-this-node-with-the-fleet
rand-node safety release-lock --datadir <dir> --i-give-up-this-validators-lockstatus कमिट किया गया हेड, व्यू और अंतिम वोट किया गया व्यू, हाई QC, क्या वैलिडेटर अपने हेड से ऊपर लॉक है, और कोई भी दर्ज सुरक्षा हॉल्ट प्रिंट करता है। जो नोड देखता है कि एक प्रमाणित थ्री-चेन ऐसा ब्लॉक कमिट करने का प्रयास कर रही है जो उसके अपने कमिट किए गए हेड से नहीं निकलता, वह रुक जाता है और इसे दर्ज करता है (ऑडिट v6, CON-5); इसके बाद clear-halt तक run उस रिकॉर्ड के साथ बाहर निकल जाता है। क्लियर करने से पहले इस नोड के हेड की तुलना दो अन्य वैलिडेटरों के हेड से करें, और यदि वह भिन्न हो तो किसी आर्काइव से पुनः सिंक करें। v0.6.8 (CON-4) से “धारित नहीं” उत्तरों का कोई कोरम अब लॉक नहीं छुड़ाता: जो वैलिडेटर ऐसे ब्लॉक पर लॉक है जिसे वह प्राप्त नहीं कर सकता, वह तब तक मौन रहता है जब तक ऐसा प्रस्ताव न आए जिसका justify लॉक से ऊँचा हो या वह ब्लॉक प्राप्त न हो जाए। release-lock स्थायी रूप से सहेजे गए लॉक को कमिट किए गए हेड के प्रमाणपत्र तक नीचे ले आता है; इसे एक समय में एक ही वैलिडेटर पर उपयोग करें, और केवल तब जब ब्लॉक स्थायी रूप से खो गया हो। अपने स्वीकृति फ़्लैग के बिना, लिखने वाला प्रत्येक कमांड बताता है कि वह क्या करेगा और कुछ नहीं बदलता।
verify
| आर्गुमेंट | डिफ़ॉल्ट | अर्थ |
|---|---|---|
--datadir <DATADIR> | आवश्यक | नोड चालू नहीं होना चाहिए |
--mode <MODE> | full | quick या full |
--repair | बंद | क्षतिग्रस्त अंतिम भाग को काट दें; सुरक्षा स्थिति बनी रहती है |
सुसंगत होने पर एग्ज़िट कोड 0, और --repair के बिना कोई समस्या मिलने पर 2।
db
db drop-receipts-index --datadir <DATADIR>, नोड रुका होने पर: v0.3 से पहले के बिल्ड पर वापस जाने से पहले receipts_by_program इंडेक्स हटा दें, क्योंकि वह बिल्ड इस इंडेक्स वाला डेटाबेस नहीं खोल सकता। बाद की शुरुआत रसीदों से इंडेक्स फिर से बनाती है।
status
--rpc <URL> (डिफ़ॉल्ट http://127.0.0.1:8545)। rand_status को ज्यों का त्यों प्रिंट करता है।
register, unbond, withdraw
| कमांड | आर्ग्युमेंट | अर्थ |
|---|---|---|
register | --key, --payout <rand1…>, --rpc, --v2 | इस नोड की कुंजी से हस्ताक्षरित एक हेक्स Registration प्रिंट करता है; चेन आईडी के लिए RPC पढ़ा जाता है, और --v2 के साथ जेनेसिस हैश के लिए भी। जिस चेन का जेनेसिस staking.registration_v2 सेट करता है, जैसा कि चेन 20 का करता है, उस पर --v2 आवश्यक है; वहाँ v1 पंजीकरण अस्वीकार किया जाता है, और अन्य सभी चेनों पर v2 पंजीकरण |
unbond <amount RAND> | --key, --rpc, --no-wait | स्टेक को अनबॉन्डिंग में ले जाता है; निःशुल्क; दो एपॉक बाद निकाला जा सकता है |
withdraw <amount RAND> | --key, --rpc, --no-wait | मुक्त हुए स्टेक और पुरस्कारों को payout पते पर एक नोट में भुगतान करता है, 0.001 RAND आधार शुल्क घटाकर |
admit sign|submit
मतदान द्वारा प्रवेश (v0.6.8)। जिस चेन का जेनेसिस staking.admission_by_vote सेट करता है, जैसा कि चेन 20 का करता है, उस पर नई वैलिडेटर कुंजी तभी पंजीकृत होती है जब मतदान भार के दो-तिहाई से अधिक भार रखने वाले वैलिडेटर उसके प्रवेश पर हस्ताक्षर कर चुके हों।
| कमांड | आर्ग्युमेंट | अर्थ |
|---|---|---|
admit sign | --candidate <key hex, registration hex, or a file holding either>, --key <validator key>, --genesis-hash <hex> | इस वैलिडेटर का मत एक पंक्ति के रूप में प्रिंट करता है, <voter key hex>:<signature hex>, जो जेनेसिस हैश और उम्मीदवार के पते पर बना होता है, ताकि यह ठीक एक ही चेन पर मान्य हो। ऑफ़लाइन: किसी नोड को नहीं पढ़ता |
admit submit | --candidate …, --signature <line> (दोहराया जा सकता है), --rpc, --no-wait | प्रत्येक मत को नोड के जेनेसिस हैश के विरुद्ध जाँचता है (किसी अन्य जेनेसिस या उम्मीदवार के लिए दिया गया मत, या दो बार आया मतदाता, नाम से बताया जाता है), उन्हें क्रम में लगाता है और शुल्क-रहित AdmitValidator सबमिट करता है |
उम्मीदवार वह कुंजी है जो पंजीकरण में होगी; rand-node address --key उसे प्रिंट करता है, और register द्वारा प्रिंट किए गए हेक्स में वह समाहित होती है। प्रवेश कमिट होने के बाद बॉन्ड पहले की तरह होता है (rand bond … --registration) और उस प्रवेश का उपभोग कर लेता है। rand_getAdmitted बताता है कि क्या प्रविष्ट हो चुका है और प्रतीक्षा में है।
bridge-gov
ब्रिज के पोस्ट-क्वांटम रोटेशन (v0.6.8), गार्जियनों और पॉज़-कुंजी धारक के लिए। प्रत्येक चरण --rpc (डिफ़ॉल्ट http://127.0.0.1:8545) से चेन आईडी, उसका बाइंडिंग डोमेन और rand_getBridgeState.rotation_nonce पढ़ता है।
| कमांड | क्या करता है |
|---|---|
rotate-pq message --new-key K… | वर्तमान nonce के लिए हेक्स रोटेशन संदेश प्रिंट करता है, ताकि हर हस्ताक्षरकर्ता पर उसका मिलान किया जा सके |
rotate-pq sign --new-key K… --key F --index I [--possession] | I:signature प्रिंट करता है: किसी वर्तमान PQ गार्जियन की कोरम पंक्ति (I वर्तमान समूह में उसका सूचकांक) या, --possession के साथ, किसी नई कुंजी के धारक की पंक्ति (I नए समूह में उसका सूचकांक); ऐसी कुंजी फ़ाइल को अस्वीकार करता है जो I पर स्थित कुंजी नहीं है |
rotate-pq submit --new-key K… --quorum @F [--possession @F] [--no-wait] | RotatePqGuardians, या possession पंक्तियों सहित V2 क्रिया, तैयार करके भेजता है; जो चेन possession स्वीकार नहीं करती उस पर उसे अस्वीकार करता है, और जो चेन उसे अनिवार्य करती है, जैसे चेन 20, उस पर उसकी अनुपस्थिति को अस्वीकार करता है |
rotate-pause message|sign|submit --new-key K | पॉज़ कुंजी के लिए यही प्रक्रिया (possession सूचकांक 0) |
cancel-rotation sign --kind pq|pause --key PAUSE_KEY | रद्दीकरण संदेश पर 0:signature प्रिंट करता है, जिसे चेन की वर्तमान पॉज़ कुंजी के विरुद्ध जाँचा जाता है |
cancel-rotation submit --kind pq|pause --signature @F | CancelRotation भेजता है, जो लंबित रोटेशन को उसकी विलंब अवधि समाप्त होने से पहले हटा देता है |
--new-key एक हेक्स Dilithium2 सार्वजनिक कुंजी है, या ऐसी कुंजी वाली @file, या @key-file (उसकी सार्वजनिक कुंजी)। हस्ताक्षर पंक्तियाँ index:hex रूप में होती हैं, रिक्त स्थान या नई पंक्तियों से अलग की गई, और # टिप्पणियाँ स्वीकार्य हैं।
vesting status|claim|revoke|bond|unbond
टाइमलॉक्ड जेनेसिस आवंटन में धारक और निरस्तकर्ता का पक्ष, ऐसी चेन पर जिसके जेनेसिस में vesting खंड हो। चेन 20 में ऐसा कोई खंड नहीं है। कुंजी एक rand-node keygen फ़ाइल है।
| कमांड | आर्ग्युमेंट | अर्थ |
|---|---|---|
vesting status <ENTRY> | --rpc | प्रविष्टि वैसी ही जैसी rand_getVesting उसे देता है: उसकी शर्तें, कितना वेस्ट हो चुका है, और अभी कितना क्लेम किया जा सकता है |
vesting claim | --entry <id>, --to <rand1…>, --amount <RAND> या --all, --key, --rpc, --no-wait | जो अनलॉक हो चुका है उसे --to पर एक नोट में भुगतान करता है, 0.001 RAND आधार शुल्क घटाकर; लाभार्थी कुंजी से हस्ताक्षरित |
vesting revoke prepare | --entry, --margin-secs (डिफ़ॉल्ट 600), --out (डिफ़ॉल्ट revoke.json), --rpc | v0.6.8, बिना कुंजी के: वह निरसन लिखता है जिस पर हर निरस्तकर्ता हस्ताक्षर करता है, यानी हेड से --margin-secs आगे तक अभी भी अन-वेस्टेड भाग का एक नोट, जिसका भुगतान प्रविष्टि के जेनेसिस treasury को होता है (कोई --to नहीं है) |
vesting revoke sign | --proposal <file>, --key, --index? | एक निरस्तकर्ता कुंजी, ऑफ़लाइन: <index>:<signature hex> प्रिंट करता है |
vesting revoke submit | --proposal <file>, --signature <index:hex> (दोहराया जा सकता है), --rpc, --no-wait | प्रविष्टि की threshold के कम से कम बराबर हस्ताक्षरों के साथ, prepare के 256 ब्लॉकों के भीतर, निरसन भेजता है। v0.6.7 का एकल-कुंजी vesting revoke --to हटा दिया गया है |
vesting bond <amount RAND> | --entry, --validator <address>, --registration <hex>, --key, --rpc, --no-wait | अपरिवर्तनीय प्रविष्टियाँ: लॉक किए गए RAND को उस वैलिडेटर के स्टेक के रूप में बॉन्ड करता है; जो वैलिडेटर अभी रजिस्टर में नहीं है, उसके लिए वह आवश्यक है जो register ने प्रिंट किया था |
vesting unbond <amount RAND> | --entry, --key, --rpc, --no-wait | बॉन्ड किए गए RAND को वापस लॉक में ले आता है; अनबॉन्डिंग एपॉक के बाद वह फिर से क्लेम किया जा सकता है |
aggregator register|unbond|withdraw, aggregate
aggregation खंड वाली चेन के लिए एग्रीगेटर भूमिका की कमांड: aggregator register --key --bond <RAND> --payout <rand1…> --rpc एक हस्ताक्षरित AggregatorRegistration प्रिंट करता है; aggregator unbond और aggregator withdraw वैलिडेटर वाली जोड़ी के समान हैं। aggregate --key <KEY> [--rpc <URL>] [--watch] [--interval-secs 15] [--no-wait] वह डेमन है जो rand_getUnsealed को पोल करता है, एक एग्रीगेट प्रूफ़ बनाता है और उसे सबमिट करता है। चेन 20 पर निष्क्रिय, क्योंकि उसके जेनेसिस में कोई aggregation खंड नहीं है।
rand (वॉलेट)
वैश्विक विकल्प, सबकमांड से पहले या बाद में:
| विकल्प | परिवेश चर | डिफ़ॉल्ट |
|---|---|---|
--rpc <RPC> | RAND_RPC | http://127.0.0.1:8545; http या https (सार्वजनिक एंडपॉइंट https://rpc.randprotocol.org है)। 64 MiB से बड़ा उत्तर अस्वीकार किया जाता है |
--key <KEY> | RAND_KEY | wallet.key.json; नोट स्टोर उसके बगल में <key>.notes.json पर रहता है। स्टोर उस चेन से बँधा होता है जिसके विरुद्ध उसे स्कैन किया गया था (नोड का rand_getGenesisHash): किसी अन्य चेन की ओर इंगित किए जाने पर, जैसे चेन 19 से 20 के कट के पार रखा गया वॉलेट, उसे खाली कर दिया जाता है और चेतावनी के साथ लीफ़ 0 से फिर से स्कैन किया जाता है। v0.6.8 से हर कमांड ऐसी कुंजी फ़ाइल को अस्वीकार करता है जिसे group या other पढ़ सकें, और सुधार का नाम बताता है (chmod 600 <key>) |
--prover | बंद। बंडल को इस मशीन के बजाय इस वॉलेट से युग्मित प्रूवर (rand prover pair) पर प्रूव करता है; प्रूफ़ को लेन-देन में डालने से पहले यहीं जाँचा जाता है (उसका डाइजेस्ट, उसका आकार और एक स्थानीय सत्यापन)। यह हर उस कमांड पर लागू होता है जो बंडल प्रूव करता है; call और program invoke के लिए केवल भुगतान वाला बंडल प्रूवर के पास जाता है और कॉल प्रूफ़ स्थानीय रहता है। युग्मन के बिना अस्वीकार, और call को छोड़कर --cuda के साथ भी अस्वीकार। चेन 20 जैसी विभाजित-प्राधिकरण वाली चेन पर प्रूवर को व्यूइंग कुंजी nk और एक साल्ट भेजे जाते हैं, स्पेंड कुंजी कभी नहीं: वह इस वॉलेट का पूरा इतिहास पढ़ सकता है, पर खर्च नहीं कर सकता। ऑथ प्रूफ़ हमेशा इसी मशीन पर बनाया जाता है। जिस चेन का बंडल गेस्ट v1 या v2 है, उस पर v0.6.8 प्रूवर से कुछ भी पूछे जाने से पहले ही --prover को अस्वीकार कर देता है | |
--max-prover-fee <RAND> | 1। कोई युग्मित प्रूवर प्रति बंडल अधिकतम इतना शुल्क ले सकता है। इससे ऊपर का कोटेशन किसी भी बंडल के बनने से पहले अस्वीकार कर दिया जाता है; 0 किसी भी शुल्क को अस्वीकार करता है। शुल्क उसी बंडल में एक अतिरिक्त RAND आउटपुट होता है, जो prover fee: <amount> RAND to <fingerprint> के रूप में दिखाया जाता है |
राशियाँ दशमलव RAND में होती हैं, अधिकतम नौ दशमलव स्थानों तक (1, 1.5, .25, 0.000000001)। send, token mint और token burn पर, तथा randpay: लिंक में, टोकन राशि टोकन की प्रदर्शन इकाइयों में होती है, उसकी रजिस्ट्री पंक्ति के अपने decimals के अनुसार (zUSD का 10 यानी 10 zUSD)। bridge-burn, token create --fixed-supply और --initial टोकन की सबसे छोटी इकाई में सादे पूर्णांक लेते हैं, और asset-balance उन्हीं को प्रिंट करता है। जहाँ भी कोई कमांड टोकन लेता है, वह रजिस्ट्री सूचकांक, rpl1… id या 64-हेक्स id लेता है; id को नोड की पूरी रजिस्ट्री सूची (rand_getTokens, हर पृष्ठ) से उसके सूचकांक में बदला जाता है, कभी भी प्रति-टोकन लुकअप से नहीं, जो नोड को बता देता कि कौन-सा टोकन स्थानांतरित होने वाला है। संख्यात्मक सूचकांक नोड तक पहुँचता ही नहीं।
| कमांड | आर्ग्युमेंट | व्यवहार |
|---|---|---|
keygen | --key पर एक नई स्पेंड-कुंजी फ़ाइल लिखता है, मोड 0600; मौजूदा फ़ाइल को अधिलेखित करने से इनकार करता है | |
address | --uri [--amount A] [--asset X] [--memo M], --qr, --qr-png <FILE> | इस वॉलेट का rand1… पता stdout पर छापता है, ठीक पता और एक नई पंक्ति, ताकि $(rand address) किसी स्क्रिप्ट में काम करे, और उसका fingerprint XXXX-XXXX-XXXX-XXXX stderr पर: 16 Crockford base32 वर्ण, पते की एक मानवीय जाँच जो कभी नेटवर्क पर नहीं भेजी जाती। --uri एक randpay: लिंक भी छापता है (पता, साथ में वैकल्पिक राशि, एसेट और मेमो)। --qr उस लिंक को टर्मिनल में QR कोड के रूप में दिखाता है; --qr-png उसे PNG के रूप में लिखता है |
contacts add <NAME> <TO> / list / show <NAME> [--qr] / remove <NAME> | --yes (add) | नामित पते, जिन पर यह वॉलेट नाम से भेज सकता है। TO एक rand1… पता या एक randpay: लिंक है, जिसमें से केवल पता रखा जाता है। add फ़िंगरप्रिंट छापता है और add? [y/N] पूछता है, जब तक --yes न दिया गया हो; उसके बिना, टर्मिनल न होने वाला stdin अस्वीकार किया जाता है। <key>.contacts.json पर संग्रहीत, मोड 0600। नाम 1 से 64 वर्णों का होता है, कभी rand1 या randpay: से शुरू नहीं होता, और अद्वितीय होता है |
prover pair <LINK> / prover pair --trusted / show / forget | --name <NAME>, --yes (pair) | इस वॉलेट को एक प्रत्यायोजित प्रूवर से जोड़ता है। pair वह randprover: लिंक लेता है जो rand-prover pair ने छापा था, ऐसा URL अस्वीकार करता है जो https:// नहीं है (सादा http:// केवल localhost, 127.0.0.1 या [::1] के लिए), फिर बताता है कि प्रूवर को क्या मिलेगा (this prover will receive this wallet's viewing key: it can read the wallet's whole history; it cannot spend) और pair? [y/N] पूछता है; --yes यह प्रश्न छोड़ देता है, और उसके बिना टर्मिनल न होने वाला stdin अस्वीकार किया जाता है। फिर यह प्रूवर से उसका prover_info माँगता है, तब तक अस्वीकार करता है जब तक उसकी कुंजी का फ़िंगरप्रिंट वही न हो जो लिंक में दिया गया है, और <key>.prover.json लिखता है, मोड 0600, किसी भी पिछली जोड़ी को प्रतिस्थापित करते हुए। --trusted (v0.6.8) कोई लिंक नहीं लेता: यह बिल्ड में शामिल लिंक से वैलिडेटरों के प्रूवर पूल, https://prover.randprotocol.org, से जुड़ता है; उसके संचालक इस वॉलेट का इतिहास पढ़ सकते हैं और खर्च नहीं कर सकते। show नाम, URL, फ़िंगरप्रिंट, own और प्रूवर की कुंजी छापता है, टोकन कभी नहीं; forget फ़ाइल हटा देता है। v0.6.7 जोड़ने से पहले नहीं पूछता था |
viewing-key | इस वॉलेट की व्यूइंग कुंजी nk छापता है, 64 hex: वही पैरामीटर जो rand_importViewingKey लेता है। यह वॉलेट द्वारा भेजा या प्राप्त हर नोट पढ़ती है और किसी को खर्च नहीं करती | |
balance | ट्री स्कैन करता है, स्टोर सहेजता है, खर्च-योग्य मूल्य और अव्ययित नोटों की संख्या छापता है | |
sync | --rescan | बैलेंस छापे बिना स्कैन करता है। पहला sync लीफ़ से पहले हर ब्लॉक हेडर पढ़ता है (प्रति कॉल 1,024)। --rescan हर नोट, व्यय-चिह्न और कर्सर भूल जाता है (चेन बाइंडिंग रखते हुए) और लीफ़ 0 से दोबारा स्कैन करता है: यही वापसी का रास्ता है जब किसी नोड ने इस वॉलेट के नोटों को गलत ढंग से खर्च हुआ बताया हो। इसे किसी भरोसेमंद नोड पर चलाना सबसे अच्छा है |
notes | --memo | हर नोट जिसे इस वॉलेट ने खोला है: इंडेक्स, एसेट, राशि, ऊँचाई, spent, pending, और मेमो 24 वर्णों तक काटकर, या --memo के साथ पूरा |
asset-balance [INDEX] | स्कैन करता है, फिर छापता है कि इस वॉलेट के पास किसी एक एसेट में कितना है, या धारित हर एसेट के लिए एक पंक्ति; राशियाँ एसेट की अपनी सबसे छोटी इकाई में | |
history | --memo | हर नोट जो इस वॉलेट ने किसी और के लिए बनाया, notes जैसे ही मेमो स्तंभ के साथ |
send <TO> [AMOUNT] | --asset <INDEX|rand|rpl1…|hex> (डिफ़ॉल्ट 0, RAND), --memo <M>, --fee <RAND> (डिफ़ॉल्ट 0.001), --no-wait, --yes, --cuda | TO एक rand1… पता, एक randpay: लिंक या किसी सहेजे गए संपर्क का नाम है, जिन्हें इसी क्रम में आज़माया जाता है। लिंक की अपनी राशि, एसेट और मेमो वह भरते हैं जो कमांड लाइन छोड़ देती है; AMOUNT केवल तब वैकल्पिक है जब लिंक में राशि हो, और दोनों तरह से दिया गया ऐसा मान जो आपस में मेल न खाए, अस्वीकार किया जाता है। कमांड पुष्टि छापती है, to <contact, if any> · fingerprint XXXX-XXXX-XXXX-XXXX · <amount> <asset> और, मेमो होने पर, अलग पंक्ति में memo: "<text>", फिर --yes न होने पर प्रूफ़ बनाने से पहले पूछती है। स्क्रिप्ट को --yes देना होगा: टर्मिनल न होने वाला stdin stdin is not a terminal: pass --yes to send without confirmation के साथ अस्वीकार किया जाता है। फिर यह एसेट के अधिकतम दो नोट और शुल्क के लिए अधिकतम दो RAND नोट चुनती है, मेमो को केवल भुगतान आउटपुट में सील करती है, एक चार-स्लॉट हिडन-एसेट बंडल का प्रूफ़ बनाती है और, स्प्लिट-ऑथराइज़ेशन चेन पर, व्यय-प्राधिकरण का प्रूफ़ स्थानीय रूप से बनाती है, सबमिट करती है और कमिट की प्रतीक्षा करती है। जिस चेन के जेनेसिस में envelope_bytes नहीं है, उस पर खाली न होने वाला मेमो प्रूफ़ बनाने से पहले अस्वीकार किया जाता है। AMOUNT एसेट की प्रदर्शन इकाइयों में है: RAND के लिए दशमलव RAND, और टोकन अपनी रजिस्ट्री पंक्ति के अपने decimals पर; केवल 0 या rand को RAND पढ़ा जाता है, नोड ने चाहे जो इंडेक्स लौटाया हो। टोकन id नोड से पूछने से पहले डिकोड किया जाता है, और जो लिस्टिंग पंक्ति उसका उत्तर इंडेक्स 0 से या असंगत id फ़ील्डों से दे, वह अस्वीकार की जाती है। पुष्टि टोकन राशि को प्रदर्शन इकाइयों और आधार इकाइयों दोनों में दिखाती है, 10.00000000 zUSD (1000000000 units), ताकि किसी टोकन के decimals के बारे में झूठ बोलने वाला नोड कुछ भी भेजे जाने से पहले पकड़ में आ जाए। एसेट इंडेक्स और शुल्क प्रूफ़ बनाने से पहले छापे जाते हैं। चेन पर टोकन ट्रांसफ़र एक सामान्य बंडल है, RAND भुगतान से अप्रभेद्य; उसका शुल्क RAND में है, और खर्च-योग्य RAND के बिना वॉलेट प्रूफ़ बनाने से पहले अस्वीकार किया जाता है |
bond <VALIDATOR> <AMOUNT> | --registration <hex>, --fee, --no-wait, --cuda | किसी वैलिडेटर पर स्टेक करता है: बंडल राशि को बर्न करता है |
faucet [ADDRESS] | --amount <RAND> (डिफ़ॉल्ट और अधिकतम 100) | केवल testnet: किसी वैलिडेटर नोड से मिंट करने को कहता है। चेन 20 पर फ़ॉसेट केवल अपनी जेनेसिस अनुमति-सूची के 16 वॉलेटों को भुगतान करता है |
program build | --guest <fib|memcpy|bubble_sort|balance_check|private_payment|public_echo|rpl2_counter>, --arg N (दोहराने योग्य), --out <file> (डिफ़ॉल्ट program.json) | एक अंतर्निहित गेस्ट असेंबल करता है; प्रोग्राम id छापता है। rpl2_counter (v0.6.8) RPL-2 का प्रदर्शन प्रोग्राम है |
program deploy <FILE> | .json, एक कच्चा .bin, या वह इमेज कंटेनर जो rand-guest build लिखता है; --public <FILE>, --input <u32> (दोहराने योग्य) या --check-call, --cuda | प्रोग्राम id, hc और शब्द-संख्या छापता है; चेन की सीमा से बड़े प्रोग्राम को (rand_estimateFee के माध्यम से) प्रूफ़ बनाने से पहले अस्वीकार करता है; डिप्लॉय का न्यूनतम शुल्क एक बंडल के माध्यम से चुकाता है, प्रतीक्षा करता है। --public प्रोग्राम के साथ एक सार्वजनिक इनपुट संग्रहीत करता है (व्हाइटस्पेस से अलग किए गए u32 शब्द, या एक ELF .so), चेन के max_program_public_words के भीतर; तब प्रोग्राम id उसे बाँधता है। --input या --check-call के साथ वॉलेट पहले उन निजी इनपुट पर एमुलेटर में एक कॉल का ड्राई-रन करता है और तब तक अस्वीकार करता है जब तक वह कॉल टियर सीमा (14) में न समाए; इस जाँच के लिए कोई प्रूफ़ नहीं बनाया जाता |
program show <ID> | डिप्लॉय किए गए प्रोग्राम का मेटाडेटा | |
program invoke <PROGRAM-ID> | --transition <FILE.json> (आवश्यक), --input N (दोहराने योग्य, निजी), --inputs-file <FILE.json> (u32 का एक JSON ऐरे, अंत में जोड़ा जाता है), --fee <RAND>, --gas-limit <N|max>, --tier T, --no-wait | v0.6.8, RPL-2: प्रोग्राम का एक स्टेट ट्रांज़िशन घोषित करता है और चेन से उसे लागू करवाता है। कुछ भी प्रूव करने से पहले यह जाँचता है कि चेन में program_state अनुभाग है, कि प्रोग्राम मौजूद है, कि ट्रांज़िशन का संदर्भ सेगमेंट नियम में समाता है, कि हर reads प्रविष्टि लाइव सेल से मेल खाती है (rand_getProgramCell; बेमेल होने पर पुराने पड़ चुके सेल का नाम बताता है और कोड 3 के साथ बाहर निकलता है), कि वॉल्ट, इस ट्रांज़िशन की जमा राशि मिलाकर, हर pays प्रविष्टि चुका सकता है, और कि इस वॉलेट के पास जमा और शुल्क के लिए आवश्यक टोकन और RAND है। यह राइट्स से बनने वाले सेल गिनता है, वास्तविक संदर्भ शब्दों पर प्रोग्राम का ड्राई-रन करता है, लेन-देन से बँधी कॉल का प्रूफ़ बनाता है, फिर बंडल का (शुल्क, साथ में burn_r के माध्यम से बर्न किया गया deposit.rand और burn_a के माध्यम से deposit.asset का deposit.amount) और ऑथ प्रूफ़ का। डिफ़ॉल्ट शुल्क घोषित गैस के लिए कॉल का न्यूनतम शुल्क है, साथ में प्रति निर्मित सेल का सेल शुल्क, call जैसी ही दो मूल्य-चरणों की गुंजाइश के साथ। हर भुगतान छापता है और, --no-wait न होने पर, रसीद के आठ outputs। समावेशन के समय पुराना पड़ चुका रीड भी कोड 3 के साथ बाहर निकलता है, ताकि कॉल करने वाला टूल फिर से पढ़कर दोबारा प्रयास करे। कोई इनपुट ट्रांसक्रिप्ट प्रकाशित नहीं करता। ट्रांज़िशन फ़ाइल, जिसका हर फ़ील्ड वैकल्पिक है: {"reads": [{"key", "value"}], "writes": [...], "deposit": {"rand": "<units>", "asset": N, "amount": "<units>", "kind": "none"|"deposit"|"burn"}, "pays": [{"asset": N, "amount": "<units>", "to": "rand1…"}], "mints": [...]}; कुंजियाँ और मान 64-hex Word8 हैं, राशियाँ एसेट की अपनी इकाइयों में दशमलव स्ट्रिंग हैं, to का डिफ़ॉल्ट यही वॉलेट है |
program state <ID> | --cell <64 hex> | v0.6.8: कुंजी क्रम में प्रोग्राम का हर सेल (rand_getProgramCells, अंत तक पेज-दर-पेज), या --cell के साथ एक सेल, अनुपस्थित होने पर 64 शून्य। program_state अनुभाग के बिना चेन पर अस्वीकार किया जाता है |
program vault <ID> | v0.6.8: प्रोग्राम का वॉल्ट (rand_getProgramVault), उसके धारित हर एसेट के लिए एक पंक्ति, राशियाँ इकाइयों में। इस अनुभाग के बिना चेन पर अस्वीकार किया जाता है | |
call <PROGRAM-ID> | --input N (दोहराने योग्य), --expect-public <FILE>, --tier T, --gas-limit <N|max>, --fee, --auditor <rand1…>, --no-envelope, --print-call-key, --cuda | पहले एमुलेटर में कॉल चलाता है और gas: <exact> (declaring <limit>, tier <t>) छापता है: सटीक गैस विटनेस है और कभी वॉलेट से बाहर नहीं जाती, घोषित सीमा प्रूफ़ का सार्वजनिक GAS_LIMIT है। गैस अनुभाग वाली चेन पर डिफ़ॉल्ट सीमा सटीक गैस को 2^(t−2) के गुणज तक ऊपर पूर्णांकित करके मिलती है; max हेडर की अधिकतम सीमा gas_max घोषित करता है, जो टियर से अधिक कुछ प्रकट नहीं करती; N सटीक गैस से कम या अधिकतम सीमा से अधिक होने पर अस्वीकार किया जाता है। अनुभाग के बिना, या --cuda के साथ, डिफ़ॉल्ट max है। फिर प्रोग्राम के सार्वजनिक इनपुट पर कॉल का प्रूफ़ स्थानीय रूप से बनाता है, उसका इनपुट ट्रांसक्रिप्ट सील करता है, एक बंडल के माध्यम से भुगतान करता है, रसीद छापता है। डिफ़ॉल्ट शुल्क घोषित सीमा के लिए न्यूनतम शुल्क है, rand_getLimits द्वारा दिए गए मूल्यों पर BUNDLE_BASE + gas_price·GAS_LIMIT + byte_price·KiB, और जहाँ मूल्य बदलते हैं वहाँ दो मूल्य-चरणों की गुंजाइश, जो fee … RAND (incl. two price steps of headroom) के रूप में छापा जाता है। hardening_v6 चेन पर शुल्क प्रूफ़ बनने से पहले तय होता है, इसलिए डिफ़ॉल्ट प्रूफ़ के स्थान पर चेन की प्रूफ़ सीमा का मूल्य लगाता है, जिससे केवल अधिक भुगतान ही हो सकता है; --fee सटीक राशि चुकाता है। --expect-public प्रूफ़ बनाने से पहले अस्वीकार करता है, जब तक प्रोग्राम का सार्वजनिक इनपुट उस फ़ाइल के शब्द न हो |
open-call <TXHASH> | --call-key <hex>, --as-auditor | किसी कॉल का ट्रांसक्रिप्ट खोलता है, उसे H_IN से जाँचता है, प्रोग्राम दोबारा चलाता है; बेमेल होने पर शून्येतर कोड के साथ बाहर निकलता है |
receipt <TX> | कमिट हो चुकी कॉल की रसीद | |
bridge-mint <ATTESTATION> | hex या @path, --pq <JSON or @path> (आवश्यक), --to <rand1…> (डिफ़ॉल्ट: यह वॉलेट), --fee (डिफ़ॉल्ट: इस क्रिया का न्यूनतम शुल्क), --no-wait, --cuda | गार्डियन-हस्ताक्षरित अटेस्टेशन को नोट के रूप में जमा करता है। --pq गार्डियनों का Dilithium2 सह-हस्ताक्षर कोरम है, [{"index":0,"signature":"<4840 hex>"},…]। किसी भी प्रूविंग से पहले: अटेस्टेशन डिकोड करता है, कोरम को नोड के pq_guardians और चेन id से जाँचता है, प्राप्तकर्ता और एसेट id जाँचता है, सूचीबद्ध इंडेक्स पढ़ता है (rand_getAssets)। जमा नोट की ब्लाइंडिंग अटेस्टेशन के डाइजेस्ट से व्युत्पन्न होती है, r = blake3("rand-deposit-r-1" || mu), वह एकमात्र r जिसे चेन स्वीकार करती है। शुल्क बंडल का प्रूफ़ पूरे लेन-देन के विरुद्ध बनता है, कोरम सहित। नोट का owner, time और r छापता है |
bridge-rotate <ROTATION> | hex या @path, --pq <JSON or @path> (आवश्यक), --fee (डिफ़ॉल्ट: इस क्रिया का न्यूनतम शुल्क), --no-wait, --cuda | वर्तमान PQ सेट के सह-हस्ताक्षर कोरम के साथ गार्डियन-सेट रोटेशन सबमिट करता है, एक ऐसे BridgeAttest के रूप में जो कुछ भी जमा नहीं करता। प्रूविंग से पहले, Rand के सेट को ठीक एक कदम आगे बढ़ाने वाले रोटेशन के अलावा कुछ भी अस्वीकार करता है। बाद में guardian_set_index छापता है |
bridge-pause | --sig <HEX or @path> (आवश्यक), --no-wait | ब्रिज मिंटिंग रोकता है: बंडल-रहित, शुल्क-रहित PauseMints, इसलिए न कुंजी फ़ाइल चाहिए न RAND। फ़ाइल rand-bridge-gov pause का आउटपुट है, पॉज़ कुंजी का 2,420-बाइट हस्ताक्षर hex के रूप में, जो ब्रिज के वर्तमान pause_nonce के लिए बनाया गया हो; भेजे जाने से पहले नोड के pause_key और चेन id से जाँचा जाता है। रोक के दौरान बर्न और रोटेशन खुले रहते हैं |
bridge-unpause | --pq <JSON or @path> (आवश्यक), --no-wait | वर्तमान pause_nonce के लिए बनाए गए PQ गार्डियन कोरम (rand-bridge-gov pq-unpause की फ़ाइल) से रोक हटाता है। बंडल-रहित और शुल्क-रहित; अकेली पॉज़ कुंजी कभी रोक नहीं हटा सकती |
bridge-burn <ASSET> <AMOUNT> <TO_CHAIN> <TOKEN> <TO> | --relayer-fee N, --fee (डिफ़ॉल्ट 0.01), --no-wait, --cuda, --yes | किसी ब्रिज्ड एसेट को बाहर की ओर बर्न करता है: जाँचता है कि TO_CHAIN पर कॉइन TOKEN ASSET को बैक करता है और उसमें कम से कम AMOUNT लॉक है, और कि AMOUNT और रिलेयर शुल्क पूर्ण रिलीज़ इकाइयाँ हैं; फिर एक बंडल का प्रूफ़ बनाता है जो स्लॉट 0–1 में एसेट खर्च करता है, उसका ठीक AMOUNT बर्न करता है (burn_a, burn_asset) और स्लॉट 2–3 से RAND शुल्क चुकाता है। --relayer-fee AMOUNT का एक हिस्सा है, अतिरिक्त शुल्क नहीं। ब्रिज शुल्क वाली चेन पर (rand_getBridgeState.fees), जैसी चेन 20 है, v0.6.8 पहले वह शुल्क छापता है जो चेन रखती है (एसेट में) और वह राशि जो रिलीज़ होगी, और पुष्टि माँगता है; --yes यह प्रश्न छोड़ देता है, और उसके बिना टर्मिनल न होने वाला stdin अस्वीकार किया जाता है। तब लॉक और रिलेयर-शुल्क की जाँचें रिलीज़ होने वाली राशि पर होती हैं |
token create | --name, --symbol, --decimals <0..=9>, --salt <hex32> (न दिए जाने पर यादृच्छिक), फिर या तो --fixed-supply <N> --to <rand1…>, --authority-key-out <FILE> [--initial <N> --to <rand1…>] या (v0.6.8) --program <PROGRAM-ID>, ऐसा टोकन जिसका मिंट प्राधिकार वह प्रोग्राम है, जिसे केवल उसी के invoke मिंट या बर्न करते हैं, जो शून्य आपूर्ति से शुरू होता है और जिसके लिए चेन का program_state अनुभाग आवश्यक है, --fee (डिफ़ॉल्ट: बंडल आधार और रजिस्ट्री का registration_fee; नोड द्वारा 10 RAND से अधिक पंजीकरण शुल्क बताए जाने पर अस्वीकार, इसलिए बड़ा शुल्क जानबूझकर चुकाने के लिए --fee दें), --no-wait, --cuda | रजिस्ट्री के अगले इंडेक्स पर टोकन पंजीकृत करता है: निश्चित आपूर्ति (एक बार मिंट करता है, प्राधिकार none) या Key-प्राधिकृत (एक नई Dilithium2 कुंजी फ़ाइल, 0600 पर लिखी गई, अधिलेखित करने से इनकार)। चेन द्वारा पंजीकरण स्वीकार किए जाने तक प्राधिकार कुंजी <FILE>.pending पर रहती है। यदि कोई अन्य पंजीकरण पहले वह इंडेक्स ले ले, तो another token took index N first — re-run to register at N+1 छापता है; सफल होने पर इंडेक्स और id छापता है, hex और rpl1… में |
token mint | --asset, --to <rand1…>, --amount <N> (टोकन की प्रदर्शन इकाइयाँ), --authority-key <FILE>, --fee (डिफ़ॉल्ट 0.001), --no-wait, --cuda | किसी Key-प्राधिकृत टोकन का और मिंट करता है; यदि टोकन Key-प्राधिकृत नहीं है या कुंजी उसका प्राधिकार नहीं है, तो किसी भी प्रूफ़ से पहले अस्वीकार किया जाता है |
token set-authority | --asset, --authority-key <FILE>, फिर या तो --new-key <FILE> या --renounce, --fee (डिफ़ॉल्ट 0.001), --no-wait, --cuda | किसी Key-प्राधिकृत टोकन को दूसरी कुंजी को सौंपता है, या मिंटिंग का स्थायी रूप से त्याग करता है |
token burn <ASSET> <AMOUNT> | --fee (डिफ़ॉल्ट 0.001), --no-wait, --cuda | इस वॉलेट के पास मौजूद किसी RPL टोकन का AMOUNT, टोकन की प्रदर्शन इकाइयों में, नष्ट करता है; उसकी सार्वजनिक आपूर्ति ठीक उतनी घटती है। ब्रिज्ड टोकन प्रूफ़ बनाने से पहले अस्वीकार किया जाता है: वह bridge-burn से बाहर जाता है |
token info <INDEX|rpl1…|hex> | एक टोकन की पूरी rand_getTokens पंक्ति: नाम, प्रतीक, दशमलव स्थान, प्राधिकार, mint_nonce, कुल आपूर्ति, registered_at, id (hex और id_text) और, ब्रिज्ड होने पर, हर बैकिंग (locked, mint_cap_per_day, minted_today, mint_day) | |
token list | --from <index> (डिफ़ॉल्ट 0), --limit <N> (डिफ़ॉल्ट 1000) | rand_getTokens का एक पेज: enabled, registration_fee, next_index, tokens |
token register-bridged | --name, --symbol, --salt <hex32>, --chain, --token <hex32>, --decimals (पहली बैकिंग के स्रोत के दशमलव स्थान), --pq <JSON or @path> (आवश्यक), --fee (डिफ़ॉल्ट: बंडल आधार और नोड का registration_fee, token create जैसे ही 10 RAND वाले इनकार के साथ), --no-wait, --cuda | जेनेसिस के बाद किसी ब्रिज्ड टोकन को उसकी पहली बैकिंग के साथ पंजीकृत करता है, नोड के list_nonce के लिए बनाए गए PQ गार्डियन कोरम (rand-bridge-gov pq-register की फ़ाइल) द्वारा प्राधिकृत। पहले Rand पर सूचीबद्ध करें, फिर एंडपॉइंट पर setToken |
token list-backing | --asset <index>, --chain, --token <hex32>, --decimals, --pq <JSON or @path> (आवश्यक), --fee (डिफ़ॉल्ट: बंडल आधार), --no-wait, --cuda | किसी ब्रिज्ड टोकन में एक बैकिंग जोड़ता है, नोड के list_nonce पर PQ गार्डियन कोरम (rand-bridge-gov pq-list की फ़ाइल) द्वारा प्राधिकृत |
bridge | ब्रिज की सार्वजनिक स्थिति: गार्डियन, एमिटर, एसेट रजिस्ट्री, बर्न अनुक्रम | |
bridge-message <SEQUENCE> | एक आउटबाउंड बर्न संदेश, शब्दशः | |
fee bundle / fee deploy <words> / fee call <tier> | --public-words M (deploy); --gas N, --bytes B, --keccak-log-height K, --sha256-log-height S (call) | नोड की शुल्क अनुसूची से न्यूनतम शुल्क। गैस अनुभाग वाली चेन पर fee call <tier> --gas N उस घोषित सीमा का मूल्य बताता है जो rand call छापता है, चेन-शीर्ष के मूल्यों पर और बिना गुंजाइश के: स्वयं न्यूनतम शुल्क। --gas के बिना यह अधिकतम सीमा gas_max(tier, K, S) का मूल्य बताता है, यानी ऐसी कॉल की अधिकतम संभव लागत। --bytes कॉल के प्रूफ़ और इनपुट-एनवेलप के बाइट हैं |
tx <HASH> | कमिट हुआ लेन-देन, उसकी ऊँचाई और इंडेक्स सहित | |
tx-key <HASH> | उस लेन-देन के हर उस आउटपुट के लिए एक पंक्ति जिसे इस वॉलेट ने भेजा, प्राप्त किया या चेंज के रूप में रखा: output (bundle:0 … bundle:3, एकमात्र बंडल के चार स्लॉट, या mint:0), भूमिका, राशि (RAND में, या टोकन के लिए N (asset I)), उसमें निहित मेमो (न होने पर -) और वह प्रति-लेन-देन कुंजी जिसके अंतर्गत उसे सील किया गया था। किसी sent पंक्ति की कुंजी प्राप्तकर्ता या ऑडिटर को दें, और rand_checkTransaction <HASH> <KEY> वह एक आउटपुट, मेमो सहित, प्रकट करता है। डमी स्लॉट किसी के लिए नहीं खुलता और उसकी कोई पंक्ति नहीं होती | |
block <ID> | ऊँचाई या हैश द्वारा ब्लॉक | |
head | { height, hash, view } | |
status | rand_status | |
peers | जुड़े हुए पीयर | |
validators | वैलिडेटर रजिस्टर |
--cuda के लिए --features cuda के साथ बना build आवश्यक है और इसका कोई fallback नहीं है; अभी तक कोई PTX नहीं बनाया गया है। यह call-input envelope को सील नहीं कर सकता: rand call --cuda के लिए --no-envelope आवश्यक है। यह केवल gas की अधिकतम सीमा घोषित करता है, और --gas-limit N को अस्वीकार करता है।
CLI जो भी memo और संपर्क नाम प्रिंट करता है (send की पुष्टि, notes, history, tx-key), वे सब पहले एक ही प्रदर्शन नियम से गुज़रते हैं: control characters, Unicode format characters (bidi controls, zero-width characters, soft hyphen) और U+2028/U+2029 को U+FFFD के रूप में दिखाया जाता है, और लगातार आने वाले space separators को एक space के रूप में।
पहला शील्डेड ट्रांसफ़र
rand keygen # wallet.key.json
rand address # rand1… on stdout, its fingerprint XXXX-XXXX-XXXX-XXXX on stderr
rand faucet # testnet, allowlisted wallets only: 100 RAND into a note only you can open
rand balance # balance: 100 RAND
rand send rand1q9f… 1.5 # asks to confirm, then a minute and a half to two minutes of local proving, then the commit
rand notes # the spent note, and the change noteपता साझा करना, और एक memo
rand address --uri --amount 1.5 --memo "invoice #42" --qr # a randpay: link, as a terminal QR
rand contacts add alice rand1q9f… # shows the fingerprint, asks add? [y/N]
rand send alice 1.5 --memo "coffee" # the memo is sealed into the payment output
rand history --memo # alice's row shows the whole memo
rand tx-key <hash> # hand the sent row's key to alice or an auditormemo उसी सील किए गए body के भीतर रहता है जिसमें नोट है, इसलिए जो एक को खोल सकता है वह दूसरे को भी खोल सकता है: भुगतान प्राप्तकर्ता notes के माध्यम से, और उस output की per-transaction key रखने वाला कोई भी व्यक्ति rand_checkTransaction <hash> <key> के माध्यम से। Chain 18 पहली chain है जिसका genesis envelope_bytes निर्धारित करता है; chain 14 से 17 पर --memo को किसी भी proof से पहले ही अस्वीकार कर दिया जाता था।
एक गोपनीय call जिसे आप बाद में फिर से खोल सकते हैं
rand program build --guest balance_check --arg 1000 --out bc.json
rand program deploy bc.json # prints the program id
rand call <id> --input 100 --input 200 --input 300 --input 400
rand open-call <txhash> # inputs: [100, 200, 300, 400] — verdict: faithful (exit 0)एक stateful प्रोग्राम: RPL-2 counter
ऐसी chain पर जिसमें program_state section हो, जैसा कि chain 20 में है। counter ठीक उन्हीं transitions को स्वीकार करता है जो एक cell को पढ़ते हैं और उसके पहले word में एक जोड़कर उसे वापस लिखते हैं; transition में बाकी सब कुछ (bundle क्या जमा करता है, vault क्या भुगतान करता है, प्रोग्राम क्या mint करता है) बिना जाँच के साथ चला जाता है, जिससे यह एक प्रदर्शन मात्र है, न कि ऐसा प्रोग्राम जिसके पीछे मूल्य रखा जाए।
rand program build --guest rpl2_counter --out counter.json
rand program deploy counter.json # prints the program id
rand token create --name "Counter Share" --symbol CTR --decimals 0 --program <id> # say index 2
rand program state <id> --cell 0100000000000000000000000000000000000000000000000000000000000000 # 64 zeros: absent
cat > step.json <<'JSON'
{ "reads": [{ "key": "0100…00", "value": "0000…00" }],
"writes": [{ "key": "0100…00", "value": "0100…00" }],
"deposit": { "rand": "500000000", "kind": "none" },
"pays": [{ "asset": 0, "amount": "200000000", "to": "rand1…" }],
"mints": [{ "asset": 2, "amount": "1" }] }
JSON
rand program invoke <id> --transition step.json # exit 3 if the cell moved since; re-read and retry
rand program vault <id> # asset 0: 300000000 units (0.5 RAND in, 0.2 out)फ़ाइल में … पूरे 64 hex characters के स्थान पर है, जो wallet के लिए आवश्यक हैं।
deploy और call क्या प्रिंट करते हैं
split-authorisation chain पर हर bundle इसी मशीन पर बने दो proofs होता है: tier-10 spend authorisation और tier-14 bundle। chain 18 पर rand v0.6.7 के साथ एक program deploy, 2026-09-30:
proving the spend authorisation on this machine (tier 10; seconds)…
authorisation proved in 6.8s: tier 10, 1368908 bytes
proving the bundle (tier 14; about a minute and a half on a laptop)…
proved in 116.7s: tier 14, 1500710 bytes
submitted deploy <hash>
0 RAND out, 59.8545 RAND change, fee 0.1007 RAND, anchored at height 97831, proved in 116.7s (bundle) + 6.8s (auth)एक call call proof से पहले अपनी gas और अपना शुल्क प्रिंट करता है, फिर भुगतान करने वाले bundle को उसी तरह सिद्ध करता है:
proving the call locally (90 inputs stay private, over the program's 11-word public input)…
gas: 5636 (declaring 6144, tier 12)
fee 0.006191437 RAND (incl. two price steps of headroom)
proved in 29.2s: tier 12, 3346865 bytes, outputs [...]यहाँ 6,144, 5,636 को 2^10 के गुणज तक ऊपर पूर्णांकित करने से प्राप्त होता है, और rand fee call 12 --gas 6144 --bytes <B> उस सीमा का मूल्य tip की कीमतों पर बिना किसी अतिरिक्त गुंजाइश के निर्धारित करता है।
rand-prover
प्रत्यायोजित प्रूवर एक स्वतंत्र binary के रूप में: यह किसी wallet का tier-14 bundle proof किसी दूसरी मशीन पर बनाता है। rand-node run --prover यही सेवा एक node के भीतर चलाता है। हर subcommand --home <DIR> लेता है (env RAND_PROVER_HOME, डिफ़ॉल्ट ~/.rand-prover), वह directory जिसमें prover.key.json और pairings.json रहते हैं।
| कमांड | arguments | व्यवहार |
|---|---|---|
keygen | prover.key.json को mode 0600 के साथ लिखता है, और key का fingerprint प्रिंट करता है; overwrite करने से इनकार करता है | |
pair | --name <LABEL> (आवश्यक), --url <URL> (डिफ़ॉल्ट http://127.0.0.1:8600), --own, --qr | एक token बनाता है, label के अंतर्गत केवल उसका hash संग्रहीत करता है और वह randprover: pairing link प्रिंट करता है जिसे rand prover pair लेता है। token केवल एक बार, link के भीतर, दिखाया जाता है। --url वह पता है जहाँ से wallet इस प्रूवर तक पहुँचता है; --own own=1 जोड़ता है; --qr link को terminal QR code के रूप में भी प्रिंट करता है |
unpair | --name <LABEL> | एक pairing हटाता है; चल रहा प्रूवर फ़ाइल को शुरू होते समय पढ़ता है, इसलिए यह restart पर प्रभावी होता है |
pairings | प्रति pairing एक पंक्ति: label, own या -, निर्माण तिथि | |
run | --listen <ADDR> (डिफ़ॉल्ट 127.0.0.1:8600), --max-parallel <N> (1), --max-queue <N> (8), --per-token <N> (2), --cuda, --skip-memory-check, --allow-origin <ORIGIN> (दोहराया जा सकता है), --fee <RAND> के साथ --fee-address <rand1…>, --accept-spend-key | Ctrl-C या SIGTERM तक prover_* JSON-RPC सेवा देता है। जब तक 5.74 GB × --max-parallel + 1 GiB memory उपलब्ध न हो, शुरुआत अस्वीकार कर दी जाती है। --per-token उन jobs की संख्या है जो एक pairing एक साथ queue में या proving में रख सकता है। --accept-spend-key v0.6.8 में हटा दिया गया है: run इसके साथ शुरू होने से इनकार करता है, और प्रूवर केवल viewing-key witnesses स्वीकार करता है। v0.6.7 पर यह spend-key witnesses स्वीकार करता था, जिन्हें केवल bundle guest v1 या v2 पर चलने वाली chain भेजती है |
chain 20 पर एक प्रूवर को wallet की viewing key nk और एक नया salt प्राप्त होता है। यह खर्च नहीं कर सकता, और वह सब कुछ पढ़ सकता है जो उस wallet ने कभी प्राप्त किया या भेजा: ऐसे प्रूवर के साथ ही pair करें जिसे आप अपना इतिहास दिखाने को तैयार हों। wallet वापस मिलने वाले हर proof की जाँच करता है।
Key फ़ाइल प्रारूप
Node key:
{ "seed": "hex of 32 bytes", "address": "base58 of blake3(\"rand-address\" || public key)", "public_key": "hex of 1312-byte Dilithium2 public key" }Wallet key, संस्करण 2:
{ "version": 2, "spend_key": "hex of 8 little-endian u32 words (64 characters)" }rand keygen इसे mode 0600 के साथ लिखता है, और v0.6.8 से हर rand कमांड ऐसी wallet key फ़ाइल को अस्वीकार करता है जिसे group या other पढ़ सकते हों: हाथ से कॉपी या restore की गई key को फिर से 0600 पर सेट करना होगा (chmod 600 <key>)। wallet key खोने से वे सभी नोट खो जाते हैं जिन्हें वह खोल सकती थी; इस release में कोई recovery phrase नहीं है।