Beispiel #1
0
    def test_update_portfolio_with_stop_loss_orders(self):
        config, portfolio_inst, _, trader_inst = self.init_default()

        # Test buy order
        limit_sell = SellLimitOrder(trader_inst)
        limit_sell.new(
            OrderConstants.TraderOrderTypeClasses[TraderOrderType.SELL_LIMIT],
            "BTC/USD", 90, 4, 90)

        # Test buy order
        limit_buy = BuyLimitOrder(trader_inst)
        limit_buy.new(
            OrderConstants.TraderOrderTypeClasses[TraderOrderType.BUY_LIMIT],
            "BTC/USD", 50, 4, 50)

        # Test stop loss order
        stop_loss = StopLossOrder(trader_inst)
        stop_loss.new(
            OrderConstants.TraderOrderTypeClasses[TraderOrderType.STOP_LOSS],
            "BTC/USD", 60, 4, 60)

        fill_limit_or_stop_order(stop_loss, 59, 61)

        portfolio_inst.update_portfolio_available(stop_loss, True)
        portfolio_inst.update_portfolio_available(limit_sell, True)
        portfolio_inst.update_portfolio_available(limit_buy, True)

        assert round(
            portfolio_inst.get_currency_portfolio("BTC", Portfolio.AVAILABLE),
            1) == 6
        assert portfolio_inst.get_currency_portfolio(
            "USD", Portfolio.AVAILABLE) == 800
        assert portfolio_inst.get_currency_portfolio("BTC",
                                                     Portfolio.TOTAL) == 10
        assert portfolio_inst.get_currency_portfolio("USD",
                                                     Portfolio.TOTAL) == 1000

        # cancel limits
        portfolio_inst.update_portfolio_available(limit_buy, False)
        portfolio_inst.update_portfolio_available(limit_sell, False)

        # filling stop loss
        # typical stop loss behavior --> update available before update portfolio
        portfolio_inst.update_portfolio(stop_loss)

        assert portfolio_inst.get_currency_portfolio("BTC",
                                                     Portfolio.AVAILABLE) == 6
        assert portfolio_inst.get_currency_portfolio(
            "USD", Portfolio.AVAILABLE) == 1240
        assert portfolio_inst.get_currency_portfolio("BTC",
                                                     Portfolio.TOTAL) == 6
        assert portfolio_inst.get_currency_portfolio("USD",
                                                     Portfolio.TOTAL) == 1240
Beispiel #2
0
    def test_update_portfolio(self):
        config, portfolio_inst, _, trader_inst = self.init_default()

        # Test buy order
        limit_buy = BuyLimitOrder(trader_inst)
        limit_buy.new(
            OrderConstants.TraderOrderTypeClasses[TraderOrderType.BUY_LIMIT],
            "BTC/USD", 70, 10, 70)

        # update portfolio with creations
        portfolio_inst.update_portfolio_available(limit_buy, True)
        assert portfolio_inst.get_currency_portfolio("BTC",
                                                     Portfolio.AVAILABLE) == 10
        assert portfolio_inst.get_currency_portfolio(
            "USD", Portfolio.AVAILABLE) == 300

        fill_limit_or_stop_order(limit_buy, 69, 71)

        portfolio_inst.update_portfolio(limit_buy)
        assert portfolio_inst.get_currency_portfolio("BTC",
                                                     Portfolio.AVAILABLE) == 20
        assert portfolio_inst.get_currency_portfolio(
            "USD", Portfolio.AVAILABLE) == 300
        assert portfolio_inst.get_currency_portfolio("BTC",
                                                     Portfolio.TOTAL) == 20
        assert portfolio_inst.get_currency_portfolio("USD",
                                                     Portfolio.TOTAL) == 300

        # Test buy order
        market_sell = SellMarketOrder(trader_inst)
        market_sell.new(
            OrderConstants.TraderOrderTypeClasses[TraderOrderType.SELL_MARKET],
            "BTC/USD", 80, 8, 80)

        # update portfolio with creations
        portfolio_inst.update_portfolio_available(market_sell, True)
        assert portfolio_inst.get_currency_portfolio("BTC",
                                                     Portfolio.AVAILABLE) == 12
        assert portfolio_inst.get_currency_portfolio(
            "USD", Portfolio.AVAILABLE) == 300

        fill_market_order(market_sell, 80)

        # when filling market sell
        portfolio_inst.update_portfolio(market_sell)
        assert portfolio_inst.get_currency_portfolio("BTC",
                                                     Portfolio.AVAILABLE) == 12
        assert portfolio_inst.get_currency_portfolio(
            "USD", Portfolio.AVAILABLE) == 940
        assert portfolio_inst.get_currency_portfolio("BTC",
                                                     Portfolio.TOTAL) == 12
        assert portfolio_inst.get_currency_portfolio("USD",
                                                     Portfolio.TOTAL) == 940
