Repository: hummingbot/hummingbot
Pull request: Feat / deprecate market order type
**Before submitting this PR, please make sure**:
- [x] Your code builds clean without any errors or warnings
- [x] You are using approved title ("feat/", "fix/", "docs/", "refactor/", etc)
- [x] Deprecate MARKER OrderType in all CEXs connectors
- [x] Modify PMM and ARB to work with recent changes
- [ ] Modify XMM to work with recent changes
- [ ] Update documentation


**Optional**:
- Related Github issue: #1911 
- Related Clubhouse Story: [ch9539]


**A description of the changes proposed in the pull request**:


Problem statement:
[Feature] Deprecate Market Order Type
**Feature Suggestion**
Simply put, there is no use for Market order type in automated trading system.
Limit order will cover most cases, if you want your order to be filled immediately, simply set the price which will likely be filled.

Using market order type has following disadvantages:
- It makes strategy vulnerable to attack, especially for open source project like ours. For example, a counter trading strategy to Arbitrage strategy can be achieved by flashing a maker order (placing order and immediately canceling it) and having another order waiting to be filled at advantaged price.
- Market order has no price, in our code base we have to cater for 2 different data structures for orders.

**Tasks / Implications:**
- All current market connectors, `order_book`, `strategy_base` and their unit tests need refactoring 
- XEMM is still currently using Market order type on the taker side, we'll need to update this to use Limit order - similar to how we update Arbitrage strategy
- Update `order_book.c_get_fee` to remove order_type argument and added in `is_maker` argument, this will require update to `Hummingsim` as well

Hints from issue discussion:

Commit message: (fix) correct Jenkins error related to mock testing

