Struct safe_network::client::client_api::Client

pub struct Client { /* fields omitted */ }

Client object

Implementations

impl Client

pub async fn read_blob(
    &self,
    head_address: ChunkAddress,
    position: Option<usize>,
    len: Option<usize>
) -> Result<Vec<u8>, Error> where
    Self: Sized, 

Read the contents of a blob from the network. The contents might be spread across different chunks in the network. This function invokes the self-encryptor and returns the data that was initially stored.

Takes position and len arguments which specify the start position and the length of bytes to be read. Passing None to position reads the data from the beginning. Passing None to length reads the full length of the data.

Examples

TODO: update once data types are crdt compliant

pub async fn store_public_blob(
    &self,
    data: &[u8]
) -> Result<ChunkAddress, Error>

Store data in public chunks on the network.

This performs self encrypt on the data itself and returns a single address pointing to the head chunk of the blob, and with which the data can be read. It performs data storage as well as all necessary payment validation and checks against the client’s AT2 actor.

Examples

TODO: update once data types are crdt compliant

pub async fn store_private_blob(
    &self,
    data: &[u8]
) -> Result<ChunkAddress, Error>

Store data in private chunks on the network.

This performs self encrypt on the data itself and returns a single address pointing to the head chunk of the blob, and with which the data can be read. It performs data storage as well as all necessary payment validation and checks against the client’s AT2 actor.

Examples

TODO: update once data types are crdt compliant

pub async fn clear_blob_cache(&mut self)

Clear the client’s blob cache

pub async fn delete_blob(&self, head_chunk: ChunkAddress) -> Result<(), Error>

Delete blob can only be performed on private chunks. But on those private chunks this will remove the data from the network.

Examples

TODO: update once data types are crdt compliant

pub async fn blob_data_map(
    data: Vec<u8>,
    privately_owned: Option<PublicKey>
) -> Result<(DataMap, ChunkAddress), Error>

Uses self_encryption to generate an encrypted Blob serialized data map, without connecting and/or writing to the network.

impl Client

pub async fn send_signed_command(
    &self,
    cmd: DataCmd,
    client_pk: PublicKey,
    serialised_cmd: Bytes,
    signature: Signature
) -> Result<(), Error>

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

impl Client

pub async fn store_private_register(
    &self,
    name: XorName,
    tag: u64,
    owner: PublicKey,
    permissions: BTreeMap<PublicKey, PrivatePermissions>
) -> Result<Address, Error>

Create a Private Register onto the Network

Creates a private Register on the network which can then be written to. Private data can be removed from the network at a later date.

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

pub async fn store_public_register(
    &self,
    name: XorName,
    tag: u64,
    owner: PublicKey,
    permissions: BTreeMap<User, PublicPermissions>
) -> Result<Address, Error>

Create a Public Register onto the Network

Creates a public Register on the network which can then be written to. Public data can not be removed from the network at a later date.

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

pub async fn delete_register(&self, address: Address) -> Result<(), Error>

Delete Register

You’re only able to delete a PrivateRegister. Public data can no be removed from the network.

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

Write to Register

Public or private isn’t important for writing, though the data you write will be Public or Private according to the type of the targeted Register.

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

Get a Register from the Network

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

Get the last data entry from a Register data.

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

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

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

Get the owner of a Register.

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

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

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

Get the Policy of a Register.

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 new(
    optional_keypair: Option<Keypair>,
    config_file_path: Option<&Path>,
    bootstrap_config: Option<HashSet<SocketAddr>>,
    query_timeout: u64
) -> Result<Self, Error>

Create a Safe Network client instance. Either for an existing SecretKey (in which case) the client will attempt to retrieve the history of the key’s balance in order to be ready for any token operations. Or if no SecreteKey is passed, a random keypair will be used, which provides a client that can only perform Read operations (at least until the client’s SecretKey receives some token).

Examples

TODO: update once data types are crdt compliant

pub fn keypair(&self) -> Keypair

Return the client’s FullId.

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

Examples

TODO: update once data types are crdt compliant

pub fn public_key(&self) -> PublicKey

Return the client’s PublicKey.

Examples

TODO: update once data types are crdt compliant

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.