Struct Processor 

pub struct Processor {
    pub swarm: Arc<Swarm>,
    /* private fields */
}

Processor for rings-node rpc server.

Cloning shares the same node handle; publishes from any clone are serialized against each other.

Fields

swarm: Arc<Swarm>

a swarm instance

Implementations

impl Processor

pub fn did(&self) -> Did

Get current did

pub async fn publish_online_node_descriptor( &self, ) -> Result<OnlineNodeDescriptor>

Publish this node’s signed online descriptor to the online-node registry.

pub async fn lookup_online_nodes( &self, include_expired: bool, ) -> Result<Vec<OnlineNodeDescriptor>>

List signed online-node descriptors from the registry.

pub async fn lookup_onion_exits( &self, service: &str, include_expired: bool, ) -> Result<Vec<OnionExitDescriptor>>

List signed onion-exit descriptors from the application-layer exit registry.

pub async fn build_onion_route( &self, service: String, hop_count: usize, allow_short_paths: bool, ) -> Result<OnionRoute>

Build an onion route from live presence descriptors and live exit descriptors.

pub async fn build_onion_proxy_route( &self, proxy: OnionProxyConfig, target: OnionProxyTarget, ) -> Result<OnionProxyRoute>

Build an onion proxy route for a client target through a target-agnostic proxy config.

pub async fn listen(&self)

Run stabilization and node registration tasks until this future is dropped or aborted.

This is a long-running task; do not await completion as a readiness signal.

pub async fn listen_with(&self, stop: StopToken)

Run stabilization and node registration tasks until stop asks them to exit.

The shutdown is cooperative: it waits for the current stabilization or registration operation to finish before returning. This avoids dropping browser IndexedDB request futures while their JavaScript callbacks are still pending.

pub async fn flush_measurements(&self) -> Result<()>

Flush all applied measurement updates with the graceful-shutdown deadline.

pub async fn connect_with_did(&self, did: Did) -> Result<()>

Connect peer with web3 did. There are 3 peers: PeerA, PeerB, PeerC.

1. PeerA has a connection with PeerB.
2. PeerC has a connection with PeerB.
3. PeerC can connect PeerA with PeerA’s web3 address.

This operation is idempotent: if topology convergence already produced the direct connection, the requested connection is satisfied.

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

Disconnect a peer with web3 did.

pub async fn send_message(&self, destination: Did, msg: &[u8]) -> Result<Uuid>

Send custom message to a did.

pub async fn send_direct_message( &self, destination: Did, msg: &[u8], ) -> Result<Uuid>

Send a custom message to an already connected peer without Chord routing.

Protocols with their own authenticated hop selection, such as onion circuits, use this to keep the core transport from replacing their selected next hop.

pub async fn send_e2e_handshake(&self, destination: Did) -> Result<Uuid>

Send an E2E handshake request to a DID.

The negotiated key is the peer’s account/identity secp256k1 key, not the ephemeral session key.

pub async fn send_e2e_message( &self, destination: Did, recipient_public_key: PublicKey<33>, msg: &[u8], ) -> Result<Uuid>

Send an ElGamal-encrypted E2E message to a DID with a verified recipient key.

Returns the stream id shared by all emitted E2E stream frames.

pub async fn send_e2e_message_with_frame_len( &self, destination: Did, recipient_public_key: PublicKey<33>, msg: &[u8], max_plaintext_frame_len: usize, ) -> Result<Uuid>

Send an ElGamal-encrypted E2E stream with an explicit plaintext frame size.

Returns the stream id shared by all emitted E2E stream frames.

pub fn verify_e2e_handshake_request( &self, requester: Did, request: &E2eHandshakeRequest, ) -> Result<PublicKey<33>>

Verify an E2E handshake request and return the requester’s identity public key.

pub fn verify_e2e_handshake_response( &self, responder: Did, response: &E2eHandshakeResponse, ) -> Result<PublicKey<33>>

Verify an E2E handshake response and return the responder’s identity public key.

pub fn e2e_stream_decryptor( &self, expected_sender: Did, stream_id: E2eStreamId, recipient_identity_key: SecretKey, ) -> Result<E2eStreamDecryptor>

Create an E2E stream decryptor with this node’s identity/signing secret key.

The ciphertext is encrypted to the DID/account key negotiated by the handshake. A session private key cannot decrypt it unless the session key is also the account key, so callers must supply the local identity key explicitly.

pub fn decrypt_e2e_stream_frame( &self, decryptor: &mut E2eStreamDecryptor, frame: &E2eStreamFrame, ) -> Result<Vec<u8>>

