Struct ClientContext 

pub struct ClientContext<Env: Environment> {
    pub client: Arc<Client<Env>>,
    pub genesis_config: GenesisConfig,
    pub send_timeout: Duration,
    pub recv_timeout: Duration,
    pub retry_delay: Duration,
    pub max_retries: u32,
    pub chain_listeners: JoinSet,
    pub default_chain: Option<ChainId>,
    pub client_metrics: Option<ClientMetrics>,
}

Fields

client: Arc<Client<Env>>

genesis_config: GenesisConfig

send_timeout: Duration

recv_timeout: Duration

retry_delay: Duration

max_retries: u32

chain_listeners: JoinSet

default_chain: Option<ChainId>

client_metrics: Option<ClientMetrics>

Implementations

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

where S: Storage, Si: Signer, W: Wallet,

pub async fn new( storage: S, wallet: W, signer: Si, options: &Options, default_chain: Option<ChainId>, genesis_config: GenesisConfig, ) -> Result<Self, Error>

impl<Env: Environment> ClientContext<Env>

pub fn wallet(&self) -> &Env::Wallet

Returns a reference to the wallet.

pub fn admin_chain(&self) -> ChainId

Returns the ID of the admin chain.

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 async fn first_non_admin_chain(&self) -> Result<ChainId, Error>

pub fn make_node_provider(&self) -> NodeProvider

pub fn client_metrics(&self) -> Option<&ClientMetrics>

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

pub async fn update_wallet_for_new_chain( &mut self, chain_id: ChainId, owner: Option<AccountOwner>, timestamp: Timestamp, epoch: Epoch, ) -> 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 ownership( &mut self, chain_id: Option<ChainId>, ) -> Result<ChainOwnership, Error>

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<ChainInfo, Error>

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

Query a validator for version info, network description, and chain info.

Returns a ValidatorQueryResults struct with the results of all three queries.

pub async fn query_local_node( &self, chain_id: ChainId, ) -> Result<ValidatorQueryResults, Error>

Query the local node for version info, network description, and chain info.

Returns a ValidatorQueryResults struct with the local node’s information.

impl<Env: Environment> ClientContext<Env>

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

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

Trait Implementations

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

type Environment = Env

fn wallet(&self) -> &Env::Wallet

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

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

fn timing_sender(&self) -> Option<UnboundedSender<(u64, TimingType)>>

Gets the timing sender for benchmarking, if available.

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

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

fn admin_chain(&self) -> ChainId

fn make_chain_client( &self, chain_id: ChainId, ) -> impl Future<Output = Result<ChainClient<Self::Environment>, Error>> + Send + Sync