lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

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 }