(i1NddlZddlmZmZmZddlmZmZddlm Z m Z m Z m Z ddl mZddlmZmZmZddlmZddlmZ ddlZd Zd ZddZ"dZ#dZ$dZ%dZ&dZ'dZ(ddZ)dZ*dZ+y#e$r6ddlZdd lmZej>d Z e jCd dZdZYYwxYw)N)big_endian_to_intint_to_big_endianis_bytes) DecodingError EncodingError)big_endian_intbinarybooleantext)Binary)Listis_sedes is_sequence) Serializable) ALL_BYTESc tj|||S#ttjf$r}t||d}~wwxYwN) rusty_rlp decode_raw TypeErrorr)itemstrictpreserve_per_item_rlpes :/var/www/br/venv/lib/python3.12/site-packages/rlp/codec.pyrrSsE )''f6KL L9223 )4( ( )sA >Ac t|tr t|}tj|S#tj $r}t ||d}~wwxYwr) isinstance bytearraybytesr encode_rawr)objrs rr r YsN (#y)Cj'', ,&& (3' ' (s/2A AA)Atomicz rlp.codecz}Consider installing rusty-rlp to improve pyrlp performance with a rust basedbackend. Not currently functional for Python 3.11ct|trt|dk(r |ddkr|S|}d}nst|ts?t|tj j rdjd|D}d}n$dt|j}t|| tt||}||zS#t$r td|wxYw) z4RLP encode (a nested sequence of) :class:`Atomic`\s.rc32K|]}t|ywr)r ).0xs r zencode_raw..9s;z!};szCannot encode object of type zItem too big to encode) rr"lenstr collectionsabcSequencejointype__name__r length_prefix ValueError)rpayload prefix_offsetmsgprefixs rr r 1s dF #4yA~$q'C- GMD#&:dKOO(4T1(= %FL# #d) )#d)c/)::LMCT* *|##  > 6= = >s AAct|tr|j}||r|S|xr|du}nd}|r|j|}n|rt |j|}n|}t |}|r||_|S)a  Encode a Python object in RLP format. By default, the object is serialized in a suitable way first (using :func:`rlp.infer_sedes`) and then encoded. Serialization can be explicitly suppressed by setting `infer_serializer` to ``False`` and not passing an alternative as `sedes`. If `obj` has an attribute :attr:`_cached_rlp` (as, notably, :class:`rlp.Serializable`) and its value is not `None`, this value is returned bypassing serialization and encoding, unless `sedes` is given (as the cache is assumed to refer to the standard serialization which can be replaced by specifying `sedes`). If `obj` is a :class:`rlp.Serializable` and `cache` is true, the result of the encoding will be stored in :attr:`_cached_rlp` if it is empty. :param sedes: an object implementing a function ``serialize(obj)`` which will be used to serialize ``obj`` before encoding, or ``None`` to use the infered one (if any) :param infer_serializer: if ``True`` an appropriate serializer will be selected using :func:`rlp.infer_sedes` to serialize `obj` before encoding :param cache: cache the return value in `obj._cached_rlp` if possible (default `True`) :returns: the RLP encoded item :raises: :exc:`rlp.EncodingError` in the rather unlikely case that the item is too big to encode (will not happen) :raises: :exc:`rlp.SerializationError` if the serialization fails NF)rr _cached_rlp serialize infer_sedesr )r!sedesinfer_serializercache cached_rlp really_cacherr>s rencoderJbs~>#|$__ =Z  2Ud]L  s# 3))#.  F  Mr&lc|dkr t||zS|tkr)t|}t|dzdz t|z|zSt d)z Construct the prefix to lists or strings denoting their length. :param length: the length of the item in bytes :param offset: ``0x80`` when encoding raw bytes, ``0xc0`` when encoding a list 8r$zLength greater than 256**8)r LONG_LENGTHrr,r5)lengthoffset length_strings rr4r4sZ{&)) + )&1 "q3}+==>NN566r&cz||}|dkr dtd|fS|tkr5|dz dk(r||dzdkr td||||dzt|dz |dzfS|dkrb|dz }||dz|dzdk(r td |||dz|dz|z}t|}|d kr td ||||dz|zt||dz|zfS|d kr|||dzt|dz |dzfS|dz d z dz}||dz|dzdk(r td |||dz|dz|z}t|}|d kr td ||||dz|zt||dz|zfS)a Read a length prefix from an RLP string. :param rlp: the rlp byte string to read from :param start: the position at which to start reading :returns: a tuple ``(prefix, type, length, end)``, where ``type`` is either ``str`` or ``list`` depending on the type of the following payload, ``length`` is the length of the payload in bytes, and ``end`` is the position of the first payload byte in the rlp string r%r&r$z9Encoded as short string although single byte was possibler+zLength starts with zero bytesrLz(Long string prefix used for short stringz$Long list prefix used for short list)r SHORT_STRINGrrlist)rlpstartb0ll len_prefixls rconsume_length_prefixr_s UB CxUAu%% l  8q=S^c1KS EEAI&rCxCC c #X uqy519 % 0 ?E EUQY^4 j ) r6 JCP PEEAI&3UAuqy2~NN hEEAI&b3h BB #X]Q  uqy519 % 0 ?E EUQY^4 j ) r6 FL LEEAI&3T1eai"nMMr&c||tur||||z}|||zg||zfS|turg}g}|}|} | |z} | | krTt|| \} } } }t|| || | \}}} |j |||dz }|j || | krT|j d|| | kDr t d|||| fStd)a Read the payload of an item from an RLP string. :param rlp: the rlp string to read from :param type_: the type of the payload (``bytes`` or ``list``) :param start: the position at which to start reading :param length: the length of the payload in bytes :returns: a tuple ``(item, per_item_rlp, end)``, where ``item`` is the read item, per_item_rlp is a list containing the RLP encoding of each item and ``end`` is the position of the first unprocessed byte rz/List length prefix announced a too small lengthz!Type must be either list or bytes)rrXr_consume_payloadappendinsertrr)rYr9rZtype_rNritemsr?list_rlpnext_item_startr@ptr^sitem_rlps rraras ~556>*v}ouv~66 $ &#.sODJAq!Q.=c1aA.N +D(O    )  #H LL # Ax( S Dc |_55;< MM! mmA&G S'9 5 6r&ct|jr |jSt|tst|tr |dk\rt St j|rtSt|ts=t|tjjrttt|St|trt St|trt"Sdt%|j&}t)|)a Try to find a sedes objects suitable for a given Python object. The sedes objects considered are `obj`'s class, `big_endian_int` and `binary`. If `obj` is a sequence, a :class:`rlp.sedes.List` will be constructed recursively. :param obj: the python object for which to find a sedes object :raises: :exc:`TypeError` if no appropriate sedes could be found rz!Did not find sedes handling type )r __class__rrwrvr BinaryClass is_valid_typer r-r.r/r0r maprDr r r2r3r)r!r8s rrDrDJs }} T "z#s';q  " "3 ' S !jkoo6N6N&OC S)** C  C  -d3i.@.@-A BC C.r&)NTT)NTF),r. eth_utilsrrrrlp.exceptionsrr rlp.sedesrr r r rlp.sedes.binaryr r~rlp.sedes.listsr rrrlp.sedes.serializabler rlp.utilsrrrr ImportErrorlogging rlp.atomicr" getLoggerloggerdebugrJrMr4rWr_rar;rsrprDr&rrs   =(`) (2j 7" 'NT&=R ,'T 6 M +$W  { +F LL <  * $E+$sA))8B$#B$