def test_serialization():
for n in random_integers:
serial = big_endian_int.serialize(n)
deserialized = big_endian_int.deserialize(serial)
assert deserialized == n
if n != 0:
assert serial[0] != b'\x00' # is not checked
def decode(self, data):
# cmdid = rlp.peek(data, 0, sedes=t_int) # cmdid is first element
t, l, pos = consume_length_prefix(data, 0)
cmdid = t_int.deserialize(consume_item(data[pos], 0)[0])
cls = self.message_class_by_id[cmdid]
print 'DECODING', cls
return cls.decode(data)
def deserialize(
cls,
serialized_enr: Sequence[bytes],
) -> "UnsignedENR":
cls._validate_serialized_length(serialized_enr)
sequence_number = big_endian_int.deserialize(serialized_enr[0])
kv_pairs = cls._deserialize_kv_pairs(serialized_enr)
return UnsignedENR(sequence_number, kv_pairs)
def deserialize(
cls,
serialized_enr: Sequence[bytes],
identity_scheme_registry:
IdentitySchemeRegistry = default_id_scheme_registry,
) -> "UnsignedENR":
cls._validate_serialized_length(serialized_enr)
sequence_number = big_endian_int.deserialize(serialized_enr[0])
kv_pairs = cls._deserialize_kv_pairs(serialized_enr)
return UnsignedENR(sequence_number, kv_pairs, identity_scheme_registry)
def deserialize(
cls,
serialized_enr: Sequence[bytes],
identity_scheme_registry:
IdentitySchemeRegistryAPI = default_id_scheme_registry,
) -> UnsignedENRAPI:
from eth_enr.enr import UnsignedENR # noqa: F811
cls._validate_serialized_length(serialized_enr)
sequence_number = big_endian_int.deserialize(serialized_enr[0])
kv_pairs = cls._deserialize_kv_pairs(serialized_enr)
return UnsignedENR(sequence_number, kv_pairs, identity_scheme_registry)
def _decode_who_are_you_payload(encoded_packet: bytes) -> Tuple[Nonce, IDNonce, int]:
payload_rlp = encoded_packet[MAGIC_SIZE:]
try:
payload = rlp.decode(payload_rlp)
except DecodingError as error:
raise ValidationError(
f"WHOAREYOU payload section is not proper RLP: {encode_hex(payload_rlp)}"
) from error
if not is_list_like(payload):
raise ValidationError(
f"WHOAREYOU payload section is not an RLP encoded list: {payload}"
)
if len(payload) != 3:
raise ValidationError(
f"WHOAREYOU payload consists of {len(payload)} instead of 3 elements: {payload}"
)
token, id_nonce, enr_seq_bytes = payload
enr_seq = big_endian_int.deserialize(enr_seq_bytes)
validate_nonce(token)
return Nonce(token), id_nonce, enr_seq
# THE SOFTWARE.
try:
from Crypto.Hash import keccak
sha3_256 = lambda x: keccak.new(digest_bits=256, data=x).digest()
except:
import sha3 as _sha3
sha3_256 = lambda x: _sha3.sha3_256(x).digest()
from bitcoin import privtopub
import sys
import rlp
from rlp.sedes import big_endian_int, BigEndianInt, Binary
from rlp.utils import decode_hex, encode_hex, ascii_chr, str_to_bytes
import random
big_endian_to_int = lambda x: big_endian_int.deserialize(
str_to_bytes(x).lstrip(b'\x00'))
int_to_big_endian = lambda x: big_endian_int.serialize(x)
TT256 = 2**256
TT256M1 = 2**256 - 1
TT255 = 2**255
if sys.version_info.major == 2:
is_numeric = lambda x: isinstance(x, (int, long))
is_string = lambda x: isinstance(x, (str, unicode))
def to_string(value):
return str(value)
def int_to_bytes(value):
if isinstance(value, str):
def decode_big_endian_int(value):
return big_endian_int.deserialize(value.lstrip(b'\x00'))
def decode_big_endian_int(value):
return big_endian_int.deserialize(value.lstrip(b'\x00'))
def big_endian_to_int(x):
return big_endian_int.deserialize(str_to_bytes(x).lstrip(b'\x00'))
def test_valid_data():
for n, serial in valid_data:
serialized = big_endian_int.serialize(n)
deserialized = big_endian_int.deserialize(serial)
assert serialized == serial
assert deserialized == n
def test_single_byte():
for n, s in single_bytes:
serial = big_endian_int.serialize(n)
assert serial == s
deserialized = big_endian_int.deserialize(serial)
assert deserialized == n
from sha3 import sha3_256
from bitcoin import privtopub
import struct
import os
import sys
import rlp
from rlp.sedes import big_endian_int, BigEndianInt, Binary
from rlp.utils import decode_hex, encode_hex, ascii_chr, str_to_bytes
import random
big_endian_to_int = lambda x: big_endian_int.deserialize(str_to_bytes(x).lstrip(b"\x00"))
int_to_big_endian = lambda x: big_endian_int.serialize(x)
TT256 = 2 ** 256
TT256M1 = 2 ** 256 - 1
TT255 = 2 ** 255
if sys.version_info.major == 2:
is_numeric = lambda x: isinstance(x, (int, long))
is_string = lambda x: isinstance(x, (str, unicode))
def to_string(value):
return str(value)
def int_to_bytes(value):
if isinstance(value, str):
return value
return int_to_big_endian(value)
