எளிய வரிசையாக்கம் (Simple serialize)

எளிய வரிசையாக்கம் (Simple serialize - SSZ) என்பது பீக்கன் செயினில் (Beacon Chain) பயன்படுத்தப்படும் வரிசையாக்க முறையாகும். இது பியர் டிஸ்கவரி நெறிமுறையைத் (peer discovery protocol) தவிர, ஒருமித்த அடுக்கு (consensus layer) முழுவதும் செயலாக்க அடுக்கில் (execution layer) பயன்படுத்தப்படும் RLP வரிசையாக்கத்தை மாற்றுகிறது. RLP வரிசையாக்கம் பற்றி மேலும் அறிய, சுழல்-நீள முன்னொட்டு (Recursive-length prefix - RLP) என்பதைப் பார்க்கவும். SSZ ஆனது தீர்மானிக்கக்கூடியதாகவும் (deterministic) மற்றும் திறமையாக மெர்க்கலைஸ் (Merkleize) செய்யும் வகையிலும் வடிவமைக்கப்பட்டுள்ளது. SSZ இரண்டு கூறுகளைக் கொண்டிருப்பதாகக் கருதலாம்: ஒரு வரிசையாக்கத் திட்டம் மற்றும் வரிசையாக்கப்பட்ட தரவுக் கட்டமைப்புடன் திறமையாகச் செயல்பட வடிவமைக்கப்பட்ட ஒரு மெர்க்கலைசேஷன் (Merkleization) திட்டம்.

SSZ எவ்வாறு செயல்படுகிறது?

வரிசையாக்கம் (Serialization)

SSZ என்பது தன்னைத்தானே விவரிக்கும் வரிசையாக்கத் திட்டம் அல்ல - மாறாக இது முன்கூட்டியே அறியப்பட வேண்டிய ஒரு திட்டவடிவத்தை (schema) நம்பியுள்ளது. SSZ வரிசையாக்கத்தின் குறிக்கோள், தன்னிச்சையான சிக்கலான பொருள்களை பைட்டுகளின் சரங்களாக (strings of bytes) பிரதிநிதித்துவப்படுத்துவதாகும். "அடிப்படை வகைகளுக்கு" (basic types) இது மிகவும் எளிமையான செயல்முறையாகும். உறுப்பு வெறுமனே ஹெக்ஸாடெசிமல் பைட்டுகளாக (hexadecimal bytes) மாற்றப்படுகிறது. அடிப்படை வகைகளில் அடங்குபவை:

குறியிடப்படாத முழு எண்கள் (unsigned integers)
பூலியன்கள் (Booleans)

சிக்கலான "கலப்பு" (composite) வகைகளுக்கு, வரிசையாக்கம் மிகவும் சிக்கலானது, ஏனெனில் கலப்பு வகையானது வெவ்வேறு வகைகள் அல்லது வெவ்வேறு அளவுகள் அல்லது இரண்டையும் கொண்ட பல உறுப்புகளைக் கொண்டுள்ளது. இந்தப் பொருள்கள் அனைத்தும் நிலையான நீளங்களைக் கொண்டிருக்கும் போது (அதாவது, உறுப்புகளின் அளவு அவற்றின் உண்மையான மதிப்புகளைப் பொருட்படுத்தாமல் எப்போதும் மாறிலியாக இருக்கும்), வரிசையாக்கம் என்பது கலப்பு வகையில் உள்ள ஒவ்வொரு உறுப்பையும் லிட்டில்-எண்டியன் பைட் சரங்களாக (little-endian bytestrings) வரிசைப்படுத்தி மாற்றுவதாகும். இந்த பைட் சரங்கள் ஒன்றாக இணைக்கப்படுகின்றன. வரிசையாக்கப்பட்ட பொருளானது, வரிசையாக்கம் நீக்கப்பட்ட பொருளில் (deserialized object) தோன்றும் அதே வரிசையில் நிலையான நீள உறுப்புகளின் பைட் பட்டியல் பிரதிநிதித்துவத்தைக் கொண்டுள்ளது.

