Struct 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 async fn resend_pending_transaction_blocking_loop( &mut self, ) -> WalletResult<()>

This is a blocking loop in cas there is pending transaction. It will keeps resending the unconfirmed spend infinitely but explictly. Function will only return on success (all unconfirmed spend uploaded), or user chose to manualy, but safely, terminate the procedure.

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());