commit b21032732edde890590cb3b86f2a7aa7cb252a9a
parent 6a4f55616684d0b595ef1e0479abfd8ab2152692
Author: triesap <tyson@radroots.org>
Date: Mon, 3 Aug 2026 12:21:45 +0000
sdk: document public api contract
- Document consumers, feature behavior, commit points, serialization, and security.
- Replace dormant legacy examples with compile-checked final API examples.
- Include the package README in rustdoc so its getting-started example is tested.
- Record the reviewed all-features public API baseline and regeneration contract.
Diffstat:
12 files changed, 472 insertions(+), 494 deletions(-)
diff --git a/crates/sdk/Cargo.toml b/crates/sdk/Cargo.toml
@@ -101,5 +101,14 @@ path = "tests/lifecycle.rs"
name = "public_api"
path = "tests/public_api.rs"
+[[example]]
+name = "safe_memory_client"
+path = "examples/safe_memory_client.rs"
+required-features = ["memory"]
+
+[[example]]
+name = "transport_profile"
+path = "examples/transport_profile.rs"
+
[lints]
workspace = true
diff --git a/crates/sdk/README.md b/crates/sdk/README.md
@@ -10,6 +10,38 @@ and `Result`. Advanced operations live in the `farm`, `listing`, `trade`,
`signing`, `transport`, `storage`, `sync`, `diagnostics`, and `capability`
modules.
+The package charter is the normative [`radroots_sdk` crate
+specification](../../docs/specs/radroots_crates_release_v1.md#18-radroots_sdk).
+This advanced front door is intended for CLI, Studio, FFI/mobile, and native
+applications that need to compose storage, signing, transport, or sync
+capabilities directly. Ordinary Rust applications should use the curated
+`radroots` facade.
+
+## Getting started
+
+The default `memory` feature provides an inert, in-process backend. The caller
+supplies its source generation; building the client creates no files, opens no
+network connection, installs no runtime, and starts no worker.
+
+```rust
+use radroots_sdk::{ClientBuilder, capability::CapabilityId};
+use radroots_storage::event::SourceGeneration;
+
+let generation = SourceGeneration::new([1; 32])?;
+let client = ClientBuilder::memory(generation).build()?;
+let storage = client
+ .capabilities()
+ .get(CapabilityId::CANONICAL_STORAGE);
+assert!(storage.is_some());
+
+# Ok::<(), Box<dyn std::error::Error>>(())
+```
+
+The complete executable form, including explicit asynchronous shutdown, lives
+in [`examples/safe_memory_client.rs`](examples/safe_memory_client.rs). The
+side-effect-free transport-selection example lives in
+[`examples/transport_profile.rs`](examples/transport_profile.rs).
+
## Feature contract
The complete public feature vocabulary is:
@@ -70,6 +102,19 @@ cancellation policy, and an explicit transport profile, then return the
canonical sync receipt. Repeating the same idempotent request is the supported
resume/replay path.
+Preparation has no commit point. During commit, durable local acceptance is
+the first commit point; a cancellation observed before that point returns
+without claiming acceptance. Cancellation after durable acceptance cannot
+roll the accepted event back: the returned error/receipt identifies the safe
+resume path, and retrying with the same idempotency identity must not create a
+second logical operation. Dropping `Client::close` before completion leaves
+the shared client in a retry-required closing state; call `close` again.
+
+The SDK does not define a second wire model. Canonical lower-crate domain and
+protocol types own serialization, validation, versioning, and size limits.
+SDK request, plan, and receipt structs are constructor-led orchestration types;
+their private representation is not a persistence or interchange format.
+
## Reliability and privacy
Backup, restore, integrity, and status operations delegate to
@@ -84,6 +129,12 @@ SPIs. Diagnostics contain only capability and canonical storage status. Public
errors and daemon failures use stable, redacted classifications while retaining
private source chains for local diagnostics.
+Signer material and bearer credentials are caller-owned capabilities. The SDK
+does not generate keys, read a keyring, persist secrets, or include credentials
+in `Debug`, `Display`, diagnostics, receipts, or public error text. Hosts remain
+responsible for protecting source chains and any lower-level logs they choose
+to expose.
+
## Daemon execution
The `radrootsd` feature compiles a private HTTP/RPC adapter using the versioned
@@ -97,3 +148,6 @@ surfaced, and the response must match the signed event and requested policies.
This package remains `publish = false` until the complete package-realistic
release qualification and separately authorized publication step. The crate is
licensed under `MIT OR Apache-2.0`.
+
+The reviewed all-features public API baseline is recorded at
+[`docs/api/radroots_sdk-0.1.0-alpha.txt`](../../docs/api/radroots_sdk-0.1.0-alpha.txt).
diff --git a/crates/sdk/examples/runtime_local.rs b/crates/sdk/examples/runtime_local.rs
@@ -1,125 +0,0 @@
-use radroots_core::{Currency, Decimal, Money, Quantity, QuantityPrice, Unit};
-use radroots_event::contract::AuthorRole;
-use radroots_event::farm::FarmRef;
-use radroots_event::id::{DTag, InventoryBinId};
-use radroots_event::listing::operational::{
- OperationalListing, OperationalListingAvailability, OperationalListingBin,
- OperationalListingDeliveryMethod, OperationalListingProduct, OperationalListingPublicLocation,
- OperationalListingStatus,
-};
-use radroots_nostr::signing::LocalSigner;
-use radroots_sdk::{
- ListingPreparePublishRequest, NostrRelayUrlPolicy, PushOutboxRequest, RadrootsClient,
- RadrootsSdkError, RadrootsSdkLocalKeySigner, RadrootsSdkSignerProvider, RadrootsSdkTimestamp,
- SdkIdempotencyKey, TargetPolicy,
-};
-use radroots_signing::{Actor, actor::ActorSource};
-
-const RELAY: &str = "wss://relay.example.com";
-
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn std::error::Error>> {
- let signer = LocalSigner::generate()?;
- let seller = signer.public_key().to_hex();
- let signer = RadrootsSdkLocalKeySigner::from_signer(signer, seller.as_str())?;
- let sdk = RadrootsClient::builder()
- .fixed_clock(RadrootsSdkTimestamp::from_unix_seconds(1_700_000_000))
- .signer_provider(RadrootsSdkSignerProvider::LocalKey(signer))
- .build()
- .await?;
- let actor = Actor::from_public_key_hex(
- seller.as_str(),
- ActorSource::ExplicitPublicKey,
- [AuthorRole::Seller],
- )?;
- let listing = sample_listing(seller.as_str());
- let prepare_request = ListingPreparePublishRequest::new(actor.clone(), listing);
- let target_policy = TargetPolicy::try_nostr_relays([RELAY], NostrRelayUrlPolicy::Public)?;
- let idempotency_key = SdkIdempotencyKey::new("01890f0e-6c00-7000-8000-000000000202")?;
-
- let prepared = sdk.listings().prepare_publish(prepare_request)?;
- let enqueue = sdk
- .listings()
- .enqueue_prepared_publish(
- &actor,
- prepared.clone(),
- target_policy,
- Some(idempotency_key),
- )
- .await?;
- let push = sdk
- .sync()
- .push_outbox(PushOutboxRequest::new().with_limit(1))
- .await;
- assert_eq!(
- prepared.public_listing_addr().as_str(),
- enqueue.public_listing_addr.as_str()
- );
- #[cfg(feature = "transport-nostr-runtime")]
- assert!(matches!(
- push,
- Err(RadrootsSdkError::ProductSyncTransportSetupFailure { .. })
- ));
- #[cfg(not(feature = "transport-nostr-runtime"))]
- assert!(matches!(
- push,
- Err(RadrootsSdkError::ProductSyncUnsupported { .. })
- ));
- Ok(())
-}
-
-fn sample_listing(seller: &str) -> OperationalListing {
- OperationalListing {
- d_tag: DTag::parse("AAAAAAAAAAAAAAAAAAAAAQ").expect("d tag"),
- published_at: None,
- farm: FarmRef {
- pubkey: seller.to_owned(),
- d_tag: "AAAAAAAAAAAAAAAAAAAAAA".to_owned(),
- },
- product: OperationalListingProduct {
- key: "coffee".to_owned(),
- title: "Coffee".to_owned(),
- category: "coffee".to_owned(),
- summary: Some("Single origin coffee".to_owned()),
- process: None,
- lot: None,
- location: None,
- profile: None,
- year: None,
- },
- primary_bin_id: InventoryBinId::parse("bin-1").expect("bin id"),
- bins: vec![OperationalListingBin {
- bin_id: InventoryBinId::parse("bin-1").expect("bin id"),
- quantity: Quantity::try_new(Decimal::from(1000u32), Unit::MassG)
- .expect("positive example quantity"),
- price_per_canonical_unit: QuantityPrice::try_new(
- Money::try_new(Decimal::from(20u32), Currency::USD)
- .expect("non-negative example money"),
- Quantity::try_new(Decimal::from(1u32), Unit::MassG)
- .expect("positive example pricing quantity"),
- )
- .expect("non-zero example pricing quantity"),
- display_amount: None,
- display_unit: None,
- display_label: None,
- display_price: None,
- display_price_unit: None,
- }],
- resource_area: None,
- plot: None,
- discounts: None,
- inventory_available: Some(Decimal::from(5u32)),
- availability: Some(OperationalListingAvailability::Status {
- status: OperationalListingStatus::Active,
- }),
- delivery_method: Some(OperationalListingDeliveryMethod::Pickup),
- location: Some(OperationalListingPublicLocation {
- primary: "Victoria".to_owned(),
- city: Some("Victoria".to_owned()),
- region: Some("British Columbia".to_owned()),
- country: Some("CA".to_owned()),
- geohash: "c287g".to_owned(),
- }),
- images: None,
- }
-}
diff --git a/crates/sdk/examples/safe_memory_client.rs b/crates/sdk/examples/safe_memory_client.rs
@@ -0,0 +1,20 @@
+//! Builds and explicitly closes the safe in-process client.
+
+use radroots_sdk::{ClientBuilder, capability::CapabilityId};
+use radroots_storage::event::SourceGeneration;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+ let generation = SourceGeneration::new([1; 32])?;
+ let client = ClientBuilder::memory(generation).build()?;
+
+ assert!(
+ client
+ .capabilities()
+ .get(CapabilityId::CANONICAL_STORAGE)
+ .is_some()
+ );
+
+ client.close().await?;
+ Ok(())
+}
diff --git a/crates/sdk/examples/sdk_v1_knowledge_prepare.rs b/crates/sdk/examples/sdk_v1_knowledge_prepare.rs
@@ -1,100 +0,0 @@
-use nostr::{EventBuilder, Keys, Kind, Tag, Timestamp};
-use radroots_event::envelope::EventEnvelopeParts;
-use radroots_identity::PublicKey;
-use radroots_sdk::knowledge::prelude::*;
-
-const CREATED_AT: u32 = 1_800_000_000;
-const RELAY: &str = "wss://relay.radroots.example";
-
-fn main() -> Result<(), Box<dyn std::error::Error>> {
- let keys = Keys::generate();
- let claim = claim_builder().build()?;
- let parts = claim_builder().build_event()?;
- let draft = claim_builder().build_draft(keys.public_key().to_hex(), CREATED_AT)?;
- let signed = sign_parts(parts, &keys)?;
- let decoded = KnowledgeCodec::new().verify_and_decode_radroots_event(signed)?;
- let manifest = contract_manifest();
- let manifest_hash = contract_manifest_sha256()?;
-
- assert_eq!(draft.contract_id(), KNOWLEDGE_CLAIM_CONTRACT_ID);
- assert_eq!(manifest.contract_count, 11);
- assert_eq!(manifest_hash.len(), 64);
-
- match decoded {
- RadrootsDecodedEvent::KnowledgeClaim(parsed) => {
- assert_eq!(parsed.data.data.text, claim.text);
- }
- _ => return Err("expected knowledge claim".into()),
- }
-
- println!(
- "prepared knowledge claim draft: {}",
- draft.expected_event_id_hex()
- );
- println!("knowledge manifest sha256: {manifest_hash}");
- Ok(())
-}
-
-fn sign_parts(
- parts: Nip01EventWireParts,
- keys: &Keys,
-) -> Result<EventEnvelope, Box<dyn std::error::Error>> {
- let tags = parts
- .tags
- .into_iter()
- .map(Tag::parse)
- .collect::<Result<Vec<_>, _>>()?;
- let event = EventBuilder::new(Kind::Custom(parts.kind as u16), parts.content)
- .tags(tags)
- .custom_created_at(Timestamp::from_secs(u64::from(CREATED_AT)))
- .sign_with_keys(keys)?;
- Ok(EventEnvelope::new(EventEnvelopeParts {
- id: event.id.to_hex(),
- author: event.pubkey.to_hex(),
- created_at: event.created_at.as_secs(),
- kind: u32::from(event.kind.as_u16()),
- tags: event
- .tags
- .as_slice()
- .iter()
- .map(|tag| tag.as_slice().to_vec())
- .collect(),
- content: event.content,
- sig: event.sig.to_string(),
- })?)
-}
-
-fn hex_64(character: char) -> String {
- character.to_string().repeat(64)
-}
-
-fn event_ref(character: char, kind: u32) -> EventRef {
- EventRef {
- id: hex_64(character),
- author: PublicKey::from_hex(
- "585591529da0bab31b3b1b1f986611cf5f435dca84f978c89ee8a40cca7103df",
- )
- .expect("fixture public key"),
- kind,
- d_tag: None,
- relays: Some(vec![RELAY.to_owned()]),
- }
-}
-
-fn claim_builder() -> RadrootsKnowledgeClaimBuilder {
- RadrootsKnowledgeClaimBuilder::new()
- .claim_type("practice_effect")
- .text("Cover crops improve soil structure.")
- .citation_span(KnowledgeCitationSpan {
- source_ref: event_ref('4', KIND_KNOWLEDGE_SOURCE),
- artifact_ref: None,
- page_start: Some(12),
- page_end: Some(13),
- section_path: vec!["chapter-1".to_owned()],
- quote_hash: Some(hex_64('5')),
- chunk_id: Some("chunk-1".to_owned()),
- })
- .topic("cover-crops")
- .applies_to("local-food")
- .author_asserted_confidence("medium")
-}
diff --git a/crates/sdk/examples/sdk_v1_listing_prepare.rs b/crates/sdk/examples/sdk_v1_listing_prepare.rs
@@ -1,86 +0,0 @@
-use radroots_core::{Currency, Decimal, Money, Quantity, QuantityPrice, Unit};
-use radroots_event::contract::AuthorRole;
-use radroots_event::farm::FarmRef;
-use radroots_event::id::{DTag, InventoryBinId};
-use radroots_event::listing::operational::{
- OperationalListing, OperationalListingAvailability, OperationalListingBin,
- OperationalListingDeliveryMethod, OperationalListingProduct, OperationalListingPublicLocation,
- OperationalListingStatus,
-};
-use radroots_sdk::{ListingPreparePublishRequest, RadrootsClient, RadrootsSdkTimestamp};
-use radroots_signing::{Actor, actor::ActorSource};
-
-const SELLER: &str = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
-
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn std::error::Error>> {
- let sdk = RadrootsClient::builder()
- .fixed_clock(RadrootsSdkTimestamp::from_unix_seconds(1_700_000_000))
- .build()
- .await?;
- let actor =
- Actor::from_public_key_hex(SELLER, ActorSource::ExplicitPublicKey, [AuthorRole::Seller])?;
- let request = ListingPreparePublishRequest::new(actor, sample_listing(SELLER));
-
- let plan = sdk.listings().prepare_publish(request)?;
-
- println!("public listing: {}", plan.public_listing_addr().as_str());
- println!("expected event: {}", plan.expected_event_id().to_hex());
- Ok(())
-}
-
-fn sample_listing(seller: &str) -> OperationalListing {
- OperationalListing {
- d_tag: DTag::parse("AAAAAAAAAAAAAAAAAAAAAQ").expect("d tag"),
- published_at: None,
- farm: FarmRef {
- pubkey: seller.to_owned(),
- d_tag: "AAAAAAAAAAAAAAAAAAAAAA".to_owned(),
- },
- product: OperationalListingProduct {
- key: "coffee".to_owned(),
- title: "Coffee".to_owned(),
- category: "coffee".to_owned(),
- summary: Some("Single origin coffee".to_owned()),
- process: None,
- lot: None,
- location: None,
- profile: None,
- year: None,
- },
- primary_bin_id: InventoryBinId::parse("bin-1").expect("bin id"),
- bins: vec![OperationalListingBin {
- bin_id: InventoryBinId::parse("bin-1").expect("bin id"),
- quantity: Quantity::try_new(Decimal::from(1000u32), Unit::MassG)
- .expect("positive example quantity"),
- price_per_canonical_unit: QuantityPrice::try_new(
- Money::try_new(Decimal::from(20u32), Currency::USD)
- .expect("non-negative example money"),
- Quantity::try_new(Decimal::from(1u32), Unit::MassG)
- .expect("positive example pricing quantity"),
- )
- .expect("non-zero example pricing quantity"),
- display_amount: None,
- display_unit: None,
- display_label: None,
- display_price: None,
- display_price_unit: None,
- }],
- resource_area: None,
- plot: None,
- discounts: None,
- inventory_available: Some(Decimal::from(5u32)),
- availability: Some(OperationalListingAvailability::Status {
- status: OperationalListingStatus::Active,
- }),
- delivery_method: Some(OperationalListingDeliveryMethod::Pickup),
- location: Some(OperationalListingPublicLocation {
- primary: "Victoria".to_owned(),
- city: Some("Victoria".to_owned()),
- region: Some("British Columbia".to_owned()),
- country: Some("CA".to_owned()),
- geohash: "c287g".to_owned(),
- }),
- images: None,
- }
-}
diff --git a/crates/sdk/examples/sdk_v1_local_enqueue_and_mock_sync.rs b/crates/sdk/examples/sdk_v1_local_enqueue_and_mock_sync.rs
@@ -1,122 +0,0 @@
-use radroots_core::{Currency, Decimal, Money, Quantity, QuantityPrice, Unit};
-use radroots_event::contract::AuthorRole;
-use radroots_event::farm::FarmRef;
-use radroots_event::id::{DTag, InventoryBinId};
-use radroots_event::listing::operational::{
- OperationalListing, OperationalListingAvailability, OperationalListingBin,
- OperationalListingDeliveryMethod, OperationalListingProduct, OperationalListingPublicLocation,
- OperationalListingStatus,
-};
-use radroots_nostr::signing::LocalSigner;
-use radroots_sdk::{
- ListingPreparePublishRequest, NostrRelayUrlPolicy, PushOutboxRequest, RadrootsClient,
- RadrootsSdkLocalKeySigner, RadrootsSdkSignerProvider, RadrootsSdkTimestamp, SdkIdempotencyKey,
- TargetPolicy, TargetSet,
-};
-use radroots_signing::{Actor, actor::ActorSource};
-use radroots_transport_nostr::{RadrootsMockRelayPublishAdapter, RadrootsNostrTransport};
-
-const LOCAL_RELAY: &str = "ws://localhost:7777";
-
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn std::error::Error>> {
- let signer = LocalSigner::generate()?;
- let seller = signer.public_key().to_hex();
- let signer = RadrootsSdkLocalKeySigner::from_signer(signer, seller.as_str())?;
- let sdk = RadrootsClient::builder()
- .fixed_clock(RadrootsSdkTimestamp::from_unix_seconds(1_700_000_000))
- .signer_provider(RadrootsSdkSignerProvider::LocalKey(signer))
- .build()
- .await?;
- let actor = Actor::from_public_key_hex(
- seller.as_str(),
- ActorSource::ExplicitPublicKey,
- [AuthorRole::Seller],
- )?;
- let targets = TargetSet::nostr_relays([LOCAL_RELAY], NostrRelayUrlPolicy::Localhost)?;
- let target_policy = TargetPolicy::explicit(targets);
-
- let prepared = sdk
- .listings()
- .prepare_publish(ListingPreparePublishRequest::new(
- actor.clone(),
- sample_listing(seller.as_str()),
- ))?;
- let enqueue = sdk
- .listings()
- .enqueue_prepared_publish(
- &actor,
- prepared,
- target_policy,
- Some(SdkIdempotencyKey::new(
- "01890f0e-6c00-7000-8000-000000000201",
- )?),
- )
- .await?;
- let adapter = RadrootsMockRelayPublishAdapter::new();
- let transport = RadrootsNostrTransport::new(&adapter);
- let push = sdk
- .sync()
- .push_outbox_with_transport(&transport, PushOutboxRequest::new().with_limit(1))
- .await?;
-
- println!("queued listing event: {}", enqueue.signed_event_id.to_hex());
- println!("published events: {}", push.published_events);
- Ok(())
-}
-
-fn sample_listing(seller: &str) -> OperationalListing {
- OperationalListing {
- d_tag: DTag::parse("AAAAAAAAAAAAAAAAAAAAAQ").expect("d tag"),
- published_at: None,
- farm: FarmRef {
- pubkey: seller.to_owned(),
- d_tag: "AAAAAAAAAAAAAAAAAAAAAA".to_owned(),
- },
- product: OperationalListingProduct {
- key: "coffee".to_owned(),
- title: "Coffee".to_owned(),
- category: "coffee".to_owned(),
- summary: Some("Single origin coffee".to_owned()),
- process: None,
- lot: None,
- location: None,
- profile: None,
- year: None,
- },
- primary_bin_id: InventoryBinId::parse("bin-1").expect("bin id"),
- bins: vec![OperationalListingBin {
- bin_id: InventoryBinId::parse("bin-1").expect("bin id"),
- quantity: Quantity::try_new(Decimal::from(1000u32), Unit::MassG)
- .expect("positive example quantity"),
- price_per_canonical_unit: QuantityPrice::try_new(
- Money::try_new(Decimal::from(20u32), Currency::USD)
- .expect("non-negative example money"),
- Quantity::try_new(Decimal::from(1u32), Unit::MassG)
- .expect("positive example pricing quantity"),
- )
- .expect("non-zero example pricing quantity"),
- display_amount: None,
- display_unit: None,
- display_label: None,
- display_price: None,
- display_price_unit: None,
- }],
- resource_area: None,
- plot: None,
- discounts: None,
- inventory_available: Some(Decimal::from(5u32)),
- availability: Some(OperationalListingAvailability::Status {
- status: OperationalListingStatus::Active,
- }),
- delivery_method: Some(OperationalListingDeliveryMethod::Pickup),
- location: Some(OperationalListingPublicLocation {
- primary: "Victoria".to_owned(),
- city: Some("Victoria".to_owned()),
- region: Some("British Columbia".to_owned()),
- country: Some("CA".to_owned()),
- geohash: "c287g".to_owned(),
- }),
- images: None,
- }
-}
diff --git a/crates/sdk/examples/sdk_v1_myc_nip46_signer_setup.rs b/crates/sdk/examples/sdk_v1_myc_nip46_signer_setup.rs
@@ -1,61 +0,0 @@
-use nostr::Keys as RadrootsNostrKeys;
-use radroots_event::envelope::kind::KIND_TRADE_PROPOSAL;
-use radroots_nostr_connect::{
- client::{CancellationToken, Client, ClientEvent, Receive, Target, Transport, TransportFuture},
- uri::RelayUrl as ConnectRelayUrl,
-};
-use radroots_sdk::{
- RadrootsClient, RadrootsSdkMycNip46Signer, RadrootsSdkSignerMode, RadrootsSdkSignerProvider,
- radroots_sdk_myc_nip46_product_permission_strings,
-};
-
-struct ExampleNip46Transport;
-
-impl Transport for ExampleNip46Transport {
- fn publish<'a>(&'a mut self, _event: ClientEvent) -> TransportFuture<'a, ()> {
- Box::pin(async { Ok(()) })
- }
-
- fn receive<'a>(
- &'a mut self,
- _cancellation: &'a CancellationToken,
- ) -> TransportFuture<'a, Receive> {
- Box::pin(async { Ok(Receive::TimedOut) })
- }
-}
-
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn std::error::Error>> {
- let remote_signer_keys = RadrootsNostrKeys::generate();
- let user_keys = RadrootsNostrKeys::generate();
- let remote_signer_public_key =
- radroots_nostr::key::public_key_from_nostr(remote_signer_keys.public_key())?;
- let target = Target::try_new(
- remote_signer_public_key,
- vec![ConnectRelayUrl::parse("wss://relay.example.com")?],
- )?;
- let client = Client::generate(target)?;
- let signer = RadrootsSdkMycNip46Signer::from_client(
- client,
- user_keys.public_key().to_hex(),
- ExampleNip46Transport,
- )?;
- let sdk = RadrootsClient::builder()
- .signer_provider(RadrootsSdkSignerProvider::MycNip46(Box::new(signer)))
- .build()
- .await?;
- let status = sdk.signer_status().expect("configured signer status");
- let permissions = radroots_sdk_myc_nip46_product_permission_strings();
-
- assert_eq!(status.mode, RadrootsSdkSignerMode::MycNip46);
- assert!(permissions.iter().any(|value| value == "sign_event:30340"));
- assert!(
- permissions
- .iter()
- .any(|value| value == &format!("sign_event:{KIND_TRADE_PROPOSAL}"))
- );
- assert!(!permissions.iter().any(|value| value == "sign_event:3422"));
- println!("configured signer mode: {}", status.mode.as_str());
- println!("requested permissions: {}", permissions.join(","));
- Ok(())
-}
diff --git a/crates/sdk/examples/transport_profile.rs b/crates/sdk/examples/transport_profile.rs
@@ -0,0 +1,11 @@
+//! Selects local-only behavior without constructing or probing a transport.
+
+use radroots_sdk::transport::Profile;
+
+fn main() {
+ let profile = Profile::local_only();
+
+ assert!(profile.is_local_only());
+ assert!(profile.targets().is_none());
+ assert!(profile.satisfaction().is_none());
+}
diff --git a/crates/sdk/src/lib.rs b/crates/sdk/src/lib.rs
@@ -24,6 +24,7 @@
//! ```
#![forbid(unsafe_code)]
+#![doc = include_str!("../README.md")]
mod adapters;
diff --git a/docs/api/README.md b/docs/api/README.md
@@ -0,0 +1,16 @@
+# Public API baselines
+
+These files are reviewed release artifacts for the standalone SDK capsule.
+They contain the simplified (`-sss`) all-features API emitted by
+`cargo-public-api`; private implementation items and automatically generated
+trait noise are intentionally omitted.
+
+Regenerate the `radroots_sdk` baseline from this repository root with:
+
+```sh
+cargo public-api -p radroots_sdk --all-features -sss --color never
+```
+
+An API change is not accepted merely because the baseline can be regenerated.
+Review additions, removals, and changed signatures against the package charter
+and versioning policy before replacing a baseline.
diff --git a/docs/api/radroots_sdk-0.1.0-alpha.txt b/docs/api/radroots_sdk-0.1.0-alpha.txt
@@ -0,0 +1,361 @@
+pub mod radroots_sdk
+pub mod radroots_sdk::capability
+pub enum radroots_sdk::capability::Availability
+pub radroots_sdk::capability::Availability::Available
+pub radroots_sdk::capability::Availability::Degraded
+pub radroots_sdk::capability::Availability::Unavailable
+pub radroots_sdk::capability::Availability::Unsupported
+pub enum radroots_sdk::capability::Maturity
+pub radroots_sdk::capability::Maturity::Experimental
+pub radroots_sdk::capability::Maturity::Preview
+pub radroots_sdk::capability::Maturity::Stable
+pub struct radroots_sdk::capability::CapabilityId(_)
+impl radroots_sdk::capability::CapabilityId
+pub const radroots_sdk::capability::CapabilityId::BACKUP_RESTORE: Self
+pub const radroots_sdk::capability::CapabilityId::CANONICAL_STORAGE: Self
+pub const radroots_sdk::capability::CapabilityId::DAEMON_DELIVERY: Self
+pub const radroots_sdk::capability::CapabilityId::FARM_PUBLICATION: Self
+pub const radroots_sdk::capability::CapabilityId::KNOWLEDGE_EVENTS: Self
+pub const radroots_sdk::capability::CapabilityId::LISTING_PUBLICATION: Self
+pub const radroots_sdk::capability::CapabilityId::LOCAL_SIGNING: Self
+pub const radroots_sdk::capability::CapabilityId::MESH_TRANSPORT: Self
+pub const radroots_sdk::capability::CapabilityId::NIP46_SIGNING: Self
+pub const radroots_sdk::capability::CapabilityId::NOSTR_DELIVERY: Self
+pub const radroots_sdk::capability::CapabilityId::NOSTR_FETCH: Self
+pub const radroots_sdk::capability::CapabilityId::PERSISTENT_STORAGE: Self
+pub const radroots_sdk::capability::CapabilityId::RETICULUM_DELIVERY: Self
+pub const radroots_sdk::capability::CapabilityId::RETICULUM_FETCH: Self
+pub const radroots_sdk::capability::CapabilityId::SIMPLEX_TRANSPORT: Self
+pub const radroots_sdk::capability::CapabilityId::SYNC_PULL: Self
+pub const radroots_sdk::capability::CapabilityId::SYNC_PUSH: Self
+pub const radroots_sdk::capability::CapabilityId::TRADE_COMMANDS: Self
+pub const radroots_sdk::capability::CapabilityId::TRADE_QUERIES: Self
+pub const fn radroots_sdk::capability::CapabilityId::as_str(self) -> &'static str
+impl core::fmt::Display for radroots_sdk::capability::CapabilityId
+pub fn radroots_sdk::capability::CapabilityId::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub struct radroots_sdk::capability::CapabilityReport
+impl radroots_sdk::capability::CapabilityReport
+pub fn radroots_sdk::capability::CapabilityReport::get(&self, radroots_sdk::capability::CapabilityId) -> core::option::Option<radroots_sdk::capability::CapabilityStatus>
+pub fn radroots_sdk::capability::CapabilityReport::iter(&self) -> impl core::iter::traits::exact_size::ExactSizeIterator<Item = &radroots_sdk::capability::CapabilityStatus>
+pub struct radroots_sdk::capability::CapabilityStatus
+impl radroots_sdk::capability::CapabilityStatus
+pub const fn radroots_sdk::capability::CapabilityStatus::availability(self) -> radroots_sdk::capability::Availability
+pub const fn radroots_sdk::capability::CapabilityStatus::id(self) -> radroots_sdk::capability::CapabilityId
+pub const fn radroots_sdk::capability::CapabilityStatus::is_compiled(self) -> bool
+pub const fn radroots_sdk::capability::CapabilityStatus::is_configured(self) -> bool
+pub const fn radroots_sdk::capability::CapabilityStatus::maturity(self) -> radroots_sdk::capability::Maturity
+pub mod radroots_sdk::client
+pub struct radroots_sdk::client::Client
+impl radroots_sdk::client::Client
+pub fn radroots_sdk::client::Client::capabilities(&self) -> radroots_sdk::capability::CapabilityReport
+pub async fn radroots_sdk::client::Client::close(&self) -> radroots_sdk::error::Result<()>
+pub fn radroots_sdk::client::Client::farm(&self) -> radroots_sdk::error::Result<core::option::Option<radroots_sdk::farm::Operations<'_>>>
+pub fn radroots_sdk::client::Client::is_closed(&self) -> bool
+pub fn radroots_sdk::client::Client::listing(&self) -> radroots_sdk::error::Result<core::option::Option<radroots_sdk::listing::Operations<'_>>>
+pub fn radroots_sdk::client::Client::signer(&self) -> radroots_sdk::error::Result<core::option::Option<&dyn radroots_signing::signer::Signer>>
+pub fn radroots_sdk::client::Client::sink(&self) -> radroots_sdk::error::Result<core::option::Option<&dyn radroots_transport::sink::EventSink>>
+pub fn radroots_sdk::client::Client::source(&self) -> radroots_sdk::error::Result<core::option::Option<&dyn radroots_transport::source::EventSource>>
+pub fn radroots_sdk::client::Client::storage(&self) -> radroots_sdk::error::Result<&dyn radroots_storage::Storage>
+pub async fn radroots_sdk::client::Client::storage_integrity(&self) -> radroots_sdk::error::Result<radroots_sdk::storage::IntegrityStatus>
+pub fn radroots_sdk::client::Client::storage_operations(&self) -> radroots_sdk::error::Result<radroots_sdk::storage::Operations<'_>>
+pub async fn radroots_sdk::client::Client::storage_status(&self) -> radroots_sdk::error::Result<radroots_sdk::storage::Status>
+pub fn radroots_sdk::client::Client::sync(&self) -> radroots_sdk::error::Result<core::option::Option<radroots_sdk::sync::Operations<'_>>>
+pub fn radroots_sdk::client::Client::trade(&self) -> radroots_sdk::error::Result<core::option::Option<radroots_sdk::trade::Operations<'_>>>
+impl core::fmt::Debug for radroots_sdk::client::Client
+pub fn radroots_sdk::client::Client::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub struct radroots_sdk::client::ClientBuilder
+impl radroots_sdk::client::ClientBuilder
+pub fn radroots_sdk::client::ClientBuilder::build(self) -> radroots_sdk::error::Result<radroots_sdk::client::Client>
+pub fn radroots_sdk::client::ClientBuilder::capability_availability(self, radroots_sdk::capability::CapabilityId, radroots_sdk::capability::Availability) -> Self
+pub fn radroots_sdk::client::ClientBuilder::memory(radroots_storage::event::SourceGeneration) -> Self
+pub fn radroots_sdk::client::ClientBuilder::new() -> Self
+pub fn radroots_sdk::client::ClientBuilder::signer(self, alloc::sync::Arc<dyn radroots_signing::signer::Signer>) -> Self
+pub fn radroots_sdk::client::ClientBuilder::signing(self, radroots_sdk::signing::Provider) -> Self
+pub fn radroots_sdk::client::ClientBuilder::sink(self, alloc::sync::Arc<dyn radroots_transport::sink::EventSink>) -> Self
+pub fn radroots_sdk::client::ClientBuilder::source(self, alloc::sync::Arc<dyn radroots_transport::source::EventSource>) -> Self
+pub async fn radroots_sdk::client::ClientBuilder::sqlite(radroots_sdk::storage::SqliteOptions) -> radroots_sdk::error::Result<Self>
+pub fn radroots_sdk::client::ClientBuilder::storage(self, alloc::sync::Arc<dyn radroots_storage::Storage>) -> Self
+pub fn radroots_sdk::client::ClientBuilder::sync_engine(self, radroots_sync::engine::Engine) -> Self
+impl core::fmt::Debug for radroots_sdk::client::ClientBuilder
+pub fn radroots_sdk::client::ClientBuilder::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub mod radroots_sdk::diagnostics
+pub struct radroots_sdk::diagnostics::Report
+impl radroots_sdk::diagnostics::Report
+pub const fn radroots_sdk::diagnostics::Report::capabilities(&self) -> &radroots_sdk::capability::CapabilityReport
+pub const fn radroots_sdk::diagnostics::Report::storage(&self) -> radroots_storage::status::StorageStatus
+pub async fn radroots_sdk::diagnostics::inspect(&radroots_sdk::client::Client) -> radroots_sdk::error::Result<radroots_sdk::diagnostics::Report>
+pub mod radroots_sdk::error
+#[non_exhaustive] pub enum radroots_sdk::error::ErrorKind
+pub radroots_sdk::error::ErrorKind::ClientClosed
+pub radroots_sdk::error::ErrorKind::ClientClosing
+pub radroots_sdk::error::ErrorKind::CloseInProgress
+pub radroots_sdk::error::ErrorKind::MissingStorage
+pub radroots_sdk::error::ErrorKind::SignerWithoutSink
+pub radroots_sdk::error::ErrorKind::StorageCloseFailed
+pub radroots_sdk::error::ErrorKind::StorageInspectionFailed
+pub radroots_sdk::error::ErrorKind::StorageOpenFailed
+impl radroots_sdk::error::ErrorKind
+pub const radroots_sdk::error::ErrorKind::ALL: &'static [Self]
+pub const fn radroots_sdk::error::ErrorKind::descriptor(self) -> radroots_sdk::error::ErrorDescriptor
+pub struct radroots_sdk::error::Error
+impl radroots_sdk::error::Error
+pub const fn radroots_sdk::error::Error::descriptor(&self) -> radroots_sdk::error::ErrorDescriptor
+pub const fn radroots_sdk::error::Error::kind(&self) -> radroots_sdk::error::ErrorKind
+pub fn radroots_sdk::error::Error::to_report(&self) -> radroots_protocol::error::v1::ErrorReport
+impl core::error::Error for radroots_sdk::error::Error
+pub fn radroots_sdk::error::Error::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+impl core::fmt::Debug for radroots_sdk::error::Error
+pub fn radroots_sdk::error::Error::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl core::fmt::Display for radroots_sdk::error::Error
+pub fn radroots_sdk::error::Error::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub struct radroots_sdk::error::ErrorDescriptor
+impl radroots_sdk::error::ErrorDescriptor
+pub const fn radroots_sdk::error::ErrorDescriptor::capability(self) -> core::option::Option<radroots_sdk::capability::CapabilityId>
+pub const fn radroots_sdk::error::ErrorDescriptor::class(self) -> radroots_protocol::error::v1::Class
+pub const fn radroots_sdk::error::ErrorDescriptor::code(self) -> radroots_protocol::error::v1::KnownCode
+pub const fn radroots_sdk::error::ErrorDescriptor::kind(self) -> radroots_sdk::error::ErrorKind
+pub const fn radroots_sdk::error::ErrorDescriptor::message(self) -> &'static str
+pub const fn radroots_sdk::error::ErrorDescriptor::operation(self) -> core::option::Option<radroots_protocol::runtime::v1::OperationId>
+pub const fn radroots_sdk::error::ErrorDescriptor::recovery_actions(self) -> &'static [radroots_protocol::error::v1::RecoveryAction]
+pub const fn radroots_sdk::error::ErrorDescriptor::retryable(self) -> bool
+pub const fn radroots_sdk::error::ErrorDescriptor::safe_detail_keys(self) -> &'static [&'static str]
+pub const radroots_sdk::error::CATALOG: &[radroots_sdk::error::ErrorDescriptor]
+pub type radroots_sdk::error::Result<T> = core::result::Result<T, radroots_sdk::error::Error>
+pub mod radroots_sdk::farm
+#[non_exhaustive] pub enum radroots_sdk::farm::PrepareErrorKind
+pub radroots_sdk::farm::PrepareErrorKind::Coordinate
+pub radroots_sdk::farm::PrepareErrorKind::Draft
+pub radroots_sdk::farm::PrepareErrorKind::Encode
+pub radroots_sdk::farm::PrepareErrorKind::UnauthorizedActor
+pub struct radroots_sdk::farm::EnqueueRequest
+impl radroots_sdk::farm::EnqueueRequest
+pub const fn radroots_sdk::farm::EnqueueRequest::new(radroots_sync::policy::SyncId, radroots_storage::journal::IdempotencyKey, radroots_sdk::farm::Plan, radroots_sdk::transport::Profile, radroots_signing::request::CancellationPolicy) -> Self
+pub struct radroots_sdk::farm::Operations<'a>
+impl<'a> radroots_sdk::farm::Operations<'a>
+pub async fn radroots_sdk::farm::Operations<'a>::enqueue(&self, radroots_sdk::farm::EnqueueRequest) -> core::result::Result<radroots_sync::push::PushReceipt, radroots_sync::policy::Error>
+pub struct radroots_sdk::farm::Plan
+impl radroots_sdk::farm::Plan
+pub const fn radroots_sdk::farm::Plan::actor(&self) -> &radroots_signing::actor::Actor
+pub const fn radroots_sdk::farm::Plan::coordinate(&self) -> &radroots_event::id::AddressableCoordinate
+pub const fn radroots_sdk::farm::Plan::draft(&self) -> &radroots_event::draft::EventDraft
+pub struct radroots_sdk::farm::PrepareError
+impl radroots_sdk::farm::PrepareError
+pub const fn radroots_sdk::farm::PrepareError::kind(&self) -> radroots_sdk::farm::PrepareErrorKind
+impl core::error::Error for radroots_sdk::farm::PrepareError
+pub fn radroots_sdk::farm::PrepareError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+impl core::fmt::Debug for radroots_sdk::farm::PrepareError
+pub fn radroots_sdk::farm::PrepareError::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl core::fmt::Display for radroots_sdk::farm::PrepareError
+pub fn radroots_sdk::farm::PrepareError::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub struct radroots_sdk::farm::PrepareRequest
+impl radroots_sdk::farm::PrepareRequest
+pub const fn radroots_sdk::farm::PrepareRequest::new(radroots_signing::actor::Actor, radroots_event::farm::Farm, u64) -> Self
+pub fn radroots_sdk::farm::prepare(radroots_sdk::farm::PrepareRequest) -> core::result::Result<radroots_sdk::farm::Plan, radroots_sdk::farm::PrepareError>
+pub mod radroots_sdk::listing
+#[non_exhaustive] pub enum radroots_sdk::listing::Action
+pub radroots_sdk::listing::Action::Publish
+pub radroots_sdk::listing::Action::Update
+#[non_exhaustive] pub enum radroots_sdk::listing::PrepareErrorKind
+pub radroots_sdk::listing::PrepareErrorKind::Edit
+pub radroots_sdk::listing::PrepareErrorKind::Mutation
+pub radroots_sdk::listing::PrepareErrorKind::UnauthorizedActor
+pub struct radroots_sdk::listing::EnqueueRequest
+impl radroots_sdk::listing::EnqueueRequest
+pub const fn radroots_sdk::listing::EnqueueRequest::new(radroots_sync::policy::SyncId, radroots_storage::journal::IdempotencyKey, radroots_sdk::listing::Plan, radroots_sdk::transport::Profile, radroots_signing::request::CancellationPolicy) -> Self
+pub struct radroots_sdk::listing::Operations<'a>
+impl<'a> radroots_sdk::listing::Operations<'a>
+pub async fn radroots_sdk::listing::Operations<'a>::enqueue(&self, radroots_sdk::listing::EnqueueRequest) -> core::result::Result<radroots_sync::push::PushReceipt, radroots_sync::policy::Error>
+pub struct radroots_sdk::listing::Plan
+impl radroots_sdk::listing::Plan
+pub const fn radroots_sdk::listing::Plan::action(&self) -> radroots_sdk::listing::Action
+pub const fn radroots_sdk::listing::Plan::actor(&self) -> &radroots_signing::actor::Actor
+pub const fn radroots_sdk::listing::Plan::address(&self) -> &radroots_event::id::ClassifiedListingAddress
+pub const fn radroots_sdk::listing::Plan::draft(&self) -> &radroots_event::draft::EventDraft
+pub const fn radroots_sdk::listing::Plan::lifecycle(&self) -> radroots_trade::operational_listing::mutation::RadrootsOperationalListingLifecycleState
+pub struct radroots_sdk::listing::PrepareError
+impl radroots_sdk::listing::PrepareError
+pub const fn radroots_sdk::listing::PrepareError::kind(&self) -> radroots_sdk::listing::PrepareErrorKind
+impl core::error::Error for radroots_sdk::listing::PrepareError
+pub fn radroots_sdk::listing::PrepareError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+impl core::fmt::Debug for radroots_sdk::listing::PrepareError
+pub fn radroots_sdk::listing::PrepareError::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl core::fmt::Display for radroots_sdk::listing::PrepareError
+pub fn radroots_sdk::listing::PrepareError::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub struct radroots_sdk::listing::PrepareRequest
+impl radroots_sdk::listing::PrepareRequest
+pub const fn radroots_sdk::listing::PrepareRequest::publish(radroots_signing::actor::Actor, radroots_trade::operational_listing::draft::RadrootsOperationalListingEditDocumentV1, u64) -> Self
+pub const fn radroots_sdk::listing::PrepareRequest::update(radroots_signing::actor::Actor, radroots_trade::operational_listing::draft::RadrootsOperationalListingEditDocumentV1, u64) -> Self
+pub fn radroots_sdk::listing::prepare(radroots_sdk::listing::PrepareRequest) -> core::result::Result<radroots_sdk::listing::Plan, radroots_sdk::listing::PrepareError>
+pub mod radroots_sdk::signing
+#[non_exhaustive] pub enum radroots_sdk::signing::Mode
+pub radroots_sdk::signing::Mode::Host
+pub radroots_sdk::signing::Mode::Local
+pub radroots_sdk::signing::Mode::Nip46
+pub struct radroots_sdk::signing::Provider
+impl radroots_sdk::signing::Provider
+pub fn radroots_sdk::signing::Provider::as_signer(&self) -> &dyn radroots_signing::signer::Signer
+pub fn radroots_sdk::signing::Provider::host(alloc::sync::Arc<dyn radroots_signing::signer::Signer>) -> Self
+pub fn radroots_sdk::signing::Provider::local(radroots_nostr::signing::LocalSigner) -> Self
+pub const fn radroots_sdk::signing::Provider::mode(&self) -> radroots_sdk::signing::Mode
+pub fn radroots_sdk::signing::Provider::nip46(alloc::sync::Arc<dyn radroots_signing::signer::Signer>) -> Self
+pub async fn radroots_sdk::signing::Provider::sign(&self, radroots_signing::request::SignRequest) -> core::result::Result<radroots_signing::receipt::SignReceipt, radroots_signing::error::Error>
+pub async fn radroots_sdk::signing::Provider::status(&self) -> core::result::Result<radroots_signing::status::SignerStatus, radroots_signing::error::Error>
+impl core::fmt::Debug for radroots_sdk::signing::Provider
+pub fn radroots_sdk::signing::Provider::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub mod radroots_sdk::storage
+pub struct radroots_sdk::storage::Operations<'a>
+impl<'a> radroots_sdk::storage::Operations<'a>
+pub async fn radroots_sdk::storage::Operations<'a>::begin_backup(&self, radroots_storage::backup::BackupPlan) -> core::result::Result<radroots_storage::backup::BackupOperation, radroots_storage::error::Error>
+pub async fn radroots_sdk::storage::Operations<'a>::begin_restore(&self, radroots_storage::backup::RestorePlan) -> core::result::Result<radroots_storage::backup::RestoreOperation, radroots_storage::error::Error>
+pub async fn radroots_sdk::storage::Operations<'a>::integrity(&self) -> core::result::Result<radroots_sdk::storage::IntegrityStatus, radroots_storage::error::Error>
+pub async fn radroots_sdk::storage::Operations<'a>::status(&self) -> core::result::Result<radroots_sdk::storage::Status, radroots_storage::error::Error>
+pub async fn radroots_sdk::storage::Operations<'a>::transition_backup(&self, radroots_storage::backup::BackupId, radroots_storage::backup::ReliabilityRevision, radroots_storage::backup::BackupTransition, u64) -> core::result::Result<radroots_storage::backup::BackupOperation, radroots_storage::error::Error>
+pub async fn radroots_sdk::storage::Operations<'a>::transition_restore(&self, radroots_storage::backup::BackupId, radroots_storage::backup::ReliabilityRevision, radroots_storage::backup::RestoreTransition, u64) -> core::result::Result<radroots_storage::backup::RestoreOperation, radroots_storage::error::Error>
+impl core::fmt::Debug for radroots_sdk::storage::Operations<'_>
+pub fn radroots_sdk::storage::Operations<'_>::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub type radroots_sdk::storage::IntegrityStatus = radroots_storage::status::IntegrityStatus
+pub type radroots_sdk::storage::SqliteOpenMode = radroots_storage_sqlite::open::OpenMode
+pub type radroots_sdk::storage::SqliteOptions = radroots_storage_sqlite::config::OpenOptions
+pub type radroots_sdk::storage::SqlitePaths = radroots_storage_sqlite::open::Paths
+pub type radroots_sdk::storage::Status = radroots_storage::status::StorageStatus
+pub mod radroots_sdk::sync
+pub struct radroots_sdk::sync::Operations<'a>
+impl<'a> radroots_sdk::sync::Operations<'a>
+pub async fn radroots_sdk::sync::Operations<'a>::deliver_pending(&self, radroots_sync::push::DeliveryRunRequest) -> core::result::Result<radroots_sync::push::DeliveryRunReceipt, radroots_sync::policy::Error>
+pub async fn radroots_sdk::sync::Operations<'a>::ingest(&self, radroots_transport::source::ObservedEvent, &dyn radroots_sync::ingest::AdmissionPolicy) -> core::result::Result<radroots_sync::ingest::IngestReceipt, radroots_sync::policy::Error>
+pub async fn radroots_sdk::sync::Operations<'a>::ingest_batch(&self, alloc::vec::Vec<radroots_transport::source::ObservedEvent>, &dyn radroots_sync::ingest::AdmissionPolicy) -> radroots_sync::ingest::IngestBatchReceipt
+pub async fn radroots_sdk::sync::Operations<'a>::pull(&self, radroots_sync::pull::PullRequest, &dyn radroots_sync::ingest::AdmissionPolicy) -> core::result::Result<radroots_sync::pull::PullReceipt, radroots_sync::policy::Error>
+pub async fn radroots_sdk::sync::Operations<'a>::refresh_projection(&self, radroots_sync::projection::RefreshRequest, &dyn radroots_sync::projection::Reducer) -> core::result::Result<radroots_sync::projection::RefreshReceipt, radroots_sync::policy::Error>
+pub fn radroots_sdk::sync::Operations<'a>::retry_decision(&self, &radroots_storage::outbox::OutboxRecord, u64) -> core::result::Result<radroots_protocol::runtime::v1::SyncRetryDecision, radroots_sync::policy::Error>
+pub async fn radroots_sdk::sync::Operations<'a>::sign_and_enqueue(&self, radroots_sync::push::PushRequest) -> core::result::Result<radroots_sync::push::PushReceipt, radroots_sync::policy::Error>
+pub async fn radroots_sdk::sync::Operations<'a>::status(&self, &[radroots_storage::projection::ProjectionId]) -> core::result::Result<radroots_sync::status::SyncStatus, radroots_sync::policy::Error>
+impl core::fmt::Debug for radroots_sdk::sync::Operations<'_>
+pub fn radroots_sdk::sync::Operations<'_>::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub mod radroots_sdk::trade
+#[non_exhaustive] pub enum radroots_sdk::trade::PrepareErrorKind
+pub radroots_sdk::trade::PrepareErrorKind::CanonicalMutation
+pub radroots_sdk::trade::PrepareErrorKind::Draft
+pub radroots_sdk::trade::PrepareErrorKind::Encode
+pub radroots_sdk::trade::PrepareErrorKind::UnauthorizedActor
+pub radroots_sdk::trade::PrepareErrorKind::Workflow
+#[non_exhaustive] pub enum radroots_sdk::trade::PrivateTermsError
+pub radroots_sdk::trade::PrivateTermsError::EvidenceMismatch
+pub radroots_sdk::trade::PrivateTermsError::NotRequired
+pub radroots_sdk::trade::PrivateTermsError::Storage
+pub struct radroots_sdk::trade::EnqueueRequest
+impl radroots_sdk::trade::EnqueueRequest
+pub const fn radroots_sdk::trade::EnqueueRequest::new(radroots_sync::policy::SyncId, radroots_storage::journal::IdempotencyKey, radroots_sdk::trade::Plan, radroots_sdk::transport::Profile, radroots_signing::request::CancellationPolicy) -> Self
+pub struct radroots_sdk::trade::Operations<'a>
+impl<'a> radroots_sdk::trade::Operations<'a>
+pub async fn radroots_sdk::trade::Operations<'a>::enqueue(&self, radroots_sdk::trade::EnqueueRequest) -> core::result::Result<radroots_sync::push::PushReceipt, radroots_sync::policy::Error>
+pub async fn radroots_sdk::trade::Operations<'a>::private_artifact(&self, radroots_storage::private_artifact::PrivateArtifactId) -> core::result::Result<core::option::Option<radroots_storage::private_artifact::PrivateArtifactMetadata>, radroots_storage::error::Error>
+pub async fn radroots_sdk::trade::Operations<'a>::query_visible(&self, radroots_storage::event::EventQuery) -> core::result::Result<radroots_storage::event::EventPage<radroots_storage::event::StoredVisibleEvent>, radroots_storage::error::Error>
+pub async fn radroots_sdk::trade::Operations<'a>::verify_private_terms(&self, &radroots_sdk::trade::Plan, radroots_storage::private_artifact::PrivateArtifactId) -> core::result::Result<radroots_storage::private_artifact::PrivateArtifactMetadata, radroots_sdk::trade::PrivateTermsError>
+impl core::fmt::Debug for radroots_sdk::trade::Operations<'_>
+pub fn radroots_sdk::trade::Operations<'_>::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub struct radroots_sdk::trade::Plan
+impl radroots_sdk::trade::Plan
+pub const fn radroots_sdk::trade::Plan::actor(&self) -> &radroots_signing::actor::Actor
+pub const fn radroots_sdk::trade::Plan::draft(&self) -> &radroots_event::draft::EventDraft
+pub const fn radroots_sdk::trade::Plan::workflow(&self) -> &radroots_trade::workflow::WorkflowPlan
+pub struct radroots_sdk::trade::PrepareError
+impl radroots_sdk::trade::PrepareError
+pub const fn radroots_sdk::trade::PrepareError::kind(&self) -> radroots_sdk::trade::PrepareErrorKind
+impl core::error::Error for radroots_sdk::trade::PrepareError
+pub fn radroots_sdk::trade::PrepareError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+impl core::fmt::Debug for radroots_sdk::trade::PrepareError
+pub fn radroots_sdk::trade::PrepareError::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl core::fmt::Display for radroots_sdk::trade::PrepareError
+pub fn radroots_sdk::trade::PrepareError::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub struct radroots_sdk::trade::PrepareRequest
+impl radroots_sdk::trade::PrepareRequest
+pub const fn radroots_sdk::trade::PrepareRequest::new(radroots_signing::actor::Actor, radroots_event::trade::TradeMutationEnvelopeV1) -> Self
+pub fn radroots_sdk::trade::prepare(radroots_sdk::trade::PrepareRequest) -> core::result::Result<radroots_sdk::trade::Plan, radroots_sdk::trade::PrepareError>
+pub fn radroots_sdk::trade::project(radroots_trade::trade_contract_v1::RadrootsTradeReductionInputV1) -> radroots_trade::trade_contract_v1::RadrootsTradeProjectionV1
+pub mod radroots_sdk::transport
+#[non_exhaustive] pub enum radroots_sdk::transport::DaemonAuth
+pub radroots_sdk::transport::DaemonAuth::BearerToken(alloc::string::String)
+pub radroots_sdk::transport::DaemonAuth::None
+impl core::fmt::Debug for radroots_sdk::transport::DaemonAuth
+pub fn radroots_sdk::transport::DaemonAuth::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+#[non_exhaustive] pub enum radroots_sdk::transport::DaemonErrorKind
+pub radroots_sdk::transport::DaemonErrorKind::Authentication
+pub radroots_sdk::transport::DaemonErrorKind::InvalidRequest
+pub radroots_sdk::transport::DaemonErrorKind::InvalidResponse
+pub radroots_sdk::transport::DaemonErrorKind::Rpc
+pub radroots_sdk::transport::DaemonErrorKind::Transport
+pub struct radroots_sdk::transport::DaemonConfig
+impl radroots_sdk::transport::DaemonConfig
+pub fn radroots_sdk::transport::DaemonConfig::new(impl core::convert::Into<alloc::string::String>) -> Self
+pub fn radroots_sdk::transport::DaemonConfig::with_auth(self, radroots_sdk::transport::DaemonAuth) -> Self
+pub const fn radroots_sdk::transport::DaemonConfig::with_timeout(self, core::time::Duration) -> Self
+pub struct radroots_sdk::transport::DaemonDelivery
+impl radroots_sdk::transport::DaemonDelivery
+pub async fn radroots_sdk::transport::DaemonDelivery::deliver(&self, radroots_event::draft::SignedEvent, radroots_protocol::radrootsd::transport_publish::v5::TargetPolicy, radroots_protocol::radrootsd::transport_publish::v5::DeliveryPolicy, core::option::Option<alloc::string::String>, core::option::Option<u64>) -> core::result::Result<radroots_protocol::radrootsd::transport_publish::v5::EventResponse, radroots_sdk::transport::DaemonError>
+pub fn radroots_sdk::transport::DaemonDelivery::new(radroots_sdk::transport::DaemonConfig) -> Self
+pub struct radroots_sdk::transport::DaemonError
+impl radroots_sdk::transport::DaemonError
+pub const fn radroots_sdk::transport::DaemonError::kind(&self) -> radroots_sdk::transport::DaemonErrorKind
+impl core::error::Error for radroots_sdk::transport::DaemonError
+pub fn radroots_sdk::transport::DaemonError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+impl core::fmt::Debug for radroots_sdk::transport::DaemonError
+pub fn radroots_sdk::transport::DaemonError::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl core::fmt::Display for radroots_sdk::transport::DaemonError
+pub fn radroots_sdk::transport::DaemonError::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub struct radroots_sdk::transport::Profile
+impl radroots_sdk::transport::Profile
+pub fn radroots_sdk::transport::Profile::delivery(radroots_transport::target::TargetSet, radroots_transport::policy::SatisfactionPolicy) -> core::result::Result<Self, radroots_transport::error::Error>
+pub const fn radroots_sdk::transport::Profile::is_local_only(&self) -> bool
+pub const fn radroots_sdk::transport::Profile::local_only() -> Self
+pub const fn radroots_sdk::transport::Profile::satisfaction(&self) -> core::option::Option<&radroots_transport::policy::SatisfactionPolicy>
+pub const fn radroots_sdk::transport::Profile::sink_status(&self) -> core::option::Option<&radroots_transport::status::SinkStatus>
+pub const fn radroots_sdk::transport::Profile::source_status(&self) -> core::option::Option<&radroots_transport::status::SourceStatus>
+pub const fn radroots_sdk::transport::Profile::targets(&self) -> core::option::Option<&radroots_transport::target::TargetSet>
+pub fn radroots_sdk::transport::Profile::unavailable_preview(radroots_transport::id::TransportId) -> Self
+impl core::default::Default for radroots_sdk::transport::Profile
+pub fn radroots_sdk::transport::Profile::default() -> Self
+pub struct radroots_sdk::Client
+impl radroots_sdk::client::Client
+pub fn radroots_sdk::client::Client::capabilities(&self) -> radroots_sdk::capability::CapabilityReport
+pub async fn radroots_sdk::client::Client::close(&self) -> radroots_sdk::error::Result<()>
+pub fn radroots_sdk::client::Client::farm(&self) -> radroots_sdk::error::Result<core::option::Option<radroots_sdk::farm::Operations<'_>>>
+pub fn radroots_sdk::client::Client::is_closed(&self) -> bool
+pub fn radroots_sdk::client::Client::listing(&self) -> radroots_sdk::error::Result<core::option::Option<radroots_sdk::listing::Operations<'_>>>
+pub fn radroots_sdk::client::Client::signer(&self) -> radroots_sdk::error::Result<core::option::Option<&dyn radroots_signing::signer::Signer>>
+pub fn radroots_sdk::client::Client::sink(&self) -> radroots_sdk::error::Result<core::option::Option<&dyn radroots_transport::sink::EventSink>>
+pub fn radroots_sdk::client::Client::source(&self) -> radroots_sdk::error::Result<core::option::Option<&dyn radroots_transport::source::EventSource>>
+pub fn radroots_sdk::client::Client::storage(&self) -> radroots_sdk::error::Result<&dyn radroots_storage::Storage>
+pub async fn radroots_sdk::client::Client::storage_integrity(&self) -> radroots_sdk::error::Result<radroots_sdk::storage::IntegrityStatus>
+pub fn radroots_sdk::client::Client::storage_operations(&self) -> radroots_sdk::error::Result<radroots_sdk::storage::Operations<'_>>
+pub async fn radroots_sdk::client::Client::storage_status(&self) -> radroots_sdk::error::Result<radroots_sdk::storage::Status>
+pub fn radroots_sdk::client::Client::sync(&self) -> radroots_sdk::error::Result<core::option::Option<radroots_sdk::sync::Operations<'_>>>
+pub fn radroots_sdk::client::Client::trade(&self) -> radroots_sdk::error::Result<core::option::Option<radroots_sdk::trade::Operations<'_>>>
+impl core::fmt::Debug for radroots_sdk::client::Client
+pub fn radroots_sdk::client::Client::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub struct radroots_sdk::ClientBuilder
+impl radroots_sdk::client::ClientBuilder
+pub fn radroots_sdk::client::ClientBuilder::build(self) -> radroots_sdk::error::Result<radroots_sdk::client::Client>
+pub fn radroots_sdk::client::ClientBuilder::capability_availability(self, radroots_sdk::capability::CapabilityId, radroots_sdk::capability::Availability) -> Self
+pub fn radroots_sdk::client::ClientBuilder::memory(radroots_storage::event::SourceGeneration) -> Self
+pub fn radroots_sdk::client::ClientBuilder::new() -> Self
+pub fn radroots_sdk::client::ClientBuilder::signer(self, alloc::sync::Arc<dyn radroots_signing::signer::Signer>) -> Self
+pub fn radroots_sdk::client::ClientBuilder::signing(self, radroots_sdk::signing::Provider) -> Self
+pub fn radroots_sdk::client::ClientBuilder::sink(self, alloc::sync::Arc<dyn radroots_transport::sink::EventSink>) -> Self
+pub fn radroots_sdk::client::ClientBuilder::source(self, alloc::sync::Arc<dyn radroots_transport::source::EventSource>) -> Self
+pub async fn radroots_sdk::client::ClientBuilder::sqlite(radroots_sdk::storage::SqliteOptions) -> radroots_sdk::error::Result<Self>
+pub fn radroots_sdk::client::ClientBuilder::storage(self, alloc::sync::Arc<dyn radroots_storage::Storage>) -> Self
+pub fn radroots_sdk::client::ClientBuilder::sync_engine(self, radroots_sync::engine::Engine) -> Self
+impl core::fmt::Debug for radroots_sdk::client::ClientBuilder
+pub fn radroots_sdk::client::ClientBuilder::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub struct radroots_sdk::Error
+impl radroots_sdk::error::Error
+pub const fn radroots_sdk::error::Error::descriptor(&self) -> radroots_sdk::error::ErrorDescriptor
+pub const fn radroots_sdk::error::Error::kind(&self) -> radroots_sdk::error::ErrorKind
+pub fn radroots_sdk::error::Error::to_report(&self) -> radroots_protocol::error::v1::ErrorReport
+impl core::error::Error for radroots_sdk::error::Error
+pub fn radroots_sdk::error::Error::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+impl core::fmt::Debug for radroots_sdk::error::Error
+pub fn radroots_sdk::error::Error::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl core::fmt::Display for radroots_sdk::error::Error
+pub fn radroots_sdk::error::Error::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub type radroots_sdk::Result<T> = core::result::Result<T, radroots_sdk::error::Error>
