clm-kernel 0.0.21

Cubical Logic Model (CLM) sovereign execution engine, CPN-VM, and Cordis spatiotemporal substrate
Documentation
//! Layer 4 Interaction Surface Tests — Sprint 364
//!
//! Verifies EOA sponsor signing, presentation membrane lifecycle, JSON-RPC gateway router,
//! structured event logs, and card navigation modalities.

use clm_rust_core::layer4::{
    generate_keypair, sign_intent, verify_signature,
    CardGraph, CardNode, NavigationDirection,
    EventLog, ExecutionEvent,
    GatewayRequest, GatewayRouter,
    MembraneAction, MembraneSession, PresentationMembrane,
};

#[test]
fn test_eoa_sponsor_signing_and_verification() {
    let (signing_key, sponsor_did) = generate_keypair();
    assert!(sponsor_did.starts_with("did:key:z"), "DID must start with did:key:z");

    let pcard_handle = "pcard:system:bootstrap";
    let intent = "run hello world";
    let timestamp = "2026-09-17T14:00:00Z";

    let receipt = sign_intent(&signing_key, pcard_handle, intent, timestamp);
    assert_eq!(receipt.sponsor_did, sponsor_did);
    assert_eq!(receipt.pcard_handle, pcard_handle);
    assert_eq!(receipt.intent, intent);
    assert!(!receipt.signature.is_empty());

    // Valid verification
    let is_valid = verify_signature(
        &receipt.sponsor_did,
        &receipt.pcard_handle,
        &receipt.intent_hash,
        &receipt.timestamp,
        &receipt.signature,
    );
    assert!(is_valid, "Valid signature must verify");

    // Tampered verification must fail
    let tampered = verify_signature(
        &receipt.sponsor_did,
        &receipt.pcard_handle,
        "tampered_hash_value_12345",
        &receipt.timestamp,
        &receipt.signature,
    );
    assert!(!tampered, "Tampered payload must fail verification");

    // Cross-language verification: verify signature generated by Python
    let py_did = "did:key:z6MkomRfctGWmsp42nVGMUhjiFFeDRe3qev6bQsHd5KQcDXW";
    let py_pcard = "pcard:test";
    let py_hash = "d74981efa70a0c880b8d8c1985d075dbcbf679b99a5f9914e5aaf96b831a9e24";
    let py_ts = "2026-09-17T14:00:00Z";
    let py_sig = "a7a2d5543fd3af436381328accbb5f229d0d1dc73f05daddc9cd1377d02e7339dcb97a586cfb254423fc7bcbb9c06ae97f1b99d8f01cae93670b8b4d93059d0b";
    let py_verified = verify_signature(py_did, py_pcard, py_hash, py_ts, py_sig);
    assert!(py_verified, "Rust must verify Python-generated Ed25519 EOA intent signature");
}

#[test]
fn test_presentation_membrane_action_dispatch() {
    let membrane = PresentationMembrane::new("tui_main", "terminal");
    let mut session = MembraneSession::new("sess_001", "did:key:z6MkuUser1");

    let action1 = MembraneAction::user_prompt("compose hello world");
    let res1 = membrane.handle_action(&mut session, action1, "2026-09-17T14:00:01Z");
    assert!(res1.success);
    assert_eq!(res1.emitted_cards.len(), 1);

    let action2 = MembraneAction::select_card(&res1.emitted_cards[0]);
    let res2 = membrane.handle_action(&mut session, action2, "2026-09-17T14:00:02Z");
    assert!(res2.success);
    assert_eq!(session.active_panel, res1.emitted_cards[0]);
    assert_eq!(session.history.len(), 2);
}

