Struct ContentNode 

pub struct ContentNode { /* private fields */ }

CHIE node instance.

Examples

use chie_core::{ContentNode, NodeConfig, PinnedContent};
use std::path::PathBuf;

let config = NodeConfig {
    storage_path: PathBuf::from("/tmp/chie-test"),
    max_storage_bytes: 10 * 1024 * 1024,
    max_bandwidth_bps: 100 * 1024 * 1024 / 8,
    coordinator_url: "https://coordinator.chie.network".to_string(),
};

let mut node = ContentNode::new(config);

// Pin some content
let content = PinnedContent {
    cid: "QmTest123".to_string(),
    size_bytes: 1024,
    encryption_key: [0u8; 32],
    predicted_revenue_per_gb: 10.0,
};
node.pin_content(content);

assert_eq!(node.pinned_count(), 1);
assert!(node.has_content(&"QmTest123".to_string()));

Implementations

impl ContentNode

pub fn new(config: NodeConfig) -> Self

Create a new content node.

pub async fn with_storage(config: NodeConfig) -> Result<Self, NodeError>

Create a new content node with storage backend.

pub fn set_storage(&mut self, storage: Arc<RwLock<ChunkStorage>>)

Set the storage backend.

pub fn storage(&self) -> Option<&Arc<RwLock<ChunkStorage>>>

Get a reference to the storage backend.

pub fn public_key(&self) -> [u8; 32]

Get the node’s public key.

pub fn earnings(&self) -> Points

Get total earnings.

pub fn config(&self) -> &NodeConfig

Get the node configuration.

pub fn pin_content(&mut self, content: PinnedContent)

Pin content for distribution.

pub fn unpin_content(&mut self, cid: &ContentCid) -> Option<PinnedContent>

Unpin content.

pub fn has_content(&self, cid: &ContentCid) -> bool

Check if content is pinned.

pub fn pinned_count(&self) -> usize

Get pinned content count.

pub async fn handle_chunk_request( &self, request: ChunkRequest, ) -> Result<ChunkResponse, NodeError>

Handle a chunk request and generate a response.

This method reads the requested chunk from storage, signs it, and returns a ChunkResponse. If storage is not configured, returns a placeholder response.

pub async fn handle_chunk_request_verified( &self, request: ChunkRequest, ) -> Result<ChunkResponse, NodeError>

Handle a chunk request with verification.

Same as handle_chunk_request but also verifies the chunk hash matches storage metadata.

pub async fn submit_proof(&self, proof: BandwidthProof) -> Result<(), NodeError>

Submit a proof to the coordinator using pooled connection.

pub async fn submit_proofs_batch( &self, proofs: Vec<BandwidthProof>, ) -> Result<(), NodeError>

Submit multiple proofs in batch for improved efficiency.

pub fn add_earnings(&mut self, amount: Points)

Add earnings (called when proof is verified).

pub async fn storage_stats(&self) -> Option<StorageStats>

Get storage statistics if storage is configured.

pub async fn handle_chunk_requests_batch( &self, requests: Vec<ChunkRequest>, ) -> Result<Vec<ChunkResponse>, NodeError>

Handle multiple chunk requests concurrently for improved throughput.