Decrypt one E2E stream frame with an already-created stream decryptor.

pub async fn send_envelope( &self, destination: Did, envelope: &Envelope, ) -> Result<Uuid>

Send a namespaced Envelope to a did over the P2P transport (the wire codec of the extension layer). send_envelope : (Did, Envelope) → IO TxId.

pub async fn send_direct_envelope( &self, destination: Did, envelope: &Envelope, ) -> Result<Uuid>

Send a namespaced envelope directly to an already connected peer.

This bypasses Chord routing while retaining the normal custom-message envelope codec.

pub async fn storage_check_cache(&self, entry_key: Did) -> Option<Entry>

check local cache of dht

pub async fn storage_fetch(&self, entry_key: Did) -> Result<()>

Fetch an entry from DHT storage

pub async fn storage_store(&self, entry: Entry) -> Result<()>

Store an entry on DHT storage

pub async fn storage_append_data( &self, topic: &str, data: Encoded, ) -> Result<()>

Append data to an entry on DHT storage

pub async fn storage_touch_data(&self, topic: &str, data: Encoded) -> Result<()>

Touch data in an entry on DHT storage, moving existing equal payloads to the end.

pub async fn storage_tombstone_data( &self, topic: &str, data: Encoded, ) -> Result<()>

Tombstone observed data in an entry on DHT storage.

pub async fn storage_compact_data( &self, topic: &str, removals: Vec<Encoded>, ) -> Result<()>

Compact observed data in an entry on DHT storage.

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

Return local measurement counters for a 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: NonZeroUsize, ) -> PeerMeasurementPage

Return one bounded page of retained local peer measurements.

pub async fn register_service(&self, name: &str) -> Result<()>

register service

pub async fn get_node_info(&self) -> Result<NodeInfoResponse>

get node info

Trait Implementations

impl Clone for Processor

fn clone(&self) -> Processor

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl HandleRpc<AcceptAnswerRequest, AcceptAnswerResponse> for Processor

