Struct WalletContext

pub struct WalletContext {
    pub config: PersistedConfig<SuiClientConfig>,
    /* private fields */
}

Fields

config: PersistedConfig<SuiClientConfig>

Implementations

impl WalletContext

pub fn new(config_path: &Path) -> Result<Self, Error>

pub fn new_for_tests( keystore: Keystore, external: Option<Keystore>, path: Option<PathBuf>, ) -> Self

pub fn with_request_timeout(self, request_timeout: Duration) -> Self

pub fn with_max_concurrent_requests(self, max_concurrent_requests: u64) -> Self

pub fn with_env_override(self, env_override: String) -> Self

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

pub fn get_env_override(&self) -> Option<String>

pub fn get_identity_address( &mut self, input: Option<KeyIdentity>, ) -> Result<SuiAddress, Error>

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

pub async fn load_or_cache_chain_id( &self, client: &SuiClient, ) -> Result<String, Error>

Load the chain ID corresponding to the active environment, or fetch and cache it if not present.

The chain ID is cached in the client.yaml file to avoid redundant network requests.

pub async fn cache_chain_id(&self, client: &SuiClient) -> Result<String, Error>

Cache (or recache) chain ID for the active environment by fetching it from the network

pub fn get_active_env(&self) -> Result<&SuiEnv, Error>

pub fn active_address(&mut self) -> Result<SuiAddress, 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 get_full_object_ref( &self, object_id: ObjectID, ) -> Result<FullObjectRef, Error>

Get the latest full object reference given a object id

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

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

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

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

pub async fn infer_sender( &mut self, gas: &[ObjectID], ) -> Result<SuiAddress, Error>

Infer the sender of a transaction based on the gas objects provided. If no gas objects are provided, assume the active address is the sender.

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

Find a gas object which fits the budget

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

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

pub async fn get_one_gas_object_owned_by_address( &self, address: SuiAddress, ) -> 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<(SuiAddress, Vec<ObjectRef>)>

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

pub async fn get_one_gas_object( &self, ) -> Result<Option<(SuiAddress, 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<(SuiAddress, 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 async fn add_account(&mut self, alias: Option<String>, keypair: SuiKeyPair)

Add an account

pub fn get_keystore_by_identity( &self, key_identity: &KeyIdentity, ) -> Result<&Keystore, Error>

pub fn get_keystore_by_identity_mut( &mut self, key_identity: &KeyIdentity, ) -> Result<&mut Keystore, Error>

pub async fn sign_secure( &self, key_identity: &KeyIdentity, data: &TransactionData, intent: Intent, ) -> Result<Signature, Error>

pub async 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, ) -> SuiTransactionBlockResponse

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<SuiTransactionBlockResponse>

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.