Struct WalletUnlocked

pub struct WalletUnlocked { /* private fields */ }

A WalletUnlocked is equivalent to a Wallet whose private key is known and stored alongside in-memory. Knowing the private key allows a WalletUlocked to sign operations, send transactions, and more.

private_key will be zeroed out on calling lock() or dropping a WalletUnlocked.

Implementations

impl WalletUnlocked

pub fn lock(self) -> Wallet

Lock the wallet by securely zeroize-ing and dropping the private key from memory.

pub fn set_provider(&mut self, provider: Provider)

pub fn new_random(provider: Option<Provider>) -> Self

Creates a new wallet with a random private key.

pub fn new_from_private_key( private_key: SecretKey, provider: Option<Provider>, ) -> Self

Creates a new wallet from the given private key.

pub fn new_from_mnemonic_phrase( phrase: &str, provider: Option<Provider>, ) -> Result<Self>

Creates a new wallet from a mnemonic phrase. The default derivation path is used.

pub fn new_from_mnemonic_phrase_with_path( phrase: &str, provider: Option<Provider>, path: &str, ) -> Result<Self>

Creates a new wallet from a mnemonic phrase. It takes a derivation path such as BIP32 or BIP44.

pub fn new_from_keystore<P, R, S>( dir: P, rng: &mut R, password: S, provider: Option<Provider>, ) -> Result<(Self, String)>

where P: AsRef<Path>, R: Rng + CryptoRng + CryptoRng, S: AsRef<[u8]>,

Creates a new wallet and stores its encrypted version in the given path.

pub fn encrypt<P, S>(&self, dir: P, password: S) -> Result<String>

where P: AsRef<Path>, S: AsRef<[u8]>,

Encrypts the wallet’s private key with the given password and saves it to the given path.

pub fn load_keystore<P, S>( keypath: P, password: S, provider: Option<Provider>, ) -> Result<Self>

where P: AsRef<Path>, S: AsRef<[u8]>,

Recreates a wallet from an encrypted JSON wallet given the provided path and password.

pub fn address(&self) -> &Bech32Address

Methods from Deref<Target = Wallet>

pub fn provider(&self) -> Option<&Provider>

pub fn address(&self) -> &Bech32Address

Trait Implementations

impl Account for WalletUnlocked

fn get_asset_inputs_for_amount<'life0, 'async_trait>( &'life0 self, asset_id: AssetId, amount: u64, excluded_coins: Option<Vec<CoinTypeId>>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Input>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns a vector consisting of Input::Coins and Input::Messages for the given asset ID and amount. The witness_index is the position of the witness (signature) in the transaction’s list of witnesses. In the validation process, the node will use the witness at this index to validate the coins returned by this method.

fn add_witnesses<Tb: TransactionBuilder>(&self, tb: &mut Tb) -> Result<()>

fn get_asset_outputs_for_amount( &self, to: &Bech32Address, asset_id: AssetId, amount: u64, ) -> Vec<Output>

Returns a vector containing the output coin and change output given an asset and amount

fn adjust_for_fee<'life0, 'life1, 'async_trait, Tb>( &'life0 self, tb: &'life1 mut Tb, used_base_amount: u64, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Tb: 'async_trait + TransactionBuilder + Sync, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Add base asset inputs to the transaction to cover the estimated fee. Requires contract inputs to be at the start of the transactions inputs vec so that their indexes are retained

fn transfer<'life0, 'life1, 'async_trait>( &'life0 self, to: &'life1 Bech32Address, amount: u64, asset_id: AssetId, tx_policies: TxPolicies, ) -> Pin<Box<dyn Future<Output = Result<(TxId, Vec<Receipt>)>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Transfer funds from this account to another Address. Fails if amount for asset ID is larger than address’s spendable coins. Returns the transaction ID that was sent and the list of receipts.

fn force_transfer_to_contract<'life0, 'life1, 'async_trait>( &'life0 self, to: &'life1 Bech32ContractId, balance: u64, asset_id: AssetId, tx_policies: TxPolicies, ) -> Pin<Box<dyn Future<Output = Result<(String, Vec<Receipt>)>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Unconditionally transfers balance of type asset_id to the contract at to. Fails if balance for asset_id is larger than this account’s spendable balance. Returns the corresponding transaction ID and the list of receipts.

fn withdraw_to_base_layer<'life0, 'life1, 'async_trait>( &'life0 self, to: &'life1 Bech32Address, amount: u64, tx_policies: TxPolicies, ) -> Pin<Box<dyn Future<Output = Result<(TxId, Nonce, Vec<Receipt>)>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Withdraws an amount of the base asset to an address on the base chain. Returns the transaction ID, message ID and the list of receipts.

impl Clone for WalletUnlocked

fn clone(&self) -> WalletUnlocked

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for WalletUnlocked

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

Formats the value using the given formatter.

impl Deref for WalletUnlocked

type Target = Wallet

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl Drop for WalletUnlocked

fn drop(&mut self)

Executes the destructor for this type.

impl Signer for WalletUnlocked

fn sign<'life0, 'async_trait>( &'life0 self, message: Message, ) -> Pin<Box<dyn Future<Output = Result<Signature>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn address(&self) -> &Bech32Address

impl ViewOnlyAccount for WalletUnlocked

fn address(&self) -> &Bech32Address

fn try_provider(&self) -> Result<&Provider>

fn get_transactions<'life0, 'async_trait>( &'life0 self, request: PaginationRequest<String>, ) -> Pin<Box<dyn Future<Output = Result<PaginatedResult<TransactionResponse, String>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_coins<'life0, 'async_trait>( &'life0 self, asset_id: AssetId, ) -> Pin<Box<dyn Future<Output = Result<Vec<Coin>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Gets all unspent coins of asset asset_id owned by the account.

fn get_asset_balance<'life0, 'life1, 'async_trait>( &'life0 self, asset_id: &'life1 AssetId, ) -> Pin<Box<dyn Future<Output = Result<u64>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get the balance of all spendable coins asset_id for address address. This is different from getting coins because we are just returning a number (the sum of UTXOs amount) instead of the UTXOs.

fn get_messages<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<Message>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Gets all unspent messages owned by the account.

fn get_balances<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<HashMap<String, u64>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get all the spendable balances of all assets for the account. This is different from getting the coins because we are only returning the sum of UTXOs coins amount and not the UTXOs coins themselves.

fn get_spendable_resources<'life0, 'async_trait>( &'life0 self, asset_id: AssetId, amount: u64, excluded_coins: Option<Vec<CoinTypeId>>, ) -> Pin<Box<dyn Future<Output = Result<Vec<CoinType>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get some spendable resources (coins and messages) of asset asset_id owned by the account that add up at least to amount amount. The returned coins (UTXOs) are actual coins that can be spent. The number of UXTOs is optimized to prevent dust accumulation.

impl Zeroize for WalletUnlocked

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the zeroization operation is not “optimized away” by the compiler.