மாறுபடும் நீளங்களைக் கொண்ட வகைகளுக்கு, வரிசையாக்கப்பட்ட பொருளில் அந்த உறுப்பின் நிலையில் உள்ள உண்மையான தரவு "ஆஃப்செட்" (offset) மதிப்பால் மாற்றப்படுகிறது. உண்மையான தரவு வரிசையாக்கப்பட்ட பொருளின் முடிவில் உள்ள ஒரு குவியலில் (heap) சேர்க்கப்படுகிறது. ஆஃப்செட் மதிப்பு என்பது குவியலில் உள்ள உண்மையான தரவின் தொடக்கத்திற்கான குறியீடாகும், இது தொடர்புடைய பைட்டுகளுக்கான சுட்டியாக (pointer) செயல்படுகிறது.

நிலையான மற்றும் மாறுபடும் நீள உறுப்புகளைக் கொண்ட ஒரு கொள்கலனுக்கு (container) ஆஃப்செட்டிங் எவ்வாறு செயல்படுகிறது என்பதை கீழேயுள்ள எடுத்துக்காட்டு விளக்குகிறது:

1
2    struct Dummy {
3
4        number1: u64,
5        number2: u64,
6        vector: Vec<u8>,
7        number3: u64
8    }
9
10    dummy = Dummy{
11
12        number1: 37,
13        number2: 55,
14        vector: vec![1,2,3,4],
15        number3: 22,
16    }
17
18    serialized = ssz.serialize(dummy)
19
அனைத்தையும் காட்டு

serialized பின்வரும் கட்டமைப்பைக் கொண்டிருக்கும் (இங்கு 4 பிட்டுகளுக்கு மட்டுமே பேட் செய்யப்பட்டுள்ளது, உண்மையில் 32 பிட்டுகளுக்கு பேட் செய்யப்படும், மேலும் தெளிவுக்காக int பிரதிநிதித்துவம் வைக்கப்பட்டுள்ளது):

1[37, 0, 0, 0, 55, 0, 0, 0, 16, 0, 0, 0, 22, 0, 0, 0, 1, 2, 3, 4]
2------------  -----------  -----------  -----------  ----------
3      |             |            |           |            |
4   number1       number2    offset for    number 3    value for
5                              vector                   vector
6

தெளிவுக்காக வரிகளாகப் பிரிக்கப்பட்டுள்ளது:

1[
2  37, 0, 0, 0,  # little-endian encoding of `number1`.
3  55, 0, 0, 0,  # little-endian encoding of `number2`.
4  16, 0, 0, 0,  # The "offset" that indicates where the value of `vector` starts (little-endian 16).
5  22, 0, 0, 0,  # little-endian encoding of `number3`.
6  1, 2, 3, 4,   # The actual values in `vector`.
7]

இது இன்னும் ஒரு எளிமைப்படுத்தலாகும் - மேலே உள்ள வரைபடங்களில் உள்ள முழு எண்கள் மற்றும் பூஜ்ஜியங்கள் உண்மையில் இதுபோன்று பைட் பட்டியல்களாக சேமிக்கப்படும்:

1[
2  10100101000000000000000000000000  # little-endian encoding of `number1`
3  10110111000000000000000000000000  # little-endian encoding of `number2`.
4  10010000000000000000000000000000  # The "offset" that indicates where the value of `vector` starts (little-endian 16).
5  10010110000000000000000000000000  # little-endian encoding of `number3`.
6  10000001100000101000001110000100   # The actual value of the `bytes` field.
7]

எனவே மாறுபடும் நீள வகைகளுக்கான உண்மையான மதிப்புகள் வரிசையாக்கப்பட்ட பொருளின் முடிவில் உள்ள ஒரு குவியலில் சேமிக்கப்படுகின்றன, அவற்றின் ஆஃப்செட்கள் புலங்களின் வரிசைப்படுத்தப்பட்ட பட்டியலில் அவற்றின் சரியான நிலைகளில் சேமிக்கப்படுகின்றன.

வரிசையாக்கத்தின் போது நீள வரம்பைச் சேர்க்க வேண்டிய மற்றும் வரிசையாக்கம் நீக்கத்தின் போது அகற்ற வேண்டிய BitList வகை போன்ற குறிப்பிட்ட சிகிச்சை தேவைப்படும் சில சிறப்பு நிகழ்வுகளும் உள்ளன. முழு விவரங்களும் SSZ விவரக்குறிப்பில் (opens in a new tab) கிடைக்கின்றன.

