Struct ChaincraftNode 

pub struct ChaincraftNode {
    pub id: PeerId,
    pub registry: Arc<RwLock<SharedObjectRegistry>>,
    pub app_objects: Arc<RwLock<ApplicationObjectRegistry>>,
    pub discovery: Option<DiscoveryManager>,
    pub storage: Arc<dyn Storage>,
    pub peers: Arc<RwLock<HashMap<PeerId, PeerInfo>>>,
    pub banned_peers: Arc<RwLock<HashSet<SocketAddr>>>,
    pub known_hashes: Arc<RwLock<HashSet<String>>>,
    pub socket: Option<Arc<UdpSocket>>,
    pub config: NodeConfig,
    pub running: Arc<RwLock<bool>>,
}

Main node structure for Chaincraft network

Fields

id: PeerId

Unique identifier for this node

registry: Arc<RwLock<SharedObjectRegistry>>

Registry of shared objects

app_objects: Arc<RwLock<ApplicationObjectRegistry>>

Registry of application objects

discovery: Option<DiscoveryManager>

Discovery manager

storage: Arc<dyn Storage>

Storage backend

peers: Arc<RwLock<HashMap<PeerId, PeerInfo>>>

Connected peers

banned_peers: Arc<RwLock<HashSet<SocketAddr>>>

Banned peer addresses (loaded from and saved to storage)

known_hashes: Arc<RwLock<HashSet<String>>>

Known message hashes for gossip

socket: Option<Arc<UdpSocket>>

UDP socket for networking (if initialized)

config: NodeConfig

Node configuration

running: Arc<RwLock<bool>>

Running flag

Implementations

impl ChaincraftNode

pub fn new(id: PeerId, storage: Arc<dyn Storage>) -> Self

Create a new Chaincraft node

pub fn default() -> Self

Create a new Chaincraft node with default settings

pub fn new_default() -> Self

Create a new Chaincraft node with default settings (alias for compatibility with examples)

pub fn builder() -> ChaincraftNodeBuilder

Create a new node builder

pub async fn start(&mut self) -> Result<()>

Start the node

pub async fn stop(&mut self) -> Result<()>

Stop the node

pub async fn close(&mut self) -> Result<()>

Close the node (alias for stop)

pub async fn is_running_async(&self) -> bool

Check if the node is running (async version)

pub async fn add_peer(&self, peer: PeerInfo) -> Result<()>

Add a peer to the node’s peer list. Rejects if peer address is banned.

pub async fn remove_peer(&self, peer_id: &PeerId) -> Result<()>

Remove a peer from the node’s peer list

pub async fn ban_peer( &self, addr: SocketAddr, duration: Option<Duration>, ) -> Result<()>

Ban a peer address for a duration. Persisted to storage.

pub async fn unban_peer(&self, addr: SocketAddr) -> Result<()>

Unban a peer address. Persisted to storage.

pub async fn is_banned(&self, addr: SocketAddr) -> bool

Check if an address is banned

pub async fn connect_to_peer(&mut self, peer_addr: &str) -> Result<()>

Connect to a peer

pub async fn connect_to_peer_with_discovery( &mut self, peer_addr: &str, _discovery: bool, ) -> Result<()>

Connect to a peer with optional discovery

pub async fn get_peers(&self) -> Vec<PeerInfo>

Get all connected peers

pub fn peers(&self) -> Vec<PeerInfo>

Get connected peers synchronously (for compatibility)

pub fn id(&self) -> &PeerId

Get the node’s ID

pub fn port(&self) -> u16

Get the node’s port

pub fn host(&self) -> &str

Get the node’s host

pub fn max_peers(&self) -> usize

Get maximum peers

pub async fn create_shared_message(&mut self, data: String) -> Result<String>

Create a shared message

pub fn has_object(&self, _hash: &str) -> bool

Check if the node has a specific object

pub async fn get_object(&self, hash: &str) -> Result<String>

Get an object by hash

pub fn db_size(&self) -> usize

Get the database size

pub async fn add_shared_object( &self, object: Box<dyn ApplicationObject>, ) -> Result<SharedObjectId>

Add a shared object (application object)

pub async fn shared_objects(&self) -> Vec<Box<dyn ApplicationObject>>

Get shared objects (for compatibility with Python tests)

pub async fn shared_object_count(&self) -> usize

Get shared object count

pub async fn create_shared_message_with_data( &mut self, data: Value, ) -> Result<String>

Create shared message with application object processing

pub async fn get_state(&self) -> Result<Value>

Get node state for testing/debugging

pub async fn get_discovery_info(&self) -> Value

Get discovery info for testing

pub fn set_port(&mut self, port: u16)

Set port for testing

pub fn disable_local_discovery(&mut self)

Disable local discovery (for single-node tests)

pub fn is_running(&self) -> bool

Check if node is running (sync version for compatibility)