def test_register_and_use_callables():
registry.register('null', encode_null, decode_null)
try:
assert encode_single('null', None) == NULL_ENCODING
assert decode_single('null', NULL_ENCODING) is None
encoded_tuple = encode_single('(int,null)', (1, None))
assert encoded_tuple == b'\x00' * 31 + b'\x01' + NULL_ENCODING
assert decode_single('(int,null)', encoded_tuple) == (1, None)
finally:
registry.unregister('null')
def test_register_and_use_callables():
registry.register('null', encode_null, decode_null)
try:
assert encode_single('null', None) == NULL_ENCODING
assert decode_single('null', NULL_ENCODING) is None
encoded_tuple = encode_single('(int,null)', (1, None))
assert encoded_tuple == b'\x00' * 31 + b'\x01' + NULL_ENCODING
assert decode_single('(int,null)', encoded_tuple) == (1, None)
finally:
registry.unregister('null')
def test_register_and_use_coder_classes():
registry.register(
lambda x: x.startswith('null'),
EncodeNull,
DecodeNull,
label='null',
)
try:
assert encode_single('null2', None) == NULL_ENCODING * 2
assert decode_single('null2', NULL_ENCODING * 2) is None
encoded_tuple = encode_single('(int,null2)', (1, None))
assert encoded_tuple == b'\x00' * 31 + b'\x01' + NULL_ENCODING * 2
assert decode_single('(int,null2)', encoded_tuple) == (1, None)
finally:
registry.unregister('null')
def test_register_and_use_coder_classes():
registry.register(
lambda x: x.startswith('null'),
EncodeNull,
DecodeNull,
label='null',
)
try:
assert encode_single('null2', None) == NULL_ENCODING * 2
assert decode_single('null2', NULL_ENCODING * 2) is None
encoded_tuple = encode_single('(int,null2)', (1, None))
assert encoded_tuple == b'\x00' * 31 + b'\x01' + NULL_ENCODING * 2
assert decode_single('(int,null2)', encoded_tuple) == (1, None)
finally:
registry.unregister('null')
def test_decode_accepts_bytes(input, expected):
output = decode_single('int256', input)
assert output == expected
def test_decode_int256(input, expected):
output = decode_single('int256', input)
assert output == expected
def test_int8_decoding(input, expected):
output = decode_single('int8', input)
assert output == expected
def test_0x_prefix_optional(input, expected):
output = decode_single('int256', input)
assert output == expected
def test_decode_bytes32(input, expected):
output = decode_single('bytes32', input)
assert output == expected
def test_decode_bool(input, expected):
output = decode_single('bool', input)
assert output == expected
def test_decode_single_wrong_data_type_raises():
with pytest.raises(TypeError):
decode_single('uint32', '')
def test_decode_single(typ, expected, abi_encoding, _):
actual = decode_single(typ, abi_encoding)
assert actual == expected
def test_decode_single(typ, expected, abi_encoding, _):
actual = decode_single(typ, abi_encoding)
assert actual == expected
def decode_logs(self, abi: EventABI,
data: List[Dict]) -> Iterator["ContractLog"]:
if not abi.anonymous:
event_id_bytes = keccak(to_bytes(text=abi.selector))
matching_logs = [
log for log in data if log["topics"][0] == event_id_bytes
]
else:
matching_logs = data
topics_list: List[EventABIType] = []
data_list: List[EventABIType] = []
for abi_input in abi.inputs:
if abi_input.indexed:
topics_list.append(abi_input)
else:
data_list.append(abi_input)
abi_topics = LogInputABICollection(abi, topics_list)
abi_data = LogInputABICollection(abi, data_list)
duplicate_names = set(abi_topics.names).intersection(abi_data.names)
if duplicate_names:
duplicate_names_str = ", ".join([n for n in duplicate_names if n])
raise DecodingError(
"The following argument names are duplicated "
f"between event inputs: '{duplicate_names_str}'.")
for log in matching_logs:
indexed_data = log["topics"] if log.get(
"anonymous", False) else log["topics"][1:]
log_data = hexstr_if_str(to_bytes, log["data"]) # type: ignore
if len(indexed_data) != len(abi_topics.types):
raise DecodingError(
f"Expected '{len(indexed_data)}' log topics. Got '{len(abi_topics.types)}'."
)
def decode_items(abi_types, data):
def decode_value(t, v) -> Any:
if t == "address":
return self.decode_address(v)
elif t == "bytes32":
return HexBytes(v)
return v
return [decode_value(t, v) for t, v in zip(abi_types, data)]
decoded_topic_data = [
decode_single(topic_type, topic_data) # type: ignore
for topic_type, topic_data in zip(abi_topics.types,
indexed_data)
]
decoded_log_data = decode_abi(abi_data.types,
log_data) # type: ignore
event_args = dict(
itertools.chain(
zip(abi_topics.names,
decode_items(abi_topics.types, decoded_topic_data)),
zip(abi_data.names,
decode_items(abi_data.types, decoded_log_data)),
))
yield ContractLog( # type: ignore
name=abi.name,
index=log["logIndex"],
event_arguments=event_args,
transaction_hash=log["transactionHash"],
block_hash=log["blockHash"],
block_number=log["blockNumber"],
) # type: ignore
def test_decode_single_wrong_data_type_raises():
with pytest.raises(TypeError):
decode_single('uint32', '')
def test_decode_single(typ, expected, byte_str):
actual = decode_single(typ, byte_str)
assert actual == expected
def test_decode_address(input, expected):
output = decode_single('address', input)
assert output == expected
