Struct NodeClient 

pub struct NodeClient { /* private fields */ }

Implementations

impl NodeClient

pub fn create_alias<T>( &self, alias: Alias<T>, scope: Option<T::Scope>, value: T, ) -> Result<()>

where T: Aliasable<Scope: StoreScopeCompat> + AsRef<[u8; 32]>,

pub fn delete_alias<T>( &self, alias: Alias<T>, scope: Option<T::Scope>, ) -> Result<()>

where T: Aliasable<Scope: StoreScopeCompat>,

pub fn lookup_alias<T>( &self, alias: Alias<T>, scope: Option<T::Scope>, ) -> Result<Option<T>>

where T: Aliasable<Scope: StoreScopeCompat> + From<[u8; 32]>,

pub fn resolve_alias<T>( &self, alias: Alias<T>, scope: Option<T::Scope>, ) -> Result<Option<T>>

where T: Aliasable<Scope: StoreScopeCompat> + From<[u8; 32]> + FromStr<Err: Into<Report>>,

pub fn list_aliases<T>( &self, scope: Option<T::Scope>, ) -> Result<Vec<(Alias<T>, T, Option<T::Scope>)>>

where T: Aliasable + From<[u8; 32]>, T::Scope: Copy + PartialEq + StoreScopeCompat,

impl NodeClient

pub fn get_application( &self, application_id: &ApplicationId, ) -> Result<Option<Application>>

pub async fn get_application_bytes( &self, application_id: &ApplicationId, ) -> Result<Option<Arc<[u8]>>>

pub fn has_application(&self, application_id: &ApplicationId) -> Result<bool>

pub fn install_application( &self, blob_id: &BlobId, size: u64, source: &ApplicationSource, metadata: Vec<u8>, package: &str, version: &str, signer_id: Option<&str>, is_bundle: bool, ) -> Result<ApplicationId>

pub async fn install_application_from_path( &self, path: Utf8PathBuf, metadata: Vec<u8>, package: Option<String>, version: Option<String>, ) -> Result<ApplicationId>

pub async fn install_application_from_url( &self, url: Url, metadata: Vec<u8>, expected_hash: Option<&Hash>, ) -> Result<ApplicationId>

pub fn is_bundle_blob(blob_bytes: &[u8]) -> bool

Check if a blob contains a bundle archive by peeking at the first few entries. This is a lightweight check that only reads the archive structure, not the full content.

Returns true if manifest.json is found, false otherwise. Logs warnings for parsing errors to help diagnose corrupted bundles.

pub async fn install_application_from_bundle_blob( &self, blob_id: &BlobId, source: &ApplicationSource, ) -> Result<ApplicationId>

Install an application from a bundle blob that’s already in the blobstore. This is used when a bundle blob is received via blob sharing or discovery. No metadata needed - bundle detection happens via is_bundle_blob()

pub fn uninstall_application( &self, application_id: &ApplicationId, ) -> Result<()>

pub fn list_applications(&self) -> Result<Vec<Application>>

pub fn update_compiled_app( &self, application_id: &ApplicationId, compiled_blob_id: &BlobId, ) -> Result<()>

pub fn list_packages(&self) -> Result<Vec<String>>

List all packages

pub fn list_versions(&self, package: &str) -> Result<Vec<String>>

List all versions of a package

pub fn get_latest_version( &self, package: &str, ) -> Result<Option<(String, ApplicationId)>>

Get the latest version of a package (version string and application id)

pub async fn install_by_package_version( &self, _package: &str, _version: &str, source: &ApplicationSource, metadata: Vec<u8>, ) -> Result<ApplicationId>

Install application by package and version

impl NodeClient

pub async fn add_blob<S: AsyncRead>( &self, stream: S, expected_size: Option<u64>, expected_hash: Option<&Hash>, ) -> Result<(BlobId, u64)>

pub async fn get_blob<'a>( &'a self, blob_id: &'a BlobId, context_id: Option<&'a ContextId>, ) -> Result<Option<Blob>>

Get blob from local storage or network if context_id is provided Returns a streaming Blob that can be used to read the data

pub async fn get_blob_bytes( &self, blob_id: &BlobId, context_id: Option<&ContextId>, ) -> Result<Option<Arc<[u8]>>>

Get blob bytes from local storage with actor-based caching Falls back to network download if context_id is provided and blob not found locally

pub async fn find_blob_providers( &self, blob_id: &BlobId, context_id: &ContextId, ) -> Result<Vec<PeerId>>

