boris
588 lines
29 KiB
Rust
588 lines
29 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 std::sync::{Arc, Mutex, OnceLock, Weak};
|
|
|
|
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/v2";
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
|
|
#[serde(rename_all = "camelCase", deny_unknown_fields)]
|
|
pub struct SignalBookReference {
|
|
pub book_id: String,
|
|
pub version_sha256: String,
|
|
pub artifact_sha256: String,
|
|
}
|
|
|
|
impl SignalBookReference {
|
|
pub fn validate(&self) -> Result<(), String> {
|
|
if !valid_sha(&self.version_sha256) || !valid_sha(&self.artifact_sha256)
|
|
|| self.book_id != format!("signal_book_{}",self.version_sha256)
|
|
{ return Err("signal_book_reference_invalid".into()); }
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
#[derive(Default)]
|
|
struct SignalCache {
|
|
entries: BTreeMap<String,Weak<ValidatedSignalBook>>,
|
|
retained: std::collections::VecDeque<(String,Arc<ValidatedSignalBook>,usize)>,
|
|
}
|
|
|
|
fn signal_cache() -> &'static Mutex<SignalCache> {
|
|
static CACHE: OnceLock<Mutex<SignalCache>> = OnceLock::new();
|
|
CACHE.get_or_init(||Mutex::new(SignalCache::default()))
|
|
}
|
|
|
|
pub fn cached_signal_book(reference: &SignalBookReference) -> Result<Option<Arc<ValidatedSignalBook>>,String> {
|
|
reference.validate()?;
|
|
let cache=signal_cache().lock().map_err(|_|"signal_cache_lock_failed")?;
|
|
let book=cache.entries.get(&reference.artifact_sha256).and_then(Weak::upgrade);
|
|
if book.as_ref().is_some_and(|book|book.version_sha256()!=reference.version_sha256) {
|
|
return Err("signal_book_cached_version_mismatch".into());
|
|
}
|
|
Ok(book)
|
|
}
|
|
|
|
pub fn register_signal_book(reference: &SignalBookReference, body: &[u8]) -> Result<Arc<ValidatedSignalBook>,String> {
|
|
use sha2::{Digest,Sha256};
|
|
reference.validate()?;
|
|
if body.len()>64*1024*1024 || format!("{:x}",Sha256::digest(body))!=reference.artifact_sha256 {
|
|
return Err("signal_book_artifact_hash_or_size_invalid".into());
|
|
}
|
|
let raw:SignalBook=serde_json::from_slice(body).map_err(|error|format!("signal_book_decode_failed: {error}"))?;
|
|
if raw.version_sha256!=reference.version_sha256 { return Err("signal_book_version_mismatch".into()); }
|
|
let book=Arc::new(raw.validate()?);
|
|
let mut cache=signal_cache().lock().map_err(|_|"signal_cache_lock_failed")?;
|
|
cache.entries.retain(|_,value|value.strong_count()>0);
|
|
if let Some(existing)=cache.entries.get(&reference.artifact_sha256).and_then(Weak::upgrade) { return Ok(existing); }
|
|
cache.entries.insert(reference.artifact_sha256.clone(),Arc::downgrade(&book));
|
|
let estimated=body.len().saturating_mul(4);
|
|
if estimated<=128*1024*1024 {
|
|
cache.retained.push_back((reference.artifact_sha256.clone(),book.clone(),estimated));
|
|
while cache.retained.len()>4 || cache.retained.iter().map(|entry|entry.2).sum::<usize>()>128*1024*1024 {
|
|
cache.retained.pop_front();
|
|
}
|
|
}
|
|
Ok(book)
|
|
}
|
|
|
|
#[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 signal_at: DateTime<Utc>,
|
|
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 model_sha256: Option<String>,
|
|
pub knowledge_cutoff: Option<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");
|
|
value["knowledgeCutoff"]=self.knowledge_cutoff.map(|at|serde_json::json!(at.timestamp_micros())).unwrap_or(serde_json::Value::Null);
|
|
value["expectedDecisions"]=serde_json::json!(self.expected_decisions.iter().map(DateTime::timestamp_micros).collect::<Vec<_>>());
|
|
for (raw,snapshot) in value["snapshots"].as_array_mut().ok_or("signal_snapshots_required")?.iter_mut().zip(&self.snapshots) {
|
|
let object=raw.as_object_mut().ok_or("signal_snapshot_required")?;
|
|
object.remove("generatedAt");
|
|
object.remove("publishedAt");
|
|
for (key,at) in [("signalAt",snapshot.signal_at),("decisionAt",snapshot.decision_at),
|
|
("inputAsOf",snapshot.input_as_of),("inputAvailableAt",snapshot.input_available_at)] {
|
|
object.insert(key.into(),serde_json::json!(at.timestamp_micros()));
|
|
}
|
|
for (raw,action) in object.get_mut("actions").and_then(serde_json::Value::as_array_mut).ok_or("signal_actions_required")?.iter_mut().zip(&snapshot.actions) {
|
|
match action {
|
|
SignalAction::TargetWeight{weight,..}=>raw["weight"]=serde_json::json!(format!("{:016x}",weight.to_bits())),
|
|
SignalAction::Reduce{remaining_ratio,..}=>raw["remaining_ratio"]=serde_json::json!(format!("{:016x}",remaining_ratio.to_bits())),
|
|
_=>{}
|
|
}
|
|
}
|
|
}
|
|
fn sorted(value:serde_json::Value)->serde_json::Value {
|
|
match value {
|
|
serde_json::Value::Object(map)=>serde_json::Value::Object(map.into_iter().map(|(key,value)|(key,sorted(value)))
|
|
.collect::<BTreeMap<_,_>>().into_iter().collect()),
|
|
serde_json::Value::Array(rows)=>serde_json::Value::Array(rows.into_iter().map(sorted).collect()),
|
|
other=>other,
|
|
}
|
|
}
|
|
let raw=serde_json::to_vec(&sorted(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.model_sha256.as_ref().is_some_and(|value| !valid_sha(value))
|
|
|| self.model_sha256.is_some() != self.knowledge_cutoff.is_some()
|
|
{ return Err("signal_model_training_identity_incomplete".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 [*expected,snapshot.signal_at,snapshot.input_as_of,snapshot.input_available_at,snapshot.generated_at,snapshot.published_at]
|
|
.iter().any(|at|at.timestamp_subsec_nanos()%1000!=0) || self.knowledge_cutoff.is_some_and(|at|at.timestamp_subsec_nanos()%1000!=0) {
|
|
return Err("signal_timestamp_requires_microsecond_precision".into());
|
|
}
|
|
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.is_some_and(|cutoff| cutoff > snapshot.signal_at) || snapshot.signal_at > *expected
|
|
|| snapshot.input_available_at > snapshot.signal_at || 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
|
|
|| self.knowledge_cutoff.is_some_and(|cutoff| snapshot.generated_at < 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 generator_sha256(&self) -> &str { &self.book.generator_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 self.book.provenance == SignalProvenance::Observed && ctx.current_datetime().is_none() {
|
|
return Err("observed_signal_consumption_clock_missing".into());
|
|
}
|
|
let consumption_clock=ctx.current_datetime()
|
|
.unwrap_or(ctx.decision_date.and_hms_opt(15,0,0).expect("completed decision session"));
|
|
let lagged_daily=ctx.is_lagged_execution() && self.book.frequency==SignalFrequency::Daily;
|
|
if lagged_daily && shanghai(snapshot.input_as_of).date()>ctx.decision_date {
|
|
return Err("next_open_signal_contains_execution_session_inputs".into());
|
|
}
|
|
if shanghai(snapshot.input_available_at)>consumption_clock || shanghai(snapshot.signal_at)>consumption_clock {
|
|
return Err("signal_not_available_at_consumption_clock".into());
|
|
}
|
|
if self.book.provenance == SignalProvenance::Observed
|
|
&& (shanghai(snapshot.generated_at)>consumption_clock || shanghai(snapshot.published_at)>consumption_clock) {
|
|
return Err("observed_signal_published_after_consumption_clock".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),
|
|
model_sha256: Some("d".repeat(64)),
|
|
knowledge_cutoff: Some("2024-12-31T15:00:00+08:00".parse().unwrap()),
|
|
provenance: SignalProvenance::Reconstructed, frequency: SignalFrequency::Daily,
|
|
expected_decisions: vec![decision], snapshots: vec![SignalSnapshot {
|
|
signal_at: source,
|
|
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
|
|
}
|
|
|
|
fn at_context<T>(at: Option<NaiveDateTime>, action: impl FnOnce(&StrategyContext<'_>) -> T) -> T {
|
|
let data = crate::DataSet::from_components(vec![], vec![], vec![], vec![], vec![]).unwrap();
|
|
let portfolio = PortfolioState::new(10_000.0);
|
|
let symbols = BTreeSet::new();
|
|
action(&StrategyContext {
|
|
execution_date: NaiveDate::from_ymd_opt(2025,1,7).unwrap(),
|
|
decision_date: NaiveDate::from_ymd_opt(2025,1,6).unwrap(), decision_index:0,
|
|
data:&data, portfolio:&portfolio, futures_account:None, open_orders:&[],
|
|
dynamic_universe:None, subscriptions:&symbols, process_events:&[], active_process_event:None,
|
|
active_datetime:at, order_events:&[], fills:&[],
|
|
})
|
|
}
|
|
|
|
#[test]
|
|
fn observed_next_open_never_backdates_a_morning_publication_into_yesterdays_orders() {
|
|
let mut raw = book();
|
|
raw.provenance=SignalProvenance::Observed;
|
|
raw.snapshots[0].generated_at="2025-01-07T08:45:00+08:00".parse().unwrap();
|
|
raw.snapshots[0].published_at="2025-01-07T08:46:00+08:00".parse().unwrap();
|
|
let value=seal(raw).validate().unwrap();
|
|
for clock in ["2025-01-06 15:00:00", "2025-01-07 08:45:00"] {
|
|
at_context(Some(clock.parse().unwrap()), |ctx| {
|
|
assert_eq!(value.intents(ctx).unwrap_err(),"observed_signal_published_after_consumption_clock");
|
|
assert!(ctx.portfolio.positions().is_empty());
|
|
});
|
|
}
|
|
at_context(Some("2025-01-07 09:30:00".parse().unwrap()), |ctx| {
|
|
assert_eq!(value.intents(ctx).unwrap().len(),1);
|
|
assert!(ctx.portfolio.positions().is_empty());
|
|
});
|
|
at_context(None, |ctx| assert_eq!(value.intents(ctx).unwrap_err(),"observed_signal_consumption_clock_missing"));
|
|
}
|
|
|
|
#[test]
|
|
fn reconstruction_ignores_research_wall_clock_but_never_early_input_availability() {
|
|
let value=book().validate().unwrap();
|
|
at_context(Some("2025-01-06 15:00:00".parse().unwrap()), |ctx| assert!(value.intents(ctx).is_ok()));
|
|
at_context(Some("2025-01-06 14:59:59".parse().unwrap()), |ctx| {
|
|
assert_eq!(value.intents(ctx).unwrap_err(),"signal_not_available_at_consumption_clock");
|
|
});
|
|
let mut raw=book();
|
|
raw.snapshots[0].input_as_of="2025-01-07T08:30:00+08:00".parse().unwrap();
|
|
raw.snapshots[0].input_available_at=raw.snapshots[0].input_as_of;
|
|
raw.snapshots[0].signal_at=raw.snapshots[0].input_as_of;
|
|
let value=seal(raw).validate().unwrap();
|
|
at_context(Some("2025-01-07 09:30:00".parse().unwrap()), |ctx| {
|
|
assert_eq!(value.intents(ctx).unwrap_err(),"next_open_signal_contains_execution_session_inputs");
|
|
});
|
|
}
|
|
|
|
#[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 = Some(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].signal_at=raw.snapshots[0].input_available_at;
|
|
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();
|
|
}
|
|
}
|