Patch to review:
diff --git a/documentation/docs/developers/tutorial/perform-trade.md b/documentation/docs/developers/tutorial/perform-trade.md
index 3cfcc181b54..e5e25fd5a12 100644
--- a/documentation/docs/developers/tutorial/perform-trade.md
+++ b/documentation/docs/developers/tutorial/perform-trade.md
@@ -30,7 +30,7 @@ The OrderTracker class includes functions monitoring when order tracking begins,
 
 The order state, specifically, whether the order is partially or completely filled is managed by events in the MarketBase class. Specifically, the logic regarding order creation, cancelation, filling, and completion can be found in the following functions in [market_base.pyx](https://github.com/CoinAlpha/hummingbot/blob/master/hummingbot/market/market_base.pyx): `buy()`, `sell()`, `cancel()`, `get_order_price_quantum()` (gets the required or allowed order price), and `get_order_size_quantum()` (gets the required or allowed order size).
 
-The order tracking logic can be found in the `c_start_tracking_limit_order()`, `c_stop_tracking_limit_order()`, `c_has_in_flight_cancel()` and `c_check_and_track_cancel()` function inside [order_tracker.pyx](https://github.com/CoinAlpha/hummingbot/blob/master/hummingbot/strategy/order_tracker.pyx).
+The order tracking logic can be found in the `c_start_tracking_maker_order()`, `c_stop_tracking_maker_order()`, `c_has_in_flight_cancel()` and `c_check_and_track_cancel()` function inside [order_tracker.pyx](https://github.com/CoinAlpha/hummingbot/blob/master/hummingbot/strategy/order_tracker.pyx).
 
 ## Logging
 
diff --git a/hummingbot/core/data_type/trade.py b/hummingbot/core/data_type/trade.py
index 78f2b08fdec..ef9e25edf50 100644
--- a/hummingbot/core/data_type/trade.py
+++ b/hummingbot/core/data_type/trade.py
@@ -45,7 +45,7 @@ def to_pandas(cls, trades: List):
                 trade.trading_pair,
                 trade.price,
                 trade.amount,
-                "market" if trade.order_type is OrderType.MARKET else "limit",
+                "limit" if trade.order_type is OrderType.LIMIT else "limit_maker",
                 "buy" if trade.side is TradeType.BUY else "sell",
                 trade.market,
                 datetime.fromtimestamp(trade.timestamp).strftime("%Y-%m-%d %H:%M:%S"),
diff --git a/hummingbot/core/event/events.py b/hummingbot/core/event/events.py
index e31cf0e9000..a8a5fa0bcc1 100644
--- a/hummingbot/core/event/events.py
+++ b/hummingbot/core/event/events.py
@@ -63,12 +63,8 @@ class TradeType(Enum):
 
 
 class OrderType(Enum):
-    MARKET = 1
-    LIMIT = 2
-    LIMIT_MAKER = 3
-
-    def is_limit_type(self):
-        return self in (OrderType.LIMIT, OrderType.LIMIT_MAKER)
+    LIMIT = 1
+    LIMIT_MAKER = 2
 
 
 class PriceType(Enum):
diff --git a/hummingbot/market/bamboo_relay/bamboo_relay_market.pxd b/hummingbot/market/bamboo_relay/bamboo_relay_market.pxd
index c64ef91ad2f..7e269858dd1 100755
--- a/hummingbot/market/bamboo_relay/bamboo_relay_market.pxd
+++ b/hummingbot/market/bamboo_relay/bamboo_relay_market.pxd
@@ -19,9 +19,9 @@ cdef class BambooRelayMarket(MarketBase):
         double _last_update_trading_rules_timestamp
         double _last_update_available_balance_timestamp
         double _poll_interval
-        dict _in_flight_limit_orders
-        dict _in_flight_market_orders
-        object _in_flight_pending_limit_orders
+        dict _in_flight_maker_orders
+        dict _in_flight_taker_orders
+        object _in_flight_pending_maker_orders
         object _in_flight_cancels
         object _in_flight_pending_cancels
         list _filled_order_hashes
@@ -44,7 +44,7 @@ cdef class BambooRelayMarket(MarketBase):
         str _coordinator_address
         str _fee_recipient_address
 
-    cdef c_start_tracking_limit_order(self,
+    cdef c_start_tracking_maker_order(self,
                                       str order_id,
                                       str exchange_order_id,
                                       str trading_pair,
@@ -55,7 +55,7 @@ cdef class BambooRelayMarket(MarketBase):
                                       object amount,
                                       int expires,
                                       object zero_ex_order)
-    cdef c_start_tracking_market_order(self,
+    cdef c_start_tracking_taker_order(self,
                                        str order_id,
                                        str trading_pair,
                                        object order_type,
diff --git a/hummingbot/market/bamboo_relay/bamboo_relay_market.pyx b/hummingbot/market/bamboo_relay/bamboo_relay_market.pyx
index 4b85fb448c8..ff4913a37ca 100755
--- a/hummingbot/market/bamboo_relay/bamboo_relay_market.pyx
+++ b/hummingbot/market/bamboo_relay/bamboo_relay_market.pyx
@@ -174,9 +174,9 @@ cdef class BambooRelayMarket(MarketBase):
         self._last_update_trading_rules_timestamp = 0
         self._last_update_available_balance_timestamp = 0
         self._poll_interval = poll_interval
-        self._in_flight_limit_orders = {}   # limit orders are off chain
-        self._in_flight_market_orders = {}  # market orders are on chain
-        self._in_flight_pending_limit_orders = OrderedDict()  # in the case that an order needs to be cancelled before its been accepted
+        self._in_flight_maker_orders = {}   # maker(limit) orders are off chain
+        self._in_flight_taker_orders = {}  # taker(market) orders are on chain
+        self._in_flight_pending_maker_orders = OrderedDict()  # in the case that an order needs to be cancelled before its been accepted
         self._in_flight_cancels = OrderedDict()
         self._in_flight_pending_cancels = OrderedDict()
         self._filled_order_hashes = []      # To prevent market filling trying to overfill an inflight market order that's pending
@@ -286,12 +286,12 @@ cdef class BambooRelayMarket(MarketBase):
         return self._trading_rules
 
     @property
-    def in_flight_limit_orders(self) -> Dict[str, BambooRelayInFlightOrder]:
-        return self._in_flight_limit_orders
+    def in_flight_maker_orders(self) -> Dict[str, BambooRelayInFlightOrder]:
+        return self._in_flight_maker_orders
 
     @property
-    def in_flight_market_orders(self) -> Dict[str, BambooRelayInFlightOrder]:
-        return self._in_flight_market_orders
+    def in_flight_taker_orders(self) -> Dict[str, BambooRelayInFlightOrder]:
+        return self._in_flight_taker_orders
 
     @property
     def limit_orders(self) -> List[LimitOrder]:
@@ -302,10 +302,10 @@ cdef class BambooRelayMarket(MarketBase):
             str quote_currency
             set expiring_order_ids = set([order_id for _, order_id in self._order_expiry_queue])
 
-        for in_flight_order in self._in_flight_limit_orders.values():
+        for in_flight_order in self._in_flight_maker_orders.values():
             typed_in_flight_order = in_flight_order
             # Skip orders that are or have been cancelled but are still being tracked
-            if (typed_in_flight_order.order_type is not OrderType.LIMIT or
+            if (typed_in_flight_order.order_type is not OrderType.LIMIT_MAKER or
                     typed_in_flight_order.client_order_id in expiring_order_ids or
                     typed_in_flight_order.client_order_id in self._in_flight_cancels or
                     typed_in_flight_order.client_order_id in self._in_flight_pending_cancels or
@@ -319,18 +319,18 @@ cdef class BambooRelayMarket(MarketBase):
         return {
             "market_orders": {
                 key: value.to_json()
-                for key, value in self._in_flight_market_orders.items()
+                for key, value in self._in_flight_taker_orders.items()
             },
             "limit_orders": {
                 key: value.to_json()
-                for key, value in self._in_flight_limit_orders.items()
+                for key, value in self._in_flight_maker_orders.items()
             }
         }
 
     def reset_state(self):
-        self._in_flight_market_orders = {}
-        self._in_flight_limit_orders = {}
-        self._in_flight_pending_limit_orders = OrderedDict()
+        self._in_flight_taker_orders = {}
+        self._in_flight_maker_orders = {}
+        self._in_flight_pending_maker_orders = OrderedDict()
         self._in_flight_cancels = OrderedDict()
         self._in_flight_pending_cancels = OrderedDict()
         self._order_expiry_queue = deque()
@@ -338,25 +338,25 @@ cdef class BambooRelayMarket(MarketBase):
     def restore_tracking_states(self, saved_states: Dict[str, any]):
         # ignore saved orders that may not reflect current version schema
         try:
-            self._in_flight_market_orders.update({
+            self._in_flight_taker_orders.update({
                 key: BambooRelayInFlightOrder.from_json(value)
                 for key, value in saved_states["market_orders"].items()
             })
-            self._in_flight_limit_orders.update({
+            self._in_flight_maker_orders.update({
                 key: BambooRelayInFlightOrder.from_json(value)
                 for key, value in saved_states["limit_orders"].items()
             })
 
             # if completed/cancelled orders are restored they should become untracked
-            if len(self._in_flight_limit_orders) >= 0:
-                for order in list(self._in_flight_limit_orders.values()):
+            if len(self._in_flight_maker_orders) >= 0:
+                for order in list(self._in_flight_maker_orders.values()):
                     if (order.is_cancelled or
                             order.has_been_cancelled or
                             order.is_expired or
                             order.is_failure or
                             order.is_done or
                             order.expires < self._current_timestamp):
-                        del self._in_flight_limit_orders[order.client_order_id]
+                        del self._in_flight_maker_orders[order.client_order_id]
         except Exception:
             self.logger().error(f"Error restoring tracking states.", exc_info=True)
 
@@ -427,7 +427,7 @@ cdef class BambooRelayMarket(MarketBase):
         return TradeFee(percent=s_decimal_0, flat_fees=[("ETH", protocol_fee),
                                                         ("ETH", transaction_cost_eth)])
         """
-        is_maker = order_type is OrderType.LIMIT
+        is_maker = order_type is OrderType.LIMIT_MAKER
         return estimate_fee("bamboo_relay", is_maker)
 
     def _update_balances(self):
@@ -444,10 +444,10 @@ cdef class BambooRelayMarket(MarketBase):
 
         if current_timestamp - self._last_update_available_balance_timestamp > 10.0:
 
-            if len(self._in_flight_limit_orders) >= 0:
+            if len(self._in_flight_maker_orders) >= 0:
                 total_balances = self._account_balances
 
-                for order in self._in_flight_limit_orders.values():
+                for order in self._in_flight_maker_orders.values():
                     # Orders that are done, cancelled or expired don't deduct from the available balance
                     if (not order.is_cancelled and
                             not order.has_been_cancelled and
@@ -463,7 +463,7 @@ cdef class BambooRelayMarket(MarketBase):
                             amount = Decimal(order.amount)
                         locked_balances[currency] = locked_balances.get(currency, s_decimal_0) + amount
 
-                for order in self._in_flight_market_orders.values():
+                for order in self._in_flight_taker_orders.values():
                     # Market orders are only tracked for their transaction duration
                     pair_split = order.trading_pair.split("-")
                     if order.trade_type is TradeType.BUY:
@@ -568,7 +568,7 @@ cdef class BambooRelayMarket(MarketBase):
             int quote_asset_decimals
             BambooRelayInFlightOrder tracked_limit_order
 
-        tracked_limit_orders = list(self._in_flight_limit_orders.values())
+        tracked_limit_orders = list(self._in_flight_maker_orders.values())
 
         for tracked_limit_order in tracked_limit_orders:
             if tracked_limit_order.exchange_order_id == fill_event.order_hash:
@@ -605,7 +605,7 @@ cdef class BambooRelayMarket(MarketBase):
                         tracked_limit_order.executed_amount_base = tracked_limit_order.executed_amount_base + order_filled_base_token_amount
                         tracked_limit_order.executed_amount_quote = tracked_limit_order.executed_amount_quote + order_filled_quote_token_amount
                         self.logger().info(f"Filled {order_filled_base_token_amount} out of {tracked_limit_order.amount} of the "
-                                           f"limit order {tracked_limit_order.client_order_id} according to the RPC transaction logs.")
+                                           f"limit maker order {tracked_limit_order.client_order_id} according to the RPC transaction logs.")
                         self.c_trigger_event(
                             self.MARKET_ORDER_FILLED_EVENT_TAG,
                             OrderFilledEvent(
@@ -613,7 +613,7 @@ cdef class BambooRelayMarket(MarketBase):
                                 tracked_limit_order.client_order_id,
                                 tracked_limit_order.trading_pair,
                                 tracked_limit_order.trade_type,
-                                OrderType.LIMIT,
+                                OrderType.LIMIT_MAKER,
                                 tracked_limit_order.price,
                                 order_filled_base_token_amount,
                                 TradeFee(0.0),  # no fee for limit order fills
@@ -626,7 +626,7 @@ cdef class BambooRelayMarket(MarketBase):
                         # Remove from log tracking
                         safe_ensure_future(self._wallet.current_backend.zeroex_fill_watcher.unwatch_order_hash(tracked_limit_order.exchange_order_id))
                         if tracked_limit_order.trade_type is TradeType.BUY:
-                            self.logger().info(f"The limit buy order {tracked_limit_order.client_order_id} "
+                            self.logger().info(f"The limit maker buy order {tracked_limit_order.client_order_id} "
                                                f"has completed according to the RPC transaction logs.")
                             self.c_trigger_event(self.MARKET_BUY_ORDER_COMPLETED_EVENT_TAG,
                                                  BuyOrderCompletedEvent(current_timestamp,
@@ -637,9 +637,9 @@ cdef class BambooRelayMarket(MarketBase):
                                                                         tracked_limit_order.executed_amount_base,
                                                                         tracked_limit_order.executed_amount_quote,
                                                                         tracked_limit_order.protocol_fee_amount,
-                                                                        OrderType.LIMIT))
+                                                                        OrderType.LIMIT_MAKER))
                         else:
-                            self.logger().info(f"The limit sell order {tracked_limit_order.client_order_id} "
+                            self.logger().info(f"The limit maker sell order {tracked_limit_order.client_order_id} "
                                                f"has completed according to the RPC transaction logs.")
                             self.c_trigger_event(self.MARKET_SELL_ORDER_COMPLETED_EVENT_TAG,
                                                  SellOrderCompletedEvent(current_timestamp,
@@ -650,7 +650,7 @@ cdef class BambooRelayMarket(MarketBase):
                                                                          tracked_limit_order.executed_amount_base,
                                                                          tracked_limit_order.executed_amount_quote,
                                                                          tracked_limit_order.protocol_fee_amount,
-                                                                         OrderType.LIMIT))
+                                                                         OrderType.LIMIT_MAKER))
                 return
 
     async def _update_limit_order_status(self):
@@ -669,8 +669,8 @@ cdef class BambooRelayMarket(MarketBase):
         cdef:
             BambooRelayInFlightOrder tracked_limit_order
 
-        if len(self._in_flight_limit_orders) > 0:
-            tracked_limit_orders = list(self._in_flight_limit_orders.values())
+        if len(self._in_flight_maker_orders) > 0:
+            tracked_limit_orders = list(self._in_flight_maker_orders.values())
             order_updates = await self._get_order_updates(tracked_limit_orders)
             # Every limit order update happens on this tick, so use the current timestamp
             current_timestamp = self._current_timestamp
@@ -720,7 +720,7 @@ cdef class BambooRelayMarket(MarketBase):
                     tracked_limit_order.executed_amount_base = tracked_limit_order.executed_amount_base + order_filled_base_token_amount
                     tracked_limit_order.executed_amount_quote = tracked_limit_order.executed_amount_quote + order_filled_quote_token_amount
                     self.logger().info(f"Filled {order_filled_base_token_amount} out of {tracked_limit_order.amount} of the "
-                                       f"limit order {tracked_limit_order.client_order_id} according to order status API.")
+                                       f"limit maker order {tracked_limit_order.client_order_id} according to order status API.")
                     self.c_trigger_event(
                         self.MARKET_ORDER_FILLED_EVENT_TAG,
                         OrderFilledEvent(
@@ -728,7 +728,7 @@ cdef class BambooRelayMarket(MarketBase):
                             tracked_limit_order.client_order_id,
                             tracked_limit_order.trading_pair,
                             tracked_limit_order.trade_type,
-                            OrderType.LIMIT,
+                            OrderType.LIMIT_MAKER,
                             tracked_limit_order.price,
                             order_filled_base_token_amount,
                             TradeFee(0.0),  # no fee for limit order fills
@@ -779,21 +779,21 @@ cdef class BambooRelayMarket(MarketBase):
                         OrderExpiredEvent(current_timestamp, tracked_limit_order.client_order_id)
                     )
                 elif not previous_is_failure and tracked_limit_order.is_failure:
-                    self.logger().info(f"The limit order {tracked_limit_order.client_order_id} has failed "
+                    self.logger().info(f"The limit maker order {tracked_limit_order.client_order_id} has failed "
                                        f"according to order status API.")
                     self.c_expire_order(tracked_limit_order.client_order_id, 30)
                     self.c_trigger_event(
                         self.MARKET_ORDER_FAILURE_EVENT_TAG,
                         MarketOrderFailureEvent(current_timestamp,
                                                 tracked_limit_order.client_order_id,
-                                                OrderType.LIMIT)
+                                                OrderType.LIMIT_MAKER)
                     )
                 elif not previous_is_done and tracked_limit_order.is_done:
                     self.c_expire_order(tracked_limit_order.client_order_id, 60)
                     # Remove from log tracking
                     await self._wallet.current_backend.zeroex_fill_watcher.unwatch_order_hash(tracked_limit_order.exchange_order_id)
                     if tracked_limit_order.trade_type is TradeType.BUY:
-                        self.logger().info(f"The limit buy order {tracked_limit_order.client_order_id} "
+                        self.logger().info(f"The limit maker buy order {tracked_limit_order.client_order_id} "
                                            f"has completed according to order status API.")
                         self.c_trigger_event(self.MARKET_BUY_ORDER_COMPLETED_EVENT_TAG,
                                              BuyOrderCompletedEvent(current_timestamp,
@@ -804,9 +804,9 @@ cdef class BambooRelayMarket(MarketBase):
                                                                     tracked_limit_order.executed_amount_base,
                                                                     tracked_limit_order.executed_amount_quote,
                                                                     tracked_limit_order.protocol_fee_amount,
-                                                                    OrderType.LIMIT))
+                                                                    OrderType.LIMIT_MAKER))
                     else:
-                        self.logger().info(f"The limit sell order {tracked_limit_order.client_order_id} "
+                        self.logger().info(f"The limit maker sell order {tracked_limit_order.client_order_id} "
                                            f"has completed according to order status API.")
                         self.c_trigger_event(self.MARKET_SELL_ORDER_COMPLETED_EVENT_TAG,
                                              SellOrderCompletedEvent(current_timestamp,
@@ -817,7 +817,7 @@ cdef class BambooRelayMarket(MarketBase):
                                                                      tracked_limit_order.executed_amount_base,
                                                                      tracked_limit_order.executed_amount_quote,
                                                                      tracked_limit_order.protocol_fee_amount,
-                                                                     OrderType.LIMIT))
+                                                                     OrderType.LIMIT_MAKER))
                 elif self._pre_emptive_soft_cancels and (
                         tracked_limit_order.is_coordinated and
                         not tracked_limit_order.is_cancelled and
@@ -842,8 +842,8 @@ cdef class BambooRelayMarket(MarketBase):
         if current_timestamp - self._last_update_market_order_timestamp <= self.UPDATE_MARKET_ORDERS_INTERVAL:
             return
 
-        if len(self._in_flight_market_orders) > 0:
-            tracked_market_orders = list(self._in_flight_market_orders.values())
+        if len(self._in_flight_taker_orders) > 0:
+            tracked_market_orders = list(self._in_flight_taker_orders.values())
             for tracked_market_order in tracked_market_orders:
                 receipt = self.get_tx_hash_receipt(tracked_market_order.tx_hash)
                 # Receipt exists and has been mined
@@ -857,7 +857,7 @@ cdef class BambooRelayMarket(MarketBase):
                         self.MARKET_ORDER_FAILURE_EVENT_TAG,
                         MarketOrderFailureEvent(self._current_timestamp,
                                                 tracked_market_order.client_order_id,
-                                                OrderType.MARKET)
+                                                OrderType.LIMIT)
                     )
                 elif receipt["status"] == 1:
                     gas_used = float(receipt.get("gasUsed", 0.0))
@@ -868,7 +868,7 @@ cdef class BambooRelayMarket(MarketBase):
                             tracked_market_order.client_order_id,
                             tracked_market_order.trading_pair,
                             tracked_market_order.trade_type,
-                            OrderType.MARKET,
+                            OrderType.LIMIT,
                             tracked_market_order.price,
                             tracked_market_order.amount,
                             TradeFee(0.0, [("ETH", gas_used), ("ETH", tracked_market_order.protocol_fee_amount)]),
@@ -888,7 +888,7 @@ cdef class BambooRelayMarket(MarketBase):
                                                                     tracked_market_order.amount,
                                                                     tracked_market_order.executed_amount_quote,
                                                                     tracked_market_order.protocol_fee_amount,
-                                                                    OrderType.MARKET))
+                                                                    OrderType.LIMIT))
                     else:
                         self.logger().info(f"The market sell order "
                                            f"{tracked_market_order.client_order_id} has completed according to "
@@ -902,7 +902,7 @@ cdef class BambooRelayMarket(MarketBase):
                                                                      tracked_market_order.amount,
                                                                      tracked_market_order.executed_amount_quote,
                                                                      tracked_market_order.protocol_fee_amount,
-                                                                     OrderType.MARKET))
+                                                                     OrderType.LIMIT))
                 else:
                     err_msg = (f"Unrecognized transaction status for market order "
                                f"{tracked_market_order.client_order_id}. Check transaction hash "
@@ -912,7 +912,7 @@ cdef class BambooRelayMarket(MarketBase):
                         self.MARKET_ORDER_FAILURE_EVENT_TAG,
                         MarketOrderFailureEvent(self._current_timestamp,
                                                 tracked_market_order.client_order_id,
-                                                OrderType.MARKET)
+                                                OrderType.LIMIT)
                     )
 
                 self.c_stop_tracking_order(tracked_market_order.tx_hash)
@@ -1290,7 +1290,7 @@ cdef class BambooRelayMarket(MarketBase):
             int order_timestamp_diff
             double current_timestamp
 
-        in_flight_limit_orders = self._in_flight_limit_orders.values()
+        in_flight_limit_orders = self._in_flight_maker_orders.values()
         incomplete_order_ids = []
         incomplete_orders = []
         has_coordinated_order = False
@@ -1394,7 +1394,7 @@ cdef class BambooRelayMarket(MarketBase):
             object amount_to_fill = q_amt
             TradingRule trading_rule = self._trading_rules[trading_pair]
             str trade_type_desc = "buy" if trade_type is TradeType.BUY else "sell"
-            str type_str = "limit" if order_type is OrderType.LIMIT else "market"
+            str type_str = "limit" if order_type is OrderType.LIMIT else "limit_maker"
         try:
             if q_amt < trading_rule.min_order_size:
                 raise ValueError(f"{trade_type_desc.capitalize()} order amount {q_amt} is lower than the "
@@ -1403,11 +1403,11 @@ cdef class BambooRelayMarket(MarketBase):
                 raise ValueError(f"{trade_type_desc.capitalize()} order amount {q_amt} is greater than the "
                                  f"maximum order size {trading_rule.max_order_size}")
 
-            if order_type is OrderType.LIMIT:
+            if order_type is OrderType.LIMIT_MAKER:
                 if math.isnan(price):
-                    raise ValueError(f"Limit orders require a price. Aborting.")
+                    raise ValueError(f"Limit maker orders require a price. Aborting.")
                 elif expires is None:
-                    raise ValueError(f"Limit orders require an expiration timestamp 'expiration_ts'. Aborting.")
+                    raise ValueError(f"Limit maker orders require an expiration timestamp 'expiration_ts'. Aborting.")
                 elif expires < time.time():
                     raise ValueError(f"expiration time {expires} must be greater than current time {time.time()}")
                 else:
@@ -1418,7 +1418,7 @@ cdef class BambooRelayMarket(MarketBase):
                                                                                      amount=q_amt,
                                                                                      price=q_price,
                                                                                      expires=expires)
-                    self.c_start_tracking_limit_order(order_id=order_id,
+                    self.c_start_tracking_maker_order(order_id=order_id,
                                                       exchange_order_id=exchange_order_id,
                                                       trading_pair=trading_pair,
                                                       order_type=order_type,
@@ -1434,7 +1434,7 @@ cdef class BambooRelayMarket(MarketBase):
                             del self._in_flight_pending_cancels[order_id]
                             self.c_cancel("", order_id)
                         del self._in_flight_pending_limit_orders[order_id]
-            elif order_type is OrderType.MARKET:
+            elif order_type is OrderType.LIMIT:
                 (amount_to_fill,
                  avg_price,
                  tx_hash,
@@ -1444,7 +1444,7 @@ cdef class BambooRelayMarket(MarketBase):
                                                                   amount=q_amt,
                                                                   price=price)
                 q_price = self.c_quantize_order_price(trading_pair, Decimal(avg_price))
-                self.c_start_tracking_market_order(order_id=order_id,
+                self.c_start_tracking_taker_order(order_id=order_id,
                                                    trading_pair=trading_pair,
                                                    order_type=order_type,
                                                    is_coordinated=is_coordinated,
@@ -1491,7 +1491,7 @@ cdef class BambooRelayMarket(MarketBase):
     cdef str c_buy(self,
                    str trading_pair,
                    object amount,
-                   object order_type=OrderType.MARKET,
+                   object order_type=OrderType.LIMIT,
                    object price=s_decimal_NaN,
                    dict kwargs={}):
         cdef:
@@ -1503,7 +1503,7 @@ cdef class BambooRelayMarket(MarketBase):
             expires = int(expires)
         else:
             expires = int(current_timestamp) + 120
-        if order_type is OrderType.LIMIT:
+        if order_type is OrderType.LIMIT_MAKER:
             # Don't spam the server endpoint if a order placement failed recently
             if current_timestamp - self._last_failed_limit_order_timestamp <= self.ORDER_CREATION_BACKOFF_TIME:
                 raise
@@ -1521,7 +1521,7 @@ cdef class BambooRelayMarket(MarketBase):
     cdef str c_sell(self,
                     str trading_pair,
                     object amount,
-                    object order_type=OrderType.MARKET,
+                    object order_type=OrderType.LIMIT,
                     object price=s_decimal_NaN,
                     dict kwargs={}):
         cdef:
@@ -1533,7 +1533,7 @@ cdef class BambooRelayMarket(MarketBase):
             expires = int(expires)
         else:
             expires = int(current_timestamp) + 120
-        if order_type is OrderType.LIMIT:
+        if order_type is OrderType.LIMIT_MAKER:
             # Don't spam the server endpoint if a order placement failed recently
             if current_timestamp - self._last_failed_limit_order_timestamp <= self.ORDER_CREATION_BACKOFF_TIME:
                 raise
@@ -1550,7 +1550,7 @@ cdef class BambooRelayMarket(MarketBase):
 
     async def cancel_order(self, client_order_id: str) -> CancellationResult:
         cdef:
-            BambooRelayInFlightOrder order = self._in_flight_limit_orders.get(client_order_id)
+            BambooRelayInFlightOrder order = self._in_flight_maker_orders.get(client_order_id)
             int order_timestamp_diff
             double current_timestamp
 
@@ -1696,7 +1696,7 @@ cdef class BambooRelayMarket(MarketBase):
         self.c_check_and_remove_expired_orders()
         self._last_timestamp = timestamp
 
-    cdef c_start_tracking_limit_order(self,
+    cdef c_start_tracking_maker_order(self,
                                       str order_id,
                                       str exchange_order_id,
                                       str trading_pair,
@@ -1707,7 +1707,7 @@ cdef class BambooRelayMarket(MarketBase):
                                       object amount,
                                       int expires,
                                       object zero_ex_order):
-        self._in_flight_limit_orders[order_id] = BambooRelayInFlightOrder(
+        self._in_flight_maker_orders[order_id] = BambooRelayInFlightOrder(
             client_order_id=order_id,
             exchange_order_id=exchange_order_id,
             trading_pair=trading_pair,
@@ -1723,7 +1723,7 @@ cdef class BambooRelayMarket(MarketBase):
         # Watch for Fill events for this order hash
         safe_ensure_future(self._wallet.current_backend.zeroex_fill_watcher.watch_order_hash(exchange_order_id, self._update_single_limit_order))
 
-    cdef c_start_tracking_market_order(self,
+    cdef c_start_tracking_taker_order(self,
                                        str order_id,
                                        str trading_pair,
                                        object order_type,
@@ -1733,7 +1733,7 @@ cdef class BambooRelayMarket(MarketBase):
                                        object amount,
                                        str tx_hash,
                                        object protocol_fee_amount):
-        self._in_flight_market_orders[tx_hash] = BambooRelayInFlightOrder(
+        self._in_flight_taker_orders[tx_hash] = BambooRelayInFlightOrder(
             client_order_id=order_id,
             exchange_order_id=None,
             trading_pair=trading_pair,
@@ -1760,12 +1760,12 @@ cdef class BambooRelayMarket(MarketBase):
             self.c_stop_tracking_order(order_id)
 
     cdef c_stop_tracking_order(self, str order_id):
-        if order_id in self._in_flight_limit_orders:
+        if order_id in self._in_flight_maker_orders:
             # Unwatch this order hash from Fill events
-            safe_ensure_future(self._wallet.current_backend.zeroex_fill_watcher.unwatch_order_hash(self._in_flight_limit_orders[order_id].exchange_order_id))
-            del self._in_flight_limit_orders[order_id]
-        elif order_id in self._in_flight_market_orders:
-            del self._in_flight_market_orders[order_id]
+            safe_ensure_future(self._wallet.current_backend.zeroex_fill_watcher.unwatch_order_hash(self._in_flight_maker_orders[order_id].exchange_order_id))
+            del self._in_flight_maker_orders[order_id]
+        elif order_id in self._in_flight_taker_orders:
+            del self._in_flight_taker_orders[order_id]
 
     cdef object c_get_order_price_quantum(self, str trading_pair, object price):
         cdef:
diff --git a/hummingbot/market/binance/binance_market.pyx b/hummingbot/market/binance/binance_market.pyx
index 7caf9f1925e..edd379f5b97 100755
--- a/hummingbot/market/binance/binance_market.pyx
+++ b/hummingbot/market/binance/binance_market.pyx
@@ -342,7 +342,7 @@ cdef class BinanceMarket(MarketBase):
             maker_trade_fee, taker_trade_fee = self._trade_fees.get(trading_pair)
         return TradeFee(percent=maker_trade_fee if order_type.is_limit_type() else taker_trade_fee)
         """
-        is_maker = order_type is OrderType.LIMIT
+        is_maker = order_type is OrderType.LIMIT_MAKER
         return estimate_fee("binance", is_maker)
 
     async def _update_trading_rules(self):
@@ -827,7 +827,7 @@ cdef class BinanceMarket(MarketBase):
                           price: Optional[Decimal] = s_decimal_NaN):
         return await self.create_order(TradeType.BUY, order_id, trading_pair, amount, order_type, price)
 
-    cdef str c_buy(self, str trading_pair, object amount, object order_type=OrderType.MARKET, object price=s_decimal_NaN,
+    cdef str c_buy(self, str trading_pair, object amount, object order_type=OrderType.LIMIT, object price=s_decimal_NaN,
                    dict kwargs={}):
         cdef:
             str t_pair = BinanceMarket.convert_from_exchange_trading_pair(trading_pair)
@@ -844,7 +844,7 @@ cdef class BinanceMarket(MarketBase):
         return OrderType[binance_type]
 
     def supported_order_types(self):
-        return [OrderType.LIMIT, OrderType.MARKET, OrderType.LIMIT_MAKER]
+        return [OrderType.LIMIT, OrderType.LIMIT_MAKER]
 
     async def create_order(self,
                            trade_type: TradeType,
@@ -856,8 +856,7 @@ cdef class BinanceMarket(MarketBase):
         cdef:
             TradingRule trading_rule = self._trading_rules[trading_pair]
         amount = self.c_quantize_order_amount(trading_pair, amount)
-        price = Decimal("NaN") if order_type == OrderType.MARKET else \
-            self.c_quantize_order_price(trading_pair, price)
+        price = self.c_quantize_order_price(trading_pair, price)
         if amount < trading_rule.min_order_size:
             raise ValueError(f"Buy order amount {amount} is lower than the minimum order size "
                              f"{trading_rule.min_order_size}.")
@@ -870,9 +869,8 @@ cdef class BinanceMarket(MarketBase):
                       "side": side_str,
                       "quantity": amount_str,
                       "type": type_str,
-                      "newClientOrderId": order_id}
-        if order_type != OrderType.MARKET:
-            api_params["price"] = price_str
+                      "newClientOrderId": order_id,
+                      "price": price_str}
         if order_type == OrderType.LIMIT:
             api_params["timeInForce"] = BinanceClient.TIME_IN_FORCE_GTC
         self.c_start_tracking_order(order_id,
@@ -911,7 +909,7 @@ cdef class BinanceMarket(MarketBase):
             self.logger().network(
                 f"Error submitting {side_str} {type_str} order to Binance for "
                 f"{amount} {trading_pair} "
-                f"{''if order_type is OrderType.MARKET else price}.",
+                f"{price}.",
                 exc_info=True,
                 app_warning_msg=str(e)
             )
@@ -926,7 +924,7 @@ cdef class BinanceMarket(MarketBase):
                            price: Optional[Decimal] = Decimal("NaN")):
         return await self.create_order(TradeType.SELL, order_id, trading_pair, amount, order_type, price)
 
-    cdef str c_sell(self, str trading_pair, object amount, object order_type=OrderType.MARKET, object price=s_decimal_NaN,
+    cdef str c_sell(self, str trading_pair, object amount, object order_type=OrderType.LIMIT, object price=s_decimal_NaN,
                     dict kwargs={}):
         cdef:
             str t_pair = BinanceMarket.convert_from_exchange_trading_pair(trading_pair)
diff --git a/hummingbot/market/bittrex/bittrex_in_flight_order.pyx b/hummingbot/market/bittrex/bittrex_in_flight_order.pyx
index b2635c69083..a58c74f838a 100644
--- a/hummingbot/market/bittrex/bittrex_in_flight_order.pyx
+++ b/hummingbot/market/bittrex/bittrex_in_flight_order.pyx
@@ -42,7 +42,7 @@ cdef class BittrexInFlightOrder(InFlightOrderBase):
 
     @property
     def order_type_description(self) -> str:
-        order_type = "market" if self.order_type is OrderType.MARKET else "limit"
+        order_type = "limit" if self.order_type is OrderType.LIMIT else "limit_maker"
         side = "buy" if self.trade_type is TradeType.BUY else "sell"
         return f"{order_type} {side}"
 
diff --git a/hummingbot/market/bittrex/bittrex_market.pyx b/hummingbot/market/bittrex/bittrex_market.pyx
index daaf600aacb..c7ef597da01 100644
--- a/hummingbot/market/bittrex/bittrex_market.pyx
+++ b/hummingbot/market/bittrex/bittrex_market.pyx
@@ -378,12 +378,7 @@ cdef class BittrexMarket(MarketBase):
                     continue
 
                 order_state = order["status"]
-                if tracked_order.order_type is OrderType.LIMIT:
-                    order_type = "LIMIT"
-                elif tracked_order.order_type is OrderType.LIMIT_MAKER:
-                    order_type = "LIMIT_MAKER"
-                elif tracked_order.order_type is OrderType.MARKET:
-                    order_type = "MARKET"
+                order_type = "LIMIT" if tracked_order.order_type is OrderType.LIMIT else "LIMIT_MAKER"
                 trade_type = "BUY" if tracked_order.trade_type is TradeType.BUY else "SELL"
                 order_type_description = tracked_order.order_type_description
 
@@ -676,7 +671,7 @@ cdef class BittrexMarket(MarketBase):
         return quantized_amount
 
     def supported_order_types(self):
-        return [OrderType.LIMIT, OrderType.MARKET, OrderType.LIMIT_MAKER]
+        return [OrderType.LIMIT, OrderType.LIMIT_MAKER]
 
     async def place_order(self,
                           order_id: str,
@@ -700,15 +695,6 @@ cdef class BittrexMarket(MarketBase):
                 # Available options [GOOD_TIL_CANCELLED, IMMEDIATE_OR_CANCEL,
                 # FILL_OR_KILL, POST_ONLY_GOOD_TIL_CANCELLED]
             }
-        elif order_type is OrderType.MARKET:
-            body = {
-                "marketSymbol": str(trading_pair),
-                "direction": "BUY" if is_buy else "SELL",
-                "type": "MARKET",
-                "quantity": str(amount),
-                "timeInForce": "IMMEDIATE_OR_CANCEL"
-                # Available options [IMMEDIATE_OR_CANCEL, FILL_OR_KILL]
-            }
         elif order_type is OrderType.LIMIT_MAKER:
             body = {
                     "marketSymbol": str(trading_pair),
@@ -759,22 +745,12 @@ cdef class BittrexMarket(MarketBase):
                 decimal_amount
             )
             if order_type is OrderType.LIMIT or order_type is OrderType.LIMIT_MAKER:
-
-                order_result = await self.place_order(order_id,
-                                                      trading_pair,
-                                                      decimal_amount,
-                                                      True,
-                                                      order_type,
-                                                      decimal_price)
-            elif order_type is OrderType.MARKET:
-                decimal_price = self.c_get_price(trading_pair, True)
                 order_result = await self.place_order(order_id,
                                                       trading_pair,
                                                       decimal_amount,
                                                       True,
                                                       order_type,
                                                       decimal_price)
-
             else:
                 raise ValueError(f"Invalid OrderType {order_type}. Aborting.")
 
@@ -783,12 +759,7 @@ cdef class BittrexMarket(MarketBase):
             tracked_order = self._in_flight_orders.get(order_id)
             if tracked_order is not None and exchange_order_id:
                 tracked_order.update_exchange_order_id(exchange_order_id)
-                if order_type == OrderType.MARKET:
-                    order_type_str = "MARKET" 
-                elif order_type == OrderType.LIMIT:
-                    order_type_str = "LIMIT"
-                elif order_type == OrderType.LIMIT_MAKER:
-                    order_type_str = "LIMIT_MAKER"
+                order_type_str = "LIMIT" if order_type == OrderType.LIMIT else "LIMIT_MAKER"
                 self.logger().info(f"Created {order_type_str} buy order {order_id} for "
                                    f"{decimal_amount} {trading_pair}")
                 self.c_trigger_event(self.MARKET_BUY_ORDER_CREATED_EVENT_TAG,
@@ -878,14 +849,6 @@ cdef class BittrexMarket(MarketBase):
                                                       False,
                                                       order_type,
                                                       decimal_price)
-            elif order_type is OrderType.MARKET:
-                decimal_price = self.c_get_price(trading_pair, False)
-                order_result = await self.place_order(order_id,
-                                                      trading_pair,
-                                                      decimal_amount,
-                                                      False,
-                                                      order_type,
-                                                      decimal_price)
             else:
                 raise ValueError(f"Invalid OrderType {order_type}. Aborting.")
 
@@ -893,12 +856,7 @@ cdef class BittrexMarket(MarketBase):
             tracked_order = self._in_flight_orders.get(order_id)
             if tracked_order is not None and exchange_order_id:
                 tracked_order.update_exchange_order_id(exchange_order_id)
-                if order_type == OrderType.MARKET:
-                    order_type_str = "MARKET" 
-                elif order_type == OrderType.LIMIT:
-                    order_type_str = "LIMIT"
-                elif order_type == OrderType.LIMIT_MAKER:
-                    order_type_str = "LIMIT_MAKER"
+                order_type_str = "LIMIT" if order_type == OrderType.LIMIT else "LIMIT_MAKER"
                 self.logger().info(f"Created {order_type_str} sell order {order_id} for "
                                    f"{decimal_amount} {trading_pair}.")
                 self.c_trigger_event(self.MARKET_SELL_ORDER_CREATED_EVENT_TAG,
@@ -930,7 +888,7 @@ cdef class BittrexMarket(MarketBase):
     cdef str c_sell(self,
                     str trading_pair,
                     object amount,
-                    object order_type=OrderType.MARKET,
+                    object order_type=OrderType.LIMIT,
                     object price=0.0,
                     dict kwargs={}):
         cdef:
diff --git a/hummingbot/market/coinbase_pro/coinbase_pro_in_flight_order.pyx b/hummingbot/market/coinbase_pro/coinbase_pro_in_flight_order.pyx
index 614efce525e..176680bcd0a 100644
--- a/hummingbot/market/coinbase_pro/coinbase_pro_in_flight_order.pyx
+++ b/hummingbot/market/coinbase_pro/coinbase_pro_in_flight_order.pyx
@@ -53,7 +53,7 @@ cdef class CoinbaseProInFlightOrder(InFlightOrderBase):
         """
         :return: Order description string . One of ["limit buy" / "limit sell" / "market buy" / "market sell"]
         """
-        order_type = "market" if self.order_type is OrderType.MARKET else "limit"
+        order_type = "limit_maker" if self.order_type is OrderType.LIMIT_MAKER else "limit"
         side = "buy" if self.trade_type == TradeType.BUY else "sell"
         return f"{order_type} {side}"
 
diff --git a/hummingbot/market/coinbase_pro/coinbase_pro_market.pyx b/hummingbot/market/coinbase_pro/coinbase_pro_market.pyx
index 14a99680952..77a9abb118e 100755
--- a/hummingbot/market/coinbase_pro/coinbase_pro_market.pyx
+++ b/hummingbot/market/coinbase_pro/coinbase_pro_market.pyx
@@ -345,7 +345,7 @@ cdef class CoinbaseProMarket(MarketBase):
             return TradeFee(percent=fee_overrides_config_map["coinbase_pro_taker_fee"].value / Decimal("100"))
         return TradeFee(percent=maker_fee if order_type is OrderType.LIMIT else taker_fee)
         """
-        is_maker = order_type is OrderType.LIMIT
+        is_maker = order_type is OrderType.LIMIT_MAKER
         return estimate_fee("coinbase_pro", is_maker)
 
     async def _update_fee_percentage(self):
@@ -478,7 +478,7 @@ cdef class CoinbaseProMarket(MarketBase):
                 else Decimal(order_update["executed_value"]) / new_confirmed_amount
 
             order_type_description = tracked_order.order_type_description
-            order_type = OrderType.MARKET if tracked_order.order_type == OrderType.MARKET else OrderType.LIMIT
+            order_type = tracked_order.order_type
             # Emit event if executed amount is greater than 0.
             if execute_amount_diff > s_decimal_0:
                 order_filled_event = OrderFilledEvent(
@@ -682,7 +682,7 @@ cdef class CoinbaseProMarket(MarketBase):
                 await asyncio.sleep(5.0)
 
     def supported_order_types(self):
-        return [OrderType.LIMIT, OrderType.MARKET, OrderType.LIMIT_MAKER]
+        return [OrderType.LIMIT, OrderType.LIMIT_MAKER]
 
     async def place_order(self, order_id: str, trading_pair: str, amount: Decimal, is_buy: bool, order_type: OrderType,
                           price: Decimal):
@@ -695,7 +695,7 @@ cdef class CoinbaseProMarket(MarketBase):
             "size": f"{amount:f}",
             "product_id": trading_pair,
             "side": "buy" if is_buy else "sell",
-            "type": "market" if order_type is OrderType.MARKET else "limit",
+            "type": "limit",
         }
         if order_type is OrderType.LIMIT:
             data["price"] = f"{price:f}"
@@ -745,7 +745,7 @@ cdef class CoinbaseProMarket(MarketBase):
             raise
         except Exception:
             self.c_stop_tracking_order(order_id)
-            order_type_str = "MARKET" if order_type == OrderType.MARKET else "LIMIT"
+            order_type_str = "LIMIT_MAKER" if order_type == OrderType.LIMIT_MAKER else "LIMIT"
             self.logger().network(
                 f"Error submitting buy {order_type_str} order to Coinbase Pro for "
                 f"{decimal_amount} {trading_pair} {price}.",
@@ -756,7 +756,7 @@ cdef class CoinbaseProMarket(MarketBase):
             self.c_trigger_event(self.MARKET_ORDER_FAILURE_EVENT_TAG,
                                  MarketOrderFailureEvent(self._current_timestamp, order_id, order_type))
 
-    cdef str c_buy(self, str trading_pair, object amount, object order_type=OrderType.MARKET, object price=s_decimal_0,
+    cdef str c_buy(self, str trading_pair, object amount, object order_type=OrderType.LIMIT, object price=s_decimal_0,
                    dict kwargs={}):
         """
         *required
@@ -809,7 +809,7 @@ cdef class CoinbaseProMarket(MarketBase):
             raise
         except Exception:
             self.c_stop_tracking_order(order_id)
-            order_type_str = "MARKET" if order_type == OrderType.MARKET else "LIMIT"
+            order_type_str = "LIMIT_MAKER" if order_type == OrderType.LIMIT_MAKER else "LIMIT"
             self.logger().network(
                 f"Error submitting sell {order_type_str} order to Coinbase Pro for "
                 f"{decimal_amount} {trading_pair} {price}.",
@@ -823,7 +823,7 @@ cdef class CoinbaseProMarket(MarketBase):
     cdef str c_sell(self,
                     str trading_pair,
                     object amount,
-                    object order_type=OrderType.MARKET,
+                    object order_type=OrderType.LIMIT,
                     object price=s_decimal_0,
                     dict kwargs={}):
         """
diff --git a/hummingbot/market/dolomite/dolomite_in_flight_order.pyx b/hummingbot/market/dolomite/dolomite_in_flight_order.pyx
index b940c8442b6..84f7941b5ae 100644
--- a/hummingbot/market/dolomite/dolomite_in_flight_order.pyx
+++ b/hummingbot/market/dolomite/dolomite_in_flight_order.pyx
@@ -41,7 +41,7 @@ cdef class DolomiteInFlightOrder(InFlightOrderBase):
 
     @property
     def description(self):
-        _type = "limit" if self.order_type == OrderType.LIMIT else "market"
+        _type = "limit" if self.order_type == OrderType.LIMIT else "limit_maker"
         _side = "buy" if self.trade_type == TradeType.BUY else "sell"
         return f"{_type} {_side}"
 
@@ -65,10 +65,10 @@ cdef class DolomiteInFlightOrder(InFlightOrderBase):
 
     @classmethod
     def from_dolomite_order(cls, dolomite_order: Dict[str, Any], client_order_id: str, market: MarketBase) -> DolomiteInFlightOrder:
-        order_type = (OrderType.MARKET, OrderType.LIMIT)[dolomite_order["order_type"] == "LIMIT"]
+        order_type = (OrderType.LIMIT, OrderType.LIMIT_MAKER)[dolomite_order["order_type"] == "LIMIT_MAKER"]
         order_side = (TradeType.SELL, TradeType.BUY)[dolomite_order["order_side"] == "BUY"]
 
-        price = (order_type == OrderType.MARKET
+        price = (order_type == OrderType.LIMIT
                  and unpad(dolomite_order["market_order_effective_price"])
                  or Decimal(dolomite_order["exchange_rate"]))
 
@@ -94,7 +94,7 @@ cdef class DolomiteInFlightOrder(InFlightOrderBase):
 
         fill_events = []
 
-        if self.order_type is OrderType.LIMIT and len(fills) > 0:
+        if self.order_type is OrderType.LIMIT_MAKER and len(fills) > 0:
             for fill in fills:
                 if fill["dolomite_order_fill_id"] not in self.tracked_fill_ids:
                     primary_fill_amount = unpad(fill["primary_amount"])
@@ -116,7 +116,7 @@ cdef class DolomiteInFlightOrder(InFlightOrderBase):
                     fill_events.append(filled_event)
                     self.tracked_fill_ids.append(fill["dolomite_order_fill_id"])
 
-        elif self.order_type is OrderType.MARKET and len(fills) > 0:
+        elif self.order_type is OrderType.LIMIT and len(fills) > 0:
             order_fee_token = ticker_for(dolomite_order["base_taker_gas_fee_amount"])
             fee_token_burn_rate = Decimal(exchange_info.fee_burn_rates_table[order_fee_token])
 
diff --git a/hummingbot/market/dolomite/dolomite_market.pyx b/hummingbot/market/dolomite/dolomite_market.pyx
index af56abd849b..85d8df8dd75 100644
--- a/hummingbot/market/dolomite/dolomite_market.pyx
+++ b/hummingbot/market/dolomite/dolomite_market.pyx
@@ -206,7 +206,7 @@ cdef class DolomiteMarket(MarketBase):
 
         for in_flight_order in self._in_flight_orders.values():
             dolomite_flight_order = in_flight_order
-            if dolomite_flight_order.order_type is OrderType.LIMIT:
+            if dolomite_flight_order.order_type is OrderType.LIMIT_MAKER:
                 retval.append(dolomite_flight_order.to_limit_order())
         return retval
 
@@ -235,9 +235,9 @@ cdef class DolomiteMarket(MarketBase):
             exchange_info = self._exchange_info
 
             # Check order type support
-            if order_type == OrderType.LIMIT and trading_rule.supports_limit_orders is False:
-                raise ValueError("LIMIT orders are not supported")
-            elif order_type == OrderType.MARKET and trading_rule.supports_market_orders is False:
+            if order_type == OrderType.LIMIT_MAKER and trading_rule.supports_limit_orders is False:
+                raise ValueError("LIMIT_MAKER orders are not supported")
+            elif order_type == OrderType.LIMIT and trading_rule.supports_market_orders is False:
                 raise ValueError("MARKET orders are not supported")
 
             # Calculate amounts and get token info
@@ -282,7 +282,7 @@ cdef class DolomiteMarket(MarketBase):
             unsigned_order = {
                 "owner_address": self._wallet.address,
                 "market": f"{primary_token.contract_address}-{secondary_token.contract_address}",
-                "order_type": "LIMIT" if order_type == OrderType.LIMIT else "MARKET",
+                "order_type": "LIMIT" if order_type == OrderType.LIMIT_MAKER else "MARKET",
                 "order_side": "BUY" if order_side == TradeType.BUY else "SELL",
                 "primary_padded_amount": primary_token.pad(primary_amount),
                 "secondary_padded_amount": secondary_token.pad(secondary_amount),
@@ -342,7 +342,7 @@ cdef class DolomiteMarket(MarketBase):
                 self.c_trigger_event(SELL_ORDER_CREATED_EVENT, sell_event)
 
         except Exception as e:
-            order_type_str = "MARKET" if order_type == OrderType.MARKET else "LIMIT"
+            order_type_str = "LIMIT" if order_type == OrderType.LIMIT else "LIMIT_MAKER"
             order_side_str = "buy" if order_side == TradeType.BUY else "sell"
 
             self.logger().warn(f"Error submitting {order_side_str} {order_type_str} order to Dolomite for "
@@ -353,13 +353,13 @@ cdef class DolomiteMarket(MarketBase):
             self.stop_tracking(client_order_id)
             self.c_trigger_event(ORDER_FAILURE_EVENT, MarketOrderFailureEvent(now(), client_order_id, order_type))
 
-    cdef str c_buy(self, str trading_pair, object amount, object order_type = OrderType.MARKET, object price = 0.0,
+    cdef str c_buy(self, str trading_pair, object amount, object order_type = OrderType.LIMIT, object price = 0.0,
                    dict kwargs = {}):
         cdef str client_order_id = str(uuid.uuid1())[:8]
         safe_ensure_future(self.place_order(client_order_id, trading_pair, TradeType.BUY, amount, order_type, price))
         return client_order_id
 
-    cdef str c_sell(self, str trading_pair, object amount, object order_type = OrderType.MARKET, object price = 0.0,
+    cdef str c_sell(self, str trading_pair, object amount, object order_type = OrderType.LIMIT, object price = 0.0,
                     dict kwargs = {}):
         cdef str client_order_id = str(uuid.uuid1())[:8]
         safe_ensure_future(self.place_order(client_order_id, trading_pair, TradeType.SELL, amount, order_type, price))
@@ -432,7 +432,7 @@ cdef class DolomiteMarket(MarketBase):
         maker_fee_percentage = Decimal(exchange_info.maker_fee_percentage)
         taker_fee_percentage = Decimal(exchange_info.taker_fee_percentage)
 
-        if order_type is OrderType.LIMIT:
+        if order_type is OrderType.LIMIT_MAKER:
             secondary_amount = self.c_quantize_order_amount(trading_pair, amount * price)
             service_fee = max(Decimal(maker_fee_percentage) * secondary_amount, s_decimal_0)
             return TradeFee(percent=maker_fee_percentage), secondary_amount, service_fee, 0, s_decimal_0, s_decimal_0
@@ -482,7 +482,7 @@ cdef class DolomiteMarket(MarketBase):
                 price=(None if price is None else Decimal(price)))
         return order_fill_and_fee_result[0]
         """
-        is_maker = order_type is OrderType.LIMIT
+        is_maker = order_type is OrderType.LIMIT_MAKER
         return estimate_fee("dolomite", is_maker)
 
     cdef object c_get_price(self, str trading_pair, bint is_buy):
diff --git a/hummingbot/market/eterbase/eterbase_in_flight_order.pyx b/hummingbot/market/eterbase/eterbase_in_flight_order.pyx
index e08220706f5..f694d2acb87 100644
--- a/hummingbot/market/eterbase/eterbase_in_flight_order.pyx
+++ b/hummingbot/market/eterbase/eterbase_in_flight_order.pyx
@@ -78,7 +78,7 @@ cdef class EterbaseInFlightOrder(InFlightOrderBase):
         """
         :return: Order description string . One of ["limit buy" / "limit sell" / "market buy" / "market sell"]
         """
-        order_type = "market" if self.order_type is OrderType.MARKET else "limit"
+        order_type = "limit_maker" if self.order_type is OrderType.LIMIT_MAKER else "limit"
         side = "buy" if self.trade_type == TradeType.BUY else "sell"
         return f"{order_type} {side}"
 
diff --git a/hummingbot/market/eterbase/eterbase_market.pyx b/hummingbot/market/eterbase/eterbase_market.pyx
index 08f45d3cda2..9e8c944af73 100644
--- a/hummingbot/market/eterbase/eterbase_market.pyx
+++ b/hummingbot/market/eterbase/eterbase_market.pyx
@@ -506,12 +506,8 @@ cdef class EterbaseMarket(MarketBase):
             # Cost only for MARKET order BUY
             execute_amount_diff = s_decimal_0
             new_confirmed_amount = s_decimal_0
-            if (tracked_order.order_type == OrderType.MARKET) and (tracked_order.trade_type == TradeType.BUY):
-                new_confirmed_amount = Decimal(order_update["cost"]) - Decimal(order_update["remainingCost"])
-                execute_amount_diff = new_confirmed_amount - tracked_order.executed_amount_base
-            else:
-                new_confirmed_amount = Decimal(order_update["qty"]) - Decimal(order_update["remainingQty"])
-                execute_amount_diff = new_confirmed_amount - tracked_order.executed_amount_base
+            new_confirmed_amount = Decimal(order_update["qty"]) - Decimal(order_update["remainingQty"])
+            execute_amount_diff = new_confirmed_amount - tracked_order.executed_amount_base
 
             client_order_id = tracked_order.client_order_id
             order_type_description = tracked_order.order_type_description
@@ -542,12 +538,8 @@ cdef class EterbaseMarket(MarketBase):
                                 # Using order_id here for easier data validation
                                 exchange_trade_id = exchange_order_id,
                             )
-                            if (tracked_order.order_type == OrderType.MARKET) and (tracked_order.trade_type == TradeType.BUY):
-                                self.logger().info(f"Filled {execute_amount_diff} out of {tracked_order.cost} costs of the "
-                                                   f"{order_type_description} order {client_order_id}.")
-                            else:
-                                self.logger().info(f"Filled {execute_amount_diff} out of {tracked_order.amount} of the "
-                                                   f"{order_type_description} order {client_order_id}.")
+                            self.logger().info(f"Filled {execute_amount_diff} out of {tracked_order.amount} of the "
+                                               f"{order_type_description} order {client_order_id}.")
 
                             self.c_trigger_event(self.MARKET_ORDER_FILLED_EVENT_TAG, order_filled_event)
 
@@ -728,7 +720,7 @@ cdef class EterbaseMarket(MarketBase):
                 await asyncio.sleep(5.0)
 
     def supported_order_types(self):
-        return [OrderType.LIMIT, OrderType.LIMIT_MAKER, OrderType.MARKET]
+        return [OrderType.LIMIT, OrderType.LIMIT_MAKER]
 
     async def place_order(self, order_id: str, trading_pair: str, amount: Decimal, is_buy: bool, order_type: OrderType,
                           price: Decimal, cost: Optional[Decimal]):
@@ -741,8 +733,6 @@ cdef class EterbaseMarket(MarketBase):
 
         if order_type is OrderType.LIMIT or order_type is OrderType.LIMIT_MAKER:
             type_order = 2
-        elif order_type is OrderType.MARKET:
-            type_order = 1
         else:
             self.logger().error(f"Unsuported Order type value - {order_type}.", exc_info=True)
 
@@ -766,11 +756,6 @@ cdef class EterbaseMarket(MarketBase):
             data["qty"] = str(amount)
             if order_type is OrderType.LIMIT_MAKER:
                 data["postOnly"] = True
-        elif order_type is OrderType.MARKET:
-            if is_buy:
-                data["cost"] = str(cost)
-            else:
-                data["qty"] = str(amount)
         else:
             self.logger().error(f"Unsuported OrderType - {order_type}.", exc_info=True)
 
@@ -791,21 +776,10 @@ cdef class EterbaseMarket(MarketBase):
         cdef:
             EterbaseTradingRule trading_rule = self._trading_rules[trading_pair]
         decimal_amount = self.quantize_order_amount(trading_pair, amount)
-        if (order_type == OrderType.MARKET) and (price != price):
-            price = self.get_price(trading_pair, True)
         decimal_price = self.quantize_order_price(trading_pair, price)
         decimal_cost = s_decimal_0
         # For Order Market type is needed cost
-        if (order_type == OrderType.MARKET):
-            decimal_cost = self.c_quantize_cost(trading_pair, amount, price)
-            decimal_cost = self.c_round_to_sig_digits(decimal_cost, trading_rule.max_cost_significant_digits, 8)
-            if decimal_cost < trading_rule.min_order_value:
-                raise ValueError(f"Buy order cost {decimal_cost} is lower than the minimum order cost "
-                                 f"{trading_rule.min_order_value}.")
-            if decimal_cost > trading_rule.max_order_value:
-                raise ValueError(f"Buy order cost {decimal_cost} is higer than the maximum order cost "
-                                 f"{trading_rule.max_order_value}.")
-        elif (order_type == OrderType.LIMIT or order_type == OrderType.LIMIT_MAKER):
+        if (order_type == OrderType.LIMIT or order_type == OrderType.LIMIT_MAKER):
             # convert price according significant digits
             decimal_price = self.c_round_to_sig_digits(decimal_price, trading_rule.max_price_significant_digits)
             if decimal_amount < trading_rule.min_order_size:
@@ -837,12 +811,7 @@ cdef class EterbaseMarket(MarketBase):
             raise
         except Exception:
             self.c_stop_tracking_order(order_id)
-            if order_type == OrderType.MARKET:
-                order_type_str = "MARKET" 
-            elif order_type == OrderType.LIMIT:
-                order_type_str = "LIMIT"
-            elif order_type == OrderType.LIMIT_MAKER:
-                order_type_str = "LIMIT_MAKER"
+            order_type_str = "LIMIT" if order_type == OrderType.LIMIT else "LIMIT_MAKER"
             self.logger().network(
                 f"Error submitting buy {order_type_str} order to Eterbase for "
                 f"{decimal_amount} {trading_pair} {price}.",
@@ -853,7 +822,7 @@ cdef class EterbaseMarket(MarketBase):
             self.c_trigger_event(self.MARKET_ORDER_FAILURE_EVENT_TAG,
                                  MarketOrderFailureEvent(self._current_timestamp, order_id, order_type))
 
-    cdef str c_buy(self, str trading_pair, object amount, object order_type=OrderType.MARKET, object price=s_decimal_0,
+    cdef str c_buy(self, str trading_pair, object amount, object order_type=OrderType.LIMIT, object price=s_decimal_0,
                    dict kwargs={}):
         """
         *required
@@ -877,8 +846,6 @@ cdef class EterbaseMarket(MarketBase):
         """
         cdef:
             EterbaseTradingRule trading_rule = self._trading_rules[trading_pair]
-        if price.is_nan() and order_type==OrderType.MARKET:
-            price = s_decimal_0
         decimal_amount = self.quantize_order_amount(trading_pair, amount)
         decimal_price = self.quantize_order_price(trading_pair, price)
         decimal_cost = s_decimal_0
@@ -910,12 +877,7 @@ cdef class EterbaseMarket(MarketBase):
             raise
         except Exception as e:
             self.c_stop_tracking_order(order_id)
-            if order_type == OrderType.MARKET:
-                order_type_str = "MARKET" 
-            elif order_type == OrderType.LIMIT:
-                order_type_str = "LIMIT"
-            elif order_type == OrderType.LIMIT_MAKER:
-                order_type_str = "LIMIT_MAKER"
+            order_type_str = "LIMIT" if order_type == OrderType.LIMIT else "LIMIT_MAKER"
             self.logger().network(
                 f"Error submitting sell {order_type_str} order to Eterbase for "
                 f"{decimal_amount} {trading_pair} {price}.",
@@ -926,7 +888,7 @@ cdef class EterbaseMarket(MarketBase):
             self.c_trigger_event(self.MARKET_ORDER_FAILURE_EVENT_TAG,
                                  MarketOrderFailureEvent(self._current_timestamp, order_id, order_type))
 
-    cdef str c_sell(self, str trading_pair, object amount, object order_type=OrderType.MARKET, object price=s_decimal_0,
+    cdef str c_sell(self, str trading_pair, object amount, object order_type=OrderType.LIMIT, object price=s_decimal_0,
                     dict kwargs={}):
         """
         *required
diff --git a/hummingbot/market/huobi/huobi_market.pyx b/hummingbot/market/huobi/huobi_market.pyx
index 6781feecd16..253b717f204 100644
--- a/hummingbot/market/huobi/huobi_market.pyx
+++ b/hummingbot/market/huobi/huobi_market.pyx
@@ -367,7 +367,7 @@ cdef class HuobiMarket(MarketBase):
             return TradeFee(percent=fee_overrides_config_map["huobi_taker_fee"].value / Decimal("100"))
         return TradeFee(percent=Decimal("0.002"))
         """
-        is_maker = order_type is OrderType.LIMIT
+        is_maker = order_type is OrderType.LIMIT_MAKER
         return estimate_fee("huobi", is_maker)
 
     async def _update_trading_rules(self):
@@ -592,7 +592,7 @@ cdef class HuobiMarket(MarketBase):
         return all(self.status_dict.values())
 
     def supported_order_types(self):
-        return [OrderType.LIMIT, OrderType.LIMIT_MAKER, OrderType.MARKET]
+        return [OrderType.LIMIT, OrderType.LIMIT_MAKER]
 
     async def place_order(self,
                           order_id: str,
@@ -603,12 +603,7 @@ cdef class HuobiMarket(MarketBase):
                           price: Decimal) -> str:
         path_url = "order/orders/place"
         side = "buy" if is_buy else "sell"
-        if order_type is OrderType.LIMIT:
-            order_type_str = "limit"
-        elif order_type is OrderType.LIMIT_MAKER:
-            order_type_str = "limit-maker"
-        elif order_type is OrderType.MARKET:
-            order_type_str = "market"
+        order_type_str = "limit" if order_type is OrderType.LIMIT else "limit-maker"
 
         params = {
             "account-id": self._account_id,
@@ -642,12 +637,7 @@ cdef class HuobiMarket(MarketBase):
             str exchange_order_id
             object tracked_order
 
-        if order_type is OrderType.MARKET:
-            quote_amount = self.c_get_quote_volume_for_base_amount(trading_pair, True, amount).result_volume
-            # Quantize according to price rules, not base token amount rules.
-            decimal_amount = self.c_quantize_order_price(trading_pair, Decimal(quote_amount))
-            decimal_price = s_decimal_0
-        else:
+        if order_type is OrderType.LIMIT or order_type is OrderType.LIMIT_MAKER:
             decimal_amount = self.c_quantize_order_amount(trading_pair, amount)
             decimal_price = self.c_quantize_order_price(trading_pair, price)
             if decimal_amount < trading_rule.min_order_size:
@@ -680,16 +670,11 @@ cdef class HuobiMarket(MarketBase):
             raise
         except Exception:
             self.c_stop_tracking_order(order_id)
-            if order_type == OrderType.MARKET:
-                order_type_str = "MARKET"
-            elif order_type == OrderType.LIMIT:
-                order_type_str = "LIMIT"
-            elif order_type == OrderType.LIMIT_MAKER:
-                order_type_str = "LIMIT_LIMIT"
+            order_type_str = "LIMIT" if order_type == OrderType.LIMIT else "LIMIT_LIMIT"
             self.logger().network(
                 f"Error submitting buy {order_type_str} order to Huobi for "
                 f"{decimal_amount} {trading_pair} "
-                f"{decimal_price if order_type is not OrderType.MARKET else ''}.",
+                f"{decimal_price}.",
                 exc_info=True,
                 app_warning_msg=f"Failed to submit buy order to Huobi. Check API key and network connection."
             )
@@ -699,7 +684,7 @@ cdef class HuobiMarket(MarketBase):
     cdef str c_buy(self,
                    str trading_pair,
                    object amount,
-                   object order_type=OrderType.MARKET,
+                   object order_type=OrderType.LIMIT,
                    object price=s_decimal_0,
                    dict kwargs={}):
         cdef:
@@ -723,9 +708,8 @@ cdef class HuobiMarket(MarketBase):
             object tracked_order
 
         decimal_amount = self.quantize_order_amount(trading_pair, amount)
-        decimal_price = (self.c_quantize_order_price(trading_pair, price)
-                         if order_type is not OrderType.MARKET
-                         else s_decimal_0)
+        decimal_price = self.c_quantize_order_price(trading_pair, price)
+
         if decimal_amount < trading_rule.min_order_size:
             raise ValueError(f"Sell order amount {decimal_amount} is lower than the minimum order size "
                              f"{trading_rule.min_order_size}.")
@@ -757,16 +741,11 @@ cdef class HuobiMarket(MarketBase):
             raise
         except Exception:
             self.c_stop_tracking_order(order_id)
-            if order_type == OrderType.MARKET:
-                order_type_str = "MARKET"
-            elif order_type == OrderType.LIMIT:
-                order_type_str = "LIMIT"
-            elif order_type == OrderType.LIMIT_MAKER:
-                order_type_str = "LIMIT_LIMIT"
+            order_type_str = "LIMIT" if order_type == OrderType.LIMIT else "LIMIT_LIMIT"
             self.logger().network(
                 f"Error submitting sell {order_type_str} order to Huobi for "
                 f"{decimal_amount} {trading_pair} "
-                f"{decimal_price if order_type is not OrderType.MARKET else ''}.",
+                f"{decimal_price}.",
                 exc_info=True,
                 app_warning_msg=f"Failed to submit sell order to Huobi. Check API key and network connection."
             )
@@ -776,7 +755,7 @@ cdef class HuobiMarket(MarketBase):
     cdef str c_sell(self,
                     str trading_pair,
                     object amount,
-                    object order_type=OrderType.MARKET, object price=s_decimal_0,
+                    object order_type=OrderType.LIMIT, object price=s_decimal_0,
                     dict kwargs={}):
         cdef:
             int64_t tracking_nonce = <int64_t> get_tracking_nonce()
diff --git a/hummingbot/market/kraken/kraken_market.pyx b/hummingbot/market/kraken/kraken_market.pyx
index 3de3ba4f68a..2b565b0f913 100755
--- a/hummingbot/market/kraken/kraken_market.pyx
+++ b/hummingbot/market/kraken/kraken_market.pyx
@@ -350,7 +350,7 @@ cdef class KrakenMarket(MarketBase):
             maker_trade_fee, taker_trade_fee = self._trade_fees.get(trading_pair)
         return TradeFee(percent=maker_trade_fee if order_type is OrderType.LIMIT else taker_trade_fee)
         """
-        is_maker = order_type is OrderType.LIMIT
+        is_maker = order_type is OrderType.LIMIT_MAKER
         return estimate_fee("kraken", is_maker)
 
     async def _update_trading_rules(self):
@@ -466,7 +466,6 @@ cdef class KrakenMarket(MarketBase):
 
                 # Update order execution status
                 tracked_order.last_state = update["status"]
-                order_type = OrderType.LIMIT if update["descr"]["ordertype"] == "limit" else OrderType.MARKET
                 executed_amount_base = Decimal(update["vol_exec"])
                 executed_amount_quote = executed_amount_base * Decimal(update["price"])
 
@@ -485,7 +484,7 @@ cdef class KrakenMarket(MarketBase):
                                                                         executed_amount_base,
                                                                         executed_amount_quote,
                                                                         update["fee"],
-                                                                        order_type))
+                                                                        tracked_order.order_type))
                         else:
                             self.logger().info(f"The market sell order {client_order_id} has completed "
                                                f"according to order status API.")
@@ -499,7 +498,7 @@ cdef class KrakenMarket(MarketBase):
                                                                          executed_amount_base,
                                                                          executed_amount_quote,
                                                                          update["fee"],
-                                                                         order_type))
+                                                                         tracked_order.order_type))
                     else:
                         # check if its a cancelled order
                         # if its a cancelled order, issue cancel and stop tracking order
@@ -516,7 +515,7 @@ cdef class KrakenMarket(MarketBase):
                                                  MarketOrderFailureEvent(
                                                      self._current_timestamp,
                                                      client_order_id,
-                                                     order_type
+                                                     tracked_order.order_type
                                                  ))
                     self.c_stop_tracking_order(client_order_id)
 
@@ -810,7 +809,7 @@ cdef class KrakenMarket(MarketBase):
         return result
 
     def supported_order_types(self):
-        return [OrderType.LIMIT, OrderType.MARKET]
+        return [OrderType.LIMIT, OrderType.LIMIT_MAKER]
 
     async def place_order(self,
                           userref: int,
@@ -826,12 +825,13 @@ cdef class KrakenMarket(MarketBase):
         data = {
             "pair": trading_pair,
             "type": "buy" if is_buy else "sell",
-            "ordertype": "limit" if order_type is OrderType.LIMIT else "market",
+            "ordertype": "limit",
             "volume": str(amount),
-            "userref": userref
+            "userref": userref,
+            "price": str(price)
         }
-        if order_type is OrderType.LIMIT:
-            data["price"] = str(price)
+        if order_type is OrderType.LIMIT_MAKER:
+            data["oflags"] = "post"
         return await self._api_request("post",
                                        ADD_ORDER_URI,
                                        data=data,
@@ -851,9 +851,7 @@ cdef class KrakenMarket(MarketBase):
             object buy_fee = self.c_get_fee(base_currency, quote_currency, order_type, TradeType.BUY, amount, price)
 
         decimal_amount = self.c_quantize_order_amount(trading_pair, amount)
-        decimal_price = (self.c_quantize_order_price(trading_pair, price)
-                         if order_type is OrderType.LIMIT
-                         else s_decimal_0)
+        decimal_price = self.c_quantize_order_price(trading_pair, price)
         if decimal_amount < trading_rule.min_order_size:
             raise ValueError(f"Buy order amount {decimal_amount} is lower than the minimum order size "
                              f"{trading_rule.min_order_size}.")
@@ -861,7 +859,7 @@ cdef class KrakenMarket(MarketBase):
         try:
             order_result = None
             order_decimal_amount = f"{decimal_amount:f}"
-            if order_type is OrderType.LIMIT:
+            if order_type is OrderType.LIMIT or order_type is OrderType.LIMIT_MAKER:
                 order_decimal_price = f"{decimal_price:f}"
                 self.c_start_tracking_order(
                     order_id,
@@ -879,22 +877,6 @@ cdef class KrakenMarket(MarketBase):
                                                       order_type=order_type,
                                                       is_buy=True,
                                                       price=order_decimal_price)
-            elif order_type is OrderType.MARKET:
-                self.c_start_tracking_order(
-                    order_id,
-                    "",
-                    trading_pair,
-                    TradeType.BUY,
-                    Decimal("NaN"),
-                    decimal_amount,
-                    order_type,
-                    userref
-                )
-                order_result = await self.place_order(userref=userref,
-                                                      trading_pair=trading_pair,
-                                                      amount=order_decimal_amount,
-                                                      order_type=order_type,
-                                                      is_buy=True)
             else:
                 raise ValueError(f"Invalid OrderType {order_type}. Aborting.")
 
@@ -919,18 +901,18 @@ cdef class KrakenMarket(MarketBase):
 
         except Exception as e:
             self.c_stop_tracking_order(order_id)
-            order_type_str = 'MARKET' if order_type == OrderType.MARKET else 'LIMIT'
+            order_type_str = 'LIMIT' if order_type is OrderType.LIMIT else "LIMIT_MAKER"
             self.logger().network(
                 f"Error submitting buy {order_type_str} order to Kraken for "
                 f"{decimal_amount} {trading_pair}"
-                f" {decimal_price if order_type is OrderType.LIMIT else ''}.",
+                f" {decimal_price}.",
                 exc_info=True,
                 app_warning_msg=f"Failed to submit buy order to Kraken. Check API key and network connection."
             )
             self.c_trigger_event(self.MARKET_ORDER_FAILURE_EVENT_TAG,
                                  MarketOrderFailureEvent(self._current_timestamp, order_id, order_type))
 
-    cdef str c_buy(self, str trading_pair, object amount, object order_type=OrderType.MARKET, object price=s_decimal_NaN,
+    cdef str c_buy(self, str trading_pair, object amount, object order_type=OrderType.LIMIT, object price=s_decimal_NaN,
                    dict kwargs={}):
         cdef:
             int64_t tracking_nonce = <int64_t> get_tracking_nonce()
@@ -950,9 +932,8 @@ cdef class KrakenMarket(MarketBase):
             TradingRule trading_rule = self._trading_rules[trading_pair]
 
         decimal_amount = self.quantize_order_amount(trading_pair, amount)
-        decimal_price = (self.c_quantize_order_price(trading_pair, price)
-                         if order_type is OrderType.LIMIT
-                         else s_decimal_0)
+        decimal_price = self.c_quantize_order_price(trading_pair, price)
+
         if decimal_amount < trading_rule.min_order_size:
             raise ValueError(f"Sell order amount {decimal_amount} is lower than the minimum order size "
                              f"{trading_rule.min_order_size}.")
@@ -960,7 +941,7 @@ cdef class KrakenMarket(MarketBase):
         try:
             order_result = None
             order_decimal_amount = f"{decimal_amount:f}"
-            if order_type is OrderType.LIMIT:
+            if order_type is OrderType.LIMIT or order_type is OrderType.LIMIT_MAKER:
                 order_decimal_price = f"{decimal_price:f}"
                 self.c_start_tracking_order(
                     order_id,
@@ -978,22 +959,6 @@ cdef class KrakenMarket(MarketBase):
                                                       order_type=order_type,
                                                       is_buy=False,
                                                       price=order_decimal_price)
-            elif order_type is OrderType.MARKET:
-                self.c_start_tracking_order(
-                    order_id,
-                    "",
-                    trading_pair,
-                    TradeType.SELL,
-                    Decimal("NaN"),
-                    decimal_amount,
-                    order_type,
-                    userref
-                )
-                order_result = await self.place_order(userref=userref,
-                                                      trading_pair=trading_pair,
-                                                      amount=order_decimal_amount,
-                                                      order_type=order_type,
-                                                      is_buy=False)
             else:
                 raise ValueError(f"Invalid OrderType {order_type}. Aborting.")
 
@@ -1017,18 +982,18 @@ cdef class KrakenMarket(MarketBase):
             raise
         except Exception:
             self.c_stop_tracking_order(order_id)
-            order_type_str = 'MARKET' if order_type is OrderType.MARKET else 'LIMIT'
+            order_type_str = 'LIMIT' if order_type is OrderType.LIMIT else "LIMIT_MAKER"
             self.logger().network(
                 f"Error submitting sell {order_type_str} order to Kraken for "
                 f"{decimal_amount} {trading_pair} "
-                f"{decimal_price if order_type is OrderType.LIMIT else ''}.",
+                f"{decimal_price}.",
                 exc_info=True,
                 app_warning_msg=f"Failed to submit sell order to Kraken. Check API key and network connection."
             )
             self.c_trigger_event(self.MARKET_ORDER_FAILURE_EVENT_TAG,
                                  MarketOrderFailureEvent(self._current_timestamp, order_id, order_type))
 
-    cdef str c_sell(self, str trading_pair, object amount, object order_type=OrderType.MARKET, object price=s_decimal_NaN,
+    cdef str c_sell(self, str trading_pair, object amount, object order_type=OrderType.LIMIT, object price=s_decimal_NaN,
                     dict kwargs={}):
         cdef:
             int64_t tracking_nonce = <int64_t> get_tracking_nonce()
diff --git a/hummingbot/market/kucoin/kucoin_market.pyx b/hummingbot/market/kucoin/kucoin_market.pyx
index 2f80802a886..402ca9c6788 100644
--- a/hummingbot/market/kucoin/kucoin_market.pyx
+++ b/hummingbot/market/kucoin/kucoin_market.pyx
@@ -469,7 +469,7 @@ cdef class KucoinMarket(MarketBase):
             return TradeFee(percent=fee_overrides_config_map["kucoin_taker_fee"].value / Decimal("100"))
         return TradeFee(percent=Decimal("0.001"))
         """
-        is_maker = order_type is OrderType.LIMIT
+        is_maker = order_type is OrderType.LIMIT_MAKER
         return estimate_fee("kucoin", is_maker)
 
     async def _update_trading_rules(self):
@@ -657,7 +657,7 @@ cdef class KucoinMarket(MarketBase):
         return self._account_balances.copy()
 
     def supported_order_types(self):
-        return [OrderType.LIMIT, OrderType.LIMIT_MAKER, OrderType.MARKET]
+        return [OrderType.LIMIT, OrderType.LIMIT_MAKER]
 
     async def place_order(self,
                           order_id: str,
@@ -668,7 +668,7 @@ cdef class KucoinMarket(MarketBase):
                           price: Decimal) -> str:
         path_url = "/api/v1/orders"
         side = "buy" if is_buy else "sell"
-        order_type_str = "market" if order_type is OrderType.MARKET else "limit"
+        order_type_str = "limit_maker" if order_type is OrderType.LIMIT_MAKER else "limit"
         params = {
             "size": str(amount),
             "clientOid": order_id,
@@ -705,10 +705,7 @@ cdef class KucoinMarket(MarketBase):
             str exchange_order_id
             object tracked_order
 
-        if order_type is OrderType.MARKET:
-            decimal_amount = self.c_quantize_order_amount(trading_pair, amount)
-            decimal_price = s_decimal_0
-        else:
+        if order_type is OrderType.LIMIT or order_type is OrderType.LIMIT_MAKER:
             decimal_amount = self.c_quantize_order_amount(trading_pair, amount)
             decimal_price = self.c_quantize_order_price(trading_pair, price)
             if decimal_amount < trading_rule.min_order_size:
@@ -741,12 +738,7 @@ cdef class KucoinMarket(MarketBase):
             raise
         except Exception:
             self.c_stop_tracking_order(order_id)
-            if order_type == OrderType.MARKET:
-                order_type_str = "MARKET" 
-            elif order_type == OrderType.LIMIT:
-                order_type_str = "LIMIT"
-            elif order_type == OrderType.LIMIT_MAKER:
-                order_type_str = "LIMIT_MAKER"
+            order_type_str = "LIMIT" if order_type == OrderType.LIMIT else "LIMIT_MAKER"
             self.logger().network(
                 f"Error submitting buy {order_type_str} order to Kucoin for "
                 f"{decimal_amount} {trading_pair} "
@@ -760,7 +752,7 @@ cdef class KucoinMarket(MarketBase):
     cdef str c_buy(self,
                    str trading_pair,
                    object amount,
-                   object order_type = OrderType.MARKET,
+                   object order_type = OrderType.LIMIT,
                    object price = s_decimal_0,
                    dict kwargs = {}):
         cdef:
@@ -784,9 +776,7 @@ cdef class KucoinMarket(MarketBase):
             object tracked_order
 
         decimal_amount = self.quantize_order_amount(trading_pair, amount)
-        decimal_price = (self.c_quantize_order_price(trading_pair, price)
-                         if order_type is not OrderType.MARKET
-                         else s_decimal_0)
+        decimal_price = self.c_quantize_order_price(trading_pair, price)
         if decimal_amount < trading_rule.min_order_size:
             raise ValueError(f"Sell order amount {decimal_amount} is lower than the minimum order size "
                              f"{trading_rule.min_order_size}.")
@@ -818,12 +808,7 @@ cdef class KucoinMarket(MarketBase):
             raise
         except Exception:
             self.c_stop_tracking_order(order_id)
-            if order_type == OrderType.MARKET:
-                order_type_str = "MARKET" 
-            elif order_type == OrderType.LIMIT:
-                order_type_str = "LIMIT"
-            elif order_type == OrderType.LIMIT_MAKER:
-                order_type_str = "LIMIT_MAKER"
+            order_type_str = "LIMIT" if order_type == OrderType.LIMIT else "LIMIT_MAKER"
             self.logger().network(
                 f"Error submitting sell {order_type_str} order to Kucoin for "
                 f"{decimal_amount} {trading_pair} "
@@ -837,7 +822,7 @@ cdef class KucoinMarket(MarketBase):
     cdef str c_sell(self,
                     str trading_pair,
                     object amount,
-                    object order_type = OrderType.MARKET,
+                    object order_type = OrderType.LIMIT,
                     object price = s_decimal_0,
                     dict kwargs = {}):
         cdef:
diff --git a/hummingbot/market/liquid/liquid_in_flight_order.pyx b/hummingbot/market/liquid/liquid_in_flight_order.pyx
index e1fddb6a9df..fa92abf159c 100644
--- a/hummingbot/market/liquid/liquid_in_flight_order.pyx
+++ b/hummingbot/market/liquid/liquid_in_flight_order.pyx
@@ -53,7 +53,7 @@ cdef class LiquidInFlightOrder(InFlightOrderBase):
         """
         :return: Order description string . One of ["limit buy" / "limit sell" / "market buy" / "market sell"]
         """
-        order_type = "market" if self.order_type is OrderType.MARKET else "limit"
+        order_type = "limit_maker" if self.order_type is OrderType.LIMIT_MAKER else "limit"
         side = "buy" if self.trade_type == TradeType.BUY else "sell"
         return f"{order_type} {side}"
 
diff --git a/hummingbot/market/liquid/liquid_market.pyx b/hummingbot/market/liquid/liquid_market.pyx
index 5df8a52a036..527227de177 100644
--- a/hummingbot/market/liquid/liquid_market.pyx
+++ b/hummingbot/market/liquid/liquid_market.pyx
@@ -344,7 +344,7 @@ cdef class LiquidMarket(MarketBase):
             return TradeFee(percent=fee_overrides_config_map["liquid_taker_fee"].value / Decimal("100"))
         return TradeFee(percent=maker_fee if order_type is OrderType.LIMIT else taker_fee)
         """
-        is_maker = order_type is OrderType.LIMIT
+        is_maker = order_type is OrderType.LIMIT_MAKER
         return estimate_fee("liquid", is_maker)
 
     async def _update_balances(self):
@@ -623,7 +623,7 @@ cdef class LiquidMarket(MarketBase):
                 else Decimal(order_update["average_price"])
 
             order_type_description = tracked_order.order_type_description
-            order_type = OrderType.MARKET if tracked_order.order_type == OrderType.MARKET else OrderType.LIMIT
+            order_type = tracked_order.order_type
             # Emit event if executed amount is greater than 0.
             if execute_amount_diff > s_decimal_0:
                 order_filled_event = OrderFilledEvent(
@@ -836,7 +836,7 @@ cdef class LiquidMarket(MarketBase):
                 await asyncio.sleep(5.0)
 
     def supported_order_types(self):
-        return [OrderType.LIMIT, OrderType.MARKET, OrderType.LIMIT_MAKER]
+        return [OrderType.LIMIT, OrderType.LIMIT_MAKER]
 
     async def place_order(self, order_id: str, trading_pair: str, amount: Decimal, is_buy: bool, order_type: OrderType,
                           price: Decimal):
@@ -849,8 +849,6 @@ cdef class LiquidMarket(MarketBase):
 
         if order_type is OrderType.LIMIT:
             order_type_str = "limit"
-        elif order_type is OrderType.MARKET:
-            order_type_str = "market"
         elif order_type is OrderType.LIMIT_MAKER:
             order_type_str = "limit_post_only"
 
@@ -940,7 +938,7 @@ cdef class LiquidMarket(MarketBase):
             raise
         except Exception as e:
             self.c_stop_tracking_order(order_id)
-            order_type_str = "MARKET" if order_type == OrderType.MARKET else "LIMIT"
+            order_type_str = "LIMIT_MAKER" if order_type == OrderType.LIMIT_MAKER else "LIMIT"
             self.logger().network(
                 f"Error submitting buy {order_type_str} order to Liquid for "
                 f"{decimal_amount} {trading_pair} {price}.",
@@ -951,7 +949,7 @@ cdef class LiquidMarket(MarketBase):
             self.c_trigger_event(self.MARKET_ORDER_FAILURE_EVENT_TAG,
                                  MarketOrderFailureEvent(self._current_timestamp, order_id, order_type))
 
-    cdef str c_buy(self, str trading_pair, object amount, object order_type=OrderType.MARKET, object price=s_decimal_0,
+    cdef str c_buy(self, str trading_pair, object amount, object order_type=OrderType.LIMIT, object price=s_decimal_0,
                    dict kwargs={}):
         """
         *required
@@ -1004,7 +1002,7 @@ cdef class LiquidMarket(MarketBase):
             raise
         except Exception as e:
             self.c_stop_tracking_order(order_id)
-            order_type_str = "MARKET" if order_type == OrderType.MARKET else "LIMIT"
+            order_type_str = "LIMIT_MAKER" if order_type == OrderType.LIMIT_MAKER else "LIMIT"
             self.logger().network(
                 f"Error submitting sell {order_type_str} order to Liquid for "
                 f"{decimal_amount} {trading_pair} {price}.",
@@ -1015,7 +1013,7 @@ cdef class LiquidMarket(MarketBase):
             self.c_trigger_event(self.MARKET_ORDER_FAILURE_EVENT_TAG,
                                  MarketOrderFailureEvent(self._current_timestamp, order_id, order_type))
 
-    cdef str c_sell(self, str trading_pair, object amount, object order_type=OrderType.MARKET, object price=s_decimal_0,
+    cdef str c_sell(self, str trading_pair, object amount, object order_type=OrderType.LIMIT, object price=s_decimal_0,
                     dict kwargs={}):
         """
         *required
diff --git a/hummingbot/market/market_base.pyx b/hummingbot/market/market_base.pyx
index 416fd6bcec3..22d2059ced7 100755
--- a/hummingbot/market/market_base.pyx
+++ b/hummingbot/market/market_base.pyx
@@ -129,11 +129,11 @@ cdef class MarketBase(NetworkIterator):
     async def cancel_all(self, timeout_seconds: float) -> List[CancellationResult]:
         raise NotImplementedError
 
-    cdef str c_buy(self, str trading_pair, object amount, object order_type=OrderType.MARKET,
+    cdef str c_buy(self, str trading_pair, object amount, object order_type=OrderType.LIMIT,
                    object price=s_decimal_NaN, dict kwargs={}):
         raise NotImplementedError
 
-    cdef str c_sell(self, str trading_pair, object amount, object order_type=OrderType.MARKET,
+    cdef str c_sell(self, str trading_pair, object amount, object order_type=OrderType.LIMIT,
                     object price=s_decimal_NaN, dict kwargs={}):
         raise NotImplementedError
 
@@ -195,7 +195,7 @@ cdef class MarketBase(NetworkIterator):
         return (amount // order_size_quantum) * order_size_quantum
 
     def supported_order_types(self):
-        return [OrderType.LIMIT, OrderType.MARKET]
+        return [OrderType.LIMIT, OrderType.LIMIT_MAKER]
 
     # ----------------------------------------------------------------------------------------------------------
     # </editor-fold>
@@ -318,11 +318,11 @@ cdef class MarketBase(NetworkIterator):
     def get_price(self, trading_pair: str, is_buy: bool) -> Decimal:
         return self.c_get_price(trading_pair, is_buy)
 
-    def buy(self, trading_pair: str, amount: Decimal, order_type=OrderType.MARKET,
+    def buy(self, trading_pair: str, amount: Decimal, order_type=OrderType.LIMIT,
             price: Decimal = s_decimal_NaN, **kwargs) -> str:
         return self.c_buy(trading_pair, amount, order_type, price, kwargs)
 
-    def sell(self, trading_pair: str, amount: Decimal, order_type=OrderType.MARKET,
+    def sell(self, trading_pair: str, amount: Decimal, order_type=OrderType.LIMIT,
              price: Decimal = s_decimal_NaN, **kwargs) -> str:
         return self.c_sell(trading_pair, amount, order_type, price, kwargs)
 
diff --git a/hummingbot/market/paper_trade/paper_trade_market.pyx b/hummingbot/market/paper_trade/paper_trade_market.pyx
index e3223aabf9d..ac6fce668c3 100644
--- a/hummingbot/market/paper_trade/paper_trade_market.pyx
+++ b/hummingbot/market/paper_trade/paper_trade_market.pyx
@@ -162,7 +162,7 @@ cdef class OrderBookMarketOrderFillListener(EventListener):
 
     cdef c_call(self, object event_object):
 
-        if event_object.trading_pair not in self._market.order_books or event_object.order_type != OrderType.MARKET:
+        if event_object.trading_pair not in self._market.order_books or event_object.order_type != OrderType.LIMIT:
             return
         order_book = self._market.order_books[event_object.trading_pair]
         order_book.record_filled_order(event_object)
@@ -330,7 +330,7 @@ cdef class PaperTradeMarket(MarketBase):
     cdef str c_buy(self,
                    str trading_pair_str,
                    object amount,
-                   object order_type=OrderType.MARKET,
+                   object order_type=OrderType.LIMIT,
                    object price=s_decimal_0,
                    dict kwargs={}):
         if trading_pair_str not in self._trading_pairs:
@@ -347,14 +347,12 @@ cdef class PaperTradeMarket(MarketBase):
             SingleTradingPairLimitOrders *limit_orders_collection_ptr = NULL
             pair[LimitOrders.iterator, cppbool] insert_result
 
-        quantized_price = (self.c_quantize_order_price(trading_pair_str, price)
-                           if order_type is OrderType.LIMIT
-                           else s_decimal_0)
+        quantized_price = self.c_quantize_order_price(trading_pair_str, price)
         quantized_amount = self.c_quantize_order_amount(trading_pair_str, amount)
-        if order_type is OrderType.MARKET:
+        if order_type is OrderType.LIMIT:
             self._queued_orders.append(QueuedOrder(self._current_timestamp, order_id, True, trading_pair_str,
                                                    quantized_amount))
-        elif order_type is OrderType.LIMIT:
+        elif order_type is OrderType.LIMIT_MAKER:
 
             map_it = self._bid_limit_orders.find(cpp_trading_pair_str)
 
@@ -386,7 +384,7 @@ cdef class PaperTradeMarket(MarketBase):
     cdef str c_sell(self,
                     str trading_pair_str,
                     object amount,
-                    object order_type=OrderType.MARKET,
+                    object order_type=OrderType.LIMIT,
                     object price=s_decimal_0,
                     dict kwargs={}):
 
@@ -403,14 +401,12 @@ cdef class PaperTradeMarket(MarketBase):
             SingleTradingPairLimitOrders *limit_orders_collection_ptr = NULL
             pair[LimitOrders.iterator, cppbool] insert_result
 
-        quantized_price = (self.c_quantize_order_price(trading_pair_str, price)
-                           if order_type is OrderType.LIMIT
-                           else s_decimal_0)
+        quantized_price = self.c_quantize_order_price(trading_pair_str, price)
         quantized_amount = self.c_quantize_order_amount(trading_pair_str, amount)
-        if order_type is OrderType.MARKET:
+        if order_type is OrderType.LIMIT:
             self._queued_orders.append(QueuedOrder(self._current_timestamp, order_id, False, trading_pair_str,
                                                    quantized_amount))
-        elif order_type is OrderType.LIMIT:
+        elif order_type is OrderType.LIMIT_MAKER:
             map_it = self._ask_limit_orders.find(cpp_trading_pair_str)
 
             if map_it == self._ask_limit_orders.end():
@@ -457,7 +453,7 @@ cdef class PaperTradeMarket(MarketBase):
                                   f"{total_quote_needed} {quote_asset} required for the order.")
             self.c_trigger_event(
                 self.MARKET_ORDER_FAILURE_EVENT_TAG,
-                MarketOrderFailureEvent(self._current_timestamp, order_id, OrderType.MARKET)
+                MarketOrderFailureEvent(self._current_timestamp, order_id, OrderType.LIMIT)
             )
             return
 
@@ -471,7 +467,7 @@ cdef class PaperTradeMarket(MarketBase):
         fees = estimate_fee(self.name, False)
 
         order_filled_events = OrderFilledEvent.order_filled_events_from_order_book_rows(
-            self._current_timestamp, order_id, trading_pair, TradeType.BUY, OrderType.MARKET,
+            self._current_timestamp, order_id, trading_pair, TradeType.BUY, OrderType.LIMIT,
             fees, buy_entries
         )
 
@@ -488,7 +484,7 @@ cdef class PaperTradeMarket(MarketBase):
                                    total_base_acquired,
                                    total_quote_needed,
                                    s_decimal_0,
-                                   OrderType.MARKET))
+                                   OrderType.LIMIT))
 
     cdef c_execute_sell(self, str order_id, str trading_pair_str, object amount):
         cdef:
@@ -506,7 +502,7 @@ cdef class PaperTradeMarket(MarketBase):
                                   f"{amount} {base_asset} required for the order.")
             self.c_trigger_event(
                 self.MARKET_ORDER_FAILURE_EVENT_TAG,
-                MarketOrderFailureEvent(self._current_timestamp, order_id, OrderType.MARKET)
+                MarketOrderFailureEvent(self._current_timestamp, order_id, OrderType.LIMIT)
             )
             return
 
@@ -532,7 +528,7 @@ cdef class PaperTradeMarket(MarketBase):
 
         order_filled_events = OrderFilledEvent.order_filled_events_from_order_book_rows(
             self._current_timestamp, order_id, trading_pair_str, TradeType.SELL,
-            OrderType.MARKET, fees, sell_entries
+            OrderType.LIMIT, fees, sell_entries
         )
 
         for order_filled_event in order_filled_events:
@@ -548,7 +544,7 @@ cdef class PaperTradeMarket(MarketBase):
                                     sold_amount,
                                     acquired_amount,
                                     fee_amount,
-                                    OrderType.MARKET))
+                                    OrderType.LIMIT))
 
     cdef c_process_market_orders(self):
         cdef:
diff --git a/hummingbot/market/radar_relay/radar_relay_market.pxd b/hummingbot/market/radar_relay/radar_relay_market.pxd
index 6004049d187..934d662ac30 100755
--- a/hummingbot/market/radar_relay/radar_relay_market.pxd
+++ b/hummingbot/market/radar_relay/radar_relay_market.pxd
@@ -17,8 +17,8 @@ cdef class RadarRelayMarket(MarketBase):
         double _last_update_trading_rules_timestamp
         double _last_update_available_balance_timestamp
         double _poll_interval
-        dict _in_flight_limit_orders
-        dict _in_flight_market_orders
+        dict _in_flight_maker_orders
+        dict _in_flight_taker_orders
         object _order_expiry_queue
         TransactionTracker _tx_tracker
         object _w3
@@ -31,7 +31,7 @@ cdef class RadarRelayMarket(MarketBase):
         public object _approval_tx_polling_task
         int64_t _latest_salt
 
-    cdef c_start_tracking_limit_order(self,
+    cdef c_start_tracking_maker_order(self,
                                       str order_id,
                                       str exchange_order_id,
                                       str trading_pair,
@@ -40,7 +40,7 @@ cdef class RadarRelayMarket(MarketBase):
                                       object price,
                                       object amount,
                                       object zero_ex_order)
-    cdef c_start_tracking_market_order(self,
+    cdef c_start_tracking_taker_order(self,
                                        str order_id,
                                        str trading_pair,
                                        object order_type,
diff --git a/hummingbot/market/radar_relay/radar_relay_market.pyx b/hummingbot/market/radar_relay/radar_relay_market.pyx
index 180a8a0dbc9..e39d970be8a 100755
--- a/hummingbot/market/radar_relay/radar_relay_market.pyx
+++ b/hummingbot/market/radar_relay/radar_relay_market.pyx
@@ -127,8 +127,8 @@ cdef class RadarRelayMarket(MarketBase):
         self._last_update_trading_rules_timestamp = 0
         self._last_update_available_balance_timestamp = 0
         self._poll_interval = poll_interval
-        self._in_flight_limit_orders = {}  # limit orders are off chain
-        self._in_flight_market_orders = {}  # market orders are on chain
+        self._in_flight_maker_orders = {}  # limit orders are off chain
+        self._in_flight_taker_orders = {}  # market orders are on chain
         self._order_expiry_queue = deque()
         self._tx_tracker = RadarRelayTransactionTracker(self)
         self._w3 = Web3(Web3.HTTPProvider(ethereum_rpc_url))
@@ -179,11 +179,11 @@ cdef class RadarRelayMarket(MarketBase):
 
     @property
     def in_flight_limit_orders(self) -> Dict[str, RadarRelayInFlightOrder]:
-        return self._in_flight_limit_orders
+        return self._in_flight_maker_orders
 
     @property
     def in_flight_market_orders(self) -> Dict[str, RadarRelayInFlightOrder]:
-        return self._in_flight_market_orders
+        return self._in_flight_taker_orders
 
     @property
     def limit_orders(self) -> List[LimitOrder]:
@@ -194,9 +194,9 @@ cdef class RadarRelayMarket(MarketBase):
             str quote_currency
             set expiring_order_ids = set([order_id for _, order_id in self._order_expiry_queue])
 
-        for in_flight_order in self._in_flight_limit_orders.values():
+        for in_flight_order in self._in_flight_maker_orders.values():
             typed_in_flight_order = in_flight_order
-            if typed_in_flight_order.order_type is not OrderType.LIMIT:
+            if typed_in_flight_order.order_type is not OrderType.LIMIT_MAKER:
                 continue
             if typed_in_flight_order.client_order_id in expiring_order_ids:
                 continue
@@ -208,20 +208,20 @@ cdef class RadarRelayMarket(MarketBase):
         return {
             "market_orders": {
                 key: value.to_json()
-                for key, value in self._in_flight_market_orders.items()
+                for key, value in self._in_flight_taker_orders.items()
             },
             "limit_orders": {
                 key: value.to_json()
-                for key, value in self._in_flight_limit_orders.items()
+                for key, value in self._in_flight_maker_orders.items()
             }
         }
 
     def restore_tracking_states(self, saved_states: Dict[str, any]):
-        self._in_flight_market_orders.update({
+        self._in_flight_taker_orders.update({
             key: RadarRelayInFlightOrder.from_json(value)
             for key, value in saved_states["market_orders"].items()
         })
-        self._in_flight_limit_orders.update({
+        self._in_flight_maker_orders.update({
             key: RadarRelayInFlightOrder.from_json(value)
             for key, value in saved_states["limit_orders"].items()
         })
@@ -271,7 +271,7 @@ cdef class RadarRelayMarket(MarketBase):
         transaction_cost_eth = self._wallet.gas_price * gas_estimate / 1e18
         return TradeFee(percent=Decimal(0.0), flat_fees=[("ETH", transaction_cost_eth)])
         """
-        is_maker = order_type is OrderType.LIMIT
+        is_maker = order_type is OrderType.LIMIT_MAKER
         return estimate_fee("radar_relay", is_maker)
 
     def _update_balances(self):
@@ -283,11 +283,11 @@ cdef class RadarRelayMarket(MarketBase):
 
         if current_timestamp - self._last_update_available_balance_timestamp > 10.0:
 
-            if len(self._in_flight_limit_orders) >= 0:
+            if len(self._in_flight_maker_orders) >= 0:
                 locked_balances = {}
                 total_balances = self._account_balances
 
-                for order in self._in_flight_limit_orders.values():
+                for order in self._in_flight_maker_orders.values():
                     # Orders that are done, cancelled or expired don't deduct from the available balance
                     if (not order.is_cancelled and
                             not order.is_expired and
@@ -382,8 +382,8 @@ cdef class RadarRelayMarket(MarketBase):
         if current_timestamp - self._last_update_limit_order_timestamp <= self.UPDATE_OPEN_LIMIT_ORDERS_INTERVAL:
             return
 
-        if len(self._in_flight_limit_orders) > 0:
-            tracked_limit_orders = list(self._in_flight_limit_orders.values())
+        if len(self._in_flight_maker_orders) > 0:
+            tracked_limit_orders = list(self._in_flight_maker_orders.values())
             order_updates = await self._get_order_updates(tracked_limit_orders)
             for order_update, tracked_limit_order in zip(order_updates, tracked_limit_orders):
                 if isinstance(order_update, Exception):
@@ -411,7 +411,7 @@ cdef class RadarRelayMarket(MarketBase):
                 tracked_limit_order.executed_amount_quote = order_remaining_quote_token_amount
                 if order_executed_amount_base > 0:
                     self.logger().info(f"Filled {order_executed_amount_base} out of {tracked_limit_order.amount} of the "
-                                       f"limit order {tracked_limit_order.client_order_id}.")
+                                       f"limit maker order {tracked_limit_order.client_order_id}.")
                     self.c_trigger_event(
                         self.MARKET_ORDER_FILLED_EVENT_TAG,
                         OrderFilledEvent(
@@ -419,7 +419,7 @@ cdef class RadarRelayMarket(MarketBase):
                             tracked_limit_order.client_order_id,
                             tracked_limit_order.trading_pair,
                             tracked_limit_order.trade_type,
-                            OrderType.LIMIT,
+                            OrderType.LIMIT_MAKER,
                             tracked_limit_order.price,
                             order_executed_amount_base,
                             TradeFee(0.0),  # no fee for limit order fills
@@ -429,7 +429,7 @@ cdef class RadarRelayMarket(MarketBase):
 
                 # do not retrigger order events if order was already in that state previously
                 if not previous_is_cancelled and tracked_limit_order.is_cancelled:
-                    self.logger().info(f"The limit order {tracked_limit_order.client_order_id} has cancelled according "
+                    self.logger().info(f"The limit maker order {tracked_limit_order.client_order_id} has cancelled according "
                                        f"to order status API.")
                     self.c_expire_order(tracked_limit_order.client_order_id)
                     self.c_trigger_event(
@@ -437,7 +437,7 @@ cdef class RadarRelayMarket(MarketBase):
                         OrderCancelledEvent(self._current_timestamp, tracked_limit_order.client_order_id)
                     )
                 elif not previous_is_expired and tracked_limit_order.is_expired:
-                    self.logger().info(f"The limit order {tracked_limit_order.client_order_id} has expired according "
+                    self.logger().info(f"The limit maker order {tracked_limit_order.client_order_id} has expired according "
                                        f"to order status API.")
                     self.c_expire_order(tracked_limit_order.client_order_id)
                     self.c_trigger_event(
@@ -445,19 +445,19 @@ cdef class RadarRelayMarket(MarketBase):
                         OrderExpiredEvent(self._current_timestamp, tracked_limit_order.client_order_id)
                     )
                 elif not previous_is_failure and tracked_limit_order.is_failure:
-                    self.logger().info(f"The limit order {tracked_limit_order.client_order_id} has failed "
+                    self.logger().info(f"The limit maker order {tracked_limit_order.client_order_id} has failed "
                                        f"according to order status API.")
                     self.c_expire_order(tracked_limit_order.client_order_id)
                     self.c_trigger_event(
                         self.MARKET_ORDER_FAILURE_EVENT_TAG,
                         MarketOrderFailureEvent(self._current_timestamp,
                                                 tracked_limit_order.client_order_id,
-                                                OrderType.LIMIT)
+                                                OrderType.LIMIT_MAKER)
                     )
                 elif not previous_is_done and tracked_limit_order.is_done:
                     self.c_expire_order(tracked_limit_order.client_order_id)
                     if tracked_limit_order.trade_type is TradeType.BUY:
-                        self.logger().info(f"The limit buy order {tracked_limit_order.client_order_id}"
+                        self.logger().info(f"The limit maker buy order {tracked_limit_order.client_order_id}"
                                            f"has completed according to order status API.")
                         self.c_trigger_event(self.MARKET_BUY_ORDER_COMPLETED_EVENT_TAG,
                                              BuyOrderCompletedEvent(self._current_timestamp,
@@ -468,9 +468,9 @@ cdef class RadarRelayMarket(MarketBase):
                                                                     tracked_limit_order.executed_amount_base,
                                                                     tracked_limit_order.executed_amount_quote,
                                                                     tracked_limit_order.gas_fee_amount,
-                                                                    OrderType.LIMIT))
+                                                                    OrderType.LIMIT_MAKER))
                     else:
-                        self.logger().info(f"The limit sell order {tracked_limit_order.client_order_id}"
+                        self.logger().info(f"The limit maker sell order {tracked_limit_order.client_order_id}"
                                            f"has completed according to order status API.")
                         self.c_trigger_event(self.MARKET_SELL_ORDER_COMPLETED_EVENT_TAG,
                                              SellOrderCompletedEvent(self._current_timestamp,
@@ -481,7 +481,7 @@ cdef class RadarRelayMarket(MarketBase):
                                                                      tracked_limit_order.executed_amount_base,
                                                                      tracked_limit_order.executed_amount_quote,
                                                                      tracked_limit_order.gas_fee_amount,
-                                                                     OrderType.LIMIT))
+                                                                     OrderType.LIMIT_MAKER))
         self._last_update_limit_order_timestamp = current_timestamp
 
     async def _update_market_order_status(self):
@@ -491,8 +491,8 @@ cdef class RadarRelayMarket(MarketBase):
         if current_timestamp - self._last_update_market_order_timestamp <= self.UPDATE_MARKET_ORDERS_INTERVAL:
             return
 
-        if len(self._in_flight_market_orders) > 0:
-            tracked_market_orders = list(self._in_flight_market_orders.values())
+        if len(self._in_flight_taker_orders) > 0:
+            tracked_market_orders = list(self._in_flight_taker_orders.values())
             for tracked_market_order in tracked_market_orders:
                 receipt = self.get_tx_hash_receipt(tracked_market_order.tx_hash)
 
@@ -507,7 +507,7 @@ cdef class RadarRelayMarket(MarketBase):
                         self.MARKET_ORDER_FAILURE_EVENT_TAG,
                         MarketOrderFailureEvent(self._current_timestamp,
                                                 tracked_market_order.client_order_id,
-                                                OrderType.MARKET)
+                                                OrderType.LIMIT)
                     )
                 elif receipt["status"] == 1:
                     gas_used = float(receipt.get("gasUsed", 0.0))
@@ -518,7 +518,7 @@ cdef class RadarRelayMarket(MarketBase):
                             tracked_market_order.client_order_id,
                             tracked_market_order.trading_pair,
                             tracked_market_order.trade_type,
-                            OrderType.MARKET,
+                            OrderType.LIMIT,
                             tracked_market_order.price,
                             tracked_market_order.amount,
                             TradeFee(0.0, [("ETH", gas_used)]),
@@ -538,7 +538,7 @@ cdef class RadarRelayMarket(MarketBase):
                                                                     tracked_market_order.amount,
                                                                     tracked_market_order.executed_amount_quote,
                                                                     tracked_market_order.gas_fee_amount,
-                                                                    OrderType.MARKET))
+                                                                    OrderType.LIMIT))
                     else:
                         self.logger().info(f"The market sell order "
                                            f"{tracked_market_order.client_order_id} has completed according to "
@@ -552,7 +552,7 @@ cdef class RadarRelayMarket(MarketBase):
                                                                      tracked_market_order.amount,
                                                                      tracked_market_order.executed_amount_quote,
                                                                      tracked_market_order.gas_fee_amount,
-                                                                     OrderType.MARKET))
+                                                                     OrderType.LIMIT))
                 else:
                     err_msg = (f"Unrecognized transaction status for market order "
                                f"{tracked_market_order.client_order_id}. Check transaction hash "
@@ -562,7 +562,7 @@ cdef class RadarRelayMarket(MarketBase):
                         self.MARKET_ORDER_FAILURE_EVENT_TAG,
                         MarketOrderFailureEvent(self._current_timestamp,
                                                 tracked_market_order.client_order_id,
-                                                OrderType.MARKET)
+                                                OrderType.LIMIT)
                     )
 
                 self.c_stop_tracking_order(tracked_market_order.tx_hash)
@@ -670,16 +670,24 @@ cdef class RadarRelayMarket(MarketBase):
     async def submit_market_order(self,
                                   trading_pair: str,
                                   trade_type: TradeType,
+                                  price: Decimal,
                                   amount: Decimal) -> Tuple[float, str]:
         response = await self.request_signed_market_orders(trading_pair=trading_pair,
                                                            trade_type=trade_type,
                                                            amount=str(amount))
         signed_market_orders = response["orders"]
         average_price = Decimal(response["averagePrice"])
+        worst_price = Decimal(response["worstPrice"])
         base_asset_increment = self.trading_rules.get(trading_pair).min_base_amount_increment
         base_asset_decimals = -int(math.ceil(math.log10(base_asset_increment)))
         amt_with_decimals = amount * Decimal(f"1e{base_asset_decimals}")
 
+        # check that price equal or  within the worstPrice recieved from marker_orders response
+        if trade_type is TradeType.BUY and price < worst_price:
+            raise ValueError("Buy price too low for the amount, recalculate market sell price")
+        elif trade_type is TradeType.SELL and price > worst_price:
+            raise ValueError("Sell price too low for the amount, recalculate market sell price")
+
         signatures = []
         orders = []
         for order in signed_market_orders:
@@ -725,7 +733,7 @@ cdef class RadarRelayMarket(MarketBase):
 
     async def cancel_all(self, timeout_seconds: float) -> List[CancellationResult]:
         incomplete_order_ids = [o.client_order_id
-                                for o in self._in_flight_limit_orders.values()
+                                for o in self._in_flight_maker_orders.values()
                                 if not (o.is_done or o.is_cancelled or o.is_expired or o.is_failure)]
         if self._latest_salt == -1 or len(incomplete_order_ids) == 0:
             return []
@@ -773,11 +781,11 @@ cdef class RadarRelayMarket(MarketBase):
                 raise ValueError(f"{trade_type_desc.capitalize()} order amount {q_amt} is greater than the "
                                  f"maximum order size {trading_rule.max_order_size}")
 
-            if order_type is OrderType.LIMIT:
+            if order_type is OrderType.LIMIT_MAKER:
                 if math.isnan(price):
-                    raise ValueError(f"Limit orders require a price. Aborting.")
+                    raise ValueError(f"Limit maker orders require a price. Aborting.")
                 elif expires is None:
-                    raise ValueError(f"Limit orders require an expiration timestamp 'expiration_ts'. Aborting.")
+                    raise ValueError(f"Limit maker orders require an expiration timestamp 'expiration_ts'. Aborting.")
                 elif expires < time.time():
                     raise ValueError(f"expiration time {expires} must be greater than current time {time.time()}")
                 else:
@@ -787,7 +795,7 @@ cdef class RadarRelayMarket(MarketBase):
                                                                                      amount=q_amt,
                                                                                      price=q_price,
                                                                                      expires=expires)
-                    self.c_start_tracking_limit_order(order_id=order_id,
+                    self.c_start_tracking_maker_order(order_id=order_id,
                                                       exchange_order_id=exchange_order_id,
                                                       trading_pair=trading_pair,
                                                       order_type=order_type,
@@ -795,12 +803,14 @@ cdef class RadarRelayMarket(MarketBase):
                                                       price=q_price,
                                                       amount=q_amt,
                                                       zero_ex_order=zero_ex_order)
-            elif order_type is OrderType.MARKET:
+            elif order_type is OrderType.LIMIT:
+                # note OrderType.LIMIT is thesame as a market taker
                 avg_price, tx_hash = await self.submit_market_order(trading_pair=trading_pair,
                                                                     trade_type=trade_type,
+                                                                    price=price,
                                                                     amount=q_amt)
                 q_price = str(self.c_quantize_order_price(trading_pair, Decimal(avg_price)))
-                self.c_start_tracking_market_order(order_id=order_id,
+                self.c_start_tracking_taker_order(order_id=order_id,
                                                    trading_pair=trading_pair,
                                                    order_type=order_type,
                                                    trade_type=trade_type,
@@ -845,7 +855,7 @@ cdef class RadarRelayMarket(MarketBase):
     cdef str c_buy(self,
                    str trading_pair,
                    object amount,
-                   object order_type=OrderType.MARKET,
+                   object order_type=OrderType.LIMIT,
                    object price=s_decimal_NaN,
                    dict kwargs={}):
         cdef:
@@ -866,7 +876,7 @@ cdef class RadarRelayMarket(MarketBase):
     cdef str c_sell(self,
                     str trading_pair,
                     object amount,
-                    object order_type=OrderType.MARKET,
+                    object order_type=OrderType.LIMIT,
                     object price=s_decimal_NaN,
                     dict kwargs={}):
         cdef:
@@ -885,7 +895,7 @@ cdef class RadarRelayMarket(MarketBase):
         return order_id
 
     async def cancel_order(self, client_order_id: str) -> Dict[str, Any]:
-        order = self._in_flight_limit_orders.get(client_order_id)
+        order = self._in_flight_maker_orders.get(client_order_id)
         if not order:
             self.logger().info(f"Failed to cancel order {client_order_id}. Order not found in tracked orders.")
             return
@@ -972,7 +982,7 @@ cdef class RadarRelayMarket(MarketBase):
         self.c_check_and_remove_expired_orders()
         self._last_timestamp = timestamp
 
-    cdef c_start_tracking_limit_order(self,
+    cdef c_start_tracking_maker_order(self,
                                       str order_id,
                                       str exchange_order_id,
                                       str trading_pair,
@@ -981,7 +991,7 @@ cdef class RadarRelayMarket(MarketBase):
                                       object price,
                                       object amount,
                                       object zero_ex_order):
-        self._in_flight_limit_orders[order_id] = RadarRelayInFlightOrder(
+        self._in_flight_maker_orders[order_id] = RadarRelayInFlightOrder(
             client_order_id=order_id,
             exchange_order_id=exchange_order_id,
             trading_pair=trading_pair,
@@ -993,7 +1003,7 @@ cdef class RadarRelayMarket(MarketBase):
             zero_ex_order=zero_ex_order
         )
 
-    cdef c_start_tracking_market_order(self,
+    cdef c_start_tracking_taker_order(self,
                                        str order_id,
                                        str trading_pair,
                                        object order_type,
@@ -1001,7 +1011,7 @@ cdef class RadarRelayMarket(MarketBase):
                                        object price,
                                        object amount,
                                        str tx_hash):
-        self._in_flight_market_orders[tx_hash] = RadarRelayInFlightOrder(
+        self._in_flight_taker_orders[tx_hash] = RadarRelayInFlightOrder(
             client_order_id=order_id,
             exchange_order_id=None,
             trading_pair=trading_pair,
@@ -1025,10 +1035,10 @@ cdef class RadarRelayMarket(MarketBase):
             self.c_stop_tracking_order(order_id)
 
     cdef c_stop_tracking_order(self, str order_id):
-        if order_id in self._in_flight_limit_orders:
-            del self._in_flight_limit_orders[order_id]
-        elif order_id in self._in_flight_market_orders:
-            del self._in_flight_market_orders[order_id]
+        if order_id in self._in_flight_maker_orders:
+            del self._in_flight_maker_orders[order_id]
+        elif order_id in self._in_flight_taker_orders:
+            del self._in_flight_taker_orders[order_id]
 
     cdef object c_get_order_price_quantum(self, str trading_pair, object price):
         cdef:
diff --git a/hummingbot/strategy/arbitrage/arbitrage.pyx b/hummingbot/strategy/arbitrage/arbitrage.pyx
index 4cec983350d..4c23a366855 100755
--- a/hummingbot/strategy/arbitrage/arbitrage.pyx
+++ b/hummingbot/strategy/arbitrage/arbitrage.pyx
@@ -424,7 +424,7 @@ cdef class ArbitrageStrategy(StrategyBase):
             buy_fee = buy_market.c_get_fee(
                 buy_market_trading_pair_tuple.base_asset,
                 buy_market_trading_pair_tuple.quote_asset,
-                OrderType.MARKET,
+                OrderType.LIMIT,
                 TradeType.BUY,
                 total_previous_step_base_amount + amount,
                 ask_price
@@ -432,7 +432,7 @@ cdef class ArbitrageStrategy(StrategyBase):
             sell_fee = sell_market.c_get_fee(
                 sell_market_trading_pair_tuple.base_asset,
                 sell_market_trading_pair_tuple.quote_asset,
-                OrderType.MARKET,
+                OrderType.LIMIT,
                 TradeType.SELL,
                 total_previous_step_base_amount + amount,
                 bid_price
diff --git a/hummingbot/strategy/cross_exchange_market_making/cross_exchange_market_making.pyx b/hummingbot/strategy/cross_exchange_market_making/cross_exchange_market_making.pyx
index 7ecb29d270e..1b740390cd4 100755
--- a/hummingbot/strategy/cross_exchange_market_making/cross_exchange_market_making.pyx
+++ b/hummingbot/strategy/cross_exchange_market_making/cross_exchange_market_making.pyx
@@ -402,7 +402,7 @@ cdef class CrossExchangeMarketMakingStrategy(StrategyBase):
             tuple order_fill_record
 
         # Make sure to only hedge limit orders.
-        if market_pair is not None and order_filled_event.order_type is OrderType.LIMIT:
+        if market_pair is not None and order_filled_event.order_type is OrderType.LIMIT_MAKER:
             limit_order_record = self._sb_order_tracker.c_get_shadow_limit_order(order_id)
             order_fill_record = (limit_order_record, order_filled_event)
 
@@ -452,7 +452,7 @@ cdef class CrossExchangeMarketMakingStrategy(StrategyBase):
             object order_type = order_completed_event.order_type
 
         if market_pair is not None:
-            if order_type == OrderType.LIMIT:
+            if order_type == OrderType.LIMIT_MAKER:
                 limit_order_record = self._sb_order_tracker.c_get_limit_order(market_pair.maker, order_id)
                 self.log_with_clock(
                     logging.INFO,
@@ -464,7 +464,7 @@ cdef class CrossExchangeMarketMakingStrategy(StrategyBase):
                     f"Maker BUY order ({limit_order_record.quantity} {limit_order_record.base_currency} @ "
                     f"{limit_order_record.price} {limit_order_record.quote_currency}) is filled."
                 )
-            if order_type == OrderType.MARKET:
+            if order_type == OrderType.LIMIT:
                 market_order_record = self._sb_order_tracker.c_get_market_order(market_pair.taker, order_id)
                 if market_order_record is not None:
                     self.log_with_clock(
@@ -488,7 +488,7 @@ cdef class CrossExchangeMarketMakingStrategy(StrategyBase):
 
         order_type = order_completed_event.order_type
         if market_pair is not None:
-            if order_type == OrderType.LIMIT:
+            if order_type == OrderType.LIMIT_MAKER:
                 limit_order_record = self._sb_order_tracker.c_get_limit_order(market_pair.maker, order_id)
                 self.log_with_clock(
                     logging.INFO,
@@ -500,7 +500,7 @@ cdef class CrossExchangeMarketMakingStrategy(StrategyBase):
                     f"Maker sell order ({limit_order_record.quantity} {limit_order_record.base_currency} @ "
                     f"{limit_order_record.price} {limit_order_record.quote_currency}) is filled."
                 )
-            if order_type == OrderType.MARKET:
+            if order_type == OrderType.LIMIT:
                 market_order_record = self._sb_order_tracker.c_get_market_order(market_pair.taker, order_id)
                 if market_order_record is not None:
                     self.log_with_clock(
@@ -1168,7 +1168,7 @@ cdef class CrossExchangeMarketMakingStrategy(StrategyBase):
                     self.c_sell_with_specific_market(
                         market_pair,
                         ask_size,
-                        order_type=OrderType.LIMIT,
+                        order_type=OrderType.LIMIT_MAKER,
                         price=ask_price
                     )
                 else:
@@ -1192,13 +1192,13 @@ cdef class CrossExchangeMarketMakingStrategy(StrategyBase):
     # attribution of trades to XEMM market pairs.
     # ----------------------------------------------------------------------------------------------------------
     cdef str c_buy_with_specific_market(self, object market_pair, object amount,
-                                        object order_type=OrderType.MARKET,
+                                        object order_type=OrderType.LIMIT,
                                         object price=s_decimal_nan,
                                         double expiration_seconds=NaN):
         if not isinstance(market_pair, CrossExchangeMarketPair):
             raise TypeError("market_pair must be a CrossExchangeMarketPair.")
 
-        market_trading_pair_tuple = market_pair.maker if order_type is OrderType.LIMIT else market_pair.taker
+        market_trading_pair_tuple = market_pair.maker if order_type is OrderType.LIMIT_MAKER else market_pair.taker
 
         if not self._active_order_canceling:
             expiration_seconds = self._limit_order_min_expiration
@@ -1212,13 +1212,13 @@ cdef class CrossExchangeMarketMakingStrategy(StrategyBase):
         return order_id
 
     cdef str c_sell_with_specific_market(self, object market_pair, object amount,
-                                         object order_type=OrderType.MARKET,
+                                         object order_type=OrderType.LIMIT,
                                          object price=s_decimal_nan,
                                          double expiration_seconds=NaN):
         if not isinstance(market_pair, CrossExchangeMarketPair):
             raise TypeError("market_pair must be a CrossExchangeMarketPair.")
 
-        market_trading_pair_tuple = market_pair.maker if order_type is OrderType.LIMIT else market_pair.taker
+        market_trading_pair_tuple = market_pair.maker if order_type is OrderType.LIMIT_MAKER else market_pair.taker
 
         if not self._active_order_canceling:
             expiration_seconds = self._limit_order_min_expiration
@@ -1240,13 +1240,13 @@ cdef class CrossExchangeMarketMakingStrategy(StrategyBase):
     # <editor-fold desc="+ Order tracking entry points">
     # Override the stop tracking entry points to include the market pair tracker as well.
     # ----------------------------------------------------------------------------------------------------------
-    cdef c_stop_tracking_limit_order(self, object market_trading_pair_tuple, str order_id):
+    cdef c_stop_tracking_maker_order(self, object market_trading_pair_tuple, str order_id):
         self._market_pair_tracker.c_stop_tracking_order_id(order_id)
-        StrategyBase.c_stop_tracking_limit_order(self, market_trading_pair_tuple, order_id)
+        StrategyBase.c_stop_tracking_maker_order(self, market_trading_pair_tuple, order_id)
 
-    cdef c_stop_tracking_market_order(self, object market_trading_pair_tuple, str order_id):
+    cdef c_stop_tracking_taker_order(self, object market_trading_pair_tuple, str order_id):
         self._market_pair_tracker.c_stop_tracking_order_id(order_id)
-        StrategyBase.c_stop_tracking_market_order(self, market_trading_pair_tuple, order_id)
+        StrategyBase.c_stop_tracking_taker_order(self, market_trading_pair_tuple, order_id)
     # ----------------------------------------------------------------------------------------------------------
     # </editor-fold>
 
diff --git a/hummingbot/strategy/order_tracker.pxd b/hummingbot/strategy/order_tracker.pxd
index bf77f08cf2f..f6d0eb1ca0d 100644
--- a/hummingbot/strategy/order_tracker.pxd
+++ b/hummingbot/strategy/order_tracker.pxd
@@ -25,11 +25,11 @@ cdef class OrderTracker(TimeIterator):
     cdef LimitOrder c_get_limit_order(self, object market_pair, str order_id)
     cdef object c_get_market_order(self, object market_pair, str order_id)
     cdef LimitOrder c_get_shadow_limit_order(self, str order_id)
-    cdef c_start_tracking_limit_order(self, object market_pair, str order_id, bint is_buy, object price,
+    cdef c_start_tracking_maker_order(self, object market_pair, str order_id, bint is_buy, object price,
                                       object quantity)
-    cdef c_stop_tracking_limit_order(self, object market_pair, str order_id)
-    cdef c_start_tracking_market_order(self, object market_pair, str order_id, bint is_buy, object quantity)
-    cdef c_stop_tracking_market_order(self, object market_pair, str order_id)
+    cdef c_stop_tracking_maker_order(self, object market_pair, str order_id)
+    cdef c_start_tracking_taker_order(self, object market_pair, str order_id, bint is_buy, object quantity)
+    cdef c_stop_tracking_taker_order(self, object market_pair, str order_id)
     cdef c_check_and_cleanup_shadow_records(self)
     cdef c_add_create_order_pending(self, str order_id)
     cdef c_remove_create_order_pending(self, str order_id)
diff --git a/hummingbot/strategy/order_tracker.pyx b/hummingbot/strategy/order_tracker.pyx
index 1216470c8f7..c0d7a710d91 100644
--- a/hummingbot/strategy/order_tracker.pyx
+++ b/hummingbot/strategy/order_tracker.pyx
@@ -174,7 +174,7 @@ cdef class OrderTracker(TimeIterator):
 
         return self._shadow_tracked_limit_orders.get(market_pair, {}).get(order_id)
 
-    cdef c_start_tracking_limit_order(self, object market_pair, str order_id, bint is_buy, object price,
+    cdef c_start_tracking_maker_order(self, object market_pair, str order_id, bint is_buy, object price,
                                       object quantity):
         if market_pair not in self._tracked_limit_orders:
             self._tracked_limit_orders[market_pair] = {}
@@ -194,7 +194,7 @@ cdef class OrderTracker(TimeIterator):
         self._order_id_to_market_pair[order_id] = market_pair
         self._shadow_order_id_to_market_pair[order_id] = market_pair
 
-    cdef c_stop_tracking_limit_order(self, object market_pair, str order_id):
+    cdef c_stop_tracking_maker_order(self, object market_pair, str order_id):
         if market_pair in self._tracked_limit_orders and order_id in self._tracked_limit_orders[market_pair]:
             del self._tracked_limit_orders[market_pair][order_id]
             if len(self._tracked_limit_orders[market_pair]) < 1:
@@ -210,7 +210,7 @@ cdef class OrderTracker(TimeIterator):
         if order_id in self._in_flight_cancels:
             del self._in_flight_cancels[order_id]
 
-    cdef c_start_tracking_market_order(self, object market_pair, str order_id, bint is_buy, object quantity):
+    cdef c_start_tracking_taker_order(self, object market_pair, str order_id, bint is_buy, object quantity):
         if market_pair not in self._tracked_market_orders:
             self._tracked_market_orders[market_pair] = {}
         self._tracked_market_orders[market_pair][order_id] = MarketOrder(
@@ -224,7 +224,7 @@ cdef class OrderTracker(TimeIterator):
         )
         self._order_id_to_market_pair[order_id] = market_pair
 
-    cdef c_stop_tracking_market_order(self, object market_pair, str order_id):
+    cdef c_stop_tracking_taker_order(self, object market_pair, str order_id):
         if market_pair in self._tracked_market_orders and order_id in self._tracked_market_orders[market_pair]:
             del self._tracked_market_orders[market_pair][order_id]
             if len(self._tracked_market_orders[market_pair]) < 1:
diff --git a/hummingbot/strategy/pure_market_making/pure_market_making.pyx b/hummingbot/strategy/pure_market_making/pure_market_making.pyx
index e4dd7846a5a..6c7259a06e2 100644
--- a/hummingbot/strategy/pure_market_making/pure_market_making.pyx
+++ b/hummingbot/strategy/pure_market_making/pure_market_making.pyx
@@ -129,7 +129,7 @@ cdef class PureMarketMakingStrategy(StrategyBase):
 
         self._cancel_timestamp = 0
         self._create_timestamp = 0
-        if paper_trade_disabled() and not take_if_crossed and OrderType.LIMIT_MAKER in self._market_info.market.supported_order_types():
+        if not take_if_crossed and OrderType.LIMIT_MAKER in self._market_info.market.supported_order_types():
             self._limit_order_type = OrderType.LIMIT_MAKER
         else:
             self._limit_order_type = OrderType.LIMIT
@@ -718,7 +718,7 @@ cdef class PureMarketMakingStrategy(StrategyBase):
         base_balance, quote_balance = self.c_get_adjusted_available_balance(self.active_non_hanging_orders)
 
         for buy in proposal.buys:
-            buy_fees = market.c_get_fee(self.base_asset, self.quote_asset, OrderType.MARKET, TradeType.BUY,
+            buy_fees = market.c_get_fee(self.base_asset, self.quote_asset, OrderType.LIMIT, TradeType.BUY,
                                         buy.size, buy.price)
             quote_size = buy.size * buy.price * (Decimal(1) + buy_fees.percent)
             if quote_balance < quote_size_total + quote_size:
@@ -802,12 +802,12 @@ cdef class PureMarketMakingStrategy(StrategyBase):
             MarketBase market = self._market_info.market
         for buy in proposal.buys:
             fee = market.c_get_fee(self.base_asset, self.quote_asset,
-                                   OrderType.LIMIT, TradeType.BUY, buy.size, buy.price)
+                                   OrderType.LIMIT_MAKER, TradeType.BUY, buy.size, buy.price)
             price = buy.price * (Decimal(1) - fee.percent)
             buy.price = market.c_quantize_order_price(self.trading_pair, price)
         for sell in proposal.sells:
             fee = market.c_get_fee(self.base_asset, self.quote_asset,
-                                   OrderType.LIMIT, TradeType.SELL, sell.size, sell.price)
+                                   OrderType.LIMIT_MAKER, TradeType.SELL, sell.size, sell.price)
             price = sell.price * (Decimal(1) + fee.percent)
             sell.price = market.c_quantize_order_price(self.trading_pair, price)
 
diff --git a/hummingbot/strategy/strategy_base.pxd b/hummingbot/strategy/strategy_base.pxd
index 1db3e9ee3da..5f6392bca30 100644
--- a/hummingbot/strategy/strategy_base.pxd
+++ b/hummingbot/strategy/strategy_base.pxd
@@ -42,11 +42,11 @@ cdef class StrategyBase(TimeIterator):
                                          object order_type = *, object price = *, double expiration_seconds = *)
     cdef c_cancel_order(self, object market_pair, str order_id)
 
-    cdef c_start_tracking_limit_order(self, object market_pair, str order_id, bint is_buy, object price,
+    cdef c_start_tracking_maker_order(self, object market_pair, str order_id, bint is_buy, object price,
                                       object quantity)
-    cdef c_stop_tracking_limit_order(self, object market_pair, str order_id)
-    cdef c_start_tracking_market_order(self, object market_pair, str order_id, bint is_buy, object quantity)
-    cdef c_stop_tracking_market_order(self, object market_pair, str order_id)
+    cdef c_stop_tracking_maker_order(self, object market_pair, str order_id)
+    cdef c_start_tracking_taker_order(self, object market_pair, str order_id, bint is_buy, object quantity)
+    cdef c_stop_tracking_taker_order(self, object market_pair, str order_id)
     cdef object c_sum_flat_fees(self,
                                 str quote_currency,
                                 list flat_fees)
diff --git a/hummingbot/strategy/strategy_base.pyx b/hummingbot/strategy/strategy_base.pyx
index 1b76cf5da34..0ce4d8175d0 100755
--- a/hummingbot/strategy/strategy_base.pyx
+++ b/hummingbot/strategy/strategy_base.pyx
@@ -327,17 +327,17 @@ cdef class StrategyBase(TimeIterator):
             object order_type = order_failed_event.order_type
             object market_pair = self._sb_order_tracker.c_get_market_pair_from_order_id(order_id)
 
-        if order_type.is_limit_type():
-            self.c_stop_tracking_limit_order(market_pair, order_id)
-        elif order_type == OrderType.MARKET:
-            self.c_stop_tracking_market_order(market_pair, order_id)
+        if order_type is OrderType.LIMIT_MAKER:
+            self.c_stop_tracking_maker_order(market_pair, order_id)
+        elif order_type is OrderType.LIMIT:
+            self.c_stop_tracking_taker_order(market_pair, order_id)
 
     cdef c_did_cancel_order_tracker(self, object order_cancelled_event):
         cdef:
             str order_id = order_cancelled_event.order_id
             object market_pair = self._sb_order_tracker.c_get_market_pair_from_order_id(order_id)
 
-        self.c_stop_tracking_limit_order(market_pair, order_id)
+        self.c_stop_tracking_maker_order(market_pair, order_id)
 
     cdef c_did_expire_order_tracker(self, object order_expired_event):
         self.c_did_cancel_order_tracker(order_expired_event)
@@ -349,10 +349,10 @@ cdef class StrategyBase(TimeIterator):
             object order_type = order_completed_event.order_type
 
         if market_pair is not None:
-            if order_type.is_limit_type():
-                self.c_stop_tracking_limit_order(market_pair, order_id)
-            elif order_type == OrderType.MARKET:
-                self.c_stop_tracking_market_order(market_pair, order_id)
+            if order_type is OrderType.LIMIT_MAKER:
+                self.c_stop_tracking_maker_order(market_pair, order_id)
+            elif order_type is OrderType.LIMIT:
+                self.c_stop_tracking_taker_order(market_pair, order_id)
 
     cdef c_did_complete_sell_order_tracker(self, object order_completed_event):
         self.c_did_complete_buy_order_tracker(order_completed_event)
@@ -363,7 +363,7 @@ cdef class StrategyBase(TimeIterator):
     # ----------------------------------------------------------------------------------------------------------
 
     def buy_with_specific_market(self, market_trading_pair_tuple, amount,
-                                 order_type=OrderType.MARKET,
+                                 order_type=OrderType.LIMIT,
                                  price=s_decimal_nan,
                                  expiration_seconds=NaN):
         return self.c_buy_with_specific_market(market_trading_pair_tuple, amount,
@@ -372,7 +372,7 @@ cdef class StrategyBase(TimeIterator):
                                                expiration_seconds)
 
     cdef str c_buy_with_specific_market(self, object market_trading_pair_tuple, object amount,
-                                        object order_type=OrderType.MARKET,
+                                        object order_type=OrderType.LIMIT,
                                         object price=s_decimal_nan,
                                         double expiration_seconds=NaN):
         if self._sb_delegate_lock:
@@ -398,15 +398,15 @@ cdef class StrategyBase(TimeIterator):
                                         kwargs=kwargs)
 
         # Start order tracking
-        if order_type.is_limit_type():
-            self.c_start_tracking_limit_order(market_trading_pair_tuple, order_id, True, price, amount)
-        elif order_type == OrderType.MARKET:
-            self.c_start_tracking_market_order(market_trading_pair_tuple, order_id, True, amount)
+        if order_type is OrderType.LIMIT_MAKER:
+            self.c_start_tracking_maker_order(market_trading_pair_tuple, order_id, True, price, amount)
+        elif order_type is OrderType.LIMIT:
+            self.c_start_tracking_taker_order(market_trading_pair_tuple, order_id, True, amount)
 
         return order_id
 
     def sell_with_specific_market(self, market_trading_pair_tuple, amount,
-                                  order_type=OrderType.MARKET,
+                                  order_type=OrderType.LIMIT,
                                   price=s_decimal_nan,
                                   expiration_seconds=NaN):
         return self.c_sell_with_specific_market(market_trading_pair_tuple, amount,
@@ -415,7 +415,7 @@ cdef class StrategyBase(TimeIterator):
                                                 expiration_seconds)
 
     cdef str c_sell_with_specific_market(self, object market_trading_pair_tuple, object amount,
-                                         object order_type=OrderType.MARKET,
+                                         object order_type=OrderType.LIMIT,
                                          object price=s_decimal_nan,
                                          double expiration_seconds=NaN):
         if self._sb_delegate_lock:
@@ -439,10 +439,10 @@ cdef class StrategyBase(TimeIterator):
                                          order_type=order_type, price=price, kwargs=kwargs)
 
         # Start order tracking
-        if order_type.is_limit_type():
-            self.c_start_tracking_limit_order(market_trading_pair_tuple, order_id, False, price, amount)
-        elif order_type == OrderType.MARKET:
-            self.c_start_tracking_market_order(market_trading_pair_tuple, order_id, False, amount)
+        if order_type is OrderType.LIMIT_MAKER:
+            self.c_start_tracking_maker_order(market_trading_pair_tuple, order_id, False, price, amount)
+        elif order_type is OrderType.LIMIT:
+            self.c_start_tracking_taker_order(market_trading_pair_tuple, order_id, False, amount)
 
         return order_id
 
@@ -463,17 +463,17 @@ cdef class StrategyBase(TimeIterator):
     # The following exposed tracking functions are meant to allow extending order tracking behavior in strategy
     # classes.
     # ----------------------------------------------------------------------------------------------------------
-    cdef c_start_tracking_limit_order(self, object market_pair, str order_id, bint is_buy, object price,
+    cdef c_start_tracking_maker_order(self, object market_pair, str order_id, bint is_buy, object price,
                                       object quantity):
-        self._sb_order_tracker.c_start_tracking_limit_order(market_pair, order_id, is_buy, price, quantity)
+        self._sb_order_tracker.c_start_tracking_maker_order(market_pair, order_id, is_buy, price, quantity)
 
-    cdef c_stop_tracking_limit_order(self, object market_pair, str order_id):
-        self._sb_order_tracker.c_stop_tracking_limit_order(market_pair, order_id)
+    cdef c_stop_tracking_maker_order(self, object market_pair, str order_id):
+        self._sb_order_tracker.c_stop_tracking_maker_order(market_pair, order_id)
 
-    cdef c_start_tracking_market_order(self, object market_pair, str order_id, bint is_buy, object quantity):
-        self._sb_order_tracker.c_start_tracking_market_order(market_pair, order_id, is_buy, quantity)
+    cdef c_start_tracking_taker_order(self, object market_pair, str order_id, bint is_buy, object quantity):
+        self._sb_order_tracker.c_start_tracking_taker_order(market_pair, order_id, is_buy, quantity)
 
-    cdef c_stop_tracking_market_order(self, object market_pair, str order_id):
-        self._sb_order_tracker.c_stop_tracking_market_order(market_pair, order_id)
+    cdef c_stop_tracking_taker_order(self, object market_pair, str order_id):
+        self._sb_order_tracker.c_stop_tracking_taker_order(market_pair, order_id)
     # ----------------------------------------------------------------------------------------------------------
     # </editor-fold>
diff --git a/test/integration/test_bamboo_relay_market_coordinated.py b/test/integration/test_bamboo_relay_market_coordinated.py
index 32d581418d3..18cc7343d82 100644
--- a/test/integration/test_bamboo_relay_market_coordinated.py
+++ b/test/integration/test_bamboo_relay_market_coordinated.py
@@ -165,7 +165,7 @@ def run_parallel(self, *tasks):
     def test_get_fee(self):
         maker_buy_trade_fee: TradeFee = self.market.get_fee(conf.test_bamboo_relay_base_token_symbol,
                                                             conf.test_bamboo_relay_quote_token_symbol,
-                                                            OrderType.LIMIT,
+                                                            OrderType.LIMIT_MAKER,
                                                             TradeType.BUY,
                                                             Decimal(20),
                                                             Decimal(0.01))
@@ -173,7 +173,7 @@ def test_get_fee(self):
         self.assertEqual(len(maker_buy_trade_fee.flat_fees), 1)
         taker_buy_trade_fee: TradeFee = self.market.get_fee(conf.test_bamboo_relay_base_token_symbol,
                                                             conf.test_bamboo_relay_quote_token_symbol,
-                                                            OrderType.MARKET,
+                                                            OrderType.LIMIT,
                                                             TradeType.BUY,
                                                             Decimal(20))
         self.assertEqual(taker_buy_trade_fee.percent, 0)
@@ -185,7 +185,7 @@ def test_get_wallet_balances(self):
         self.assertGreaterEqual((balances["ETH"]), s_decimal_0)
         self.assertGreaterEqual((balances[self.quote_token_asset]), s_decimal_0)
 
-    def test_single_limit_order_cancel(self):
+    def test_single_limit_maker_order_cancel(self):
         trading_pair: str = self.base_token_asset + "-" + self.quote_token_asset
         current_price: Decimal = self.market.get_price(trading_pair, True)
         amount = Decimal("0.001")
@@ -193,12 +193,12 @@ def test_single_limit_order_cancel(self):
         quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
         buy_order_id = self.market.buy(trading_pair=trading_pair,
                                        amount=amount,
-                                       order_type=OrderType.LIMIT,
+                                       order_type=OrderType.LIMIT_MAKER,
                                        price=current_price - Decimal("0.2") * current_price,
                                        expiration_ts=expires)
         [buy_order_opened_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCreatedEvent))
         self.assertEqual(self.base_token_asset + "-" + self.quote_token_asset, buy_order_opened_event.trading_pair)
-        self.assertEqual(OrderType.LIMIT, buy_order_opened_event.type)
+        self.assertEqual(OrderType.LIMIT_MAKER, buy_order_opened_event.type)
         self.assertEqual(float(quantized_amount), float(buy_order_opened_event.amount))
         [cancellation_results,
          buy_order_cancelled_event] = self.run_parallel(self.market.cancel_order(buy_order_id),
@@ -208,7 +208,7 @@ def test_single_limit_order_cancel(self):
         # Reset the logs
         self.market_logger.clear()
 
-    def test_limit_buy_and_sell_and_cancel_all(self):
+    def test_limit_maker_buy_and_sell_and_cancel_all(self):
         trading_pair: str = self.base_token_asset + "-" + self.quote_token_asset
         current_price: Decimal = self.market.get_price(trading_pair, True)
         amount = Decimal("0.001")
@@ -216,14 +216,14 @@ def test_limit_buy_and_sell_and_cancel_all(self):
         quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
         buy_order_id = self.market.buy(trading_pair=trading_pair,
                                        amount=amount,
-                                       order_type=OrderType.LIMIT,
+                                       order_type=OrderType.LIMIT_MAKER,
                                        price=current_price - Decimal("0.2") * current_price,
                                        expiration_ts=expires)
         [buy_order_opened_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCreatedEvent))
         self.assertEqual(buy_order_id, buy_order_opened_event.order_id)
         self.assertEqual(float(quantized_amount), float(buy_order_opened_event.amount))
         self.assertEqual(self.base_token_asset + "-" + self.quote_token_asset, buy_order_opened_event.trading_pair)
-        self.assertEqual(OrderType.LIMIT, buy_order_opened_event.type)
+        self.assertEqual(OrderType.LIMIT_MAKER, buy_order_opened_event.type)
 
         # Reset the logs
         self.market_logger.clear()
@@ -231,14 +231,14 @@ def test_limit_buy_and_sell_and_cancel_all(self):
         current_price: Decimal = self.market.get_price(trading_pair, False)
         sell_order_id = self.market.sell(trading_pair=trading_pair,
                                          amount=amount,
-                                         order_type=OrderType.LIMIT,
+                                         order_type=OrderType.LIMIT_MAKER,
                                          price=current_price + Decimal("0.2") * current_price,
                                          expiration_ts=expires)
         [sell_order_opened_event] = self.run_parallel(self.market_logger.wait_for(SellOrderCreatedEvent))
         self.assertEqual(sell_order_id, sell_order_opened_event.order_id)
         self.assertEqual(float(quantized_amount), float(sell_order_opened_event.amount))
         self.assertEqual(self.base_token_asset + "-" + self.quote_token_asset, sell_order_opened_event.trading_pair)
-        self.assertEqual(OrderType.LIMIT, sell_order_opened_event.type)
+        self.assertEqual(OrderType.LIMIT_MAKER, sell_order_opened_event.type)
 
         [cancellation_results, order_cancelled_event] = self.run_parallel(self.market.cancel_all(60 * 3),
                                                                           self.market_logger.wait_for(
@@ -259,13 +259,13 @@ def test_order_pre_emptive_cancel(self):
         expires = int(time.time() + 60)  # expires in 1 min
         self.market.buy(trading_pair=trading_pair,
                         amount=amount,
-                        order_type=OrderType.LIMIT,
+                        order_type=OrderType.LIMIT_MAKER,
                         price=current_price - Decimal("0.2") * current_price,
                         expiration_ts=expires)
         [buy_order_opened_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCreatedEvent))
 
         self.assertEqual(self.base_token_asset + "-" + self.quote_token_asset, buy_order_opened_event.trading_pair)
-        self.assertEqual(OrderType.LIMIT, buy_order_opened_event.type)
+        self.assertEqual(OrderType.LIMIT_MAKER, buy_order_opened_event.type)
         [buy_order_expired_event] = self.run_parallel(self.market_logger.wait_for(OrderCancelledEvent, 75))
         self.assertEqual(buy_order_opened_event.order_id, buy_order_expired_event.order_id)
 
@@ -274,16 +274,17 @@ def test_order_pre_emptive_cancel(self):
 
     def test_market_buy(self):
         trading_pair: str = self.base_token_asset + "-" + self.quote_token_asset
+        price: Decimal = self.market.get_price(trading_pair, True)
         amount = Decimal("0.002")
         quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
-        order_id = self.market.buy(self.base_token_asset + "-" + self.quote_token_asset, amount, OrderType.MARKET)
+        order_id = self.market.buy(self.base_token_asset + "-" + self.quote_token_asset, amount, OrderType.LIMIT, price)
 
         [order_completed_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCompletedEvent))
         order_completed_event: BuyOrderCompletedEvent = order_completed_event
         order_filled_events: List[OrderFilledEvent] = [t for t in self.market_logger.event_log
                                                        if isinstance(t, OrderFilledEvent)]
 
-        self.assertTrue([evt.order_type == OrderType.MARKET for evt in order_filled_events])
+        self.assertTrue([evt.order_type == OrderType.LIMIT for evt in order_filled_events])
         self.assertEqual(order_id, order_completed_event.order_id)
         self.assertEqual(float(quantized_amount), float(order_completed_event.base_asset_amount))
         self.assertEqual(self.base_token_asset, order_completed_event.base_asset)
@@ -299,14 +300,14 @@ def test_batch_market_buy(self):
         expires = int(time.time() + 60 * 3)
         self.market.sell(trading_pair=trading_pair,
                          amount=amount,
-                         order_type=OrderType.LIMIT,
+                         order_type=OrderType.LIMIT_MAKER,
                          price=current_price,
                          expiration_ts=expires)
         self.run_parallel(self.market_logger.wait_for(SellOrderCreatedEvent))
 
         amount = Decimal("0.004")
         quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
-        order_id = self.market.buy(self.base_token_asset + "-" + self.quote_token_asset, amount, OrderType.MARKET)
+        order_id = self.market.buy(self.base_token_asset + "-" + self.quote_token_asset, amount, OrderType.LIMIT, current_price)
 
         [order_completed_event,
          _] = self.run_parallel(self.market_logger.wait_for(BuyOrderCompletedEvent),
@@ -315,7 +316,7 @@ def test_batch_market_buy(self):
         order_filled_events: List[OrderFilledEvent] = [t for t in self.market_logger.event_log
                                                        if isinstance(t, OrderFilledEvent)]
 
-        self.assertTrue([evt.order_type == OrderType.MARKET for evt in order_filled_events])
+        self.assertTrue([evt.order_type == OrderType.LIMIT for evt in order_filled_events])
         self.assertEqual(order_id, order_completed_event.order_id)
         self.assertEqual(float(quantized_amount), float(order_completed_event.base_asset_amount))
         self.assertEqual(self.base_token_asset, order_completed_event.base_asset)
@@ -325,16 +326,17 @@ def test_batch_market_buy(self):
 
     def test_market_sell(self):
         trading_pair: str = self.base_token_asset + "-" + self.quote_token_asset
+        price: Decimal = self.market.get_price(trading_pair, False)
         amount = Decimal("0.001")
         quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
-        order_id = self.market.sell(trading_pair, amount, OrderType.MARKET)
+        order_id = self.market.sell(trading_pair, amount, OrderType.LIMIT, price)
 
         [order_completed_event] = self.run_parallel(self.market_logger.wait_for(SellOrderCompletedEvent))
         order_completed_event: SellOrderCompletedEvent = order_completed_event
         order_filled_events: List[OrderFilledEvent] = [t for t in self.market_logger.event_log
                                                        if isinstance(t, OrderFilledEvent)]
 
-        self.assertTrue([evt.order_type == OrderType.MARKET for evt in order_filled_events])
+        self.assertTrue([evt.order_type == OrderType.LIMIT for evt in order_filled_events])
         self.assertEqual(order_id, order_completed_event.order_id)
         self.assertEqual(float(quantized_amount), float(order_completed_event.base_asset_amount))
         self.assertEqual(self.base_token_asset, order_completed_event.base_asset)
@@ -350,14 +352,14 @@ def test_batch_market_sell(self):
         expires = int(time.time() + 60 * 3)
         self.market.buy(trading_pair=trading_pair,
                         amount=amount,
-                        order_type=OrderType.LIMIT,
+                        order_type=OrderType.LIMIT_MAKER,
                         price=current_price,
                         expiration_ts=expires)
         self.run_parallel(self.market_logger.wait_for(BuyOrderCreatedEvent))
 
         amount = Decimal("0.005")
         quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
-        order_id = self.market.sell(self.base_token_asset + "-" + self.quote_token_asset, amount, OrderType.MARKET)
+        order_id = self.market.sell(self.base_token_asset + "-" + self.quote_token_asset, amount, OrderType.LIMIT, current_price)
 
         [order_completed_event,
          _] = self.run_parallel(self.market_logger.wait_for(SellOrderCompletedEvent),
@@ -366,7 +368,7 @@ def test_batch_market_sell(self):
         order_filled_events: List[OrderFilledEvent] = [t for t in self.market_logger.event_log
                                                        if isinstance(t, OrderFilledEvent)]
 
-        self.assertTrue([evt.order_type == OrderType.MARKET for evt in order_filled_events])
+        self.assertTrue([evt.order_type == OrderType.LIMIT for evt in order_filled_events])
         self.assertEqual(order_id, order_completed_event.order_id)
         self.assertEqual(float(quantized_amount), float(order_completed_event.base_asset_amount))
         self.assertEqual(self.base_token_asset, order_completed_event.base_asset)
@@ -417,7 +419,7 @@ def test_z_orders_saving_and_restoration(self):
             quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
 
             expires = int(time.time() + 60 * 3)
-            order_id = self.market.buy(trading_pair, quantized_amount, OrderType.LIMIT, quantize_bid_price,
+            order_id = self.market.buy(trading_pair, quantized_amount, OrderType.LIMIT_MAKER, quantize_bid_price,
                                        expiration_ts=expires)
             [order_created_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCreatedEvent))
             order_created_event: BuyOrderCreatedEvent = order_created_event
diff --git a/test/integration/test_bamboo_relay_market_uncoordinated.py b/test/integration/test_bamboo_relay_market_uncoordinated.py
index a65270ec093..9c0cbaeb098 100644
--- a/test/integration/test_bamboo_relay_market_uncoordinated.py
+++ b/test/integration/test_bamboo_relay_market_uncoordinated.py
@@ -166,7 +166,7 @@ def run_parallel(self, *tasks):
     def test_get_fee(self):
         maker_buy_trade_fee: TradeFee = self.market.get_fee(conf.test_bamboo_relay_base_token_symbol,
                                                             conf.test_bamboo_relay_quote_token_symbol,
-                                                            OrderType.LIMIT,
+                                                            OrderType.LIMIT_MAKER,
                                                             TradeType.BUY,
                                                             Decimal(20),
                                                             Decimal(0.01))
@@ -174,7 +174,7 @@ def test_get_fee(self):
         self.assertEqual(len(maker_buy_trade_fee.flat_fees), 1)
         taker_buy_trade_fee: TradeFee = self.market.get_fee(conf.test_bamboo_relay_base_token_symbol,
                                                             conf.test_bamboo_relay_quote_token_symbol,
-                                                            OrderType.MARKET,
+                                                            OrderType.LIMIT,
                                                             TradeType.BUY,
                                                             Decimal(20))
         self.assertEqual(taker_buy_trade_fee.percent, 0)
@@ -194,12 +194,12 @@ def test_single_limit_order_cancel(self):
         quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
         buy_order_id = self.market.buy(trading_pair=trading_pair,
                                        amount=amount,
-                                       order_type=OrderType.LIMIT,
+                                       order_type=OrderType.LIMIT_MAKER,
                                        price=current_price - Decimal("0.2") * current_price,
                                        expiration_ts=expires)
         [buy_order_opened_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCreatedEvent))
         self.assertEqual(self.base_token_asset + "-" + self.quote_token_asset, buy_order_opened_event.trading_pair)
-        self.assertEqual(OrderType.LIMIT, buy_order_opened_event.type)
+        self.assertEqual(OrderType.LIMIT_MAKER, buy_order_opened_event.type)
         self.assertEqual(float(quantized_amount), float(buy_order_opened_event.amount))
         [cancellation_results,
          buy_order_cancelled_event] = self.run_parallel(self.market.cancel_order(buy_order_id),
@@ -217,14 +217,14 @@ def test_limit_buy_and_sell_and_cancel_all(self):
         quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
         buy_order_id = self.market.buy(trading_pair=trading_pair,
                                        amount=amount,
-                                       order_type=OrderType.LIMIT,
+                                       order_type=OrderType.LIMIT_MAKER,
                                        price=current_price - Decimal("0.2") * current_price,
                                        expiration_ts=expires)
         [buy_order_opened_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCreatedEvent))
         self.assertEqual(buy_order_id, buy_order_opened_event.order_id)
         self.assertEqual(float(quantized_amount), float(buy_order_opened_event.amount))
         self.assertEqual(self.base_token_asset + "-" + self.quote_token_asset, buy_order_opened_event.trading_pair)
-        self.assertEqual(OrderType.LIMIT, buy_order_opened_event.type)
+        self.assertEqual(OrderType.LIMIT_MAKER, buy_order_opened_event.type)
 
         # Reset the logs
         self.market_logger.clear()
@@ -232,14 +232,14 @@ def test_limit_buy_and_sell_and_cancel_all(self):
         current_price: Decimal = self.market.get_price(trading_pair, False)
         sell_order_id = self.market.sell(trading_pair=trading_pair,
                                          amount=amount,
-                                         order_type=OrderType.LIMIT,
+                                         order_type=OrderType.LIMIT_MAKER,
                                          price=current_price + Decimal("0.2") * current_price,
                                          expiration_ts=expires)
         [sell_order_opened_event] = self.run_parallel(self.market_logger.wait_for(SellOrderCreatedEvent))
         self.assertEqual(sell_order_id, sell_order_opened_event.order_id)
         self.assertEqual(float(quantized_amount), float(sell_order_opened_event.amount))
         self.assertEqual(self.base_token_asset + "-" + self.quote_token_asset, sell_order_opened_event.trading_pair)
-        self.assertEqual(OrderType.LIMIT, sell_order_opened_event.type)
+        self.assertEqual(OrderType.LIMIT_MAKER, sell_order_opened_event.type)
 
         [cancellation_results, order_cancelled_event] = self.run_parallel(self.market.cancel_all(60 * 3),
                                                                           self.market_logger.wait_for(OrderCancelledEvent))
@@ -266,13 +266,13 @@ def test_order_expire(self):
         expires = int(time.time() + 60)  # expires in 1 min
         self.market.buy(trading_pair=trading_pair,
                         amount=amount,
-                        order_type=OrderType.LIMIT,
+                        order_type=OrderType.LIMIT_MAKER,
                         price=current_price - Decimal("0.2") * current_price,
                         expiration_ts=expires)
 
         [buy_order_opened_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCreatedEvent))
         self.assertEqual(self.base_token_asset + "-" + self.quote_token_asset, buy_order_opened_event.trading_pair)
-        self.assertEqual(OrderType.LIMIT, buy_order_opened_event.type)
+        self.assertEqual(OrderType.LIMIT_MAKER, buy_order_opened_event.type)
         [buy_order_expired_event] = self.run_parallel(self.market_logger.wait_for(OrderExpiredEvent, 75))
         self.assertEqual(buy_order_opened_event.order_id, buy_order_expired_event.order_id)
 
@@ -281,16 +281,17 @@ def test_order_expire(self):
 
     def test_market_buy(self):
         trading_pair: str = self.base_token_asset + "-" + self.quote_token_asset
+        price: Decimal = self.market.get_price(trading_pair, True)
         amount = Decimal("0.002")
         quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
-        order_id = self.market.buy(self.base_token_asset + "-" + self.quote_token_asset, amount, OrderType.MARKET)
+        order_id = self.market.buy(self.base_token_asset + "-" + self.quote_token_asset, amount, OrderType.LIMIT, price)
 
         [order_completed_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCompletedEvent))
         order_completed_event: BuyOrderCompletedEvent = order_completed_event
         order_filled_events: List[OrderFilledEvent] = [t for t in self.market_logger.event_log
                                                        if isinstance(t, OrderFilledEvent)]
 
-        self.assertTrue([evt.order_type == OrderType.MARKET for evt in order_filled_events])
+        self.assertTrue([evt.order_type == OrderType.LIMIT for evt in order_filled_events])
         self.assertEqual(order_id, order_completed_event.order_id)
         self.assertEqual(float(quantized_amount), float(order_completed_event.base_asset_amount))
         self.assertEqual(self.base_token_asset, order_completed_event.base_asset)
@@ -306,14 +307,14 @@ def test_batch_market_buy(self):
         expires = int(time.time() + 60 * 3)
         self.market.sell(trading_pair=trading_pair,
                          amount=amount,
-                         order_type=OrderType.LIMIT,
+                         order_type=OrderType.LIMIT_MAKER,
                          price=current_price,
                          expiration_ts=expires)
         self.run_parallel(self.market_logger.wait_for(SellOrderCreatedEvent))
 
         amount = Decimal("0.004")
         quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
-        order_id = self.market.buy(self.base_token_asset + "-" + self.quote_token_asset, amount, OrderType.MARKET)
+        order_id = self.market.buy(self.base_token_asset + "-" + self.quote_token_asset, amount, OrderType.LIMIT, current_price)
 
         [order_completed_event,
          _] = self.run_parallel(self.market_logger.wait_for(BuyOrderCompletedEvent),
@@ -322,7 +323,7 @@ def test_batch_market_buy(self):
         order_filled_events: List[OrderFilledEvent] = [t for t in self.market_logger.event_log
                                                        if isinstance(t, OrderFilledEvent)]
 
-        self.assertTrue([evt.order_type == OrderType.MARKET for evt in order_filled_events])
+        self.assertTrue([evt.order_type == OrderType.LIMIT for evt in order_filled_events])
         self.assertEqual(order_id, order_completed_event.order_id)
         self.assertEqual(float(quantized_amount), float(order_completed_event.base_asset_amount))
         self.assertEqual(self.base_token_asset, order_completed_event.base_asset)
@@ -332,16 +333,17 @@ def test_batch_market_buy(self):
 
     def test_market_sell(self):
         trading_pair: str = self.base_token_asset + "-" + self.quote_token_asset
+        price: Decimal = self.market.get_price(trading_pair, False)
         amount = Decimal("0.001")
         quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
-        order_id = self.market.sell(trading_pair, amount, OrderType.MARKET)
+        order_id = self.market.sell(trading_pair, amount, OrderType.LIMIT, price)
 
         [order_completed_event] = self.run_parallel(self.market_logger.wait_for(SellOrderCompletedEvent))
         order_completed_event: SellOrderCompletedEvent = order_completed_event
         order_filled_events: List[OrderFilledEvent] = [t for t in self.market_logger.event_log
                                                        if isinstance(t, OrderFilledEvent)]
 
-        self.assertTrue([evt.order_type == OrderType.MARKET for evt in order_filled_events])
+        self.assertTrue([evt.order_type == OrderType.LIMIT for evt in order_filled_events])
         self.assertEqual(order_id, order_completed_event.order_id)
         self.assertEqual(float(quantized_amount), float(order_completed_event.base_asset_amount))
         self.assertEqual(self.base_token_asset, order_completed_event.base_asset)
@@ -357,14 +359,14 @@ def test_batch_market_sell(self):
         expires = int(time.time() + 60 * 3)
         self.market.buy(trading_pair=trading_pair,
                         amount=amount,
-                        order_type=OrderType.LIMIT,
+                        order_type=OrderType.LIMIT_MAKER,
                         price=current_price,
                         expiration_ts=expires)
         self.run_parallel(self.market_logger.wait_for(BuyOrderCreatedEvent))
 
         amount = Decimal("0.005")
         quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
-        order_id = self.market.sell(self.base_token_asset + "-" + self.quote_token_asset, amount, OrderType.MARKET)
+        order_id = self.market.sell(self.base_token_asset + "-" + self.quote_token_asset, amount, OrderType.LIMIT, current_price)
 
         [order_completed_event, _] = self.run_parallel(self.market_logger.wait_for(SellOrderCompletedEvent),
                                                        self.market_logger.wait_for(BuyOrderCompletedEvent))
@@ -372,7 +374,7 @@ def test_batch_market_sell(self):
         order_filled_events: List[OrderFilledEvent] = [t for t in self.market_logger.event_log
                                                        if isinstance(t, OrderFilledEvent)]
 
-        self.assertTrue([evt.order_type == OrderType.MARKET for evt in order_filled_events])
+        self.assertTrue([evt.order_type == OrderType.LIMIT for evt in order_filled_events])
         self.assertEqual(order_id, order_completed_event.order_id)
         self.assertEqual(float(quantized_amount), float(order_completed_event.base_asset_amount))
         self.assertEqual(self.base_token_asset, order_completed_event.base_asset)
@@ -423,7 +425,7 @@ def test_z_orders_saving_and_restoration(self):
             quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
 
             expires = int(time.time() + 60 * 3)
-            order_id = self.market.buy(trading_pair, quantized_amount, OrderType.LIMIT, quantize_bid_price,
+            order_id = self.market.buy(trading_pair, quantized_amount, OrderType.LIMIT_MAKER, quantize_bid_price,
                                        expiration_ts=expires)
             [order_created_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCreatedEvent))
             order_created_event: BuyOrderCreatedEvent = order_created_event
diff --git a/test/integration/test_binance_market.py b/test/integration/test_binance_market.py
index 6089ff5cb73..fd089a8e55c 100644
--- a/test/integration/test_binance_market.py
+++ b/test/integration/test_binance_market.py
@@ -194,10 +194,10 @@ def run_parallel(self, *tasks):
         return self.ev_loop.run_until_complete(self.run_parallel_async(*tasks))
 
     def test_get_fee(self):
-        maker_buy_trade_fee: TradeFee = self.market.get_fee("BTC", "USDT", OrderType.LIMIT, TradeType.BUY, Decimal(1), Decimal(4000))
+        maker_buy_trade_fee: TradeFee = self.market.get_fee("BTC", "USDT", OrderType.LIMIT_MAKER, TradeType.BUY, Decimal(1), Decimal(4000))
         self.assertGreater(maker_buy_trade_fee.percent, 0)
         self.assertEqual(len(maker_buy_trade_fee.flat_fees), 0)
-        taker_buy_trade_fee: TradeFee = self.market.get_fee("BTC", "USDT", OrderType.MARKET, TradeType.BUY, Decimal(1))
+        taker_buy_trade_fee: TradeFee = self.market.get_fee("BTC", "USDT", OrderType.LIMIT, TradeType.BUY, Decimal(1))
         self.assertGreater(taker_buy_trade_fee.percent, 0)
         self.assertEqual(len(taker_buy_trade_fee.flat_fees), 0)
         sell_trade_fee: TradeFee = self.market.get_fee("BTC", "USDT", OrderType.LIMIT, TradeType.SELL, Decimal(1), Decimal(4000))
@@ -210,28 +210,29 @@ def test_get_fee(self):
 
     def test_fee_overrides_config(self):
         fee_overrides_config_map["binance_taker_fee"].value = None
-        taker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.MARKET, TradeType.BUY, Decimal(1),
+        taker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.LIMIT, TradeType.BUY, Decimal(1),
                                                   Decimal('0.1'))
         self.assertAlmostEqual(Decimal("0.001"), taker_fee.percent)
         fee_overrides_config_map["binance_taker_fee"].value = Decimal('0.2')
-        taker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.MARKET, TradeType.BUY, Decimal(1),
+        taker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.LIMIT, TradeType.BUY, Decimal(1),
                                                   Decimal('0.1'))
         self.assertAlmostEqual(Decimal("0.002"), taker_fee.percent)
         fee_overrides_config_map["binance_maker_fee"].value = None
-        maker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.LIMIT, TradeType.BUY, Decimal(1),
+        maker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.LIMIT_MAKER, TradeType.BUY, Decimal(1),
                                                   Decimal('0.1'))
         self.assertAlmostEqual(Decimal("0.001"), maker_fee.percent)
         fee_overrides_config_map["binance_maker_fee"].value = Decimal('0.5')
-        maker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.LIMIT, TradeType.BUY, Decimal(1),
+        maker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.LIMIT_MAKER, TradeType.BUY, Decimal(1),
                                                   Decimal('0.1'))
         self.assertAlmostEqual(Decimal("0.005"), maker_fee.percent)
 
     def test_buy_and_sell(self):
         self.assertGreater(self.market.get_balance("ETH"), Decimal("0.05"))
+        bid_price: Decimal = self.market.get_price("LINKETH", True)
         amount: Decimal = 1
         quantized_amount: Decimal = self.market.quantize_order_amount("LINKETH", amount)
 
-        order_id = self.place_order(True, "LINKETH", amount, OrderType.MARKET, 0, 10001, FixtureBinance.ORDER_BUY,
+        order_id = self.place_order(True, "LINKETH", amount, OrderType.LIMIT, bid_price, 10001, FixtureBinance.ORDER_BUY,
                                     FixtureBinance.WS_AFTER_BUY_1, FixtureBinance.WS_AFTER_BUY_2)
         [order_completed_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCompletedEvent))
         order_completed_event: BuyOrderCompletedEvent = order_completed_event
@@ -240,7 +241,7 @@ def test_buy_and_sell(self):
         base_amount_traded: Decimal = sum(t.amount for t in trade_events)
         quote_amount_traded: Decimal = sum(t.amount * t.price for t in trade_events)
 
-        self.assertTrue([evt.order_type == OrderType.MARKET for evt in trade_events])
+        self.assertTrue([evt.order_type == OrderType.LIMIT for evt in trade_events])
         self.assertEqual(order_id, order_completed_event.order_id)
         self.assertEqual(quantized_amount, order_completed_event.base_asset_amount)
         self.assertEqual("LINK", order_completed_event.base_asset)
@@ -255,9 +256,10 @@ def test_buy_and_sell(self):
         self.market_logger.clear()
 
         # Try to sell back the same amount of ZRX to the exchange, and watch for completion event.
+        ask_price: Decimal = self.market.get_price("LINKETH", False)
         amount = order_completed_event.base_asset_amount
         quantized_amount = order_completed_event.base_asset_amount
-        order_id = self.place_order(False, "LINKETH", amount, OrderType.MARKET, 0, 10002, FixtureBinance.ORDER_SELL,
+        order_id = self.place_order(False, "LINKETH", amount, OrderType.LIMIT, ask_price, 10002, FixtureBinance.ORDER_SELL,
                                     FixtureBinance.WS_AFTER_SELL_1, FixtureBinance.WS_AFTER_SELL_2)
         [order_completed_event] = self.run_parallel(self.market_logger.wait_for(SellOrderCompletedEvent))
         order_completed_event: SellOrderCompletedEvent = order_completed_event
@@ -266,66 +268,6 @@ def test_buy_and_sell(self):
         base_amount_traded = sum(t.amount for t in trade_events)
         quote_amount_traded = sum(t.amount * t.price for t in trade_events)
 
-        self.assertTrue([evt.order_type == OrderType.MARKET for evt in trade_events])
-        self.assertEqual(order_id, order_completed_event.order_id)
-        self.assertEqual(quantized_amount, order_completed_event.base_asset_amount)
-        self.assertEqual("LINK", order_completed_event.base_asset)
-        self.assertEqual("ETH", order_completed_event.quote_asset)
-        self.assertAlmostEqual(base_amount_traded, order_completed_event.base_asset_amount)
-        self.assertAlmostEqual(quote_amount_traded, order_completed_event.quote_asset_amount)
-        self.assertGreater(order_completed_event.fee_amount, Decimal(0))
-        self.assertTrue(any([isinstance(event, SellOrderCreatedEvent) and event.order_id == order_id
-                             for event in self.market_logger.event_log]))
-
-    def test_limit_buy_and_sell(self):
-        self.assertGreater(self.market.get_balance("ETH"), Decimal("0.05"))
-
-        # Try to put limit buy order for 1 LINK, and watch for completion event.
-        ask_price: Decimal = self.market.get_price("LINKETH", False) * Decimal("1.01")
-        quantize_bid_price: Decimal = self.market.quantize_order_price("LINKETH", ask_price)
-
-        amount: Decimal = 1
-        quantized_amount: Decimal = self.market.quantize_order_amount("LINKETH", amount)
-
-        order_id = self.place_order(True, "LINKETH", quantized_amount, OrderType.LIMIT, quantize_bid_price, 10001,
-                                    FixtureBinance.ORDER_BUY_LIMIT, FixtureBinance.WS_AFTER_BUY_1,
-                                    FixtureBinance.WS_AFTER_BUY_2)
-        [order_completed_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCompletedEvent))
-        order_completed_event: BuyOrderCompletedEvent = order_completed_event
-        trade_events: List[OrderFilledEvent] = [t for t in self.market_logger.event_log
-                                                if isinstance(t, OrderFilledEvent)]
-        base_amount_traded: Decimal = sum(t.amount for t in trade_events)
-        quote_amount_traded: Decimal = sum(t.amount * t.price for t in trade_events)
-
-        self.assertTrue([evt.order_type == OrderType.LIMIT for evt in trade_events])
-        self.assertEqual(order_id, order_completed_event.order_id)
-        self.assertEqual(quantized_amount, order_completed_event.base_asset_amount)
-        self.assertEqual("LINK", order_completed_event.base_asset)
-        self.assertEqual("ETH", order_completed_event.quote_asset)
-        self.assertAlmostEqual(base_amount_traded, order_completed_event.base_asset_amount)
-        self.assertAlmostEqual(quote_amount_traded, order_completed_event.quote_asset_amount)
-        self.assertGreater(order_completed_event.fee_amount, Decimal(0))
-        self.assertTrue(any([isinstance(event, BuyOrderCreatedEvent) and event.order_id == order_id
-                             for event in self.market_logger.event_log]))
-
-        # Reset the logs
-        self.market_logger.clear()
-
-        # Try to put limit sell order for 0.02 ETH worth of ZRX, and watch for completion event.
-        bid_price: Decimal = self.market.get_price("LINKETH", True) * Decimal('0.99')
-        quantize_ask_price: Decimal = self.market.quantize_order_price("LINKETH", bid_price)
-        quantized_amount = order_completed_event.base_asset_amount
-
-        order_id = self.place_order(False, "LINKETH", quantized_amount, OrderType.LIMIT, quantize_ask_price, 10002,
-                                    FixtureBinance.ORDER_SELL_LIMIT, FixtureBinance.WS_AFTER_SELL_1,
-                                    FixtureBinance.WS_AFTER_SELL_2)
-        [order_completed_event] = self.run_parallel(self.market_logger.wait_for(SellOrderCompletedEvent))
-        order_completed_event: SellOrderCompletedEvent = order_completed_event
-        trade_events = [t for t in self.market_logger.event_log
-                        if isinstance(t, OrderFilledEvent)]
-        base_amount_traded = sum(t.amount for t in trade_events)
-        quote_amount_traded = sum(t.amount * t.price for t in trade_events)
-
         self.assertTrue([evt.order_type == OrderType.LIMIT for evt in trade_events])
         self.assertEqual(order_id, order_completed_event.order_id)
         self.assertEqual(quantized_amount, order_completed_event.base_asset_amount)
@@ -673,8 +615,9 @@ def test_order_fill_record(self):
 
         try:
             # Try to buy 1 LINK from the exchange, and watch for completion event.
+            bid_price: Decimal = self.market.get_price("LINKETH", True)
             amount: Decimal = 1
-            order_id = self.place_order(True, "LINKETH", amount, OrderType.MARKET, 0, 10001,
+            order_id = self.place_order(True, "LINKETH", amount, OrderType.LIMIT, bid_price, 10001,
                                         FixtureBinance.ORDER_BUY_LIMIT, FixtureBinance.WS_AFTER_BUY_1,
                                         FixtureBinance.WS_AFTER_BUY_2)
             [buy_order_completed_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCompletedEvent))
@@ -683,8 +626,9 @@ def test_order_fill_record(self):
             self.market_logger.clear()
 
             # Try to sell back the same amount of LINK to the exchange, and watch for completion event.
+            ask_price: Decimal = self.market.get_price("LINKETH", False)
             amount = buy_order_completed_event.base_asset_amount
-            order_id = self.place_order(False, "LINKETH", amount, OrderType.MARKET, 0, 10002,
+            order_id = self.place_order(False, "LINKETH", amount, OrderType.LIMIT, ask_price, 10002,
                                         FixtureBinance.ORDER_SELL_LIMIT, FixtureBinance.WS_AFTER_SELL_1,
                                         FixtureBinance.WS_AFTER_SELL_2)
             [sell_order_completed_event] = self.run_parallel(self.market_logger.wait_for(SellOrderCompletedEvent))
diff --git a/test/integration/test_bittrex_market.py b/test/integration/test_bittrex_market.py
index 63330d417c7..d4280459543 100644
--- a/test/integration/test_bittrex_market.py
+++ b/test/integration/test_bittrex_market.py
@@ -184,28 +184,28 @@ def run_parallel(self, *tasks):
         return self.ev_loop.run_until_complete(self.run_parallel_async(*tasks))
 
     def test_get_fee(self):
-        limit_fee: TradeFee = self.market.get_fee("ETH", "USDT", OrderType.LIMIT, TradeType.BUY, 1, 1)
+        limit_fee: TradeFee = self.market.get_fee("ETH", "USDT", OrderType.LIMIT_MAKER, TradeType.BUY, 1, 1)
         self.assertGreater(limit_fee.percent, 0)
         self.assertEqual(len(limit_fee.flat_fees), 0)
-        market_fee: TradeFee = self.market.get_fee("ETH", "USDT", OrderType.MARKET, TradeType.BUY, 1)
+        market_fee: TradeFee = self.market.get_fee("ETH", "USDT", OrderType.LIMIT, TradeType.BUY, 1)
         self.assertGreater(market_fee.percent, 0)
         self.assertEqual(len(market_fee.flat_fees), 0)
 
     def test_fee_overrides_config(self):
         fee_overrides_config_map["bittrex_taker_fee"].value = None
-        taker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.MARKET, TradeType.BUY, Decimal(1),
+        taker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.LIMIT, TradeType.BUY, Decimal(1),
                                                   Decimal('0.1'))
         self.assertAlmostEqual(Decimal("0.0025"), taker_fee.percent)
         fee_overrides_config_map["bittrex_taker_fee"].value = Decimal('0.2')
-        taker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.MARKET, TradeType.BUY, Decimal(1),
+        taker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.LIMIT, TradeType.BUY, Decimal(1),
                                                   Decimal('0.1'))
         self.assertAlmostEqual(Decimal("0.002"), taker_fee.percent)
         fee_overrides_config_map["bittrex_maker_fee"].value = None
-        maker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.LIMIT, TradeType.BUY, Decimal(1),
+        maker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.LIMIT_MAKER, TradeType.BUY, Decimal(1),
                                                   Decimal('0.1'))
         self.assertAlmostEqual(Decimal("0.0025"), maker_fee.percent)
         fee_overrides_config_map["bittrex_maker_fee"].value = Decimal('0.5')
-        maker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.LIMIT, TradeType.BUY, Decimal(1),
+        maker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.LIMIT_MAKER, TradeType.BUY, Decimal(1),
                                                   Decimal('0.1'))
         self.assertAlmostEqual(Decimal("0.005"), maker_fee.percent)
 
@@ -221,7 +221,7 @@ def place_order(self, is_buy, trading_pair, amount, order_type, price, nonce, po
             side = 'buy' if is_buy else 'sell'
             resp["direction"] = side.upper()
             resp["type"] = order_type.name.upper()
-            if order_type == OrderType.MARKET:
+            if order_type == OrderType.LIMIT:
                 del resp["limit"]
             self.web_app.update_response("post", API_BASE_URL, "/v3/orders", resp)
         if is_buy:
@@ -241,70 +241,6 @@ def cancel_order(self, trading_pair, order_id, exch_order_id):
             self.web_app.update_response("delete", API_BASE_URL, f"/v3/orders/{exch_order_id}", resp)
         self.market.cancel(trading_pair, order_id)
 
-    def test_limit_buy(self):
-        self.assertGreater(self.market.get_balance("USDT"), 20)
-        trading_pair = "ETH-USDT"
-
-        self.run_parallel(asyncio.sleep(3))
-        current_bid_price: Decimal = self.market.get_price(trading_pair, True)
-        bid_price: Decimal = current_bid_price * Decimal('1.005')
-        quantize_bid_price: Decimal = self.market.quantize_order_price(trading_pair, bid_price)
-
-        amount: Decimal = Decimal("0.06")
-        quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
-
-        order_id, _ = self.place_order(True, trading_pair, quantized_amount, OrderType.LIMIT, quantize_bid_price,
-                                       10001, FixtureBittrex.ORDER_PLACE_FILLED, FixtureBittrex.WS_ORDER_FILLED)
-        [order_completed_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCompletedEvent))
-        order_completed_event: BuyOrderCompletedEvent = order_completed_event
-        trade_events: List[OrderFilledEvent] = [t for t in self.market_logger.event_log
-                                                if isinstance(t, OrderFilledEvent)]
-        base_amount_traded: Decimal = sum(t.amount for t in trade_events)
-        quote_amount_traded: Decimal = sum(t.amount * t.price for t in trade_events)
-
-        self.assertTrue([evt.order_type == OrderType.LIMIT for evt in trade_events])
-        self.assertEqual(order_id, order_completed_event.order_id)
-        self.assertAlmostEqual(quantized_amount, order_completed_event.base_asset_amount)
-        self.assertEqual("ETH", order_completed_event.base_asset)
-        self.assertEqual("USDT", order_completed_event.quote_asset)
-        self.assertAlmostEqual(base_amount_traded, order_completed_event.base_asset_amount)
-        self.assertAlmostEqual(quote_amount_traded, order_completed_event.quote_asset_amount)
-        self.assertTrue(any([isinstance(event, BuyOrderCreatedEvent) and event.order_id == order_id
-                             for event in self.market_logger.event_log]))
-        # Reset the logs
-        self.market_logger.clear()
-
-    def test_limit_sell(self):
-        trading_pair = "ETH-USDT"
-
-        current_ask_price: Decimal = self.market.get_price(trading_pair, False)
-        ask_price: Decimal = current_ask_price - Decimal('0.005') * current_ask_price
-        quantize_ask_price: Decimal = self.market.quantize_order_price(trading_pair, ask_price)
-
-        amount: Decimal = Decimal("0.06")
-        quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
-
-        order_id, _ = self.place_order(False, trading_pair, quantized_amount, OrderType.LIMIT, quantize_ask_price,
-                                       10001, FixtureBittrex.ORDER_PLACE_FILLED, FixtureBittrex.WS_ORDER_FILLED)
-
-        [order_completed_event] = self.run_parallel(self.market_logger.wait_for(SellOrderCompletedEvent))
-        order_completed_event: SellOrderCompletedEvent = order_completed_event
-        trade_events = [t for t in self.market_logger.event_log if isinstance(t, OrderFilledEvent)]
-        base_amount_traded = sum(t.amount for t in trade_events)
-        quote_amount_traded = sum(t.amount * t.price for t in trade_events)
-
-        self.assertTrue([evt.order_type == OrderType.LIMIT for evt in trade_events])
-        self.assertEqual(order_id, order_completed_event.order_id)
-        self.assertAlmostEqual(quantized_amount, order_completed_event.base_asset_amount)
-        self.assertEqual("ETH", order_completed_event.base_asset)
-        self.assertEqual("USDT", order_completed_event.quote_asset)
-        self.assertAlmostEqual(base_amount_traded, order_completed_event.base_asset_amount)
-        self.assertAlmostEqual(quote_amount_traded, order_completed_event.quote_asset_amount)
-        self.assertTrue(any([isinstance(event, SellOrderCreatedEvent) and event.order_id == order_id
-                             for event in self.market_logger.event_log]))
-        # Reset the logs
-        self.market_logger.clear()
-
     def test_limit_maker_rejections(self):
         trading_pair = "ETH-USDT"
 
@@ -313,9 +249,7 @@ def test_limit_maker_rejections(self):
         price: Decimal = self.market.quantize_order_price(trading_pair, price)
         amount = self.market.quantize_order_amount(trading_pair, 1)
 
-        order_id = self.place_order(True, trading_pair, amount, OrderType.LIMIT_MAKER,
-                                    price, 10001,
-                                    FixtureBittrex.LIMIT_MAKER_ERROR, FixtureBittrex.EMPTY)
+        order_id = self.market.buy(trading_pair, amount, OrderType.LIMIT_MAKER, price)
         [order_failure_event] = self.run_parallel(self.market_logger.wait_for(MarketOrderFailureEvent))
         self.assertEqual(order_id, order_failure_event.order_id)
 
@@ -326,9 +260,7 @@ def test_limit_maker_rejections(self):
         price: Decimal = self.market.quantize_order_price(trading_pair, price)
         amount = self.market.quantize_order_amount(trading_pair, 1)
 
-        order_id = self.place_order(False, trading_pair, amount, OrderType.LIMIT_MAKER,
-                                    price, 10002,
-                                    FixtureBittrex.LIMIT_MAKER_ERROR, FixtureBittrex.EMPTY)
+        order_id = self.market.sell(trading_pair, amount, OrderType.LIMIT_MAKER, price)
         [order_failure_event] = self.run_parallel(self.market_logger.wait_for(MarketOrderFailureEvent))
         self.assertEqual(order_id, order_failure_event.order_id)
 
@@ -338,9 +270,9 @@ def test_limit_makers_unfilled(self):
         price = self.market.quantize_order_price(trading_pair, price)
         amount = self.market.quantize_order_amount(trading_pair, 1)
 
-        order_id = self.place_order(True, trading_pair, amount, OrderType.LIMIT_MAKER,
-                                    price, 10001,
-                                    FixtureBittrex.ORDER_PLACE_OPEN, FixtureBittrex.WS_ORDER_OPEN)
+        order_id, _ = self.place_order(True, trading_pair, amount, OrderType.LIMIT_MAKER,
+                                       price, 10001,
+                                       FixtureBittrex.ORDER_PLACE_OPEN, FixtureBittrex.WS_ORDER_OPEN)
         [order_created_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCreatedEvent))
         order_created_event: BuyOrderCreatedEvent = order_created_event
         self.assertEqual(order_id, order_created_event.order_id)
@@ -349,9 +281,9 @@ def test_limit_makers_unfilled(self):
         price = self.market.quantize_order_price(trading_pair, price)
         amount = self.market.quantize_order_amount(trading_pair, 1)
 
-        order_id = self.place_order(False, trading_pair, amount, OrderType.LIMIT_MAKER,
-                                    price, 10002,
-                                    FixtureBittrex.ORDER_PLACE_OPEN, FixtureBittrex.WS_ORDER_OPEN)
+        order_id, _ = self.place_order(False, trading_pair, amount, OrderType.LIMIT_MAKER,
+                                       price, 10002,
+                                       FixtureBittrex.ORDER_PLACE_OPEN, FixtureBittrex.WS_ORDER_OPEN)
         [order_created_event] = self.run_parallel(self.market_logger.wait_for(SellOrderCreatedEvent))
         order_created_event: BuyOrderCreatedEvent = order_created_event
         self.assertEqual(order_id, order_created_event.order_id)
@@ -364,10 +296,11 @@ def test_market_buy(self):
         self.assertGreater(self.market.get_balance("USDT"), 20)
         trading_pair = "ETH-USDT"
 
+        price: Decimal = self.market.get_price(trading_pair, True)
         amount: Decimal = Decimal("0.06")
         quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
 
-        order_id, _ = self.place_order(True, trading_pair, quantized_amount, OrderType.MARKET, 0, 10001,
+        order_id, _ = self.place_order(True, trading_pair, quantized_amount, OrderType.LIMIT, price, 10001,
                                        FixtureBittrex.ORDER_PLACE_FILLED, FixtureBittrex.WS_ORDER_FILLED)
         [order_completed_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCompletedEvent))
         order_completed_event: BuyOrderCompletedEvent = order_completed_event
@@ -376,7 +309,7 @@ def test_market_buy(self):
         base_amount_traded: Decimal = sum(t.amount for t in trade_events)
         quote_amount_traded: Decimal = sum(t.amount * t.price for t in trade_events)
 
-        self.assertTrue([evt.order_type == OrderType.MARKET for evt in trade_events])
+        self.assertTrue([evt.order_type == OrderType.LIMIT for evt in trade_events])
         self.assertEqual(order_id, order_completed_event.order_id)
         self.assertAlmostEqual(quantized_amount, order_completed_event.base_asset_amount)
         self.assertEqual("ETH", order_completed_event.base_asset)
@@ -392,10 +325,11 @@ def test_market_sell(self):
         trading_pair = "ETH-USDT"
         self.assertGreater(self.market.get_balance("ETH"), 0.06)
 
+        price: Decimal = self.market.get_price(trading_pair, False)
         amount: Decimal = Decimal("0.06")
         quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
 
-        order_id, _ = self.place_order(False, trading_pair, quantized_amount, OrderType.MARKET, 0, 10001,
+        order_id, _ = self.place_order(False, trading_pair, quantized_amount, OrderType.LIMIT, price, 10001,
                                        FixtureBittrex.ORDER_PLACE_FILLED, FixtureBittrex.WS_ORDER_FILLED)
         [order_completed_event] = self.run_parallel(self.market_logger.wait_for(SellOrderCompletedEvent))
         order_completed_event: SellOrderCompletedEvent = order_completed_event
@@ -403,7 +337,7 @@ def test_market_sell(self):
         base_amount_traded = sum(t.amount for t in trade_events)
         quote_amount_traded = sum(t.amount * t.price for t in trade_events)
 
-        self.assertTrue([evt.order_type == OrderType.MARKET for evt in trade_events])
+        self.assertTrue([evt.order_type == OrderType.LIMIT for evt in trade_events])
         self.assertEqual(order_id, order_completed_event.order_id)
         self.assertAlmostEqual(quantized_amount, order_completed_event.base_asset_amount)
         self.assertEqual("ETH", order_completed_event.base_asset)
@@ -424,7 +358,7 @@ def test_cancel_order(self):
         amount: Decimal = Decimal("0.06")
         quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
 
-        order_id, exch_order_id = self.place_order(True, trading_pair, quantized_amount, OrderType.LIMIT,
+        order_id, exch_order_id = self.place_order(True, trading_pair, quantized_amount, OrderType.LIMIT_MAKER,
                                                    quantize_bid_price, 10001, FixtureBittrex.ORDER_PLACE_OPEN,
                                                    FixtureBittrex.WS_ORDER_OPEN)
         self.run_parallel(self.market_logger.wait_for(BuyOrderCreatedEvent))
@@ -447,10 +381,10 @@ def test_cancel_all(self):
         ask_amount: Decimal = Decimal('0.06')
         quantized_ask_amount: Decimal = self.market.quantize_order_amount(trading_pair, ask_amount)
 
-        _, exch_order_id_1 = self.place_order(True, trading_pair, quantized_bid_amount, OrderType.LIMIT,
+        _, exch_order_id_1 = self.place_order(True, trading_pair, quantized_bid_amount, OrderType.LIMIT_MAKER,
                                               quantize_bid_price, 10001,
                                               FixtureBittrex.ORDER_PLACE_OPEN, FixtureBittrex.WS_ORDER_OPEN)
-        _, exch_order_id_2 = self.place_order(False, trading_pair, quantized_ask_amount, OrderType.LIMIT,
+        _, exch_order_id_2 = self.place_order(False, trading_pair, quantized_ask_amount, OrderType.LIMIT_MAKER,
                                               quantize_ask_price, 10002,
                                               FixtureBittrex.ORDER_PLACE_OPEN, FixtureBittrex.WS_ORDER_OPEN)
         self.run_parallel(asyncio.sleep(1))
@@ -465,26 +399,6 @@ def test_cancel_all(self):
         for cr in cancellation_results:
             self.assertEqual(cr.success, True)
 
-    @unittest.skipUnless(any("test_list_orders" in arg for arg in sys.argv), "List order test requires manual action.")
-    def test_list_orders(self):
-        self.assertGreater(self.market.get_balance("USDT"), 20)
-        trading_pair = "ETH-USDT"
-
-        current_bid_price: Decimal = self.market.get_price(trading_pair, True) * Decimal('0.80')
-        quantize_bid_price: Decimal = self.market.quantize_order_price(trading_pair, current_bid_price)
-        bid_amount: Decimal = Decimal('0.06')
-        quantized_bid_amount: Decimal = self.market.quantize_order_amount(trading_pair, bid_amount)
-
-        self.market.buy(trading_pair, quantized_bid_amount, OrderType.LIMIT, quantize_bid_price)
-        self.run_parallel(asyncio.sleep(1))
-        [order_details] = self.run_parallel(self.market.list_orders())
-        self.assertGreaterEqual(len(order_details), 1)
-
-        self.market_logger.clear()
-        [cancellation_results] = self.run_parallel(self.market.cancel_all(5))
-        for cr in cancellation_results:
-            self.assertEqual(cr.success, True)
-
     def test_orders_saving_and_restoration(self):
         config_path: str = "test_config"
         strategy_name: str = "test_strategy"
@@ -572,9 +486,10 @@ def test_order_fill_record(self):
 
         try:
 
+            price: Decimal = self.market.get_price(trading_pair, True)
             amount: Decimal = Decimal("0.06")
             quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
-            order_id, _ = self.place_order(True, trading_pair, quantized_amount, OrderType.MARKET, 0, 10001,
+            order_id, _ = self.place_order(True, trading_pair, quantized_amount, OrderType.LIMIT, price, 10001,
                                            FixtureBittrex.ORDER_PLACE_FILLED, FixtureBittrex.WS_ORDER_FILLED)
             [buy_order_completed_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCompletedEvent))
 
@@ -582,7 +497,7 @@ def test_order_fill_record(self):
             self.market_logger.clear()
 
             amount = Decimal(buy_order_completed_event.base_asset_amount)
-            order_id, _ = self.place_order(False, trading_pair, amount, OrderType.MARKET, 0, 10001,
+            order_id, _ = self.place_order(False, trading_pair, amount, OrderType.LIMIT, 0, 10001,
                                            FixtureBittrex.ORDER_PLACE_FILLED, FixtureBittrex.WS_ORDER_FILLED)
             [sell_order_completed_event] = self.run_parallel(self.market_logger.wait_for(SellOrderCompletedEvent))
 
diff --git a/test/integration/test_coinbase_pro_market.py b/test/integration/test_coinbase_pro_market.py
index 25d546ce9ec..7fd678f3ee3 100644
--- a/test/integration/test_coinbase_pro_market.py
+++ b/test/integration/test_coinbase_pro_market.py
@@ -169,28 +169,28 @@ def run_parallel(self, *tasks):
         return self.ev_loop.run_until_complete(self.run_parallel_async(*tasks))
 
     def test_get_fee(self):
-        limit_fee: TradeFee = self.market.get_fee("ETH", "USDC", OrderType.LIMIT, TradeType.BUY, 1, 1)
+        limit_fee: TradeFee = self.market.get_fee("ETH", "USDC", OrderType.LIMIT_MAKER, TradeType.BUY, 1, 1)
         self.assertGreater(limit_fee.percent, 0)
         self.assertEqual(len(limit_fee.flat_fees), 0)
-        market_fee: TradeFee = self.market.get_fee("ETH", "USDC", OrderType.MARKET, TradeType.BUY, 1)
+        market_fee: TradeFee = self.market.get_fee("ETH", "USDC", OrderType.LIMIT, TradeType.BUY, 1)
         self.assertGreater(market_fee.percent, 0)
         self.assertEqual(len(market_fee.flat_fees), 0)
 
     def test_fee_overrides_config(self):
         fee_overrides_config_map["coinbase_pro_taker_fee"].value = None
-        taker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.MARKET, TradeType.BUY, Decimal(1),
+        taker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.LIMIT, TradeType.BUY, Decimal(1),
                                                   Decimal('0.1'))
         self.assertAlmostEqual(Decimal("0.005"), taker_fee.percent)
         fee_overrides_config_map["coinbase_pro_taker_fee"].value = Decimal('0.2')
-        taker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.MARKET, TradeType.BUY, Decimal(1),
+        taker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.LIMIT, TradeType.BUY, Decimal(1),
                                                   Decimal('0.1'))
         self.assertAlmostEqual(Decimal("0.002"), taker_fee.percent)
         fee_overrides_config_map["coinbase_pro_maker_fee"].value = None
-        maker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.LIMIT, TradeType.BUY, Decimal(1),
+        maker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.LIMIT_MAKER, TradeType.BUY, Decimal(1),
                                                   Decimal('0.1'))
         self.assertAlmostEqual(Decimal("0.005"), maker_fee.percent)
         fee_overrides_config_map["coinbase_pro_maker_fee"].value = Decimal('0.75')
-        maker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.LIMIT, TradeType.BUY, Decimal(1),
+        maker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.LIMIT_MAKER, TradeType.BUY, Decimal(1),
                                                   Decimal('0.1'))
         self.assertAlmostEqual(Decimal("0.0075"), maker_fee.percent)
 
@@ -223,37 +223,6 @@ def cancel_order(self, trading_pair, order_id, exchange_order_id, fixture_ws):
             resp["order_id"] = exchange_order_id
             HummingWsServerFactory.send_json_threadsafe(WS_BASE_URL, resp, delay=0.1)
 
-    def test_limit_buy(self):
-        self.assertGreater(self.market.get_balance("ETH"), Decimal("0.1"))
-        trading_pair = "ETH-USDC"
-        amount: Decimal = Decimal("0.02")
-        quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
-
-        current_bid_price: Decimal = self.market.get_price(trading_pair, True)
-        bid_price: Decimal = current_bid_price + Decimal("0.05") * current_bid_price
-        quantize_bid_price: Decimal = self.market.quantize_order_price(trading_pair, bid_price)
-
-        order_id, _ = self.place_order(True, trading_pair, quantized_amount, OrderType.LIMIT, quantize_bid_price,
-                                       10001, FixtureCoinbasePro.ORDERS_LIMIT, FixtureCoinbasePro.WS_ORDER_FILLED)
-        [order_completed_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCompletedEvent))
-        order_completed_event: BuyOrderCompletedEvent = order_completed_event
-        trade_events: List[OrderFilledEvent] = [t for t in self.market_logger.event_log
-                                                if isinstance(t, OrderFilledEvent)]
-        base_amount_traded: Decimal = sum(t.amount for t in trade_events)
-        quote_amount_traded: Decimal = sum(t.amount * t.price for t in trade_events)
-
-        self.assertTrue([evt.order_type == OrderType.LIMIT for evt in trade_events])
-        self.assertEqual(order_id, order_completed_event.order_id)
-        self.assertAlmostEqual(quantized_amount, order_completed_event.base_asset_amount)
-        self.assertEqual("ETH", order_completed_event.base_asset)
-        self.assertEqual("USDC", order_completed_event.quote_asset)
-        self.assertAlmostEqual(base_amount_traded, order_completed_event.base_asset_amount)
-        self.assertAlmostEqual(quote_amount_traded, order_completed_event.quote_asset_amount)
-        self.assertTrue(any([isinstance(event, BuyOrderCreatedEvent) and event.order_id == order_id
-                             for event in self.market_logger.event_log]))
-        # Reset the logs
-        self.market_logger.clear()
-
     def test_limit_maker_rejections(self):
         trading_pair = "ETH-USDC"
 
@@ -262,9 +231,7 @@ def test_limit_maker_rejections(self):
         price: Decimal = self.market.quantize_order_price(trading_pair, price)
         amount = self.market.quantize_order_amount(trading_pair, Decimal("0.02"))
 
-        order_id = self.place_order(True, trading_pair, amount, OrderType.LIMIT_MAKER,
-                                    price, 10001,
-                                    FixtureCoinbasePro.LIMIT_MAKER_ERROR, FixtureCoinbasePro.EMPTY)
+        order_id = self.market.buy(trading_pair, amount, OrderType.LIMIT_MAKER, price)
         [order_failure_event] = self.run_parallel(self.market_logger.wait_for(MarketOrderFailureEvent))
         self.assertEqual(order_id, order_failure_event.order_id)
 
@@ -275,9 +242,7 @@ def test_limit_maker_rejections(self):
         price: Decimal = self.market.quantize_order_price(trading_pair, price)
         amount = self.market.quantize_order_amount(trading_pair, Decimal("0.02"))
 
-        order_id = self.place_order(False, trading_pair, amount, OrderType.LIMIT_MAKER,
-                                    price, 10002,
-                                    FixtureCoinbasePro.LIMIT_MAKER_ERROR, FixtureCoinbasePro.EMPTY)
+        order_id = self.market.sell(trading_pair, amount, OrderType.LIMIT_MAKER, price)
         [order_failure_event] = self.run_parallel(self.market_logger.wait_for(MarketOrderFailureEvent))
         self.assertEqual(order_id, order_failure_event.order_id)
 
@@ -287,9 +252,9 @@ def test_limit_makers_unfilled(self):
         price = self.market.quantize_order_price(trading_pair, price)
         amount = self.market.quantize_order_amount(trading_pair, Decimal("0.02"))
 
-        order_id = self.place_order(True, trading_pair, amount, OrderType.LIMIT_MAKER,
-                                    price, 10001,
-                                    FixtureCoinbasePro.ORDERS_LIMIT, FixtureCoinbasePro.WS_ORDER_OPEN)
+        order_id, _ = self.place_order(True, trading_pair, amount, OrderType.LIMIT_MAKER,
+                                       price, 10001,
+                                       FixtureCoinbasePro.ORDERS_LIMIT, FixtureCoinbasePro.WS_ORDER_OPEN)
         [order_created_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCreatedEvent))
         order_created_event: BuyOrderCreatedEvent = order_created_event
         self.assertEqual(order_id, order_created_event.order_id)
@@ -298,9 +263,9 @@ def test_limit_makers_unfilled(self):
         price = self.market.quantize_order_price(trading_pair, price)
         amount = self.market.quantize_order_amount(trading_pair, Decimal("0.02"))
 
-        order_id = self.place_order(False, trading_pair, amount, OrderType.LIMIT_MAKER,
-                                    price, 10002,
-                                    FixtureCoinbasePro.ORDERS_LIMIT_2, FixtureCoinbasePro.WS_ORDER_OPEN)
+        order_id, _ = self.place_order(False, trading_pair, amount, OrderType.LIMIT_MAKER,
+                                       price, 10002,
+                                       FixtureCoinbasePro.ORDERS_LIMIT_2, FixtureCoinbasePro.WS_ORDER_OPEN)
         [order_created_event] = self.run_parallel(self.market_logger.wait_for(SellOrderCreatedEvent))
         order_created_event: BuyOrderCreatedEvent = order_created_event
         self.assertEqual(order_id, order_created_event.order_id)
@@ -309,42 +274,15 @@ def test_limit_makers_unfilled(self):
         for cr in cancellation_results:
             self.assertEqual(cr.success, True)
 
-    def test_limit_sell(self):
-        trading_pair = "ETH-USDC"
-        amount: Decimal = Decimal("0.02")
-        quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
-        current_ask_price: Decimal = self.market.get_price(trading_pair, False)
-        ask_price: Decimal = current_ask_price - Decimal("0.05") * current_ask_price
-        quantize_ask_price: Decimal = self.market.quantize_order_price(trading_pair, ask_price)
-
-        order_id, _ = self.place_order(False, trading_pair, amount, OrderType.LIMIT, quantize_ask_price, 10001,
-                                       FixtureCoinbasePro.ORDERS_LIMIT, FixtureCoinbasePro.WS_ORDER_FILLED)
-        [order_completed_event] = self.run_parallel(self.market_logger.wait_for(SellOrderCompletedEvent))
-        order_completed_event: SellOrderCompletedEvent = order_completed_event
-        trade_events = [t for t in self.market_logger.event_log if isinstance(t, OrderFilledEvent)]
-        base_amount_traded = sum(t.amount for t in trade_events)
-        quote_amount_traded = sum(t.amount * t.price for t in trade_events)
-
-        self.assertTrue([evt.order_type == OrderType.LIMIT for evt in trade_events])
-        self.assertEqual(order_id, order_completed_event.order_id)
-        self.assertAlmostEqual(quantized_amount, order_completed_event.base_asset_amount)
-        self.assertEqual("ETH", order_completed_event.base_asset)
-        self.assertEqual("USDC", order_completed_event.quote_asset)
-        self.assertAlmostEqual(base_amount_traded, order_completed_event.base_asset_amount)
-        self.assertAlmostEqual(quote_amount_traded, order_completed_event.quote_asset_amount)
-        self.assertTrue(any([isinstance(event, SellOrderCreatedEvent) and event.order_id == order_id
-                             for event in self.market_logger.event_log]))
-        # Reset the logs
-        self.market_logger.clear()
-
     # NOTE that orders of non-USD pairs (including USDC pairs) are LIMIT only
     def test_market_buy(self):
         self.assertGreater(self.market.get_balance("ETH"), Decimal("0.1"))
         trading_pair = "ETH-USDC"
+        price: Decimal = self.market.get_price(trading_pair, True)
         amount: Decimal = Decimal("0.02")
         quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
 
-        order_id, _ = self.place_order(True, trading_pair, quantized_amount, OrderType.MARKET, Decimal("nan"), 10001,
+        order_id, _ = self.place_order(True, trading_pair, quantized_amount, OrderType.LIMIT, price, 10001,
                                        FixtureCoinbasePro.ORDERS_MARKET, FixtureCoinbasePro.WS_MARKET_FILLED)
         [order_completed_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCompletedEvent))
         order_completed_event: BuyOrderCompletedEvent = order_completed_event
@@ -353,7 +291,7 @@ def test_market_buy(self):
         base_amount_traded: Decimal = sum(t.amount for t in trade_events)
         quote_amount_traded: Decimal = sum(t.amount * t.price for t in trade_events)
 
-        self.assertTrue([evt.order_type == OrderType.LIMIT for evt in trade_events])
+        self.assertTrue([evt.order_type == OrderType.LIMIT_MAKER for evt in trade_events])
         self.assertEqual(order_id, order_completed_event.order_id)
         self.assertAlmostEqual(quantized_amount, order_completed_event.base_asset_amount)
         self.assertEqual("ETH", order_completed_event.base_asset)
@@ -368,10 +306,11 @@ def test_market_buy(self):
     # NOTE that orders of non-USD pairs (including USDC pairs) are LIMIT only
     def test_market_sell(self):
         trading_pair = "ETH-USDC"
+        price: Decimal = self.market.get_price(trading_pair, False)
         amount: Decimal = Decimal("0.02")
         quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
 
-        order_id, _ = self.place_order(False, trading_pair, quantized_amount, OrderType.MARKET, Decimal("nan"), 10001,
+        order_id, _ = self.place_order(False, trading_pair, quantized_amount, OrderType.LIMIT, price, 10001,
                                        FixtureCoinbasePro.ORDERS_MARKET, FixtureCoinbasePro.WS_MARKET_FILLED)
         [order_completed_event] = self.run_parallel(self.market_logger.wait_for(SellOrderCompletedEvent))
         order_completed_event: SellOrderCompletedEvent = order_completed_event
@@ -379,7 +318,7 @@ def test_market_sell(self):
         base_amount_traded = sum(t.amount for t in trade_events)
         quote_amount_traded = sum(t.amount * t.price for t in trade_events)
 
-        self.assertTrue([evt.order_type == OrderType.LIMIT for evt in trade_events])
+        self.assertTrue([evt.order_type == OrderType.LIMIT_MAKER for evt in trade_events])
         self.assertEqual(order_id, order_completed_event.order_id)
         self.assertAlmostEqual(quantized_amount, order_completed_event.base_asset_amount)
         self.assertEqual("ETH", order_completed_event.base_asset)
@@ -402,7 +341,7 @@ def test_cancel_order(self):
         quantize_bid_price: Decimal = self.market.quantize_order_price(trading_pair, bid_price)
         quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
 
-        order_id, exch_order_id = self.place_order(True, trading_pair, quantized_amount, OrderType.LIMIT,
+        order_id, exch_order_id = self.place_order(True, trading_pair, quantized_amount, OrderType.LIMIT_MAKER,
                                                    quantize_bid_price, 10001, FixtureCoinbasePro.ORDERS_LIMIT,
                                                    FixtureCoinbasePro.WS_ORDER_OPEN)
 
@@ -422,9 +361,9 @@ def test_cancel_all(self):
         quantize_bid_price: Decimal = self.market.quantize_order_price(trading_pair, bid_price * Decimal("0.7"))
         quantize_ask_price: Decimal = self.market.quantize_order_price(trading_pair, ask_price * Decimal("1.5"))
 
-        _, exch_order_id = self.place_order(True, trading_pair, quantized_amount, OrderType.LIMIT, quantize_bid_price,
+        _, exch_order_id = self.place_order(True, trading_pair, quantized_amount, OrderType.LIMIT_MAKER, quantize_bid_price,
                                             10001, FixtureCoinbasePro.ORDERS_LIMIT, FixtureCoinbasePro.WS_ORDER_OPEN)
-        _, exch_order_id_2 = self.place_order(False, trading_pair, quantized_amount, OrderType.LIMIT,
+        _, exch_order_id_2 = self.place_order(False, trading_pair, quantized_amount, OrderType.LIMIT_MAKER,
                                               quantize_ask_price, 10002, FixtureCoinbasePro.ORDERS_LIMIT_2,
                                               FixtureCoinbasePro.WS_ORDER_OPEN)
         self.run_parallel(asyncio.sleep(1))
@@ -454,7 +393,7 @@ def test_list_orders(self):
         bid_price: Decimal = current_bid_price + Decimal("0.05") * current_bid_price
         quantize_bid_price: Decimal = self.market.quantize_order_price(trading_pair, bid_price)
 
-        self.market.buy(trading_pair, quantized_amount, OrderType.LIMIT, quantize_bid_price)
+        self.market.buy(trading_pair, quantized_amount, OrderType.LIMIT_MAKER, quantize_bid_price)
         self.run_parallel(asyncio.sleep(1))
         [order_details] = self.run_parallel(self.market.list_orders())
         self.assertGreaterEqual(len(order_details), 1)
@@ -481,7 +420,7 @@ def test_orders_saving_and_restoration(self):
             amount: Decimal = Decimal("0.02")
             quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
 
-            order_id, exch_order_id = self.place_order(True, trading_pair, quantized_amount, OrderType.LIMIT,
+            order_id, exch_order_id = self.place_order(True, trading_pair, quantized_amount, OrderType.LIMIT_MAKER,
                                                        quantize_bid_price, 10001, FixtureCoinbasePro.ORDERS_LIMIT,
                                                        FixtureCoinbasePro.WS_ORDER_OPEN)
             [order_created_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCreatedEvent))
@@ -561,8 +500,9 @@ def test_order_fill_record(self):
 
         try:
             # Try to buy 0.04 ETH from the exchange, and watch for completion event.
+            price: Decimal = self.market.get_price(trading_pair, True)
             amount: Decimal = Decimal("0.02")
-            order_id, exch_order_id = self.place_order(True, trading_pair, amount, OrderType.MARKET, Decimal("nan"),
+            order_id, exch_order_id = self.place_order(True, trading_pair, amount, OrderType.LIMIT, price,
                                                        10001, FixtureCoinbasePro.ORDERS_MARKET,
                                                        FixtureCoinbasePro.WS_MARKET_FILLED)
             [buy_order_completed_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCompletedEvent))
@@ -571,8 +511,9 @@ def test_order_fill_record(self):
             self.market_logger.clear()
 
             # Try to sell back the same amount of ETH to the exchange, and watch for completion event.
+            price: Decimal = self.market.get_price(trading_pair, False)
             amount = buy_order_completed_event.base_asset_amount
-            order_id, exch_order_id = self.place_order(False, trading_pair, amount, OrderType.MARKET, Decimal("nan"),
+            order_id, exch_order_id = self.place_order(False, trading_pair, amount, OrderType.LIMIT, price,
                                                        10002, FixtureCoinbasePro.ORDERS_MARKET_2,
                                                        FixtureCoinbasePro.WS_MARKET_FILLED)
             [sell_order_completed_event] = self.run_parallel(self.market_logger.wait_for(SellOrderCompletedEvent))
diff --git a/test/integration/test_dolomite_market.py b/test/integration/test_dolomite_market.py
index 7d759341bcb..ece9c00bd6d 100644
--- a/test/integration/test_dolomite_market.py
+++ b/test/integration/test_dolomite_market.py
@@ -126,10 +126,10 @@ def run_parallel(self, *tasks):
     # ====================================================
 
     def test_get_fee(self):
-        limit_trade_fee: TradeFee = self.market.get_fee("WETH", "DAI", OrderType.LIMIT, TradeType.BUY, 10000, 1)
+        limit_trade_fee: TradeFee = self.market.get_fee("WETH", "DAI", OrderType.LIMIT_MAKER, TradeType.BUY, 10000, 1)
         self.assertLess(limit_trade_fee.percent, 0.01)
         self.assertEqual(len(limit_trade_fee.flat_fees), 0)
-        market_trade_fee: TradeFee = self.market.get_fee("WETH", "DAI", OrderType.MARKET, TradeType.BUY, 0.1)
+        market_trade_fee: TradeFee = self.market.get_fee("WETH", "DAI", OrderType.LIMIT, TradeType.BUY, 0.1)
         self.assertGreater(market_trade_fee.percent, 0)
         self.assertEqual(len(market_trade_fee.flat_fees), 1)
         self.assertEqual(market_trade_fee.flat_fees[0][0], "DAI")
@@ -153,7 +153,7 @@ def test_cancel_order(self):
         amount = 0.5
 
         # Intentionally setting invalid price to prevent getting filled
-        client_order_id = self.market.buy(trading_pair, amount, OrderType.LIMIT, bid_price * 0.7)
+        client_order_id = self.market.buy(trading_pair, amount, OrderType.LIMIT_MAKER, bid_price * 0.7)
         self.run_parallel(asyncio.sleep(1.0))
         self.market.cancel(trading_pair, client_order_id)
         [order_cancelled_event] = self.run_parallel(self.market_logger.wait_for(OrderCancelledEvent))
@@ -163,6 +163,7 @@ def test_cancel_order(self):
         self.assertEqual(0, len(self.market.limit_orders))
         self.assertEqual(client_order_id, order_cancelled_event.order_id)
 
+    # NOTE: this actually tests maker order
     def test_place_limit_buy_and_sell(self):
         self.assertGreater(self.market.get_balance("WETH"), 0.4)
         self.assertGreater(self.market.get_balance("DAI"), 60)
@@ -171,7 +172,7 @@ def test_place_limit_buy_and_sell(self):
         trading_pair = "WETH-DAI"
         bid_price: float = self.market.get_price(trading_pair, True)
         amount: float = 0.4
-        buy_order_id: str = self.market.buy(trading_pair, amount, OrderType.LIMIT, bid_price * 0.7)
+        buy_order_id: str = self.market.buy(trading_pair, amount, OrderType.LIMIT_MAKER, bid_price * 0.7)
         [buy_order_created_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCreatedEvent))
         self.assertEqual(buy_order_id, buy_order_created_event.order_id)
         self.market.cancel(trading_pair, buy_order_id)
@@ -179,7 +180,7 @@ def test_place_limit_buy_and_sell(self):
 
         # Try to sell 0.2 WETH to the exchange, and watch for creation event.
         ask_price: float = self.market.get_price(trading_pair, False)
-        sell_order_id: str = self.market.sell(trading_pair, amount, OrderType.LIMIT, ask_price * 1.5)
+        sell_order_id: str = self.market.sell(trading_pair, amount, OrderType.LIMIT_MAKER, ask_price * 1.5)
         [sell_order_created_event] = self.run_parallel(self.market_logger.wait_for(SellOrderCreatedEvent))
         self.assertEqual(sell_order_id, sell_order_created_event.order_id)
         self.market.cancel(trading_pair, sell_order_id)
diff --git a/test/integration/test_eterbase_market.py b/test/integration/test_eterbase_market.py
index 04682a282ce..5688af27bde 100644
--- a/test/integration/test_eterbase_market.py
+++ b/test/integration/test_eterbase_market.py
@@ -131,70 +131,13 @@ def run_parallel(self, *tasks):
         return self.ev_loop.run_until_complete(self.run_parallel_async(*tasks))
 
     def test_get_fee(self):
-        limit_fee: TradeFee = self.market.get_fee("ETH", "EUR", OrderType.LIMIT, TradeType.BUY, 1, 1)
+        limit_fee: TradeFee = self.market.get_fee("ETH", "EUR", OrderType.LIMIT_MAKER, TradeType.BUY, 1, 1)
         self.assertGreaterEqual(limit_fee.percent, 0)
         self.assertEqual(len(limit_fee.flat_fees), 0)
-        market_fee: TradeFee = self.market.get_fee("ETH", "EUR", OrderType.MARKET, TradeType.BUY, 1)
+        market_fee: TradeFee = self.market.get_fee("ETH", "EUR", OrderType.LIMIT, TradeType.BUY, 1)
         self.assertGreaterEqual(market_fee.percent, 0)
         self.assertEqual(len(market_fee.flat_fees), 0)
 
-    def test_limit_buy(self):
-        self.assertGreater(self.market.get_balance("ETH"), Decimal("0.1"))
-        trading_pair = "ETHEUR"
-        amount: Decimal = Decimal("0.02")
-        quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
-
-        current_bid_price: Decimal = self.market.get_price(trading_pair, True)
-        bid_price: Decimal = current_bid_price + Decimal("0.05") * current_bid_price
-        quantize_bid_price: Decimal = self.market.quantize_order_price(trading_pair, bid_price)
-
-        order_id = self.market.buy(trading_pair, quantized_amount, OrderType.LIMIT, quantize_bid_price)
-        [order_completed_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCompletedEvent))
-        order_completed_event: BuyOrderCompletedEvent = order_completed_event
-        trade_events: List[OrderFilledEvent] = [t for t in self.market_logger.event_log
-                                                if isinstance(t, OrderFilledEvent)]
-        base_amount_traded: Decimal = sum(t.amount for t in trade_events)
-        quote_amount_traded: Decimal = sum(t.amount * t.price for t in trade_events)
-
-        self.assertTrue([evt.order_type == OrderType.LIMIT for evt in trade_events])
-        self.assertEqual(order_id, order_completed_event.order_id)
-        self.assertAlmostEqual(quantized_amount, order_completed_event.base_asset_amount)
-        self.assertEqual("ETH", order_completed_event.base_asset)
-        self.assertEqual("EUR", order_completed_event.quote_asset)
-        self.assertAlmostEqual(base_amount_traded, order_completed_event.base_asset_amount)
-        self.assertAlmostEqual(quote_amount_traded, order_completed_event.quote_asset_amount)
-        self.assertTrue(any([isinstance(event, BuyOrderCreatedEvent) and event.order_id == order_id
-                             for event in self.market_logger.event_log]))
-        # Reset the logs
-        self.market_logger.clear()
-
-    def test_limit_sell(self):
-        trading_pair = "ETHEUR"
-        amount: Decimal = Decimal("0.01")
-        quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
-        current_ask_price: Decimal = self.market.get_price(trading_pair, False)
-        ask_price: Decimal = current_ask_price - Decimal("0.05") * current_ask_price
-        quantize_ask_price: Decimal = self.market.quantize_order_price(trading_pair, ask_price)
-
-        order_id = self.market.sell(trading_pair, amount, OrderType.LIMIT, quantize_ask_price)
-        [order_completed_event] = self.run_parallel(self.market_logger.wait_for(SellOrderCompletedEvent))
-        order_completed_event: SellOrderCompletedEvent = order_completed_event
-        trade_events = [t for t in self.market_logger.event_log if isinstance(t, OrderFilledEvent)]
-        base_amount_traded = sum(t.amount for t in trade_events)
-        quote_amount_traded = sum(t.amount * t.price for t in trade_events)
-
-        self.assertTrue([evt.order_type == OrderType.LIMIT for evt in trade_events])
-        self.assertEqual(order_id, order_completed_event.order_id)
-        self.assertAlmostEqual(quantized_amount, order_completed_event.base_asset_amount)
-        self.assertEqual("ETH", order_completed_event.base_asset)
-        self.assertEqual("EUR", order_completed_event.quote_asset)
-        self.assertAlmostEqual(base_amount_traded, order_completed_event.base_asset_amount)
-        self.assertAlmostEqual(quote_amount_traded, order_completed_event.quote_asset_amount, 1)
-        self.assertTrue(any([isinstance(event, SellOrderCreatedEvent) and event.order_id == order_id
-                             for event in self.market_logger.event_log]))
-        # Reset the logs
-        self.market_logger.clear()
-
     def test_limit_maker_rejections(self):
         trading_pair = "ETHEUR"
 
@@ -253,7 +196,7 @@ def test_market_buy(self):
         ask_price: Decimal = current_ask_price - Decimal("0.05") * current_ask_price
         quantize_price: Decimal = self.market.quantize_order_price(trading_pair, ask_price)
 
-        order_id = self.market.buy(trading_pair, quantize_amount, OrderType.MARKET, quantize_price)
+        order_id = self.market.buy(trading_pair, quantize_amount, OrderType.LIMIT, quantize_price)
 
         [order_completed_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCompletedEvent))
         order_completed_event: BuyOrderCompletedEvent = order_completed_event
@@ -263,7 +206,7 @@ def test_market_buy(self):
         base_amount_traded: Decimal = sum(t.amount for t in trade_events)
         quote_amount_traded: Decimal = sum(t.amount * t.price for t in trade_events)
 
-        self.assertTrue([evt.order_type == OrderType.MARKET for evt in trade_events])
+        self.assertTrue([evt.order_type == OrderType.LIMIT for evt in trade_events])
         self.assertEqual(order_id, order_completed_event.order_id)
         # not possible to exactly defined, as reuest is in COSTS (amount*price)
         self.assertAlmostEqual(quantize_amount * quantize_price, order_completed_event.quote_asset_amount, 1)
@@ -297,17 +240,18 @@ def test_market_buy(self):
     # NOTE that orders of non-USD pairs (including USDC pairs) are LIMIT only
     def test_market_sell(self):
         trading_pair = "ETHEUR"
+        price: Decimal = self.market.get_price(trading_pair, False)
         amount: Decimal = Decimal("0.02")
         quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
 
-        order_id = self.market.sell(trading_pair, amount, OrderType.MARKET)
+        order_id = self.market.sell(trading_pair, amount, OrderType.LIMIT, price)
         [order_completed_event] = self.run_parallel(self.market_logger.wait_for(SellOrderCompletedEvent))
         order_completed_event: SellOrderCompletedEvent = order_completed_event
         trade_events = [t for t in self.market_logger.event_log if isinstance(t, OrderFilledEvent)]
         base_amount_traded = sum(t.amount for t in trade_events)
         quote_amount_traded = sum(t.price * t.amount for t in trade_events)
 
-        self.assertTrue([evt.order_type == OrderType.MARKET for evt in trade_events])
+        self.assertTrue([evt.order_type == OrderType.LIMIT for evt in trade_events])
         self.assertEqual(order_id, order_completed_event.order_id)
         self.assertAlmostEqual(quantized_amount, order_completed_event.base_asset_amount)
         self.assertEqual("ETH", order_completed_event.base_asset)
@@ -330,7 +274,7 @@ def test_cancel_order(self):
         quantize_bid_price: Decimal = self.market.quantize_order_price(trading_pair, bid_price)
         quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
 
-        client_order_id = self.market.buy(trading_pair, quantized_amount, OrderType.LIMIT, quantize_bid_price)
+        client_order_id = self.market.buy(trading_pair, quantized_amount, OrderType.LIMIT_MAKER, quantize_bid_price)
         self.market.cancel(trading_pair, client_order_id)
         [order_cancelled_event] = self.run_parallel(self.market_logger.wait_for(OrderCancelledEvent))
         order_cancelled_event: OrderCancelledEvent = order_cancelled_event
@@ -347,8 +291,8 @@ def test_cancel_all(self):
         quantize_bid_price: Decimal = self.market.quantize_order_price(trading_pair, bid_price * Decimal("0.7"))
         quantize_ask_price: Decimal = self.market.quantize_order_price(trading_pair, ask_price * Decimal("1.5"))
 
-        self.market.buy(trading_pair, quantized_amount, OrderType.LIMIT, quantize_bid_price)
-        self.market.sell(trading_pair, quantized_amount, OrderType.LIMIT, quantize_ask_price)
+        self.market.buy(trading_pair, quantized_amount, OrderType.LIMIT_MAKER, quantize_bid_price)
+        self.market.sell(trading_pair, quantized_amount, OrderType.LIMIT_MAKER, quantize_ask_price)
         self.run_parallel(asyncio.sleep(1))
         [cancellation_results] = self.run_parallel(self.market.cancel_all(5))
         for cr in cancellation_results:
@@ -365,7 +309,7 @@ def test_list_orders(self):
         bid_price: Decimal = current_bid_price + Decimal("0.05") * current_bid_price
         quantize_bid_price: Decimal = self.market.quantize_order_price(trading_pair, bid_price)
 
-        self.market.buy(trading_pair, quantized_amount, OrderType.LIMIT, quantize_bid_price)
+        self.market.buy(trading_pair, quantized_amount, OrderType.LIMIT_MAKER, quantize_bid_price)
         self.run_parallel(asyncio.sleep(1))
         [order_details] = self.run_parallel(self.market.list_orders())
         self.assertGreaterEqual(len(order_details), 1)
@@ -392,7 +336,7 @@ def test_orders_saving_and_restoration(self):
             amount: Decimal = Decimal("0.04")
             quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
 
-            order_id = self.market.buy(trading_pair, quantized_amount, OrderType.LIMIT, quantize_bid_price)
+            order_id = self.market.buy(trading_pair, quantized_amount, OrderType.LIMIT_MAKER, quantize_bid_price)
             [order_created_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCreatedEvent))
             order_created_event: BuyOrderCreatedEvent = order_created_event
             self.assertEqual(order_id, order_created_event.order_id)
@@ -468,7 +412,7 @@ def test_order_fill_record(self):
             ask_price: Decimal = current_ask_price - Decimal("0.05") * current_ask_price
             quantize_price: Decimal = self.market.quantize_order_price(trading_pair, ask_price)
 
-            order_id = self.market.buy(trading_pair, amount, OrderType.MARKET, quantize_price)
+            order_id = self.market.buy(trading_pair, amount, OrderType.LIMIT, quantize_price)
 
             [buy_order_completed_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCompletedEvent))
 
@@ -476,8 +420,9 @@ def test_order_fill_record(self):
             self.market_logger.clear()
 
             # Try to sell back the same amount of ETH to the exchange, and watch for completion event.
+            price: Decimal = self.market.get_price(trading_pair, False)
             amount = buy_order_completed_event.base_asset_amount
-            order_id = self.market.sell(trading_pair, amount)
+            order_id = self.market.sell(trading_pair, amount, OrderType.LIMIT, price)
             [sell_order_completed_event] = self.run_parallel(self.market_logger.wait_for(SellOrderCompletedEvent))
 
             # Query the persisted trade logs
diff --git a/test/integration/test_huobi_market.py b/test/integration/test_huobi_market.py
index d18cac8805c..514c0344f7b 100644
--- a/test/integration/test_huobi_market.py
+++ b/test/integration/test_huobi_market.py
@@ -167,31 +167,31 @@ def run_parallel(self, *tasks):
         return self.ev_loop.run_until_complete(self.run_parallel_async(*tasks))
 
     def test_get_fee(self):
-        limit_fee: TradeFee = self.market.get_fee("eth", "usdt", OrderType.LIMIT, TradeType.BUY, 1, 10)
+        limit_fee: TradeFee = self.market.get_fee("eth", "usdt", OrderType.LIMIT_MAKER, TradeType.BUY, 1, 10)
         self.assertGreater(limit_fee.percent, 0)
         self.assertEqual(len(limit_fee.flat_fees), 0)
-        market_fee: TradeFee = self.market.get_fee("eth", "usdt", OrderType.MARKET, TradeType.BUY, 1)
+        market_fee: TradeFee = self.market.get_fee("eth", "usdt", OrderType.LIMIT, TradeType.BUY, 1)
         self.assertGreater(market_fee.percent, 0)
         self.assertEqual(len(market_fee.flat_fees), 0)
-        sell_trade_fee: TradeFee = self.market.get_fee("eth", "usdt", OrderType.LIMIT, TradeType.SELL, 1, 10)
+        sell_trade_fee: TradeFee = self.market.get_fee("eth", "usdt", OrderType.LIMIT_MAKER, TradeType.SELL, 1, 10)
         self.assertGreater(sell_trade_fee.percent, 0)
         self.assertEqual(len(sell_trade_fee.flat_fees), 0)
 
     def test_fee_overrides_config(self):
         fee_overrides_config_map["huobi_taker_fee"].value = None
-        taker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.MARKET, TradeType.BUY, Decimal(1),
+        taker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.LIMIT, TradeType.BUY, Decimal(1),
                                                   Decimal('0.1'))
         self.assertAlmostEqual(Decimal("0.002"), taker_fee.percent)
         fee_overrides_config_map["huobi_taker_fee"].value = Decimal('0.1')
-        taker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.MARKET, TradeType.BUY, Decimal(1),
+        taker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.LIMIT, TradeType.BUY, Decimal(1),
                                                   Decimal('0.1'))
         self.assertAlmostEqual(Decimal("0.001"), taker_fee.percent)
         fee_overrides_config_map["huobi_maker_fee"].value = None
-        maker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.LIMIT, TradeType.BUY, Decimal(1),
+        maker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.LIMIT_MAKER, TradeType.BUY, Decimal(1),
                                                   Decimal('0.1'))
         self.assertAlmostEqual(Decimal("0.002"), maker_fee.percent)
         fee_overrides_config_map["huobi_maker_fee"].value = Decimal('0.5')
-        maker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.LIMIT, TradeType.BUY, Decimal(1),
+        maker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.LIMIT_MAKER, TradeType.BUY, Decimal(1),
                                                   Decimal('0.1'))
         self.assertAlmostEqual(Decimal("0.005"), maker_fee.percent)
 
@@ -234,69 +234,6 @@ def cancel_order(self, trading_pair, order_id, exchange_order_id, get_resp):
             resp["data"]["client-order-id"] = order_id
             self.web_app.update_response("get", API_BASE_URL, f"/v1/order/orders/{exchange_order_id}", resp)
 
-    def test_limit_buy(self):
-        trading_pair = "ethusdt"
-
-        amount: Decimal = Decimal("0.06")
-        quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
-
-        current_bid_price: Decimal = self.market.get_price(trading_pair, True)
-        bid_price: Decimal = current_bid_price + Decimal("0.05") * current_bid_price
-        quantize_bid_price: Decimal = self.market.quantize_order_price(trading_pair, bid_price)
-
-        order_id, _ = self.place_order(True, trading_pair, quantized_amount, OrderType.LIMIT, quantize_bid_price,
-                                       10001, FixtureHuobi.ORDER_GET_LIMIT_BUY_FILLED)
-        [order_completed_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCompletedEvent))
-        order_completed_event: BuyOrderCompletedEvent = order_completed_event
-        trade_events: List[OrderFilledEvent] = [t for t in self.market_logger.event_log
-                                                if isinstance(t, OrderFilledEvent)]
-        base_amount_traded: Decimal = sum(t.amount for t in trade_events)
-        quote_amount_traded: Decimal = sum(t.amount * t.price for t in trade_events)
-
-        self.assertTrue([evt.order_type == OrderType.LIMIT for evt in trade_events])
-        self.assertEqual(order_id, order_completed_event.order_id)
-        self.assertAlmostEqual(quantized_amount, order_completed_event.base_asset_amount)
-        self.assertEqual("eth", order_completed_event.base_asset)
-        self.assertEqual("usdt", order_completed_event.quote_asset)
-        self.assertAlmostEqual(base_amount_traded, order_completed_event.base_asset_amount)
-        self.assertAlmostEqual(quote_amount_traded, order_completed_event.quote_asset_amount)
-        self.assertGreater(order_completed_event.fee_amount, Decimal(0))
-        self.assertTrue(any([isinstance(event, BuyOrderCreatedEvent) and event.order_id == order_id
-                             for event in self.market_logger.event_log]))
-        # Reset the logs
-        self.market_logger.clear()
-
-    def test_limit_sell(self):
-        trading_pair = "ethusdt"
-        amount: Decimal = Decimal("0.06")
-        quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
-
-        current_ask_price: Decimal = self.market.get_price(trading_pair, False)
-        ask_price: Decimal = current_ask_price - Decimal("0.05") * current_ask_price
-        quantize_ask_price: Decimal = self.market.quantize_order_price(trading_pair, ask_price)
-
-        order_id, _ = self.place_order(False, trading_pair, amount, OrderType.LIMIT, quantize_ask_price,
-                                       10001, FixtureHuobi.ORDER_GET_LIMIT_SELL_FILLED)
-        [order_completed_event] = self.run_parallel(self.market_logger.wait_for(SellOrderCompletedEvent))
-        order_completed_event: SellOrderCompletedEvent = order_completed_event
-        trade_events: List[OrderFilledEvent] = [t for t in self.market_logger.event_log
-                                                if isinstance(t, OrderFilledEvent)]
-        base_amount_traded = sum(t.amount for t in trade_events)
-        quote_amount_traded = sum(t.amount * t.price for t in trade_events)
-
-        self.assertTrue([evt.order_type == OrderType.LIMIT for evt in trade_events])
-        self.assertEqual(order_id, order_completed_event.order_id)
-        self.assertAlmostEqual(quantized_amount, order_completed_event.base_asset_amount)
-        self.assertEqual("eth", order_completed_event.base_asset)
-        self.assertEqual("usdt", order_completed_event.quote_asset)
-        self.assertAlmostEqual(base_amount_traded, order_completed_event.base_asset_amount)
-        self.assertAlmostEqual(quote_amount_traded, order_completed_event.quote_asset_amount)
-        self.assertGreater(order_completed_event.fee_amount, Decimal(0))
-        self.assertTrue(any([isinstance(event, SellOrderCreatedEvent) and event.order_id == order_id
-                             for event in self.market_logger.event_log]))
-        # Reset the logs
-        self.market_logger.clear()
-
     def test_limit_maker_rejections(self):
         trading_pair = "ethusdt"
 
@@ -305,9 +242,7 @@ def test_limit_maker_rejections(self):
         price: Decimal = self.market.quantize_order_price(trading_pair, price)
         amount = self.market.quantize_order_amount(trading_pair, Decimal("0.06"))
 
-        order_id = self.place_order(True, trading_pair, amount, OrderType.LIMIT_MAKER,
-                                    price, 10001,
-                                    FixtureHuobi.LIMIT_MAKER_ERROR)
+        order_id = self.market.buy(trading_pair, amount, OrderType.LIMIT_MAKER, price)
         [order_failure_event] = self.run_parallel(self.market_logger.wait_for(MarketOrderFailureEvent))
         self.assertEqual(order_id, order_failure_event.order_id)
 
@@ -318,9 +253,7 @@ def test_limit_maker_rejections(self):
         price: Decimal = self.market.quantize_order_price(trading_pair, price)
         amount = self.market.quantize_order_amount(trading_pair, Decimal("0.06"))
 
-        order_id = self.place_order(False, trading_pair, amount, OrderType.LIMIT_MAKER,
-                                    price, 10002,
-                                    FixtureHuobi.LIMIT_MAKER_ERROR)
+        order_id = self.market.sell(trading_pair, amount, OrderType.LIMIT_MAKER, price)
         [order_failure_event] = self.run_parallel(self.market_logger.wait_for(MarketOrderFailureEvent))
         self.assertEqual(order_id, order_failure_event.order_id)
 
@@ -330,9 +263,9 @@ def test_limit_makers_unfilled(self):
         price = self.market.quantize_order_price(trading_pair, price)
         amount = self.market.quantize_order_amount(trading_pair, Decimal("0.06"))
 
-        order_id = self.place_order(True, trading_pair, amount, OrderType.LIMIT_MAKER,
-                                    price, 10001,
-                                    FixtureHuobi.ORDER_GET_LIMIT_BUY_UNFILLED)
+        order_id, _ = self.place_order(True, trading_pair, amount, OrderType.LIMIT_MAKER,
+                                       price, 10001,
+                                       FixtureHuobi.ORDER_GET_LIMIT_BUY_UNFILLED)
         [order_created_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCreatedEvent))
         order_created_event: BuyOrderCreatedEvent = order_created_event
         self.assertEqual(order_id, order_created_event.order_id)
@@ -341,9 +274,9 @@ def test_limit_makers_unfilled(self):
         price = self.market.quantize_order_price(trading_pair, price)
         amount = self.market.quantize_order_amount(trading_pair, Decimal("0.06"))
 
-        order_id = self.place_order(False, trading_pair, amount, OrderType.LIMIT_MAKER,
-                                    price, 10002,
-                                    FixtureHuobi.ORDER_GET_LIMIT_SELL_UNFILLED)
+        order_id, _ = self.place_order(False, trading_pair, amount, OrderType.LIMIT_MAKER,
+                                       price, 10002,
+                                       FixtureHuobi.ORDER_GET_LIMIT_SELL_UNFILLED)
         [order_created_event] = self.run_parallel(self.market_logger.wait_for(SellOrderCreatedEvent))
         order_created_event: BuyOrderCreatedEvent = order_created_event
         self.assertEqual(order_id, order_created_event.order_id)
@@ -354,10 +287,11 @@ def test_limit_makers_unfilled(self):
 
     def test_market_buy(self):
         trading_pair = "ethusdt"
+        price: Decimal = self.market.get_price(trading_pair, True)
         amount: Decimal = Decimal("0.06")
         quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
 
-        order_id, _ = self.place_order(True, trading_pair, quantized_amount, OrderType.MARKET, 0, 10001,
+        order_id, _ = self.place_order(True, trading_pair, quantized_amount, OrderType.LIMIT, price, 10001,
                                        FixtureHuobi.ORDER_GET_MARKET_BUY)
         [buy_order_completed_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCompletedEvent))
         buy_order_completed_event: BuyOrderCompletedEvent = buy_order_completed_event
@@ -366,7 +300,7 @@ def test_market_buy(self):
         base_amount_traded: Decimal = sum(t.amount for t in trade_events)
         quote_amount_traded: Decimal = sum(t.amount * t.price for t in trade_events)
 
-        self.assertTrue([evt.order_type == OrderType.MARKET for evt in trade_events])
+        self.assertTrue([evt.order_type == OrderType.LIMIT for evt in trade_events])
         self.assertEqual(order_id, buy_order_completed_event.order_id)
         self.assertAlmostEqual(quantized_amount, buy_order_completed_event.base_asset_amount, places=4)
         self.assertEqual("eth", buy_order_completed_event.base_asset)
@@ -381,10 +315,11 @@ def test_market_buy(self):
 
     def test_market_sell(self):
         trading_pair = "ethusdt"
+        price: Decimal = self.market.get_price(trading_pair, False)
         amount: Decimal = Decimal("0.06")
         quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
 
-        order_id, _ = self.place_order(False, trading_pair, amount, OrderType.MARKET, 0, 10001,
+        order_id, _ = self.place_order(False, trading_pair, amount, OrderType.LIMIT, price, 10001,
                                        FixtureHuobi.ORDER_GET_MARKET_SELL)
         [sell_order_completed_event] = self.run_parallel(self.market_logger.wait_for(SellOrderCompletedEvent))
         sell_order_completed_event: SellOrderCompletedEvent = sell_order_completed_event
@@ -393,7 +328,7 @@ def test_market_sell(self):
         base_amount_traded = sum(t.amount for t in trade_events)
         quote_amount_traded = sum(t.amount * t.price for t in trade_events)
 
-        self.assertTrue([evt.order_type == OrderType.MARKET for evt in trade_events])
+        self.assertTrue([evt.order_type == OrderType.LIMIT for evt in trade_events])
         self.assertEqual(order_id, sell_order_completed_event.order_id)
         self.assertAlmostEqual(quantized_amount, sell_order_completed_event.base_asset_amount)
         self.assertEqual("eth", sell_order_completed_event.base_asset)
@@ -416,7 +351,7 @@ def test_cancel_order(self):
         quantize_bid_price: Decimal = self.market.quantize_order_price(trading_pair, bid_price)
         quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
 
-        order_id, exch_order_id = self.place_order(True, trading_pair, quantized_amount, OrderType.LIMIT,
+        order_id, exch_order_id = self.place_order(True, trading_pair, quantized_amount, OrderType.LIMIT_MAKER,
                                                    quantize_bid_price, 10001, FixtureHuobi.ORDER_GET_LIMIT_BUY_UNFILLED)
         [order_created_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCreatedEvent))
 
@@ -437,9 +372,9 @@ def test_cancel_all(self):
         quantize_bid_price: Decimal = self.market_2.quantize_order_price(trading_pair, bid_price * Decimal("0.9"))
         quantize_ask_price: Decimal = self.market_2.quantize_order_price(trading_pair, ask_price * Decimal("1.1"))
 
-        _, exch_order_id1 = self.place_order(True, trading_pair, quantized_amount, OrderType.LIMIT, quantize_bid_price,
+        _, exch_order_id1 = self.place_order(True, trading_pair, quantized_amount, OrderType.LIMIT_MAKER, quantize_bid_price,
                                              1001, FixtureHuobi.ORDER_GET_LIMIT_BUY_UNFILLED, self.market_2)
-        _, exch_order_id2 = self.place_order(False, trading_pair, quantized_amount, OrderType.LIMIT, quantize_ask_price,
+        _, exch_order_id2 = self.place_order(False, trading_pair, quantized_amount, OrderType.LIMIT_MAKER, quantize_ask_price,
                                              1002, FixtureHuobi.ORDER_GET_LIMIT_SELL_UNFILLED, self.market_2)
         self.run_parallel(asyncio.sleep(1))
         if API_MOCK_ENABLED:
@@ -470,7 +405,7 @@ def test_orders_saving_and_restoration(self):
             amount: Decimal = Decimal("0.06")
             quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
 
-            order_id, exch_order_id = self.place_order(True, trading_pair, quantized_amount, OrderType.LIMIT,
+            order_id, exch_order_id = self.place_order(True, trading_pair, quantized_amount, OrderType.LIMIT_MAKER,
                                                        quantize_bid_price, 10001,
                                                        FixtureHuobi.ORDER_GET_LIMIT_BUY_UNFILLED)
             [order_created_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCreatedEvent))
@@ -541,8 +476,9 @@ def test_order_fill_record(self):
 
         try:
             # Try to buy 0.04 ETH from the exchange, and watch for completion event.
+            price: Decimal = self.market.get_price(trading_pair, True)
             amount: Decimal = Decimal("0.06")
-            order_id, _ = self.place_order(True, trading_pair, amount, OrderType.MARKET, 0, 10001,
+            order_id, _ = self.place_order(True, trading_pair, amount, OrderType.LIMIT, price, 10001,
                                            FixtureHuobi.ORDER_GET_MARKET_BUY)
             [buy_order_completed_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCompletedEvent))
 
@@ -550,8 +486,9 @@ def test_order_fill_record(self):
             self.market_logger.clear()
 
             # Try to sell back the same amount of ETH to the exchange, and watch for completion event.
+            price: Decimal = self.market.get_price(trading_pair, False)
             amount = buy_order_completed_event.base_asset_amount
-            order_id, _ = self.place_order(False, trading_pair, amount, OrderType.MARKET, 0, 10002,
+            order_id, _ = self.place_order(False, trading_pair, amount, OrderType.LIMIT, price, 10002,
                                            FixtureHuobi.ORDER_GET_MARKET_SELL)
             [sell_order_completed_event] = self.run_parallel(self.market_logger.wait_for(SellOrderCompletedEvent))
 
diff --git a/test/integration/test_huobi_market_mock.py b/test/integration/test_huobi_market_mock.py
index f811a58c142..8a1185ba696 100644
--- a/test/integration/test_huobi_market_mock.py
+++ b/test/integration/test_huobi_market_mock.py
@@ -162,88 +162,25 @@ def run_parallel(self, *tasks):
 
     def test_get_fee(self):
         self.customSetUp()
-        limit_fee: TradeFee = self.market.get_fee("eth", "usdt", OrderType.LIMIT, TradeType.BUY, 1, 10)
+        limit_fee: TradeFee = self.market.get_fee("eth", "usdt", OrderType.LIMIT_MAKER, TradeType.BUY, 1, 10)
         self.assertGreater(limit_fee.percent, 0)
         self.assertEqual(len(limit_fee.flat_fees), 0)
-        market_fee: TradeFee = self.market.get_fee("eth", "usdt", OrderType.MARKET, TradeType.BUY, 1)
+        market_fee: TradeFee = self.market.get_fee("eth", "usdt", OrderType.LIMIT, TradeType.BUY, 1)
         self.assertGreater(market_fee.percent, 0)
         self.assertEqual(len(market_fee.flat_fees), 0)
-        sell_trade_fee: TradeFee = self.market.get_fee("eth", "usdt", OrderType.LIMIT, TradeType.SELL, 1, 10)
+        sell_trade_fee: TradeFee = self.market.get_fee("eth", "usdt", OrderType.LIMIT_MAKER, TradeType.SELL, 1, 10)
         self.assertGreater(sell_trade_fee.percent, 0)
         self.assertEqual(len(sell_trade_fee.flat_fees), 0)
 
-    def test_limit_buy(self):
-        self.customSetUp()
-        self.mock_api.order_id = self.mock_api.MOCK_HUOBI_LIMIT_BUY_ORDER_ID
-        trading_pair = "ethusdt"
-        amount: Decimal = Decimal(0.02)
-        quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
-        current_bid_price: Decimal = self.market.get_price(trading_pair, True)
-        bid_price: Decimal = current_bid_price + Decimal(0.05) * current_bid_price
-        quantize_bid_price: Decimal = self.market.quantize_order_price(trading_pair, bid_price)
-
-        order_id = self.market.buy(trading_pair, quantized_amount, OrderType.LIMIT, quantize_bid_price)
-
-        [order_completed_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCompletedEvent))
-        order_completed_event: BuyOrderCompletedEvent = order_completed_event
-        trade_events: List[OrderFilledEvent] = [t for t in self.market_logger.event_log
-                                                if isinstance(t, OrderFilledEvent)]
-        base_amount_traded: Decimal = Decimal(sum(t.amount for t in trade_events))
-        quote_amount_traded: Decimal = Decimal(sum(t.amount * t.price for t in trade_events))
-
-        self.assertTrue([evt.order_type == OrderType.LIMIT for evt in trade_events])
-        self.assertEqual(order_id, order_completed_event.order_id)
-        self.assertAlmostEqual(quantized_amount, order_completed_event.base_asset_amount)
-        self.assertEqual("eth", order_completed_event.base_asset)
-        self.assertEqual("usdt", order_completed_event.quote_asset)
-        self.assertAlmostEqual(base_amount_traded, order_completed_event.base_asset_amount)
-        self.assertAlmostEqual(quote_amount_traded, order_completed_event.quote_asset_amount)
-        self.assertGreater(order_completed_event.fee_amount, Decimal(0))
-        self.assertTrue(any([isinstance(event, BuyOrderCreatedEvent) and event.order_id == order_id
-                             for event in self.market_logger.event_log]))
-        # Reset the logs
-        self.market_logger.clear()
-
-    def test_limit_sell(self):
-        self.customSetUp()
-        self.mock_api.order_id = self.mock_api.MOCK_HUOBI_LIMIT_SELL_ORDER_ID
-        trading_pair = "ethusdt"
-        amount: Decimal = Decimal(0.02)
-        quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
-
-        current_ask_price: Decimal = self.market.get_price(trading_pair, False)
-        ask_price: Decimal = current_ask_price - Decimal(0.05) * current_ask_price
-        quantize_ask_price: Decimal = self.market.quantize_order_price(trading_pair, ask_price)
-
-        order_id = self.market.sell(trading_pair, amount, OrderType.LIMIT, quantize_ask_price)
-        [order_completed_event] = self.run_parallel(self.market_logger.wait_for(SellOrderCompletedEvent))
-        order_completed_event: SellOrderCompletedEvent = order_completed_event
-        trade_events: List[OrderFilledEvent] = [t for t in self.market_logger.event_log
-                                                if isinstance(t, OrderFilledEvent)]
-        base_amount_traded = sum(t.amount for t in trade_events)
-        quote_amount_traded = sum(t.amount * t.price for t in trade_events)
-
-        self.assertTrue([evt.order_type == OrderType.LIMIT for evt in trade_events])
-        self.assertEqual(order_id, order_completed_event.order_id)
-        self.assertAlmostEqual(quantized_amount, order_completed_event.base_asset_amount)
-        self.assertEqual("eth", order_completed_event.base_asset)
-        self.assertEqual("usdt", order_completed_event.quote_asset)
-        self.assertAlmostEqual(base_amount_traded, order_completed_event.base_asset_amount)
-        self.assertAlmostEqual(quote_amount_traded, order_completed_event.quote_asset_amount)
-        self.assertGreater(order_completed_event.fee_amount, Decimal(0))
-        self.assertTrue(any([isinstance(event, SellOrderCreatedEvent) and event.order_id == order_id
-                             for event in self.market_logger.event_log]))
-        # Reset the logs
-        self.market_logger.clear()
-
     def test_market_buy(self):
         self.customSetUp()
         self.mock_api.order_id = self.mock_api.MOCK_HUOBI_MARKET_BUY_ORDER_ID
         trading_pair = "ethusdt"
+        price: Decimal = self.market.get_price(trading_pair, True)
         amount: Decimal = Decimal(0.02)
         quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
 
-        order_id = self.market.buy(trading_pair, quantized_amount, OrderType.MARKET, 0)
+        order_id = self.market.buy(trading_pair, quantized_amount, OrderType.LIMIT, price)
         [buy_order_completed_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCompletedEvent))
         buy_order_completed_event: BuyOrderCompletedEvent = buy_order_completed_event
         trade_events: List[OrderFilledEvent] = [t for t in self.market_logger.event_log
@@ -251,7 +188,7 @@ def test_market_buy(self):
         base_amount_traded: Decimal = Decimal(sum(t.amount for t in trade_events))
         quote_amount_traded: Decimal = Decimal(sum(t.amount * t.price for t in trade_events))
 
-        self.assertTrue([evt.order_type == OrderType.MARKET for evt in trade_events])
+        self.assertTrue([evt.order_type == OrderType.LIMIT for evt in trade_events])
         self.assertEqual(order_id, buy_order_completed_event.order_id)
         self.assertAlmostEqual(quantized_amount, buy_order_completed_event.base_asset_amount, places=4)
         self.assertEqual("eth", buy_order_completed_event.base_asset)
@@ -268,10 +205,11 @@ def test_market_sell(self):
         self.customSetUp()
         self.mock_api.order_id = self.mock_api.MOCK_HUOBI_MARKET_SELL_ORDER_ID
         trading_pair = "ethusdt"
+        price: Decimal = self.market.get_price(trading_pair, False)
         amount: Decimal = Decimal(0.02)
         quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
 
-        order_id = self.market.sell(trading_pair, amount, OrderType.MARKET, 0)
+        order_id = self.market.sell(trading_pair, amount, OrderType.LIMIT, price)
         [sell_order_completed_event] = self.run_parallel(self.market_logger.wait_for(SellOrderCompletedEvent))
         sell_order_completed_event: SellOrderCompletedEvent = sell_order_completed_event
         trade_events: List[OrderFilledEvent] = [t for t in self.market_logger.event_log
@@ -279,7 +217,7 @@ def test_market_sell(self):
         base_amount_traded = Decimal(sum(t.amount for t in trade_events))
         quote_amount_traded = Decimal(sum(t.amount * t.price for t in trade_events))
 
-        self.assertTrue([evt.order_type == OrderType.MARKET for evt in trade_events])
+        self.assertTrue([evt.order_type == OrderType.LIMIT for evt in trade_events])
         self.assertEqual(order_id, sell_order_completed_event.order_id)
         self.assertAlmostEqual(quantized_amount, sell_order_completed_event.base_asset_amount)
         self.assertEqual("eth", sell_order_completed_event.base_asset)
@@ -304,7 +242,7 @@ def test_cancel_order(self):
         quantize_bid_price: Decimal = self.market.quantize_order_price(trading_pair, bid_price)
         quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
 
-        client_order_id = self.market.buy(trading_pair, quantized_amount, OrderType.LIMIT, quantize_bid_price)
+        client_order_id = self.market.buy(trading_pair, quantized_amount, OrderType.LIMIT_MAKER, quantize_bid_price)
         [order_created_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCreatedEvent))
         self.market.cancel(trading_pair, client_order_id)
         self.mock_api.order_response_dict[self.mock_api.MOCK_HUOBI_LIMIT_CANCEL_ORDER_ID]["data"]["state"] = "canceled"
@@ -329,9 +267,9 @@ def test_cancel_all(self):
         quantize_bid_price: Decimal = self.market.quantize_order_price(trading_pair, bid_price * Decimal(0.7))
         quantize_ask_price: Decimal = self.market.quantize_order_price(trading_pair, ask_price * Decimal(1.5))
         self.mock_api.order_id = self.mock_api.MOCK_HUOBI_LIMIT_BUY_ORDER_ID
-        self.market.buy(trading_pair, quantized_amount, OrderType.LIMIT, quantize_bid_price)
+        self.market.buy(trading_pair, quantized_amount, OrderType.LIMIT_MAKER, quantize_bid_price)
         self.mock_api.order_id = self.mock_api.MOCK_HUOBI_LIMIT_SELL_ORDER_ID
-        self.market.sell(trading_pair, quantized_amount, OrderType.LIMIT, quantize_ask_price)
+        self.market.sell(trading_pair, quantized_amount, OrderType.LIMIT_MAKER, quantize_ask_price)
         self.run_parallel(asyncio.sleep(1))
         [cancellation_results] = self.run_parallel(self.market.cancel_all(5))
         for cr in cancellation_results:
@@ -359,7 +297,7 @@ def test_orders_saving_and_restoration(self):
             quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
 
             self.mock_api.order_id = self.mock_api.MOCK_HUOBI_LIMIT_OPEN_ORDER_ID
-            order_id = self.market.buy(trading_pair, quantized_amount, OrderType.LIMIT, quantize_bid_price)
+            order_id = self.market.buy(trading_pair, quantized_amount, OrderType.LIMIT_MAKER, quantize_bid_price)
             [order_created_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCreatedEvent))
             order_created_event: BuyOrderCreatedEvent = order_created_event
             self.assertEqual(order_id, order_created_event.order_id)
diff --git a/test/integration/test_kraken_market.py b/test/integration/test_kraken_market.py
index c41c339ce5b..7857281980d 100644
--- a/test/integration/test_kraken_market.py
+++ b/test/integration/test_kraken_market.py
@@ -136,57 +136,48 @@ def sleep(self, t=1.0):
         self.run_parallel(asyncio.sleep(t))
 
     def test_get_fee(self):
-        limit_fee: TradeFee = self.market.get_fee(BASE, QUOTE, OrderType.LIMIT, TradeType.BUY, 1, 1)
+        limit_fee: TradeFee = self.market.get_fee(BASE, QUOTE, OrderType.LIMIT_MAKER, TradeType.BUY, 1, 1)
         self.assertGreater(limit_fee.percent, 0)
         self.assertEqual(len(limit_fee.flat_fees), 0)
-        market_fee: TradeFee = self.market.get_fee(BASE, QUOTE, OrderType.MARKET, TradeType.BUY, 1)
+        market_fee: TradeFee = self.market.get_fee(BASE, QUOTE, OrderType.LIMIT, TradeType.BUY, 1)
         self.assertGreater(market_fee.percent, 0)
         self.assertEqual(len(market_fee.flat_fees), 0)
 
     def test_fee_overrides_config(self):
         fee_overrides_config_map["kraken_taker_fee"].value = None
-        taker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.MARKET, TradeType.BUY, Decimal(1),
+        taker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.LIMIT, TradeType.BUY, Decimal(1),
                                                   Decimal('0.1'))
         self.assertAlmostEqual(Decimal("0.0026"), taker_fee.percent)
         fee_overrides_config_map["kraken_taker_fee"].value = Decimal('0.2')
-        taker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.MARKET, TradeType.BUY, Decimal(1),
+        taker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.LIMIT, TradeType.BUY, Decimal(1),
                                                   Decimal('0.1'))
         self.assertAlmostEqual(Decimal("0.002"), taker_fee.percent)
         fee_overrides_config_map["kraken_maker_fee"].value = None
-        maker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.LIMIT, TradeType.BUY, Decimal(1),
+        maker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.LIMIT_MAKER, TradeType.BUY, Decimal(1),
                                                   Decimal('0.1'))
         self.assertAlmostEqual(Decimal("0.0016"), maker_fee.percent)
         fee_overrides_config_map["kraken_maker_fee"].value = Decimal('0.5')
-        maker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.LIMIT, TradeType.BUY, Decimal(1),
+        maker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.LIMIT_MAKER, TradeType.BUY, Decimal(1),
                                                   Decimal('0.1'))
         self.assertAlmostEqual(Decimal("0.005"), maker_fee.percent)
 
     def place_order(self, is_buy, trading_pair, amount, order_type, price):
         order_id = None
         if is_buy:
-            if order_type is OrderType.LIMIT:
-                order_id = self.market.buy(trading_pair, amount, order_type, price)
-            else:
-                order_id = self.market.buy(trading_pair, amount)
+            order_id = self.market.buy(trading_pair, amount, order_type, price)
         else:
-            if order_type is OrderType.LIMIT:
-                order_id = self.market.sell(trading_pair, amount, order_type, price)
-            else:
-                order_id = self.market.sell(trading_pair, amount)
+            order_id = self.market.sell(trading_pair, amount, order_type, price)
         return order_id
 
     def cancel_order(self, trading_pair, order_id):
         self.market.cancel(trading_pair, order_id)
 
-    def test_limit_buy(self):
+    def test_market_buy(self):
         self.assertGreater(self.market.get_balance(QUOTE), 6)
         trading_pair = PAIR
 
         self.sleep(3)
-        current_bid_price: Decimal = self.market.get_price(trading_pair, True)
-        bid_price: Decimal = current_bid_price * Decimal('1.005')
-        quantized_bid_price: Decimal = self.market.quantize_order_price(trading_pair, bid_price)
-
+        price: Decimal = self.market.get_price(trading_pair, True)
         amount: Decimal = Decimal("0.02")
         quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
 
@@ -195,7 +186,7 @@ def test_limit_buy(self):
             trading_pair,
             quantized_amount,
             OrderType.LIMIT,
-            quantized_bid_price
+            price
         )
         [order_completed_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCompletedEvent))
         order_completed_event: BuyOrderCompletedEvent = order_completed_event
@@ -216,82 +207,12 @@ def test_limit_buy(self):
         # Reset the logs
         self.market_logger.clear()
 
-    def test_limit_sell(self):
-        self.assertGreater(self.market.get_balance(BASE), 0.02)
-        trading_pair = PAIR
-
-        current_ask_price: Decimal = self.market.get_price(trading_pair, False)
-        ask_price: Decimal = current_ask_price - Decimal('0.005') * current_ask_price
-        quantized_ask_price: Decimal = self.market.quantize_order_price(trading_pair, ask_price)
-
-        amount: Decimal = Decimal("0.02")
-        quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
-
-        order_id = self.place_order(
-            False,
-            trading_pair,
-            quantized_amount,
-            OrderType.LIMIT,
-            quantized_ask_price
-        )
-
-        [order_completed_event] = self.run_parallel(self.market_logger.wait_for(SellOrderCompletedEvent))
-        order_completed_event: SellOrderCompletedEvent = order_completed_event
-        trade_events = [t for t in self.market_logger.event_log if isinstance(t, OrderFilledEvent) and t.amount is not None]
-        base_amount_traded = sum(t.amount for t in trade_events)
-        quote_amount_traded = sum(t.amount * t.price for t in trade_events)
-
-        self.assertTrue([evt.order_type == OrderType.LIMIT for evt in trade_events])
-        self.assertEqual(order_id, order_completed_event.order_id)
-        self.assertAlmostEqual(quantized_amount, order_completed_event.base_asset_amount)
-        self.assertEqual(BASE, order_completed_event.base_asset)
-        self.assertEqual(QUOTE, order_completed_event.quote_asset)
-        self.assertAlmostEqual(base_amount_traded, order_completed_event.base_asset_amount)
-        self.assertAlmostEqual(quote_amount_traded, order_completed_event.quote_asset_amount)
-        self.assertTrue(any([isinstance(event, SellOrderCreatedEvent) and event.order_id == order_id
-                             for event in self.market_logger.event_log]))
-        # Reset the logs
-        self.market_logger.clear()
-
-    def test_market_buy(self):
-        self.assertGreater(self.market.get_balance(QUOTE), 6)
-        trading_pair = PAIR
-
-        self.sleep(3)
-        amount: Decimal = Decimal("0.02")
-        quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
-
-        order_id = self.place_order(
-            True,
-            trading_pair,
-            quantized_amount,
-            OrderType.MARKET,
-            Decimal("nan")
-        )
-        [order_completed_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCompletedEvent))
-        order_completed_event: BuyOrderCompletedEvent = order_completed_event
-        trade_events: List[OrderFilledEvent] = [t for t in self.market_logger.event_log
-                                                if isinstance(t, OrderFilledEvent) and t.amount is not None]
-        base_amount_traded: Decimal = sum(t.amount for t in trade_events)
-        quote_amount_traded: Decimal = sum(t.amount * t.price for t in trade_events)
-
-        self.assertTrue([evt.order_type == OrderType.MARKET for evt in trade_events])
-        self.assertEqual(order_id, order_completed_event.order_id)
-        self.assertAlmostEqual(quantized_amount, order_completed_event.base_asset_amount)
-        self.assertEqual(BASE, order_completed_event.base_asset)
-        self.assertEqual(QUOTE, order_completed_event.quote_asset)
-        self.assertAlmostEqual(base_amount_traded, order_completed_event.base_asset_amount)
-        self.assertAlmostEqual(quote_amount_traded, order_completed_event.quote_asset_amount)
-        self.assertTrue(any([isinstance(event, BuyOrderCreatedEvent) and event.order_id == order_id
-                             for event in self.market_logger.event_log]))
-        # Reset the logs
-        self.market_logger.clear()
-
     def test_market_sell(self):
         self.assertGreater(self.market.get_balance(BASE), 0.02)
         trading_pair = PAIR
 
         self.sleep(3)
+        price: Decimal = self.market.get_price(trading_pair, False)
         amount: Decimal = Decimal("0.02")
         quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
 
@@ -299,8 +220,8 @@ def test_market_sell(self):
             False,
             trading_pair,
             quantized_amount,
-            OrderType.MARKET,
-            Decimal("nan")
+            OrderType.LIMIT,
+            price
         )
         [order_completed_event] = self.run_parallel(self.market_logger.wait_for(SellOrderCompletedEvent))
         order_completed_event: SellOrderCompletedEvent = order_completed_event
@@ -309,7 +230,7 @@ def test_market_sell(self):
         base_amount_traded: Decimal = sum(t.amount for t in trade_events)
         quote_amount_traded: Decimal = sum(t.amount * t.price for t in trade_events)
 
-        self.assertTrue([evt.order_type == OrderType.MARKET for evt in trade_events])
+        self.assertTrue([evt.order_type == OrderType.LIMIT for evt in trade_events])
         self.assertEqual(order_id, order_completed_event.order_id)
         self.assertAlmostEqual(quantized_amount, order_completed_event.base_asset_amount)
         self.assertEqual(BASE, order_completed_event.base_asset)
@@ -336,7 +257,7 @@ def underpriced_limit_buy(self):
             True,
             trading_pair,
             quantized_amount,
-            OrderType.LIMIT,
+            OrderType.LIMIT_MAKER,
             quantized_bid_price
         )
 
@@ -446,14 +367,15 @@ def test_order_fill_record(self):
 
         try:
             # Try to buy 0.02 ETH from the exchange, and watch for completion event.
+            price: Decimal = self.market.get_price(PAIR, True)
             amount: Decimal = Decimal("0.02")
             quantized_amount: Decimal = self.market.quantize_order_amount(PAIR, amount)
             order_id = self.place_order(
                 True,
                 PAIR,
                 quantized_amount,
-                OrderType.MARKET,
-                Decimal("nan")
+                OrderType.LIMIT,
+                price
             )
             [buy_order_completed_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCompletedEvent))
 
@@ -461,14 +383,15 @@ def test_order_fill_record(self):
             self.market_logger.clear()
 
             # Try to sell back the same amount of ETH to the exchange, and watch for completion event.
+            price: Decimal = self.market.get_price(PAIR, False)
             amount = buy_order_completed_event.base_asset_amount
             quantized_amount: Decimal = self.market.quantize_order_amount(PAIR, amount)
             order_id = self.place_order(
                 False,
                 PAIR,
                 quantized_amount,
-                OrderType.MARKET,
-                Decimal("nan")
+                OrderType.LIMIT,
+                price
             )
             [sell_order_completed_event] = self.run_parallel(self.market_logger.wait_for(SellOrderCompletedEvent))
 
diff --git a/test/integration/test_kucoin_market.py b/test/integration/test_kucoin_market.py
index 5e0f49c06b5..a3cc6625622 100644
--- a/test/integration/test_kucoin_market.py
+++ b/test/integration/test_kucoin_market.py
@@ -170,13 +170,13 @@ def run_parallel(self, *tasks):
         return self.ev_loop.run_until_complete(self.run_parallel_async(*tasks))
 
     def test_get_fee(self):
-        limit_fee: TradeFee = self.market.get_fee("ETH", "USDT", OrderType.LIMIT, TradeType.BUY, 1, 10)
+        limit_fee: TradeFee = self.market.get_fee("ETH", "USDT", OrderType.LIMIT_MAKER, TradeType.BUY, 1, 10)
         self.assertGreater(limit_fee.percent, 0)
         self.assertEqual(len(limit_fee.flat_fees), 0)
-        market_fee: TradeFee = self.market.get_fee("ETH", "USDT", OrderType.MARKET, TradeType.BUY, 1)
+        market_fee: TradeFee = self.market.get_fee("ETH", "USDT", OrderType.LIMIT, TradeType.BUY, 1)
         self.assertGreater(market_fee.percent, 0)
         self.assertEqual(len(market_fee.flat_fees), 0)
-        sell_trade_fee: TradeFee = self.market.get_fee("ETH", "USDT", OrderType.LIMIT, TradeType.SELL, 1, 10)
+        sell_trade_fee: TradeFee = self.market.get_fee("ETH", "USDT", OrderType.LIMIT_MAKER, TradeType.SELL, 1, 10)
         self.assertGreater(sell_trade_fee.percent, 0)
         self.assertEqual(len(sell_trade_fee.flat_fees), 0)
 
@@ -207,83 +207,22 @@ def place_order(self, is_buy, trading_pair, amount, order_type, price, nonce, po
 
     def test_fee_overrides_config(self):
         fee_overrides_config_map["kucoin_taker_fee"].value = None
-        taker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.MARKET, TradeType.BUY, Decimal(1),
+        taker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.LIMIT, TradeType.BUY, Decimal(1),
                                                   Decimal('0.1'))
         self.assertAlmostEqual(Decimal("0.001"), taker_fee.percent)
         fee_overrides_config_map["kucoin_taker_fee"].value = Decimal('0.2')
-        taker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.MARKET, TradeType.BUY, Decimal(1),
+        taker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.LIMIT, TradeType.BUY, Decimal(1),
                                                   Decimal('0.1'))
         self.assertAlmostEqual(Decimal("0.002"), taker_fee.percent)
         fee_overrides_config_map["kucoin_maker_fee"].value = None
-        maker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.LIMIT, TradeType.BUY, Decimal(1),
+        maker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.LIMIT_MAKER, TradeType.BUY, Decimal(1),
                                                   Decimal('0.1'))
         self.assertAlmostEqual(Decimal("0.001"), maker_fee.percent)
         fee_overrides_config_map["kucoin_maker_fee"].value = Decimal('0.5')
