hjnormey/sentiment-engine
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

malkhut(wire): OrderType as three orthogonal dimensions — Fable's corrections

Browse Source 
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.
This commit is contained in:
Codex
2026-07-14 14:46:44 +02:00
parent a21f64e066
commit d24d9bc6bd
21 changed files with 346 additions and 199 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
MALKHUT/malkhut/actions.py
View File

@@ -11,6 +11,16 @@ from typing import Any, Mapping, Optional, Tuple
from malkhut.state import ActionKind, AgentRole, OrderType, Side 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) @dataclass(frozen=True, slots=True)
class FulfilmentAction: class FulfilmentAction:
@@ -24,8 +34,14 @@ class FulfilmentAction:
cancel_order_id: Optional[str] = None cancel_order_id: Optional[str] = None
reduce_only: bool = False reduce_only: bool = False
post_only: bool = False post_only: bool = False
time_in_force: str = "GTC"
metadata: Mapping[str, Any] = field(default_factory=dict) 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) @dataclass(frozen=True, slots=True)
class CounterpartyAction: class CounterpartyAction:

7
MALKHUT/malkhut/planner/action_menu.py
View File

@@ -90,7 +90,7 @@ def build_our_actions(
for offset in params.quote_offsets_ticks: for offset in params.quote_offsets_ticks:
actions.append(FulfilmentAction( actions.append(FulfilmentAction(
kind=ActionKind.CANCEL_REPLACE, side=side, 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, price_ticks_from_best=offset, qty_fraction=0.25,
ttl_ms=params.passive_ttl_ms, cancel_order_id=oo.client_order_id, ttl_ms=params.passive_ttl_ms, cancel_order_id=oo.client_order_id,
post_only=intent.prefer_maker, reduce_only=intent.reduce_only, 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: for frac in params.quote_size_fractions:
actions.append(FulfilmentAction( actions.append(FulfilmentAction(
kind=ActionKind.PLACE, side=side, 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, price_ticks_from_best=offset, qty_fraction=frac,
ttl_ms=params.passive_ttl_ms, ttl_ms=params.passive_ttl_ms,
post_only=intent.prefer_maker, reduce_only=intent.reduce_only, 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): for frac in (0.05, 0.10, 0.25):
actions.append(FulfilmentAction( actions.append(FulfilmentAction(
kind=ActionKind.CROSS_SPREAD, side=side, 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, qty_fraction=frac, ttl_ms=params.aggressive_ttl_ms,
time_in_force="IOC",
reduce_only=intent.reduce_only, reduce_only=intent.reduce_only,
)) ))

28
MALKHUT/malkhut/state.py
View File

@@ -26,33 +26,23 @@ class Side(str, Enum):
class OrderType(str, Enum): class OrderType(str, Enum):
"""Standardized order types — FIX/CCXT-aligned, multi-exchange. """Standardized order types — FIX/CCXT-aligned, multi-exchange.
Five-layer taxonomy (values are uppercase for backward compatibility): THREE ORTHOGONAL DIMENSIONS (not one flat enum):
Layer 1: Base types (FIX Tag 40) — MARKET, LIMIT 1. Order Type (FIX Tag 40): what the order IS — this enum
Layer 2: Time-in-force (FIX Tag 59) — GTC, IOC, FOK, GTD 2. TimeInForce (FIX Tag 59): how long it LIVES — separate parameter
Layer 3: Conditional (FIX Tag 3/4+MIT) — STOP_MARKET, STOP_LIMIT, etc. 3. Instructions (FIX Tag 18): behavioral modifiers — separate parameter
Layer 4: Instructions (FIX Tag 18) — POST_ONLY, REDUCE_ONLY, etc.
Layer 5: Compound (exchange-specific) — OCO, TP_SL 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" MARKET = "MARKET"
LIMIT = "LIMIT" 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_MARKET = "STOP_MARKET"
STOP_LIMIT = "STOP_LIMIT" STOP_LIMIT = "STOP_LIMIT"
TRIGGER_MARKET = "TRIGGER_MARKET" TRIGGER_MARKET = "TRIGGER_MARKET"
TRIGGER_LIMIT = "TRIGGER_LIMIT" TRIGGER_LIMIT = "TRIGGER_LIMIT"
TRAILING_STOP = "TRAILING_STOP" 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" OCO = "OCO"
TP_SL = "TP_SL" TP_SL = "TP_SL"

2
MALKHUT/malkhut/tests/test_adversarial.py
View File

@@ -132,7 +132,7 @@ class TestRiskGateAdversarial:
gate = RiskGate() gate = RiskGate()
state = _state_with_intent() state = _state_with_intent()
action = FulfilmentAction( 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,), planned = PlannedPolicy(actions=(action,), probabilities=(1.0,),
selected_action=action, diagnostics={}) selected_action=action, diagnostics={})

2
MALKHUT/malkhut/tests/test_bingx_adapter.py
View File

@@ -98,7 +98,7 @@ class TestOrderPlacement:
def test_place_cross_spread_market(self): def test_place_cross_spread_market(self):
adapter = BingXVenueAdapter() adapter = BingXVenueAdapter()
action = FulfilmentAction( 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() state = _state()
adapter.execute(state, _decision(action=action)) adapter.execute(state, _decision(action=action))

12
MALKHUT/malkhut/tests/test_cwm.py
View File

@@ -103,7 +103,7 @@ class TestExchangeMechanics:
cwm = MinimalCryptoLOBCWM() cwm = MinimalCryptoLOBCWM()
state = _default_state() state = _default_state()
action = FulfilmentAction( 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, post_only=True,
) )
result = cwm.transition(state, (action,)) result = cwm.transition(state, (action,))
@@ -113,7 +113,7 @@ class TestExchangeMechanics:
from malkhut.state import OpenOrderState from malkhut.state import OpenOrderState
oo = OpenOrderState( oo = OpenOrderState(
client_order_id="test_123", venue_order_id="v_123", 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, price=50000.0, qty=0.001, remaining_qty=0.001,
queue_ahead_estimate=0.001, created_ts_ns=1_000_000_000, queue_ahead_estimate=0.001, created_ts_ns=1_000_000_000,
last_update_ts_ns=1_000_000_000, post_only=True, last_update_ts_ns=1_000_000_000, post_only=True,
@@ -136,7 +136,7 @@ class TestExchangeMechanics:
state = _default_state() state = _default_state()
# Post-only buy at best_ask should be rejected # Post-only buy at best_ask should be rejected
action = FulfilmentAction( 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, post_only=True,
) )
result = cwm.transition(state, (action,)) result = cwm.transition(state, (action,))
@@ -148,7 +148,7 @@ class TestPriceMaterialization:
def test_cross_spread_buy_returns_best_ask(self): def test_cross_spread_buy_returns_best_ask(self):
state = _default_state() state = _default_state()
action = FulfilmentAction( 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) price = materialize_price_from_action(state, action)
assert price == 50001.0 assert price == 50001.0
@@ -156,7 +156,7 @@ class TestPriceMaterialization:
def test_cross_spread_sell_returns_best_bid(self): def test_cross_spread_sell_returns_best_bid(self):
state = _default_state() state = _default_state()
action = FulfilmentAction( 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) price = materialize_price_from_action(state, action)
assert price == 50000.0 assert price == 50000.0
@@ -164,7 +164,7 @@ class TestPriceMaterialization:
def test_buy_offset_0_returns_best_bid(self): def test_buy_offset_0_returns_best_bid(self):
state = _default_state() state = _default_state()
action = FulfilmentAction( 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) price = materialize_price_from_action(state, action)
assert price == 50000.0 assert price == 50000.0

20
MALKHUT/malkhut/tests/test_cwm_core.py
View File

@@ -110,32 +110,32 @@ class TestCWMDeterminism:
class TestPriceMaterialization: class TestPriceMaterialization:
def test_cross_spread_buy_returns_best_ask(self): def test_cross_spread_buy_returns_best_ask(self):
s = _state() 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 assert materialize_price_from_action(s, a) == 50001.0
def test_cross_spread_sell_returns_best_bid(self): def test_cross_spread_sell_returns_best_bid(self):
s = _state() 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 assert materialize_price_from_action(s, a) == 50000.0
def test_buy_offset_0_returns_best_bid(self): def test_buy_offset_0_returns_best_bid(self):
s = _state() 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 assert materialize_price_from_action(s, a) == 50000.0
def test_buy_offset_1_one_tick_behind(self): def test_buy_offset_1_one_tick_behind(self):
s = _state() 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 assert materialize_price_from_action(s, a) == 49999.9
def test_sell_offset_0_returns_best_ask(self): def test_sell_offset_0_returns_best_ask(self):
s = _state() 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 assert materialize_price_from_action(s, a) == 50001.0
def test_sell_offset_1_one_tick_behind(self): def test_sell_offset_1_one_tick_behind(self):
s = _state() 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 assert materialize_price_from_action(s, a) == 50001.1
def test_none_side_returns_none(self): def test_none_side_returns_none(self):
@@ -145,12 +145,12 @@ class TestPriceMaterialization:
def test_wide_spread_offsets(self): def test_wide_spread_offsets(self):
s = _state(bid=49000.0, ask=51000.0) 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 assert materialize_price_from_action(s, a) == 48999.5
def test_tight_spread_one_tick(self): def test_tight_spread_one_tick(self):
s = _state(bid=50000.0, ask=50000.1) 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 assert materialize_price_from_action(s, a) == 50000.0
@@ -190,7 +190,7 @@ class TestRewardFunction:
params = self._params(w_fee_quality=1.0) params = self._params(w_fee_quality=1.0)
s = _state() s = _state()
a = FulfilmentAction( 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,)) r = cwm.transition(s, (a,))
reward = cwm.reward(s, a, r, params) reward = cwm.reward(s, a, r, params)
@@ -200,7 +200,7 @@ class TestRewardFunction:
def test_cross_spread_penalty(self): def test_cross_spread_penalty(self):
cwm = MinimalCryptoLOBCWM() cwm = MinimalCryptoLOBCWM()
s = _state() 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,)) r = cwm.transition(s, (a,))
reward = cwm.reward(s, a, r, self._params()) reward = cwm.reward(s, a, r, self._params())
assert reward < 0 assert reward < 0

6
MALKHUT/malkhut/tests/test_cwm_exhaustive.py
View File

@@ -86,14 +86,14 @@ def _noop():
def _place(side, offset=0, frac=0.1, post_only=False, reduce_only=False): def _place(side, offset=0, frac=0.1, post_only=False, reduce_only=False):
return FulfilmentAction( return FulfilmentAction(
ActionKind.PLACE, side, ActionKind.PLACE, side,
OrderType.POST_ONLY if post_only else OrderType.LIMIT, OrderType.LIMIT if post_only else OrderType.LIMIT,
offset, frac, 200, offset, frac, 200,
post_only=post_only, reduce_only=reduce_only, post_only=post_only, reduce_only=reduce_only,
) )
def _cross(side, frac=0.1): 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): 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): def _oo(cid="c1", price=50000.0, qty=0.001, side=Side.BUY, ts=1_000_000_000):
return OpenOrderState( return OpenOrderState(
client_order_id=cid, venue_order_id="v1", symbol="BTCUSDT", 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, qty=qty, remaining_qty=qty, queue_ahead_estimate=qty * 0.5,
created_ts_ns=ts, last_update_ts_ns=ts, post_only=True, created_ts_ns=ts, last_update_ts_ns=ts, post_only=True,
) )

2
MALKHUT/malkhut/tests/test_diagnostic.py
View File

@@ -223,7 +223,7 @@ def _noop():
def _cross(side, frac): 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): def _place(side, offset=0, frac=0.1):

2
MALKHUT/malkhut/tests/test_e2e_integration.py
View File

@@ -409,4 +409,4 @@ def _noop():
def _cross(side, frac=0.1): def _cross(side, frac=0.1):
from malkhut.actions import OrderType 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)

36
MALKHUT/malkhut/tests/test_exchange_mechanics.py
View File

@@ -41,7 +41,7 @@ class TestPostOnlyRejection:
cwm = MinimalCryptoLOBCWM() cwm = MinimalCryptoLOBCWM()
s = _state() s = _state()
# price = best_bid - (-10)*tick = 50000 + 1.0 = 50001.0 = best_ask # 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,)) r = cwm.transition(s, (a,))
assert r.account.equity == s.account.equity assert r.account.equity == s.account.equity
@@ -49,14 +49,14 @@ class TestPostOnlyRejection:
cwm = MinimalCryptoLOBCWM() cwm = MinimalCryptoLOBCWM()
s = _state() s = _state()
# price = best_ask + (-10)*tick = 50001 - 1.0 = 50000.0 = best_bid # 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,)) r = cwm.transition(s, (a,))
assert r.account.equity == s.account.equity assert r.account.equity == s.account.equity
def test_buy_inside_spread_accepted(self): def test_buy_inside_spread_accepted(self):
cwm = MinimalCryptoLOBCWM() cwm = MinimalCryptoLOBCWM()
s = _state() 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,)) r = cwm.transition(s, (a,))
# Should be in open orders (passive placement) # Should be in open orders (passive placement)
assert any(o.side == Side.BUY for o in r.open_orders) 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): def test_sell_inside_spread_accepted(self):
cwm = MinimalCryptoLOBCWM() cwm = MinimalCryptoLOBCWM()
s = _state() 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,)) r = cwm.transition(s, (a,))
assert any(o.side == Side.SELL for o in r.open_orders) 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): def test_cross_buy_fills_at_best_ask(self):
cwm = MinimalCryptoLOBCWM() cwm = MinimalCryptoLOBCWM()
s = _state() 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,)) r = cwm.transition(s, (a,))
assert r.account.equity < s.account.equity # fees paid assert r.account.equity < s.account.equity # fees paid
def test_cross_sell_fills_at_best_bid(self): def test_cross_sell_fills_at_best_bid(self):
cwm = MinimalCryptoLOBCWM() cwm = MinimalCryptoLOBCWM()
s = _state() 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,)) r = cwm.transition(s, (a,))
assert r.account.equity <= s.account.equity assert r.account.equity <= s.account.equity
def test_cross_spread_taker_fee_applied(self): def test_cross_spread_taker_fee_applied(self):
cwm = MinimalCryptoLOBCWM() cwm = MinimalCryptoLOBCWM()
s = _state() 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,)) r = cwm.transition(s, (a,))
fee = s.venue.taker_fee_bps fee = s.venue.taker_fee_bps
assert fee > 0 assert fee > 0
@@ -97,7 +97,7 @@ class TestCancelOrder:
def test_cancel_removes_order(self): def test_cancel_removes_order(self):
oo = OpenOrderState( oo = OpenOrderState(
client_order_id="c1", venue_order_id="v1", symbol="BTCUSDT", 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, 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, created_ts_ns=1_000_000_000, last_update_ts_ns=1_000_000_000,
post_only=True, post_only=True,
@@ -111,7 +111,7 @@ class TestCancelOrder:
def test_cancel_wrong_id_keeps_order(self): def test_cancel_wrong_id_keeps_order(self):
oo = OpenOrderState( oo = OpenOrderState(
client_order_id="c1", venue_order_id="v1", symbol="BTCUSDT", 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, 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, created_ts_ns=1_000_000_000, last_update_ts_ns=1_000_000_000,
post_only=True, post_only=True,
@@ -125,7 +125,7 @@ class TestCancelOrder:
def test_cancel_replace_removes_old_adds_new(self): def test_cancel_replace_removes_old_adds_new(self):
oo = OpenOrderState( oo = OpenOrderState(
client_order_id="c1", venue_order_id="v1", symbol="BTCUSDT", 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, 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, created_ts_ns=1_000_000_000, last_update_ts_ns=1_000_000_000,
post_only=True, post_only=True,
@@ -133,7 +133,7 @@ class TestCancelOrder:
cwm = MinimalCryptoLOBCWM() cwm = MinimalCryptoLOBCWM()
s = _state(open_orders=(oo,)) s = _state(open_orders=(oo,))
a = FulfilmentAction( 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, 200, cancel_order_id="c1", post_only=True,
) )
r = cwm.transition(s, (a,)) r = cwm.transition(s, (a,))
@@ -145,7 +145,7 @@ class TestAccountUpdate:
def test_buy_increases_position(self): def test_buy_increases_position(self):
cwm = MinimalCryptoLOBCWM() cwm = MinimalCryptoLOBCWM()
s = _state() 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,)) r = cwm.transition(s, (a,))
pos = r.account.positions.get("BTCUSDT") pos = r.account.positions.get("BTCUSDT")
assert pos is not None assert pos is not None
@@ -165,7 +165,7 @@ class TestAccountUpdate:
available_balance=10000.0, margin_used=0.0, total_notional=5000.0, available_balance=10000.0, margin_used=0.0, total_notional=5000.0,
positions={"BTCUSDT": pos}, 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,)) r = cwm.transition(s, (a,))
new_pos = r.account.positions.get("BTCUSDT") new_pos = r.account.positions.get("BTCUSDT")
assert new_pos.qty < pos.qty assert new_pos.qty < pos.qty
@@ -173,7 +173,7 @@ class TestAccountUpdate:
def test_fees_reduce_equity(self): def test_fees_reduce_equity(self):
cwm = MinimalCryptoLOBCWM() cwm = MinimalCryptoLOBCWM()
s = _state() 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,)) r = cwm.transition(s, (a,))
assert r.account.equity < s.account.equity assert r.account.equity < s.account.equity
@@ -188,7 +188,7 @@ class TestAccountUpdate:
cwm = MinimalCryptoLOBCWM() cwm = MinimalCryptoLOBCWM()
s = _state() s = _state()
# Both maker and taker should apply their respective fees # 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,)) r_cross = cwm.transition(s, (a_cross,))
assert s.venue.taker_fee_bps > s.venue.maker_fee_bps 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): def test_passive_order_added_to_book(self):
cwm = MinimalCryptoLOBCWM() cwm = MinimalCryptoLOBCWM()
s = _state() 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,)) r = cwm.transition(s, (a,))
assert len(r.open_orders) == 1 assert len(r.open_orders) == 1
assert r.open_orders[0].side == Side.BUY assert r.open_orders[0].side == Side.BUY
@@ -205,14 +205,14 @@ class TestPassivePlacement:
def test_passive_order_price_correct(self): def test_passive_order_price_correct(self):
cwm = MinimalCryptoLOBCWM() cwm = MinimalCryptoLOBCWM()
s = _state() 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,)) r = cwm.transition(s, (a,))
assert r.open_orders[0].price == 49999.9 assert r.open_orders[0].price == 49999.9
def test_passive_order_symbol_matches(self): def test_passive_order_symbol_matches(self):
cwm = MinimalCryptoLOBCWM() cwm = MinimalCryptoLOBCWM()
s = _state() 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,)) r = cwm.transition(s, (a,))
assert r.open_orders[0].symbol == "BTCUSDT" assert r.open_orders[0].symbol == "BTCUSDT"

