Struct ClientWrapper 

pub struct ClientWrapper {
    pub path_provider: PathProvider,
    /* private fields */
}

Wrapper to run a Linera client command.

Fields

path_provider: PathProvider

Provides the working directory for the client and its files.

Implementations

impl ClientWrapper

pub fn new( path_provider: PathProvider, network: Network, testing_prng_seed: Option<u64>, id: usize, on_drop: OnClientDrop, ) -> Self

Creates a new ClientWrapper, waiting for outgoing messages by default.

pub fn new_with_extra_args( path_provider: PathProvider, network: Network, testing_prng_seed: Option<u64>, id: usize, on_drop: OnClientDrop, extra_args: Vec<String>, ) -> Self

Creates a new ClientWrapper with the given extra arguments passed to every command.

pub async fn project_new( &self, project_name: &str, linera_root: &Path, ) -> Result<TempDir>

Runs linera project new.

pub async fn project_publish<T: Serialize>( &self, path: PathBuf, required_application_ids: Vec<String>, publisher: impl Into<Option<ChainId>>, argument: &T, ) -> Result<String>

Runs linera project publish.

pub async fn project_test(&self, path: &Path) -> Result<()>

Runs linera project test.

pub async fn create_genesis_config( &self, num_other_initial_chains: u32, initial_funding: Amount, policy_config: ResourceControlPolicyConfig, http_allow_list: Option<Vec<String>>, ) -> Result<()>

Runs linera create-genesis-config.

pub async fn wallet_init(&self, faucet: Option<&Faucet>) -> Result<()>

Runs linera wallet init. The genesis config is read from genesis.json, or from the faucet if provided.

pub async fn request_chain( &self, faucet: &Faucet, set_default: bool, ) -> Result<(ChainId, AccountOwner)>

Runs linera wallet request-chain.

pub async fn publish_and_create<A: ContractAbi, Parameters: Serialize, InstantiationArgument: Serialize>( &self, contract: PathBuf, service: PathBuf, vm_runtime: VmRuntime, parameters: &Parameters, argument: &InstantiationArgument, required_application_ids: &[ApplicationId], publisher: impl Into<Option<ChainId>>, ) -> Result<ApplicationId<A>>

Runs linera wallet publish-and-create.

pub async fn publish_module<Abi, Parameters, InstantiationArgument>( &self, contract: PathBuf, service: PathBuf, vm_runtime: VmRuntime, publisher: impl Into<Option<ChainId>>, ) -> Result<ModuleId<Abi, Parameters, InstantiationArgument>>

Runs linera publish-module.

pub async fn publish_module_with_formats<Abi, Parameters, InstantiationArgument>( &self, contract: PathBuf, service: PathBuf, formats: PathBuf, registry_application_id: ApplicationId, vm_runtime: VmRuntime, publisher: impl Into<Option<ChainId>>, ) -> Result<ModuleId<Abi, Parameters, InstantiationArgument>>

Runs linera publish-module-with-formats.

pub async fn create_application<Abi: ContractAbi, Parameters: Serialize, InstantiationArgument: Serialize>( &self, module_id: &ModuleId<Abi, Parameters, InstantiationArgument>, parameters: &Parameters, argument: &InstantiationArgument, required_application_ids: &[ApplicationId], creator: impl Into<Option<ChainId>>, ) -> Result<ApplicationId<Abi>>

Runs linera create-application.

pub async fn run_node_service( &self, port: impl Into<Option<u16>>, process_inbox: ProcessInbox, ) -> Result<NodeService>

Runs linera service.

pub async fn run_node_service_with_options( &self, port: impl Into<Option<u16>>, process_inbox: ProcessInbox, operator_application_ids: &[ApplicationId], operators: &[(String, PathBuf)], read_only: bool, ) -> Result<NodeService>

Runs linera service with optional task processor configuration.

pub async fn run_node_service_with_all_options( &self, port: impl Into<Option<u16>>, process_inbox: ProcessInbox, operator_application_ids: &[ApplicationId], operators: &[(String, PathBuf)], read_only: bool, allowed_subscriptions: &[String], subscription_ttls: &[(String, u64)], ) -> Result<NodeService>

Runs linera service with all available options.

pub async fn run_node_service_with_controller( &self, port: impl Into<Option<u16>>, process_inbox: ProcessInbox, controller_id: &ApplicationId, operators: &[(String, PathBuf)], ) -> Result<NodeService>

Runs linera service with a controller application.

pub async fn query_validator(&self, address: &str) -> Result<CryptoHash>

Runs linera validator query

pub async fn query_validators(&self, chain_id: Option<ChainId>) -> Result<()>

Runs linera validator list.

pub async fn sync_validator( &self, chain_ids: impl IntoIterator<Item = &ChainId>, validator_address: impl Into<String>, ) -> Result<()>

Runs linera validator sync.

pub async fn validator_benchmark( &self, address: impl Into<String>, chains: impl IntoIterator<Item = &ChainId>, extra_args: &[&str], ) -> Result<String>

Runs linera validator benchmark and returns its stdout.

pub async fn run_faucet( &self, port: impl Into<Option<u16>>, chain_id: ChainId, amount: Amount, ) -> Result<FaucetService>

Runs linera faucet.