-        maker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.LIMIT, TradeType.BUY, Decimal(1),
+        maker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.LIMIT_MAKER, TradeType.BUY, Decimal(1),
                                                   Decimal('0.1'))
         self.assertAlmostEqual(Decimal("0.005"), maker_fee.percent)
 
-    def test_limit_buy(self):
-        trading_pair = "ETH-USDT"
-        amount: Decimal = Decimal(0.01)
-        quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
-
-        current_bid_price: float = self.market.get_price(trading_pair, True)
-        bid_price: Decimal = Decimal(current_bid_price + Decimal(0.05) * current_bid_price)
-        quantize_bid_price: Decimal = self.market.quantize_order_price(trading_pair, bid_price)
-        order_id, _ = self.place_order(True, trading_pair, quantized_amount, OrderType.LIMIT, quantize_bid_price, 10001,
-                                       FixtureKucoin.ORDER_PLACE_2, FixtureKucoin.ORDER_GET_AFTER_BUY)
-        [order_completed_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCompletedEvent))
-        order_completed_event: BuyOrderCompletedEvent = order_completed_event
-        trade_events: List[OrderFilledEvent] = [t for t in self.market_logger.event_log
-                                                if isinstance(t, OrderFilledEvent)]
-        base_amount_traded: float = sum(t.amount for t in trade_events)
-        quote_amount_traded: float = sum(t.amount * t.price for t in trade_events)
-
-        self.assertTrue([evt.order_type == OrderType.LIMIT for evt in trade_events])
-        self.assertEqual(order_id, order_completed_event.order_id)
-        self.assertAlmostEqual(float(quantized_amount), order_completed_event.base_asset_amount)
-        self.assertEqual("ETH", order_completed_event.base_asset)
-        self.assertEqual("USDT", order_completed_event.quote_asset)
-        self.assertAlmostEqual(base_amount_traded, float(order_completed_event.base_asset_amount))
-        self.assertAlmostEqual(quote_amount_traded, float(order_completed_event.quote_asset_amount))
-        self.assertGreater(order_completed_event.fee_amount, Decimal(0))
-        self.assertTrue(any([isinstance(event, BuyOrderCreatedEvent) and event.order_id == order_id
-                             for event in self.market_logger.event_log]))
-        # Reset the logs
-        self.market_logger.clear()
-
-    def test_limit_sell(self):
-        trading_pair = "ETH-USDT"
-        amount: Decimal = Decimal(0.01)
-        quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
-
-        current_ask_price: float = self.market.get_price(trading_pair, False)
-        ask_price: Decimal = Decimal(current_ask_price - Decimal(0.05) * current_ask_price)
-        quantize_ask_price: Decimal = self.market.quantize_order_price(trading_pair, ask_price)
-
-        order_id, _ = self.place_order(False, trading_pair, amount, OrderType.LIMIT, quantize_ask_price, 10001,
-                                       FixtureKucoin.ORDER_PLACE, FixtureKucoin.ORDER_GET_AFTER_SELL)
-        [order_completed_event] = self.run_parallel(self.market_logger.wait_for(SellOrderCompletedEvent))
-        order_completed_event: SellOrderCompletedEvent = order_completed_event
-        trade_events: List[OrderFilledEvent] = [t for t in self.market_logger.event_log
-                                                if isinstance(t, OrderFilledEvent)]
-        base_amount_traded = sum(t.amount for t in trade_events)
-        quote_amount_traded = sum(t.amount * t.price for t in trade_events)
-
-        self.assertTrue([evt.order_type == OrderType.LIMIT for evt in trade_events])
-        self.assertEqual(order_id, order_completed_event.order_id)
-        self.assertAlmostEqual(float(quantized_amount), order_completed_event.base_asset_amount)
-        self.assertEqual("ETH", order_completed_event.base_asset)
-        self.assertEqual("USDT", order_completed_event.quote_asset)
-        self.assertAlmostEqual(base_amount_traded, float(order_completed_event.base_asset_amount))
-        self.assertAlmostEqual(quote_amount_traded, float(order_completed_event.quote_asset_amount))
-        self.assertGreater(order_completed_event.fee_amount, Decimal(0))
-        self.assertTrue(any([isinstance(event, SellOrderCreatedEvent) and event.order_id == order_id
-                             for event in self.market_logger.event_log]))
-        # Reset the logs
-        self.market_logger.clear()
-
     def test_limit_maker_rejections(self):
         trading_pair = "ETH-USDT"
 
