1mod 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}