def _decode_logs(logs: List) -> Union["EventDict", List[None]]:
if not logs:
return []
idx = 0
events: List = []
while True:
address = logs[idx]["address"]
try:
new_idx = logs.index(
next(i for i in logs[idx:] if i["address"] != address))
log_slice = logs[idx:new_idx]
idx = new_idx
except StopIteration:
log_slice = logs[idx:]
topics_map = _deployment_topics.get(address, _topics)
events.extend(
eth_event.decode_logs(log_slice, topics_map, allow_undecoded=True))
if log_slice[-1] == logs[-1]:
break
events = [format_event(i) for i in events]
return EventDict(events)
def _decode_logs(logs: List, contracts: Optional[Dict] = None) -> EventDict:
if not logs:
return EventDict()
idx = 0
events: List = []
while True:
address = logs[idx]["address"]
try:
new_idx = logs.index(next(i for i in logs[idx:] if i["address"] != address))
log_slice = logs[idx:new_idx]
idx = new_idx
except StopIteration:
log_slice = logs[idx:]
topics_map = _deployment_topics.get(address, _topics)
for item in log_slice:
if contracts and contracts[item.address]:
note = _decode_ds_note(item, contracts[item.address])
if note:
events.append(note)
continue
try:
events.extend(eth_event.decode_logs([item], topics_map, allow_undecoded=True))
except EventError as exc:
warnings.warn(f"{address}: {exc}")
if log_slice[-1] == logs[-1]:
break
events = [format_event(i) for i in events]
return EventDict(events)
def _decode_logs(logs: List) -> EventDict:
if not logs:
return EventDict()
idx = 0
events: List = []
while True:
address = logs[idx]["address"]
try:
new_idx = logs.index(
next(i for i in logs[idx:] if i["address"] != address))
log_slice = logs[idx:new_idx]
idx = new_idx
except StopIteration:
log_slice = logs[idx:]
topics_map = _deployment_topics.get(address, _topics)
for item in log_slice:
try:
events.extend(
eth_event.decode_logs([item],
topics_map,
allow_undecoded=True))
except EventError as exc:
warnings.warn(str(exc))
if log_slice[-1] == logs[-1]:
break
events = [format_event(i) for i in events]
return EventDict(events)
def _decode_logs(logs: List) -> Union["EventDict", List[None]]:
if not logs:
return []
events: List = []
for value in logs:
try:
events += eth_event.decode_logs([value], _topics)
except KeyError:
pass
events = [format_event(i) for i in events]
return EventDict(events)
def decode_log(tx, contract, event_name):
"""
Get transaction logs for specific event name
:param tx: transaction object
:param contract: Contract object
:param event_name: name of the event
:return: EventDict with the events parsed
"""
topic_map = eth_event.get_topic_map(contract.abi)
logs = eth_event.decode_logs(tx.logs, topic_map, True)
events = list(filter(lambda tx_: tx_['name'] == event_name, logs))
return EventDict([format_event(i) for i in events])[event_name]
def test_decode_logs_no_topic(anon_a_log, topic_map):
logs = [anon_a_log]
event = decode_logs(logs, topic_map, allow_undecoded=True)
assert event == [
{
"name": None,
"address": "0x3194cBDC3dbcd3E11a07892e7bA5c3394048Cc87",
"data": "0x00000000000000000000000066ab6d9362d4f35596279692f0251db635165871",
"topics": [],
"decoded": False,
}
]
def _await_confirm(self, silent, callback):
while True:
tx = web3.eth.getTransaction(self.txid)
if tx:
break
time.sleep(0.5)
if not self.sender:
self.sender = tx['from']
self.__dict__.update({
'receiver': tx['to'],
'value': tx['value'],
'gas_price': tx['gasPrice'],
'gas_limit': tx['gas'],
'input': tx['input'],
'nonce': tx['nonce'],
})
if not tx['blockNumber'] and CONFIG['logging']['tx'] and not silent:
print("Waiting for confirmation...")
receipt = web3.eth.waitForTransactionReceipt(self.txid, None)
self.__dict__.update({
'block_number': receipt['blockNumber'],
'txindex': receipt['transactionIndex'],
'gas_used': receipt['gasUsed'],
'contract_address': receipt['contractAddress'],
'logs': receipt['logs'],
'status': receipt['status']
})
try:
self.events = eth_event.decode_logs(receipt['logs'], topics())
except:
pass
if self.fn_name and config.ARGV['gas']:
_profile_gas(self.fn_name, receipt['gasUsed'])
if not silent:
if CONFIG['logging']['tx'] >= 2:
self.info()
elif CONFIG['logging']['tx']:
color.print_colors(
"{} confirmed {}- block: {} gas used: {} ({:.2%})".
format(
self.fn_name or "Transaction",
"" if self.status else "({0[error]}{1}{0}) ".format(
color, self.revert_msg or "reverted"),
self.block_number, self.gas_used,
self.gas_used / self.gas_limit))
if receipt['contractAddress']:
color.print_colors("{} deployed at: {}".format(
self.fn_name.split('.')[0],
receipt['contractAddress']))
if callback:
callback(self)
def parse_swap(log):
addr_pair = log['address']
[(t0_balance, t0_address), (t1_balance, t1_address),
amount_lp] = web3_utils.get_lp_value(uni_wrapper, addr_pair)
t0_info = web3_utils.get_token_info(uni_wrapper, t0_address)
t0_info = TokenInfo(addr=t0_address,
name=t0_info['name'],
symbol=t0_info['symbol'],
decimals=t0_info['decimals'])
t1_info = web3_utils.get_token_info(uni_wrapper, t1_address)
t1_info = TokenInfo(addr=t1_address,
name=t1_info['name'],
symbol=t1_info['symbol'],
decimals=t1_info['decimals'])
topic_map = eth_event.get_topic_map(abi_pair)
swap = eth_event.decode_logs([log], topic_map)
# pprint(swap)
(amount0In, amount1Out, amount1In, amount0Out, to,
sender) = (None, None, None, None, None, None)
for value in swap[0]['data']:
# pprint(value)
if value['name'] == 'sender':
sender = value['value']
elif value['name'] == 'to':
to = value['value']
elif value['name'] == 'amount0In':
amount0In = int(value['value'])
elif value['name'] == 'amount0Out':
amount0Out = int(value['value'])
elif value['name'] == 'amount1In':
amount1In = int(value['value'])
elif value['name'] == 'amount1Out':
amount1Out = int(value['value'])
if None in [amount0In, amount1Out, amount1In, amount0Out, to, sender]:
return None
if amount0In > 0:
return Swap((t1_info, amount1Out), (t0_info, amount0In),
sender=to,
to=sender)
else:
return Swap((t0_info, amount0Out), (t1_info, amount1In),
sender=sender,
to=to)
def decode_logs(logs):
if not logs:
return []
events = eth_event.decode_logs(logs, _topics)
events = [format_event(i) for i in events]
return EventDict(events)
def _decode_logs(logs: List) -> Union["EventDict", List[None]]:
if not logs:
return []
events = eth_event.decode_logs(logs, _topics)
events = [_format_event(i) for i in events]
return EventDict(events)
def decode_logs(logs):
try:
return eth_event.decode_logs(logs, _topics)
except Exception:
return []
def test_decode_logs_not_allow_undecoded(anon_a_log, topic_map):
logs = [anon_a_log]
with pytest.raises(UnknownEvent):
decode_logs(logs, topic_map, allow_undecoded=False)
def test_decode_logs_allow_undecoded(anon_a_log, anon_b_log, complex_log, topic_map):
logs = [anon_a_log, complex_log, anon_b_log]
events = decode_logs(logs, topic_map, allow_undecoded=True)
assert len(events) == 3
assert len([i for i in events if i["decoded"]]) == 1
def test_decode_logs(log, complex_log, topic_map):
decode_logs([log, complex_log], topic_map)
