def test_volatility(self, estimate_fee_mock, get_mid_price_mock): """ Assert that volatility information is updated after the expected number of intervals """ estimate_fee_mock.return_value = AddedToCostTradeFee( percent=0, flat_fees=[TokenAmount('ETH', Decimal(0.00005))]) # initiate with similar balances so the skew is obvious usdt_balance = 1000 eth_balance = 1000 trading_pairs = list( map(lambda quote_asset: "ETH-" + quote_asset, ["USDT"])) market, market_infos = self.create_market(trading_pairs, 100, { "USDT": usdt_balance, "ETH": eth_balance }) strategy = LiquidityMiningStrategy() strategy.init_params( exchange=market, market_infos=market_infos, token="ETH", order_amount=Decimal(2), spread=Decimal(0.0005), inventory_skew_enabled=False, target_base_pct=Decimal(0.5), # less base, more quote order_refresh_time=1, order_refresh_tolerance_pct=Decimal( 0.1), # tolerance of 10 % change # volatility_interval=2, # avg_volatility_period=2, # volatility_to_spread_multiplier=2, ) get_mid_price_mock.return_value = Decimal(100.0) self.clock.add_iterator(strategy) self.clock.backtest_til(self.start_timestamp + 1) # update prices to create volatility after 2 intervals get_mid_price_mock.return_value = Decimal(105.0) self.clock.backtest_til(self.start_timestamp + 2) get_mid_price_mock.return_value = Decimal(110) self.clock.backtest_til(self.start_timestamp + 3) # assert that volatility is none zero self.assertAlmostEqual(float( strategy.market_status_df().loc[0, 'Volatility'].strip('%')), 10.00, delta=0.1)
def test_create_order_and_process_fill(self): recorder = MarketsRecorder(sql=self.manager, markets=[self], config_file_path=self.config_file_path, strategy_name=self.strategy_name) create_event = BuyOrderCreatedEvent( timestamp=1642010000, type=OrderType.LIMIT, trading_pair=self.trading_pair, amount=Decimal(1), price=Decimal(1000), order_id="OID1-1642010000000000", creation_timestamp=1640001112.223, exchange_order_id="EOID1", ) recorder._did_create_order(MarketEvent.BuyOrderCreated.value, self, create_event) fill_event = OrderFilledEvent(timestamp=1642020000, order_id=create_event.order_id, trading_pair=create_event.trading_pair, trade_type=TradeType.BUY, order_type=create_event.type, price=Decimal(1010), amount=create_event.amount, trade_fee=AddedToCostTradeFee(), exchange_trade_id="TradeId1") recorder._did_fill_order(MarketEvent.OrderFilled.value, self, fill_event) with self.manager.get_new_session() as session: query = session.query(Order) orders = query.all() order = orders[0] order_status = order.status trade_fills = order.trade_fills self.assertEqual(1, len(orders)) self.assertEqual(self.config_file_path, orders[0].config_file_path) self.assertEqual(create_event.order_id, orders[0].id) self.assertEqual(2, len(order_status)) self.assertEqual(MarketEvent.BuyOrderCreated.name, order_status[0].status) self.assertEqual(MarketEvent.OrderFilled.name, order_status[1].status) self.assertEqual(1, len(trade_fills)) self.assertEqual(self.config_file_path, trade_fills[0].config_file_path) self.assertEqual(fill_event.order_id, trade_fills[0].order_id)
def test_to_json(self): fee = AddedToCostTradeFee(percent=Decimal("0.5"), percent_token=self.quote_asset) trade_update = TradeUpdate( trade_id="12345", client_order_id=self.client_order_id, exchange_order_id="EOID1", trading_pair=self.trading_pair, fill_timestamp=1640001112, fill_price=Decimal("1000.11"), fill_base_amount=Decimal("2"), fill_quote_amount=Decimal("2000.22"), fee=fee, ) order: InFlightOrder = InFlightOrder( client_order_id=self.client_order_id, trading_pair=self.trading_pair, order_type=OrderType.LIMIT, trade_type=TradeType.BUY, amount=Decimal("1000.0"), creation_timestamp=1640001112.0, price=Decimal("1.0"), ) order.order_fills["1"] = trade_update order_json = order.to_json() self.assertIsInstance(order_json, dict) self.assertEqual(order_json["client_order_id"], order.client_order_id) self.assertEqual(order_json["exchange_order_id"], order.exchange_order_id) self.assertEqual(order_json["trading_pair"], order.trading_pair) self.assertEqual(order_json["order_type"], order.order_type.name) self.assertEqual(order_json["trade_type"], order.trade_type.name) self.assertEqual(order_json["price"], str(order.price)) self.assertEqual(order_json["amount"], str(order.amount)) self.assertEqual(order_json["executed_amount_base"], str(order.executed_amount_base)) self.assertEqual(order_json["executed_amount_quote"], str(order.executed_amount_quote)) self.assertEqual(order_json["last_state"], str(order.current_state.value)) self.assertEqual(order_json["leverage"], str(order.leverage)) self.assertEqual(order_json["position"], order.position.value) self.assertEqual(order_json["creation_timestamp"], order.creation_timestamp) self.assertEqual(order_json["order_fills"], {"1": trade_update.to_json()})
async def _process_trade_message(self, trade_msg: Dict[str, Any]): """ Updates in-flight order and trigger order filled event for trade message received. Triggers order completed event if the total executed amount equals to the specified order amount. """ for order in self._in_flight_orders.values(): await order.get_exchange_order_id() track_order = [o for o in self._in_flight_orders.values() if trade_msg["order_id"] == o.exchange_order_id] if not track_order: return tracked_order = track_order[0] updated = tracked_order.update_with_trade_update(trade_msg) if not updated: return self.trigger_event( MarketEvent.OrderFilled, OrderFilledEvent( self.current_timestamp, tracked_order.client_order_id, tracked_order.trading_pair, tracked_order.trade_type, tracked_order.order_type, Decimal(str(trade_msg["traded_price"])), Decimal(str(trade_msg["traded_quantity"])), AddedToCostTradeFee( flat_fees=[TokenAmount(trade_msg["fee_currency"], Decimal(str(trade_msg["fee"])))] ), exchange_trade_id=str(trade_msg.get("trade_id", int(self._time() * 1e6))) ) ) if math.isclose(tracked_order.executed_amount_base, tracked_order.amount) or \ tracked_order.executed_amount_base >= tracked_order.amount: tracked_order.last_state = "FILLED" self.logger().info(f"The {tracked_order.trade_type.name} order " f"{tracked_order.client_order_id} has completed " f"according to order status API.") event_tag = MarketEvent.BuyOrderCompleted if tracked_order.trade_type is TradeType.BUY \ else MarketEvent.SellOrderCompleted event_class = BuyOrderCompletedEvent if tracked_order.trade_type is TradeType.BUY \ else SellOrderCompletedEvent self.trigger_event(event_tag, event_class(self.current_timestamp, tracked_order.client_order_id, tracked_order.base_asset, tracked_order.quote_asset, tracked_order.executed_amount_base, tracked_order.executed_amount_quote, tracked_order.order_type)) self.stop_tracking_order(tracked_order.client_order_id)
def test_collect_metrics_for_single_event(self): self.rate_oracle._prices = {"HBOT-USDT": Decimal("100")} event = OrderFilledEvent( timestamp=1000, order_id="OID1", trading_pair="COINALPHA-HBOT", trade_type=TradeType.BUY, order_type=OrderType.LIMIT, price=Decimal(1000), amount=Decimal(1), trade_fee=AddedToCostTradeFee(), ) self.async_run_with_timeout( self.metrics_collector.collect_metrics([event])) expected_dispatch_request = { "url": f"{self.metrics_collector_url}/client_metrics", "method": "POST", "request_obj": { "headers": { 'Content-Type': "application/json" }, "data": json.dumps({ "source": "hummingbot", "name": TradeVolumeMetricCollector.METRIC_NAME, "instance_id": self.instance_id, "exchange": self.connector_name, "version": self.client_version, "system": f"{platform.system()} {platform.release()}({platform.platform()})", "value": str(event.amount * event.price * 100) }), "params": { "ddtags": f"instance_id:{self.instance_id}," f"client_version:{self.client_version}," f"type:metrics", "ddsource": "hummingbot-client" } } } self.dispatcher_mock.request.assert_called() dispatched_metric = self.dispatcher_mock.request.call_args[0][0] self.assertEqual(expected_dispatch_request, dispatched_metric)
def order_filled_event_from_binance_execution_report(cls, execution_report: Dict[str, any]) -> "OrderFilledEvent": execution_type: str = execution_report.get("x") if execution_type != "TRADE": raise ValueError(f"Invalid execution type '{execution_type}'.") return OrderFilledEvent( execution_report["E"] * 1e-3, execution_report["c"], execution_report["s"], TradeType.BUY if execution_report["S"] == "BUY" else TradeType.SELL, OrderType[execution_report["o"]], Decimal(execution_report["L"]), Decimal(execution_report["l"]), AddedToCostTradeFee(flat_fees=[TokenAmount(execution_report["N"], Decimal(execution_report["n"]))]), exchange_trade_id=execution_report["t"] )
def test_process_order_fill_event_sell_no_initial_cost_set(self): amount = Decimal("1") price = Decimal("9000") event = OrderFilledEvent( timestamp=1, order_id="order1", trading_pair=self.trading_pair, trade_type=TradeType.SELL, order_type=OrderType.LIMIT, price=price, amount=amount, trade_fee=AddedToCostTradeFee(percent=Decimal("0"), flat_fees=[]), ) with self.assertRaises(RuntimeError): self.delegate.process_order_fill_event(event)
def get_fee(self, base_currency: str, quote_currency: str, order_type: OrderType, order_side: TradeType, amount: Decimal, price: Decimal = s_decimal_NaN, is_maker: Optional[bool] = None) -> AddedToCostTradeFee: """ To get trading fee, this function is simplified by using fee override configuration. Most parameters to this function are ignore except order_type. Use OrderType.LIMIT_MAKER to specify you want trading fee for maker order. """ is_maker = order_type is OrderType.LIMIT_MAKER return AddedToCostTradeFee(percent=self.estimate_fee_pct(is_maker))
def test_budget_allocation(self, estimate_fee_mock): """ Liquidity mining strategy budget allocation is different from pmm, it depends on the token base and it splits its budget between the quote tokens. """ estimate_fee_mock.return_value = AddedToCostTradeFee( percent=0, flat_fees=[TokenAmount('ETH', Decimal(0.00005))] ) # initiate usdt_balance = 1000 busd_balance = 900 eth_balance = 100 btc_balance = 10 trading_pairs = list(map(lambda quote_asset: "ETH-" + quote_asset, ["USDT", "BUSD", "BTC"])) market, market_infos = self.create_market(trading_pairs, 100, {"USDT": usdt_balance, "BUSD": busd_balance, "ETH": eth_balance, "BTC": btc_balance}) strategy = LiquidityMiningStrategy() strategy.init_params( exchange=market, market_infos=market_infos, token="ETH", order_amount=Decimal(2), spread=Decimal(0.0005), inventory_skew_enabled=False, target_base_pct=Decimal(0.5), order_refresh_time=5, order_refresh_tolerance_pct=Decimal(0.1), # tolerance of 10 % change ) self.clock.add_iterator(strategy) self.clock.backtest_til(self.start_timestamp + 10) # there should be a buy and sell budget for each pair self.assertEqual(len(strategy.sell_budgets), 3) self.assertEqual(len(strategy.buy_budgets), 3) # the buy budgets use all of the available balance for the quote tokens self.assertEqual(strategy.buy_budgets["ETH-USDT"], usdt_balance) self.assertEqual(strategy.buy_budgets["ETH-BTC"], btc_balance) self.assertEqual(strategy.buy_budgets["ETH-BUSD"], busd_balance) # the sell budget tries to evenly split the base token between the quote tokens self.assertLess(strategy.sell_budgets["ETH-USDT"], eth_balance * 0.4) self.assertLess(strategy.sell_budgets["ETH-BTC"], eth_balance * 0.4) self.assertLess(strategy.sell_budgets["ETH-BUSD"], eth_balance * 0.4)
def test_fill_events_created_from_order_book_rows_have_unique_trade_ids( self): rows = [ OrderBookRow(Decimal(1000), Decimal(1), 1), OrderBookRow(Decimal(1001), Decimal(2), 2) ] fill_events = OrderFilledEvent.order_filled_events_from_order_book_rows( timestamp=1640001112.223, order_id="OID1", trading_pair="COINALPHA-HBOT", trade_type=TradeType.BUY, order_type=OrderType.LIMIT, trade_fee=AddedToCostTradeFee(), order_book_rows=rows) self.assertEqual("OID1_0", fill_events[0].exchange_trade_id) self.assertEqual("OID1_1", fill_events[1].exchange_trade_id)
def _get_fee(self, base_currency: str, quote_currency: str, order_type: OrderType, order_side: TradeType, amount: Decimal, price: Decimal = s_decimal_NaN, is_maker: Optional[bool] = None) -> TradeFeeBase: """ Calculates the estimated fee an order would pay based on the connector configuration :param base_currency: the order base currency :param quote_currency: the order quote currency :param order_type: the type of order (MARKET, LIMIT, LIMIT_MAKER) :param order_side: if the order is for buying or selling :param amount: the order amount :param price: the order price :param is_maker: if we take into account maker fee (True) or taker fee (None, False) :return: the estimated fee for the order """ trading_pair = combine_to_hb_trading_pair(base=base_currency, quote=quote_currency) fee_schema = self._trading_fees.get(trading_pair, None) if fee_schema is None: self.logger().warning( f"For trading pair = {trading_pair} there is no fee schema loaded, using presets!" ) fee = build_trade_fee(exchange=self.name, is_maker=is_maker, base_currency=base_currency, quote_currency=quote_currency, order_type=order_type, order_side=order_side, amount=amount, price=price) else: if fee_schema.type == LatokenTakeType.PROPORTION or fee_schema.take == LatokenCommissionType.PERCENT: pass # currently not implemented but is nice to have in next release(s) percent = fee_schema.maker_fee if order_type is OrderType.LIMIT_MAKER or ( is_maker is not None and is_maker) else fee_schema.taker_fee fee = AddedToCostTradeFee( percent=percent ) if order_side == TradeType.BUY else DeductedFromReturnsTradeFee( percent=percent) return fee
def test_multiple_markets(self, estimate_fee_mock): """ Liquidity Mining supports one base asset but multiple quote assets. This shows that the user can successfully provide liquidity for two different pairs and the market can execute the other side of them. """ estimate_fee_mock.return_value = AddedToCostTradeFee( percent=0, flat_fees=[TokenAmount('ETH', Decimal(0.00005))]) # initiate self.clock.add_iterator(self.default_strategy) self.clock.backtest_til(self.start_timestamp + self.clock_tick_size) # ETH-USDT self.simulate_maker_market_trade(False, 50, 1, "ETH-USDT") self.clock.backtest_til(self.start_timestamp + 8) # ETH-BTC self.simulate_maker_market_trade(False, 50, 1, "ETH-BTC") self.clock.backtest_til(self.start_timestamp + 16)
def test_attribute_names_for_file_export_are_valid(self): trade_fill = TradeFill(config_file_path=self.config_file_path, strategy=self.strategy_name, market=self.display_name, symbol=self.symbol, base_asset=self.base, quote_asset=self.quote, timestamp=int(time.time()), order_id="OID1", trade_type=TradeType.BUY.name, order_type=OrderType.LIMIT.name, price=Decimal(1000), amount=Decimal(1), leverage=1, trade_fee=AddedToCostTradeFee().to_json(), exchange_trade_id="EOID1", position="NILL") values = [ getattr(trade_fill, attribute) for attribute in TradeFill.attribute_names_for_file_export() ] expected_values = [ trade_fill.exchange_trade_id, trade_fill.config_file_path, trade_fill.strategy, trade_fill.market, trade_fill.symbol, trade_fill.base_asset, trade_fill.quote_asset, trade_fill.timestamp, trade_fill.order_id, trade_fill.trade_type, trade_fill.order_type, trade_fill.price, trade_fill.amount, trade_fill.leverage, trade_fill.trade_fee, trade_fill.position, ] self.assertEqual(expected_values, values)
def test_calculate_fees_in_quote_for_one_trade_fill_with_fees_different_tokens( self): rate_oracle = RateOracle() rate_oracle._prices["DAI-COINALPHA"] = Decimal("2") rate_oracle._prices["USDT-DAI"] = Decimal("0.9") RateOracle._shared_instance = rate_oracle performance_metric = PerformanceMetrics() flat_fees = [ TokenAmount(token="USDT", amount=Decimal("10")), TokenAmount(token="DAI", amount=Decimal("5")), ] trade = TradeFill( config_file_path="some-strategy.yml", strategy="pure_market_making", market="binance", symbol="HBOT-COINALPHA", base_asset="HBOT", quote_asset="COINALPHA", timestamp=int(time.time()), order_id="someId0", trade_type="BUY", order_type="LIMIT", price=1000, amount=1, trade_fee=AddedToCostTradeFee(percent=Decimal("0.1"), percent_token="COINALPHA", flat_fees=flat_fees).to_json(), exchange_trade_id="someExchangeId0", position=PositionAction.NIL.value, ) self.async_run_with_timeout( performance_metric._calculate_fees(quote="COINALPHA", trades=[trade])) expected_fee_amount = Decimal(str(trade.amount)) * Decimal( str(trade.price)) * Decimal("0.1") expected_fee_amount += flat_fees[0].amount * Decimal("0.9") * Decimal( "2") expected_fee_amount += flat_fees[1].amount * Decimal("2") self.assertEqual(expected_fee_amount, performance_metric.fee_in_quote)
def get_fee(self, base_currency: str, quote_currency: str, order_type: OrderType, order_side: TradeType, amount: Decimal, price: Decimal = s_decimal_NaN, is_maker: Optional[bool] = None) -> AddedToCostTradeFee: """ Calculates the fee to pay based on the fee information provided by the exchange for the account and the token pair. If exchange info is not available it calculates the estimated fee an order would pay based on the connector configuration :param base_currency: the order base currency :param quote_currency: the order quote currency :param order_type: the type of order (MARKET, LIMIT, LIMIT_MAKER) :param order_side: if the order is for buying or selling :param amount: the order amount :param price: the order price :param is_maker: True if the order is a maker order, False if it is a taker order :return: the calculated or estimated fee """ is_maker = is_maker or (order_type is OrderType.LIMIT_MAKER) trading_pair = combine_to_hb_trading_pair(base=base_currency, quote=quote_currency) if trading_pair in self._trading_fees: fees_data = self._trading_fees[trading_pair] fee_value = Decimal(fees_data["makerFeeRate"]) if is_maker else Decimal(fees_data["takerFeeRate"]) fee = AddedToCostTradeFee(percent=fee_value) else: fee = build_trade_fee( self.name, is_maker, base_currency=base_currency, quote_currency=quote_currency, order_type=order_type, order_side=order_side, amount=amount, price=price, ) return fee
async def _trigger_order_fill(self, tracked_order: AltmarketsInFlightOrder, update_msg: Dict[str, Any]): executed_price = Decimal(str(update_msg.get("price") if update_msg.get("price") is not None else update_msg.get("avg_price", "0"))) self.trigger_event( MarketEvent.OrderFilled, OrderFilledEvent( self.current_timestamp, tracked_order.client_order_id, tracked_order.trading_pair, tracked_order.trade_type, tracked_order.order_type, executed_price, tracked_order.executed_amount_base, AddedToCostTradeFee(percent=update_msg["trade_fee"]), update_msg.get("exchange_trade_id", update_msg.get("id", update_msg.get("order_id"))) ) ) if math.isclose(tracked_order.executed_amount_base, tracked_order.amount) or \ tracked_order.executed_amount_base >= tracked_order.amount or \ (not tracked_order.is_cancelled and tracked_order.is_done): tracked_order.last_state = "done" self.logger().info(f"The {tracked_order.trade_type.name} order " f"{tracked_order.client_order_id} has completed " f"according to order status API.") event_tag = MarketEvent.BuyOrderCompleted if tracked_order.trade_type is TradeType.BUY \ else MarketEvent.SellOrderCompleted event_class = BuyOrderCompletedEvent if tracked_order.trade_type is TradeType.BUY \ else SellOrderCompletedEvent self.trigger_event(event_tag, event_class(self.current_timestamp, tracked_order.client_order_id, tracked_order.base_asset, tracked_order.quote_asset, tracked_order.fee_asset, tracked_order.executed_amount_base, tracked_order.executed_amount_quote, tracked_order.fee_paid, tracked_order.order_type)) self.stop_tracking_order(tracked_order.client_order_id)
def get_fee( self, base_currency: str, quote_currency: str, order_type: OrderType, order_side: TradeType, amount: Decimal, price: Decimal = s_decimal_NaN, is_maker: Optional[bool] = None ) -> AddedToCostTradeFee: """For more information: https://ascendex.github.io/ascendex-pro-api/#place-order.""" trading_pair = f"{base_currency}-{quote_currency}" trading_rule = self._trading_rules[trading_pair] fee_percent = Decimal("0") if order_side == TradeType.BUY: if trading_rule.commission_type == AscendExCommissionType.QUOTE: fee_percent = trading_rule.commission_reserve_rate elif trading_rule.commission_type == AscendExCommissionType.BASE: fee_percent = trading_rule.commission_reserve_rate return AddedToCostTradeFee(percent=fee_percent)
def test_simulate_maker_market_trade(self, estimate_fee_mock): """ Test that we can set up a liquidity mining strategy, and a trade """ estimate_fee_mock.return_value = AddedToCostTradeFee( percent=0, flat_fees=[TokenAmount('ETH', Decimal(0.00005))]) # initiate self.clock.add_iterator(self.default_strategy) self.clock.backtest_til(self.start_timestamp) # assert that there are no active trades on initialization and before clock has moved forward self.assertEqual(0, len(self.default_strategy.active_orders)) # advance by one tick, the strategy will initiate two orders per pair self.clock.backtest_til(self.start_timestamp + self.clock_tick_size) self.assertEqual(4, len(self.default_strategy.active_orders)) # assert that a buy and sell order is made for each pair self.assertTrue( self.has_limit_order(self.default_strategy.active_orders, 'ETH-USDT', True, Decimal(99.95), Decimal(2.0))) self.assertTrue( self.has_limit_order(self.default_strategy.active_orders, 'ETH-USDT', False, Decimal(100.05), Decimal(2.0))) self.assertTrue( self.has_limit_order(self.default_strategy.active_orders, 'ETH-BTC', True, Decimal(99.95), Decimal(1.0005))) self.assertTrue( self.has_limit_order(self.default_strategy.active_orders, 'ETH-BTC', False, Decimal(100.05), Decimal(2))) # Simulate buy order fill self.clock.backtest_til(self.start_timestamp + 8) self.simulate_maker_market_trade(False, Decimal("50"), Decimal("1"), "ETH-USDT") self.assertEqual(3, len(self.default_strategy.active_orders))
def _trigger_order_fill(self, tracked_order: GateIoInFlightOrder, update_msg: Dict[str, Any]): self.trigger_event( MarketEvent.OrderFilled, OrderFilledEvent( self.current_timestamp, tracked_order.client_order_id, tracked_order.trading_pair, tracked_order.trade_type, tracked_order.order_type, Decimal( str( update_msg.get("fill_price", update_msg.get("price", "0")))), tracked_order.executed_amount_base, AddedToCostTradeFee(flat_fees=[ TokenAmount(tracked_order.fee_asset, tracked_order.fee_paid) ]), str(update_msg.get("update_time_ms", update_msg.get("id"))))) if math.isclose(tracked_order.executed_amount_base, tracked_order.amount) or \ tracked_order.executed_amount_base >= tracked_order.amount or \ tracked_order.is_done: tracked_order.last_state = "FILLED" self.logger().info( f"The {tracked_order.trade_type.name} order " f"{tracked_order.client_order_id} has completed " f"according to order status API.") event_tag = MarketEvent.BuyOrderCompleted if tracked_order.trade_type is TradeType.BUY \ else MarketEvent.SellOrderCompleted event_class = BuyOrderCompletedEvent if tracked_order.trade_type is TradeType.BUY \ else SellOrderCompletedEvent self.trigger_event( event_tag, event_class(self.current_timestamp, tracked_order.client_order_id, tracked_order.base_asset, tracked_order.quote_asset, tracked_order.fee_asset, tracked_order.executed_amount_base, tracked_order.executed_amount_quote, tracked_order.fee_paid, tracked_order.order_type, tracked_order.exchange_order_id)) self.stop_tracking_order(tracked_order.client_order_id)
async def _trigger_order_fill(self, tracked_order: CoinzoomInFlightOrder, update_msg: Dict[str, Any]): self.trigger_event( MarketEvent.OrderFilled, OrderFilledEvent( self.current_timestamp, tracked_order.client_order_id, tracked_order.trading_pair, tracked_order.trade_type, tracked_order.order_type, Decimal( str( update_msg.get("averagePrice", update_msg.get("price", "0")))), tracked_order.executed_amount_base, AddedToCostTradeFee(percent=update_msg["trade_fee"]), update_msg.get("exchange_trade_id", update_msg.get("id", update_msg.get("orderId"))))) if math.isclose(tracked_order.executed_amount_base, tracked_order.amount) or \ tracked_order.executed_amount_base >= tracked_order.amount or \ tracked_order.is_done: tracked_order.last_state = "FILLED" self.logger().info( f"The {tracked_order.trade_type.name} order " f"{tracked_order.client_order_id} has completed " f"according to order status API.") event_tag = MarketEvent.BuyOrderCompleted if tracked_order.trade_type is TradeType.BUY \ else MarketEvent.SellOrderCompleted event_class = BuyOrderCompletedEvent if tracked_order.trade_type is TradeType.BUY \ else SellOrderCompletedEvent await asyncio.sleep(0.1) self.trigger_event( event_tag, event_class(self.current_timestamp, tracked_order.client_order_id, tracked_order.base_asset, tracked_order.quote_asset, tracked_order.executed_amount_base, tracked_order.executed_amount_quote, tracked_order.order_type)) self.stop_tracking_order(tracked_order.client_order_id)
def test_update_with_trade_update_duplicate_trade_update(self): order: InFlightOrder = InFlightOrder( client_order_id=self.client_order_id, trading_pair=self.trading_pair, order_type=OrderType.LIMIT, trade_type=TradeType.BUY, amount=Decimal("1000.0"), creation_timestamp=1640001112.0, price=Decimal("1.0"), ) trade_update: TradeUpdate = TradeUpdate( trade_id="someTradeId", client_order_id=self.client_order_id, exchange_order_id=self.exchange_order_id, trading_pair=self.trading_pair, fill_price=Decimal("1.0"), fill_base_amount=Decimal("500.0"), fill_quote_amount=Decimal("500.0"), fee=AddedToCostTradeFee(flat_fees=[ TokenAmount(token=self.quote_asset, amount=self.trade_fee_percent * Decimal("500.0")) ]), fill_timestamp=1, ) self.assertTrue(order.update_with_trade_update(trade_update)) self.assertEqual(order.executed_amount_base, trade_update.fill_base_amount) self.assertEqual(order.executed_amount_quote, trade_update.fill_quote_amount) self.assertEqual(order.last_update_timestamp, trade_update.fill_timestamp) self.assertEqual(1, len(order.order_fills)) self.assertIn(trade_update.trade_id, order.order_fills) # Ignores duplicate trade update self.assertFalse(order.update_with_trade_update(trade_update))
def test_process_order_fill_event_sell(self): amount = Decimal("1") price = Decimal("9000") # Test when no records self.assertIsNone(self.delegate.get_price()) with self.trade_fill_sql.get_new_session() as session: with session.begin(): record = InventoryCost( base_asset=self.base_asset, quote_asset=self.quote_asset, base_volume=amount, quote_volume=amount * price, ) session.add(record) amount_sell = Decimal("0.5") price_sell = Decimal("10000") event = OrderFilledEvent( timestamp=1, order_id="order1", trading_pair=self.trading_pair, trade_type=TradeType.SELL, order_type=OrderType.LIMIT, price=price_sell, amount=amount_sell, trade_fee=AddedToCostTradeFee(percent=Decimal("0"), flat_fees=[]), ) self.delegate.process_order_fill_event(event) with self.trade_fill_sql.get_new_session() as session: record = InventoryCost.get_record(session, self.base_asset, self.quote_asset) # Remaining base volume reduced by sold amount self.assertEqual(record.base_volume, amount - amount_sell) # Remaining quote volume has been reduced using original price self.assertEqual(record.quote_volume, amount_sell * price)
def simulate_limit_order_fill(market: MockPaperExchange, limit_order: LimitOrder): quote_currency_traded: Decimal = limit_order.price * limit_order.quantity base_currency_traded: Decimal = limit_order.quantity quote_currency: str = limit_order.quote_currency base_currency: str = limit_order.base_currency if limit_order.is_buy: market.set_balance( quote_currency, market.get_balance(quote_currency) - quote_currency_traded) market.set_balance( base_currency, market.get_balance(base_currency) + base_currency_traded) else: market.set_balance( quote_currency, market.get_balance(quote_currency) + quote_currency_traded) market.set_balance( base_currency, market.get_balance(base_currency) - base_currency_traded) market.trigger_event( MarketEvent.OrderFilled, OrderFilledEvent( market.current_timestamp, limit_order.client_order_id, limit_order.trading_pair, TradeType.BUY if limit_order.is_buy else TradeType.SELL, OrderType.LIMIT, limit_order.price, limit_order.quantity, AddedToCostTradeFee(Decimal("0")))) event_type = MarketEvent.BuyOrderCompleted if limit_order.is_buy else MarketEvent.SellOrderCompleted event_class = BuyOrderCompletedEvent if limit_order.is_buy else SellOrderCompletedEvent market.trigger_event( event_type, event_class(market.current_timestamp, limit_order.client_order_id, base_currency, quote_currency, quote_currency, base_currency_traded, quote_currency_traded, Decimal("0"), OrderType.LIMIT))
def test_process_tick_starts_metrics_collection_if_activation_interval_reached( self): event = OrderFilledEvent( timestamp=1000, order_id="OID1", trading_pair="COINALPHA-HBOT", trade_type=TradeType.BUY, order_type=OrderType.LIMIT, price=Decimal(1000), amount=Decimal(1), trade_fee=AddedToCostTradeFee(), ) self.metrics_collector._register_fill_event(event) last_executed_collection_process = self.metrics_collector._last_executed_collection_process self.metrics_collector.process_tick(timestamp=15) self.assertEqual(15, self.metrics_collector._last_process_tick_timestamp) self.assertNotEqual( last_executed_collection_process, self.metrics_collector._last_executed_collection_process) self.assertNotIn(event, self.metrics_collector._collected_events)
def test_tolerance_level(self, estimate_fee_mock): """ Test tolerance level """ estimate_fee_mock.return_value = AddedToCostTradeFee( percent=0, flat_fees=[TokenAmount('ETH', Decimal(0.00005))] ) # initiate strategy and add active orders self.clock.add_iterator(self.default_strategy) self.clock.backtest_til(self.start_timestamp + 9) # the order tolerance is 1% # set the orders to the same values proposal = Proposal("ETH-USDT", PriceSize(100, 1), PriceSize(100, 1)) self.assertTrue(self.default_strategy.is_within_tolerance(self.default_strategy.active_orders, proposal)) # update orders to withint the tolerance proposal = Proposal("ETH-USDT", PriceSize(109, 1), PriceSize(91, 1)) self.assertTrue(self.default_strategy.is_within_tolerance(self.default_strategy.active_orders, proposal)) # push the orders beyond the tolerance, this proposal should return False proposal = Proposal("ETH-USDT", PriceSize(150, 1), PriceSize(50, 1)) self.assertFalse(self.default_strategy.is_within_tolerance(self.default_strategy.active_orders, proposal))
def test_performance_metrics_for_derivatives(self, is_trade_fill_mock): rate_oracle = RateOracle() rate_oracle._prices["USDT-HBOT"] = Decimal("5") RateOracle._shared_instance = rate_oracle is_trade_fill_mock.return_value = True trades = [] trades.append( self.mock_trade(id="order1", amount=Decimal("100"), price=Decimal("10"), position="OPEN", type="BUY", fee=AddedToCostTradeFee( flat_fees=[TokenAmount(quote, Decimal("0"))]))) trades.append( self.mock_trade(id="order2", amount=Decimal("100"), price=Decimal("15"), position="CLOSE", type="SELL", fee=AddedToCostTradeFee( flat_fees=[TokenAmount(quote, Decimal("0"))]))) trades.append( self.mock_trade(id="order3", amount=Decimal("100"), price=Decimal("20"), position="OPEN", type="SELL", fee=AddedToCostTradeFee( Decimal("0.1"), flat_fees=[TokenAmount("USD", Decimal("0"))]))) trades.append( self.mock_trade(id="order4", amount=Decimal("100"), price=Decimal("15"), position="CLOSE", type="BUY", fee=AddedToCostTradeFee( Decimal("0.1"), flat_fees=[TokenAmount("USD", Decimal("0"))]))) cur_bals = {base: 100, quote: 10000} metrics = asyncio.get_event_loop().run_until_complete( PerformanceMetrics.create(trading_pair, trades, cur_bals)) self.assertEqual(metrics.num_buys, 2) self.assertEqual(metrics.num_sells, 2) self.assertEqual(metrics.num_trades, 4) self.assertEqual(metrics.b_vol_base, Decimal("200")) self.assertEqual(metrics.s_vol_base, Decimal("-200")) self.assertEqual(metrics.tot_vol_base, Decimal("0")) self.assertEqual(metrics.b_vol_quote, Decimal("-2500")) self.assertEqual(metrics.s_vol_quote, Decimal("3500")) self.assertEqual(metrics.tot_vol_quote, Decimal("1000")) self.assertEqual(metrics.avg_b_price, Decimal("12.5")) self.assertEqual(metrics.avg_s_price, Decimal("17.5")) self.assertEqual(metrics.avg_tot_price, Decimal("15")) self.assertEqual(metrics.start_base_bal, Decimal("100")) self.assertEqual(metrics.start_quote_bal, Decimal("9000")) self.assertEqual(metrics.cur_base_bal, 100) self.assertEqual(metrics.cur_quote_bal, 10000), self.assertEqual(metrics.start_price, Decimal("10")), self.assertEqual(metrics.cur_price, Decimal("0.2")) self.assertEqual(metrics.trade_pnl, Decimal("1000")) self.assertEqual(metrics.total_pnl, Decimal("650"))
def test_update_with_trade_update_multiple_trade_updates(self): order: InFlightOrder = InFlightOrder( client_order_id=self.client_order_id, trading_pair=self.trading_pair, order_type=OrderType.LIMIT, trade_type=TradeType.BUY, amount=Decimal("1000.0"), creation_timestamp=1640001112.0, price=Decimal("1.0"), ) initial_fill_price: Decimal = Decimal("0.5") initial_fill_amount: Decimal = Decimal("500.0") trade_update_1: TradeUpdate = TradeUpdate( trade_id="someTradeId_1", client_order_id=self.client_order_id, exchange_order_id=self.exchange_order_id, trading_pair=self.trading_pair, fill_price=initial_fill_price, fill_base_amount=initial_fill_amount, fill_quote_amount=initial_fill_price * initial_fill_amount, fee=AddedToCostTradeFee( flat_fees=[TokenAmount(token=self.quote_asset, amount=self.trade_fee_percent * initial_fill_amount)]), fill_timestamp=1, ) subsequent_fill_price: Decimal = Decimal("1.0") subsequent_fill_amount: Decimal = Decimal("500.0") trade_update_2: TradeUpdate = TradeUpdate( trade_id="someTradeId_2", client_order_id=self.client_order_id, exchange_order_id=self.exchange_order_id, trading_pair=self.trading_pair, fill_price=subsequent_fill_price, fill_base_amount=subsequent_fill_amount, fill_quote_amount=subsequent_fill_price * subsequent_fill_amount, fee=AddedToCostTradeFee( flat_fees=[TokenAmount(token=self.quote_asset, amount=self.trade_fee_percent * subsequent_fill_amount)]), fill_timestamp=2, ) self.assertTrue(order.update_with_trade_update(trade_update_1)) self.assertIn(trade_update_1.trade_id, order.order_fills) self.assertEqual(order.executed_amount_base, trade_update_1.fill_base_amount) self.assertEqual(order.executed_amount_quote, trade_update_1.fill_quote_amount) self.assertEqual(order.last_update_timestamp, trade_update_1.fill_timestamp) self.assertEqual(1, len(order.order_fills)) self.assertTrue(order.is_open) self.assertTrue(order.update_with_trade_update(trade_update_2)) self.assertIn(trade_update_2.trade_id, order.order_fills) self.assertEqual(order.executed_amount_base, order.amount) self.assertEqual( order.executed_amount_quote, trade_update_1.fill_quote_amount + trade_update_2.fill_quote_amount ) self.assertEqual(order.last_update_timestamp, trade_update_2.fill_timestamp) self.assertEqual(2, len(order.order_fills)) self.assertEqual( order.average_executed_price, (trade_update_1.fill_quote_amount + trade_update_2.fill_quote_amount) / order.amount, ) self.assertTrue(order.is_filled) self.assertEqual(order.current_state, OrderState.PENDING_CREATE)
def test_average_executed_price(self): order_0: InFlightOrder = InFlightOrder( client_order_id=self.client_order_id, trading_pair=self.trading_pair, order_type=OrderType.LIMIT, trade_type=TradeType.BUY, amount=Decimal("1000.0"), creation_timestamp=1640001112.0, price=Decimal("1.0"), ) self.assertIsNone(order_0.average_executed_price) trade_update_0: TradeUpdate = TradeUpdate( trade_id="someTradeId", client_order_id=self.client_order_id, exchange_order_id=self.exchange_order_id, trading_pair=order_0.trading_pair, fill_price=order_0.price, fill_base_amount=order_0.amount, fill_quote_amount=(order_0.price * order_0.amount), fee=AddedToCostTradeFee(flat_fees=[TokenAmount(self.base_asset, Decimal(0.01) * order_0.amount)]), fill_timestamp=time.time(), ) # Order completely filled after single trade update order_0.order_fills.update({trade_update_0.trade_id: trade_update_0}) self.assertEqual(order_0.price, order_0.average_executed_price) order_1: InFlightOrder = InFlightOrder( client_order_id=self.client_order_id, trading_pair=self.trading_pair, order_type=OrderType.LIMIT, trade_type=TradeType.BUY, amount=Decimal("1000.0"), creation_timestamp=1640001112.0, price=Decimal("1.0"), ) trade_update_1: TradeUpdate = TradeUpdate( trade_id="someTradeId_1", client_order_id=self.client_order_id, exchange_order_id=self.exchange_order_id, trading_pair=order_1.trading_pair, fill_price=Decimal("0.5"), fill_base_amount=(order_1.amount / Decimal("2.0")), fill_quote_amount=(order_1.price * (order_1.amount / Decimal("2.0"))), fee=AddedToCostTradeFee( flat_fees=[TokenAmount(self.base_asset, Decimal(0.01) * (order_1.amount / Decimal("2.0")))]), fill_timestamp=time.time(), ) trade_update_2: TradeUpdate = TradeUpdate( trade_id="someTradeId_2", client_order_id=self.client_order_id, exchange_order_id=self.exchange_order_id, trading_pair=order_1.trading_pair, fill_price=order_1.price, fill_base_amount=(order_1.amount / Decimal("2.0")), fill_quote_amount=(order_1.price * (order_1.amount / Decimal("2.0"))), fee=AddedToCostTradeFee( flat_fees=[TokenAmount(self.base_asset, Decimal(0.01) * (order_1.amount / Decimal("2.0")))]), fill_timestamp=time.time(), ) # Order completely filled after 2 trade updates order_1.order_fills.update( { trade_update_1.trade_id: trade_update_1, trade_update_2.trade_id: trade_update_2, } ) expected_average_price = ( sum([order_fill.fill_price * order_fill.fill_base_amount for order_fill in order_1.order_fills.values()]) / order_1.amount ) self.assertEqual(expected_average_price, order_1.average_executed_price)
def simulate_limit_order_fill(market: MockPaperExchange, limit_order: LimitOrder, timestamp: float = 0): quote_currency_traded: Decimal = limit_order.price * limit_order.quantity base_currency_traded: Decimal = limit_order.quantity quote_currency: str = limit_order.quote_currency base_currency: str = limit_order.base_currency trade_event: OrderBookTradeEvent = OrderBookTradeEvent( trading_pair=limit_order.trading_pair, timestamp=timestamp, type=TradeType.BUY if limit_order.is_buy else TradeType.SELL, price=limit_order.price, amount=limit_order.quantity) market.get_order_book( limit_order.trading_pair).apply_trade(trade_event) if limit_order.is_buy: market.set_balance( quote_currency, market.get_balance(quote_currency) - quote_currency_traded) market.set_balance( base_currency, market.get_balance(base_currency) + base_currency_traded) market.trigger_event( MarketEvent.OrderFilled, OrderFilledEvent(market.current_timestamp, limit_order.client_order_id, limit_order.trading_pair, TradeType.BUY, OrderType.LIMIT, limit_order.price, limit_order.quantity, AddedToCostTradeFee(Decimal(0.0)))) market.trigger_event( MarketEvent.BuyOrderCompleted, BuyOrderCompletedEvent(market.current_timestamp, limit_order.client_order_id, base_currency, quote_currency, quote_currency, base_currency_traded, quote_currency_traded, Decimal(0.0), OrderType.LIMIT)) else: market.set_balance( quote_currency, market.get_balance(quote_currency) + quote_currency_traded) market.set_balance( base_currency, market.get_balance(base_currency) - base_currency_traded) market.trigger_event( MarketEvent.OrderFilled, OrderFilledEvent(market.current_timestamp, limit_order.client_order_id, limit_order.trading_pair, TradeType.SELL, OrderType.LIMIT, limit_order.price, limit_order.quantity, AddedToCostTradeFee(Decimal(0.0)))) market.trigger_event( MarketEvent.SellOrderCompleted, SellOrderCompletedEvent(market.current_timestamp, limit_order.client_order_id, base_currency, quote_currency, quote_currency, base_currency_traded, quote_currency_traded, Decimal(0.0), OrderType.LIMIT))
def setUpClass(cls): cls._patcher = unittest.mock.patch( "hummingbot.connector.connector_base.estimate_fee") cls._url_mock = cls._patcher.start() cls._url_mock.return_value = AddedToCostTradeFee(percent=Decimal("0"), flat_fees=[])