@@ -292,9 +231,7 @@ def test_limit_maker_rejections(self):
         price: Decimal = self.market.quantize_order_price(trading_pair, price)
         amount = self.market.quantize_order_amount(trading_pair, Decimal(0.01))
 
-        order_id = self.place_order(True, trading_pair, amount, OrderType.LIMIT_MAKER,
-                                    price, 10001,
-                                    FixtureKucoin.LIMIT_MAKER_ERROR, FixtureKucoin.EMPTY)
+        order_id = self.market.buy(trading_pair, amount, OrderType.LIMIT_MAKER, price)
         [order_failure_event] = self.run_parallel(self.market_logger.wait_for(MarketOrderFailureEvent))
         self.assertEqual(order_id, order_failure_event.order_id)
 
@@ -305,9 +242,7 @@ def test_limit_maker_rejections(self):
         price: Decimal = self.market.quantize_order_price(trading_pair, price)
         amount = self.market.quantize_order_amount(trading_pair, Decimal(0.01))
 
-        order_id = self.place_order(False, trading_pair, amount, OrderType.LIMIT_MAKER,
-                                    price, 10002,
-                                    FixtureKucoin.LIMIT_MAKER_ERROR, FixtureKucoin.EMPTY)
+        order_id = self.market.sell(trading_pair, amount, OrderType.LIMIT_MAKER, price)
         [order_failure_event] = self.run_parallel(self.market_logger.wait_for(MarketOrderFailureEvent))
         self.assertEqual(order_id, order_failure_event.order_id)
 