2
MALKHUT/malkhut/tests/test_harness.py
View File

@@ -359,7 +359,7 @@ def _noop():
def _cross(side, frac): 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): def _place(side, offset=0, frac=0.1):

2
MALKHUT/malkhut/tests/test_hypothesis_properties.py
View File

@@ -105,7 +105,7 @@ class TestCWMProperties:
account=AccountState(ts_ns=1, equity=10000.0, wallet_balance=10000.0, account=AccountState(ts_ns=1, equity=10000.0, wallet_balance=10000.0,
available_balance=10000.0, margin_used=0.0, total_notional=0.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) price = materialize_price_from_action(s, a)
assert price is not None assert price is not None
assert price <= book.best_bid # buy offset should be <= best bid assert price <= book.best_bid # buy offset should be <= best bid

142
MALKHUT/malkhut/tests/test_order_types.py
View File

@@ -1,83 +1,135 @@
""" """
Tests for standardized order types — FIX/CCXT-aligned, multi-exchange. Tests for standardized order types — FIX/CCXT-aligned, multi-exchange.
Three orthogonal dimensions: OrderType, TimeInForce, OrderInstruction.
""" """
import pytest import pytest
from malkhut.training.order_types import ( from malkhut.training.order_types import (
BaseType, TimeInForce, ConditionalType, OrderInstruction, CompoundOrder, OrderType, TimeInForce, OrderInstruction,
EXCHANGE_ORDER_MAP, normalize_to_exchange, get_supported_types, is_type_available, 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: class TestOrderTypeEnums:
def test_base_types(self): def test_core_order_types(self):
assert BaseType.MARKET.value == "market" assert OrderType.MARKET.value == "MARKET"
assert BaseType.LIMIT.value == "limit" 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): def test_time_in_force(self):
assert TimeInForce.GTC.value == "gtc" assert TimeInForce.GTC.value == "GTC"
assert TimeInForce.IOC.value == "ioc" assert TimeInForce.IOC.value == "IOC"
assert TimeInForce.FOK.value == "fok" assert TimeInForce.FOK.value == "FOK"
assert TimeInForce.GTD.value == "GTD"
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"
def test_instructions(self): def test_instructions(self):
assert OrderInstruction.POST_ONLY.value == "post_only" assert OrderInstruction.POST_ONLY.value == "POST_ONLY"
assert OrderInstruction.REDUCE_ONLY.value == "reduce_only" assert OrderInstruction.REDUCE_ONLY.value == "REDUCE_ONLY"
assert OrderInstruction.HIDDEN.value == "HIDDEN"
assert OrderInstruction.ICEBERG.value == "ICEBERG"
def test_compound(self): def test_post_only_is_not_order_type(self):
assert CompoundOrder.OCO.value == "oco" """POST_ONLY is an instruction, not an order type."""
assert CompoundOrder.TP_SL.value == "tp_sl" 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): def test_binance_has_all_types(self):
types = get_supported_types("binance") types = get_supported_types("binance")
assert "limit" in types assert "LIMIT" in types
assert "market" in types assert "MARKET" in types
assert "stop_market" in types assert "STOP_MARKET" in types
assert "post_only" in types assert "TRAILING_STOP" in types
def test_bingx_has_all_types(self): def test_bingx_has_all_types(self):
types = get_supported_types("bingx") types = get_supported_types("bingx")
assert "limit" in types assert "LIMIT" in types
assert "market" in types assert "MARKET" in types
assert "trigger_market" in types assert "TRIGGER_MARKET" in types
assert "TRAILING_STOP" in types
def test_bybit_has_all_types(self): def test_bybit_has_all_types(self):
types = get_supported_types("bybit") types = get_supported_types("bybit")
assert "limit" in types assert "LIMIT" in types
assert "market" in types assert "MARKET" in types
assert "stop_market" in types assert "STOP_MARKET" in types
def test_normalize_limit_all_exchanges(self): def test_normalize_limit_all_exchanges(self):
"""LIMIT should map to LIMIT on all exchanges."""
for ex in ["binance", "bingx", "bybit"]: 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): def test_normalize_market_all_exchanges(self):
"""MARKET should map to MARKET on all exchanges."""
for ex in ["binance", "bingx", "bybit"]: 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): def test_bingx_stop_market(self):
"""POST_ONLY maps differently across exchanges.""" assert normalize_type_to_exchange(OrderType.STOP_MARKET, "bingx") == "TRIGGER_MARKET"
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_normalize_unknown_type(self): def test_bingx_trailing_stop(self):
assert normalize_to_exchange("invalid_type", "binance") is None 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): def test_is_type_available(self):
assert is_type_available("limit", "binance") assert is_type_available(OrderType.LIMIT, "binance")
assert is_type_available("stop_market", "bingx") assert is_type_available(OrderType.STOP_MARKET, "bingx")
assert not is_type_available("invalid", "binance") assert is_type_available(OrderType.TRAILING_STOP, "bybit")
def test_get_supported_types_unique(self): def test_get_supported_types_unique(self):
"""Each exchange should support at least 8 types."""
for ex in ["binance", "bingx", "bybit"]: for ex in ["binance", "bingx", "bybit"]:
types = get_supported_types(ex) 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

