Struct NostrRootResolver 

pub struct NostrRootResolver { /* private fields */ }

NostrRootResolver - Maps npub/treename keys to merkle root hashes

Implementations

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 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 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.