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
# 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:

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

@@ -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,
))

28
MALKHUT/malkhut/state.py
View File

@@ -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"

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

@@ -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={})

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

@@ -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))

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

@@ -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

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

@@ -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

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):
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,
)

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

@@ -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):

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

@@ -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)

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

@@ -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"

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

@@ -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):

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,
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

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

@@ -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

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

@@ -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)
# ══════════════════════════════════════════════════════════════════════════════

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

@@ -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,),

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

@@ -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):

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

@@ -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:

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,
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,
)

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

@@ -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)

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}"
# 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,