Struct sn_client::WalletClient

pub struct WalletClient { /* private fields */ }

A wallet client can be used to send and receive tokens to and from other wallets.

Implementations

impl WalletClient

pub fn new(client: Client, wallet: HotWallet) -> Self

Create a new wallet client.

Arguments

• client - A instance of the struct sn_client::Client
• wallet - An instance of the struct HotWallet

Example

use sn_client::{Client, WalletClient, Error};
use tempfile::TempDir;
use bls::SecretKey;
use sn_transfers::{HotWallet, MainSecretKey};
let client = Client::new(SecretKey::random(), None, None, None).await?;
let tmp_path = TempDir::new()?.path().to_owned();
let mut wallet = HotWallet::load_from_path(&tmp_path,Some(MainSecretKey::new(SecretKey::random())))?;
let mut wallet_client = WalletClient::new(client, wallet);

pub fn store_local_wallet(&mut self) -> WalletResult<()>

Stores the wallet to the local wallet directory.

Example

let mut wallet_client = WalletClient::new(client, wallet);
wallet_client.store_local_wallet()?;

pub fn balance(&self) -> NanoTokens

Display the wallet balance

Example

// Display the wallet balance in the terminal
let mut wallet_client = WalletClient::new(client, wallet);
println!("{}" ,wallet_client.balance());

pub fn unconfirmed_spend_requests_exist(&self) -> bool

See if any unconfirmed transactions exist.

Example

// Print unconfirmed spends to the terminal
let mut wallet_client = WalletClient::new(client, wallet);
if wallet_client.unconfirmed_spend_requests_exist() {println!("Unconfirmed spends exist!")};

pub fn get_recent_payment_for_addr( &self, address: &NetworkAddress ) -> WalletResult<(Payment, PeerId)>

Returns the most recent cached Payment for a provided NetworkAddress. This function does not check if the quote has expired or not. Use get_non_expired_payment_for_addr if you want to get a non expired one.

If multiple payments have been made to the same address, then we pick the last one as it is the most recent.

Arguments

• address - The NetworkAddress.

Example

// Getting the payment for an address using a random PeerId
use libp2p_identity::PeerId;
use sn_protocol::NetworkAddress;

let mut wallet_client = WalletClient::new(client, wallet);
let network_address = NetworkAddress::from_peer(PeerId::random());
let payment = wallet_client.get_recent_payment_for_addr(&network_address)?;

pub fn get_all_payments_for_addr( &self, address: &NetworkAddress ) -> WalletResult<Vec<(Payment, PeerId)>>

Returns the all cached Payment for a provided NetworkAddress.

Arguments

• address - The NetworkAddress.

Example

// Getting the payment for an address using a random PeerId
use libp2p_identity::PeerId;
use sn_protocol::NetworkAddress;

let mut wallet_client = WalletClient::new(client, wallet);
let network_address = NetworkAddress::from_peer(PeerId::random());
let payments = wallet_client.get_all_payments_for_addr(&network_address)?;

pub fn remove_payment_for_addr( &self, address: &NetworkAddress ) -> WalletResult<()>

Remove the payment for a given network address from disk.

Arguments

• address - The NetworkAddress.

Example

// Removing a payment address using a random PeerId
use libp2p_identity::PeerId;
use sn_protocol::NetworkAddress;

let mut wallet_client = WalletClient::new(client, wallet);
let network_address = NetworkAddress::from_peer(PeerId::random());
let payment = wallet_client.remove_payment_for_addr(&network_address)?;

pub async fn send_cash_note( &mut self, amount: NanoTokens, to: MainPubkey, verify_store: bool ) -> WalletResult<CashNote>

Send tokens to another wallet. Can also verify the store has been successful. Verification will be attempted via GET request through a Spend on the network.

Arguments

• amount - NanoTokens.
• to - MainPubkey.
• verify_store - A boolean to verify store. Set this to true for mandatory verification.

Example