Query the network for peers that have a specific blob

pub async fn announce_blob_to_network( &self, blob_id: &BlobId, context_id: &ContextId, size: u64, ) -> Result<()>

Announce a blob to the network for discovery

pub fn has_blob(&self, blob_id: &BlobId) -> Result<bool>

pub fn list_blobs(&self) -> Result<Vec<BlobInfo>>

List all root blobs

Returns a list of all root blob IDs and their metadata. Root blobs are either:

• Blobs that contain links to chunks (segmented large files)
• Standalone blobs that aren’t referenced as chunks by other blobs This excludes individual chunk blobs to provide a cleaner user experience.

pub async fn delete_blob(&self, blob_id: BlobId) -> Result<bool>

Delete a blob by its ID

Removes blob metadata from database and deletes the actual blob files. This includes all associated chunk files for large blobs.

pub async fn get_blob_info( &self, blob_id: BlobId, ) -> Result<Option<BlobMetadata>>

Get blob metadata

Returns blob metadata including size, hash, and detected MIME type. This is efficient for checking blob existence and getting metadata info.

pub async fn detect_blob_mime_type(&self, blob_id: BlobId) -> Option<String>

Detect MIME type by reading the first few bytes of a blob

pub fn find_owned_identity( &self, context_id: &ContextId, ) -> Result<Option<(PublicKey, PrivateKey)>>

Helper to find an identity in the datastore for which the node possesses the private key.

pub fn create_blob_auth( &self, blob_id: &BlobId, context_id: &ContextId, public_key: PublicKey, private_key: &PrivateKey, ) -> Result<BlobAuth>

Generates the BlobAuth authentication structure by creating a payload envelope and signing it.

Arguments

• blob_id - The ID of the blob being requested.
• context_id - The context context the blob belongs to.
• public_key - The public key of the requester that is a member of the context.
• private_key - The private key used to sign the request.

pub fn create_blob_auth_for_context( &self, context_id: &ContextId, blob_id: &BlobId, ) -> Result<Option<BlobAuth>>

A helper function that finds identity from store and creates blob authentication struct.

Attempts to find a local identity for the context. If found, generates a signature. If not found, returns None (which implies a public access request).

Returns

• Ok(Some(blob_auth)) - if the local identity was found and blob authentication struct was successfully created.
• Ok(None) - if the node doesn’t own any identity for the given context.
• Err - if some internal error occured (e.g. DB error, serialization, etc).

impl NodeClient

pub fn new( datastore: Store, blobstore: BlobManager, network_client: NetworkClient, node_manager: LazyRecipient<NodeMessage>, event_sender: Sender<NodeEvent>, ctx_sync_tx: Sender<(Option<ContextId>, Option<PeerId>)>, specialized_node_invite_topic: String, ) -> Self

pub async fn subscribe(&self, context_id: &ContextId) -> Result<()>

pub async fn unsubscribe(&self, context_id: &ContextId) -> Result<()>

pub async fn get_peers_count(&self, context: Option<&ContextId>) -> usize

pub async fn broadcast( &self, context: &Context, sender: &PublicKey, sender_key: &PrivateKey, artifact: Vec<u8>, delta_id: [u8; 32], parent_ids: Vec<[u8; 32]>, hlc: HybridTimestamp, events: Option<Vec<u8>>, ) -> Result<()>

pub async fn broadcast_heartbeat( &self, context_id: &ContextId, root_hash: Hash, dag_heads: Vec<[u8; 32]>, ) -> Result<()>

pub async fn broadcast_specialized_node_invite( &self, context_id: ContextId, inviter_id: PublicKey, ) -> Result<[u8; 32]>

Broadcast a specialized node invite discovery to the global invite topic.

This broadcasts a discovery message and registers a pending invite so that when a specialized node responds with verification, the node can create an invitation.

Arguments

• context_id - The context to invite specialized nodes to
• inviter_id - The identity performing the invitation
• invite_topic - The global topic name for specialized node invite discovery

Returns

The nonce used in the request

pub fn send_event(&self, event: NodeEvent) -> Result<()>

pub fn receive_events(&self) -> impl Stream<Item = NodeEvent>

pub async fn sync( &self, context_id: Option<&ContextId>, peer_id: Option<&PeerId>, ) -> Result<()>

Trait Implementations

impl Clone for NodeClient

fn clone(&self) -> NodeClient

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for NodeClient

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.