வரிசையாக்கம் நீக்கம் (Deserialization)

இந்தப் பொருளை வரிசையாக்கம் நீக்க திட்டவடிவம் (schema) தேவை. திட்டவடிவமானது வரிசையாக்கப்பட்ட தரவின் துல்லியமான அமைப்பை வரையறுக்கிறது, இதனால் ஒவ்வொரு குறிப்பிட்ட உறுப்பும் பைட்டுகளின் தொகுப்பிலிருந்து சரியான வகை, மதிப்பு, அளவு மற்றும் நிலையைக் கொண்ட உறுப்புகளுடன் சில அர்த்தமுள்ள பொருளாக வரிசையாக்கம் நீக்கப்படலாம். எந்த மதிப்புகள் உண்மையான மதிப்புகள் மற்றும் எவை ஆஃப்செட்கள் என்பதை வரிசையாக்கம் நீக்கிக்கு (deserializer) திட்டவடிவமே கூறுகிறது. ஒரு பொருள் வரிசையாக்கப்படும் போது அனைத்து புலப் பெயர்களும் மறைந்துவிடும், ஆனால் திட்டவடிவத்தின்படி வரிசையாக்கம் நீக்கப்படும் போது மீண்டும் உருவாக்கப்படும்.

இது குறித்த ஊடாடும் விளக்கத்திற்கு ssz.dev (opens in a new tab) ஐப் பார்க்கவும்.

மெர்க்கலைசேஷன் (Merkleization)

இந்த SSZ வரிசையாக்கப்பட்ட பொருளை பின்னர் மெர்க்கலைஸ் செய்யலாம் - அதாவது அதே தரவின் மெர்க்கல்-மர (Merkle-tree) பிரதிநிதித்துவமாக மாற்றலாம். முதலில், வரிசையாக்கப்பட்ட பொருளில் உள்ள 32-பைட் துண்டுகளின் எண்ணிக்கை தீர்மானிக்கப்படுகிறது. இவை மரத்தின் "இலைகள்" (leaves) ஆகும். இலைகளின் மொத்த எண்ணிக்கை 2 இன் அடுக்காக இருக்க வேண்டும், இதனால் இலைகளை ஒன்றாக ஹாஷ் செய்வது இறுதியில் ஒரு ஒற்றை ஹாஷ்-மர-வேரை (hash-tree-root) உருவாக்குகிறது. இது இயற்கையாகவே இல்லையென்றால், 32 பைட்டுகள் பூஜ்ஜியங்களைக் கொண்ட கூடுதல் இலைகள் சேர்க்கப்படுகின்றன. வரைபடமாக:

1        hash tree root
2            /     \
3           /       \
4          /         \
5         /           \
6   hash of leaves  hash of leaves
7     1 and 2         3 and 4
8      /   \            /  \
9     /     \          /    \
10    /       \        /      \
11 leaf1     leaf2  leaf3     leaf4
அனைத்தையும் காட்டு

மேலே உள்ள எடுத்துக்காட்டில் உள்ளதைப் போல மரத்தின் இலைகள் இயற்கையாகவே சமமாக விநியோகிக்கப்படாத நிகழ்வுகளும் உள்ளன. எடுத்துக்காட்டாக, இலை 4 என்பது மெர்க்கல் மரத்தில் கூடுதல் "ஆழம்" (depth) சேர்க்கப்பட வேண்டிய பல உறுப்புகளைக் கொண்ட ஒரு கொள்கலனாக இருக்கலாம், இது சீரற்ற மரத்தை உருவாக்குகிறது.

