Struct sn_client::api::Client

pub struct Client { /* private fields */ }

Client object

Implementations

impl Client

pub fn sign(&self, data: &[u8]) -> Signature

Sign data using the client keypair

pub async fn send_signed_cmd( &self, dst_address: XorName, client_pk: PublicKey, serialised_cmd: Bytes, signature: Signature, is_spend_cmd: bool ) -> Result<()>

Send a signed DataCmd to the network. This is part of the public API, for the user to provide the serialised and already signed cmd.

pub async fn send_cmd(&self, cmd: DataCmd) -> Result<()>

Public API to send a DataCmd to the network. The provided DataCmd is serialised and signed with the keypair this Client instance has been setup with.

impl Client

pub async fn read_bytes(&self, address: XorName) -> Result<Bytes>

Reads Bytes from the network, whose contents are contained within on or more chunks.

pub async fn read_bytes_from_replicas( &self, name: XorName, replicas: &[usize] ) -> Result<Vec<QueriedDataReplicas>>

Reads Bytes from the network, querying each of the data replicas which match any of the indexes provided.

pub async fn read_from( &self, address: XorName, position: usize, length: usize ) -> Result<Bytes>where Self: Sized,

Read bytes from the network. The contents are spread across multiple chunks in the network. This function invokes the self-encryptor and returns the data that was initially stored.

Takes position and length arguments which specify the start position and the length of bytes to be read. Passing 0 to position reads the data from the beginning, and the length is just an upper limit.

pub fn chunk_bytes(bytes: Bytes) -> Result<(XorName, Vec<Chunk>)>

Tries to chunk the bytes, returning an address and chunks, without storing anything to network.

pub async fn upload(&self, bytes: Bytes) -> Result<XorName>

Directly writes Bytes to the network in the form of immutable chunks, without any batching.

pub async fn upload_and_verify(&self, bytes: Bytes) -> Result<XorName>

Directly writes Bytes to the network in the form of immutable chunks, without any batching. It also attempts to verify that all the data was uploaded to the network before returning. It does this via running read_bytes with each chunk with query_timeout set.

pub fn calculate_address(bytes: Bytes) -> Result<XorName>

Calculates a LargeFile’s/SmallFile’s address from self encrypted chunks, without storing them onto the network.

impl Client

pub async fn send_query(&self, query: DataQuery) -> Result<QueryResponse>

Send a Query to the network and await a response. Queries are automatically retried using exponential backoff if the timeout is hit.

pub async fn send_query_without_retry( &self, query: DataQuery ) -> Result<QueryResponse>

Send a Query to the network and await a response. Queries are not retried if the timeout is hit.

pub async fn send_signed_query( &self, query: DataQuery, query_index: usize, client_pk: PublicKey, serialised_query: Bytes, signature: Signature ) -> Result<QueryResponse>

Send a Query to the network and await a response. This is part of a public API, for the user to provide the serialised and already signed query.

pub async fn send_query_to_replicas( &self, query: DataQuery, replicas: &[usize] ) -> Result<Vec<(usize, Result<QueryResponse>)>, Error>

Send a Query to the network and await a response. Queries are sent once per each replica, i.e. it sends the query targeting the replicas (using node_index) matching the indexes provided.

impl Client

pub async fn publish_register_ops( &self, wal: RegisterWriteAheadLog ) -> Result<()>

Publish all register mutation operations in a WAL to the network Incrementing the WAL index as successful writes are sent out. Stops at the first error. Starts publishing from the index when called again with the same WAL.

pub async fn create_register( &self, name: XorName, tag: u64, policy: Policy ) -> Result<(Address, RegisterWriteAheadLog)>

Creates a Register which can then be written to.

Returns a write ahead log (WAL) of register operations, note that the changes are not uploaded to the network until the WAL is published with publish_register_ops

A tag must be supplied. A xorname must be supplied, this can be random or deterministic as per your apps needs.

pub async fn write_to_local_register( &self, address: Address, entry: Entry, children: BTreeSet<EntryHash> ) -> Result<(EntryHash, RegisterWriteAheadLog)>

Write to Register

Returns a write ahead log (WAL) of register operations, note that the changes are not uploaded to the network until the WAL is published with publish_register_ops

pub async fn get_register(&self, address: Address) -> Result<Register>

Get the entire Register from the Network

pub async fn read_register( &self, address: Address ) -> Result<BTreeSet<(EntryHash, Entry)>>

Get the latest entry (or entries if branching)

pub async fn get_register_entry( &self, address: Address, hash: EntryHash ) -> Result<Entry>

Get an entry from a Register on the Network by its hash

pub async fn get_register_owner(&self, address: Address) -> Result<User>

Get the owner of a Register.

pub async fn get_register_permissions_for_user( &self, address: Address, user: User ) -> Result<Permissions>

Get the set of Permissions in a Register for a specific user.

pub async fn get_register_policy(&self, address: Address) -> Result<Policy>

Get the Policy of a Register.

impl Client

pub async fn spend_dbc( &self, public_key: PublicKey, tx: DbcTransaction, spent_proofs: BTreeSet<SpentProof>, spent_transactions: BTreeSet<DbcTransaction> ) -> Result<()>

Spend a DBC’s public key.

It’s possible that the section processing the spend request will not be aware of the section keys used to sign the spent proofs. If this is the case, the network will return a particular error and we will retry. There are several retries because there could be several keys the section is not aware of, but it only returns back the first one it encounters.

When the request is resubmitted, it gets sent along with a proof chain and a signed SAP that the section can use to update itself.

pub async fn spent_proof_shares( &self, public_key: PublicKey ) -> Result<Vec<SpentProofShare>>

Return the set of spent proof shares if the provided DBC’s public key is spent

impl Client

Easily manage connections to/from The Safe Network with the client and its APIs. Use a random client for read-only or one-time operations. Supply an existing, SecretKey which holds a SafeCoin balance to be able to perform write operations.

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

Bootstrap this client to the network.

In case of an existing SecretKey the client will attempt to retrieve the history of the key’s balance in order to be ready for any token operations.

pub fn keypair(&self) -> &Keypair

Return the client’s keypair.

Useful for retrieving the PublicKey or KeyPair in the event you need to sign something

pub fn public_key(&self) -> PublicKey

Return the client’s PublicKey.

pub fn dbc_owner(&self) -> &Owner

Return the client’s DBC owner, which will be a secret key.

This can then be used to sign output DBCs during a DBC reissue.

pub async fn is_known_section_key(&self, section_key: &PublicKey) -> bool

Check if the provided public key is a known section key based on our current knowledge of the network and sections chains.

pub async fn section_tree(&self) -> SectionTree

SectionTree used to bootstrap the client on the network.

This is updated by the client as it receives Anti-Entropy/update messages from the network. Any user of this API is responsible for caching it so it can use it for any new Client instance not needing to obtain all this information from the network all over again.

pub fn builder() -> ClientBuilder

Create a builder to instantiate a Client

Trait Implementations

impl Clone for Client

fn clone(&self) -> Client

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Client

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.