Struct NostrRootResolver 

pub struct NostrRootResolver { /* private fields */ }

NostrRootResolver - Maps npub/treename keys to merkle root hashes

Implementations

impl NostrRootResolver

pub async fn resolve_open( &self, key: &str, window: Duration, ) -> Result<Cid, ResolverError>

Observe a mutable root for a bounded window, keeping the subscription open after EOSE. Returns the newest usable signed root observed in that window; a quiet window is a timeout, not proof that the root does not exist. Unlike quick resolution, this does not use cached observations or a quorum shortcut. It closes only its own subscription before returning.

impl NostrRootResolver

pub async fn new( config: NostrResolverConfig, ) -> Result<NostrRootResolver, ResolverError>

Create a new NostrRootResolver

pub fn pubkey(&self) -> Option<PublicKey>

Get current user’s public key (if we have a secret key)

pub fn filter_for_key(key: &str) -> Result<Filter, ResolverError>

Build the exact Nostr filter for a resolver key without opening a relay connection. Pubsub transports can use this to subscribe on behalf of the resolver.

pub fn root_event_builder( tree_name: &str, cid: &Cid, latest_created_at: Option<Timestamp>, ) -> EventBuilder

Build an unsigned public-root announcement for any event transport. The caller signs with the owner of the resolver key.

pub fn event_matches_key( key: &str, event: &Event, ) -> Result<bool, ResolverError>

Validate that a signed event is a usable root for exactly this key.

Pubsub consumers can use this before caching an event obtained from an untrusted transport. Private roots require resolver keys and therefore are not considered usable by this transport-neutral check.

pub fn root_from_event( key: &str, event: &Event, ) -> Result<Option<Cid>, ResolverError>

Authenticate and decode a public root without creating a relay client.

pub async fn ingest_event(&self, event: Event) -> Result<bool, ResolverError>

Ingest a signed root event obtained from any transport. Returns true only when it advances the replaceable root for its author and tree.

pub async fn resolve_wait(&self, key: &str) -> Result<Cid, ResolverError>

Resolve a key, waiting indefinitely until found.

Unlike resolve() which returns None after timeout, this method subscribes and waits until a Cid is found. Caller should apply their own timeout if needed (e.g., via tokio::time::timeout).

This matches the behavior of hashtree-ts NostrRootResolver.

pub async fn publish_private( &self, key: &str, cid: &Cid, ) -> Result<bool, ResolverError>

Publish a private root (selfEncryptedKey tag, NIP-44 to self)

Trait Implementations

impl RootResolver for NostrRootResolver

fn resolve<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<Cid>, ResolverError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, NostrRootResolver: 'async_trait,

Resolve a key to its current Cid (one-shot)

fn resolve_shared<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, key: &'life1 str, share_secret: &'life2 [u8; 32], ) -> Pin<Box<dyn Future<Output = Result<Option<Cid>, ResolverError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, NostrRootResolver: 'async_trait,

Resolve with a share secret (for encrypted_key decryption)

fn subscribe<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Receiver<Option<Cid>>, ResolverError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, NostrRootResolver: 'async_trait,

Subscribe to Cid changes for a key.

fn publish<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, key: &'life1 str, cid: &'life2 Cid, ) -> Pin<Box<dyn Future<Output = Result<bool, ResolverError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, NostrRootResolver: 'async_trait,

Publish/update a Cid (optional - only for writable backends)

fn publish_shared<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, key: &'life1 str, cid: &'life2 Cid, share_secret: &'life3 [u8; 32], ) -> Pin<Box<dyn Future<Output = Result<bool, ResolverError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, NostrRootResolver: 'async_trait,

Publish with encrypted key for sharing

fn list<'life0, 'life1, 'async_trait>( &'life0 self, prefix: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<ResolverEntry>, ResolverError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, NostrRootResolver: 'async_trait,

List all keys matching a prefix (one-shot)

fn stop<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), ResolverError>> + Send + 'async_trait>>

where 'life0: 'async_trait, NostrRootResolver: 'async_trait,

Stop the resolver and clean up resources

fn subscribe_list<'life0, 'life1, 'async_trait>( &'life0 self, prefix: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Receiver<Vec<ResolverEntry>>, ResolverError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

Subscribe to list changes for a prefix.