Beispiel #3
0
    def test_update_portfolio_with_multiple_filled_orders(self):
        config, portfolio_inst, _, trader_inst = self.init_default()

        # Test buy order
        limit_sell = SellLimitOrder(trader_inst)
        limit_sell.new(
            OrderConstants.TraderOrderTypeClasses[TraderOrderType.SELL_LIMIT],
            "BTC/USD", 90, 4, 90)

        # Test buy order
        limit_buy = BuyLimitOrder(trader_inst)
        limit_buy.new(
            OrderConstants.TraderOrderTypeClasses[TraderOrderType.BUY_LIMIT],
            "BTC/USD", 60, 2, 60)

        # Test buy order
        limit_buy_2 = BuyLimitOrder(trader_inst)
        limit_buy_2.new(
            OrderConstants.TraderOrderTypeClasses[TraderOrderType.BUY_LIMIT],
            "BTC/USD", 50, 4, 50)

        # Test buy order
        limit_buy_3 = BuyLimitOrder(trader_inst)
        limit_buy_3.new(
            OrderConstants.TraderOrderTypeClasses[TraderOrderType.BUY_LIMIT],
            "BTC/USD", 46, 2, 46)

        # Test buy order
        limit_buy_4 = BuyLimitOrder(trader_inst)
        limit_buy_4.new(
            OrderConstants.TraderOrderTypeClasses[TraderOrderType.BUY_LIMIT],
            "BTC/USD", 41, 1.78, 41)

        # Test buy order
        limit_buy_5 = BuyLimitOrder(trader_inst)
        limit_buy_5.new(
            OrderConstants.TraderOrderTypeClasses[TraderOrderType.BUY_LIMIT],
            "BTC/USD", 0.2122427, 3.72448, 0.2122427)

        # Test buy order
        limit_buy_6 = BuyLimitOrder(trader_inst)
        limit_buy_6.new(
            OrderConstants.TraderOrderTypeClasses[TraderOrderType.BUY_LIMIT],
            "BTC/USD", 430, 1.05, 430)

        # Test sell order
        limit_sell_2 = SellLimitOrder(trader_inst)
        limit_sell_2.new(
            OrderConstants.TraderOrderTypeClasses[TraderOrderType.SELL_LIMIT],
            "BTC/USD", 10, 2, 10)

        # Test stop loss order
        stop_loss_2 = StopLossOrder(trader_inst)
        stop_loss_2.new(
            OrderConstants.TraderOrderTypeClasses[TraderOrderType.STOP_LOSS],
            "BTC/USD", 10, 2, 10)

        # Test sell order
        limit_sell_3 = SellLimitOrder(trader_inst)
        limit_sell_3.new(
            OrderConstants.TraderOrderTypeClasses[TraderOrderType.SELL_LIMIT],
            "BTC/USD", 20, 1, 20)

        # Test stop loss order
        stop_loss_3 = StopLossOrder(trader_inst)
        stop_loss_3.new(
            OrderConstants.TraderOrderTypeClasses[TraderOrderType.STOP_LOSS],
            "BTC/USD", 20, 1, 20)

        # Test sell order
        limit_sell_4 = SellLimitOrder(trader_inst)
        limit_sell_4.new(
            OrderConstants.TraderOrderTypeClasses[TraderOrderType.SELL_LIMIT],
            "BTC/USD", 50, 0.2, 50)

        # Test stop loss order
        stop_loss_4 = StopLossOrder(trader_inst)
        stop_loss_4.new(
            OrderConstants.TraderOrderTypeClasses[TraderOrderType.STOP_LOSS],
            "BTC/USD", 45, 0.2, 45)

        # Test sell order
        limit_sell_5 = SellLimitOrder(trader_inst)
        limit_sell_5.new(
            OrderConstants.TraderOrderTypeClasses[TraderOrderType.SELL_LIMIT],
            "BTC/USD", 11, 0.7, 11)

        # Test stop loss order
        stop_loss_5 = StopLossOrder(trader_inst)
        stop_loss_5.new(
            OrderConstants.TraderOrderTypeClasses[TraderOrderType.STOP_LOSS],
            "BTC/USD", 9, 0.7, 9)

        portfolio_inst.update_portfolio_available(stop_loss_2, True)
        portfolio_inst.update_portfolio_available(stop_loss_3, True)
        portfolio_inst.update_portfolio_available(stop_loss_4, True)
        portfolio_inst.update_portfolio_available(stop_loss_5, True)
        portfolio_inst.update_portfolio_available(limit_sell, True)
        portfolio_inst.update_portfolio_available(limit_sell_2, True)
        portfolio_inst.update_portfolio_available(limit_sell_3, True)
        portfolio_inst.update_portfolio_available(limit_sell_4, True)
        portfolio_inst.update_portfolio_available(limit_sell_5, True)
        portfolio_inst.update_portfolio_available(limit_buy, True)
        portfolio_inst.update_portfolio_available(limit_buy_2, True)
        portfolio_inst.update_portfolio_available(limit_buy_3, True)
        portfolio_inst.update_portfolio_available(limit_buy_4, True)
        portfolio_inst.update_portfolio_available(limit_buy_5, True)
        portfolio_inst.update_portfolio_available(limit_buy_6, True)

        assert round(
            portfolio_inst.get_currency_portfolio("BTC", Portfolio.AVAILABLE),
            1) == 2.1
        assert round(
            portfolio_inst.get_currency_portfolio("USD", Portfolio.AVAILABLE),
            7) == 62.7295063
        assert portfolio_inst.get_currency_portfolio("BTC",
                                                     Portfolio.TOTAL) == 10
        assert portfolio_inst.get_currency_portfolio("USD",
                                                     Portfolio.TOTAL) == 1000

        # cancels
        portfolio_inst.update_portfolio_available(stop_loss_3, False)
        portfolio_inst.update_portfolio_available(stop_loss_5, False)
        portfolio_inst.update_portfolio_available(limit_sell_2, False)
        portfolio_inst.update_portfolio_available(limit_buy, False)
        portfolio_inst.update_portfolio_available(limit_buy_3, False)
        portfolio_inst.update_portfolio_available(limit_buy_5, False)
        portfolio_inst.update_portfolio_available(limit_sell_4, False)

        # filling
        fill_limit_or_stop_order(stop_loss_2, 9, 11)
        fill_limit_or_stop_order(limit_sell, 89, 91)
        fill_limit_or_stop_order(limit_sell_3, 19, 21)
        fill_limit_or_stop_order(limit_buy_2, 49, 51)
        fill_limit_or_stop_order(limit_sell_5, 9, 12)
        fill_limit_or_stop_order(stop_loss_4, 44, 46)
        fill_limit_or_stop_order(limit_buy_4, 40, 42)
        fill_limit_or_stop_order(limit_buy_5, 0.2122426, 0.2122428)
        fill_limit_or_stop_order(limit_buy_6, 429, 431)

        portfolio_inst.update_portfolio(stop_loss_2)
        portfolio_inst.update_portfolio(limit_buy_4)
        portfolio_inst.update_portfolio(limit_sell)
        portfolio_inst.update_portfolio(limit_sell_3)
        portfolio_inst.update_portfolio(limit_buy_2)
        portfolio_inst.update_portfolio(limit_sell_5)
        portfolio_inst.update_portfolio(stop_loss_4)
        portfolio_inst.update_portfolio(limit_buy_5)
        portfolio_inst.update_portfolio(limit_buy_6)

        assert portfolio_inst.get_currency_portfolio(
            "BTC", Portfolio.AVAILABLE) == 12.65448
        assert portfolio_inst.get_currency_portfolio(
            "USD", Portfolio.AVAILABLE) == 692.22
        assert portfolio_inst.get_currency_portfolio(
            "BTC", Portfolio.TOTAL) == 12.65448
        assert round(
            portfolio_inst.get_currency_portfolio("USD", Portfolio.TOTAL),
            7) == 691.4295063
