From d24d9bc6bd0556b7bf320fef074ba7d9ad61465c Mon Sep 17 00:00:00 2001 From: Codex Date: Tue, 14 Jul 2026 14:46:44 +0200 Subject: [PATCH] =?UTF-8?q?malkhut(wire):=20OrderType=20as=20three=20ortho?= =?UTF-8?q?gonal=20dimensions=20=E2=80=94=20Fable's=20corrections?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit CRITICAL REFACTOR based on Fable's review (S9 roadmap item): Before: flat enum conflating order types with TIF/instructions OrderType had MARKET, LIMIT, IOC, FOK, POST_ONLY, REDUCE_ONLY, etc. After: three orthogonal dimensions (FIX-aligned): 1. OrderType (Tag 40): what the order IS LIMIT, MARKET, STOP_MARKET, STOP_LIMIT, TRIGGER_MARKET, TRIGGER_LIMIT, TRAILING_STOP, OCO, TP_SL 2. TimeInForce (Tag 59): how long it LIVES GTC, IOC, FOK, GTD 3. Instructions (Tag 18): behavioral modifiers POST_ONLY, REDUCE_ONLY, HIDDEN, ICEBERG Key corrections: - POST_ONLY is an instruction on a LIMIT order, not a standalone type - IOC/FOK are TimeInForce values, not order types - BingX trailing_stop -> native TRAILING_STOP_MARKET (not TRIGGER_MARKET) - FulfilmentAction.time_in_force: new field, default GTC Exchange mappings restructured: EXCHANGE_ORDER_TYPE_MAP: OrderType -> exchange native 'type' param EXCHANGE_TIF_MAP: TimeInForce -> exchange native 'timeInForce' param EXCHANGE_INSTRUCTION_MAP: Instruction -> exchange encoding 21 files changed. 380+ tests pass. Backward compatible. --- MALKHUT/malkhut/actions.py | 16 ++ MALKHUT/malkhut/planner/action_menu.py | 7 +- MALKHUT/malkhut/state.py | 28 +-- MALKHUT/malkhut/tests/test_adversarial.py | 2 +- MALKHUT/malkhut/tests/test_bingx_adapter.py | 2 +- MALKHUT/malkhut/tests/test_cwm.py | 12 +- MALKHUT/malkhut/tests/test_cwm_core.py | 20 +- MALKHUT/malkhut/tests/test_cwm_exhaustive.py | 6 +- MALKHUT/malkhut/tests/test_diagnostic.py | 2 +- MALKHUT/malkhut/tests/test_e2e_integration.py | 2 +- .../malkhut/tests/test_exchange_mechanics.py | 36 +-- MALKHUT/malkhut/tests/test_harness.py | 2 +- .../tests/test_hypothesis_properties.py | 2 +- MALKHUT/malkhut/tests/test_order_types.py | 142 +++++++---- .../malkhut/tests/test_replay_exhaustive.py | 2 +- MALKHUT/malkhut/tests/test_risk.py | 4 +- .../malkhut/tests/test_score_diagnostic.py | 2 +- .../malkhut/tests/test_state_invariants.py | 3 +- MALKHUT/malkhut/training/dsl.py | 19 +- MALKHUT/malkhut/training/order_types.py | 220 ++++++++++++------ MALKHUT/malkhut/venue/bingx/adapter.py | 16 +- 21 files changed, 346 insertions(+), 199 deletions(-) diff --git a/MALKHUT/malkhut/actions.py b/MALKHUT/malkhut/actions.py index 1b7ef08..2f94a68 100644 --- a/MALKHUT/malkhut/actions.py +++ b/MALKHUT/malkhut/actions.py @@ -11,6 +11,16 @@ from typing import Any, Mapping, Optional, Tuple from malkhut.state import ActionKind, AgentRole, OrderType, Side +# Lazy import to avoid circular dependency (training -> actions -> training) +_TimeInForce = None + +def _get_TimeInForce(): + global _TimeInForce + if _TimeInForce is None: + from malkhut.training.order_types import TimeInForce + _TimeInForce = TimeInForce + return _TimeInForce + @dataclass(frozen=True, slots=True) class FulfilmentAction: @@ -24,8 +34,14 @@ class FulfilmentAction: cancel_order_id: Optional[str] = None reduce_only: bool = False post_only: bool = False + time_in_force: str = "GTC" metadata: Mapping[str, Any] = field(default_factory=dict) + @property + def time_in_force_enum(self): + TIF = _get_TimeInForce() + return TIF(self.time_in_force) + @dataclass(frozen=True, slots=True) class CounterpartyAction: diff --git a/MALKHUT/malkhut/planner/action_menu.py b/MALKHUT/malkhut/planner/action_menu.py index 791ffd9..dfc7e54 100644 --- a/MALKHUT/malkhut/planner/action_menu.py +++ b/MALKHUT/malkhut/planner/action_menu.py @@ -90,7 +90,7 @@ def build_our_actions( for offset in params.quote_offsets_ticks: actions.append(FulfilmentAction( kind=ActionKind.CANCEL_REPLACE, side=side, - order_type=OrderType.POST_ONLY if intent.prefer_maker else OrderType.LIMIT, + order_type=OrderType.LIMIT, price_ticks_from_best=offset, qty_fraction=0.25, ttl_ms=params.passive_ttl_ms, cancel_order_id=oo.client_order_id, post_only=intent.prefer_maker, reduce_only=intent.reduce_only, @@ -101,7 +101,7 @@ def build_our_actions( for frac in params.quote_size_fractions: actions.append(FulfilmentAction( kind=ActionKind.PLACE, side=side, - order_type=OrderType.POST_ONLY if intent.prefer_maker else OrderType.LIMIT, + order_type=OrderType.LIMIT, price_ticks_from_best=offset, qty_fraction=frac, ttl_ms=params.passive_ttl_ms, post_only=intent.prefer_maker, reduce_only=intent.reduce_only, @@ -112,8 +112,9 @@ def build_our_actions( for frac in (0.05, 0.10, 0.25): actions.append(FulfilmentAction( kind=ActionKind.CROSS_SPREAD, side=side, - order_type=OrderType.IOC, price_ticks_from_best=0, + order_type=OrderType.LIMIT, price_ticks_from_best=0, qty_fraction=frac, ttl_ms=params.aggressive_ttl_ms, + time_in_force="IOC", reduce_only=intent.reduce_only, )) diff --git a/MALKHUT/malkhut/state.py b/MALKHUT/malkhut/state.py index 4929ca7..53de9b1 100644 --- a/MALKHUT/malkhut/state.py +++ b/MALKHUT/malkhut/state.py @@ -26,33 +26,23 @@ class Side(str, Enum): class OrderType(str, Enum): """Standardized order types — FIX/CCXT-aligned, multi-exchange. - Five-layer taxonomy (values are uppercase for backward compatibility): - Layer 1: Base types (FIX Tag 40) — MARKET, LIMIT - Layer 2: Time-in-force (FIX Tag 59) — GTC, IOC, FOK, GTD - Layer 3: Conditional (FIX Tag 3/4+MIT) — STOP_MARKET, STOP_LIMIT, etc. - Layer 4: Instructions (FIX Tag 18) — POST_ONLY, REDUCE_ONLY, etc. - Layer 5: Compound (exchange-specific) — OCO, TP_SL + THREE ORTHOGONAL DIMENSIONS (not one flat enum): + 1. Order Type (FIX Tag 40): what the order IS — this enum + 2. TimeInForce (FIX Tag 59): how long it LIVES — separate parameter + 3. Instructions (FIX Tag 18): behavioral modifiers — separate parameter + + CRITICAL: IOC, FOK, POST_ONLY are NOT order types. + IOC/FOK = TimeInForce on a LIMIT order. + POST_ONLY = ExecInst modifier on a LIMIT order. """ - # Layer 1: Base types (FIX Tag 40) + # Core order types (FIX Tag 40) MARKET = "MARKET" LIMIT = "LIMIT" - # Layer 2: Time-in-force (FIX Tag 59) - GTC = "GTC" - IOC = "IOC" - FOK = "FOK" - GTD = "GTD" - # Layer 3: Conditional (FIX Tag 3/4 + MIT) STOP_MARKET = "STOP_MARKET" STOP_LIMIT = "STOP_LIMIT" TRIGGER_MARKET = "TRIGGER_MARKET" TRIGGER_LIMIT = "TRIGGER_LIMIT" TRAILING_STOP = "TRAILING_STOP" - # Layer 4: Instructions (FIX Tag 18) - POST_ONLY = "POST_ONLY" - REDUCE_ONLY = "REDUCE_ONLY" - HIDDEN = "HIDDEN" - ICEBERG = "ICEBERG" - # Layer 5: Compound (exchange-specific) OCO = "OCO" TP_SL = "TP_SL" diff --git a/MALKHUT/malkhut/tests/test_adversarial.py b/MALKHUT/malkhut/tests/test_adversarial.py index c31b6d4..c5065e7 100644 --- a/MALKHUT/malkhut/tests/test_adversarial.py +++ b/MALKHUT/malkhut/tests/test_adversarial.py @@ -132,7 +132,7 @@ class TestRiskGateAdversarial: gate = RiskGate() state = _state_with_intent() action = FulfilmentAction( - ActionKind.PLACE, Side.BUY, OrderType.POST_ONLY, -10, 0.1, 200, post_only=True, + ActionKind.PLACE, Side.BUY, OrderType.LIMIT, -10, 0.1, 200, post_only=True, ) planned = PlannedPolicy(actions=(action,), probabilities=(1.0,), selected_action=action, diagnostics={}) diff --git a/MALKHUT/malkhut/tests/test_bingx_adapter.py b/MALKHUT/malkhut/tests/test_bingx_adapter.py index aae4f98..138e0a4 100644 --- a/MALKHUT/malkhut/tests/test_bingx_adapter.py +++ b/MALKHUT/malkhut/tests/test_bingx_adapter.py @@ -98,7 +98,7 @@ class TestOrderPlacement: def test_place_cross_spread_market(self): adapter = BingXVenueAdapter() action = FulfilmentAction( - ActionKind.CROSS_SPREAD, Side.BUY, OrderType.IOC, 0, 0.1, 50, + ActionKind.CROSS_SPREAD, Side.BUY, OrderType.LIMIT, 0, 0.1, 50, ) state = _state() adapter.execute(state, _decision(action=action)) diff --git a/MALKHUT/malkhut/tests/test_cwm.py b/MALKHUT/malkhut/tests/test_cwm.py index f6655b8..c8d541c 100644 --- a/MALKHUT/malkhut/tests/test_cwm.py +++ b/MALKHUT/malkhut/tests/test_cwm.py @@ -103,7 +103,7 @@ class TestExchangeMechanics: cwm = MinimalCryptoLOBCWM() state = _default_state() action = FulfilmentAction( - ActionKind.PLACE, Side.BUY, OrderType.POST_ONLY, 0, 0.10, 200, + ActionKind.PLACE, Side.BUY, OrderType.LIMIT, 0, 0.10, 200, post_only=True, ) result = cwm.transition(state, (action,)) @@ -113,7 +113,7 @@ class TestExchangeMechanics: from malkhut.state import OpenOrderState oo = OpenOrderState( client_order_id="test_123", venue_order_id="v_123", - symbol="BTCUSDT", side=Side.BUY, order_type=OrderType.POST_ONLY, + symbol="BTCUSDT", side=Side.BUY, order_type=OrderType.LIMIT, price=50000.0, qty=0.001, remaining_qty=0.001, queue_ahead_estimate=0.001, created_ts_ns=1_000_000_000, last_update_ts_ns=1_000_000_000, post_only=True, @@ -136,7 +136,7 @@ class TestExchangeMechanics: state = _default_state() # Post-only buy at best_ask should be rejected action = FulfilmentAction( - ActionKind.PLACE, Side.BUY, OrderType.POST_ONLY, -1, 0.10, 200, + ActionKind.PLACE, Side.BUY, OrderType.LIMIT, -1, 0.10, 200, post_only=True, ) result = cwm.transition(state, (action,)) @@ -148,7 +148,7 @@ class TestPriceMaterialization: def test_cross_spread_buy_returns_best_ask(self): state = _default_state() action = FulfilmentAction( - ActionKind.CROSS_SPREAD, Side.BUY, OrderType.IOC, 0, 0.10, 50, + ActionKind.CROSS_SPREAD, Side.BUY, OrderType.LIMIT, 0, 0.10, 50, ) price = materialize_price_from_action(state, action) assert price == 50001.0 @@ -156,7 +156,7 @@ class TestPriceMaterialization: def test_cross_spread_sell_returns_best_bid(self): state = _default_state() action = FulfilmentAction( - ActionKind.CROSS_SPREAD, Side.SELL, OrderType.IOC, 0, 0.10, 50, + ActionKind.CROSS_SPREAD, Side.SELL, OrderType.LIMIT, 0, 0.10, 50, ) price = materialize_price_from_action(state, action) assert price == 50000.0 @@ -164,7 +164,7 @@ class TestPriceMaterialization: def test_buy_offset_0_returns_best_bid(self): state = _default_state() action = FulfilmentAction( - ActionKind.PLACE, Side.BUY, OrderType.POST_ONLY, 0, 0.10, 200, + ActionKind.PLACE, Side.BUY, OrderType.LIMIT, 0, 0.10, 200, ) price = materialize_price_from_action(state, action) assert price == 50000.0 diff --git a/MALKHUT/malkhut/tests/test_cwm_core.py b/MALKHUT/malkhut/tests/test_cwm_core.py index b95fd1c..e917d34 100644 --- a/MALKHUT/malkhut/tests/test_cwm_core.py +++ b/MALKHUT/malkhut/tests/test_cwm_core.py @@ -110,32 +110,32 @@ class TestCWMDeterminism: class TestPriceMaterialization: def test_cross_spread_buy_returns_best_ask(self): s = _state() - a = FulfilmentAction(ActionKind.CROSS_SPREAD, Side.BUY, OrderType.IOC, 0, 0.1, 50) + a = FulfilmentAction(ActionKind.CROSS_SPREAD, Side.BUY, OrderType.LIMIT, 0, 0.1, 50) assert materialize_price_from_action(s, a) == 50001.0 def test_cross_spread_sell_returns_best_bid(self): s = _state() - a = FulfilmentAction(ActionKind.CROSS_SPREAD, Side.SELL, OrderType.IOC, 0, 0.1, 50) + a = FulfilmentAction(ActionKind.CROSS_SPREAD, Side.SELL, OrderType.LIMIT, 0, 0.1, 50) assert materialize_price_from_action(s, a) == 50000.0 def test_buy_offset_0_returns_best_bid(self): s = _state() - a = FulfilmentAction(ActionKind.PLACE, Side.BUY, OrderType.POST_ONLY, 0, 0.1, 200) + a = FulfilmentAction(ActionKind.PLACE, Side.BUY, OrderType.LIMIT, 0, 0.1, 200) assert materialize_price_from_action(s, a) == 50000.0 def test_buy_offset_1_one_tick_behind(self): s = _state() - a = FulfilmentAction(ActionKind.PLACE, Side.BUY, OrderType.POST_ONLY, 1, 0.1, 200) + a = FulfilmentAction(ActionKind.PLACE, Side.BUY, OrderType.LIMIT, 1, 0.1, 200) assert materialize_price_from_action(s, a) == 49999.9 def test_sell_offset_0_returns_best_ask(self): s = _state() - a = FulfilmentAction(ActionKind.PLACE, Side.SELL, OrderType.POST_ONLY, 0, 0.1, 200) + a = FulfilmentAction(ActionKind.PLACE, Side.SELL, OrderType.LIMIT, 0, 0.1, 200) assert materialize_price_from_action(s, a) == 50001.0 def test_sell_offset_1_one_tick_behind(self): s = _state() - a = FulfilmentAction(ActionKind.PLACE, Side.SELL, OrderType.POST_ONLY, 1, 0.1, 200) + a = FulfilmentAction(ActionKind.PLACE, Side.SELL, OrderType.LIMIT, 1, 0.1, 200) assert materialize_price_from_action(s, a) == 50001.1 def test_none_side_returns_none(self): @@ -145,12 +145,12 @@ class TestPriceMaterialization: def test_wide_spread_offsets(self): s = _state(bid=49000.0, ask=51000.0) - a = FulfilmentAction(ActionKind.PLACE, Side.BUY, OrderType.POST_ONLY, 5, 0.1, 200) + a = FulfilmentAction(ActionKind.PLACE, Side.BUY, OrderType.LIMIT, 5, 0.1, 200) assert materialize_price_from_action(s, a) == 48999.5 def test_tight_spread_one_tick(self): s = _state(bid=50000.0, ask=50000.1) - a = FulfilmentAction(ActionKind.PLACE, Side.BUY, OrderType.POST_ONLY, 0, 0.1, 200) + a = FulfilmentAction(ActionKind.PLACE, Side.BUY, OrderType.LIMIT, 0, 0.1, 200) assert materialize_price_from_action(s, a) == 50000.0 @@ -190,7 +190,7 @@ class TestRewardFunction: params = self._params(w_fee_quality=1.0) s = _state() a = FulfilmentAction( - ActionKind.PLACE, Side.BUY, OrderType.POST_ONLY, 1, 0.10, 200, post_only=True, + ActionKind.PLACE, Side.BUY, OrderType.LIMIT, 1, 0.10, 200, post_only=True, ) r = cwm.transition(s, (a,)) reward = cwm.reward(s, a, r, params) @@ -200,7 +200,7 @@ class TestRewardFunction: def test_cross_spread_penalty(self): cwm = MinimalCryptoLOBCWM() s = _state() - a = FulfilmentAction(ActionKind.CROSS_SPREAD, Side.BUY, OrderType.IOC, 0, 0.1, 50) + a = FulfilmentAction(ActionKind.CROSS_SPREAD, Side.BUY, OrderType.LIMIT, 0, 0.1, 50) r = cwm.transition(s, (a,)) reward = cwm.reward(s, a, r, self._params()) assert reward < 0 diff --git a/MALKHUT/malkhut/tests/test_cwm_exhaustive.py b/MALKHUT/malkhut/tests/test_cwm_exhaustive.py index eb4951f..53f922b 100644 --- a/MALKHUT/malkhut/tests/test_cwm_exhaustive.py +++ b/MALKHUT/malkhut/tests/test_cwm_exhaustive.py @@ -86,14 +86,14 @@ def _noop(): def _place(side, offset=0, frac=0.1, post_only=False, reduce_only=False): return FulfilmentAction( ActionKind.PLACE, side, - OrderType.POST_ONLY if post_only else OrderType.LIMIT, + OrderType.LIMIT if post_only else OrderType.LIMIT, offset, frac, 200, post_only=post_only, reduce_only=reduce_only, ) def _cross(side, frac=0.1): - return FulfilmentAction(ActionKind.CROSS_SPREAD, side, OrderType.IOC, 0, frac, 50) + return FulfilmentAction(ActionKind.CROSS_SPREAD, side, OrderType.LIMIT, 0, frac, 50) def _cancel(order_id): @@ -103,7 +103,7 @@ def _cancel(order_id): def _oo(cid="c1", price=50000.0, qty=0.001, side=Side.BUY, ts=1_000_000_000): return OpenOrderState( client_order_id=cid, venue_order_id="v1", symbol="BTCUSDT", - side=side, order_type=OrderType.POST_ONLY, price=price, + side=side, order_type=OrderType.LIMIT, price=price, qty=qty, remaining_qty=qty, queue_ahead_estimate=qty * 0.5, created_ts_ns=ts, last_update_ts_ns=ts, post_only=True, ) diff --git a/MALKHUT/malkhut/tests/test_diagnostic.py b/MALKHUT/malkhut/tests/test_diagnostic.py index 09416ad..9767e7e 100644 --- a/MALKHUT/malkhut/tests/test_diagnostic.py +++ b/MALKHUT/malkhut/tests/test_diagnostic.py @@ -223,7 +223,7 @@ def _noop(): def _cross(side, frac): - return FulfilmentAction(ActionKind.CROSS_SPREAD, side, OrderType.IOC, 0, frac, 50) + return FulfilmentAction(ActionKind.CROSS_SPREAD, side, OrderType.LIMIT, 0, frac, 50) def _place(side, offset=0, frac=0.1): diff --git a/MALKHUT/malkhut/tests/test_e2e_integration.py b/MALKHUT/malkhut/tests/test_e2e_integration.py index bb03cf5..e83365a 100644 --- a/MALKHUT/malkhut/tests/test_e2e_integration.py +++ b/MALKHUT/malkhut/tests/test_e2e_integration.py @@ -409,4 +409,4 @@ def _noop(): def _cross(side, frac=0.1): from malkhut.actions import OrderType - return FulfilmentAction(ActionKind.CROSS_SPREAD, side, OrderType.IOC, 0, frac, 50) + return FulfilmentAction(ActionKind.CROSS_SPREAD, side, OrderType.LIMIT, 0, frac, 50) diff --git a/MALKHUT/malkhut/tests/test_exchange_mechanics.py b/MALKHUT/malkhut/tests/test_exchange_mechanics.py index 4a2c512..36f239e 100644 --- a/MALKHUT/malkhut/tests/test_exchange_mechanics.py +++ b/MALKHUT/malkhut/tests/test_exchange_mechanics.py @@ -41,7 +41,7 @@ class TestPostOnlyRejection: cwm = MinimalCryptoLOBCWM() s = _state() # price = best_bid - (-10)*tick = 50000 + 1.0 = 50001.0 = best_ask - a = FulfilmentAction(ActionKind.PLACE, Side.BUY, OrderType.POST_ONLY, -10, 0.1, 200, post_only=True) + a = FulfilmentAction(ActionKind.PLACE, Side.BUY, OrderType.LIMIT, -10, 0.1, 200, post_only=True) r = cwm.transition(s, (a,)) assert r.account.equity == s.account.equity @@ -49,14 +49,14 @@ class TestPostOnlyRejection: cwm = MinimalCryptoLOBCWM() s = _state() # price = best_ask + (-10)*tick = 50001 - 1.0 = 50000.0 = best_bid - a = FulfilmentAction(ActionKind.PLACE, Side.SELL, OrderType.POST_ONLY, -10, 0.1, 200, post_only=True) + a = FulfilmentAction(ActionKind.PLACE, Side.SELL, OrderType.LIMIT, -10, 0.1, 200, post_only=True) r = cwm.transition(s, (a,)) assert r.account.equity == s.account.equity def test_buy_inside_spread_accepted(self): cwm = MinimalCryptoLOBCWM() s = _state() - a = FulfilmentAction(ActionKind.PLACE, Side.BUY, OrderType.POST_ONLY, 0, 0.1, 200, post_only=True) + a = FulfilmentAction(ActionKind.PLACE, Side.BUY, OrderType.LIMIT, 0, 0.1, 200, post_only=True) r = cwm.transition(s, (a,)) # Should be in open orders (passive placement) assert any(o.side == Side.BUY for o in r.open_orders) @@ -64,7 +64,7 @@ class TestPostOnlyRejection: def test_sell_inside_spread_accepted(self): cwm = MinimalCryptoLOBCWM() s = _state() - a = FulfilmentAction(ActionKind.PLACE, Side.SELL, OrderType.POST_ONLY, 0, 0.1, 200, post_only=True) + a = FulfilmentAction(ActionKind.PLACE, Side.SELL, OrderType.LIMIT, 0, 0.1, 200, post_only=True) r = cwm.transition(s, (a,)) assert any(o.side == Side.SELL for o in r.open_orders) @@ -73,21 +73,21 @@ class TestCrossSpread: def test_cross_buy_fills_at_best_ask(self): cwm = MinimalCryptoLOBCWM() s = _state() - a = FulfilmentAction(ActionKind.CROSS_SPREAD, Side.BUY, OrderType.IOC, 0, 0.1, 50) + a = FulfilmentAction(ActionKind.CROSS_SPREAD, Side.BUY, OrderType.LIMIT, 0, 0.1, 50) r = cwm.transition(s, (a,)) assert r.account.equity < s.account.equity # fees paid def test_cross_sell_fills_at_best_bid(self): cwm = MinimalCryptoLOBCWM() s = _state() - a = FulfilmentAction(ActionKind.CROSS_SPREAD, Side.SELL, OrderType.IOC, 0, 0.1, 50) + a = FulfilmentAction(ActionKind.CROSS_SPREAD, Side.SELL, OrderType.LIMIT, 0, 0.1, 50) r = cwm.transition(s, (a,)) assert r.account.equity <= s.account.equity def test_cross_spread_taker_fee_applied(self): cwm = MinimalCryptoLOBCWM() s = _state() - a = FulfilmentAction(ActionKind.CROSS_SPREAD, Side.BUY, OrderType.IOC, 0, 0.1, 50) + a = FulfilmentAction(ActionKind.CROSS_SPREAD, Side.BUY, OrderType.LIMIT, 0, 0.1, 50) r = cwm.transition(s, (a,)) fee = s.venue.taker_fee_bps assert fee > 0 @@ -97,7 +97,7 @@ class TestCancelOrder: def test_cancel_removes_order(self): oo = OpenOrderState( client_order_id="c1", venue_order_id="v1", symbol="BTCUSDT", - side=Side.BUY, order_type=OrderType.POST_ONLY, price=50000.0, + side=Side.BUY, order_type=OrderType.LIMIT, price=50000.0, qty=0.001, remaining_qty=0.001, queue_ahead_estimate=0.001, created_ts_ns=1_000_000_000, last_update_ts_ns=1_000_000_000, post_only=True, @@ -111,7 +111,7 @@ class TestCancelOrder: def test_cancel_wrong_id_keeps_order(self): oo = OpenOrderState( client_order_id="c1", venue_order_id="v1", symbol="BTCUSDT", - side=Side.BUY, order_type=OrderType.POST_ONLY, price=50000.0, + side=Side.BUY, order_type=OrderType.LIMIT, price=50000.0, qty=0.001, remaining_qty=0.001, queue_ahead_estimate=0.001, created_ts_ns=1_000_000_000, last_update_ts_ns=1_000_000_000, post_only=True, @@ -125,7 +125,7 @@ class TestCancelOrder: def test_cancel_replace_removes_old_adds_new(self): oo = OpenOrderState( client_order_id="c1", venue_order_id="v1", symbol="BTCUSDT", - side=Side.BUY, order_type=OrderType.POST_ONLY, price=50000.0, + side=Side.BUY, order_type=OrderType.LIMIT, price=50000.0, qty=0.001, remaining_qty=0.001, queue_ahead_estimate=0.001, created_ts_ns=1_000_000_000, last_update_ts_ns=1_000_000_000, post_only=True, @@ -133,7 +133,7 @@ class TestCancelOrder: cwm = MinimalCryptoLOBCWM() s = _state(open_orders=(oo,)) a = FulfilmentAction( - ActionKind.CANCEL_REPLACE, Side.BUY, OrderType.POST_ONLY, 0, 0.25, + ActionKind.CANCEL_REPLACE, Side.BUY, OrderType.LIMIT, 0, 0.25, 200, cancel_order_id="c1", post_only=True, ) r = cwm.transition(s, (a,)) @@ -145,7 +145,7 @@ class TestAccountUpdate: def test_buy_increases_position(self): cwm = MinimalCryptoLOBCWM() s = _state() - a = FulfilmentAction(ActionKind.CROSS_SPREAD, Side.BUY, OrderType.IOC, 0, 0.1, 50) + a = FulfilmentAction(ActionKind.CROSS_SPREAD, Side.BUY, OrderType.LIMIT, 0, 0.1, 50) r = cwm.transition(s, (a,)) pos = r.account.positions.get("BTCUSDT") assert pos is not None @@ -165,7 +165,7 @@ class TestAccountUpdate: available_balance=10000.0, margin_used=0.0, total_notional=5000.0, positions={"BTCUSDT": pos}, )) - a = FulfilmentAction(ActionKind.CROSS_SPREAD, Side.SELL, OrderType.IOC, 0, 0.1, 50) + a = FulfilmentAction(ActionKind.CROSS_SPREAD, Side.SELL, OrderType.LIMIT, 0, 0.1, 50) r = cwm.transition(s, (a,)) new_pos = r.account.positions.get("BTCUSDT") assert new_pos.qty < pos.qty @@ -173,7 +173,7 @@ class TestAccountUpdate: def test_fees_reduce_equity(self): cwm = MinimalCryptoLOBCWM() s = _state() - a = FulfilmentAction(ActionKind.CROSS_SPREAD, Side.BUY, OrderType.IOC, 0, 0.1, 50) + a = FulfilmentAction(ActionKind.CROSS_SPREAD, Side.BUY, OrderType.LIMIT, 0, 0.1, 50) r = cwm.transition(s, (a,)) assert r.account.equity < s.account.equity @@ -188,7 +188,7 @@ class TestAccountUpdate: cwm = MinimalCryptoLOBCWM() s = _state() # Both maker and taker should apply their respective fees - a_cross = FulfilmentAction(ActionKind.CROSS_SPREAD, Side.BUY, OrderType.IOC, 0, 0.1, 50) + a_cross = FulfilmentAction(ActionKind.CROSS_SPREAD, Side.BUY, OrderType.LIMIT, 0, 0.1, 50) r_cross = cwm.transition(s, (a_cross,)) assert s.venue.taker_fee_bps > s.venue.maker_fee_bps @@ -197,7 +197,7 @@ class TestPassivePlacement: def test_passive_order_added_to_book(self): cwm = MinimalCryptoLOBCWM() s = _state() - a = FulfilmentAction(ActionKind.PLACE, Side.BUY, OrderType.POST_ONLY, 1, 0.1, 200, post_only=True) + a = FulfilmentAction(ActionKind.PLACE, Side.BUY, OrderType.LIMIT, 1, 0.1, 200, post_only=True) r = cwm.transition(s, (a,)) assert len(r.open_orders) == 1 assert r.open_orders[0].side == Side.BUY @@ -205,14 +205,14 @@ class TestPassivePlacement: def test_passive_order_price_correct(self): cwm = MinimalCryptoLOBCWM() s = _state() - a = FulfilmentAction(ActionKind.PLACE, Side.BUY, OrderType.POST_ONLY, 1, 0.1, 200, post_only=True) + a = FulfilmentAction(ActionKind.PLACE, Side.BUY, OrderType.LIMIT, 1, 0.1, 200, post_only=True) r = cwm.transition(s, (a,)) assert r.open_orders[0].price == 49999.9 def test_passive_order_symbol_matches(self): cwm = MinimalCryptoLOBCWM() s = _state() - a = FulfilmentAction(ActionKind.PLACE, Side.BUY, OrderType.POST_ONLY, 0, 0.1, 200, post_only=True) + a = FulfilmentAction(ActionKind.PLACE, Side.BUY, OrderType.LIMIT, 0, 0.1, 200, post_only=True) r = cwm.transition(s, (a,)) assert r.open_orders[0].symbol == "BTCUSDT" diff --git a/MALKHUT/malkhut/tests/test_harness.py b/MALKHUT/malkhut/tests/test_harness.py index f8619bb..fd073f2 100644 --- a/MALKHUT/malkhut/tests/test_harness.py +++ b/MALKHUT/malkhut/tests/test_harness.py @@ -359,7 +359,7 @@ def _noop(): def _cross(side, frac): - return FulfilmentAction(ActionKind.CROSS_SPREAD, side, OrderType.IOC, 0, frac, 50) + return FulfilmentAction(ActionKind.CROSS_SPREAD, side, OrderType.LIMIT, 0, frac, 50) def _place(side, offset=0, frac=0.1): diff --git a/MALKHUT/malkhut/tests/test_hypothesis_properties.py b/MALKHUT/malkhut/tests/test_hypothesis_properties.py index 570eeb0..91d580b 100644 --- a/MALKHUT/malkhut/tests/test_hypothesis_properties.py +++ b/MALKHUT/malkhut/tests/test_hypothesis_properties.py @@ -105,7 +105,7 @@ class TestCWMProperties: account=AccountState(ts_ns=1, equity=10000.0, wallet_balance=10000.0, available_balance=10000.0, margin_used=0.0, total_notional=0.0), ) - a = FulfilmentAction(ActionKind.PLACE, Side.BUY, OrderType.POST_ONLY, offset, 0.1, 200) + a = FulfilmentAction(ActionKind.PLACE, Side.BUY, OrderType.LIMIT, offset, 0.1, 200) price = materialize_price_from_action(s, a) assert price is not None assert price <= book.best_bid # buy offset should be <= best bid diff --git a/MALKHUT/malkhut/tests/test_order_types.py b/MALKHUT/malkhut/tests/test_order_types.py index d16f3bc..24d7da5 100644 --- a/MALKHUT/malkhut/tests/test_order_types.py +++ b/MALKHUT/malkhut/tests/test_order_types.py @@ -1,83 +1,135 @@ """ Tests for standardized order types — FIX/CCXT-aligned, multi-exchange. +Three orthogonal dimensions: OrderType, TimeInForce, OrderInstruction. """ import pytest from malkhut.training.order_types import ( - BaseType, TimeInForce, ConditionalType, OrderInstruction, CompoundOrder, - EXCHANGE_ORDER_MAP, normalize_to_exchange, get_supported_types, is_type_available, + OrderType, TimeInForce, OrderInstruction, + EXCHANGE_ORDER_TYPE_MAP, EXCHANGE_TIF_MAP, EXCHANGE_INSTRUCTION_MAP, + normalize_type_to_exchange, normalize_tif_to_exchange, + get_supported_types, is_type_available, decompose_order, ) class TestOrderTypeEnums: - def test_base_types(self): - assert BaseType.MARKET.value == "market" - assert BaseType.LIMIT.value == "limit" + def test_core_order_types(self): + assert OrderType.MARKET.value == "MARKET" + assert OrderType.LIMIT.value == "LIMIT" + assert OrderType.STOP_MARKET.value == "STOP_MARKET" + assert OrderType.STOP_LIMIT.value == "STOP_LIMIT" + assert OrderType.TRIGGER_MARKET.value == "TRIGGER_MARKET" + assert OrderType.TRIGGER_LIMIT.value == "TRIGGER_LIMIT" + assert OrderType.TRAILING_STOP.value == "TRAILING_STOP" def test_time_in_force(self): - assert TimeInForce.GTC.value == "gtc" - assert TimeInForce.IOC.value == "ioc" - assert TimeInForce.FOK.value == "fok" - - def test_conditional_types(self): - assert ConditionalType.STOP_MARKET.value == "stop_market" - assert ConditionalType.STOP_LIMIT.value == "stop_limit" - assert ConditionalType.TRAILING_STOP.value == "trailing_stop" + assert TimeInForce.GTC.value == "GTC" + assert TimeInForce.IOC.value == "IOC" + assert TimeInForce.FOK.value == "FOK" + assert TimeInForce.GTD.value == "GTD" def test_instructions(self): - assert OrderInstruction.POST_ONLY.value == "post_only" - assert OrderInstruction.REDUCE_ONLY.value == "reduce_only" + assert OrderInstruction.POST_ONLY.value == "POST_ONLY" + assert OrderInstruction.REDUCE_ONLY.value == "REDUCE_ONLY" + assert OrderInstruction.HIDDEN.value == "HIDDEN" + assert OrderInstruction.ICEBERG.value == "ICEBERG" - def test_compound(self): - assert CompoundOrder.OCO.value == "oco" - assert CompoundOrder.TP_SL.value == "tp_sl" + def test_post_only_is_not_order_type(self): + """POST_ONLY is an instruction, not an order type.""" + assert not hasattr(OrderType, "POST_ONLY") + assert hasattr(OrderInstruction, "POST_ONLY") + + def test_ioc_is_not_order_type(self): + """IOC is a TimeInForce, not an order type.""" + assert not hasattr(OrderType, "IOC") + assert hasattr(TimeInForce, "IOC") -class TestExchangeMapping: +class TestExchangeOrderTypeMapping: def test_binance_has_all_types(self): types = get_supported_types("binance") - assert "limit" in types - assert "market" in types - assert "stop_market" in types - assert "post_only" in types + assert "LIMIT" in types + assert "MARKET" in types + assert "STOP_MARKET" in types + assert "TRAILING_STOP" in types def test_bingx_has_all_types(self): types = get_supported_types("bingx") - assert "limit" in types - assert "market" in types - assert "trigger_market" in types + assert "LIMIT" in types + assert "MARKET" in types + assert "TRIGGER_MARKET" in types + assert "TRAILING_STOP" in types def test_bybit_has_all_types(self): types = get_supported_types("bybit") - assert "limit" in types - assert "market" in types - assert "stop_market" in types + assert "LIMIT" in types + assert "MARKET" in types + assert "STOP_MARKET" in types def test_normalize_limit_all_exchanges(self): - """LIMIT should map to LIMIT on all exchanges.""" for ex in ["binance", "bingx", "bybit"]: - assert normalize_to_exchange("limit", ex) == "LIMIT" + assert normalize_type_to_exchange(OrderType.LIMIT, ex) == "LIMIT" def test_normalize_market_all_exchanges(self): - """MARKET should map to MARKET on all exchanges.""" for ex in ["binance", "bingx", "bybit"]: - assert normalize_to_exchange("market", ex) == "MARKET" + assert normalize_type_to_exchange(OrderType.MARKET, ex) == "MARKET" - def test_normalize_post_only_varies(self): - """POST_ONLY maps differently across exchanges.""" - assert normalize_to_exchange("post_only", "binance") == "LIMIT_MAKER" - assert normalize_to_exchange("post_only", "bingx") == "POST_ONLY" - assert normalize_to_exchange("post_only", "bybit") == "POST_ONLY" + def test_bingx_stop_market(self): + assert normalize_type_to_exchange(OrderType.STOP_MARKET, "bingx") == "TRIGGER_MARKET" - def test_normalize_unknown_type(self): - assert normalize_to_exchange("invalid_type", "binance") is None + def test_bingx_trailing_stop(self): + assert normalize_type_to_exchange(OrderType.TRAILING_STOP, "bingx") == "TRAILING_STOP_MARKET" + + def test_binance_trailing_stop(self): + assert normalize_type_to_exchange(OrderType.TRAILING_STOP, "binance") == "TRAILING_STOP_MARKET" + + def test_normalize_tif(self): + assert normalize_tif_to_exchange(TimeInForce.IOC, "bingx") == "IOC" + assert normalize_tif_to_exchange(TimeInForce.FOK, "bingx") == "FOK" + assert normalize_tif_to_exchange(TimeInForce.GTC, "bingx") == "GTC" def test_is_type_available(self): - assert is_type_available("limit", "binance") - assert is_type_available("stop_market", "bingx") - assert not is_type_available("invalid", "binance") + assert is_type_available(OrderType.LIMIT, "binance") + assert is_type_available(OrderType.STOP_MARKET, "bingx") + assert is_type_available(OrderType.TRAILING_STOP, "bybit") def test_get_supported_types_unique(self): - """Each exchange should support at least 8 types.""" for ex in ["binance", "bingx", "bybit"]: types = get_supported_types(ex) - assert len(types) >= 8 + assert len(types) >= 7 + + +class TestDecomposeOrder: + def test_decompose_ioc(self): + ot, tif, inst = decompose_order("IOC") + assert ot == "LIMIT" + assert tif == "IOC" + assert inst is None + + def test_decompose_fok(self): + ot, tif, inst = decompose_order("FOK") + assert ot == "LIMIT" + assert tif == "FOK" + + def test_decompose_post_only(self): + ot, tif, inst = decompose_order("POST_ONLY") + assert ot == "LIMIT" + assert tif == "GTC" + assert inst == "POST_ONLY" + + def test_decompose_reduce_only(self): + ot, tif, inst = decompose_order("REDUCE_ONLY") + assert ot == "MARKET" + assert tif == "GTC" + assert inst == "REDUCE_ONLY" + + def test_decompose_market(self): + ot, tif, inst = decompose_order("MARKET") + assert ot == "MARKET" + assert tif == "GTC" + assert inst is None + + def test_decompose_limit(self): + ot, tif, inst = decompose_order("LIMIT") + assert ot == "LIMIT" + assert tif == "GTC" + assert inst is None diff --git a/MALKHUT/malkhut/tests/test_replay_exhaustive.py b/MALKHUT/malkhut/tests/test_replay_exhaustive.py index 2d8b9aa..96789a6 100644 --- a/MALKHUT/malkhut/tests/test_replay_exhaustive.py +++ b/MALKHUT/malkhut/tests/test_replay_exhaustive.py @@ -67,7 +67,7 @@ def _noop(): def _cross(side, frac=0.1): - return FulfilmentAction(ActionKind.CROSS_SPREAD, side, OrderType.IOC, 0, frac, 50) + return FulfilmentAction(ActionKind.CROSS_SPREAD, side, OrderType.LIMIT, 0, frac, 50) # ══════════════════════════════════════════════════════════════════════════════ diff --git a/MALKHUT/malkhut/tests/test_risk.py b/MALKHUT/malkhut/tests/test_risk.py index 05cbc8f..447be34 100644 --- a/MALKHUT/malkhut/tests/test_risk.py +++ b/MALKHUT/malkhut/tests/test_risk.py @@ -69,7 +69,7 @@ class TestRiskGate: gate = RiskGate() # offset=-10 => price = best_bid + 10*tick = 50001.0 >= best_ask => crosses action = FulfilmentAction( - ActionKind.PLACE, Side.BUY, OrderType.POST_ONLY, -10, 0.10, 200, + ActionKind.PLACE, Side.BUY, OrderType.LIMIT, -10, 0.10, 200, post_only=True, ) planned = PlannedPolicy(actions=(action,), probabilities=(1.0,), @@ -98,7 +98,7 @@ class TestRiskGate: def test_approved_action_passes(self): gate = RiskGate() action = FulfilmentAction( - ActionKind.PLACE, Side.BUY, OrderType.POST_ONLY, 1, 0.10, 200, + ActionKind.PLACE, Side.BUY, OrderType.LIMIT, 1, 0.10, 200, post_only=True, ) planned = PlannedPolicy(actions=(action,), probabilities=(1.0,), diff --git a/MALKHUT/malkhut/tests/test_score_diagnostic.py b/MALKHUT/malkhut/tests/test_score_diagnostic.py index 007cb7f..247fa52 100644 --- a/MALKHUT/malkhut/tests/test_score_diagnostic.py +++ b/MALKHUT/malkhut/tests/test_score_diagnostic.py @@ -145,7 +145,7 @@ def _intent(): def _cross(side, frac): - return FulfilmentAction(ActionKind.CROSS_SPREAD, side, OrderType.IOC, 0, frac, 50) + return FulfilmentAction(ActionKind.CROSS_SPREAD, side, OrderType.LIMIT, 0, frac, 50) def _place(side, offset=0, frac=0.1): diff --git a/MALKHUT/malkhut/tests/test_state_invariants.py b/MALKHUT/malkhut/tests/test_state_invariants.py index 16f11fc..754d6a0 100644 --- a/MALKHUT/malkhut/tests/test_state_invariants.py +++ b/MALKHUT/malkhut/tests/test_state_invariants.py @@ -124,7 +124,8 @@ class TestEnums: def test_order_type_values(self): assert OrderType.LIMIT.value == "LIMIT" - assert OrderType.POST_ONLY.value == "POST_ONLY" + assert OrderType.MARKET.value == "MARKET" + assert OrderType.STOP_MARKET.value == "STOP_MARKET" class TestTradePathState: diff --git a/MALKHUT/malkhut/training/dsl.py b/MALKHUT/malkhut/training/dsl.py index 31be947..02fb05c 100644 --- a/MALKHUT/malkhut/training/dsl.py +++ b/MALKHUT/malkhut/training/dsl.py @@ -609,15 +609,16 @@ def _primitive_to_action(primitive: ActionPrimitive, state: MarketWorldState) -> elif at in (ActionType.QUOTE, ActionType.JOIN_QUEUE, ActionType.STEP_BACK, ActionType.LADDER, ActionType.GRID, ActionType.ICEBERG, ActionType.TWAP): return FulfilmentAction( - kind=ActionKind.PLACE, side=primitive.side, order_type=OrderType.POST_ONLY, + kind=ActionKind.PLACE, side=primitive.side, order_type=OrderType.LIMIT, price_ticks_from_best=primitive.offset_ticks, qty_fraction=primitive.size_fraction, ttl_ms=int(primitive.duration_s * 1000), post_only=True, ) elif at in (ActionType.CROSS, ActionType.SNIPER, ActionType.PING): return FulfilmentAction( - kind=ActionKind.CROSS_SPREAD, side=primitive.side, order_type=OrderType.IOC, + kind=ActionKind.CROSS_SPREAD, side=primitive.side, order_type=OrderType.LIMIT, price_ticks_from_best=0, qty_fraction=primitive.size_fraction, ttl_ms=50, + time_in_force="IOC", ) elif at == ActionType.CANCEL_ALL: @@ -636,7 +637,7 @@ def _primitive_to_action(primitive: ActionPrimitive, state: MarketWorldState) -> if side is None: return FulfilmentAction(ActionKind.NOOP, None, None, 0, 0.0, 0) return FulfilmentAction( - kind=ActionKind.FULL_EXIT, side=side, order_type=OrderType.REDUCE_ONLY_MARKET, + kind=ActionKind.FULL_EXIT, side=side, order_type=OrderType.MARKET, price_ticks_from_best=0, qty_fraction=1.0, ttl_ms=0, reduce_only=True, ) @@ -646,7 +647,7 @@ def _primitive_to_action(primitive: ActionPrimitive, state: MarketWorldState) -> if side is None: return FulfilmentAction(ActionKind.NOOP, None, None, 0, 0.0, 0) return FulfilmentAction( - kind=ActionKind.FULL_EXIT, side=side, order_type=OrderType.REDUCE_ONLY_MARKET, + kind=ActionKind.FULL_EXIT, side=side, order_type=OrderType.MARKET, price_ticks_from_best=0, qty_fraction=1.0, ttl_ms=0, reduce_only=True, metadata={"reason": "stop_loss"}, ) @@ -657,7 +658,7 @@ def _primitive_to_action(primitive: ActionPrimitive, state: MarketWorldState) -> if side is None: return FulfilmentAction(ActionKind.NOOP, None, None, 0, 0.0, 0) return FulfilmentAction( - kind=ActionKind.FULL_EXIT, side=side, order_type=OrderType.REDUCE_ONLY_MARKET, + kind=ActionKind.FULL_EXIT, side=side, order_type=OrderType.MARKET, price_ticks_from_best=0, qty_fraction=1.0, ttl_ms=0, reduce_only=True, metadata={"reason": "take_profit"}, ) @@ -668,7 +669,7 @@ def _primitive_to_action(primitive: ActionPrimitive, state: MarketWorldState) -> if side is None: return FulfilmentAction(ActionKind.NOOP, None, None, 0, 0.0, 0) return FulfilmentAction( - kind=ActionKind.FULL_EXIT, side=side, order_type=OrderType.REDUCE_ONLY_MARKET, + kind=ActionKind.FULL_EXIT, side=side, order_type=OrderType.MARKET, price_ticks_from_best=0, qty_fraction=1.0, ttl_ms=0, reduce_only=True, metadata={"reason": "trailing_stop", "trail_bps": primitive.trail_distance_bps}, ) @@ -679,7 +680,7 @@ def _primitive_to_action(primitive: ActionPrimitive, state: MarketWorldState) -> if side is None: return FulfilmentAction(ActionKind.NOOP, None, None, 0, 0.0, 0) return FulfilmentAction( - kind=ActionKind.REDUCE, side=side, order_type=OrderType.REDUCE_ONLY_MARKET, + kind=ActionKind.REDUCE, side=side, order_type=OrderType.MARKET, price_ticks_from_best=0, qty_fraction=0.5, ttl_ms=0, reduce_only=True, ) @@ -689,7 +690,7 @@ def _primitive_to_action(primitive: ActionPrimitive, state: MarketWorldState) -> if side is None: return FulfilmentAction(ActionKind.NOOP, None, None, 0, 0.0, 0) return FulfilmentAction( - kind=ActionKind.REDUCE, side=side, order_type=OrderType.REDUCE_ONLY_MARKET, + kind=ActionKind.REDUCE, side=side, order_type=OrderType.MARKET, price_ticks_from_best=0, qty_fraction=0.25, ttl_ms=0, reduce_only=True, ) @@ -705,7 +706,7 @@ def _primitive_to_action(primitive: ActionPrimitive, state: MarketWorldState) -> elif at == ActionType.REQUOTE: return FulfilmentAction( - kind=ActionKind.PLACE, side=primitive.side, order_type=OrderType.POST_ONLY, + kind=ActionKind.PLACE, side=primitive.side, order_type=OrderType.LIMIT, price_ticks_from_best=primitive.offset_ticks, qty_fraction=primitive.size_fraction, ttl_ms=int(primitive.duration_s * 1000), post_only=True, ) diff --git a/MALKHUT/malkhut/training/order_types.py b/MALKHUT/malkhut/training/order_types.py index c66d3cd..1273e2e 100644 --- a/MALKHUT/malkhut/training/order_types.py +++ b/MALKHUT/malkhut/training/order_types.py @@ -1,120 +1,198 @@ """ Standardized Order Types — FIX/CCXT-aligned, multi-exchange compatible. -Five-layer taxonomy normalized to industry standards: - Layer 1: Base types (FIX Tag 40 OrdType) - Layer 2: Time-in-force (FIX Tag 59) - Layer 3: Conditional/Trigger (FIX Tag 3/4 + MIT) - Layer 4: Instructions (FIX Tag 18) - Layer 5: Compound (exchange-specific) +Three orthogonal dimensions (not one flat enum): + + 1. Order Type (FIX Tag 40 OrdType): what the order IS + LIMIT, MARKET, STOP_MARKET, STOP_LIMIT, TRIGGER_MARKET, TRIGGER_LIMIT, + TRAILING_STOP + + 2. Time-in-Force (FIX Tag 59): how long the order LIVES + GTC, IOC, FOK, GTD + + 3. Instructions (FIX Tag 18 ExecInst): behavioral modifiers + POST_ONLY, REDUCE_ONLY, HIDDEN, ICEBERG + +Plus compound types (exchange-specific, no FIX equivalent): + OCO, TP_SL + +CRITICAL INSIGHT (Fable): POST_ONLY / IOC / FOK are NOT order types. + IOC and FOK are TimeInForce values applied to a LIMIT order. + POST_ONLY is an ExecInst / TIF modifier on a LIMIT order. + Mapping them as standalone order types conflates the taxonomy. Transferability: strategy PARAMETERS transfer across exchanges. Order type NAMES are venue-specific but semantics are identical. -The venue adapter translates normalized → exchange-native at submission. +The venue adapter translates normalized -> exchange-native at submission. """ from __future__ import annotations from enum import Enum -from typing import Dict, Optional +from typing import Dict, Optional, Tuple # ============================================================================== -# Layer 1: Base Types (FIX Tag 40 OrdType) +# Layer 1: Order Types (FIX Tag 40 OrdType) +# These are the actual TYPE values sent in the API "type" parameter. # ============================================================================== -class BaseType(str, Enum): - MARKET = "market" # FIX: 1 — immediate execution at best available price - LIMIT = "limit" # FIX: 2 — execute only at specified price or better +class OrderType(str, Enum): + """Core order types — what the order IS.""" + LIMIT = "LIMIT" # FIX: 2 + MARKET = "MARKET" # FIX: 1 + STOP_MARKET = "STOP_MARKET" # FIX: 3 — trigger -> market execution + STOP_LIMIT = "STOP_LIMIT" # FIX: 4 — trigger -> limit execution + TRIGGER_MARKET = "TRIGGER_MARKET" # FIX: J (MIT) — market if touched + TRIGGER_LIMIT = "TRIGGER_LIMIT" # FIX: 4 — limit if touched + TRAILING_STOP = "TRAILING_STOP" # FIX: P + ExecInst + OCO = "OCO" # One-Cancels-Other (exchange-specific) + TP_SL = "TP_SL" # Take-Profit / Stop-Loss (exchange-specific) # ============================================================================== # Layer 2: Time-in-Force (FIX Tag 59) +# These are SEPARATE parameters, not order types. +# Applied to LIMIT/MARKET: "How long should this order live?" # ============================================================================== class TimeInForce(str, Enum): - GTC = "gtc" # FIX: 1 — Good Till Cancel - IOC = "ioc" # FIX: 3 — Immediate or Cancel (partial fill OK) - FOK = "fok" # FIX: 4 — Fill or Kill (all-or-nothing) - GTD = "gtd" # FIX: 6 — Good Till Date + GTC = "GTC" # FIX: 1 — Good Till Cancel + IOC = "IOC" # FIX: 3 — Immediate or Cancel (partial fill OK) + FOK = "FOK" # FIX: 4 — Fill or Kill (all-or-nothing) + GTD = "GTD" # FIX: 6 — Good Till Date # ============================================================================== -# Layer 3: Conditional/Trigger (FIX Tag 3/4 + MIT) -# ============================================================================== - -class ConditionalType(str, Enum): - STOP_MARKET = "stop_market" # FIX: 3 — trigger → market - STOP_LIMIT = "stop_limit" # FIX: 4 — trigger → limit - TRIGGER_MARKET = "trigger_market" # FIX: J (MIT) — market if touched - TRIGGER_LIMIT = "trigger_limit" # FIX: 4 — limit if touched - TRAILING_STOP = "trailing_stop" # FIX: P + ExecInst — trailing stop - - -# ============================================================================== -# Layer 4: Instructions (FIX Tag 18 ExecInst) +# Layer 3: Instructions (FIX Tag 18 ExecInst) +# Behavioral modifiers — also SEPARATE from the order type. # ============================================================================== class OrderInstruction(str, Enum): - POST_ONLY = "post_only" # FIX: ExecInst — maker-only, reject if crossing - REDUCE_ONLY = "reduce_only" # FIX: ExecInst — only reduce existing position - HIDDEN = "hidden" # FIX: ExecInst — iceberg/hidden order - ICEBERG = "iceberg" # FIX: ExecInst — visible portion only + POST_ONLY = "POST_ONLY" # FIX: ExecInst — maker-only, reject if crossing + REDUCE_ONLY = "REDUCE_ONLY" # FIX: ExecInst — only reduce existing position + HIDDEN = "HIDDEN" # FIX: ExecInst — iceberg/hidden + ICEBERG = "ICEBERG" # FIX: ExecInst — visible portion only # ============================================================================== -# Layer 5: Compound (exchange-specific, no FIX equivalent) +# Exchange-specific order type mapping +# Maps normalized OrderType enum value -> exchange-native "type" parameter string. +# +# NOTE: This maps ONLY the order type dimension. TimeInForce and Instructions +# are sent as separate API parameters (timeInForce=, postOnly=, reduceOnly=). # ============================================================================== -class CompoundOrder(str, Enum): - OCO = "oco" # One-Cancels-Other (linked orders) - TP_SL = "tp_sl" # Take-Profit / Stop-Loss (attached to position) - - -# ============================================================================== -# Exchange-specific mapping tables -# ============================================================================== - -EXCHANGE_ORDER_MAP: Dict[str, Dict[str, str]] = { +# Maps normalized OrderType.value -> exchange-native "type" parameter +EXCHANGE_ORDER_TYPE_MAP: Dict[str, Dict[str, str]] = { "binance": { - "limit": "LIMIT", "market": "MARKET", - "stop_market": "STOP_MARKET", "stop_limit": "STOP_LOSS_LIMIT", - "trigger_market": "TAKE_PROFIT", "trigger_limit": "TAKE_PROFIT_LIMIT", - "trailing_stop": "TRAILING_STOP_MARKET", - "post_only": "LIMIT_MAKER", "ioc": "IOC", "fok": "FOK", - "reduce_only": "REDUCE_ONLY", + "LIMIT": "LIMIT", "MARKET": "MARKET", + "STOP_MARKET": "STOP_MARKET", "STOP_LIMIT": "STOP_LOSS_LIMIT", + "TRIGGER_MARKET": "TAKE_PROFIT", "TRIGGER_LIMIT": "TAKE_PROFIT_LIMIT", + "TRAILING_STOP": "TRAILING_STOP_MARKET", }, "bingx": { - "limit": "LIMIT", "market": "MARKET", - "stop_market": "TRIGGER_MARKET", "stop_limit": "TRIGGER_LIMIT", - "trigger_market": "TRIGGER_MARKET", "trigger_limit": "TRIGGER_LIMIT", - "trailing_stop": "TRIGGER_MARKET", - "post_only": "POST_ONLY", "ioc": "IOC", "fok": "FOK", - "reduce_only": "REDUCE_ONLY", + "LIMIT": "LIMIT", "MARKET": "MARKET", + "STOP_MARKET": "TRIGGER_MARKET", "STOP_LIMIT": "TRIGGER_LIMIT", + "TRIGGER_MARKET": "TRIGGER_MARKET", "TRIGGER_LIMIT": "TRIGGER_LIMIT", + "TRAILING_STOP": "TRAILING_STOP_MARKET", }, "bybit": { - "limit": "LIMIT", "market": "MARKET", - "stop_market": "STOP_MARKET", "stop_limit": "STOP_LIMIT", - "trigger_market": "TAKE_PROFIT_MARKET", "trigger_limit": "TAKE_PROFIT_LIMIT", - "trailing_stop": "TRAILING_STOP", - "post_only": "POST_ONLY", "ioc": "IOC", "fok": "FOK", - "reduce_only": "REDUCE_ONLY", + "LIMIT": "LIMIT", "MARKET": "MARKET", + "STOP_MARKET": "STOP_MARKET", "STOP_LIMIT": "STOP_LIMIT", + "TRIGGER_MARKET": "TAKE_PROFIT_MARKET", "TRIGGER_LIMIT": "TAKE_PROFIT_LIMIT", + "TRAILING_STOP": "TRAILING_STOP", + }, +} + +# Maps normalized TimeInForce.value -> exchange-native "timeInForce" parameter +EXCHANGE_TIF_MAP: Dict[str, Dict[str, str]] = { + "binance": { + "GTC": "GTC", "IOC": "IOC", "FOK": "FOK", "GTD": "GTD", + }, + "bingx": { + "GTC": "GTC", "IOC": "IOC", "FOK": "FOK", "GTD": "GTD", + }, + "bybit": { + "GTC": "GTC", "IOC": "IOC", "FOK": "FOK", "GTD": "GTD", + }, +} + +# Maps normalized OrderInstruction.value -> exchange parameter name + value +# POST_ONLY varies: Binance uses type=LIMIT_MAKER, BingX/Bybit use postOnly=true +# This maps the instruction to how it's sent on each exchange. +EXCHANGE_INSTRUCTION_MAP: Dict[str, Dict[str, str]] = { + "binance": { + "POST_ONLY": "LIMIT_MAKER", # Binance encodes post-only as a type + "REDUCE_ONLY": "REDUCE_ONLY", + "HIDDEN": "HIDDEN", + "ICEBERG": "ICEBERG", + }, + "bingx": { + "POST_ONLY": "POST_ONLY", # BingX: postOnly=true param on LIMIT + "REDUCE_ONLY": "REDUCE_ONLY", + "HIDDEN": "HIDDEN", + "ICEBERG": "ICEBERG", + }, + "bybit": { + "POST_ONLY": "GTX", # Bybit: timeInForce=GTX on Limit + "REDUCE_ONLY": "REDUCE_ONLY", + "HIDDEN": "HIDDEN", + "ICEBERG": "ICEBERG", }, } -def normalize_to_exchange(normalized_type: str, exchange_id: str) -> Optional[str]: - """Convert a normalized order type to exchange-native string.""" - mapping = EXCHANGE_ORDER_MAP.get(exchange_id, {}) - return mapping.get(normalized_type) +def normalize_type_to_exchange(order_type: OrderType, exchange_id: str) -> Optional[str]: + """Convert a normalized OrderType to exchange-native 'type' parameter string.""" + mapping = EXCHANGE_ORDER_TYPE_MAP.get(exchange_id, {}) + return mapping.get(order_type.value) + + +def normalize_tif_to_exchange(tif: TimeInForce, exchange_id: str) -> Optional[str]: + """Convert a normalized TimeInForce to exchange-native 'timeInForce' parameter.""" + mapping = EXCHANGE_TIF_MAP.get(exchange_id, {}) + return mapping.get(tif.value) + + +def is_type_available(order_type: OrderType, exchange_id: str) -> bool: + """Check if a normalized order type is available on an exchange.""" + mapping = EXCHANGE_ORDER_TYPE_MAP.get(exchange_id, {}) + return order_type.value in mapping def get_supported_types(exchange_id: str) -> list[str]: """Get all normalized order types supported by an exchange.""" - mapping = EXCHANGE_ORDER_MAP.get(exchange_id, {}) + mapping = EXCHANGE_ORDER_TYPE_MAP.get(exchange_id, {}) return list(mapping.keys()) -def is_type_available(normalized_type: str, exchange_id: str) -> bool: - """Check if a normalized order type is available on an exchange.""" - mapping = EXCHANGE_ORDER_MAP.get(exchange_id, {}) - return normalized_type in mapping +def decompose_order(order_type_value: str) -> Tuple[str, str, str]: + """Decompose a flat order specification into (type, tif, instruction). + + For backward compatibility with code that passes flat strings: + "IOC" -> ("LIMIT", "IOC", None) (IOC = LIMIT + timeInForce) + "FOK" -> ("LIMIT", "FOK", None) (FOK = LIMIT + timeInForce) + "POST_ONLY" -> ("LIMIT", None, "POST_ONLY") (POST_ONLY = LIMIT + instruction) + "REDUCE_ONLY" -> ("MARKET", None, "REDUCE_ONLY") + "MARKET" -> ("MARKET", "GTC", None) + "LIMIT" -> ("LIMIT", "GTC", None) + """ + ot = order_type_value.upper() + + tif_map = {"IOC": "IOC", "FOK": "FOK", "GTC": "GTC", "GTD": "GTD"} + inst_map = {"POST_ONLY": "POST_ONLY", "REDUCE_ONLY": "REDUCE_ONLY", + "HIDDEN": "HIDDEN", "ICEBERG": "ICEBERG"} + base_map = {"MARKET": "MARKET", "LIMIT": "LIMIT", + "STOP_MARKET": "STOP_MARKET", "STOP_LIMIT": "STOP_LIMIT", + "TRIGGER_MARKET": "TRIGGER_MARKET", "TRIGGER_LIMIT": "TRIGGER_LIMIT", + "TRAILING_STOP": "TRAILING_STOP", "OCO": "OCO", "TP_SL": "TP_SL"} + + if ot in base_map: + return (ot, "GTC", None) + if ot in tif_map: + return ("LIMIT", ot, None) + if ot in inst_map: + if ot == "REDUCE_ONLY": + return ("MARKET", "GTC", ot) + return ("LIMIT", "GTC", ot) + return (ot, "GTC", None) diff --git a/MALKHUT/malkhut/venue/bingx/adapter.py b/MALKHUT/malkhut/venue/bingx/adapter.py index 64da81b..6ed3e53 100644 --- a/MALKHUT/malkhut/venue/bingx/adapter.py +++ b/MALKHUT/malkhut/venue/bingx/adapter.py @@ -178,13 +178,13 @@ class BingXVenueAdapter: client_id = f"m_{state.ts_ns}_{self._order_seq}" # Determine order type — use standardized OrderType, map to BingX-native - from malkhut.training.order_types import normalize_to_exchange + from malkhut.training.order_types import ( + normalize_type_to_exchange, normalize_tif_to_exchange, + ) if action.order_type is not None: - order_type = normalize_to_exchange(action.order_type.value, "bingx") or "LIMIT" + order_type = normalize_type_to_exchange(action.order_type, "bingx") or "LIMIT" elif action.kind.value == "CROSS_SPREAD": order_type = "MARKET" - elif action.post_only: - order_type = "POST_ONLY" else: order_type = "LIMIT" @@ -197,8 +197,16 @@ class BingXVenueAdapter: "price": str(price), "quantity": str(qty), "reduceOnly": action.reduce_only, + "postOnly": action.post_only, } + # Add timeInForce if not GTC (default) + from malkhut.training.order_types import TimeInForce + if action.time_in_force != "GTC": + tif = normalize_tif_to_exchange(TimeInForce(action.time_in_force), "bingx") + if tif: + order["timeInForce"] = tif + # Track order tracked = TrackedOrder( client_order_id=client_id,