def test_trade_from_binance(mock_binance):
binance_trades_list = [
{
'symbol': 'RDNETH',
'id': 1,
'orderId': 1,
'price': FVal(0.0063213),
'qty': FVal(5.0),
'commission': FVal(0.005),
'commissionAsset': 'RDN',
'time': 1512561941,
'isBuyer': True,
'isMaker': False,
'isBestMatch': True,
}, {
'symbol': 'ETHUSDT',
'id': 1,
'orderId': 1,
'price': FVal(481.0),
'qty': FVal(0.505),
'commission': FVal(0.242905),
'commissionAsset': 'USDT',
'time': 1531117990,
'isBuyer': False,
'isMaker': True,
'isBestMatch': True,
}, {
'symbol': 'BTCUSDT',
'id': 1,
'orderId': 1,
'price': FVal(6376.39),
'qty': FVal(0.051942),
'commission': FVal(0.00005194),
'commissionAsset': 'BTC',
'time': 1531728338,
'isBuyer': True,
'isMaker': False,
'isBestMatch': True,
}, {
'symbol': 'ADAUSDT',
'id': 1,
'orderId': 1,
'price': FVal(0.17442),
'qty': FVal(285.2),
'commission': FVal(0.00180015),
'commissionAsset': 'BNB',
'time': 1531871806,
'isBuyer': False,
'isMaker': True,
'isBestMatch': True,
},
]
our_expected_list = [
Trade(
timestamp=1512561941,
location='binance',
pair='RDN_ETH',
trade_type=TradeType.BUY,
amount=FVal(5.0),
rate=FVal(0.0063213),
fee=FVal(0.005),
fee_currency='RDN',
),
Trade(
timestamp=1531117990,
location='binance',
pair='ETH_USDT',
trade_type=TradeType.SELL,
amount=FVal(0.505),
rate=FVal(481.0),
fee=FVal(0.242905),
fee_currency='USDT',
),
Trade(
timestamp=1531728338,
location='binance',
pair='BTC_USDT',
trade_type=TradeType.BUY,
amount=FVal(0.051942),
rate=FVal(6376.39),
fee=FVal(0.00005194),
fee_currency='BTC',
),
Trade(
timestamp=1531871806,
location='binance',
pair='ADA_USDT',
trade_type=TradeType.SELL,
amount=FVal(285.2),
rate=FVal(0.17442),
fee=FVal(0.00180015),
fee_currency='BNB',
),
]
for idx, binance_trade in enumerate(binance_trades_list):
our_trade = trade_from_binance(binance_trade, mock_binance.symbols_to_pair)
assert our_trade == our_expected_list[idx]
def create_history(self, start_ts, end_ts, end_at_least_ts):
"""Creates trades and loans history from start_ts to end_ts or if
`end_at_least` is given and we have a cache history for that particular source
which satisfies it we return the cache
"""
# start creating the all trades history list
history = list()
asset_movements = list()
if self.kraken is not None:
kraken_history = self.kraken.query_trade_history(
start_ts=start_ts,
end_ts=end_ts,
end_at_least_ts=end_at_least_ts
)
for trade in kraken_history:
history.append(trade_from_kraken(trade))
kraken_asset_movements = self.kraken.query_deposits_withdrawals(
start_ts=start_ts,
end_ts=end_ts,
end_at_least_ts=end_at_least_ts,
)
asset_movements.extend(kraken_asset_movements)
if self.poloniex is not None:
polo_history = self.poloniex.query_trade_history(
start_ts=start_ts,
end_ts=end_ts,
end_at_least_ts=end_at_least_ts
)
poloniex_margin_trades = list()
for pair, trades in polo_history.items():
for trade in trades:
category = trade['category']
if category == 'exchange' or category == 'settlement':
history.append(trade_from_poloniex(trade, pair))
elif category == 'marginTrade':
if not self.read_manual_margin_positions:
poloniex_margin_trades.append(trade_from_poloniex(trade, pair))
else:
raise ValueError("Unexpected poloniex trade category: {}".format(category))
if self.read_manual_margin_positions:
# Just read the manual positions log and make virtual trades that
# correspond to the profits
assert poloniex_margin_trades == list(), (
"poloniex margin trades list should be empty here"
)
poloniex_margin_trades = do_read_manual_margin_positions(
self.data_directory
)
else:
poloniex_margin_trades.sort(key=lambda trade: trade.timestamp)
poloniex_margin_trades = limit_trade_list_to_period(
poloniex_margin_trades,
start_ts,
end_ts
)
polo_loans = self.poloniex.query_loan_history(
start_ts=start_ts,
end_ts=end_ts,
end_at_least_ts=end_at_least_ts,
from_csv=True
)
polo_loans = process_polo_loans(polo_loans, start_ts, end_ts)
polo_asset_movements = self.poloniex.query_deposits_withdrawals(
start_ts=start_ts,
end_ts=end_ts,
end_at_least_ts=end_at_least_ts,
)
asset_movements.extend(polo_asset_movements)
if self.bittrex is not None:
bittrex_history = self.bittrex.query_trade_history(
start_ts=start_ts,
end_ts=end_ts,
end_at_least_ts=end_at_least_ts
)
for trade in bittrex_history:
history.append(trade_from_bittrex(trade))
if self.binance is not None:
binance_history = self.binance.query_trade_history(
start_ts=start_ts,
end_ts=end_ts,
end_at_least_ts=end_at_least_ts
)
for trade in binance_history:
history.append(trade_from_binance(trade))
eth_transactions = query_etherscan_for_transactions(self.eth_accounts)
# 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: trade.timestamp)
history = limit_trade_list_to_period(history, start_ts, end_ts)
# Write to files
historyfile_path = os.path.join(self.data_directory, TRADES_HISTORYFILE)
write_tupledata_history_in_file(history, historyfile_path, start_ts, end_ts)
if not self.read_manual_margin_positions:
marginfile_path = os.path.join(self.data_directory, MARGIN_HISTORYFILE)
write_tupledata_history_in_file(
poloniex_margin_trades,
marginfile_path,
start_ts,
end_ts
)
loansfile_path = os.path.join(self.data_directory, LOANS_HISTORYFILE)
write_history_data_in_file(polo_loans, loansfile_path, start_ts, end_ts)
assetmovementsfile_path = os.path.join(self.data_directory, ASSETMOVEMENTS_HISTORYFILE)
write_tupledata_history_in_file(asset_movements, assetmovementsfile_path, start_ts, end_ts)
eth_tx_log_path = os.path.join(self.data_directory, ETHEREUM_TX_LOGFILE)
write_tupledata_history_in_file(eth_transactions, eth_tx_log_path, start_ts, end_ts)
# After writting everything to files include the external trades in the history
history = include_external_trades(self.db, start_ts, end_ts, history)
return history, poloniex_margin_trades, polo_loans, asset_movements, eth_transactions
def create_history(self, start_ts, end_ts, end_at_least_ts):
"""Creates trades and loans history from start_ts to end_ts or if
`end_at_least` is given and we have a cache history for that particular source
which satisfies it we return the cache
"""
log.info(
'Starting trade history creation',
start_ts=start_ts,
end_ts=end_ts,
end_at_least_ts=end_at_least_ts,
)
# start creating the all trades history list
history = list()
asset_movements = list()
empty_or_error = ''
if self.kraken is not None:
try:
kraken_history = self.kraken.query_trade_history(
start_ts=start_ts,
end_ts=end_ts,
end_at_least_ts=end_at_least_ts)
for trade in kraken_history:
history.append(trade_from_kraken(trade))
kraken_asset_movements = self.kraken.query_deposits_withdrawals(
start_ts=start_ts,
end_ts=end_ts,
end_at_least_ts=end_at_least_ts,
)
asset_movements.extend(kraken_asset_movements)
except RemoteError as e:
empty_or_error += '\n' + str(e)
try:
(
history,
asset_movements,
poloniex_margin_trades,
polo_loans,
) = self.query_poloniex_history(
history,
asset_movements,
start_ts,
end_ts,
end_at_least_ts,
)
except RemoteError as e:
empty_or_error += '\n' + str(e)
if self.bittrex is not None:
try:
bittrex_history = self.bittrex.query_trade_history(
start_ts=start_ts,
end_ts=end_ts,
end_at_least_ts=end_at_least_ts,
)
for trade in bittrex_history:
history.append(trade_from_bittrex(trade))
except RemoteError as e:
empty_or_error += '\n' + str(e)
if self.bitmex is not None:
try:
bitmex_history = self.bitmex.query_trade_history(
start_ts=start_ts,
end_ts=end_ts,
end_at_least_ts=end_at_least_ts,
)
for trade in bitmex_history:
history.append(trade_from_bitmex(trade))
bitmex_asset_movements = self.bitmex.query_deposits_withdrawals(
start_ts=start_ts,
end_ts=end_ts,
end_at_least_ts=end_at_least_ts,
)
asset_movements.extend(bitmex_asset_movements)
except RemoteError as e:
empty_or_error += '\n' + str(e)
if self.binance is not None:
try:
binance_history = self.binance.query_trade_history(
start_ts=start_ts,
end_ts=end_ts,
end_at_least_ts=end_at_least_ts)
for trade in binance_history:
history.append(
trade_from_binance(trade,
self.binance.symbols_to_pair))
except RemoteError as e:
empty_or_error += '\n' + str(e)
try:
eth_transactions = query_etherscan_for_transactions(
self.eth_accounts)
except RemoteError as e:
empty_or_error += '\n' + str(e)
# 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: trade.timestamp)
history = limit_trade_list_to_period(history, start_ts, end_ts)
# Write to files
historyfile_path = os.path.join(self.data_directory,
TRADES_HISTORYFILE)
write_tupledata_history_in_file(history, historyfile_path, start_ts,
end_ts)
if self.poloniex is not None and not self.read_manual_margin_positions:
marginfile_path = os.path.join(self.data_directory,
MARGIN_HISTORYFILE)
write_tupledata_history_in_file(poloniex_margin_trades,
marginfile_path, start_ts, end_ts)
if self.poloniex is not None:
loansfile_path = os.path.join(self.data_directory,
LOANS_HISTORYFILE)
write_history_data_in_file(polo_loans, loansfile_path, start_ts,
end_ts)
assetmovementsfile_path = os.path.join(self.data_directory,
ASSETMOVEMENTS_HISTORYFILE)
write_tupledata_history_in_file(asset_movements,
assetmovementsfile_path, start_ts,
end_ts)
eth_tx_log_path = os.path.join(self.data_directory,
ETHEREUM_TX_LOGFILE)
write_tupledata_history_in_file(eth_transactions, eth_tx_log_path,
start_ts, end_ts)
# After writting everything to files include the external trades in the history
history = include_external_trades(self.db, start_ts, end_ts, history)
return (
empty_or_error,
history,
poloniex_margin_trades,
polo_loans,
asset_movements,
eth_transactions,
)