package_boundary.rs (11375B)
1 use std::collections::BTreeSet; 2 3 const MANIFEST: &str = include_str!("../Cargo.toml"); 4 const ROOT: &str = include_str!("../src/lib.rs"); 5 const CAPABILITY: &str = include_str!("../src/capability.rs"); 6 const ERROR: &str = include_str!("../src/error.rs"); 7 const EVENT: &str = include_str!("../src/event.rs"); 8 const RADROOTSD: &str = include_str!("../src/radrootsd.rs"); 9 const RUNTIME: &str = include_str!("../src/runtime.rs"); 10 #[cfg(feature = "terms")] 11 const TERMS_CONTRACT: &str = include_str!("../../../contracts/protocol/terms.v1.json"); 12 #[cfg(feature = "commerce")] 13 const COMMERCE_CONTRACT: &str = include_str!("../../../contracts/protocol/commerce.v1.json"); 14 const VERSIONED_SOURCES: &[&str] = &[ 15 include_str!("../src/capability/v1.rs"), 16 include_str!("../src/error/v1.rs"), 17 include_str!("../src/event/v1.rs"), 18 include_str!("../src/radrootsd/transport_publish/v5.rs"), 19 include_str!("../src/runtime/v1.rs"), 20 include_str!("../src/schema.rs"), 21 include_str!("../src/profile.rs"), 22 include_str!("../src/terms.rs"), 23 include_str!("../src/terms/writer.rs"), 24 include_str!("../src/terms/decode.rs"), 25 include_str!("../src/private_json.rs"), 26 include_str!("../src/json_array.rs"), 27 include_str!("../src/advertisement.rs"), 28 include_str!("../src/listing/read.rs"), 29 include_str!("../src/private_rumor.rs"), 30 include_str!("../src/commerce.rs"), 31 include_str!("../src/commerce/decode.rs"), 32 include_str!("../src/commerce/payload.rs"), 33 include_str!("../src/commerce/rumor.rs"), 34 include_str!("../src/commerce/seal.rs"), 35 include_str!("../src/commerce/initial_commitment.rs"), 36 include_str!("../src/commerce/signing_plan.rs"), 37 include_str!("../src/command.rs"), 38 include_str!("../src/nip01.rs"), 39 include_str!("../src/intent.rs"), 40 include_str!("../src/chat.rs"), 41 include_str!("../src/nip59.rs"), 42 include_str!("../src/nip59/routes.rs"), 43 include_str!("../src/chat/plan.rs"), 44 include_str!("../src/listing.rs"), 45 include_str!("../src/listing/input.rs"), 46 include_str!("../src/listing_values.rs"), 47 include_str!("../src/listing/command.rs"), 48 include_str!("../src/listing/plan.rs"), 49 include_str!("../src/plan.rs"), 50 ]; 51 52 #[cfg(feature = "commerce")] 53 #[test] 54 fn complete_record_contract_binds_closed_families_limits_and_independent_fixtures() { 55 use sha2::{Digest as _, Sha256}; 56 let contract: serde_json::Value = serde_json::from_str(COMMERCE_CONTRACT).unwrap(); 57 assert_eq!(contract["schema"], "radroots.commerce.codec.v1"); 58 assert_eq!( 59 contract["content_max_utf8_bytes"], 60 radroots_protocol::commerce::RECORD_MAX_BYTES 61 ); 62 assert_eq!( 63 contract["carrier_kind"], 64 radroots_protocol::profile::COMMERCE_KIND 65 ); 66 assert_eq!( 67 contract["record_id"]["domain_utf8_with_terminal_nul"], 68 "radroots.record.v1\0" 69 ); 70 assert_eq!( 71 contract["limits"]["structured_rumor_authoring_enabled"], 72 false 73 ); 74 assert_eq!( 75 contract["carrier_matching"]["creates_authenticated_capability"], 76 false 77 ); 78 let fixture_bytes = include_bytes!("fixtures/commerce_wire.v1.json"); 79 assert_eq!( 80 format!("{:x}", Sha256::digest(fixture_bytes)), 81 contract["independent_vectors"]["sha256"] 82 ); 83 assert_eq!( 84 format!( 85 "{:x}", 86 Sha256::digest(include_bytes!("support/commerce_wire_oracle.mjs")) 87 ), 88 contract["independent_vectors"]["producer_sha256"] 89 ); 90 assert_eq!( 91 format!( 92 "{:x}", 93 Sha256::digest(include_bytes!("fixtures/terms_wire.v1.json")) 94 ), 95 contract["independent_vectors"]["source_terms_fixture_sha256"] 96 ); 97 let fixture: serde_json::Value = serde_json::from_slice(fixture_bytes).unwrap(); 98 let required: BTreeSet<_> = contract["header_required_fields"] 99 .as_array() 100 .unwrap() 101 .iter() 102 .map(|v| v.as_str().unwrap()) 103 .collect(); 104 assert_eq!(required.len(), 14); 105 assert_eq!( 106 contract["payload_required_fields"] 107 .as_object() 108 .unwrap() 109 .len(), 110 19 111 ); 112 for row in fixture["vectors"].as_array().unwrap() { 113 let value: serde_json::Value = serde_json::from_str(row["wire"].as_str().unwrap()).unwrap(); 114 assert_eq!( 115 value 116 .as_object() 117 .unwrap() 118 .keys() 119 .map(String::as_str) 120 .collect::<BTreeSet<_>>(), 121 required 122 ); 123 let fields: BTreeSet<_> = contract["payload_required_fields"] 124 [row["type"].as_str().unwrap()] 125 .as_array() 126 .unwrap() 127 .iter() 128 .map(|v| v.as_str().unwrap()) 129 .collect(); 130 assert_eq!( 131 value["payload"] 132 .as_object() 133 .unwrap() 134 .keys() 135 .map(String::as_str) 136 .collect::<BTreeSet<_>>(), 137 fields 138 ); 139 } 140 } 141 142 #[cfg(feature = "terms")] 143 #[test] 144 fn terms_contract_binds_limits_hash_domain_and_packaged_independent_fixtures() { 145 use sha2::{Digest as _, Sha256}; 146 let contract: serde_json::Value = serde_json::from_str(TERMS_CONTRACT).unwrap(); 147 assert_eq!(contract["schema"], "radroots.terms.codec.v1"); 148 assert_eq!(contract["decoding"]["objects_only"], true); 149 assert_eq!(contract["decoding"]["max_json_depth"], 16); 150 assert_eq!(contract["decoding"]["max_lines"], 32); 151 assert_eq!(contract["decoding"]["max_fulfillment_groups"], 8); 152 assert_eq!( 153 contract["limits"]["authenticated_admission_implemented_by_this_contract"], 154 false 155 ); 156 assert_eq!( 157 contract["content_max_utf8_bytes"], 158 radroots_protocol::terms::TERMS_MAX_BYTES 159 ); 160 assert_eq!( 161 contract["digest"]["domain_utf8_with_terminal_nul"], 162 "radroots.terms.v1\0" 163 ); 164 assert_eq!( 165 contract["limits"]["structured_record_authoring_enabled"], 166 false 167 ); 168 assert_eq!( 169 contract["retention"]["automatic_private_serialize_or_clone"], 170 false 171 ); 172 assert_eq!( 173 contract["retention"]["private_fields_in_temporary_json_trees"], 174 false 175 ); 176 let fixture_bytes = include_bytes!("fixtures/terms_wire.v1.json"); 177 let producer = include_bytes!("support/terms_wire_oracle.mjs"); 178 assert_eq!( 179 format!("{:x}", Sha256::digest(fixture_bytes)), 180 contract["independent_vectors"]["sha256"] 181 ); 182 assert_eq!( 183 format!("{:x}", Sha256::digest(producer)), 184 contract["independent_vectors"]["producer_sha256"] 185 ); 186 let fixture: serde_json::Value = serde_json::from_slice(fixture_bytes).unwrap(); 187 let required: BTreeSet<_> = contract["required_fields"] 188 .as_array() 189 .unwrap() 190 .iter() 191 .map(|v| v.as_str().unwrap()) 192 .collect(); 193 assert_eq!(required.len(), 9); 194 for row in fixture["vectors"].as_array().unwrap() { 195 let object: serde_json::Value = 196 serde_json::from_str(row["wire"].as_str().unwrap()).unwrap(); 197 assert_eq!( 198 object 199 .as_object() 200 .unwrap() 201 .keys() 202 .map(String::as_str) 203 .collect::<BTreeSet<_>>(), 204 required 205 ); 206 } 207 } 208 209 #[test] 210 fn manifest_has_approved_data_only_features_and_dependencies() { 211 assert!(MANIFEST.contains("name = \"radroots_protocol\"")); 212 assert!(MANIFEST.contains("version = \"0.1.0-alpha\"")); 213 assert!(MANIFEST.contains("publish = [\"crates-io\"]")); 214 assert!(MANIFEST.contains("[lib]\nname = \"radroots_protocol\"")); 215 assert!(MANIFEST.contains("default = [\"std\", \"serde\"]")); 216 assert_eq!( 217 table_keys(MANIFEST, "[features]"), 218 BTreeSet::from([ 219 "advertisement", 220 "chat", 221 "commands", 222 "commerce", 223 "default", 224 "intent", 225 "listing", 226 "nip01", 227 "private_rumor", 228 "serde", 229 "std", 230 "terms" 231 ]) 232 ); 233 assert_eq!( 234 table_keys(MANIFEST, "[dependencies]"), 235 BTreeSet::from([ 236 "radroots_domain", 237 "radroots_identity", 238 "serde", 239 "serde_json", 240 "sha2", 241 "zeroize" 242 ]) 243 ); 244 assert_eq!( 245 table_keys(MANIFEST, "[dev-dependencies]"), 246 BTreeSet::from(["serde_json"]) 247 ); 248 } 249 250 #[test] 251 fn crate_root_exposes_only_the_approved_versioned_skeleton() { 252 assert!(ROOT.contains("#![cfg_attr(not(feature = \"std\"), no_std)]")); 253 assert_eq!( 254 root_declarations("pub mod "), 255 BTreeSet::from([ 256 "advertisement", 257 "capability", 258 "chat", 259 "command", 260 "commerce", 261 "error", 262 "event", 263 "nip01", 264 "intent", 265 "nip59", 266 "listing", 267 "plan", 268 "profile", 269 "private_rumor", 270 "radrootsd", 271 "runtime", 272 "schema", 273 "terms" 274 ]) 275 ); 276 for source in [CAPABILITY, EVENT] { 277 assert!(source.lines().any(|line| line.trim() == "pub mod v1;")); 278 } 279 assert!(ERROR.lines().any(|line| line.trim() == "pub mod v1;")); 280 assert!(RUNTIME.lines().any(|line| line.trim() == "pub mod v1;")); 281 assert!(RADROOTSD.contains("pub mod transport_publish {")); 282 assert!(RADROOTSD.lines().any(|line| line.trim() == "pub mod v5;")); 283 assert!( 284 !ROOT 285 .lines() 286 .map(str::trim) 287 .any(|line| line.starts_with("pub use ")) 288 ); 289 } 290 291 #[test] 292 fn public_contract_sources_exclude_runtime_dependencies_and_wrapper_traits() { 293 assert!(ROOT.contains("#![forbid(unsafe_code)]")); 294 for source in VERSIONED_SOURCES { 295 for forbidden in [ 296 "dto_bindgen", 297 "wasm_bindgen", 298 "uniffi", 299 "tokio::", 300 "sqlx::", 301 "reqwest::", 302 "nostr::", 303 "std::fs", 304 "std::net", 305 "std::process", 306 "impl core::ops::Deref", 307 "impl std::ops::Deref", 308 "unsafe fn", 309 "unsafe impl", 310 "unsafe {", 311 ] { 312 assert!( 313 !source.contains(forbidden), 314 "protocol contract source contains forbidden surface `{forbidden}`" 315 ); 316 } 317 } 318 } 319 320 fn table_keys<'a>(manifest: &'a str, heading: &str) -> BTreeSet<&'a str> { 321 let Some((_, table)) = manifest.split_once(heading) else { 322 return BTreeSet::new(); 323 }; 324 table 325 .lines() 326 .skip(1) 327 .take_while(|line| !line.trim_start().starts_with('[')) 328 .filter_map(|line| { 329 let line = line.trim(); 330 (line 331 .bytes() 332 .next() 333 .is_some_and(|byte| byte.is_ascii_lowercase() || byte == b'_') 334 && !line.starts_with('#')) 335 .then(|| line.split_once('=').map(|(key, _)| key.trim())) 336 .flatten() 337 }) 338 .collect() 339 } 340 341 fn root_declarations(prefix: &str) -> BTreeSet<&str> { 342 ROOT.lines() 343 .map(str::trim) 344 .filter_map(|line| line.strip_prefix(prefix)) 345 .filter_map(|name| name.strip_suffix(';')) 346 .collect() 347 }