async def _get_tools(symbol="BTC/USDT"):
config = test_config.load_test_config()
config[commons_constants.CONFIG_SIMULATOR][commons_constants.CONFIG_STARTING_PORTFOLIO]["USDT"] = 1000
exchange_manager = exchanges.ExchangeManager(config, "binance")
exchange_manager.tentacles_setup_config = test_utils_config.get_tentacles_setup_config()
# use backtesting not to spam exchanges apis
exchange_manager.is_simulated = True
exchange_manager.is_backtesting = True
backtesting = await backtesting_api.initialize_backtesting(
config,
exchange_ids=[exchange_manager.id],
matrix_id=None,
data_files=[
os.path.join(test_config.TEST_CONFIG_FOLDER, "AbstractExchangeHistoryCollector_1586017993.616272.data")])
exchange_manager.exchange = exchanges.ExchangeSimulator(exchange_manager.config,
exchange_manager,
backtesting)
await exchange_manager.exchange.initialize()
for exchange_channel_class_type in [exchanges_channel.ExchangeChannel, exchanges_channel.TimeFrameExchangeChannel]:
await channel_util.create_all_subclasses_channel(exchange_channel_class_type, exchanges_channel.set_chan,
exchange_manager=exchange_manager)
trader = exchanges.TraderSimulator(config, exchange_manager)
await trader.initialize()
mode = Mode.DailyTradingMode(config, exchange_manager)
await mode.initialize()
# add mode to exchange manager so that it can be stopped and freed from memory
exchange_manager.trading_modes.append(mode)
# set BTC/USDT price at 1000 USDT
trading_api.force_set_mark_price(exchange_manager, symbol, 1000)
return mode.producers[0], mode.consumers[0], trader
async def test_create_orders_with_fixed_volume_per_order():
try:
symbol = "BTC/USDT"
producer, _, exchange_manager = await _get_tools(symbol)
producer.buy_volume_per_order = decimal.Decimal("0.1")
producer.sell_volume_per_order = decimal.Decimal("0.3")
# set BTC/USD price at 4000 USD
trading_api.force_set_mark_price(exchange_manager, symbol, 4000)
await producer._ensure_staggered_orders()
await asyncio.create_task(_check_open_orders_count(exchange_manager, 27))
created_orders = trading_api.get_open_orders(exchange_manager)
created_buy_orders = [o for o in created_orders if o.side is trading_enums.TradeOrderSide.BUY]
created_sell_orders = [o for o in created_orders if o.side is trading_enums.TradeOrderSide.SELL]
assert len(created_buy_orders) == 2 # not enough funds to create more orders
assert len(created_sell_orders) == producer.sell_orders_count # 25
# ensure only closest orders got created with the right value and in the right order
assert created_buy_orders[0].origin_price == 3995
assert created_buy_orders[1].origin_price == 3990
assert created_sell_orders[0].origin_price == 4005
assert created_sell_orders[1].origin_price == 4010
assert created_sell_orders[0] is created_orders[0]
assert all(o.origin_quantity == float(producer.buy_volume_per_order) for o in created_buy_orders)
assert all(o.origin_quantity == float(producer.sell_volume_per_order) for o in created_sell_orders)
finally:
await _stop(exchange_manager)
async def exchange(exchange_name, backtesting=None, symbol="BTC/USDT"):
exchange_manager = None
try:
config = test_config.load_test_config()
config[commons_constants.CONFIG_SIMULATOR][commons_constants.CONFIG_STARTING_PORTFOLIO]["USDT"] = 2000
exchange_manager = exchanges.ExchangeManager(config, exchange_name)
# use backtesting not to spam exchanges apis
exchange_manager.is_simulated = True
exchange_manager.is_backtesting = True
backtesting = backtesting or await backtesting_api.initialize_backtesting(
config,
exchange_ids=[exchange_manager.id],
matrix_id=None,
data_files=[os.path.join(test_config.TEST_CONFIG_FOLDER,
"AbstractExchangeHistoryCollector_1586017993.616272.data")])
exchange_manager.exchange = exchanges.ExchangeSimulator(exchange_manager.config,
exchange_manager,
backtesting)
await exchange_manager.exchange.initialize()
for exchange_channel_class_type in [exchanges_channel.ExchangeChannel,
exchanges_channel.TimeFrameExchangeChannel]:
await channel_util.create_all_subclasses_channel(exchange_channel_class_type, exchanges_channel.set_chan,
exchange_manager=exchange_manager)
trader = exchanges.TraderSimulator(config, exchange_manager)
await trader.initialize()
mode = modes.ArbitrageTradingMode(config, exchange_manager)
mode.symbol = None if mode.get_is_symbol_wildcard() else symbol
await mode.initialize()
# add mode to exchange manager so that it can be stopped and freed from memory
exchange_manager.trading_modes.append(mode)
# set BTC/USDT price at 1000 USDT
trading_api.force_set_mark_price(exchange_manager, symbol, 1000)
# force triggering_price_delta_ratio equivalent to a 0.2% setting in minimal_price_delta_percent
delta_percent = 2
mode.producers[0].inf_triggering_price_delta_ratio = 1 - delta_percent / 100
mode.producers[0].sup_triggering_price_delta_ratio = 1 + delta_percent / 100
yield mode.producers[0], mode.consumers[0], exchange_manager
finally:
if exchange_manager is not None:
for importer in backtesting_api.get_importers(exchange_manager.exchange.backtesting):
await backtesting_api.stop_importer(importer)
if exchange_manager.exchange.backtesting.time_updater is not None:
await exchange_manager.exchange.backtesting.stop()
await exchange_manager.stop()
async def test_create_orders_without_enough_funds_for_all_orders_3_total_orders():
try:
symbol = "BTC/USDT"
producer, _, exchange_manager = await _get_tools(symbol)
producer.buy_funds = decimal.Decimal("0.07") # 1 order
producer.sell_funds = decimal.Decimal("0.000025") # 2 orders
# set BTC/USD price at 4000 USD
trading_api.force_set_mark_price(exchange_manager, symbol, 4000)
await producer._ensure_staggered_orders()
btc_available_funds = producer._get_available_funds("BTC")
usd_available_funds = producer._get_available_funds("USDT")
used_btc = 10 - btc_available_funds
used_usd = 1000 - usd_available_funds
assert used_usd >= producer.buy_funds * decimal.Decimal(0.99)
assert used_btc >= producer.sell_funds * decimal.Decimal(0.99)
# btc_available_funds for reduced because orders are not created
assert 10 - 0.001 <= btc_available_funds < 10
assert 1000 - 100 <= usd_available_funds < 1000
await asyncio.create_task(_check_open_orders_count(exchange_manager, 1 + 2))
created_orders = trading_api.get_open_orders(exchange_manager)
created_buy_orders = [o for o in created_orders if o.side is trading_enums.TradeOrderSide.BUY]
created_sell_orders = [o for o in created_orders if o.side is trading_enums.TradeOrderSide.SELL]
assert len(created_buy_orders) < producer.buy_orders_count
assert len(created_buy_orders) == 1
assert len(created_sell_orders) < producer.sell_orders_count
assert len(created_sell_orders) == 2
# ensure only orders closest to the current price have been created
min_buy_price = 4000 - (producer.flat_spread / 2) - (producer.flat_increment * (len(created_buy_orders) - 1))
assert all(
o.origin_price >= min_buy_price for o in created_buy_orders
)
max_sell_price = 4000 + (producer.flat_spread / 2) + (producer.flat_increment * (len(created_sell_orders) - 1))
assert all(
o.origin_price <= max_sell_price for o in created_sell_orders
)
pf_btc_available_funds = trading_api.get_portfolio_currency(exchange_manager, "BTC")
pf_usd_available_funds = trading_api.get_portfolio_currency(exchange_manager, "USDT")
assert pf_btc_available_funds >= 10 - 0.000025
assert pf_usd_available_funds >= 1000 - 0.07
assert pf_btc_available_funds >= btc_available_funds
assert pf_usd_available_funds >= usd_available_funds
finally:
await _stop(exchange_manager)
async def _get_tools(symbol, btc_holdings=None, additional_portfolio={}, fees=None):
config = test_config.load_test_config()
config[commons_constants.CONFIG_SIMULATOR][commons_constants.CONFIG_STARTING_PORTFOLIO]["USDT"] = 1000
config[commons_constants.CONFIG_SIMULATOR][commons_constants.CONFIG_STARTING_PORTFOLIO][
"BTC"] = 10 if btc_holdings is None else btc_holdings
config[commons_constants.CONFIG_SIMULATOR][commons_constants.CONFIG_STARTING_PORTFOLIO].update(additional_portfolio)
if fees is not None:
config[commons_constants.CONFIG_SIMULATOR][commons_constants.CONFIG_SIMULATOR_FEES][
commons_constants.CONFIG_SIMULATOR_FEES_TAKER] = fees
config[commons_constants.CONFIG_SIMULATOR][commons_constants.CONFIG_SIMULATOR_FEES][
commons_constants.CONFIG_SIMULATOR_FEES_MAKER] = fees
exchange_manager = exchanges.ExchangeManager(config, "binance")
exchange_manager.tentacles_setup_config = test_utils_config.get_tentacles_setup_config()
# use backtesting not to spam exchanges apis
exchange_manager.is_simulated = True
exchange_manager.is_backtesting = True
backtesting = await backtesting_api.initialize_backtesting(
config,
exchange_ids=[exchange_manager.id],
matrix_id=None,
data_files=[
os.path.join(test_config.TEST_CONFIG_FOLDER, "AbstractExchangeHistoryCollector_1586017993.616272.data")])
exchange_manager.exchange = exchanges.ExchangeSimulator(exchange_manager.config,
exchange_manager,
backtesting)
await exchange_manager.exchange.initialize()
for exchange_channel_class_type in [exchanges_channel.ExchangeChannel, exchanges_channel.TimeFrameExchangeChannel]:
await channel_util.create_all_subclasses_channel(exchange_channel_class_type, exchanges_channel.set_chan,
exchange_manager=exchange_manager)
trader = exchanges.TraderSimulator(config, exchange_manager)
await trader.initialize()
# set BTC/USDT price at 1000 USDT
trading_api.force_set_mark_price(exchange_manager, symbol, 1000)
mode, producer = await _init_trading_mode(config, exchange_manager, symbol)
producer.flat_spread = decimal.Decimal(10)
producer.flat_increment = decimal.Decimal(5)
producer.buy_orders_count = 25
producer.sell_orders_count = 25
return producer, mode.consumers[0], exchange_manager
async def test_create_new_orders_with_dusts_included():
try:
exchange_manager, trader, symbol, consumer, last_btc_price = await _get_tools(
)
exchange_manager.exchange_personal_data.portfolio_manager.portfolio.portfolio = {
"BTC": {
commons_constants.PORTFOLIO_TOTAL: 0.000015,
commons_constants.PORTFOLIO_AVAILABLE: 0.000015
}
}
# trigger order that should not sell everything but does sell everything because remaining amount
# is not sellable
orders = await consumer.create_new_orders(
symbol, 0.6, trading_enums.EvaluatorStates.VERY_SHORT.value)
assert len(orders) == 1
assert exchange_manager.exchange_personal_data.portfolio_manager.portfolio.portfolio[
"BTC"] == {
commons_constants.PORTFOLIO_TOTAL: 0,
commons_constants.PORTFOLIO_AVAILABLE: 0
}
test_currency = "NEO"
test_pair = f"{test_currency}/BTC"
exchange_manager.exchange_personal_data.portfolio_manager.portfolio.portfolio = {
test_currency: {
commons_constants.PORTFOLIO_TOTAL: 0.44,
commons_constants.PORTFOLIO_AVAILABLE: 0.44
}
}
trading_api.force_set_mark_price(exchange_manager, test_pair, 0.005318)
# trigger order that should not sell everything but does sell everything because remaining amount
# is not sellable
orders = await consumer.create_new_orders(
test_pair, 0.75445456165478,
trading_enums.EvaluatorStates.SHORT.value)
assert len(orders) == 1
assert exchange_manager.exchange_personal_data.portfolio_manager.portfolio.portfolio[
test_currency] == {
commons_constants.PORTFOLIO_TOTAL: orders[0].origin_quantity,
commons_constants.PORTFOLIO_AVAILABLE: 0
}
finally:
await _stop(exchange_manager)
async def test_create_multiple_buy_orders_after_fill():
exchange_manager, trader, symbol, consumer, last_btc_price = await _get_tools()
# with BTC/USDT
exchange_manager.exchange_personal_data.portfolio_manager.portfolio_value_holder.currencies_last_prices[symbol] = \
last_btc_price
exchange_manager.exchange_personal_data.portfolio_manager.portfolio_value_holder.portfolio_current_value = \
10 + 1000 / last_btc_price
# force many traded asset not to create all in orders
exchange_manager.exchange_personal_data.portfolio_manager.portfolio_value_holder.origin_crypto_currencies_values \
= {
"a": 0,
"b": 0,
"c": 0,
"d": 0,
"e": 0
}
await ensure_smaller_orders(consumer, symbol, trader)
# with another symbol with 0 quantity when start
trading_api.force_set_mark_price(exchange_manager, "ADA/BTC", 0.0000001)
await ensure_smaller_orders(consumer, "ADA/BTC", trader)
await _stop(exchange_manager)
async def test_create_order_using_a_lot_of_different_inputs_without_portfolio_reset(
):
exchange_manager, trader, symbol, consumer, last_btc_price = await _get_tools(
)
gradient_step = 0.001
nb_orders = "unknown"
initial_portfolio = copy.deepcopy(exchange_manager.exchange_personal_data.
portfolio_manager.portfolio.portfolio)
portfolio_wrapper = exchange_manager.exchange_personal_data.portfolio_manager.portfolio
market_status = exchange_manager.exchange.get_market_status(
symbol, with_fixer=False)
min_trigger_market = "ADA/BNB"
trading_api.force_set_mark_price(exchange_manager, min_trigger_market,
0.001)
_reset_portfolio(exchange_manager)
for state in _get_states_gradient_with_invald_states():
for evaluation in _get_evaluations_gradient(gradient_step):
# orders are possible
try:
orders = await consumer.create_new_orders(
symbol, evaluation, state)
trading_mode_test_toolkit.check_orders(orders, evaluation,
state, nb_orders,
market_status)
trading_mode_test_toolkit.check_portfolio(
portfolio_wrapper.portfolio, initial_portfolio, orders,
True)
await trading_mode_test_toolkit.fill_orders(orders, trader)
except trading_errors.MissingMinimalExchangeTradeVolume:
pass
# orders are impossible
try:
orders = []
orders = await consumer.create_new_orders(
min_trigger_market, evaluation, state)
trading_mode_test_toolkit.check_orders(orders, evaluation,
state, 0, market_status)
trading_mode_test_toolkit.check_portfolio(
portfolio_wrapper.portfolio, initial_portfolio, orders,
True)
await trading_mode_test_toolkit.fill_orders(orders, trader)
except trading_errors.MissingMinimalExchangeTradeVolume:
pass
_reset_portfolio(exchange_manager)
for state in _get_states_gradient_with_invald_states():
for evaluation in _get_irrationnal_numbers():
# orders are possible
try:
orders = await consumer.create_new_orders(
symbol, evaluation, state)
trading_mode_test_toolkit.check_orders(orders, evaluation,
state, nb_orders,
market_status)
trading_mode_test_toolkit.check_portfolio(
portfolio_wrapper.portfolio, initial_portfolio, orders,
True)
if any(order for order in orders if order.order_type not in (
trading_enums.TraderOrderType.SELL_MARKET,
trading_enums.TraderOrderType.BUY_MARKET)):
# no need to fill market orders
await trading_mode_test_toolkit.fill_orders(orders, trader)
except trading_errors.MissingMinimalExchangeTradeVolume:
pass
# orders are impossible
try:
orders = []
orders = await consumer.create_new_orders(
min_trigger_market, evaluation, state)
trading_mode_test_toolkit.check_orders(orders, evaluation,
state, 0, market_status)
trading_mode_test_toolkit.check_portfolio(
portfolio_wrapper.portfolio, initial_portfolio, orders,
True)
if any(order for order in orders if order.order_type not in (
trading_enums.TraderOrderType.SELL_MARKET,
trading_enums.TraderOrderType.BUY_MARKET)):
# no need to fill market orders
await trading_mode_test_toolkit.fill_orders(orders, trader)
except trading_errors.MissingMinimalExchangeTradeVolume:
pass
_reset_portfolio(exchange_manager)
for state in _get_states_gradient_with_invald_states():
# orders are possible
try:
orders = await consumer.create_new_orders(symbol, math.nan, state)
trading_mode_test_toolkit.check_orders(orders, math.nan, state,
nb_orders, market_status)
trading_mode_test_toolkit.check_portfolio(
portfolio_wrapper.portfolio, initial_portfolio, orders, True)
await trading_mode_test_toolkit.fill_orders(orders, trader)
except trading_errors.MissingMinimalExchangeTradeVolume:
pass
# orders are impossible
try:
orders = []
orders = await consumer.create_new_orders(min_trigger_market,
math.nan, state)
trading_mode_test_toolkit.check_orders(orders, math.nan, state, 0,
market_status)
trading_mode_test_toolkit.check_portfolio(
portfolio_wrapper.portfolio, initial_portfolio, orders, True)
await trading_mode_test_toolkit.fill_orders(orders, trader)
except trading_errors.MissingMinimalExchangeTradeVolume:
pass
await _stop(exchange_manager)
async def test_create_orders_using_a_lot_of_different_inputs_with_portfolio_reset(
):
exchange_manager, trader, symbol, consumer, last_btc_price = await _get_tools(
)
gradient_step = 0.005
nb_orders = 1
initial_portfolio = copy.deepcopy(exchange_manager.exchange_personal_data.
portfolio_manager.portfolio.portfolio)
portfolio_wrapper = exchange_manager.exchange_personal_data.portfolio_manager.portfolio
market_status = exchange_manager.exchange.get_market_status(
symbol, with_fixer=False)
min_trigger_market = "ADA/BNB"
trading_api.force_set_mark_price(exchange_manager, min_trigger_market,
0.001)
for state in _get_states_gradient_with_invald_states():
for evaluation in _get_evaluations_gradient(gradient_step):
_reset_portfolio(exchange_manager)
# orders are possible
try:
orders = await consumer.create_new_orders(
symbol, evaluation, state)
trading_mode_test_toolkit.check_orders(orders, evaluation,
state, nb_orders,
market_status)
trading_mode_test_toolkit.check_portfolio(
portfolio_wrapper.portfolio, initial_portfolio, orders)
except trading_errors.MissingMinimalExchangeTradeVolume:
pass
# orders are impossible
try:
orders = []
orders = await consumer.create_new_orders(
min_trigger_market, evaluation, state)
trading_mode_test_toolkit.check_orders(orders, evaluation,
state, 0, market_status)
trading_mode_test_toolkit.check_portfolio(
portfolio_wrapper.portfolio, initial_portfolio, orders)
except trading_errors.MissingMinimalExchangeTradeVolume:
pass
for evaluation in _get_irrationnal_numbers():
# orders are possible
_reset_portfolio(exchange_manager)
try:
orders = await consumer.create_new_orders(
symbol, evaluation, state)
trading_mode_test_toolkit.check_orders(orders, evaluation,
state, nb_orders,
market_status)
trading_mode_test_toolkit.check_portfolio(
portfolio_wrapper.portfolio, initial_portfolio, orders)
except trading_errors.MissingMinimalExchangeTradeVolume:
pass
# orders are impossible
try:
orders = []
orders = await consumer.create_new_orders(
min_trigger_market, evaluation, state)
trading_mode_test_toolkit.check_orders(orders, evaluation,
state, 0, market_status)
trading_mode_test_toolkit.check_portfolio(
portfolio_wrapper.portfolio, initial_portfolio, orders)
except trading_errors.MissingMinimalExchangeTradeVolume:
pass
_reset_portfolio(exchange_manager)
# orders are possible
try:
orders = await consumer.create_new_orders(symbol, math.nan, state)
trading_mode_test_toolkit.check_orders(orders, math.nan, state,
nb_orders, market_status)
trading_mode_test_toolkit.check_portfolio(
portfolio_wrapper.portfolio, initial_portfolio, orders)
except trading_errors.MissingMinimalExchangeTradeVolume:
pass
# orders are impossible
try:
orders = []
orders = await consumer.create_new_orders(min_trigger_market,
math.nan, state)
trading_mode_test_toolkit.check_orders(orders, math.nan, state, 0,
market_status)
trading_mode_test_toolkit.check_portfolio(
portfolio_wrapper.portfolio, initial_portfolio, orders)
except trading_errors.MissingMinimalExchangeTradeVolume:
pass
await _stop(exchange_manager)
async def test_split_create_new_orders():
try:
exchange_manager, trader, symbol, consumer, last_btc_price = await _get_tools(
)
# change reference market to get more orders
exchange_manager.exchange_personal_data.portfolio_manager.reference_market = "USDT"
exchange_manager.exchange_personal_data.portfolio_manager.reference_market = "USDT"
market_status = exchange_manager.exchange.get_market_status(
symbol, with_fixer=False)
exchange_manager.exchange_personal_data.portfolio_manager.portfolio.portfolio = {
"BTC": {
commons_constants.PORTFOLIO_TOTAL: 2000000001,
commons_constants.PORTFOLIO_AVAILABLE: 2000000001
}
}
exchange_manager.exchange_personal_data.portfolio_manager.portfolio_value_holder.last_prices_by_trading_pair[
symbol] = last_btc_price
exchange_manager.exchange_personal_data.portfolio_manager.portfolio_value_holder.portfolio_current_value = \
last_btc_price * 2000000001 + 1000
# split orders because order too big and coin price too high
orders = await consumer.create_new_orders(
symbol, 0.6, trading_enums.EvaluatorStates.SHORT.value)
assert len(orders) == 11
adapted_order = orders[0]
identical_orders = orders[1:]
assert isinstance(adapted_order, trading_personal_data.SellLimitOrder)
assert adapted_order.currency == "BTC"
assert adapted_order.symbol == "BTC/USDT"
assert adapted_order.origin_price == 7065.26855999
assert adapted_order.created_last_price == last_btc_price
assert adapted_order.order_type == trading_enums.TraderOrderType.SELL_LIMIT
assert adapted_order.side == trading_enums.TradeOrderSide.SELL
assert adapted_order.status == trading_enums.OrderStatus.OPEN
assert adapted_order.exchange_manager == exchange_manager
assert adapted_order.trader == trader
assert adapted_order.fee is None
assert adapted_order.filled_price == 0
assert adapted_order.origin_quantity == 64625635.97358092
assert adapted_order.filled_quantity == adapted_order.origin_quantity
assert adapted_order.simulated is True
assert adapted_order.linked_to is None
trading_mode_test_toolkit.check_order_limits(adapted_order,
market_status)
assert len(adapted_order.linked_orders) == 1
trading_mode_test_toolkit.check_linked_order(
adapted_order, adapted_order.linked_orders[0],
trading_enums.TraderOrderType.STOP_LOSS, 6658.73524999,
market_status)
for order in identical_orders:
assert isinstance(order, trading_personal_data.SellLimitOrder)
assert order.currency == adapted_order.currency
assert order.symbol == adapted_order.symbol
assert order.origin_price == adapted_order.origin_price
assert order.created_last_price == adapted_order.created_last_price
assert order.order_type == adapted_order.order_type
assert order.side == adapted_order.side
assert order.status == adapted_order.status
assert order.exchange_manager == adapted_order.exchange_manager
assert order.trader == adapted_order.trader
assert order.fee == adapted_order.fee
assert order.filled_price == adapted_order.filled_price
assert order.origin_quantity == 141537436.47664192
assert order.origin_quantity > adapted_order.origin_quantity
assert order.filled_quantity > adapted_order.filled_quantity
assert order.simulated == adapted_order.simulated
assert order.linked_to == adapted_order.linked_to
assert len(order.linked_orders) == 1
trading_mode_test_toolkit.check_order_limits(order, market_status)
trading_mode_test_toolkit.check_linked_order(
order, order.linked_orders[0],
trading_enums.TraderOrderType.STOP_LOSS, 6658.73524999,
market_status)
exchange_manager.exchange_personal_data.portfolio_manager.portfolio.portfolio = {
"USDT": {
commons_constants.PORTFOLIO_TOTAL: 40000000000,
commons_constants.PORTFOLIO_AVAILABLE: 40000000000
}
}
# set btc last price to 6998.55407999 * 0.000001 = 0.00699855408
trading_api.force_set_mark_price(exchange_manager, symbol,
last_btc_price * 0.000001)
# split orders because order too big and too many coins
orders = await consumer.create_new_orders(
symbol, -0.6, trading_enums.EvaluatorStates.LONG.value)
assert len(orders) == 3
adapted_order = orders[0]
identical_orders = orders[1:]
assert isinstance(adapted_order, trading_personal_data.BuyLimitOrder)
assert adapted_order.currency == "BTC"
assert adapted_order.symbol == "BTC/USDT"
assert adapted_order.origin_price == 0.00695312
assert adapted_order.created_last_price == 0.007009194999999998
assert adapted_order.order_type == trading_enums.TraderOrderType.BUY_LIMIT
assert adapted_order.side == trading_enums.TradeOrderSide.BUY
assert adapted_order.status == trading_enums.OrderStatus.OPEN
assert adapted_order.exchange_manager == exchange_manager
assert adapted_order.trader == trader
assert adapted_order.fee is None
assert adapted_order.filled_price == 0
assert adapted_order.origin_quantity == 396851564266.65326
assert adapted_order.filled_quantity == adapted_order.origin_quantity
assert adapted_order.simulated is True
assert adapted_order.linked_to is None
trading_mode_test_toolkit.check_order_limits(adapted_order,
market_status)
# assert len(order.linked_orders) == 1 # check linked orders when it will be developed
for order in identical_orders:
assert isinstance(order, trading_personal_data.BuyLimitOrder)
assert order.currency == adapted_order.currency
assert order.symbol == adapted_order.symbol
assert order.origin_price == adapted_order.origin_price
assert order.created_last_price == adapted_order.created_last_price
assert order.order_type == adapted_order.order_type
assert order.side == adapted_order.side
assert order.status == adapted_order.status
assert order.exchange_manager == adapted_order.exchange_manager
assert order.trader == adapted_order.trader
assert order.fee == adapted_order.fee
assert order.filled_price == adapted_order.filled_price
assert order.origin_quantity == 1000000000000.0
assert order.origin_quantity > adapted_order.origin_quantity
assert order.filled_quantity > adapted_order.filled_quantity
assert order.simulated == adapted_order.simulated
assert order.linked_to == adapted_order.linked_to
trading_mode_test_toolkit.check_order_limits(order, market_status)
# assert len(order.linked_orders) == 1 # check linked orders when it will be developed
finally:
await _stop(exchange_manager)
