def _decode_legacy_trade( # pylint: disable=no-self-use
self,
tx_log: EthereumTxReceiptLog,
transaction: EthereumTransaction, # pylint: disable=unused-argument
decoded_events: List[HistoryBaseEntry],
all_logs: List[EthereumTxReceiptLog], # pylint: disable=unused-argument
action_items: Optional[List[ActionItem]], # pylint: disable=unused-argument
) -> Tuple[Optional[HistoryBaseEntry], Optional[ActionItem]]:
if tx_log.topics[0] == KYBER_TRADE_LEGACY:
return None, None
sender, source_token, destination_token = _legacy_contracts_basic_info(tx_log)
if source_token is None or destination_token is None:
return None, None
spent_amount_raw = hex_or_bytes_to_int(tx_log.data[64:96])
return_amount_raw = hex_or_bytes_to_int(tx_log.data[96:128])
spent_amount = asset_normalized_value(amount=spent_amount_raw, asset=source_token)
return_amount = asset_normalized_value(amount=return_amount_raw, asset=destination_token)
_maybe_update_events_legacy_contrats(
decoded_events=decoded_events,
sender=sender,
source_token=source_token,
destination_token=destination_token,
spent_amount=spent_amount,
return_amount=return_amount,
)
return None, None
def _decode_redeem(
self,
tx_log: EthereumTxReceiptLog,
decoded_events: List[HistoryBaseEntry],
compound_token: EthereumToken,
) -> Tuple[Optional[HistoryBaseEntry], Optional[ActionItem]]:
redeemer = hex_or_bytes_to_address(tx_log.data[0:32])
if not self.base.is_tracked(redeemer):
return None, None
redeem_amount_raw = hex_or_bytes_to_int(tx_log.data[32:64])
redeem_tokens_raw = hex_or_bytes_to_int(tx_log.data[64:96])
underlying_token = symbol_to_asset_or_token(compound_token.symbol[1:])
redeem_amount = asset_normalized_value(redeem_amount_raw, underlying_token)
redeem_tokens = token_normalized_value(redeem_tokens_raw, compound_token)
out_event = in_event = None
for event in decoded_events:
# Find the transfer event which should have come before the redeeming
if event.event_type == HistoryEventType.RECEIVE and event.asset == underlying_token and event.balance.amount == redeem_amount: # noqa: E501
event.event_type = HistoryEventType.WITHDRAWAL
event.event_subtype = HistoryEventSubType.REMOVE_ASSET
event.counterparty = CPT_COMPOUND
event.notes = f'Withdraw {redeem_amount} {underlying_token.symbol} from compound'
in_event = event
if event.event_type == HistoryEventType.SPEND and event.asset == compound_token and event.balance.amount == redeem_tokens: # noqa: E501
event.event_type = HistoryEventType.SPEND
event.event_subtype = HistoryEventSubType.RETURN_WRAPPED
event.counterparty = CPT_COMPOUND
event.notes = f'Return {redeem_tokens} {compound_token.symbol} to compound'
out_event = event
maybe_reshuffle_events(out_event=out_event, in_event=in_event, events_list=decoded_events)
return None, None
def _decode_send_eth( # pylint: disable=no-self-use
self,
tx_log: EthereumTxReceiptLog,
transaction: EthereumTransaction, # pylint: disable=unused-argument
decoded_events: List[HistoryBaseEntry], # pylint: disable=unused-argument
all_logs: List[EthereumTxReceiptLog], # pylint: disable=unused-argument
action_items: List[ActionItem], # pylint: disable=unused-argument
) -> Tuple[Optional[HistoryBaseEntry], Optional[ActionItem]]:
if tx_log.topics[0] != TRANSFER_TO_L2:
return None, None
chain_id = hex_or_bytes_to_int(tx_log.topics[1])
recipient = hex_or_bytes_to_address(tx_log.topics[2])
amount_raw = hex_or_bytes_to_int(tx_log.data[:32])
name = chainid_to_name.get(chain_id,
f'Unknown Chain with id {chain_id}')
amount = from_wei(FVal(amount_raw))
for event in decoded_events:
if event.event_type == HistoryEventType.SPEND and event.counterparty == ETH_BRIDGE and event.asset == A_ETH and event.balance.amount == amount: # noqa: E501
if recipient == event.location_label:
target_str = 'at the same address'
else:
target_str = f'at address {recipient}'
event.event_type = HistoryEventType.TRANSFER
event.event_subtype = HistoryEventSubType.BRIDGE
event.counterparty = CPT_HOP
event.notes = f'Bridge {amount} ETH to {name} {target_str} via Hop protocol'
break
return None, None
def get_block_by_number(self, block_number: int) -> Dict[str, Any]:
"""
Gets a block object by block number
May raise:
- RemoteError due to self._query().
"""
options = {'tag': hex(block_number), 'boolean': 'true'}
block_data = self._query(module='proxy', action='eth_getBlockByNumber', options=options)
# We need to convert some data from hex here
block_data['timestamp'] = hex_or_bytes_to_int(block_data['timestamp'])
block_data['number'] = hex_or_bytes_to_int(block_data['number'])
return block_data
def _decode_elfi_claim( # pylint: disable=no-self-use
self,
tx_log: EthereumTxReceiptLog,
transaction: EthereumTransaction, # pylint: disable=unused-argument
decoded_events: List[HistoryBaseEntry], # pylint: disable=unused-argument
all_logs: List[EthereumTxReceiptLog], # pylint: disable=unused-argument
action_items: List[ActionItem], # pylint: disable=unused-argument
) -> Tuple[Optional[HistoryBaseEntry], Optional[ActionItem]]:
"""Example:
https://etherscan.io/tx/0x1e58aed1baf70b57e6e3e880e1890e7fe607fddc94d62986c38fe70e483e594b
"""
if tx_log.topics[0] != ELFI_VOTE_CHANGE:
return None, None
user_address = hex_or_bytes_to_address(tx_log.topics[1])
delegate_address = hex_or_bytes_to_address(tx_log.topics[2])
raw_amount = hex_or_bytes_to_int(tx_log.data[0:32])
amount = asset_normalized_value(amount=raw_amount, asset=A_ELFI)
# now we need to find the transfer, but can't use decoded events
# since the transfer is from one of at least 2 airdrop contracts to
# vote/locking contract. Since neither the from, nor the to is a
# tracked address there won't be a decoded transfer. So we search for
# the raw log
for other_log in all_logs:
if other_log.topics[0] != ERC20_OR_ERC721_TRANSFER:
continue
transfer_raw = hex_or_bytes_to_int(other_log.data[0:32])
if other_log.address == A_ELFI.ethereum_address and transfer_raw == raw_amount:
delegate_str = 'self-delegate' if user_address == delegate_address else f'delegate it to {delegate_address}' # noqa: E501
event = HistoryBaseEntry(
event_identifier=transaction.tx_hash.hex(),
sequence_index=self.base.get_sequence_index(tx_log),
timestamp=ts_sec_to_ms(transaction.timestamp),
location=Location.BLOCKCHAIN,
location_label=user_address,
asset=A_ELFI,
balance=Balance(amount=amount),
notes=
f'Claim {amount} ELFI from element-finance airdrop and {delegate_str}',
event_type=HistoryEventType.RECEIVE,
event_subtype=HistoryEventSubType.AIRDROP,
counterparty=CPT_ELEMENT_FINANCE,
)
return event, None
return None, None
def _decode_swapped( # pylint: disable=no-self-use
self,
tx_log: EthereumTxReceiptLog,
transaction: EthereumTransaction, # pylint: disable=unused-argument
decoded_events: List[HistoryBaseEntry], # pylint: disable=unused-argument
all_logs: List[EthereumTxReceiptLog], # pylint: disable=unused-argument
) -> Tuple[Optional[HistoryBaseEntry], Optional[ActionItem]]:
sender = hex_or_bytes_to_address(tx_log.topics[1])
source_token_address = hex_or_bytes_to_address(tx_log.topics[2])
destination_token_address = hex_or_bytes_to_address(tx_log.topics[3])
source_token = ethaddress_to_asset(source_token_address)
if source_token is None:
return None, None
destination_token = ethaddress_to_asset(destination_token_address)
if destination_token is None:
return None, None
receiver = hex_or_bytes_to_address(tx_log.data[0:32])
spent_amount_raw = hex_or_bytes_to_int(tx_log.data[64:96])
return_amount_raw = hex_or_bytes_to_int(tx_log.data[96:128])
spent_amount = asset_normalized_value(amount=spent_amount_raw,
asset=source_token)
return_amount = asset_normalized_value(amount=return_amount_raw,
asset=destination_token)
out_event = in_event = None
for event in decoded_events:
# Now find the sending and receiving events
if event.event_type == HistoryEventType.SPEND and event.location_label == sender and spent_amount == event.balance.amount and source_token == event.asset: # noqa: E501
event.event_type = HistoryEventType.TRADE
event.event_subtype = HistoryEventSubType.SPEND
event.counterparty = CPT_ONEINCH_V2
event.notes = f'Swap {spent_amount} {source_token.symbol} in {CPT_ONEINCH_V2}' # noqa: E501
out_event = event
elif event.event_type == HistoryEventType.RECEIVE and event.location_label == sender and receiver == event.location_label and return_amount == event.balance.amount and destination_token == event.asset: # noqa: E501
event.event_type = HistoryEventType.TRADE
event.event_subtype = HistoryEventSubType.RECEIVE
event.counterparty = CPT_ONEINCH_V2
event.notes = f'Receive {return_amount} {destination_token.symbol} from {CPT_ONEINCH_V2} swap' # noqa: E501
# use this index as the event may be an ETH transfer and appear at the start
event.sequence_index = tx_log.log_index
in_event = event
maybe_reshuffle_events(out_event=out_event,
in_event=in_event,
events_list=decoded_events)
return None, None
def _decode_swapped( # pylint: disable=no-self-use
self,
tx_log: EthereumTxReceiptLog,
transaction: EthereumTransaction,
decoded_events: List[HistoryBaseEntry], # pylint: disable=unused-argument
all_logs: List[EthereumTxReceiptLog], # pylint: disable=unused-argument
) -> Tuple[Optional[HistoryBaseEntry], Optional[ActionItem]]:
"""We use the Swapped event to get the fee kept by 1inch"""
to_token_address = hex_or_bytes_to_address(tx_log.topics[2])
to_asset = ethaddress_to_asset(to_token_address)
if to_asset is None:
return None, None
to_raw = hex_or_bytes_to_int(tx_log.data[32:64])
fee_raw = hex_or_bytes_to_int(tx_log.data[96:128])
if fee_raw == 0:
return None, None # no need to do anything for zero fee taken
full_amount = asset_normalized_value(to_raw + fee_raw, to_asset)
sender_address = None
for event in decoded_events:
# Edit the full amount in the swap's receive event
if event.event_type == HistoryEventType.TRADE and event.event_subtype == HistoryEventSubType.RECEIVE and event.counterparty == CPT_ONEINCH_V1: # noqa: E501
event.balance.amount = full_amount
event.notes = f'Receive {full_amount} {event.asset.symbol} from {CPT_ONEINCH_V1} swap in {event.location_label}' # noqa: E501
sender_address = event.location_label
break
if sender_address is None:
return None, None
# And now create a new event for the fee
fee_amount = asset_normalized_value(fee_raw, to_asset)
fee_event = HistoryBaseEntry(
event_identifier=transaction.tx_hash.hex(),
sequence_index=self.base.get_sequence_index(tx_log),
timestamp=ts_sec_to_ms(transaction.timestamp),
location=Location.BLOCKCHAIN,
location_label=sender_address,
asset=to_asset,
balance=Balance(amount=fee_amount),
notes=
f'Deduct {fee_amount} {to_asset.symbol} from {sender_address} as {CPT_ONEINCH_V1} fees', # noqa: E501
event_type=HistoryEventType.SPEND,
event_subtype=HistoryEventSubType.FEE,
counterparty=CPT_ONEINCH_V1,
)
return fee_event, None
def _decode_claim( # pylint: disable=no-self-use
self,
tx_log: EthereumTxReceiptLog,
transaction: EthereumTransaction, # pylint: disable=unused-argument
decoded_events: List[HistoryBaseEntry],
all_logs: List[EthereumTxReceiptLog], # pylint: disable=unused-argument
action_items: Optional[List[ActionItem]], # pylint: disable=unused-argument
) -> Tuple[Optional[HistoryBaseEntry], Optional[ActionItem]]:
if tx_log.topics[0] != VOTIUM_CLAIM:
return None, None
claimed_token_address = hex_or_bytes_to_address(tx_log.topics[1])
claimed_token = ethaddress_to_asset(claimed_token_address)
if claimed_token is None:
return None, None
receiver = hex_or_bytes_to_address(tx_log.topics[2])
claimed_amount_raw = hex_or_bytes_to_int(tx_log.data[32:64])
amount = asset_normalized_value(amount=claimed_amount_raw,
asset=claimed_token)
for event in decoded_events:
if event.event_type == HistoryEventType.RECEIVE and event.location_label == receiver and event.balance.amount == amount and claimed_token == event.asset: # noqa: E501
event.event_subtype = HistoryEventSubType.REWARD
event.counterparty = CPT_VOTIUM
event.notes = f'Receive {event.balance.amount} {event.asset.symbol} from votium bribe' # noqa: E501
return None, None
def decode_comp_claim(
self,
tx_log: EthereumTxReceiptLog,
transaction: EthereumTransaction, # pylint: disable=unused-argument
decoded_events: List[HistoryBaseEntry], # pylint: disable=unused-argument
all_logs: List[EthereumTxReceiptLog], # pylint: disable=unused-argument
action_items: Optional[List[ActionItem]], # pylint: disable=unused-argument
) -> Tuple[Optional[HistoryBaseEntry], Optional[ActionItem]]:
"""Example tx:
https://etherscan.io/tx/0x024bd402420c3ba2f95b875f55ce2a762338d2a14dac4887b78174254c9ab807
"""
if tx_log.topics[0] != DISTRIBUTED_SUPPLIER_COMP:
return None, None
supplier_address = hex_or_bytes_to_address(tx_log.topics[2])
if not self.base.is_tracked(supplier_address):
return None, None
comp_raw_amount = hex_or_bytes_to_int(tx_log.data[0:32])
if comp_raw_amount == 0:
return None, None # do not count zero comp collection
# A DistributedSupplierComp event can happen without a transfer. Just accrues
# comp in the Comptroller until enough for a transfer is there. We should only
# count a payout if the transfer occurs
for event in decoded_events:
if event.event_type == HistoryEventType.RECEIVE and event.location_label == supplier_address and event.asset == A_COMP and event.counterparty == COMPTROLLER_PROXY.address: # noqa: E501
event.event_subtype = HistoryEventSubType.REWARD
event.counterparty = CPT_COMPOUND
event.notes = f'Collect {event.balance.amount} COMP from compound'
break
return None, None
def _maybe_decode_erc20_approve(
self,
token: Optional[EthereumToken],
tx_log: EthereumTxReceiptLog,
transaction: EthereumTransaction,
decoded_events: List[HistoryBaseEntry], # pylint: disable=unused-argument
action_items: List[ActionItem], # pylint: disable=unused-argument
) -> Optional[HistoryBaseEntry]:
if tx_log.topics[0] != ERC20_APPROVE or token is None:
return None
owner_address = hex_or_bytes_to_address(tx_log.topics[1])
spender_address = hex_or_bytes_to_address(tx_log.topics[2])
if not any(
self.base.is_tracked(x)
for x in (owner_address, spender_address)):
return None
amount_raw = hex_or_bytes_to_int(tx_log.data)
amount = token_normalized_value(token_amount=amount_raw, token=token)
notes = f'Approve {amount} {token.symbol} of {owner_address} for spending by {spender_address}' # noqa: E501
return HistoryBaseEntry(
event_identifier=transaction.tx_hash.hex(),
sequence_index=self.base.get_sequence_index(tx_log),
timestamp=ts_sec_to_ms(transaction.timestamp),
location=Location.BLOCKCHAIN,
location_label=owner_address,
asset=token,
balance=Balance(amount=amount),
notes=notes,
event_type=HistoryEventType.INFORMATIONAL,
event_subtype=HistoryEventSubType.APPROVE,
counterparty=spender_address,
)
def _decode_deposit( # pylint: disable=no-self-use
self,
tx_log: EthereumTxReceiptLog,
transaction: EthereumTransaction, # pylint: disable=unused-argument
decoded_events: List[HistoryBaseEntry], # pylint: disable=unused-argument
all_logs: List[EthereumTxReceiptLog], # pylint: disable=unused-argument
action_items: List[ActionItem], # pylint: disable=unused-argument
) -> Tuple[Optional[HistoryBaseEntry], Optional[ActionItem]]:
"""Match a zksync deposit with the transfer to decode it
TODO: This is now quite bad. We don't use the token id of zksync as we should.
Example: https://etherscan.io/tx/0xdd6d1f92980faf622c09acd84dbff4fe0bd7ae466a23c2479df709f8996d250e#eventlog
We should include the zksync api querying module which is in this PR:
https://github.com/rotki/rotki/pull/3985/files
to get the ids of tokens and then match them to what is deposited.
""" # noqa: E501
user_address = hex_or_bytes_to_address(tx_log.topics[1])
amount_raw = hex_or_bytes_to_int(tx_log.data)
for event in decoded_events:
if event.event_type == HistoryEventType.SPEND and event.location_label == user_address:
event_raw_amount = asset_raw_value(amount=event.balance.amount, asset=event.asset)
if event_raw_amount != amount_raw:
continue
# found the deposit transfer
event.event_type = HistoryEventType.DEPOSIT
event.event_subtype = HistoryEventSubType.BRIDGE
event.counterparty = CPT_ZKSYNC
event.notes = f'Deposit {event.balance.amount} {event.asset.symbol} to zksync' # noqa: E501
break
return None, None
def _decode_vault_creation(
self,
tx_log: EthereumTxReceiptLog,
transaction: EthereumTransaction,
decoded_events: List[HistoryBaseEntry], # pylint: disable=unused-argument
all_logs: List[EthereumTxReceiptLog], # pylint: disable=unused-argument
) -> Tuple[Optional[HistoryBaseEntry], Optional[ActionItem]]:
owner_address = self._get_address_or_proxy(
hex_or_bytes_to_address(tx_log.topics[2]))
if owner_address is None:
return None, None
if not self.base.is_tracked(owner_address):
return None, None
cdp_id = hex_or_bytes_to_int(tx_log.topics[3])
notes = f'Create MakerDAO vault with id {cdp_id} and owner {owner_address}'
event = HistoryBaseEntry(
event_identifier=transaction.tx_hash.hex(),
sequence_index=self.base.get_sequence_index(tx_log),
timestamp=ts_sec_to_ms(transaction.timestamp),
location=Location.BLOCKCHAIN,
location_label=owner_address,
# TODO: This should be null for proposals and other informational events
asset=A_ETH,
balance=Balance(),
notes=notes,
event_type=HistoryEventType.INFORMATIONAL,
event_subtype=HistoryEventSubType.DEPLOY,
counterparty='makerdao vault',
)
return event, None
def decode_makerdao_debt_payback( # pylint: disable=no-self-use
self,
tx_log: EthereumTxReceiptLog,
transaction: EthereumTransaction, # pylint: disable=unused-argument
decoded_events: List[HistoryBaseEntry], # pylint: disable=unused-argument
all_logs: List[EthereumTxReceiptLog], # pylint: disable=unused-argument
action_items: List[ActionItem], # pylint: disable=unused-argument
) -> Tuple[Optional[HistoryBaseEntry], Optional[ActionItem]]:
if tx_log.topics[0] == GENERIC_JOIN:
join_user_address = hex_or_bytes_to_address(tx_log.topics[2])
raw_amount = hex_or_bytes_to_int(tx_log.topics[3])
amount = token_normalized_value(
token_amount=raw_amount,
token=A_DAI,
)
# The transfer comes right before, but we don't have enough information
# yet to make sure that this transfer is indeed a vault payback debt. We
# need to get a cdp frob event and compare vault id to address matches
action_item = ActionItem(
action='transform',
sequence_index=tx_log.log_index,
from_event_type=HistoryEventType.SPEND,
from_event_subtype=HistoryEventSubType.NONE,
asset=A_DAI,
amount=amount,
to_event_subtype=HistoryEventSubType.PAYBACK_DEBT,
to_counterparty=CPT_VAULT,
extra_data={'vault_address': join_user_address},
)
return None, action_item
return None, None
def _decode_fpis_claim( # pylint: disable=no-self-use
self,
tx_log: EthereumTxReceiptLog,
transaction: EthereumTransaction, # pylint: disable=unused-argument
decoded_events: List[HistoryBaseEntry], # pylint: disable=unused-argument
all_logs: List[EthereumTxReceiptLog], # pylint: disable=unused-argument
action_items: List[ActionItem], # pylint: disable=unused-argument
airdrop: Literal['convex', 'fpis'],
) -> Tuple[Optional[HistoryBaseEntry], Optional[ActionItem]]:
if tx_log.topics[0] != FPIS_CONVEX_CLAIM:
return None, None
user_address = hex_or_bytes_to_address(tx_log.data[0:32])
raw_amount = hex_or_bytes_to_int(tx_log.data[32:64])
if airdrop == CPT_CONVEX:
amount = asset_normalized_value(amount=raw_amount, asset=A_CVX)
note_location = 'from convex airdrop'
counterparty = CPT_CONVEX
else:
amount = asset_normalized_value(amount=raw_amount, asset=A_FPIS)
note_location = 'from FPIS airdrop'
counterparty = CPT_FRAX
for event in decoded_events:
if event.event_type == HistoryEventType.RECEIVE and event.location_label == user_address and amount == event.balance.amount and A_FPIS == event.asset: # noqa: E501
event.event_type = HistoryEventType.RECEIVE
event.event_subtype = HistoryEventSubType.AIRDROP
event.counterparty = counterparty
event.notes = f'Claim {amount} {event.asset.symbol} {note_location}' # noqa: E501
break
return None, None
def _decode_history(
self,
tx_log: EthereumTxReceiptLog,
transaction: EthereumTransaction, # pylint: disable=unused-argument
decoded_events: List[HistoryBaseEntry], # pylint: disable=unused-argument
all_logs: List[EthereumTxReceiptLog], # pylint: disable=unused-argument
) -> Tuple[Optional[HistoryBaseEntry], Optional[ActionItem]]:
sender = hex_or_bytes_to_address(tx_log.topics[1])
if not self.base.is_tracked(sender):
return None, None
from_token_address = hex_or_bytes_to_address(tx_log.data[0:32])
to_token_address = hex_or_bytes_to_address(tx_log.data[32:64])
from_asset = ethaddress_to_asset(from_token_address)
to_asset = ethaddress_to_asset(to_token_address)
if None in (from_asset, to_asset):
return None, None
from_raw = hex_or_bytes_to_int(tx_log.data[64:96])
from_amount = asset_normalized_value(from_raw,
from_asset) # type: ignore
to_raw = hex_or_bytes_to_int(tx_log.data[96:128])
to_amount = asset_normalized_value(to_raw, to_asset) # type: ignore
out_event = in_event = None
for event in decoded_events:
if event.event_type == HistoryEventType.SPEND and event.location_label == sender and from_amount == event.balance.amount and from_asset == event.asset: # noqa: E501
# find the send event
event.event_type = HistoryEventType.TRADE
event.event_subtype = HistoryEventSubType.SPEND
event.counterparty = CPT_ONEINCH_V1
event.notes = f'Swap {from_amount} {from_asset.symbol} in {CPT_ONEINCH_V1} from {event.location_label}' # noqa: E501
out_event = event
elif event.event_type == HistoryEventType.RECEIVE and event.location_label == sender and to_amount == event.balance.amount and to_asset == event.asset: # noqa: E501
# find the receive event
event.event_type = HistoryEventType.TRADE
event.event_subtype = HistoryEventSubType.RECEIVE
event.counterparty = CPT_ONEINCH_V1
event.notes = f'Receive {to_amount} {to_asset.symbol} from {CPT_ONEINCH_V1} swap in {event.location_label}' # noqa: E501
# use this index as the event may be an ETH transfer and appear at the start
event.sequence_index = tx_log.log_index
in_event = event
maybe_reshuffle_events(out_event=out_event,
in_event=in_event,
events_list=decoded_events)
return None, None
def get_block_by_number(self, block_number: int) -> Dict[str, Any]:
"""
Gets a block object by block number
May raise:
- RemoteError due to self._query().
"""
options = {'tag': hex(block_number), 'boolean': 'true'}
block_data = self._query(module='proxy',
action='eth_getBlockByNumber',
options=options)
# We need to convert some data from hex here
# https://github.com/PyCQA/pylint/issues/4739
block_data['timestamp'] = hex_or_bytes_to_int(block_data['timestamp']) # pylint: disable=unsubscriptable-object # noqa: E501
block_data['number'] = hex_or_bytes_to_int(block_data['number']) # pylint: disable=unsubscriptable-object # noqa: E501
return block_data
def _decode_mint(
self,
transaction: EthereumTransaction,
tx_log: EthereumTxReceiptLog,
decoded_events: List[HistoryBaseEntry],
compound_token: EthereumToken,
) -> Tuple[Optional[HistoryBaseEntry], Optional[ActionItem]]:
minter = hex_or_bytes_to_address(tx_log.data[0:32])
if not self.base.is_tracked(minter):
return None, None
mint_amount_raw = hex_or_bytes_to_int(tx_log.data[32:64])
minted_amount_raw = hex_or_bytes_to_int(tx_log.data[64:96])
underlying_asset = symbol_to_asset_or_token(compound_token.symbol[1:])
mint_amount = asset_normalized_value(mint_amount_raw, underlying_asset)
minted_amount = token_normalized_value(minted_amount_raw, compound_token)
out_event = None
for event in decoded_events:
# Find the transfer event which should have come before the minting
if event.event_type == HistoryEventType.SPEND and event.asset == underlying_asset and event.balance.amount == mint_amount: # noqa: E501
event.event_type = HistoryEventType.DEPOSIT
event.event_subtype = HistoryEventSubType.DEPOSIT_ASSET
event.counterparty = CPT_COMPOUND
event.notes = f'Deposit {mint_amount} {underlying_asset.symbol} to compound'
out_event = event
break
if out_event is None:
log.debug(f'At compound mint decoding of tx {transaction.tx_hash.hex()} the out event was not found') # noqa: E501
return None, None
# also create an action item for the receive of the cTokens
action_item = ActionItem(
action='transform',
sequence_index=tx_log.log_index,
from_event_type=HistoryEventType.RECEIVE,
from_event_subtype=HistoryEventSubType.NONE,
asset=compound_token,
amount=minted_amount,
to_event_subtype=HistoryEventSubType.RECEIVE_WRAPPED,
to_notes=f'Receive {minted_amount} {compound_token.symbol} from compound',
to_counterparty=CPT_COMPOUND,
paired_event_data=(out_event, True),
)
return None, action_item
def decode_makerdao_vault_action( # pylint: disable=no-self-use
self,
tx_log: EthereumTxReceiptLog,
transaction: EthereumTransaction, # pylint: disable=unused-argument
decoded_events: List[HistoryBaseEntry],
all_logs: List[EthereumTxReceiptLog], # pylint: disable=unused-argument
action_items: List[ActionItem], # pylint: disable=unused-argument
vault_asset: Asset,
vault_type: str,
) -> Tuple[Optional[HistoryBaseEntry], Optional[ActionItem]]:
if tx_log.topics[0] == GENERIC_JOIN:
raw_amount = hex_or_bytes_to_int(tx_log.topics[3])
amount = asset_normalized_value(
amount=raw_amount,
asset=vault_asset,
)
# Go through decoded events to find and edit the transfer event
for event in decoded_events:
if event.event_type == HistoryEventType.SPEND and event.asset == vault_asset and event.balance.amount == amount: # noqa: E501
event.sequence_index = tx_log.log_index # to better position it in the list
event.event_type = HistoryEventType.DEPOSIT
event.event_subtype = HistoryEventSubType.DEPOSIT_ASSET
event.counterparty = CPT_VAULT
event.notes = f'Deposit {amount} {vault_asset.symbol} to {vault_type} MakerDAO vault' # noqa: E501
event.extra_data = {'vault_type': vault_type}
return None, None
elif tx_log.topics[0] == GENERIC_EXIT:
raw_amount = hex_or_bytes_to_int(tx_log.topics[3])
amount = asset_normalized_value(
amount=raw_amount,
asset=vault_asset,
)
# Go through decoded events to find and edit the transfer event
for event in decoded_events:
if event.event_type == HistoryEventType.RECEIVE and event.asset == vault_asset and event.balance.amount == amount: # noqa: E501
event.event_type = HistoryEventType.WITHDRAWAL
event.event_subtype = HistoryEventSubType.REMOVE_ASSET
event.counterparty = CPT_VAULT
event.notes = f'Withdraw {amount} {vault_asset.symbol} from {vault_type} MakerDAO vault' # noqa: E501
event.extra_data = {'vault_type': vault_type}
return None, None
return None, None
def _get_comp_events(
self,
address: ChecksumEthAddress,
from_ts: Timestamp,
to_ts: Timestamp,
) -> List[CompoundEvent]:
self.ethereum.etherscan.get_blocknumber_by_time(from_ts)
from_block = max(
COMP_DEPLOYED_BLOCK,
self.ethereum.etherscan.get_blocknumber_by_time(from_ts),
)
argument_filters = {
'from': COMPTROLLER_PROXY.address,
'to': address,
}
comp_events = self.ethereum.get_logs(
contract_address=A_COMP.ethereum_address,
abi=ERC20TOKEN_ABI,
event_name='Transfer',
argument_filters=argument_filters,
from_block=from_block,
to_block=self.ethereum.etherscan.get_blocknumber_by_time(to_ts),
)
events = []
for event in comp_events:
timestamp = self.ethereum.get_event_timestamp(event)
amount = token_normalized_value(hex_or_bytes_to_int(event['data']),
A_COMP)
usd_price = query_usd_price_zero_if_error(
asset=A_COMP,
time=timestamp,
location='comp_claim',
msg_aggregator=self.msg_aggregator,
)
value = Balance(amount, amount * usd_price)
events.append(
CompoundEvent(
event_type='comp',
address=address,
block_number=deserialize_blocknumber(event['blockNumber']),
timestamp=timestamp,
asset=A_COMP,
value=value,
to_asset=None,
to_value=None,
realized_pnl=value,
tx_hash=event['transactionHash'],
log_index=deserialize_int_from_hex_or_int(
event['logIndex'], 'comp log index'),
))
return events
def _decode_vault_debt_generation(
self,
tx_log: EthereumTxReceiptLog,
transaction: EthereumTransaction, # pylint: disable=unused-argument
decoded_events: List[HistoryBaseEntry], # pylint: disable=unused-argument
all_logs: List[EthereumTxReceiptLog], # pylint: disable=unused-argument
) -> Tuple[Optional[HistoryBaseEntry], Optional[ActionItem]]:
"""Decode vault debt generation by parsing a lognote for cdpmanager move"""
cdp_id = hex_or_bytes_to_int(tx_log.topics[2])
destination = hex_or_bytes_to_address(tx_log.topics[3])
owner = self._get_address_or_proxy(destination)
if owner is None:
return None, None
# now we need to get the rad and since it's the 3rd argument its not in the indexed topics
# but it's part of the data location after the first 132 bytes.
# also need to shift by ray since it's in rad
raw_amount = shift_num_right_by(
hex_or_bytes_to_int(tx_log.data[132:164]), RAY_DIGITS)
amount = token_normalized_value(
token_amount=raw_amount,
token=A_DAI,
)
# The transfer event appears after the debt generation event, so we need to transform it
action_item = ActionItem(
action='transform',
sequence_index=tx_log.log_index,
from_event_type=HistoryEventType.RECEIVE,
from_event_subtype=HistoryEventSubType.NONE,
asset=A_DAI,
amount=amount,
to_event_type=HistoryEventType.WITHDRAWAL,
to_event_subtype=HistoryEventSubType.GENERATE_DEBT,
to_counterparty=CPT_VAULT,
to_notes=f'Generate {amount} DAI from MakerDAO vault {cdp_id}',
extra_data={'cdp_id': cdp_id},
)
return None, action_item
def _get_vat_join_exit_at_transaction(
self,
movement_type: Literal['join', 'exit'],
proxy_address: ChecksumEthAddress,
block_number: int,
transaction_index: int,
) -> Optional[int]:
"""Returns values in DSR DAI that were deposited/withdrawn at a block number and tx index
DSR DAI means they need they have a lot more digits than normal DAI and they
need to be divided by RAD (10**45) in order to get real DAI value. Keeping
it like that since most calculations deal with RAD precision in DSR.
Returns None if no value was found of if there was an error with conversion.
May raise:
- RemoteError if etherscan is used and there is a problem with
reaching it or with the returned result.
- BlockchainQueryError if an ethereum node is used and the contract call
queries fail for some reason
"""
argument_filters = {
'sig': '0x3b4da69f' if movement_type == 'join' else '0xef693bed',
'usr': proxy_address,
}
events = self.ethereum.get_logs(
contract_address=MAKERDAO_DAI_JOIN.address,
abi=MAKERDAO_DAI_JOIN.abi,
event_name='LogNote',
argument_filters=argument_filters,
from_block=block_number,
to_block=block_number,
)
value = None
for event in events:
if event['transactionIndex'] == transaction_index:
if value is not None:
log.error( # type: ignore
'Mistaken assumption: There is multiple vat.move events for '
'the same transaction',
)
try:
value = hex_or_bytes_to_int(event['topics'][3])
break
except ConversionError:
value = None
return value * RAY # turn it from DAI to RAD
def _decode_redeem_underlying_event( # pylint: disable=no-self-use
self,
tx_log: EthereumTxReceiptLog,
transaction: EthereumTransaction, # pylint: disable=unused-argument
decoded_events: List[HistoryBaseEntry], # pylint: disable=unused-argument
all_logs: List[EthereumTxReceiptLog], # pylint: disable=unused-argument
action_items: List[ActionItem], # pylint: disable=unused-argument
) -> Tuple[Optional[HistoryBaseEntry], Optional[ActionItem]]:
reserve_address = hex_or_bytes_to_address(tx_log.topics[1])
reserve_asset = ethaddress_to_asset(reserve_address)
if reserve_asset is None:
return None, None
user_address = hex_or_bytes_to_address(tx_log.topics[2])
raw_amount = hex_or_bytes_to_int(tx_log.data[0:32])
amount = asset_normalized_value(raw_amount, reserve_asset)
atoken = asset_to_atoken(asset=reserve_asset, version=1)
if atoken is None:
return None, None
receive_event = return_event = None
for event in decoded_events:
if event.event_type == HistoryEventType.RECEIVE and event.location_label == user_address and amount == event.balance.amount and reserve_asset == event.asset: # noqa: E501
event.event_type = HistoryEventType.WITHDRAWAL
event.event_subtype = HistoryEventSubType.REMOVE_ASSET
event.counterparty = CPT_AAVE_V1
event.notes = f'Withdraw {amount} {reserve_asset.symbol} from aave-v1'
receive_event = event
elif event.event_type == HistoryEventType.SPEND and event.location_label == user_address and amount == event.balance.amount and atoken == event.asset: # noqa: E501
# find the redeem aToken transfer
event.event_type = HistoryEventType.SPEND
event.event_subtype = HistoryEventSubType.RETURN_WRAPPED
event.counterparty = CPT_AAVE_V1
event.notes = f'Return {amount} {atoken.symbol} to aave-v1'
return_event = event
elif event.event_type == HistoryEventType.RECEIVE and event.location_label == user_address and event.counterparty == ZERO_ADDRESS and event.asset == atoken: # noqa: E501
event.event_subtype = HistoryEventSubType.REWARD
event.counterparty = CPT_AAVE_V1
event.notes = f'Gain {event.balance.amount} {atoken.symbol} from aave-v1 as interest' # noqa: E501
maybe_reshuffle_events(out_event=return_event,
in_event=receive_event,
events_list=decoded_events) # noqa: E501
return None, None
def _get_vat_move_event_value(
self,
from_address: ChecksumEthAddress,
to_address: ChecksumEthAddress,
block_number: int,
transaction_index: int,
) -> Optional[int]:
"""Returns values in DAI that were moved from to address at a block number and tx index
Returns None if no value was found of if there was an error with conversion.
May raise:
- RemoteError if etherscan is used and there is a problem with
reaching it or with the returned result.
"""
arg1 = address_to_bytes32(from_address)
arg2 = address_to_bytes32(to_address)
argument_filters = {
'sig': '0xbb35783b', # move
'arg1': arg1, # src
'arg2': arg2, # dst
}
events = self.ethereum.get_logs(
contract_address=MAKERDAO_VAT_ADDRESS,
abi=MAKERDAO_VAT_ABI,
event_name='LogNote',
argument_filters=argument_filters,
from_block=block_number,
to_block=block_number,
)
value = None
for event in events:
if event['transactionIndex'] == transaction_index:
if value is not None:
log.error( # type: ignore
'Mistaken assumption: There is multiple vat.move events for '
'the same transaction', )
try:
value = hex_or_bytes_to_int(event['topics'][3])
break
except ConversionError:
value = None
return value
def _decode_fox_claim( # pylint: disable=no-self-use
self,
tx_log: EthereumTxReceiptLog,
transaction: EthereumTransaction, # pylint: disable=unused-argument
decoded_events: List[HistoryBaseEntry], # pylint: disable=unused-argument
all_logs: List[EthereumTxReceiptLog], # pylint: disable=unused-argument
action_items: List[ActionItem], # pylint: disable=unused-argument
) -> Tuple[Optional[HistoryBaseEntry], Optional[ActionItem]]:
if tx_log.topics[0] != FOX_CLAIMED:
return None, None
user_address = hex_or_bytes_to_address(tx_log.topics[1])
raw_amount = hex_or_bytes_to_int(tx_log.data[64:96])
amount = asset_normalized_value(amount=raw_amount, asset=A_FOX)
for event in decoded_events:
if event.event_type == HistoryEventType.RECEIVE and event.location_label == user_address and amount == event.balance.amount and A_FOX == event.asset: # noqa: E501
event.event_type = HistoryEventType.RECEIVE
event.event_subtype = HistoryEventSubType.AIRDROP
event.counterparty = CPT_SHAPESHIFT
event.notes = f'Claim {amount} FOX from shapeshift airdrop' # noqa: E501
break
return None, None
def _query_vault_details(
self,
vault: MakerDAOVault,
proxy: ChecksumEthAddress,
urn: ChecksumEthAddress,
) -> Optional[MakerDAOVaultDetails]:
asset_symbol = vault.collateral_asset.identifier
# They can raise:
# ConversionError due to hex_or_bytes_to_address, hex_or_bytes_to_int
# RemoteError due to external query errors
events = self.ethereum.get_logs(
contract_address=MAKERDAO_CDP_MANAGER.address,
abi=MAKERDAO_CDP_MANAGER.abi,
event_name='NewCdp',
argument_filters={'cdp': vault.identifier},
from_block=MAKERDAO_CDP_MANAGER.deployed_block,
)
if len(events) == 0:
self.msg_aggregator.add_error(
'No events found for a Vault creation. This should never '
'happen. Please open a bug report: https://github.com/rotki/rotki/issues',
)
return None
elif len(events) != 1:
log.error(
f'Multiple events found for a Vault creation: {events}. Taking '
f'only the first. This should not happen. Something is wrong',
)
self.msg_aggregator.add_error(
'Multiple events found for a Vault creation. This should never '
'happen. Please open a bug report: https://github.com/rotki/rotki/issues',
)
creation_ts = self.ethereum.get_event_timestamp(events[0])
# get vat frob events for cross-checking
argument_filters = {
'sig': '0x76088703', # frob
'arg1': '0x' + vault.ilk.hex(), # ilk
'arg2': address_to_bytes32(urn), # urn
# arg3 can be urn for the 1st deposit, and proxy/owner for the next ones
# so don't filter for it
# 'arg3': address_to_bytes32(proxy), # proxy - owner
}
frob_events = self.ethereum.get_logs(
contract_address=MAKERDAO_VAT.address,
abi=MAKERDAO_VAT.abi,
event_name='LogNote',
argument_filters=argument_filters,
from_block=MAKERDAO_VAT.deployed_block,
)
frob_event_tx_hashes = [x['transactionHash'] for x in frob_events]
gemjoin = GEMJOIN_MAPPING[vault.collateral_type]
vault_events = []
# Get the collateral deposit events
argument_filters = {
'sig': '0x3b4da69f', # join
# In cases where a CDP has been migrated from a SAI CDP to a DAI
# Vault the usr in the first deposit will be the old address. To
# detect the first deposit in these cases we need to check for
# arg1 being the urn
# 'usr': proxy,
'arg1': address_to_bytes32(urn),
}
events = self.ethereum.get_logs(
contract_address=gemjoin.address,
abi=gemjoin.abi,
event_name='LogNote',
argument_filters=argument_filters,
from_block=gemjoin.deployed_block,
)
# all subsequent deposits should have the proxy as a usr
# but for non-migrated CDPS the previous query would also work
# so in those cases we will have the first deposit 2 times
argument_filters = {
'sig': '0x3b4da69f', # join
'usr': proxy,
}
events.extend(self.ethereum.get_logs(
contract_address=gemjoin.address,
abi=gemjoin.abi,
event_name='LogNote',
argument_filters=argument_filters,
from_block=gemjoin.deployed_block,
))
deposit_tx_hashes = set()
for event in events:
tx_hash = event['transactionHash']
if tx_hash in deposit_tx_hashes:
# Skip duplicate deposit that would be detected in non migrated CDP case
continue
if tx_hash not in frob_event_tx_hashes:
# If there is no corresponding frob event then skip
continue
deposit_tx_hashes.add(tx_hash)
amount = _normalize_amount(
asset_symbol=asset_symbol,
amount=hex_or_bytes_to_int(event['topics'][3]),
)
timestamp = self.ethereum.get_event_timestamp(event)
usd_price = query_usd_price_or_use_default(
asset=vault.collateral_asset,
time=timestamp,
default_value=ZERO,
location='vault collateral deposit',
)
vault_events.append(VaultEvent(
event_type=VaultEventType.DEPOSIT_COLLATERAL,
amount=amount,
amount_usd_value=amount * usd_price,
timestamp=timestamp,
tx_hash=tx_hash,
))
# Get the collateral withdrawal events
argument_filters = {
'sig': '0xef693bed', # exit
'usr': proxy,
}
events = self.ethereum.get_logs(
contract_address=gemjoin.address,
abi=gemjoin.abi,
event_name='LogNote',
argument_filters=argument_filters,
from_block=gemjoin.deployed_block,
)
for event in events:
tx_hash = event['transactionHash']
if tx_hash not in frob_event_tx_hashes:
# If there is no corresponding frob event then skip
continue
amount = _normalize_amount(
asset_symbol=asset_symbol,
amount=hex_or_bytes_to_int(event['topics'][3]),
)
timestamp = self.ethereum.get_event_timestamp(event)
usd_price = query_usd_price_or_use_default(
asset=vault.collateral_asset,
time=timestamp,
default_value=ZERO,
location='vault collateral withdrawal',
)
vault_events.append(VaultEvent(
event_type=VaultEventType.WITHDRAW_COLLATERAL,
amount=amount,
amount_usd_value=amount * usd_price,
timestamp=timestamp,
tx_hash=event['transactionHash'],
))
total_dai_wei = 0
# Get the dai generation events
argument_filters = {
'sig': '0xbb35783b', # move
'arg1': address_to_bytes32(urn),
# For CDPs that were created by migrating from SAI the first DAI generation
# during vault creation will have the old owner as arg2. So we can't
# filter for it here. Still seems like the urn as arg1 is sufficient
# 'arg2': address_to_bytes32(proxy),
}
events = self.ethereum.get_logs(
contract_address=MAKERDAO_VAT.address,
abi=MAKERDAO_VAT.abi,
event_name='LogNote',
argument_filters=argument_filters,
from_block=MAKERDAO_VAT.deployed_block,
)
for event in events:
given_amount = _shift_num_right_by(hex_or_bytes_to_int(event['topics'][3]), RAY_DIGITS)
total_dai_wei += given_amount
amount = _normalize_amount(
asset_symbol='DAI',
amount=given_amount,
)
timestamp = self.ethereum.get_event_timestamp(event)
usd_price = query_usd_price_or_use_default(
asset=A_DAI,
time=timestamp,
default_value=FVal(1),
location='vault debt generation',
)
vault_events.append(VaultEvent(
event_type=VaultEventType.GENERATE_DEBT,
amount=amount,
amount_usd_value=amount * usd_price,
timestamp=timestamp,
tx_hash=event['transactionHash'],
))
# Get the dai payback events
argument_filters = {
'sig': '0x3b4da69f', # join
'usr': proxy,
'arg1': address_to_bytes32(urn),
}
events = self.ethereum.get_logs(
contract_address=MAKERDAO_DAI_JOIN.address,
abi=MAKERDAO_DAI_JOIN.abi,
event_name='LogNote',
argument_filters=argument_filters,
from_block=MAKERDAO_DAI_JOIN.deployed_block,
)
for event in events:
given_amount = hex_or_bytes_to_int(event['topics'][3])
total_dai_wei -= given_amount
amount = _normalize_amount(
asset_symbol='DAI',
amount=given_amount,
)
if amount == ZERO:
# it seems there is a zero DAI value transfer from the urn when
# withdrawing ETH. So we should ignore these as events
continue
timestamp = self.ethereum.get_event_timestamp(event)
usd_price = query_usd_price_or_use_default(
asset=A_DAI,
time=timestamp,
default_value=FVal(1),
location='vault debt payback',
)
vault_events.append(VaultEvent(
event_type=VaultEventType.PAYBACK_DEBT,
amount=amount,
amount_usd_value=amount * usd_price,
timestamp=timestamp,
tx_hash=event['transactionHash'],
))
# Get the liquidation events
argument_filters = {'urn': urn}
events = self.ethereum.get_logs(
contract_address=MAKERDAO_CAT.address,
abi=MAKERDAO_CAT.abi,
event_name='Bite',
argument_filters=argument_filters,
from_block=MAKERDAO_CAT.deployed_block,
)
sum_liquidation_amount = ZERO
sum_liquidation_usd = ZERO
for event in events:
if isinstance(event['data'], str):
lot = event['data'][:66]
else: # bytes
lot = event['data'][:32]
amount = _normalize_amount(
asset_symbol=asset_symbol,
amount=hex_or_bytes_to_int(lot),
)
timestamp = self.ethereum.get_event_timestamp(event)
sum_liquidation_amount += amount
usd_price = query_usd_price_or_use_default(
asset=vault.collateral_asset,
time=timestamp,
default_value=ZERO,
location='vault collateral liquidation',
)
amount_usd_value = amount * usd_price
sum_liquidation_usd += amount_usd_value
vault_events.append(VaultEvent(
event_type=VaultEventType.LIQUIDATION,
amount=amount,
amount_usd_value=amount_usd_value,
timestamp=timestamp,
tx_hash=event['transactionHash'],
))
total_interest_owed = vault.debt_value - _normalize_amount(
asset_symbol='DAI',
amount=total_dai_wei,
)
# sort vault events by timestamp
vault_events.sort(key=lambda event: event.timestamp)
return MakerDAOVaultDetails(
identifier=vault.identifier,
total_interest_owed=total_interest_owed,
creation_ts=creation_ts,
total_liquidated_amount=sum_liquidation_amount,
total_liquidated_usd=sum_liquidation_usd,
events=vault_events,
)
def _get_vault_withdraw_events(
self,
vault: YearnVault,
address: ChecksumEthAddress,
from_block: int,
to_block: int,
) -> List[YearnVaultEvent]:
"""Get all withdraw events of the underlying token to the vault"""
events: List[YearnVaultEvent] = []
argument_filters = {'from': vault.contract.address, 'to': address}
withdraw_events = self.ethereum.get_logs(
contract_address=vault.underlying_token.ethereum_address,
abi=ERC20TOKEN_ABI,
event_name='Transfer',
argument_filters=argument_filters,
from_block=from_block,
to_block=to_block,
)
for withdraw_event in withdraw_events:
timestamp = self.ethereum.get_event_timestamp(withdraw_event)
withdraw_amount = token_normalized_value(
token_amount=hex_or_bytes_to_int(withdraw_event['data']),
token=vault.token,
)
tx_hash = withdraw_event['transactionHash']
tx_receipt = self.ethereum.get_transaction_receipt(tx_hash)
withdraw_index = deserialize_int_from_hex_or_int(
withdraw_event['logIndex'],
'yearn withdraw log index',
)
burn_amount = None
for log in tx_receipt['logs']:
found_event = (
log['topics'][0] ==
'0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef'
and # noqa: E501
log['topics'][1] == address_to_bytes32(address) and
log['topics'][2] == address_to_bytes32(ZERO_ADDRESS))
if found_event:
# found the burn log
burn_amount = token_normalized_value(
token_amount=hex_or_bytes_to_int(log['data']),
token=vault.token,
)
if burn_amount is None:
self.msg_aggregator.add_error(
f'Ignoring yearn withdraw event with tx_hash {tx_hash} and log index '
f'{withdraw_index} due to inability to find corresponding burn event',
)
continue
withdraw_usd_price = get_usd_price_zero_if_error(
asset=vault.underlying_token,
time=timestamp,
location='yearn vault withdraw',
msg_aggregator=self.msg_aggregator,
)
burn_usd_price = get_usd_price_zero_if_error(
asset=vault.token,
time=timestamp,
location='yearn vault withdraw',
msg_aggregator=self.msg_aggregator,
)
events.append(
YearnVaultEvent(
event_type='withdraw',
block_number=deserialize_blocknumber(
withdraw_event['blockNumber']),
timestamp=timestamp,
from_asset=vault.token,
from_value=Balance(
amount=burn_amount,
usd_value=burn_amount * burn_usd_price,
),
to_asset=vault.underlying_token,
to_value=Balance(
amount=withdraw_amount,
usd_value=withdraw_amount * withdraw_usd_price,
),
realized_pnl=None,
tx_hash=tx_hash,
log_index=withdraw_index,
))
return events
def _decode_vault_change(
self,
tx_log: EthereumTxReceiptLog,
transaction: EthereumTransaction, # pylint: disable=unused-argument
decoded_events: List[HistoryBaseEntry], # pylint: disable=unused-argument
all_logs: List[EthereumTxReceiptLog], # pylint: disable=unused-argument
action_items: List[ActionItem], # pylint: disable=unused-argument
) -> Tuple[Optional[HistoryBaseEntry], Optional[ActionItem]]:
"""Decode CDPManger Frob (vault change)
Used to find the vault id of a collateral deposit
"""
cdp_id = hex_or_bytes_to_int(tx_log.topics[2])
dink = hex_or_bytes_to_int(tx_log.topics[3])
action_item = None
for item in action_items:
if item.extra_data and 'vault_address' in item.extra_data:
action_item = item
break
if action_item is not None:
# this concerns a vault debt payback. Checking only if CDP matches since
# the owner response is at the time of the call and may have changed
cdp_address, _ = self._get_vault_details(cdp_id)
if cdp_address != action_item.extra_data[
'vault_address']: # type: ignore
return None, None # vault address does not match
# now find the payback transfer and transform it
for event in decoded_events:
if event.event_type == action_item.from_event_type and event.event_subtype == action_item.from_event_subtype and event.asset == action_item.asset and event.balance.amount == action_item.amount: # noqa: E501
if action_item.to_event_type:
event.event_type = action_item.to_event_type
if action_item.to_event_subtype:
event.event_subtype = action_item.to_event_subtype
if action_item.to_counterparty:
event.counterparty = action_item.to_counterparty
if action_item.extra_data:
event.extra_data = action_item.extra_data
event.extra_data['cdp_id'] = cdp_id
event.notes = f'Payback {event.balance.amount} DAI of debt to makerdao vault {cdp_id}' # noqa: E501
break
else: # collateral deposit
# dink is the raw collateral amount change. Let's use this event to see if
# there was a deposit event beforehand to append the cdp id
for event in decoded_events:
if event.event_type == HistoryEventType.DEPOSIT and event.event_subtype == HistoryEventSubType.DEPOSIT_ASSET and event.counterparty == CPT_VAULT: # noqa: E501
normalized_dink = asset_normalized_value(amount=dink,
asset=event.asset)
if normalized_dink != event.balance.amount:
continue
vault_type = event.extra_data.get(
'vault_type', 'unknown'
) if event.extra_data else 'unknown' # noqa: E501
event.notes = f'Deposit {event.balance.amount} {event.asset.symbol} to {vault_type} vault {cdp_id}' # noqa: E501
break
return None, None
def get_events_for_atoken_and_address(
self,
user_address: ChecksumEthAddress,
atoken: EthereumToken,
deposit_events: List[Dict[str, Any]],
withdraw_events: List[Dict[str, Any]],
from_block: int,
to_block: int,
) -> List[AaveEvent]:
"""This function should be entered while holding the history_lock
semaphore"""
argument_filters = {
'from': ZERO_ADDRESS,
'to': user_address,
}
mint_events = self.ethereum.get_logs(
contract_address=atoken.ethereum_address,
abi=ATOKEN_ABI,
event_name='Transfer',
argument_filters=argument_filters,
from_block=from_block,
to_block=to_block,
)
mint_data = set()
mint_data_to_log_index = {}
for event in mint_events:
amount = hex_or_bytes_to_int(event['data'])
if amount == 0:
continue # first mint can be for 0. Ignore
entry = (
deserialize_blocknumber(event['blockNumber']),
amount,
self.ethereum.get_event_timestamp(event),
event['transactionHash'],
)
mint_data.add(entry)
mint_data_to_log_index[entry] = deserialize_int_from_hex_or_int(
event['logIndex'],
'aave log index',
)
reserve_asset = _atoken_to_reserve_asset(atoken)
reserve_address, decimals = _get_reserve_address_decimals(
reserve_asset.identifier)
aave_events = []
for event in deposit_events:
if hex_or_bytes_to_address(event['topics'][1]) == reserve_address:
# first 32 bytes of the data are the amount
deposit = hex_or_bytes_to_int(event['data'][:66])
block_number = deserialize_blocknumber(event['blockNumber'])
timestamp = self.ethereum.get_event_timestamp(event)
tx_hash = event['transactionHash']
log_index = deserialize_int_from_hex_or_int(
event['logIndex'], 'aave log index')
# If there is a corresponding deposit event remove the minting event data
entry = (block_number, deposit, timestamp, tx_hash)
if entry in mint_data:
mint_data.remove(entry)
del mint_data_to_log_index[entry]
usd_price = query_usd_price_zero_if_error(
asset=reserve_asset,
time=timestamp,
location='aave deposit',
msg_aggregator=self.msg_aggregator,
)
deposit_amount = deposit / (FVal(10)**FVal(decimals))
aave_events.append(
AaveEvent(
event_type='deposit',
asset=reserve_asset,
value=Balance(
amount=deposit_amount,
usd_value=deposit_amount * usd_price,
),
block_number=block_number,
timestamp=timestamp,
tx_hash=tx_hash,
log_index=log_index,
))
for data in mint_data:
usd_price = query_usd_price_zero_if_error(
asset=atoken,
time=data[2],
location='aave interest profit',
msg_aggregator=self.msg_aggregator,
)
interest_amount = data[1] / (FVal(10)**FVal(decimals))
aave_events.append(
AaveEvent(
event_type='interest',
asset=atoken,
value=Balance(
amount=interest_amount,
usd_value=interest_amount * usd_price,
),
block_number=data[0],
timestamp=data[2],
tx_hash=data[3],
log_index=mint_data_to_log_index[data],
))
for event in withdraw_events:
if hex_or_bytes_to_address(event['topics'][1]) == reserve_address:
# first 32 bytes of the data are the amount
withdrawal = hex_or_bytes_to_int(event['data'][:66])
block_number = deserialize_blocknumber(event['blockNumber'])
timestamp = self.ethereum.get_event_timestamp(event)
tx_hash = event['transactionHash']
usd_price = query_usd_price_zero_if_error(
asset=reserve_asset,
time=timestamp,
location='aave withdrawal',
msg_aggregator=self.msg_aggregator,
)
withdrawal_amount = withdrawal / (FVal(10)**FVal(decimals))
aave_events.append(
AaveEvent(
event_type='withdrawal',
asset=reserve_asset,
value=Balance(
amount=withdrawal_amount,
usd_value=withdrawal_amount * usd_price,
),
block_number=block_number,
timestamp=timestamp,
tx_hash=tx_hash,
log_index=deserialize_int_from_hex_or_int(
event['logIndex'], 'aave log index'),
))
return aave_events
def _historical_dsr_for_account(
self,
account: ChecksumEthAddress,
proxy: ChecksumEthAddress,
) -> DSRAccountReport:
"""Creates a historical DSR report for a single account
May raise:
- RemoteError if etherscan is used and there is a problem with
reaching it or with the returned result.
"""
movements = []
join_normalized_balances = []
exit_normalized_balances = []
argument_filters = {
'sig': '0x049878f3', # join
'usr': proxy,
}
join_events = self.ethereum.get_logs(
contract_address=MAKERDAO_POT_ADDRESS,
abi=MAKERDAO_POT_ABI,
event_name='LogNote',
argument_filters=argument_filters,
from_block=POT_CREATION_BLOCK,
)
for join_event in join_events:
try:
wad_val = hex_or_bytes_to_int(join_event['topics'][2])
except ConversionError as e:
msg = f'Error at reading DSR join event topics. {str(e)}. Skipping event...'
self.msg_aggregator.add_error(msg)
continue
join_normalized_balances.append(wad_val)
# and now get the deposit amount
try:
block_number = deserialize_blocknumber(
join_event['blockNumber'])
except DeserializationError as e:
msg = f'Error at reading DSR join event block number. {str(e)}. Skipping event...'
self.msg_aggregator.add_error(msg)
continue
dai_value = self._get_vat_move_event_value(
from_address=proxy,
to_address=MAKERDAO_POT_ADDRESS,
block_number=block_number,
transaction_index=join_event['transactionIndex'],
)
if not dai_value:
self.msg_aggregator.add_error(
'Did not find corresponding vat.move event for pot join. Skipping ...',
)
continue
movements.append(
DSRMovement(
movement_type='deposit',
address=account,
normalized_balance=wad_val,
amount=dai_value,
block_number=deserialize_blocknumber(
join_event['blockNumber']),
timestamp=self.ethereum.get_event_timestamp(join_event),
), )
argument_filters = {
'sig': '0x7f8661a1', # exit
'usr': proxy,
}
exit_events = self.ethereum.get_logs(
contract_address=MAKERDAO_POT_ADDRESS,
abi=MAKERDAO_POT_ABI,
event_name='LogNote',
argument_filters=argument_filters,
from_block=POT_CREATION_BLOCK,
)
for exit_event in exit_events:
try:
wad_val = hex_or_bytes_to_int(exit_event['topics'][2])
except ConversionError as e:
msg = f'Error at reading DSR exit event topics. {str(e)}. Skipping event...'
self.msg_aggregator.add_error(msg)
continue
exit_normalized_balances.append(wad_val)
try:
block_number = deserialize_blocknumber(
exit_event['blockNumber'])
except DeserializationError as e:
msg = f'Error at reading DSR exit event block number. {str(e)}. Skipping event...'
self.msg_aggregator.add_error(msg)
continue
# and now get the withdrawal amount
dai_value = self._get_vat_move_event_value(
from_address=MAKERDAO_POT_ADDRESS,
to_address=proxy,
block_number=block_number,
transaction_index=exit_event['transactionIndex'],
)
if not dai_value:
self.msg_aggregator.add_error(
'Did not find corresponding vat.move event for pot exit. Skipping ...',
)
continue
movements.append(
DSRMovement(
movement_type='withdrawal',
address=account,
normalized_balance=wad_val,
amount=dai_value,
block_number=deserialize_blocknumber(
exit_event['blockNumber']),
timestamp=self.ethereum.get_event_timestamp(exit_event),
), )
normalized_balance = 0
amount_in_dsr = 0
movements.sort(key=lambda x: x.block_number)
for m in movements:
current_chi = FVal(m.amount) / FVal(m.normalized_balance)
gain_so_far = normalized_balance * current_chi - amount_in_dsr
m.gain_so_far = gain_so_far.to_int(exact=False)
if m.movement_type == 'deposit':
normalized_balance += m.normalized_balance
amount_in_dsr += m.amount
else: # withdrawal
amount_in_dsr -= m.amount
normalized_balance -= m.normalized_balance
chi = self.ethereum.call_contract(
contract_address=MAKERDAO_POT_ADDRESS,
abi=MAKERDAO_POT_ABI,
method_name='chi',
)
normalized_balance = normalized_balance * chi
amount_in_dsr = amount_in_dsr
gain = normalized_balance - amount_in_dsr
return DSRAccountReport(movements=movements, gain_so_far=gain)
def _try_get_chi_close_to(self, time: Timestamp) -> FVal:
"""Best effort attempt to get a chi value close to the given timestamp
It can't be 100% accurate since we use the logs of join() or exit()
in order to find the closest time chi was changed. It also may not work
if for some reason there is no logs in the block range we are looking for.
Better solution would have been an archive node's query.
May raise:
- RemoteError if there are problems with querying etherscan
- ChiRetrievalError if we are unable to query chi at the given timestamp
"""
block_number = self.ethereum.etherscan.get_blocknumber_by_time(time)
if self.ethereum.connected:
latest_block = self.ethereum.web3.eth.blockNumber
else:
latest_block = self.ethereum.query_eth_highest_block()
blocks_queried = 0
counter = 1
# Keep trying to find events that could reveal the chi to us. Go back
# as far as MAX_BLOCKS_TO_QUERY and only then give up
while blocks_queried < MAX_BLOCKS_TO_QUERY:
back_from_block = max(
POT_CREATION_BLOCK,
block_number - counter * CHI_BLOCKS_SEARCH_DISTANCE,
)
back_to_block = block_number - (counter -
1) * CHI_BLOCKS_SEARCH_DISTANCE
forward_from_block = min(
latest_block,
block_number + (counter - 1) * CHI_BLOCKS_SEARCH_DISTANCE,
)
forward_to_block = min(
latest_block,
block_number + CHI_BLOCKS_SEARCH_DISTANCE,
)
back_joins, back_exits = self._get_join_exit_events(
back_from_block, back_to_block)
forward_joins, forward_exits = self._get_join_exit_events(
from_block=forward_from_block,
to_block=forward_to_block,
)
no_results = all(
len(x) == 0 for x in (back_joins, back_exits, forward_joins,
forward_exits))
if latest_block == forward_to_block and no_results:
# if our forward querying got us to the latest block and there is
# still no other results, then take current chi
return self.ethereum.call_contract(
contract_address=MAKERDAO_POT_ADDRESS,
abi=MAKERDAO_POT_ABI,
method_name='chi',
)
if not no_results:
# got results!
break
blocks_queried += 2 * CHI_BLOCKS_SEARCH_DISTANCE
counter += 1
if no_results:
raise ChiRetrievalError(
f'Found no DSR events around timestamp {time}. Cant query chi.',
)
# Find the closest event to the to_block number, looking both at events
# in the blocks before and in the blocks after block_number
found_event = None
back_event = _find_closest_event(back_joins, back_exits, -1,
operator.gt)
forward_event = _find_closest_event(forward_joins, forward_exits, 0,
operator.lt)
if back_event and not forward_event:
found_event = back_event
elif forward_event and not back_event:
found_event = forward_event
else:
# We have both backward and forward events, get the one closer to block number
try:
back_block_number = deserialize_blocknumber(
back_event['blockNumber']) # type: ignore # noqa: E501
forward_block_number = deserialize_blocknumber(
forward_event['blockNumber']) # type: ignore # noqa: E501
except DeserializationError as e:
msg = f'Error at reading DSR drip event block number. {str(e)}'
raise ChiRetrievalError(msg)
if block_number - back_block_number <= forward_block_number - block_number:
found_event = back_event
else:
found_event = forward_event
assert found_event, 'at this point found_event should be populated' # helps mypy
event_block_number = deserialize_blocknumber(
found_event['blockNumber'])
first_topic = found_event['topics'][0]
if isinstance(first_topic, bytes):
first_topic = first_topic.hex()
if first_topic.startswith('0x049878f3'): # join
from_address = hex_or_bytes_to_address(found_event['topics'][1])
to_address = MAKERDAO_POT_ADDRESS
else:
from_address = MAKERDAO_POT_ADDRESS
to_address = hex_or_bytes_to_address(found_event['topics'][1])
amount = self._get_vat_move_event_value(
from_address=from_address,
to_address=to_address,
block_number=event_block_number,
transaction_index=found_event['transactionIndex'],
)
if not amount:
raise ChiRetrievalError(
f'Found no VAT.move events around timestamp {time}. Cant query chi.',
)
wad_val = hex_or_bytes_to_int(found_event['topics'][2])
chi = FVal(amount) / FVal(wad_val)
return chi