@@ -317,9 +252,9 @@ def test_limit_makers_unfilled(self):
         price = self.market.quantize_order_price(trading_pair, price)
         amount = self.market.quantize_order_amount(trading_pair, Decimal(0.01))
 
-        order_id = self.place_order(True, trading_pair, amount, OrderType.LIMIT_MAKER,
-                                    price, 10001,
-                                    FixtureKucoin.ORDER_PLACE, FixtureKucoin.ORDER_GET_BUY_UNMATCHED)
+        order_id, _ = self.place_order(True, trading_pair, amount, OrderType.LIMIT_MAKER,
+                                       price, 10001,
+                                       FixtureKucoin.ORDER_PLACE, FixtureKucoin.ORDER_GET_BUY_UNMATCHED)
         [order_created_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCreatedEvent))
         order_created_event: BuyOrderCreatedEvent = order_created_event
         self.assertEqual(order_id, order_created_event.order_id)
@@ -328,9 +263,9 @@ def test_limit_makers_unfilled(self):
         price = self.market.quantize_order_price(trading_pair, price)
         amount = self.market.quantize_order_amount(trading_pair, Decimal(0.01))
 
-        order_id = self.place_order(False, trading_pair, amount, OrderType.LIMIT_MAKER,
-                                    price, 10002,
-                                    FixtureKucoin.ORDER_PLACE, FixtureKucoin.ORDER_GET_SELL_UNMATCHED)
+        order_id, _ = self.place_order(False, trading_pair, amount, OrderType.LIMIT_MAKER,
+                                       price, 10002,
+                                       FixtureKucoin.ORDER_PLACE, FixtureKucoin.ORDER_GET_SELL_UNMATCHED)
         [order_created_event] = self.run_parallel(self.market_logger.wait_for(SellOrderCreatedEvent))
         order_created_event: BuyOrderCreatedEvent = order_created_event
         self.assertEqual(order_id, order_created_event.order_id)
