Struct ClientContext

pub struct ClientContext<Env: Environment, W> {
    pub wallet: W,
    pub client: Arc<Client<Env>>,
    pub send_timeout: Duration,
    pub recv_timeout: Duration,
    pub retry_delay: Duration,
    pub max_retries: u32,
    pub chain_listeners: JoinSet,
}

Fields

wallet: W

client: Arc<Client<Env>>

send_timeout: Duration

recv_timeout: Duration

retry_delay: Duration

max_retries: u32

chain_listeners: JoinSet

Implementations

impl<S, Si, W> ClientContext<Impl<S, NodeProvider, Si>, W>

where S: Storage, Si: Signer, W: Persist<Target = Wallet>,

pub fn new( storage: S, options: ClientContextOptions, wallet: W, signer: Si, ) -> Self

pub fn new_test_client_context(storage: S, wallet: W, signer: Si) -> Self

impl<Env: Environment, W: Persist<Target = Wallet>> ClientContext<Env, W>

pub fn wallet(&self) -> &Wallet

Returns a reference to the wallet.

pub fn wallet_mut(&mut self) -> &mut W

Returns the wallet as a mutable reference.

pub async fn mutate_wallet<R: Send>( &mut self, mutation: impl FnOnce(&mut Wallet) -> R + Send, ) -> Result<R, Error>

pub fn default_account(&self) -> Account

Retrieve the default account. Current this is the common account of the default chain.

pub fn default_chain(&self) -> ChainId

Retrieve the default chain.

pub fn first_non_admin_chain(&self) -> ChainId

pub fn make_node_provider(&self) -> NodeProvider

pub async fn save_wallet(&mut self) -> Result<(), Error>

pub async fn update_wallet_from_client<Env_: Environment>( &mut self, client: &ChainClient<Env_>, ) -> Result<(), Error>

pub async fn update_wallet_for_new_chain( &mut self, chain_id: ChainId, owner: Option<AccountOwner>, timestamp: Timestamp, ) -> Result<(), Error>

Remembers the new chain and its owner (if any) in the wallet.

pub async fn process_inbox( &mut self, chain_client: &ChainClient<Env>, ) -> Result<Vec<ConfirmedBlockCertificate>, Error>

pub async fn assign_new_chain_to_key( &mut self, chain_id: ChainId, owner: AccountOwner, ) -> Result<(), Error>

pub async fn apply_client_command<E, F, Fut, T>( &mut self, client: &ChainClient<Env>, f: F, ) -> Result<T, Error>

where F: FnMut(&ChainClient<Env>) -> Fut, Fut: Future<Output = Result<ClientOutcome<T>, E>>, Error: From<E>,

Applies the given function to the chain client.

Updates the wallet regardless of the outcome. As long as the function returns a round timeout, it will wait and retry.

pub async fn change_ownership( &mut self, chain_id: Option<ChainId>, ownership_config: ChainOwnershipConfig, ) -> Result<(), Error>

pub async fn set_preferred_owner( &mut self, chain_id: Option<ChainId>, preferred_owner: AccountOwner, ) -> Result<(), Error>

pub async fn check_compatible_version_info( &self, address: &str, node: &impl ValidatorNode, ) -> Result<VersionInfo, Error>

pub async fn check_matching_network_description( &self, address: &str, node: &impl ValidatorNode, ) -> Result<CryptoHash, Error>

pub async fn check_validator_chain_info_response( &self, public_key: Option<&ValidatorPublicKey>, address: &str, node: &impl ValidatorNode, chain_id: ChainId, ) -> Result<(), Error>

impl<Env: Environment, W> ClientContext<Env, W>

where W: Persist<Target = Wallet>,

pub async fn publish_module( &mut self, chain_client: &ChainClient<Env>, contract: PathBuf, service: PathBuf, vm_runtime: VmRuntime, ) -> Result<ModuleId, Error>

pub async fn publish_data_blob( &mut self, chain_client: &ChainClient<Env>, blob_path: PathBuf, ) -> Result<CryptoHash, Error>

pub async fn read_data_blob( &mut self, chain_client: &ChainClient<Env>, hash: CryptoHash, ) -> Result<(), Error>

impl<Env: Environment, W> ClientContext<Env, W>

where W: Persist<Target = Wallet>,

pub async fn prepare_for_benchmark( &mut self, num_chain_groups: usize, num_chains_per_chain_group: usize, transactions_per_block: usize, tokens_per_chain: Amount, fungible_application_id: Option<ApplicationId>, pub_keys: Vec<AccountPublicKey>, ) -> Result<(Vec<Vec<ChainClient<Env>>>, Vec<Vec<(Vec<Operation>, AccountOwner)>>, Committee), Error>

pub async fn wrap_up_benchmark( &mut self, chain_clients: Vec<Vec<ChainClient<Env>>>, close_chains: bool, wrap_up_max_in_flight: usize, ) -> Result<(), Error>

Trait Implementations

impl<Env: Environment, W> ClientContext for ClientContext<Env, W>

where W: Persist<Target = Wallet>,

type Environment = Env

fn wallet(&self) -> &Wallet

fn storage(&self) -> &Env::Storage

fn client(&self) -> &Arc<Client<Env>>

async fn update_wallet_for_new_chain( &mut self, chain_id: ChainId, owner: Option<AccountOwner>, timestamp: Timestamp, ) -> Result<(), Error>

async fn update_wallet( &mut self, client: &ChainClient<Env>, ) -> Result<(), Error>

fn make_chain_client(&self, chain_id: ChainId) -> ChainClient<Self::Environment>