இந்த மர உறுப்புகளை இலை X, முனை X (node X) என்று குறிப்பிடுவதற்குப் பதிலாக, வேர் = 1 (root = 1) என்று தொடங்கி ஒவ்வொரு மட்டத்திலும் இடமிருந்து வலமாக எண்ணி, அவற்றுக்கு பொதுவான குறியீடுகளை (generalized indices) வழங்கலாம். மேலே விளக்கப்பட்ட பொதுவான குறியீடு இதுதான். வரிசையாக்கப்பட்ட பட்டியலில் உள்ள ஒவ்வொரு உறுப்பும் 2**depth + idx க்கு சமமான பொதுவான குறியீட்டைக் கொண்டுள்ளது, இதில் idx என்பது வரிசையாக்கப்பட்ட பொருளில் அதன் பூஜ்ஜிய-குறியீட்டு நிலை மற்றும் ஆழம் என்பது மெர்க்கல் மரத்தில் உள்ள நிலைகளின் எண்ணிக்கையாகும், இது உறுப்புகளின் (இலைகள்) எண்ணிக்கையின் அடிமானம்-இரண்டு மடக்கையாக (base-two logarithm) தீர்மானிக்கப்படலாம்.

பொதுவான குறியீடுகள் (Generalized indices)

பொதுவான குறியீடு என்பது பைனரி மெர்க்கல் மரத்தில் உள்ள ஒரு முனையைக் குறிக்கும் முழு எண்ணாகும், இதில் ஒவ்வொரு முனையும் 2 ** depth + index in row என்ற பொதுவான குறியீட்டைக் கொண்டுள்ளது.

1        1           --depth = 0  2**0 + 0 = 1
2    2       3       --depth = 1  2**1 + 0 = 2, 2**1+1 = 3
3  4   5   6   7     --depth = 2  2**2 + 0 = 4, 2**2 + 1 = 5...
4

இந்தப் பிரதிநிதித்துவம் மெர்க்கல் மரத்தில் உள்ள ஒவ்வொரு தரவுத் துண்டிற்கும் ஒரு முனை குறியீட்டை (node index) அளிக்கிறது.

மல்டிப்ரூஃப்கள் (Multiproofs)

ஒரு குறிப்பிட்ட உறுப்பைக் குறிக்கும் பொதுவான குறியீடுகளின் பட்டியலை வழங்குவது, ஹாஷ்-மர-வேருக்கு (hash-tree-root) எதிராக அதைச் சரிபார்க்க அனுமதிக்கிறது. இந்த வேர் என்பது நாம் ஏற்றுக்கொண்ட யதார்த்தத்தின் பதிப்பாகும். நமக்கு வழங்கப்படும் எந்தவொரு தரவையும் மெர்க்கல் மரத்தில் சரியான இடத்தில் செருகுவதன் மூலம் (அதன் பொதுவான குறியீட்டால் தீர்மானிக்கப்படுகிறது) மற்றும் வேர் மாறிலியாக இருப்பதைக் கவனிப்பதன் மூலம் அந்த யதார்த்தத்திற்கு எதிராகச் சரிபார்க்கலாம். ஒரு குறிப்பிட்ட பொதுவான குறியீடுகளின் உள்ளடக்கங்களைச் சரிபார்க்கத் தேவையான முனைகளின் குறைந்தபட்ச தொகுப்பை எவ்வாறு கணக்கிடுவது என்பதைக் காட்டும் செயல்பாடுகள் இங்கே (opens in a new tab) விவரக்குறிப்பில் உள்ளன.

எடுத்துக்காட்டாக, கீழே உள்ள மரத்தில் குறியீடு 9 இல் உள்ள தரவைச் சரிபார்க்க, குறியீடுகள் 8, 9, 5, 3, 1 இல் உள்ள தரவின் ஹாஷ் நமக்குத் தேவை. (8,9) இன் ஹாஷ், ஹாஷ் (4) க்கு சமமாக இருக்க வேண்டும், இது 5 உடன் ஹாஷ் செய்து 2 ஐ உருவாக்குகிறது, இது 3 உடன் ஹாஷ் செய்து மரத்தின் வேர் 1 ஐ உருவாக்குகிறது. 9 க்கு தவறான தரவு வழங்கப்பட்டால், வேர் மாறும் - இதை நாங்கள் கண்டறிந்து கிளையைச் சரிபார்க்கத் தவறிவிடுவோம்.

1* = data required to generate proof
2
3                    1*
4          2                      3*
5    4          5*          6          7
68*     9*   10    11   12    13    14    15
7