రికార్సివ్-లెంగ్త్ ప్రిఫిక్స్ (RLP) శ్రేణీకరణ

రికార్సివ్ లెంగ్త్ ప్రిఫిక్స్ (RLP) శ్రేణీకరణ ఎథీరియం యొక్క అమలు క్లయింట్‌లలో విస్తృతంగా ఉపయోగించబడుతుంది. RLP నోడ్‌ల మధ్య డేటా బదిలీని స్పేస్-ఎఫిషియంట్ ఫార్మాట్‌లో ప్రామాణీకరిస్తుంది. బైనరీ డేటా యొక్క ఏకపక్షంగా నెస్ట్ చేయబడిన శ్రేణులను ఎన్‌కోడ్ చేయడం RLP యొక్క ఉద్దేశ్యం, మరియు ఎథీరియం యొక్క అమలు పొరలో ఆబ్జెక్ట్‌లను శ్రేణీకరించడానికి ఉపయోగించే ప్రాథమిక ఎన్‌కోడింగ్ పద్ధతి RLP. RLP యొక్క ప్రధాన ఉద్దేశ్యం నిర్మాణాన్ని ఎన్‌కోడ్ చేయడం; పాజిటివ్ పూర్ణాంకాలు మినహా, RLP నిర్దిష్ట డేటా రకాలను (ఉదా., స్ట్రింగ్‌లు, ఫ్లోట్‌లు) ఎన్‌కోడ్ చేయడాన్ని ఉన్నత-స్థాయి ప్రోటోకాల్‌లకు అప్పగిస్తుంది. పాజిటివ్ పూర్ణాంకాలను లీడింగ్ సున్నాలు లేకుండా బిగ్-ఎండియన్ బైనరీ రూపంలో సూచించాలి (తద్వారా సున్నా పూర్ణాంక విలువను ఖాళీ బైట్ శ్రేణికి సమానంగా చేస్తుంది). RLPని ఉపయోగించే ఏదైనా ఉన్నత-స్థాయి ప్రోటోకాల్ ద్వారా లీడింగ్ సున్నాలు ఉన్న డీసీరియలైజ్ చేయబడిన పాజిటివ్ పూర్ణాంకాలను చెల్లనివిగా పరిగణించాలి.

మరింత సమాచారం ఎథీరియం ఎల్లో పేపర్ (అపెండిక్స్ B) (opens in a new tab)లో ఉంది.

డిక్షనరీని ఎన్‌కోడ్ చేయడానికి RLPని ఉపయోగించడానికి, సూచించబడిన రెండు కానానికల్ రూపాలు:

• లెక్సికోగ్రాఫిక్ క్రమంలో కీలతో [[k1,v1],[k2,v2]...]ని ఉపయోగించండి
• ఎథీరియం చేసే విధంగా ఉన్నత-స్థాయి ప్యాట్రిసియా ట్రీ ఎన్‌కోడింగ్‌ను ఉపయోగించండి

నిర్వచనం

RLP ఎన్‌కోడింగ్ ఫంక్షన్ ఒక అంశాన్ని తీసుకుంటుంది. ఒక అంశం ఈ క్రింది విధంగా నిర్వచించబడింది：

• ఒక స్ట్రింగ్ (అంటే, బైట్ శ్రేణి) ఒక అంశం
• అంశాల జాబితా ఒక అంశం
• ఒక పాజిటివ్ పూర్ణాంకం ఒక అంశం

ఉదాహరణకు, కిందివన్నీ అంశాలు:

• ఖాళీ స్ట్రింగ్;
• "cat" అనే పదాన్ని కలిగి ఉన్న స్ట్రింగ్;
• ఎన్ని స్ట్రింగ్‌లనైనా కలిగి ఉన్న జాబితా;
• మరియు ["cat", ["puppy", "cow"], "horse", [[]], "pig", [""], "sheep"] వంటి మరింత సంక్లిష్టమైన డేటా నిర్మాణాలు.
• 100 సంఖ్య