@@ -342,10 +277,11 @@ def test_limit_makers_unfilled(self):
     def test_market_buy(self):
         self.assertGreater(self.market.get_balance("ETH"), Decimal("0.05"))
         trading_pair = "ETH-USDT"
+        price: Decimal = self.market.get_price(trading_pair, True)
         amount: Decimal = Decimal(0.01)
         quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
 
-        order_id, _ = self.place_order(True, trading_pair, quantized_amount, OrderType.MARKET, 0, 10001,
+        order_id, _ = self.place_order(True, trading_pair, quantized_amount, OrderType.LIMIT, price, 10001,
                                        FixtureKucoin.ORDER_PLACE, FixtureKucoin.ORDER_GET_MARKET_BUY)
         [buy_order_completed_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCompletedEvent))
         buy_order_completed_event: BuyOrderCompletedEvent = buy_order_completed_event
@@ -354,7 +290,7 @@ def test_market_buy(self):
         base_amount_traded: float = sum(t.amount for t in trade_events)
         quote_amount_traded: float = sum(t.amount * t.price for t in trade_events)
 
-        self.assertTrue([evt.order_type == OrderType.MARKET for evt in trade_events])
+        self.assertTrue([evt.order_type == OrderType.LIMIT for evt in trade_events])
         self.assertEqual(order_id, buy_order_completed_event.order_id)
         self.assertAlmostEqual(float(quantized_amount), buy_order_completed_event.base_asset_amount, places=4)
         self.assertEqual("ETH", buy_order_completed_event.base_asset)