pub async fn local_balance(&self, account: Account) -> Result<Amount>

Runs linera local-balance.

pub async fn query_balance(&self, account: Account) -> Result<Amount>

Runs linera query-balance.

pub async fn sync(&self, chain_id: ChainId) -> Result<()>

Runs linera sync.

pub async fn process_inbox(&self, chain_id: ChainId) -> Result<()>

Runs linera process-inbox.

pub async fn transfer( &self, amount: Amount, from: ChainId, to: ChainId, ) -> Result<()>

Runs linera transfer.

pub async fn transfer_with_silent_logs( &self, amount: Amount, from: ChainId, to: ChainId, ) -> Result<()>

Runs linera transfer with no logging.

pub async fn transfer_with_accounts( &self, amount: Amount, from: Account, to: Account, ) -> Result<()>

Runs linera transfer with owner accounts.

pub async fn benchmark(&self, args: BenchmarkCommand) -> Result<()>

Runs linera benchmark.

pub async fn benchmark_detached( &self, args: BenchmarkCommand, tx: Sender<()>, ) -> Result<(Child, JoinHandle<()>, JoinHandle<()>)>

Runs linera benchmark, but detached: don’t wait for the command to finish, just spawn it and return the child process, and the handles to the stdout and stderr.

pub async fn open_chain_super_owner( &self, from: ChainId, owner: Option<AccountOwner>, initial_balance: Amount, ) -> Result<(ChainId, AccountOwner)>

Runs linera open-chain --super-owner.

pub async fn open_chain( &self, from: ChainId, owner: Option<AccountOwner>, initial_balance: Amount, ) -> Result<(ChainId, AccountOwner)>

Runs linera open-chain.

pub async fn open_and_assign( &self, client: &ClientWrapper, initial_balance: Amount, ) -> Result<ChainId>

Runs linera open-chain then linera assign.

pub async fn open_multi_owner_chain( &self, from: ChainId, owners: BTreeMap<AccountOwner, u64>, multi_leader_rounds: u32, balance: Amount, base_timeout_ms: u64, ) -> Result<ChainId>

Runs linera open-multi-owner-chain and returns the new chain’s ID.

pub async fn change_ownership( &self, chain_id: ChainId, super_owners: Vec<AccountOwner>, owners: Vec<AccountOwner>, ) -> Result<()>

Runs linera change-ownership.

pub async fn follow_chain(&self, chain_id: ChainId, sync: bool) -> Result<()>

Runs linera wallet follow-chain CHAIN_ID.

pub async fn forget_chain(&self, chain_id: ChainId) -> Result<()>

Runs linera wallet forget-chain CHAIN_ID.

pub async fn set_default_chain(&self, chain_id: ChainId) -> Result<()>

Runs linera wallet set-default CHAIN_ID.

pub async fn retry_pending_block( &self, chain_id: Option<ChainId>, ) -> Result<Option<CryptoHash>>

Runs linera retry-pending-block and returns the hash of the produced block, if any.

pub async fn publish_data_blob( &self, path: &Path, chain_id: Option<ChainId>, ) -> Result<CryptoHash>

Runs linera publish-data-blob.

pub async fn read_data_blob( &self, hash: CryptoHash, chain_id: Option<ChainId>, ) -> Result<()>

Runs linera read-data-blob.

pub fn load_wallet(&self) -> Result<Wallet>

Loads the wallet from this client’s wallet file.

pub fn load_keystore(&self) -> Result<InMemorySigner>

Loads the in-memory signer from this client’s keystore file.

pub fn wallet_path(&self) -> PathBuf

Returns the path to this client’s wallet file.

pub fn keystore_path(&self) -> PathBuf

Returns the path to this client’s keystore file.

pub fn storage_path(&self) -> &str

Returns the storage specification string used by this client.

pub fn get_owner(&self) -> Option<AccountOwner>

Returns the owner of the wallet’s default chain, if any.

pub fn is_chain_present_in_wallet(&self, chain: ChainId) -> bool

Returns whether the given chain is present in the wallet.

pub async fn set_validator( &self, validator_key: &(String, String), port: usize, votes: usize, ) -> Result<()>

Runs linera validator add.

pub async fn remove_validator(&self, validator_key: &str) -> Result<()>

Runs linera validator remove.

pub async fn change_validators( &self, add_validators: &[(String, String, usize, usize)], modify_validators: &[(String, String, usize, usize)], remove_validators: &[String], ) -> Result<()>

Runs linera validator update to add, modify, and remove validators in one call.

pub async fn revoke_epochs(&self, epoch: Epoch) -> Result<()>

Runs linera revoke-epochs.

pub async fn change_http_whitelist(&self, list: &[&str]) -> Result<()>

Runs linera resource-control-policy --http-request-allow-list.

pub async fn keygen(&self) -> Result<AccountOwner>

Runs linera keygen.

pub fn default_chain(&self) -> Option<ChainId>

Returns the default chain.

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

Runs linera assign.

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

Runs linera set-preferred-owner for chain_id.

pub async fn build_application( &self, path: &Path, name: &str, is_workspace: bool, ) -> Result<(PathBuf, PathBuf)>

Builds the application at path with cargo and returns its contract and service paths.

Trait Implementations

impl Drop for ClientWrapper

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.