def _query_vault_details(
self,
vault: MakerDAOVault,
proxy: ChecksumEthAddress,
urn: ChecksumEthAddress,
) -> Optional[MakerDAOVaultDetails]:
# They can raise:
# ConversionError due to hex_or_bytes_to_address, hexstr_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
if 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.get(vault.collateral_type, None)
if gemjoin is None:
self.msg_aggregator.add_warning(
f'Unknown makerdao vault collateral type detected {vault.collateral_type}.'
'Skipping ...', )
return None
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 = asset_normalized_value(
amount=hexstr_to_int(event['topics'][3]),
asset=vault.collateral_asset,
)
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,
value=Balance(amount, 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 = asset_normalized_value(
amount=hexstr_to_int(event['topics'][3]),
asset=vault.collateral_asset,
)
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,
value=Balance(amount, 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(
hexstr_to_int(event['topics'][3]), RAY_DIGITS)
total_dai_wei += given_amount
amount = token_normalized_value(
token_amount=given_amount,
token=A_DAI,
)
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,
value=Balance(amount, 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 = hexstr_to_int(event['topics'][3])
total_dai_wei -= given_amount
amount = token_normalized_value(
token_amount=given_amount,
token=A_DAI,
)
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,
value=Balance(amount, 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 = asset_normalized_value(
amount=hexstr_to_int(lot),
asset=vault.collateral_asset,
)
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,
value=Balance(amount, amount_usd_value),
timestamp=timestamp,
tx_hash=event['transactionHash'],
))
total_interest_owed = vault.debt.amount - token_normalized_value(
token_amount=total_dai_wei,
token=A_DAI,
)
# sort vault events by timestamp
vault_events.sort(key=lambda event: event.timestamp)
return MakerDAOVaultDetails(
identifier=vault.identifier,
collateral_asset=vault.collateral_asset,
total_interest_owed=total_interest_owed,
creation_ts=creation_ts,
total_liquidated=Balance(sum_liquidation_amount,
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
