Skip to main content

qualia_core_db/domain_licence/
mod.rs

1//! Domain licence instruments — signed grants binding licence terms to domain names.
2//!
3//! Implements the methodology in
4//! `docs/work-in-progress/DOMAIN_LICENCE_METHODOLOGY_WIP.md`: a `DomainLicence`
5//! is an Ed25519-signed JSON document (`.qlic.json`) that names subject domains,
6//! a licence class, a capability scope, a validity window, optional payment
7//! evidence, and optional chain anchors carrying the canonical digest.
8
9mod codec;
10mod model;
11mod registry;
12mod verify;
13
14pub use codec::{
15    amendment_from_json, amendment_to_json, anchor_op_return, canonical_bytes, canonical_digest,
16    canonical_digest_tag, from_json, to_json, LICENCE_FORMAT,
17};
18pub use model::{
19    AgentKind, ChainAnchor, Delegation, DomainLicence, LicenceAmendment, LicenceClass,
20    PaymentEvidence, PrincipalCategory, RepresentedPrincipalContext,
21};
22pub use registry::{LicenceRegistry, RegistryEntry, RegistrySource, COMPILED_IN_LICENSED_DOMAINS};
23pub use verify::{
24    delegated_members, issue, issue_amendment, licence_status, normalize_domain, verify,
25    verify_amendment, verify_represented_principal, IssueParams, LicenceError, LicenceStatus,
26};
27
28#[cfg(test)]
29mod tests {
30    use super::*;
31    use ed25519_dalek::SigningKey;
32
33    fn key() -> SigningKey {
34        SigningKey::from_bytes(&[7u8; 32])
35    }
36
37    fn base_params() -> IssueParams {
38        IssueParams {
39            issuer_did: "did:q42:issuer:test".into(),
40            subject_domains: vec!["Example.ORG".into()],
41            licence_class: LicenceClass::Community,
42            capability_scope: vec!["wasm-ontology".into()],
43            terms_uri: "https://webcivics.example/terms/community-1".into(),
44            ..Default::default()
45        }
46    }
47
48    fn pinned(lic: &DomainLicence) -> String {
49        lic.issuer_pubkey_hex.clone()
50    }
51
52    #[test]
53    fn issued_licence_verifies_for_subject_domain() {
54        let lic = issue(base_params(), &key()).unwrap();
55        assert!(lic.licence_id.starts_with("did:q42:licence:"));
56        assert!(verify(
57            &lic,
58            100,
59            "example.org",
60            "wasm-ontology",
61            Some(&pinned(&lic)),
62            &[]
63        )
64        .is_ok());
65        assert!(verify(
66            &lic,
67            100,
68            "EXAMPLE.org.",
69            "wasm-ontology",
70            Some(&pinned(&lic)),
71            &[]
72        )
73        .is_ok());
74    }
75
76    #[test]
77    fn tampered_signature_denies() {
78        let mut lic = issue(base_params(), &key()).unwrap();
79        lic.licensee_label = "forged".into();
80        assert_eq!(
81            verify(
82                &lic,
83                100,
84                "example.org",
85                "wasm-ontology",
86                Some(&pinned(&lic)),
87                &[]
88            ),
89            Err(LicenceError::BadSignature)
90        );
91    }
92
93    #[test]
94    fn wrong_domain_denies() {
95        let lic = issue(base_params(), &key()).unwrap();
96        assert_eq!(
97            verify(
98                &lic,
99                100,
100                "other.org",
101                "wasm-ontology",
102                Some(&pinned(&lic)),
103                &[]
104            ),
105            Err(LicenceError::DomainNotCovered)
106        );
107    }
108
109    #[test]
110    fn expired_and_not_yet_valid_deny() {
111        let mut p = base_params();
112        p.not_before_unix = 50;
113        p.expires_unix = 200;
114        let lic = issue(p, &key()).unwrap();
115        assert_eq!(
116            verify(&lic, 10, "example.org", "", Some(&pinned(&lic)), &[]),
117            Err(LicenceError::NotYetValid)
118        );
119        assert_eq!(
120            verify(&lic, 200, "example.org", "", Some(&pinned(&lic)), &[]),
121            Err(LicenceError::Expired)
122        );
123    }
124
125    #[test]
126    fn scope_not_covered_denies() {
127        let lic = issue(base_params(), &key()).unwrap();
128        assert_eq!(
129            verify(&lic, 100, "example.org", "portal", Some(&pinned(&lic)), &[]),
130            Err(LicenceError::ScopeNotCovered)
131        );
132    }
133
134    #[test]
135    fn unpinned_issuer_denies_when_pinned() {
136        let lic = issue(base_params(), &key()).unwrap();
137        let other = SigningKey::from_bytes(&[9u8; 32]);
138        let wrong = hex::encode(other.verifying_key().to_bytes());
139        assert_eq!(
140            verify(&lic, 100, "example.org", "", Some(&wrong), &[]),
141            Err(LicenceError::UntrustedIssuer)
142        );
143    }
144
145    #[test]
146    fn unknown_class_and_format_fail_closed() {
147        let mut lic = issue(base_params(), &key()).unwrap();
148        lic.licence_class = "platinum".into();
149        assert_eq!(
150            verify(&lic, 100, "example.org", "", Some(&pinned(&lic)), &[]),
151            Err(LicenceError::UnknownClass)
152        );
153        let mut lic2 = issue(base_params(), &key()).unwrap();
154        lic2.format = "something-else".into();
155        assert_eq!(
156            verify(&lic2, 100, "example.org", "", Some(&pinned(&lic2)), &[]),
157            Err(LicenceError::UnknownFormat)
158        );
159    }
160
161    #[test]
162    fn commercial_requires_payment_evidence_at_issue() {
163        let mut p = base_params();
164        p.licence_class = LicenceClass::Commercial;
165        assert_eq!(
166            issue(p.clone(), &key()),
167            Err(LicenceError::PaymentEvidenceMissing)
168        );
169        p.payment_evidence = Some(PaymentEvidence {
170            rail: "xec".into(),
171            txid: "ab".repeat(32),
172            amount_sats: 50_000,
173        });
174        assert!(issue(p, &key()).is_ok());
175    }
176
177    #[test]
178    fn commercial_principal_acting_via_agent_cannot_claim_gratis_community_tier() {
179        let community_lic = issue(base_params(), &key()).unwrap();
180        let commercial_via_person = RepresentedPrincipalContext {
181            invoking_agent_kind: AgentKind::NaturalPerson,
182            represented_principal: PrincipalCategory::CommercialEntityOrPrincipal,
183            beneficiary_is_commercial: true,
184        };
185        assert_eq!(
186            verify_represented_principal(&community_lic, &commercial_via_person),
187            Err(LicenceError::CommercialPrincipalRequiresCommercialLicence)
188        );
189
190        let fiduciary_for_human = RepresentedPrincipalContext {
191            invoking_agent_kind: AgentKind::AiAgent,
192            represented_principal: PrincipalCategory::FiduciaryAgentForHumanBeneficiary,
193            beneficiary_is_commercial: false,
194        };
195        assert_eq!(
196            verify_represented_principal(&community_lic, &fiduciary_for_human),
197            Ok(())
198        );
199    }
200
201    #[test]
202    fn delegation_only_for_steward_classes() {
203        let mut p = base_params();
204        p.delegation = Some(Delegation {
205            covers_subdomains: false,
206            members: vec!["bakery.example.org".into()],
207            steward_agreement: String::new(),
208        });
209        assert_eq!(
210            issue(p.clone(), &key()),
211            Err(LicenceError::DelegationNotPermitted)
212        );
213        p.licence_class = LicenceClass::CommunitySteward;
214        let lic = issue(p, &key()).unwrap();
215        assert!(verify(
216            &lic,
217            100,
218            "bakery.example.org",
219            "",
220            Some(&pinned(&lic)),
221            &[]
222        )
223        .is_ok());
224        assert_eq!(
225            verify(
226                &lic,
227                100,
228                "grocer.example.org",
229                "",
230                Some(&pinned(&lic)),
231                &[]
232            ),
233            Err(LicenceError::DomainNotCovered)
234        );
235    }
236
237    #[test]
238    fn subdomain_wildcard_via_covers_subdomains() {
239        let mut p = base_params();
240        p.licence_class = LicenceClass::CommunitySteward;
241        p.delegation = Some(Delegation {
242            covers_subdomains: true,
243            members: vec![],
244            steward_agreement: String::new(),
245        });
246        let lic = issue(p, &key()).unwrap();
247        assert!(verify(
248            &lic,
249            100,
250            "anything.example.org",
251            "",
252            Some(&pinned(&lic)),
253            &[]
254        )
255        .is_ok());
256        assert!(verify(&lic, 100, "example.org", "", Some(&pinned(&lic)), &[]).is_ok());
257        assert_eq!(
258            verify(&lic, 100, "notexample.org", "", Some(&pinned(&lic)), &[]),
259            Err(LicenceError::DomainNotCovered)
260        );
261    }
262
263    #[test]
264    fn amendment_chain_join_leave() {
265        let mut p = base_params();
266        p.licence_class = LicenceClass::CommunitySteward;
267        p.delegation = Some(Delegation {
268            covers_subdomains: false,
269            members: vec!["bakery.example.org".into()],
270            steward_agreement: String::new(),
271        });
272        let lic = issue(p, &key()).unwrap();
273        let add = issue_amendment(
274            &lic.licence_id,
275            1,
276            vec!["grocer.example.org".into()],
277            vec![],
278            100,
279            &key(),
280        )
281        .unwrap();
282        let members = delegated_members(&lic, &[add.clone()]).unwrap();
283        assert!(members.contains(&"grocer.example.org".to_string()));
284        let remove = issue_amendment(
285            &lic.licence_id,
286            2,
287            vec![],
288            vec!["bakery.example.org".into()],
289            200,
290            &key(),
291        )
292        .unwrap();
293        let members = delegated_members(&lic, &[add, remove]).unwrap();
294        assert!(!members.contains(&"bakery.example.org".to_string()));
295    }
296
297    #[test]
298    fn amendment_signed_by_non_issuer_denies() {
299        let mut p = base_params();
300        p.licence_class = LicenceClass::CommunitySteward;
301        p.delegation = Some(Delegation {
302            covers_subdomains: false,
303            members: vec![],
304            steward_agreement: String::new(),
305        });
306        let lic = issue(p, &key()).unwrap();
307        let stranger = SigningKey::from_bytes(&[3u8; 32]);
308        let forged = issue_amendment(
309            &lic.licence_id,
310            1,
311            vec!["mall.example.org".into()],
312            vec![],
313            100,
314            &stranger,
315        )
316        .unwrap();
317        assert_eq!(
318            delegated_members(&lic, &[forged]),
319            Err(LicenceError::BadSignature)
320        );
321    }
322
323    #[test]
324    fn json_round_trip_preserves_licence() {
325        let lic = issue(base_params(), &key()).unwrap();
326        let json = to_json(&lic).unwrap();
327        let back = from_json(&json).unwrap();
328        assert_eq!(back, lic);
329        assert_eq!(canonical_digest(&back), canonical_digest(&lic));
330        assert!(canonical_digest_tag(&lic).starts_with("sha256:"));
331    }
332
333    #[test]
334    fn anchors_outside_signed_bytes() {
335        let mut lic = issue(base_params(), &key()).unwrap();
336        let digest = canonical_digest_tag(&lic);
337        lic.chain_anchors.push(ChainAnchor {
338            chain: "xec".into(),
339            txid: "ab".repeat(32),
340            op_return_hex: hex::encode(anchor_op_return(&lic)),
341            digest: digest.clone(),
342        });
343        assert!(verify(&lic, 100, "example.org", "", Some(&pinned(&lic)), &[]).is_ok());
344        assert_eq!(canonical_digest_tag(&lic), digest);
345        assert!(anchor_op_return(&lic).starts_with(b"QUALIA-LIC "));
346    }
347
348    #[test]
349    fn status_reports_reason_for_unlicensed() {
350        let s = licence_status(None, 0, "example.org", "", None, &[]);
351        assert!(!s.licensed);
352        assert_eq!(s.reason, "no licence");
353        let lic = issue(base_params(), &key()).unwrap();
354        let s = licence_status(
355            Some(&lic),
356            100,
357            "evil.example",
358            "",
359            Some(&pinned(&lic)),
360            &[],
361        );
362        assert!(!s.licensed);
363        assert_eq!(s.reason, "domain is not covered by this licence");
364    }
365}