நிரல்கள்

இந்தப் பக்கத்தைப் பயன்படுத்தி ஒரு நிரலைச் சங்கிலியில் வைத்து அதை அழைக்கலாம்: நிரல் என்பது என்ன, அதை எவ்வாறு உருவாக்குவது, ஓர் அழைப்பு எதை வெளியிடுகிறது, எதை மறைக்கிறது, ஒரு ரசீதை எவ்வாறு திரும்பப் படிப்பது, நீங்கள் எதிர்கொள்ளும் வரம்புகள் ஆகியவற்றை இது விளக்குகிறது. ஒவ்வொரு நிரலும் பொதுக் குறியீடு; ஒவ்வொரு அழைப்பும் ஒரு நிரூபணம். எடுத்துக்காட்டு நிரல்கள் பக்கத்தில் முழுமையான பயன்பாடுகள் உள்ளன; சங்கிலி 20 இல் வரிசைப்படுத்தப்பட்ட நிரல்களின் மூலக் குறியீடு, RPL-2 நிரல்கள் உட்பட (கீழே), randprotocol/example-programs இல் உள்ளது.

நிரல் என்பது என்ன

நிரல் என்பது Rand zkVM-க்கான RV32IM இயந்திரக் குறியீடு: { base_pc: u32, words: Vec<u32> }. அதன் அளவு அதிகபட்சம் சங்கிலியின் நிரல் வரம்பு வரை இருக்கலாம் (சங்கிலி 13 முதல் ஒவ்வொரு சங்கிலியிலும் உள்ளது போலவே சங்கிலி 20 இல் 65,535 சொற்கள்; max_program_words இல்லாத ஜெனிசிஸில், எடுத்துக்காட்டாகச் சங்கிலி 12 இல், 4,096). base_pc 4 இன் மடங்காக இருக்க வேண்டும்; ஒவ்வொரு சொல்லும் ஓர் அறிவுறுத்தலாகக் குறிவிலக்கப்பட வேண்டும் (குறிவிலக்கப்படாத சொல் வரிசைப்படுத்தும்போதே நிராகரிக்கப்படும், இயக்க நேரத்தில் ஒருபோதும் அல்ல). சங்கிலி 19 போலவே சங்கிலி 20-உம் எந்த அழைப்பாலும் தாங்க முடியாத நிரலை வரிசைப்படுத்த மறுக்கிறது: பொதுப் பிரிவு இல்லாவிட்டால் 8,180 சொற்களுக்கு மேல், பொதுப் பிரிவு இருந்தால் அதைவிடக் குறைவு (கீழே). நிரல் உள்ளடக்கத்தால் முகவரியிடப்படுகிறது, அதை மாற்ற முடியாது:

program_id = blake3("rand-program" || base_pc || words)       // the id, with no public input
program_id = blake3("rand-program-2", base_pc || u32_le(len(words)) || words || u32_le(len(public)) || public)   // deployed with --public
code_hash  = hc = Poseidon2 digest of (base_pc, len, words)    // what calls are verified against

ஓர் அழைப்பு என்பது ஒரு STARK நிரூபணம். டைஜெஸ்ட் hc கொண்ட நிரல் சில தனிப்பட்ட உள்ளீடுகளின் மீது இயங்கியது, அறிவிக்கப்பட்ட கேஸ் வரம்புக்கு மேல் செலவிடவில்லை, எட்டு வெளியீட்டுச் சொற்களை வெளியிட்டது என்பதை அது நிரூபிக்கிறது. கணு நிரூபணத்தைச் சரிபார்த்து ஒரு ரசீதைப் பதிவுசெய்கிறது; வேறு எதுவும் நடப்பதில்லை: வெளியீடுகள் தரவு மட்டுமே, விளைவுகள் அல்ல. ஓர் அழைப்பால் RAND-ஐ நகர்த்த முடியாது. அழைப்புக்குக் கட்டணம் செலுத்தும் தொகுப்பில் அழைப்பாளரே மதிப்பை நகர்த்துகிறார். ஒரு நிரலின் வெளியீடுகளின் பொருள், நிரலும் அதன் அழைப்பாளரும் ஒப்புக்கொள்வதே. சங்கிலி 20 இல் Invoke மட்டும் விதிவிலக்கு: அதன் நிரூபணம் அறிவிக்கப்பட்ட ஒரு நிலை மாற்றத்துக்கு உத்தரவாதம் அளிக்கிறது, பேரேடு அந்த மாற்றத்தைச் செயல்படுத்துகிறது (நிரல் நிலை (RPL-2)).

விருந்தினர் நிரல் செய்யக்கூடியவை:

அமைப்பு அழைப்புகள், a7 இல் உள்ள எண்ணின்படி:

நினைவகம்: x0 எப்போதும் பூஜ்ஜியமாக உள்ள 32 பதிவேடுகள்; பூஜ்ஜியத்தில் தொடங்கும் RAM; ஒவ்வொரு முகவரியும் 2³⁰-க்குக் கீழே; தொகுக்கப்பட்ட விருந்தினர் நிரல்களுக்கு 64 KiB அடுக்கு. rand-guest கொண்டு உருவாக்கப்பட்ட நிரல் தனது படிக்க மட்டுமான தரவையும் தொடக்க மதிப்பிடப்பட்ட தரவையும் படிமக் கொள்கலனில் சுமக்கிறது. நிரலின் ஒரு பகுதியான ஏற்றி முன்னுரை, நிரலின் சொந்தக் குறியீடு இயங்கும் முன் அந்தத் தரவை எழுதுகிறது (RISC-V ISA). குறிப்பு உறுதிப்பாடுகள், நலிஃபையர்கள், Merkle சரிபார்ப்புகள் ஆகியவை அமைப்பு அழைப்புகள் அல்ல; அவை POSEIDON2 மீது இயங்கும் நூலக நடைமுறைகள்.

