lib

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

commit 6ada4f98859a8b24b84caef70445c6cdc13b380c
parent 7845f46c23bcfc4ebc4d3b8e705fe456308f7ce1
Author: triesap <tyson@radroots.org>
Date:   Thu, 22 Oct 2026 23:44:53 +0000

protocol: Assign commerce and capability event kinds

- Reserve regular kind 8890 and replaceable kind 18890 with explicit profile identities.
- Preserve authoring gates pending bounded wire and cryptographic qualification.
- Align machine authority and compiler-input bindings with bounded contract guards.
- Verify protocol tests, target checks, API stability, strict lint and contract boundaries.

Diffstat:
Mcontracts/api_baselines/radroots_protocol.txt | 6++++++
Mcontracts/architecture/decisions/shared_sdk_compiler_preparation.v1.json | 2+-
Acontracts/architecture/decisions/shared_sdk_protocol.v1.json | 43+++++++++++++++++++++++++++++++++++++++++++
Mcontracts/architecture/decisions/shared_sdk_refactor.v1.json | 7++++---
Mcrates/protocol/README.md | 1+
Mcrates/protocol/src/lib.rs | 3+++
Acrates/protocol/src/profile.rs | 13+++++++++++++
Mcrates/protocol/tests/package_boundary.rs | 2++
Mtools/xtask/src/architecture/decision_package.rs | 23++++++++++++++++++-----
Mtools/xtask/src/compiler_preparation.rs | 2+-
Mtools/xtask/src/main.rs | 2++
Atools/xtask/src/shared_protocol.rs | 208+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
12 files changed, 302 insertions(+), 10 deletions(-)

