def get_history(
self,
start_ts: Timestamp,
end_ts: Timestamp,
has_premium: bool,
) -> HistoryResult:
"""Creates trades and loans history from start_ts to end_ts"""
log.info(
'Get/create trade history',
start_ts=start_ts,
end_ts=end_ts,
)
now = ts_now()
# start creating the all trades history list
history: List[Union[Trade, MarginPosition]] = []
asset_movements = []
loans = []
empty_or_error = ''
def populate_history_cb(
trades_history: List[Trade],
margin_history: List[MarginPosition],
result_asset_movements: List[AssetMovement],
exchange_specific_data: Any,
) -> None:
"""This callback will run for succesfull exchange history query"""
history.extend(trades_history)
history.extend(margin_history)
asset_movements.extend(result_asset_movements)
if exchange_specific_data:
# This can only be poloniex at the moment
polo_loans_data = exchange_specific_data
loans.extend(
process_polo_loans(
msg_aggregator=self.msg_aggregator,
data=polo_loans_data,
# We need to have full history of loans available
start_ts=Timestamp(0),
end_ts=now,
))
def fail_history_cb(error_msg: str) -> None:
"""This callback will run for failure in exchange history query"""
nonlocal empty_or_error
empty_or_error += '\n' + error_msg
for _, exchange in self.exchange_manager.connected_exchanges.items():
exchange.query_history_with_callbacks(
# We need to have full history of exchanges available
start_ts=Timestamp(0),
end_ts=now,
success_callback=populate_history_cb,
fail_callback=fail_history_cb,
)
try:
eth_transactions = query_ethereum_transactions(
database=self.db,
etherscan=self.chain_manager.ethchain.etherscan,
# We need to have full history of transactions available
from_ts=Timestamp(0),
to_ts=now,
)
except RemoteError as e:
eth_transactions = []
msg = str(e)
self.msg_aggregator.add_error(
f'There was an error when querying etherscan for ethereum transactions: {msg}'
f'The final history result will not include ethereum transactions',
)
empty_or_error += '\n' + msg
# Include the external trades in the history
external_trades = self.db.get_trades(
# We need to have full history of trades available
from_ts=Timestamp(0),
to_ts=now,
location=Location.EXTERNAL,
)
history.extend(external_trades)
# Include makerdao DSR gains as a simple gains only blockchain loan entry for the given
# time period
makerdao = self.chain_manager.eth_modules.get('makerdao', None)
if makerdao and has_premium:
gain = makerdao.get_dsr_gains_in_period(from_ts=start_ts,
to_ts=end_ts)
if gain > ZERO:
loans.append(
Loan(
location=Location.BLOCKCHAIN,
open_time=start_ts,
close_time=end_ts,
currency=A_DAI,
fee=Fee(ZERO),
earned=gain,
amount_lent=AssetAmount(ZERO),
))
history.sort(key=lambda trade: action_get_timestamp(trade))
return (
empty_or_error,
history,
loans,
asset_movements,
eth_transactions,
)
def get_history(
self,
start_ts: Timestamp,
end_ts: Timestamp,
has_premium: bool,
) -> HistoryResult:
"""Creates trades and loans history from start_ts to end_ts"""
log.info(
'Get/create trade history',
start_ts=start_ts,
end_ts=end_ts,
)
now = ts_now()
# start creating the all trades history list
history: List[Union[Trade, MarginPosition]] = []
asset_movements = []
loans = []
empty_or_error = ''
def populate_history_cb(
trades_history: List[Trade],
margin_history: List[MarginPosition],
result_asset_movements: List[AssetMovement],
exchange_specific_data: Any,
) -> None:
"""This callback will run for succesfull exchange history query"""
history.extend(trades_history)
history.extend(margin_history)
asset_movements.extend(result_asset_movements)
if exchange_specific_data:
# This can only be poloniex at the moment
polo_loans_data = exchange_specific_data
loans.extend(process_polo_loans(
msg_aggregator=self.msg_aggregator,
data=polo_loans_data,
# We need to have full history of loans available
start_ts=Timestamp(0),
end_ts=now,
))
def fail_history_cb(error_msg: str) -> None:
"""This callback will run for failure in exchange history query"""
nonlocal empty_or_error
empty_or_error += '\n' + error_msg
for _, exchange in self.exchange_manager.connected_exchanges.items():
exchange.query_history_with_callbacks(
# We need to have full history of exchanges available
start_ts=Timestamp(0),
end_ts=now,
success_callback=populate_history_cb,
fail_callback=fail_history_cb,
)
try:
eth_transactions = query_ethereum_transactions(
database=self.db,
etherscan=self.chain_manager.ethereum.etherscan,
# We need to have full history of transactions available
from_ts=Timestamp(0),
to_ts=now,
)
except RemoteError as e:
eth_transactions = []
msg = str(e)
self.msg_aggregator.add_error(
f'There was an error when querying etherscan for ethereum transactions: {msg}'
f'The final history result will not include ethereum transactions',
)
empty_or_error += '\n' + msg
# Include the external trades in the history
external_trades = self.db.get_trades(
# We need to have full history of trades available
from_ts=Timestamp(0),
to_ts=now,
location=Location.EXTERNAL,
)
history.extend(external_trades)
# Include makerdao DSR gains and vault events
defi_events = []
if self.chain_manager.makerdao and has_premium:
dsr_gains = self.chain_manager.makerdao.get_dsr_gains_in_period(
from_ts=start_ts,
to_ts=end_ts,
)
log.debug('DSR GAINS: {dsr_gains}')
for gain, timestamp in dsr_gains:
if gain > ZERO:
defi_events.append(DefiEvent(
timestamp=timestamp,
event_type=DefiEventType.DSR_LOAN_GAIN,
asset=A_DAI,
amount=gain,
))
vault_details = self.chain_manager.makerdao.get_vault_details()
# We count the loss on a vault in the period if the last event is within
# the given period. It's not a very accurate approach but it's good enough
# for now. A more detailed approach would need archive node or log querying
# to find owed debt at any given timestamp
for detail in vault_details:
last_event_ts = detail.events[-1].timestamp
if last_event_ts >= start_ts and last_event_ts <= end_ts:
defi_events.append(DefiEvent(
timestamp=last_event_ts,
event_type=DefiEventType.MAKERDAO_VAULT_LOSS,
asset=A_USD,
amount=detail.total_liquidated_usd + detail.total_interest_owed,
))
history.sort(key=lambda trade: action_get_timestamp(trade))
return (
empty_or_error,
history,
loans,
asset_movements,
eth_transactions,
defi_events,
)
def create_history(self, start_ts: Timestamp, end_ts: Timestamp) -> HistoryResult:
"""Creates trades and loans history from start_ts to end_ts"""
log.info(
'Starting trade history creation',
start_ts=start_ts,
end_ts=end_ts,
)
# start creating the all trades history list
history: List[Union[Trade, MarginPosition]] = []
asset_movements = []
polo_loans = []
empty_or_error = ''
def populate_history_cb(
trades_history: List[Trade],
margin_history: List[MarginPosition],
result_asset_movements: List[AssetMovement],
exchange_specific_data: Any,
) -> None:
"""This callback will run for succesfull exchange history query"""
history.extend(trades_history)
history.extend(margin_history)
asset_movements.extend(result_asset_movements)
if exchange_specific_data:
# This can only be poloniex at the moment
polo_loans_data = exchange_specific_data
polo_loans.extend(process_polo_loans(
msg_aggregator=self.msg_aggregator,
data=polo_loans_data,
start_ts=start_ts,
end_ts=end_ts,
))
def fail_history_cb(error_msg: str) -> None:
"""This callback will run for failure in exchange history query"""
nonlocal empty_or_error
empty_or_error += '\n' + error_msg
for _, exchange in self.exchange_manager.connected_exchanges.items():
exchange.query_history_with_callbacks(
start_ts=start_ts,
end_ts=end_ts,
success_callback=populate_history_cb,
fail_callback=fail_history_cb,
)
try:
eth_transactions = query_ethereum_transactions(
database=self.db,
etherscan=self.etherscan,
from_ts=start_ts,
to_ts=end_ts,
)
except RemoteError as e:
eth_transactions = []
msg = str(e)
self.msg_aggregator.add_error(
f'There was an error when querying etherscan for ethereum transactions: {msg}'
f'The final history result will not include ethereum transactions',
)
empty_or_error += '\n' + msg
# We sort it here ... but when accounting runs through the entire actions list,
# it resorts, so unless the fact that we sort is used somewhere else too, perhaps
# we can skip it?
history.sort(key=lambda trade: action_get_timestamp(trade))
history = limit_trade_list_to_period(history, start_ts, end_ts)
# Include the external trades in the history
external_trades = self.db.get_trades(
from_ts=start_ts,
to_ts=end_ts,
location=Location.EXTERNAL,
)
history.extend(external_trades)
history.sort(key=lambda trade: action_get_timestamp(trade))
return (
empty_or_error,
history,
polo_loans,
asset_movements,
eth_transactions,
)