o h1@s4ddlZddlmZmZmZddlmZmZddlm Z m Z m Z m Z ddl mZddlmZmZmZddlmZddlmZzddlZWn%eyiddlZdd lmZed Zed d d Z ddZ!Yn wddZ!dd Z d&ddZ"dZ#ddZ$dZ%ddZ&ddZ'ddZ(d'd d!Z)d"d#Z*d$d%Z+dS)(N)big_endian_to_intint_to_big_endianis_bytes) DecodingError EncodingError)big_endian_intbinarybooleantext)Binary)Listis_sedes is_sequence) Serializable) ALL_BYTES)Atomicz rlp.codecz}Consider installing rusty-rlp to improve pyrlp performance with a rust basedbackend. Not currently functional for Python 3.11cCst|trt|dkr|ddkr|S|}d}n&t|ts1t|tjjr1ddd|D}d}n dt|j }t ||z t t||}W||St yVt d |w) z4RLP encode (a nested sequence of) :class:`Atomic`\s.rcss|]}t|VqdSN) encode_raw).0xrV/var/www/html/HyperOracle/crypto_trader/venv/lib/python3.10/site-packages/rlp/codec.py 9szencode_raw..zCannot encode object of type zItem too big to encode) isinstancerlenstr collectionsabcSequencejointype__name__r length_prefix ValueError)itempayload prefix_offsetmsgprefixrrrr1s   rcCsdz t|d\}}}Wn tytd|w|t|kr.|r.dt||d}t||||fS)NrzRLP string too shortzRLP string ends with z superfluous bytes) consume_item IndexErrorrr)r(strict_result per_item_rlpendr+rrr decode_rawFs   r4c Cs:zt|||WSttjfy}zt||d}~wwr) rusty_rlpr4 TypeErrorr)r(r/preserve_per_item_rlperrrr4Ss  c CsDzt|tr t|}t|WStjy!}zt||d}~wwr)r bytearraybytesr5rr)objr8rrrrYs   TcCspt|tr|j}|dur|r|S|o|du}nd}|r!||}n |r+t||}n|}t|}|r6||_|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_cacher(r1rrrencodebs   rDlcCsH|dkr t||S|tkr t|}t|ddt||Std)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 8rzLength greater than 256**8)r LONG_LENGTHrrr')lengthoffset length_stringrrrr&s  r&cCs||}|dkrdtd|fS|tkr5|ddkr%||ddkr%td||||dt|d|dfS|dkry|d}||d|ddkrNtd |||d|d|}t|}|d krgtd ||||d|t||d|fS|d kr|||dt|d|dfS|dd d}||d|ddkrtd |||d|d|}t|}|d krtd ||||d|t||d|fS)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 rrrz9Encoded as short string although single byte was possiblerzLength starts with zero bytesrEz(Long string prefix used for short stringz$Long list prefix used for short list)r: SHORT_STRINGrrlist)rlpstartb0ll len_prefixlrrrconsume_length_prefixs8     $   $rWcCs|tur||||}|||g||fS|turfg}g}|}|} | |} | | krRt|| \} } } }t|| || | \}}} ||||d7}||| | ks*|d|| | kratd|||| 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)r:rPrWconsume_payloadappendinsertrr6)rQr,rRtype_rGr(itemsr2list_rlpnext_item_startr3ptrVsitem_rlprrrrXs.      rXcCs"t||\}}}}t|||||S)a Read an item from an RLP string. :param rlp: the rlp string to read from :param start: the position at which to start reading :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 )rWrX)rQrRr_r`rVrarrrr-s r-FcKszt|stdt|j|t|||\}}t|dkr|g}|r;|j|fi|}t|s3t|dr9t ||||S|S)a Decode an RLP encoded object. If the deserialized result `obj` has an attribute :attr:`_cached_rlp` (e.g. if `sedes` is a subclass of :class:`rlp.Serializable`) it will be set to `rlp`, which will improve performance on subsequent :func:`rlp.encode` calls. Bear in mind however that `obj` needs to make sure that this value is updated whenever one of its fields changes or prevent such changes entirely (:class:`rlp.sedes.Serializable` does the latter). :param sedes: an object implementing a function ``deserialize(code)`` which will be applied after decoding, or ``None`` if no deserialization should be performed :param `**kwargs`: additional keyword arguments that will be passed to the deserializer :param strict: if false inputs that are longer than necessary don't cause an exception :returns: the decoded and maybe deserialized Python object :raises: :exc:`rlp.DecodingError` if the input string does not end after the root item and `strict` is true :raises: :exc:`rlp.DeserializationError` if the deserialization fails z&Can only decode RLP bytes, got type %srr<) rrr$r%r4r deserializerhasattr_apply_rlp_cache)rQr?r/recursive_cachekwargsr(r2r;rrrdecodes  rhcCs~|d}t|tttttfrdSt|dr||_|sdS|D]}t|tttttfr1|dq|d}t |||qdS)Nrr<) poprintboolrr:r9rdr<re)r; split_rlp recursiverbsubsub_rlprrrre:s    recCst|jr|jSt|tst|tr|dkrtSt|rtSt|t s2t|t j j r2t tt|St|tr9tSt|t r@tSdt|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__rrkrjr BinaryClass is_valid_typerrr r!r"r mapr>r r r$r%r6)r;r+rrrr>Js    r>)NTT)NTF),r eth_utilsrrrrlp.exceptionsrr rlp.sedesrrr r rlp.sedes.binaryr rqrlp.sedes.listsr r rrlp.sedes.serializabler rlp.utilsrr5 ImportErrorlogging rlp.atomicr getLoggerloggerdebugrr4rDrFr&rOrWrXr-rhrer>rrrrs@        / 5*) *