Struct Swarm 

pub struct Swarm { /* private fields */ }

The transport and dht management.

Implementations

impl Swarm

pub fn did(&self) -> Did

Get did of self.

pub fn account_pubkey(&self) -> Result<PublicKey<33>, Error>

Get the local account public key used for E2E public-key negotiation.

pub fn account_verification_pubkey( &self, ) -> Result<VerificationPublicKey, Error>

Get the typed account verification public key.

pub fn network_id(&self) -> u32

Get this swarm’s network id.

pub fn storage_redundancy(&self) -> u16

Get the storage redundancy for this swarm’s DHT protocol mode.

pub fn dht_virtual_nodes(&self) -> u16

Get the storage virtual-node positions for this swarm’s DHT protocol mode.

pub fn dht_protocol_mode(&self) -> DhtProtocolMode

Get this swarm’s full DHT protocol mode descriptor.

pub fn dht(&self) -> Arc<PeerRing>

Get DHT(Distributed Hash Table) of self.

pub fn set_callback( &self, callback: Arc<dyn SwarmCallback + Sync + Send>, ) -> Result<(), Error>

Set callback for swarm.

pub fn stabilizer(&self) -> Stabilizer

Create Stabilizer for swarm.

pub async fn disconnect(&self, peer: Did) -> Result<(), Error>

Disconnect a connection. There are three steps:

1. remove from DHT;
2. remove from Transport;
3. close the connection;

pub async fn connect(&self, peer: Did) -> Result<(), Error>

Start a non-routable handshake with a peer.

The peer becomes visible through the connection inspection APIs only after its data channel opens and the swarm admits it to the DHT.

pub async fn send_message( &self, msg: Message, destination: Did, ) -> Result<Uuid, Error>

Send Message to peer.

pub async fn send_direct_message( &self, msg: Message, destination: Did, ) -> Result<Uuid, Error>

Send a message directly to an already connected peer, without a Chord lookup.

This preserves an application protocol’s explicit next-hop selection. Callers must ensure the destination has an active direct transport connection.

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

List active, routable peers and their connection status.

pub fn peer_dids(&self) -> Vec<Did>

List DIDs with active, routable transport connections.

pub fn connected_peer_dids(&self) -> Vec<Did>

List DIDs whose direct WebRTC transport connection is active.

pub async fn peer_measurement(&self, peer: Did) -> Option<PeerMeasurement>

Return local measurement counters for peer, if observed.

pub async fn peer_measurements(&self) -> Vec<PeerMeasurement>

Return every retained local peer measurement.

pub async fn peer_measurements_page( &self, after: Option<Did>, limit: NonZero<usize>, ) -> PeerMeasurementPage

Return one bounded page of retained local peer measurements.

pub async fn inspect(&self) -> SwarmInspect

Check the status of swarm

impl Swarm

pub async fn create_offer(&self, peer: Did) -> Result<MessagePayload, Error>

Create new connection and its answer. This function will wrap the offer inside a payload with verification.

pub async fn answer_offer( &self, offer_payload: MessagePayload, ) -> Result<MessagePayload, Error>

Answer the offer of remote connection. This function will verify the answer payload and will wrap the answer inside a payload with verification.

pub async fn accept_answer( &self, answer_payload: MessagePayload, ) -> Result<(), Error>

Accept the answer of remote connection. This function will verify the answer payload and will return its did with the connection.

Trait Implementations

impl<const REDUNDANT: u16> ChordStorageInterface<REDUNDANT> for Swarm

fn storage_fetch<'life0, 'async_trait>( &'life0 self, entry_key: Did, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Swarm: 'async_trait,

Fetch an entry. If it exists in local storage, copy it to the cache; otherwise query the responsible remote node.

fn storage_store<'life0, 'async_trait>( &'life0 self, entry: Entry, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Swarm: 'async_trait,

Store Entry, TryInto<Entry> is implemented for alot of types

fn storage_append_data<'life0, 'life1, 'async_trait>( &'life0 self, topic: &'life1 str, data: Encoded, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Swarm: 'async_trait,

Append data to a Data kind entry.

fn storage_touch_data<'life0, 'life1, 'async_trait>( &'life0 self, topic: &'life1 str, data: Encoded, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Swarm: 'async_trait,

Append data to a Data kind entry uniquely.

fn storage_tombstone_data<'life0, 'life1, 'async_trait>( &'life0 self, topic: &'life1 str, data: Encoded, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Swarm: 'async_trait,

Tombstone observed data in a Data kind entry.

fn storage_compact_data<'life0, 'life1, 'async_trait>( &'life0 self, topic: &'life1 str, removals: Vec<Encoded>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Swarm: 'async_trait,

Compact a Data kind entry after removing listed payloads.

impl ChordStorageInterfaceCacheChecker for Swarm

fn storage_check_cache<'life0, 'async_trait>( &'life0 self, entry_key: Did, ) -> Pin<Box<dyn Future<Output = Option<Entry>> + Send + 'async_trait>>

where 'life0: 'async_trait, Swarm: 'async_trait,

Check local cache