From 51093868f85fc11b951002cef7b3e3f8cd5f8a75 Mon Sep 17 00:00:00 2001
From: Vladimir Kamarzin <vvk@vvk.pp.ru>
Date: Mon, 29 Apr 2019 00:22:44 +0500
Subject: [PATCH 01/19] Add example logging.ini

May be used in case someone needs to log RPC exchange on the node side.
---
 tests/node_config/logging.ini | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 tests/node_config/logging.ini

diff --git a/tests/node_config/logging.ini b/tests/node_config/logging.ini
new file mode 100644
index 000000000..1aedcc1e5
--- /dev/null
+++ b/tests/node_config/logging.ini
@@ -0,0 +1,20 @@
+[log.console_appender.stderr]
+stream=std_error
+
+#[log.file_appender.p2p]
+#filename=logs/p2p/p2p.log
+
+[logger.default]
+level=debug
+appenders=stderr
+
+#[logger.p2p]
+#level=debug
+#appenders=stderr
+#
+
+
+#[logger.rpc]
+#level=debug
+#appenders=stderr
+#

From 799549ed1cfdcc17fb94a4225fd97e22c74ec515 Mon Sep 17 00:00:00 2001
From: Vladimir Kamarzin <vvk@vvk.pp.ru>
Date: Thu, 9 May 2019 19:25:03 +0500
Subject: [PATCH 02/19] Add check for correct asset symbol

---
 tests/test_prepared_testnet.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tests/test_prepared_testnet.py b/tests/test_prepared_testnet.py
index b27bf2adf..51912f0f5 100644
--- a/tests/test_prepared_testnet.py
+++ b/tests/test_prepared_testnet.py
@@ -26,8 +26,10 @@ def test_worker_balance(bitshares, accounts):
 def test_asset_base(bitshares, assets):
     a = Asset('MYBASE', full=True, bitshares_instance=bitshares)
     assert a['dynamic_asset_data']['current_supply'] > 1000
+    assert a.symbol == 'MYBASE'
 
 
 def test_asset_quote(bitshares, assets):
     a = Asset('MYQUOTE', full=True, bitshares_instance=bitshares)
     assert a['dynamic_asset_data']['current_supply'] > 1000
+    assert a.symbol == 'MYQUOTE'

From e283a695caa726fca3c7c40e23842cffa52fa7d2 Mon Sep 17 00:00:00 2001
From: Vladimir Kamarzin <vvk@vvk.pp.ru>
Date: Sat, 18 May 2019 21:45:46 +0500
Subject: [PATCH 03/19] Add initial tests for Staggered Orders

---
 tests/conftest.py                             |    4 +
 tests/strategies/staggered_orders/conftest.py |  389 ++++++
 .../staggered_orders/test_pybitshares.py      |    8 +
 .../test_staggered_orders_complex.py          | 1044 +++++++++++++++++
 .../test_staggered_orders_highlevel.py        |  556 +++++++++
 .../test_staggered_orders_init.py             |   36 +
 .../test_staggered_orders_lowlevel.py         |   44 +
 .../test_staggered_orders_unittests.py        |   44 +
 8 files changed, 2125 insertions(+)
 create mode 100644 tests/strategies/staggered_orders/conftest.py
 create mode 100644 tests/strategies/staggered_orders/test_pybitshares.py
 create mode 100644 tests/strategies/staggered_orders/test_staggered_orders_complex.py
 create mode 100644 tests/strategies/staggered_orders/test_staggered_orders_highlevel.py
 create mode 100644 tests/strategies/staggered_orders/test_staggered_orders_init.py
 create mode 100644 tests/strategies/staggered_orders/test_staggered_orders_lowlevel.py
 create mode 100644 tests/strategies/staggered_orders/test_staggered_orders_unittests.py

diff --git a/tests/conftest.py b/tests/conftest.py
index 96ad1d99b..e7148418b 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -123,6 +123,10 @@ def _create_asset(asset, precision):
 @pytest.fixture(scope='session')
 def issue_asset(bitshares):
     """ Issue asset shares to specified account
+
+        :param str asset: asset symbol to issue
+        :param float amount: amount to issue
+        :param str to: account name to receive new shares
     """
 
     def _issue_asset(asset, amount, to):
