akquant 0.3.3__tar.gz → 0.3.4__tar.gz

{akquant-0.3.3 → akquant-0.3.4}/Cargo.lock

@@ -30,7 +30,7 @@ dependencies = [
 
 [[package]]
 name = "akquant"
-version = "0.3.3"
+version = "0.3.4"
 dependencies = [
  "anyhow",
  "chrono",

{akquant-0.3.3 → akquant-0.3.4}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "akquant"
-version = "0.3.3"
+version = "0.3.4"
 edition = "2024"
 description = "High-performance quantitative trading framework based on Rust and Python"
 license = "MIT"

{akquant-0.3.3 → akquant-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: akquant
-Version: 0.3.3
+Version: 0.3.4
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{akquant-0.3.3 → akquant-0.3.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "akquant"
-version = "0.3.3"
+version = "0.3.4"
 description = "High-performance quantitative trading framework based on Rust and Python"
 readme = "README.md"
 license = {text = "MIT License"}

{akquant-0.3.3 → akquant-0.3.4}/python/akquant/__init__.py

@@ -8,7 +8,7 @@ try:
 except metadata.PackageNotFoundError:
     __version__ = "0.0.0+unknown"
 
-__engine_rule_version__ = "1.2.0"  # Increment on behavior-changing updates
+__engine_rule_version__ = "1.3.0"  # Increment on behavior-changing updates
 
 from . import akquant as _akquant
 from . import log as _log

{akquant-0.3.3 → akquant-0.3.4}/python/akquant/akquant.pyi

@@ -948,6 +948,7 @@ class Instrument:
     option_margin_model: typing.Optional[akquant.OptionMarginModel]
     implied_volatility: typing.Optional[float]
     reference_volatility: typing.Optional[float]
+    sellable_after_days: int
     def __new__(
         cls,
         symbol: str,
@@ -965,6 +966,7 @@ class Instrument:
         option_margin_model: typing.Optional[OptionMarginModel] = ...,
         implied_volatility: typing.Optional[float] = ...,
         reference_volatility: typing.Optional[float] = ...,
+        sellable_after_days: typing.Optional[int] = ...,
     ) -> "Instrument": ...
 
 class MACD:
@@ -2585,6 +2587,7 @@ class StrategyContext:
     last_closed_trade: typing.Optional[ClosedTrade]
     closed_trades: list[ClosedTrade]
     cash: float
+    buying_power: float
     positions: dict[str, float]
     available_positions: dict[str, float]
     def __new__(

{akquant-0.3.3 → akquant-0.3.4}/python/akquant/backtest/engine.py

@@ -2838,8 +2838,8 @@ def run_backtest(
                 option_margin_model=_option_margin_model_to_upper_name(
                     getattr(prebuilt, "option_margin_model", None)
                 ),
-                tick_size=float(getattr(prebuilt, "tick_size", 0.01)),
-                lot_size=float(getattr(prebuilt, "lot_size", 1.0)),
+                tick_size=float(getattr(prebuilt, "tick_size", 0.01) or 0.01),
+                lot_size=float(getattr(prebuilt, "lot_size", 1.0) or 1.0),
                 implied_volatility=(
                     float(getattr(prebuilt, "implied_volatility"))
                     if getattr(prebuilt, "implied_volatility", None) is not None
@@ -3661,6 +3661,15 @@ def run_backtest(
     ):
         has_futures_instruments = True
 
+    # Any explicit per-instrument T+1 (sellable_after_days>=1) needs ChinaMarket so
+    # on_day_close releases the lock; otherwise a T+1 instrument under t_plus_one=False
+    # (SimpleMarket) would silently never become sellable.
+    any_t_plus_one_instrument = any(
+        getattr(ic, "sellable_after_days", None) is not None
+        and getattr(ic, "sellable_after_days", 0) >= 1
+        for ic in (kwargs.get("instruments") or [])
+    )
+
     if china_futures_config and has_futures_instruments:
         if (
             not china_futures_config.use_china_futures_market
@@ -3683,9 +3692,10 @@ def run_backtest(
                 engine.use_simple_market(commission_rate)
         if t_plus_one:
             engine.set_t_plus_one(True)
-    elif t_plus_one:
+    elif t_plus_one or any_t_plus_one_instrument:
         engine.use_china_market()
-        engine.set_t_plus_one(True)
+        if t_plus_one:
+            engine.set_t_plus_one(True)
     else:
         if hasattr(engine, "use_simple_market_policy"):
             cast(Any, engine).use_simple_market_policy(
@@ -4097,8 +4107,8 @@ def run_backtest(
                 option_margin_model=_option_margin_model_to_upper_name(
                     getattr(prebuilt, "option_margin_model", None)
                 ),
-                tick_size=float(getattr(prebuilt, "tick_size", 0.01)),
-                lot_size=float(getattr(prebuilt, "lot_size", 1.0)),
+                tick_size=float(getattr(prebuilt, "tick_size", 0.01) or 0.01),
+                lot_size=float(getattr(prebuilt, "lot_size", 1.0) or 1.0),
                 implied_volatility=(
                     float(getattr(prebuilt, "implied_volatility"))
                     if getattr(prebuilt, "implied_volatility", None) is not None
@@ -4170,6 +4180,11 @@ def run_backtest(
                 i_conf.settlement_type
             )
             p_settlement_price = i_conf.settlement_price
+            p_sellable_after_days = (
+                i_conf.sellable_after_days
+                if i_conf.sellable_after_days is not None
+                else (1 if t_plus_one else 0)
+            )
             static_attrs = getattr(i_conf, "static_attrs", {})
             if static_attrs is None:
                 static_attrs = {}
@@ -4222,6 +4237,7 @@ def run_backtest(
                 default_settlement_type
             )
             p_settlement_price = default_settlement_price
+            p_sellable_after_days = 1 if t_plus_one else 0
             static_attrs = {}
 
         if p_asset_type != AssetType.Futures:
@@ -4265,6 +4281,7 @@ def run_backtest(
             p_option_margin_model,
             p_implied_volatility,
             p_reference_volatility,
+            p_sellable_after_days,
         )
         engine.add_instrument(instr)
         instrument_snapshots[sym] = InstrumentSnapshot(
@@ -5305,8 +5322,8 @@ def run_warm_start(
                 option_margin_model=_option_margin_model_to_upper_name(
                     getattr(prebuilt, "option_margin_model", None)
                 ),
-                tick_size=float(getattr(prebuilt, "tick_size", 0.01)),
-                lot_size=float(getattr(prebuilt, "lot_size", 1.0)),
+                tick_size=float(getattr(prebuilt, "tick_size", 0.01) or 0.01),
+                lot_size=float(getattr(prebuilt, "lot_size", 1.0) or 1.0),
                 option_type=_option_type_to_upper_name(
                     getattr(prebuilt, "option_type", None)
                 ),
@@ -5418,6 +5435,11 @@ def run_warm_start(
             p_implied_volatility = None
             p_reference_volatility = None
 
+        p_sellable_after_days = (
+            conf.sellable_after_days
+            if conf is not None and conf.sellable_after_days is not None
+            else None
+        )
         instr = Instrument(
             symbol=sym,
             asset_type=p_asset_type,
@@ -5434,6 +5456,7 @@ def run_warm_start(
             option_margin_model=p_option_margin_model,
             implied_volatility=p_implied_volatility,
             reference_volatility=p_reference_volatility,
+            sellable_after_days=p_sellable_after_days,
         )
         engine.add_instrument(instr)
         warm_start_instrument_snapshots[sym] = InstrumentSnapshot(

{akquant-0.3.3 → akquant-0.3.4}/python/akquant/config.py

@@ -185,6 +185,7 @@ class InstrumentConfig:
     reference_volatility: Optional[float] = None
     settlement_type: Optional[InstrumentSettlementTypeInput] = None
     settlement_price: Optional[float] = None
+    sellable_after_days: Optional[int] = None
     static_attrs: Dict[str, Union[str, int, float, bool]] = field(default_factory=dict)
 
     def __post_init__(self) -> None:
@@ -241,6 +242,14 @@ class InstrumentConfig:
             raise ValueError("lot_size must be > 0")
         if self.reference_volatility is not None and self.reference_volatility <= 0:
             raise ValueError("reference_volatility must be > 0")
+        if self.sellable_after_days is not None and self.sellable_after_days not in (
+            0,
+            1,
+        ):
+            raise ValueError(
+                "InstrumentConfig.sellable_after_days must be 0 (T+0) or 1 (T+1); "
+                f"got {self.sellable_after_days} (T+2+ not yet supported)"
+            )
 
 
 @dataclass

{akquant-0.3.3 → akquant-0.3.4}/python/akquant/execution/base.py

@@ -36,6 +36,9 @@ class ExecutionBackend(Protocol):
     def get_cash(self) -> float:
         """获取现金."""
 
+    def get_buying_power(self) -> float:
+        """获取可用买入力."""
+
     def submit_order(self, **kwargs: Any) -> str:
         """提交订单，返回订单号."""
 

{akquant-0.3.3 → akquant-0.3.4}/python/akquant/execution/sim.py

@@ -51,6 +51,10 @@ class SimExecution:
         """获取现金."""
         return api._sim_get_cash(self._s)
 
+    def get_buying_power(self) -> float:
+        """获取可用买入力."""
+        return api._sim_get_buying_power(self._s)
+
     def submit_order(self, **kwargs: Any) -> OrderReceipt:
         """提交订单，返回 OrderReceipt（携带回测拆腿产生的全部订单 id）."""
         return api._sim_submit_order(self._s, **kwargs)

{akquant-0.3.3 → akquant-0.3.4}/python/akquant/gateway/broker_execution.py

@@ -129,6 +129,10 @@ class BrokerExecution:
         """获取现金."""
         return float(getattr(self._cache.account(), "cash", 0.0) or 0.0)
 
+    def get_buying_power(self) -> float:
+        """获取可用买入力（实盘暂以可用现金近似）."""
+        return self.get_cash()
+
     def submit_order(self, **kwargs: Any) -> OrderReceipt:
         """提交订单，返回下单回执（OrderReceipt，含全部腿 id）.
 

{akquant-0.3.3 → akquant-0.3.4}/python/akquant/strategy.py

@@ -112,6 +112,9 @@ from .strategy_trading_api import (
 from .strategy_trading_api import (
     get_available_position as _get_available_position_impl,
 )
+from .strategy_trading_api import (
+    get_buying_power as _get_buying_power_impl,
+)
 from .strategy_trading_api import (
     get_cash as _get_cash_impl,
 )
@@ -2228,6 +2231,11 @@ class Strategy:
         """当前可用现金（等同旧 get_cash()）."""
         return _get_cash_impl(self)
 
+    @property
+    def buying_power(self) -> float:
+        """可用买入力（含本回调已提交卖单的预期回笼；用于卖出后为买单定量）."""
+        return _get_buying_power_impl(self)
+
     @property
     def equity(self) -> float:
         """当前账户总权益（现金 + 持仓市值，权威只读；等同旧 get_portfolio_value()）."""

{akquant-0.3.3 → akquant-0.3.4}/python/akquant/strategy_trading_api.py

@@ -1527,6 +1527,11 @@ def get_cash(strategy: Any) -> float:
     return float(strategy.execution.get_cash())
 
 
+def get_buying_power(strategy: Any) -> float:
+    """获取可用买入力（经执行后端）."""
+    return float(strategy.execution.get_buying_power())
+
+
 # --- SimExecution 后端原语（Task 1 引入；Task 3/4 让公共函数 delegate 到 execution）---
 def _sim_get_position(strategy: Any, symbol: Optional[str] = None) -> float:
     if strategy.ctx is None:
@@ -1558,6 +1563,12 @@ def _sim_get_cash(strategy: Any) -> float:
     return float(strategy.ctx.cash)
 
 
+def _sim_get_buying_power(strategy: Any) -> float:
+    if strategy.ctx is None:
+        return 0.0
+    return float(strategy.ctx.buying_power)
+
+
 def _sim_get_open_orders(strategy: Any, symbol: Optional[str] = None) -> List[Any]:
     """获取当前未完成的订单（_sim_ 原语，复制自 get_open_orders，逻辑一字不改）."""
     if strategy.ctx is None:

{akquant-0.3.3 → akquant-0.3.4}/src/context.rs

@@ -71,6 +71,8 @@ pub struct ContextInit {
     pub previous_account_maintenance_ratio: f64,
     pub margin_accrued_interest: f64,
     pub margin_daily_interest: f64,
+    pub instruments: Arc<HashMap<String, Instrument>>,
+    pub last_prices: Arc<HashMap<String, Decimal>>,
 }
 
 pub struct ContextUpdate {
@@ -102,6 +104,7 @@ pub struct ContextUpdate {
     pub previous_account_maintenance_ratio: f64,
     pub margin_accrued_interest: f64,
     pub margin_daily_interest: f64,
+    pub last_prices: Arc<HashMap<String, Decimal>>,
 }
 
 #[gen_stub_pyclass]
@@ -294,6 +297,7 @@ impl StrategyContext {
         self.positions = update.positions;
         self.available_positions = update.available_positions;
         self.position_entry_prices = update.position_entry_prices;
+        self.last_prices = update.last_prices;
         self.session = update.session;
         self.current_time = update.current_time;
         self.active_orders_arc = update.active_orders.clone();
@@ -380,6 +384,10 @@ pub struct StrategyContext {
     pub active_orders_arc: Arc<Vec<Order>>,
     pub timers_arc: Arc<RwLock<Vec<Timer>>>,
 
+    // Snapshots for buying-power computation (set at construction / each bar).
+    pub instruments: Arc<HashMap<String, Instrument>>,
+    pub last_prices: Arc<HashMap<String, Decimal>>,
+
     pub cash: Decimal,
     pub previous_cash: Decimal,
     pub positions: Arc<HashMap<String, Decimal>>,
@@ -484,6 +492,8 @@ impl StrategyContext {
             previous_account_maintenance_ratio: init.previous_account_maintenance_ratio,
             margin_accrued_interest: init.margin_accrued_interest,
             margin_daily_interest: init.margin_daily_interest,
+            instruments: init.instruments,
+            last_prices: init.last_prices,
         }
     }
 }
@@ -589,6 +599,8 @@ impl StrategyContext {
             previous_account_maintenance_ratio: previous_account_maintenance_ratio.unwrap_or(0.0),
             margin_accrued_interest: margin_accrued_interest.unwrap_or(0.0),
             margin_daily_interest: margin_daily_interest.unwrap_or(0.0),
+            instruments: Arc::new(HashMap::new()),
+            last_prices: Arc::new(HashMap::new()),
         })
     }
 
@@ -676,6 +688,46 @@ impl StrategyContext {
         self.cash.to_f64().unwrap_or_default()
     }
 
+    /// 可用买入力:现金 + 本回调及既有挂单的净预期回笼,投影后按风控口径
+    /// 计算 free_margin × (1 - safety_margin)。用于在同一 on_bar 内、卖出后
+    /// 为买单定量(卖出资金当日可复用)。
+    #[getter]
+    fn get_buying_power(&self) -> f64 {
+        let portfolio = crate::portfolio::Portfolio {
+            cash: self.cash,
+            positions: self.positions.clone(),
+            available_positions: self.available_positions.clone(),
+        };
+        let mut pending: Vec<Order> =
+            Vec::with_capacity(self.active_orders.len() + self.orders.len());
+        pending.extend(self.active_orders.iter().cloned());
+        pending.extend(self.orders.iter().cloned());
+        let projected = crate::risk::common::project_active_orders_into(
+            &portfolio,
+            &pending,
+            &self.last_prices,
+            &self.instruments,
+        );
+        let stock_ratio_override = if self.risk_config.is_margin_account() {
+            Some(self.risk_config.stock_initial_margin_ratio())
+        } else {
+            None
+        };
+        let free_margin = projected.calculate_free_margin_with_stock_ratio(
+            &self.last_prices,
+            &self.instruments,
+            stock_ratio_override,
+        );
+        let safety = Decimal::from_f64(self.risk_config.safety_margin).unwrap_or(Decimal::ZERO);
+        let factor = (Decimal::ONE - safety).max(Decimal::ZERO);
+        free_margin
+            .checked_mul(factor)
+            .unwrap_or(Decimal::ZERO)
+            .max(Decimal::ZERO)
+            .to_f64()
+            .unwrap_or_default()
+    }
+
     #[getter]
     fn get_previous_cash(&self) -> f64 {
         self.previous_cash.to_f64().unwrap_or_default()

{akquant-0.3.3 → akquant-0.3.4}/src/engine/core.rs

@@ -765,6 +765,7 @@ impl Engine {
                             .margin_daily_interest
                             .to_f64()
                             .unwrap_or_default(),
+                        last_prices: Arc::new(self.last_prices.clone()),
                     });
                 }
                 Ok::<_, PyErr>(py_ctx)
@@ -1148,6 +1149,8 @@ impl Engine {
                 .unwrap_or_default(),
             margin_accrued_interest: self.margin_accrued_interest.to_f64().unwrap_or_default(),
             margin_daily_interest: self.margin_daily_interest.to_f64().unwrap_or_default(),
+            instruments: Arc::new(self.instruments.clone()),
+            last_prices: Arc::new(self.last_prices.clone()),
         })
     }
 

{akquant-0.3.3 → akquant-0.3.4}/src/engine/mod.rs

@@ -49,6 +49,7 @@ mod tests {
                 lot_size: Decimal::from(100),
                 tick_size: Decimal::new(1, 2),
                 expiry_date: None,
+                sellable_after_days: 1,
             }),
         };
         engine.add_instrument(instr);

{akquant-0.3.3 → akquant-0.3.4}/src/execution/simulated.rs

@@ -194,19 +194,31 @@ impl SimulatedExecutionClient {
         Self::is_same_cycle_close_policy(Self::effective_policy(order, ctx))
     }
 
-    fn has_cross_symbol_reduce_pending(
+    /// Whether the order is scheduled to attempt its fill during the current
+    /// timestamp. Same-cycle-close orders fill at the close of their creation
+    /// bar (created_at == now); next-open orders fill at the open of the first
+    /// bar after submission (created_at < now while still active).
+    fn fills_current_cycle(&self, order: &Order, ctx: &crate::context::EngineContext) -> bool {
+        let policy = Self::effective_policy(order, ctx);
+        if Self::is_same_cycle_close_policy(policy) {
+            order.created_at == ctx.current_time
+        } else {
+            order.created_at < ctx.current_time
+        }
+    }
+
+    /// A co-submitted (same created_at) cross-symbol reduce/close order that
+    /// also fills this cycle — its proceeds should fund `order` before it fills.
+    fn has_cosubmitted_cross_symbol_reduce_pending(
         &self,
-        event: &Event,
+        order: &Order,
         ctx: &crate::context::EngineContext,
     ) -> bool {
-        let Some(event_symbol) = Self::event_symbol(event) else {
-            return false;
-        };
         self.orders.values().any(|candidate| {
             Self::is_order_active(candidate)
-                && candidate.created_at == ctx.current_time
-                && candidate.symbol != event_symbol
-                && self.is_same_cycle_close_order(candidate, ctx)
+                && candidate.symbol != order.symbol
+                && candidate.created_at == order.created_at
+                && self.fills_current_cycle(candidate, ctx)
                 && crate::model::is_reduce_first_order(candidate.side, candidate.position_effect)
         })
     }
@@ -217,7 +229,7 @@ impl SimulatedExecutionClient {
         event: &Event,
         ctx: &crate::context::EngineContext,
     ) -> bool {
-        if order.created_at != ctx.current_time || !self.is_same_cycle_close_order(order, ctx) {
+        if !self.fills_current_cycle(order, ctx) {
             return false;
         }
         if crate::model::is_reduce_first_order(order.side, order.position_effect) {
@@ -226,15 +238,15 @@ impl SimulatedExecutionClient {
         Self::event_symbol(event)
             .map(|symbol| order.symbol == symbol)
             .unwrap_or(false)
-            && self.has_cross_symbol_reduce_pending(event, ctx)
+            && self.has_cosubmitted_cross_symbol_reduce_pending(order, ctx)
     }
 
     fn should_finalize_order(&self, order: &Order, ctx: &crate::context::EngineContext) -> bool {
-        order.created_at == ctx.current_time
-            && Self::is_order_active(order)
-            && self.is_same_cycle_close_order(order, ctx)
-            && (!self.attempted_same_cycle_order_ids.contains(&order.id)
-                || self.deferred_same_cycle_order_ids.contains(&order.id))
+        Self::is_order_active(order)
+            && (self.deferred_same_cycle_order_ids.contains(&order.id)
+                || (order.created_at == ctx.current_time
+                    && self.is_same_cycle_close_order(order, ctx)
+                    && !self.attempted_same_cycle_order_ids.contains(&order.id)))
     }
 
     fn sorted_queue(&self) -> Vec<String> {
@@ -313,6 +325,21 @@ impl SimulatedExecutionClient {
                     continue;
                 }
 
+                // A next-open (bar_offset>=1) order must not fill on any event at or
+                // before its submission timestamp — including a same-timestamp bar of a
+                // different symbol processed after the order was queued (e.g. a strategy
+                // that submits a cross-symbol order inside another symbol's bar callback).
+                // Without this, such an order fills on its own creation-timestamp bar
+                // instead of the next one, skewing cross-symbol switch timing (#307).
+                let order_policy = Self::effective_policy(&order_snapshot, ctx);
+                if order_policy.bar_offset >= 1
+                    && Self::event_timestamp(event)
+                        .map(|ts| ts <= order_snapshot.created_at)
+                        .unwrap_or(false)
+                {
+                    continue;
+                }
+
                 let defer_current = defer_cross_symbol_increase
                     && self.should_defer_order_on_current_event(&order_snapshot, event, ctx);
                 let mark_attempted = order_snapshot.created_at == ctx.current_time
@@ -794,6 +821,7 @@ mod tests {
                 lot_size: Decimal::from(100),
                 tick_size: Decimal::new(1, 2),
                 expiry_date: None,
+                sellable_after_days: 1,
             }),
         };
         map.insert("AAPL".to_string(), aapl);
@@ -1261,6 +1289,7 @@ mod tests {
                     lot_size: Decimal::from(100),
                     tick_size: Decimal::new(1, 2),
                     expiry_date: None,
+                    sellable_after_days: 1,
                 }),
             },
         );
@@ -1372,6 +1401,7 @@ mod tests {
                     lot_size: Decimal::from(100),
                     tick_size: Decimal::new(1, 2),
                     expiry_date: None,
+                    sellable_after_days: 1,
                 }),
             },
         );

{akquant-0.3.3 → akquant-0.3.4}/src/execution/stock.rs

@@ -46,6 +46,7 @@ mod tests {
                 lot_size: dec!(100),
                 tick_size: dec!(0.01),
                 expiry_date: None,
+                sellable_after_days: 1,
             }),
         }
     }

{akquant-0.3.3 → akquant-0.3.4}/src/market/china.rs

@@ -232,30 +232,22 @@ impl MarketModel for ChinaMarket {
         let symbol = &instrument.symbol();
         match instrument.asset_type {
             AssetType::Stock => {
-                if let Some(config) = &self.config.stock {
-                    stock::update_available_position(
-                        config,
-                        available_positions,
-                        symbol,
-                        quantity,
-                        side,
-                    );
-                } else {
-                    panic!("Stock market configuration not found for position update");
-                }
+                stock::update_available_position(
+                    instrument.sellable_after_days(),
+                    available_positions,
+                    symbol,
+                    quantity,
+                    side,
+                );
             }
             AssetType::Fund => {
-                if let Some(config) = &self.config.fund {
-                    fund::update_available_position(
-                        config,
-                        available_positions,
-                        symbol,
-                        quantity,
-                        side,
-                    );
-                } else {
-                    panic!("Fund market configuration not found for position update");
-                }
+                fund::update_available_position(
+                    instrument.sellable_after_days(),
+                    available_positions,
+                    symbol,
+                    quantity,
+                    side,
+                );
             }
             AssetType::Futures => {
                 if let Some(config) = &self.config.futures {
@@ -296,34 +288,14 @@ impl MarketModel for ChinaMarket {
         instruments: &HashMap<String, Instrument>,
     ) {
         for (symbol, quantity) in positions {
-            let is_t_plus_one_asset = if let Some(instr) = instruments.get(symbol) {
-                matches!(instr.asset_type, AssetType::Stock | AssetType::Fund)
-            } else {
-                false
-            };
-
-            // 使用各自配置中的 T+1 设置
-            let should_settle = if let Some(instr) = instruments.get(symbol) {
-                match instr.asset_type {
-                    AssetType::Stock => self
-                        .config
-                        .stock
-                        .as_ref()
-                        .map(|c| c.t_plus_one)
-                        .unwrap_or(false),
-                    AssetType::Fund => self
-                        .config
-                        .fund
-                        .as_ref()
-                        .map(|c| c.t_plus_one)
-                        .unwrap_or(false),
-                    _ => false,
-                }
-            } else {
-                false
-            };
-
-            if is_t_plus_one_asset && should_settle {
+            // sellable_after_days>=1 的标的:持有进入新交易日后全量可卖(T+1)。
+            // T+0(==0)标的的可卖量由 update_available_position 在成交时即时维护,
+            // 此处不覆盖。
+            let releases = instruments
+                .get(symbol)
+                .map(|instr| instr.sellable_after_days() >= 1)
+                .unwrap_or(false);
+            if releases {
                 available_positions.insert(symbol.clone(), *quantity);
             }
         }

{akquant-0.3.3 → akquant-0.3.4}/src/market/fund.rs

@@ -47,9 +47,9 @@ pub fn calculate_commission(
     commission
 }
 
-/// 更新基金可用持仓 (与股票类似，处理 T+1)
+/// 更新基金可用持仓 (按 per-instrument sellable_after_days 处理 T+0/T+1)
 pub fn update_available_position(
-    config: &FundConfig,
+    sellable_after_days: u32,
     available_positions: &mut HashMap<String, Decimal>,
     symbol: &str,
     quantity: Decimal,
@@ -61,7 +61,7 @@ pub fn update_available_position(
                 .entry(symbol.to_string())
                 .or_insert(Decimal::ZERO);
 
-            if !config.t_plus_one
+            if sellable_after_days == 0
                 && let Some(pos) = available_positions.get_mut(symbol)
             {
                 *pos += quantity;