@@ -370,9 +306,10 @@ def test_market_buy(self):
     def test_market_sell(self):
         self.assertGreater(self.market.get_balance("ETH"), Decimal("0.05"))
         trading_pair = "ETH-USDT"
+        price: Decimal = self.market.get_price(trading_pair, False)
         amount: Decimal = Decimal(0.011)
         quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
-        order_id, _ = self.place_order(False, trading_pair, amount, OrderType.MARKET, 0, 10001,
+        order_id, _ = self.place_order(False, trading_pair, amount, OrderType.LIMIT, price, 10001,
                                        FixtureKucoin.ORDER_PLACE, FixtureKucoin.ORDER_GET_MARKET_SELL)
         [sell_order_completed_event] = self.run_parallel(self.market_logger.wait_for(SellOrderCompletedEvent))
         sell_order_completed_event: SellOrderCompletedEvent = sell_order_completed_event
@@ -381,7 +318,7 @@ def test_market_sell(self):
         base_amount_traded = sum(t.amount for t in trade_events)
         quote_amount_traded = sum(t.amount * t.price for t in trade_events)
 
-        self.assertTrue([evt.order_type == OrderType.MARKET for evt in trade_events])
+        self.assertTrue([evt.order_type == OrderType.LIMIT for evt in trade_events])
         self.assertEqual(order_id, sell_order_completed_event.order_id)
         self.assertAlmostEqual(float(quantized_amount), sell_order_completed_event.base_asset_amount)
         self.assertEqual("ETH", sell_order_completed_event.base_asset)
@@ -404,7 +341,7 @@ def test_cancel(self):
         quantized_price: Decimal = self.market.quantize_order_price(trading_pair, price)
         quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
 
-        order_id, exch_order_id = self.place_order(False, trading_pair, quantized_amount, OrderType.LIMIT,
+        order_id, exch_order_id = self.place_order(False, trading_pair, quantized_amount, OrderType.LIMIT_MAKER,
                                                    quantized_price, 10001,
                                                    FixtureKucoin.ORDER_PLACE_2, FixtureKucoin.ORDER_GET_SELL_UNMATCHED)
         [order_created_event] = self.run_parallel(self.market_logger.wait_for(SellOrderCreatedEvent))
@@ -435,10 +372,10 @@ def test_cancel_all(self):
         quantize_bid_price: Decimal = self.market_2.quantize_order_price(trading_pair, bid_price * Decimal(0.8))
         quantize_ask_price: Decimal = self.market_2.quantize_order_price(trading_pair, ask_price * Decimal(1.2))
 
-        _, exch_order_id = self.place_order(True, trading_pair, quantized_amount, OrderType.LIMIT, quantize_bid_price,
+        _, exch_order_id = self.place_order(True, trading_pair, quantized_amount, OrderType.LIMIT_MAKER, quantize_bid_price,
                                             10001, FixtureKucoin.ORDER_PLACE, FixtureKucoin.ORDER_GET_BUY_UNMATCHED)
 
-        _, exch_order_id2 = self.place_order(False, trading_pair, quantized_amount, OrderType.LIMIT, quantize_ask_price,
+        _, exch_order_id2 = self.place_order(False, trading_pair, quantized_amount, OrderType.LIMIT_MAKER, quantize_ask_price,
                                              10002, FixtureKucoin.ORDER_PLACE, FixtureKucoin.ORDER_GET_SELL_UNMATCHED)
 
         self.run_parallel(asyncio.sleep(1))
@@ -471,7 +408,7 @@ def test_orders_saving_and_restoration(self):
             amount: Decimal = Decimal(0.04)
             quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
 
-            order_id, exch_order_id = self.place_order(True, trading_pair, quantized_amount, OrderType.LIMIT,
+            order_id, exch_order_id = self.place_order(True, trading_pair, quantized_amount, OrderType.LIMIT_MAKER,
                                                        quantize_bid_price,
                                                        10001, FixtureKucoin.ORDER_PLACE,
                                                        FixtureKucoin.ORDER_GET_BUY_UNMATCHED)
@@ -554,8 +491,9 @@ def test_order_fill_record(self):
 
         try:
             # Try to buy 0.01 ETH from the exchange, and watch for completion event.
+            price: Decimal = self.market.get_price(trading_pair, True)
             amount: Decimal = Decimal(0.01)
-            order_id, _ = self.place_order(True, trading_pair, amount, OrderType.MARKET, 0, 10001,
+            order_id, _ = self.place_order(True, trading_pair, amount, OrderType.LIMIT, price, 10001,
                                            FixtureKucoin.ORDER_PLACE, FixtureKucoin.ORDER_GET_MARKET_BUY)
             [buy_order_completed_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCompletedEvent))
 
@@ -563,8 +501,9 @@ def test_order_fill_record(self):
             self.market_logger.clear()
 
             # Try to sell back the same amount of ETH to the exchange, and watch for completion event.
+            price: Decimal = self.market.get_price(trading_pair, False)
             amount: Decimal = Decimal(buy_order_completed_event.base_asset_amount)
-            order_id, _ = self.place_order(False, trading_pair, amount, OrderType.MARKET, 0, 10002,
+            order_id, _ = self.place_order(False, trading_pair, amount, OrderType.LIMIT, price, 10002,
                                            FixtureKucoin.ORDER_PLACE, FixtureKucoin.ORDER_GET_MARKET_SELL)
             [sell_order_completed_event] = self.run_parallel(self.market_logger.wait_for(SellOrderCompletedEvent))
 
diff --git a/test/integration/test_liquid_market.py b/test/integration/test_liquid_market.py
index 9987435fd7e..830ae88d834 100644
--- a/test/integration/test_liquid_market.py
+++ b/test/integration/test_liquid_market.py
@@ -160,33 +160,33 @@ def run_parallel(self, *tasks):
         return self.ev_loop.run_until_complete(self.run_parallel_async(*tasks))
 
     def test_get_fee(self):
-        maker_buy_trade_fee: TradeFee = self.market.get_fee("BTC", "USD", OrderType.LIMIT, TradeType.BUY, Decimal(1),
+        maker_buy_trade_fee: TradeFee = self.market.get_fee("BTC", "USD", OrderType.LIMIT_MAKER, TradeType.BUY, Decimal(1),
                                                             Decimal(4000))
         self.assertGreater(maker_buy_trade_fee.percent, 0)
         self.assertEqual(len(maker_buy_trade_fee.flat_fees), 0)
-        taker_buy_trade_fee: TradeFee = self.market.get_fee("BTC", "USD", OrderType.MARKET, TradeType.BUY, Decimal(1))
+        taker_buy_trade_fee: TradeFee = self.market.get_fee("BTC", "USD", OrderType.LIMIT, TradeType.BUY, Decimal(1))
         self.assertGreater(taker_buy_trade_fee.percent, 0)
         self.assertEqual(len(taker_buy_trade_fee.flat_fees), 0)
-        sell_trade_fee: TradeFee = self.market.get_fee("BTC", "USD", OrderType.LIMIT, TradeType.SELL, Decimal(1),
+        sell_trade_fee: TradeFee = self.market.get_fee("BTC", "USD", OrderType.LIMIT_MAKER, TradeType.SELL, Decimal(1),
                                                        Decimal(4000))
         self.assertGreater(sell_trade_fee.percent, 0)
         self.assertEqual(len(sell_trade_fee.flat_fees), 0)
 
     def test_fee_overrides_config(self):
         fee_overrides_config_map["liquid_taker_fee"].value = None
-        taker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.MARKET, TradeType.BUY, Decimal(1),
+        taker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.LIMIT, TradeType.BUY, Decimal(1),
                                                   Decimal('0.1'))
         self.assertAlmostEqual(Decimal("0.001"), taker_fee.percent)
         fee_overrides_config_map["liquid_taker_fee"].value = Decimal('0.2')
-        taker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.MARKET, TradeType.BUY, Decimal(1),
+        taker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.LIMIT, TradeType.BUY, Decimal(1),
                                                   Decimal('0.1'))
         self.assertAlmostEqual(Decimal("0.002"), taker_fee.percent)
         fee_overrides_config_map["liquid_maker_fee"].value = None
-        maker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.LIMIT, TradeType.BUY, Decimal(1),
+        maker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.LIMIT_MAKER, TradeType.BUY, Decimal(1),
                                                   Decimal('0.1'))
         self.assertAlmostEqual(Decimal("0.001"), maker_fee.percent)
         fee_overrides_config_map["liquid_maker_fee"].value = Decimal('0.5')
-        maker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.LIMIT, TradeType.BUY, Decimal(1),
+        maker_fee: TradeFee = self.market.get_fee("LINK", "ETH", OrderType.LIMIT_MAKER, TradeType.BUY, Decimal(1),
                                                   Decimal('0.1'))
         self.assertAlmostEqual(Decimal("0.005"), maker_fee.percent)
 
@@ -217,7 +217,7 @@ def test_buy_and_sell(self):
         amount: Decimal = 1
         quantized_amount: Decimal = self.market.quantize_order_amount("CEL-ETH", amount)
 
-        order_id, _ = self.place_order(True, "CEL-ETH", amount, OrderType.MARKET, current_price, 10001,
+        order_id, _ = self.place_order(True, "CEL-ETH", amount, OrderType.LIMIT, current_price, 10001,
                                        FixtureLiquid.ORDER_BUY, FixtureLiquid.ORDERS_GET_AFTER_BUY)
         [order_completed_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCompletedEvent))
         order_completed_event: BuyOrderCompletedEvent = order_completed_event
@@ -226,7 +226,7 @@ def test_buy_and_sell(self):
         base_amount_traded: Decimal = sum(t.amount for t in trade_events)
         quote_amount_traded: Decimal = sum(t.amount * t.price for t in trade_events)
 
-        self.assertTrue([evt.order_type == OrderType.MARKET for evt in trade_events])
+        self.assertTrue([evt.order_type == OrderType.LIMIT for evt in trade_events])
         self.assertEqual(order_id, order_completed_event.order_id)
         self.assertEqual(quantized_amount, order_completed_event.base_asset_amount)
         self.assertEqual("CEL", order_completed_event.base_asset)
@@ -243,7 +243,7 @@ def test_buy_and_sell(self):
         # Try to sell back the same amount of CEL to the exchange, and watch for completion event.
         amount = order_completed_event.base_asset_amount
         quantized_amount = order_completed_event.base_asset_amount
-        order_id, _ = self.place_order(False, "CEL-ETH", amount, OrderType.MARKET, current_price, 10002,
+        order_id, _ = self.place_order(False, "CEL-ETH", amount, OrderType.LIMIT, current_price, 10002,
                                        FixtureLiquid.ORDER_SELL, FixtureLiquid.ORDERS_GET_AFTER_SELL)
         [order_completed_event] = self.run_parallel(self.market_logger.wait_for(SellOrderCompletedEvent))
         order_completed_event: SellOrderCompletedEvent = order_completed_event
@@ -252,68 +252,6 @@ def test_buy_and_sell(self):
         base_amount_traded = sum(t.amount for t in trade_events)
         quote_amount_traded = sum(t.amount * t.price for t in trade_events)
 
-        self.assertTrue([evt.order_type == OrderType.MARKET for evt in trade_events])
-        self.assertEqual(order_id, order_completed_event.order_id)
-        self.assertEqual(quantized_amount, order_completed_event.base_asset_amount)
-        self.assertEqual("CEL", order_completed_event.base_asset)
-        self.assertEqual("ETH", order_completed_event.quote_asset)
-        self.assertAlmostEqual(base_amount_traded, order_completed_event.base_asset_amount)
-        self.assertAlmostEqual(quote_amount_traded, order_completed_event.quote_asset_amount)
-        self.assertGreater(order_completed_event.fee_amount, Decimal(0))
-        self.assertTrue(any([isinstance(event, SellOrderCreatedEvent) and event.order_id == order_id
-                             for event in self.market_logger.event_log]))
-
-    def test_limit_buy_and_sell(self):
-        self.assertGreater(self.market.get_balance("ETH"), Decimal("0.001"))
-
-        # Try to put limit buy order for 0.05 ETH worth of CEL, and watch for completion event.
-        current_bid_price: Decimal = self.market.get_price("CEL-ETH", True)
-        bid_price: Decimal = current_bid_price + Decimal("0.05") * current_bid_price
-        quantize_bid_price: Decimal = self.market.quantize_order_price("CEL-ETH", bid_price)
-
-        amount: Decimal = 1
-        quantized_amount: Decimal = self.market.quantize_order_amount("CEL-ETH", amount)
-
-        order_id, _ = self.place_order(True, "CEL-ETH", quantized_amount, OrderType.LIMIT, quantize_bid_price,
-                                       10001, FixtureLiquid.ORDER_BUY_LIMIT, FixtureLiquid.ORDERS_GET_AFTER_LIMIT_BUY)
-        [order_completed_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCompletedEvent))
-        order_completed_event: BuyOrderCompletedEvent = order_completed_event
-        trade_events: List[OrderFilledEvent] = [t for t in self.market_logger.event_log
-                                                if isinstance(t, OrderFilledEvent)]
-        base_amount_traded: Decimal = sum(t.amount for t in trade_events)
-        quote_amount_traded: Decimal = sum(t.amount * t.price for t in trade_events)
-
-        self.assertTrue([evt.order_type == OrderType.LIMIT for evt in trade_events])
-        self.assertEqual(order_id, order_completed_event.order_id)
-        self.assertEqual(quantized_amount, order_completed_event.base_asset_amount)
-        self.assertEqual("CEL", order_completed_event.base_asset)
-        self.assertEqual("ETH", order_completed_event.quote_asset)
-        self.assertAlmostEqual(base_amount_traded, order_completed_event.base_asset_amount)
-        self.assertAlmostEqual(quote_amount_traded, order_completed_event.quote_asset_amount)
-        self.assertGreater(order_completed_event.fee_amount, Decimal(0))
-        self.assertTrue(any([isinstance(event, BuyOrderCreatedEvent) and event.order_id == order_id
-                             for event in self.market_logger.event_log]))
-
-        # Reset the logs
-        self.market_logger.clear()
-
-        # Try to put limit sell order for 0.05 ETH worth of CEL, and watch for completion event.
-        current_ask_price: Decimal = self.market.get_price("CEL-ETH", False)
-        ask_price: Decimal = current_ask_price - Decimal("0.05") * current_ask_price
-        quantize_ask_price: Decimal = self.market.quantize_order_price("CEL-ETH", ask_price)
-
-        quantized_amount = order_completed_event.base_asset_amount
-
-        order_id, _ = self.place_order(False, "CEL-ETH", quantized_amount, OrderType.LIMIT, quantize_ask_price,
-                                       10002, FixtureLiquid.ORDER_SELL_LIMIT, FixtureLiquid.ORDERS_GET_AFTER_SELL_LIMIT)
-
-        [order_completed_event] = self.run_parallel(self.market_logger.wait_for(SellOrderCompletedEvent))
-        order_completed_event: SellOrderCompletedEvent = order_completed_event
-        trade_events = [t for t in self.market_logger.event_log
-                        if isinstance(t, OrderFilledEvent)]
-        base_amount_traded = sum(t.amount for t in trade_events)
-        quote_amount_traded = sum(t.amount * t.price for t in trade_events)
-
         self.assertTrue([evt.order_type == OrderType.LIMIT for evt in trade_events])
         self.assertEqual(order_id, order_completed_event.order_id)
         self.assertEqual(quantized_amount, order_completed_event.base_asset_amount)
@@ -333,9 +271,7 @@ def test_limit_maker_rejections(self):
         price: Decimal = self.market.quantize_order_price(trading_pair, price)
         amount = self.market.quantize_order_amount(trading_pair, 1)
 
-        order_id = self.place_order(True, trading_pair, amount, OrderType.LIMIT_MAKER,
-                                    price, 10001,
-                                    FixtureLiquid.LIMIT_MAKER_ERROR, FixtureLiquid.EMPTY)
+        order_id = self.market.buy(trading_pair, amount, OrderType.LIMIT_MAKER, price)
         [order_failure_event] = self.run_parallel(self.market_logger.wait_for(MarketOrderFailureEvent))
         self.assertEqual(order_id, order_failure_event.order_id)
 
@@ -346,9 +282,7 @@ def test_limit_maker_rejections(self):
         price: Decimal = self.market.quantize_order_price(trading_pair, price)
         amount = self.market.quantize_order_amount(trading_pair, 1)
 
-        order_id = self.place_order(False, trading_pair, amount, OrderType.LIMIT_MAKER,
-                                    price, 10002,
-                                    FixtureLiquid.LIMIT_MAKER_ERROR, FixtureLiquid.EMPTY)
+        order_id = self.market.sell(trading_pair, amount, OrderType.LIMIT_MAKER, price)
         [order_failure_event] = self.run_parallel(self.market_logger.wait_for(MarketOrderFailureEvent))
         self.assertEqual(order_id, order_failure_event.order_id)
 
@@ -358,9 +292,9 @@ def test_limit_makers_unfilled(self):
         price = self.market.quantize_order_price(trading_pair, price)
         amount = self.market.quantize_order_amount(trading_pair, 1)
 
-        order_id = self.place_order(True, trading_pair, amount, OrderType.LIMIT_MAKER,
-                                    price, 10001,
-                                    FixtureLiquid.ORDER_BUY_LIMIT, FixtureLiquid.ORDERS_GET_AFTER_SELL_LIMIT)
+        order_id, _ = self.place_order(True, trading_pair, amount, OrderType.LIMIT_MAKER,
+                                       price, 10001,
+                                       FixtureLiquid.ORDER_BUY_LIMIT, FixtureLiquid.ORDERS_GET_AFTER_SELL_LIMIT)
         [order_created_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCreatedEvent))
         order_created_event: BuyOrderCreatedEvent = order_created_event
         self.assertEqual(order_id, order_created_event.order_id)
@@ -369,9 +303,9 @@ def test_limit_makers_unfilled(self):
         price = self.market.quantize_order_price(trading_pair, price)
         amount = self.market.quantize_order_amount(trading_pair, 1)
 
-        order_id = self.place_order(False, trading_pair, amount, OrderType.LIMIT_MAKER,
-                                    price, 10002,
-                                    FixtureLiquid.ORDER_SELL_LIMIT, FixtureLiquid.ORDERS_GET_AFTER_SELL_LIMIT)
+        order_id, _ = self.place_order(False, trading_pair, amount, OrderType.LIMIT_MAKER,
+                                       price, 10002,
+                                       FixtureLiquid.ORDER_SELL_LIMIT, FixtureLiquid.ORDERS_GET_AFTER_SELL_LIMIT)
         [order_created_event] = self.run_parallel(self.market_logger.wait_for(SellOrderCreatedEvent))
         order_created_event: BuyOrderCreatedEvent = order_created_event
         self.assertEqual(order_id, order_created_event.order_id)
@@ -417,10 +351,10 @@ def test_cancel_all(self):
         quantize_bid_price: Decimal = self.market.quantize_order_price(trading_pair, bid_price * Decimal("0.7"))
         quantize_ask_price: Decimal = self.market.quantize_order_price(trading_pair, ask_price * Decimal("1.5"))
 
-        _, buy_exchange_id = self.place_order(True, trading_pair, quantized_amount, OrderType.LIMIT, quantize_bid_price,
+        _, buy_exchange_id = self.place_order(True, trading_pair, quantized_amount, OrderType.LIMIT_MAKER, quantize_bid_price,
                                               10001, FixtureLiquid.ORDER_BUY_CANCEL_ALL,
                                               FixtureLiquid.ORDERS_GET_AFTER_BUY)
-        _, sell_exchange_id = self.place_order(False, trading_pair, quantized_amount, OrderType.LIMIT,
+        _, sell_exchange_id = self.place_order(False, trading_pair, quantized_amount, OrderType.LIMIT_MAKER,
                                                quantize_ask_price, 10002, FixtureLiquid.ORDER_SELL_CANCEL_ALL,
                                                FixtureLiquid.ORDERS_GET_AFTER_SELL)
 
@@ -455,7 +389,7 @@ def test_orders_saving_and_restoration(self):
             amount: Decimal = 1
             quantized_amount: Decimal = self.market.quantize_order_amount("CEL-ETH", amount)
 
-            order_id, buy_exchange_id = self.place_order(True, "CEL-ETH", quantized_amount, OrderType.LIMIT,
+            order_id, buy_exchange_id = self.place_order(True, "CEL-ETH", quantized_amount, OrderType.LIMIT_MAKER,
                                                          quantize_bid_price, 10001, FixtureLiquid.ORDER_SAVE_RESTORE,
                                                          FixtureLiquid.ORDERS_GET_AFTER_BUY)
             [order_created_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCreatedEvent))
@@ -534,7 +468,7 @@ def test_order_fill_record(self):
             # Try to buy 1 CEL from the exchange, and watch for completion event.
             current_price: Decimal = self.market.get_price("CEL-ETH", True)
             amount: Decimal = 1
-            order_id, _ = self.place_order(True, "CEL-ETH", amount, OrderType.MARKET, current_price, 10001,
+            order_id, _ = self.place_order(True, "CEL-ETH", amount, OrderType.LIMIT, current_price, 10001,
                                            FixtureLiquid.ORDER_BUY_LIMIT, FixtureLiquid.ORDERS_GET_AFTER_LIMIT_BUY)
             [buy_order_completed_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCompletedEvent))
 
@@ -542,8 +476,9 @@ def test_order_fill_record(self):
             self.market_logger.clear()
 
             # Try to sell back the same amount of CEL to the exchange, and watch for completion event.
+            current_price: Decimal = self.market.get_price("CEL-ETH", False)
             amount = buy_order_completed_event.base_asset_amount
-            order_id, _ = self.place_order(False, "CEL-ETH", amount, OrderType.MARKET, current_price, 10002,
+            order_id, _ = self.place_order(False, "CEL-ETH", amount, OrderType.LIMIT, current_price, 10002,
                                            FixtureLiquid.ORDER_SELL_LIMIT, FixtureLiquid.ORDERS_GET_AFTER_SELL_LIMIT)
             [sell_order_completed_event] = self.run_parallel(self.market_logger.wait_for(SellOrderCompletedEvent))
 
diff --git a/test/integration/test_paper_trade_market.py b/test/integration/test_paper_trade_market.py
index 8fde444d4fe..03b0ef60c8d 100644
--- a/test/integration/test_paper_trade_market.py
+++ b/test/integration/test_paper_trade_market.py
@@ -202,7 +202,7 @@ def run_parallel(self, *tasks):
         return self.ev_loop.run_until_complete(self.run_parallel_async(*tasks))
 
     def test_place_market_orders(self):
-        self.market.sell("ETHUSDT", 30, OrderType.MARKET)
+        self.market.sell("ETHUSDT", 30, OrderType.LIMIT)
         list_queued_orders: List[QueuedOrder] = self.market.queued_orders
         first_queued_order: QueuedOrder = list_queued_orders[0]
         self.assertFalse(first_queued_order.is_buy, msg="Market order is not sell")
@@ -211,7 +211,7 @@ def test_place_market_orders(self):
         self.assertEqual(len(list_queued_orders), 1, msg="First market order did not get added")
 
         # Figure out why this test is failing
-        self.market.buy("BTCUSDT", 30, OrderType.MARKET)
+        self.market.buy("BTCUSDT", 30, OrderType.LIMIT)
         list_queued_orders: List[QueuedOrder] = self.market.queued_orders
         second_queued_order: QueuedOrder = list_queued_orders[1]
         self.assertTrue(second_queued_order.is_buy, msg="Market order is not buy")
@@ -223,7 +223,7 @@ def test_place_market_orders(self):
     def test_market_order_simulation(self):
         self.market.set_balance("ETH", 20)
         self.market.set_balance("USDT", 100)
-        self.market.sell("ETHUSDT", 10, OrderType.MARKET)
+        self.market.sell("ETHUSDT", 10, OrderType.LIMIT)
         self.run_parallel(self.market_logger.wait_for(SellOrderCompletedEvent))
 
         # Get diff between composite bid entries and original bid entries
@@ -239,7 +239,7 @@ def test_market_order_simulation(self):
         self.assertFalse(diff_bid.to_numpy().any())
 
         self.assertEquals(10, self.market.get_balance("ETH"), msg="Balance was not updated.")
-        self.market.buy("ETHUSDT", 5, OrderType.MARKET)
+        self.market.buy("ETHUSDT", 5, OrderType.LIMIT)
         self.run_parallel(self.market_logger.wait_for(BuyOrderCompletedEvent))
 
         # Get diff between composite bid entries and original bid entries
@@ -260,13 +260,13 @@ def test_limit_order_crossed(self):
         starting_quote_balance = 1000
         self.market.set_balance("ETH", starting_base_balance)
         self.market.set_balance("USDT", starting_quote_balance)
-        self.market.sell("ETHUSDT", 10, OrderType.LIMIT, 100)
+        self.market.sell("ETHUSDT", 10, OrderType.LIMIT_MAKER, 100)
         self.run_parallel(self.market_logger.wait_for(SellOrderCompletedEvent))
         self.assertEquals(starting_base_balance - 10, self.market.get_balance("ETH"),
                           msg="ETH Balance was not updated.")
         self.assertEquals(starting_quote_balance + 1000, self.market.get_balance("USDT"),
                           msg="USDT Balance was not updated.")
-        self.market.buy("ETHUSDT", 1, OrderType.LIMIT, 500)
+        self.market.buy("ETHUSDT", 1, OrderType.LIMIT_MAKER, 500)
         self.run_parallel(self.market_logger.wait_for(BuyOrderCompletedEvent))
         self.assertEquals(11, self.market.get_balance("ETH"),
                           msg="ETH Balance was not updated.")
@@ -285,7 +285,7 @@ def test_bid_limit_order_trade_match(self):
         self.market.set_balance(trading_pair.quote_asset, starting_quote_balance)
 
         best_bid_price = self.market.order_books[trading_pair.trading_pair].get_price(True)
-        client_order_id = self.market.buy(trading_pair.trading_pair, base_quantity, OrderType.LIMIT, best_bid_price)
+        client_order_id = self.market.buy(trading_pair.trading_pair, base_quantity, OrderType.LIMIT_MAKER, best_bid_price)
 
         matched_limit_orders = TestUtils.get_match_limit_orders(self.market.limit_orders, {
             "client_order_id": client_order_id,
@@ -307,7 +307,7 @@ def test_bid_limit_order_trade_match(self):
                                starting_quote_balance - base_quantity * best_bid_price)
 
         matched_order_create_events = TestUtils.get_match_events(self.market_logger.event_log, BuyOrderCreatedEvent, {
-            "type": OrderType.LIMIT,
+            "type": OrderType.LIMIT_MAKER,
             "amount": base_quantity,
             "price": best_bid_price,
             "order_id": client_order_id
@@ -345,7 +345,7 @@ async def delay_trigger_event1():
                 "trading_pair": trading_pair.trading_pair,
                 "order_id": client_order_id
             })
-        # Market should emit OrderFilledEvent
+        # Marketshould emit OrderFilledEvent
         self.assertEqual(1, len(matched_order_fill_events))
 
         # Market should have no more on hold balance
@@ -366,7 +366,7 @@ def test_ask_limit_order_trade_match(self):
         self.market.set_balance(trading_pair.quote_asset, starting_quote_balance)
 
         best_ask_price = self.market.order_books[trading_pair.trading_pair].get_price(False)
-        client_order_id = self.market.sell(trading_pair.trading_pair, base_quantity, OrderType.LIMIT, best_ask_price)
+        client_order_id = self.market.sell(trading_pair.trading_pair, base_quantity, OrderType.LIMIT_MAKER, best_ask_price)
 
         matched_limit_orders = TestUtils.get_match_limit_orders(self.market.limit_orders, {
             "client_order_id": client_order_id,
@@ -387,7 +387,7 @@ def test_ask_limit_order_trade_match(self):
                                starting_base_balance - base_quantity)
 
         matched_order_create_events = TestUtils.get_match_events(self.market_logger.event_log, SellOrderCreatedEvent, {
-            "type": OrderType.LIMIT,
+            "type": OrderType.LIMIT_MAKER,
             "amount": base_quantity,
             "price": best_ask_price,
             "order_id": client_order_id
@@ -445,9 +445,9 @@ def test_order_cancellation(self):
         self.market.set_balance(trading_pair.quote_asset, starting_quote_balance)
         best_ask_price = self.market.order_books[trading_pair.trading_pair].get_price(False)
         ask_client_order_id = self.market.sell(trading_pair.trading_pair, base_quantity,
-                                               OrderType.LIMIT, best_ask_price)
+                                               OrderType.LIMIT_MAKER, best_ask_price)
         best_bid_price = self.market.order_books[trading_pair.trading_pair].get_price(True)
-        self.market.buy(trading_pair.trading_pair, base_quantity, OrderType.LIMIT, best_bid_price)
+        self.market.buy(trading_pair.trading_pair, base_quantity, OrderType.LIMIT_MAKER, best_bid_price)
 
         # Market should track limit orders
         self.assertEqual(2, len(self.market.limit_orders))
@@ -482,9 +482,9 @@ def test_order_cancel_all(self):
         self.market.set_balance(trading_pair.quote_asset, starting_quote_balance)
         best_ask_price = self.market.order_books[trading_pair.trading_pair].get_price(False)
         self.market.sell(trading_pair.trading_pair, base_quantity,
-                         OrderType.LIMIT, best_ask_price)
+                         OrderType.LIMIT_MAKER, best_ask_price)
         best_bid_price = self.market.order_books[trading_pair.trading_pair].get_price(True)
-        self.market.buy(trading_pair.trading_pair, base_quantity, OrderType.LIMIT, best_bid_price)
+        self.market.buy(trading_pair.trading_pair, base_quantity, OrderType.LIMIT_MAKER, best_bid_price)
 
         # Market should track limit orders
         self.assertEqual(2, len(self.market.limit_orders))
diff --git a/test/integration/test_radar_relay_market.py b/test/integration/test_radar_relay_market.py
index b61dd95b13c..8180902aad1 100644
--- a/test/integration/test_radar_relay_market.py
+++ b/test/integration/test_radar_relay_market.py
@@ -153,10 +153,10 @@ def run_parallel(self, *tasks):
         return self.ev_loop.run_until_complete(self.run_parallel_async(*tasks))
 
     def test_get_fee(self):
-        maker_buy_trade_fee: TradeFee = self.market.get_fee("ZRX", "WETH", OrderType.LIMIT, TradeType.BUY, Decimal(20), Decimal(0.01))
+        maker_buy_trade_fee: TradeFee = self.market.get_fee("ZRX", "WETH", OrderType.LIMIT_MAKER, TradeType.BUY, Decimal(20), Decimal(0.01))
         self.assertEqual(maker_buy_trade_fee.percent, 0)
         self.assertEqual(len(maker_buy_trade_fee.flat_fees), 0)
-        taker_buy_trade_fee: TradeFee = self.market.get_fee("ZRX", "WETH", OrderType.MARKET, TradeType.BUY, Decimal(20))
+        taker_buy_trade_fee: TradeFee = self.market.get_fee("ZRX", "WETH", OrderType.LIMIT, TradeType.BUY, Decimal(20))
         self.assertEqual(taker_buy_trade_fee.percent, 0)
         self.assertEqual(len(taker_buy_trade_fee.flat_fees), 1)
         self.assertEqual(taker_buy_trade_fee.flat_fees[0][0], "ETH")
@@ -174,12 +174,12 @@ def test_single_limit_order_cancel(self):
         quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
         buy_order_id = self.market.buy(trading_pair=trading_pair,
                                        amount=amount,
-                                       order_type=OrderType.LIMIT,
+                                       order_type=OrderType.LIMIT_MAKER,
                                        price=current_price * Decimal("0.8"),
                                        expiration_ts=expires)
         [buy_order_opened_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCreatedEvent))
         self.assertEqual("ZRX-WETH", buy_order_opened_event.trading_pair)
-        self.assertEqual(OrderType.LIMIT, buy_order_opened_event.type)
+        self.assertEqual(OrderType.LIMIT_MAKER, buy_order_opened_event.type)
         self.assertEqual(quantized_amount, Decimal(buy_order_opened_event.amount))
 
         self.run_parallel(self.market.cancel_order(buy_order_id))
@@ -197,28 +197,28 @@ def test_limit_buy_and_sell_and_cancel_all(self):
         quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, amount)
         buy_order_id = self.market.buy(trading_pair=trading_pair,
                                        amount=amount,
-                                       order_type=OrderType.LIMIT,
+                                       order_type=OrderType.LIMIT_MAKER,
                                        price=current_price * Decimal("0.8"),
                                        expiration_ts=expires)
         [buy_order_opened_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCreatedEvent))
         self.assertEqual(buy_order_id, buy_order_opened_event.order_id)
         self.assertEqual(quantized_amount, Decimal(buy_order_opened_event.amount))
         self.assertEqual("ZRX-WETH", buy_order_opened_event.trading_pair)
-        self.assertEqual(OrderType.LIMIT, buy_order_opened_event.type)
+        self.assertEqual(OrderType.LIMIT_MAKER, buy_order_opened_event.type)
 
         # Reset the logs
         self.market_logger.clear()
 
         sell_order_id = self.market.sell(trading_pair=trading_pair,
                                          amount=amount,
-                                         order_type=OrderType.LIMIT,
+                                         order_type=OrderType.LIMIT_MAKER,
                                          price=current_price * Decimal("1.2"),
                                          expiration_ts=expires)
         [sell_order_opened_event] = self.run_parallel(self.market_logger.wait_for(SellOrderCreatedEvent))
         self.assertEqual(sell_order_id, sell_order_opened_event.order_id)
         self.assertEqual(quantized_amount, Decimal(sell_order_opened_event.amount))
         self.assertEqual("ZRX-WETH", sell_order_opened_event.trading_pair)
-        self.assertEqual(OrderType.LIMIT, sell_order_opened_event.type)
+        self.assertEqual(OrderType.LIMIT_MAKER, sell_order_opened_event.type)
 
         [cancellation_results] = self.run_parallel(self.market.cancel_all(60 * 5))
         self.assertEqual(cancellation_results[0], CancellationResult(buy_order_id, True))
@@ -233,13 +233,13 @@ def test_order_expire(self):
         expires = int(time.time() + 60 * 2)  # expires in 2 min
         self.market.buy(trading_pair=trading_pair,
                         amount=amount,
-                        order_type=OrderType.LIMIT,
+                        order_type=OrderType.LIMIT_MAKER,
                         price=current_price * Decimal("0.8"),
                         expiration_ts=expires)
         [buy_order_opened_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCreatedEvent))
 
         self.assertEqual("ZRX-WETH", buy_order_opened_event.trading_pair)
-        self.assertEqual(OrderType.LIMIT, buy_order_opened_event.type)
+        self.assertEqual(OrderType.LIMIT_MAKER, buy_order_opened_event.type)
         [buy_order_expired_event] = self.run_parallel(self.market_logger.wait_for(OrderExpiredEvent, 60 * 3))
         self.assertEqual(buy_order_opened_event.order_id, buy_order_expired_event.order_id)
 
@@ -247,16 +247,17 @@ def test_order_expire(self):
         self.market_logger.clear()
 
     def test_market_buy(self):
+        price: Decimal = self.market.get_price("ZRX-WETH", True)
         amount: Decimal = Decimal(5)
         quantized_amount: Decimal = self.market.quantize_order_amount("ZRX-WETH", amount)
-        order_id = self.market.buy("ZRX-WETH", amount, OrderType.MARKET)
+        order_id = self.market.buy("ZRX-WETH", amount, OrderType.LIMIT, price)
 
         [order_completed_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCompletedEvent))
         order_completed_event: BuyOrderCompletedEvent = order_completed_event
         order_filled_events: List[OrderFilledEvent] = [t for t in self.market_logger.event_log
                                                        if isinstance(t, OrderFilledEvent)]
 
-        self.assertTrue([evt.order_type == OrderType.MARKET for evt in order_filled_events])
+        self.assertTrue([evt.order_type == OrderType.LIMIT for evt in order_filled_events])
         self.assertEqual(order_id, order_completed_event.order_id)
         self.assertEqual(float(quantized_amount), float(order_completed_event.base_asset_amount))
         self.assertEqual("ZRX", order_completed_event.base_asset)
@@ -264,16 +265,17 @@ def test_market_buy(self):
         self.market_logger.clear()
 
     def test_market_sell(self):
+        price: Decimal = self.market.get_price("ZRX-WETH", False)
         amount: Decimal = Decimal(5)
         quantized_amount: Decimal = self.market.quantize_order_amount("ZRX-WETH", amount)
-        order_id = self.market.sell("ZRX-WETH", amount, OrderType.MARKET)
+        order_id = self.market.sell("ZRX-WETH", amount, OrderType.LIMIT, price)
 
         [order_completed_event] = self.run_parallel(self.market_logger.wait_for(SellOrderCompletedEvent))
         order_completed_event: SellOrderCompletedEvent = order_completed_event
         order_filled_events: List[OrderFilledEvent] = [t for t in self.market_logger.event_log
                                                        if isinstance(t, OrderFilledEvent)]
 
-        self.assertTrue([evt.order_type == OrderType.MARKET for evt in order_filled_events])
+        self.assertTrue([evt.order_type == OrderType.LIMIT for evt in order_filled_events])
         self.assertEqual(order_id, order_completed_event.order_id)
         self.assertEqual(float(quantized_amount), float(order_completed_event.base_asset_amount))
         self.assertEqual("ZRX", order_completed_event.base_asset)
@@ -321,7 +323,7 @@ def test_orders_saving_and_restoration(self):
             quantized_amount: Decimal = self.market.quantize_order_amount(trading_pair, Decimal(amount))
 
             expires = int(time.time() + 60 * 5)
-            order_id = self.market.buy(trading_pair, quantized_amount, OrderType.LIMIT, quantize_bid_price,
+            order_id = self.market.buy(trading_pair, quantized_amount, OrderType.LIMIT_MAKER, quantize_bid_price,
                                        expiration_ts=expires)
             [order_created_event] = self.run_parallel(self.market_logger.wait_for(BuyOrderCreatedEvent))
             order_created_event: BuyOrderCreatedEvent = order_created_event


Code review comments:
diff_hunk: @@ -45,7 +45,7 @@ def to_pandas(cls, trades: List):
                 trade.trading_pair,
                 trade.price,
                 trade.amount,
-                "market" if trade.order_type is OrderType.MARKET else "limit",
+                "limit" if trade.order_type is OrderType.LIMIT else "limit_maker",
path: hummingbot/core/data_type/trade.py
text: @user1:
This can be just `trade.order_type`, right?