fn handle_rpc<'life0, 'async_trait>( &'life0 self, req: AcceptAnswerRequest, ) -> Pin<Box<dyn Future<Output = Result<AcceptAnswerResponse>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Handle rpc request and return response.

impl HandleRpc<AnswerOfferRequest, AnswerOfferResponse> for Processor

fn handle_rpc<'life0, 'async_trait>( &'life0 self, req: AnswerOfferRequest, ) -> Pin<Box<dyn Future<Output = Result<AnswerOfferResponse>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Handle rpc request and return response.

impl HandleRpc<BuildOnionRouteRequest, BuildOnionRouteResponse> for Processor

fn handle_rpc<'life0, 'async_trait>( &'life0 self, req: BuildOnionRouteRequest, ) -> Pin<Box<dyn Future<Output = Result<BuildOnionRouteResponse>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Handle rpc request and return response.

impl HandleRpc<ConnectPeerViaHttpRequest, ConnectPeerViaHttpResponse> for Processor

fn handle_rpc<'life0, 'async_trait>( &'life0 self, req: ConnectPeerViaHttpRequest, ) -> Pin<Box<dyn Future<Output = Result<ConnectPeerViaHttpResponse>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Handle rpc request and return response.

impl HandleRpc<ConnectWithDidRequest, ConnectWithDidResponse> for Processor

fn handle_rpc<'life0, 'async_trait>( &'life0 self, req: ConnectWithDidRequest, ) -> Pin<Box<dyn Future<Output = Result<ConnectWithDidResponse>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Handle rpc request and return response.

impl HandleRpc<ConnectWithSeedRequest, ConnectWithSeedResponse> for Processor

fn handle_rpc<'life0, 'async_trait>( &'life0 self, req: ConnectWithSeedRequest, ) -> Pin<Box<dyn Future<Output = Result<ConnectWithSeedResponse>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Handle rpc request and return response.

impl HandleRpc<CreateOfferRequest, CreateOfferResponse> for Processor

fn handle_rpc<'life0, 'async_trait>( &'life0 self, req: CreateOfferRequest, ) -> Pin<Box<dyn Future<Output = Result<CreateOfferResponse>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Handle rpc request and return response.

impl HandleRpc<DisconnectRequest, DisconnectResponse> for Processor

fn handle_rpc<'life0, 'async_trait>( &'life0 self, req: DisconnectRequest, ) -> Pin<Box<dyn Future<Output = Result<DisconnectResponse>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Handle rpc request and return response.

impl HandleRpc<FetchTopicMessagesRequest, FetchTopicMessagesResponse> for Processor

fn handle_rpc<'life0, 'async_trait>( &'life0 self, req: FetchTopicMessagesRequest, ) -> Pin<Box<dyn Future<Output = Result<FetchTopicMessagesResponse>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Handle rpc request and return response.

impl HandleRpc<ListPeerMeasurementsRequest, ListPeerMeasurementsResponse> for Processor

fn handle_rpc<'life0, 'async_trait>( &'life0 self, req: ListPeerMeasurementsRequest, ) -> Pin<Box<dyn Future<Output = Result<ListPeerMeasurementsResponse>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Handle rpc request and return response.

impl HandleRpc<ListPeersRequest, ListPeersResponse> for Processor

fn handle_rpc<'life0, 'async_trait>( &'life0 self, _req: ListPeersRequest, ) -> Pin<Box<dyn Future<Output = Result<ListPeersResponse>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Handle rpc request and return response.

impl HandleRpc<LookupOnionExitsRequest, LookupOnionExitsResponse> for Processor

fn handle_rpc<'life0, 'async_trait>( &'life0 self, req: LookupOnionExitsRequest, ) -> Pin<Box<dyn Future<Output = Result<LookupOnionExitsResponse>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Handle rpc request and return response.

impl HandleRpc<LookupOnlineNodesRequest, LookupOnlineNodesResponse> for Processor

fn handle_rpc<'life0, 'async_trait>( &'life0 self, req: LookupOnlineNodesRequest, ) -> Pin<Box<dyn Future<Output = Result<LookupOnlineNodesResponse>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Handle rpc request and return response.

impl HandleRpc<LookupServiceRequest, LookupServiceResponse> for Processor

fn handle_rpc<'life0, 'async_trait>( &'life0 self, req: LookupServiceRequest, ) -> Pin<Box<dyn Future<Output = Result<LookupServiceResponse>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Handle rpc request and return response.

impl HandleRpc<NodeDidRequest, NodeDidResponse> for Processor

fn handle_rpc<'life0, 'async_trait>( &'life0 self, _req: NodeDidRequest, ) -> Pin<Box<dyn Future<Output = Result<NodeDidResponse>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Handle rpc request and return response.

impl HandleRpc<NodeInfoRequest, NodeInfoResponse> for Processor

fn handle_rpc<'life0, 'async_trait>( &'life0 self, _req: NodeInfoRequest, ) -> Pin<Box<dyn Future<Output = Result<NodeInfoResponse>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Handle rpc request and return response.

impl HandleRpc<PeerMeasurementRequest, PeerMeasurementResponse> for Processor

fn handle_rpc<'life0, 'async_trait>( &'life0 self, req: PeerMeasurementRequest, ) -> Pin<Box<dyn Future<Output = Result<PeerMeasurementResponse>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Handle rpc request and return response.

impl HandleRpc<PublishMessageToTopicRequest, PublishMessageToTopicResponse> for Processor

fn handle_rpc<'life0, 'async_trait>( &'life0 self, req: PublishMessageToTopicRequest, ) -> Pin<Box<dyn Future<Output = Result<PublishMessageToTopicResponse>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Handle rpc request and return response.

impl HandleRpc<RegisterServiceRequest, RegisterServiceResponse> for Processor

fn handle_rpc<'life0, 'async_trait>( &'life0 self, req: RegisterServiceRequest, ) -> Pin<Box<dyn Future<Output = Result<RegisterServiceResponse>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Handle rpc request and return response.

impl HandleRpc<SendBackendMessageRequest, SendBackendMessageResponse> for Processor

fn handle_rpc<'life0, 'async_trait>( &'life0 self, req: SendBackendMessageRequest, ) -> Pin<Box<dyn Future<Output = Result<SendBackendMessageResponse>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Handle rpc request and return response.

impl HandleRpc<SendE2eHandshakeRequest, SendE2eHandshakeResponse> for Processor

fn handle_rpc<'life0, 'async_trait>( &'life0 self, req: SendE2eHandshakeRequest, ) -> Pin<Box<dyn Future<Output = Result<SendE2eHandshakeResponse>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Handle rpc request and return response.

impl HandleRpc<SendE2eMessageRequest, SendE2eMessageResponse> for Processor

fn handle_rpc<'life0, 'async_trait>( &'life0 self, req: SendE2eMessageRequest, ) -> Pin<Box<dyn Future<Output = Result<SendE2eMessageResponse>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Handle rpc request and return response.