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