boris
424 lines
19 KiB
Rust
424 lines
19 KiB
Rust
//! Immutable, account-independent trading signals. Quantity and execution
|
|
//! prices are intentionally absent; the existing broker owns those decisions.
|
|
|
|
use std::collections::{BTreeMap, BTreeSet};
|
|
|
|
use chrono::{DateTime, FixedOffset, NaiveDate, NaiveDateTime, NaiveTime, Utc};
|
|
use serde::{Deserialize, Serialize};
|
|
use sha2::{Digest, Sha256};
|
|
|
|
use crate::strategy::{OrderIntent, StrategyContext};
|
|
use crate::portfolio::PortfolioState;
|
|
|
|
pub const SIGNAL_BOOK_SCHEMA: &str = "fidc.signal-book/v1";
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize, Serialize)]
|
|
#[serde(rename_all = "snake_case")]
|
|
pub enum SignalProvenance {
|
|
Observed,
|
|
Reconstructed,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize, Serialize)]
|
|
#[serde(rename_all = "snake_case")]
|
|
pub enum SignalFrequency {
|
|
Daily,
|
|
Minute,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Deserialize, Serialize)]
|
|
#[serde(tag = "kind", rename_all = "snake_case", deny_unknown_fields)]
|
|
pub enum SignalAction {
|
|
TargetWeight { symbol: String, weight: f64 },
|
|
BuyCondition { symbol: String, allowed: bool },
|
|
Exit { symbol: String },
|
|
Reduce { symbol: String, remaining_ratio: f64 },
|
|
}
|
|
|
|
impl SignalAction {
|
|
fn symbol(&self) -> &str {
|
|
match self {
|
|
Self::TargetWeight { symbol, .. }
|
|
| Self::BuyCondition { symbol, .. }
|
|
| Self::Exit { symbol }
|
|
| Self::Reduce { symbol, .. } => symbol,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, Deserialize, Serialize)]
|
|
#[serde(rename_all = "camelCase", deny_unknown_fields)]
|
|
pub struct SignalSnapshot {
|
|
pub decision_at: DateTime<Utc>,
|
|
pub input_as_of: DateTime<Utc>,
|
|
pub input_available_at: DateTime<Utc>,
|
|
pub generated_at: DateTime<Utc>,
|
|
pub published_at: DateTime<Utc>,
|
|
pub input_sha256: String,
|
|
pub complete_targets: bool,
|
|
pub actions: Vec<SignalAction>,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Deserialize, Serialize)]
|
|
#[serde(rename_all = "camelCase", deny_unknown_fields)]
|
|
pub struct SignalBook {
|
|
pub schema: String,
|
|
pub version_sha256: String,
|
|
pub generator_sha256: String,
|
|
pub knowledge_cutoff: DateTime<Utc>,
|
|
pub provenance: SignalProvenance,
|
|
pub frequency: SignalFrequency,
|
|
pub expected_decisions: Vec<DateTime<Utc>>,
|
|
pub snapshots: Vec<SignalSnapshot>,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct ValidatedSignalBook {
|
|
book: SignalBook,
|
|
index: BTreeMap<NaiveDateTime, usize>,
|
|
}
|
|
|
|
fn valid_sha(value: &str) -> bool {
|
|
value.len() == 64 && value.bytes().all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte))
|
|
}
|
|
|
|
fn shanghai(value: DateTime<Utc>) -> NaiveDateTime {
|
|
value.with_timezone(&FixedOffset::east_opt(8 * 3600).expect("Shanghai offset")).naive_local()
|
|
}
|
|
|
|
impl SignalBook {
|
|
pub fn content_sha256(&self) -> Result<String, String> {
|
|
let mut value=serde_json::to_value(self).map_err(|error|error.to_string())?;
|
|
value.as_object_mut().ok_or("signal_book_object_required")?.remove("versionSha256");
|
|
let raw=serde_json::to_vec(&value).map_err(|error|error.to_string())?;
|
|
Ok(format!("{:x}",Sha256::digest(raw)))
|
|
}
|
|
|
|
pub fn validate(self) -> Result<ValidatedSignalBook, String> {
|
|
if self.schema != SIGNAL_BOOK_SCHEMA || !valid_sha(&self.version_sha256)
|
|
|| !valid_sha(&self.generator_sha256)
|
|
{
|
|
return Err("signal_book_identity_invalid".into());
|
|
}
|
|
if self.expected_decisions.is_empty() || self.expected_decisions.len() > 100_000
|
|
|| self.expected_decisions.len() != self.snapshots.len()
|
|
{
|
|
return Err("signal_book_decision_coverage_incomplete".into());
|
|
}
|
|
let mut index = BTreeMap::new();
|
|
let mut previous = None;
|
|
let mut total_actions = 0usize;
|
|
for (number, (expected, snapshot)) in self.expected_decisions.iter().zip(&self.snapshots).enumerate() {
|
|
if snapshot.decision_at != *expected || previous.is_some_and(|value| value >= *expected) {
|
|
return Err("signal_book_decisions_duplicate_or_unordered".into());
|
|
}
|
|
previous = Some(*expected);
|
|
if self.knowledge_cutoff >= *expected || snapshot.input_as_of > *expected
|
|
|| snapshot.input_available_at > *expected || snapshot.input_as_of > snapshot.input_available_at
|
|
|| snapshot.published_at < snapshot.generated_at || !valid_sha(&snapshot.input_sha256)
|
|
|| snapshot.generated_at < snapshot.input_available_at
|
|
|| snapshot.generated_at < self.knowledge_cutoff
|
|
{
|
|
return Err("signal_book_future_or_invalid_input".into());
|
|
}
|
|
if self.provenance == SignalProvenance::Observed && snapshot.published_at > *expected {
|
|
return Err("observed_signal_not_available_at_decision".into());
|
|
}
|
|
total_actions = total_actions.checked_add(snapshot.actions.len()).ok_or("signal_book_action_limit")?;
|
|
if total_actions > 2_000_000 { return Err("signal_book_action_limit".into()); }
|
|
let mut action_keys = BTreeSet::new();
|
|
let mut target_symbols = BTreeSet::new();
|
|
let mut reductions = BTreeSet::new();
|
|
let mut total_weight = 0.0;
|
|
for action in &snapshot.actions {
|
|
let symbol = action.symbol();
|
|
if symbol.is_empty() || symbol.trim() != symbol { return Err("signal_symbol_invalid".into()); }
|
|
let kind = match action {
|
|
SignalAction::TargetWeight { weight, .. } => {
|
|
if !weight.is_finite() || !(0.0..=1.0).contains(weight) { return Err("signal_target_weight_invalid".into()); }
|
|
target_symbols.insert(symbol);
|
|
total_weight += weight;
|
|
"target"
|
|
}
|
|
SignalAction::BuyCondition { .. } => "buy_condition",
|
|
SignalAction::Exit { .. } => { reductions.insert(symbol); "exit" }
|
|
SignalAction::Reduce { remaining_ratio, .. } => {
|
|
if !remaining_ratio.is_finite() || !(0.0..1.0).contains(remaining_ratio) { return Err("signal_reduction_invalid".into()); }
|
|
reductions.insert(symbol);
|
|
"reduce"
|
|
}
|
|
};
|
|
if !action_keys.insert((symbol, kind)) { return Err("signal_action_duplicate".into()); }
|
|
}
|
|
if total_weight > 1.0 + 1e-12 { return Err("signal_target_exposure_exceeds_one".into()); }
|
|
if snapshot.complete_targets && !reductions.is_empty() {
|
|
return Err("complete_target_snapshot_cannot_mix_relative_exits".into());
|
|
}
|
|
if !target_symbols.is_disjoint(&reductions) { return Err("signal_target_exit_conflict".into()); }
|
|
for symbol in &reductions {
|
|
if action_keys.contains(&(*symbol, "exit")) && action_keys.contains(&(*symbol, "reduce")) {
|
|
return Err("signal_exit_reduction_conflict".into());
|
|
}
|
|
}
|
|
index.insert(shanghai(*expected), number);
|
|
}
|
|
if self.content_sha256()? != self.version_sha256 {
|
|
return Err("signal_book_content_hash_mismatch".into());
|
|
}
|
|
Ok(ValidatedSignalBook { book: self, index })
|
|
}
|
|
}
|
|
|
|
impl ValidatedSignalBook {
|
|
pub fn require_observed(&self) -> Result<(), String> {
|
|
if self.book.provenance != SignalProvenance::Observed {
|
|
return Err("reconstructed_signal_forbidden_in_online_execution".into());
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
pub fn version_sha256(&self) -> &str { &self.book.version_sha256 }
|
|
|
|
pub fn decision_dates(&self) -> BTreeSet<NaiveDate> {
|
|
self.index.keys().map(|value| value.date()).collect()
|
|
}
|
|
|
|
pub fn symbols(&self) -> BTreeSet<String> {
|
|
self.book.snapshots.iter().flat_map(|snapshot| &snapshot.actions)
|
|
.map(|action| action.symbol().to_owned()).collect()
|
|
}
|
|
|
|
pub fn snapshot_for(&self, ctx: &StrategyContext<'_>) -> Result<&SignalSnapshot, String> {
|
|
let snapshot = self.snapshot_at(ctx.execution_date, ctx.current_time(), ctx.is_lagged_execution())?;
|
|
if ctx.is_lagged_execution() && shanghai(snapshot.input_as_of).date() > ctx.decision_date {
|
|
return Err("next_open_signal_contains_execution_session_inputs".into());
|
|
}
|
|
Ok(snapshot)
|
|
}
|
|
|
|
pub fn is_due_on(&self, execution_date: NaiveDate) -> bool {
|
|
self.index.range(execution_date.and_hms_opt(0,0,0).expect("session start")..)
|
|
.next().is_some_and(|(at,_)|at.date()==execution_date)
|
|
}
|
|
|
|
fn snapshot_at(&self, execution_date: NaiveDate, current_time: Option<NaiveTime>, lagged: bool) -> Result<&SignalSnapshot, String> {
|
|
let at = if self.book.frequency == SignalFrequency::Daily && lagged {
|
|
execution_date.and_hms_opt(9, 30, 0).expect("next open")
|
|
} else {
|
|
execution_date.and_time(current_time.unwrap_or(NaiveTime::from_hms_opt(15, 0, 0).expect("daily close")))
|
|
};
|
|
self.index.get(&at).map(|index| &self.book.snapshots[*index])
|
|
.ok_or_else(|| format!("signal_snapshot_missing_at_decision: {at}"))
|
|
}
|
|
|
|
pub fn intents(&self, ctx: &StrategyContext<'_>) -> Result<Vec<OrderIntent>, String> {
|
|
let snapshot = self.snapshot_for(ctx)?;
|
|
self.snapshot_intents(snapshot, ctx.portfolio)
|
|
}
|
|
|
|
fn snapshot_intents(&self, snapshot: &SignalSnapshot, portfolio: &PortfolioState) -> Result<Vec<OrderIntent>, String> {
|
|
let reason = format!("信号执行 version={} decision={}", self.book.version_sha256, snapshot.decision_at);
|
|
let mut intents = Vec::new();
|
|
let mut weights = BTreeMap::new();
|
|
for action in &snapshot.actions {
|
|
match action {
|
|
SignalAction::TargetWeight { symbol, weight } if snapshot.complete_targets => {
|
|
weights.insert(symbol.clone(), *weight);
|
|
}
|
|
SignalAction::TargetWeight { symbol, weight } => intents.push(OrderIntent::TargetPercent {
|
|
symbol: symbol.clone(), target_percent: *weight, reason: reason.clone(),
|
|
}),
|
|
SignalAction::Exit { symbol } => intents.push(OrderIntent::TargetPercent {
|
|
symbol: symbol.clone(), target_percent: 0.0, reason: reason.clone(),
|
|
}),
|
|
SignalAction::Reduce { symbol, remaining_ratio } => {
|
|
if let Some(position) = portfolio.position(symbol).filter(|position| position.quantity > 0) {
|
|
let quantity = (f64::from(position.quantity) * remaining_ratio).floor() as u32;
|
|
let target_quantity = i32::try_from(quantity).map_err(|_| "signal_reduction_quantity_overflow")?;
|
|
intents.push(OrderIntent::TargetShares { symbol: symbol.clone(), target_quantity, reason: reason.clone() });
|
|
}
|
|
}
|
|
SignalAction::BuyCondition { .. } => {}
|
|
}
|
|
}
|
|
if snapshot.complete_targets {
|
|
if weights.is_empty() {
|
|
for position in portfolio.positions().values().filter(|position| position.quantity > 0) {
|
|
intents.push(OrderIntent::TargetPercent { symbol: position.symbol.clone(), target_percent: 0.0, reason: reason.clone() });
|
|
}
|
|
} else {
|
|
intents.push(OrderIntent::TargetPortfolioSmart { target_weights: weights,
|
|
order_prices: None, valuation_prices: None, reason });
|
|
}
|
|
}
|
|
Ok(intents)
|
|
}
|
|
|
|
pub fn buy_denials(&self, ctx: &StrategyContext<'_>) -> Result<BTreeMap<String, String>, String> {
|
|
Ok(self.snapshot_for(ctx)?.actions.iter().filter_map(|action| match action {
|
|
SignalAction::BuyCondition { symbol, allowed: false } => Some((symbol.clone(), "信号买入条件未满足".into())),
|
|
_ => None,
|
|
}).collect())
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use chrono::Duration;
|
|
use serde_json::json;
|
|
|
|
fn book() -> SignalBook {
|
|
let decision: DateTime<Utc> = "2025-01-07T09:30:00+08:00".parse().unwrap();
|
|
let source: DateTime<Utc> = "2025-01-06T15:00:00+08:00".parse().unwrap();
|
|
seal(SignalBook {
|
|
schema: SIGNAL_BOOK_SCHEMA.into(), version_sha256: "a".repeat(64), generator_sha256: "b".repeat(64),
|
|
knowledge_cutoff: "2024-12-31T15:00:00+08:00".parse().unwrap(),
|
|
provenance: SignalProvenance::Reconstructed, frequency: SignalFrequency::Daily,
|
|
expected_decisions: vec![decision], snapshots: vec![SignalSnapshot {
|
|
decision_at: decision, input_as_of: source, input_available_at: source,
|
|
generated_at: decision + Duration::days(10), published_at: decision + Duration::days(10),
|
|
input_sha256: "c".repeat(64), complete_targets: true,
|
|
actions: vec![SignalAction::TargetWeight { symbol: "000001.SZ".into(), weight: 0.5 }],
|
|
}],
|
|
})
|
|
}
|
|
|
|
fn seal(mut book:SignalBook)->SignalBook {
|
|
book.version_sha256=book.content_sha256().unwrap();
|
|
book
|
|
}
|
|
|
|
#[test]
|
|
fn historical_reconstruction_is_not_online_publication() {
|
|
let validated = book().validate().unwrap();
|
|
assert!(validated.require_observed().unwrap_err().contains("reconstructed"));
|
|
let mut observed = book();
|
|
observed.provenance = SignalProvenance::Observed;
|
|
assert!(observed.clone().validate().unwrap_err().contains("not_available"));
|
|
observed.snapshots[0].generated_at = observed.snapshots[0].decision_at;
|
|
observed.snapshots[0].published_at = observed.snapshots[0].decision_at;
|
|
seal(observed).validate().unwrap().require_observed().unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn rejects_future_inputs_and_model_knowledge() {
|
|
for field in 0..3 {
|
|
let mut value = book();
|
|
let future = value.snapshots[0].decision_at + Duration::seconds(1);
|
|
match field {
|
|
0 => value.snapshots[0].input_as_of = future,
|
|
1 => value.snapshots[0].input_available_at = future,
|
|
_ => value.knowledge_cutoff = future,
|
|
}
|
|
assert!(value.validate().unwrap_err().contains("future"));
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn rejects_quantities_prices_and_unknown_signal_fields() {
|
|
for name in ["quantity", "execution_price", "account_id", "cash"] {
|
|
let mut action = json!({"kind":"target_weight","symbol":"000001.SZ","weight":0.5});
|
|
action[name] = json!(100);
|
|
assert!(serde_json::from_value::<SignalAction>(action).is_err());
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn coverage_and_duplicate_actions_fail_closed() {
|
|
let mut value = book();
|
|
value.expected_decisions.push(value.expected_decisions[0] + Duration::days(1));
|
|
assert!(value.validate().unwrap_err().contains("coverage"));
|
|
let mut value = book();
|
|
value.snapshots.push(value.snapshots[0].clone());
|
|
value.expected_decisions.push(value.expected_decisions[0]);
|
|
assert!(value.validate().unwrap_err().contains("duplicate"));
|
|
let mut value = book();
|
|
let repeated = value.snapshots[0].actions[0].clone();
|
|
value.snapshots[0].actions.push(repeated);
|
|
assert!(value.validate().unwrap_err().contains("duplicate"));
|
|
}
|
|
|
|
#[test]
|
|
fn rejects_overallocation_nonfinite_and_ambiguous_actions() {
|
|
for weight in [f64::NAN, f64::INFINITY, -0.1, 1.1] {
|
|
let mut value = book();
|
|
value.snapshots[0].actions[0] = SignalAction::TargetWeight { symbol: "000001.SZ".into(), weight };
|
|
assert!(value.validate().is_err());
|
|
}
|
|
let mut value = book();
|
|
value.snapshots[0].actions.push(SignalAction::TargetWeight { symbol:"000002.SZ".into(),weight:0.6 });
|
|
assert!(value.validate().unwrap_err().contains("exposure"));
|
|
let mut value = book();
|
|
value.snapshots[0].actions.push(SignalAction::Exit {symbol:"000001.SZ".into()});
|
|
assert!(value.validate().is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn next_open_uses_decision_session_and_never_nearest_signal() {
|
|
let value = book().validate().unwrap();
|
|
let day = NaiveDate::from_ymd_opt(2025,1,7).unwrap();
|
|
assert!(value.snapshot_at(day, NaiveTime::from_hms_opt(9,30,0), true).is_ok());
|
|
assert!(value.snapshot_at(day, NaiveTime::from_hms_opt(14,59,0), false).is_err());
|
|
assert!(value.snapshot_at(day + Duration::days(1), None, true).is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn reduction_is_resolved_from_each_accounts_actual_position() {
|
|
let mut raw = book();
|
|
raw.snapshots[0].complete_targets = false;
|
|
raw.snapshots[0].actions = vec![SignalAction::Reduce {symbol:"000001.SZ".into(),remaining_ratio:0.5}];
|
|
let value = seal(raw).validate().unwrap();
|
|
let day = NaiveDate::from_ymd_opt(2025,1,3).unwrap();
|
|
for (held, expected) in [(1000,500),(3000,1500)] {
|
|
let mut portfolio = PortfolioState::new(100_000.0);
|
|
portfolio.position_mut("000001.SZ").buy(day,held,10.0);
|
|
let result = value.snapshot_intents(&value.book.snapshots[0],&portfolio).unwrap();
|
|
assert!(matches!(result[0],OrderIntent::TargetShares {target_quantity,..} if target_quantity==expected));
|
|
assert_eq!(portfolio.position("000001.SZ").unwrap().quantity,held);
|
|
}
|
|
assert!(value.snapshot_intents(&value.book.snapshots[0],&PortfolioState::new(10_000.0)).unwrap().is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn empty_complete_snapshot_clears_only_that_accounts_holdings() {
|
|
let mut raw = book();
|
|
raw.snapshots[0].actions.clear();
|
|
let value = seal(raw).validate().unwrap();
|
|
let day = NaiveDate::from_ymd_opt(2025,1,3).unwrap();
|
|
let mut portfolio = PortfolioState::new(100_000.0);
|
|
portfolio.position_mut("000002.SZ").buy(day,200,10.0);
|
|
let result = value.snapshot_intents(&value.book.snapshots[0],&portfolio).unwrap();
|
|
assert!(matches!(&result[0],OrderIntent::TargetPercent {symbol,target_percent,..} if symbol=="000002.SZ" && *target_percent==0.0));
|
|
}
|
|
|
|
#[test]
|
|
fn platform_spec_consumes_book_without_running_another_selection() {
|
|
let spec = json!({"signalBook":book(),"runtimeExpressions":{"trading":{"actions":[{"kind":"consume_signal"}]}}});
|
|
let config = crate::platform_strategy_spec::platform_expr_config_from_value("signal-fixture","000001.SZ",&spec).unwrap();
|
|
assert!(!config.rotation_enabled && config.signal_book.is_some());
|
|
assert!(matches!(config.explicit_actions.as_slice(),[crate::PlatformTradeAction::ConsumeSignal]));
|
|
}
|
|
|
|
#[test]
|
|
fn changed_valid_contents_must_not_reuse_a_version_hash() {
|
|
let mut raw=book();
|
|
raw.snapshots[0].actions=vec![SignalAction::TargetWeight{symbol:"000001.SZ".into(),weight:0.4}];
|
|
assert_eq!(raw.clone().validate().unwrap_err(),"signal_book_content_hash_mismatch");
|
|
seal(raw).validate().unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn completed_daily_inputs_may_be_published_after_market_close() {
|
|
let mut raw=book();
|
|
raw.expected_decisions=vec!["2026-07-07T09:30:00+08:00".parse().unwrap()];
|
|
raw.snapshots[0].decision_at=raw.expected_decisions[0];
|
|
raw.snapshots[0].input_as_of="2026-07-06T15:30:00+08:00".parse().unwrap();
|
|
raw.snapshots[0].input_available_at="2026-07-06T16:00:00+08:00".parse().unwrap();
|
|
raw.snapshots[0].generated_at=raw.snapshots[0].input_available_at;
|
|
raw.snapshots[0].published_at=raw.snapshots[0].generated_at;
|
|
raw.provenance=SignalProvenance::Observed;
|
|
seal(raw).validate().unwrap().require_observed().unwrap();
|
|
}
|
|
}
|