def _decode_transaction(self, data: Union[bytes, str]) -> Tuple[str, List[Tuple[str, str, Any]]]:
"""
Decode tx data
:param data: Tx data as `hex string` or `bytes`
:return: Tuple with the `function name` and a List of sorted tuples with
the `name` of the argument, `type` and `value`
:raises: CannotDecode if data cannot be decoded. You should catch this exception when using this function
:raises: UnexpectedProblemDecoding if there's an unexpected problem decoding (it shouldn't happen)
"""
if not data:
raise CannotDecode(data)
data = HexBytes(data)
selector, params = data[:4], data[4:]
if selector not in self.supported_fn_selectors:
raise CannotDecode(data.hex())
try:
contract_fn = self.supported_fn_selectors[selector]
names = get_abi_input_names(contract_fn.abi)
types = get_abi_input_types(contract_fn.abi)
decoded = self.dummy_w3.codec.decode_abi(types, cast(HexBytes, params))
normalized = map_abi_data(BASE_RETURN_NORMALIZERS, types, decoded)
values = map(self._parse_decoded_arguments, normalized)
except ValueError as exc:
raise UnexpectedProblemDecoding from exc
return contract_fn.fn_name, list(zip(names, types, values))
def decode_log(log_data, events):
topic_inputs = get_indexed_event_inputs(log_data['abi'])
topic_types = get_abi_input_types({'inputs': topic_inputs})
topic_names = get_abi_input_names({'inputs': topic_inputs})
topic_data = [HexBytes(topic) for topic in log_data['topics'][1:]]
decoded_topics = [
decode_single(topic_type, topic_data)
for topic_type, topic_data in zip(topic_types, topic_data)
]
data_inputs = exclude_indexed_event_inputs(log_data['abi'])
data_types = get_abi_input_types({'inputs': data_inputs})
data_names = get_abi_input_names({'inputs': data_inputs})
decoded_data = decode_abi(data_types, HexBytes(log_data['data']))
return dict(
itertools.chain(
zip(topic_names, decoded_topics),
zip(data_names, decoded_data),
))
def decode_function_input(self, data):
data = HexBytes(data)
selector, params = data[:4], data[4:]
func = self.get_function_by_selector(selector)
names = get_abi_input_names(func.abi)
types = get_abi_input_types(func.abi)
decoded = self.web3.codec.decode_abi(types, params)
normalized = map_abi_data(BASE_RETURN_NORMALIZERS, types, decoded)
return func, dict(zip(names, normalized))
def decode_func_with_fallback(abis_to_try, data):
for abi in abis_to_try:
try:
selector, params = data[:4], data[4:]
names = get_abi_input_names(abi)
types = get_abi_input_types(abi)
decoded = w3.codec.decode_abi(types, params)
normalized = map_abi_data(BASE_RETURN_NORMALIZERS, types, decoded)
return abi['name'], dict(zip(names, normalized))
except DecodingError:
logger.debug('trying fallback fn input decoder')
raise DecodingError('could not decode fn input')
def _decode_data(
self,
data: Union[bytes, str],
address: Optional[ChecksumAddress] = None
) -> Tuple[str, List[Tuple[str, str, Any]]]:
"""
Decode tx data
:param data: Tx data as `hex string` or `bytes`
:param address: contract address in case of ABI colliding
:return: Tuple with the `function name` and a List of sorted tuples with
the `name` of the argument, `type` and `value`
:raises: CannotDecode if data cannot be decoded. You should catch this exception when using this function
:raises: UnexpectedProblemDecoding if there's an unexpected problem decoding (it shouldn't happen)
"""
if not data:
raise CannotDecode(data)
data = HexBytes(data)
params = data[4:]
fn_abi = self.get_abi_function(data, address)
if not fn_abi:
raise CannotDecode(data.hex())
try:
names = get_abi_input_names(fn_abi)
types = get_abi_input_types(fn_abi)
decoded = self.dummy_w3.codec.decode_abi(types,
cast(HexBytes, params))
normalized = map_abi_data(BASE_RETURN_NORMALIZERS, types, decoded)
values = map(self._parse_decoded_arguments, normalized)
except (ValueError, DecodingError) as exc:
logger.warning("Cannot decode %s", data.hex())
raise UnexpectedProblemDecoding(data) from exc
return fn_abi["name"], list(zip(names, types, values))
def get_event_data(abi_codec: ABICodec, event_abi: ABIEvent, log_entry: LogReceipt) -> EventData:
"""
Given an event ABI and a log entry for that event, return the decoded
event data
"""
if event_abi['anonymous']:
log_topics = log_entry['topics']
elif not log_entry['topics']:
raise MismatchedABI("Expected non-anonymous event to have 1 or more topics")
# type ignored b/c event_abi_to_log_topic(event_abi: Dict[str, Any])
elif event_abi_to_log_topic(event_abi) != log_entry['topics'][0]: # type: ignore
raise MismatchedABI("The event signature did not match the provided ABI")
else:
log_topics = log_entry['topics'][1:]
log_topics_abi = get_indexed_event_inputs(event_abi)
log_topic_normalized_inputs = normalize_event_input_types(log_topics_abi)
log_topic_types = get_event_abi_types_for_decoding(log_topic_normalized_inputs)
log_topic_names = get_abi_input_names(ABIEvent({'inputs': log_topics_abi}))
if len(log_topics) != len(log_topic_types):
raise LogTopicError("Expected {0} log topics. Got {1}".format(
len(log_topic_types),
len(log_topics),
))
log_data = hexstr_if_str(to_bytes, log_entry['data'])
log_data_abi = exclude_indexed_event_inputs(event_abi)
log_data_normalized_inputs = normalize_event_input_types(log_data_abi)
log_data_types = get_event_abi_types_for_decoding(log_data_normalized_inputs)
log_data_names = get_abi_input_names(ABIEvent({'inputs': log_data_abi}))
# sanity check that there are not name intersections between the topic
# names and the data argument names.
duplicate_names = set(log_topic_names).intersection(log_data_names)
if duplicate_names:
raise InvalidEventABI(
"The following argument names are duplicated "
f"between event inputs: '{', '.join(duplicate_names)}'"
)
decoded_log_data = abi_codec.decode_abi(log_data_types, log_data)
normalized_log_data = map_abi_data(
BASE_RETURN_NORMALIZERS,
log_data_types,
decoded_log_data
)
decoded_topic_data = [
abi_codec.decode_single(topic_type, topic_data)
for topic_type, topic_data
in zip(log_topic_types, log_topics)
]
normalized_topic_data = map_abi_data(
BASE_RETURN_NORMALIZERS,
log_topic_types,
decoded_topic_data
)
event_args = dict(itertools.chain(
zip(log_topic_names, normalized_topic_data),
zip(log_data_names, normalized_log_data),
))
event_data = {
'args': event_args,
'event': event_abi['name'],
'logIndex': log_entry['logIndex'],
'transactionIndex': log_entry['transactionIndex'],
'transactionHash': log_entry['transactionHash'],
'address': log_entry['address'],
'blockHash': log_entry['blockHash'],
'blockNumber': log_entry['blockNumber'],
}
return cast(EventData, AttributeDict.recursive(event_data))