ఈ పేజీలోని మిగిలిన సందర్భంలో, 'స్ట్రింగ్' అంటే "బైనరీ డేటా యొక్క నిర్దిష్ట సంఖ్యలో బైట్‌లు" అని గమనించండి; ఎటువంటి ప్రత్యేక ఎన్‌కోడింగ్‌లు ఉపయోగించబడవు మరియు స్ట్రింగ్‌ల కంటెంట్ గురించి ఎటువంటి అవగాహన సూచించబడదు (నాన్-మినిమల్ పాజిటివ్ పూర్ణాంకాలకు వ్యతిరేకంగా ఉన్న నియమం ప్రకారం అవసరమైనవి మినహా).

RLP ఎన్‌కోడింగ్ ఈ క్రింది విధంగా నిర్వచించబడింది:

• పాజిటివ్ పూర్ణాంకం కోసం, ఇది బిగ్-ఎండియన్ ఇంటర్‌ప్రిటేషన్ పూర్ణాంకంగా ఉండే అతి చిన్న బైట్ శ్రేణిగా మార్చబడుతుంది, ఆపై దిగువ నియమాల ప్రకారం స్ట్రింగ్‌గా ఎన్‌కోడ్ చేయబడుతుంది.
• [0x00, 0x7f] (దశాంశ [0, 127]) పరిధిలో విలువ ఉన్న ఒకే బైట్ కోసం, ఆ బైట్ దాని స్వంత RLP ఎన్‌కోడింగ్ అవుతుంది.
• లేకపోతే, ఒక స్ట్రింగ్ 0-55 బైట్‌ల పొడవు ఉంటే, RLP ఎన్‌కోడింగ్ 0x80 (దశాంశ 128) విలువతో పాటు స్ట్రింగ్ పొడవు మరియు దాని తర్వాత స్ట్రింగ్‌ను కలిగి ఉంటుంది. మొదటి బైట్ పరిధి ఈ విధంగా [0x80, 0xb7] (దశాంశ [128, 183]) అవుతుంది.
• ఒక స్ట్రింగ్ 55 బైట్‌ల కంటే ఎక్కువ పొడవు ఉంటే, RLP ఎన్‌కోడింగ్ 0xb7 (దశాంశ 183) విలువతో పాటు బైనరీ రూపంలో స్ట్రింగ్ పొడవు యొక్క బైట్‌ల పొడవు, దాని తర్వాత స్ట్రింగ్ పొడవు, దాని తర్వాత స్ట్రింగ్‌ను కలిగి ఉంటుంది. ఉదాహరణకు, 1024 బైట్‌ల పొడవైన స్ట్రింగ్ \xb9\x04\x00 (దశాంశ 185, 4, 0) గా ఎన్‌కోడ్ చేయబడి, దాని తర్వాత స్ట్రింగ్ వస్తుంది. ఇక్కడ, మొదటి బైట్‌గా 0xb9 (183 + 2 = 185), దాని తర్వాత అసలు స్ట్రింగ్ పొడవును సూచించే 2 బైట్‌లు 0x0400 (దశాంశ 1024) వస్తాయి. మొదటి బైట్ పరిధి ఈ విధంగా [0xb8, 0xbf] (దశాంశ [184, 191]) అవుతుంది.
• ఒక స్ట్రింగ్ 2^64 బైట్‌ల పొడవు లేదా అంతకంటే ఎక్కువ ఉంటే, అది ఎన్‌కోడ్ చేయబడకపోవచ్చు.
• జాబితా యొక్క మొత్తం పేలోడ్ (అంటే, RLP ఎన్‌కోడ్ చేయబడుతున్న దాని అన్ని అంశాల మిశ్రమ పొడవు) 0-55 బైట్‌ల పొడవు ఉంటే, RLP ఎన్‌కోడింగ్ 0xc0 విలువతో పాటు పేలోడ్ పొడవు మరియు దాని తర్వాత అంశాల RLP ఎన్‌కోడింగ్‌ల కలయికను కలిగి ఉంటుంది. మొదటి బైట్ పరిధి ఈ విధంగా [0xc0, 0xf7] (దశాంశ [192, 247]) అవుతుంది.
• జాబితా యొక్క మొత్తం పేలోడ్ 55 బైట్‌ల కంటే ఎక్కువ పొడవు ఉంటే, RLP ఎన్‌కోడింగ్ 0xf7 విలువతో పాటు బైనరీ రూపంలో పేలోడ్ పొడవు యొక్క బైట్‌ల పొడవు, దాని తర్వాత పేలోడ్ పొడవు, దాని తర్వాత అంశాల RLP ఎన్‌కోడింగ్‌ల కలయికను కలిగి ఉంటుంది. మొదటి బైట్ పరిధి ఈ విధంగా [0xf8, 0xff] (దశాంశ [248, 255]) అవుతుంది.