diff --git a/tests/strategies/staggered_orders/conftest.py b/tests/strategies/staggered_orders/conftest.py
new file mode 100644
index 000000000..4066d73f8
--- /dev/null
+++ b/tests/strategies/staggered_orders/conftest.py
@@ -0,0 +1,389 @@
+import pytest
+import copy
+import time
+import tempfile
+import os
+import logging
+
+from bitshares.amount import Amount
+
+from dexbot.strategies.staggered_orders import Strategy
+
+log = logging.getLogger("dexbot")
+
+MODES = ['mountain', 'valley', 'neutral', 'buy_slope', 'sell_slope']
+
+
+@pytest.fixture(scope='session')
+def assets(create_asset):
+    """ Create some assets with different precision
+    """
+    create_asset('BASEA', 3)
+    create_asset('QUOTEA', 8)
+    create_asset('BASEB', 8)
+    create_asset('QUOTEB', 3)
+
+
+@pytest.fixture(scope='module')
+def base_account(assets, prepare_account):
+    """ Factory to generate random account with pre-defined balances
+    """
+
+    def func():
+        account = prepare_account({'BASEA': 10000, 'QUOTEA': 100, 'BASEB': 10000, 'QUOTEB': 100, 'TEST': 1000})
+        return account
+
+    return func
+
+
+@pytest.fixture
+def account(base_account):
+    """ Prepare worker account with some balance
+    """
+    return base_account()
+
+
+@pytest.fixture
+def account_only_base(assets, prepare_account):
+    """ Prepare worker account with only BASE assets balance
+    """
+    account = prepare_account({'BASEA': 1000, 'BASEB': 1000, 'TEST': 1000})
+    return account
+
+
+@pytest.fixture
+def account_1_sat(assets, prepare_account):
+    """ Prepare worker account to simulate XXX/BTC trading near zero prices
+    """
+    account = prepare_account({'BASEB': 0.02, 'QUOTEB': 10000000, 'TEST': 1000})
+    return account
+
+
+@pytest.fixture(scope='session')
+def so_worker_name():
+    """ Fixture to share Staggered Orders worker name
+    """
+    return 'so-worker'
+
+
+@pytest.fixture(params=[('QUOTEA', 'BASEA'), ('QUOTEB', 'BASEB')])
+def config(request, bitshares, account, so_worker_name):
+    """ Define worker's config with variable assets
+
+        This fixture should be function-scoped to use new fresh bitshares account for each test
+    """
+    worker_name = so_worker_name
+    config = {
+        'node': '{}'.format(bitshares.rpc.url),
+        'workers': {
+            worker_name: {
+                'account': '{}'.format(account),
+                'market': '{}/{}'.format(request.param[0], request.param[1]),
+                'module': 'dexbot.strategies.staggered_orders',
+                'mode': 'valley',
+                'center_price': 100.0,
+                'center_price_dynamic': False,
+                'fee_asset': 'TEST',
+                'lower_bound': 90.0,
+                'spread': 2.0,
+                'increment': 1.0,
+                'upper_bound': 110.0,
+                'operational_depth': 10,
+            }
+        },
+    }
+    return config
+
+
+@pytest.fixture(params=MODES)
+def config_variable_modes(request, config, so_worker_name):
+    """ Test config which tests all modes
+    """
+    worker_name = so_worker_name
+    config = copy.deepcopy(config)
+    config['workers'][worker_name]['mode'] = request.param
+    return config
+
+
+@pytest.fixture
+def config_only_base(config, so_worker_name, account_only_base):
+    """ Config which uses an account with only BASE asset
+    """
+    worker_name = so_worker_name
+    config = copy.deepcopy(config)
+    config['workers'][worker_name]['account'] = account_only_base
+    return config
+
+
+@pytest.fixture
+def config_1_sat(so_worker_name, bitshares, account_1_sat):
+    """ Config to set up a worker on market with center price around 1 sats
+    """
+    worker_name = so_worker_name
+    config = {
+        'node': '{}'.format(bitshares.rpc.url),
+        'workers': {
+            worker_name: {
+                'account': '{}'.format(account_1_sat),
+                'market': 'QUOTEB/BASEB',
+                'module': 'dexbot.strategies.staggered_orders',
+                'mode': 'valley',
+                'center_price': 0.00000001,
+                'center_price_dynamic': False,
+                'fee_asset': 'TEST',
+                'lower_bound': 0.000000002,
+                'spread': 30.0,
+                'increment': 10.0,
+                'upper_bound': 0.00000002,
+                'operational_depth': 10,
+            }
+        },
+    }
+    return config
+
+
+@pytest.fixture
+def base_worker(bitshares, so_worker_name, storage_db):
+    worker_name = so_worker_name
+    workers = []
+
+    def _base_worker(config):
+        worker = Strategy(config=config, name=worker_name, bitshares_instance=bitshares)
+        # Set market center price to avoid calling of maintain_strategy()
+        worker.market_center_price = worker.worker['center_price']
+        log.info('Initialized {} on account {}'.format(worker_name, worker.account.name))
+        workers.append(worker)
+        return worker
+
+    yield _base_worker
+
+    # We need to make sure no orders left after test finished
+    for worker in workers:
+        worker.cancel_all_orders()
+        worker.bitshares.txbuffer.clear()
+        worker.bitshares.bundle = False
+
+
+@pytest.fixture(scope='session')
+def storage_db():
+    """ Prepare custom sqlite database to not mess with main one
+    """
+    from dexbot.storage import sqlDataBaseFile
+
+    fd, sqlDataBaseFile = tempfile.mkstemp()  # noqa: F811
+    yield
+    os.unlink(sqlDataBaseFile)
+
+
+@pytest.fixture
+def worker(base_worker, config):
+    """ Worker to test in single mode (for methods which not required to be tested against all modes)
+    """
+    worker = base_worker(config)
+    return worker
+
+
+@pytest.fixture
+def worker2(base_worker, config_variable_modes):
+    """ Worker to test all modes
+    """
+    worker = base_worker(config_variable_modes)
+    return worker
+
+
+@pytest.fixture
+def init_empty_balances(worker, bitshares):
+    # Defaults are None, which breaks place_virtual_xxx_order()
+    worker.quote_balance = Amount(0, worker.market['quote']['symbol'], bitshares_instance=bitshares)
+    worker.base_balance = Amount(0, worker.market['base']['symbol'], bitshares_instance=bitshares)
+
+
+@pytest.fixture
+def orders1(worker, bitshares, init_empty_balances):
+    """ Place 1 buy+sell real order, and 1 buy+sell virtual orders with prices outside of the range.
+
+        Note: this fixture don't calls refresh.xxx() intentionally!
+    """
+    # Make sure there are no orders
+    worker.cancel_all_orders()
+    # Prices outside of the range
+    buy_price = 1  # price for test_refresh_balances()
+    sell_price = worker.upper_bound + 1
+    # Place real orders
+    worker.place_market_buy_order(10, buy_price)
+    worker.place_market_sell_order(10, sell_price)
+    # Place virtual orders
+    worker.place_virtual_buy_order(10, buy_price)
+    worker.place_virtual_sell_order(10, sell_price)
+    yield worker
+    # Remove orders on teardown
+    worker.cancel_all_orders()
+    worker.virtual_orders = []
+    # Need to wait until trxs will be included into block because several consequent runs of tests which uses this
+    # fixture will cause identical cancel trxs, which is not allowed by the node
+    time.sleep(1.1)
+
+
+@pytest.fixture
+def orders2(worker):
+    """ Place buy+sell real orders near center price
+    """
+    worker.cancel_all_orders()
+    buy_price = worker.market_center_price - 1
+    sell_price = worker.market_center_price + 1
+    # Place real orders
+    worker.place_market_buy_order(1, buy_price)
+    worker.place_market_sell_order(1, sell_price)
+    worker.refresh_orders()
+    worker.refresh_balances()
+    yield worker
+    worker.cancel_all_orders()
+    worker.virtual_orders = []
+    time.sleep(1.1)
+
+
+@pytest.fixture
+def orders3(worker):
+    """ Place buy+sell virtual orders near center price
+    """
+    worker.cancel_all_orders()
+    worker.refresh_balances()
+    buy_price = worker.market_center_price - 1
+    sell_price = worker.market_center_price + 1
+    # Place virtual orders
+    worker.place_virtual_buy_order(1, buy_price)
+    worker.place_virtual_sell_order(1, sell_price)
+    worker.refresh_orders()
+    yield worker
+    worker.virtual_orders = []
+
+
+@pytest.fixture
+def orders4(worker, orders1):
+    """ Just wrap orders1, but refresh balances in addition
+    """
+    worker.refresh_balances()
+    yield orders1
+
+
+@pytest.fixture
+def orders5(worker2):
+    """ Place buy+sell virtual orders at some distance from center price, and
+        buy+sell real orders at 1 order distance from center
+    """
+    worker = worker2
+
+    worker.cancel_all_orders()
+    worker.refresh_balances()
+
+    # Virtual orders outside of operational depth
+    buy_price = worker.market_center_price / (1 + worker.increment) ** (worker.operational_depth * 2)
+    sell_price = worker.market_center_price * (1 + worker.increment) ** (worker.operational_depth * 2)
+    worker.place_virtual_buy_order(1, buy_price)
+    worker.place_virtual_sell_order(1, sell_price)
+
+    # Virtual orders within operational depth
+    buy_price = worker.market_center_price / (1 + worker.increment) ** (worker.operational_depth // 2)
+    sell_price = worker.market_center_price * (1 + worker.increment) ** (worker.operational_depth // 2)
+    worker.place_virtual_buy_order(1, buy_price)
+    worker.place_virtual_sell_order(1, sell_price)
+
+    # Real orders outside of operational depth
+    buy_price = worker.market_center_price / (1 + worker.increment) ** (worker.operational_depth + 2)
+    sell_price = worker.market_center_price * (1 + worker.increment) ** (worker.operational_depth + 2)
+    worker.place_market_buy_order(1, buy_price)
+    worker.place_market_sell_order(1, sell_price)
+
+    # Real orders at 2 increment distance from the center
+    buy_price = worker.market_center_price / (1 + worker.increment) ** 2
+    sell_price = worker.market_center_price * (1 + worker.increment) ** 2
+    worker.place_market_buy_order(1, buy_price)
+    worker.place_market_sell_order(1, sell_price)
+
+    worker.refresh_orders()
+    yield worker
+    worker.virtual_orders = []
+    worker.cancel_all_orders()
+    time.sleep(1.1)
+
+
+@pytest.fixture
+def partially_filled_order(worker):
+    """ Create partially filled order
+    """
+    worker.cancel_all_orders()
+    order = worker.place_market_buy_order(100, 1, returnOrderId=True)
+    worker.place_market_sell_order(20, 1)
+    worker.refresh_balances()
+    # refresh order
+    order = worker.get_order(order)
+    yield order
+    worker.cancel_all_orders()
+    time.sleep(1.1)
+
+
+@pytest.fixture(scope='session')
+def increase_until_allocated():
+    """ Run increase_order_sizes() until funds are allocated
+
+        :param Strategy worker: worker instance
+    """
+
+    def func(worker):
+        buy_increased = False
+        sell_increased = False
+
+        while not buy_increased or not sell_increased:
+            worker.refresh_orders()
+            worker.refresh_balances(use_cached_orders=True)
+            buy_increased = worker.increase_order_sizes('base', worker.base_balance, worker.buy_orders)
+            sell_increased = worker.increase_order_sizes('quote', worker.quote_balance, worker.sell_orders)
+        worker.refresh_orders()
+        log.info('Increase done')
+
+    return func
+
+
+@pytest.fixture(scope='session')
+def maintain_until_allocated():
+    """ Run maintain_strategy() on a specific worker until funds are allocated
+
+        :param Strategy worker: worker instance
+    """
+
+    def func(worker):
+        # Speed up a little
+        worker.min_check_interval = 0.01
+        worker.current_check_interval = worker.min_check_interval
+        while True:
+            worker.maintain_strategy()
+            if not worker.current_check_interval == worker.min_check_interval:
+                # Use "if" statement instead of putting this into a "while" to avoid waiting max_check_interval on last
+                # run
+                break
+            time.sleep(worker.min_check_interval)
+        log.info('Allocation done')
+
+    return func
+
+
+@pytest.fixture
+def do_initial_allocation(maintain_until_allocated):
+    """ Run maintain_strategy() to make an initial allocation of funds
+
+        :param Strategy worker: initialized worker
+        :param str mode: SO mode (valley, mountain etc)
+    """
+
+    def func(worker, mode):
+        worker.mode = mode
+        worker.cancel_all_orders()
+        maintain_until_allocated(worker)
+        worker.refresh_orders()
+        worker.refresh_balances(use_cached_orders=True)
+        worker.current_check_interval = 0
+        log.info('Initial allocation done')
+
+        return worker
+
+    return func
diff --git a/tests/strategies/staggered_orders/test_pybitshares.py b/tests/strategies/staggered_orders/test_pybitshares.py
new file mode 100644
index 000000000..4f5a54eab
--- /dev/null
+++ b/tests/strategies/staggered_orders/test_pybitshares.py
@@ -0,0 +1,8 @@
+def test_correct_asset_names(orders1):
+    """ Test for https://github.com/bitshares/python-bitshares/issues/239
+    """
+    worker = orders1
+    worker.account.refresh()
+    orders = worker.account.openorders
+    symbols = ['BASEA', 'BASEB', 'QUOTEA', 'QUOTEB']
+    assert orders[0]['base']['asset']['symbol'] in symbols
diff --git a/tests/strategies/staggered_orders/test_staggered_orders_complex.py b/tests/strategies/staggered_orders/test_staggered_orders_complex.py
new file mode 100644
index 000000000..81d862d90
--- /dev/null
+++ b/tests/strategies/staggered_orders/test_staggered_orders_complex.py
@@ -0,0 +1,1044 @@
+import logging
+import pytest
+import math
+
+from datetime import datetime
+from bitshares.account import Account
+from bitshares.amount import Amount
+
+# Turn on debug for dexbot logger
+log = logging.getLogger("dexbot")
+log.setLevel(logging.DEBUG)
+
+MODES = ['mountain', 'valley', 'neutral', 'buy_slope', 'sell_slope']
+
+
+def get_spread(worker):
+    """ Get actual spread on SO worker
+
+        :param Strategy worker: an active worker instance
+    """
+    if worker.buy_orders:
+        highest_buy_price = worker.buy_orders[0].get('price')
+    else:
+        return float('Inf')
+
+    if worker.sell_orders:
+        lowest_sell_price = worker.sell_orders[0].get('price')
+        # Invert the sell price to BASE so it can be used in comparison
+        lowest_sell_price = lowest_sell_price ** -1
+    else:
+        return float('Inf')
+
+    return (lowest_sell_price / highest_buy_price) - 1
+
+
+###################
+# Most complex methods which depends on high-level methods
+###################
+
+
+def test_maintain_strategy_manual_cp_empty_market(worker):
+    """ On empty market, center price should be set to manual CP
+    """
+    worker.cancel_all_orders()
+    # Undefine market_center_price
+    worker.market_center_price = None
+    # Workaround for https://github.com/Codaone/DEXBot/issues/566
+    worker.last_check = datetime(2000, 1, 1)
+    worker.maintain_strategy()
+    assert worker.market_center_price == worker.center_price
+
+
+def test_maintain_strategy_no_manual_cp_empty_market(worker):
+    """ Strategy should not work on empty market if no manual CP was set
+    """
+    worker.cancel_all_orders()
+    # Undefine market_center_price
+    worker.market_center_price = None
+    worker.center_price = None
+    # Workaround for https://github.com/Codaone/DEXBot/issues/566
+    worker.last_check = datetime(2000, 1, 1)
+    worker.maintain_strategy()
+    assert worker.market_center_price is None
+
+
+@pytest.mark.xfail(reason='https://github.com/Codaone/DEXBot/issues/575')
+@pytest.mark.parametrize('mode', MODES)
+def test_maintain_strategy_basic(mode, worker, do_initial_allocation):
+    """ Check if intial orders placement is correct
+    """
+    worker = do_initial_allocation(worker, mode)
+
+    # Check target spread is reached
+    assert worker.actual_spread < worker.target_spread + worker.increment
+
+    # Check number of orders
+    price = worker.center_price * math.sqrt(1 + worker.target_spread)
+    sell_orders_count = worker.calc_sell_orders_count(price, worker.upper_bound)
+    assert len(worker.sell_orders) == sell_orders_count
+
+    price = worker.center_price / math.sqrt(1 + worker.target_spread)
+    buy_orders_count = worker.calc_buy_orders_count(price, worker.lower_bound)
+    assert len(worker.buy_orders) == buy_orders_count
+
+    # Make sure balances are allocated after full maintenance
+    # Unallocated balances are less than closest order amount
+    assert worker.base_balance['amount'] < worker.buy_orders[0]['base']['amount']
+    assert worker.quote_balance['amount'] < worker.sell_orders[0]['base']['amount']
+
+    # Test how ranges are covered
+    # Expect furthest order price to be less than increment x2
+    assert worker.buy_orders[-1]['price'] < worker.lower_bound * (1 + worker.increment * 2)
+    assert worker.sell_orders[-1]['price'] ** -1 > worker.upper_bound / (1 + worker.increment * 2)
+
+
+@pytest.mark.xfail(reason='https://github.com/Codaone/DEXBot/issues/575')
+@pytest.mark.parametrize('mode', MODES)
+def test_maintain_strategy_one_sided(mode, base_worker, config_only_base, do_initial_allocation):
+    """ Test for one-sided start (buy only)
+    """
+    worker = base_worker(config_only_base)
+    do_initial_allocation(worker, mode)
+
+    # Check target spread is reached
+    assert worker.actual_spread < worker.target_spread + worker.increment
+
+    # Check number of orders
+    price = worker.center_price / math.sqrt(1 + worker.target_spread)
+    buy_orders_count = worker.calc_buy_orders_count(price, worker.lower_bound)
+    assert len(worker.buy_orders) == buy_orders_count
+
+    # Make sure balances are allocated after full maintenance
+    # Unallocated balances are less than closest order amount
+    assert worker.base_balance['amount'] < worker.buy_orders[0]['base']['amount']
+
+    # Test how ranges are covered
+    # Expect furthest order price to be less than increment x2
+    assert worker.buy_orders[-1]['price'] < worker.lower_bound * (1 + worker.increment * 2)
+
+
+@pytest.mark.xfail(reason='https://github.com/Codaone/DEXBot/issues/575')
+def test_maintain_strategy_1sat(base_worker, config_1_sat, do_initial_allocation):
+    worker = base_worker(config_1_sat)
+    do_initial_allocation(worker, worker.mode)
+
+    # Check target spread is reached
+    assert worker.actual_spread < worker.target_spread + worker.increment
+
+    # Check number of orders
+    price = worker.center_price * math.sqrt(1 + worker.target_spread)
+    sell_orders_count = worker.calc_sell_orders_count(price, worker.upper_bound)
+    assert len(worker.sell_orders) == sell_orders_count
+
+    price = worker.center_price / math.sqrt(1 + worker.target_spread)
+    buy_orders_count = worker.calc_buy_orders_count(price, worker.lower_bound)
+    assert len(worker.buy_orders) == buy_orders_count
+
+    # Make sure balances are allocated after full maintenance
+    # Unallocated balances are less than closest order amount
+    assert worker.base_balance['amount'] < worker.buy_orders[0]['base']['amount']
+    assert worker.quote_balance['amount'] < worker.sell_orders[0]['base']['amount']
+
+    # Test how ranges are covered
+    # Expect furthest order price to be less than increment x2
+    assert worker.buy_orders[-1]['price'] < worker.lower_bound * (1 + worker.increment * 2)
+    assert worker.sell_orders[-1]['price'] ** -1 > worker.upper_bound / (1 + worker.increment * 2)
+
+
+# Combine each mode with base and quote
+@pytest.mark.parametrize('asset', ['base', 'quote'])
+@pytest.mark.parametrize('mode', MODES)
+def test_maintain_strategy_fallback_logic(asset, mode, worker, do_initial_allocation):
+    """ Check fallback logic: when spread is not reached, furthest order should be cancelled to make free funds to
+        close spread
+    """
+    do_initial_allocation(worker, worker.mode)
+    # TODO: strategy must turn off bootstrapping once target spread is reached
+    worker.bootstrapping = False
+
+    if asset == 'base':
+        worker.cancel_orders_wrapper(worker.buy_orders[0])
+        amount = worker.balance(worker.market['base']['symbol'])
+        worker.bitshares.reserve(amount, account=worker.account)
+    elif asset == 'quote':
+        worker.cancel_orders_wrapper(worker.sell_orders[0])
+        amount = worker.balance(worker.market['quote']['symbol'])
+        worker.bitshares.reserve(amount, account=worker.account)
+
+    worker.refresh_orders()
+    spread_before = get_spread(worker)
+    assert spread_before > worker.target_spread + worker.increment
+
+    for i in range(0, 6):
+        worker.maintain_strategy()
+
+    worker.refresh_orders()
+    spread_after = get_spread(worker)
+    assert spread_after <= worker.target_spread + worker.increment
+
+
+def test_increase_order_sizes_valley_basic(worker, do_initial_allocation, issue_asset, increase_until_allocated):
+    """ Test increases in valley mode when all orders are equal (new allocation round).
+    """
+    do_initial_allocation(worker, 'valley')
+    # Double worker's balance
+    issue_asset(worker.market['base']['symbol'], worker.base_total_balance, worker.account.name)
+    issue_asset(worker.market['quote']['symbol'], worker.quote_total_balance, worker.account.name)
+
+    increase_until_allocated(worker)
+
+    # All orders must be equal-sized
+    for order in worker.buy_orders:
+        assert order['base']['amount'] == worker.buy_orders[0]['base']['amount']
+    for order in worker.sell_orders:
+        assert order['base']['amount'] == worker.sell_orders[0]['base']['amount']
+
+
+def test_increase_order_sizes_valley_direction(worker, do_initial_allocation, issue_asset, increase_until_allocated):
+    """ Test increase direction in valley mode: new allocation round must be started from closest order.
+
+        Buy side, amounts in BASE:
+
+        100 100 100 100 100
+        100 100 100 100 115
+        100 100 100 115 115
+        100 100 115 115 115
+    """
+    do_initial_allocation(worker, 'valley')
+
+    # Add balance to increase several orders
+    increase_factor = max(1 + worker.increment, worker.min_increase_factor)
+    to_issue = worker.buy_orders[0]['base']['amount'] * (increase_factor - 1) * 3
+    issue_asset(worker.market['base']['symbol'], to_issue, worker.account.name)
+    to_issue = worker.sell_orders[0]['base']['amount'] * (increase_factor - 1) * 3
+    issue_asset(worker.market['quote']['symbol'], to_issue, worker.account.name)
+
+    increase_until_allocated(worker)
+
+    for order in worker.buy_orders:
+        assert order['base']['amount'] <= worker.buy_orders[0]['base']['amount']
+    for order in worker.sell_orders:
+        assert order['base']['amount'] <= worker.sell_orders[0]['base']['amount']
+
+
+def test_increase_order_sizes_valley_transit_from_mountain(worker, do_initial_allocation, issue_asset):
+    """ Transition from mountain to valley
+
+        Buy side, amounts in BASE, increase should be like this:
+
+        70 80 90 100 <c>
+        80 80 90 100 <c>
+        80 90 90 100 <c>
+        90 90 90 100 <c>
+    """
+    # Set up mountain
+    do_initial_allocation(worker, 'mountain')
+    # Switch to valley
+    worker.mode = 'valley'
+    # Add balance to increase several orders
+    to_issue = worker.buy_orders[0]['base']['amount'] * 10
+    issue_asset(worker.market['base']['symbol'], to_issue, worker.account.name)
+
+    for _ in range(0, 6):
+        previous_buy_orders = worker.buy_orders
+        worker.refresh_balances()
+        worker.increase_order_sizes('base', worker.base_balance, previous_buy_orders)
+        worker.refresh_orders()
+
+        for i in range(-1, -6, -1):
+            if (
+                previous_buy_orders[i]['base']['amount'] < previous_buy_orders[i - 1]['base']['amount']
+                and previous_buy_orders[i - 1]['base']['amount'] - previous_buy_orders[i]['base']['amount']
+                > previous_buy_orders[i]['base']['amount'] * worker.increment / 2
+            ):
+                # Expect increased order if closer order is bigger than further
+                assert worker.buy_orders[i]['base']['amount'] > previous_buy_orders[i]['base']['amount']
+                # Only one check at a time
+                break
+
+
+def test_increase_order_sizes_valley_smaller_closest_orders(worker, do_initial_allocation, increase_until_allocated):
+    """ Test increase when closest-to-center orders are less than further orders. Normal situation when initial sides
+        are imbalanced and several orders were filled.
+
+        Buy side, amounts in BASE:
+
+        100 100 100 10 10 10 <center>
+    """
+    worker = do_initial_allocation(worker, 'valley')
+    increase_until_allocated(worker)
+
+    # Cancel several closest orders
+    num_orders_to_cancel = 3
+    num_orders_before = len(worker.own_orders)
+    worker.cancel_orders_wrapper(worker.buy_orders[:num_orders_to_cancel])
+    worker.cancel_orders_wrapper(worker.sell_orders[:num_orders_to_cancel])
+    worker.refresh_orders()
+    worker.refresh_balances()
+
+    # Place limited orders
+    initial_base = worker.buy_orders[0]['base']['amount']
+    initial_quote = worker.sell_orders[0]['base']['amount']
+    base_limit = initial_base / 2
+    quote_limit = initial_quote / 2
+    for _ in range(0, num_orders_to_cancel):
+        worker.place_closer_order('base', worker.buy_orders[0], own_asset_limit=base_limit)
+        worker.place_closer_order('quote', worker.sell_orders[0], own_asset_limit=quote_limit)
+        worker.refresh_orders()
+
+    increase_until_allocated(worker)
+
+    # Number of orders should be the same
+    num_orders_after = len(worker.own_orders)
+    assert num_orders_before == num_orders_after
+
+    # New closest orders amount should be equal to initial ones
+    assert worker.buy_orders[0]['base']['amount'] == initial_base
+    assert worker.sell_orders[0]['base']['amount'] == initial_quote
+
+
+@pytest.mark.xfail(reason='https://github.com/Codaone/DEXBot/issues/444')
+def test_increase_order_sizes_valley_imbalaced_small_further(worker, do_initial_allocation, increase_until_allocated):
+    """
+        TODO: test stub for https://github.com/Codaone/DEXBot/pull/484
+
+        Buy side, amounts in BASE:
+
+        5 5 5 100 100 10 10 10 <center>
+
+        Should be:
+
+        10 10 10 100 100 10 10 10 <center>
+    """
+    worker = do_initial_allocation(worker, 'valley')
+
+    # Cancel several closest orders
+    num_orders_to_cancel = 3
+    worker.cancel_orders_wrapper(worker.buy_orders[:num_orders_to_cancel])
+    # Cancel furthest orders
+    worker.cancel_orders_wrapper(worker.buy_orders[-num_orders_to_cancel:])
+    worker.refresh_orders()
+    worker.refresh_balances()
+
+    # Place limited orders
+    initial_base = worker.buy_orders[0]['base']['amount']
+    base_limit = initial_base / 2
+    for i in range(0, num_orders_to_cancel):
+        # Place smaller closer order
+        worker.place_closer_order('base', worker.buy_orders[0], own_asset_limit=base_limit)
+        # place_further_order() doesn't have own_asset_limit, so do own calculation
+        further_order = worker.place_further_order('base', worker.buy_orders[-1], place_order=False)
+        # Place smaller further order
+        to_buy = base_limit / further_order['price']
+        worker.place_market_buy_order(to_buy, further_order['price'])
+        worker.refresh_orders()
+
+    # Drop excess balance, the goal is to keep balance to only increase furthest orders
+    amount = Amount(
+        base_limit * num_orders_to_cancel, worker.market['base']['symbol'], bitshares_instance=worker.bitshares
+    )
+    worker.bitshares.reserve(amount, account=worker.account)
+
+    increase_until_allocated(worker)
+
+    for i in range(1, num_orders_to_cancel):
+        assert worker.buy_orders[-i]['base']['amount'] == worker.buy_orders[i - 1]['base']['amount']
+
+
+@pytest.mark.xfail(reason='https://github.com/Codaone/DEXBot/issues/586')
+def test_increase_order_sizes_valley_closest_order(worker, do_initial_allocation, issue_asset):
+    """ Should test proper calculation of closest order: order should not be less that min_increase_factor
+    """
+    worker = do_initial_allocation(worker, 'valley')
+
+    # Add balance to increase 2 orders
+    increase_factor = max(1 + worker.increment, worker.min_increase_factor)
+    to_issue = worker.buy_orders[0]['base']['amount'] * (increase_factor - 1) * 2
+    issue_asset(worker.market['base']['symbol'], to_issue, worker.account.name)
+
+    previous_buy_orders = worker.buy_orders
+    worker.refresh_balances()
+    worker.increase_order_sizes('base', worker.base_balance, previous_buy_orders)
+    worker.refresh_orders()
+
+    assert worker.buy_orders[0]['base']['amount'] - previous_buy_orders[0]['base']['amount'] >= previous_buy_orders[0][
+        'base'
+    ]['amount'] * (increase_factor - 1)
+
+
+def test_increase_order_sizes_mountain_basic(worker, do_initial_allocation, issue_asset, increase_until_allocated):
+    """ Test increases in mountain mode when all orders are equal (new allocation round). New orders should be equal in
+        their "quote"
+    """
+    do_initial_allocation(worker, 'mountain')
+    increase_until_allocated(worker)
+
+    # Double worker's balance
+    issue_asset(worker.market['base']['symbol'], worker.base_total_balance, worker.account.name)
+    issue_asset(worker.market['quote']['symbol'], worker.quote_total_balance, worker.account.name)
+
+    increase_until_allocated(worker)
+
+    # All orders must be equal-sized in their quote, accept slight error
+    for order in worker.buy_orders:
+        assert order['quote']['amount'] == pytest.approx(
+            worker.buy_orders[0]['quote']['amount'], rel=(1 ** -worker.market['quote']['precision'])
+        )
+    for order in worker.sell_orders:
+        assert order['quote']['amount'] == pytest.approx(
+            worker.sell_orders[0]['quote']['amount'], rel=(1 ** -worker.market['base']['precision'])
+        )
+
+
+def test_increase_order_sizes_mountain_direction(worker, do_initial_allocation, issue_asset):
+    """ Test increase direction in mountain mode
+
+        Buy side, amounts in QUOTE:
+
+        10 10 10 10 10
+        15 10 10 10 10
+        15 15 10 10 10
+        15 15 15 10 10
+    """
+    do_initial_allocation(worker, 'mountain')
+    worker.mode = 'mountain'
+
+    # Double worker's balance
+    issue_asset(worker.market['base']['symbol'], worker.base_total_balance, worker.account.name)
+
+    for _ in range(0, 6):
+        previous_buy_orders = worker.buy_orders
+        worker.refresh_balances()
+        worker.increase_order_sizes('base', worker.base_balance, previous_buy_orders)
+        worker.refresh_orders()
+
+        for i in range(-1, -6, -1):
+            if (
+                previous_buy_orders[i]['quote']['amount'] > previous_buy_orders[i - 1]['quote']['amount']
+                and previous_buy_orders[i]['quote']['amount'] - previous_buy_orders[i - 1]['quote']['amount']
+                > previous_buy_orders[i - 1]['quote']['amount'] * worker.increment / 2
+            ):
+                # Expect increased order if further order is bigger than closer
+                assert worker.buy_orders[i - 1]['quote']['amount'] > previous_buy_orders[i - 1]['quote']['amount']
+                # Only one check at a time
+                break
+
+
+@pytest.mark.xfail(reason='https://github.com/Codaone/DEXBot/issues/585')
+def test_increase_order_sizes_mountain_furthest_order(worker, do_initial_allocation, issue_asset):
+    """ Should test proper calculation of furthest order: try to maximize, don't allow too small increase
+    """
+    do_initial_allocation(worker, 'mountain')
+    worker.mode = 'mountain'
+
+    # Add balance to increase 2 orders
+    increase_factor = max(1 + worker.increment, worker.min_increase_factor)
+    to_issue = worker.buy_orders[0]['base']['amount'] * (increase_factor - 1) * 2
+    issue_asset(worker.market['base']['symbol'], to_issue, worker.account.name)
+
+    previous_buy_orders = worker.buy_orders
+    worker.refresh_balances()
+    worker.increase_order_sizes('base', worker.base_balance, previous_buy_orders)
+    worker.refresh_orders()
+
+    assert worker.buy_orders[-1]['base']['amount'] - previous_buy_orders[-1]['base']['amount'] >= previous_buy_orders[
+        -1
+    ]['base']['amount'] * (increase_factor - 1)
+
+
+def test_increase_order_sizes_mountain_imbalanced(worker, do_initial_allocation):
+    """ Test situation when sides was imbalances, several orders filled on opposite side.
+        This also tests transition from vally to mountain.
+
+        Buy side, amounts in QUOTE:
+
+        100 100 100 10 10 10 <c>
+        100 100 100 20 10 10 <c>
+        100 100 100 20 20 10 <c>
+    """
+    do_initial_allocation(worker, 'mountain')
+    worker.mode = 'mountain'
+
+    # Cancel several closest orders
+    num_orders_to_cancel = 3
+    worker.cancel_orders_wrapper(worker.buy_orders[:num_orders_to_cancel])
+    worker.refresh_orders()
+    worker.refresh_balances()
+
+    # Place limited orders
+    initial_base = worker.buy_orders[0]['base']['amount']
+    base_limit = initial_base / 2
+    # Add own_asset_limit only for first new order
+    worker.place_closer_order('base', worker.buy_orders[0], own_asset_limit=base_limit)
+    for _ in range(1, num_orders_to_cancel):
+        worker.place_closer_order('base', worker.buy_orders[0])
+        worker.refresh_orders()
+
+    for _ in range(0, num_orders_to_cancel):
+        previous_buy_orders = worker.buy_orders
+        worker.refresh_balances()
+        worker.increase_order_sizes('base', worker.base_balance, previous_buy_orders)
+        worker.refresh_orders()
+
+        for order in worker.buy_orders:
+            order_index = worker.buy_orders.index(order)
+
+            if (
+                previous_buy_orders[order_index]['quote']['amount']
+                < previous_buy_orders[order_index + 1]['quote']['amount']
+                and previous_buy_orders[order_index + 1]['base']['amount']
+                - previous_buy_orders[order_index]['base']['amount']
+                > previous_buy_orders[order_index]['base']['amount'] * worker.increment / 2
+            ):
+                # If order before increase was smaller than further order, expect to see it increased
+                assert order['quote']['amount'] > previous_buy_orders[order_index]['quote']['amount']
+                break
+
+
+def test_increase_order_sizes_neutral_basic(worker, do_initial_allocation, issue_asset, increase_until_allocated):
+    """ Test increases in neutral mode when all orders are equal (new allocation round)
+    """
+    do_initial_allocation(worker, 'neutral')
+    increase_until_allocated(worker)
+
+    # Double worker's balance
+    issue_asset(worker.market['base']['symbol'], worker.base_total_balance, worker.account.name)
+    issue_asset(worker.market['quote']['symbol'], worker.quote_total_balance, worker.account.name)
+
+    increase_until_allocated(worker)
+
+    for index, order in enumerate(worker.buy_orders):
+        if index == 0:
+            continue
+        # Assume amounts are equal within some tolerance
+        assert order['base']['amount'] == pytest.approx(
+            worker.buy_orders[index - 1]['base']['amount'] / math.sqrt(1 + worker.increment),
+            rel=(1 ** -worker.market['base']['precision']),
+        )
+    for index, order in enumerate(worker.sell_orders):
+        if index == 0:
+            continue
+        assert order['base']['amount'] == pytest.approx(
+            worker.sell_orders[index - 1]['base']['amount'] / math.sqrt(1 + worker.increment),
+            rel=(1 ** -worker.market['quote']['precision']),
+        )
+
+
+def test_increase_order_sizes_neutral_direction(worker, do_initial_allocation, issue_asset, increase_until_allocated):
+    """ Test increase direction in neutral mode: new allocation round must be started from closest order.
+
+        Buy side, amounts in BASE:
+
+        100 100 100 100 100
+        100 100 100 100 115
+        100 100 100 114 115
+        100 100 113 114 115
+    """
+    do_initial_allocation(worker, 'neutral')
+
+    # Add balance to increase several orders
+    increase_factor = max(1 + worker.increment, worker.min_increase_factor)
+    to_issue = worker.buy_orders[0]['base']['amount'] * (increase_factor - 1) * 3
+    issue_asset(worker.market['base']['symbol'], to_issue, worker.account.name)
+    to_issue = worker.sell_orders[0]['base']['amount'] * (increase_factor - 1) * 3
+    issue_asset(worker.market['quote']['symbol'], to_issue, worker.account.name)
+
+    increase_until_allocated(worker)
+
+    for order in worker.buy_orders:
+        assert order['base']['amount'] <= worker.buy_orders[0]['base']['amount']
+    for order in worker.sell_orders:
+        assert order['base']['amount'] <= worker.sell_orders[0]['base']['amount']
+
+
+def test_increase_order_sizes_neutral_transit_from_mountain(worker, do_initial_allocation, issue_asset):
+    """ Transition from mountain to neutral
+
+        Buy side, amounts in BASE, increase should be like this:
+
+        70 80 90 100 <c>
+        80 80 90 100 <c>
+        80 90 90 100 <c>
+        90 90 90 100 <c>
+    """
+    # Set up mountain
+    do_initial_allocation(worker, 'mountain')
+    # Switch to neutral
+    worker.mode = 'neutral'
+    # Add balance to increase several orders
+    to_issue = worker.buy_orders[0]['base']['amount'] * 10
+    issue_asset(worker.market['base']['symbol'], to_issue, worker.account.name)
+
+    for _ in range(0, 6):
+        previous_buy_orders = worker.buy_orders
+        worker.refresh_balances()
+        worker.increase_order_sizes('base', worker.base_balance, previous_buy_orders)
+        worker.refresh_orders()
+
+        for i in range(-1, -6, -1):
+            if (
+                previous_buy_orders[i]['base']['amount'] < previous_buy_orders[i - 1]['base']['amount']
+                and previous_buy_orders[i - 1]['base']['amount'] - previous_buy_orders[i]['base']['amount']
+                > previous_buy_orders[i]['base']['amount'] * worker.increment / 2
+            ):
+                # Expect increased order if closer order is bigger than further
+                assert worker.buy_orders[i]['base']['amount'] > previous_buy_orders[i]['base']['amount']
+                # Only one check at a time
+                break
+
+
+@pytest.mark.xfail(reason='Closest order failed to increase up to initial balance, fp/rounding issue')
+def test_increase_order_sizes_neutral_smaller_closest_orders(worker, do_initial_allocation, increase_until_allocated):
+    """ Test increase when closest-to-center orders are less than further orders. Normal situation when initial sides
+        are imbalanced and several orders were filled.
+
+        Buy side, amounts in BASE:
+
+        100 100 100 10 10 10 <center>
+    """
+    worker = do_initial_allocation(worker, 'neutral')
+    increase_until_allocated(worker)
+
+    initial_base = worker.buy_orders[0]['base']['amount']
+    initial_quote = worker.sell_orders[0]['base']['amount']
+
+    # Cancel several closest orders
+    num_orders_to_cancel = 3
+    worker.cancel_orders_wrapper(worker.buy_orders[:num_orders_to_cancel])
+    worker.cancel_orders_wrapper(worker.sell_orders[:num_orders_to_cancel])
+    worker.refresh_orders()
+    worker.refresh_balances()
+
+    # Place limited orders
+    base_limit = initial_base / 2
+    quote_limit = initial_quote / 2
+    worker.place_closer_order('base', worker.buy_orders[0], own_asset_limit=base_limit)
+    worker.place_closer_order('quote', worker.sell_orders[0], own_asset_limit=quote_limit)
+    worker.refresh_orders()
+    for i in range(1, num_orders_to_cancel):
+        worker.place_closer_order('base', worker.buy_orders[0])
+        worker.place_closer_order('quote', worker.sell_orders[0])
+        worker.refresh_orders()
+
+    increase_until_allocated(worker)
+
+    # New closest orders amount should be equal to initial ones
+    assert worker.buy_orders[0]['base']['amount'] == initial_base
+    assert worker.sell_orders[0]['base']['amount'] == initial_quote
+
+
+@pytest.mark.xfail(reason='https://github.com/Codaone/DEXBot/issues/444')
+def test_increase_order_sizes_neutral_imbalaced_small_further(worker, do_initial_allocation, increase_until_allocated):
+    """
+        TODO: test stub for https://github.com/Codaone/DEXBot/pull/484
+
+        Buy side, amounts in BASE:
+
+        5 5 5 100 100 10 10 10 <center>
+
+        Should be:
+
+        10 10 10 100 100 10 10 10 <center>
+    """
+    worker = do_initial_allocation(worker, 'neutral')
+    increase_until_allocated(worker)
+
+    # Cancel several closest orders
+    num_orders_to_cancel = 3
+    worker.cancel_orders_wrapper(worker.buy_orders[:num_orders_to_cancel])
+    # Cancel furthest orders
+    worker.cancel_orders_wrapper(worker.buy_orders[-num_orders_to_cancel:])
+    worker.refresh_orders()
+    worker.refresh_balances()
+
+    # Place limited orders
+    initial_base = worker.buy_orders[0]['base']['amount']
+    base_limit = initial_base / 2
+    for i in range(0, num_orders_to_cancel):
+        worker.place_closer_order('base', worker.buy_orders[0], own_asset_limit=base_limit)
+        # place_further_order() doesn't have own_asset_limit, so do own calculation
+        further_order = worker.place_further_order('base', worker.buy_orders[-1], place_order=False)
+        worker.place_market_buy_order(base_limit / further_order['price'], further_order['price'])
+        worker.refresh_orders()
+
+    # Drop excess balance, the goal is to keep balance to only increase furthest orders
+    amount = Amount(
+        base_limit * num_orders_to_cancel, worker.market['base']['symbol'], bitshares_instance=worker.bitshares
+    )
+    worker.bitshares.reserve(amount, account=worker.account)
+
+    increase_until_allocated(worker)
+
+    for i in range(1, num_orders_to_cancel):
+        # TODO: this is a simple check without precise calculation
+        # We're roughly checking that new furthest orders are not exceed new closest orders
+        assert worker.buy_orders[-i]['base']['amount'] < worker.buy_orders[i - 1]['base']['amount']
+
+
+@pytest.mark.xfail(reason='https://github.com/Codaone/DEXBot/issues/586')
+def test_increase_order_sizes_neutral_closest_order(worker, do_initial_allocation, issue_asset):
+    """ Should test proper calculation of closest order: order should not be less that min_increase_factor
+    """
+    worker = do_initial_allocation(worker, 'neutral')
+
+    # Add balance to increase 2 orders
+    increase_factor = max(1 + worker.increment, worker.min_increase_factor)
+    to_issue = worker.buy_orders[0]['base']['amount'] * (increase_factor - 1) * 2
+    issue_asset(worker.market['base']['symbol'], to_issue, worker.account.name)
+
+    previous_buy_orders = worker.buy_orders
+    worker.refresh_balances()
+    worker.increase_order_sizes('base', worker.base_balance, previous_buy_orders)
+    worker.refresh_orders()
+
+    assert worker.buy_orders[0]['base']['amount'] - previous_buy_orders[0]['base']['amount'] >= previous_buy_orders[0][
+        'base'
+    ]['amount'] * (increase_factor - 1)
+
+
+def test_increase_order_sizes_buy_slope(worker, do_initial_allocation, issue_asset, increase_until_allocated):
+    """ Check correct orders sizes on both sides
+    """
+    do_initial_allocation(worker, 'buy_slope')
+
+    # Double worker's balance
+    issue_asset(worker.market['base']['symbol'], worker.base_total_balance, worker.account.name)
+    issue_asset(worker.market['quote']['symbol'], worker.quote_total_balance, worker.account.name)
+
+    increase_until_allocated(worker)
+
+    for order in worker.buy_orders:
+        # All buy orders must be equal-sized in BASE
+        assert order['base']['amount'] == worker.buy_orders[0]['base']['amount']
+    for order in worker.sell_orders:
+        # Sell orders are equal-sized in BASE asset
+        assert order['quote']['amount'] == pytest.approx(
+            worker.sell_orders[0]['quote']['amount'], rel=(1 ** -worker.market['base']['precision'])
+        )
+
+
+def test_increase_order_sizes_sell_slope(worker, do_initial_allocation, issue_asset, increase_until_allocated):
+    """ Check correct orders sizes on both sides
+    """
+    do_initial_allocation(worker, 'sell_slope')
+
+    # Double worker's balance
+    issue_asset(worker.market['base']['symbol'], worker.base_total_balance, worker.account.name)
+    issue_asset(worker.market['quote']['symbol'], worker.quote_total_balance, worker.account.name)
+
+    increase_until_allocated(worker)
+
+    for order in worker.buy_orders:
+        # All buy orders must be equal-sized in market QUOTE
+        assert order['quote']['amount'] == pytest.approx(
+            worker.buy_orders[0]['quote']['amount'], rel=(1 ** -worker.market['quote']['precision'])
+        )
+
+    for order in worker.sell_orders:
+        # All sell orders must be equal-sized in market QUOTE
+        assert order['base']['amount'] == worker.sell_orders[0]['base']['amount']
+
+
+# Note: no other tests for slope modes because they are combined modes. If valley and mountain are ok, so slopes too
+
+
+def test_allocate_asset_basic(worker):
+    """ Check that free balance is shrinking after each allocation and spread is decreasing
+    """
+
+    worker.calculate_asset_thresholds()
+    worker.refresh_balances()
+    spread_after = get_spread(worker)
+
+    # Allocate asset until target spread will be reached
+    while spread_after >= worker.target_spread + worker.increment:
+        free_base = worker.base_balance
+        free_quote = worker.quote_balance
+        spread_before = get_spread(worker)
+
+        worker.allocate_asset('base', free_base)
+        worker.allocate_asset('quote', free_quote)
+        worker.refresh_orders()
+        worker.refresh_balances(use_cached_orders=True)
+        spread_after = get_spread(worker)
+
+        # Update whistory of balance changes
+        worker.base_balance_history.append(worker.base_balance['amount'])
+        worker.quote_balance_history.append(worker.quote_balance['amount'])
+        if len(worker.base_balance_history) > 3:
+            del worker.base_balance_history[0]
+            del worker.quote_balance_history[0]
+
+        # Free balance is shrinking after each allocation
+        assert worker.base_balance < free_base or worker.quote_balance < free_quote
+
+        # Actual spread is decreasing
+        assert spread_after < spread_before
+
+
+def test_allocate_asset_replace_closest_partial_order(worker, do_initial_allocation, base_account, issue_asset):
+    """ Test that partially filled order is replaced when target spread is not reached, before placing closer order
+    """
+    do_initial_allocation(worker, worker.mode)
+    additional_account = base_account()
+
+    # Sell some quote from another account to make PF order on buy side
+    price = worker.buy_orders[0]['price'] / 1.01
+    amount = worker.buy_orders[0]['quote']['amount'] * (1 - worker.partial_fill_threshold * 1.1)
+    worker.market.sell(price, amount, account=additional_account)
+
+    # Fill sell order
+    price = worker.sell_orders[0]['price'] ** -1 * 1.01
+    amount = worker.sell_orders[0]['base']['amount']
+    worker.market.buy(price, amount, account=additional_account)
+
+    # Expect replaced closest buy order
+    worker.refresh_orders()
+    worker.refresh_balances(use_cached_orders=True)
+    worker.allocate_asset('base', worker.base_balance)
+    worker.refresh_orders()
+    assert worker.buy_orders[0]['base']['amount'] == worker.buy_orders[0]['for_sale']['amount']
+
+
+def test_allocate_asset_replace_partially_filled_orders(
+    worker, do_initial_allocation, base_account, issue_asset, maintain_until_allocated
+):
+    """ Check replacement of partially filled orders on both sides. Simple check.
+    """
+    do_initial_allocation(worker, worker.mode)
+    # TODO: automatically turn off bootstrapping after target spread is closed?
+    worker.bootstrapping = False
+    additional_account = base_account()
+
+    # Partially fill closest orders
+    price = worker.buy_orders[0]['price']
+    amount = worker.buy_orders[0]['quote']['amount'] / 2
+    log.debug('Filling {} @ {}'.format(amount, price))
+    worker.market.sell(price, amount, account=additional_account)
+    price = worker.sell_orders[0]['price'] ** -1
+    amount = worker.sell_orders[0]['base']['amount'] / 2
+    log.debug('Filling {} @ {}'.format(amount, price))
+    worker.market.buy(price, amount, account=additional_account)
+
+    # Add some balance to worker
+    to_issue = worker.buy_orders[0]['base']['amount']
+    issue_asset(worker.market['base']['symbol'], to_issue, worker.account.name)
+    to_issue = worker.sell_orders[0]['base']['amount']
+    issue_asset(worker.market['quote']['symbol'], to_issue, worker.account.name)
+
+    maintain_until_allocated(worker)
+    worker.refresh_orders()
+    assert worker.buy_orders[0]['base']['amount'] == worker.buy_orders[0]['for_sale']['amount']
+    assert worker.sell_orders[0]['base']['amount'] == worker.sell_orders[0]['for_sale']['amount']
+
+
+def test_allocate_asset_increase_orders(worker, do_initial_allocation, maintain_until_allocated, issue_asset):
+    """ Add balance, expect increased orders
+    """
+    do_initial_allocation(worker, worker.mode)
+    order_ids = [order['id'] for order in worker.own_orders]
+    balance_in_orders_before = worker.get_allocated_assets(order_ids)
+    to_issue = worker.buy_orders[0]['base']['amount'] * 3
+    issue_asset(worker.market['base']['symbol'], to_issue, worker.account.name)
+    to_issue = worker.sell_orders[0]['base']['amount'] * 3
+    issue_asset(worker.market['quote']['symbol'], to_issue, worker.account.name)
+    # Use maintain_strategy() here for simplicity
+    maintain_until_allocated(worker)
+    order_ids = [order['id'] for order in worker.own_orders]
+    balance_in_orders_after = worker.get_allocated_assets(order_ids)
+    assert balance_in_orders_after['base'] > balance_in_orders_before['base']
+    assert balance_in_orders_after['quote'] > balance_in_orders_before['quote']
+
+
+@pytest.mark.xfail(reason='https://github.com/Codaone/DEXBot/issues/588')
+def test_allocate_asset_dust_order(worker, do_initial_allocation, maintain_until_allocated, base_account):
+    """ Make dust order, check if it canceled and closer opposite order placed
+    """
+    do_initial_allocation(worker, worker.mode)
+    num_sell_orders_before = len(worker.sell_orders)
+    num_buy_orders_before = len(worker.buy_orders)
+    additional_account = base_account()
+    # Partially fill order from another account
+    sell_price = worker.buy_orders[0]['price'] / 1.01
+    sell_amount = worker.buy_orders[0]['quote']['amount'] * (1 - worker.partial_fill_threshold) * 1.1
+    worker.market.sell(sell_price, sell_amount, account=additional_account)
+    worker.refresh_balances()
+    worker.refresh_orders()
+    worker.allocate_asset('quote', worker.quote_balance)
+    worker.refresh_orders()
+    num_sell_orders_after = len(worker.sell_orders)
+    num_buy_orders_after = len(worker.buy_orders)
+
+    assert num_buy_orders_before - num_buy_orders_after == 1
+    assert num_sell_orders_after - num_sell_orders_before == 1
+
+
+@pytest.mark.xfail(reason='https://github.com/Codaone/DEXBot/issues/587')
+def test_allocate_asset_dust_order_increase(worker, do_initial_allocation, base_account, issue_asset):
+    """ Test for https://github.com/Codaone/DEXBot/issues/587
+    """
+    do_initial_allocation(worker, worker.mode)
+    additional_account = base_account()
+    num_buy_orders_before = len(worker.buy_orders)
+
+    # Make closest sell order small enough to be a most likely candidate for increase
+    worker.cancel_orders_wrapper(worker.sell_orders[0])
+    worker.refresh_orders()
+    worker.refresh_balances()
+    worker.place_closer_order(
+        'quote', worker.sell_orders[0], own_asset_limit=(worker.sell_orders[0]['base']['amount'] / 100)
+    )
+    worker.refresh_orders()
+    # Additional balance to overcome reservation
+    to_issue = worker.sell_orders[1]['base']['amount']
+    issue_asset(worker.market['quote']['symbol'], to_issue, worker.account.name)
+    # Partially fill order from another account
+    buy_price = worker.sell_orders[0]['price'] ** -1 * 1.01
+    buy_amount = worker.sell_orders[0]['base']['amount'] * (1 - worker.partial_fill_threshold) * 1.1
+    log.debug('{}, {}'.format(buy_price, buy_amount))
+    worker.market.buy(buy_price, buy_amount, account=additional_account)
+
+    # PF fill sell order should be replaced without errors
+    worker.maintain_strategy()
+    worker.refresh_orders()
+    num_buy_orders_after = len(worker.buy_orders)
+    assert num_buy_orders_before - num_buy_orders_after == 1
+
+
+@pytest.mark.xfail(reason='https://github.com/Codaone/DEXBot/issues/588')
+def test_allocate_asset_filled_orders(worker, do_initial_allocation, base_account):
+    """ Fill an order and check if opposite order placed
+    """
+    do_initial_allocation(worker, worker.mode)
+    # TODO: automatically turn off bootstrapping after target spread is closed?
+    worker.bootstrapping = False
+    additional_account = base_account()
+    num_sell_orders_before = len(worker.sell_orders)
+
+    # Fill sell order
+    price = worker.buy_orders[0]['price']
+    amount = worker.buy_orders[0]['quote']['amount']
+    worker.market.sell(price, amount, account=additional_account)
+    worker.refresh_balances()
+    worker.refresh_orders()
+    worker.allocate_asset('quote', worker.quote_balance)
+    worker.refresh_orders()
+    num_sell_orders_after = len(worker.sell_orders)
+    assert num_sell_orders_after - num_sell_orders_before == 1
+
+
+@pytest.mark.parametrize('mode', MODES)
+def test_allocate_asset_limiting_on_sell_side(mode, worker, do_initial_allocation, base_account):
+    """ Check order size limiting when placing closer order on side which is bigger (using funds obtained from filled
+        orders on side which is smaller)
+    """
+    do_initial_allocation(worker, worker.mode)
+    # TODO: automatically turn off bootstrapping after target spread is closed?
+    worker.bootstrapping = False
+    additional_account = base_account()
+
+    # Fill several orders
+    num_orders_to_fill = 4
+    for i in range(0, num_orders_to_fill):
+        price = worker.buy_orders[i]['price']
+        amount = worker.buy_orders[i]['quote']['amount'] * 1.01
+        log.debug('Filling {} @ {}'.format(amount, price))
+        worker.market.sell(price, amount, account=additional_account)
+
+    # Cancel unmatched dust
+    account = Account(additional_account, bitshares_instance=worker.bitshares)
+    ids = [order['id'] for order in account.openorders if 'id' in order]
+    worker.bitshares.cancel(ids, account=additional_account)
+
+    # Allocate asset until target spread will be reached
+    worker.refresh_orders()
+    worker.refresh_balances(use_cached_orders=True)
+    spread_after = get_spread(worker)
+    counter = 0
+    while spread_after >= worker.target_spread + worker.increment:
+        worker.allocate_asset('base', worker.base_balance)
+        worker.allocate_asset('quote', worker.quote_balance)
+        worker.refresh_orders()
+        worker.refresh_balances(use_cached_orders=True)
+        spread_after = get_spread(worker)
+        counter += 1
+        # Counter is for preventing infinity loop
+        assert counter < 20
+
+    # Check 2 closest orders to match mode
+    if worker.mode == 'valley' or worker.mode == 'sell_slope':
+        assert worker.sell_orders[0]['base']['amount'] == worker.sell_orders[1]['base']['amount']
+    elif worker.mode == 'mountain' or worker.mode == 'buy_slope':
+        assert worker.sell_orders[0]['quote']['amount'] == pytest.approx(
+            worker.sell_orders[1]['quote']['amount'], rel=(1 ** -worker.market['base']['precision'])
+        )
+    elif worker.mode == 'neutral':
+        assert worker.sell_orders[0]['base']['amount'] == pytest.approx(
+            worker.sell_orders[1]['base']['amount'] * math.sqrt(1 + worker.increment),
+            rel=(1 ** -worker.market['quote']['precision']),
+        )
+
+
+@pytest.mark.parametrize('mode', MODES)
+def test_allocate_asset_limiting_on_buy_side(mode, worker, do_initial_allocation, base_account, issue_asset):
+    """ Check order size limiting when placing closer order on side which is bigger (using funds obtained from filled
+        orders on side which is smaller)
+    """
+    worker.center_price = 1
+    worker.lower_bound = 0.4
+    worker.upper_bound = 1.4
+    do_initial_allocation(worker, worker.mode)
+    # TODO: automatically turn off bootstrapping after target spread is closed?
+    worker.bootstrapping = False
+    additional_account = base_account()
+
+    # Fill several orders
+    num_orders_to_fill = 5
+    for i in range(0, num_orders_to_fill):
+        price = worker.sell_orders[i]['price'] ** -1
+        amount = worker.sell_orders[i]['base']['amount'] * 1.01
+        log.debug('Filling {} @ {}'.format(amount, price))
+        worker.market.buy(price, amount, account=additional_account)
+
+    # Cancel unmatched dust
+    account = Account(additional_account, bitshares_instance=worker.bitshares)
+    ids = [order['id'] for order in account.openorders if 'id' in order]
+    worker.bitshares.cancel(ids, account=additional_account)
+
+    # Allocate asset until target spread will be reached
+    worker.refresh_orders()
+    worker.refresh_balances(use_cached_orders=True)
+    spread_after = get_spread(worker)
+    counter = 0
+    while spread_after >= worker.target_spread + worker.increment:
+        worker.allocate_asset('base', worker.base_balance)
+        worker.allocate_asset('quote', worker.quote_balance)
+        worker.refresh_orders()
+        worker.refresh_balances(use_cached_orders=True)
+        spread_after = get_spread(worker)
+        counter += 1
+        # Counter is for preventing infinity loop
+        assert counter < 20
+
+    # Check 2 closest orders to match mode
+    if worker.mode == 'valley' or worker.mode == 'buy_slope':
+        assert worker.buy_orders[0]['base']['amount'] == worker.buy_orders[1]['base']['amount']
+    elif worker.mode == 'mountain' or worker.mode == 'sell_slope':
+        assert worker.buy_orders[0]['quote']['amount'] == pytest.approx(
+            worker.buy_orders[1]['quote']['amount'], rel=(1 ** -worker.market['base']['precision'])
+        )
+    elif worker.mode == 'neutral':
+        assert worker.buy_orders[0]['base']['amount'] == pytest.approx(
+            worker.buy_orders[1]['base']['amount'] * math.sqrt(1 + worker.increment),
+            rel=(1 ** -worker.market['quote']['precision']),
+        )
+
+
+def test_tick(worker):
+    """ Check tick counter increment
+    """
+    counter_before = worker.counter
+    worker.tick('foo')
+    counter_after = worker.counter
+    assert counter_after - counter_before == 1
diff --git a/tests/strategies/staggered_orders/test_staggered_orders_highlevel.py b/tests/strategies/staggered_orders/test_staggered_orders_highlevel.py
new file mode 100644
index 000000000..1a35fc5f8
--- /dev/null
+++ b/tests/strategies/staggered_orders/test_staggered_orders_highlevel.py
@@ -0,0 +1,556 @@
+import logging
+import math
+import pytest
+
+from dexbot.strategies.staggered_orders import VirtualOrder
+
+# Turn on debug for dexbot logger
+logger = logging.getLogger("dexbot")
+logger.setLevel(logging.DEBUG)
+
+
+###################
+# Higher-level methods which depends on lower-level methods
+###################
+
+
+def test_refresh_balances(orders1):
+    """ Check if balance refresh works
+    """
+    worker = orders1
+    worker.refresh_balances()
+    balance = worker.count_asset()
+
+    assert worker.base_balance['amount'] > 0
+    assert worker.quote_balance['amount'] > 0
+    assert worker.base_total_balance == balance['base']
+    assert worker.quote_total_balance == balance['quote']
+
+
+def test_refresh_orders(orders1):
+    """ Make sure orders refresh is working
+
+        Note: this test doesn't checks orders sorting
+    """
+    worker = orders1
+    worker.refresh_orders()
+    assert worker.virtual_buy_orders[0]['base']['amount'] == 10
+    assert worker.virtual_sell_orders[0]['base']['amount'] == 10
+    assert worker.real_buy_orders[0]['base']['amount'] == 10
+    assert worker.real_sell_orders[0]['base']['amount'] == 10
+    assert len(worker.sell_orders) == 2
+    assert len(worker.buy_orders) == 2
+
+
+def test_check_min_order_size(worker):
+    """ Make sure our orders are always match minimal allowed size
+    """
+    worker.calculate_min_amounts()
+    if worker.order_min_quote > worker.order_min_base:
+        # Limiting asset is QUOTE
+        # Intentionally pass amount 2 times lower than minimum, the function should return increased amount
+        corrected_amount = worker.check_min_order_size(worker.order_min_quote / 2, 1)
+        assert corrected_amount == worker.order_min_quote
+    else:
+        # Limiting precision is BASE, at price=1 amounts are the same, so pass 2 times lower amount
+        corrected_amount = worker.check_min_order_size(worker.order_min_base / 2, 1)
+        assert corrected_amount >= worker.order_min_quote
+
+    # Place/cancel real order to ensure no errors from the node
+    worker.place_market_sell_order(corrected_amount, 1, returnOrderId=False)
+    worker.cancel_all_orders()
+
+
+def test_remove_outside_orders(orders1):
+    """ All orders in orders1 fixture are outside of the range, so remove_outside_orders() should cancel all
+    """
+    worker = orders1
+    worker.refresh_orders()
+    assert worker.remove_outside_orders(worker.sell_orders, worker.buy_orders)
+    assert len(worker.sell_orders) == 0
+    assert len(worker.buy_orders) == 0
+
+
+def test_restore_virtual_orders(orders2):
+    """ Very basic test, checks if number of virtual orders at least 2
+    """
+    worker = orders2
+    worker.restore_virtual_orders()
+    assert len(worker.virtual_orders) >= 2
+
+
+def test_replace_real_order_with_virtual(orders2):
+    """ Try to replace 2 furthest orders with virtual, then compare difference
+    """
+    worker = orders2
+    worker.virtual_orders = []
+    num_orders_before = len(worker.real_buy_orders) + len(worker.real_sell_orders)
+    worker.replace_real_order_with_virtual(worker.real_buy_orders[-1])
+    worker.replace_real_order_with_virtual(worker.real_sell_orders[-1])
+    worker.refresh_orders()
+    num_orders_after = len(worker.real_buy_orders) + len(worker.real_sell_orders)
+    assert num_orders_before - num_orders_after == 2
+    assert len(worker.virtual_orders) == 2
+
+
+def test_replace_virtual_order_with_real(orders3):
+    """ Try to replace 2 furthest virtual orders with real orders
+    """
+    worker = orders3
+    num_orders_before = len(worker.virtual_orders)
+    num_real_orders_before = len(worker.own_orders)
+    assert worker.replace_virtual_order_with_real(worker.virtual_buy_orders[-1])
+    assert worker.replace_virtual_order_with_real(worker.virtual_sell_orders[-1])
+    num_orders_after = len(worker.virtual_orders)
+    num_real_orders_after = len(worker.own_orders)
+    assert num_orders_before - num_orders_after == 2
+    assert num_real_orders_after - num_real_orders_before == 2
+
+
+def test_store_profit_estimation_data(worker, storage_db):
+    """ Check if storing of profit estimation data works
+    """
+    worker.refresh_balances()
+    worker.store_profit_estimation_data(force=True)
+    account = worker.worker.get('account')
+    data = worker.get_recent_balance_entry(account, worker.worker_name, worker.base_asset, worker.quote_asset)
+    assert data.center_price == worker.market_center_price
+    assert data.base_total == worker.base_total_balance
+    assert data.quote_total == worker.quote_total_balance
+
+
+def test_check_partial_fill(worker, partially_filled_order):
+    """ Test that check_partial_fill() can detect partially filled order
+    """
+    is_not_partially_filled = worker.check_partial_fill(partially_filled_order, fill_threshold=0)
+    assert not is_not_partially_filled
+    is_not_partially_filled = worker.check_partial_fill(partially_filled_order, fill_threshold=90)
+    assert is_not_partially_filled
+
+
+def test_replace_partially_filled_order(worker, partially_filled_order):
+    """ Test if replace_partially_filled_order() do correct replacement
+    """
+    worker.replace_partially_filled_order(partially_filled_order)
+    new_order = worker.own_orders[0]
+    assert new_order['base']['amount'] == new_order['for_sale']['amount']
+
+
+def test_place_lowest_buy_order(worker2):
+    """ Check if placement of lowest buy order works in general
+    """
+    worker = worker2
+    worker.refresh_balances()
+    worker.place_lowest_buy_order(worker.base_balance)
+    worker.refresh_orders()
+
+    # Expect furthest order price to be less than increment x2
+    assert worker.buy_orders[-1]['price'] < worker.lower_bound * (1 + worker.increment * 2)
+
+
+def test_place_highest_sell_order(worker2):
+    """ Check if placement of highest sell order works in general
+    """
+    worker = worker2
+    worker.refresh_balances()
+    worker.place_highest_sell_order(worker.quote_balance)
+    worker.refresh_orders()
+
+    # Expect furthest order price to be less than increment x2
+    assert worker.sell_orders[-1]['price'] ** -1 > worker.upper_bound / (1 + worker.increment * 2)
+
+
+@pytest.mark.parametrize('asset', ['base', 'quote'])
+def test_place_closer_order_real_or_virtual(orders5, asset):
+    """ Closer order may be real or virtual, depending on distance from the center and operational_depth
+
+        1. Closer order within operational depth must be real
+        2. Closer order outside of operational depth must be virtual if previous order is virtual
+        3. Closer order outside of operational depth must be real if previous order is real
+    """
+    worker = orders5
+    if asset == 'base':
+        virtual_outside = worker.virtual_buy_orders[-1]
+        virtual_within = worker.virtual_buy_orders[0]
+        real_outside = worker.real_buy_orders[-1]
+        real_within = worker.real_buy_orders[0]
+    elif asset == 'quote':
+        virtual_outside = worker.virtual_sell_orders[-1]
+        virtual_within = worker.virtual_sell_orders[0]
+        real_outside = worker.real_sell_orders[-1]
+        real_within = worker.real_sell_orders[0]
+
+    closer_order = worker.place_closer_order(asset, virtual_outside, place_order=True)
+    assert isinstance(
+        closer_order, VirtualOrder
+    ), "Closer order outside of operational depth must be virtual if previous order is virtual"
+
+    # When self.returnOrderId is True, place_market_xxx_order() will return bool
+    closer_order = worker.place_closer_order(asset, virtual_within, place_order=True)
+    assert closer_order, "Closer order within operational depth must be real"
+
+    closer_order = worker.place_closer_order(asset, real_outside, place_order=True)
+    assert closer_order, "Closer order outside of operational depth must be real if previous order is real"
+
+    closer_order = worker.place_closer_order(asset, real_within, place_order=True)
+    assert closer_order, "Closer order within operational depth must be real"
+
+
+@pytest.mark.xfail(reason='https://github.com/bitshares/python-bitshares/issues/227')
+@pytest.mark.parametrize('asset', ['base', 'quote'])
+def test_place_closer_order_price_amount(orders5, asset):
+    """ Test that closer order price and amounts are correct
+    """
+    worker = orders5
+
+    if asset == 'base':
+        order = worker.buy_orders[0]
+    elif asset == 'quote':
+        order = worker.sell_orders[0]
+
+    worker.returnOrderId = True
+    closer_order = worker.place_closer_order(asset, order, place_order=True)
+
+    # Test for correct price
+    assert closer_order['price'] == order['price'] * (1 + worker.increment)
+
+    # Test for correct amount
+    if (
+        worker.mode == 'mountain'
+        or (worker.mode == 'buy_slope' and asset == 'quote')
+        or (worker.mode == 'sell_slope' and asset == 'base')
+    ):
+        assert closer_order['quote']['amount'] == order['quote']['amount']
+    elif (
+        worker.mode == 'valley'
+        or (worker.mode == 'buy_slope' and asset == 'base')
+        or (worker.mode == 'sell_slope' and asset == 'quote')
+    ):
+        assert closer_order['base']['amount'] == order['base']['amount']
+    elif worker.mode == 'neutral':
+        assert closer_order['base']['amount'] == order['base']['amount'] * math.sqrt(1 + worker.increment)
+
+
+@pytest.mark.xfail(reason='https://github.com/bitshares/python-bitshares/issues/227')
+@pytest.mark.parametrize('asset', ['base', 'quote'])
+def test_place_closer_order_no_place_order(orders5, asset):
+    """ Test place_closer_order() with place_order=False kwarg
+    """
+    worker = orders5
+
+    if asset == 'base':
+        order = worker.buy_orders[0]
+    elif asset == 'quote':
+        order = worker.sell_orders[0]
+
+    closer_order = worker.place_closer_order(asset, order, place_order=False)
+    worker.place_closer_order(asset, order, place_order=True)
+    worker.refresh_orders()
+
+    if asset == 'base':
+        real_order = worker.buy_orders[0]
+        price = real_order['price']
+        amount = real_order['quote']['amount']
+    elif asset == 'quote':
+        real_order = worker.sell_orders[0]
+        price = real_order['price'] ** -1
+        amount = real_order['base']['amount']
+
+    assert closer_order['price'] == price
+    assert closer_order['amount'] == amount
+
+
+@pytest.mark.parametrize('asset', ['base', 'quote'])
+def test_place_closer_order_allow_partial_hard_limit(orders2, asset):
+    """ Test place_closer_order with allow_partial=True when avail balance is less than minimal allowed order size
+    """
+    worker = orders2
+
+    if asset == 'base':
+        order = worker.buy_orders[0]
+        price = order['price']
+        # Pretend we have balance smaller than hard limit
+        worker.base_balance['amount'] = worker.check_min_order_size(0, price) / 2
+    elif asset == 'quote':
+        order = worker.sell_orders[0]
+        price = order['price'] ** -1
+        worker.quote_balance['amount'] = worker.check_min_order_size(0, price) / 2
+
+    num_orders_before = len(worker.own_orders)
+    worker.place_closer_order(asset, order, place_order=True, allow_partial=True)
+    num_orders_after = len(worker.own_orders)
+    # Expect that order was not placed
+    assert num_orders_before == num_orders_after
+
+
+@pytest.mark.parametrize('asset', ['base', 'quote'])
+def test_place_closer_order_allow_partial_soft_limit(orders2, asset):
+    """ Test place_closer_order with allow_partial=True when avail balance is less than self.partial_fill_threshold
+        restriction
+    """
+    worker = orders2
+
+    if asset == 'base':
+        order = worker.buy_orders[0]
+        # Pretend we have balance smaller than soft limit
+        worker.base_balance['amount'] = order['base']['amount'] * worker.partial_fill_threshold / 1.1
+    elif asset == 'quote':
+        order = worker.sell_orders[0]
+        worker.quote_balance['amount'] = order['base']['amount'] * worker.partial_fill_threshold / 1.1
+
+    num_orders_before = len(worker.own_orders)
+    worker.place_closer_order(asset, order, place_order=True, allow_partial=True)
+    num_orders_after = len(worker.own_orders)
+    # Expect that order was not placed
+    assert num_orders_before == num_orders_after
+
+
+@pytest.mark.parametrize('asset', ['base', 'quote'])
+def test_place_closer_order_allow_partial(orders2, asset):
+    """ Test place_closer_order with allow_partial=True when avail balance is more than self.partial_fill_threshold
+        restriction (enough for partial order)
+    """
+    worker = orders2
+
+    if asset == 'base':
+        order = worker.buy_orders[0]
+        worker.base_balance['amount'] = order['base']['amount'] * worker.partial_fill_threshold * 2
+    elif asset == 'quote':
+        order = worker.sell_orders[0]
+        worker.quote_balance['amount'] = order['base']['amount'] * worker.partial_fill_threshold * 2
+
+    num_orders_before = len(worker.own_orders)
+    worker.place_closer_order(asset, order, place_order=True, allow_partial=True)
+    num_orders_after = len(worker.own_orders)
+    # Expect order placed
+    assert num_orders_after - num_orders_before == 1
+
+
+@pytest.mark.parametrize('asset', ['base', 'quote'])
+def test_place_closer_order_not_allow_partial(orders2, asset):
+    """ Test place_closer_order with allow_partial=False
+    """
+    worker = orders2
+
+    if asset == 'base':
+        order = worker.buy_orders[0]
+        worker.base_balance['amount'] = order['base']['amount'] * worker.partial_fill_threshold * 2
+    elif asset == 'quote':
+        order = worker.sell_orders[0]
+        worker.quote_balance['amount'] = order['base']['amount'] * worker.partial_fill_threshold * 2
+
+    num_orders_before = len(worker.own_orders)
+    worker.place_closer_order(asset, order, place_order=True, allow_partial=False)
+    num_orders_after = len(worker.own_orders)
+    # Expect that order was not placed
+    assert num_orders_before == num_orders_after
+
+
+@pytest.mark.parametrize('asset', ['base', 'quote'])
+def test_place_closer_order_own_asset_limit(orders5, asset):
+    """ Place closer order with own_asset_limit, test that amount of a new order is matching limit
+    """
+    worker = orders5
+
+    if asset == 'base':
+        order = worker.buy_orders[0]
+    elif asset == 'quote':
+        order = worker.sell_orders[0]
+
+    limit = order['base']['amount'] / 2
+
+    worker.returnOrderId = True
+    closer_order = worker.place_closer_order(asset, order, place_order=True, own_asset_limit=limit)
+    assert closer_order['base']['amount'] == limit
+
+
+@pytest.mark.parametrize('asset', ['base', 'quote'])
+def test_place_closer_order_opposite_asset_limit(orders5, asset):
+    """  Place closer order with opposite_asset_limit, test that amount of a new order is matching limit
+    """
+    worker = orders5
+
+    if asset == 'base':
+        order = worker.buy_orders[0]
+    elif asset == 'quote':
+        order = worker.sell_orders[0]
+
+    limit = order['quote']['amount'] / 2
+
+    worker.returnOrderId = True
+    closer_order = worker.place_closer_order(asset, order, place_order=True, opposite_asset_limit=limit)
+    assert closer_order['quote']['amount'] == limit
+
+
+@pytest.mark.parametrize('asset', ['base', 'quote'])
+def test_place_closer_order_instant_fill_disabled(orders5, asset):
+    """ When instant fill is disabled, new order should not cross lowest ask or highest bid
+    """
+    worker = orders5
+
+    if asset == 'base':
+        order = worker.buy_orders[0]
+    elif asset == 'quote':
+        order = worker.sell_orders[0]
+
+    worker.is_instant_fill_enabled = False
+    # Bump increment so hish that closer order will inevitably cross an opposite one
+    worker.increment = 100
+    result = worker.place_closer_order(asset, order, place_order=True)
+    assert result is None
+
+
+@pytest.mark.parametrize('asset', ['base', 'quote'])
+def test_place_further_order_real_or_virtual(orders5, asset):
+    """ Further order may be real or virtual, depending on distance from the center and operational_depth
+
+        1. Further order within operational depth must be real
+        2. Further order within operational depth must be virtual if virtual=True was given
+        2. Further order outside of operational depth must be virtual
+    """
+    worker = orders5
+    if asset == 'base':
+        real_outside = worker.real_buy_orders[-1]
+        real_within = worker.real_buy_orders[0]
+    elif asset == 'quote':
+        real_outside = worker.real_sell_orders[-1]
+        real_within = worker.real_sell_orders[0]
+
+    further_order = worker.place_further_order(asset, real_within, place_order=True)
+    assert further_order, "Further order within operational depth must be real"
+
+    further_order = worker.place_further_order(asset, real_within, place_order=True, virtual=True)
+    assert isinstance(
+        further_order, VirtualOrder
+    ), "Further order within operational depth must be virtual if virtual=True was given"
+
+    further_order = worker.place_further_order(asset, real_outside, place_order=True)
+    assert isinstance(further_order, VirtualOrder), "Further order outside of operational depth must be virtual"
+
+
+@pytest.mark.xfail(reason='https://github.com/bitshares/python-bitshares/issues/227')
+@pytest.mark.parametrize('asset', ['base', 'quote'])
+def test_place_further_order_price_amount(orders5, asset):
+    """ Test that further order price and amounts are correct
+    """
+    worker = orders5
+
+    if asset == 'base':
+        order = worker.buy_orders[0]
+    elif asset == 'quote':
+        order = worker.sell_orders[0]
+
+    worker.returnOrderId = True
+    further_order = worker.place_further_order(asset, order, place_order=True)
+
+    # Test for correct price
+    assert further_order['price'] == order['price'] / (1 + worker.increment)
+
+    # Test for correct amount
+    if (
+        worker.mode == 'mountain'
+        or (worker.mode == 'buy_slope' and asset == 'quote')
+        or (worker.mode == 'sell_slope' and asset == 'base')
+    ):
+        assert further_order['quote']['amount'] == order['quote']['amount']
+    elif (
+        worker.mode == 'valley'
+        or (worker.mode == 'buy_slope' and asset == 'base')
+        or (worker.mode == 'sell_slope' and asset == 'quote')
+    ):
+        assert further_order['base']['amount'] == order['base']['amount']
+    elif worker.mode == 'neutral':
+        assert further_order['base']['amount'] == order['base']['amount'] / math.sqrt(1 + worker.increment)
+
+
+@pytest.mark.xfail(reason='https://github.com/bitshares/python-bitshares/issues/227')
+@pytest.mark.parametrize('asset', ['base', 'quote'])
+def test_place_further_order_no_place_order(orders5, asset):
+    """ Test place_further_order() with place_order=False kwarg
+    """
+    worker = orders5
+
+    if asset == 'base':
+        order = worker.buy_orders[0]
+    elif asset == 'quote':
+        order = worker.sell_orders[0]
+
+    further_order = worker.place_further_order(asset, order, place_order=False)
+    # Place real order to compare with
+    worker.place_further_order(asset, order, place_order=True)
+    worker.refresh_orders()
+
+    if asset == 'base':
+        real_order = worker.buy_orders[1]
+        price = real_order['price']
+        amount = real_order['quote']['amount']
+    elif asset == 'quote':
+        real_order = worker.sell_orders[1]
+        price = real_order['price'] ** -1
+        amount = real_order['base']['amount']
+
+    assert further_order['price'] == price
+    assert further_order['amount'] == amount
+
+
+@pytest.mark.parametrize('asset', ['base', 'quote'])
+def test_place_further_order_not_allow_partial(orders2, asset):
+    """ Test place_further_order with allow_partial=False
+    """
+    worker = orders2
+
+    if asset == 'base':
+        order = worker.buy_orders[0]
+        worker.base_balance['amount'] = order['base']['amount'] / 2
+    elif asset == 'quote':
+        order = worker.sell_orders[0]
+        worker.quote_balance['amount'] = order['base']['amount'] / 2
+
+    num_orders_before = len(worker.own_orders)
+    worker.place_further_order(asset, order, place_order=True, allow_partial=False)
+    num_orders_after = len(worker.own_orders)
+    # Expect that order was not placed
+    assert num_orders_before == num_orders_after
+
+
+@pytest.mark.parametrize('asset', ['base', 'quote'])
+def test_place_further_order_allow_partial_hard_limit(orders2, asset):
+    """ Test place_further_order with allow_partial=True when avail balance is less than minimal allowed order size
+    """
+    worker = orders2
+
+    if asset == 'base':
+        order = worker.buy_orders[0]
+        price = order['price']
+        # Pretend we have balance smaller than hard limit
+        worker.base_balance['amount'] = worker.check_min_order_size(0, price) / 2
+    elif asset == 'quote':
+        order = worker.sell_orders[0]
+        price = order['price'] ** -1
+        worker.quote_balance['amount'] = worker.check_min_order_size(0, price) / 2
+
+    num_orders_before = len(worker.own_orders)
+    worker.place_further_order(asset, order, place_order=True, allow_partial=True)
+    num_orders_after = len(worker.own_orders)
+    # Expect that order was not placed
+    assert num_orders_before == num_orders_after
+
+
+@pytest.mark.parametrize('asset', ['base', 'quote'])
+def test_place_further_order_allow_partial(orders2, asset):
+    """ Test place_further_order with allow_partial=True
+    """
+    worker = orders2
+
+    if asset == 'base':
+        order = worker.buy_orders[0]
+        worker.base_balance['amount'] = order['base']['amount'] / 2
+    elif asset == 'quote':
+        order = worker.sell_orders[0]
+        worker.quote_balance['amount'] = order['base']['amount'] / 2
+
+    num_orders_before = len(worker.own_orders)
+    worker.place_closer_order(asset, order, place_order=True, allow_partial=True)
+    num_orders_after = len(worker.own_orders)
+    # Expect order placed
+    assert num_orders_after - num_orders_before == 1
diff --git a/tests/strategies/staggered_orders/test_staggered_orders_init.py b/tests/strategies/staggered_orders/test_staggered_orders_init.py
new file mode 100644
index 000000000..01679c301
--- /dev/null
+++ b/tests/strategies/staggered_orders/test_staggered_orders_init.py
@@ -0,0 +1,36 @@
+import copy
+import logging
+import pytest
+
+from dexbot.strategies.staggered_orders import Strategy
+
+# Turn on debug for dexbot logger
+logger = logging.getLogger("dexbot")
+logger.setLevel(logging.DEBUG)
+
+
+###################
+# __init__ tests here
+###################
+
+
+@pytest.mark.parametrize('spread, increment', [(1, 2), pytest.param(2, 2, marks=pytest.mark.xfail(reason="bug"))])
+def test_spread_increment_check(bitshares, config, so_worker_name, spread, increment):
+    """ Spread must be greater than increment
+    """
+    worker_name = so_worker_name
+    incorrect_config = copy.deepcopy(config)
+    incorrect_config['workers'][worker_name]['spread'] = spread
+    incorrect_config['workers'][worker_name]['increment'] = increment
+    worker = Strategy(config=incorrect_config, name=worker_name, bitshares_instance=bitshares)
+    assert worker.disabled
+
+
+def test_min_operational_depth(bitshares, config, so_worker_name):
+    """ Operational depth should not be too small
+    """
+    worker_name = so_worker_name
+    incorrect_config = copy.deepcopy(config)
+    incorrect_config['workers'][worker_name]['operational_depth'] = 1
+    worker = Strategy(config=incorrect_config, name=worker_name, bitshares_instance=bitshares)
+    assert worker.disabled
diff --git a/tests/strategies/staggered_orders/test_staggered_orders_lowlevel.py b/tests/strategies/staggered_orders/test_staggered_orders_lowlevel.py
new file mode 100644
index 000000000..589119515
--- /dev/null
+++ b/tests/strategies/staggered_orders/test_staggered_orders_lowlevel.py
@@ -0,0 +1,44 @@
+import logging
+
+# Turn on debug for dexbot logger
+logger = logging.getLogger("dexbot")
+logger.setLevel(logging.DEBUG)
+
+
+###################
+# Lower-level methods used by higher-level methods
+###################
+
+
+def test_cancel_orders_wrapper(orders4):
+    worker = orders4
+
+    # test real order
+    orders = worker.own_orders
+    before = len(orders)
+    worker.cancel_orders_wrapper(orders[0])
+    after = len(worker.own_orders)
+    assert before - after == 1
+    # test virtual order
+    before = len(worker.virtual_orders)
+    worker.cancel_orders_wrapper(worker.virtual_orders[0])
+    after = len(worker.virtual_orders)
+    assert before - after == 1
+
+
+def test_place_virtual_buy_order(worker, init_empty_balances):
+    worker.place_virtual_buy_order(100, 1)
+    assert len(worker.virtual_orders) == 1
+    assert worker.virtual_orders[0]['base']['amount'] == 100
+    assert worker.virtual_orders[0]['for_sale']['amount'] == 100
+    assert worker.virtual_orders[0]['quote']['amount'] == 100
+    assert worker.virtual_orders[0]['price'] == 1
+
+
+def test_place_virtual_sell_order(worker, init_empty_balances):
+    worker.place_virtual_sell_order(100, 1)
+    assert len(worker.virtual_orders) == 1
+    assert worker.virtual_orders[0]['base']['amount'] == 100
+    assert worker.virtual_orders[0]['for_sale']['amount'] == 100
+    assert worker.virtual_orders[0]['quote']['amount'] == 100
+    assert worker.virtual_orders[0]['price'] == 1
diff --git a/tests/strategies/staggered_orders/test_staggered_orders_unittests.py b/tests/strategies/staggered_orders/test_staggered_orders_unittests.py
new file mode 100644
index 000000000..ce2b27f48
--- /dev/null
+++ b/tests/strategies/staggered_orders/test_staggered_orders_unittests.py
@@ -0,0 +1,44 @@
+import logging
+
+# Turn on debug for dexbot logger
+logger = logging.getLogger("dexbot")
+logger.setLevel(logging.DEBUG)
+
+
+###################
+# Methods which not depends on other methods at all, can be tested separately
+###################
+
+
+def test_log_maintenance_time(worker):
+    """ Should just not fail
+    """
+    worker.log_maintenance_time()
+
+
+def test_calculate_min_amounts(worker):
+    """ Min amounts should be greater than assets precision
+    """
+    worker.calculate_min_amounts()
+    assert worker.order_min_base > 10 ** -worker.market['base']['precision']
+    assert worker.order_min_quote > 10 ** -worker.market['quote']['precision']
+
+
+def test_calculate_asset_thresholds(worker):
+    """ Check asset threshold
+
+        Todo: https://github.com/Codaone/DEXBot/issues/554
+    """
+    worker.calculate_asset_thresholds()
+    assert worker.base_asset_threshold > 0
+    assert worker.quote_asset_threshold > 0
+
+
+def test_calc_buy_orders_count(worker):
+    worker.increment = 0.01
+    assert worker.calc_buy_orders_count(100, 90) == 11
+
+
+def test_calc_sell_orders_count(worker):
+    worker.increment = 0.01
+    assert worker.calc_sell_orders_count(90, 100) == 11

From 25ebe82e6a56979fc95b58516c4541e46b20e5d2 Mon Sep 17 00:00:00 2001
From: Vladimir Kamarzin <vvk@vvk.pp.ru>
Date: Wed, 22 May 2019 14:09:11 +0500
Subject: [PATCH 04/19] Fix unused variables

---
 tests/strategies/staggered_orders/conftest.py                 | 2 +-
 .../staggered_orders/test_staggered_orders_complex.py         | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/strategies/staggered_orders/conftest.py b/tests/strategies/staggered_orders/conftest.py
index 4066d73f8..099892362 100644
--- a/tests/strategies/staggered_orders/conftest.py
+++ b/tests/strategies/staggered_orders/conftest.py
@@ -170,7 +170,7 @@ def storage_db():
     """
     from dexbot.storage import sqlDataBaseFile
 
-    fd, sqlDataBaseFile = tempfile.mkstemp()  # noqa: F811
+    _, sqlDataBaseFile = tempfile.mkstemp()  # noqa: F811
     yield
     os.unlink(sqlDataBaseFile)
 
diff --git a/tests/strategies/staggered_orders/test_staggered_orders_complex.py b/tests/strategies/staggered_orders/test_staggered_orders_complex.py
index 81d862d90..a4f2c64f9 100644
--- a/tests/strategies/staggered_orders/test_staggered_orders_complex.py
+++ b/tests/strategies/staggered_orders/test_staggered_orders_complex.py
@@ -170,7 +170,7 @@ def test_maintain_strategy_fallback_logic(asset, mode, worker, do_initial_alloca
     spread_before = get_spread(worker)
     assert spread_before > worker.target_spread + worker.increment
 
-    for i in range(0, 6):
+    for _ in range(0, 6):
         worker.maintain_strategy()
 
     worker.refresh_orders()
@@ -616,7 +616,7 @@ def test_increase_order_sizes_neutral_smaller_closest_orders(worker, do_initial_
     worker.place_closer_order('base', worker.buy_orders[0], own_asset_limit=base_limit)
     worker.place_closer_order('quote', worker.sell_orders[0], own_asset_limit=quote_limit)
     worker.refresh_orders()
-    for i in range(1, num_orders_to_cancel):
+    for _ in range(1, num_orders_to_cancel):
         worker.place_closer_order('base', worker.buy_orders[0])
         worker.place_closer_order('quote', worker.sell_orders[0])
         worker.refresh_orders()

From 927a5f08927b4b0d5fe7daebaa93d2ceec1ef324 Mon Sep 17 00:00:00 2001
From: Vladimir Kamarzin <vvk@vvk.pp.ru>
Date: Wed, 22 May 2019 15:00:59 +0500
Subject: [PATCH 05/19] Restore tests/__init__.py to be able to run via
 `pytest`

When tests/__init__.py is present, pytest adds root directory to
PYTHONPATH, so tests can use imports `from dexbot.foo import bar`;
otherwise, `pip install -e .` is needed. See doc for details:

https://docs.pytest.org/en/latest/goodpractices.html#choosing-a-test-layout-import-rules
---
 tests/__init__.py | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 tests/__init__.py

diff --git a/tests/__init__.py b/tests/__init__.py
new file mode 100644
index 000000000..e69de29bb

From 4da0ba9be501dbd916473375e45c3d4cf4a7408c Mon Sep 17 00:00:00 2001
From: Vladimir Kamarzin <vvk@vvk.pp.ru>
Date: Wed, 22 May 2019 16:27:01 +0500
Subject: [PATCH 06/19] Set shared bitshares instance in tests

This is a workaround for
https://github.com/bitshares/python-bitshares/issues/234
---
 tests/conftest.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/tests/conftest.py b/tests/conftest.py
index 822081070..5c810b485 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -6,6 +6,7 @@
 import random
 
 from bitshares import BitShares
+from bitshares.instance import set_shared_bitshares_instance
 from bitshares.genesisbalance import GenesisBalance
 from bitshares.account import Account
 from bitshares.asset import Asset
@@ -87,6 +88,9 @@ def bitshares_instance(bitshares_testnet):
     bitshares = BitShares(
         node='ws://127.0.0.1:{}'.format(bitshares_testnet.service_port), keys=PRIVATE_KEYS, num_retries=-1
     )
+    # Shared instance allows to avoid any bugs when bitshares_instance is not passed explicitly when instantiating
+    # objects
+    set_shared_bitshares_instance(bitshares)
     # Todo: show chain params when connectiong to unknown network
     # https://github.com/bitshares/python-bitshares/issues/221
 

From b5433a96815cde8aef5fd8db1addb133d0702615 Mon Sep 17 00:00:00 2001
From: Vladimir Kamarzin <vvk@vvk.pp.ru>
Date: Fri, 7 Jun 2019 08:53:56 +0500
Subject: [PATCH 07/19] Implement in-memory calculation of increased orders

Closes: #614
---
 dexbot/strategies/staggered_orders.py | 338 ++++++++++++++++++--------
 1 file changed, 231 insertions(+), 107 deletions(-)

diff --git a/dexbot/strategies/staggered_orders.py b/dexbot/strategies/staggered_orders.py
index 629e5b618..198fd27fa 100644
--- a/dexbot/strategies/staggered_orders.py
+++ b/dexbot/strategies/staggered_orders.py
@@ -797,112 +797,106 @@ def allocate_asset(self, asset, asset_balance):
         if self.returnOrderId:
             self.refresh_orders()
 
-    def increase_order_sizes(self, asset, asset_balance, orders):
-        """ Checks which order should be increased in size and replaces it
-            with a maximum size order, according to global limits. Logic
-            depends on mode in question.
+    def _increase_single_order(self, asset, asset_balance, order, new_order_amount):
+        """ To avoid code doubling, use this unified function to increase single order
+
+            :param str asset: 'base' or 'quote', depending if checking sell or buy
+            :param Amount asset_balance: asset balance available for increase
+            :param order order: order needed to be increased
+            :param float new_order_amount: BASE or QUOTE amount of a new order (depending on asset)
+            :return: True = available funds were allocated, cannot allocate remainder
+                     False = not all funds were allocated, can increase more orders next time
+            :rtype: bool
+        """
+        quote_amount = 0
+        base_amount = 0
+        price = 0
+        order_amount = order['base']['amount']
+        order_type = ''
+        symbol = ''
+        precision = 0
 
-            Mountain:
-            Maximize order size as close to center as possible. When all orders are max, the new increase round is
-            started from the furthest order.
+        if asset == 'quote':
+            order_type = 'sell'
+            symbol = self.market['quote']['symbol']
+            precision = self.market['quote']['precision']
+            price = order['price'] ** -1
+            # New order amount must be at least x2 precision bigger
+            new_order_amount = max(
+                new_order_amount, order['base']['amount'] + 2 * 10 ** -self.market['quote']['precision']
+            )
+            quote_amount = new_order_amount
+            base_amount = quote_amount * price
+        elif asset == 'base':
+            order_type = 'buy'
+            symbol = self.market['base']['symbol']
+            precision = self.market['base']['precision']
+            price = order['price']
+            # New order amount must be at least x2 precision bigger
+            new_order_amount = max(
+                new_order_amount, order['base']['amount'] + 2 * 10 ** -self.market['base']['precision']
+            )
+            base_amount = new_order_amount
+            quote_amount = base_amount / price
+
+        needed_balance = new_order_amount - order['for_sale']['amount']
+        if asset_balance < needed_balance:
+            # Balance should be enough to replace partially filled order
+            self.log.debug(
+                'Not enough balance to increase {} order at price {:.8f}: {:.{prec}f}/{:.{prec}f} {}'.format(
+                    order_type, price, asset_balance['amount'], needed_balance, symbol, prec=precision
+                )
+            )
+            # Increase finished
+            return True
 
-            Neutral:
-            Try to flatten everything by increasing order sizes to neutral. When everything is correct, maximize
-            closest orders and then increase other orders to match that.
+        self.log.debug(
+            'Pre-increasing {} order at price {:.8f} from {:.{prec}f} to {:.{prec}f} {}'.format(
+                order_type, price, order_amount, new_order_amount, symbol, prec=precision
+            )
+        )
 
-            Valley:
-            Maximize order sizes as far as possible from center first. When all orders are max, the new increase round
-            is started from the closest-to-center order.
+        if asset == 'quote':
+            order['base']['amount'] = quote_amount
+            order['for_sale']['amount'] += needed_balance
+            order['quote']['amount'] = base_amount
+            asset_balance -= quote_amount - order_amount
+        elif asset == 'base':
+            order['base']['amount'] = base_amount
+            order['for_sale']['amount'] += needed_balance
+            order['quote']['amount'] = quote_amount
+            asset_balance -= base_amount - order_amount
 
-            Buy slope:
-            Maximize order size as low as possible. Buy orders maximized as far as possible (same as valley), and sell
-            orders as close as possible to cp (same as mountain).
+        # Increase not finished
+        return False
 
-            Sell slope:
-            Maximize order size as high as possible. Buy orders as close (same as mountain), and sell orders as far as
-            possible from cp (same as valley).
+    def _calc_increase(self, asset, asset_balance, orders):
+        """ Calculate increased order sizes for specified orders with inplace replacement of order amounts.
+            Only one increase is performed at a time.
 
-            :param str | asset: 'base' or 'quote', depending if checking sell or buy
-            :param Amount | asset_balance: Balance of the account
-            :param list | orders: List of buy or sell orders
-            :return bool | True = all available funds was allocated
-                           False = not all funds was allocated, can increase more orders next time
+            :param str asset: 'base' or 'quote', depending if checking sell or buy
+            :param Amount asset_balance: Balance of the account
+            :param list orders: List of buy or sell orders
+            :return: True = all available funds were allocated
+                     False = not all funds was allocated, can increase more orders next time
+            :rtype: bool
         """
 
-        def increase_single_order(asset, order, new_order_amount):
-            """ To avoid code doubling, use this unified function to increase single order
-
-                :param str | asset: 'base' or 'quote', depending if checking sell or buy
-                :param order | order: order needed to be increased
-                :param float | new_order_amount: BASE or QUOTE amount of a new order (depending on asset)
-                :return bool | True = available funds was allocated, cannot allocate remainder
-                               False = not all funds was allocated, can increase more orders next time
-            """
-            quote_amount = 0
-            price = 0
-            order_type = ''
-            order_amount = order['base']['amount']
-
-            if asset == 'quote':
-                order_type = 'sell'
-                price = (order['price'] ** -1)
-                # New order amount must be at least x2 precision bigger
-                new_order_amount = max(
-                    new_order_amount, order['base']['amount'] + 2 * 10 ** -self.market['quote']['precision']
-                )
-                quote_amount = new_order_amount
-            elif asset == 'base':
-                order_type = 'buy'
-                price = order['price']
-                # New order amount must be at least x2 precision bigger
-                new_order_amount = max(new_order_amount,
-                                       order['base']['amount'] + 2 * 10 ** -self.market['base']['precision'])
-                quote_amount = new_order_amount / price
-
-            if asset_balance < new_order_amount - order['for_sale']['amount']:
-                # Balance should be enough to replace partially filled order
-                self.log.debug('Not enough balance to increase {} order at price {:.8f}'
-                               .format(order_type, price))
-                return True
-
-            self.log.info('Increasing {} order at price {:.8f} from {:.{prec}f} to {:.{prec}f} {}'
-                          .format(order_type, price, order_amount, new_order_amount, symbol, prec=precision))
-            self.log.debug('Cancelling {} order in increase_order_sizes(); mode: {}, amount: {}, price: {:.8f}'
-                           .format(order_type, self.mode, order_amount, price))
-            self.cancel_orders_wrapper(order)
-            if asset == 'quote':
-                if isinstance(order, VirtualOrder):
-                    self.place_virtual_sell_order(quote_amount, price)
-                else:
-                    self.place_market_sell_order(quote_amount, price)
-            elif asset == 'base':
-                if isinstance(order, VirtualOrder):
-                    self.place_virtual_buy_order(quote_amount, price)
-                else:
-                    self.place_market_buy_order(quote_amount, price)
-
-            # Only one increase at a time. This prevents running more than one increment round simultaneously
-            return False
-
-        total_balance = 0
-        symbol = ''
-        precision = 0
         new_order_amount = 0
         furthest_order_bound = 0
+        total_balance = 0
 
         if asset == 'quote':
             total_balance = self.quote_total_balance
-            symbol = self.market['quote']['symbol']
-            precision = self.market['quote']['precision']
         elif asset == 'base':
             total_balance = self.base_total_balance
-            symbol = self.market['base']['symbol']
-            precision = self.market['base']['precision']
 
         # Mountain mode:
-        if (self.mode == 'mountain' or
-                (self.mode == 'buy_slope' and asset == 'quote') or
-                (self.mode == 'sell_slope' and asset == 'base')):
+        if (
+            self.mode == 'mountain'
+            or (self.mode == 'buy_slope' and asset == 'quote')
+            or (self.mode == 'sell_slope' and asset == 'base')
+        ):
             """ Starting from the furthest order. For each order, see if it is approximately
                 maximum size.
                 If it is, move on to next.
@@ -947,8 +941,10 @@ def increase_single_order(asset, order, new_order_amount):
 
                 further_bound = further_order['base']['amount'] * (1 + self.increment)
 
-                if (further_bound > order_amount * (1 + self.increment / 10) < closer_bound and
-                        further_bound - order_amount >= order_amount * self.increment / 2):
+                if (
+                    further_bound > order_amount * (1 + self.increment / 10) < closer_bound
+                    and further_bound - order_amount >= order_amount * self.increment / 2
+                ):
                     # Calculate new order size and place the order to the market
                     """ To prevent moving liquidity away from center, let new order be no more than `order_amount *
                         increase_factor`. This is for situations when we increasing order on side which was previously
@@ -999,11 +995,13 @@ def increase_single_order(asset, order, new_order_amount):
                         self.log.debug('Deactivating max increase mode for mountain mode')
                         self.mountain_max_increase_mode = False
 
-                    return increase_single_order(asset, order, new_order_amount)
+                    return self._increase_single_order(asset, asset_balance, order, new_order_amount)
 
-        elif (self.mode == 'valley' or
-              (self.mode == 'buy_slope' and asset == 'base') or
-              (self.mode == 'sell_slope' and asset == 'quote')):
+        elif (
+            self.mode == 'valley'
+            or (self.mode == 'buy_slope' and asset == 'base')
+            or (self.mode == 'sell_slope' and asset == 'quote')
+        ):
             """ Starting from the furthest order, for each order, see if it is approximately
                 maximum size.
                 If it is, move on to next.
@@ -1053,9 +1051,11 @@ def increase_single_order(asset, order, new_order_amount):
                 order_amount_normalized = order_amount * (1 + self.increment / 10)
                 need_increase = False
 
-                if (order_amount_normalized < further_order_bound and
-                        further_order_bound - order_amount >= order_amount * self.increment / 2 and
-                        order_amount_normalized < closest_order_bound):
+                if (
+                    order_amount_normalized < further_order_bound
+                    and further_order_bound - order_amount >= order_amount * self.increment / 2
+                    and order_amount_normalized < closest_order_bound
+                ):
                     """ Check whether order amount is less than further order and also less than `closer order +
                         increment`. We need this check to be able to increase closer orders more smoothly. Here is the
                         example:
@@ -1079,8 +1079,10 @@ def increase_single_order(asset, order, new_order_amount):
                         # Skip order if new amount is less than current for any reason
                         need_increase = False
 
-                elif (order_amount_normalized < closer_order_bound and
-                        closer_order_bound - order_amount >= order_amount * self.increment / 2):
+                elif (
+                    order_amount_normalized < closer_order_bound
+                    and closer_order_bound - order_amount >= order_amount * self.increment / 2
+                ):
                     """ Check whether order amount is less than closer or order and the diff is more than 50% of one
                         increment. Note: we can use only 50% or less diffs. Bigger will not work. For example, with
                         diff 80% an order may have an actual difference like 30% from closer and 70% from further.
@@ -1089,7 +1091,7 @@ def increase_single_order(asset, order, new_order_amount):
                     need_increase = True
 
                 if need_increase:
-                    return increase_single_order(asset, order, new_order_amount)
+                    return self._increase_single_order(asset, asset_balance, order, new_order_amount)
 
         elif self.mode == 'neutral':
             """ Starting from the furthest order, for each order, see if it is approximately
@@ -1146,8 +1148,10 @@ def increase_single_order(asset, order, new_order_amount):
                 need_increase = False
                 order_amount_normalized = order_amount * (1 + self.increment / 10)
 
-                if (order_amount_normalized < further_order_bound and
-                        further_order_bound - order_amount >= order_amount * (math.sqrt(1 + self.increment) - 1) / 2):
+                if (
+                    order_amount_normalized < further_order_bound
+                    and further_order_bound - order_amount >= order_amount * (math.sqrt(1 + self.increment) - 1) / 2
+                ):
                     # Order is less than further order and diff is more than `increment / 2`
 
                     if is_closest_order:
@@ -1167,17 +1171,137 @@ def increase_single_order(asset, order, new_order_amount):
                             new_order_amount = min(order['base']['amount'] * (1 + self.increment), further_order_bound)
                             need_increase = True
 
-                elif (order_amount_normalized < closer_order_bound and
-                        closer_order_bound - order_amount >= order_amount * (math.sqrt(1 + self.increment) - 1) / 2):
+                elif (
+                    order_amount_normalized < closer_order_bound
+                    and closer_order_bound - order_amount >= order_amount * (math.sqrt(1 + self.increment) - 1) / 2
+                ):
                     # Order is less than closer order and diff is more than `increment / 2`
 
                     new_order_amount = closer_order_bound
                     need_increase = True
 
                 if need_increase:
-                    return increase_single_order(asset, order, new_order_amount)
+                    return self._increase_single_order(asset, asset_balance, order, new_order_amount)
 
-        return None
+    def increase_order_sizes(self, asset, asset_balance, orders):
+        """ Checks which order should be increased in size and replaces it
+            with a maximum size order, according to global limits. Logic
+            depends on mode in question.
+
+            Mountain:
+            Maximize order size as close to center as possible. When all orders are max, the new increase round is
+            started from the furthest order.
+
+            Neutral:
+            Try to flatten everything by increasing order sizes to neutral. When everything is correct, maximize
+            closest orders and then increase other orders to match that.
+
+            Valley:
+            Maximize order sizes as far as possible from center first. When all orders are max, the new increase round
+            is started from the closest-to-center order.
+
+            Buy slope:
+            Maximize order size as low as possible. Buy orders maximized as far as possible (same as valley), and sell
+            orders as close as possible to cp (same as mountain).
+
+            Sell slope:
+            Maximize order size as high as possible. Buy orders as close (same as mountain), and sell orders as far as
+            possible from cp (same as valley).
+
+            :param str asset: 'base' or 'quote', depending if checking sell or buy
+            :param Amount asset_balance: Balance of the account
+            :param list orders: List of buy or sell orders
+            :return: True = all available funds were allocated
+                     False = not all funds were allocated, can increase more orders next time
+            :rtype: bool
+        """
+
+        # Create temp order list (copy.deepcopy() doesn't work here)
+        temp_orders = []
+        for order in orders:
+            tmp_order = {
+                'base': {'amount': order['base']['amount']},
+                'quote': {'amount': order['quote']['amount']},
+                'for_sale': {'amount': order['for_sale']['amount']},
+                'price': order['price'],
+            }
+            temp_orders.append(tmp_order)
+
+        # Get calculated increased orders
+        increase_finished = False
+        while not increase_finished:
+            increase_finished = self._calc_increase(asset, asset_balance, temp_orders)
+
+        price = 0
+        order_type = ''
+        symbol = ''
+        opposite_symbol = ''
+        precision = 0
+        opposite_precision = 0
+
+        if asset == 'quote':
+            order_type = 'sell'
+            symbol = self.market['quote']['symbol']
+            opposite_symbol = self.market['base']['symbol']
+            precision = self.market['quote']['precision']
+            opposite_precision = self.market['base']['precision']
+        elif asset == 'base':
+            order_type = 'buy'
+            symbol = self.market['base']['symbol']
+            opposite_symbol = self.market['quote']['symbol']
+            precision = self.market['base']['precision']
+            opposite_precision = self.market['quote']['precision']
+
+        # We're iterating in reverse manner to place further orders first
+        orders = list(reversed(orders))
+        temp_orders = list(reversed(temp_orders))
+
+        for index, order in enumerate(temp_orders):
+            if order['base']['amount'] != orders[index]['base']['amount']:
+                price = order['price'] if asset == 'base' else order['price'] ** -1
+                old_amount = orders[index]['base']['amount']
+                new_amount = order['base']['amount']
+                old_opposite_amount = orders[index]['quote']['amount']
+                new_opposite_amount = order['quote']['amount']
+                self.log.info(
+                    'Increasing {} order at price {:.8f}, {:.{prec}f} -> {:.{prec}f} {}, '
+                    '({:.{opposite_prec}f} -> {:.{opposite_prec}f} {})'.format(
+                        order_type,
+                        price,
+                        old_amount,
+                        new_amount,
+                        symbol,
+                        old_opposite_amount,
+                        new_opposite_amount,
+                        opposite_symbol,
+                        prec=precision,
+                        opposite_prec=opposite_precision,
+                    )
+                )
+                self.log.debug(
+                    'Cancelling {} order in increase_order_sizes(); mode: {}, amount: {}, price: {:.8f}'.format(
+                        order_type, self.mode, old_amount, price
+                    )
+                )
+                self.cancel_orders_wrapper(orders[index])
+
+                if asset == 'quote':
+                    if isinstance(orders[index], VirtualOrder):
+                        self.place_virtual_sell_order(order['base']['amount'], price)
+                    else:
+                        self.place_market_sell_order(order['base']['amount'], price)
+                elif asset == 'base':
+                    if isinstance(orders[index], VirtualOrder):
+                        self.place_virtual_buy_order(order['quote']['amount'], price)
+                    else:
+                        self.place_market_buy_order(order['quote']['amount'], price)
+
+                # Limit number of operations to send at once
+                if len(self.bitshares.txbuffer.ops) > 10:
+                    return False
+
+        # All funds were used
+        return True
 
     def check_partial_fill(self, order, fill_threshold=None):
         """ Checks whether order was partially filled it needs to be replaced

From 8142113044f089fea83e0a4204e274d5703cf5a4 Mon Sep 17 00:00:00 2001
From: Vladimir Kamarzin <vvk@vvk.pp.ru>
Date: Fri, 7 Jun 2019 09:36:18 +0500
Subject: [PATCH 08/19] Fix closest order calculation for neutral mode

Closest order caclulation was a bit wrong which caused an error with new
in-memory caclulation logic.
---
 dexbot/strategies/staggered_orders.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/dexbot/strategies/staggered_orders.py b/dexbot/strategies/staggered_orders.py
index 198fd27fa..6318d7998 100644
--- a/dexbot/strategies/staggered_orders.py
+++ b/dexbot/strategies/staggered_orders.py
@@ -1135,11 +1135,11 @@ def _calc_increase(self, asset, asset_balance, orders):
 
                     new_orders_sum = 0
                     amount = order_amount
-                    for o in orders:
+                    for _ in orders:
                         new_orders_sum += amount
                         amount = amount / math.sqrt(1 + self.increment)
                     virtual_furthest_order_bound = amount * (total_balance / new_orders_sum)
-                    new_amount = order_amount * (total_balance / new_orders_sum)
+                    new_amount = order_amount * (total_balance / new_orders_sum) / self.min_increase_factor
 
                     if new_amount > closer_order_bound and virtual_furthest_order_bound > furthest_order_bound:
                         # Maximize order up to max possible amount if we can

From ca5eb8a344a50e05800e60aa2cb187b9495324a8 Mon Sep 17 00:00:00 2001
From: Vladimir Kamarzin <vvk@vvk.pp.ru>
Date: Fri, 7 Jun 2019 10:15:38 +0500
Subject: [PATCH 09/19] Fix furthest order calculation for mountain mode

---
 dexbot/strategies/staggered_orders.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dexbot/strategies/staggered_orders.py b/dexbot/strategies/staggered_orders.py
index 6318d7998..1ca3603e4 100644
--- a/dexbot/strategies/staggered_orders.py
+++ b/dexbot/strategies/staggered_orders.py
@@ -976,7 +976,7 @@ def _calc_increase(self, asset, asset_balance, orders):
                             amount = amount * (1 + self.increment)
                             new_orders_sum += amount
                         # To reduce allocation rounds, increase furthest order more
-                        new_order_amount = order_amount * (total_balance / new_orders_sum) * (1 + self.increment)
+                        new_order_amount = order_amount * (total_balance / new_orders_sum)
 
                         if new_order_amount < closer_bound:
                             """ This is for situations when calculated new_order_amount is not big enough to

From 1884606582f13af092fbb8055442764fb2c0f688 Mon Sep 17 00:00:00 2001
From: Vladimir Kamarzin <vvk@vvk.pp.ru>
Date: Fri, 7 Jun 2019 10:47:08 +0500
Subject: [PATCH 10/19] Fix SO tests for new in-memory increases

---
 .../test_staggered_orders_complex.py          | 45 ++++++++++---------
 1 file changed, 24 insertions(+), 21 deletions(-)

diff --git a/tests/strategies/staggered_orders/test_staggered_orders_complex.py b/tests/strategies/staggered_orders/test_staggered_orders_complex.py
index a4f2c64f9..f700b0c85 100644
--- a/tests/strategies/staggered_orders/test_staggered_orders_complex.py
+++ b/tests/strategies/staggered_orders/test_staggered_orders_complex.py
@@ -236,11 +236,11 @@ def test_increase_order_sizes_valley_transit_from_mountain(worker, do_initial_al
     do_initial_allocation(worker, 'mountain')
     # Switch to valley
     worker.mode = 'valley'
-    # Add balance to increase several orders
-    to_issue = worker.buy_orders[0]['base']['amount'] * 10
-    issue_asset(worker.market['base']['symbol'], to_issue, worker.account.name)
 
     for _ in range(0, 6):
+        # Add balance to increase ~1 order
+        to_issue = worker.buy_orders[0]['base']['amount']
+        issue_asset(worker.market['base']['symbol'], to_issue, worker.account.name)
         previous_buy_orders = worker.buy_orders
         worker.refresh_balances()
         worker.increase_order_sizes('base', worker.base_balance, previous_buy_orders)
@@ -391,7 +391,7 @@ def test_increase_order_sizes_mountain_basic(worker, do_initial_allocation, issu
         )
 
 
-def test_increase_order_sizes_mountain_direction(worker, do_initial_allocation, issue_asset):
+def test_increase_order_sizes_mountain_direction(worker, do_initial_allocation, issue_asset, increase_until_allocated):
     """ Test increase direction in mountain mode
 
         Buy side, amounts in QUOTE:
@@ -402,12 +402,14 @@ def test_increase_order_sizes_mountain_direction(worker, do_initial_allocation,
         15 15 15 10 10
     """
     do_initial_allocation(worker, 'mountain')
+    increase_until_allocated(worker)
     worker.mode = 'mountain'
-
-    # Double worker's balance
-    issue_asset(worker.market['base']['symbol'], worker.base_total_balance, worker.account.name)
+    increase_factor = max(1 + worker.increment, worker.min_increase_factor)
 
     for _ in range(0, 6):
+        # Add balance to increase ~1 order
+        to_issue = worker.buy_orders[0]['base']['amount'] * (increase_factor - 1)
+        issue_asset(worker.market['base']['symbol'], to_issue, worker.account.name)
         previous_buy_orders = worker.buy_orders
         worker.refresh_balances()
         worker.increase_order_sizes('base', worker.base_balance, previous_buy_orders)
@@ -471,29 +473,30 @@ def test_increase_order_sizes_mountain_imbalanced(worker, do_initial_allocation)
     base_limit = initial_base / 2
     # Add own_asset_limit only for first new order
     worker.place_closer_order('base', worker.buy_orders[0], own_asset_limit=base_limit)
+    worker.refresh_orders()
     for _ in range(1, num_orders_to_cancel):
         worker.place_closer_order('base', worker.buy_orders[0])
         worker.refresh_orders()
 
+    previous_buy_orders = worker.buy_orders
+
     for _ in range(0, num_orders_to_cancel):
-        previous_buy_orders = worker.buy_orders
         worker.refresh_balances()
         worker.increase_order_sizes('base', worker.base_balance, previous_buy_orders)
         worker.refresh_orders()
 
-        for order in worker.buy_orders:
-            order_index = worker.buy_orders.index(order)
-
-            if (
-                previous_buy_orders[order_index]['quote']['amount']
-                < previous_buy_orders[order_index + 1]['quote']['amount']
-                and previous_buy_orders[order_index + 1]['base']['amount']
-                - previous_buy_orders[order_index]['base']['amount']
-                > previous_buy_orders[order_index]['base']['amount'] * worker.increment / 2
-            ):
-                # If order before increase was smaller than further order, expect to see it increased
-                assert order['quote']['amount'] > previous_buy_orders[order_index]['quote']['amount']
-                break
+    for order_index in range(0, num_orders_to_cancel):
+        order = worker.buy_orders[order_index]
+        if (
+            previous_buy_orders[order_index]['quote']['amount']
+            < previous_buy_orders[order_index + 1]['quote']['amount']
+            and previous_buy_orders[order_index + 1]['base']['amount']
+            - previous_buy_orders[order_index]['base']['amount']
+            > previous_buy_orders[order_index]['base']['amount'] * worker.increment / 2
+        ):
+            # If order before increase was smaller than further order, expect to see it increased
+            assert order['quote']['amount'] > previous_buy_orders[order_index]['quote']['amount']
+            break
 
 
 def test_increase_order_sizes_neutral_basic(worker, do_initial_allocation, issue_asset, increase_until_allocated):

From b9257b3538c8b687ac5b2e06d9b91edd40ccbaae Mon Sep 17 00:00:00 2001
From: Vladimir Kamarzin <vvk@vvk.pp.ru>
Date: Mon, 4 Feb 2019 01:03:47 +0500
Subject: [PATCH 11/19] Fix typo

---
 dexbot/strategies/staggered_orders.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dexbot/strategies/staggered_orders.py b/dexbot/strategies/staggered_orders.py
index 1ca3603e4..716c08cf0 100644
--- a/dexbot/strategies/staggered_orders.py
+++ b/dexbot/strategies/staggered_orders.py
@@ -710,7 +710,7 @@ def allocate_asset(self, asset, asset_balance):
                 # Target spread is reached, let's allocate remaining funds
                 if not self.check_partial_fill(closest_own_order, fill_threshold=0):
                     """ Detect partially filled order on the own side and reserve funds to replace order in case
-                        opposite oreder will be fully filled.
+                        opposite order will be fully filled.
                     """
                     funds_to_reserve = closest_own_order['base']['amount']
                     self.log.debug('Partially filled order on own side, reserving funds to replace: '

From cc3f895cdf9846ef5f61ebadbdaeccb74c9e8270 Mon Sep 17 00:00:00 2001
From: Vladimir Kamarzin <vvk@vvk.pp.ru>
Date: Mon, 4 Feb 2019 00:35:27 +0500
Subject: [PATCH 12/19] Refactor orders increase logic

Prevent moving liquidity away from center in valley and neutral modes.

Closes: #444, #586
---
 dexbot/strategies/staggered_orders.py         | 68 ++++++++++++-------
 .../test_staggered_orders_complex.py          | 65 ++++++++++--------
 2 files changed, 81 insertions(+), 52 deletions(-)

diff --git a/dexbot/strategies/staggered_orders.py b/dexbot/strategies/staggered_orders.py
index 716c08cf0..81be4e6e8 100644
--- a/dexbot/strategies/staggered_orders.py
+++ b/dexbot/strategies/staggered_orders.py
@@ -885,11 +885,17 @@ def _calc_increase(self, asset, asset_balance, orders):
         new_order_amount = 0
         furthest_order_bound = 0
         total_balance = 0
+        symbol = ''
+        precision = 0
 
         if asset == 'quote':
             total_balance = self.quote_total_balance
+            symbol = self.market['quote']['symbol']
+            precision = self.market['quote']['precision']
         elif asset == 'base':
             total_balance = self.base_total_balance
+            symbol = self.market['base']['symbol']
+            precision = self.market['base']['precision']
 
         # Mountain mode:
         if (
@@ -1016,8 +1022,11 @@ def _calc_increase(self, asset, asset_balance, orders):
             orders_count = len(orders)
             orders = list(reversed(orders))
 
+            # To speed up the process, use at least N% increases
+            increase_factor = max(1 + self.increment, self.min_increase_factor)
+
             closest_order = orders[-1]
-            closest_order_bound = closest_order['base']['amount'] * (1 + self.increment)
+            closest_order_bound = closest_order['base']['amount'] * increase_factor
 
             for order in orders:
                 order_index = orders.index(order)
@@ -1070,8 +1079,6 @@ def _calc_increase(self, asset, asset_balance, orders):
                     """
                     need_increase = True
 
-                    # To speed up the process, use at least N% increases
-                    increase_factor = max(1 + self.increment, self.min_increase_factor)
                     # Do not allow to increase more than further order amount
                     new_order_amount = min(closer_order_bound * increase_factor, further_order_bound)
 
@@ -1081,13 +1088,25 @@ def _calc_increase(self, asset, asset_balance, orders):
 
                 elif (
                     order_amount_normalized < closer_order_bound
-                    and closer_order_bound - order_amount >= order_amount * self.increment / 2
+                    and order_amount_normalized < closest_order_bound
+                    and closer_order_bound - order_amount >= order_amount * (math.sqrt(1 + self.increment) - 1) / 2
                 ):
                     """ Check whether order amount is less than closer or order and the diff is more than 50% of one
                         increment. Note: we can use only 50% or less diffs. Bigger will not work. For example, with
                         diff 80% an order may have an actual difference like 30% from closer and 70% from further.
+
+                        Also prevent moving liqudity away from closer-to-center orders. Instead of increasing "80"
+                        orders, increase closer-to-center orders first:
+
+                        [80 80 80 100 100 100 60 50 40 40]
+                        [80 80 80 100 100 100 60 50 50 40]
+                        [80 80 80 100 100 100 60 50 50 50]
+                        ...
+                        [80 80 80 100 100 100 60 60 60 60]
+                        ...
+                        [80 80 80 100 100 100 80 80 80 80]
                     """
-                    new_order_amount = closer_order_bound
+                    new_order_amount = min(closest_order_bound, closer_order_bound)
                     need_increase = True
 
                 if need_increase:
@@ -1109,11 +1128,14 @@ def _calc_increase(self, asset, asset_balance, orders):
             orders_count = len(orders)
             orders = list(reversed(orders))
             closest_order = orders[-1]
-            previous_amount = 0
+            increase_factor = max(1 + self.increment, self.min_increase_factor)
+            initial_closest_order_bound = closest_order['base']['amount'] * increase_factor
 
             for order in orders:
                 order_index = orders.index(order)
+                reverse_index = orders_count - order_index
                 order_amount = order['base']['amount']
+                closest_order_bound = initial_closest_order_bound
 
                 if order_index == 0:
                     # This is a furthest order
@@ -1129,9 +1151,11 @@ def _calc_increase(self, asset, asset_balance, orders):
                     closer_order = orders[order_index + 1]
                     closer_order_bound = closer_order['base']['amount'] / math.sqrt(1 + self.increment)
                     is_closest_order = False
+                    # What size current order may be based on initial closest order bound
+                    closest_order_bound = initial_closest_order_bound / (math.sqrt(1 + self.increment) ** reverse_index)
                 else:
                     is_closest_order = True
-                    closer_order_bound = order['base']['amount'] * (1 + self.increment)
+                    closer_order_bound = initial_closest_order_bound
 
                     new_orders_sum = 0
                     amount = order_amount
@@ -1143,6 +1167,7 @@ def _calc_increase(self, asset, asset_balance, orders):
 
                     if new_amount > closer_order_bound and virtual_furthest_order_bound > furthest_order_bound:
                         # Maximize order up to max possible amount if we can
+                        # New order may be feeling bigger than expected after mountain -> neutral transition, it's ok
                         closer_order_bound = new_amount
 
                 need_increase = False
@@ -1150,34 +1175,29 @@ def _calc_increase(self, asset, asset_balance, orders):
 
                 if (
                     order_amount_normalized < further_order_bound
+                    and order_amount_normalized < closest_order_bound
                     and further_order_bound - order_amount >= order_amount * (math.sqrt(1 + self.increment) - 1) / 2
                 ):
                     # Order is less than further order and diff is more than `increment / 2`
-
+                    # Order is also less than previously calculated closest_order_bound
                     if is_closest_order:
-                        new_order_amount = closer_order_bound
-                        need_increase = True
+                        # At first, maximize order as we can
+                        new_order_amount = max(closer_order_bound, further_order_bound)
                     else:
-                        price = closest_order['price']
-                        amount = closest_order['base']['amount']
-                        while price > order['price'] * (1 + self.increment / 10):
-                            # Calculate closer order amount based on current closest order
-                            previous_amount = amount
-                            price = price / (1 + self.increment)
-                            amount = amount / math.sqrt(1 + self.increment)
-                        if order_amount_normalized < previous_amount:
-                            # Current order is less than virtually calculated next order
-                            # Do not allow to increase more than further order amount
-                            new_order_amount = min(order['base']['amount'] * (1 + self.increment), further_order_bound)
-                            need_increase = True
+                        # Current order is less than virtually calculated next order (closest_order_bound)
+                        # Do not allow to increase more than further order amount
+                        new_order_amount = min(order['base']['amount'] * increase_factor, further_order_bound)
+                    need_increase = True
 
                 elif (
                     order_amount_normalized < closer_order_bound
+                    and order_amount_normalized < closest_order_bound
                     and closer_order_bound - order_amount >= order_amount * (math.sqrt(1 + self.increment) - 1) / 2
                 ):
                     # Order is less than closer order and diff is more than `increment / 2`
-
-                    new_order_amount = closer_order_bound
+                    # Order is also less than virtually calculated closest_order_bound, this prevents moving liquidity
+                    # away from center, see similar code in Valley mode for description
+                    new_order_amount = min(closer_order_bound, closest_order_bound)
                     need_increase = True
 
                 if need_increase:
diff --git a/tests/strategies/staggered_orders/test_staggered_orders_complex.py b/tests/strategies/staggered_orders/test_staggered_orders_complex.py
index f700b0c85..7bba306dc 100644
--- a/tests/strategies/staggered_orders/test_staggered_orders_complex.py
+++ b/tests/strategies/staggered_orders/test_staggered_orders_complex.py
@@ -298,10 +298,9 @@ def test_increase_order_sizes_valley_smaller_closest_orders(worker, do_initial_a
     assert worker.sell_orders[0]['base']['amount'] == initial_quote
 
 
-@pytest.mark.xfail(reason='https://github.com/Codaone/DEXBot/issues/444')
 def test_increase_order_sizes_valley_imbalaced_small_further(worker, do_initial_allocation, increase_until_allocated):
-    """
-        TODO: test stub for https://github.com/Codaone/DEXBot/pull/484
+    """ If furthest orders are smaller than closest, they should be increased first.
+        See https://github.com/Codaone/DEXBot/issues/444 for details
 
         Buy side, amounts in BASE:
 
@@ -334,19 +333,22 @@ def test_increase_order_sizes_valley_imbalaced_small_further(worker, do_initial_
         worker.place_market_buy_order(to_buy, further_order['price'])
         worker.refresh_orders()
 
-    # Drop excess balance, the goal is to keep balance to only increase furthest orders
-    amount = Amount(
-        base_limit * num_orders_to_cancel, worker.market['base']['symbol'], bitshares_instance=worker.bitshares
-    )
+    # Drop excess balance to only allow to one increase round
+    worker.refresh_balances()
+    increase_factor = max(1 + worker.increment, worker.min_increase_factor)
+    to_keep = base_limit * (increase_factor - 1) * num_orders_to_cancel * 2 * 1.01
+    to_drop = worker.base_balance['amount'] - to_keep
+    amount = Amount(to_drop, worker.market['base']['symbol'], bitshares_instance=worker.bitshares)
     worker.bitshares.reserve(amount, account=worker.account)
 
     increase_until_allocated(worker)
 
     for i in range(1, num_orders_to_cancel):
-        assert worker.buy_orders[-i]['base']['amount'] == worker.buy_orders[i - 1]['base']['amount']
+        further_order_amount = worker.buy_orders[-i]['base']['amount']
+        closer_order_amount = worker.buy_orders[i - 1]['base']['amount']
+        assert further_order_amount == closer_order_amount
 
 
-@pytest.mark.xfail(reason='https://github.com/Codaone/DEXBot/issues/586')
 def test_increase_order_sizes_valley_closest_order(worker, do_initial_allocation, issue_asset):
     """ Should test proper calculation of closest order: order should not be less that min_increase_factor
     """
@@ -631,10 +633,9 @@ def test_increase_order_sizes_neutral_smaller_closest_orders(worker, do_initial_
     assert worker.sell_orders[0]['base']['amount'] == initial_quote
 
 
-@pytest.mark.xfail(reason='https://github.com/Codaone/DEXBot/issues/444')
 def test_increase_order_sizes_neutral_imbalaced_small_further(worker, do_initial_allocation, increase_until_allocated):
-    """
-        TODO: test stub for https://github.com/Codaone/DEXBot/pull/484
+    """ If furthest orders are smaller than closest, they should be increased first.
+        See https://github.com/Codaone/DEXBot/issues/444 for details
 
         Buy side, amounts in BASE:
 
@@ -645,7 +646,6 @@ def test_increase_order_sizes_neutral_imbalaced_small_further(worker, do_initial
         10 10 10 100 100 10 10 10 <center>
     """
     worker = do_initial_allocation(worker, 'neutral')
-    increase_until_allocated(worker)
 
     # Cancel several closest orders
     num_orders_to_cancel = 3
@@ -658,28 +658,37 @@ def test_increase_order_sizes_neutral_imbalaced_small_further(worker, do_initial
     # Place limited orders
     initial_base = worker.buy_orders[0]['base']['amount']
     base_limit = initial_base / 2
-    for i in range(0, num_orders_to_cancel):
-        worker.place_closer_order('base', worker.buy_orders[0], own_asset_limit=base_limit)
-        # place_further_order() doesn't have own_asset_limit, so do own calculation
-        further_order = worker.place_further_order('base', worker.buy_orders[-1], place_order=False)
-        worker.place_market_buy_order(base_limit / further_order['price'], further_order['price'])
+    # Apply limit only for first order
+    worker.place_closer_order('base', worker.buy_orders[0], own_asset_limit=base_limit)
+    # place_further_order() doesn't have own_asset_limit, so do own calculation
+    further_order = worker.place_further_order('base', worker.buy_orders[-1], place_order=False)
+    worker.place_market_buy_order(base_limit / further_order['price'], further_order['price'])
+    worker.refresh_orders()
+
+    # Place remainig limited orders
+    for i in range(1, num_orders_to_cancel):
+        worker.place_closer_order('base', worker.buy_orders[0])
+        worker.place_further_order('base', worker.buy_orders[-1])
         worker.refresh_orders()
 
-    # Drop excess balance, the goal is to keep balance to only increase furthest orders
-    amount = Amount(
-        base_limit * num_orders_to_cancel, worker.market['base']['symbol'], bitshares_instance=worker.bitshares
-    )
+    # Drop excess balance to only allow to one increase round
+    worker.refresh_balances()
+    increase_factor = max(1 + worker.increment, worker.min_increase_factor)
+    to_keep = base_limit * (increase_factor - 1) * num_orders_to_cancel * 2 * 1.1
+    to_drop = worker.base_balance['amount'] - to_keep
+    amount = Amount(to_drop, worker.market['base']['symbol'], bitshares_instance=worker.bitshares)
     worker.bitshares.reserve(amount, account=worker.account)
 
     increase_until_allocated(worker)
 
     for i in range(1, num_orders_to_cancel):
-        # TODO: this is a simple check without precise calculation
+        # This is a simple check without precise calculation
         # We're roughly checking that new furthest orders are not exceed new closest orders
-        assert worker.buy_orders[-i]['base']['amount'] < worker.buy_orders[i - 1]['base']['amount']
+        further_order_amount = worker.buy_orders[-i]['base']['amount']
+        closer_order_amount = worker.buy_orders[i - 1]['base']['amount']
+        assert further_order_amount < closer_order_amount
 
 
-@pytest.mark.xfail(reason='https://github.com/Codaone/DEXBot/issues/586')
 def test_increase_order_sizes_neutral_closest_order(worker, do_initial_allocation, issue_asset):
     """ Should test proper calculation of closest order: order should not be less that min_increase_factor
     """
@@ -695,9 +704,9 @@ def test_increase_order_sizes_neutral_closest_order(worker, do_initial_allocatio
     worker.increase_order_sizes('base', worker.base_balance, previous_buy_orders)
     worker.refresh_orders()
 
-    assert worker.buy_orders[0]['base']['amount'] - previous_buy_orders[0]['base']['amount'] >= previous_buy_orders[0][
-        'base'
-    ]['amount'] * (increase_factor - 1)
+    assert worker.buy_orders[0]['base']['amount'] - previous_buy_orders[0]['base']['amount'] == pytest.approx(
+        previous_buy_orders[0]['base']['amount'] * (increase_factor - 1), rel=(1 ** -worker.market['base']['precision'])
+    )
 
 
 def test_increase_order_sizes_buy_slope(worker, do_initial_allocation, issue_asset, increase_until_allocated):

From 3b35b6ccaa3e2e78720ae7c84ed33149785f26f8 Mon Sep 17 00:00:00 2001
From: Vladimir Kamarzin <vvk@vvk.pp.ru>
Date: Wed, 20 Feb 2019 00:10:27 +0500
Subject: [PATCH 13/19] Update furthest order increase in mountain mode

Don't allow too small increase steps in mountain mode. This will reduce
number of calculations.

Closes: #585
---
 dexbot/strategies/staggered_orders.py         | 23 ++++++++-----------
 .../test_staggered_orders_complex.py          | 12 +++++-----
 2 files changed, 16 insertions(+), 19 deletions(-)

diff --git a/dexbot/strategies/staggered_orders.py b/dexbot/strategies/staggered_orders.py
index 81be4e6e8..18e902d7a 100644
--- a/dexbot/strategies/staggered_orders.py
+++ b/dexbot/strategies/staggered_orders.py
@@ -970,29 +970,26 @@ def _calc_increase(self, asset, asset_balance, orders):
                         examining furthest order.
                     """
                     new_order_amount = further_bound
+                    increase_factor = max(1 + self.increment, self.min_increase_factor)
 
                     if not self.mountain_max_increase_mode:
-                        increase_factor = max(1 + self.increment, self.min_increase_factor)
+                        # Smooth increase for orders between furthest and closest (see docstring example)
                         new_order_amount = min(further_bound, order_amount * increase_factor)
 
                     if is_least_order:
+                        new_order_amount = order_amount * increase_factor
                         new_orders_sum = 0
                         amount = order_amount
                         for o in orders:
                             amount = amount * (1 + self.increment)
                             new_orders_sum += amount
-                        # To reduce allocation rounds, increase furthest order more
-                        new_order_amount = order_amount * (total_balance / new_orders_sum)
-
-                        if new_order_amount < closer_bound:
-                            """ This is for situations when calculated new_order_amount is not big enough to
-                                allocate all funds. Use partial-increment increase, so we'll got at least one full
-                                increase round.  Whether we will just use `new_order_amount = further_bound`, we will
-                                get less than one full allocation round, thus leaving closest-to-center order not
-                                increased.
-                            """
-                            new_order_amount = closer_bound / (1 + self.increment * 0.2)
-                        else:
+                        # To reduce allocation rounds, increase furthest order more if we can
+                        increased_amount = order_amount * (total_balance / new_orders_sum)
+
+                        if increased_amount > new_order_amount:
+                            self.log.debug('Correcting furthest order amount from {:.{prec}f} to: {:.{prec}f} {}'
+                                           .format(new_order_amount, increased_amount, symbol, prec=precision))
+                            new_order_amount = increased_amount
                             # Set bypass flag to not limit next orders
                             self.mountain_max_increase_mode = True
                             self.log.debug('Activating max increase mode for mountain mode')
diff --git a/tests/strategies/staggered_orders/test_staggered_orders_complex.py b/tests/strategies/staggered_orders/test_staggered_orders_complex.py
index 7bba306dc..f4d448f03 100644
--- a/tests/strategies/staggered_orders/test_staggered_orders_complex.py
+++ b/tests/strategies/staggered_orders/test_staggered_orders_complex.py
@@ -429,16 +429,15 @@ def test_increase_order_sizes_mountain_direction(worker, do_initial_allocation,
                 break
 
 
-@pytest.mark.xfail(reason='https://github.com/Codaone/DEXBot/issues/585')
 def test_increase_order_sizes_mountain_furthest_order(worker, do_initial_allocation, issue_asset):
     """ Should test proper calculation of furthest order: try to maximize, don't allow too small increase
     """
     do_initial_allocation(worker, 'mountain')
     worker.mode = 'mountain'
 
-    # Add balance to increase 2 orders
+    # Add balance to increase ~2 orders
     increase_factor = max(1 + worker.increment, worker.min_increase_factor)
-    to_issue = worker.buy_orders[0]['base']['amount'] * (increase_factor - 1) * 2
+    to_issue = worker.buy_orders[-1]['base']['amount'] * (increase_factor - 1) * 2.2
     issue_asset(worker.market['base']['symbol'], to_issue, worker.account.name)
 
     previous_buy_orders = worker.buy_orders
@@ -446,9 +445,10 @@ def test_increase_order_sizes_mountain_furthest_order(worker, do_initial_allocat
     worker.increase_order_sizes('base', worker.base_balance, previous_buy_orders)
     worker.refresh_orders()
 
-    assert worker.buy_orders[-1]['base']['amount'] - previous_buy_orders[-1]['base']['amount'] >= previous_buy_orders[
-        -1
-    ]['base']['amount'] * (increase_factor - 1)
+    assert worker.buy_orders[-1]['base']['amount'] - previous_buy_orders[-1]['base']['amount'] == pytest.approx(
+        previous_buy_orders[-1]['base']['amount'] * (increase_factor - 1),
+        rel=(1 ** -worker.market['base']['precision']),
+    )
 
 
 def test_increase_order_sizes_mountain_imbalanced(worker, do_initial_allocation):

From 1a8d9df591d0a79d08a3e4db7eccdee4a27d2868 Mon Sep 17 00:00:00 2001
From: Vladimir Kamarzin <vvk@vvk.pp.ru>
Date: Fri, 7 Jun 2019 16:03:20 +0500
Subject: [PATCH 14/19] Fix closest order increase in valley mode

---
 dexbot/strategies/staggered_orders.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dexbot/strategies/staggered_orders.py b/dexbot/strategies/staggered_orders.py
index 18e902d7a..d812a4a47 100644
--- a/dexbot/strategies/staggered_orders.py
+++ b/dexbot/strategies/staggered_orders.py
@@ -1052,7 +1052,7 @@ def _calc_increase(self, asset, asset_balance, orders):
                     new_amount = (total_balance / orders_count) / (1 + self.increment / 100)
                     if furthest_order_bound < new_amount > closer_order_bound:
                         # Maximize order up to max possible amount if we can
-                        closer_order_bound = new_amount
+                        closer_order_bound = closest_order_bound = new_amount
 
                 order_amount_normalized = order_amount * (1 + self.increment / 10)
                 need_increase = False

From 371339833649098f81b36a53ad3b594474ff6ed7 Mon Sep 17 00:00:00 2001
From: Vladimir Kamarzin <vvk@vvk.pp.ru>
Date: Fri, 7 Jun 2019 16:03:49 +0500
Subject: [PATCH 15/19] Fix closest order increase in neutral mode

---
 dexbot/strategies/staggered_orders.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/dexbot/strategies/staggered_orders.py b/dexbot/strategies/staggered_orders.py
index d812a4a47..c07277cd6 100644
--- a/dexbot/strategies/staggered_orders.py
+++ b/dexbot/strategies/staggered_orders.py
@@ -1178,8 +1178,8 @@ def _calc_increase(self, asset, asset_balance, orders):
                     # Order is less than further order and diff is more than `increment / 2`
                     # Order is also less than previously calculated closest_order_bound
                     if is_closest_order:
-                        # At first, maximize order as we can
-                        new_order_amount = max(closer_order_bound, further_order_bound)
+                        # At first, maximize order up to further_order_bound
+                        new_order_amount = min(closer_order_bound, further_order_bound)
                     else:
                         # Current order is less than virtually calculated next order (closest_order_bound)
                         # Do not allow to increase more than further order amount

From cbbb7c3ca10fe2b0c64aeb3f394fc13f624bf072 Mon Sep 17 00:00:00 2001
From: Vladimir Kamarzin <vvk@vvk.pp.ru>
Date: Fri, 7 Jun 2019 16:05:18 +0500
Subject: [PATCH 16/19] Reduce min_increase_factor

Because we're now calculating increased orders in memory, it's a good
idea to reduce min_increase_factor to allow more smooth distribution of
profits.
---
 dexbot/strategies/staggered_orders.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dexbot/strategies/staggered_orders.py b/dexbot/strategies/staggered_orders.py
index c07277cd6..61b1d3d1a 100644
--- a/dexbot/strategies/staggered_orders.py
+++ b/dexbot/strategies/staggered_orders.py
@@ -84,7 +84,7 @@ def __init__(self, *args, **kwargs):
         self.base_balance = None
         self.quote_asset_threshold = 0
         self.base_asset_threshold = 0
-        self.min_increase_factor = 1.15
+        self.min_increase_factor = 1.05
         self.mountain_max_increase_mode = False
         # Initial balance history elements should not be equal to avoid immediate bootstrap turn off
         self.quote_balance_history = [1, 2, 3]

From 399052175a8ff5d27dc660bb23ecfb57374255e9 Mon Sep 17 00:00:00 2001
From: Vladimir Kamarzin <vvk@vvk.pp.ru>
Date: Fri, 7 Jun 2019 16:07:09 +0500
Subject: [PATCH 17/19] Fix SO tests

Some tests were broken after increase logic related changes, this fixes
them.
---
 .../test_staggered_orders_complex.py          | 48 +++++++++++--------
 1 file changed, 28 insertions(+), 20 deletions(-)

diff --git a/tests/strategies/staggered_orders/test_staggered_orders_complex.py b/tests/strategies/staggered_orders/test_staggered_orders_complex.py
index f4d448f03..973a7c111 100644
--- a/tests/strategies/staggered_orders/test_staggered_orders_complex.py
+++ b/tests/strategies/staggered_orders/test_staggered_orders_complex.py
@@ -207,11 +207,11 @@ def test_increase_order_sizes_valley_direction(worker, do_initial_allocation, is
     """
     do_initial_allocation(worker, 'valley')
 
-    # Add balance to increase several orders
+    # Add balance to increase several orders; 1.01 to mitigate rounding issues
     increase_factor = max(1 + worker.increment, worker.min_increase_factor)
-    to_issue = worker.buy_orders[0]['base']['amount'] * (increase_factor - 1) * 3
+    to_issue = worker.buy_orders[0]['base']['amount'] * (increase_factor - 1) * 3 * 1.01
     issue_asset(worker.market['base']['symbol'], to_issue, worker.account.name)
-    to_issue = worker.sell_orders[0]['base']['amount'] * (increase_factor - 1) * 3
+    to_issue = worker.sell_orders[0]['base']['amount'] * (increase_factor - 1) * 3 * 1.01
     issue_asset(worker.market['quote']['symbol'], to_issue, worker.account.name)
 
     increase_until_allocated(worker)
@@ -293,9 +293,11 @@ def test_increase_order_sizes_valley_smaller_closest_orders(worker, do_initial_a
     num_orders_after = len(worker.own_orders)
     assert num_orders_before == num_orders_after
 
-    # New closest orders amount should be equal to initial ones
-    assert worker.buy_orders[0]['base']['amount'] == initial_base
-    assert worker.sell_orders[0]['base']['amount'] == initial_quote
+    # New orders amounts should be equal to initial ones
+    # TODO: this relaxed test checks next closest orders because due to fp calculations closest orders may remain not
+    # increased
+    assert worker.buy_orders[1]['base']['amount'] == initial_base
+    assert worker.sell_orders[1]['base']['amount'] == initial_quote
 
 
 def test_increase_order_sizes_valley_imbalaced_small_further(worker, do_initial_allocation, increase_until_allocated):
@@ -333,7 +335,7 @@ def test_increase_order_sizes_valley_imbalaced_small_further(worker, do_initial_
         worker.place_market_buy_order(to_buy, further_order['price'])
         worker.refresh_orders()
 
-    # Drop excess balance to only allow to one increase round
+    # Drop excess balance to only allow one increase round
     worker.refresh_balances()
     increase_factor = max(1 + worker.increment, worker.min_increase_factor)
     to_keep = base_limit * (increase_factor - 1) * num_orders_to_cancel * 2 * 1.01
@@ -364,9 +366,9 @@ def test_increase_order_sizes_valley_closest_order(worker, do_initial_allocation
     worker.increase_order_sizes('base', worker.base_balance, previous_buy_orders)
     worker.refresh_orders()
 
-    assert worker.buy_orders[0]['base']['amount'] - previous_buy_orders[0]['base']['amount'] >= previous_buy_orders[0][
-        'base'
-    ]['amount'] * (increase_factor - 1)
+    assert worker.buy_orders[0]['base']['amount'] - previous_buy_orders[0]['base']['amount'] == pytest.approx(
+        previous_buy_orders[0]['base']['amount'] * (increase_factor - 1)
+    )
 
 
 def test_increase_order_sizes_mountain_basic(worker, do_initial_allocation, issue_asset, increase_until_allocated):
@@ -408,9 +410,9 @@ def test_increase_order_sizes_mountain_direction(worker, do_initial_allocation,
     worker.mode = 'mountain'
     increase_factor = max(1 + worker.increment, worker.min_increase_factor)
 
-    for _ in range(0, 6):
+    for i in range(-1, -6, -1):
         # Add balance to increase ~1 order
-        to_issue = worker.buy_orders[0]['base']['amount'] * (increase_factor - 1)
+        to_issue = worker.buy_orders[i]['base']['amount'] * (increase_factor - 1)
         issue_asset(worker.market['base']['symbol'], to_issue, worker.account.name)
         previous_buy_orders = worker.buy_orders
         worker.refresh_balances()
@@ -429,15 +431,18 @@ def test_increase_order_sizes_mountain_direction(worker, do_initial_allocation,
                 break
 
 
-def test_increase_order_sizes_mountain_furthest_order(worker, do_initial_allocation, issue_asset):
+def test_increase_order_sizes_mountain_furthest_order(
+    worker, do_initial_allocation, increase_until_allocated, issue_asset
+):
     """ Should test proper calculation of furthest order: try to maximize, don't allow too small increase
     """
     do_initial_allocation(worker, 'mountain')
     worker.mode = 'mountain'
+    increase_until_allocated(worker)
 
     # Add balance to increase ~2 orders
     increase_factor = max(1 + worker.increment, worker.min_increase_factor)
-    to_issue = worker.buy_orders[-1]['base']['amount'] * (increase_factor - 1) * 2.2
+    to_issue = worker.buy_orders[-1]['base']['amount'] * (increase_factor - 1) * 2.01
     issue_asset(worker.market['base']['symbol'], to_issue, worker.account.name)
 
     previous_buy_orders = worker.buy_orders
@@ -484,7 +489,7 @@ def test_increase_order_sizes_mountain_imbalanced(worker, do_initial_allocation)
 
     for _ in range(0, num_orders_to_cancel):
         worker.refresh_balances()
-        worker.increase_order_sizes('base', worker.base_balance, previous_buy_orders)
+        worker.increase_order_sizes('base', worker.base_balance, worker.buy_orders)
         worker.refresh_orders()
 
     for order_index in range(0, num_orders_to_cancel):
@@ -665,16 +670,16 @@ def test_increase_order_sizes_neutral_imbalaced_small_further(worker, do_initial
     worker.place_market_buy_order(base_limit / further_order['price'], further_order['price'])
     worker.refresh_orders()
 
-    # Place remainig limited orders
+    # Place remaining limited orders
     for i in range(1, num_orders_to_cancel):
         worker.place_closer_order('base', worker.buy_orders[0])
         worker.place_further_order('base', worker.buy_orders[-1])
         worker.refresh_orders()
 
-    # Drop excess balance to only allow to one increase round
+    # Drop excess balance to only allow one increase round
     worker.refresh_balances()
     increase_factor = max(1 + worker.increment, worker.min_increase_factor)
-    to_keep = base_limit * (increase_factor - 1) * num_orders_to_cancel * 2 * 1.1
+    to_keep = base_limit * (increase_factor - 1) * num_orders_to_cancel * 2
     to_drop = worker.base_balance['amount'] - to_keep
     amount = Amount(to_drop, worker.market['base']['symbol'], bitshares_instance=worker.bitshares)
     worker.bitshares.reserve(amount, account=worker.account)
@@ -683,16 +688,19 @@ def test_increase_order_sizes_neutral_imbalaced_small_further(worker, do_initial
 
     for i in range(1, num_orders_to_cancel):
         # This is a simple check without precise calculation
-        # We're roughly checking that new furthest orders are not exceed new closest orders
+        # We're roughly checking that new furthest orders are not exceeds new closest orders
         further_order_amount = worker.buy_orders[-i]['base']['amount']
         closer_order_amount = worker.buy_orders[i - 1]['base']['amount']
         assert further_order_amount < closer_order_amount
 
 
-def test_increase_order_sizes_neutral_closest_order(worker, do_initial_allocation, issue_asset):
+def test_increase_order_sizes_neutral_closest_order(
+    worker, do_initial_allocation, increase_until_allocated, issue_asset
+):
     """ Should test proper calculation of closest order: order should not be less that min_increase_factor
     """
     worker = do_initial_allocation(worker, 'neutral')
+    increase_until_allocated(worker)
 
     # Add balance to increase 2 orders
     increase_factor = max(1 + worker.increment, worker.min_increase_factor)

From 7e3f79c4ebde7c20ea02e6f1ba903fbb7ae60e17 Mon Sep 17 00:00:00 2001
From: Vladimir Kamarzin <vvk@vvk.pp.ru>
Date: Fri, 7 Jun 2019 16:48:09 +0500
Subject: [PATCH 18/19] A bit cleaner log message

---
 dexbot/strategies/staggered_orders.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dexbot/strategies/staggered_orders.py b/dexbot/strategies/staggered_orders.py
index 61b1d3d1a..317f063a0 100644
--- a/dexbot/strategies/staggered_orders.py
+++ b/dexbot/strategies/staggered_orders.py
@@ -1281,7 +1281,7 @@ def increase_order_sizes(self, asset, asset_balance, orders):
                 old_opposite_amount = orders[index]['quote']['amount']
                 new_opposite_amount = order['quote']['amount']
                 self.log.info(
-                    'Increasing {} order at price {:.8f}, {:.{prec}f} -> {:.{prec}f} {}, '
+                    'Increasing {} order at price {:.8f}: {:.{prec}f} -> {:.{prec}f} {} '
                     '({:.{opposite_prec}f} -> {:.{opposite_prec}f} {})'.format(
                         order_type,
                         price,

From ab6a7ff96cc1a9469d4324f436954ee798b676ac Mon Sep 17 00:00:00 2001
From: Vladimir Kamarzin <vvk@vvk.pp.ru>
Date: Fri, 7 Jun 2019 17:02:13 +0500
Subject: [PATCH 19/19] Enable previosly xfailed test

test_increase_order_sizes_neutral_smaller_closest_orders is working if
some approximation allowed.
---
 .../staggered_orders/test_staggered_orders_complex.py    | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/tests/strategies/staggered_orders/test_staggered_orders_complex.py b/tests/strategies/staggered_orders/test_staggered_orders_complex.py
index 973a7c111..5a5be5844 100644
--- a/tests/strategies/staggered_orders/test_staggered_orders_complex.py
+++ b/tests/strategies/staggered_orders/test_staggered_orders_complex.py
@@ -598,7 +598,6 @@ def test_increase_order_sizes_neutral_transit_from_mountain(worker, do_initial_a
                 break
 
 
-@pytest.mark.xfail(reason='Closest order failed to increase up to initial balance, fp/rounding issue')
 def test_increase_order_sizes_neutral_smaller_closest_orders(worker, do_initial_allocation, increase_until_allocated):
     """ Test increase when closest-to-center orders are less than further orders. Normal situation when initial sides
         are imbalanced and several orders were filled.
@@ -634,8 +633,12 @@ def test_increase_order_sizes_neutral_smaller_closest_orders(worker, do_initial_
     increase_until_allocated(worker)
 
     # New closest orders amount should be equal to initial ones
-    assert worker.buy_orders[0]['base']['amount'] == initial_base
-    assert worker.sell_orders[0]['base']['amount'] == initial_quote
+    assert worker.buy_orders[0]['base']['amount'] == pytest.approx(
+        initial_base, rel=(1 ** -worker.market['base']['precision'])
+    )
+    assert worker.sell_orders[0]['base']['amount'] == pytest.approx(
+        initial_quote, rel=(1 ** -worker.market['quote']['precision'])
+    )
 
 
 def test_increase_order_sizes_neutral_imbalaced_small_further(worker, do_initial_allocation, increase_until_allocated):