Beispiel #4
0
    def test_update_portfolio_with_some_filled_orders(self):
        config, portfolio_inst, _, trader_inst = self.init_default()

        # Test buy order
        limit_sell = SellLimitOrder(trader_inst)
        limit_sell.new(
            OrderConstants.TraderOrderTypeClasses[TraderOrderType.SELL_LIMIT],
            "BTC/USD", 90, 4, 90)

        # Test buy order
        limit_buy = BuyLimitOrder(trader_inst)
        limit_buy.new(
            OrderConstants.TraderOrderTypeClasses[TraderOrderType.BUY_LIMIT],
            "BTC/USD", 60, 2, 60)

        # Test buy order
        limit_buy_2 = BuyLimitOrder(trader_inst)
        limit_buy_2.new(
            OrderConstants.TraderOrderTypeClasses[TraderOrderType.BUY_LIMIT],
            "BTC/USD", 50, 4, 50)

        # Test sell order
        limit_sell_2 = SellLimitOrder(trader_inst)
        limit_sell_2.new(
            OrderConstants.TraderOrderTypeClasses[TraderOrderType.SELL_LIMIT],
            "BTC/USD", 10, 2, 10)

        # Test stop loss order
        stop_loss_2 = StopLossOrder(trader_inst)
        stop_loss_2.new(
            OrderConstants.TraderOrderTypeClasses[TraderOrderType.STOP_LOSS],
            "BTC/USD", 10, 2, 10)

        # Test sell order
        limit_sell_3 = SellLimitOrder(trader_inst)
        limit_sell_3.new(
            OrderConstants.TraderOrderTypeClasses[TraderOrderType.SELL_LIMIT],
            "BTC/USD", 20, 1, 20)

        # Test stop loss order
        stop_loss_3 = StopLossOrder(trader_inst)
        stop_loss_3.new(
            OrderConstants.TraderOrderTypeClasses[TraderOrderType.STOP_LOSS],
            "BTC/USD", 20, 1, 20)

        portfolio_inst.update_portfolio_available(stop_loss_2, True)
        portfolio_inst.update_portfolio_available(stop_loss_3, True)
        portfolio_inst.update_portfolio_available(limit_sell, True)
        portfolio_inst.update_portfolio_available(limit_sell_2, True)
        portfolio_inst.update_portfolio_available(limit_sell_3, True)
        portfolio_inst.update_portfolio_available(limit_buy, True)
        portfolio_inst.update_portfolio_available(limit_buy_2, True)

        assert round(
            portfolio_inst.get_currency_portfolio("BTC", Portfolio.AVAILABLE),
            1) == 3
        assert portfolio_inst.get_currency_portfolio(
            "USD", Portfolio.AVAILABLE) == 680
        assert portfolio_inst.get_currency_portfolio("BTC",
                                                     Portfolio.TOTAL) == 10
        assert portfolio_inst.get_currency_portfolio("USD",
                                                     Portfolio.TOTAL) == 1000

        # cancels
        portfolio_inst.update_portfolio_available(stop_loss_3, False)
        portfolio_inst.update_portfolio_available(limit_sell_2, False)
        portfolio_inst.update_portfolio_available(limit_buy, False)

        # filling
        fill_limit_or_stop_order(stop_loss_2, 9, 11)
        fill_limit_or_stop_order(limit_sell, 89, 91)
        fill_limit_or_stop_order(limit_sell_3, 19, 21)
        fill_limit_or_stop_order(limit_buy_2, 49, 51)

        portfolio_inst.update_portfolio(stop_loss_2)
        portfolio_inst.update_portfolio(limit_sell)
        portfolio_inst.update_portfolio(limit_sell_3)
        portfolio_inst.update_portfolio(limit_buy_2)

        assert portfolio_inst.get_currency_portfolio("BTC",
                                                     Portfolio.AVAILABLE) == 7
        assert portfolio_inst.get_currency_portfolio(
            "USD", Portfolio.AVAILABLE) == 1200
        assert portfolio_inst.get_currency_portfolio("BTC",
                                                     Portfolio.TOTAL) == 7
        assert portfolio_inst.get_currency_portfolio("USD",
                                                     Portfolio.TOTAL) == 1200