#[test]
fn test_gateway_router_jsonrpc_dispatch() {
    let mut router = GatewayRouter::new();
    router.register_card("hash_mcard_123", serde_json::json!({ "title": "System Card" }));

    // Test clm.status
    let req_status = GatewayRequest {
        jsonrpc: "2.0".to_string(),
        method: "clm.status".to_string(),
        params: None,
        id: serde_json::json!(1),
    };
    let res_status = router.dispatch(&req_status);
    assert!(res_status.error.is_none());
    let status_val = res_status.result.unwrap();
    assert_eq!(status_val["status"], "ready");

    // Test clm.eval
    let req_eval = GatewayRequest {
        jsonrpc: "2.0".to_string(),
        method: "clm.eval".to_string(),
        params: Some(serde_json::json!({ "expression": "1 + 1" })),
        id: serde_json::json!(2),
    };
    let res_eval = router.dispatch(&req_eval);
    assert!(res_eval.error.is_none());
    let eval_val = res_eval.result.unwrap();
    assert_eq!(eval_val["evaluated"], "1 + 1");
    assert!(eval_val["content_hash"].as_str().unwrap().len() == 64);

    // Test clm.card_get existing
    let req_get = GatewayRequest {
        jsonrpc: "2.0".to_string(),
        method: "clm.card_get".to_string(),
        params: Some(serde_json::json!({ "hash": "hash_mcard_123" })),
        id: serde_json::json!(3),
    };
    let res_get = router.dispatch(&req_get);
    assert!(res_get.error.is_none());
    assert_eq!(res_get.result.unwrap()["title"], "System Card");

    // Test clm.card_get non-existent
    let req_missing = GatewayRequest {
        jsonrpc: "2.0".to_string(),
        method: "clm.card_get".to_string(),
        params: Some(serde_json::json!({ "hash": "non_existent" })),
        id: serde_json::json!(4),
    };
    let res_missing = router.dispatch(&req_missing);
    assert!(res_missing.error.is_some());
    assert_eq!(res_missing.error.unwrap().code, -32004);
}

#[test]
fn test_structured_event_log_and_receipt() {
    let mut log = EventLog::new("run_999", "did:key:z6MkuSponsor");
    log.append_event(ExecutionEvent {
        transition_id: "t_fire_1".to_string(),
        transition_name: "Fire Prompt".to_string(),
        source_places: vec!["p_input".to_string()],
        target_places: vec!["p_output".to_string()],
        token_deltas: serde_json::json!({ "tokens": 1 }),
        timestamp: "2026-09-17T14:00:00Z".to_string(),
    });

    let receipt_hash = log.compute_receipt_hash();
    assert_eq!(receipt_hash.len(), 64);
    assert_eq!(log.events.len(), 1);
}

#[test]
fn test_card_navigation_modalities() {
    let mut graph = CardGraph::new();

    // Node A (content: "hello")
    graph.insert_node(CardNode {
        hash: "card_a".to_string(),
        handle: Some("mcard:a".to_string()),
        card_type: "mcard".to_string(),
        content_hash: "content_same".to_string(),
        upstream_vcards: vec!["vcard_prev".to_string()],
        downstream_pcards: vec!["pcard_next_1".to_string(), "pcard_next_2".to_string()],
    });

    // Node B (same content as A: "content_same")
    graph.insert_node(CardNode {
        hash: "card_b".to_string(),
        handle: Some("mcard:b".to_string()),
        card_type: "mcard".to_string(),
        content_hash: "content_same".to_string(),
        upstream_vcards: vec![],
        downstream_pcards: vec![],
    });

    // Covariant (forward)
    let fwd = graph.navigate("card_a", NavigationDirection::Covariant);
    assert_eq!(fwd, vec!["pcard_next_1".to_string(), "pcard_next_2".to_string()]);

    // Contravariant (backward)
    let bwd = graph.navigate("card_a", NavigationDirection::Contravariant);
    assert_eq!(bwd, vec!["vcard_prev".to_string()]);

    // Invariant (isomorphic content equivalence)
    let iso = graph.navigate("card_a", NavigationDirection::Invariant);
    assert_eq!(iso, vec!["card_a".to_string(), "card_b".to_string()]);
}