diff --git a/contracts/api_baselines/radroots_protocol.txt b/contracts/api_baselines/radroots_protocol.txt @@ -614,6 +614,12 @@ impl core::convert::From<radroots_identity::key::PublicKey> for radroots_protoco pub fn radroots_protocol::plan::SigningTarget::from(radroots_identity::key::PublicKey) -> Self impl core::fmt::Debug for radroots_protocol::plan::SigningTarget pub fn radroots_protocol::plan::SigningTarget::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result +pub mod radroots_protocol::profile +pub const radroots_protocol::profile::CAPABILITIES_KIND: u16 +pub const radroots_protocol::profile::CAPABILITIES_PROFILE: &str +pub const radroots_protocol::profile::COMMERCE_KIND: u16 +pub const radroots_protocol::profile::COMMERCE_PROFILE: &str +pub const radroots_protocol::profile::PROFILE_VERSION: u32 pub mod radroots_protocol::radrootsd pub mod radroots_protocol::radrootsd::transport_publish pub mod radroots_protocol::radrootsd::transport_publish::v5 diff --git a/contracts/architecture/decisions/shared_sdk_compiler_preparation.v1.json b/contracts/architecture/decisions/shared_sdk_compiler_preparation.v1.json @@ -8,7 +8,7 @@ "source_inputs": [ { "path": "contracts/architecture/decisions/shared_sdk_refactor.v1.json", - "sha256": "d434039e9199bd35bf51886ee3bb46f88a764b80f1bce9317381bf6fcf91d5f0" + "sha256": "cc9906ff7c811b80100a0a1a1d363a7a58fb301b901b3f059eee3cb259e95e9e" }, { "path": "contracts/architecture/decisions/services_hardening_source_lock.v4.json", diff --git a/contracts/architecture/decisions/shared_sdk_protocol.v1.json b/contracts/architecture/decisions/shared_sdk_protocol.v1.json @@ -0,0 +1,43 @@ +{ + "schema_version": 1, + "contract_id": "radroots.shared_sdk.protocol.v1", + "state": "assigned_implementation_and_qualification_pending", + "profile_version": 1, + "commerce": { + "kind": 8890, + "class": "regular", + "profile": "radroots.commerce" + }, + "capabilities": { + "kind": 18890, + "class": "replaceable", + "profile": "radroots.capabilities" + }, + "structured_authoring_qualified": false, + "collision_review": { + "reviewed_at": "2026-10-22", + "nips_repository": "https://github.com/nostr-protocol/nips", + "nips_revision": "d47a2ec8aacb9d01ac00e6294ae77582f483ff68", + "nips_readme_sha256": "6db76d7a87f9f0997fe10f323d68fdde38fe5a2505b0679172703a9d6ce6c692", + "registry_repository": "https://github.com/nostr-protocol/registry-of-kinds", + "registry_revision": "2ae5c82dc82e0d1e62dc23f9895e5ef1d4a922de", + "registry_schema_sha256": "560821b6dff52a4faf7b736aeca958011a0f7a3070aae7da717e47ba79e21445", + "registry_numeric_entries": 281, + "nips_source_files_scanned": 101, + "known_collisions": [], + "coordination": "The primary registry accepts definitions and requires implementation and usage guidance elsewhere. Neither reviewed NIP-01 nor the registry contribution guidance requires central assignment permission. These are Radroots protocol assignments, not a claim of registry inclusion or exclusive global reservation.", + "proposal_search": "Exact numeric searches across issues and pull requests in both primary repositories returned zero results with incomplete_results=false on the review date.", + "limits": "A pinned source census and proposal search cannot prove global nonuse. No external maintainers were contacted. One owner reviewed the assignments; independent producer interoperability and full protocol acceptance remain pending." + }, + "rules": [ + "Commerce content is closed radroots.commerce v1 and is carried only by unsigned kind8890 rumors, NIP-44 v2 encrypted under signed kind13 seals and durable kind1059 gift wraps.", + "Kind14 remains NIP-17 plaintext chat; it is not a structured-commerce fallback. Kinds78 and30078 are not cross-application commerce substitutes.", + "Seal tags are empty. Authenticate the outer signature and recipient, then the seal signature, then recompute the rumor ID. Seal author, rumor author, content author and participant/recipient bindings must agree before admission.", + "Peer and self copies retain identical logical content and record identity with distinct recipient-specific seals and envelopes. Preserve each obtained result independently.", + "Capability kind18890 is replaceable per author and kind, has closed radroots.capabilities v1 content, and carries no d coordinate, grant, stock balance or trusted endpoint. Support is a bounded participant claim, not authority.", + "Authenticate observed heads before supported-profile, expiry or clock-actionability filtering. Newer authentic unsupported or anomalous heads prevent actionable fallback; bad signatures do not replace heads.", + "Recipient routing uses kind10050 DM relay information. Structured support readiness is distinct from route reachability; no advertised usable route blocks sending.", + "Existing kind30402 listings and their d coordinates, service event reservations, NIP-01 tag order, public interoperability and separately typed record/rumor/seal/envelope identities remain distinct.", + "Unknown profile versions and types remain unsupported evidence rather than partially interpreted records. Exact tags and bounded parsers require prospective qualification before authoring." + ] +} diff --git a/contracts/architecture/decisions/shared_sdk_refactor.v1.json b/contracts/architecture/decisions/shared_sdk_refactor.v1.json @@ -564,9 +564,10 @@ "chat_rumor_kind": 14, "seal_kind": 13, "gift_wrap_kind": 1059, - "commerce_kind": null, - "capability_kind": null, - "structured_authoring": "blocked_until_qualified_kind_assignment", + "commerce_kind": 8890, + "capability_kind": 18890, + "assignment_contract": "radroots.shared_sdk.protocol.v1", + "structured_authoring": "blocked_until_wire_and_crypto_qualification", "independent_vectors_required": true, "duplicate_json_fields_rejected": true }, diff --git a/crates/protocol/README.md b/crates/protocol/README.md @@ -30,6 +30,7 @@ numbers embedded in wire and schema contracts. | `runtime::v1` | operation descriptors, risk, approval, idempotency, and effects | | `radrootsd::transport_publish::v5` | daemon transport-publish request, job, outcome, and capability DTOs | | `schema` | schema IDs, module generations, descriptors, and aggregate registries | +| `profile` | assigned regular commerce kind8890 and replaceable capability kind18890, with closed profile identities; authoring qualification remains pending | | `command` (`commands` feature) | bounded closed v1 inquiry/reply data codec and exact command/approval-intent hashes | | `nip01` (`nip01` feature) | exact bounded canonical preimages, IDs and complete-event sizes | | `intent` (`intent` feature) | exact v1 signing commitment data without execution authority | diff --git a/crates/protocol/src/lib.rs b/crates/protocol/src/lib.rs @@ -37,6 +37,9 @@ extern crate std; /// Versioned capability catalog contracts. pub mod capability; +/// Exact assigned commerce and capability wire identities. +pub mod profile; + /// Versioned stable error-report contracts. pub mod error; diff --git a/crates/protocol/src/profile.rs b/crates/protocol/src/profile.rs @@ -0,0 +1,13 @@ +//! Assigned interoperable profile identities. Assignments alone do not qualify +//! authoring, authenticate a participant or establish a capability grant. + +/// Regular unsigned rumor kind for NIP-59-wrapped structured commerce. +pub const COMMERCE_KIND: u16 = 8890; +/// Replaceable per-participant capability advertisement kind. +pub const CAPABILITIES_KIND: u16 = 18890; +/// Closed structured-commerce content profile. +pub const COMMERCE_PROFILE: &str = "radroots.commerce"; +/// Closed capability-advertisement content profile. +pub const CAPABILITIES_PROFILE: &str = "radroots.capabilities"; +/// Supported content version for these profiles. +pub const PROFILE_VERSION: u32 = 1; diff --git a/crates/protocol/tests/package_boundary.rs b/crates/protocol/tests/package_boundary.rs @@ -14,6 +14,7 @@ const VERSIONED_SOURCES: &[&str] = &[ include_str!("../src/radrootsd/transport_publish/v5.rs"), include_str!("../src/runtime/v1.rs"), include_str!("../src/schema.rs"), + include_str!("../src/profile.rs"), include_str!("../src/command.rs"), include_str!("../src/nip01.rs"), include_str!("../src/intent.rs"), @@ -72,6 +73,7 @@ fn crate_root_exposes_only_the_approved_versioned_skeleton() { "intent", "listing", "plan", + "profile", "radrootsd", "runtime", "schema" diff --git a/tools/xtask/src/architecture/decision_package.rs b/tools/xtask/src/architecture/decision_package.rs @@ -180,6 +180,7 @@ struct Protocol { gift_wrap_kind: u16, commerce_kind: Option<u16>, capability_kind: Option<u16>, + assignment_contract: String, structured_authoring: String, independent_vectors_required: bool, duplicate_json_fields_rejected: bool, @@ -213,6 +214,7 @@ pub(super) fn validate(workspace_root: &Path) -> Result<(), String> { ) .map_err(|_| "shared SDK contract: bounded regular source admission failed".to_owned())?; validate_bytes(&raw)?; + crate::shared_protocol::validate_contract(workspace_root)?; currency_registry::validate(workspace_root) } @@ -566,9 +568,10 @@ fn validate_execution(e: &Execution, p: &Protocol, c: &Cutover) -> Result<(), St p.seal_kind, p.gift_wrap_kind, ) == (30_402, 14, 13, 1_059) - && p.commerce_kind.is_none() - && p.capability_kind.is_none() - && p.structured_authoring == "blocked_until_qualified_kind_assignment" + && p.commerce_kind == Some(radroots_protocol::profile::COMMERCE_KIND) + && p.capability_kind == Some(radroots_protocol::profile::CAPABILITIES_KIND) + && p.assignment_contract == "radroots.shared_sdk.protocol.v1" + && p.structured_authoring == "blocked_until_wire_and_crypto_qualification" && p.independent_vectors_required && p.duplicate_json_fields_rejected, "protocol assignment or authenticated admission prerequisites drift", @@ -774,9 +777,19 @@ mod tests { } #[test] - fn unassigned_kinds_and_target_metadata_cannot_authorize_publication() { - assert!(validate_bytes(&changed("/protocol/commerce_kind", json!(8890))).is_err()); + fn assigned_protocol_kinds_and_target_metadata_cannot_authorize_publication() { + assert!(validate_bytes(&changed("/protocol/commerce_kind", json!(8891))).is_err()); + assert!(validate_bytes(&changed("/protocol/commerce_kind", json!(null))).is_err()); assert!(validate_bytes(&changed("/protocol/capability_kind", json!(38990))).is_err()); + assert!(validate_bytes(&changed("/protocol/capability_kind", json!(null))).is_err()); + assert!(validate_bytes(&changed("/protocol/assignment_contract", json!("other"))).is_err()); + assert!( + validate_bytes(&changed( + "/protocol/structured_authoring", + json!("qualified") + )) + .is_err() + ); assert!(validate_bytes(&changed("/publication_authorized", json!(true))).is_err()); assert!( validate_bytes(&changed( diff --git a/tools/xtask/src/compiler_preparation.rs b/tools/xtask/src/compiler_preparation.rs @@ -12,7 +12,7 @@ const MAX_CONTRACT_BYTES: usize = 65_536; const BOUND_INPUTS: [(&str, &str); 3] = [ ( "contracts/architecture/decisions/shared_sdk_refactor.v1.json", - "d434039e9199bd35bf51886ee3bb46f88a764b80f1bce9317381bf6fcf91d5f0", + "cc9906ff7c811b80100a0a1a1d363a7a58fb301b901b3f059eee3cb259e95e9e", ), ( "contracts/architecture/decisions/services_hardening_source_lock.v4.json", diff --git a/tools/xtask/src/main.rs b/tools/xtask/src/main.rs @@ -62,6 +62,7 @@ mod service_source_lock_parts; #[cfg(test)] mod service_source_lock_v3; mod service_source_lock_v4; +mod shared_protocol; #[cfg_attr(coverage_nightly, coverage(off))] mod supply_chain_qualification; #[cfg_attr(coverage_nightly, coverage(off))] @@ -532,6 +533,7 @@ fn validate_contract() -> Result<(), String> { // Retain historical qualification integrity separately from current requirements. service_build_qualification::validate_contract(&root)?; compiler_preparation::validate_contract(&root)?; + shared_protocol::validate_contract(&root)?; service_release_artifacts::validate_contract(&root)?; service_repro_install::validate_contract(&root)?; dto_roots::check(&root)?; diff --git a/tools/xtask/src/shared_protocol.rs b/tools/xtask/src/shared_protocol.rs @@ -0,0 +1,208 @@ +//! Prospective wire assignments, without authoring or qualification authority. + +use radroots_protocol::profile; +use serde::Deserialize; +use std::path::Path; + +const CONTRACT: &str = "contracts/architecture/decisions/shared_sdk_protocol.v1.json"; +const MAX_BYTES: u64 = 8192; +const INVALID: &str = "shared protocol assignment contract is invalid"; + +#[derive(Deserialize)] +#[serde(deny_unknown_fields)] +struct Decision { + schema_version: u32, + contract_id: String, + state: String, + profile_version: u32, + commerce: Assignment, + capabilities: Assignment, + structured_authoring_qualified: bool, + collision_review: CollisionReview, + rules: Vec<String>, +} + +#[derive(Deserialize)] +#[serde(deny_unknown_fields)] +struct Assignment { + kind: u16, + class: String, + profile: String, +} + +#[derive(Deserialize)] +#[serde(deny_unknown_fields)] +struct CollisionReview { + reviewed_at: String, + nips_repository: String, + nips_revision: String, + nips_readme_sha256: String, + registry_repository: String, + registry_revision: String, + registry_schema_sha256: String, + registry_numeric_entries: usize, + nips_source_files_scanned: usize, + known_collisions: Vec<u16>, + coordination: String, + proposal_search: String, + limits: String, +} + +pub(crate) fn validate_contract(root: &Path) -> Result<(), String> { + let bytes = crate::safe_artifact_io::read_regular(root, Path::new(CONTRACT), MAX_BYTES) + .map_err(|_| INVALID.to_string())?; + validate_bytes(&bytes).map_err(str::to_string) +} + +fn validate_bytes(bytes: &[u8]) -> Result<(), &'static str> { + let shape: serde_json::Value = serde_json::from_slice(bytes).map_err(|_| INVALID)?; + if !shape.is_object() + || ["commerce", "capabilities", "collision_review"] + .iter() + .any(|key| !shape[key].is_object()) + { + return Err(INVALID); + } + // The independent typed pass retains duplicate, required-field and closure checks. + let value: Decision = serde_json::from_slice(bytes).map_err(|_| INVALID)?; + let review = &value.collision_review; + let exact = value.schema_version == 1 + && value.contract_id == "radroots.shared_sdk.protocol.v1" + && value.state == "assigned_implementation_and_qualification_pending" + && value.profile_version == profile::PROFILE_VERSION + && value.commerce.kind == profile::COMMERCE_KIND + && (1000..10000).contains(&value.commerce.kind) + && value.commerce.class == "regular" + && value.commerce.profile == profile::COMMERCE_PROFILE + && value.capabilities.kind == profile::CAPABILITIES_KIND + && (10000..20000).contains(&value.capabilities.kind) + && value.capabilities.class == "replaceable" + && value.capabilities.profile == profile::CAPABILITIES_PROFILE + && !value.structured_authoring_qualified + && review.reviewed_at == "2026-10-22" + && review.nips_repository == "https://github.com/nostr-protocol/nips" + && review.nips_revision == "d47a2ec8aacb9d01ac00e6294ae77582f483ff68" + && review.nips_readme_sha256 + == "6db76d7a87f9f0997fe10f323d68fdde38fe5a2505b0679172703a9d6ce6c692" + && review.registry_repository == "https://github.com/nostr-protocol/registry-of-kinds" + && review.registry_revision == "2ae5c82dc82e0d1e62dc23f9895e5ef1d4a922de" + && review.registry_schema_sha256 + == "560821b6dff52a4faf7b736aeca958011a0f7a3070aae7da717e47ba79e21445" + && review.registry_numeric_entries == 281 + && review.nips_source_files_scanned == 101 + && review.known_collisions.is_empty() + && !review.coordination.is_empty() + && !review.proposal_search.is_empty() + && !review.limits.is_empty() + && value.rules.len() == 9 + && value.rules.iter().all(|rule| !rule.is_empty()); + if exact { Ok(()) } else { Err(INVALID) } +} + +#[cfg(test)] +mod tests { + use super::*; + use serde_json::{Value, json}; + + const SOURCE: &[u8] = + include_bytes!("../../../contracts/architecture/decisions/shared_sdk_protocol.v1.json"); + + #[test] + fn assignments_preserve_classes_profiles_and_unqualified_authoring() { + validate_bytes(SOURCE).unwrap(); + let root = Path::new(env!("CARGO_MANIFEST_DIR")) + .parent() + .unwrap() + .parent() + .unwrap(); + validate_contract(root).unwrap(); + for (pointer, replacement) in [ + ("/commerce/kind", json!(14)), + ("/commerce/kind", json!(65536)), + ("/commerce/kind", json!(18890)), + ("/capabilities/kind", json!(38990)), + ("/capabilities/class", json!("addressable")), + ("/commerce/profile", json!("radroots.capabilities")), + ("/profile_version", json!(2)), + ("/structured_authoring_qualified", json!(true)), + ("/collision_review/known_collisions", json!([8890])), + ("/collision_review/registry_schema_sha256", json!("changed")), + ("/rules", json!([])), + ] { + let mut value: Value = serde_json::from_slice(SOURCE).unwrap(); + *value.pointer_mut(pointer).unwrap() = replacement; + assert_eq!( + validate_bytes(&serde_json::to_vec(&value).unwrap()), + Err(INVALID) + ); + } + } + + #[test] + fn contract_rejects_duplicate_extra_missing_and_oversized_inputs() { + for (pointer, keys) in [ + ( + "", + &[ + "schema_version", + "contract_id", + "state", + "profile_version", + "commerce", + "capabilities", + "structured_authoring_qualified", + "collision_review", + "rules", + ][..], + ), + ("/commerce", &["kind", "class", "profile"][..]), + ("/capabilities", &["kind", "class", "profile"][..]), + ( + "/collision_review", + &[ + "reviewed_at", + "nips_repository", + "nips_revision", + "nips_readme_sha256", + "registry_repository", + "registry_revision", + "registry_schema_sha256", + "registry_numeric_entries", + "nips_source_files_scanned", + "known_collisions", + "coordination", + "proposal_search", + "limits", + ][..], + ), + ] { + let mut value: Value = serde_json::from_slice(SOURCE).unwrap(); + let array = Value::Array( + keys.iter() + .map(|key| value.pointer(pointer).unwrap()[key].clone()) + .collect(), + ); + *value.pointer_mut(pointer).unwrap() = array; + assert_eq!( + validate_bytes(&serde_json::to_vec(&value).unwrap()), + Err(INVALID) + ); + } + for bytes in [ + [b"{\"schema_version\":1,".as_slice(), &SOURCE[1..]].concat(), + [b"{\"unexpected\":true,".as_slice(), &SOURCE[1..]].concat(), + b"{}".to_vec(), + b"[]".to_vec(), + ] { + assert_eq!(validate_bytes(&bytes), Err(INVALID)); + } + let root = tempfile::tempdir().unwrap(); + assert!(validate_contract(root.path()).is_err()); + let path = root.path().join(CONTRACT); + std::fs::create_dir_all(path.parent().unwrap()).unwrap(); + let mut bytes = SOURCE.to_vec(); + bytes.resize(MAX_BYTES as usize + 1, b' '); + std::fs::write(path, bytes).unwrap(); + assert!(validate_contract(root.path()).is_err()); + } +}