సంక్షిప్త రూపంలో:

• p = పేలోడ్
• n = పొడవు (పేలోడ్ బైట్‌ల సంఖ్య)
• N = పొడవు-యొక్క-పొడవు ఆఫ్‌సెట్ (N+1 n బైట్‌లు అనుసరిస్తాయి)

కోడ్‌లో, ఇది:

def rlp_encode(input):
    if isinstance(input,str):
        if len(input) == 1 and ord(input) < 0x80:
            return input
        return encode_length(len(input), 0x80) + input
    elif isinstance(input, list):
        output = ''
        for item in input:
            output += rlp_encode(item)
        return encode_length(len(output), 0xc0) + output

def encode_length(L, offset):
    if L < 56:
         return chr(L + offset)
    elif L < 256**8:
         BL = to_binary(L)
         return chr(len(BL) + offset + 55) + BL
    raise Exception("input too long")

def to_binary(x):
    if x == 0:
        return ''
    return to_binary(int(x / 256)) + chr(x % 256)

ఉదాహరణలు

• "dog" స్ట్రింగ్ = [ 0x83, 'd', 'o', 'g' ]
• [ "cat", "dog" ] జాబితా = [ 0xc8, 0x83, 'c', 'a', 't', 0x83, 'd', 'o', 'g' ]
• ఖాళీ స్ట్రింగ్ ('null') = [ 0x80 ]
• ఖాళీ జాబితా = [ 0xc0 ]
• పూర్ణాంకం 0 = [ 0x80 ]
• బైట్ '\x00' = [ 0x00 ]
• బైట్ '\x0f' = [ 0x0f ]
• బైట్‌లు '\x04\x00' = [ 0x82, 0x04, 0x00 ]
• మూడు యొక్క సెట్ థియరిటికల్ రిప్రజెంటేషన్ (opens in a new tab), [ [], [[]], [ [], [[]] ] ] = [ 0xc7, 0xc0, 0xc1, 0xc0, 0xc3, 0xc0, 0xc1, 0xc0 ]
• "Lorem ipsum dolor sit amet, consectetur adipisicing elit" స్ట్రింగ్ = [ 0xb8, 0x38, 'L', 'o', 'r', 'e', 'm', ' ', ... , 'e', 'l', 'i', 't' ]

RLP డీకోడింగ్

RLP ఎన్‌కోడింగ్ యొక్క నియమాలు మరియు ప్రక్రియ ప్రకారం, RLP డీకోడ్ యొక్క ఇన్‌పుట్ బైనరీ డేటా శ్రేణిగా పరిగణించబడుతుంది. RLP డీకోడింగ్ ప్రక్రియ ఈ క్రింది విధంగా ఉంటుంది:

1. ఇన్‌పుట్ డేటా యొక్క మొదటి బైట్ (అంటే, ప్రిఫిక్స్) మరియు డేటా రకాన్ని డీకోడింగ్ చేయడం ప్రకారం, అసలు డేటా పొడవు మరియు ఆఫ్‌సెట్;

2. డేటా రకం మరియు ఆఫ్‌సెట్ ప్రకారం, పాజిటివ్ పూర్ణాంకాల కోసం కనీస ఎన్‌కోడింగ్ నియమాన్ని గౌరవిస్తూ, డేటాను తదనుగుణంగా డీకోడ్ చేయండి;

3. మిగిలిన ఇన్‌పుట్‌ను డీకోడ్ చేయడం కొనసాగించండి;

వాటిలో, డేటా రకాలు మరియు ఆఫ్‌సెట్‌ను డీకోడింగ్ చేసే నియమాలు ఈ క్రింది విధంగా ఉన్నాయి:

1. మొదటి బైట్ (అంటే, ప్రిఫిక్స్) పరిధి [0x00, 0x7f] అయితే డేటా ఒక స్ట్రింగ్ అవుతుంది, మరియు స్ట్రింగ్ ఖచ్చితంగా మొదటి బైట్ అవుతుంది;

