Struct Processor 

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

Processor for rings-node rpc server

Fields

swarm: Arc<Swarm>

a swarm instance

Implementations

impl Processor

pub fn did(&self) -> Did

Get current did

pub async fn listen(&self)

Run stabilization daemon

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.

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_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 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 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<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<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<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<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.