Struct iota_sdk::wallet_context::WalletContext

pub struct WalletContext { /* private fields */ }

Implementations

impl WalletContext

pub fn config(&self) -> &PersistedConfig<IotaClientConfig>

pub fn request_timeout(&self) -> &Option<Duration>

pub fn client(&self) -> &Arc<RwLock<Option<IotaClient>>>

pub fn max_concurrent_requests(&self) -> &Option<u64>

impl WalletContext

pub fn config_mut(&mut self) -> &mut PersistedConfig<IotaClientConfig>

pub fn request_timeout_mut(&mut self) -> &mut Option<Duration>

pub fn client_mut(&mut self) -> &mut Arc<RwLock<Option<IotaClient>>>

pub fn max_concurrent_requests_mut(&mut self) -> &mut Option<u64>

impl WalletContext

pub fn new( config_path: &Path, request_timeout: impl Into<Option<Duration>>, max_concurrent_requests: impl Into<Option<u64>>, ) -> Result<Self, Error>

pub fn get_addresses(&self) -> Vec<IotaAddress>

pub async fn get_client(&self) -> Result<IotaClient, Error>

pub fn active_address(&mut self) -> Result<IotaAddress, Error>

pub async fn get_object_ref( &self, object_id: ObjectID, ) -> Result<ObjectRef, Error>

Get the latest object reference given a object id

pub async fn gas_objects( &self, address: IotaAddress, ) -> Result<Vec<(u64, IotaObjectData)>, Error>

Get all the gas objects (and conveniently, gas amounts) for the address

pub async fn get_object_owner( &self, id: &ObjectID, ) -> Result<IotaAddress, Error>

pub async fn try_get_object_owner( &self, id: &Option<ObjectID>, ) -> Result<Option<IotaAddress>, Error>

pub async fn gas_for_owner_budget( &self, address: IotaAddress, budget: u64, forbidden_gas_objects: BTreeSet<ObjectID>, ) -> Result<(u64, IotaObjectData), Error>

Find a gas object which fits the budget

pub async fn get_all_gas_objects_owned_by_address( &self, address: IotaAddress, ) -> Result<Vec<ObjectRef>>

pub async fn get_gas_objects_owned_by_address( &self, address: IotaAddress, limit: impl Into<Option<usize>>, ) -> Result<Vec<ObjectRef>>

pub async fn get_one_gas_object_owned_by_address( &self, address: IotaAddress, ) -> Result<Option<ObjectRef>>

Given an address, return one gas object owned by this address. The actual implementation just returns the first one returned by the read api.

pub async fn get_one_account(&self) -> Result<(IotaAddress, Vec<ObjectRef>)>

Returns one address and all gas objects owned by that address.

pub async fn get_one_gas_object( &self, ) -> Result<Option<(IotaAddress, ObjectRef)>>

Return a gas object owned by an arbitrary address managed by the wallet.

pub async fn get_all_accounts_and_gas_objects( &self, ) -> Result<Vec<(IotaAddress, Vec<ObjectRef>)>>

Returns all the account addresses managed by the wallet and their owned gas objects.

pub async fn get_reference_gas_price(&self) -> Result<u64, Error>

pub fn add_account( &mut self, alias: impl Into<Option<String>>, keypair: IotaKeyPair, )

Add an account

pub fn sign_transaction(&self, data: &TransactionData) -> Transaction

Sign a transaction with a key currently managed by the WalletContext

pub async fn execute_transaction_must_succeed( &self, tx: Transaction, ) -> IotaTransactionBlockResponse

Execute a transaction and wait for it to be locally executed on the fullnode. Also expects the effects status to be ExecutionStatus::Success.

pub async fn execute_transaction_may_fail( &self, tx: Transaction, ) -> Result<IotaTransactionBlockResponse>

Execute a transaction and wait for it to be locally executed on the fullnode. The transaction execution is not guaranteed to succeed and may fail. This is usually only needed in non-test environment or the caller is explicitly testing some failure behavior.