use sn_transfers::NanoTokens;
let mut wallet_client = WalletClient::new(client, wallet);
let nano = NanoTokens::from(10);
let main_pub_key = MainSecretKey::random().main_pubkey();
let payment = wallet_client.send_cash_note(nano,main_pub_key, true);

pub async fn get_store_cost_at_address( &self, address: NetworkAddress ) -> WalletResult<PayeeQuote>

Get storecost from the network Returns the MainPubkey of the node to pay and the price in NanoTokens

Arguments

• content_addrs - Iterator<Items = NetworkAddress>

Returns:

• WalletResult<StoragePaymentResult>

Example

 use sn_protocol::NetworkAddress;
 use libp2p_identity::PeerId;
 use sn_registers::{Permissions, RegisterAddress};
 let client = Client::new(SecretKey::random(), None, None, None).await?;
 let mut wallet = HotWallet::load_from_path(&tmp_path,Some(MainSecretKey::new(SecretKey::random())))?;
 let network_address = NetworkAddress::from_peer(PeerId::random());
 let mut wallet_client = WalletClient::new(client, wallet);
 // Use get_store_cost_at_address(network_address) to get a storecost from the network.
 let cost = wallet_client.get_store_cost_at_address(network_address).await?.2.cost.as_nano();

pub async fn pay_for_storage( &mut self, content_addrs: impl Iterator<Item = NetworkAddress> ) -> WalletResult<StoragePaymentResult>

Send tokens to nodes closest to the data we want to make storage payment for. Runs mandatory verification.

Arguments

• content_addrs - Iterator<Items = NetworkAddress>

Returns:

• WalletResult<StoragePaymentResult>

Example

 use sn_protocol::NetworkAddress;
 use sn_registers::{Permissions, RegisterAddress};
 let client = Client::new(SecretKey::random(), None, None, None).await?;
 let mut wallet_client = WalletClient::new(client.clone(), wallet);
 let mut rng = rand::thread_rng();
 let xor_name = XorName::random(&mut rng);
 let address = RegisterAddress::new(xor_name, client.signer_pk());
 let net_addr = NetworkAddress::from_register_address(address);

 // Paying for a random Register Address
 let cost = wallet_client.pay_for_storage(std::iter::once(net_addr)).await?;

pub async fn pay_for_records( &mut self, cost_map: &BTreeMap<XorName, (MainPubkey, PaymentQuote, Vec<u8>)>, verify_store: bool ) -> WalletResult<(NanoTokens, NanoTokens)>

Send tokens to nodes closest to the data that we want to make storage payments for.

Returns:

• WalletResult<(NanoTokens, NanoTokens)>

This return contains the amount paid for storage. Including the network royalties fee paid.

Params:

• cost_map - BTreeMap(XorName,(MainPubkey, PaymentQuote))
• verify_store - This optional check can verify if the store has been successful.

Verification will be attempted via GET request through a Spend on the network.

Example

 use xor_name::XorName;
 use sn_transfers::{MainPubkey, Payment, PaymentQuote};
 let client = Client::new(SecretKey::random(), None, None, None).await?;
 let mut wallet_client = WalletClient::new(client, wallet);
 let mut cost_map:BTreeMap<XorName,(MainPubkey,PaymentQuote,Vec<u8>)> = BTreeMap::new();
 wallet_client.pay_for_records(&cost_map,true).await?;

pub fn into_wallet(self) -> HotWallet

Returns the wallet:

Return type: HotWallet

Example

let mut wallet_client = WalletClient::new(client, wallet);
let paying_wallet = wallet_client.into_wallet();
// Display the wallet balance in the terminal
println!("{}",paying_wallet.balance());

pub fn mut_wallet(&mut self) -> &mut HotWallet

Returns a mutable wallet instance

Return type: HotWallet

Example

let mut wallet_client = WalletClient::new(client, wallet);
let paying_wallet = wallet_client.mut_wallet();
// Display the mutable wallet balance in the terminal
println!("{}",paying_wallet.balance());