சங்கிலி 18 முதல் (கட்டுப்பாட்டுத் தொகுப்பு 8) ஒவ்வொரு இயக்கமும் கேஸில் அளவிடப்படுகிறது. ஒரு சாதாரண அறிவுறுத்தலுக்கும், அமைப்பு அழைப்புகள் 0, 1, 2, 6 ஒவ்வொன்றுக்கும் தலா 1 கேஸ் ஆகும். n சொற்கள் மீதான POSEIDON2 3 + 3 × ⌈n / 4⌉ கேஸ், ஒரு KECCAK வரிசைமாற்றம் 192 கேஸ், ஒரு SHA256 சுருக்கம் 64 கேஸ். முழு அட்டவணையையும் ஓர் அழைப்பு எதை அறிவிக்கிறது என்பதையும் எடுத்துக்காட்டு நிரல்கள் பக்கத்தில் காணலாம்.

நிரலை உருவாக்குதல்

மூன்று வழிகள் உள்ளன; மூன்றும் RV32IM சொற்களையே உருவாக்குகின்றன:

உள்ளமைந்த அசெம்பிளர். வாலெட்டுடன் கையால் அசெம்பிள் செய்யப்பட்ட ஐந்து விருந்தினர் நிரல்கள் வருகின்றன. வாலெட் அவற்றை { "base_pc", "words" } வடிவ JSON கோப்பாக அசெம்பிள் செய்கிறது:

rand program build --guest private_payment --arg 1000 --out pp.json   # prints the program id
rand program build --guest balance_check --arg 1000 --out bc.json
# guests: fib, memcpy, bubble_sort, balance_check, private_payment, public_echo, rpl2_counter (v0.6.8); --arg is repeatable