2
MALKHUT/malkhut/tests/test_replay_exhaustive.py
View File

@@ -67,7 +67,7 @@ def _noop():
def _cross(side, frac=0.1): 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)
# ══════════════════════════════════════════════════════════════════════════════ # ══════════════════════════════════════════════════════════════════════════════

4
MALKHUT/malkhut/tests/test_risk.py
View File

@@ -69,7 +69,7 @@ class TestRiskGate:
gate = RiskGate() gate = RiskGate()
# offset=-10 => price = best_bid + 10*tick = 50001.0 >= best_ask => crosses # offset=-10 => price = best_bid + 10*tick = 50001.0 >= best_ask => crosses
action = FulfilmentAction( 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, post_only=True,
) )
planned = PlannedPolicy(actions=(action,), probabilities=(1.0,), planned = PlannedPolicy(actions=(action,), probabilities=(1.0,),
@@ -98,7 +98,7 @@ class TestRiskGate:
def test_approved_action_passes(self): def test_approved_action_passes(self):
gate = RiskGate() gate = RiskGate()
action = FulfilmentAction( 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, post_only=True,
) )
planned = PlannedPolicy(actions=(action,), probabilities=(1.0,), planned = PlannedPolicy(actions=(action,), probabilities=(1.0,),

2
MALKHUT/malkhut/tests/test_score_diagnostic.py
View File

@@ -145,7 +145,7 @@ def _intent():
def _cross(side, frac): 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): def _place(side, offset=0, frac=0.1):

3
MALKHUT/malkhut/tests/test_state_invariants.py
View File

@@ -124,7 +124,8 @@ class TestEnums:
def test_order_type_values(self): def test_order_type_values(self):
assert OrderType.LIMIT.value == "LIMIT" 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: class TestTradePathState:

19
MALKHUT/malkhut/training/dsl.py
View File

@@ -609,15 +609,16 @@ def _primitive_to_action(primitive: ActionPrimitive, state: MarketWorldState) ->
elif at in (ActionType.QUOTE, ActionType.JOIN_QUEUE, ActionType.STEP_BACK, elif at in (ActionType.QUOTE, ActionType.JOIN_QUEUE, ActionType.STEP_BACK,
ActionType.LADDER, ActionType.GRID, ActionType.ICEBERG, ActionType.TWAP): ActionType.LADDER, ActionType.GRID, ActionType.ICEBERG, ActionType.TWAP):
return FulfilmentAction( 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, price_ticks_from_best=primitive.offset_ticks, qty_fraction=primitive.size_fraction,
ttl_ms=int(primitive.duration_s * 1000), post_only=True, ttl_ms=int(primitive.duration_s * 1000), post_only=True,
) )
elif at in (ActionType.CROSS, ActionType.SNIPER, ActionType.PING): elif at in (ActionType.CROSS, ActionType.SNIPER, ActionType.PING):
return FulfilmentAction( 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, price_ticks_from_best=0, qty_fraction=primitive.size_fraction, ttl_ms=50,
time_in_force="IOC",
) )
elif at == ActionType.CANCEL_ALL: elif at == ActionType.CANCEL_ALL:
@@ -636,7 +637,7 @@ def _primitive_to_action(primitive: ActionPrimitive, state: MarketWorldState) ->
if side is None: if side is None:
return FulfilmentAction(ActionKind.NOOP, None, None, 0, 0.0, 0) return FulfilmentAction(ActionKind.NOOP, None, None, 0, 0.0, 0)
return FulfilmentAction( 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, 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: if side is None:
return FulfilmentAction(ActionKind.NOOP, None, None, 0, 0.0, 0) return FulfilmentAction(ActionKind.NOOP, None, None, 0, 0.0, 0)
return FulfilmentAction( 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, price_ticks_from_best=0, qty_fraction=1.0, ttl_ms=0, reduce_only=True,
metadata={"reason": "stop_loss"}, metadata={"reason": "stop_loss"},
) )
@@ -657,7 +658,7 @@ def _primitive_to_action(primitive: ActionPrimitive, state: MarketWorldState) ->
if side is None: if side is None:
return FulfilmentAction(ActionKind.NOOP, None, None, 0, 0.0, 0) return FulfilmentAction(ActionKind.NOOP, None, None, 0, 0.0, 0)
return FulfilmentAction( 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, price_ticks_from_best=0, qty_fraction=1.0, ttl_ms=0, reduce_only=True,
metadata={"reason": "take_profit"}, metadata={"reason": "take_profit"},
) )
@@ -668,7 +669,7 @@ def _primitive_to_action(primitive: ActionPrimitive, state: MarketWorldState) ->
if side is None: if side is None:
return FulfilmentAction(ActionKind.NOOP, None, None, 0, 0.0, 0) return FulfilmentAction(ActionKind.NOOP, None, None, 0, 0.0, 0)
return FulfilmentAction( 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, 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}, 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: if side is None:
return FulfilmentAction(ActionKind.NOOP, None, None, 0, 0.0, 0) return FulfilmentAction(ActionKind.NOOP, None, None, 0, 0.0, 0)
return FulfilmentAction( 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, 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: if side is None:
return FulfilmentAction(ActionKind.NOOP, None, None, 0, 0.0, 0) return FulfilmentAction(ActionKind.NOOP, None, None, 0, 0.0, 0)
return FulfilmentAction( 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, 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: elif at == ActionType.REQUOTE:
return FulfilmentAction( 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, price_ticks_from_best=primitive.offset_ticks, qty_fraction=primitive.size_fraction,
ttl_ms=int(primitive.duration_s * 1000), post_only=True, ttl_ms=int(primitive.duration_s * 1000), post_only=True,
) )

220
MALKHUT/malkhut/training/order_types.py
View File

@@ -1,120 +1,198 @@
""" """
Standardized Order Types — FIX/CCXT-aligned, multi-exchange compatible. Standardized Order Types — FIX/CCXT-aligned, multi-exchange compatible.
Five-layer taxonomy normalized to industry standards: Three orthogonal dimensions (not one flat enum):
Layer 1: Base types (FIX Tag 40 OrdType)
Layer 2: Time-in-force (FIX Tag 59) 1. Order Type (FIX Tag 40 OrdType): what the order IS
Layer 3: Conditional/Trigger (FIX Tag 3/4 + MIT) LIMIT, MARKET, STOP_MARKET, STOP_LIMIT, TRIGGER_MARKET, TRIGGER_LIMIT,
Layer 4: Instructions (FIX Tag 18) TRAILING_STOP
Layer 5: Compound (exchange-specific)
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. Transferability: strategy PARAMETERS transfer across exchanges.
Order type NAMES are venue-specific but semantics are identical. 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 __future__ import annotations
from enum import Enum 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): class OrderType(str, Enum):
MARKET = "market" # FIX: 1 — immediate execution at best available price """Core order types — what the order IS."""
LIMIT = "limit" # FIX: 2 — execute only at specified price or better 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) # 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): class TimeInForce(str, Enum):
GTC = "gtc" # FIX: 1 — Good Till Cancel GTC = "GTC" # FIX: 1 — Good Till Cancel
IOC = "ioc" # FIX: 3 — Immediate or Cancel (partial fill OK) IOC = "IOC" # FIX: 3 — Immediate or Cancel (partial fill OK)
FOK = "fok" # FIX: 4 — Fill or Kill (all-or-nothing) FOK = "FOK" # FIX: 4 — Fill or Kill (all-or-nothing)
GTD = "gtd" # FIX: 6 — Good Till Date GTD = "GTD" # FIX: 6 — Good Till Date
# ============================================================================== # ==============================================================================
# Layer 3: Conditional/Trigger (FIX Tag 3/4 + MIT) # Layer 3: Instructions (FIX Tag 18 ExecInst)
# ============================================================================== # Behavioral modifiers — also SEPARATE from the order type.
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)
# ============================================================================== # ==============================================================================
class OrderInstruction(str, Enum): class OrderInstruction(str, Enum):
POST_ONLY = "post_only" # FIX: ExecInst — maker-only, reject if crossing POST_ONLY = "POST_ONLY" # FIX: ExecInst — maker-only, reject if crossing
REDUCE_ONLY = "reduce_only" # FIX: ExecInst — only reduce existing position REDUCE_ONLY = "REDUCE_ONLY" # FIX: ExecInst — only reduce existing position
HIDDEN = "hidden" # FIX: ExecInst — iceberg/hidden order HIDDEN = "HIDDEN" # FIX: ExecInst — iceberg/hidden
ICEBERG = "iceberg" # FIX: ExecInst — visible portion only 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): # Maps normalized OrderType.value -> exchange-native "type" parameter
OCO = "oco" # One-Cancels-Other (linked orders) EXCHANGE_ORDER_TYPE_MAP: Dict[str, Dict[str, str]] = {
TP_SL = "tp_sl" # Take-Profit / Stop-Loss (attached to position)
# ==============================================================================
# Exchange-specific mapping tables
# ==============================================================================
EXCHANGE_ORDER_MAP: Dict[str, Dict[str, str]] = {
"binance": { "binance": {
"limit": "LIMIT", "market": "MARKET", "LIMIT": "LIMIT", "MARKET": "MARKET",
"stop_market": "STOP_MARKET", "stop_limit": "STOP_LOSS_LIMIT", "STOP_MARKET": "STOP_MARKET", "STOP_LIMIT": "STOP_LOSS_LIMIT",
"trigger_market": "TAKE_PROFIT", "trigger_limit": "TAKE_PROFIT_LIMIT", "TRIGGER_MARKET": "TAKE_PROFIT", "TRIGGER_LIMIT": "TAKE_PROFIT_LIMIT",
"trailing_stop": "TRAILING_STOP_MARKET", "TRAILING_STOP": "TRAILING_STOP_MARKET",
"post_only": "LIMIT_MAKER", "ioc": "IOC", "fok": "FOK",
"reduce_only": "REDUCE_ONLY",
}, },
"bingx": { "bingx": {
"limit": "LIMIT", "market": "MARKET", "LIMIT": "LIMIT", "MARKET": "MARKET",
"stop_market": "TRIGGER_MARKET", "stop_limit": "TRIGGER_LIMIT", "STOP_MARKET": "TRIGGER_MARKET", "STOP_LIMIT": "TRIGGER_LIMIT",
"trigger_market": "TRIGGER_MARKET", "trigger_limit": "TRIGGER_LIMIT", "TRIGGER_MARKET": "TRIGGER_MARKET", "TRIGGER_LIMIT": "TRIGGER_LIMIT",
"trailing_stop": "TRIGGER_MARKET", "TRAILING_STOP": "TRAILING_STOP_MARKET",
"post_only": "POST_ONLY", "ioc": "IOC", "fok": "FOK",
"reduce_only": "REDUCE_ONLY",
}, },
"bybit": { "bybit": {
"limit": "LIMIT", "market": "MARKET", "LIMIT": "LIMIT", "MARKET": "MARKET",
"stop_market": "STOP_MARKET", "stop_limit": "STOP_LIMIT", "STOP_MARKET": "STOP_MARKET", "STOP_LIMIT": "STOP_LIMIT",
"trigger_market": "TAKE_PROFIT_MARKET", "trigger_limit": "TAKE_PROFIT_LIMIT", "TRIGGER_MARKET": "TAKE_PROFIT_MARKET", "TRIGGER_LIMIT": "TAKE_PROFIT_LIMIT",
"trailing_stop": "TRAILING_STOP", "TRAILING_STOP": "TRAILING_STOP",
"post_only": "POST_ONLY", "ioc": "IOC", "fok": "FOK", },
"reduce_only": "REDUCE_ONLY", }
# 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]: def normalize_type_to_exchange(order_type: OrderType, exchange_id: str) -> Optional[str]:
"""Convert a normalized order type to exchange-native string.""" """Convert a normalized OrderType to exchange-native 'type' parameter string."""
mapping = EXCHANGE_ORDER_MAP.get(exchange_id, {}) mapping = EXCHANGE_ORDER_TYPE_MAP.get(exchange_id, {})
return mapping.get(normalized_type) 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]: def get_supported_types(exchange_id: str) -> list[str]:
"""Get all normalized order types supported by an exchange.""" """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()) return list(mapping.keys())
def is_type_available(normalized_type: str, exchange_id: str) -> bool: def decompose_order(order_type_value: str) -> Tuple[str, str, str]:
"""Check if a normalized order type is available on an exchange.""" """Decompose a flat order specification into (type, tif, instruction).
mapping = EXCHANGE_ORDER_MAP.get(exchange_id, {})
return normalized_type in mapping 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)

16
MALKHUT/malkhut/venue/bingx/adapter.py
View File

@@ -178,13 +178,13 @@ class BingXVenueAdapter:
client_id = f"m_{state.ts_ns}_{self._order_seq}" client_id = f"m_{state.ts_ns}_{self._order_seq}"
# Determine order type — use standardized OrderType, map to BingX-native # 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: 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": elif action.kind.value == "CROSS_SPREAD":
order_type = "MARKET" order_type = "MARKET"
elif action.post_only:
order_type = "POST_ONLY"
else: else:
order_type = "LIMIT" order_type = "LIMIT"
@@ -197,8 +197,16 @@ class BingXVenueAdapter:
"price": str(price), "price": str(price),
"quantity": str(qty), "quantity": str(qty),
"reduceOnly": action.reduce_only, "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 # Track order
tracked = TrackedOrder( tracked = TrackedOrder(
client_order_id=client_id, client_order_id=client_id,