2. మొదటి బైట్ పరిధి [0x80, 0xb7] అయితే డేటా ఒక స్ట్రింగ్ అవుతుంది, మరియు మొదటి బైట్ మైనస్ 0x80కి సమానమైన పొడవు ఉన్న స్ట్రింగ్ మొదటి బైట్‌ను అనుసరిస్తుంది;

3. మొదటి బైట్ పరిధి [0xb8, 0xbf] అయితే డేటా ఒక స్ట్రింగ్ అవుతుంది, మరియు బైట్‌లలో పొడవు మొదటి బైట్ మైనస్ 0xb7కి సమానంగా ఉన్న స్ట్రింగ్ పొడవు మొదటి బైట్‌ను అనుసరిస్తుంది, మరియు స్ట్రింగ్ స్ట్రింగ్ పొడవును అనుసరిస్తుంది;

4. మొదటి బైట్ పరిధి [0xc0, 0xf7] అయితే డేటా ఒక జాబితా అవుతుంది, మరియు మొత్తం పేలోడ్ మొదటి బైట్ మైనస్ 0xc0కి సమానంగా ఉన్న జాబితాలోని అన్ని అంశాల RLP ఎన్‌కోడింగ్‌ల కలయిక మొదటి బైట్‌ను అనుసరిస్తుంది;

5. మొదటి బైట్ పరిధి [0xf8, 0xff] అయితే డేటా ఒక జాబితా అవుతుంది, మరియు పొడవు మొదటి బైట్ మైనస్ 0xf7కి సమానంగా ఉన్న జాబితా యొక్క మొత్తం పేలోడ్ మొదటి బైట్‌ను అనుసరిస్తుంది, మరియు జాబితాలోని అన్ని అంశాల RLP ఎన్‌కోడింగ్‌ల కలయిక జాబితా యొక్క మొత్తం పేలోడ్‌ను అనుసరిస్తుంది;

కోడ్‌లో, ఇది:

def rlp_decode(input):
    if len(input) == 0:
        return
    output = ''
    (offset, dataLen, type) = decode_length(input)
    if type is str:
        output = instantiate_str(substr(input, offset, dataLen))
    elif type is list:
        output = instantiate_list(substr(input, offset, dataLen))
    output += rlp_decode(substr(input, offset + dataLen))
    return output

def decode_length(input):
    length = len(input)
    if length == 0:
        raise Exception("input is null")
    prefix = ord(input[0])
    if prefix <= 0x7f:
        return (0, 1, str)
    elif prefix <= 0xb7 and length > prefix - 0x80:
        strLen = prefix - 0x80
        return (1, strLen, str)
    elif prefix <= 0xbf and length > prefix - 0xb7 and length > prefix - 0xb7 + to_integer(substr(input, 1, prefix - 0xb7)):
        lenOfStrLen = prefix - 0xb7
        strLen = to_integer(substr(input, 1, lenOfStrLen))
        return (1 + lenOfStrLen, strLen, str)
    elif prefix <= 0xf7 and length > prefix - 0xc0:
        listLen = prefix - 0xc0;
        return (1, listLen, list)
    elif prefix <= 0xff and length > prefix - 0xf7 and length > prefix - 0xf7 + to_integer(substr(input, 1, prefix - 0xf7)):
        lenOfListLen = prefix - 0xf7
        listLen = to_integer(substr(input, 1, lenOfListLen))
        return (1 + lenOfListLen, listLen, list)
    raise Exception("input does not conform to RLP encoding form")

def to_integer(b):
    length = len(b)
    if length == 0:
        raise Exception("input is null")
    elif length == 1:
        return ord(b[0])
    return ord(substr(b, -1)) + to_integer(substr(b, 0, -1)) * 256

మరింత చదవడానికి

• ఎథీరియంలో RLP (opens in a new tab)
• ఎథీరియం అంతర్గతంగా: RLP (opens in a new tab)
• Coglio, A. (2020). ACL2లో ఎథీరియం యొక్క రికార్సివ్ లెంగ్త్ ప్రిఫిక్స్. arXiv ప్రిప్రింట్ arXiv:2009.13769. (opens in a new tab)

సంబంధిత అంశాలు

• ప్యాట్రిసియా మెర్కిల్ ట్రీ

పేజీ చివరి నవీకరణ: 15 ఏప్రిల్, 2026

s (opens in a new tab)

p (opens in a new tab)

d (opens in a new tab)

+13

సహకారులను చూడండి