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)