def validate_value(cls, value):
if not is_bytes(value):
raise EncodingTypeError(
"Value of type {} cannot be encoded by {}".format(
type(value),
cls.__name__,
))
def generate_cache_key(value):
"""
Generates a cache key for the *args and **kwargs
"""
if is_bytes(value):
return hashlib.md5(value).hexdigest()
elif is_text(value):
return generate_cache_key(to_bytes(text=value))
elif is_boolean(value) or is_null(value) or is_number(value):
return generate_cache_key(repr(value))
elif is_dict(value):
return generate_cache_key((
(key, value[key])
for key
in sorted(value.keys())
))
elif is_list_like(value) or isinstance(value, Generator):
return generate_cache_key("".join((
generate_cache_key(item)
for item
in value
)))
else:
raise TypeError("Cannot generate cache key for value {0} of type {1}".format(
value,
type(value),
))
def __eq__(self, other: Any) -> bool:
if hasattr(other, 'to_bytes'):
return self.to_bytes() == other.to_bytes()
elif is_bytes(other):
return self.to_bytes() == other
else:
return False
def hex_encode_abi_type(abi_type, value, force_size=None):
"""
Encodes value into a hex string in format of abi_type
"""
validate_abi_type(abi_type)
validate_abi_value(abi_type, value)
data_size = force_size or size_of_type(abi_type)
if is_array_type(abi_type):
sub_type = sub_type_of_array_type(abi_type)
return "".join([
remove_0x_prefix(hex_encode_abi_type(sub_type, v, 256))
for v in value
])
elif is_bool_type(abi_type):
return to_hex_with_size(value, data_size)
elif is_uint_type(abi_type):
return to_hex_with_size(value, data_size)
elif is_int_type(abi_type):
return to_hex_twos_compliment(value, data_size)
elif is_address_type(abi_type):
return pad_hex(value, data_size)
elif is_bytes_type(abi_type):
if is_bytes(value):
return encode_hex(value)
else:
return value
elif is_string_type(abi_type):
return to_hex(text=value)
else:
raise ValueError("Unsupported ABI type: {0}".format(abi_type))
def test_eth_sign(self, web3, unlocked_account_dual_type):
signature = web3.eth.sign(unlocked_account_dual_type,
text='Message tö sign. Longer than hash!')
assert is_bytes(signature)
assert len(signature) == 32 + 32 + 1
# test other formats
hexsign = web3.eth.sign(
unlocked_account_dual_type,
hexstr=
'0x4d6573736167652074c3b6207369676e2e204c6f6e676572207468616e206861736821'
)
assert hexsign == signature
intsign = web3.eth.sign(
unlocked_account_dual_type,
0x4d6573736167652074c3b6207369676e2e204c6f6e676572207468616e206861736821
)
assert intsign == signature
bytessign = web3.eth.sign(
unlocked_account_dual_type,
b'Message t\xc3\xb6 sign. Longer than hash!')
assert bytessign == signature
new_signature = web3.eth.sign(unlocked_account_dual_type,
text='different message is different')
assert new_signature != signature
def decode_abi(types, data):
if not is_bytes(data):
raise TypeError("The `data` value must be of bytes type. Got {0}".format(type(data)))
decoders = [
registry.get_decoder(type_str)
for type_str in types
]
decoder = TupleDecoder(decoders=decoders)
stream = ContextFramesBytesIO(data)
return decoder(stream)
def decode_single(typ, data):
if not is_bytes(data):
raise TypeError("The `data` value must be of bytes type. Got {0}".format(type(data)))
if isinstance(typ, str):
type_str = typ
else:
type_str = collapse_type(*typ)
decoder = registry.get_decoder(type_str)
stream = ContextFramesBytesIO(data)
return decoder(stream)
def validate_value(self, value):
if not is_bytes(value):
raise EncodingTypeError(
"Value of type {0} cannot be encoded by {1}".format(
type(value),
type(self).__name__,
))
if len(value) > self.value_bit_size // 8:
raise ValueOutOfBounds(
"String {0} exceeds total byte size for bytes{1} encoding".
format(
value,
self.value_bit_size // 8,
))
def validate_abi_value(abi_type, value):
"""
Helper function for validating a value against the expected abi_type
Note: abi_type 'bytes' must either be python3 'bytes' object or ''
"""
if is_array_type(abi_type) and is_list_like(value):
# validate length
specified_length = length_of_array_type(abi_type)
if specified_length is not None:
if specified_length < 1:
raise TypeError(
"Invalid abi-type: {abi_type}. Length of fixed sized arrays"
"must be greater than 0.".format(abi_type=abi_type))
if specified_length != len(value):
raise TypeError(
"The following array length does not the length specified"
"by the abi-type, {abi_type}: {value}".format(
abi_type=abi_type, value=value))
# validate sub_types
sub_type = sub_type_of_array_type(abi_type)
for v in value:
validate_abi_value(sub_type, v)
return
elif is_bool_type(abi_type) and is_boolean(value):
return
elif is_uint_type(abi_type) and is_integer(value) and value >= 0:
return
elif is_int_type(abi_type) and is_integer(value):
return
elif is_address_type(abi_type):
validate_address(value)
return
elif is_bytes_type(abi_type):
if is_bytes(value):
return
elif is_string(value):
if is_0x_prefixed(value):
return
else:
raise TypeError(
"ABI values of abi-type 'bytes' must be either"
"a python3 'bytes' object or an '0x' prefixed string.")
elif is_string_type(abi_type) and is_string(value):
return
raise TypeError(
"The following abi value is not a '{abi_type}': {value}".format(
abi_type=abi_type, value=value))
def is_predefined_block_number(value):
if is_text(value):
value_text = value
elif is_bytes(value):
# `value` could either be random bytes or the utf-8 encoding of
# one of the words in: {"latest", "pending", "earliest"}
# We cannot decode the bytes as utf8, because random bytes likely won't be valid.
# So we speculatively decode as 'latin-1', which cannot fail.
value_text = value.decode('latin-1')
elif is_integer(value):
return False
else:
raise TypeError("unrecognized block reference: %r" % value)
return value_text in {"latest", "pending", "earliest"}
def validate_bytes(value: Any) -> None:
if not is_bytes(value):
raise ValidationError("Value must be a byte string. Got: {0}".format(
type(value)))
