iicp-client 0.7.93

Use the open IICP AI mesh from Rust without running a node
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

use iicp_client::dispatch_ticket_trust::{
    verify_dispatch_ticket_v2, DispatchTicketBindings, DispatchTrustBundle,
    LocalDispatchReplayCache,
};
use serde_json::Value;

#[test]
fn runtime_verifier_consumes_portable_vectors() {
    let fixture: Value = serde_json::from_str(include_str!(
        "../parity/dispatch-ticket-trust-v2-crypto.json"
    ))
    .unwrap();
    for vector in fixture["vectors"].as_array().unwrap() {
        let keys = fixture["keys"]
            .as_array()
            .unwrap()
            .iter()
            .filter(|key| {
                vector["trust_bundle_key_ids"]
                    .as_array()
                    .unwrap()
                    .contains(&key["key_id"])
            })
            .cloned()
            .collect::<Vec<_>>();
        let bundle: DispatchTrustBundle =
            serde_json::from_value(serde_json::json!({"bundle_version": 4, "keys": keys})).unwrap();
        let claims = &vector["claims"];
        let bindings = DispatchTicketBindings {
            issuer: claims["issuer"].as_str().unwrap().into(),
            provider_id: claims["provider_id"].as_str().unwrap().into(),
            intent: claims["intent"].as_str().unwrap().into(),
            constraints_digest: claims["constraints_digest"].as_str().unwrap().into(),
            audience: None,
        };
        let mut replay = LocalDispatchReplayCache::default();
        if vector["jti_seen"].as_bool().unwrap() {
            replay.remember(
                claims["jti"].as_str().unwrap(),
                claims["expires_at"].as_u64().unwrap(),
            );
        }
        let result = verify_dispatch_ticket_v2(
            claims,
            vector["signature_b64url"].as_str().unwrap(),
            &bundle,
            &bindings,
            vector["now"].as_u64().unwrap(),
            4,
            Some(&mut replay),
        );
        assert_eq!(
            result.code,
            vector["expected"].as_str().unwrap(),
            "{}",
            vector["id"]
        );
    }
}

#[test]
fn bundle_rollback_and_binding_mismatch_fail_closed() {
    let fixture: Value = serde_json::from_str(include_str!(
        "../parity/dispatch-ticket-trust-v2-crypto.json"
    ))
    .unwrap();
    let vector = &fixture["vectors"][0];
    let mut bundle: DispatchTrustBundle = serde_json::from_value(
        serde_json::json!({"bundle_version": 3, "keys": [fixture["keys"][0].clone()]}),
    )
    .unwrap();
    let bindings = DispatchTicketBindings {
        issuer: vector["claims"]["issuer"].as_str().unwrap().into(),
        provider_id: "wrong-provider".into(),
        intent: vector["claims"]["intent"].as_str().unwrap().into(),
        constraints_digest: vector["claims"]["constraints_digest"]
            .as_str()
            .unwrap()
            .into(),
        audience: None,
    };
    assert_eq!(
        verify_dispatch_ticket_v2(
            &vector["claims"],
            vector["signature_b64url"].as_str().unwrap(),
            &bundle,
            &bindings,
            vector["now"].as_u64().unwrap(),
            4,
            None
        )
        .code,
        "reject_bundle_rollback"
    );
    bundle.bundle_version = 4;
    assert_eq!(
        verify_dispatch_ticket_v2(
            &vector["claims"],
            vector["signature_b64url"].as_str().unwrap(),
            &bundle,
            &bindings,
            vector["now"].as_u64().unwrap(),
            0,
            None
        )
        .code,
        "reject_claim_mismatch"
    );
}