clm-kernel 0.0.11

Cubical Logic Model (CLM) sovereign execution engine, CPN-VM, and Cordis spatiotemporal substrate
Documentation
use super::*;

    fn dummy_manifest(service_id: &str, did: &str, cost: f64, latency: u32) -> ServiceCapabilityManifest {
        ServiceCapabilityManifest {
            service_id: service_id.to_string(),
            version: "1.0.0".to_string(),
            provider_did: did.to_string(),
            description: "Dummy capability".to_string(),
            input_schema: SchemaSpec {
                schema_type: "object".to_string(),
                properties: None,
                required: None,
                polynomial_order: None,
                description: None,
            },
            output_schema: SchemaSpec {
                schema_type: "object".to_string(),
                properties: None,
                required: None,
                polynomial_order: None,
                description: None,
            },
            sla: SlaWitness {
                context_window: Some(4096),
                compute_type: "cpu-generic".to_string(),
                p95_latency_ms: latency,
                throughput_tps: Some(50),
                reliability_score: Some(0.99),
            },
            pricing: PricingSpec {
                base_cost: cost,
                cost_per_token: None,
                currency: "PKC_TOKEN".to_string(),
            },
            endpoints: vec![ServiceEndpoint {
                protocol: "noise_xx".to_string(),
                address: "192.168.1.50".to_string(),
                port: 9095,
                noise_pubkey_hex: None,
            }],
            registered_at: 1000,
            ttl_seconds: 60,
            content_hash: String::new(),
            signature: None,
        }
    }

    #[test]
    fn test_valid_service_id() {
        assert!(is_valid_service_id("service.pkc.llm.inference"));
        assert!(is_valid_service_id("service.pkc.tikz.compiler"));
        assert!(!is_valid_service_id("service.ollama.inference"));
        assert!(!is_valid_service_id("service.pkc."));
        assert!(!is_valid_service_id("service.pkc.llm"));
    }

    #[test]
    fn test_manifest_signing_and_verification() {
        let identity = SovereignNodeIdentity::generate();
        let mut manifest = dummy_manifest("service.pkc.proof.checker", &identity.did, 0.001, 35);
        manifest = sign_capability_manifest(manifest, &identity).expect("sign manifest");

        assert_eq!(manifest.content_hash.len(), 64);
        assert!(manifest.signature.is_some());
        assert!(verify_capability_manifest(&manifest));

        // Tamper
        let mut tampered = manifest.clone();
        tampered.pricing.base_cost = 99.0;
        assert!(!verify_capability_manifest(&tampered));
    }

    #[test]
    fn test_router_candidate_ranking_and_loop_detection() {
        let alice = SovereignNodeIdentity::generate();
        let bob = SovereignNodeIdentity::generate();

        let mut catalog = ServiceCatalog::new(&alice.did);

        let mut m_local = dummy_manifest("service.pkc.llm.inference", &alice.did, 0.01, 20);
        m_local = sign_capability_manifest(m_local, &alice).unwrap();
        catalog.register_local_service(m_local).unwrap();

        let mut m_remote = dummy_manifest("service.pkc.llm.inference", &bob.did, 0.001, 60);
        m_remote.endpoints[0].address = "203.0.113.1".to_string(); // Overlay
        m_remote = sign_capability_manifest(m_remote, &bob).unwrap();
        catalog.register_remote_service(m_remote);

        let router = ServiceRouter::new(&catalog);
        let ranked = router.rank_candidates("service.pkc.llm.inference", None);

        assert_eq!(ranked.len(), 2);
        assert_eq!(ranked[0].tier, RouteTier::Local);
        assert_eq!(ranked[1].tier, RouteTier::Overlay);

        // Loop detection
        let mut trace = create_trace_vector(&alice.did, None);
        append_trace_hop(&mut trace, &bob.did, 100);
        assert!(detect_routing_loop(&trace, &bob.did));
    }