Merge commit 'd803bfe2b1fe7f5e219e50ac20d6801a0a58ac75' as 'vendor/ruvector'

vendor/ruvector/examples/verified-applications/src/financial_routing.rs

@@ -0,0 +1,125 @@
+//! # 3. Financial Order Routing Integrity
+//!
+//! Before routing a trade decision:
+//! - Prove feature vector dimension matches model
+//! - Prove metric compatibility (L2 for risk, Cosine for similarity)
+//! - Prove risk scoring pipeline composition
+//!
+//! Store proof hash with trade ID. Replay the proof term if questioned later.
+//! Result: the feature pipeline itself was mathematically coherent.
+
+use crate::ProofReceipt;
+use ruvector_verified::{
+    gated::{self, ProofKind, ProofTier},
+    pipeline::compose_chain,
+    proof_store, vector_types, ProofEnvironment,
+};
+
+/// A trade order with its verified proof chain.
+#[derive(Debug)]
+pub struct VerifiedTradeOrder {
+    pub trade_id: String,
+    pub direction: String,
+    pub feature_dim: u32,
+    pub risk_score_proof: u32,
+    pub pipeline_proof: u32,
+    pub attestation: Vec<u8>,
+    pub proof_hash: u64,
+}
+
+/// Verify and emit proof for a trade order routing decision.
+pub fn verify_trade_order(
+    trade_id: &str,
+    feature_vector: &[f32],
+    feature_dim: u32,
+    risk_metric: &str,
+    direction: &str,
+) -> Result<VerifiedTradeOrder, String> {
+    let mut env = ProofEnvironment::new();
+
+    // 1. Feature dimension proof
+    let dim_check = vector_types::verified_dim_check(&mut env, feature_dim, feature_vector)
+        .map_err(|e| format!("feature dim: {e}"))?;
+
+    // 2. Risk metric proof
+    let _metric = vector_types::mk_distance_metric(&mut env, risk_metric)
+        .map_err(|e| format!("metric: {e}"))?;
+
+    // 3. Index type proof
+    let _index = vector_types::mk_hnsw_index_type(&mut env, feature_dim, risk_metric)
+        .map_err(|e| format!("index: {e}"))?;
+
+    // 4. Pipeline: feature_extract -> risk_score -> order_route
+    let chain = vec![
+        ("feature_extract".into(), 10u32, 11),
+        ("risk_score".into(), 11, 12),
+        ("order_route".into(), 12, 13),
+    ];
+    let (_in_ty, _out_ty, pipeline_proof) =
+        compose_chain(&chain, &mut env).map_err(|e| format!("pipeline: {e}"))?;
+
+    // 5. Route proof to appropriate tier
+    let _decision = gated::route_proof(ProofKind::PipelineComposition { stages: 3 }, &env);
+
+    // 6. Create attestation and compute hash for storage
+    let attestation = proof_store::create_attestation(&env, pipeline_proof);
+    let proof_hash = attestation.content_hash();
+
+    Ok(VerifiedTradeOrder {
+        trade_id: trade_id.into(),
+        direction: direction.into(),
+        feature_dim,
+        risk_score_proof: dim_check.proof_id,
+        pipeline_proof,
+        attestation: attestation.to_bytes(),
+        proof_hash,
+    })
+}
+
+/// Verify a batch of trade orders and return pass/fail counts.
+pub fn verify_trade_batch(
+    orders: &[(&str, &[f32], u32)], // (trade_id, features, dim)
+) -> (usize, usize) {
+    let mut passed = 0;
+    let mut failed = 0;
+    for (id, features, dim) in orders {
+        match verify_trade_order(id, features, *dim, "L2", "BUY") {
+            Ok(_) => passed += 1,
+            Err(_) => failed += 1,
+        }
+    }
+    (passed, failed)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn valid_trade_verified() {
+        let features = vec![0.3f32; 128];
+        let order = verify_trade_order("TRD-001", &features, 128, "L2", "BUY");
+        assert!(order.is_ok());
+        let o = order.unwrap();
+        assert_eq!(o.attestation.len(), 82);
+        assert_ne!(o.proof_hash, 0);
+    }
+
+    #[test]
+    fn wrong_dimension_blocks_trade() {
+        let features = vec![0.3f32; 64]; // Wrong
+        let result = verify_trade_order("TRD-002", &features, 128, "L2", "SELL");
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn batch_mixed_results() {
+        let good = vec![0.5f32; 128];
+        let bad = vec![0.5f32; 64];
+        let orders: Vec<(&str, &[f32], u32)> =
+            vec![("T1", &good, 128), ("T2", &bad, 128), ("T3", &good, 128)];
+        let (pass, fail) = verify_trade_batch(&orders);
+        assert_eq!(pass, 2);
+        assert_eq!(fail, 1);
+    }
+}