rand-guest கொண்டு தொகுக்கப்பட்ட நிரல்கள். circuits களஞ்சியத்தில் உள்ள rand-guest, ஒரு no_std Rust கிரேட்டை (riscv32im-unknown-none-elf, Rust 1.98.1) அல்லது ஒரு C கோப்பகத்தை (clang 23.1.1) படிமக் கொள்கலனாக உருவாக்குகிறது. பிறகு ஒவ்வொரு சொல்லையும் இயந்திரத்தின் குறிவிலக்கியைக் கொண்டு சரிபார்த்து, hc-ஐயும் நிரல் அடையாளத்தையும் அச்சிடுகிறது. உருவாக்கம் வெளிச்சூழலைச் சார்ந்திருப்பதில்லை; எனவே ஒரே மூலக் குறியீடு எந்த இயந்திரத்திலும் அதே hc-ஐத் தரும். சங்கிலிகள் 18 முதல் 20 வரைக்கு, கருவித்தொகுப்பை circuits கமிட் aeacf31 இல் (கிளை feat/v067-circuits) உருவாக்குங்கள். fullnode v0.6.7, v0.6.8 இரண்டும் நிர்ணயித்துள்ள கமிட் அதுவே. அந்தக் கமிட்டில் rand-guest check அமைப்பு அழைப்புகள் 0 முதல் 6 வரை மட்டுமே பட்டியலிடுகிறது. எனவே guest_sdk::poseidon2_len (அமைப்பு அழைப்பு 7)-ஐ அழைக்கும் விருந்தினர் நிரலை இயந்திரம் இயக்கினாலும், உருவாக்கத்தின்போதே அது நிராகரிக்கப்படுகிறது (zkp-circuits சிக்கல் #1). படிப்படியான வழிகாட்டிகள்: Rust நிரலை வரிசைப்படுத்துதல், RISC-V நிரலை வரிசைப்படுத்துதல்.

மொழிபெயர்க்கப்பட்ட நிரல்கள். sbpf2rv ஒரு Solana sBPF ELF-ஐயும், evm2rv EVM இயக்கநேரப் பைட்கோடையும் நிரல்களாக மொழிபெயர்க்கின்றன. அந்த நிரல்களின் வெளியீடுகள் Rand-இன் உரைபெயர்ப்பி விருந்தினர் நிரல்களின் வெளியீடுகளுடன் சொல்லுக்குச் சொல் சமமாக இருக்கும்: Solana டிரான்ஸ்பைலர், Ethereum டிரான்ஸ்பைலர்.

வாலெட்டில் தொகுப்பி இல்லை. rand program deploy மூன்று வடிவங்களை ஏற்கிறது: ஒரு .json கோப்பு, லிட்டில்-எண்டியன் சொற்களைக் கொண்ட மூல .bin கோப்பு, அல்லது rand-guest எழுதும் படிமக் கொள்கலன் (fullnode v0.3 முதல்).

வரிசைப்படுத்துதல்

rand program deploy pp.json          # a bundle pays the floor; waits for the commit; prints the id
rand program show <id>               # id, base_pc, words_len, code_hash, deployed_at, public_words_len, public_digest

testnet என்பது சங்கிலி 20. அதில் வரிசைப்படுத்த, அழைக்க அல்லது தூண்ட fullnode v0.6.8 அல்லது அதற்குப் பிந்தைய பதிப்பின் rand வாலெட் தேவை. பழைய வாலெட்டால் அங்கு எதையுமே அனுப்ப முடியாது. சங்கிலி 20 இன் ஜெனிசிஸ் binding_domain: 1 என அமைக்கிறது; எனவே ஒவ்வொரு நிரூபணப் பிணைப்பிலும் ஒவ்வொரு கையொப்பமிட்ட செய்தியிலும் ஜெனிசிஸ் ஹாஷ் சேர்க்கப்படுகிறது. v0.6.7 வாலெட்டின் பிணைப்புகளிலோ சங்கிலி அடையாளம் மட்டுமே உள்ளது. பொது முனைப்புள்ளி https://rpc.randprotocol.org வாலெட்டின் ஒத்திசைவு, வரிசைப்படுத்தல்கள், அழைப்புகள் ஆகியவற்றைக் கையாள்கிறது (அமைவு).

வாலெட் முதலில் நிரல் அடையாளம், சொல் எண்ணிக்கை, hc ஆகியவற்றை அச்சிடுகிறது. பிறகு rand_estimateFee மூலம் கணுவிடம் கட்டணத்தைக் கேட்கிறது; சங்கிலியின் வரம்பை மீறும் நிரலை இந்தக் கட்டத்திலேயே, நிரூபணம் தொடங்கும் முன்பே, கணு மறுத்துவிடுகிறது. அடுத்து வாலெட் பூஜ்ஜிய மதிப்புள்ள சுய-பரிமாற்றத் தொகுப்பை உருவாக்குகிறது (ஒவ்வொரு பரிவர்த்தனையும் சுமக்கும் அதே 4-உள்ளீடு-4-வெளியீடு மறைக்கப்பட்ட-சொத்துத் தொகுப்பு; கட்டணம் அதன் RAND இடங்களிலிருந்து எடுக்கப்படுகிறது). அந்தத் தொகுப்பு தனது சொந்தக் குறிப்புகளிலிருந்து 0.001 RAND + 100,000 units × words செலுத்துகிறது (பொதுப் பிரிவுச் சொற்களும் குறியீட்டுச் சொற்களாகவே கணக்கிடப்படுகின்றன). வாலெட் அதில் Action::Deploy { base_pc, words, public }-ஐ இணைத்து, பரிவர்த்தனையின் பிணைப்புக்கு எதிராகத் தொகுப்பை நிரூபித்துச் சமர்ப்பிக்கிறது. சங்கிலி 17 முதல் இதற்கு இரண்டு நிரூபணங்கள் தேவை; வாலெட் ஒவ்வொன்றுக்கும் ஒரு வரியை அச்சிடுகிறது: அடுக்கு-10 செலவு அங்கீகாரம் (சில வினாடிகள், சுமார் 1.37 MB), அடுக்கு-14 தொகுப்பு (மடிக்கணினியில் சுமார் இரண்டு நிமிடங்கள், சுமார் 1.5 MB). சங்கிலி 17-க்கு முன் தொகுப்பு நிரூபணம் மட்டுமே இருந்தது; சங்கிலி 15 இல் அது சுமார் 100 s, சுமார் 1.42 MB. வரிசைப்படுத்தல் கட்டணத்தில் கேஸ் அல்லது பைட் அடிப்படையிலான பகுதி இல்லை; கேஸ் அழைப்புகளுக்கு மட்டுமே விலை நிர்ணயிக்கிறது. கணு ஒவ்வொரு சொல்லும் குறிவிலக்கப்படுகிறதா எனச் சரிபார்த்து, hc-ஐக் கணக்கிட்டு, பதிவைச் சேமித்து, பின்னணியில் சரிபார்ப்பு விசையை உருவாக்கத் தொடங்குகிறது. குறியீடு பொதுவானது; அதற்குக் கட்டணம் செலுத்தியவர் யார் என்பது பொதுவானதல்ல — rand_getProgram-இல் deployer புலம் இல்லை. அதே சொற்களை இருமுறை வரிசைப்படுத்தினாலும் விளைவு மாறாது.

→ {"method":"rand_getProgram","params":["675adeea…0065"]}
← { "id": "675adeea…0065", "base_pc": 0, "words_len": 42, "code_hash": "…", "deployed_at": 10,
    "public_words_len": 0, "public_digest": null }
→ {"method":"rand_getProgramCode","params":["675adeea…0065"]}
← { "base_pc": 0, "words": [ … ] }

அழைத்தல்

rand call <program id> --input 400 --input 250 --input 300 --input 75
rand receipt <tx hash>

வாலெட் கணுவிலிருந்து குறியீட்டையும் பொதுப் பிரிவையும் பெற்று, அவற்றின் ஹாஷ் நிரல் அடையாளத்துடன் பொருந்துகிறதா எனச் சரிபார்க்கிறது. பிறகு அழைப்பை எமுலேட்டரில் இயக்கி, எதையும் நிரூபிக்கும் முன்பே கேஸையும் கட்டணத்தையும் அச்சிடுகிறது:

gas: 5636 (declaring 6144, tier 12)
fee 0.006191437 RAND (incl. two price steps of headroom)

அதன் பிறகு வாலெட் உள்ளீட்டுப் பதிவை முத்திரையிடுகிறது (கீழே). உள்ளீடுகளைத் தனிப்பட்ட வெக்டராகக் கொண்டு, சங்கிலியின் FRI சுயவிவரத்தின் கீழ் அழைப்பை உள்ளூரிலேயே நிரூபிக்கிறது. பின்னர் கட்டணம் செலுத்தும் தொகுப்பை நிரூபித்து, சமர்ப்பித்து, காத்திருந்து, ரசீதை அச்சிடுகிறது. சங்கிலி 20 இல் அழைப்பு நிரூபணம் அதன் சொந்தப் பரிவர்த்தனையுடன் பிணைக்கப்பட்டுள்ளது (ஜெனிசிஸ் ஹாஷை உள்ளடக்கிய பிணைப்பு); தொகுப்புக்கு இரண்டு நிரூபணங்கள் தேவை. எனவே ஓர் அழைப்புக்கு மொத்தம் மூன்று நிரூபணங்கள்: அழைப்பு, அடுக்கு-10 செலவு அங்கீகாரம், அடுக்கு-14 தொகுப்பு. மேலே உள்ள இரண்டு வரிகளும் 2026-09-30 அன்று சங்கிலி 18 இல் நடந்த அநாமதேய வாக்கெடுப்பின் அழைப்பிலிருந்து எடுக்கப்பட்டவை (அநாமதேய வாக்கெடுப்பு).

கட்டணம். சங்கிலி 20-இல் குறைந்தபட்சக் கட்டணம் BUNDLE_BASE + gas_price × declared gas limit + byte_price × ⌈bytes / 1024⌉ ஆகும். இதில் BUNDLE_BASE என்பது 0.001 RAND. பைட்டுகள் என்பவை அழைப்பு நிரூபணமும் உள்ளீட்டு உறையும் ஆகும். விலைகள் 100, 800 அலகுகளில் தொடங்கின (ஓர் அலகு 10⁻⁹ RAND); பிளாக் எவ்வளவு நிரம்பியுள்ளது என்பதைப் பொறுத்து அவை மாறுகின்றன. சங்கிலி 20 அவற்றுக்கு 10,000, 80,000 அலகுகள் என உச்சவரம்பு விதிக்கிறது. பைட் விலையைச் செலுத்தும் பைட்டுகள் (அழைப்புகளின் நிரூபணங்களும் உறைகளும்) மட்டுமே அதன் சுமையில் கணக்கிடப்படுகின்றன (byte_load: "paying"). சங்கிலிகள் 18, 19-இல் விலைகளுக்கு உச்சவரம்பு இல்லை; ஒவ்வொரு பரிவர்த்தனையின் பைட்டுகளும் பைட் விலையை மாற்றின. சங்கிலி 15-இல் விதியாக இருந்த பேரேட்டின் நிலையான 0.001 RAND + call_fee(tier) அட்டவணை அங்கு பொருந்தாது. நிரூபணம் உருவாகும் முன்பே வாலட் கட்டணத்தை நிர்ணயிக்கிறது. எனவே அது நிரூபணத்தைச் சங்கிலியின் 4 MiB உச்சவரம்பில் விலையிட்டு, இரண்டு விலைப் படிகள் அளவு கூடுதல் இடைவெளியைச் சேர்க்கிறது. சங்கிலி 18-இல் அளவிடப்பட்ட நான்கு அழைப்புகள் ஒவ்வொன்றும் 0.0057 முதல் 0.0075 RAND வரை செலவாயின (கணக்கீடு). rand fee call <tier> --gas <limit> --bytes <B> குறைந்தபட்சக் கட்டணத்தை நேரடியாக நோடிடம் கேட்கிறது. private_payment நான்கு தனிப்பட்ட இருப்புகளைப் படிக்கிறது; அவற்றின் கூட்டுத்தொகை அதன் வரம்பை எட்டினால், உபரியை வெளியிடுகிறது: வெளியீடுகள் [1, 0, 25, 0, 0, 0, 0, 0]. சங்கிலி நிரூபணத்தையும் அடுக்கையும் அந்த எட்டுச் சொற்களையும் காண்கிறது; இருப்புகளை அது ஒருபோதும் காண்பதில்லை.

கொடிகள்: --tier T ஓர் அடுக்கைக் கட்டாயப்படுத்துகிறது. --gas-limit <N|max> இயல்புநிலைக்குப் பதிலாகத் துல்லியமான கேஸ் வரம்பையோ அடுக்கின் உச்சவரம்பையோ அறிவிக்கிறது; இயல்புநிலை என்பது 2^(tier − 2)-இன் மடங்குக்கு மேல்நோக்கி முழுமையாக்கப்பட்ட துல்லியமான கேஸ் ஆகும். --fee <RAND> கட்டணத்தை அமைக்கிறது. நிரலின் பொதுப் பகுதி அந்தக் கோப்பின் சொற்களாக இல்லாவிட்டால், --expect-public <FILE> நிரூபிப்பதற்கு முன்பே மறுக்கிறது. --auditor <rand1…> பெயரிடப்பட்ட தணிக்கையாளருக்கும் பதிவேட்டை முத்திரையிடுகிறது. --print-call-key ஒவ்வொரு அழைப்புக்குமான விசையை அச்சிடுகிறது. --no-envelope எந்தப் பதிவேட்டையும் வெளியிடுவதில்லை. --cuda GPU பின்தளத்தைத் தேர்ந்தெடுக்கிறது (வன்பொருளில் சோதிக்கப்படவில்லை; உறையை முத்திரையிடுவதுடனும் ஒத்துப்போகாது). சங்கிலி 20 ஓர் அழைப்பில் --cuda-ஐ முழுமையாக மறுக்கிறது: அதன் பரிவர்த்தனையுடன் பிணைக்கப்பட்ட அழைப்பு நிரூபணம் CPU பின்தளத்திலேயே உருவாக்கப்படுகிறது.

ரசீதுகள்

உறுதிசெய்யப்பட்ட ஒவ்வொரு அழைப்புக்கும் ஒரு ரசீது சேமிக்கப்படுகிறது. ஒரு நோட் தன் சங்கிலியை ஒத்திசைக்கும்போதோ சரிபார்க்கும்போதோ அது மீண்டும் கணக்கிடப்படுகிறது:

→ {"method":"rand_getReceipt","params":["b082…09b0"]}
← { "tx": "b082…09b0", "program": "675adeea…0065", "tier": 14,
    "outputs": [1, 0, 25, 0, 0, 0, 0, 0], "height": 105, "index": 0, "h_in": "9c0e…7f", "h_pub": null }

h_in என்பது தனிப்பட்ட உள்ளீடுகள் மீது நிரூபணம் செய்யும் சால்ட் சேர்க்கப்பட்ட உறுதிப்பாடு; தனியாக அது எதையும் வெளிப்படுத்துவதில்லை. h_pub என்பது நிரல் பயன்படுத்தப்பட்டபோது இருந்த பொதுப் பகுதியின் டைஜஸ்ட், அதாவது நிரலின் public_digest; பொதுப் பகுதி இல்லாமல் பயன்படுத்தப்பட்ட நிரலுக்கு இது null. effect புலம் எதுவும் இல்லை; அறிவிக்கப்பட்ட கேஸ் வரம்பும் ரசீதில் இல்லை. ஒரு call-க்கு எக்ஸ்ப்ளோரர் இதே பொருளை GET /transactions/:hash-இல் receipt ஆகக் காட்டுகிறது. ஒரு நிரலின் அழைப்புகளை GET /programs/:id-இல் பட்டியலிடுகிறது; GET /transactions?kind=call&program=<id> மூலம் வடிகட்டுகிறது.

உள்ளீட்டு உறைகள்: ஓர் அழைப்பைப் பின்னர் வெளிப்படுத்துதல்

இயல்பாக, rand call அழைப்பின் (salt, inputs) பதிவேட்டை ஒரு அழைப்பு-உள்ளீட்டு உறையில் முத்திரையிட்டு வெளியிடுகிறது. இதனால் இரண்டாவது நிரூபணம் இல்லாமலேயே உள்ளீடுகளைப் பின்னர் காட்ட முடியும்:

உள்ளடக்கத்தின் தொடர்புடைய தரவு H_IN ஆகும். எனவே வேறோர் அழைப்புக்கு மாற்றப்பட்ட உறையை யாராலும் திறக்க முடியாது. சங்கிலி அளவை மட்டுமே சரிபார்க்கிறது (அதிகபட்சம் max_call_envelope_bytes: சங்கிலி 20-இல் 65,536 பைட்டுகள், அந்தப் புலம் இல்லாத ஜெனிசிஸில் 18,432). அதை rand_getCallEnvelope(tx) மூலம் மாற்றமின்றி வழங்குகிறது. மூன்று விசைகள் அதைத் திறக்கின்றன, அவற்றுக்கு மேல் எதுவுமில்லை: அழைப்பாளரின் பார்வை விசை (அந்த வாலட் செய்த ஒவ்வோர் அழைப்பையும்), அழைப்புக்கான விசை (அந்த ஓர் அழைப்பை), தணிக்கையாளரின் பார்வை விசை (அந்த ஓர் அழைப்பை).

rand open-call <txhash>                    # as the caller
rand open-call <txhash> --as-auditor       # as the auditor
rand open-call <txhash> --call-key <hex>   # with the per-call key alone

open-call பதிவேட்டைத் திறந்து, input_digest(salt, inputs) == H_IN என்பதைச் சரிபார்க்கிறது. மீட்கப்பட்ட உள்ளீடுகளில் நிரலை எமுலேட்டர் வழியாக மீண்டும் இயக்கி, வெளியீடுகளை ரசீதின் வெளியீடுகளுடன் ஒப்பிடுகிறது. இவற்றில் ஏதேனும் ஒரு சரிபார்ப்பு தோல்வியுற்றால் பூஜ்ஜியமற்ற குறியீட்டுடன் வெளியேறுகிறது; இதனால் ஒரு ஸ்கிரிப்ட் எச்சரிக்கையை ஒப்புதலாகத் தவறாகப் புரிந்துகொள்ள முடியாது. --no-envelope திரும்பப்பெற முடியாதது: சால்ட் போய்விட்டால், அழைப்பாளர் உட்பட யாராலும் அந்த அழைப்பைத் திறக்க முடியாது.

v0.6.8 முதல், நிரூபணம் எந்தப் பொதுப் பகுதியின் மீது உருவாக்கப்பட்டதோ அதே பகுதியின் மீது மறு இயக்கம் நடைபெறுகிறது. அதாவது நிரல் பயன்படுத்தப்பட்டபோது இருந்த பொதுச் சொற்கள், hardening_v6-இன் கீழ் அவற்றைத் தொடர்ந்து எட்டுச் சொல் அழைப்புப் பிணைப்பு (fullnode issue #116). v0.6.7-இல் பொதுப் பகுதி இல்லாமல் பயன்படுத்தப்பட்ட நிரலுக்கு மட்டுமே open-call வேலை செய்தது. பொதுப் பகுதி கொண்ட நிரலுக்கு அது உள்ளீடுகளை அச்சிட்டு, பின்னர் re-running the program on these inputs failed: PublicIndex(0) என நின்றது. இரண்டு சரிபார்ப்புகளில் எதையும் இயக்காமலேயே பூஜ்ஜியமற்ற குறியீட்டுடன் வெளியேறியது.

நிரல் நிலை (RPL-2)

RPL-2 கொண்ட முதல் சங்கிலி சங்கிலி 20 ஆகும்; அதன் ஜெனிசிஸின் program_state பிரிவு இதைச் செயல்படுத்துகிறது. ஒரு நிரலுக்கு முன்பு இல்லாத மூன்று அம்சங்கள் கிடைக்கின்றன (fullnode docs/program-state.md, v0.6.8-இல் crates/randprotocol-core/src/ledger/program_state.rs):

ஒரு டோக்கனின் வழங்கல் போலவே கலங்களும் பெட்டக இருப்புகளும் பொதுவானவை. அவற்றில் எதுவும் நோட்டு அல்ல.

Invoke (Action 33) என்பது ஒரு நிலைமாற்றத்தையும் அறிவிக்கும் அழைப்பு. நிரல் சரியாக அந்த நிலைமாற்றத்தை ஏற்கிறது என்பதை அதன் அழைப்பு நிரூபணம் காட்டுகிறது:

Invoke     { program, proof, input_envelope, transition }
Transition { reads:  [{ key, value }]     // cells read, with the values read; keys strictly ascending
             writes: [{ key, value }]     // cells written; keys strictly ascending
             inflow: none | deposit | burn
             pays:   [{ asset, amount, recipient, r, envelope }]   // notes out of the vault
             mints:  [{ asset, amount, recipient, r, envelope }] } // new units of the program's own token

தொகுப்பு எரிப்பதே உள்ளே வருவது: burn_r என்பது பெட்டகத்தில் வைப்பீடு செய்யப்படும் RAND. burn_asset-இன் burn_a என்பது வைப்பீடு செய்யப்படும் டோக்கன் (உள்வரவு deposit) அல்லது அழிக்கப்படும் டோக்கன் (உள்வரவு burn, நிரலின் சொந்த டோக்கன் மட்டும்). வெளியே போவது ஒவ்வொரு வழங்கலுக்கும் சங்கிலி கணக்கிடும் ஒரு நோட்டு; முதலில் கொடுப்பனவுகள், பின்னர் அச்சிடல்கள். ஓர் அச்சிடலைப் போலவே தொகையும் பெறுநரின் pk-வும் பொதுவானவை. நிரல் இருந்தால், அமைப்பு முறையானதாக இருந்தால், reads-இல் உள்ள ஒவ்வொரு கலமும் இன்னும் அறிவிக்கப்பட்ட மதிப்பையே கொண்டிருந்தால், பெட்டகம் (இந்தப் பரிவர்த்தனையின் சொந்த வைப்பீட்டுக்குப் பின்) ஒவ்வொரு கொடுப்பனவையும் ஈடுகட்டினால், ஒவ்வோர் அச்சிடலும் நிரலின் சொந்த டோக்கனாக இருந்தால், நிரூபணங்கள் சரிபார்க்கப்பட்டால் மட்டுமே பேரேடு நிலைமாற்றத்தைப் பயன்படுத்துகிறது. இனி பொருந்தாத வாசிப்பு StaleRead என மறுக்கப்படுகிறது; வாலட் மீண்டும் படித்து மீண்டும் நிரூபிக்கிறது.

இன்வோக் அழைப்பிலிருந்து எவ்வாறு வேறுபடுகிறது.

ஒரு நிரல் READ_PUBLIC(public_len + 8 + i) மூலம் சூழல் சொல் i-ஐப் படிக்கிறது. சொல் 0 பதிப்பு (1). சொற்கள் 1 முதல் 4 வரை முறையே வாசிப்புகள், எழுதுதல்கள், கொடுப்பனவுகள், அச்சிடல்கள் ஆகியவற்றின் எண்ணிக்கைகள். அதைத் தொடர்ந்து burn_r, உள்வரவு வகை, burn_asset, burn_a. பின்னர் ஒவ்வொரு வாசிப்பும் எழுதுதலும் விசையாகவும் மதிப்பாகவும் (ஒவ்வொன்றும் 8 சொற்கள்), அதன் பின் ஒவ்வொரு வழங்கலும் சொத்தாகவும் தொகையாகவும் வருகின்றன. பெறுநர்கள் சூழலில் இல்லை: தொகைகளை நிரல் தீர்மானிக்கிறது, யாருக்குச் செலுத்தப்படுகிறது என்பதைப் பிணைப்பு நிர்ணயிக்கிறது. தனக்குக் காட்டப்படும் ஒவ்வொரு சூழல் சொல்லையும் ஒரு நிரல் கட்டுப்படுத்த வேண்டும். அதில் panic ஆகும் பாதை எதுவும் இருக்கக்கூடாது, ஏனெனில் guest-sdk-இன் panic கையாளி இயக்கத்தை நிறுத்துகிறது, நிறுத்தப்பட்ட இயக்கமும் நிரூபிக்கக்கூடிய இயக்கமே.

சங்கிலி 20-இன் வரம்புகள் (rand_getLimits.program_state):

பொதுவாகப் பகுதி விதியே கடுமையானது: அதே நிரலுக்கான அழைப்பு எந்தப் பொது அட்டவணையின் மீது நிரூபிக்கப்படுகிறதோ, அதற்குள் முழுப் பகுதியும் பொருந்த வேண்டும். பொது உள்ளீடு இல்லாத நிரலுக்கு அது 127 சொற்கள். இது 119 சூழல் சொற்களை விட்டுவைக்கிறது; எடுத்துக்காட்டாக, மூன்று வாசிப்புகள், மூன்று எழுதுதல்கள், நான்கு வழங்கல்கள்.

கட்டளைகளும் RPC-யும் (வாலட் v0.6.8):

rand program build --guest rpl2_counter --out counter.json   # one cell, incremented by one per invoke
rand program invoke <id> --transition step.json [--input N | --inputs-file F.json]
rand program state <id> [--cell <64 hex>]                   # rand_getProgramCell / rand_getProgramCells
rand program vault <id>                                      # rand_getProgramVault

program invoke நிரூபிப்பதற்கு முன் ஒவ்வொரு reads பதிவையும் நடப்புக் கலத்துடன் ஒப்பிட்டுச் சரிபார்க்கிறது. நிரூபிப்பதற்கு முன்போ சேர்க்கப்படும்போதோ பழைய வாசிப்பு கண்டறியப்பட்டால் குறியீடு 3 உடன் வெளியேறுகிறது; இதனால் ஒரு ஸ்கிரிப்ட் மீண்டும் படித்து மறுமுயற்சி செய்யும். "kind": "invoke" உடன் rand_estimateFee கட்டணத்தைக் கூறுகிறது. நிலைமாற்றக் கோப்பின் வடிவம் fullnode-இன் docs/cli.md-இல் உள்ளது. சங்கிலி 20-இல் பயன்படுத்தப்பட்ட முழுமையான RPL-2 நிரல்களும் (amm, stableswap, orderbook, stablecoin, lending, perp, crowdfund, stoploss), RPL-1 நிரல்களும் (sealed-auction, ballot, eligibility, private-join, credit-score) randprotocol/example-programs-இல் உள்ளன.

எது பொதுவானது, எது மறைக்கப்பட்டது

ஒரே இயக்கத்தின் இரண்டு நிரூபணங்கள் வெவ்வேறு பைட்டுகளாக இருக்கும். சங்கிலி 15 மற்றும் அதற்கு முந்தைய சங்கிலிகளில் அது போதுமானதாக இருக்கவில்லை: 31 அல்லது அதற்குக் குறைவான தனிப்பட்ட சொற்களைக் கொண்ட ஓர் அழைப்பு, மறைக்க முடியாத அளவுக்குச் சிறிய அட்டவணையை நிரூபித்தது; அதன் உள்ளீடுகளை நிரூபணத்திலிருந்து மீட்டெடுக்க முடிந்தது. v0.6 முதல் நிரூபிப்பான் அந்த அட்டவணைகளுக்குக் குறைந்தபட்சம் 128 வரிசைகளை நிர்ணயிக்கிறது; கட்டுப்பாட்டுத் தொகுப்பு 7 (சங்கிலி 16 மற்றும் அதற்குப் பிந்தையவை) அப்போதும் கசிந்துகொண்டிருந்த அட்டவணைவாரி மொத்தங்களை மறைக்கிறது. hc பிணைக்கும் தன்மை கொண்டது, ஆனால் மறைக்கும் தன்மை கொண்டதல்ல: வேட்பு நிரல்களைப் பட்டியலிட முடிந்த எவரும் அவற்றில் எது நிலைநிறுத்தப்பட்டது என்பதை உறுதிப்படுத்த முடியும்.

இன்னும் சாத்தியமில்லாதவை

fullnode கூறுவதைப் போலவே:

• நிரல்களுக்கு இடையிலான அழைப்புகள் இல்லை; RPL-2 க்கு வெளியே நிலை இல்லை. ஒரு Call என்பது ஓர் இயக்கத்தின் மீதான ஒரு நிரூபணம்; அழைப்பவர் மீண்டும் உள்ளிடுவதைத் தவிர, ஓர் அழைப்பிலிருந்து அடுத்த அழைப்புக்கு எதுவும் கடத்தப்படுவதில்லை. சங்கிலி 20 இல் ஒரு Invoke நிரலின் சொந்தக் கலங்களையும் பெட்டகத்தையும் படிக்கவும் எழுதவும் செய்கிறது (மேலே); சங்கிலி 20 க்கு முந்தைய எந்தச் சங்கிலியிலும் நிரல் நிலை இல்லை, மேலும் ஓர் invoke வேறொரு நிரலின் கலங்களைத் தொட முடியாது.
• பெட்டகத்துக்கு வெளியே நிரல் இயக்கும் பரிமாற்றங்கள் இல்லை. விளைவு வகை 1, அதாவது நிரல் செலுத்தும் கணக்குக்கான பரிமாற்றம், கணக்குகளுடன் சேர்த்து நீக்கப்பட்டது; ஒரு Call இன் வெளியீடுகள் கூற்றுகள் மட்டுமே. சங்கிலி 20 இல் ஒரு Invoke நிரலின் சொந்தப் பெட்டகத்திலிருந்து செலுத்துகிறது: அதிகபட்சம் நான்கு குறிப்புகள், தொகைகளும் பெறுநர்களும் பொதுவானவை.
• பணப்பையில் தொகுப்பி இல்லை. நிரல்கள் என்பவை உள்ளமைந்த, தொகுக்கப்பட்ட விருந்தினர்கள் அல்லது circuits களஞ்சியத்தில் rand-guest கொண்டு உருவாக்கப்பட்ட படிமங்கள்.
• பொது உள்ளீடு ஒவ்வோர் அழைப்புக்கும் அல்ல, நிலைநிறுத்தும்போதே நிர்ணயிக்கப்படுகிறது. கட்டுப்பாட்டுத் தொகுப்பு 6 READ_PUBLIC மற்றும் H_PUB ஐச் சேர்த்தது. சங்கிலி 20 இல் ஒரு நிலைநிறுத்தல் 32,768 பொதுச் சொற்கள் வரை கொண்டிருக்கலாம்; நிரல் அடையாளம் அவற்றைப் பிணைக்கிறது; ஒவ்வோர் அழைப்பின் நிரூபணமும் அவற்றின் சுருக்கத்துக்கு எதிராகச் சரிபார்க்கப்படுகிறது. அழைப்புவாரி பொதுச் சொற்கள் இல்லை.
• ஹாஷ் syscall கள் பெரிய நிரூபணங்களை உருவாக்குகின்றன. keccak கொண்ட ஒரு நிரூபணம் சுமார் 3.2 MB; இது இயல்புநிலை 2 MiB நிரூபண உச்சவரம்பை நேரடியாகவே மீறுகிறது; sha256 கொண்ட ஒரு நிரூபணம் சுமார் 400 KB கூடுதலாகச் சேர்க்கிறது. சங்கிலி 20 இன் உச்சவரம்பு 4,194,304 பைட்டுகள் (4 MiB, சங்கிலிகள் 17 முதல் 19 வரை இருந்தது போல; சங்கிலிகள் 13 முதல் 16 வரை அது 8 MiB ஆக இருந்தது); இது இரண்டையும் ஏற்கிறது: சங்கிலி 18 இல் Keccak அட்டவணையுடன் கூடிய ஓர் அடுக்கு-12 அழைப்பு 3.35 MB ஆகவும், SHA-256 அட்டவணையுடன் கூடிய ஓர் அடுக்கு-14 அழைப்பு 1.91 MB ஆகவும் அளவிடப்பட்டன (எடுத்துக்காட்டு நிரல்கள்). ஓர் அழைப்பு 128 Keccak-f வரிசைமாற்றங்கள் மற்றும் 128 SHA-256 சுருக்கங்களுக்கும் வரம்பிடப்பட்டுள்ளது (கீழே), மேலும் நிரூபணத்தின் ஒவ்வொரு KiB க்கும் பைட் விலையில் கட்டணம் விதிக்கப்படுகிறது.
• EVM மற்றும் Solana நிரல்கள் சங்கிலி 20 இல் நிலைநிறுத்தப்படுவதில்லை; அவற்றின் அழைப்புகள் அழைப்பு-அடுக்கு உச்சவரம்பை மீறுகின்றன. மொழிபெயர்ப்பி விருந்தினர்களும் (evm.bin, 18,009 சொற்கள்; sbpf.bin, 8,317) மொழிமாற்றப்பட்ட படிமங்களும் (ERC-20, 11,686 சொற்கள்; SPL Token, 65,096) இயல்புநிலை 4,096-சொல் உச்சவரம்பை மீறுகின்றன; ஆனால் சங்கிலி 13 நிர்ணயித்து, அதன் பிறகு ஒவ்வொரு சங்கிலியும் தக்கவைத்துள்ள 65,535 க்குள் உள்ளன. மொழிமாற்றப்பட்ட இரண்டு படிமங்களும் 2026-09-19 அன்று சங்கிலி 13 இல் நிலைநிறுத்தப்பட்டன; SPL Token அதன் ELF ஐப் பொது உள்ளீடாகக் கொண்டு நிலைநிறுத்தப்பட்டது. சங்கிலிகள் 14, 15 புதிதாகத் தொடங்கப்பட்டன; அவற்றில் எதிலும் எந்தப் படிமமும் மீண்டும் நிலைநிறுத்தப்படவில்லை. சங்கிலி 19 ஐப் போலவே சங்கிலி 20 உம் இந்த நான்கில் எதையும் நிலைநிறுத்த மறுக்கிறது: அதன் hardening_v6 விதியின்படி, எந்த அடுக்கு-14 அழைப்பாலும் தாங்க முடியாத நிரல், அதாவது பொதுப் பிரிவு இல்லாவிட்டால் 8,180 சொற்களுக்கு மேல், பொதுப் பிரிவு இருந்தால் அதைவிடக் குறைவான சொற்களுக்கு மேல் உள்ள நிரல், நிலைநிறுத்தும்போதே மறுக்கப்படுகிறது (ProgramUncallable); இதனால் யாராலும் அழைக்க முடியாத ஒரு நிரலுக்கு நிலைநிறுத்தக் கட்டணம் செலுத்தப்படுவதில்லை. ஓர் ERC-20 அழைப்பு அடுக்கு 16 அல்லது 18 இல் நிரூபிக்கப்படுகிறது: அடுக்கு-16 approve 2026-09-19 அன்று சங்கிலி 13 இல் 3,412,405-பைட் உற்பத்தி நிரூபணத்துடன் அழைக்கப்பட்டது (Ethereum மொழிமாற்றி); சங்கிலி 20 அடுக்கு 14 க்கு மேற்பட்ட எந்த அழைப்பையும் மறுக்கிறது (அடுத்த உருப்படி), எனவே இன்று அங்கு எந்த ERC-20 அழைப்பும் ஏற்கத்தக்கதல்ல. SPL Token அழைப்புகள் அடுக்கு 20 இல் உள்ளன; அதற்குச் சுமார் 330 GB தேவை; எந்த SPL அழைப்பு நிரூபணமும் இதுவரை இல்லை (நிரூபண நினைவகம்). EVM தொகுதி-சூழல் செயற்குறிகள் நிறுத்தத்தை ஏற்படுத்துகின்றன; சங்கிலியில் EVM நிலை இல்லை.
• ஓர் அழைப்பு அடுக்கு 14 அல்லது அதற்குக் கீழே நிரூபிக்கப்படுகிறது. fullnode v0.5.6 (2026-09-25) முதல், அடுக்கு 14 க்கு மேற்பட்ட அழைப்பு நிரூபணம் மறுக்கப்படுகிறது (CallTierTooHigh); 128 க்கு மேற்பட்ட Keccak-f வரிசைமாற்றங்கள் அல்லது 128 க்கு மேற்பட்ட SHA-256 சுருக்கங்கள் கொண்ட நிரூபணமும் மறுக்கப்படுகிறது. சங்கிலி 13 இன் அடுக்கு-16 ERC-20 approve, சங்கிலிகள் 15, 18, 19 இல் மறுக்கப்பட்டிருக்கும் என்பது போலவே, சங்கிலி 20 இலும் மறுக்கப்படும்; ஒவ்வோர் அடுக்கு-18 ERC-20 அழைப்பும் அடுக்கு-20 SPL Token அழைப்பும் அவ்வாறே மறுக்கப்படும்; அவை இன்னும் சங்கிலிக்கு வெளியே நிரூபிக்கப்படுகின்றன (வரவுசெலவு வரம்பு).
• GPU நிரூபணம் இதுவரை வன்பொருளில் இயக்கப்படவில்லை. --cuda க்கு --features cuda உருவாக்கமும் commit செய்யப்பட்ட PTX உம் தேவை; இவ்விரண்டும் fleet இல் இல்லை. சங்கிலி 20 இல், உருவாக்கம் எதுவாயினும், அழைப்பு நிரூபணம் CPU பின்தளத்திலேயே உருவாக்கப்படுகிறது.
• hc மறைக்கும் தன்மை கொண்டதல்ல, மேலே கூறியபடி; மேலும் ஒரு சாட்சிக் கோரிக்கை, பணப்பை எந்த இலையைச் செலவிடுகிறது என்பதை இன்னும் முனையத்துக்குத் தெரிவிக்கிறது.