Beispiel #5
0
    def test_update_portfolio_with_filled_orders(self):
        config, portfolio_inst, exchange_inst, trader_inst = self.init_default(
        )

        # force fees => should have consequences
        exchange_inst.config[CONFIG_SIMULATOR][CONFIG_SIMULATOR_FEES] = {
            CONFIG_SIMULATOR_FEES_MAKER: 0.05,
            CONFIG_SIMULATOR_FEES_TAKER: 0.1
        }

        # Test buy order
        market_sell = SellMarketOrder(trader_inst)
        market_sell.new(
            OrderConstants.TraderOrderTypeClasses[TraderOrderType.SELL_MARKET],
            "BTC/USD", 70, 3, 70)

        fill_market_order(market_sell, 70)

        # Test sell order
        limit_sell = SellLimitOrder(trader_inst)
        limit_sell.new(
            OrderConstants.TraderOrderTypeClasses[TraderOrderType.SELL_LIMIT],
            "BTC/USD", 100, 4.2, 100)

        # Test stop loss order
        stop_loss = StopLossOrder(trader_inst)
        stop_loss.new(
            OrderConstants.TraderOrderTypeClasses[TraderOrderType.STOP_LOSS],
            "BTC/USD", 80, 4.2, 80)

        limit_sell.add_linked_order(stop_loss)
        stop_loss.add_linked_order(limit_sell)

        # Test buy order
        limit_buy = BuyLimitOrder(trader_inst)
        limit_buy.new(
            OrderConstants.TraderOrderTypeClasses[TraderOrderType.BUY_LIMIT],
            "BTC/USD", 50, 2, 50)

        fill_limit_or_stop_order(limit_buy, 49, 51)

        # update portfolio with creations
        portfolio_inst.update_portfolio_available(market_sell, True)
        portfolio_inst.update_portfolio_available(limit_sell, True)
        portfolio_inst.update_portfolio_available(stop_loss, True)
        portfolio_inst.update_portfolio_available(limit_buy, True)

        assert portfolio_inst.get_currency_portfolio(
            "BTC", Portfolio.AVAILABLE) == 2.8
        assert portfolio_inst.get_currency_portfolio(
            "USD", Portfolio.AVAILABLE) == 900

        # when cancelling limit sell, market sell and stop orders
        portfolio_inst.update_portfolio_available(stop_loss, False)
        portfolio_inst.update_portfolio_available(limit_sell, False)

        assert portfolio_inst.get_currency_portfolio("BTC",
                                                     Portfolio.AVAILABLE) == 7
        assert portfolio_inst.get_currency_portfolio(
            "USD", Portfolio.AVAILABLE) == 900

        # when filling limit buy
        portfolio_inst.update_portfolio(limit_buy)

        assert portfolio_inst.get_currency_portfolio(
            "BTC", Portfolio.AVAILABLE) == 8.999
        assert portfolio_inst.get_currency_portfolio(
            "USD", Portfolio.AVAILABLE) == 900
        assert portfolio_inst.get_currency_portfolio("BTC",
                                                     Portfolio.TOTAL) == 11.999
        assert portfolio_inst.get_currency_portfolio("USD",
                                                     Portfolio.TOTAL) == 900

        # when filling market sell
        portfolio_inst.update_portfolio(market_sell)

        assert portfolio_inst.get_currency_portfolio(
            "BTC", Portfolio.AVAILABLE) == 8.999
        assert portfolio_inst.get_currency_portfolio(
            "USD", Portfolio.AVAILABLE) == 1109.79
        assert portfolio_inst.get_currency_portfolio("BTC",
                                                     Portfolio.TOTAL) == 8.999
        assert portfolio_inst.get_currency_portfolio(
            "USD", Portfolio.TOTAL) == 1109.79