Struct linera_client::client_context::ClientContext

pub struct ClientContext<Storage, W>
where
    Storage: Storage,
{
    pub wallet: WalletState<W>,
    pub client: Arc<Client<NodeProvider, Storage>>,
    pub send_timeout: Duration,
    pub recv_timeout: Duration,
    pub retry_delay: Duration,
    pub max_retries: u32,
    pub chain_listeners: JoinSet,
    pub blanket_message_policy: BlanketMessagePolicy,
    pub restrict_chain_ids_to: Option<HashSet<ChainId>>,
}

Fields

wallet: WalletState<W>

client: Arc<Client<NodeProvider, Storage>>

send_timeout: Duration

recv_timeout: Duration

retry_delay: Duration

max_retries: u32

chain_listeners: JoinSet

blanket_message_policy: BlanketMessagePolicy

restrict_chain_ids_to: Option<HashSet<ChainId>>

Implementations

impl<S, W> ClientContext<S, W>

where S: Storage + Clone + Send + Sync + 'static, W: Persist<Target = Wallet>,

pub fn wallet(&self) -> &Wallet

Returns a reference to the wallet.

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

Returns the WalletState 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 new(storage: S, options: ClientOptions, wallet: W) -> Self

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

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 make_node_provider(&self) -> NodeProvider

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

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

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

Remembers the new chain and private key (if any) in the wallet.

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

pub async fn assign_new_chain_to_key( &mut self, chain_id: ChainId, message_id: MessageId, owner: Owner, validators: Option<Vec<(ValidatorPublicKey, String)>>, ) -> Result<(), Error>

where S: Storage + Clone + Send + Sync + 'static,

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

where F: FnMut(&ChainClient<NodeProvider, S>) -> 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>

impl<S, W> ClientContext<S, W>

where S: Storage + Clone + Send + Sync + 'static, W: Persist<Target = Wallet>,

pub async fn publish_bytecode( &mut self, chain_client: &ChainClient<NodeProvider, S>, contract: PathBuf, service: PathBuf, vm_runtime: VmRuntime, ) -> Result<BytecodeId, Error>

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

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

impl<S, W> ClientContext<S, W>

where S: Storage + Clone + Send + Sync + 'static, W: Persist<Target = Wallet>,

pub async fn prepare_for_benchmark( &mut self, num_chains: usize, transactions_per_block: usize, tokens_per_chain: Amount, fungible_application_id: Option<ApplicationId>, ) -> Result<(HashMap<ChainId, ChainClient<NodeProvider, S>>, Epoch, Vec<(ChainId, Vec<Operation>, AccountSecretKey)>, Committee), Error>

Trait Implementations

impl<S, W> ClientContext for ClientContext<S, W>

where S: Storage + Clone + Send + Sync + 'static, W: Persist<Target = Wallet> + 'static,

type ValidatorNodeProvider = NodeProvider

type Storage = S

fn wallet(&self) -> &Wallet

fn make_chain_client( &self, chain_id: ChainId, ) -> Result<ChainClient<NodeProvider, S>, Error>

fn update_wallet_for_new_chain<'life0, 'async_trait>( &'life0 mut self, chain_id: ChainId, key_pair: Option<AccountSecretKey>, timestamp: Timestamp, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

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

fn update_wallet<'life0, 'life1, 'async_trait>( &'life0 mut self, client: &'life1 ChainClient<NodeProvider, S>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

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

fn clients( &self, ) -> Result<Vec<ChainClient<<Self as ClientContext>::ValidatorNodeProvider, <Self as ClientContext>::Storage>>, Error>