def coerce_addr_to_hex(x):
if is_numeric(x):
return encode_hex(zpad(big_endian_int.serialize(x), 20))
elif len(x) == 40 or len(x) == 0:
return x
else:
return encode_hex(zpad(x, 20)[-20:])
def coerce_addr_to_hex(x):
if is_numeric(x):
return encode_hex(zpad(big_endian_int.serialize(x), 20))
elif len(x) == 40 or len(x) == 0:
return x
else:
return encode_hex(zpad(x, 20)[-20:])
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 coerce_to_bytes(x):
if is_numeric(x):
return big_endian_int.serialize(x)
elif len(x) == 40:
return decode_hex(x)
else:
return x
def coerce_to_bytes(x):
if is_numeric(x):
return big_endian_int.serialize(x)
elif len(x) == 40:
return decode_hex(x)
else:
return x
def serialize(cls, enr: ENRAPI) -> Tuple[bytes, ...]:
serialized_sequence_number = big_endian_int.serialize(
enr.sequence_number)
sorted_key_value_pairs = sorted(enr.items(),
key=operator.itemgetter(0))
serialized_keys = tuple(
binary.serialize(key) for key, _ in sorted_key_value_pairs)
values_and_serializers = tuple(
(value, ENR_KEY_SEDES_MAPPING.get(key, FALLBACK_ENR_VALUE_SEDES))
for key, value in sorted_key_value_pairs)
serialized_values = tuple(
value_serializer.serialize(value)
for value, value_serializer in values_and_serializers)
return tuple(
cons(
serialized_sequence_number,
interleave((serialized_keys, serialized_values)),
))
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):
return value
def int_to_big_endian(x): return big_endian_int.serialize(x) TT256 = 2 ** 256
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
def rand_bytes(num=32):
return zpad(big_endian_int.serialize(random.getrandbits(num * 8)), num)
def test_rejects_bool(value):
with pytest.raises(SerializationError):
big_endian_int.serialize(value)
def int_to_big_endian(x):
return big_endian_int.serialize(x) # Serialize interger to big endian
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)
def rand_bytes(num=32):
return zpad(big_endian_int.serialize(random.getrandbits(num * 8)), num)
def test_neg():
for n in negative_ints:
with pytest.raises(SerializationError):
big_endian_int.serialize(n)
def int_to_big_endian(x: int) -> bytes:
return big_endian_int.serialize(x)
def int_to_hexstring(v):
return "0x" + encode_hex(big_endian_int.serialize(parse_int_or_hex(v)))
